文章目录
1、内置函数
(1)作用域相关
locals()
和globals()
(2)迭代器/生成器相关
-
iter([可迭代对象])
返回迭代器,和__iter__()
一样 -
next([迭代器])
等同于__next__()
In [1]: l = [1, 2, 3] In [2]: l_iter = iter(l) In [3]: type(l_iter) Out[3]: list_iterator In [4]: next(l_iter) Out[4]: 1 In [5]: next(l_iter) Out[5]: 2 In [6]: next(l_iter) Out[6]: 3 In [7]: next(l_iter) --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-7-43aece5a3964> in <module>() ----> 1 next(l_iter) StopIteration:
(3)其它
-
输入输出
print()
返回Noneinput()
返回字符串
-
内存相关
id()
返回内存地址hash([不可变对象])
返回一串数字,目的是存储()- 实际上字典的键就是以hash值存储的,查找的时候不用遍历,直接根据hash值查找
-
文件操作相关
open()
-
模块相关
__import__("模块")
动态加载模块,即在程序运行期间加载模块
-
帮助
help()
返回帮助文档
-
调用相关
callable([变量])
返回True/False
,查看该变量是否能被调用
-
查看内置属性
dir()
-
字符串类型代码的执行
-
eval()
动态执行一段字符串类型的代码,如s = eval("5 + 6 - 1")
- 服务器和浏览器之间只能传输字符串,如
"{"name":"dream", "age":19}"
- 可以用
eval()
返回,把字符串还原成代码
- 服务器和浏览器之间只能传输字符串,如
-
exec()
动态执行代码,没有返回值 -
complie()
将一个字符串编译成字节代码- 第一个参数,resource,要执行的代码
- 第二个参数,代码存放的文件名,有第一个参数时为空,即
""
- 第三个参数,模式
- 模式1,exec,一帮放一些流程语句
- 模式2,eval,只放一个求值代码
- 模式3,single,代码有交互时使用
-
例子:
In [8]: eval("3*5 - (2+8)/10 + 21") Out[8]: 35.0 In [9]: exec("print('这是exec执行的代码')") 这是exec执行的代码
-
(4)和数字相关
-
数据类型
bool() int() float()
类型转换complex()
创建复数
-
进制转换
bin()
十进制转换为二进制,返回0b···
oct()
十进制转换为八进制,返回0o···
hex()
十进制转换为十六进制,返回0x···
-
数学运算
abs() sum([可迭代对象]) min([可迭代对象]) max([可迭代对象])
divmod()
计算商和余数,如divmod(5, 2)
round()
返回四舍五入后的数据(准确说不是四舍五入,而是另一种更科学的舍入规则,详细请百度)pow()
求次幂,第三个参数为求余数,如pow(2, 3, 5)
-
例子
In [10]: bin(15) Out[10]: '0b1111' In [11]: oct(15) Out[11]: '0o17' In [12]: hex(15) Out[12]: '0xf' In [13]: divmod(17, 4) Out[13]: (4, 1) In [17]: round(2.49, 1) # round的第二个参数是保留位数 Out[17]: 2.5 In [18]: round(2.51, 1) Out[18]: 2.5 In [19]: round(2.55, 1) # 从这个例子中也可以看出round的规则并不是四舍五入 Out[19]: 2.5
(5)数据结构相关
<1>序列相关函数
-
列表和元组
list(), tuple()
创建类型或类型转换
-
相关内置函数
-
reversed([可迭代对象])
返回一个反序的迭代器 -
slice()
列表的切片In [59]: s1 = slice(4) # slice(start=None, stop, step=None),该函数用于确定切片 In [60]: s1 # s1表示按步长为1,从0开始切到3 Out[60]: slice(None, 4, None) In [61]: s2 = slice(2, 8, 2) In [62]: s2 # s1表示按步长为2,从2开始切到7 Out[62]: slice(2, 8, 2) In [66]: lis = list(range(10)) In [67]: lis[s1] Out[67]: [0, 1, 2, 3] In [68]: lis[s2] Out[68]: [2, 4, 6]
-
-
字符串
-
str(), bytes()
创建类型或类型转换 -
bytearray()
字节数组 -
memoryview([bytes])
返回内存地址 -
ord()
输入字符,找到字符的编码位置,如ord("a") # 97
-
chr()
和ord相反 -
assci()
是ASSCI中的字符就返回该字符 -
repr()
原样输出字符串 -
format()
用于格式化-
对字符串格式化,
^(拉长后居中)
,>(右对齐)
,<(左对齐
-
对数值格式化,如
format(10, 'b')
,把10转换为二进制,b(二),o(八),d(十),x(十六进制
-
对浮点数格式化,如
format(123445, 'e')
,科学计数法,默认保留6位小数,e(科学计数法),f(普通小数表示
-
详细请见这个链接
-
-
补充知识:
print(r"string")
原样输出字符串
In [71]: name = 'aaa' In [73]: print(f"My name is {name}") My name is aaa
-
<2>数据集合相关函数
- 字典:
dict()
- 集合:
set()
fronzenset()
使集合不可变
<3>其它相关内置函数
-
len()
计算长度 -
enumerate()
对于列表同时取出索引和数据In [77]: lis = ['a', 'b', 'c'] In [78]: for i, ele in enumerate(lis): ...: print(i, ': ', ele) ...: 0 : a 1 : b 2 : c
-
all()
所有参数相与(只能接受一个参数)In [75]: all([False, True, True, True]) Out[75]: False In [76]: all([True, True, True]) Out[76]: True
-
any()
同all(),所有参数相或 -
zip([可迭代对象])
合并打包,具体用法见例子In [79]: lis1 = [100, 200, 300] In [80]: lis2 = ['a', 'b'] In [81]: lis3 = ['aaa', 'bbb', 'ccc'] In [82]: s = zip(lis1, lis2, lis3) In [83]: for ele in s: ...: print(ele) ...: (100, 'a', 'aaa') (200, 'b', 'bbb') In [84]: lis1 = [100, 200, 300] In [85]: lis2 = ['a', 'b', 'c', 'd'] In [86]: lis3 = ['aaa', 'bbb', 'ccc'] In [87]: s = zip(lis1, lis2, lis3) In [88]: for ele in s: ...: print(ele) ...: (100, 'a', 'aaa') (200, 'b', 'bbb') (300, 'c', 'ccc')
2、特殊函数
(1)lambda匿名函数
-
语法:
lambda 参数: 返回值
- 如
lambda m, n: (m, n) # 返回(m, n)元组
- 如
-
访问函数名字:
__name__
- 如在函数传参中,把函数作为参数传递,可以用
__name__
查看传进来的实参是什么 - 匿名函数的
__name__
都是<lambda>
- 如在函数传参中,把函数作为参数传递,可以用
-
例子
In [1]: def cal(func, a, b): ...: return func(a, b) ...: ...: In [2]: cal(lambda m,n: m+n, 5, 10) Out[2]: 15 In [3]: cal(lambda m,n: m*n, 5, 10) Out[3]: 50 In [4]: func = lambda m,n: m+n # 查看函数的名字 In [5]: func.__name__ Out[5]: '<lambda>' In [9]: def cal(func, a, b): ...: print(func.__name__) ...: return func(a, b) ...: ...: In [8]: def add(a, b): ...: return a+b ...: ...: In [10]: cal(add, 1, 2) add Out[10]: 3 In [11]: cal(lambda m,n: m+n, 1, 2) <lambda> Out[11]: 3
(2)排序函数sorted()
-
sorted([可迭代对象], [key], [reverse=True/False])
key
是一个函数,sorted函数内部会把可迭代对象中的每一个元素拿出来交给后面的key来处理,
key计算出一个数字,把这个数值作为当前这个元素的权重,然后根据权重排序,例子如下
In [18]: lst = ["aaa", "aaaa", "aa", "a"] In [19]: ll = sorted(lst, key=len, reverse=False) #这个例子就是以元素的长度为权重 # 或者可以 ll = sorted(lst, key=lambda s:len(s), reverse=False) In [20]: ll Out[20]: ['a', 'aa', 'aaa', 'aaaa']
(3)过滤函数filter()
-
filter([一个函数], [可迭代对象])
用于过滤数据,返回迭代器,例子如下In [21]: lst = ["a1", "a2", "b1", "b2", "c1"] In [22]: ll = filter(lambda el:el[0] != "a", lst) # filter把lst(可迭代)的元素拿出来传参给lambda,通过返回的bool值进行筛选 In [23]: ll Out[23]: <filter at 0x109dce668> In [25]: list(ll) Out[25]: ['b1', 'b2', 'c1']
(4)映射函数map()
-
map([一个函数], [可迭代对象])
- 可以对可迭代对象的每一个元素进行映射,分别去交给传入的函数执行,map返回函数执行结果(返回迭代器),例子如下
In [31]: lis = [1, 2, 3] In [32]: m = map(lambda x: x*x, lis) In [33]: list(m) Out[33]: [1, 4, 9]
(5)递归(recursion)
-
递归调用存在递归深度(<1000)
-
例子:递归遍历某一文件夹下所有文件(如/tmp/testFotRecursion)
In [34]: import os In [35]: def func(filepath, n): ...: files = os.listdir(filepath) # 列出当前目录下所有文件或文件夹(不递归) ...: for file in files: ...: file_p = os.path.join(filepath, file) # 获取当前文件file的绝对路径 ...: if os.path.isdir(file_p): ...: print("\t"*n, file, ":") ...: func(file_p, n+1) ...: else: ...: print("\t"*n, file_p) ...: In [37]: func("/tmp/testFotRecursion", 1) /tmp/testFotRecursion/file2 dir2 : dir3 : tttt : /tmp/testFotRecursion/dir3/f2 /tmp/testFotRecursion/dir3/f1 /tmp/testFotRecursion/file1 dir1 : /tmp/testFotRecursion/dir1/file222 /tmp/testFotRecursion/dir1/file111