1.abs()
取数字的绝对值,参数可以是整数或浮点数。如果参数是一个复数，则返回其大小
>>> print(abs(-28))
28
>>> print(abs(-2.34))
2.34
>>> print(abs(1/3))
0.3333333333333333
2.dict()
用于创建字典
>>> dict() #创建空字典
{}
>>> dict(a='who',b='while',c='whit') #传入关键字创建字典
{'b': 'while', 'c': 'whit', 'a': 'who'}
>>> dict(zip([1,2,3],['one','two','three'])) #映射函数方式创建字典
{1: 'one', 2: 'two', 3: 'three'}
>>> dict([(1,'one'),(2,'two'),(3,'three')]) #可迭代对象方式创建字典
{1: 'one', 2: 'two', 3: 'three'}
3.help()
用于查看函数或模块用途的详细说明
>>> help('sys') #查看sys模块的帮助
>>> help('str') #查看str数据类型帮助信息
>>> a = [1,2,3]
>>> help(a) #查看列表list帮助信息
>>> help(a.extend) #显示list的extend方法的帮助信息
4.min()
返回给定参数的最小值，参数可以为列表，元组，字典和集合
>>> print(min(1,23,4)) #给定序列的最小值，这里实际上判断的元组类
1
>>> print(min([1,2,3,4])) #列表
1
>>> print(min((3,4,5))) #元组
3
>>> print(min({'a':3,'b':44,'c':22})) #字典，对字符串按ascii码位置判断
a
>>> print(min({22,33,44})) #集合判断
22
5.setattr()
对应函数 getatt()，用于设置属性值，该属性必须存在,参数是一个对象，一个字符串和一个任意值。该字符串可以命名现有的属性或新的属性。如果该对象允许，该函数将该值分配给该属性。
>>> class x(object):
... def aa():
... print('test is aa')
...
>>> setattr(x,'foo',123)
>>> print(x.foo)
123
6.all()
判断给定的可迭代参数中所有元素不为0，空，False,返回True,否则返回False
>>> all([1,2,3]) #列表元素不为空或0返回True
True
>>> all([0,2,3]) #列表元素为0返回False
False
>>> all([1,'',3]) #列表元素为空返回False
False
>>> all([1,False,3]) #列表元素为False返回False
False
>>> all([]) #注意：空列表返回True
True
>>> all((1,2,3)) #元组元素都不为空或0返回True
True
>>> all((0,2,3)) #为0返回False
False
>>> all((1,'',3)) #为空返回False
False
>>> all(()) #注意：空元组返回True
True
>>> all((1,False,3)) #为False返回False
False
7.dir()
获取当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表
>>> dir() #获取当前范围内的变量，方法和定义的类型列表，
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'd1']
#带参数时返回参数的属性，方法列表
>>> dir(list) #返回列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
8.hex()
将数值转换成十六进制
>>> hex(16) #将十进制转换成十六进制
'0x10'
>>> hex(-17)
'-0x11'
>>> hex(0o11) #将八进制转换成十六进制
'0x9'
>>> hex(0b1100) #将二进制转换成十六直接
'0xc'
>>> hex(0b10)
'0x2'
#说明：二进制表示（0b）,八进制表示（0o）,十六进制（0x）
9.next()
返回迭代器的下一个项目，可在没有下一个项目时返回设置的默认值
>>> it = iter([1,2,3,4,5]) #使用iter生成迭代器
>>> next(it) #返回一个可迭代数据结构中的下一个元素
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
4
>>> next(it)
5
>>> next(it) #在没有下一个元素则会触发 StopIteration 异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>> next(it,'no values') #在没有下一个元素时返回指定默认值
'no values'
10.slice()
用来创建切片对象，可指定起始和结束位置，间隔
class slice(stop)
class slice(start,stop[,step])
>>> l1 = [1,2,3,4,5,6,7,8]
>>> slice1 = slice(5) #定义一个切片对象，截取长度为5，不指定起始位置默认从索引0开始
>>> l1[slice1] #列表引用切片对象
[1, 2, 3, 4, 5]
>>> slice3 = slice(1,6,1) #定义一个切片对象，指定起始位置为1结束位置为6，间隔为1
>>> l1[slice3] #当间隔为1时，相当于0间隔
[2, 3, 4, 5, 6]
>>> slice2 = slice(1,7,2) #间隔为2时，相隔一个截取元素
>>> l1[slice2]
[2, 4, 6]
11.any()
判断可迭代参数是否全部为空或0或False则返回False，否则返回True。
>>> any([1,2,3])
True
>>> any([0,'',1])
True
>>> any([0,'',False]) #全部为空值才返回False
False
>>> any([]) #空列表返回False
False
>>> any((1,2,3))
True
>>> any((0,'',1))
True
>>> any((0,'',False))
False
>>> any(()) #空元组返回False
False
12.divmod(a,b)
返回a除以b的商和余数的元组(a//b,a%b)
>>> divmod(4,2) #返回4除以2的商和余数
(2, 0)
>>> divmod(15,4)
(3, 3)
>>> divmod(2+0.2j,3+1.3j) #不支持负数
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can't take floor or mod of complex number.
>>> divmod(4,8) #当不被整除时余数返回4，不解！
(0, 4)
>>> divmod(4,9)
(0, 4)
>>> divmod(4,100)
(0, 4)
13.id()
用于获取对象的内存地址
>>> id(1)
8956480
>>> id(2)
8956512
>>> id('b')
140349300904040
>>> a = 'python'
>>> id(a)
140349300975744
14.object()
获取一个新的，无特性(geatureless)对象。Object是所有类的基类。它提供的方法将在所有的类型实例中共享。
该函数时2.2.版本新增，2.3版本之后，该函数不接受任何参数。
15.sorted()
对所有可迭代的对象进行排序操作
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
语法：sorted(iterable, /, *, key=None, reverse=False)
iterable:可迭代对象
key:用来进行比较的元素，只有一个参数，指定可迭代对象中的一个元素来进行排序
reverse:排序规则，reverse=True为降序，reverse= False为升序（默认）
>>> sorted([-12,3,23,18]) #列表按数字排序
[-12, 3, 18, 23]
>>> sorted([-12,3,23,18],key=abs) #列表数字按绝对值排序
[3, -12, 18, 23]
>>> sorted(['bc','aa','fd','cj']) #列表字符按首字母的ASCII码排序
['aa', 'bc', 'cj', 'fd']
#如果是数字与字符混合，在python3需要指定key的函数对象
>>> l1 = [2,'a','b',4,-33,'python']
>>> l1
[2, 'a', 'b', 4, -33, 'python']
>>> sorted(l1,key=id) #按内存地址排序
[2, 4, -33, 'a', 'b', 'python']
>>> sorted(l1,key=str) #按字符串排序，对所有数据转换成字符串后首个字符按ASCII排序
[-33, 2, 4, 'a', 'b', 'python']
>>> ord('-')
45
>>> ord('2')
50
>>> ord('4')
52
>>> ord('a')
97
>>> ord('b')
98
>>> ord('p')
112
#如果需要排序的是一个列表嵌套元组，则需要使用参数key，指定关键字
>>> a = [('b',2),('a',1),('c',0)]
>>> sorted(a,key=lambda x:x[0])
[('a', 1), ('b', 2), ('c', 0)]
>>> sorted(a,key=lambda x:x[1])
[('c', 0), ('a', 1), ('b', 2)]
>>> tup1 = ('python','java','c++','bash','php','perl','c#')
>>> tup1
('python', 'java', 'c++', 'bash', 'php', 'perl', 'c#')
>>> sorted(tup1,key=str.lower) #忽略大小写排序
['bash', 'c#', 'c++', 'java', 'perl', 'php', 'python']
>>> sorted(tup1,key=str.lower,reverse=True) #反向排序
['python', 'php', 'perl', 'java', 'c++', 'c#', 'bash']
#嵌套字典，按某个键值排序
>>>alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
>>>sorted(alist,key=lambda x:x['age'],reverse=False) #False为升序，True降序
[{'age': 20, 'name': 'a'}, {'age': 25, 'name': 'c'}, {'age': 30, 'name': 'b'}]
16.ascii()
类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 x, u 或 U 编码的字符
>>> ascii('bb')
"'bb'"
>>> ascii('+')
"'+'"
>>> ascii('中')
"'\u4e2d'"
17.enumerate()
函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
语法：enumerate(sequence,[start=o])
sequence：一个序列，迭代器或其他支持迭代对象
start：下标起始位置
>>> l1 = ['python','c++','java','php','css']
>>> list(enumerate(l1)) #生成数据和数据下标
[(0, 'python'), (1, 'c++'), (2, 'java'), (3, 'php'), (4, 'css')]
>>> list(enumerate(l1,1)) #指定下标从1开始
[(1, 'python'), (2, 'c++'), (3, 'java'), (4, 'php'), (5, 'css')]
>>> l1 = ['python','c++','java','php','css']
>>> for i,v in enumerate(l1):
... print(i,v)
...
0 python
1 c++
2 java
3 php
4 css
18.input()
用来获取交换输入，python3默认接受的是字符串
>>> in1 =input('inside:')
inside:123
>>> type(in1) #默认接受字符串
<class 'str'>
>>> in2 =input('inside:')
inside:python
>>> type(in2)
<class 'str'>
19.oct()
将一个整数转换成8进制字符串
>>> oct(10) #十进制转八进制
'0o12'
>>> oct(0b1010) #二进制转八进制
'0o12'
>>> oct(0xA) #十六进制转八进制
'0o12'
>>> oct(3.3) #不支持float浮点型转八进制
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
>>> oct(0.1+1.2j) #不支持complex复数转八进制
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'complex' object cannot be interpreted as an integer
20.staticmethod()
返回函数的静态方法
21.bin()
返回一个整数 int 或者长整数 long int 的二进制表示。可以将八进制，十进制，十六进制转换为二进制，不支持float类型
>>> bin(10) #十进制转二进制
'0b1010'
>>> bin(10.1) #float不支持转二进制
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
>>> bin(0o10) #八进制转二进制
'0b1000'
>>> bin(0xA) #十六进制转二进制
'0b1010'
22.eval()
用来执行一个字符串表达式，并返回表达式的值。
>>> eval('123')
123
>>> a = eval('123') #可以将数值字符串转换为int类型
>>> type(a)
<class 'int'>
>>> eval('2**8') #将数值字符串当表达式并计算结果返回int类型
256
>>> eval("'a'+'b'") #字符串运算，必须这么写
'ab'
>>> eval("'a'*5") #必须这么写，5不能加引号否则报错
'aaaaa'
>>> eval("'a'*'5'")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'str'
23.int()
用于将一个字符串数值或数字转换为整形
>>> int() #不传入参数结果为0
0
>>> a =int('2') #将字符串转换成int类型
>>> type(a)
<class 'int'>
>>> a
2
>>> int(2.6) #将浮点型转换为整型
2
>>> b =int('12',16) #以字符串的十六进制转换为十进制
>>> type(b)
<class 'int'>
>>> b
18
>>> int('0xC',16) #可以这样写十六进制
12
>>> int('10',8) #八进制转十进制
8
>>> int('0o10',8)
8
>>> int('0b1000',2) #二进制转十进制
8
>>> int('1000',2) #可以省略进制表示法
8
24.open()
用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写
>>> f = open('aa.txt','r+') #以读写方式打开一个文件
>>> f.write('hello python
') #写入内容到文件中
13
>>> f.flush() #刷新文件内容
>>> f.tell() #查看指针位置
13
>>> f.seek(0) #移动文件指针到起始位置
0
>>> f.tell() #查看指针
0
>>> f.readline() #根据指针位置返回一行文件内容
'hello python
'
file1 = open('aa.txt','a+',1) #以追加写的模式打开文件，1表示行缓冲，如为0则不缓冲，大于1时表示缓冲区大小，为负数时使用系统默认值。
25.str()
将字节转换成字符串，bytes() 将字符串转换为字节
>>> s1=str(11)
>>> type(s1) #将对象转换成字符串
<class 'str'>
>>> bytes('中',encoding = 'utf-8') #将字符串转换bytes字节
b'xe4xb8xad'
>>> str(b'xe4xb8xad',encoding = 'utf-8') #将字节转换为字符串
'中'
>>> bytes() #生成空字节对象
b''
26.bool()
判断给的参数是否为真，则返回True,否则返回False
>>> bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> bool(False)
False
>>> bool(True)
True
>>> bool('')
False
>>> bool('a')
True
>>> bool(None)
False
>>> bool("")
False
>>> bool([])
False
>>> bool(())
False
>>> bool({})
False
27.exec()
执行字符串或complie方法编译过的字符串，没有返回值
>>> exec("a=1+2+3+4")
>>> a
10
>>> exec('''sum = 0
... for i in range(101):
... sum+=i
... print(sum)
... ''')
5050
28.isinstance()
判断对象是否是某个类的实例
>>> isinstance('a',str) #判断a是否是字符类的对象
True
>>> isinstance('a',int)
False
>>> isinstance(11,int)
True
>>> isinstance({1:'a'},dict)
True
>>> isinstance({1,2},dict)
False
>>> isinstance({1,2},set)
True
>>> isinstance((1,2),(str,int,list)) #判断对象是否在元祖中的一个类创建返回True，否则返回False
False
>>> isinstance((1,2),(str,int,list,tuple))
True
29.ord()
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常
>>> ord('2') #长度只能为一个字符串
50
>>> ord('a')
97
>>> ord('A')
65
>>> ord('中') #返回对应的unicode值
20013
>>> ord('国')
22269
>>> ord('+') #返回ascii数值
43
30.sum()
对系列进行求和计算，只能是列表或元祖
>>> sum([1,2,3,4]) #求有序列的和，只能是数字类型
10
>>> sum([1,2,3,4],5) #对有序列求和后相加的数字
15
31.bytearray()
返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
>>> bytearray() #没有参数时，初始化数组0个元素
bytearray(b'')
>>> bytearray(12) #为整数时，返回一个长度为源的初始化数组
bytearray(b'x00x00x00x00x00x00x00x00x00x00x00x00')
>>> bytearray('python','utf-8') #为字符串时，按指定编码转换为字节序列
bytearray(b'python')
>>> bytearray([1,2,3]) #可迭代时，必须为0-255中的整数，字节序列
bytearray(b'x01x02x03')
32.filter()
用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的迭代器
语法：filter(function,iterable) function:判断函数，iterable:可迭代对象
>>> def is_odd(x):
... return x % 2 == 1 #创建一个过滤奇数的函数
...
>>> newlist = filter(is_odd,[1,2,3,4,5,6,7,8,9]) #使用filter过滤以is_odd函数为判断依据的迭代器
>>> print(newlist)
<filter object at 0x7f544ab79908>
>>> next(newlist) #使用next打印迭代器的下一个值
1
>>> next(newlist)
3
>>> next(newlist)
5
>>> next(newlist)
7
>>> next(newlist)
9
33.issubclass()
用于判断参数 class 是否是类型参数 classinfo 的子类
class A(object):
pass
class B(A):
pass
print(issubclass(B,A)) #判断B是否是A的派生类，是返回True，否则返回False
34.pow()
返回x的y次方，如果z存在则再对结果取模（pow(x,y)%z）
>>> pow(6,2) #6的2次方
36
>>> pow(6,2,5) #先预算6的2次方，在对结果取5的模
1
>>> pow(8,2)
64
>>> pow(8,2,5)
4
#math模块的pow（）方法对比
>>> import math
>>> math.pow(6,2) #math模块会把参数转换成float计算
36.0
>>> math.pow(6,2,5) #math模块中没有取模方法参数
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pow expected 2 arguments, got 3
35.super()
调用父类的方法
class A(object):
def __init__(self):
self.name = 'python'
def foo(self):
print('class,A')
class B(A):
super(A) #调用父类的方法和属性
def foo_b(self):
print('class',self.name)
#print(issubclass(B,A))
bb = B()
bb.foo()
bb.foo_b()
#output
class,A
class python
36.float()
用于将整数和字符串转换成浮点数
>>> float(2)
2.0
>>> float('2')
2.0
>>> float(-23)
-23.0
37.iter()
用来生成迭代器
>>> new1 = iter(('a','b','c','e','g'))
>>> new1
<tuple_iterator object at 0x7f544ab7b5f8>
>>> next(new1)
'a'
>>> next(new1)
'b'
38.print()
打印输出
语法：print(*objects,sep=' ',end=' ',file=sys.stdout)
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符
，我们可以换成其他字符串。
file -- 要写入的文件对象。
>>> print('hello world')
hello world
>>> print('hello world',123) #多对象打印
hello world 123
>>> print('hello world',123,sep='++') #多对象打印连接符
hello world++123
>>> print('hello world',123,sep='++',end=' ') #结尾符设置
hello world++123 >>>
>>> print('hello world',123,sep='++',end='')
hello world++123>>>
39.tuple()
将列表转换成元组
>>> tuple([1,2,3,4,5]) #列表转元组
(1, 2, 3, 4, 5)
>>> tuple({1,2,3,4,5}) #集合转元组
(1, 2, 3, 4, 5)
>>> tuple({1:'a',2:'b',3:'c'}) #字典转元组，只获取自动的key
(1, 2, 3)
40.callable()
检查一个对象是否是可调用的，返回True否则返回False
>>> def func():
... return 1 + 2
...
>>> func()
3
>>> callable(func) #对象函数可执行返回True
True
41.format()
格式化字符串，语法通过{}和:来代替以前的%，不限制参数个数，可以不按顺序传参
In [27]: '{}+{}={}'.format(1,2,3) #格式化按顺序应用参数值
Out[27]: '1+2=3'
In [28]: '{2}-{1}={0}'.format(1,2,3) #指定顺序应用参数值，0代表第一个元素，1代表第二个元素，以此类推，指定元素位置时要么全部指定，要不都不指定，不能只指定一部分
Out[28]: '3-2=1'
In [29]: '{0}+{0}={1}'.format(2,3) #指定参数可以重复使用
Out[29]: '2+2=3'
In [30]: '{}+{}={}'.format(2,3) #如不指定顺序，format参数不够就会报错
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-30-29f40e412920> in <module>()
----> 1 '{}+{}={}'.format(2,3)
IndexError: tuple index out of range
In [31]: l1 = [2,4,8]
In [32]: '{}*{}={}'.format(*l1) #使用列表引用参数值
Out[32]: '2*4=8'
In [33]: dct = {'name':'python','age':20} #定义字典
In [35]: 'welcom to {name},age is {age}'.format(name='qi',age=28) #变量引用
Out[35]: 'welcom to qi,age is 28'
In [36]: 'welcom to {name},age is {age}'.format(**dct) #使用**引用字典参数必须填写key值
Out[36]: 'welcom to python,age is 20'
填充与格式化：
In [53]: "{0: >20}".format("string") #使用空格填充20宽度右对齐，0代表指定第一个参数值
Out[53]: ' string'
In [54]: "{0:&>20}".format("string")
Out[54]: '&&&&&&&&&&&&&&string'
In [55]: "{0:#>20}".format("string") #使用#号会有个小bug
....:
Out[55]: '##############string'
In [60]: '{0:+<20}'.format("string") #向左对齐填充+
Out[60]: 'string++++++++++++++'
In [61]: '{0:+^20}'.format("string") #剧中对齐填充+
Out[61]: '+++++++string+++++++'
精度与进制：
>>> '{0:.3f}'.format(10/3) #小数位进度格式化
'3.333'
>>> '{0:b}'.format(8) #格式化二进制
'1000'
>>> '{0:o}'.format(9) #格式化八进制
'11'
>>> '{0:x}'.format(26) #格式化十六进制
'1a'
>>> '{0:,}'.format(123456789) #千分位格式化
'123,456,789'
使用索引：
>>> l2 = ['AA',{'bb':'cc'},('d','e')] #列表索引引用
>>> 'outing:{0[0]}'.format(l2)
'outing:AA'
>>> 'outing:{0[0]},{0[1]}'.format(l2) #将列表当成一个元素，在其中索引值
"outing:AA,{'bb': 'cc'}"
42.len()
返回对象（字符、列表、元组等）长度或项目个数
>>> len('python')
6
>>> len('123')
3
>>> len([1,2,3,4])
4
>>> len((1,2,3,4))
4
>>> len({1:'a',2:'b',3:'c'})
3
>>> len({1,2,3,4})
4
43.property()
在新式类中返回属性值
44.type()
返回对象的类型
>>> type('123')
<class 'str'>
>>> type(12)
<class 'int'>
>>> type(12.2)
<class 'float'>
>>> type([])
<class 'list'>
>>> type(())
<class 'tuple'>
>>> type({})
<class 'dict'>
>>> type({1,2,3})
<class 'set'>
45.chr()
返回一个数字在ASCII编码中对应的字符，取值范围256个
>>> chr(1)
'x01'
>>> chr(11)
'x0b'
>>> chr(255)
'ÿ'
>>> chr(256)
'Ā'
>>> chr(257)
'ā'
>>> chr(0x31)
'1'
>>> chr(0x3)
'x03'
>>> chr(0x11)
'x11'
46.frozenset()
返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
>>> set1 = frozenset([1,2,3,4]) #列表返回一个不可变集合
>>> set1
frozenset({1, 2, 3, 4})
>>> frozenset((5,6,7)) #元祖返回一个不可变集合
frozenset({5, 6, 7})
>>> a
{1: 'a', 2: 'b', 3: 'c'}
>>> frozenset(a) #字典返回一个不可变集合
frozenset({1, 2, 3})
>>> frozenset({3,4,5}) #集合返回一个不可变集合
frozenset({3, 4, 5})
47.list()
将字符串或元祖转换为列表
>>> l1 = list('python') #字符串转列表
>>> type(l1)
<class 'list'>
>>> l1
['p', 'y', 't', 'h', 'o', 'n']
>>> list((1,2,3,4,5)) #元祖转列表
[1, 2, 3, 4, 5]
>>> dic1 = {1:'a',2:'b',3:'c'}
>>> list(dic1) #字典转列表
[1, 2, 3]
>>> list({1,2,3,4}) #集合转列表
[1, 2, 3, 4]
>>> list() #返回空列表
[]
48.range()
创建一个整数列表
>>> l1 = range(5)
>>> l1
range(0, 5)
>>> for i in l1: #循环取序列
... print(i)
...
0
1
2
3
4
>>> for i in range(1,4):print(i) #指定起始和结束位置
...
1
2
3
>>> for i in range(1,10,3):print(i) #指定起始和结束位置和步长
...
1
4
7
>>> for i in range(0,-10,-4):print(i) #负数以补偿循环
...
0
-4
-8
>>> for i in range(len('python')):print('python'[i]) #字符串循环打印
...
p
y
t
h
o
n
49.vars()
返回当前模块中的所有变量
>>> class runoob:
... a = 1
...
>>> print(vars(runoob))
{'__dict__': <attribute '__dict__' of 'runoob' objects>, '__module__': '__main__', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'runoob' objects>, 'a': 1}
>>> aa = runoob()
>>> aa
<__main__.runoob object at 0x7f98f1b3c0d0>
>>> print(vars(aa))
{}
50.classmethod()
返回一个类方法，具体实例请看python3之面向对象类定义
51.getattr()
返回一个对象属性值,也就是函数内存地址
class test(object):
i = 'hello'
def show(self):
print('output:',self.i)
obj1 = test() #实例化对象
ss = getattr(obj1,'show') #返回一个对象的方法内存地址
ss() #执行对象方法
#output
output: hello
52.set()
创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等
>>> s1 = set('pythonpython')
>>> s1 = set('pythonpython') #重复的被删除
>>> s1
{'h', 'n', 'o', 'p', 't', 'y'}
>>> type(s1)
<class 'set'>
>>> s2 = set('pyqi')
>>> s2
{'p', 'y', 'i', 'q'}
>>> s1 & s2 #交集
{'p', 'y'}
>>> s1 | s2 #并集
{'p', 'q', 't', 'i', 'h', 'y', 'n', 'o'}
>>> s1 - s2 #差集i
{'h', 't', 'n', 'o'}
53.locals()
以字典类型返回当前位置的全部局部变量
>>> def funct(*args): #两个局部变量
... a = 22
... print(locals())
...
>>> funct(33,44) #返回所有局部变量的健值
{'a': 22, 'args': (33, 44)}
54.repr()
将对象转化为供解释器读取的形式
>>> aa = repr([1,2,3])
>>> type(aa) #将对象转换为字符
<class 'str'>
>>> repr({'a':'A','b':'B'})
"{'a': 'A', 'b': 'B'}"
55.zip()
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表
>>> aa = (zip([1,2,3],['a','b','c']))
>>> aa
<zip object at 0x7f98f1893680>
>>> next(aa)
(1, 'a')
>>> next(aa)
(2, 'b')
>>> next(aa)
(3, 'c')
>>> bb = zip([1,2,3],['a','b','c','d'],['A','B','C','D','E'])
>>> bb
<zip object at 0x7f98f18936c8>
>>> next(bb)
(1, 'a', 'A')
>>> next(bb)
(2, 'b', 'B')
>>> next(bb)
(3, 'c', 'C')
56.compile()
将一个字符串编译为字节代码
>>> str = 'for i in range(10):print(i)'
>>> c = compile(str,'','exec')
>>> c
<code object <module> at 0x7f98f1b774b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = '3*5+3'
>>> a = compile(str,'','eval')
>>> eval(a)
18
57.globals()
以字典类型返回当前位置的全部全局变量
>>> a = 'python'
>>> print(globals()) #返回一个全局变量的字典，包括导入的变量
{'__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__builtins__': <module 'builtins' (built-in)>, 'a': 'python', '__name__': '__main__', '__doc__': None, '__package__': None, '__spec__': None}
58.map()
将函数调用映射到每个序列的对应元素上并返回一个含有所有返回值的列表
>>> def out(x,y):
... return (x,y)
...
>>> l1 =map(out,[1,2,3,4,5],['a','b','c','d','e']) #映射序列，返回函数的值
>>> print(list(l1))
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]
>>> def foo(x,y):
... return x*y
...
>>> print(list(map(foo,[2,3,4],[5,6,7])))
[10, 18, 28]
59.reversed()
返回一个反转的迭代器
>>> print(list(reversed(range(10)))) #range反转
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> print(list(reversed(['a','c','f'])))
['f', 'c', 'a']
>>> print(list(reversed(('java','c++','python'))))
['python', 'c++', 'java']
>>> print(list(reversed('python')))
['n', 'o', 'h', 't', 'y', 'p']
60.__import__()
用于动态加载类和函数
61.complex()
返回一个复数
>>> complex(1,2)
(1+2j)
>>> complex('2')
(2+0j)
>>> complex('2','3') #为字符串时只能指定一位
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: complex() can't take second arg if first is a string
>>> complex('2+3j')
(2+3j)
62.hasattr()
用于判断对象是否包含对应的属性
>>> print(hasattr(list,'append'))
True
>>> print(hasattr(tuple,'append'))
False
>>> print(hasattr(tuple,'index'))
True
>>> print(hasattr(dict,'keys'))
True
>>> print(hasattr(dict,'values'))
True
63.max()
返回给定参数的最大值
>>> max([2,44,55,88])
88
>>> max((3,48))
48
>>> max({1:48,2:23})
2
64.round()
返回浮点数x的四舍五入值
>>> print(round(1.345))
1
>>> print(round(1.345,3)) #3为小数点后位数
1.345
>>> print(round(1.345,2))
1.34
>>> print(round(1.345,1))
1.3
>>> print(round(1.545,1))
1.5
>>> print(round(1.545,2))
1.54
65.delattr()
删除对象的属性
66.hash()
获取一个对象（字符串或者数值等）的哈希值
>>> hash('python')
-7183818677546017823
>>> hash(1)
1
>>> hash(36)
36
>>> hash([1,2,3]) #列表不能取哈希值
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> hash(str([1,2,3]))
-1281906435344341319
>>> hash(str({1:'a'}))
-6473938891374685725
>>> hash(str({'1':'1'}))
-5747816388481399936
67.memoryview()
返回字节对象的内存地址
>>> a = bytes([1,2,3]) #定义一个字节对象
>>> a
b'x01x02x03'
>>> memoryview(a)
<memory at 0x7f7cd1bbcb88>
>>> b = memoryview(a) #返回字节对象的内存地址
>>> b[0]
1
>>> b[1]
2
>>> b[1:4] #切片取的是一个迭代器
<memory at 0x7f7cd1bbcb88>
>>> b[1:3].tobytes()
b'x02x03'
>>> for i in b:print(i) #迭代取数值
...
1
2
3