python3-基础5

时间 2019-11-09

原文原文链接

#函数python

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

生活中要作某件事的时候，可能会用到各类工具，且能够重复使用。git

遇到这种状况，如何解决问题：编程

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

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

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

函数的分类工具

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

　　　　　　　　对于内置函数，咱们能够拿来就用而无需事先定义，如len(),sum(),max()设计

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

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

函数的定义语法：

关键字 def 来定义

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

　　　　　“注释”

　　　　　函数体

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

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

　　注释信息必定要有　

return :函数内部能够没有return，返回None，等同于 return None

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

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

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

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

函数的使用，两个阶段

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

　　　　　　　　　func

　　　　　　　　　ruturn 值

　　二、再调用 : 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 一、写函数，，用户传入修改的文件名，与要修改的内容，执行函数，完成批了修改操做
 4 二、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其余】的个数
 5 
 6 三、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
 7 
 8 四、写函数，检查传入列表的长度，若是大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
 9 
10 五、写函数，检查获取传入列表或元组对象的全部奇数位索引对应的元素，并将其做为新列表返回给调用者。
11 
12 六、写函数，检查字典的每个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')}))