My python day3

函数

一、为何使用函数:

1.代码重用

2.保持一致性、易维护

3.可扩展性

二、函数分为内置函数和自定义函数

内置函数：python解释器已经为我们定义好了的函数即内置函数

自定义函数：根据自己的需求实现某种功能

 

#自定义函数
def 函数名(参数1,参数2,参数3,...):
    '''注释'''
    函数体
    return 返回值

函数需要先定义才能调用

三、调用函数：

函数名 + 括号

四、函数的返回值：

调用函数，需要得到结果，必须要有返回值

调用函数，不需要得到结果，不需要返回值

无return 则返回None

1个return 则返回object

多个return 则返回tuple

碰到return 则代表函数运行结束

五、函数的参数

函数可以没有参数也可以有参数，分为位置参数、关键字参数、默认参数、可变长参数.

 

def t():
    '''无参数'''
    print("in the t")
t()
def t2(name):
    print("my name is %s"%name)
t2("Ezhizen")

 

def t(x,y):
    z = x+y
    return z
z = t(1,2)   #位置参数，实参和行参一一对应
def t2(x,y):
    z = x+y
    return z
z = t2(y=1,x=2)  #关键字参数，位置可以不固定
def t3(x,y,z):
    q = x+y+z
    return q
q = t3(1,2,z=3)  #位置参数和关键字参数混合时，位置参数必须在关键字参数的左边
def t4(x,y,z=3):
    q =x+y+z
    return q
q = t4(1,2)   #当有默认参数时，如果不传参数就使用默认值，如果传就使用传的值
def t5(x,*args,**kwargs):
    print(x)
    print(args)   #args=(2,3)  返回一个元组
    print(kwargs)   #kwargs={'a': 5, 'b': 6}  #返回一个字典
t5(1,2,3,a=5,b=6)  #和可变长参数连用时，*args接受位置参数，**kwargs接受关键字参数
t5(1,*[2,3],**{'a': 5, 'b': 6})  
#如果args传递一个列表,则列表前要加*,如果不加，列表就会被当作一个元素，kwargs传递一个字典，字典前需要加**

六、全局变量和局部变量

在定格定义的是全局变量，在子程序中定义的为局部变量

局部变量会从局部开始找，找不到再到外一层中找，当局部变量与全局变量重名时，在定义局部变量的子程序中，局部变量起作用，在其他地方全局变量起作用。

局部变量子程序无global关键字，先读取局部变量，再读取全局变量，无法重新赋值，可变类型内部可以进行元素操作

如果函数中有global，可以读取赋值全局变量。

nonlocal 操作上一级变量

一般情况下，为例区分全局变量和局部变量，全局变量用大写，局部变量用小写。 

 

name ="Ezhizen"  #全局变量
def f1():
    name="a"   #局部变量
    def f2():
        print(name)   #name="a" 局部变量从局部开始找，无法对全局变量重新赋值
    f2()
f1()

l=[1,32,2]
def f3():
    def f4():
        l.append(54)   #对于全局可变类型可以进行内部元素操作
    f4()
f3()
print(l)

name ="Ezhizen"
def f5():
    # name="a"
    def f6():
        print(name)    #局部变量不存在时，就会到全局变量中找
    f6()
f5()
def f7():
    name="a"
    def f8():
        global name
        name="Echizen"  #当存在global 关键字时，可以读取赋值全局变量
        print(name)
    f8()
f7()
print(name)
def f9():
    name="a"
    def f10():
        nonlocal name  #nonlocal 关键字，可以对上一级变量进行赋值
        name="b"
    print(name)
    f10()
    print(name)
f9()

 

七、函数递归

 

一个函数自己调用自己

递归的条件：1.明确的终止条件2.每进入更深一层递归，规模减小

 

九、高阶函数

1.一个函数接受另一个函数作为参数

2.返回值中有函数

 

def g1(func):   #参数中有函数
    print(func)
def g2():
    print("in the g2")
g1(g2)
def g3():
    print("in the g3")
def g4():
    return g3   #返回值中有函数名
g3 = g4() 
print(g3)    

 

十、map、filter、reduce的使用

 

print(list(map(lambda x:x+1,[1,2,3])))  #
print(list(filter(lambda x:x<5,[1,2,6])))  #过滤
from functools import reduce
print(reduce(lambda x,y:x+y,[1,2,3,4],3))  #累加，起始值为3

 

十一、内置函数

 

 

ord("a")  #ascill码中a对应的数字
chr(97)  #97对应的字母
bytes(name,encoding="utf-8")#转为二进制
bytes(name,encoding="utf-8").decode("utf-8") #二进制解码
dir(all) #查看all下的所有方法
divmod(10,3)  #得到（3，1）
for i,v in enumerate([1,2,3]): #生成序号
    print(i,v)

eval("{'name':'a'}") #从字符串中得到字典
eval("1+2*3")  #计算字符串中的值
globals()  #全局变量
locals()  #局部变量
hash()  #进行hash运算 不可变类型是可hash，可变类型是不可hash的
hex(20) #10进制转为16进制
int("011",base=2)  #2进制转10进制
oct(20) #10进制转8进制
bin(10)  #10进制转2进制
id()  #查看内存地址
isinstance([1,2,3],list) #判断【1，2，3】是不是list的实例
max([1,2,3]) #最大值

dic=[{"name":"a","age":18},
{"name2":"ab","age":180},
{"name3":"ac","age":1800},
     ]

print(max(dic,key=lambda x:x["age"]) ) #max的本质遍历dic，根据dic的age求最大值
print(list(zip([1,2,3],[4,5,6])))  #拉链函数,对应元素以元组相连接,不对称时，取短的
print(pow(2,3))  #2**3
print(pow(2,3,5)) #2**3%5
l=[1,2,3]
print(reversed(l))  #反转
print(round(1.5))  #四舍五入
sorted([1,3,6,4])  #排序 ,默认升序
sorted([1,3,6,4],reverse=True)  #降序
print(sorted(dic,key=lambda x:x["age"]))  #升序
sum([1,5,6])  #求和
__import__("test")  #导入字符串模块