Duang！
68个内置函数
分类记忆
数学运算 × 7
abs() 、 divmod() 、 max() 、 min() 、pow() 、round() 、sum()
类型转换 × 24
bool() 、 int() 、 float() 、 complex() 、str() 、 ord() 、 chr() 、 bytearray() 、 bytes() 、 memoryview() 、 bin() 、 oct() 、 hex() 、 tuple() 、 list() 、 dict() 、 set() 、 frozenset()、 enumerate() 、 range() 、 iter() 、 slice() 、super() 、object()
序列操作 × 8
all() 、any() 、 filter() 、 map() 、next() 、reversed() 、sorted() 、zip()
对象操作 × 9
help() 、dir() 、 id() 、hash() 、type() 、len() 、ascii() 、format() 、vars()
反射操作 × 8
Import() 、isinstance() 、issubclass() 、hasattr() 、getattr() 、setattr() 、delattr() 、callable()
变量操作 × 2
globals() 、locals()
交互操作 × 2
print()、input()
文件操作 × 1
open()
编译执行 × 4
compile() 、eval() 、exec() 、repr()
装饰器 × 3
property() 、 classmethod() 、staticmethod()
————————————————
版权声明：本文为CSDN博主「anti_ice_point」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/anti_ice_point/article/details/88621821
1、 abs() 取绝对值
>>> abs(-5.24)
5.24
2、 all() 用于判断给定的可迭代参数中的所有元素是否都为True。若括号内存在为 0、空（’’）、None、False的元素，返回False。
#注：空元组、空列表返回值为True
>>> all([]) # 空列表
True
>>> all(()) # 空元组
True
>>> all(['a', 'b', 'c', 'd']) #列表list，元素都不为 0、''、None、False
True
>>> all(['a', 'b', '', 'd']) #列表list，存在一个为空的元素
False
>>> all([0, 1，2, 3]) #列表list，存在一个为0的元素
False
>>> all(('a', 'b', 'c', 'd')) #元组tuple，元素都不为 0、''、None、False
True
>>> all(('a', 'b', '', 'd')) #元组tuple，存在一个为空的元素
False
>>> all((0, 1，2, 3)) #元组tuple，存在一个为0的元素
False
3、 any() 用于判断给定的可迭代参数中是否有为True值的元素。若括号内所有元素都是 0、空（’’）、None、False，返回False。
>>> any([]) # 空列表
False
>>> any(()) # 空元组
False
>>> any(['a', 'b', 'c', 'd']) #列表list，元素都不为 0、''、None、False
True
>>> any(['a', 'b', '', 'd']) #列表list，存在一个为空的元素
True
>>> any([0, '', False]) #列表list，元素全为 0、''、None、False
False
>>> any(('a', 'b', 'c', 'd')) #元组tuple，元素都不为 0、''、None、False
True
>>> any(('a', 'b', '', 'd')) #元组tuple，存在一个为空的元素
True
>>> any((0, '', False)) #元组tuple，元素全为 0、''、None、False
False
4、 ascii() 返回一个可打印的对象字符串方式表示，若是非ascii字符就会输出\x，\u或\U等字符来表示。（与python2版本里的repr()是等效的函数）
>>> ascii(524)
'524'
>>> ascii('￥')
"'￥'"
>>> ascii('我是沙雕') #非ascii字符
"'\\u6211\\u662f\\u6c99\\u96d5'"
5、 bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'
6、 bool() 用于将给定参数转换为布尔类型，如果没有参数，返回 False。
>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> issubclass(bool, int) # bool 是 int 子类
True
7、 bytearray() 返回一个新的字节数组。bytearray类是range 0 ≤ x ≤ 256的一个可变序列。
>>> b = bytearray()
>>> b
bytearray(b'')
>>> len(b)
0
#当source参数为字符串时，encoding参数也必须提供，函数将字符串使用str.encode方法转换成字节数组
>>> bytearray('中文')
Traceback (most recent call last):
File "<pyshell#48>", line 1, in <module>
bytearray('中文')
TypeError: string argument without an encoding
>>> bytearray('中文','utf-8')
bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
#当source参数为整数时，返回这个整数所指定长度的空字节数组
>>> bytearray(2)
bytearray(b'\x00\x00')
>>> bytearray(-2) #整数需大于0，使用来做数组长度的
Traceback (most recent call last):
File "<pyshell#51>", line 1, in <module>
bytearray(-2)
#当source参数是一个可迭代对象，那么这个迭代对象的元素都必须符合 0 ≤ x ≤ 256，以便可以初始化到数组里
>>> bytearray([1,2,3])
bytearray(b'\x01\x02\x03')
>>> bytearray([256,2,3]) #不在0-255范围内报错
Traceback (most recent call last):
File "<pyshell#53>", line 1, in <module>
bytearray([256,2,3])
ValueError: byte must be in range(0, 256)
8、 bytes() 将一个字符串转换成字节类型复制代码
>>> s = 'python'
>>> x = bytes(s, encoding='utf-8')
>>> x
b'python'
>>> a = '王'
>>> s = bytes(a, encoding='utf-8')
>>> s
b'\xe7\x8e\x8b'
9、 callable() 判断对象是否可以被调用，能被调用的对象就是一个callables对象
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False
10、 chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符
>>>print chr(0x30), chr(0x31), chr(0x61) # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97) # 十进制
0 1 a
11、 classmethod() 用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行雷的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法。
class Province:
country = "中国"
def __init__(self, name):
self.name = name
@classmethod
def show(cls): # 类方法，由类调用，最少要有一个参数cls，调用的时候这个参数不用传值，自动将类名赋值给cls
print(cls)
# 调用方法
Province.show()
12、complie() 将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译
1） compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
2） 将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。
3） 参数source：字符串或者AST（abstract syntax trees）对象。
4） 参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
5）参数model：指定编译代码的种类。可以指定’exec’, ‘eval’, ‘single’。
6）参数flag和dont_inherit：这两个参数为可选参数。
————————————————
版权声明：本文为CSDN博主「anti_ice_point」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/anti_ice_point/article/details/88621821
>>> s = "print('helloworld')"
>>> r = compile(s, "<string>", "exec")
>>> r
<code object <module> at 0x000001C648038390, file "<string>", line 1>
13、 complex() 用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
>>>complex(1, 2)
(1 + 2j)
>>> complex(1) # 数字
(1 + 0j)
>>> complex("1") # 当做字符串处理
(1 + 0j)
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)
14、 delattr() 用于删除属性
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 "test.py", line 22, in <module>
print('z = ',point1.z)
AttributeError: Coordinate instance has no attribute 'z'
15、 dict() 根据传入的参数创建一个新的字典
>>> dict() # 不传入任何参数时，返回空字典
{}
>>> dict(a = 1,b = 2) # 可以传入键值对创建字典
{'b': 2, 'a': 1}
>>> dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典
{'b': 2, 'a': 1}
>>> dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典
{'b': 2, 'a': 1}
16、 dir() 不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表。
>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'li', 'li1', 'li2', 'li_1']
>>> 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']
17、 divmod() 分别取商和余数
>>> divmod(20,6)
(3, 2)
18、 enumerate() 根据可迭代对象创建枚举对象
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1)) #指定起始值
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
19、 eval() 用来执行一个字符串表达式，并返回表达式的值。将字符串str当成有效的表达式来求值并返回计算结果。
eval(expression[, globals[, locals]])
expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
————————————————
版权声明：本文为CSDN博主「anti_ice_point」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/anti_ice_point/article/details/88621821
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
20、 exec() 动态执行python代码。也就是说exec可以执行复杂的python代码，而不像eval函数那样只能计算一个表达式的值。
eval()函数和exec()函数的区别：
eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。
eval()函数可以有返回值，而exec()函数返回值永远为None。
————————————————
版权声明：本文为CSDN博主「anti_ice_point」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/anti_ice_point/article/details/88621821
>>>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()
60
33
34
21、 filter() 过滤器，构造一个序列，等价于[ item for item in iterables if function(item)]，在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据。
filter(function, iterable)
参数function：返回值为True或False的函数，可以为None。
参数iterable：序列或可迭代对象。
>>> def bigerthan5(x):
... return x > 5
>>> filter(bigerthan5, [3, 4, 5, 6, 7, 8])
[6, 7, 8]
22、 float() 讲一个字符串或整数转换为浮点数
>>> float()
0.0
>>> float('123')
123.0
>>> float(1)
1.0
>>> float('a')
Traceback (most recent call last):
File "<pyshell#45>", line 1, in <module>
float('a')
ValueError: could not convert string to float: 'a'
23、 format() 格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法
>>> "I am {0}, I like {1}!".format("wang", "moon")
'I am wang, I like moon!'
24、 frozenset() 创建一个不可修改的集合
>>> a = frozenset(range(10))
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
25、 getattr() 获取对象的属性
getattr(object, name [, defalut]) 获取对象object名为name的特性，如果object不包含名为name的特性，将会抛AttributeError异常；如果不包含名为name的特性且提供default参数，将返回default。
object：对象
name：对象的特性名
default：缺省返回值
————————————————
版权声明：本文为CSDN博主「anti_ice_point」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/anti_ice_point/article/details/88621821
>>> append = getattr(list, 'append')
>>> append
<method 'append' of 'list' objects>
>>> mylist = [3, 4, 5]
>>> append(mylist, 6)
>>> mylist
[3, 4, 5, 6]
>>> method = getattr(list, 'add')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: type object 'list' has no attribute 'add'
>>> method = getattr(list, 'add', 'NoMethod')
>>> method
'NoMethod'
26、 globals() 返回一个描述当前全局变量的字典
>>> a = 1
>>>> globals()
{'__loader__': <class '_frozen_importlib.BuiltinImporter'>, 'a': 1, '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__name__': '__main__', '__package__': None, '__spec__': None}
27、 hasattr()
hasattr(object，name) 判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object，name)）是否抛出异常来实现的。
参数object：对象
参数name：特性名称
>>> hasattr(list, 'append')
True
>>> hasattr(list, 'add')
False
28、 hash() 获取对象的哈希值
hash(object) 如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数，在字典查找中，哈希值用于快递比价字典的键。两个数值如果相等，则哈希值也相等。
>>> hash('good good study')
1032709256
29、 help() 返回对象的帮助信息
>>> help(str)
Help on class str in module builtins:
class str(object)
str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str
Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to sys.getdefaultencoding().
errors defaults to 'strict'.
Methods defined here:
__add__(self, value, /)
Return self+value.
30、hex() 用于将10进制整数转换成16进制，以字符串形式表示。
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
>>> hex(12)
'0xc'
>>> type(hex(12))
<class 'str'> # 字符串
31、 id() 返回对象的唯一标识符
>>> a = 'some text'
>>> id(a)
69228568
32、 input() 获取用户输入内容
num = input("请输入一个数字：")
# 用户输入3
print(num)
# 输出结果
3
33、 int() 将一个字符串或数值转换为一个普通整数
int([x[,radix]]) 如果参数是字符串，那么它可能包含符号和小数点。参数radix表示转换的基数（默认是10进制）。 它可以是[2,36]范围内的值，或者0。如果是0，系统将根据字符串内容来解析。如果提供了参数radix，但参数x并不是一个字符串，将抛出TypeError异常；否则，参数x必须是数值（普通整数，长整数，浮点数）。通过舍去小数点来转换浮点数。如果超出了普通整数的表示范围，一个长整数被返回。如果没有提供参数，函数返回0。
————————————————
版权声明：本文为CSDN博主「anti_ice_point」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/anti_ice_point/article/details/88621821
>>>int()
0
>>>int(3.1)
3
34、 isinstance() 检查对象是否是类的对象，返回True或False
>>> isinstance(1,int)
True
>>> isinstance(1,str)
False
>>> isinstance(1,(int,str))
True
35、 issubclass() 判断类是否是另外一个类或者类型元组中任意类元素的子类
>>> issubclass(bool,int)
True
>>> issubclass(bool,str)
False
>>> issubclass(bool,(str,int))
True
36、 iter() 用来生成迭代器
>>>lst = [1, 2, 3]
>>> for i in iter(lst):
... print(i)
...
1
2
3
37、 len() 返回对象的长度
>>> len('abcd') # 字符串
>>> len(bytes('abcd','utf-8')) # 字节数组
>>> len((1,2,3,4)) # 元组
>>> len([1,2,3,4]) # 列表
>>> len(range(1,5)) # range对象
>>> len({'a':1,'b':2,'c':3,'d':4}) # 字典
>>> len({'a','b','c','d'}) # 集合
>>> len(frozenset('abcd')) #不可变集合
38、 list() 根据传入的参数创建一个新的列表
>>>list() # 不传入参数，创建空列表
[]
>>> list('abcd') # 传入可迭代对象，使用其元素创建新的列表
['a', 'b', 'c', 'd']
39、 locals() 返回当前作用域内的局部变量和其值组成的字典
>>> def f():
print('before define a ')
print(locals()) #作用域内无变量
a = 1
print('after define a')
print(locals()) #作用域内有一个a变量，值为1
>>> f
<function f at 0x03D40588>
>>> f()
before define a
{}
after define a
{'a': 1}
40、 map() 使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象
>>> a = map(ord,'abcd')
>>> a
<map object at 0x03994E50>
>>> list(a)
[97, 98, 99, 100]
41、 max() 返回可迭代对象中的元素中的最大值或者所有参数的最大值。
>>> max(1,2,3) # 传入3个参数 取3个中较大者
3
>>> max('1234') # 传入1个可迭代对象，取其最大元素值
'4'
>>> max(-6,3,key = abs) # 求绝对值函数，则比较参数绝对值大小后，再取较大者
-6
42、 memoryview() 根据传入的参数创建一个新的内存查看对象。
>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
43、 min() 返回可迭代对象中的元素中的最小值或者所有参数的最小值
>>> min(1,2,3) # 传入3个参数 取3个中较小者
1
>>> min('1234') # 传入1个可迭代对象，取其最小元素值
'1'
>>> min(-1,-2,key = abs) # 传入求绝对值函数，比较参数绝对值大小后，取较小者
-1
44、 next() 返回可迭代对象中的下一个元素值
>>> a = iter('abcd')
>>> next(a)
'a'
>>> next(a)
'b'
>>> next(a)
'c'
>>> next(a)
'd'
>>> next(a)
Traceback (most recent call last):
File "<pyshell#18>", line 1, in <module>
next(a)
StopIteration
#传入default参数后，如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所
有元素已经返回，则返回default指定的默认值而不抛出StopIteration 异常
>>> next(a,'e')
'e'
>>> next(a,'e')
'e'
45、 object() 创建一个新的object对象
>>> a = object()
>>> a.name = 'kim' # 不能设置属性
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
a.name = 'kim'
AttributeError: 'object' object has no attribute 'name'
46、 oct() 将整数转化成8进制数字符串
>>> oct(10)
'0o12'
47、 open() 使用指定的模式和编码打开文件，返回文件读写对象
#t为文本读写，b为二进制读写
>>> a = open('test.txt','rt')
>>> a.read()
'some text'
>>> a.close()
48、ord() 返回Unicode字符对应的整数
>>> ord('a')
97
49、pow() 返回两个数值的幂运算值或其与指定整数的模值
>>>pow(2, 3) #等价于 2 ** 3
8
>>>pow(2, 3, 5) #等价于 (2 ** 3) % 5
3
50、print() 向标准输出对象打印输出
>>> print(1,2,3)
1 2 3
>>> print(1,2,3,sep = '+')
1+2+3
>>> print(1,2,3,sep = '+',end = '=?')
1+2+3=?
51、 property() 标示属性的装饰器
>>> class C:
def __init__(self):
self._name = ''
@property
def name(self):
"""i'm the 'name' property."""
return self._name
@name.setter
def name(self,value):
if value is None:
raise RuntimeError('name can not be None')
else:
self._name = value
>>> c = C()
>>> c.name # 访问属性
>>> c.name = None # 设置属性时进行验证
Traceback (most recent call last):
File "<pyshell#84>", line 1, in <module>
c.name = None
File "<pyshell#81>", line 11, in name
raise RuntimeError('name can not be None')
RuntimeError: name can not be None
>>> c.name = 'Kim' # 设置属性
>>> c.name # 访问属性
'Kim'
>>> del c.name # 删除属性，不提供deleter则不能删除
Traceback (most recent call last):
File "<pyshell#87>", line 1, in <module>
del c.name
AttributeError: can't delete attribute
>>> c.name
'Kim'
52、range() 根据传入的参数创建一个新的range对象
>>> a = range(10)
>>> b = range(1,10)
>>> c = range(1,10,3)
>>> a,b,c # 分别输出a,b,c
(range(0, 10), range(1, 10), range(1, 10, 3))
>>> list(a),list(b),list(c) # 分别输出a,b,c的元素
([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])
53、repr() 返回一个对象的字符串表现形式(给解释器)
>>> a = 'some text'
>>> str(a)
'some text'
>>> repr(a)
"'some text'"
54、 reversed() 反转序列生成新的可迭代对象
>>> a = reversed(range(10)) # 传入range对象
>>> a # 类型变成迭代器
<range_iterator object at 0x035634E8>
>>> list(a)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
55、 round(x,k) 对浮点数x进行四舍五入求值,参数k表示保留几位小数
>>> round(3.1415926) #若没有参数，则默认保留0位小数
3
>>> round(3.14159,2) # k=2代表保留2位小数
3.14
>>> round(1689,-2) # k为-2，表示小数点左边第2位四舍五入：8>6,所以进位为1700
1700
56、 set() 根据传入的参数创建一个新的集合
>>>set() # 不传入参数，创建空集合
set()
>>> a = set(range(10)) # 传入可迭代对象，创建集合
>>> a
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
57、 setattr() 设置对象的属性值
>>> class Student:
def __init__(self,name):
self.name = name
>>> a = Student('Kim')
>>> a.name
'Kim'
>>> setattr(a,'name','Bob')
>>> a.name
'Bob'
58、 slice（）：根据传入的参数创建一个新的切片对象
>>> c1 = slice(5) # 定义c1
>>> c1
slice(None, 5, None)
>>> c2 = slice(2,5) # 定义c2
>>> c2
slice(2, 5, None)
>>> c3 = slice(1,10,3) # 定义c3
>>> c3
slice(1, 10, 3)
59、 sorted() 对可迭代对象进行排序，返回一个新的列表
>>> a = ['a','b','d','c','B','A']
>>> a
['a', 'b', 'd', 'c', 'B', 'A']
>>> sorted(a) # 默认按字符ascii码排序
['A', 'B', 'a', 'b', 'c', 'd']
>>> sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，
'b'和'B'值一样
['a', 'A', 'b', 'B', 'c', 'd']
60、 staticmethod() 标示方法为静态方法的装饰器
#使用装饰器定义静态方法
>>> class Student(object):
def __init__(self,name):
self.name = name
@staticmethod
def sayHello(lang):
print(lang)
if lang == 'en':
print('Welcome!')
else:
print('你好！')
>>> Student.sayHello('en') #类调用,'en'传给了lang参数
en
Welcome!
>>> b = Student('Kim')
>>> b.sayHello('zh') #类实例对象调用,'zh'传给了lang参数
zh
你好
61、str() 返回一个对象的字符串表现形式
>>> str()
''
>>> str(None)
'None'
>>> str('abc')
'abc'
>>> str(123)
'123'
62、 sum() 对元素类型是数值的可迭代对象中的每个元素求和
>>> sum((1,2,3,4))
10
>>>sum((1,2),3)
>6
>>> sum((1.5,2.5,3.5,4.5))
12.0
>>> sum((1,2,3,4),-10)
0
63、 super() 根据传入的参数创建一个新的子类和父类关系的代理对象
#定义父类A
>>> class A(object):
def __init__(self):
print('A.__init__')
#定义子类B，继承A
>>> class B(A):
def __init__(self):
print('B.__init__')
super().__init__()
#super调用父类方法
>>> b = B()
B.__init__
A.__init__
64、 tuple() 根据传入的参数创建一个新的元组
>>> tuple() #不传入参数，创建空元组
()
>>> tuple('121') #传入可迭代对象。使用其元素创建新的元组
('1', '2', '1')
65、 type()：返回对象的类型，或者根据传入的参数创建一个新的类型
>>> type(1) # 返回对象的类型
<class 'int'>
#使用type函数创建类型D，含有属性InfoD
>>> D = type('D',(A,B),dict(InfoD='some thing defined in D'))
>>> d = D()
>>> d.InfoD
'some thing defined in D'
66、 vars() 返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表
>>> class A(object):
pass
>>> a.__dict__
{}
>>> vars(a)
{}
>>> a.name = 'Kim'
>>> a.__dict__
{'name': 'Kim'}
>>> vars(a)
{'name': 'Kim'}
67、 zip() 聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
>>> x = [1,2,3] #长度3
>>> y = [4,5,6,7,8] #长度5
>>> list(zip(x,y)) # 取最小长度3
[(1, 4), (2, 5), (3, 6)]
68、 --import–() 动态导入模块
index = __import__('index')
index.sayHello()
来源：CSDN
作者：White.Magic
链接：https://blog.csdn.net/weixin_44659258/article/details/104191766