python基础之函数式编程

Posted 2020-11-13 Wolf_Coder

一、函数的定义

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

2、特性：

（1）减少重复代码；

（2）使程序变的可扩展；

（3）使程序变得易维护。

3、函数的分类

（1）内置函数：为了方便我们的开发，针对一些简单的功能，python解释器已经为我们定义好了的函数即内置函数。对于内置函数，我们可以拿来就用而无需事先定义，如len(),sum(),max()

（2）自定义函数：很明显内置函数所能提供的功能是有限的，这就需要我们自己根据需求，事先定制好我们自己的函数来实现某种功能，以后，在遇到应用场景时，调用自定义的函数即可。

例子：打印佛祖

 1 def print_buddha(): #def 函数名():定义函数名和变量名一样
 2     print("                            _ooOoo_   ")
 3     print("                           o8888888o  ")
 4     print("                           88  .  88  ")
 5     print("                           (| -_- |)  ")
 6     print("                            O\ = /O  ")
 7     print("                        ____/`---‘\____  ")
 8     print("                      .   ‘ \| |// `.  ")
 9     print("                       / \||| : |||// \  ")
10     print("                     / _||||| -:- |||||- \  ")
11     print("                       | | \\\ - /// | |  ")
12     print("                     | \_| ‘‘\---/‘‘ | |  ")
13     print("                      \ .-\__ `-` ___/-. /  ")
14     print("                   ___`. .‘ /--.--\ `. . __  ")
15     print("                ."" ‘< `.___\_<|>_/___.‘ >‘"".  ")
16     print("               | | : `- \`.;`\ _ /`;.`/ - ` : | |  ")
17     print("                 \ \ `-. \_ __\ /__ _/ .-` / /  ")
18     print("         ======`-.____`-.___\_____/___.-`____.-‘======  ")
19     print("                            `=---=‘  ")
20     print("  ")
21     print("     .............................................  ")
22     print("                  佛祖镇楼                BUG辟易  ")
23     print("          佛曰:  ")
24     print("                  写字楼里写字间，写字间里程序员；  ")
25     print("                  程序人员写程序，又拿程序换酒钱。  ")
26     print("                  酒醒只在网上坐，酒醉还来网下眠；  ")
27     print("                  酒醉酒醒日复日，网上网下年复年。  ")
28     print("                  但愿老死电脑间，不愿鞠躬老板前；  ")
29     print("                  奔驰宝马贵者趣，公交自行程序员。  ")
30     print("                  别人笑我忒疯癫，我笑自己命太贱；  ")
31     print("                  不见满街漂亮妹，哪个归得程序员？")
32 print_buddha()  #执行函数，加（）就是执行，不加（）打印的是函数的内存地址

二、函数的定义和调用

1、定义函数

格式：

#语法def 函数名(参数1,参数2,参数3,...):
    ‘‘‘注释‘‘‘
    函数体
    return 返回的值

注意：函数名要能反映其意义

demo：

def print_name():　　#定义函数
    print(‘-----------------------------‘)　　#代码块
    print(‘my name is renyz.‘)
    print(‘-----------------------------‘)
print_name()　　#调用函数

注意：函数在定义阶段只检测语法，不执行代码

也就是说，语法错误在函数定义阶段就会检测出来，而代码的逻辑错误只有在执行时才会知道。

2、调用函数

　　定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它调用函数很简单的，通过 函数名() 即可完成调用

　　函数的调用：先找到名字，根据名字调用代码（函数名加括号）

3、分析函数的执行过程

（1）回顾程序执行的三种流程

顺序执行、选择执行、循环执行

（2）函数的执行过程

# 定义函数
def print_info():     # 1、程序从第一行开始执行，发现定义一个函数print_info
    # 函数功能代码
    print ("-"*50)　　# 3、开始依次执行代码
    print("名片管理系统...")
    print ("人生苦短，我用python")
    print(" 1:登录")
    print(" 2:退出")
    print ("-" * 50)  # 4、执行到这一步，从哪里进去的从哪里出去
# 调用函数
print_info() # 2、加括号代表执行   # 最后函数print_info走到这里 开始调用里面的函数。

4、定义多个函数

5、定义函数的三种形式

（1）无参：应用场景仅仅只是执行一些操作，比如与用户交互、打印

1 def auth():
2     name = input(">>>:").strip()
3     password = input("passwd>>>:").strip()
4     if name == "test" and  password == "123":
5         print("login successfull")
6     else:
7         print("user or password error")
8 auth()

（2）有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值

