python 内置函数大全

最新推荐文章于 2024-05-19 23:12:39 发布

csdn_wangyixiao

最新推荐文章于 2024-05-19 23:12:39 发布

阅读量1.6k

点赞数 2

分类专栏： python 文章标签： python 内置函数大全 python 内置函数简介

本文链接：https://blog.csdn.net/csdn_wangyixiao/article/details/99706749

版权

python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

本文粗略的介绍了python 3 的内置函数，如有错误和不足，还望指正。

A

1.abs(x)

参数–x：数值表达式，可以是整形，浮点型，复数。
返回值：返回数值（x）的绝对值，如果（x）是复数则返回复数的大小。
示例：

>>> abs(-1)
1
>>> abs(-1.0100)
1.01
>>> abs(2.000)
2.0
>>> abs(1+1j)
1.4142135623730951

当参数为浮点形时会保留实际长度，多余的0会被省略。
此外math模块中的fabs()函数也有类似的功能，但是fabs()的参数不能是复数。
示例：

>>> import math
>>> math.fabs(1+1j)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't convert complex to float
>>>

2.all(iterable)

参数：iterable：：可迭代对象。
返回值：如果iterable的所有元素不为0、’’、False或者iterable为空，all(iterable)返回True，否则返回False。
示例：

>>> t = ['k', 'o', '']
>>> all(t)
False
>>> s = [1, 0, 1]
>>> all(s)
False
>>> l = ["False", 2, "1"]   #这里False是字符串
>>> all(l)
True
>>> l = [False, 1, 3]
>>> all(l)
False

注意：空集合，空列表，空元组会返回True。
示例：

>>> all([])
True
>>> all({})
True
>>> all(())
True

3.any(iterable)

参数–iterable：可迭代对象。
返回值：any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE。
大部分情况与all()函数结果相反。

>>> any({})
False
>>> any([])
False
>>> any(())
False
>>> t = {1, 0, 2}
>>> any(t)
True
>>> q = ["False", 1, 2]    #与all()结果相同
>>> any(q)
True

4.ascii(object)

参数–object：对象
返回值：返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。
示例：

>>> ascii(2)
'2'
>>> ascii(1.00)   #当末尾有多个0时， 只会保存一个
'1.0'
>>> ascii("中国")
"'\\u4e2d\\u56fd'"

B

5.bin(x)

参数–x：int或者long int
返回值：x的二进制表达
示例：

>>> bin(10)
'0b1010'
>>> bin(256)
'0b100000000'
>>> bin(-10)
'-0b1010'

6.bool([object])

参数–object：要转化的对象
返回值：True 或者 False。当参数为 0，’’，或者为其他数据类型却为空时返回False，当参数为空时返回False。
示例：

>>> t = {}
>>> bool(t)
False
>>> t = []
>>> bool(t)
False
>>> bool(0)
False
>>> bool(-1)
True
>>> bool("")
False
>>> bool()
False

7.bytearray([source, [encoding, [errors]]])

参数–source：要转化的对象
encoding：字符串的编码格式
errors：默认值为"strict"（？？？）
返回值：根据参数的不同，有不同的返回值。返回值为字符数组，数组元素可变。
a.当source为空时，返回长度为0的字符数组
b.当source为字符串时，必须要给encode参数赋值。返回经过encode
编码的字符数组。
c.当source为int时，返回长度为source的空数组。
d.当source为缓冲区的对象时，会用只读的方式将对象按字节读取到字符数组后返回。
e.当source为可迭代对象时，则此对象的元素必须属于集合[0，256)，以便初始化到字符数组。
应用技巧
示例：

>>> bytearray()   #参数为空
bytearray(b'')

>>> bytearray(10)           #整数
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')

>>> bytearray("中文",'utf-8')   #字符串
bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

>>> bytearray([1,0,1,1,1,0,1])    #可迭代对象
bytearray(b'\x01\x00\x01\x01\x01\x00\x01')

>>> bytearray([1.2, 2])            #可迭代对象的元素必须是整数
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer

>>> bytearray([1,256,2])          #可迭代对象的元素必须是range(0,256)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: byte must be in range(0, 256)

8.bytes([source, [encoding, [errors]]])

参数–source：要转化的对象
encode：字符串的编码格式
errors：默认值为"strict"
返回值：根据参数的不同，有不同的返回值。返回值为字符数组，数组元素不可变，是betyarray的不可变版本。返回值与bytearray()类似。
a.当source为空时，返回长度为0的字符数组
b.当source为字符串时，必须要给encode参数赋值。返回经过encode
编码的字符数组。
c.当source为int时，返回长度为source的空数组。
d.当source为缓冲区的对象时，会用只读的方式将对象按字节读取到字符数组后返回。
e.当source为可迭代对象时，则此对象的元素必须属于集合[0，256)，以便初始化到字符数组。
示例：

