Cloud-book/Python/Python面向函数/内置函数与匿名函数.md

内置函数

截止到python版本3.9.22，python一共为我们提供了69个内置函数。

https://docs.python.org/zh-cn/3.9/library/functions.html

作用域相关

locals()

函数会以字典的类型返回当前位置的全部局部变量。

globals()

函数以字典的类型返回全部全局变量。

示例

a = 1
b = 2

print(locals())
print(globals())

# 这两个一样，因为是在全局执行的

def func(argv):
    c = 2
    print(locals())
    print(globals())

func(3)

字符串类型代码执行

eval()

计算指定表达式的值，并返回最终结果

ret = eval('2 + 2')
print(ret)

n = 20
ret = eval('n + 23')
print(ret)

eval('print("Hello world")')

exec()

执行字符串类型的代码

s = '''
for i in range(5):
    print(i)
'''

exec(s)

compile()

用于将源代码编译成字节码，从而可以在后续执行中使用。这个函数的主要作用是将字符串形式的代码转换为可以通过 exec() 或 eval() 执行的代码对象。

语法

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

参数

• source：要编译的源代码，可以是字符串或 AST（抽象语法树）对象。
• filename：表示代码的文件名（通常为字符串），用于错误消息的显示。可以是任意字符串。
• mode：指定编译模式
  • 'exec' ：用于编译多条语句（如模块或函数）。
  • 'eval' ：用于编译单个表达式。
  • 'single' ：用于编译单个交互式语句。

返回值

返回一个代码对象，可以使用 exec() 或 eval() 执行

示例

# 流程语句使用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()

打印输出。

''' 源码分析
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）的哈希值。

print(hash(12322))
print(hash('123'))
print(hash('arg'))
print(hash('aaron'))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))

id()

用于获取对象的内存地址

print(id('abc'))
print(id('123'))

文件操作相关

open()

用于打开一个文件，创建一个 file 对象

read()

通过文件对象调用，读取文件的内容

write()

文件文件对象调用，往文件里下入内容

.......

帮助文档

help()

函数用于查看函数或模块用途的详细说明。

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 绝对不会成功。

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__() ，该方法将最大限度地收集参数信息。

import time
print(dir(time))        # 查看某个模块的属性和方法

print(dir([]))          # 查看列表的属性和方法

迭代器生成器相关

range()

函数可创建一个整数对象，一般用在 for 循环中。

next()

内部实际使用了 __next__ 方法，返回迭代器的下一个项目。

iter()

函数用来生成迭代器（通过一个可迭代对象生成迭代器）。

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 是虚数单位。

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()

将十进制转化成十六进制字符串并返回。

示例

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)

示例

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 为函数名，通过函数的规则，返回最大值）。

示例

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()

创建一个冻结的集合。

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()

具体数据相关，用于计算各种小数，精算等。

# 字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
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 形式

name = 'EaglesLab'
print('Hello %r' % name)

str1 = '{"name":"EaglesLab"}'
print(repr(str1))
print(str1)

数据结构操作相关

reversed()

将一个序列翻转，并返回此翻转序列的迭代器。

slice()

构造一个切片对象，用于列表的切片。

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()

对所有可迭代的对象进行排序操作。

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 循环当中。

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

print(all([1,2,True,0]))
print(any([1,'',0]))

zip()

将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

names = ['zhangsan', 'lisi', 'wangwu']
ages = [25, 30, 35, 40]

zipped = zip(names, ages)
print(list(zipped)) 

filter()

过滤序列中不符合条件的元素，返回由符合元素组成的新的迭代器。

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()

将指定函数应用于可迭代对象中的每个元素，并返回一个迭代器。这个函数非常有用，可以简化对数据的转换和处理。

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() 等函数中。

也可以理解为，为了解决那些功能很简单的需求而设计的一句话函数。

语法

lambda 参数: 表达式

• 参数可以有多个，用逗号隔开
• 匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
• 返回值和正常的函数一样可以是任意数据类型

示例：

# 自定义函数的方法
def func1(n):
	return n ** n

print(func1(10))

# 换成匿名函数
func2 = lambda n: n ** n
print(func2(10))

案例

1. 计算两个数的和

add = lambda x, y: x + y
print(add(2, 3))  # 输出: 5

2. 配合 map() 使用

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() 使用

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)