全局变量与局部变量
顶头，没有任何缩进就是全局变量
函数里的变量是局部变量
如果在函数里使用 global全局变量，则可以改变全局变量。
如果没有global全局变量，调用全局变量的时候，只能读取，无法重新赋值
nonlocal 取上一级变量
书写规范
全局变量大写
局部变量小写
递归函数
归函数特性
一个函数调用自己
1.必须有一个明确的结束条件
2.每进入更深层次递归时，问题规模相比上一次递归都应有所减少
3.递归效率不高，递归层次过多会导致栈溢出。
person_list = ['alex','wupeiqi','linhaifeng','zsc']def ask_way(person_list):print('-'*60)if len(person_list) == 0:return '根本没人知道'person = person_list.pop(0)if person == 'linhaifeng':return '%s说:我知道，老男孩就在....' % personprint('hi 你好[%s],敢问路在何方'%person)print('%s回答道：我不知道，但念你慧眼识猪，你等着，我帮你问问%s...'%(person,person_list))res = ask_way(person_list)print('%s问的结果是：%s'%(person,res))return res
res = ask_way(person_list)
print(res)
#>>>
------------------------------------------------------------
hi 你好[alex],敢问路在何方
alex回答道：我不知道，但念你慧眼识猪，你等着，我帮你问问['wupeiqi', 'linhaifeng', 'zsc']...
------------------------------------------------------------
hi 你好[wupeiqi],敢问路在何方
wupeiqi回答道：我不知道，但念你慧眼识猪，你等着，我帮你问问['linhaifeng', 'zsc']...
------------------------------------------------------------
wupeiqi问的结果是：linhaifeng说:我知道，老男孩就在....
alex问的结果是：linhaifeng说:我知道，老男孩就在....
linhaifeng说:我知道，老男孩就在....
函数作用域
name = 'alex'def foo():name = 'hg'def bar():name = 'lg'def tt():return namereturn ttreturn barfoo = foo()()() #foo()执行第一个函数，返回bar == foo(),然后foo()() == bar(),接着执行bar().....
print(foo)
匿名函数lambda
lambda x:x+1 # 函数形式 lambda 形参 : 返回值
a = lambda x:x+1
print(a(10)) #11
name = 'lghg'
def change_name(x):return name+'_nb'
res = change_name(name)
print(res) #>>>lghg_nbf = lambda x:name+'_nb'
res = f(name)
print(res)#>>>lghg_nb
# print((lambda x:name+'_nb')(name)) #更加简洁f = lambda x,y,z:x+y+z
res = f(1,2,3)
print(res) #>>>6
函数式编程
函数式 = 编程语言定义的函数+数学意义的函数
高阶函数：1.函数接收的参数是一个函数名 2。返回值中包含函数
#非函数式
a = 1
def text():global aa += 2return a#函数式
n = 1
def func(n):return n+1# 高阶函数：1.函数接收的参数是一个函数名 2。返回值中包含函数
def foo(n):print(n)
def bar(name):print(name)
foo(bar("hg"))
内置函数
map函数：重点
map函数 表达式：map(func,可迭代对象)， 功能：把可迭代对象用for循环的方式进行功能函数处理,得到的结果是一个列表地址，位置以及个数与原来一样
点击查看代码
num1 = [1,2,3,4,5,6,7,8,9]
#执行每个数加1
def add_1(x):return x+1
lambda x:x+1def reduce_1(x): #执行每个数减1return x-1lambda x:x-1
def mab_text(func,array): #使用func（i）是为了不把函数写死，这样这个函数就可以调用其他功能函数res=[]for i in array:ret=func(i) #add_1(i)/(lambda x:x+1)(i)/reduce_1(i)/(lambda x:x-1)(i)res.append(ret)return res
print(mab_text(add_1,num1))
print(mab_text(lambda x:x+1,num1))
print(mab_text(reduce_1,num1))
print(mab_text(lambda x:x-1,num1))#map函数可以使上面的功能更加简洁
#map函数 map(func,可迭代对象) 功能：把可迭代对象用for循环的方式进行功能函数处理,得到的结果是一个列表地址，位置以及个数与原来一样
res = map(lambda x:x+1,num1)
print("内置函数map,处理结果",res) #<map object at 0x0000018981841750> 地址
print(list(res)) #[2, 3, 4, 5, 6, 7, 8, 9, 10]print(list(map(reduce_1,num1)))#[0, 1, 2, 3, 4, 5, 6, 7, 8]lh = 'hjgjkcgj' #全部转换成大写
print(list(map(lambda x:x.upper(),lh))) #['H', 'J', 'G', 'J', 'K', 'C', 'G', 'J']
filter函数 ：重点
filter函数 把迭代对象在功能函数进行for循环，判断为True则输出，判断为False则过滤，删除
点击查看代码
movie_people = ['sb_jhj','sb_kk','sb_jj','hg','lg','sb_jhj']"""
滤除不要的人
"""
res = []
for person in movie_people: #不用函数if not person.startswith('sb'):res.append(person)
print(res) #['hg', 'lg']def filter_movie(array): #用函数ret = []for i in array:if not i.startswith('sb'):ret.append(i)return ret
print(filter_movie(movie_people)) #['hg', 'lg']def sb_show(n):return n.startswith('sb')def filter_movie(func,array):ret = []for i in array:if not func(i): #使用func（i）是为了不把函数写死，这样这个函数就可以调用其他功能函数ret.append(i)return ret
print(filter_movie(sb_show,movie_people)) #['hg', 'lg']#终极版本
res = filter_movie(lambda x:x.startswith("sb"),movie_people)
print(res) #['hg', 'lg']#filter函数 把迭代对象在功能函数进行for循环，判断为True则输出，判断为False则过滤，删除
movie_people = ['sb_jhj','sb_kk','sb_jj','hg','lg','sb_jhj']
print(filter(lambda x:x.startswith("sb"),movie_people)) #<filter object at 0x000001B1D28A1FF0> 内存地址
print(list(filter(lambda x:x.startswith("sb"),movie_people)))#['sb_jhj', 'sb_kk', 'sb_jj', 'sb_jhj'] #如果是以sb开头则为真，即输出
print(list(filter(lambda x:not x.startswith("sb"),movie_people)))#['hg', 'lg']
print(list(map(lambda x:not x.startswith("sb"),movie_people)))#[False, False, False, True, True, False]from functools import reduce #必须要有
print(reduce(lambda x,y:x*y,num_1)) #362880
zip函数
#zip #一一对应，形成元组，再组成列表
print(list(zip(('a','b','c'),(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)]
print(list(zip(('a','b','c','d'),(1,2,3,4))))#[('a', 1), ('b', 2), ('c', 3)]p = {'name':'hg','age':23,'hoppy':'mv'}
print(list(zip(p.keys(),p.values()))) #[('name', 'hg'), ('age', 23), ('hoppy', 'mv')]
max、min函数及高级使用
max 取最大值 min取最小值
高级使用：
1.max函数处理的是可迭代对象，相当于一个for循环取出每个元素进行比较，注意，不同类型之间不能进行比较
2.每个元素进行比较，是从每个元素的第一个位置依次比较，如果这一位置区分出大小，后面的都不需要比较了，直接得出这两个元素的大小
age_dic = {'age1':18,'age2':19,'age3':20}
print(max(age_dic.values()))
print(max((zip(age_dic.values(),age_dic.keys())))) #(20, 'age3')people = [{'name':'hg','age':23},{'name':'lg','age':18},{'name':'mv','age':19}
]print(max(people, key = lambda dic:dic['age']))#>>>{'name': 'hg', 'age': 23}
sorted函数
sorted排序 本质比较大小，只有同类型才能比较
L = [2,8,6,7,3]
print(sorted(L)) #[2, 3, 6, 7, 8]people = [{'name':'hg','age':23},{'name':'lg','age':18},{'name':'mv','age':19}
]
print(sorted(people, key = lambda dic:dic['age'])) #[{'name': 'lg', 'age': 18}, {'name': 'mv', 'age': 19}, {'name': 'hg', 'age': 23}]name = {'lg':2000,'mv':300,'hg':1000
}
print(sorted(name))#['hg', 'lg', 'mv'] 按照keys值直接进行比较
print(sorted(name,key = lambda x:name[x]))#['mv', 'hg', 'lg']
print(sorted(zip(name.values(),name.keys())))#[(300, 'mv'), (1000, 'hg'), (2000, 'lg')]
其他函数
点击查看代码
name = '你好'
print(bytes(name,'utf-8')) #b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(bytes(name,'utf-8').decode('utf-8')) #解码你好
print(bytes(name,'gbk').decode('gbk')) #你好#===divmod
print(divmod(7,2)) #取商，余数>>>(3, 1)#eval
dic = {"name":'hg'}
dic_str = str(dic)
print(dic_str) #{'name': 'hg'}字符串
print(eval(dic_str))#{'name': 'hg'} 字典 #把字符串中的数据结构提取出来
a = eval(dic_str) #字符串变为字典
print(a['name']) #hgexpress = '1+1+23*2'
print(eval(express)) #48 把字符串中的表达式进行运算#hash 可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型
name = 'hg' #可以用hash判断所定义的变量，有没有被修改
print(hash(name))#8023437410973310514
print(hash(name))#8023437410973310514
name = 'lg'
print(hash(name)) #-2793483496824705473#isinstance 判断数据类型
print(isinstance('hg',str))#True
print(isinstance(123,int))#True#ord
print(chr(97)) #a
print(ord('a'))#97
#pow
print(pow(2,3))# 2**3
print(pow(2,3,3))#2**3%3#round 四舍五入
print(round(3.5)) #4#切片slice
L = 'lghgkk'
print(L[3:5]) #gk
a = slice(3,5)
print(L[a]) #gk#sum求和#type
a= '123'
if type(a) == str:a = int(a)a +=1print(a) #124#var 用处不大def test():msg = "hello world"print(locals())
test() #>>>{'msg': 'hello world'}def test():msg = "hello world"print(vars()) #没有参数和locals（）一样，有参数的时候把对象打印成字典的形式test() #>>>{'msg': 'hello world'}