>>> bytes(10)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
>>> bytes("中文",'utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'

C

9.callable(object)

参数–object：对象
返回值：可调用返回True，不可调用返回False。callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
对于函数、方法、lambda 函式、类以及实现了 _ call _ 方法的类实例, 它都返回 True。
示例：

>>> callable(10)    #常数
False
>>> def add():     #方法
...     print("11")
...
>>> callable(add)
True
>>> class A():    #类， 没有实现__call__()方法
...     def __init__(self):
...             x = 10
...
>>> callable(A)
True
>>> a = A()     #类实例
>>> callable(a)
False
>>> class B():       #类，实现__call__()方法
...     def __call__(self):
...             return 0
>>> callable(B)
True
>>> b = B()
>>> callable(b)
True
>>>

10.chr(x)

参数–x：10进制或者16进制的整数，x>=0。
返回值：返回对应的ascii码字符。
示例：

>>> chr(0)
'\x00'
>>> chr(1)
'\x01'
>>> chr(52)
'4'
>>> chr(97)
'a'
>>> chr(10000)
'✐'
>>> chr(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)

11.classmethod()
描述：装饰器的一种与@联用。返回一个经过装饰器装饰的函数。classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
参数：无
返回值：返回函数的类方法。
参考112479的博客
示例：

class A():
    q = 10
    def __init__(self, s):
        print(s)

    @classmethod
    def testmethod(cls):
        print(cls.q)        #经@classmethod修饰，可直接使用类的属性
        return cls(123)

t = A.testmethod()  #经@classmethod修饰可不初始化直接调用

执行结果：

10
123

这里的执行顺序是A ->testmethod -> _ init _
另外 cls是个位置参数，可更换为其他名称，如 this。
示例：

class A():
    q = 10
    def __init__(self, s):
        print(s)

    @classmethod
    def testmethod(this):
        print(this.q)
        return this(123)

t = A.testmethod()

执行结果：

10
123

12.compile(source，filename， mode[， flags， [dont_inherit，optimize = -1]])

描述：将字符串编译成字节代码。
参数–source：字符串或AST对象。
filename：需要的是代码读取的文件名；如果代码不需要从文件中读取，可以传入一些可辨识的值（经常会使用 ‘<string>’）
mode：mode 实参指定了编译代码必须用的模式。如果 source 是语句序列，可以是 ‘exec’；如果是单一表达式，可以是 ‘eval’；如果是单个交互式语句，可以是 ‘single’。（在最后一种情况下，如果表达式执行结果不是 None 将会被打印出来。）
flags和dont_inherit是用来控制编译源码时的标志
optimize：optimize 实参指定编译器的优化级别；默认值 -1 选择与解释器的 -O 选项相同的优化级别。显式级别为 0 （没有优化；debug 为真）、1 （断言被删除， debug 为假）或 2 （文档字符串也被删除）。
示例：

>>> str = "for i in range(10): print(i)"
>>> c = compile(str, "", "exec")
>>> c
<code object <module> at 0x0000029C7FA48030, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 + 5 * 4"
>>> d = compile(str, "", "eval")
>>> eval(d)
23
>>> exec(d)   #不是指定的mode，不能得出结果。

如果是单一表达式，只能是eval；使用exec不会报错但得不到结果。
在 ‘single’ 或 ‘eval’ 模式编译多行代码字符串时，输入必须以至少一个换行符结尾。这使 code 模块更容易检测语句的完整性。

13.complex([real [，imag])

描述：将字符串或数字转换为复数。
参数–real：实数部分，可以是int，也可以是string
image：虚数部分
如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略，则返回 0j。
返回值：返回一个大小为 real + imag * j 的复数

注意：从字符串转换时，字符串在 + 或 - 的周围必须不能有空格。例如 complex(‘1+2j’) 是合法的，但 complex(‘1 + 2j’) 会触发 ValueError 异常。
示例：

>>> complex(1)
(1+0j)
>>> complex(1, -1)
(1-1j)

>>> complex("1", -1)     #当第一个参数为字符串，不能有第二个参数
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: complex() can't take second arg if first is a string

>>> complex(1+1j, -1)   #参数可以是复数
(1+0j)
>>> complex("1+1j")
(1+1j)

>>> complex("1 + 1j")   #注意 ‘+’ / ‘-’ 周围不能有空格
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string

D

14.delattr(object，name)

描述：删除一个对象的某个属性。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。例如 delattr(x, ‘foobar’) 等价于 del x.foobar 。

参数–object：对象
name：该对象的某个属性名称，是个字符串s。
返回值：无
示例：

class test():
    a = 1
    b = 2

t = test()
print(t.a)
print(t.b)
delattr(test, "b")
print(t.a)
print(t.b)

执行结果：

1
2
1
Traceback (most recent call last):
  File "c:/Users/hasee/Desktop/111-1.py", line 74, in <module>
    print(t.b)
AttributeError: 'test' object has no attribute 'b'

15.dict()

描述：创建一个新的字典。共有三种形式dict(**kwarg)，dict(mapping，**kwarg)，dict(iterable，**kwarg)
参数–**kwarg：关键字
mapping：元素的容器
iterable：可迭代的对象
示例：

#五种字典初始化方法
>>> dict1 = {}
>>> dict1['firstname'] = 'ma'
>>> dict1['lastname'] = 'yun'
>>>
>>> dict1 = {'firstname':'ma', 'lastname':'yun'}
>>>
>>> dict1 = dict([('firstname','ma'), ('lastname', 'yun')])
>>>
>>> dict1 = dict(firstname = 'ma', lastname = 'yun')
>>>
>>> dict1 = dict(zip(['firstname', 'lastname'], ['ma', 'yun']))

16.dir(object)

描述：如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。
参数–object：对象，类型，变量
示例：

>>>dir()   #  获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ])    # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

17.divmod(a，b)

描述：divmod() 函数接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。
参数–a：数字，非复数
b：数字，非复数
返回值：对于整数（a//b，a%b），对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能会比 1 小。在任何情况下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符号和 b 一样，并且 0 <= abs(a % b) < abs(b) 。
示例：

>>> divmod(3,2)
(1, 1)
>>> divmod(-3,2)
(-2, 1)
>>> divmod(3,-2)       #当余数不为0时，余数的符号与 b 相同
(-2, -1)
>>> divmod(3.2,2)
(1.0, 1.2000000000000002)
>>> divmod(3.3,3)                  
(1.0, 0.2999999999999998)    #当是浮点数时，结果是近似
>>> divmod(3.3,4)
(0.0, 3.3)

E

18.enumerate(iterable，start = 0)

描述：接收一个元组，返回一个枚举对象。
参数–iterable：一个序列、迭代器或其他支持迭代对象。
start：序号的起始，默认为0。
返回值：返回一个枚举对象。
示例：

>>> for i in enumerate(a):
...     print(i)
...
(0, 'a')
(1, 'b')
(2, 'c')
#对于字典，会枚举输出关键字
>>> d = dict(firstname = "zhong",lastname = "guo")
>>> for i in enumerate(d):
...     print(i)
...
(0, 'firstname')
(1, 'lastname')

19.eval(expression, globals=None, locals=None)

描述：接收一个字符串表达式，返回其计算结果。
参数–expression：字符串表达式
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值：表达式的计算结果。
示例：

>>> eval("3 + 4 > 10")
False
>>> x = 2
>>> eval("3*x")
6
>>> d = dict(x = 7, y = 8, z = 9)
>>> eval("y + z", "", d)      #globals 不能为 ""
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: globals must be a real dict; try eval(expr, {}, mapping)
>>> c = {}
>>> eval("y+z", c, d)
17
>>> eval("y+z", d)  
17

小技巧：
A.eval()可以去掉字符串的引号，返回字符串本身
示例：

>>> a = "123"
>>> eval(a)
123

B.可以用来直接读取用户输入的多个数据

>>> a, b = input()   #直接input()不能同时输入多个数据
10,5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

>>> a, b = eval(input())   
10,5
>>> print(a,b)
10 5

20.exec(object[, globals[, locals]])

描述：exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
参数–object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。
globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。
返回值：None
示例：

x = 10
y = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
    y = 20
    exec(expr)  # 默认使用最近的参数  计算过程为 30 + 20 +10
    exec(expr, {'x': 1, 'y': 2})   #计算过程为  30 + 1 + 2
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})  # 外部参数不能替代原本字符串里面的值，且当globals与locals有相同参数时优先使用locals的
    
