匿名函数
lambda x: x + 1
# lambda:定义匿名函数的关键字
# x：形参
# x+1：程序处理逻辑
fun = lambda x: x + 1
print(fun(5))
#6
fun = lambda name: name + "_new"
print(fun("Cindy"))
#Cindy_new
注意：
1、匿名函数一般不会单独使用，而是与其他函数配合使用
2、匿名函数的程序处理逻辑简单，不可以使用多行
fun = lambda x, y, z: (x + 1, y + 1, z + 1)
print(fun(1, 3, 5))
# (2, 4, 6)
函数式编程
编程的方法论：
1、面向过程：找到解决问题的入口，按照一个固定的流程去模拟解决问题的流程
2、函数式编程：编程语言定义的函数+数学意义的函数，即用编程语言去实现数学函数，返回值是函数，没有for和while循环，所有循环使用递归实现。
特点：a.不可变数据：不用变量保存状态，不修改变量 b.第一类对象：函数即“变量” c.尾调用优化（尾递归）：在函数的最后一步（不一定是最后一行）进行递归
def test1(x):
return x
def test2(y):
return test1(y) + 1 #不是尾递归
# 拆解：res = test1(y)
# return res + 1
3、面向对象
高阶函数
满足下列任一要求即为高阶函数：
1、函数的传入参数是一个函数名
2、函数的返回值是一个函数名
map函数
def plus_one(x):
return x + 1
def minis_one(x):
return x - 1
def square(x):
return x**2
def map_test(func,num) :
nl = []
for i in num:
nl.append(func(i))
return nl num = [1,2,3,4,5]
nl = map_test(square,num)
print(nl)
# [1, 4, 9, 16, 25]
nl1 = map_test(plus_one,num)
print(nl1)
# [2, 3, 4, 5, 6]
也可以写成
plus_one = lambda x: x + 1
minis_one = lambda x: x - 1
square = lambda x: x**2
def map_test(func,num) :
nl = []
for i in num:
nl.append(func(i))
return nl num = [1,2,3,4,5]
nl = map_test(square,num)
print(nl)
# [1, 4, 9, 16, 25]
nl1 = map_test(plus_one,num
print(nl1)
# [2, 3, 4, 5, 6]
最好的写法：
def map_test(func,num) :
nl = []
for i in num:
nl.append(func(i))
return nl num = [1,2,3,4,5]
nl = map_test(lambda x: x + 1,num)
print(nl)
# [2, 3, 4, 5, 6]
map函数
功能：依次处理序列中的每个元素，得到的结果是一个“列表”，该“列表”元素个数及位置与原来一样
注意：得到的结果并不是真正的列表
num = [1, 2, 3, 4, 5]
res = map(lambda x: x + 1, num)
print(res)
#<map object at 0x000002205AF765C0>
print(list(res))
# [2, 3, 4, 5, 6]
map的第一个参数是处理逻辑，第二个参数是可迭代对象，得到的结果是一个可迭代对象
str = "hello"
res = map(lambda x: x.upper(), str)
print(list(res))
#['H', 'E', 'L', 'L', 'O']
print(res)
# <map object at 0x000002672E8282E8>
filter函数
功能：遍历序列中的每个元素，判断每个元素得到布尔值，True的元素保留下来，否则过滤掉
filter的第一个参数是处理逻辑，第二个参数是可迭代对象，得到的结果是一个可迭代对象
前一个参数得到的结果是布尔值，是True则保留，是False则过滤掉，可以在处理逻辑处＋not来反过滤
array = ["Allen", "Leo", "jennifer"]
res = filter(lambda x: x.istitle(), array)
print(res)
# <filter object at 0x00000291B3981470>
print("英文人名有：",list(res))
# 英文人名有： ['Allen', 'Leo']
也可以处理其他的
people = [
{"name":"A","age":9000},
{"name":"B","age":900},
{"name":"C","age":18},
{"name":"D","age":50}
]
res = filter(lambda x: x["age"] < 100, people)
print(list(res))
# [{'name': 'C', 'age': 18}, {'name': 'D', 'age': 50}]
reduce函数
功能：把所有数据合并
num = [1,2,3,100]
def reduce_test(func,num):
res = 1
for i in num:
res = func(i,res)
return res
res = reduce_test(lambda x,y: x * y, num)
print(res)
#
指定一个倍数
num = [1,2,3,100]
def reduce_test(func,num,initial = None):
if initial == None:
res = 1
else:
res = initial for i in num:
res = func(i,res)
return res
res = reduce_test(lambda x,y: x * y, num, 10)
print(res)
#
reduce函数
from functools import reduce num = [1, 2, 3, 100]
res = reduce(lambda x, y: x * y, num, 10)
print(res)
#
注意：map和reduce适合共同在大数据中使用
内置函数
abs() 绝对值
all() 判断内部所有元素的布尔值为Ture则Ture，否则假
注意：如果可迭代对象是空的返回True
any() 判断内部元素的布尔值有一个为Ture则Ture，否则假
bin() 十进制转成二进制
hex() 十进制转十六进制
oct() 十进制转八进制
bool() 求布尔值
注意：None，空，0的布尔值为False
bytes(）转换成字节，需要指定编码
name = "你好"
print(bytes(name,encoding = "utf-8"))
# b'\xe4\xbd\xa0\xe5\xa5\xbd'
.decode() 按指定编码方式解码
print(bytes(name,encoding = "utf-8").decode("utf-8"))
# 你好
dir() 打印某一对象的方法，但不解释
help() 打印方法且详细解释
divmod(a,b) a除b的商并取余
a = divmod(10,3)
print(a)
#(3, 1)
eval() 把字符串中的数据结构提取出来、把字符串中的数学运算计算出来
hash() 得出固定值，不能根据得到结果反推原数据，只要数据不变则得到结果不变
hashable即不可变数据类型，unhashable即可变数据类型
name = "aff"
print("old_value:",hash(name))
print(hash(name))
print(hash(name))
name = "s"
print("new_value:",hash(name))
# old_value: 9152753171858710842
# 9152753171858710842
# 9152753171858710842
# new_value: -4828918846689666711
isinstance() 判断是否是类型
print(isinstance(1,int))
print(isinstance(1.11,float))
print(isinstance("",int))
print(isinstance("",str))
print(isinstance([],list))
# True
# True
# False
# True
# True
globals() 打印全局变量（包括系统提供的）
locals() 打印局部变量
zip() 按照一一对应的关系生成一个个元组，两边长度不一致时从左到右取较短相同长度的元素
print(zip(("a","b","c"),(1,2,3)))
#<zip object at 0x00000289A9C7E148>
print(list(zip(("a","b","c"),(1,2,3))))
#[('a', 1), ('b', 2), ('c', 3)]
print(list(zip(("a","b","c","d"),(1,2,3))))
#[('a', 1), ('b', 2), ('c', 3)]
print(list(zip(("a","b","c"),(1,2,3,4))))
#[('a', 1), ('b', 2), ('c', 3)]
只要传入的两个值都是有序列的即可
p = {"name":"Jenny","age":18,"gender":"female"}
print(list(zip(p.keys(),p.values())))
#[('name', 'Jenny'), ('age', 18), ('gender', 'female')]
print(list(zip("hello","")))
# [('h', '1'), ('e', '2'), ('l', '4'), ('l', '5'), ('o', '4')]
max()取最大值 min()取最小值
对字典比较默认比key，从左到右一一比较
l = {"A_age":18,'B_age':89,"C_age":50,"D_age":30}
m_list = list(zip(l.values(),l.keys()))
print(m_list)
print(max(m_list))
# [(18, 'A_age'), (89, 'B_age'), (50, 'C_age'), (30, 'D_age')]
# (89, 'B_age')
从元素的第一位往后比值，一旦有一位是最大的，后面不再比较
d = {"a10","a8","a03"}
print(max(d))
#a8 第一位一样，比第二位，8>1>0,直接得出最大值，后面不比了
可以指定比较逻辑
ages = [
{"name": "a", "age": 18},
{"name": "b", "age": 50},
{"name": "c", "age": 99}]
print(max(ages, key=lambda dic: dic["age"]))
# {'name': 'c', 'age': 99}
sorted() 升序排序，用法与max()类似
注意：排序本质就是比较大小，同类型之间才可以比较
prices = {
"a": 900,
"b": 800,
"c": 1000
}
print(sorted(prices, key=lambda key: prices[key]))
# ['b', 'a', 'c']
print(sorted(zip(prices.values(), prices.keys())))
# [(800, 'b'), (900, 'a'), (1000, 'c')]
ord() 打印出ASCII码字母代表的数字
chr() 打印出ASCII码数字代表的字母 pow()
print(chr(97))
print(ord("a"))
# a
#
pow()
pow(a,b) 求a^b
pow(a,b,c) 求a^b%c
reversed() 反转
反转后没有保存
round() 四舍五入
set() 变成集合
slice()切片
主要为了提高程序的可读性，可以指定步长
m = "hello"
s = slice(3,5)
print(m[s])
#lo
sum() 求和
type() 查看数据类型
vars() 如果没有参数，等于locals()，有参数则显示帮助
import 导入模块
import test #调用.py文件名
test.hi()
#HELLO
z = __import__("test") #调用字符串名
z.hi()
#HELLO