内置函数
abs()
3 函数返回x的绝对值，如果参数是一个复数，则返回它的大小 5 print(abs(-40)) 6 print(abs(100.10))
#40
#100.10
dict()
函数用于创建一个字典 a=dict()#创建空字典 b=dict(a='a',b='b',t='t')#传入关键字 c=dict(zip(['one','two','three'],[1,2,3]))#映射函数方式来构造字典 d=dict([('one',1),('two',2),('three',3)])#可迭代对象方式来构造字典 print(a) print(b) print(c) print(d) #{} #{'a': 'a', 'b': 'b', 't': 't'} #{'one': 1, 'two': 2, 'three': 3} #{'one': 1, 'two': 2, 'three': 3}
help（）
函数用于查看函数或模块用途的详细说明
help('sys')#查看sys模块的帮助 help('str')#查看str数据类型的帮助 a=[1,2,3] help(a)#查看列表list帮助信息 help(a.append)#显示list的append方法的帮助
min()
返回给定参数的最小值，参数可以为序列 print(min(80,100,1000)) print(min(-20,100,400)) print(min(-80,-20,-10)) print(min(0,100,-400))
setattr()
setattr函数对应getattr,用于设置属性值，该属性必须存在 class A(object): bar=1 a=A() getattr(a,'bar')#获取属性bar值 setattr(a,'bar',5)#设置属性bar值
all()
2 3 函数用于判断给定的可迭代参数iterable中的所有元素是否为True,如果是返回True,否则返回False,元素除了0，空，False外都算True 4 5 函数等价于 6 7 def all(iterable): 8 for element in iterable: 9 if not element: 10 return False 11 return True 12
参数是元组或列表
13 print(all(['a','b','c','d']))#True 元素都不为空或0 14 print(all(['a','b','','d']))#False 存在一个为空的元素 15 print(all([0,1,2,3]))#False 存在一个为0的元素 16 print(all(('a','b','c','d')))#True 元素都不为空或0 17 print(all(('a','b','','d')))#False 存在一个为空的元素 18 print(all((0,1,2,3)))#False 存在一个为0的元素 19 print(all([]))#True 空列表 20 print(all(()))#True 空元组
dir()
函数不带参数时，返回当前范围内的变量、方法和定义的类型列表 带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(), 该方法将被调用。如果参数不包含__dir__(),该方法将最大限度的收集参数信息 print(dir())#获得当前模块的属性列表 print(dir([]))#查看列表的方法
hex()
函数用于将10进制整数转换成16进制，以字符串形式表示 print(hex(255))#0xff print(hex(-42))#-0x2a
next()
返回迭代器的下一个项目 # 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while True: try: # 获得下一个值: x = next(it) print(x) except StopIteration: # 遇到StopIteration就退出循环 break
slice()
函数实现切片对象，主要用在切片操作函数里的参数传递 myslice=slice(5)#设置截取5个元素的切片 print(myslice) #slice(None, 5, None)
arr=range(10) print(arr) #range(0, 10) print(arr[myslice]) #截取5个元素 range(0, 5)
any()
函数用于判断给定的可迭代参数iterable是否全部为False,返回False,如果有一个为True,则返回True 元素除了是0，空，False外都算True 函数等价于 def any(iterable): for element in iterable: if element: return True return False
13 print(any(['a','b','c','d']))#True 元素都不为空或0 14 print(any(['a','b','','d']))#True 存在一个为空的元素
print(any([0,'',False]))#False 元素全为0
16 print(any(('a','b','c','d')))#True 元素都不为空或0
17 print(any(('a','b','','d')))#True 存在一个为空的元素
18 print(any((0,'',False)))#False 存在一个为0的元素
19 print(any([]))#False 空列表
20 print(any(()))#False 空元组
divmod（）
#函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组（a//b,a%b） a=divmod(10,3) print(a) #(3,1) b=divmod(8,2) print(b) #(4,0)
id()
函数用于获取对象的内存地址 print(id('hello'))#34772336 print(id('123'))#34772504 print(id(123))#1414513536
sorted()
sorded()函数对所有可迭代对象进行排序操作 sort和sorted区别 sort是应用在list上的方法，sorted可以对所有可迭代对象进行排序操作 list的sort方法返回的是对已经存在的列表进行操作，而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作 print(sorted([1,23,4,5,6]))#[1, 4, 5, 6, 23]
a=[11,42,33,4,5,6]
a.sort()
print(a)#[4, 5, 6, 11, 33, 42]
sort没有返回值，直接对原来的列表进行修改
sorted函数可以接受任何的可迭代对象，如
a=sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
print(a)#[1, 2, 3, 4, 5]
a=[1,23,4,5,55]
b=sorted(a,reverse=True)
print(b)#[55, 23, 5, 4, 1]
ascii()
函数类似于repr()函数，返回一个表示对象的字符串，但是对于字符串中的非ASCII字符则返回通过repr()函数使用\x，\u或\U编码的字符，生成字符串类似python2版本中repr（）函数的返回值 print(ascii('hello'))#'hello'
enumerate()
函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中 a=[1,23,4,5,65,88] b=enumerate(a,1) for i in b: print(i) #(1, 1) #(2, 23) #(3, 4) #(4, 5) #(5, 65) #(6, 88)
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i, seq[i])
#0 one
#1 two
#2 three
input()
函数接受一个标准输入数据，返回为string类型 python3里input()默认接受到的是str类型 a=input('input:') print(type(a)) #input:123 #<class 'str'>
oct()
print(oct(10)) print(oct(20)) print(oct(15)) #0o12 #0o24 #0o17
staticmethod()
返回函数的静态方法,和类没有绑定关系，就是一个普通的函数 class C(object): @staticmethod def f(): print('runoob') C.f()#静态方法无需实例化 cobj=C() cobj.f()#也可以实例化后调用
bin()
bin()返回一个整数int的二进制表示 print(bin(10)) print(bin(20)) #0b1010 #0b10100
eval()
函数用来执行一个字符串表达式，并返回表达式的值 x=5 a=eval('3*x') print(a)#15
int()
用于将一个字符串或数字转换为整型 print(int())#不传入参数时，得到结果0 print(int(10))#10 print(int(2.9))#2 print(int('12',16))#18 如果是带参数base的话，12要以字符串的形式进行输入，12为16进制 print(int('10',8))#8
open()
str()
str()函数将对象转化为适于人阅读的形式
a=str(1) print(type(a)) dict = {'runoob': 'runoob.com', 'google': 'google.com'}; print(type(dict)) s_dict=str(dict) print(type(s_dict))
bool()
bool函数用于将给定参数转换为布尔类型，如果没有参数，返回False bool是int的子类 print(bool())#False print(bool(0))#False print(bool(1))#True print(bool(2))#True
print(issubclass(bool, int))#bool是int的子类
exec()
描述 exec执行存储在字符串或文件中的python语句，相比于eval,exec可以执行更复杂的python代码 语法 exec(object[,globals[,locals]])
参数： object:必选参数，表示需要被指定的python代码，他必须是字符串或code对象，如果object是一个字符串，该字符串会先被解析为一组python语句，然后再执行,如果object是一个code对象， 那么他只是被简单地执行 globals:可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象 locals:可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象，如果该参数被忽略，那么它将会取与globals相同的值
返回值 exec返回值永远为None
实例 print(exec('print("Hello World")')) # 单行语句字符串 print(exec("print ('runoob.com')")) # 多行语句字符串 print(exec("""for i in range(5): print ("iter time: %d" % i) """)) """ Hello World None runoob.com None iter time: 0 iter time: 1 iter time: 2 iter time: 3 iter time: 4 None """ x = 10 expr = """ z = 30 sum = x + y + z print(sum) """ def func(): y = 20 exec(expr) exec(expr, {'x': 1, 'y': 2}) exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4}) func()
isinstance()
描述 isinstance()函数来判断一个对象是否是一个已知的类型，类似type() isintance()与type（）的区别： type不会认为子类是一种父类类型，不考虑继承关系 isinstance（）会认为子类是一种父类关系，考虑继承关系 如果要判断两个类型是否相同推荐使用isintance() 语法 以下是isinstance（）方法的语法 isinstance（object，classinfo） 参数 object--实例对象 classinfo--可以是直接或间接类名、基本类型或者由它们组成的元组 返回值 如果对象的类型与参数二的类型(classinfo)相同则返回True,否则返回False 实例 a = 2 print(isinstance (a,int)) print(isinstance (a,str)) print(isinstance (a,(str,int,list))) # 是元组中的一个返回 True class A: pass class B(A): pass print(isinstance(A(), A)) # returns True print(type(A()) == A) # returns True print(isinstance(B(), A)) # returns True print(type(B()) == A) # returns False """ True True True False """
ord()
描述 ord（）函数是chr（）函数（对于8位的ASCLL字符串）或unichr（）函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应ASCLL数值，或者Unicode数值，如果所给的Unicode字符超出了你的python定义范围，则会引发一个typeerror的异常 语法 以下是ord（）方法的语法 ord(c) 参数 c--字符 返回值 返回值是对应的十进制整数 实例 print(ord('a')) print(ord('b')) print(ord('c')) """ 97 98 99 """
sum()
描述 sum()方法对系列进行求和运算 语法 以下是sum（）方法的语法 sum(iterable[,start]) 参数 iterable--可迭代对象，如列表、元组、集合 start--指定相加的参数，如果没有设置这个值，默认为0 返回值 返回计算结果 实例 print(sum([0,1,2])) print(sum((2, 3, 4), 1)) # 元组计算总和后再加 1 print(sum([0,1,2,3,4], 2)) # 列表计算总和后再加 2
bytearray()
描述 bytearray()方法返回一个新字节数组，这个数组里的元素是可变的，并且每个元素的值范围：0<=x<256 语法 bytearray()方法语法 class bytearray([source[,encoding[,error]]]) 参数 如果source为整数，则返回一个长度为source的初始化数组 如果source为字符串，则按照指定的encoding将字符串转换为字节序列 如果source为可迭代类型，则元素必须为[0,255]中的整数 如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray 如果没有输入任何参数，默认就是初始化数组为的元素 返回值 返回新字节数组 实例 print(bytearray()) # bytearray(b'') print(bytearray([1,2,3])) # bytearray(b'\x01\x02\x03') print(bytearray('runoob', 'utf-8')) # bytearray(b'runoob')
filter()
描述
filter（）函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表
该接受两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回True或Flase,最后将返回True的元素放到新列表中
number_list=range(-5,5)
less_than_zero=filter(lambda x:x<0,number_list)
print(list(less_than_zero))#[-5, -4, -3, -2, -1]
filter类似于for循环，但它是一个内置函数，并且更快
语法 filter(function,iterable) 参数 function--判断函数 iterable--可迭代对象 返回值 返回列表 实例 #过滤出列表中所有的奇数 def is_odd(n): return n % 2 == 1 newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) print(list(newlist))#[1, 3, 5, 7, 9]
#过滤出1-100中平方根是整数的数 import math def is_sqr(x): return math.sqrt(x) % 1 == 0 newlist = filter(is_sqr, range(1, 101)) print(list(newlist))#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
issubclass()
描述 issubclass()方法用于判断参数class是否是类型参数classinfo的子类 语法 issubclass(class,classinfo) 参数 class--类 classinfo--类 返回值 如果class是classinfo的子类返回True,否则返回False 实例 class A: pass class B(A): pass print(issubclass(B, A)) # 返回 True
pow()
描述 pow（）方法返回xy（x的y次方） 的值。 语法 以下是math模块pow()方法的语法 import math math.pow(x,y) 内置的pow()方法 pow(x,y[,z]) 函数是计算x的y次方，如果z在存在，则在对结果进行取模，其结果等效于pow(x,y)%z 注意：pow()通过内置的方法直接调用，内置方法会把参数作为整型，而math模块则会把参数转换为float 参数 x--数值表达式 y--数值表达式 z--数值表达式 返回值 返回 xy（x的y次方） 的值。 实例 import math # 导入 math 模块 print ("math.pow(100, 2) : ", math.pow(100, 2)) # 使用内置，查看输出结果区别 print ("pow(100, 2) : ", pow(100, 2)) print ("math.pow(100, -2) : ", math.pow(100, -2)) print ("math.pow(2, 4) : ", math.pow(2, 4)) print ("math.pow(3, 0) : ", math.pow(3, 0)) """ math.pow(100, 2) : 10000.0 pow(100, 2) : 10000 math.pow(100, -2) : 0.0001 math.pow(2, 4) : 16.0 math.pow(3, 0) : 1.0 """
super()
描述 super()函数适用于调用父类（超类）的一个方法 super是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题 MRO就是类的方法解析顺序表，其实也就是继承父类方法时的顺序表 语法 super(type[,object-or-type]) 参数 type--类 object-or-type--类，一般是self python3.x和python2.x的一个区别是：python3可以直接使用super().xxx代替super(class,self).xxx Python3.x 实例： class A: pass class B(A): def add(self, x): super().add(x) Python2.x 实例： class A(object): # Python2.x 记得继承 object pass class B(A): def add(self, x): super(B, self).add(x) 返回值 无 实例 class FooParent(object): def __init__(self): self.parent = 'I\'m the parent.' print('Parent') def bar(self, message): print("%s from Parent" % message) class FooChild(FooParent): def __init__(self): # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象 super(FooChild, self).__init__() print('Child') def bar(self, message): super(FooChild, self).bar(message) print('Child bar fuction') print(self.parent) if __name__ == '__main__': fooChild = FooChild() fooChild.bar('HelloWorld') """ Parent Child HelloWorld from Parent Child bar fuction I'm the parent. """
bytes()
描述 bytes函数返回一个新的bytes对象，该对象是一个0<=x<256区间内的整数不可变序列。它是bytearray的不可变版本 语法 class bytes([source[,encoding[,errors]]]) 参数 如果source为整数，则返回一个长度为source的初始化数组 如果source为字符串，则按照指定的encoding将字符串转换为字节序列 如果source为可迭代类型，则元素必须为[0,255]中的整数 如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray 如果没有输入任何参数，默认就是初始化数组为0个元素 返回值 返回一个新的bytes对象 实例 a = bytes([1,2,3,4]) print(a) #b'\x01\x02\x03\x04' print(type(a)) #<class 'bytes'> a = bytes('hello','ascii') print(a) #b'hello' print(type(a)) #<class 'bytes'>
float（）
描述 float（）函数用于将整数和字符串转换成浮点数 语法 class float([x]) 参数 x--整数或字符串 返回值 返回浮点数 实例 print(float(1)) print(float(112)) print(float(-123.6)) print(float('123')) # 字符串 """ 1.0 112.0 -123.6 123.0 """
iter()
描述 iter（）函数用来生成迭代器,把一个可迭代对象变成迭代器对象 语法 iter(object[,sentinel]) 参数 object--支持迭代的集合对象 sentinel--如果传递了第二个参数，则参数object必须是一个可调用的对象（如，函数），此时，iter创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用object 返回值 迭代器对象 实例 lst = [1, 2, 3] for i in iter(lst): print(i) """ 1 2 3 """
print()
描述 print()方法用于打印输出，最常见的一个函数 print在python3.x是一个函数，但在python2.x版本不是一个函数，只是一个关键字 语法 print(*object,sep=' ',end='\n',file=sys.stdout) 参数 object--复数，表示可以一次输出多个对象。输出多个对象时，需要用，分隔 sep--用来间隔多个对象，默认值是一个空格 end--用来设定以什么结尾，默认值是换行符\n,我们可以换成其他字符串 file--要写入的文件对象 返回值 无 实例 print(1) print("Hello World") a = 1 b = 'runoob' print(a, b) print("aaa""bbb") print("aaa", "bbb") print("www", "runoob", "com", sep=".") # 设置间隔符 """ 1 Hello World 1 runoob aaabbb aaa bbb www.runoob.com """
tuple()
描述 tuple函数将列表转换为元组 语法 tuple(seq) 参数 seq--要转换为元组的序列 返回值 返回元祖 实例 list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] tuple1=tuple(list1) print(tuple1)#('Google', 'Taobao', 'Runoob', 'Baidu')
callable()
描述 callable()函数用于检查一个对象是否是可调用的，如果返回True,object仍然可能调用失败，如果是False,调用对象object绝对不会成功 对于函数、方法、lambda函数类，以及实现了__call__方法的类实例，它都返回True 语法 callable(object) 参数 object--对象 返回值 可调用返回True,否则返回False 实例 print(callable(0))#False print(callable("runoob"))#False def add(a, b): return a + b print(callable(add)) # 函数返回 True class A: # 类 def method(self): return 0 print(callable(A)) # 类返回 True a = A() print(callable(a)) # 没有实现 __call__, 返回 False class B: def __call__(self): return 0 print(callable(B))#返回True b = B() print(callable(b)) # 实现 __call__, 返回 True
format（）
python2.6开始，新增了一种格式化字符串的函数str.format(),它增强了字符串格式化的功能 基本语法是通过{}和：来代替以前的% format函数可以接受不限个参数，位置可以不按顺序 实例 print("{} {}".format("hello", "world")) # 不设置指定位置，按默认顺序 print("{0} {1}".format("hello", "world")) # 设置指定位置 print("{1} {0} {1}".format("hello", "world")) # 设置指定位置 """ hello world hello world world hello world """ 设置参数 print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com")) # 通过字典设置参数 site = {"name": "菜鸟教程", "url": "www.runoob.com"} print("网站名：{name}, 地址 {url}".format(**site)) # 通过列表索引设置参数 my_list = ['菜鸟教程', 'www.runoob.com'] print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的 """ 网站名：菜鸟教程, 地址 www.runoob.com 网站名：菜鸟教程, 地址 www.runoob.com 网站名：菜鸟教程, 地址 www.runoob.com """ 也可以向str.format()传入对象 class AssignValue(object): def __init__(self, value): self.value = value my_value = AssignValue(6) print('value 为: {0.value}'.format(my_value)) # "0" 是可选的 """ value 为: 6 """ 数字格式化 下表展示了str.format()格式化数字的多种方法 print("{:.2f}".format(3.1415926))#3.14
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
| -1 | {:+.2f} | -1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
| 5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
| 10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
| 13 | {:10d} | 13 | 右对齐 (默认, 宽度为10) |
| 13 | {:<10d} | 13 | 左对齐 (宽度为10) |
| 13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
| 11 |
'{:b}'.format(11)
'{:d}'.format(11)
'{:o}'.format(11)
'{:x}'.format(11)
'{:#x}'.format(11)
'{:#X}'.format(11)
|
1011
11
13
b
0xb
0XB
|
进制 |
^,<,>分别是居中，左对齐，右对齐，后面带宽度，：号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充
+表示在正数前显示+，负数前显示-； （空格）表示在正数前加空格
b、d、o、x分别是二进制、十进制、八进制、十六进制
此外我们可以使用大括号{}来转义大括号如下实例
print ("{} 对应的位置是 {{0}}".format("runoob"))#runoob 对应的位置是 {0}
len()
描述 python len()方法返回对象（字符、列表、元组）长度或项目个数 语法 len(s) 参数 s--对象 返回值 返回对象长度 实例 str = "runoob" print(len(str))#6 字符串长度 l = [1,2,3,4,5] print(len(l))#5 列表元素个数
property()
描述 property（）函数的作用是在新式类中返回属性值 语法 class property([fget[,fset[,fdel[,doc]]]]) 参数 fget--获取属性值的函数 fset--设置属性值的函数 fdel--删除属性值函数 doc--属性描述信息 返回值 返回新式类属性 实例 定义一个可控属性值x class C(object): def __init__(self): self._x = None def getx(self): return self._x def setx(self, value): self._x = value def delx(self): del self._x x = property(getx, setx, delx, "I'm the 'x' property.") 如果c是C的实例化，c.x将触发getter,c.x=value将触发setter,del c.x触发deleter,如果给定doc参数，其将成为这个属性值的docstring，否则property函数就会复制fget函数的docstring(如果有的话) 将property函数用作装饰器可以很方便的创建只读属性： class Parrot(object): def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage 上面的代码将voltage()方法转化成同名只读属性的getter方法 property的getter,setter和deleter方法同样可以用作装饰器 class C(object): def __init__(self): self._x = None @property def x(self): """I'm the 'x' property.""" return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x 这个代码和第一个例子完全相同，但要注意这些额外函数的名字和property下的一样，例如这里的x
type()
描述 type（）函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象 isintance（）与type()的区别 type()不会认为子类是一种父类类型，不考虑继承关系 isintance（）会认为子类是一种父类类型，考虑继承关系 如果要判断两个类型是否相同推荐使用isintance（） 语法 class type(name,bases,dict) 参数 name--类的名称 bases--基类的元组 dict--字典，类内定义的命名空间变量 返回值 一个参数返回对象类型，三个参数，返回新的类型对象 实例 # 一个参数实例 print(type(1))#<class 'int'> print(type('runoob'))#<class 'str'> print(type([2]))#<class 'list'> print(type({0: 'zero'}))#<class 'dict'> x = 1 print(type(x) == int)#True 判断类型是否相等 # 三个参数 class X(object): a = 1 X = type('X', (object,), dict(a=1)) # 产生一个新的类型 X print(X)#<class '__main__.X'> type和isintance的区别 class A: pass class B(A): pass print(isinstance(A(), A)) # returns True print(type(A()) == A) # returns True print(isinstance(B(), A)) # returns True print(type(B()) == A) # returns False
chr()
描述 chr()用一个范围在range(256)内的（就是0-255）整数做参数，返回一个对应的字符 语法 chr(i) 参数 i--可以是10进制也可以是16进制的形式的数字 返回值 返回值是当前整数对应的ascii字符 实例 print(chr(0x30), chr(0x31), chr(0x61)) # 十六进制 print(chr(48), chr(49), chr(97)) # 十进制
frozenset()
描述 frozenset()返回一个冻结的集合，冻结后集合不能再添加或删除任何元素 语法 class frozenset([iterable]) 参数 iterable--可迭代的对象，比如列表、字典、元组等等 返回值 返回新的frozenset对象，如果不提供任参数，默认会生成空集合 实例 a = frozenset(range(10)) # 生成一个新的不可变集合 print(a) #frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) b = frozenset('runoob') print(b) #frozenset({'u', 'o', 'r', 'b', 'n'}) # 创建不可变集合
list()
描述 list()方法用于将元组转换为列表 注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放在方括号中 语法 list(seq) 参数 list--要转换为列表的元组 返回值 返回列表 实例 aTuple = (123, 'Google', 'Runoob', 'Taobao') list1 = list(aTuple) print ("列表元素 : ", list1) #列表元素 : [123, 'Google', 'Runoob', 'Taobao'] str="Hello World" list2=list(str) print ("列表元素 : ", list2) #列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
range()
python3 range()函数返回的是一个可迭代对象（类型是对象），而不是列表类型，所以打印的时候不会打印列表。 python3 list()函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表 python2 range()函数返回的是列表 函数语法 range(stop) range(start,stop[,step]) 参数说明： start:计数从start开始。默认是从0开始。例如range(5)等价于range(0,5) stop:计数到stop结束，但不包括stop。例如：range(0,5)是[0,1,2,3,4]没有5 step:步长，默认为1。例如：range(0,5)等价于range(0,5,1) 实例 print(range(5)) for i in range(5): print(i) print(list(range(5))) print(list(range(0))) """ range(0, 5) 0 1 2 3 4 [0, 1, 2, 3, 4] [] """
有两个参数或三个参数的情况
print(list(range(0, 30, 5)))
print(list(range(0, 10, 2)))
print(list(range(0, -10, -1)))
print(list(range(1, 0)))
"""
[0, 5, 10, 15, 20, 25]
[0, 2, 4, 6, 8]
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
[]
"""
vars()
描述 vars()函数返回对象object的属性和属性值的字典对象 语法 vars([object]) 参数 object--对象 返回值 返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值类似locals() 实例 print(vars()) class Runoob: a = 1 print(vars(Runoob)) runoob = Runoob() print(vars(runoob)) """ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DE8710>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/py3code/jintong_day1/jinrong/t2.py', '__cached__': None} {'__module__': '__main__', 'a': 1, '__dict__': <attribute '__dict__' of 'Runoob' objects>, '__weakref__': <attribute '__weakref__' of 'Runoob' objects>, '__doc__': None} {} """
classmethod()
描述 classmethod修饰符对应的函数不需要实例化，不需要self参数，但第一个参数需要是表示自身类的cls参数，可以来调用类的属性，类的方法，实例化对象
语法 classmethod 参数 无 返回值 返回函数的类方法 实例 class A(object): bar = 1 def func1(self): print('foo') @classmethod def func2(cls): print('func2') print(cls.bar) cls().func1() # 调用 foo 方法 A.func2() # 不需要实例化
#a=A()
#a.func2()#也可以实例化后调用
""" func2 1 foo """
getattr（）
描述 getattr()函数用于返回一个对象属性值 语法 getattr(object,name[,default]) 参数 object--对象 name--字符串，对象属性 default--默认返回值，如果不提供该参数，在没有对应属性时，将触发AttributeError 返回值 返回对象属性值 实例 class A(object): bar = 1 a = A() print(getattr(a, 'bar')) # 获取属性 bar 值 print(getattr(a, 'bar2')) # 属性 bar2 不存在，触发异常 print(getattr(a, 'bar2', 3)) # 属性 bar2 不存在，但设置了默认值,返回3
locals()
描述 locals()函数会以字典类型返回当前位置的全部全局变量 对于函数，方法，lambda函数，类，以及实现了__call__方法的类实例，它都返回True 语法 locals() 参数 无 返回值 返回字典类型的局部变量 实例 def runoob(arg): # 两个局部变量：arg、z z = 1 print (locals()) runoob(4)# 返回一个名字/值对的字典
repr()
描述 repr()函数将对象转化为供解释器读取的形式 语法 repr(object) 参数 object--对象 返回值 返回一个对象的string格式 实例 s = 'RUNOOB' print(repr(s)) dict = {'runoob': 'runoob.com', 'google': 'google.com'} print(repr(dict)) """ 'RUNOOB' {'runoob': 'runoob.com', 'google': 'google.com'} """
zip()
描述 zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元祖解压为列表 语法 zip([iterable,]) 参数说明 iterable--一个或多个迭代器 返回值 返回元祖列表 实例 a = [1,2,3] b = [4,5,6] c = [4,5,6,7,8] zipped = zip(a,b) # 打包为元组的列表 print(list(zipped)) print(list(zip(a,c))) # 元素个数与最短的列表一致 print(list(zip(*zipped))) # 与 zip 相反，可理解为解压，返回二维矩阵式 """ [(1, 4), (2, 5), (3, 6)] [(1, 4), (2, 5), (3, 6)] [] """
compile()
描述 compile()函数将一个字符串编译为字节代码 语法 compile(source,filename,mode[,flag[,dont_inherit]]) 参数 source--字符串或者AST对象 filename--代码文件名称，如果不是从文件读取代码则传递一些可辨认的值 mode--指定编译代码的种类，可以指定为exec,eval,single flags--变量作用域，局部命名空间，如果被提供，可以是任何映射对象 flags和dont_inherit是用来控制编译源码时的标志 返回值 返回表达式执行结果 实例 str = "for i in range(0,10): print(i)" c = compile(str,'','exec') # 编译为字节代码对象 print(c) print(exec(c)) str = "3 * 4 + 5" a = compile(str,'','eval') print(eval(a))
globals()
描述 globals()函数会以字典类型返回当前位置的全部全局变量 语法 globals() 参数 无 返回值 返回全局变量的字典 实例 a='runoob' print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。 """ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DB8710>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/py3code/jintong_day1/jinrong/t2.py', '__cached__': None, 'a': 'runoob'} """
map()
描述 map()会根据提供的函数对指定序列做映射 第一个参数function以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的新列表 语法 map(function,iterable,) 参数 function--函数，有两个参数 iterable--一个或多个序列 返回值 python2.x返回列表 python3.x返回迭代器 实例 def square(x): # 计算平方数 return x ** 2 print(list(map(square, [1, 2, 3, 4, 5]))) # 计算列表各个元素的平方 print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))) # 使用 lambda 匿名函数 # 提供了两个列表，对相同位置的列表数据进行相加 print(list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])))
大多数时候，我们使用匿名函数来配合map,所以我在上面也是这么做的，不仅用于一列表的输入，我们甚至可以用于一列表的函数
def multiply(x):
return (x*x)
def add(x):
return (x+x)
funcs=[multiply,add]
for i in range(5):
values=map(lambda x:x(i),funcs)
print(list(values))
"""
[0, 0]
[1, 2]
[4, 4]
[9, 6]
[16, 8]
"""
reversed()
描述 reversed函数返回一个反转的迭代器 语法 reversed(seq) 参数 seq--要转换的序列，可以是tuple,string,list或range 返回值 返回一个反转的迭代器 实例 # 字符串 seqString = 'Runoob' print(list(reversed(seqString))) # 元组 seqTuple = ('R', 'u', 'n', 'o', 'o', 'b') print(list(reversed(seqTuple))) # range seqRange = range(5, 9) print(list(reversed(seqRange))) # 列表 seqList = [1, 2, 4, 3, 5] print(list(reversed(seqList))) """ ['b', 'o', 'o', 'n', 'u', 'R'] ['b', 'o', 'o', 'n', 'u', 'R'] [8, 7, 6, 5] [5, 3, 4, 2, 1] """
__import__()
描述 __import__()函数用于动态加载类和函数 如果一个模块经常变化就可以使用__import__()来动态载入 语法 __import__(name[,globals[,locals[,fromlist[,level]]]]) 参数说明 name--模块名 返回值 返回元祖列表 实例 a.py 文件代码： #!/usr/bin/env python #encoding: utf-8 import os print ('在 a.py 文件中 %s' % id(os)) test.py 文件代码： #!/usr/bin/env python #encoding: utf-8 import sys __import__('a') # 导入 a.py 模块 """ 在 a.py 文件中 31245400 """
complex()
描述 complex()函数用于创建一个值为real+imag*j的复数或者转化一个字符串或数为复数，如果第一个参数为字符串，则不需要指定第二个参数 语法 class complex([real[,imag]]) 参数说明 real--int,long,float或字符串 imag--int,long,float 返回值 返回一个复数 实例 print(complex(1, 2)) print(complex(1)) # 数字 print(complex("1")) # 当做字符串处理 # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 print(complex("1+2j")) """ (1+2j) (1+0j) (1+0j) (1+2j) """
hasattr()
描述 hasattr()函数用于判断对象是否包含对应的属性 语法 hasattr(object,name) 参数 object--对象 name--字符串，属性名 返回值 如果对象有该属性返回True,否则返回False 实例 class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print(hasattr(point1, 'x'))#True print(hasattr(point1, 'y'))#True print(hasattr(point1, 'z'))#True print(hasattr(point1, 'no')) # False 没有该属性
max()
描述 max()方法返回给定参数的最大值，参数可以为序列 语法 max(x,y,z) 参数 x--数值表达式 y--数值表达式 z--数值表达式 返回值 返回给定参数的最大值 实例 print ("max(80, 100, 1000) : ", max(80, 100, 1000)) print ("max(-20, 100, 400) : ", max(-20, 100, 400)) print ("max(-80, -20, -10) : ", max(-80, -20, -10)) print ("max(0, 100, -400) : ", max(0, 100, -400)) """ max(80, 100, 1000) : 1000 max(-20, 100, 400) : 400 max(-80, -20, -10) : -10 max(0, 100, -400) : 100 """
round()
描述 round()方法返回浮点数x的四舍五入值 语法 round(x[,n]) 参数 x--数字表达式 n--表示从小数点位数，其中x需要四舍五入，默认值为0 返回值 返回浮点数x的四舍五入值 实例 print ("round(70.23456) : ", round(70.23456)) print ("round(56.659,1) : ", round(56.659,1)) print ("round(80.264, 2) : ", round(80.264, 2)) print ("round(100.000056, 3) : ", round(100.000056, 3)) print ("round(-100.000056, 3) : ", round(-100.000056, 3)) """ round(70.23456) : 70 round(56.659,1) : 56.7 round(80.264, 2) : 80.26 round(100.000056, 3) : 100.0 round(-100.000056, 3) : -100.0 """
delattr()
描述 delattr函数用于删除属性 delattr（x,'foobar'）相等于del x.foobar 语法 delattr(object,name) 参数 object--对象 name--必须是对象的属性 返回值 无 实例 class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print('x = ', point1.x) print('y = ', point1.y) print('z = ', point1.z) delattr(Coordinate, 'z') print('--删除 z 属性后--') print('x = ', point1.x) print('y = ', point1.y) # 触发错误 print('z = ', point1.z) """ x = 10 y = -5 z = 0 --删除 z 属性后-- x = 10 y = -5 Traceback (most recent call last): File "D:/py3code/t2.py", line 95, in <module> print('z = ', point1.z) AttributeError: 'Coordinate' object has no attribute 'z' """
hash()
描述 hash()用于获取一个对象（字符串或者数值等）的哈希值 语法 hash(object) 参数说明 object--对象 返回值 返回对象的哈希值 实例 print(hash('test')) # 字符串 print(hash(1)) # 数字 print(hash(str([1,2,3]))) # 集合 print(hash(str(sorted({'1':1})))) # 字典 """ 13132176260035010 1 6599750410123157373 5131818324150481159 """
memoryview()
描述 memoryview()函数返回给定参数的内存查看对象 所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许python代码访问 语法 memoryview（obj） 参数说明 obj--对象 返回值 返回元祖列表 实例
python2.x
v = memoryview('abcefg')
print(v[1])
print(v[-1])
print(v[1:4])
print(v[1:4].tobytes())
"""
'b'
'g'
<memory at 0x77ab28>
'bce'
"""
python3.x v = memoryview(bytearray("abcefg", 'utf-8')) print(v[1]) print(v[-1]) print(v[1:4]) print(v[1:4].tobytes()) """ 98 103 <memory at 0x0000000001EAE708> b'bce' """
set()
描述 set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集，差集，并集 语法 class set([iterable]) 参数说明 iterable--可迭代对象 返回值 返回新的集合对象 实例 x = set('runoob') y = set('google') print(x, y) # 重复的被删除 print(x & y) # 交集 print(x | y) # 并集 print(x - y) # 差集 """ {'r', 'b', 'u', 'n', 'o'} {'g', 'e', 'o', 'l'} {'o'} {'r', 'b', 'l', 'g', 'e', 'u', 'n', 'o'} {'r', 'b', 'u', 'n'} """
reduce()
当需要对一个列表进行一些计算并返回结果时，reduce是个非常有用的函数，举个例子，当你需要计算一个整数列表的乘积时 通常在python中你可能会使用基本的for循环来完成任务 from functools import reduce product=reduce((lambda x,y:x*y),[1,2,3,4]) print(product)#24
