内置函数、匿名函数
一、内置函数
作用域相关：locals()、globals()，点击查看
其他：eval、exec、dir、input、print、hash、open、__import__、compile
- eval和exec都可以执行字符串类型的代码
- eval有返回值：适合有结果的计算
- exec没有返回值：适合流程控制
eval("print(1+2)") # 3 exec("print(1+2)") # 3 print(eval("1+2")) # 3 print(exec("1+2")) # None
dir()：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
# 查看使用方法 print(dir()) print(dir([])) print(dir(str))
input()：函数接受一个标准输入数据，返回为string(字符串)类型。
print()：打印
print(*args, sep = " ", end = "\n", file = sys.stdout, flush = False) # 将对象打印到文本流文件，以sep分隔，然后结束。sep，end，file和flush（如果存在）必须作为关键字参数给出。 sep： 打印多个值之间的分隔符，默认为空格 end： 每一次打印的结尾，默认为换行符 file： 默认是输出到屏幕，如果设置为文件句柄，输出到文件 flush：立即把内容输出到流文件，不作缓存 print("AB", "CD", sep="|") #AB|CD print(11, end="") print(22) #1122 print(11, end=" ") print(22) #11 22 with open("1.txt", "w", encoding="utf-8") as f: print(11, 22, sep="-", file=f, flush=True) # 文件里写入了11-22
# 打印进度条 import time for i in range(0, 101, 2): time.sleep(0.1) symbol_num = i // 2 progress_str = "\r{}% {}\n".format(i, "#"*symbol_num) if i == 100 else "\r{}% {}".format(i, "#"*symbol_num) print(progress_str, end=" ") # 100% ##################################################
hash(object)：返回object的哈希值（如果有的话）
print(hash(123)) # 123 print(hash("pd")) # 1092457194709355922 print(hash(True)) # 1 print(hash(False)) # 0 print(hash((1, 2, 3))) # 2528502973977326415 # print(hash([1, 2, 3]))# 不可哈希，报错
open()：打开文件并返回相应的文件对象，比如返回给句柄f。
compile()：compile(source，filename，mode)
source
# 字符串或者AST（Abstract Syntax Trees）对象 filename
# 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可 model
# 指定编译代码的种类，可以指定为'eval','exec','single'；当source中只包含一个简单的求值表达式，model应指定为'eval'；当source中包含流程语句时，model应指定为'exec'；当source中包含了交互式命令语句，model应指定为'single'
# 简单求值用eval s = "1 + 2" c = compile(s, "", "eval") print(eval(c)) # 3 # 流程语句使用exec s= "for i in range(1, 6):print(i)" c = compile(s, "", "exec") print(eval(c)) # 交互语句用single c = "name = input('please input your name：')" c = compile(c, "", "single") # print(name) # exec(c)执行前，name变量还没被定义，报错 exec(c) # 执行时显示交互命令，提示输入 print(name) # exec(c)执行后，name变量有值
迭代器、生成器：range、next、iter
range()：创建一个整数对象，一般用在 for 循环中
iter(iterable)：将可迭代对象转化为迭代器
from collections import Iterable from collections import Iterator
lis1 = [1,2,3] print(isinstance(lis1,Iterable)) # True print(isinstance(lis1,Iterator)) # False
lis2 = iter(lis1) print(isinstance(lis2,Iterable)) # True print(isinstance(lis2,Iterator)) # True
next()：从迭代器中一个一个地取值
ret = iter([1, 2, 3]) print(next(ret)) # 1 print(next(ret)) # 2
基础数据类型：有一些未记录
float()：用于将整数和字符串转换成浮点数
complex()：用于创建一个值为 real + imag*j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数
print(complex(1, 2)) # (1+2j) print(complex(1)) # (1+0j) print(complex("1")) # (1+0j)
二进制(bin)、八进制(oct)、十六进制(hex)
print(bin(10), type(bin(10))) # 0b1010 <class 'str'> print(oct(10), type(oct(10))) # 0o12 <class 'str'> print(hex(10), type(hex(10))) # 0xa <class 'str'>
abs()：求绝对值
print(abs(-5)) # 5
divmod()：除余
print(divmod(7,2)) --> 7除以2，得3余1 print(divmod(9,5)) --> 9除以5，得1余4 #(3, 1) #(1, 4)
pow()：幂运算
print(pow(2, 3)) # 幂运算，2的3次方 print(pow(2, 3, 3)) # 幂运算之后再取余数，即2*2*2/3余2 #8 #2
round()：小数精确度
print(round(3.1415, 2)) # 3.14 print(round(3.1415, 3)) # 3.142 print(round(3.1414, 3)) # 3.141
sum()：对可迭代对象进行求和计算（可设置初始值）
print(sum([1, 2])) # 3 print(sum((1, 2), 100)) # 103
min()：返回可迭代对象的最小值（参数key为函数名，通过函数的规则，返回最小值）
max()：返回可迭代对象的最大值（参数key为函数名，通过函数的规则，返回最大值）
print(min([1, 2, 3])) print(min([-1, 4, 6], key=abs)) # key=abs 按绝对值比较大小，然后返回本来的值 # 1 # -1
list()：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）
print(list((1, 2, 3))) # [1, 2, 3] print(list({"k1": 1, "k2": 2})) # ['k2', 'k1']
tuple()：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）
print(tuple((1, 2, 3))) # (1, 2, 3) print(tuple({"k1": 1, "k2": 2})) # ('k1', 'k2')
reversed()：返回反向迭代器
lis1 = [1, 2, 3, 4, 5] lis2 = reversed(lis1) print(lis2) # <list_reverseiterator object at 0x0000000000B7B2B0> for i in lis2: print(i)
slice()：返回表示由指定的索引集的切片对象
l = (1,2,3,4,5,6,7) s = slice(1, 5, 2) print(l[s]) # (2, 4) print(l[1:5:2]) # (2, 4)
format()：将值转换为“格式化”表示
# 字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐 print(format("xx", "<20")) print(format("xx", ">20")) print(format("xx", "^20"))
bytes()：返回一个新的"bytes"对象
print(bytes("你好", encoding="GBK")) # unicode转换成GBK的bytes print(bytes("你好", encoding="utf-8")) # unicode转换成utf-8的bytes
memoryview()：返回从给定参数创建的"内存视图"对象
ret = memoryview(bytes("你好", encoding="utf-8")) print(len(ret)) # 6 print(bytes(ret[:3])) # b'\xe4\xbd\xa0' print(bytes(ret[:3]).decode("utf-8")) # 你
ord()：字符按unicode转数字
chr()：数字按unicode转字符
print(chr(48)) # 0 print(chr(49)) # 1 print(ord("A")) # 65 print(ord("a")) # 97 print(chr(65)) # A print(chr(97)) # a
repr()：返回包含对象的可打印表示的字符串
s = "xxx" print("%r" % s) # 'xxx' print(repr("1"), type(repr("1"))) # '1' <class 'str'> print(repr(1), type(repr(1))) # 1 <class 'str'>
frozenset()：让集合变成不可变类型
s = frozenset("abcd") print(s, type(s)) # frozenset({'c', 'a', 'd', 'b'}) <class 'frozenset'>
enumerate(iterable，start = 0)：返回一个枚举对象（从start开始，默认为0）
lis = ["my", "name", "is", "pd"] for i, item in enumerate(lis): print(i, item) # 0 my # 1 name # 2 is # 3 pd for i, item in enumerate(lis, 1): print(i, item) # 1 my # 2 name # 3 is # 4 pd
all()：可迭代对象中，有一个False就是False
any()：可迭代对象中，有一个True就是True
print(all([0, 1])) # False print(any([0, 1])) # True
zip()：函数用于将可迭代的对象作为参数，将对象与对象之间对应的元素打包成一个元组。如果各个对象的元素个数不一致，则返回元祖的长度与最短的对象相同。
lis1 = [1, 2, 3] lis2 = ["a", "b", "c"] lis3 = {"k1": 11, "k2": 22} for i in zip(lis1, lis2, lis3): print(i) # (1, 'a', 'k1') # (2, 'b', 'k2')
filter(function, iterable)：过滤、返回一个迭代器
def func(x): return x % 2 == 1 ret = filter(func, [1, 2, 3, 4, 5, 6]) # 删除偶数，保留奇数 for i in ret: print(i) # 相当于print([i for i in [1, 2, 3, 4, 5, 6] if i % 2 == 1]) # 利用filter()删除None和空字符串 def func(s): return s and len(s.strip()) > 0 ret = filter(func, ["a", None, "", "1"]) for i in ret: print(i) # 求100以内的开平方 import math def func(x): return math.sqrt(x) % 1 == 0 ret = filter(func, range(1, 101)) for i in ret: print(i)
map(function, iterable)：返回一个迭代器
ret = map(abs, [1, -4, 6, -8]) for i in ret: print(i) # 1 # 4 # 6 # 8
filter()：执行了filter之后的结果集合 <= 执行之前的个数
filter只管筛选，不会改变原来的值
map()：执行前后元素个数不变，值可能发生改变
sorted(iterable, key=None, reverse=False)：临时排序，sort()为永久排序
# 参数key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序 lis = [1, -3, 4, -6, 5, -2] print(sorted(lis, key=abs, reverse=True)) # 取绝对值，再反向排序 print(lis) # 证明sorted()为临时排序 # [-6, 5, 4, -3, -2, 1] # [1, -3, 4, -6, 5, -2]
二、匿名函数
lambda：为了解决那些功能很简单的需求而设计的一句话函数
格式：函数名 = lambda 参数：返回值
- 参数可以有多个，用逗号隔开
- 匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
- 返回值和正常的函数一样可以是任意数据类型
def add(x, y): return x + y print(add(1, 2)) # 3 # 换成匿名函数 add = lambda x, y: x + y print(add(1, 2)) # 3
# 求字典中最大值对应的键 dic = {"k1": 10, "k2": 20, "k3": 30} def func(k): return dic[k] ret = max(dic, key=func) print(ret) # k3 # 换成匿名函数 print(max(dic, key=lambda k:dic[k])) # k3
现有两个元组(("a"), ("b")),(("c"), ("d"))，使用匿名函数生成列表[{"a": "c"}, {"b": "d"}]
ret1 = zip((("a"),("b")),(("c"),("d"))) def func(tup): return {tup[0],tup[1]} ret2 = map(func, ret1) print(list(ret2)) # [{'c', 'a'}, {'d', 'b'}] ret3 = map(lambda tup:{tup[0]:tup[1]}, ret1) print(list(ret3)) # []