func()

执行结果：

60
33
34

F

21.filter(function，iterable)

描述：根据function对iterable进行筛选，符合条件的留下，不符合的剔除，构建新的迭代器。
参数–function：判断函数。
iterable：可迭代对象。
返回值：新的可迭代对象。
示例：

#选出1~100中平方根是整数的数
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)

执行结果：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

22.float([x])

描述：将字符串或整数转化为浮点型。
参数–x：字符串或者整数。如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。可选的符号有 ‘+’ 和 ‘-’ ； ‘+’ 对创建的值没有影响。实参也可以是 NaN（非数字）、正负无穷大的字符串。确切地说，除去首尾的空格后，输入必须遵循以下语法：


sign	“+” \| “-”
infinity	“Infinity” \| “inf”
nan	“nan”
numeric_value	floatnumber \| infinity \| nan
numeric_string	[sign] numeric_value

返回值：返回浮点数。实参为空时返回 0.0
示例：

>>> float("inf")
inf
>>> float("nan")
nan
>>> float("-3.14e10")
-31400000000.0
>>> float()
0.0

23.format(value[, format_spec]))

描述：用于格式化输出，取代%。将 value 转换为 format_spec 控制的“格式化”表示。
参数–value：要输出的值
format_spec：控制value输出的格式。
返回值：无
示例：

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

>>> format(255, '#x'), format(255, 'x'), format(255, 'X')  #设置format_spec 为16进制输出
('0xff', 'ff', 'FF')

>>> f'{255:#x}', f'{255:x}', f'{255:X}'   #简化书写
('0xff', 'ff', 'FF')

也可以设置参数名字：

>>> print("name = {name}, age = {age}".format(name = "china", age = 70))  #直接设置参数值
name = china, age = 70

>>> s = ["china", 70]                               #用单个列表保存实参值
>>> print("name = {0}, age = {1}".format(*s))
name = china, age = 70

>>> t1 = ["china"]								   #用多个列表保存实参值
>>> t2 = [70]
>>> print("name = {0[0]}, age = {1[0]}".format(t1,t2))
name = china, age = 70

>>> t = dict(name = "china", age = 70)              #用字典保存实参值
>>> print("name = {name}, age = {age}".format(**t))
name = china, age = 70

更多详细使用技巧参考菜鸟教程

24.frozenset([iterable])

描述：返回一个冻结的集合，不能再对此集合进行增删操作。
参数–iterable：可迭代的对象，比如列表、字典、元组等等。
返回值：返回一个forzenset对象，该对象的元素来自于iterable。没有实参则返回一个空集合。
示例：

>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合

G

25.getattr(object， name[，default])

描述：获得对象(object)名字为name的属性。
参数–object：对象
name：字符串，想要获取的属性的名字。
default：当要获取的属性不存在时的默认返回值。如果不提供，当属性不存在时将触发 AttributeError。可以是字符串，可以是数字类型，也可以是函数。可以认为是异常处理手段。
返回值：返回对应属性的值。
示例：

>>> class A():
...     x = 10
...     y = 15
...
>>>
>>> getattr(A,"x")
10
>>>
>>> getattr(A, "z", -1)
-1
>>>
>>> getattr(A, "z", "无此属性")   #default 可以是字符串
'无此属性'
>>>
>>> def test():       #default 可以是函数
...     print("111")
...
>>> getattr(A, "z", test())
111

此外也可以获取方法。
示例：

class A():
    def set(self, a, b):
        print(a + b)
    x = 10

a = A()
c = getattr(a, "set")   #获取到对象的方法 并且可以直接使用
c(1, 2)

执行结果：

26.globals()----

描述：函数会以字典类型返回当前位置的全部全局变量。
参数：无
返回值：返回全局变量的字典。
示例：

