python学习随笔_函数

Posted 2021-01-03 springquanquan

函数    #作用:封装和复用
    数学定义：y=f(x) ，y是x的函数，x是自变量。y=f(x0, x1, ..., xn)
    Python函数
        由若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元
        完成一定的功能

    函数的作用
        *结构化编程对代码的最基本的封装*，一般按照功能组织一段代码
        封装的目的为了复用*，减少冗余代码
        代码更加简洁美观、可读易懂
    函数的分类
        内建函数，如max()、reversed()等
        库函数，如math.ceil()等

函数定义、调用
    def语句定义函数
    def 函数名(参数列表):
        函数体（代码块）
        [return 返回值]
        函数名就是标识符*，命名要求一样
        语句块必须缩进，约定4个空格
        Python的函数没有return语句，隐式会返回一个None值
        *定义中的参数列表成为*形式参数*，只是一种符号表达，简称形参
    调用
        函数定义，只是声明了一个函数，它不会被执行，需要调用
        调用的方式，就是函数名加上小括号，括号内写上参数
        *调用时写的参数是*实际参数*，是实实在在传入的值，简称实参

定义时是形参,调用时是实参,调用加小括号

python是动态的,强类型语言
因为是动态的,参数没有定义类型,会带来很大问题(自由工业化开发会带来问题)
无法限制参数类型,除非进行判断
能不能控制这个?是解决团队的问题

函数参数
    参数调用时传入的参数要和定义的个数相匹配（可变参数例外）
    位置参数
        def f(x, y, z) 调用使用 f(1, 3, 5)#顺序对应,个数也要相同#传参,传入实参
        按照参数定义顺序传入实参
    关键字参数    #谁等于谁就是关键字传参(keyword)
        def f(x, y, z) 调用使用 f(x=1, y=3, z=5)    #顺序可以不一样,因为可以按名字找
        使用形参的名字来出入实参的方式，如果使用了形参名字，那么传参顺序就可和定义顺序不同
    传参
        f(z=None, y=10, x=[1])
        f((1,), z=6, y=4.1)
        f(y=5, z=6, 2) #位置参数必须在前,keyword在后是可以的
        要求位置参数必须在关键字参数之前传入，位置参数是按位置对应的


函数参数默认值    #记得时候可以记带等号不可以放前面
  参数默认值（缺省值）
  定义时，在形参后跟上一个值
def add(x=4, y=5):
return x+y
测试调用 add(6, 10) 、add(6, y=7) 、add(x=5) 、add()、add(y=7)、 add(x=5, 6) #这个不可以、add(y=8,
4)、add(x=5, y=6)、add(y=5, x=6)
测试定义后面这样的函数 def add(x=4,y)#非缺省跟在非缺省后不可以(记得时候可以记带等号不可以放前面)
  作用
  参数的默认值可以在未传入足够的实参的时候，对没有给定的参数赋值为默认值
  参数非常多的时候，并不需要用户每次都输入所有的参数，简化函数调用
  举例
  定义一个函数login，参数名称为host、port、username、password
函数参数默认值
 

  在形参前使用*表示该形参是可变参数，可以接收多个实参
****收集多个实参为一个tuple***


可变类型和解构类型,但不全相同(keyword-only)

def fn(*args,x,y,**kwargs)
(x,y)属于keyword-only:在后面 必须定义关键字传参
可以用缺省值,必须使用关键字传参#经常给keyword-only定义缺省值
def add(*,x,y):    #逗号标志后面的是keyword-only


***总结定义形参和传参的几种类型(定义时是形参,调用时是实参)
定义形参:,位置参数,可变位置参数(封装成元组tuple),可变关键字传参(封装成dict字典)


定义传参:位置传参,关键字传参,混着用的时候:位置传参在前,关键字传参在后

普通位置传参:位置传参和关键字传参都支持但是位置传参在前
可变参数:
    可变位置传参:不允许关键字传参,只可以写在一起让可变参数对应#add(1,2,3,4)

    可变关键字传参只收集关键字传参,不可以位置传参


