第三章| 3.2函数 3函数

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

减少重复代码
使程序变的可扩展
使程序变得易维护

语法定义

def sayhi():#函数名
　　print("Hello") 
　　print("my name is kris!")

sayhi() #调用函数

调用参数

def sayhi(name):#函数名
　　print("Hello",name) 
　　print("my name is kris!")

sayhi("alex") #调用函数

def calc(x,y):
    res = x**y
    return res #返回函数执行结果
c = calc(a,b) ＃结果赋值给c变量
print(c)

函数参数

形参变量

实参

第三章| 3.2函数
3函数

默认参数

位置参数（按照位置）

def stu_register(name,age,country,course):
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)

stu_register("王山炮",22,"CN","python_devops")
stu_register("张叫春",21,"CN","linux")
stu_register("刘老根",25,"CN","linux")

def stu_register(name,age,course,country="CN"):  #country="CN" 就是默认参数

def stu_register(name,age,course,country = 'CN'): #country='CN'就是默认参数
    print("registriation info...")
    print(name,age,course,country)
stu_register("alex",22,"python")
stu_register("kris",23,"python","CN")
stu_register("shanshan",18,"python","Korean")

关键参数（必须放在位置参数之后）

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可(指定了参数名的参数就叫关键参数)，但记住一个要求就是，关键参数必须放在位置参数(以位置顺序确定对应关系的参数)之后

def stu_register(name, age, course='PY' ,country='CN'):
    print("----注册学生信息------")
    print("姓名:", name)
    print("age:", age)
    print("国籍:", country)
    print("课程:", course)
stu_register("王山炮",course='PY', age=22,country='JP' )  #调用

非固定参数 *args（会把多传入的参数变成一个元组形式） **kwargs（*kwargs 会把多传入的参数变成一个dict形式）

def send_alert(msg,*users): #如果参数出现，*users，传递的参数就可以不再是固定个数，传过来的所有参数打包元组。    # *users是非主流的，*args才是主流。
    for u in users:
        print('报警发送给'，u)
send_alert('别他么狠了' , ‘alex’, 'rain' ,'xxx' ) #后边三个打包成元组传递

def send_alert(msg,*users,age):
    for u in users:
        print('报警发送给'，u)
#如果参数中出现*users，传递的参数就可以不再是固定个数，传过来的所有参数打包元组。
#方式一
send_alert('别他么狠了' , ‘alex’, 'rain' ,'xxx' )

#方式二
send_alert('别他么狠了' , *[‘alex’, 'rain' ,'xxx'] ) #([‘alex’, 'rain' ,'xxx'] ) ------>(‘alex’, 'rain' ,'xxx')
send_alert("alex","rain","eric",age=22) # "rain","eric" 它们一块传给了*users

**kwargs 是关键字参数（未定义的），指定的那个参数名。

def func(name,*args,**kwargs):
    print(name,args,kwargs)     #输出 alex (22 , 'tesla' , '500w') {'num':123444332 , 'addr':'山东'}

func('alex' ,22 ,'tesla' , '500w' , addr = '山东' , num = 123444332)

def func(name,*args,**kwargs):
    print(name,args,kwargs)     #输出 alex (22 , 'tesla' , '500w') {'num':123444332 , 'addr':'山东'}
　　　　　　　　　　　　　　　　　　　　#   jack () {'degree': 'primary school'}
func('alex' ,22 ,'tesla' , '500w' , addr = '山东' , num = 123444332)

d = { 'degree':'primary school' }
func('jack' ,**d)

返回值（return代表函数的终值）

外部的代码要想获取函数的执行结果，就可以在函数里用return语句把结果返回；return语句退出函数，并返回一个表达式。不带参数值的return语句返回None

第三章| 3.2函数
3函数

局部变量

定义在函数外部一级代码的变量，叫全局变量，全局能用；局部变量就是指定义在函数里的变量，只能在局部生效； 在函数内部，可以引用全局变量；

如果全局和局部都有一个变量叫name，函数查找变量的顺序是由内而外的。

name = "Black girl"
def change_name():
    name = "黑色姑娘"
    print("在" ,name ,"里面...")    #打印: 在 黑色姑娘 里面....
change_name()
print(name)     #打印: Black girl

里边可以调用外边，但是不能修改。外边不能调用里边的变量。局部只能引用全局，是修改不了的 .

第三章| 3.2函数
3函数

name = "Black girl"
def change_name():
    #name = "黑色姑娘"
    print("在" ,name ,"里面..." ,id(name) )    #打印: 

def func2():
    name = "rain"
func2()
charge_name()
print(name,id(name))     #打印: Black girl

在函数里修改全局变量（整体改，要加global）

name = "Black girl"
def change_name():
    global name  #改为全局
    name = "黑色的姑娘"
    age = 25
    print("在" ,name ,"里面...", id(name))   

change_name()
print(name, id(name) )