>>> class A():
...     x = 10
...
>>>
>>> print(globals())
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__':
{}, '__builtins__': <module 'builtins' (built-in)>, 'A': <class '__main__.A'>}

H

27.hasattr(object，name)

描述：用于判断对象是否包含对应的属性。
参数–object：对象。
name：属性名称，字符串。
返回值：如果对象有该属性返回 True，否则返回 False。
示例：

class A():
    def set(self, a, b):
        print(a + b)
    x = 10

print(hasattr(A, "set"))
print(hasattr(A, "x"))

执行结果：

True
True

28.hash(object)

描述：返回该对象的哈希值（如果它有的话）。
参数–object：对象。一般是整型，浮点型，字符串。不能直接是list，set，dictionary。
返回值：对象的hash值。
示例：

>>> hash("qwer")
3620707056588834181

>>> hash("qwrerthlfbkncndfjoidddviofj")
-3805363231758489070

>>> hash("qwrerthlfbkncndfjoidddviofj")
-3805363231758489070

可以看出同一个值的hash值相同，可以利用这一点来校验字符串是否被第三方篡改。

29.help([object])

描述：用于查看函数或模块用途的详细说明。
参数–object：对象。
返回值：返回对象帮助信息。
示例：

>>> import math
>>> help(math)   #查询模块信息
Help on built-in module math:

NAME
    math

DESCRIPTION
    This module is always available.  It provides access to the
    mathematical functions defined by the C standard.
......

>>> help(math.sin)  #查询函数信息
Help on built-in function sin in module math:

sin(x, /)
    Return the sine of x (measured in radians).

30.hex(x)

描述：将整数转换为以“0x”为前缀的小写十六进制字符串。
参数–x：整数。
返回值：小写的十六进制字符串。
示例：

>>> hex(16)
'0x10'

>>> "%x" %10    #用 %x 转换进制
'a'

>>> format(10,  "#x")    #用format转换进制
'0xa'

>>> f'{255:#x}', f'{255:x}', f'{255:X}'  
('0xff', 'ff', 'FF')

I

31.id(object)

描述：返回对象在内存中的地址。
参数–object：对象。
返回值：对象在内存中的地址。
示例：

>>> a = "china"
>>> id(a)
1739113113224
>>> b = 10
>>> id(b)
140733210059696

32.input([prompt])

描述：Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。
参数–prompt：提示信息
返回值：以字符串形式返回输入的内容。
示例：

>>> num = input()
10
>>> num
'10'
>>> temp = input("请输入数字temp：")
请输入数字temp：10
>>> temp
'10'

33.int(x, base = 10)

描述：用于将一个字符串或数字转换为整型。
参数--x：字符串或数字。如果 x 不是数字，或者有 base 参数，x 必须是字符串、bytes、表示进制为 base 的整数字面值的 bytearray 实例。该文字前可以有 + 或 - （中间不能有空格），前后可以有空格。
返回值：返回10进制整型数据。
示例：

>>> int()
0
>>> int("123", 10) 
123
>>> int("123", 16)    #当有base = 8时，表示123为八进制数
291
>>> int("123", 8)  
83

34.isinstance(object，classinfo)

描述：isinstance() 函数来判断一个对象是否是一个已知的类型的实例，类似 type()。
参数–object：实例对象。
classinfo：可以是直接或间接类名、基本类型或者由它们组成的元组。
返回值：如果 object 实参是 classinfo 实参的实例，或者是（直接、间接或虚拟）子类的实例，则返回 true。如果 object 不是给定类型的对象，函数始终返回 false。如果 classinfo 是对象类型（或多个递归元组）的元组，如果 object 是其中的任何一个的实例则返回 true。如果 classinfo 既不是类型，也不是类型元组或类型的递归元组，那么会触发 TypeError 异常。
示例：

>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True

isinstance()与type()的区别：

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

从上可以看出type()不能识别出子类。
此外注意在classinfo中字符串是 str 不是string，字典是 dict。
示例：

>>> a = 123
>>> isinstance(a, str)
False

>>> isinstance(a, string)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'string' is not defined

35.issubclass(class, classinfo)

描述：用于判断参数 class 是否是类型参数 classinfo 的子类。方法与isinstance()类似。
参数–class ：子类。
classinfo ：父类。
返回值：如果 class 是 classinfo 的子类（直接、间接或虚拟的），则返回 true。classinfo 可以是类对象的元组，此时 classinfo 中的每个元素都会被检查。其他情况，会触发 TypeError 异常。
示例：

class A:
    pass
 
class B(A):
    pass

print(issubclass(B, A))

执行结果：

True

36.iter(object[, sentinel])----

描述：iter() 函数用来生成迭代器。
参数–object：支持迭代的集合对象。
sentinel：如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。可以认为是一个终止符。
返回值：迭代器对象。
示例：

>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
... 
1
2
3

详细使用可参考一只小小寄居蟹的博客

37.len(s)

描述：返回对象中元素的个数。
参数–s：可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。
返回值：对象s中元素的个数。
示例：

>>> str = "abcdefg"
>>> len(str)
7

>>> e = {1, 2, 3, 4, 5}
>>> len(e)
5

38.list([iterable])

描述：用于将元组或字符串转换为列表。
参数–iterable：要转换为列表的元组或字符串。
返回值：返回一个列表。
示例：

>>> tuple = {1, "a", 32, "cd" }
>>> temp = list(tuple)    #将元组转换成了列表，可以再次对其进行修改
>>> temp.append(4)
>>> temp
[32, 1, 'cd', 'a', 4]

39.locals()

描述：更新并返回表示当前本地符号表的字典。
参数：无
返回值：更新并返回表示当前本地符号表的字典。
示例：

