#函数

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 y10 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 210 411 (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 510 711 {
   '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 29 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 os23     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']+=145         elif s.isalpha():46             res['string']+=147         elif s.isspace():48             res['space']+=149         else:50             res['other']+=151     return res52 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 seq64 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 d80 print(func3({
   'k1':'abcdef','k2':[1,2,3,4],'k3':('a','b','c')}))