python基础之函数详解

Python基础之函数详解

一、函数的定义

到现在为止,我们已经掌握了Python的基本语法和数据类型等相关基础知识了,以进行一个项目的编写了,这个时候,就会发现,很多代码需要我们进行复制粘贴,这简直就是损害我们小文艺的脸面啊,这个时候,我们就需要向函数求助了。

函数的三大优点:

  1. 代码不冗余
  2. 可阅读性高
  3. 可维护性,可拓展性得到提升。

函数定义会发生什么呢?

  1. 先向内存申请一块空间将函数体的内容存放进去
  2. 将函数体的内容和函数名绑定一起
  3. 程序在执行到定义函数的阶段,只识别语法,不会执行函数体的内容

那么函数的语法是什么呢?

def 函数名(有无参数都可以):
"""描述性信息"""
代码块
return 值。
  1. def:这是定义函数的关键字
  2. 函数名:遵循变量名的定义,最好对函数有一个功能性介绍(动词为主)
  3. 括号:内部可以选填参数
  4. “”“描述性信息”“”:可有可无,但是推荐使用,对函数体的功能进行描述
  5. return:可有可无。给出返回值

二、函数的调用

使用函数要遵循一个原则:这个原则就表明了它的内部的一些现象:大家一定要记牢:先定义后使用。是不是很熟悉,没毛病,这就是变量的使用原则。

函数名实际上跟“变量名”有些相似,都是储存一个内存地址,当我们调用函数的时候,最最基本的方式就是函数名加括号的方式。

def func():
pass # 最最基本的调用方式。
func() def func(a,b):
pass # 函数体有参数的方式
func(1,2)

三、函数返回值

这时候就不得不讲一下return的作用了,如果我们把函数当做一个工厂,那么参数就是我们送到工厂的原材料,而工厂生产出来的东西就是我们return的值了。他可以是任意数据类型,当函数运行结束的时候,我们可以对其进行赋值,就可以得到我们的产品了。

# 当函数没有return 值的时候,默认返回值为None
def func():
pass
v= func()
print(v) # None # 当只有一个return,但是并没有写返回值的时候,默认返回值也是None
def func():
return v= func()
print(v) # None # 当函数有返回值的时候,对其调用进行赋值会得到返回值。
# 返回值可以是单个,也可以是多个
def num_sum(a,b):
return a+b sums = num_sum(1,2)
print(sums) # 3

return 的作用不止如此,他也是函数终结者。当函数体中运行到return的时候,就会终止函数的运行,不会执行return之下的代码。

当然,我们还可以将函数的返回值当做参数传给另外一个函数,因为返回值的本质就是一个变量值。

四、函数的参数

当我们在定义有参函数的时候,括号内部的参数相当于变量名,而在函数调用的时候,传进的值将内存地址绑定给定义阶段的参数。

在定义阶段,函数括号内的参数称为形参。

在调用阶段,函数括号内的参数称为实参。

参数可以有好几种形式表现,比如单个数据类型、key=value、函数等,但是其核心概念就是传入的是个值。

4.1 位置参数

位置形参函数在定义的时候是按照从左到右依次定义的参数。特点是必须被传值,不能多也不能少。

位置实参:函数在调用的时候是按照从左到右依次定义的参数。特点是按顺序与形参一一对应。

# 特点:必须被传值,多少给参数都不行。

def func(x,y):  # 括号内就是位置形参
print(x,y) func(1,2,3) # 过多的位置实参被传
func(1,) # 太少的位置实参
func(1,2) # 完美

4.2 关键字参数

我们还可以利用key=value的形式进行传参,调用阶段的参数是关键字参数。关键字可以指定形参进行传值,可以不参照顺序。

# 关键字参数:按照key=value的形式传入当做参数。
def func(x,y=2): # 默认参数
print(x,y) # func(y=2,x=1) # 关键字实参
# func(1,2)

默认参数在定义阶段已经被赋值了,所以在调用阶段可以不必为该参数传值,当然,如果要是进行传值的话,会以传的值为准。