在函数里修改列表数据字典、列表、集合、类，不可以修改的有字符串

names = ['alex' , 'black girl' , 'peiqi' ]
def change_name():
    del names[2]
    names[1] = "黑姑娘"  #整体不可以修改，但里边内部可以改
    print(names)
change_name()
print(names)

嵌套函数

#嵌套函数

#1
def func1():
    print('alex')
    def func2():
        print('eric')  #它没有被调用所以就不会输出eric
func1()  #输出alex

#2
def func1():
    print('alex')
    def func2():
        print('eric')
    func2()
func1()   #输出alex  eric
             # ====>1.函数内部可以再次定义函数。 2.执行需要被调用

#3
def func1():
    age = 73
    print(age)
    def func2():
        print(age) #它会去父级找
    func2()
func1()  #输出 73  73

第三章| 3.2函数
3函数

自己没有，就去父级找，没有再去爷爷级。由内向往，一层层的找。局部变量之间也是有等级关系的。

age = 19
def func1():
    age = 73
    def func2():
        print(age)  #输出 73
    func2()
func1()  


age = 19
def func1():
    def func2():
        print(age)  #输出73
    age = 73  #程序是从上往下读的，先读age，再去调用func2（）
    func2()
func1()  


age = 19
def func1():
    global age  #把age=19拿回了
    def func2():
        print(age)  #19
    func2() #当程序走到这的时候，调用func2（）然后往上走，输入age=19，再往下走age=73
    age = 73        #73 它已经是全局了
func1()  
print(age) #73


age = 19
def func1():
    global age  #把全局拿过来了
    def func2():
        print(age)  #73
    age = 73  #把全局的给改了，然后再往下走去执行func2（）
    func2()
func1()  
print(age)   #73

从上往下找，代码谁先执行，掌握global

作用域

在python中一个函数就是一个作用域。无论在任何地方调用这个函数，永远回到它最开始的地方从上执行，往上找。

python中函数就是一个作用域（javascript），局部变量放置在其作用域中；

c# Java中作用域{ }；

代码完成后，作用域已经生成，作用域链向上查找。

age = 18
def func1():
    age = 73
    def func2():
　　　　print(age)
    return 666  #返回值为666

val = func1()
print(val)  #打印出 666

age = 18
def func1():
    age = 73
    def func2():
        print(age)  #打印
    return func2  #返回的是一个函数，函数名作为一返回值

val = func1()
print(val)   #<function func1.<locals>.func2 at 0x00000000027F1730>

age = 18
def func1():
    age = 73
    def func2():
        print(age)  #打印出 73
    return func2  #返回的是一个函数

val = func1()
val（）#返回值func2再调用它

函数名可以当做返回值。

匿名函数

匿名函数就是不需要显式的指定函数名。没有名字，不能调用，只是一个函数。节省代码量；看着高级。

匿名函数主要是和其它函数搭配使用的呢。

#这段代码
def calc(x,y):
    return x**y
print(calc(2,5))  #32

#换成匿名函数
calc = lambda x,y:x**y
print(calc(2,5))

def calc(x,y):
    return x*y
func = lambda x,y:x**y #声明一个匿名函数
print(calc(3,8)) #24
print(func(3,8)) #6561

def calc(x,y):
    if x < y :
        return x*y
    else:
        return x/y

func = lambda x,y:x*y  if x < y else x/y #声明一个匿名函数   ###只能用三元运算了。
print(calc(16,8))  #2
print(func(16,8))  #2
print(func(16,32)) #512

data = list(range(10))
print(data)    #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#for index,i in enumerate(data):
#    data[index] = i * i
#print(data)   #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

def f2(n):
    return n *n
print(list(map(f2, data)))   #map函数 #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

print(list(map(lambda x:x*x, data))) #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

##匿名函数不需要return来返回值，表达式本身结果就是返回值.
lambda x,y:x+y
lambda x,y,z : x+y+z
lambda x,y: x if x> y else y

lambda x,y=2:x+y  #含默认值
a = lambda x,y=2:x+y ##调用
a(2) ##不输就使用默认值
a(2,3)

>>>a = lambda *z:z  ##*z返回的是一个元祖
>>> a('Testing1','Testing2')
('Testing1', 'Testing2')
>>>c = lambda **Arg: Arg #arg返回的是一个字典
>>> c()
{}



#lambda返回的值，结合map,filter,reduce使用
>>> filter(lambda x:x%3==0,[1,2,3,4,5,6])
[3, 6]
##等价于下面的列表推导式
>>> l = [x for x in [1,2,3,4,5,6] if x%3==0]
>>> l
[3, 6]

>>>  squares = map(lambda x:x**2,range(10))  #[0,1,4,9,16,25,36,49,64,81]
>>> filters = filter(lambda x:x>5 and x<50,squares)
>>> filters
[9, 16, 25, 36, 49]

