Python入门基础学习五
------------恢复内容开始------------
------------恢复内容开始------------
函数
1 python中函数定义方法： 2 3 def test(x): 4 "the function definitions" 5 x+=1 6 return x 7 8 def ：定义函数的关键字 9 test : 函数名 10 （） :内可定义形参 11 “” ：文档描述（非必要，但是强烈建议为你的函数添加描述信息） 12 x+=1:泛指代码块或程序处理逻辑 13 return：定义放回值 14 15 16 调用运行：可以带参数也可以不带
使用函数的好处
1、代码重用
2、保持一致性，易维护
3、可拓展性
函数和过程
def test01():
msg = "test01"
print(msg)
def test02():
msg = "test02"
print(msg)
return msg
def test03():
msg = "test03"
print(msg)
return 1,2,3,4,"a",["alex"],{"name":"elex"}
t1 = test01()
t2 = test02()
t3 = test03()
print(t1)
print(t2)
print(t3)
总结：
1、返回值数 = 0；返回None
2、返回值数 = 1；返回object
3、返回值数 > 1；返回tuple
函数参数
位置参数/关键字
位置参数必须在关键字参数左边
def test(x,y,z): print(x) print(y) print(z) #位置参数，必须一一对应，缺一不行 少一也不行 # test(1,2,3) #关键字参数，无须一一对应，缺一不行多一页不行 # test(y=1,x=2,z=3) #位置参数必须在关键字参数前面 #test(1,y=2,3)#报错 #test(1,3,y=2)#报错 # test(1,3,z=5) #test(1,3,z=2,y=4)#报错
默认参数
def handle(x,type="alxe"): print(x) print(type) handle("hello") handle("hello",type="123") handle("hello","12312")
参数组
def test(x,*args): print(x) print(args) print(args[0][0]) # test(1) # test(1,2,3,4) # test(1,{"name":"alex"}) # test(1,["a","b","c"],{"alex":"21"}) # test(1,*["a","b","c"]) # test(1,["a","b","c"])
def test(x,*args,**kwargs): print(x) print(args) print(kwargs) # test(1,y=2,z=3) test(1,2,3,4,5,6,y=2,z=3) test(1,*[1,2,3],**{"a":1})
全局变量与局部变量
NAME = "alex" #全局变量 def change_name(): print("我的名字", NAME) change_name() def change_name(): name = "帅的一逼" #局部变量 print("我的名字", name) change_name() def change_name(): global NAME #把以下全局变量全改掉 NAME = "酷的一逼" print("我的名字", NAME) change_name()
#如果函数的内容无global关键字，优先读取局部变量，能读取全局变量，无法对全局变量重新赋值 # 有声明局部变量 # NAME = {"产品经理", "无敌"} # def zhangzan(): # NAME = "自己" # print("我哟搞", NAME) # zhangzan() # 无声明局部变量 # NAME = ["产品经理", "无敌"] # def zhangzan(): # NAME.append("xx00") # print("我哟搞", NAME) # zhangzan()
#如果函数的内容有global关键字,变量本质上就是全局那个变量，可读可赋值 # 有声明局部变量 # NAME = ["产品经理","尿不湿"] # def zhangzan(): # global NAME # NAME = "自己" # print("我要搞", NAME) # zhangzan() #错误示例 # NAME = ["产品经理","尿不湿"] # def zhangzan(): # NAME = "自己" # global NAME # print("我要搞", NAME) # zhangzan() # 无声明局部变量 # NAME = ["产品经理","尿不湿"] # def zhangzan(): # global NAME # NAME = ["阿毛"] # NAME.append("xx") # print("我要搞", NAME) # zhangzan()
###全局变量变量名大写
###局部变量变量名小写
执行顺序
NAME = "海风" #1 def yongchao(): name = "黄伟" #3 print(name) #4 def canhui(): name = "刘洋"#6 print(name) #7 def yuzhi(): name = "芦淞"#10 print(name)#11 print(name)#8 yuzhi()#9 canhui()#5 print(name) yongchao() #2
NAME = "刚娘" def zhangzan(): NAME = "陈卓" def yongchao(): global NAME NAME = "冷静" yongchao() print(NAME) print(NAME) zhangzan() #刚娘 #陈卓
NAME = "刚娘" def zhangzan(): NAME = "陈卓" def yongchao(): nonlocal NAME #nonlocal:指定上一级变量 NAME = "冷静" yongchao() print(NAME) print(NAME) zhangzan() print(NAME) #刚娘 #冷静 #刚娘
前向引用“函数即变量”
def action(): print("in the action") logger() action() # #会报错,找不到logger()函数这个变量 def logger(): print("in the logger") def action(): print("in the action") logger() action() #不会报错，先运行action()函数，再找到logger()变量运行
NAME = "刚娘" def weihou(): name = "陈卓" def weiweihou(): global NAME NAME = "冷静" weiweihou() print(name) print(NAME) weihou() print(NAME) #刚娘 #陈卓 #冷静
------------恢复内容结束------------
------------恢复内容开始------------
------------恢复内容开始------------
函数
1 python中函数定义方法： 2 3 def test(x): 4 "the function definitions" 5 x+=1 6 return x 7 8 def ：定义函数的关键字 9 test : 函数名 10 （） :内可定义形参 11 “” ：文档描述（非必要，但是强烈建议为你的函数添加描述信息） 12 x+=1:泛指代码块或程序处理逻辑 13 return：定义放回值 14 15 16 调用运行：可以带参数也可以不带
使用函数的好处
1、代码重用
2、保持一致性，易维护
3、可拓展性
函数和过程
def test01():
msg = "test01"
print(msg)
def test02():
msg = "test02"
print(msg)
return msg
def test03():
msg = "test03"
print(msg)
return 1,2,3,4,"a",["alex"],{"name":"elex"}
t1 = test01()
t2 = test02()
t3 = test03()
print(t1)
print(t2)
print(t3)
总结：
1、返回值数 = 0；返回None
2、返回值数 = 1；返回object
3、返回值数 > 1；返回tuple
函数参数
位置参数/关键字
位置参数必须在关键字参数左边
def test(x,y,z): print(x) print(y) print(z) #位置参数，必须一一对应，缺一不行 少一也不行 # test(1,2,3) #关键字参数，无须一一对应，缺一不行多一页不行 # test(y=1,x=2,z=3) #位置参数必须在关键字参数前面 #test(1,y=2,3)#报错 #test(1,3,y=2)#报错 # test(1,3,z=5) #test(1,3,z=2,y=4)#报错
默认参数
def handle(x,type="alxe"): print(x) print(type) handle("hello") handle("hello",type="123") handle("hello","12312")
参数组
def test(x,*args): print(x) print(args) print(args[0][0]) # test(1) # test(1,2,3,4) # test(1,{"name":"alex"}) # test(1,["a","b","c"],{"alex":"21"}) # test(1,*["a","b","c"]) # test(1,["a","b","c"])
def test(x,*args,**kwargs): print(x) print(args) print(kwargs) # test(1,y=2,z=3) test(1,2,3,4,5,6,y=2,z=3) test(1,*[1,2,3],**{"a":1})
全局变量与局部变量
NAME = "alex" #全局变量 def change_name(): print("我的名字", NAME) change_name() def change_name(): name = "帅的一逼" #局部变量 print("我的名字", name) change_name() def change_name(): global NAME #把以下全局变量全改掉 NAME = "酷的一逼" print("我的名字", NAME) change_name()
#如果函数的内容无global关键字，优先读取局部变量，能读取全局变量，无法对全局变量重新赋值 # 有声明局部变量 # NAME = {"产品经理", "无敌"} # def zhangzan(): # NAME = "自己" # print("我哟搞", NAME) # zhangzan() # 无声明局部变量 # NAME = ["产品经理", "无敌"] # def zhangzan(): # NAME.append("xx00") # print("我哟搞", NAME) # zhangzan()
#如果函数的内容有global关键字,变量本质上就是全局那个变量，可读可赋值 # 有声明局部变量 # NAME = ["产品经理","尿不湿"] # def zhangzan(): # global NAME # NAME = "自己" # print("我要搞", NAME) # zhangzan() #错误示例 # NAME = ["产品经理","尿不湿"] # def zhangzan(): # NAME = "自己" # global NAME # print("我要搞", NAME) # zhangzan() # 无声明局部变量 # NAME = ["产品经理","尿不湿"] # def zhangzan(): # global NAME # NAME = ["阿毛"] # NAME.append("xx") # print("我要搞", NAME) # zhangzan()
###全局变量变量名大写
###局部变量变量名小写
执行顺序
NAME = "海风" #1 def yongchao(): name = "黄伟" #3 print(name) #4 def canhui(): name = "刘洋"#6 print(name) #7 def yuzhi(): name = "芦淞"#10 print(name)#11 print(name)#8 yuzhi()#9 canhui()#5 print(name) yongchao() #2
NAME = "刚娘" def zhangzan(): NAME = "陈卓" def yongchao(): global NAME NAME = "冷静" yongchao() print(NAME) print(NAME) zhangzan() #刚娘 #陈卓
NAME = "刚娘" def zhangzan(): NAME = "陈卓" def yongchao(): nonlocal NAME #nonlocal:指定上一级变量 NAME = "冷静" yongchao() print(NAME) print(NAME) zhangzan() print(NAME) #刚娘 #冷静 #刚娘
前向引用“函数即变量”
def action(): print("in the action") logger() action() # #会报错,找不到logger()函数这个变量 def logger(): print("in the logger") def action(): print("in the action") logger() action() #不会报错，先运行action()函数，再找到logger()变量运行
NAME = "刚娘" def weihou(): name = "陈卓" def weiweihou(): global NAME NAME = "冷静" weiweihou() print(name) print(NAME) weihou() print(NAME) #刚娘 #陈卓 #冷静
name = "Alex" def change_name(): name = "Alex2" def change_name2(): name = "Alex3" print("第3层打印",name) change_name2() #调用内层函数 print("第2层打印",name) change_name() print("最外层打印",name)
name = "alex" def foo(): name = "lhf" def bar(): name = "wupeiqi" def tt(): print(name) return tt return bar func = foo() func()()
name = "alxe" #匿名函数 # def change_name(x): # return name+"_sb" # res=change_name(name) # print(res) f=lambda x:name+"_sb" f(name) print(f(name))
f=lambda x,y,z:(x+1,y+1,z+1) print(f(1,1,1))
递归调动
def calc(n): print(n) if int(n/2) == 0: return n return calc(int(n/2)) calc(10)
__author__="linhaifeng" import time person_list=["alex","wupeiqi","yuanhao","lihaifeng"] def ask_way(person_list): print("-"*60) if len(person_list) == 0: return "没人知道" person = person_list.pop(0) if person == "lihaifeng": return "%s说：我知道，老男孩就在沙河汇的商厦，下地铁就是" %person print("hi,美男[%s],敢问路在何方"%person) print("%s回答道：我不知道，但念你慧眼识珠，你等着，我帮你问问%s..."%(person,person_list)) time.sleep(3) res = ask_way((person_list)) print("%s问的结果是：%s"%(person,res)) return res res = ask_way(person_list) print(res)
递归特性：
1、必须有一个明确的结束条件
2、每次进入更深一层递归时，问题规模比上次递归都应有所减少
3、递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
函数式编程
把函数当做参数传给另外一个函数
def foo(n): print(n) def bar(name): print("my name is %s"%name) foo(bar) # foo(bar())#报错 foo(bar("alex"))
返回值中包含函数
def bar(): print("from bar") def foo(): print("from foo") return bar n=foo() n()
高阶函数：1、函数接收的参数是一个函数名；2、返回值中包含函数。二者满足其一就是高阶函数
MAP函数
num_l=[1,2,3,4,5,7] ret = [] for i in num_l: ret.append(i**2) print(ret) def map_test(array): ret = [] for i in num_l: ret.append(i**2) return ret ret=map_test(num_l) print(ret) print(map_test(num_l)) num_l = [1,2,3,4,5,7] def add_one(x): return x+1 def reduce_one(x): return x-1 def pf(x): return x**2 def map_test(func,array): ret = [] for i in num_l: res = func(i) ret.append(res) return ret print(map_test(add_one,num_l)) print(map_test(reduce_one,num_l)) print(map_test(pf,num_l)) num_l = [1,2,3,4,5,7] def map_test(func,array): ret = [] for i in num_l: res = func(i) ret.append(res) return ret print(map_test(lambda x:x+1 , num_l)) print(map_test(lambda x:x-1,num_l)) print(map_test(lambda x:x**2,num_l)) num_l = [1,2,3,4,5,7] def map_test(func,array): ret = [] for i in num_l: res = func(i) ret.append(res) return ret res = map(lambda x:x**2,num_l) print(list(res)) print("传的是有名函数", list(map(lambda x:x+1,num_l))) #具体看函数，若比较复杂，不为lambda需重新定义 num_l = [1,2,3,4,5,7] res = map(lambda x:x**2,num_l) print(list(res)) print("传的是有名函数", list(map(lambda x:x+1,num_l)))
filter函数
movie_people = ["alex_sb","wupeiqi_sb","linhaifeng","yuanhao_sb"] def sb_show(n): return n.endswith("sb") def filter_test(func,array): ret=[] for p in array : if not func(p): ret.append(p) return ret res = filter_test(sb_show,movie_people) print(res)
movie_people = ["alex_sb","wupeiqi_sb","linhaifeng","yuanhao_sb"] def sb_show(n): return n.endswith("sb") def filter_test(func,array): ret=[] for p in array : if not func(p): ret.append(p) return ret print(list(filter_test(lambda n:n.endswith("sb"),movie_people)))
#filter函数 movie_people = ["alex_sb","wupeiqi_sb","linhaifeng","yuanhao_sb"] print(list(filter(lambda n:not n.endswith("sb") , movie_people)))
reduce函数
from functools import reduce num_l=[1,2,3,100] print(reduce(lambda x,y:x*y , num_l)) print(reduce(lambda x,y:x*y , num_l,100)) print(reduce(lambda x,y:x+y , num_l,)) print(reduce(lambda x,y:x+y , num_l,1))
num_l = [1,2,3,100] def reduce_test(array): res=0 for num in array: res+=num return res print(reduce_test(num_l))
num_l = [1,2,3,100] def reduce_test(func,array): res = 1 for num in array: res=func(res,num) return res print(reduce_test(lambda x,y:x*y,num_l))
num_l = [1,2,3,100] def reduce_test(func,array): res=array.pop(0) for num in array: res=func(res,num) return res print(reduce_test(lambda x,y: x*y ,num_l))
#filter遍历序列中每个元素，判断每个元素得到布尔值，如果Ture则留下来 people=[ {"name":"linhaifeng","age":1000}, {"name":"wupei","age":1000}, {"name":"yuanhao","age":9000}, {"name":"wangwei","age":18} ] print(list(filter(lambda p:p["age"]<=18 , people)))
#reduce:处理一个序列，然后吧序列进行合并操作 from functools import reduce print(reduce(lambda x,y:x+y , range(100),100)) print(reduce(lambda x,y:x+y , range(1,101)))
内置函数
print(all([1,2,"1"])) print(all([1,2,"1",""])) print(bin(3))#十进制转二进制 #空，None,0的布尔值为False,其余都为True print(bool("")) print(bool(None)) print(bool(0)) name="你好" print(bytes(name,encoding="utf-8"))#把一个字符串转换为字节,编码:encoding print(bytes(name,encoding="utf-8").decode("utf-8")) #解码：decode print(bytes(name,encoding="gbk").decode("gbk"))#用什么编码，就用什么解码
print(chr(97))#ask码表对应做的打印 print(dir(all))#打印某一个对象“all”下面有哪些方法 print(divmod(10,3))#10除3取商得余数，用来做分页功能，10为内容数，3为每页内容，得商为分几页，余数为剩余 dic={"name":"alex"} dic_str=str(dic) d1=eval(dic_str) #把字符串中的数据结构提取出来 print(d1) express="1+2*(3/3-1)-2" print(eval(express)) #把字符串中的表达式数字运算算出来 #可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型 name="alex" print(hash(name)) print("-->before",hash(name)) name="sb" print("-->after",hash(name)) print(bin(10))#10进制->2进制 print(hex(12))#10进制->16进制 print(oct(12))#10进制->8进制 print(isinstance(1,int)) #判断前面类型是否是后面的数据类型 print(isinstance("abc",str)) print(isinstance([],list)) print(globals())#打印全局变量 print(locals())#打印局部变量
l=[1,3,100,-1,2] print(max(l)) 1，max函数处理的是可迭代对象，相当于一个for循环取出每个元素进行比较，注意，不同类型之间不能比较 print(min(l)) 1，每个元素之间进行比较，是从每个元素的第一个位置一次比较，如果这一个位置分出大小，后面都不需要比较，直接得出两元素大小 print(list(zip(("a","b","c"),(1,2,3))))#zip传序列类型，列表元组字符串，即可组成 p={'name':'alex','age':18,'gender':'none'} print(list(zip(p.keys(),p.values()))) print(list(p.keys())) print(list(p.values())) print(list(zip("hello","12345"))) age_dic={'age1':18,'age2':20,'age3':100,'age40':30} print(max(age_dic.values())) print(list(max(zip(age_dic.values(),age_dic.keys()))))
people=[ {'name':'alex','age':1000}, {'name':'wupeiqi','age':10000}, {'name':'yuanhao','age':900}, {'name':'linhaifeng','age':18}, ] print(max(people, key=lambda dic:dic["age"])) # ret=[] # for item in people: # ret.append(item['age']) # print(ret) # max(ret)
print(ord("a"))#"a"在ask码表的位置 print(pow(3,3))#3**3 print(pow(3,3,2))#3**3%2 l=[1,2,3,4] print(list(reversed(l)))#顺序颠倒、 print(l) print(round(3.5))#四舍五入 l="hello" s1=slice(3,5) #切片 print(l[s1]) l=[3,2,1,4,5] print(sorted(l)) #排序 people=[ {'name':'alex','age':1000}, {'name':'wupeiqi','age':10000}, {'name':'yuanhao','age':900}, {'name':'linhaifeng','age':18}, ] print(sorted(people,key=lambda dic:dic['age'])) name_dic= { 'yuanhao':900, 'alex':200, 'wupei':300, } print(sorted(name_dic,key=lambda key:name_dic[key])) print(sorted(zip(name_dic.values(),name_dic.keys())))
浙公网安备 33010602011771号