class A():
    x = 10
    def test(self, a, b):
        y = 20
        print(locals())      #locals的范围小，当在方法中使用时指方法的全局变量

print(globals())        #globals范围大，一般指模块内的全局变量
a = A()
a.test(1, 2)

执行结果：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000025803BBEEF0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'c:/Users/hasee/Desktop/111-1.py', '__cached__': None, 'A': <class '__main__.A'>}
{'self': <__main__.A object at 0x0000025805821438>, 'a': 1, 'b': 2, 'y': 20}

M

40.map(function，iterable，…)

描述：根据提供的函数对指定序列做映射。
参数–function：函数。
iterable：序列
返回值：返回一个经过function映射的迭代器。如果传入了额外的 iterable 参数，function 的映射操作会从每一个iterable对应位置取一个值进行计算。当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。
示例：

>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> for i in map(square, [1,2,3,4,5]):# 计算列表各个元素的平方
...     print(i)

#使用匿名函数
>>> for i in map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10, 12]):
...     print(i)
...
3
7
11
15
19

与filter()的区别：filter 是通过生成 True 和 False 组成的迭代器将可迭代对象中不符合条件的元素过滤掉；而 map 返回的则是 True 和 False 组成的迭代器。

>>> res1 = map(lambda n: n > 5, range(10))
>>> lt1 = list(res1)
>>> print(lt1)
[False, False, False, False, False, False, True, True, True, True]

>>> res2 = filter(lambda n: n > 5, range(10))
>>> lt = list(res2)
>>> print(lt) 
[6, 7, 8, 9]

41.max(iterable, *[, key, default])

描述：获取序列中值最大的元素。还有一种写法为 max(arg1, arg2, *args[, key])
参数–当只有一个位置参数时，必须是非空的iterable。
iterable：列表，元组，字典等。
key：指定排序函数用的参数
default：当可迭代对象为空时返回的值。
返回值：如果只提供了一个位置参数，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。如果有多个最小元素，则此函数将返回第一个找到的。
示例：

t1 = (2, "wang")
t2 = (3, "zhao")
t3 = (4, "li")

print(max(t3, t2, t1, key = lambda x: x[0]))  # key 一般用关键字 + 匿名函数来表示

执行结果：

(4, 'li')

42.memoryview(object)

描述：memoryview() 函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
参数–object：必须支持缓冲区协议的对象，支持缓冲区协议的内置对象包括 bytes 和 bytearray。
返回值：返回元组列表。
示例：

>> a = b"aaaaa"
>>> ma = memoryview(a)
>>> ma.readonly   #只读memoryview
True
>>> mb = ma[:2]   #不会产生新的字符串
>>> mb = "bb"
>>> ma.tobytes()
b'aaaaa'

>>> a = bytearray('aaaa', "utf8")
>>> ma = memoryview(a)
>>> mb = ma[:2]
>>> mb.readonly      #可写memoryview
False
>>> mb[:2] = b"bb"   #修改mb相当于修改ma，同时注意赋值方法
>>> mb.tobytes()
b'bb'
>>> ma.tobytes()
b'bbaa'

详细使用技巧可参考这里

43.min(iterable, *[, key, default])

描述：获取序列中值最小的元素。还有一种写法为 min(arg1, arg2, *args[, key])
参数–当只有一个位置参数时，必须是非空的iterable。
iterable：列表，元组，字典等。
key：指定排序函数用的参数
default：当可迭代对象为空时返回的值。
返回值：如果只提供了一个位置参数，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。如果有多个最小元素，则此函数将返回第一个找到的。
示例：

t1 = (2, "wang")
t2 = (3, "zhao")
t3 = (4, "li")

print(min(t3, t2, t1, key = lambda x: x[0]))  # key 一般用关键字 + 匿名函数来表示

执行结果：

(2, "wang")

N

44.next(iterator[，default])

描述：返回迭代器的下一个项目。
参数–iterable：迭代器。
default：用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
返回值：迭代器中的一个元素。当下一个元素不存在，且default不为空将返回default 的值，否则抛出StopIteration异常。
注意：list，dict，set 都不是迭代器，不能直接使用next()，需要使用 iter() 方法将其转化为iterator
示例：

>>> lst = [1, 3, 4, 6]
>>> next(lst)    #不能直接使用
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'list' object is not an iterator

>>> next(iter(lst))    #用名称只能获取到第一个元素
1

>>> lst = iter(lst)  #结合循环使用时，要先转化成 iterator
>>> while 1:
...     x = next(lst, "a")    #设置default
...     print(x)
...     if x == "a":
...             break
...
1
3
4
6
a

O

45.object()

描述：返回一个没有特征的对象。
参数：无。
返回值：返回一个object类的实例。object 是所有类的基类。它具有所有 Python 类实例的通用方法。
注意：由于 object 没有 _ _dict_ _ ，因此无法将任何属性赋给 object 的实例。

示例：

>>> o = object()
>>> dir(o)      #object 有所有类的公共方法
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

>>> class A:
...     x = 10
...

>>> issubclass(A, object)  #object 是所有类的基类
True

>>> a = A()  
>>> a.name = "wang"   #普通类可以设置属性

>>> o.name = "wang"    #object 不可以设置属性
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'dict' object has no attribute 'name'

46.oct(x)

描述：将一个整数变成前缀为 "0o"的进制字符串。
参数–x：整数
返回值：八进制的字符串。
示例：

>>> oct(8)
'0o10'