##lambda和reduce联合使用
>>> L = [1,2,3,4]
>>> sum = reduce(lambda x,y:x+y,L)
>>> sum
10



##求2-50之间的素数
#素数:只能被1或被自己整除的数
>>> nums = range(2,50)
>>> for i in nums:
nums = filter(lambda x:x==i or x % i,nums)
>>> nums
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
###求两个列表元素的和
>>> a = [1,2,3,4]
>>> b = [5,6,7,8]
>>> map(lambda x,y:x+y, a,b)
[6, 8, 10, 12]
lambda和sorted联合使用

#按death名单里面，按年龄来排序
#匿名函数的值返回给key，进来排序
>>> death = [ ('James',32),
('Alies',20),
('Wendy',25)]
>>> sorted(death,key=lambda age:age[1]) #按照第二个元素，索引为1排序
[('Alies', 20), ('Wendy', 25), ('James', 32)]

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def calc(x):
    return x*x
#f = lambda x:x*x  #变量指向匿名函数
f = calc  #变量不光可以赋值，可以指向函数，什么都可以赋值；
f()


def calc(x):
    return x*x
n = 10  
calc(n) #函数的参数能接收变量
print(calc(n)) #100


def func(x,y):
    return x+y
def calc(x):
    return x  #x()可以执行这个函数； x=func
n = func
calc(n)  #一个函数可以接收另一个函数作为参数


def func(x,y):
    return x+y
def calc(x):  #把func当做参数传给了x，又返回了；不返回pass也是高阶函数
    return x
f = calc(func)  
print(f(5,9)) //14; 上一步执行calc这个函数的时候把x返回了，也就是把func这个函数给返回了,返回给外部使用；相当于执行的是func(5,9)


def func2(x,y):
    return abs,x,y  #返回另外一个函数
res = func2(3,-10)
print(res)

只需满足以下任意一个条件，即是高阶函数：

接受一个或多个函数作为输入
return 返回另外一个函数

def func(x,y):
    return x+y

def calc(x):
    return x

f = calc(func)  
print(f(5,9))  //14

def func2(x,y):
    return abs,x,y

res = func2(3,-10)
print(res)

递归

递归就是在函数的执行过程中调用自己。

python有一个最大递归层。

最大递归深度限制，为什么要限制呢？

通俗来讲，是因为每个函数在调用自己的时候还没有退出，占内存，多了肯定会导致内存崩溃。

本质上讲呢，在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

import sys
print(sys.getrecursionlimit())  #python默认的最大递归层
sys.setrecursionlimit(1500) #可以给它设置递归层，让它无限递归下去会把系统给弄爆
def recursion(n):
    print(n)
    recursion(n+1)
recursion(1)

def calc(n):
    print(n) #10 5 2 1 
    if int(n/2) ==0: 加一个判断条件就不用再往下递归了
        return n
    return calc(int(n/2))
calc(10)

def calc(n):
    v = int(n/2)
    print(v)  #5 2 1 
    if v > 0:
        calc(v)
    print(n)#0 1 2 5 10   它会一层层再出来，从内到外
calc(10)

递归执行过程

第三章| 3.2函数
3函数

递归的返回值

def calc(n,count)
    print(n,count) #188 1 , 94.0  2 , 47.0  3, 23.5  4 , 11.75  5
    if count < 5:
        calc(n/2,count+1)
calc(188,1)

两个return的作用，最里层那个往外返回那个结果；每一层接收它下一层的，就是里边一层返回给它上边一层的那个值

def calc(n,count)
    print(n,count) #打印：188 1 , 94.0  2 , 47.0  3, 23.5  4 , 11.75  5  ,res 11.75 #这样就拿到了最里层的那个结果11.75
    if count < 5:
        return calc(n/2,count+1)
    else:
        return n
res = calc(188,1)
print('res' , res)

递归特性:

必须有一个明确的结束条件
每次进入更深一层递归时，问题规模相比上次递归都应有所减少
递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html

递归的用途

如阶乘、二分查找

def factorial(n):
    if n == 1: #结束条件，最里层；倒数第二层跟这个1相乘
        return 1
    return n * factorial(n-1)  #factorial(n-1)层层进去得到最里层结果,返回值直接用return；调用下一层时自己退出了，但它还要等着下一层的结果，所以不叫尾递归
print(factorial(5)) #120

二分查找

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]


def binary_search(dataset,find_num):
    print(dataset)

    if len(dataset) >1:
        mid = int(len(dataset)/2)
        if dataset[mid] == find_num:  #find it
            print("找到数字",dataset[mid])
        elif dataset[mid] > find_num :# 找的数在mid左面
            print("

第三章| 3.2函数 3函数

语法定义

函数参数

返回值 （return代表函数的终值）

局部变量

嵌套函数

作用域

匿名函数

高阶函数

递归

相关推荐

返回值（return代表函数的终值）