python3-基础5

#函数

 1 什么是函数？
 2 为什么要用函数？
 3 函数的分类：内置函数与自定义函数
 4 如何自定义函数
 5   语法
 6   定义有参数函数，及有参函数的应用场景
 7   定义无参数函数，及无参函数的应用场景
 8   定义空函数，及空函数的应用场景
 9 调用函数
10     如何调用函数
11     函数的返回值
12     函数参数的应用：形参和实参，位置参数，关键字参数，默认参数，*args，**kwargs
13 高阶函数（函数对象）
14 函数嵌套
15 作用域与名称空间
16 装饰器
17 迭代器与生成器及协程函数
18 三元运算，列表解析、生成器表达式
19 函数的递归调用
20 内置函数
21 面向过程编程与函数式编程

生活中要做某件事的时候，可能会用到各种工具，且可以重复使用。

遇到这种情况，如何解决问题：

工具就具备某一种功能的物件，就是程序中的函数的概念

事先准备工具的过程称为函数的定义

遇到特定的场景拿来就用称为函数的调用

函数的分类

　　内置函数：　为了方便开发，针对一些简单的功能，python解释器已经为我们定义好了的函数即内置函数。

　　　　　　　　对于内置函数，我们可以拿来就用而无需事先定义，如len(),sum(),max()

　　自定义函数 ：很明显内置函数所能提供的功能是有限的，这就需要我们自己根据需求，事先定制好我们自己的函数来实现某种功能，

　　　　　　　　以后，在遇到应用场景时，调用自定义的函数即可。

函数的定义语法：

关键字  def  来定义

　　def    函数名  （参数1，参数2，。。。）：

　　　　　“注释”

　　　　　函数体

　　　　　return 返回值   # 若此处为print()     则函数的值不能赋值给变量

　　函数名一般是动词，表示一个功能，要干什么

　　注释信息一定要有　

return :函数内部可以没有return，返回None，等同于 return None

　　　  如果return 后面跟一个值 ， 将返回该值 ， 这个值没有类型限制， 字符串、数字、列表等都可以返回

　　      如果return 后面跟多个值 ， 将返回一个元组，里面包含多个值

也可以有多个return，但是只能执行一次，函数就结束调用，并且会吧return后的值作为函数执行的结果返回。

什么时候该有返回值？
　　　　调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值。
　　　　通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果。
什么时候不需要有返回值？
　　　　调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值。
　　　　通常无参函数不需要有返回值。

函数的使用，两个阶段

　　1、先定义 :  def  func-name(空，或者参数1，参数2，。。。):

　　　　　　　　　func

　　　　　　　　　ruturn 值

　　2、再调用 :  func-name()

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

函数在调用阶段，找已经定义的函数的名字，执行函数的内容

函数名和变量名：

　　本质一样，都是名字，函数的定义与变量的定义类似，没有事先定义变量，而直接引用变量，会报错

　　没有事先定义函数，而直接引用函数，相当于在引用一个不存在的变量名。

　　函数名加括号可以传参，变量名不行

定义函数的三种形式：

无参函数：应用场景仅仅只是执行一些操作，比如与用户交互、打印，一般就是一些可执行的语句，普通操作等等

有参函数：需要根据外部传进来的参数，才能执行响应的逻辑，比如统计长度、求最大值等等

空函数： 设计代码结构，编程的一种思路

　　def bar():

　　pass

 1 #有参函数，注意返回值用return
 2 #求最大值
 3 def my_max(x,y):
 4     if x > y:
 5         # print(x)    #若为print   则返回的值不能赋值给变量
 6         return x
 7     else:
 8         # print(y)
 9         return y
10
11 res=my_max(1,2)
12 print(res)

函数调用的三种形式（如上例）：

调用函数的语句形式　：  my_max(1,2)

调用函数作为表达式　：  my_max(1,2)*10

