1、数学运算类
(1)、abs(x)
求绝对值，参数x可以是整形，也可也是复数，如果是复数，则返回复数的模
abs(-1) >> 1
(2)、divmod(x,y)
返回两个数值的商和余数
divmod(5,2) >>(2,1)
divmod(4.5,3) >>(1.0, 1.5)
(3)、max(iterable[, args...][key])
返回可迭代对象中的元素中的最大值或者所有参数的最大值
max(1,2,3) #传入三个参数，取三个中最大的一个 >> 3 max('1234') # 传入一个可迭代对象，取最大值 >> "4" max(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取较大者 >> -1
(4)、min(iterable[, args...][key])
返回可迭代对象中的元素中的最小值或者所有参数的最小值
min(1,2,3) #传入三个参数，取三个中最小的一个 >> 1 min('1234') # 传入一个可迭代对象，取最小值 >> "1" min(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取最下者 >> 0
(5)、pow(x,y,z)
返回两个数值的幂运算值或其与指定整数的模值
如果只有两个参数，计算为x**y，如果三个参数，计算为x**y%z
pow(2,3) # 2**3 >> 8 pow(2,3,4) # 2**3%4 >>0
(6)、round(x[, n])
对浮点数进行四舍五入求值,可以指定小数点后的位数，默认为0
round(1.3455664) # 没有指定小数点后的位置，默认为0 >> 1round(1.3455664,2) # 保留两位小数 >> 1.35
(7)、sum(iterable[, start])
sum((1,2,3,4)) # 传入可迭代对象，元素必须是数值 >> 10
sum((1,2,3,4), -10) # 先计算元祖，在计算-10
>> 0
2、类型转换
(1)、bool()
根据传入的参数的逻辑值创建一个新的布尔值
bool() # 为传入任何参数 >> False bool(None) # None，空字符串，0都为False >> False bool(1) >> True
(2)、int()
根据传入的参数创建一个新的整数
int() # 不传入任何参数，默认返回为0 >> 0 int("3") # 传入一个数字型的字符串 >> 3 int(3.5) # 传入一个浮点数 >> 3
(3)、float()
根据传入的参数创建一个新的浮点数
float() # 不传入任何参数，返回0.0 >> 0.0 float('3.5') # 传入浮点型的字符串 >> 3.5 float(3) # 传入整数 >> 3.0
(4)、complex()
根据传入参数创建一个新的复数
complex() >> 0j complex("1+2j") >> (1+2j) complex(1,2) >> (1+2j)
(5)、str()
返回一个对象的字符串表现形式
str() >> '' str(123) >>'123'
str(None)
>> 'None'
(6)、bytes()
把字符串转换为字节形式
name = "你好" a = bytes(name,encoding="utf-8") # 指定编码方式
a >> b'xe4xbdxa0xe5xa5xbd'
a.decode('utf-8') # 用什么方式编码，就用什么方式解码
>> '你好'
(7)、ord()
返回ascii字符对应的整数
ord('a') >> 97
(8)、chr()
返回整数所对应的ascii字符
chr(97)
>>a
(9)、bin()
将整数转换为二进制字符串
bin(3) >>'0b11'
(10)、oct()
将整数转化成8进制数字符串
oct(10) >> '0o12'
(11)、hex()
将整数转换成16进制字符串
hex(12) >> '0xc'
(12)、frozenset()
根据传入的参数创建一个新的不可变集合
a = frozenset(range(10))
a>> frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
(13)、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')]
(14)、iter(object[, sentinel])
object -- 支持迭代的集合对象。
sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
一般常用的是传入object。
for i in iter(range(2)): print(i) >> 0 1
可以利用iter()实现一个for死循环
for i in iter(int, 1): # int永远是0 pass
(15)、siice(start, stop[, step])
根据传入的参数创建一个新的切片对象
a = slice(5) a >>slice(None, 5, None) range(10)[a] >>range(0, 5)
3、序列操作
(1)、all()
判断可迭代对象的每个元素是否都为True值
all([1,2,3]) # 列表中每个元素逻辑值都为真，则返回True >> True all([0,1,2]) >> False
all([]) # 空列表
>> True
all(()) # 空元祖
>> True
all({}) # 空字典
>> True
(2)、any()
判断可迭代对象的元素是否有为True值的元素。
any([0,1,2]) # 列表元素逻辑值有为True的，则返回True >> True any([0,False]) # 列表中的逻辑值全为False,则返回False >> False any([]) # 空列表 >> False any(()) # 空元祖 >> True any({}) # 空字典 >> True
(3)、next()
返回可迭代对象中的下一个元素值
a = iter('abc') next(a) >> 'a' next(a) >> 'b' next(a) >> 'c' next(a) # 越界会抛出异常 >> --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-9-15841f3f11d4> in <module> ----> 1 next(a) StopIteration:
传入default参数后，如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所有元素已经返回，则返回default指定的默认值而不抛出StopIteration 异常
a = iter("abc") next(a, 'd') >> 'a' next(a, 'd') >> 'b' next(a, 'd') >> 'c' next(a, 'd') >> 'd'
(4)、reversed()
反转序列生成新的可迭代对象
a = reversed(range(10)) # 传入range对象 a >> <range_iterator at 0x5c0b770> # list(a) >> [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
(5)、sorted()
对可迭代对象进行排序，返回一个新的列表
注意：不同类型之间不可以比较大小
实例1：
a = ['a','b','d','c','B','A'] sorted(a) >> ['A', 'B', 'a', 'b', 'c', 'd'] # 默认使用ascii排序,返回新的列表 # 可以使用sort()方法实现同样的效果，但是不会产生新的列表，在原列表的基础上排序 a.sort() a >> ['A', 'B', 'a', 'b', 'c', 'd'] sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样 >> ['A', 'a', 'B', 'b', 'c', 'd'] a.sort(key=str.lower) a >> ['A', 'a', 'B', 'b', 'c', 'd']
实例2：
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] # 按照年龄降序排序 sorted(students, key=lambda s:s[2], reverse=True) >> [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
(6)、zip()
拉链函数，将对象一一配对（不管是左边还是右边多出，不会报错）
list(zip(('a','n','c'),(1,2,3))) >> [('a', 1), ('b', 2), ('c', 3)]
利用zip()函数将字段的key与value进行对调
dic = {'name': 'Alex',
'age':18,
'genter':None}
list((zip(dic.values(),dic)))
>> [('Alex', 'name'), (18, 'age'), (None, 'genter')]
4、对象操作
(1)、help()
返回对象的帮助信息
(2)、dir()
显示函数内部的属性和方法，以列表的形式返回
['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']
(3)、id()
返回对象的唯一标识符
(4)、hash()
可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型
hash的作用：去网上下载软件，判断是否被人修改，通过比对hash值，就知道
hash('good good study') >> -6498340610423324471
(5)、vars()
返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表
def test(): msg='多想和你一样臭不要脸' print(locals()) #打印出上一层的值，如果上一层没有，再往上找 print(vars()) #如果没有参数，跟locals一样，如果有参数，查看某一个方法，显示成字典的方式 test()
>>{'msg': '多想和你一样臭不要脸'}
{'msg': '多想和你一样臭不要脸'}
返回对象属性列表
vars(int)
5、反射操作
(1)、isinstance(object, classinfo)
用来判断一个对象是否为一个已知的类型，类似type()
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。
注意：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
a = 2 isinstance (a,int) >>True isinstance (a,str) >>False isinstance (a,(str,int,list)) # 是元组中的一个返回 True >> True
(2)、issubclass(class, classinfo)
用于判断参数 class 是否是类型参数 classinfo 的子类。
class -- 类。
classinfo -- 类
如果 class 是 classinfo 的子类返回 True，否则返回 False
class A: pass class B(A): pass issubclass(B,A) # 返回 True
(3)、hasattr(object, name)
object -- 对象。
name -- 字符串，属性名。
如果对象有该属性返回 True，否则返回 False
class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() hasattr(point1, 'x') >> True hasattr(point1, 'y') >> True hasattr(point1, 'z') >> True hasattr(point1, 'no') >> False # 没有该属性
(4)、getattr(object, name[, default])
用于返回一个对象的属性值。
object -- 对象。
name -- 字符串，对象属性。
default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
class A(object): bar = 1 a = A() getattr(a, 'bar') # 获取属性 bar 值 >> 1 getattr(a, 'bar2') # 属性 bar2 不存在，触发异常 >>Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'A' object has no attribute 'bar2' getattr(a, 'bar2', 3) # 属性 bar2 不存在，但设置了默认值 >> 3
(5)、setattr(object, name, value)
函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
object -- 对象。
name -- 字符串，对象属性。
value -- 属性值。
①、对已存在的属性进行赋值
class A(object): bar = 1 a = A() getattr(a, 'bar') >> 1 setattr(a, 'bar', 2) a.bar >> 2
②、如果属性不存在会创建一个新的对象属性，并对属性赋值
class A(object): name = 'Negan' a = A() setattr(a, 'age', 20) a.age >> 20
(6)、delattr(object, name)
用于删除属性，delattr(x, 'foobar') 相等于 del x.foobar。
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)
(7)、callable(object)
用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。
callable(0) >>False callable("runoob") >>False def add(a, b): return a + b callable(add) # 函数返回 True >>True class A: # 类 def method(self): return 0 callable(A) # 类返回 True >> True a = A() callable(a) # 没有实现 __call__, 返回 False >> False class B: def __call__(self): return 0 callable(B) >>True b = B() callable(b) # 实现 __call__, 返回 True >>True
(8)、eval(expression[, globals[, locals]])
用来执行一个字符串表达式，并返回表达式的值
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
x = 7 eval( '3 * x' ) >>21 eval('pow(2,2)') >>4 eval('2 + 2') >>4 n=81 eval("n + 4") >>85
(9)、exec()
执行动态语句块
exec('a=1+2') #执行语句 a >>3
(10)、repr(object)
将对象转化为供解释器读取的形式，返回对象的string格式
dict = {'runoob': 'runoob.com', 'google': 'google.com'};
repr(dict)
>>"{'google': 'google.com', 'baidu': 'baidu.com'}"
---