672 lines
14 KiB
Markdown
672 lines
14 KiB
Markdown
# 内置函数
|
||
|
||
截止到python版本3.9.22，python一共为我们提供了**69个内置函数。**
|
||
|
||
https://docs.python.org/zh-cn/3.9/library/functions.html
|
||
|
||
## 作用域相关
|
||
|
||
### `locals()`
|
||
函数会以字典的类型返回当前位置的全部局部变量。
|
||
|
||
### `globals()`
|
||
函数以字典的类型返回全部全局变量。
|
||
|
||
**示例**
|
||
```python
|
||
a = 1
|
||
b = 2
|
||
|
||
print(locals())
|
||
print(globals())
|
||
|
||
# 这两个一样，因为是在全局执行的
|
||
|
||
def func(argv):
|
||
c = 2
|
||
print(locals())
|
||
print(globals())
|
||
|
||
func(3)
|
||
```
|
||
|
||
## 字符串类型代码执行
|
||
|
||
### `eval()`
|
||
|
||
计算指定表达式的值，并返回最终结果
|
||
|
||
```python
|
||
ret = eval('2 + 2')
|
||
print(ret)
|
||
|
||
n = 20
|
||
ret = eval('n + 23')
|
||
print(ret)
|
||
|
||
eval('print("Hello world")')
|
||
```
|
||
|
||
### `exec()`
|
||
|
||
执行字符串类型的代码
|
||
|
||
```python
|
||
s = '''
|
||
for i in range(5):
|
||
print(i)
|
||
'''
|
||
|
||
exec(s)
|
||
|
||
```
|
||
|
||
### `compile()`
|
||
|
||
用于将源代码编译成字节码，从而可以在后续执行中使用。这个函数的主要作用是将字符串形式的代码转换为可以通过 `exec()` 或 `eval()` 执行的代码对象。
|
||
|
||
**语法**
|
||
|
||
```python
|
||
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
|
||
```
|
||
|
||
**参数**
|
||
|
||
- **source**：要编译的源代码，可以是字符串或 AST（抽象语法树）对象。
|
||
- **filename**：表示代码的文件名（通常为字符串），用于错误消息的显示。可以是任意字符串。
|
||
- **mode**：指定编译模式
|
||
- `'exec'` ：用于编译多条语句（如模块或函数）。
|
||
- `'eval'` ：用于编译单个表达式。
|
||
- `'single'` ：用于编译单个交互式语句。
|
||
|
||
**返回值**
|
||
|
||
返回一个代码对象，可以使用 `exec()` 或 `eval()` 执行
|
||
|
||
**示例**
|
||
|
||
```python
|
||
# 流程语句使用exec
|
||
code1 = 'for i in range(5): print(i)'
|
||
compile1 = compile(code1,'','exec')
|
||
exec(compile1)
|
||
|
||
# 简单求值表达式用eval
|
||
code2 = '1 + 2 + 3'
|
||
compile2 = compile(code2,'','eval')
|
||
eval(compile2)
|
||
|
||
# 交互语句用single
|
||
code3 = 'name = input("please input you name: ")'
|
||
compile3 = compile(code3,'','single')
|
||
|
||
exec(compile3)
|
||
print(name)
|
||
```
|
||
|
||
有返回值的字符串形式的代码用 eval，没有返回值的字符串形式的代码用 exec，一般不用 compile。
|
||
|
||
## 输入/输出相关
|
||
|
||
### `input()`
|
||
|
||
函数接受一个标准输入数据，返回为 string 类型。
|
||
|
||
### `print()`
|
||
|
||
打印输出。
|
||
|
||
```python
|
||
''' 源码分析
|
||
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
|
||
"""
|
||
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
|
||
file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
|
||
sep: 打印多个值之间的分隔符，默认为空格
|
||
end: 每一次打印的结尾，默认为换行符
|
||
flush: 立即把内容输出到流文件，不作缓存
|
||
"""
|
||
'''
|
||
|
||
print(11,22,33,sep='*')
|
||
print(11,22,33,end='')
|
||
print(44,55)
|
||
|
||
with open('log','w',encoding='utf-8') as f:
|
||
print('写入文件',file=f,flush=True)
|
||
```
|
||
|
||
## 内存相关
|
||
|
||
### `hash()`
|
||
|
||
获取一个对象（可哈希对象：int，str，bool，tuple）的哈希值。
|
||
|
||
```python
|
||
print(hash(12322))
|
||
print(hash('123'))
|
||
print(hash('arg'))
|
||
print(hash('aaron'))
|
||
print(hash(True))
|
||
print(hash(False))
|
||
print(hash((1,2,3)))
|
||
|
||
```
|
||
|
||
### `id()`
|
||
|
||
用于获取对象的内存地址
|
||
|
||
```python
|
||
print(id('abc'))
|
||
print(id('123'))
|
||
|
||
```
|
||
|
||
## 文件操作相关
|
||
|
||
### `open()`
|
||
|
||
用于打开一个文件，创建一个 file 对象
|
||
|
||
### `read()`
|
||
|
||
通过文件对象调用，读取文件的内容
|
||
|
||
### `write()`
|
||
|
||
文件文件对象调用，往文件里下入内容
|
||
|
||
.......
|
||
|
||
## 帮助文档
|
||
|
||
### `help()`
|
||
|
||
函数用于查看函数或模块用途的详细说明。
|
||
|
||
```python
|
||
print(help(print))
|
||
|
||
#结果
|
||
print(...)
|
||
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
|
||
|
||
Prints the values to a stream, or to sys.stdout by default.
|
||
Optional keyword arguments:
|
||
file: a file-like object (stream); defaults to the current sys.stdout.
|
||
sep: string inserted between values, default a space.
|
||
end: string appended after the last value, default a newline.
|
||
flush: whether to forcibly flush the stream.
|
||
```
|
||
|
||
## 调用相关
|
||
|
||
### `callable()`
|
||
|
||
用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 ojbect 绝对不会成功。
|
||
|
||
```python
|
||
print(callable(0))
|
||
print(callable('hello'))
|
||
|
||
# 自定义函数
|
||
def demo1(a, b):
|
||
return a + b
|
||
print(callable(demo1))
|
||
|
||
# 自定义类
|
||
class Demo2:
|
||
def test1(self):
|
||
return 0
|
||
|
||
print(callable(Demo2))
|
||
|
||
# 实例化对象
|
||
a = Demo2()
|
||
print(callable(a))
|
||
|
||
```
|
||
|
||
## 查看内置属性
|
||
|
||
### `dir()`
|
||
函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法 `__dir__()` ，该方法将被调用。如果参数不包含 `__dir__()` ，该方法将最大限度地收集参数信息。
|
||
|
||
```python
|
||
import time
|
||
print(dir(time)) # 查看某个模块的属性和方法
|
||
|
||
print(dir([])) # 查看列表的属性和方法
|
||
```
|
||
|
||
## 迭代器生成器相关
|
||
|
||
### `range()`
|
||
|
||
函数可创建一个整数对象，一般用在 for 循环中。
|
||
|
||
### `next()`
|
||
|
||
内部实际使用了 `__next__` 方法，返回迭代器的下一个项目。
|
||
|
||
### `iter()`
|
||
|
||
函数用来生成迭代器（通过一个可迭代对象生成迭代器）。
|
||
|
||
```python
|
||
from collections import Iterator
|
||
|
||
# 首先获得Iterator对象:
|
||
l = [1,2,3,4]
|
||
l1 = iter(l)
|
||
|
||
print(isinstance(l1,Iterable))
|
||
print(isinstance(l1,Iterator))
|
||
|
||
# 循环
|
||
while True:
|
||
try:
|
||
# 获得下一个值
|
||
x = next(l1)
|
||
print(x)
|
||
except StopIteration: # 遇到StopIteration就退出循环
|
||
break
|
||
```
|
||
|
||
## 数据类型相关
|
||
|
||
### `bool()`
|
||
|
||
将给定参数转换为布尔类型，如果没有参数，返回 False
|
||
|
||
### `int()`
|
||
|
||
将一个字符串或数字转换为整型
|
||
|
||
### `float()`
|
||
|
||
将整数和字符串转换成浮点数。
|
||
|
||
### `complex()`
|
||
|
||
将创建复数（complex numbers）。复数是由实部和虚部组成的，通常写作 `a + bj` 的形式，其中 `a` 是实部，`b` 是虚部，`j` 是虚数单位。
|
||
|
||
```python
|
||
print(int())
|
||
print(int('12'))
|
||
print(int(3.6))
|
||
print(int('0100',base=2)) # 将2进制的 0100 转化成十进制。结果为 4
|
||
z1 = complex(2, 3) # 实部为 2，虚部为 3
|
||
print(z1) # 输出: (2+3j)
|
||
|
||
```
|
||
|
||
## 进制转换相关
|
||
|
||
### `bin()`
|
||
|
||
将十进制转换成二进制并返回。
|
||
|
||
### `ocb()`
|
||
|
||
将十进制转化成八进制字符串并返回。
|
||
|
||
### `hex()`
|
||
|
||
将十进制转化成十六进制字符串并返回。
|
||
|
||
**示例**
|
||
|
||
```python
|
||
print(bin(10),type(bin(10)))
|
||
print(oct(10),type(oct(10)))
|
||
print(hex(10),type(hex(10)))
|
||
```
|
||
|
||
## 数学运算相关
|
||
|
||
### `abs()`
|
||
|
||
返回数字的绝对值。
|
||
|
||
### `divmod()`
|
||
|
||
计算除数与被除数的结果，返回一个包含商和余数的元组 `(a // b, a % b)`。
|
||
|
||
### `round()`
|
||
|
||
保留浮点数的小数位数，默认保留整数。
|
||
|
||
### `pow()`
|
||
|
||
函数是计算 x 的 y 次方，如果 z 存在，则再对结果进行取模，其结果等效于 `(pow(x,y) % z)`
|
||
|
||
**示例**
|
||
|
||
```python
|
||
print(abs(-5)) # 5
|
||
|
||
print(divmod(7,2)) # (3, 1)
|
||
|
||
print(round(7/3,2)) # 2.33
|
||
print(round(7/3)) # 2
|
||
print(round(3.32567,3)) # 3.326
|
||
|
||
print(pow(2,3)) # 8
|
||
print(pow(2,3,3)) # 2
|
||
```
|
||
|
||
### `sum()`
|
||
|
||
对可迭代对象进行求和计算（可设置初始值）。
|
||
|
||
### `min()`
|
||
|
||
返回可迭代对象的最小值（可加 key，key 为函数名，通过函数的规则，返回最小值）。
|
||
|
||
### `max()`
|
||
|
||
返回可迭代对象的最大值（可加 key，key 为函数名，通过函数的规则，返回最大值）。
|
||
|
||
|
||
**示例**
|
||
|
||
```python
|
||
print(sum([1,2,3]))
|
||
print(sum([1,2,3],100))
|
||
|
||
print(min([1,2,3]))
|
||
|
||
ret = min([1,2,3,-10],key=abs)
|
||
print(ret)
|
||
|
||
print(max([1,2,3]))
|
||
|
||
ret = max([1,2,3,-10],key=abs)
|
||
print(ret)
|
||
|
||
```
|
||
|
||
## 数据结构相关
|
||
|
||
### `list()`
|
||
|
||
将一个可迭代对象转化成列表（如果是字典，默认将 key 作为列表的元素）。
|
||
|
||
### `tuple()`
|
||
|
||
将一个可迭代对象转化成元祖（如果是字典，默认将 key 作为元祖的元素）。
|
||
|
||
### `dict()`
|
||
|
||
创建一个字典。
|
||
|
||
### `set()`
|
||
|
||
创建一个集合。
|
||
|
||
### `frozenset()`
|
||
|
||
创建一个冻结的集合。
|
||
|
||
|
||
```python
|
||
l = list((1,2,3))
|
||
print(l)
|
||
l = list({1,2,3})
|
||
print(l)
|
||
l = list({'k1':1,'k2':2})
|
||
print(l)
|
||
|
||
tu = tuple((1,2,3))
|
||
print(tu)
|
||
tu = tuple([1,2,3])
|
||
print(tu)
|
||
tu = tuple({'k1':1,'k2':2})
|
||
print(tu)
|
||
```
|
||
|
||
## 字符串相关
|
||
|
||
### `str()`
|
||
|
||
将数据转化成字符串。
|
||
|
||
### `format()`
|
||
|
||
具体数据相关，用于计算各种小数，精算等。
|
||
|
||
```python
|
||
# 字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
|
||
print(format('test','<20'))
|
||
print(format('test','>20'))
|
||
print(format('test','^20'))
|
||
|
||
# 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
|
||
print(format(192,'b')) # 转换为二进制
|
||
print(format(97,'c')) # 转换unicode成字符
|
||
print(format(11,'d')) # 转换成10进制
|
||
print(format(11,'o')) # 转换为8进制
|
||
print(format(11,'x')) # 转换为16进制，小写字母表示
|
||
print(format(11,'X')) # 转换为16进制，大写字母表示
|
||
print(format(11,'n')) # 和d一样
|
||
print(format(11)) # 和d一样
|
||
|
||
# 浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
|
||
print(format(314159265,'e')) # 科学计数法，默认保留6位小数
|
||
print(format(314159265,'0.2e')) # 科学计数法，保留2位小数
|
||
print(format(314159265,'0.2E')) # 科学计数法，保留2位小数,大写E
|
||
print(format(3.14159265,'f')) # 小数点计数法，默认保留6位小数
|
||
print(format(3.14159265,'0.10f')) # 小数点计数法，保留10位小数
|
||
print(format(3.14e+10000,'F')) # 小数点计数法，无穷大转换成大小字母
|
||
|
||
# g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
|
||
print(format(0.00003141566,'.1g'))
|
||
# p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
|
||
print(format(0.00003141566,'.2g'))
|
||
# p=2,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
|
||
|
||
print(format(3.1415926777,'.1g'))
|
||
# p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
|
||
print(format(3.1415926777,'.2g'))
|
||
# p=2,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
|
||
print(format(3141.5926777,'.2g'))
|
||
# p=2,exp=3 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
|
||
|
||
print(format(0.00003141566,'.1n')) # 和g相同
|
||
print(format(0.00003141566)) # 和g相同
|
||
```
|
||
|
||
### `repr()`
|
||
|
||
返回一个对象的 string 形式
|
||
|
||
```python
|
||
name = 'EaglesLab'
|
||
print('Hello %r' % name)
|
||
|
||
str1 = '{"name":"EaglesLab"}'
|
||
print(repr(str1))
|
||
print(str1)
|
||
```
|
||
|
||
## 数据结构操作相关
|
||
|
||
### `reversed()`
|
||
|
||
将一个序列翻转，并返回此翻转序列的迭代器。
|
||
|
||
### `slice()`
|
||
|
||
构造一个切片对象，用于列表的切片。
|
||
|
||
```python
|
||
ite = reversed(['a',2,4,'f',12,6])
|
||
for i in ite:
|
||
print(i)
|
||
|
||
l = ['a','b','c','d','e','f','g']
|
||
sli = slice(3)
|
||
print(l[sli])
|
||
|
||
sli = slice(0,7,2) # 也可以加上步长
|
||
print(l[sli])
|
||
```
|
||
|
||
### `len()`
|
||
|
||
返回一个对象中元素的个数。
|
||
|
||
### `sorted()`
|
||
|
||
对所有可迭代的对象进行排序操作。
|
||
|
||
```python
|
||
numbers = [5, 2, 9, 1, 5, 6] # 升序
|
||
sorted_numbers = sorted(numbers)
|
||
print(sorted_numbers) # 输出: [1, 2, 5, 5, 6, 9]
|
||
|
||
numbers = [5, 2, 9, 1, 5, 6] # 降序
|
||
sorted_numbers_desc = sorted(numbers, reverse=True)
|
||
print(sorted_numbers_desc) # 输出: [9, 6, 5, 5, 2, 1]
|
||
|
||
# 可以使用 key 参数指定一个函数，用于从元素中提取用于排序的比较键
|
||
words = ['banana', 'apple', 'cherry']
|
||
sorted_words = sorted(words, key=len)
|
||
print(sorted_words) # 输出: ['apple', 'banana', 'cherry']
|
||
```
|
||
|
||
### `enumerate()`
|
||
|
||
将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
|
||
|
||
```python
|
||
print(enumerate([1,2,3]))
|
||
|
||
for i in enumerate([1,2,3]):
|
||
print(i)
|
||
|
||
for i in enumerate([1,2,3],100):
|
||
print(i)
|
||
```
|
||
|
||
### `all()`
|
||
|
||
可迭代对象中，全都是True才是True。
|
||
|
||
### `any()`
|
||
|
||
可迭代对象中，有一个True 就是True
|
||
|
||
```python
|
||
print(all([1,2,True,0]))
|
||
print(any([1,'',0]))
|
||
```
|
||
|
||
### `zip()`
|
||
|
||
将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
|
||
|
||
```python
|
||
names = ['zhangsan', 'lisi', 'wangwu']
|
||
ages = [25, 30, 35, 40]
|
||
|
||
zipped = zip(names, ages)
|
||
print(list(zipped))
|
||
```
|
||
|
||
### `filter()`
|
||
|
||
过滤序列中不符合条件的元素，返回由符合元素组成的新的迭代器。
|
||
|
||
```python
|
||
def func(x):
|
||
return x % 2 == 0
|
||
ret = filter(func,[1,2,3,4,5,6,7,8,9,10])
|
||
print(ret)
|
||
for i in ret:
|
||
print(i)
|
||
|
||
# 过滤出大于 5 的数字
|
||
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
|
||
filtered_numbers = filter(lambda x: x > 5, numbers)
|
||
print(list(filtered_numbers)) # 输出: [6, 7, 8, 9]
|
||
```
|
||
|
||
### `map()`
|
||
将指定函数应用于可迭代对象中的每个元素，并返回一个迭代器。这个函数非常有用，可以简化对数据的转换和处理。
|
||
|
||
```python
|
||
def square(x):
|
||
return x**2
|
||
|
||
list1 = [1,2,3,4,5,6,7,8]
|
||
|
||
ret = map(square,list1)
|
||
print(ret)
|
||
|
||
for i in ret:
|
||
print(i)
|
||
```
|
||
|
||
# 匿名函数
|
||
|
||
在 Python 中，匿名函数是指没有名称的函数，通常使用 `lambda` 关键字定义。匿名函数可以用于需要函数作为参数的场合，比如在 `map()`、`filter()` 和 `sorted()` 等函数中。
|
||
|
||
也可以理解为，为了解决那些功能很简单的需求而设计的一句话函数。
|
||
|
||
## 语法
|
||
|
||
```python
|
||
lambda 参数: 表达式
|
||
```
|
||
|
||
- 参数可以有多个，用逗号隔开
|
||
- 匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
|
||
- 返回值和正常的函数一样可以是任意数据类型
|
||
|
||
示例：
|
||
|
||
```python
|
||
# 自定义函数的方法
|
||
def func1(n):
|
||
return n ** n
|
||
|
||
print(func1(10))
|
||
|
||
# 换成匿名函数
|
||
func2 = lambda n: n ** n
|
||
print(func2(10))
|
||
```
|
||
|
||
## 案例
|
||
|
||
1. 计算两个数的和
|
||
|
||
```python
|
||
add = lambda x, y: x + y
|
||
print(add(2, 3)) # 输出: 5
|
||
```
|
||
|
||
2. 配合 `map()` 使用
|
||
|
||
```python
|
||
list1 = [1,2,3,4,5,6,7,8]
|
||
|
||
ret = map(lambda x: x ** 2,list1)
|
||
print(ret)
|
||
|
||
for i in ret:
|
||
print(i)
|
||
```
|
||
|
||
3. 配合 `filter()` 使用
|
||
|
||
```python
|
||
ret = filter(lambda x: x % 2 == 0,[1,2,3,4,5,6,7,8,9,10])
|
||
print(ret)
|
||
for i in ret:
|
||
print(i)
|
||
``` |