实参:位置实参和关键字参数的混合使用

混合使用的话,一定要注意一下两点:

  1. 位置实参必须放在关键字实参之前。
  2. 不能为同一个形参重复传参。

形参:位置形参和默认参数的混合使用

形参中的混合使用需要注意:

  1. 位置形参必须在默认参数之前。
  2. 默认参数是在定义阶段就被传入的值的内存地址
  3. 建议默认值不推荐使用可变数据类型

4.3 可变长度参数

4.3.1 可变长度形参

如果我们在调用函数的时候,如果传入的实参过多,就回出现错误,但是我们可以使用(*+形参名)或者(**形参名)来接受过多的实参。

原则上形参名可以是任意名,但是约定俗成通常为(*args)和(**kwargs)。

  1. *args。用来接受位置实参。多出来的实参会被保存成元祖。
  2. **kwargs。用来接受关键字参数。多出来的实参会被保存成字典。

当然,在函数内部使用的时候,是不带星号的。

在定义的时候请务必放到默认参数之后。*args在**kwargs之前。

# *args的使用
def foo(x,y,*args):
print(x,y,args) foo(1,2,3,4,5,6) # 1 2 (3,4,5,6) # **kwargs的使用
def foo(x,y,**kwargs):
print(x,y,kwargs) foo(1,2,a=3,c=4) # 1 2 {"a":3,"c":4}

4.3.2 星号在实参上的应用

多出来的实参有*args和**kwargs接受,那么如果在调用的时候就给实参加上星号会有什么结果呢?

如果我们给实参前加上星号,本质是将该实参进行循环,然后得出的值当做实参传入形参。当然*args后可以跟多个可循环的数据类型,如果是字典只传入key。**kwargs只能使用字典,代表的是将key=value的格式传入。

# 在字典上的应用。
def func(x,y,z):
print(x,y,z) func(*{'x':1,'y':2,'z':3}) # func('x','y','z')
func(**{'x':1,'y':2,'z':3}) # func(x=1,y=2,z=3)

当然,传入的实参数量要和形参数量相同,不然会出现错误。

4.3.3 星号的综合应用

def index(x,y,z):
print(x,y,z) def foo(*args,**kwargs): # (1,2)传给args,{"z":3}传给kwargs
# *args将(1,2)转成1,2。**kwargs将{"z":3}转成z=3,然后传入index函数做参数
index(*args,**kwargs) foo(1,2,z=3)

当函数定义的参数为*args,**kwargs时,代表函数可以接受任意符合格式的实参,上述的函数调用foo的本质是调用index函数。

4.4 命名关键字参数

这个参数使用的比较少,在定义形参的阶段,如果某些参数出现在星号之后,那么这些参数就被称为命名关键字参数。

# 命名关键字参数
def func(x,y,*,a,b): # a,b就是命名关键字参数
print(x,y,a,b) def foo(x,y,*,b=1,a): # 命名关键字参数是不用按key=value在单个值之后的顺序
print(x,y,a)

注意,由于命名关键字参数位于星号之后,所以如果不用关键字实参的话,其值是传不进去的,因此必须的用指名道姓的方法传参数,而且调用的时候还必须被传值。

4.5形参和实参的顺序

形参的顺序:位置形参、默认参数、*args、命名关键字参数、**Kwargs。

实参的顺序:位置实参、*args、关键字参数、**kwargs。

五、函数闭包函数

在了解闭包函数之前,我们是需要一些储备知识的。然后,你不知不觉就一边蒙逼一边明白什么是闭包函数了。

5.1 函数的应用。

# 1、函数可以赋值,因为函数名本身引用着函数体的内存地址。
def foo():
pass f = foo # 2、可以把函数当做参数传递给另外一个函数。
def func():
print() def foo(x):
print(x) foo(func) # 3、可以当作另一个函数的返回值。
def f1():
return foo # 4、可以当作容器类型的一个元素。
def foo():
pass l = [foo,1,a]

其实看着有这么多应用,但是大家发现没有,函数名其实就是一个变量名,凡是变量名能做到的它都能做到。这点很重要哦。