将函数作为另一个函数的参数   ：   my_max(my_max(1,2) ， 3）

函数参数：

　　形参 ： 形式上的参数，不占内存空间，实际上就是变量名

　　实参 ： 实际存在的参数，占内存空间，实际上就是变量值

在定义函数阶段，函数括号内的参数是形参

在调用函数阶段，函数括号内的参数是实参　　

变量名和变量值是绑定关系，再调用阶段，实参（变量值）才会绑定到形参（变量名），调用结束后，解除绑定。

参数的分类：

　　位置参数 ：按照从左到右的顺序，依次定义的参数

　　　　位置形参：必选参数，必须被传值，多一个不行，少一个也不行

　　　　位置实参：按照位置给形参传值，与形参按照位置一一对应

　　关键字参数---关键字实参：无需按照位置为形参传值

　　        按照name = value 的形式定义的实参，指名道姓的给name传值    fun(age = 18 , name= 'lalal')

　　注意的问题：

　　　　　　1. 关键字实参必须在位置实参右面

　　　　　　2. 对同一个形参不能重复传值

　　位置实参必须在关键字实参前面，关键字参数只能放在位置实参后面。

　　形参 在什么情况下 必须被定义  ， 每次都需要一个不同的值， 就要定义成位置参数。

形参 默认参数是 ， 值是固定的，每次调用都可以不传值。

　　默认参数需要注意的问题：

　　　　问题一：默认参数要在位置参数之后，否则报错

　　　　　　def   foo(x ， y=1)

　　　　　　　　print(x,y)

　　　　问题二：默认参数，只在定义阶段赋值一次，而且，仅赋值一次。

　　　  问题三： 默认参数的值，应该定义成不可变类型

　　默认参数：形参在定义时就已经为其赋值

        可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
        注意的问题：
                1. 只在定义时赋值一次
                2. 默认参数的定义应该在位置形参右面
                3. 默认参数通常应该定义成不可变类型

可变长参数： 指的是 实参的个数多了，不固定（实参有位置实参和关键字实参两种）

形参必须要两种机制来分别处理

按照位置定义的实参溢出的情况：  *变量名    （通常   *args）     *就到表多出来的位置参数

按照关键字定义的实参溢出的情况： **变量名    （通常 **kwargs）

可变长指的是实参值的个数不固定
而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

 1 #可变长位置实参
 2 def foo(x,y,*num):
 3     print(x)
 4     print(y)
 5     print(num)
 6 foo(2,4,6,8,9,3,5,)
 7
 8 #结果
 9 2
10 4
11 (6, 8, 9, 3, 5)    #多出来的参数，会组成一个元组，赋值给num

 1 #可变长关键字实参 **
 2 def foo(x,y,**num):
 3     print(x)
 4     print(y)
 5     print(num)
 6 foo(x=5,y=7,z=0,d=8,k=9,s=2,)
 7
 8 #结果
 9 5
10 7
11 {'z': 0, 'd': 8, 'k': 9, 's': 2}    #多余的关键字实参，会组成一个字典，赋值给num

扩展用法

　　若遇到实参里面有*的参数，把参数打回原形，再传参　

1 def foo(x,y):
2     print(x)
3     print(y)
4 #foo(2,4,*(6,8,9,3,5,))    #实参中有*号，表示的是多余的位置实参，打回原形相当于  foo(2,4,6,8,9,3,5,)，则最终会报错
5 foo(2,*(6,))   #若实参的个数刚好和形参一一对应，则可以正常赋值，不报错
6
7 #结果
8 2
9 6

命名关键字参数：在*后面定义的形参称为命名关键字参数，必须是被以关键字实参的形式传值

 1 #这俩东西 *args，**kwargs做什么用？？？
 2 def register(name,age,sex='male'):
 3     print(name)
 4     print(age)
 5     print(sex)
 6
 7 ##装饰器概念（不改源代码的情况下，满足要求），一个函数调用另一个函数
 8 def wrapper(*args,**kwargs): #万用形参，不过切记，位置参数在关键字参数前面
 9     print(args)
10     print(kwargs)
11     register(*args,**kwargs)    #调用另一个函数
12 #     register(*(1, 2, 3),**{'a': 1, 'b': 2})
13 #     register(1, 2, 3,a=1,b=2)
14
15
16 wrapper('lalala' , 28)    #实参是什么就原生态的传给register什么

 

练习：

函数对象：  函数是第一类对象，可以被当做数据传递

被赋值

可以当做参数传入

可以当做函数的返回值

可以当做容器类型的元素

 1 '''
 2 阶段性练习
 3 1、写函数，，用户传入修改的文件名，与要修改的内容，执行函数，完成批了修改操作
 4 2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
 5
 6 3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
 7
 8 4、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
 9
10 5、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
11
12 6、写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
13 dic = {"k1": "v1v1", "k2": [11,22,33,44]}
14 PS:字典中的value只能是字符串或列表
15 '''
16
17 #======================>>
18
19
20 #题目一
21 def modify_file(filename,old,new):
22     import os
23     with open(filename,'r',encoding='utf-8') as read_f,\
24         open('.bak.swap','w',encoding='utf-8') as write_f:
25         for line in read_f:
26             if old in line:
27                 line=line.replace(old,new)
28             write_f.write(line)
29     os.remove(filename)
30     os.rename('.bak.swap',filename)
31
32 modify_file('/Users/jieli/PycharmProjects/爬虫/a.txt','alex','SB')
33
34 #题目二
35 def check_str(msg):
36     res={
37         'num':0,
38         'string':0,
39         'space':0,
40         'other':0,
41     }
42     for s in msg:
43         if s.isdigit():
44             res['num']+=1
45         elif s.isalpha():
46             res['string']+=1
47         elif s.isspace():
48             res['space']+=1
49         else:
50             res['other']+=1
51     return res
52
53 res=check_str('hello name:aSB passowrd:alex3714')
54 print(res)
55
56
57 #题目三：略
58
59 #题目四
60 def func1(seq):
61     if len(seq) > 2:
62         seq=seq[0:2]
63     return seq
64 print(func1([1,2,3,4]))
65
66
67 #题目五
68 def func2(seq):
69     return seq[::2]
70 print(func2([1,2,3,4,5,6,7]))
71
72
73 #题目六
74 def func3(dic):
75     d={}
76     for k,v in dic.items():
77         if len(v) > 2:
78             d[k]=v[0:2]
79     return d
80 print(func3({'k1':'abcdef','k2':[1,2,3,4],'k3':('a','b','c')}))