python之内置函数，匿名函数，递归函数
一. 内置函函数
什么是内置函数？就是Python给你提供的，拿来直接用的函数，比如print，input等等。截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。它们就是python提供给你直接可以拿来使用的所有函数。这些函数有些我们已经用过了，有些我们还没用到过，还有一些需要学完面向对象才能继续学习的。今天我们就一起来认识一下python的内置函数。
函数分类：
https://www.processon.com/mindmap/5c459eb7e4b0fa03cea19d8f
作用域相关：
locals() 返回当前作用域中的变量
globals() 返回全局作用域中的变量
a = "lishichao" b = "123" print(locals()) print(globals()) print(globals() is locals()) #True 这两个一样，因为是在全局执行的。 def func(): c = "lishichao" print(globals() is locals()) func() #False
迭代器相关:
range() 生成数据
next() 迭代器向下执行一次, 内部实际使用了__next__()方法返回迭代器的下一个项目
iter()
lst = ["宅", "上班", "加班", "坐地铁", "睡觉"] # 获取迭代器 it1 = lst.__iter__() # 类的特殊成员,特定的场景固定的调用方式 # print(it1) it2 = iter(lst) # 内部执行的就是__iter__() # print(it2) # 迭代器向下执行一次 print(it1.__next__()) print(next(it2))
输入和输出相关:
input() 获取用户输入的内容
print() 打印输出
内存相关:
hash() 获取到对象的哈希值(int, str, bool, tuple)
print(hash("哈哈哈")) # 哈希值就是一个数字 print(hash(456)) # 数字的哈希值就是它本身
id() 获取到对象的内存地址
a = "123" b = a print(id(a)) print(id(b))
文件操作相关:
open() 用于打开一个文件, 创建一个文件句柄
模块相关:
__import__() 用于动态加载类和函数
# import os 正常导入 mokuai = input("请输入你要导入的模块") __import__(mokuai) #动态导入
帮助：
help() 函数用于查看函数或模块用途的详细说明
>>> print(help(str)) # 在命令行模式下，查看帮助信息 Help on class str in module __builtin__:
调用相关:
callable() 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功
# # callable 判断你给的参数是否可以被调用 def func(fn): if callable(fn): # 判断你传进来的这个东西能不能+() print("哈哈哈哈哈") fn() print("哇哈哈哈哈哈") else: print("不可以被调用") def chi(): print("吃自助餐了") foo = "123" func(chi) #可以被调用 func(foo) #不可以被调用
查看内置属性:
dir() 查看对象的内置属性, 方法. 访问的是对象中的__dir__()方法
print(dir(str))
基础数据类型相关:
数字相关:
bool() 将给定的数据转换成bool值. 如果不给值. 返回False
print(bool(2)) # True print(bool(0)) # False a = "" b = " " print(bool(a)) # False print(bool(b)) # True # 所有的空都为False
int() 将给定的数据转换成int值. 如果不给值, 返回0
float() 将给定的数据转换成float值. 也就是小数
complex() 创建一个复数. 第一个参数为实部, 第二个参数为虚部. 或者第一个参数直接用字符串来描述复数
进制转换:
bin() 将给的参数转换成二进制
otc() 将给的参数转换成八进制
hex() 将给的参数转换成十六进制
a = 0b101 # 二进制 print(a) a = 0o11 # 八进制 print(a) a = 0x12 # 十六进制 print(a) print(bin(5)) # 二进制 0b101 print(oct(9)) # 八进制 0o11 print(hex(18)) # 十六进制 0x12
数学运算:
abs() 返回绝对值
divmode() 返回商和余数
round() 四舍五入
# 保留两位小数 print(round(0.456,2))
# 执行结果: 0.46
pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余
sum() 求和
min() 求最小值
max() 求最大值
和数据结构相关:
列表和元组:
list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
reversed() 将一个序列翻转, 返回翻转序列的迭代器
lst = ["宅", "上班", "加班", "坐地铁", "睡觉"] print(reversed(lst)) <list_reverseiterator object at 0x00000000021D39B0>
slice() 切片，多个数据都需要固定的切片时。
s = "你好啊, 我叫周杰伦" ss = "巴拉巴拉巴拉巴拉巴拉" sss = "哈哈进口红酒客户" s1 = slice(2, 9) print(s[s1]) print(ss[s1]) print(sss[s1])
字符串相关:
format() 与具体数据相关, 用于计算各种小数, 精算等
print(format(1.23456789, ".2f")) # 保留小数点2位 print(format(10.000000000000000005, ".2f")) print(format(10/3, ".3")) # 保留小数点2位
bytes() 把字符串转化成bytes类型
s = "你好" bs = s.encode("UTF-8") print(bs) s1 = bs.decode("UTF-8") print(s1) bs = bytes(s, encoding="utf-8") # 把字符串编码成UTF-8 print(bs)
bytearray() 返回一个新字节数组. 这个数字里的元素是可变的, 并且每个元素的值得范围是[0,256)
ret = bytearray('lishichao',encoding='utf-8') print(ret[0]) print(ret)
memoryview() 查看bytes在内存中的情况
s = memoryview("麻花藤".encode("utf-8")) print(s) #<memory at 0x00000000023D6288>
ord() 输入字符找到字符编码的位置
chr() 输入位置数字找出对应的字符
print(ord("中")) #找到对应字符的编码位置 20013 print(chr(20013)) # 找到对应编码位置的字符 for i in range(65536): print(chr(i), end=" ") # 打印0-65536编码位置的字符
ascii() 是ascii码中的返回该值 不是就返回\u....
s = "金角大王吧" print(ascii(s)) # 判断你的文字是否是ascii范畴得 内容 s1 = "abc" print(ascii(s1)) # '\u91d1\u89d2\u5927\u738b\u5427' # 'abc'
repr() 返回一个对象的官方表示形式
# s = "哈哈哈哈" # => 变成C里面的字符串 # print(s) # print(repr(s)) # 把字符串还原回最应该显示的样子 # s = "哈\哈哈" # \ 转义 \n \t \\ \" \' # print(s) # print(repr(s)) # s = "胡辣汤\\n蝙蝠侠" # print(s) # print(repr(s)) # print(r"") # 原样输出 => 和repr没关系 # print(r"哈\n\\\n\]\\\\\\\\n哈\t哈") # 正则表达式 # 很重要 # 1. str 普通字符串 # 2. repr 还原最官方的字符串 # 3. r"" 原样输出
str() 将数据转换成字符串
数据集合：
dict() 创建一个字典
set() 创建一个集合
frozenset() 创建一个冻结的集合. 冻结的集合不能进行添加和删除操作
s = {1,2,3} # 不可哈希. 因为可变
s.add(4)
s.add("刘老根")
print(s)
s = frozenset({1,2,3})
print(hash(s)) # 可哈希,因为不可变
# list => tuple
# set => fronzenset
其他相关:
len() 返回一个对象中的元素的个数
for i in range(len(lst)): print(i, lst[i])
for i in enumerate(lst): print(i) # 拿到的是元祖 (0, '刘老根') (1, '药匣子') (2, '马大帅') (3, '西游记') 元祖解包： for i, el in enumerate(lst, 100): #第二个参数，可以指定从多少开始 print(i, el)
#执行结果:
101 药匣子
102 马大帅
103 西游记
# all print(all([0, 1, "哈哈哈", '呵呵呵'])) # and # any print(any([0, None, True, []])) # or if any([5>8, 3 > 5, 1 < 0]): pass if 5 > 8 or 3 > 5 or 1 < 0: pass
zip() # 拉链
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
lst1 = ["赵本山", "范伟", "于月仙"] lst2 = ["相亲", "卖拐"] lst3 = [28, 60, 50] z = zip(lst1, lst2, lst3) # 水桶效应 print(z) # <zip object at 0x00000000029632C8> for el in z: print(el) #执行结果: # ('赵本山', '相亲', 28) # ('范伟', '卖拐', 60)
sorted() 对可迭代对象进行排序操作(讲完lamda后再讲这个)
filter() 过滤(讲完lamda)
map() 会根据提供的函数对指定序列做映射(lamda)
字符串类型代码的执行：
eval() 执行字符串类型的代码. 并返回最终结果
print(eval("2+2")) # 4 n = 8 print(eval("2+n")) # 10 def func(): print(666) eval("func()") # 666
# evel使用：
#把字典直接写到文件 lst = [{"name":"电脑", "price":1999}, {"name":"鼠标", "price":10}, {"name":"波多老师", "price":99999}, {"name":"七天", "price":123456}] # f = open("商品.txt", mode="a", encoding="utf-8") for el in lst: f.write(str(el)+"\n") f.flush() f.close() # 读取，使用eval直接读取文件中字典 f = open("商品.txt", mode="r", encoding="utf-8") for line in f: #每一行的数据 {'name': '电脑', 'price': 1999} s = line.strip() d = eval(s) # {'name': '电脑', 'price': 1999} => 字典 print(d) print(d['name'])
exec() 执行字符串类型的代码
exec(""" for i in range(10): print(i) """) exec(""" def func(): print("我是周杰伦") func() """)
compile() 将字符串类型的代码编译. 代码对象能够通过exec语句来执行或者eval()进行求值
''' 参数说明: 1. resource 要执行的代码, 动态代码片段 2. 文件名, 代码存放的文件名, 当传入了第一个参数的时候, 这个参数给空就可以了 3. 模式, 取值有3个, 1. exec: 一般放一些流程语句的时候 2. eval: resource只存放一个求值表达式. 3. single: resource存放的代码有交互的时候. mode应为single ''' code1 = "for i in range(10): print(i)" c1 = compile(code1, "", mode="exec") exec(c1) code2 = "1+2+3" c2 = compile(code2, "", mode="eval") a = eval(c2) print(a) code3 = "name = input('请输入你的名字:')" c3 = compile(code3, "", mode="single") exec(c3) print(name)
有返回值的字符串形式的代码用eval(). 没有返回值的字符串形式的代码用exec(). 一般很少用到compile()
二. lamda匿名函数
为了解决一些简单的需求而设计的一句话函数
# 计算n的n次方 def func(n): return n**n print(func(10)) f = lambda n: n**n print(f(10))
lambda表示的是匿名函数. 不需要用def来声明, 一句话就可以声明出一个函数
语法:
函数名 = lambda 参数: 返回值
注意:
1. 函数的参数可以有多个. 多个参数之间用逗号隔开
2. 匿名函数不管多复杂. 只能写一行, 且逻辑结束后直接返回数据
3. 返回值和正常的函数一样, 可以是任意数据类型
匿名函数并不是说一定没有名字. 这里前面的变量就是一个函数名. 说他是匿名原因是我们通过__name__查看的时候是没有名字的. 统一都叫 lambda. 在调用的时候没有什么特别之处.像正常的函数调用即可。
一般都配合下面三个函数一起使用。
# 逻辑排序题
lst = [0,2,-3,8,7,-5,-7] # 结果 # [0,2,7,8,-3,-5,-7] # print(sorted(lst, key=lambda x:__________)) print(sorted(lst, key=lambda x:x if x >= 0 else abs(x) + 10))
sorted()
排序函数. 语法: sorted(Iterable, key=None, reverse=False) Iterable: 可迭代对象 key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序 reverse: 是否是倒叙. True: 倒叙, False: 正序(默认 从小到大排序) lst = [1,5,3,4,6] lst2 = sorted(lst,reverse=True) print(lst) # 原列表不会改变 print(lst2) # 返回的新列表是经过排序的 dic = {1:'A', 3:'C', 2:'B'} print(sorted(dic)) # 如果是字典. 则返回排序过后的key # 和函数组合使用 # 根据字符串长度度进行排序 lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"] # 计算字符串长度 def func(s): return len(s) print(sorted(lst, key=func)) # 和lambda组合使用 # 根据字符串⻓度进⾏排序 lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"] # 计算字符串度 def func(s): return len(s) print(sorted(lst, key=lambda s: len(s))) lst = [{"id":1, "name":'alex', "age":18}, {"id":2, "name":'wusir', "age":16}, {"id":3, "name":'taibai', "age":17}] # 按照年龄对学生信息进行排序 print(sorted(lst, key=lambda e: e['age']))
filter()
筛选函数
语法: filter(function. Iterable)
function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留此项数据
Iterable: 可迭代对象
lst = [1,2,3,4,5,6,7] ll = filter(lambda x: x%2==0,lst) #筛选所有的偶数,返回的是一个迭代器 print(ll) print(ll.__next__()) print(list(ll))
lst = [{"id":1, "name":'alex', "age":18}, {"id":2, "name":'wusir', "age":16}, {"id":3, "name":'taibai', "age":17}] fl = filter(lambda e: e['age'] > 16, lst) # 筛选年龄大于16的数据 print(list(fl))
# filter 把可迭代对象进行迭代. 把每一项数据传递给前面的函数. 根据函数返回的true和false来决定该元素是否保留
map()
映射函数
语法: map(function, iterable) 可以对可迭代对象中的每一个元素进行映射. 分别去执行function
计算列表中每个元素的平方 ,返回新列表
def func(e): return e * e lst = [1,2,3,4,5] mp = map(func,lst) print(mp) print(list(mp)) # <map object at 0x00000000023C3BA8> # [1, 4, 9, 16, 25]
改写成lambda
mp = map(lambda x:x * x,lst) for el in mp: print(el)
计算两个列表中相同位置的数据的和
lst1 = [1, 2, 3, 4, 5] lst2 = [2, 4, 6, 8, 10] mp = map(lambda x, y: x+y, lst1, lst2) for el in mp: print(el)
# 把可迭代对象中每一项传递给前面的函数. 函数执行的结果作为整个运算的结果
二. 递归函数
在函数中调用函数本身. 就是递归。
def func(): print("我是谁") func() func()
在python中递归的深度最大到998
def foo(n): print(n) n += 1 foo(n) foo(1)
递归的应用:
我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统. 可以使用递归来遍历该文件夹中的所有文件。
# 递归的一个应用: 遍历文件夹 import os def read_dir(s, n): # 1. 打开这个文件夹 lst = os.listdir(s) # 打开文件夹. 拿到文件 for el in lst: # 拿到的都是文件的名字 # 2. 拼接出文件的路径 real_path = os.path.join(s, el) # D:\25期周末班\a\b print("----"*n, el) # 打印文件名字 # 3. 判断是否是文件夹 if os.path.isdir(real_path): read_dir(real_path, n + 1) # 递归的入口 else: pass # open(real_path, mode="w", encoding="utf-8").write(1) read_dir(r"c:\\", 0)