5.2 函数的嵌套

函数的嵌套共有两种。

# 1、函数的嵌套调用。即在调用一个函数的时候,在其内部又调用另外一个函数。
def foo():
pass
def func():
foo() # 2、函数的嵌套定义。即在定义一个函数的时候,在其内部又定义另外一个函数。 def func():
def foo():
print(1)

5.3 闭包函数

首先上面都是闭包函数的铺垫。

明确一个概念:闭包函数= 名称空间与作用域+函数嵌套+函数对象。

  1. 闭:该函数是内嵌函数。这字说明了该函数所处的位置,肯定是嵌套函数中的定义函数。

  2. 包:指该函数包含对外层函数作用域名字的引用。注意,自己本身不含有,只有外部函数有。

是不是看不懂,接下来看个例子、

# 闭函数:名称空间与作用域+函数嵌套
def outer():
x = 1111
def inter():
print(x)
inter()
x = 22222
outer()

当我们在外界去调用inter函数的时候,由于名称空间与作用域的查找关系(按照定义的时候的查找顺序)的原因,不管我们在外界定义的是否含有x ,他都会使用outer内定义的变量。

# 闭包函数:名称空间与作用域+函数嵌套+函数对象
def outer():
x = 1111
def inter():
print(x)
return inter
f1 = outer() f1()

注意,是把函数名当做变量来用,return后返回的inter是一个函数的内存地址,如果加上括号就是执行函数功能的意思。所以一定不能加括号。在运行Outer的时候,返回一个内部函数名,然后复制给一个全局变量,然后该全局变量就被绑定了inter函数的内存地址,当该函数名后加括号的话,就相当于执行了inter()。

这样我们就可以在任意地方调用函数的局部名称空间。

当然,你也可以把x当做参数进行传递。但是原理一定要搞清楚,因为这是接下来的重点内容的铺垫。

六、装饰器

当我们的软件已经在线上运行的时候,需要拓展新的功能,那么我们 应该怎么办呢?首先我们要提到开放封闭原则。

  1. 开放原则:对拓展功能是开放的。
  2. 封闭原则:对修改源代码则是封闭的。

也就是说我们既不能更改函数的源代码,也不能更改调用方式,这个时候,我们就要用到装饰器了。

装饰器:为函数增加额外的功能且不更改调用方式的函数。

6.1 无参装饰器

下面我们进行循序渐进的讲解,究竟是怎么用到装饰器的,他又是怎么做到的符合开放封闭原则的。我们以为一个函数增加一个计算运行时间的功能为例来进行推导。

import time

def foo(x):
print("其实我这里有很多代码,但是你看不到")
time.sleep(3)
return x # 1、我们直接在函数内部进行更改。
def foo(x):
start_time = time.time()
print("其实我这里有很多代码,但是你看不到")
time.sleep(3)
stop_time = time.time()
process_time = stop_time - start_time
print(process_time)
return x

这时候虽然我们增加了功能,但是我们已经违反了开放封闭原则,所以失败。

# 2、利用函数的嵌套定义来直接增加新功能

def outer(x):
start_time = time.time()
foo(x)
stop_time = time.time()
process_time = stop_time - start_time
print(process_time)
return x

我们同样实现了功能,调用方式改变,源代码没变。

# 3、利用闭包函数来修改

def outer(foo):
def inter(x):
start_time = time.time()
res = foo(x)
stop_time = time.time()
process_time = stop_time - start_time
print(process_time)
return res
return inter foo = outer(foo)
foo(x)

上述已经实现了不更改函数源码,不更改调用方式了,但是函数被写死了,如果用来修饰多个函数呢?这些函数又有不同个数的参数呢?

# 终极版装饰器的诞生。
def outer(func):
def inter(*args,**kwargs):
start_time = time.time()
res = func(*args,**kwargs)
stop_time = time.time()
process_time = stop_time - start_time
print(process_time)
return res
return inter foo = outer(foo)

这是利用星号在形参和实参不同的作用来实现的。