>>> oct(8.0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer

47.open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

描述：Python open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
参数–file：必需，文件路径（相对或者绝对路径）。
mode：可选，文件打开模式。
buffering：设置缓冲。
encoding：一般使用utf8。
errors：是一个可选的字符串参数，用于指定如何处理编码和解码错误 - 这不能在二进制模式下使用。
newline：设置换行符。它可以是 None，’’，’\n’，’\r’ 和 ‘\r\n’。
closefd：传入的file参数类型。
opener：
返回值：返回对应的file object，如果文件不存在，则触发OSError。
注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。使用with open() 可以自动关闭文件对象。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
示例：

>>> with open(r"C:\Users\hasee\Desktop\test.txt", "r") as f:
...     f.read()
...
'Hello World！'

附表1 mode的类型

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

注意：1.Python区分二进制和文本I/O。以二进制模式打开的文件（包括 mode 参数中的 ‘b’ ）返回的内容为 bytes 对象，不进行任何解码。在文本模式下（默认情况下，或者在 mode 参数中包含 ‘t’）时，文件内容返回为 str ，首先使用指定的 encoding （如果给定）或者使用平台默认的的字节编码解码。

2.a 与 a+ 的区别
a ：追加写，但是不能读。
a+：追加写，可读。但是文件指针在末尾，直接读取内容为空。

示例：

>>> with open(r"C:\Users\hasee\Desktop\test.txt", "a") as f:
...     f.read()    #  a 不能直接读取
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
io.UnsupportedOperation: not readable

>>> with open(r"C:\Users\hasee\Desktop\test.txt", "a+") as f:
...     f.read()    # a+ 直接读取内容为空 
...
''

附表二设置buffering 的含义

数值	含义
0	关闭缓冲，仅允许在二进制模式下
1	选择行缓冲，仅允许在文本模式下
>1	以指示固定大小的块缓冲区的大小（以字节为单位）

附表三 errors 的类型

模式	含义
None	如果存在编码错误，会引发 ValueError 异常
strict	如果存在编码错误，会引发 ValueError 异常
ignore	忽略错误。请注意，忽略编码错误可能会导致数据丢失。
replace	会将替换标记（例如 ‘?’ ）插入有错误数据的地方。
surrogateescape	将表示任何不正确的字节作为Unicode专用区中的代码点，范围从U+DC80到U+DCFF。当在写入数据时使用 surrogateescape 错误处理程序时，这些私有代码点将被转回到相同的字节中。这对于处理未知编码的文件很有用。
xmlcharrefreplace	只有在写入文件时才支持 ‘xmlcharrefreplace’。编码不支持的字符将替换为相应的XML字符引用 &#nnn;。
backslashreplace	用Python的反向转义序列替换格式错误的数据。
namereplace	(也只在编写时支持）用 \N{…} 转义序列替换不支持的字符。

注：转义序列即转义字符的集合，包括 \n，\r，\t，\u 等等。

48.ord( c )

描述：对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。
参数–c：单个的 Unicode 字符。
返回值：对应的 Unicode 码点的整数。
示例：

>>> ord("#")
35

P

49.pow(x，y[，z])

描述：返回 x 的 y 次幂；如果 z 存在，则对 z 取余。
参数–x：数值表达式
y：数值表达式
z：数值表达式
返回值：返回 x 的 y 次幂；如果 z 存在，则对 z 取余。
注意： math 模块中也包含 pow()方法，区别如下：

区别	描述
参数个数	math.pow() 只能有两个参数，内置的pow()可以有三个参数。
返回值类型	math.pow()默认返回float，内置的pow()默认返回int

示例：

>>> import math
>>> math.pow(10, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pow() takes exactly 2 arguments (3 given)

>>> math.pow(10, 2)  
100.0

>>> pow(10, 2, 3)
1

>>> pow(3*2, 2*2)
1296

50.print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

描述：print() 方法用于打印输出，最常见的一个函数。print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。
参数–*objects：可以接收多个参数，中键用 ‘,’ 分隔开。
sep：间隔符，当接收多个输出值时，两两之间用 sep 间隔开，默认为空格。
end：结尾后缀。输出以什么结尾，默认为’\n’，可替换成其他合理值。
file：要写入的文件对象。如果参数不存在或为 None，则将使用 sys.stdout.
flush：当为真是，会强制刷新流。
返回值：无。
示例：

>>> a = 123
>>> b = "hello"
>>> c = "world"
>>> print(a, b, c, sep = "##", end = "&&")    #这里没有换行符
123##hello##world&&>>>

>>> print(a, b, c, sep = "##", end = "&&\n")
123##hello##world&&

>>> with open(r"C:\Users\hasee\Desktop\test.txt", "a+") as f:
...     print(a, b, c, sep = "##", file = f)
...
>>> with open(r"C:\Users\hasee\Desktop\test.txt", "r") as f:
...     f.read()
...
'Hello World！123##hello##world\n'
>>>

51.property(fget=None， fset=None， fdel=None， doc=None)

描述：可以对属性进行封装，不直接调用属性。
参数–fget：获取属性值的函数
fset：设置属性值的函数
fdel：删除属性值的函数
doc：属性的描述信息
返回值：返回封装好的属性。
示例：

class A:
    def __init__(self, value):
        self._x = value
    
    def getx(self):
        print("get self._x")
        return self._x
    
    def setx(self, value):
        print("set self._x")
        self._x = value
    
    def delx(self):
        print("del self._x")
        del self._x

    x = property(getx, setx, delx, "this is private _x")   #对私有属性进行封装

a = A(10)
print(a.x)
a.x = 20
print(a.x)
del a.x
print(a.x)

执行结果：

get self._x
10
set self._x
get self._x
20
del self._x
get self._x
Traceback (most recent call last):
  File "c:/Users/hasee/Desktop/111-1.py", line 163, in <module>
    print(a.x)
  File "c:/Users/hasee/Desktop/111-1.py", line 146, in getx
    return self._x
AttributeError: 'A' object has no attribute '_x'

a.x 将触发 getx，a.x = value 将触发 setx ， del a.x 触发 delx。
如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。
注意：python 中还有 @property 装饰器，可以将方法变为属性使用。具体使用可参照Funhacks的博客

R

52.range(start，stop[，step])

描述：Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型，所以打印的时候不会打印列表。
Python3 list() 函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表。
Python2 range() 函数返回的是列表。
参数–start：计数起始值，默认为 0 。
stop：计数结束值，将不会输出，即range的取值范围为[start，stop)。
step：步长。默认为1。
返回值：返回一个序列对象range
示例：

>>> x = range(5)
>>> type(x)
<class 'range'>
>>> for i in x:
...     print(i)
...
0
1
2
3
4

>>> for i in range(0, 10, 2):
...     print(i)
...
0
2
4
6
8

注意：当有step不为空时，start 必须不为空，否则会出现错我的结果。
range的计算公式为 i = start + step 。所以范围为负数时要将数值小的作为 start。同时可以将步长设为 -1 倒序遍历，此时应将start 设为大的值。
示例：

>>> for i in range(0, 10, -1):
...     print(i)
...
>>>
>>>
>>>
>>>
>>>
>>> for i in range(5, 0, -1):
...     print(i)
...
5
4
3
2
1
>>> for i in range(-4, -1):
...     print(i)
...
-4
-3
-2

53.repr(object)

描述：将对象转化成可输出的字符串，如果给与参数时可执行的语句，则先执行，再返回结果的字符串。
参数–object：对象。
返回值：一个字符串对象。
示例：

>>> x = [1, 2, 3, 4]
>>> repr(x)
'[1, 2, 3, 4]'

>>> a = 3
>>> b = 4
>>> repr((a + b))
'7'

54.reversed(seq)

描述：将序列顺序颠倒，返回一个迭代器。
参数–seq：要反转的序列。
返回值：返回一个迭代器。
示例：

>>> x
[1, 2, 3, 4]
>>> x = reversed(x)
>>> print(x)
<list_reverseiterator object at 0x0000018E528D1CC0>
>>> list(x)
[4, 3, 2, 1]

55.round(number[， ndigits])

描述：对数字进行四舍五入计算。返回 number 舍入到小数点后 ndigits 位精度的值。
参数–Number：数字表达式。
ndigits：精度，即保持小数后几位。任何整数值都可作为有效的 ndigits (正数、零或负数)。
返回值：如果 ndigits 被省略或为 None 则返回值将为整数。否则返回值与 number 的类型相同。
示例：

>>> round(3.14159265359, 2)
3.14
>>> round(3.14159265359, -1)
0.0
>>> round(3.14159265359, 0)
3.0
>>> round(314.1592653579, -1)  #当为负数的时候，表示对整数部分进行四舍五入计算。
310.0
>>> round(2.675, 2)       #这里并不是错误
2.67

注意：对浮点数进行round()计算时，结果可能不是预期的结果。例如，round(2.675, 2) 将给出 2.67 而不是期望的 2.68。这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。详细可以参阅官方文档浮点计算

S

56.set([iterable])

描述：返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。
参数–iterable：可迭代对象对象。
返回值：一个新的set对象。
示例：

>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])

57.setattr(object， name， value）

描述：对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
参数–object：对象。
name：字符串。
value：任意值。
返回值：无。
示例：

>>> class A:
...     x = 10
...
>>> a = A()
>>> setattr(a, "x", 20)
>>> print(a.x)
20

58.slice(start， stop[， step])

描述：返回一个表示由 range(start, stop, step) 所指定索引集的 slice 对象。也可以表示为slice(stop)。
参数–start：起始位置。
stop：结束位置。
step：步长。
返回值：一个切片对象。
示例：

>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]

59.sorted(iterable，key=None，reverse=False)

描述：对所有可迭代的对象进行排序操作。具有两个可选参数，它们都必须指定为关键字参数。
参数–iterable：可迭代对象。
Key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。key一般用匿名函数来表示。
reverse：排序规则，reverse = True 降序， reverse = False 升序（默认）。
示例：

 a = [{"name":"aaa", "score":30}, {"name":"bcd", "score":28}, {"name":"bbc", "score":"28"}, {"name":"ddd", "score":35}]
 
 >>> sorted(a, key = lambda x:(x["score"], x["name"]), reverse = True)    #先对分数排序，分数相同按名字排序
 
[{'name': 'ddd', 'score': 35}, {'name': 'aaa', 'score': 30}, {'name': 'bcd', 'score': 28}, {'name': 'bbc', 'score': 28}]

60.staticmethod(function) —

描述：将方法转换成静态方法，该方法不强制要求传递参数。与 @staticmethod 相同。
参数–function：方法名。
返回值：无。
示例：

class A:
    def setx(self, Value):
        self.x = Value
        print(self.x)
    
    @staticmethod    #装饰器
    def setx_s(value):
        x = value
        print(x)

    set_x = staticmethod(setx)   #这里将setx() 转变成静态的方法。使得可以直接调用它，但是同时self也作为参数，需要赋值。-----

A.setx_s(10)
A.set_x(A, 20)

执行结果：

10
20

61.str(object=b’’, encoding=‘utf-8’, errors=‘strict’)

描述：将对象转换成字符串形式。也可以表示为str(object)。
参数–object：对象。
encoding：编码格式
errors：报错级别。详细在open()函数出有介绍。
示例：

>>> from datetime import datetime
>>> now =datetime.now()
>>> repr(now)
'datetime.datetime(2019, 9, 20, 15, 41, 45, 660991)'
>>> str(now)
'2019-09-20 15:41:45.660991'

与repr()的区别是，str()倾向于可读性，面向用户。repr()倾向于精准的表达，所以输出不是常用类型时会带上数据类型，面向开发人员。参考学python桃子

62.sum(iterable[，start])

描述：求一个序列的和。
参数–itreable：序列，可以是列表，集合，元组。
start：指定相加的参数，如果没有设置这个值，默认为0。
返回值：返回序列求和的结果，序列元素全为整数时返回整数，否则返回浮点数。

>>> l = [1.1, 2.4, 3, 4]
>>> sum(l)
10.5
>>> sum(l, 3)  #将3 作为求和运算的第一个值。
13.5

63.super([type[， object-or-type]])

描述：调用父类的方法。
参数–type：类。
object-or-type：类或对象。如果省略第二个参数，则返回的超类对象是未绑定的。如果第二个参数为obj，则 isinstance(obj, type) 必须为真值，即第二个参数为第一个参数的实例。如果第二个参数为一个类型，则 issubclass(type2, type) 必须为真值，即第二个参数是第一个参数的子类（这适用于类方法）。
示例：

class A:
    def __init__(self):
        print("this is class A")
        self.x = 1
    
    def add(self):
        print("this self is class {0}, this method is A.add()".format(self))
        self.x += 1
        print(self.x, "this is a.add()")
        return self.x

class B(A):
    def __init__(self):
        print("this is class B")
        self.x = 2

    def add(self):
        print("this is class {0}, this is B.add()".format(self))
        super().add()
        self.x += 2
        print(self.x, "this is b.add()")
        return self.x

class C(A):
    def __init__(self):
        print("this is class C")
        self.x = 3
    
    def add(self):
        print("this self is class {0}, this is c.add()".format(self))
        super().add()
        self.x += 3
        print(self.x, "this c.add()")
        return self.x

class D(B, C):
    def __init__(self):
        print("this is class D")
        self.x = 4

    def add(self):
        print("this self is class {0}, this is D.add()".format(self))
        super().add()
        self.x += 4
        print(self.x, "this d.add()")
        return self.x

d = D()
temp = d.add()
print(temp)

执行结果：

this is class D
this self is class <__main__.D object at 0x0000012C056D1668>, this is D.add()
this is class <__main__.D object at 0x0000012C056D1668>, this is B.add()
this self is class <__main__.D object at 0x0000012C056D1668>, this is c.add()
this self is class <__main__.D object at 0x0000012C056D1668>, this method is A.add()
5 this is a.add()
8 this c.add()
10 this is b.add()
14 this d.add()
14

可以看到多继承的执行顺序是D->B->C->A。更详细的描述可以参考Huang Huang的博客

T

64.tuple([iterable])

描述：将序列转化成元组。
参数–iterable：序列，可以是列表，字典，集合。
返回值：返回一个新的tuple对象。
示例：

>>> a = [1, 2, 3]
>>> tuple(a)
(1, 2, 3)

>>> b = "abcd"
>>> tuple(b)
('a', 'b', 'c', 'd')

>>> c = dict(a = 1, b = 2, c = 3)  #字典转化成元组时，只保留键。
>>> tuple(c)
('a', 'b', 'c')

65.type()

描述：有两种形式，type(object)，type(name，bases，dict)。如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
参数–object：对象。
name：类名。
bases：bases 元组列出基类并且会成为 bases 属性。基类的元组。
dict：而 dict 字典为包含类主体定义的命名空间并且会被复制到一个标准字典成为 dict 属性。
返回值：如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
示例：

>>> a = 123
>>> type(a)    #一个参数时
<class 'int'>

>>> x = type('x', (object,), dict(a = 1))   #三个参数时，等价于创建一个类名为 x 的类，包含一个属性 a = 1
>>> type(x)
<class 'type'>
>>> print(x.a)
1

66.vars([object])

描述：返回模块、类、实例或任何其它具有 dict 属性的对象的 dict 属性。
参数–object：对象。
返回值：返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值类似 locals()。
示例：

>>> x = type('x', (object,), dict(a = 1)) 
>>> vars(x)
mappingproxy({'a': 1, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'x' objects>, '__weakref__': <attribute '__weakref__' of 'x' objects>, '__doc__': None})
>>> x.__dict__
mappingproxy({'a': 1, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'x' objects>, '__weakref__': <attribute '__weakref__' of 'x' objects>, '__doc__': None})
>>> dir(x)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a']

可以看出 vars() 的值与 _ _dict_ _的值一致。
与dir()最显著的区别之一就是vars()会带上属性值。
注意：在赋值语句 x = 1 执行后，名称 x 可以引用数值 1，这类似字典的键值对，可以用 vars() 返回这个 “字典” 。
示例：

>>> x = 1
>>> d = vars()
>>> d["x"]
1

67.zip(*iterable)

描述：zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
参数–iterable：一个或多个迭代器。
返回值：返回一个元组的迭代器，其中的第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。
示例：

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
 
>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

>>> a = dict(name1 = "aaa", name2 = "bbb", name3 = "ccc")  #当参数为字典是只会保留关键字
>>> b = dict(age1 = 10, age2 = 20, age3 = 30)
>>> c = zip(a, b)
>>> list(c) 
[('name1', 'age1'), ('name2', 'age2'), ('name3', 'age3')]

68._ _import_ _(name， globals=None， locals=None，fromlist=()， level=0)

描述：动态加载模块。
参数–name：必选，包，模块名称
globals：包含全局变量的字典，默认采用 globals()，一般很少使用。
locals：包含局部变量的字典，默认采用 locals()，一般很少使用。
fromlist：想要导入的下级模块的名字。
level：指定是使用绝对还是相对导入。0 表示仅绝对导入， level 为正数值表示相对于模块调用 _ import _() 的目录，将要搜索的父目录层数。

使用技巧参考传送门