位置参数往放前(可变的也要放前),关键字参数放后(记带星的放后星星放最后)

传参时对应形参必须只有一个,全是关键字传参可以不考虑顺序


函数参数
    参数规则
***参数列表参数一般顺序是，普通参数、缺省参数、可变位置参数、keyword-only参数（可带缺
省值）、可变关键字参数
模版:def fn(x, y, z=3, *arg, m=4, n, **kwargs):
print(x,y,z,m,n)
print(args)
print(kwargs)


参数解构
***只能在参数传参中运用
    传参的时候才解构,解构出元素作为实参

  非字典类型使用*解构成位置参数
****字典类型使用**解构成关键字参数
字典解构:一个*解key,**解字典
add(*{‘a‘: 5, ‘b‘: 6})#解构后为x = ‘a‘,y = ‘b‘
#add(**{‘a‘: 5, ‘b‘: 6})#解构后为‘a‘ = 5,‘b‘ = 6

函数默认return none,如果想要函数有返回值修改return

------------------------------------------------------------------------------------------------------------------------------------

函数返回值
return 语句
一个函数只有一条return语句

多分支结构可以有多条return,但只能执行一条return
#多分支结构可以设置个变量,最后return变量,可以省着每次分支都写return
if..ret=..else..ret=..最后return ret

函数可以返回值可以不同类型
一个函数只要碰到return就立即返回终止

函数默认return none,往往函数需要写return

return返回必须是一个值,不是一个会被它封装成一个元组
返回多个值包在容器中  得到它们使用解构一一对应
---------------------------------------------------------------------------------------------------------------------------
作用域****
嵌套函数
    函数内部的函数不可以在外部单独执行#因为在外部没有定义,报NameError

    在外部的函数可以调用嵌套在内的函数

****###函数是有可见范围的,这就是作用域

函数内部的标识符(变量),外部是不可见的


函数定义直接过,执行时看前面定义有没有用到变量

函数内部
x = 5
def show():
    x += 1#报错
    print(x)
show()

x = x +1    #在函数内部要先定义,要不然会说内部没有定义
    #右边x+1,赋值即重新定义,赋值要先算右边,
    #右边是内部本地变量(本地作用域),x要重新定义

嵌套函数:赋值即重新定义,但是是定义自己的变量

全局作用域    #在整个运行环境中都可见

局部作用域(local)    #在函数和类等内部中可见

---------------------------------------------------------------------------------------------------------------------------
全局作用域(了解,写函数基本不用,改动影响太大)
global x    #使用全局作用域变量
    #尽可能放在前面第一行

global 用在局部作用域中定义一个全局作用域中操作变量
但是global只影响当前作用域

函数应该用定义形参,传参这种形式用,尽量不要用global

---------------------------------------------------------------------------------------------------------------------------

闭包***#一般在有嵌套函数时候用

自由变量：未在本地作用域中定义的变量。例如定义在内存函数外的外层函数的作用域中的变量

本来变量在外层函数  内层函数用到了这个局部变量,闭包就已经产生


nonlocal    关键字
    #声明变量不在本地作用域中,但是在外层作用域中找,但是不会再全局作用域中找
    #形成闭包
    #一层层向外找但不在全局中找
    #不可在全局下一层中用(因为全局中的下一层可以直接用全局变量了)
形参可以当局部变量来看

---------------------------------------------------------------------------------------------------------------------------

默认值的作用域

函数也是对象,如果对象中包含引用类型时,会更改默认值,简单类型不会更改默认值

函数名.__defaults__        #查看默认值属性,使用元组保存所有位置参数默认值#使用元组位置就不会变
函数名.__kwdefaults__    #查看使用字典保存所有keyword-only参数的默认值,dict是关键字传参


缺省值函数默认的特殊属性,生命周期跟函数同样周期共消亡

缺省值只有自己的作用域的,要看缺省值指的是什么,如果指的是缺省值送给形参,形参的作用域就在函数内部,它是局部作用域中的局部变量

