| 数学运算 |
- abs：求数值的绝对值
def func(x,y,f):
return f(x)+f(y)
print(func(-1,9,abs))
#输出结果：10
- divmod：地板除（返回两个数值的商和余数）
print(divmod(5,2))
#输出结果：(2, 1)
- max：返回可迭代对象中的元素的最大值或者所有参数的最大值
print(max([2,3,4,5,6,7]))
print(max([1,2],[2,3],[3,4]))
a=[3,4,5,6,7,8,9,10,11]
print(a.index(max(a))) #index为元素下标，输出最大值所对应的元素下标
print(max("aa","ab","ac")) #按ASCII码中的数值大小
print(max(-1,0,key=abs)) #abs为绝对值参数
print(max(1,2,3,"4",key=int)) #转为int型进行比较
#输出结果：7
#输出结果：[3,4]
#输出结果：8
#输出结果：ac
#输出结果：-1
#输出结果：4
- min：返回可迭代对象中的元素的最小值或者所有参数的最小值
print(min([2,3,4,5,6,7]))
print(min([1,2],[2,3],[3,4]))
a=[3,4,5,6,7,8,9,10,11]
print(a.index(min(a))) #index为元素下标，输出最小值所对应的元素下标
print(min("aa","ab","ac")) #按ASCII码中的数值大小
print(min(-1,0,key=abs)) #abs为绝对值参数
print(min(1,2,3,"4",key=int)) #转为int型进行比较
#输出结果：2
#输出结果：[1,2]
#输出结果：0
#输出结果：aa
#输出结果：0
#输出结果：1
- pow：返回两个数值的幂运算值或者其与指定整数的余数值
print(2**3)
print(pow(3,3)) #3**3
print(pow(2,3,3)) #2**3%3
#输出结果：8
#输出结果：27
#输出结果：2
- round：对浮点数进行四舍五入求值
print(round(1.734567)) #取四舍五入的值
print(round(1.234565,3)) #四舍五入取三位
#输出结果：2
#输出结果：1.235
- sum：对元素类型是数值的可迭代对象中的每个元素求和
a = sum((1,2,3,4))
print(a)
#输出结果：10
| 类型转换 |
- bool：根据传入参数创建布尔值
print(bool([1]))
print(bool([8]))
#输出结果：True
#输出结果：True
- int：根据传入参数创建一个新的整数
a = int()
print(a)
b = int("3")
print(b)
c = int(3.2)
print(c)
#输出结果：0
#输出结果：3
#输出结果：3
- float：根据传入的参数创建一个新的浮点数
a = float()
print(a)
b = float("3")
print(b)
c = float(4)
print(c)
#输出结果：0.0
#输出结果：3.0
#输出结果：4.0
- complex：根据传入参数创建一个新的复数
a = complex()
print(a)
b = complex(1,2)
print(b)
c = complex("1+2j")
print(c)
#输出结果：0j
#输出结果：(1+2j)
#输出结果：(1+2j)
- str：返回一个对象的字符串表现形式（给用户）
print(str(12))
print(type(str(12)))
#输出结果：12 '''在cmd中以'12'输出'''
#输出结果：<class 'str'>
- bytes：根据传入参数创建一个新的不可变字节数组
a = bytes("abcdef",encoding="utf-8")
print(a)
b = bytes("栗子",encoding="utf-8")
print(b)
#输出结果：b'abcdef'
#输出结果：b'xe6xa0x97xe5xadx90'
- bytearray：根据传入的参数创建一个新的字节数组
b = bytearray("abcdef",encoding="utf-8")
print(b[0])
print(b)
#输出结果：97
#输出结果：bytearray(b'abcdef')
- memoryview：根据传入的参数创建一个新的内存查看对象
a = memoryview(b"abcde")
print(a)
print(a[-1])
#输出结果：<memory at 0x000001D79E53A348>
#输出结果：101
- chr：返回整数所对应的Unicode字符
print(chr(97))
print(chr(165))
#输出结果：a
#输出结果：¥
- ord：返回Unicode字符所对应的ASCII码数
print(ord("b"))
print(ord("A"))
#输出结果：98
#输出结果：65
- bin：将整数转换成二进制字符串
print(bin(8978))
print(type(bin(8978)))
#输出结果：0b10001100010010
#输出结果：<class 'str'>
- oct：将整数转换成八进制字符串
print(oct(8978))
print(type(oct(8978)))
#输出结果：0o21422
#输出结果：<class 'str'>
- hex：将整数转换成十六进制字符串
print(hex(89))
print(type(hex(89)))
#输出结果：0x59
#输出结果：<class 'str'>
- tuple：根据传入的参数创建一个新的元组
a = tuple()
print(a)
b = tuple("12345")
print(b)
#输出结果：()
#输出结果：('1', '2', '3', '4', '5')
- list：根据传入的参数创建一个新的列表
a = list()
print(a)
b = list("12345")
print(b)
#输出结果：[]
#输出结果：['1', '2', '3', '4', '5']
- dict：根据传入的参数创建一个新的字典
a = dict()
print(a)
b = dict((("1",1),("2",2)))
print(b)
c = dict((["a","b"],[1,2]))
print(c)
#输出结果：{}
#输出结果：{'1': 1, '2': 2}
#输出结果：{'a': 'b', 1: 2}
- frozenset：根据传入的参数创建一个新的不可变集合
a=frozenset([2,3,4])
print(a)
# a[2]="aaa" #TypeError: 'frozenset' object does not support item assignment
#输出结果：frozenset({2, 3, 4})
- set：根据传入的参数创建一个新的集合
a = set()
print(a)
b = set(range(10))
print(b)
c = set("ab12")
print(c)
#输出结果：set()
#输出结果：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
#输出结果：{'1', '2', 'b', 'a'}
- enumerate
- 在字典上是枚举、列举的意思；
- 参数为可遍历|可迭代的对象（如列表、字符串）；
- 多用于在for循环中的得到计数，利用它可以同时获得索引和值，即需要index和value值的时候可以使用enumerate；
- 根据可迭代对象创建枚举对象，返回的是一个enumerate对象；
- 格式：
enumerate（sequence，[start = 0]）
- sequence —— 一个序列，迭代器或其他支持迭代对象
- start —— 下标的起始位置
例1：
'''enumerate用法'''
l = ["you","are","a","pig"]
for index,item in enumerate(l,1):
print(index,item)
#输出结果：
'''
1 you
2 are
3 a
4 pig
'''
例2：
color = ["red","green","yellow","bule"]
print(list(enumerate(color)))
print(list(enumerate(color,start=2)))
#输出结果：[(0, 'red'), (1, 'green'), (2, 'yellow'), (3, 'bule')]
#输出结果：[(2, 'red'), (3, 'green'), (4, 'yellow'), (5, 'bule')]
通过上述实例可知，通过enumerate可以自增一列序号，并且起始位置可以通过start指定任意所需值，避免了下标从0开始的局限性。
| 序列操作 |
- all：判断可迭代对象的每个元素是否都为True值
print(all(["jfdks",2,3,1]))
print(all([0,3,1])) #列表中0的逻辑值为False
#输出结果：True
#输出结果：False
- any：判断可迭代对象的元素是否有为True值的元素
print(any([37,0,3])) #有一个为True则全为True
print(any([0,0])) #全为False时才为False
#输出结果：True
#输出结果：False
- sorted：对可迭代对象进行排序，返回一个新列表
a={1:2,3:4,9:2,8:6}
print(sorted(a.items())) #以键的大小为排序对象
print(sorted(a.items(),key=lambda x:x[1])) #以值的大小为排序对象
#输出结果：[(1, 2), (3, 4), (8, 6), (9, 2)]
#输出结果：[(1, 2), (9, 2), (3, 4), (8, 6)]
- filter
- filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个可迭代对象，这个函数 f 的作用是对每个元素进行判断；
- f返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素；
- 使用指定方法过滤可迭代对象元素；
例1：输出9以内满足n>5的数
#filter,将满足情况的项输出
ve=filter(lambda n:n>5,range(10))
for i in ve:
print(i)
#输出结果：6
#输出结果：7
#输出结果：8
#输出结果：9
- map
- map()是 Python内置的高阶函数，它接收一个函数f和列表或元组对象,并通过把函数f依次作用在列表或元组的每个元素上。
- 使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象。
- 返回值
- Python 2.x 返回列表
- Python 3.x 返回迭代器
例1：将原有列表通过map的方法，使其元素输出平方值。
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# def f(x):
# return x**2
#a = map(f,l)
a = map(lambda i:i**2,l) #等价于def
print(a)
#输出结果：
'''
<map object at 0x000001B1539144A8>
迭代器的形式，并非真值
'''
for i in a:
print(i)
#利用for循环可以打印出所需的值
#输出结果：
'''
1
4
9
16
25
36
49
64
81
'''
例2：将下列中不规范的姓名，规范化，即首字母大写。
def format(s):
s1=s.title()
return s1
a = map(format, ['LIZI', 'yin', 'bob'])
for i in a:
print(i)
#输出结果：
'''
Lizi
Yin
Bob
'''
例3：判断True或False
#map，将判断结果输出
re=map(lambda n:n>5,range(3))
for i in re:
print(i)
#输出结果：False
#输出结果：False
#输出结果：False
PS：lambda函数是一种快速定义单行的最小函数，是从 Lisp 借用来的，可以用在任何需要函数的地方 。lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。 lambda 函数不能包含命令，包含的表达式不能超过一个。使用lambda函数来定义更加精简灵活，还可以直接把函数赋值给一个变量，用变量名来表示函数名。
- zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
a=[1,2,3,4]
b=[5,6,7,8]
for i in zip(a,b):
print(i)
#输出结果：(1, 5)
#输出结果：(2, 6)
#输出结果：(3, 7)
#输出结果：(4, 8)
a=[1,2,3]
b=[5,6,7,8]
for i in zip(a,b):
print(i)
#输出结果：(1, 5)
#输出结果：(2, 6)
#输出结果：(3, 7)
c=[[1,2,3],[4,5,6],[7,8,9]]
for i in zip(*c):
print(i)
#输出结果：(1, 4, 7)
#输出结果：(2, 5, 8)
#输出结果：(3, 6, 9)
| 对象操作 |
- dir：返回对象或者当前作用域内的属性列表
print(dir([]))
#输出结果：['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__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']
- id：返回对象的唯一标识符
a = "lizi"
print(id(a))
#输出结果：2269288752104
- hash：获取对象的哈希值
print(hash("a"))
#输出结果：4677843747549717534
- type：返回对象的类型，或者根据传入的参数创建一个新的类型
print(type(1))
#输出结果：<class 'int'>
- ascii：返回对象的可打印表以字符串形式输出
a = ascii(12)
print(a)
print(type(a))
#输出结果：12
#输出结果：<class 'str'>
| 反射操作 |
- isinstance：判断对象是否是类或者类型元组中任意类元素的实例
a=1
print(isinstance(a,int))
print(type(1))
#输出结果：True
#输出结果：<class 'int'>type和isinstance的区别：
- type不认为子类是一种父类类型，不考虑继承
- isinstance会认为子类是一种父类类型，考虑继承
- 如果需要判断两种类型的关系，建议使用isinstance
- callable：检测对象是否可被调用
def func(x,y,f):
return f(x)+f(y)
print(callable(func))
#输出结果：True
| 变量操作 |
- locals：返回当前作用域内的局部变量和其值组成的字典
def A():
varse=234
print(locals()) #打印局部变量
print(A())
#输出结果：{'varse': 234}
#输出结果：None
- globals：返回当前作用域内的全局变量和其值组成的字典
def A():
varse=2347
print(globals()) # 返回本模块中所有的全局变量
print(A())
#输出结果：{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001F73AA56080>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/lenovo/Documents/WeChat Files/qian414414/Files/内置方法(1).py', '__cached__': None, 'A': <function A at 0x000001F738EEC1E0>}
#输出结果：None