1 def my_max(x,y):
2     if x > y:
3         print(x)
4     else:
5         print(y)
6 my_max(1,3)

（3）空函数：设计代码结构

1 def placeholder():
2     pass

　　pass，什么也不做，占位用

结论：

（1）定义时无参，意味着调用时也无需传入参数

（2）定义时有参，意味着调用时则必须传入参数

三、函数的参数与局部变量

1、形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量（在定义阶段函数名称括号内的参数叫做形参，可以给默认值）

2、实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值（在执行阶段传入的参数叫做实参，可以是位置参数，也可以以键值对的形式传参，还可以传入函数的执行结果）

def sum(x,y):    #x,y为形参
     print(x)
     print(y)
sum(10,20)    #10,20代表实参

3、默认参数

def stu_register(name, age, country, course):
    print("注册学生信息".center(25,‘-‘))
    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")

　　发现 country 这个参数 基本都 是"CN", 就像我们在网站上注册用户，像国籍这种信息，你不填写，默认就会是 中国， 这就是通过默认参数实现的，把country变成默认参数非常简单

def stu_register(name, age, course, country=‘CN‘):

　　这样，这个参数在调用时不指定，那默认就是CN，指定了的话，就用你指定的值。

4、关键参数

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

5、非固定参数（*args-元组;**kwargs-字典）

若函数在定义时不确定想传入多少个参数，就可以使用非固定参数

def stu_register(name, age, *args):  # *args 会把多传入的参数变成一个元组形式
    print(name, age, args)
stu_register("Renyz", 22)
# 输出
# Renyz 22 () #后面这个()就是args,只是因为没传值,所以为空
stu_register("Jack", 32, "CN", "Python")
# 输出
# Jack 32 (‘CN‘, ‘Python‘)

还可以有一个**kwargs

1 def stu_register(name, age, *args, **kwargs):  # *kwargs 会把多传入的参数变成一个dict形式
2     print(name, age, args, kwargs)
3 stu_register("Renyz", 18)
4 # 输出
5 # Renyz 18 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空
6 stu_register("Jack", 22, "CN", "Python", sex="Male", province="ShanDong")
7 # 输出
8 # Jack 22 (‘CN‘, ‘Python‘) {‘province‘: ‘ShanDong‘, ‘sex‘: ‘Male‘}

6、全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

 1 name = "Renyz"
 2 def change_name(name):
 3     print("Old name:", name)
 4     name = "任彦忠"
 5     print("Change name:", name)
 6 change_name(name)
 7 print("在外面看看变量name改了么?", name)
 8 -----------------------------------------------------------
 9 Old name: Renyz
10 Change name: 任彦忠
11 在外面看看变量name改了么? Renyz

#内置名称空间:（python启动时就有）python解释器内置的名字，print,max,min
#全局名称空间:（执行python文件时启动）定投定义的变量
#局部名称空间:（调用函数时启动，调用结束失效）函数内部定义的变量
# 总结：三者的加载顺序
# 内置 --->全局 - -->局部
# 三者的访问顺序
# 局部 --->全局 - -->内置

四、返回值

要想获取函数的执行结果，就可以用return语句把结果返回

注意：

1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
2. 如果未在函数中指定return,那这个函数的返回值为None 

 1 def test():
 2     a = 11
 3     b = 12
 4     c = 33
 5     # return a
 6     # return b
 7     # return c  #无法调用多个值
 8 #调用多个值得方法：
 9     # 第1种 ,用一个列表来封装3个变量的值
10     # d = [a,b,c]
11     # return d
12     # 第2种,第一种的另外写法
13     # return [a,b,c]
14     # 第3种 封装到元祖里面返回
15     return a,b,c
16 num = test()
17 print (num)
18 # return隐藏的功能结束函数的执行

无return->None；return 1个值->返回1个值；return 逗号分隔多个值->元组

什么时候该有返回值？

　　　调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值

　　　通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果

什么时候不需要有返回值？

　　　调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值

　　　通常无参函数不需要有返回值

注意：每次调用一次函数的时候都会从函数最开始的地方执行。想做到用生成器（yiled）

4种函数的类型：

　　无参数，无返回值；无参数，有返回值；有参数，无返回值；有参数，有返回值

def 函数名():
    pass

def 函数名():
    return xxx

def 函数名(参数):
    pass

def 函数名(参数):
    return xxx

五、嵌套函数

 

 

六、递归函数

 

 

 

七、匿名函数

 

 

八、函数式编程

 

 

 

 

九、高阶函数

 

 

 

十、内置函数