#default这个东西它又属于函数对象本身的特殊属性,它是放在函数对象上的
#函数对象是和函数定义相关的,函数在定义时它的标识符(形参)关联到它内存中创建的那一个函数对象上去了


默认值作用域为形参用,形参可以当函数的局部变量来看
如果形参可变的类型(如列表),(无缺省值)没有固定的缺省值,有缺省值也会变的
#有时候这个特性是好的，有的时候这种特性是不好的，有副作用

def foo(xyz=[], u=‘abc‘, z=123):
    xyz.append(1)
    return xyz
print(foo(), id(foo))
print(foo.__defaults__)
print(foo(), id(foo))
print(foo.__defaults__)#引用类型默认值改变


def foo(xyz=[], u=‘abc‘, z=123):
   #xyz = foo.__defaults__
    xyz = xyz[:] # 影子拷贝,简单类型空列表内存中新生成一份,内存地址不同
    xyz.append(1)
    print(xyz)
foo()
print(foo.__defaults__)
foo()
print(foo.__defaults__)
foo([10])
print(foo.__defaults__)
foo([10,5])
print(foo.__defaults__)#不改变默认值


def foo(xyz=None, u=‘abc‘, z=123):#使用不可变类型默认值
    if xyz is None:#使用默认值时创建列表
        xyz = []
        xyz.append(1)# 如果传入一个列表，就修改这个列表
    print(xyz)
foo()
print(foo.__defaults__)
foo()
print(foo.__defaults__)
foo([10])
print(foo.__defaults__)
foo([10,5])
print(foo.__defaults__)

第一种方法
    使用影子拷贝创建一个新的对象，永远不能改变传入的参数
第二种方法
    通过值的判断就可以灵活的选择创建或者修改传入对象
    这种方式灵活，应用广泛
    很多函数的定义，都可以看到使用None这个不可变的值作为默认参数，可以说这是一种惯用法


---------------------------------------------------------------------------------------------------------------------------

变量名解析原则LEGB        #一个名词的查找顺序就是LEGB,一层一层向外解析
LEGB规定了查找一个名称的顺序为：local-->enclosing function locals-->global-->builtin

Local，本地作用域、局部作用域的local命名空间。函数调用时创
建，调用结束消亡

Enclosing，Python2.2时引入了嵌套函数，实现了闭包，这个就
是嵌套函数的外部函数的命名空间

Global，全局作用域，即一个模块的命名空间。模块被import时
创建，解释器退出时消亡

Build-in，内置模块的命名空间，生命周期从python解释器启动
时创建到解释器退出时消亡。例如 print(open)，print和open都是内置的变量

---------------------------------------------------------------------------------------------------------------------------

函数的销毁
#函数的定义一般只做一次,除非你想把它覆盖掉再定义一次
#定义函数的目的就是复用,要明确为什么要销毁,不要轻易销毁

全局函数的销毁
     重新定义同名函数
    del 语句删除函数对象
    程序结束时

局部函数销毁
    重新在上级作用域定义同名函数
    del 语句删除函数名称，函数对象的引用计数减1
    上级作用域销毁时

 

--------------------------------------------------------------------------------------------------------------------------

递归函数

#栈和线程相关,栈是每个线程自己的空间
函数执行要压栈,一个落一个,函数局部变量也要压栈,用完后弹出
#局部变量,函数调用时创建,调用结束消亡

递归 Recursion
函数直接或者间接调用自身就是递归

递归一定要有退出条件 return 出一个结果
每次计算后也要return


import sys
print(sys.getrecursionlimit)    #查看递归层数

---------------------------------------------------------------------------------------------------------------------------

匿名函数

格式
    lambda 参数列表 : 表达式

map是生成一个惰性求值的

(lambda x : 0)(3)
冒号后面不可以用等号
---------------------------------------------------------------------------------------------------------------------------
生成器***
生成器generator

next()    #

生成器函数必须包含yield语句,生成器函数的函数体不会立即执行

协程    #非抢占式,轮询

yield from    #新语法从可迭代对象中一个个拿元素
for x in range(10)  =>   yield from range(10)
    yield x