自此,装饰器就写好了,遵守开放封闭原则,让用户在不知情的情况下,完成了函数的更新。要想掌握装饰器,必须弄懂闭包函数这些前置只是,如果还是不太懂,就继续看看闭包函数板块和参数的知识。

# 装饰器的模板。
def outer(func):
def inter(*args,**kwargs):
res = func(*args,**kwargs)
return res
return inter

添加装饰器的时候,可以根据模板然后在inter函数里面添加相关功能。

当然,还有一点就是语法糖的使用,我们可以将装饰器的赋值转成在被修饰函数上一行添加@装饰器名。

# 语法糖:在被修饰函数上一行添加@装饰器名。
@outer
def foo(x):
print(x)

6.2 有参装饰器

当用户进行身份验证时,有的函数要从info文件里得到信息,有的则是从数据库等等,那么如何让让一个装饰器实现那么多功能呢?我们都能想到,那就再给装饰器一个状态参数呗,要知道,之前为了伪装成被装饰参数,内部函数的参数已经固定,外部参数虽然也可以进行参数赋值,但是由于语法糖的存在,导致我们如果在外部函数增加参数之后,语法糖就不能使用了。

综上,我们还可以再次利用给函数传参的两种方式中的第二种,在函数外在套一层,此时的炸U那个时期已经是三个函数定义了。

# 语法糖的实际效果相当于执行了这一步:与被修饰函数名相同的全局变量 = 装饰器(被装饰函数名)
@outer # foo = outer(foo)
def foo():
print("1") # 有参装饰器的模板 def auth(参数):
def outer(func):
def wrapper(*args,**kwargs):
res = func(*args,**kwargs)
return res
return wrapper
return outer @auth("参数")
def foo():
print(123)

当程序运行到语法糖时,由于函数名加括号,开始执行函数返回outer的内存地址,所以实际上语法糖依然是@outer。不过是多执行了一步函数将参数传到内部函数的名称空间而已。

6.3多个装饰器的运行原理

def outer1(func):
def wrapper1(*args,**kwargs):
res = func(*args,**kwargs)
return res
return wrapper def outer2(func):
def wrapper2(*args,**kwargs):
res = func(*args,**kwargs)
return res
return wrapper2 def outer3(func):
def wrapper3(*args,**kwargs):
res = func(*args,**kwargs)
return res
return wrapper3 @outer1 # foo = outer1(foo)= wrapper1的内存地址
@outer2 # foo = outer2(foo)= wrapper2的内存地址
@outer3 # foo = outer3(foo) = wrapper3的内存地址
def foo():
print("123")

加载顺序:outer3>outer2>outer1

执行顺序:outer1==>outer2>outer3

七、递归函数

递归函数的本质就是循环,在运行函数体期间一直在不停地调用自己。在Python解释器中,递归有一个最大限制,超过这个限制就会报错。

# 递归的直接调用
def foo():
print("一直循环我会报错")
foo() # 递归的间接调用
def foo1():
print("我是正常的函数,调用了foo我就不正常了")
foo()

递归函数在调用自己的时候又两个过程

  1. 回溯:在函数中不停地调用自己的过程
  2. 递推:在函数满足条件退出函数之后,不停地将已打开的函数结束的过程。
# while循环
count = 0 while count <5:
print(count)
count += 1 # 改成递归函数之后 def cou(count):
if count > 4:
return
print(count)
count += 1
cou(count) cou(0)

据我观察,递归函数应该是主要应用在需要参数且多次循环的场景之上。

八、函数的类型提示

这是一个可用可不用的一个提示。

def foo(x:str,y:"这里面应该写整数",z:list=[1,2,3]):
pass

形参后面加个冒号然后可以写一些提示性信息,声明一下数据类型等,但是如果你不按照规定传参,函数也不会报错,因为这个规定本来就是自己定的 ,但是你打破了这个自己提示的类型,那你声明干嘛呢,,就像调皮的用户,哈哈哈

上一篇:HDU 1560 DNA sequence(IDA*)


下一篇:【转】Building a RESTful Web Service