Python学习之路（六）：基础知识之函数

1.函数语法

函数是对功能的封装

语法：def 函数名()

函数体

函数名() =--->调用函数

2.返回值

（1） 如果无函数体，不写return，没有返回值

（2） 如果在函数体中间或这末写return，返回的是None

  (3) 在函数中写 return 值,返回一个值，多个返回值接受到的是元组

3.参数

函数执行的时候给函数传递信息

• 形参：函数声明的位置的变量
• 实参：函数调用的时候的具体的值
• 传参：把实参交给形参的过程

3.1 实参

1)位置参数

 

def chi(good_food, no_good_food, drink, ice_cream)
    print(good_food, no_good_food, drink, ice_cream)
chi('法国鹅肝', '飞龙大辣片', '大白梨', '哈根达斯')

按照形参的参数位置给形参传参，当参数很多时，需要记住参数的位置

2)关键字参数

 

def chi(good_food, no_good_food, drink, ice_cream)
    print(good_food, no_good_food, drink, ice_cream)
chi(drink="神仙水", ice_cream="老彬棍", good_food="盖浇饭", no_good_food="大烂片")

根据形参的参数名给形参传参

3)混合参数

前两者混合使用

 

def chi(good_food, no_good_food, drink, ice_cream)
    print(good_food, no_good_food, drink, ice_cream)
chi('法国鹅肝', '飞龙大辣片', drink="神仙水", ice_cream="老彬棍")

在运用是必须先写位置参数，后写关键字参数，否则关键字参数会占位置参数的位置

(2) 形参

1) 位置参数

2) 默认参数

 

def regist(name, phone, gender='男')  # 在变量声明的时候给定实参，默认值参数必须在参数列表的末尾
    print(name,phone,gender)
regist('Shiledon', '1010011010')
regist('Richil', '5545', '女')  # 不适用默认值时另给定实参

3)动态参数

*args

表示接收位置参数的动态传参，，接收到的数据类型是元组

def chi(*food):  #函数名是food，*表示动态传参
    print(food)
chi('可乐', '馒头', '酱油')

各类参数的位置：位置参数==> *args ==> 默认值参数

def chi(name, *food, location='天津'):
    print(name, *food, location)
chi('刘大哥', '玉米', '土豆')

**kwargs

关键字的动态传参：

def chi(**food):
    print(food)
chi(good_good='盖浇饭', no_good_food='卫龙', drink='可口可乐')

顺序：位置参数==> *args ==> 默认值参数 ==> **kwargs

4.文档注释

文档注释也可以称为函数注释：

 

def func(a, b):
    """
    这一行用来解释这个函数的功能
    :param a: 第一个参数值
    :param b:第二个参数值
    :return:返回值
    """
    return a+b

print(func(1, 4))
print(func.__doc__)
print(str.__doc__)  #可以看其他类型数据的文档注释

 

5.聚合和打散

def func(*food):  #这里是将所有的food参数聚合到一个元组中
    print(food)
lst = ['煎饼果子', '来一套', '美滋滋']
func(*lst)  # 这个时候是将传参列表中的元素打散，方便传参,可以打散list,tuple,dic,set

def func(**food):
    print(food)
dic = {"good_food":"煎饼果子", "no_good_food":"辣条"}
func(**dic)  #字典打散成关键字参数

6.函数名

 

1.函数名也可以当作变量名进行使用

def func_1():
    print('我是1')
def func_2():
    print('我是2')

def func_3():
    print('我是3')

lst = [func_1, func_2, func_3]
for el in lst:
    el()

2.函数名可以作为参数传递给函数

def my():
    print('我是my')
def proxy(fn):  # proxy代理
    print('在处理之前')
    fn()
    print('在处理之后')

proxy(my)

# 结果：在处理之前
#       我是my
#       在处理之后

3.函数可以作为返回值

def func():
    print('我是func')
    a = 10
    def inner():
        print('我是inner')
    return inner  # 返回函数inner的内存地址
print(func())

如果要执行inner()：

def func():
    print('我是func')
    a = 10
    def inner():
        print('我是inner')
    return inner  # 返回函数inner的内存地址
ret = func()
ret()

7.名称空间

在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, 至于函数内部的变量和逻辑, 解释器是不关心的. 也就是说一开始的时候函数只是加载进来, 仅此而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开辟变量的内部空间. 随着函数执行完毕, 这些函数内部变量占用的空间也会随着函数执行完毕而被清空。

命名空间分类:

​ 1. 全局名称空间—> 我们直接在py文件中, 函数外声明的变量都属于全局名称空间

​ 2. 局部名称空间—> 在函数中声明的变量会放在局部名称空间

​ 3. 内置名称空间—> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置名称空间　　

 

 

全局名称空间
a = 10  # 全局名称空间中的内容
def func():  # func()也在全局名称空间中 ==> 顶格
    b = 10  # b为局部变量
    return a*b
def func_1():
    print(a)
print(func())
func_1()
python的命名空间：内置变量==> 全局变量 ==> 局部变量(函数调用的时候产生)

 

a = 10
def fn():
    b = 20
    def gn():
        pass
        print(globals())
        print(locals())
    gn()  # 局部的函数要在内部进行调用
fn()

global

a = 10
def fn():
    global a  # global可以将全局中的内容引入到函数内部
    a = 20
fn()
print(a)

a = 10
def fn():
    global a  # global可以将全局中的内容引入到函数内部
    
    a += 10  # 此时局部没有变量a，会将全局的a引入到局部,先进行a+10然后赋值
    #  给a，但是a是全局变量，不能修改，所以程序不能执行，所以应该加入global
fn()
print(a)

nonlocal

def outer():
    a = 10
    def inner():
        nonlocal a  # 寻找外层函数离它最近的变量
        a = 20
    inner()
    print(a)
outer()

8.闭包

 

闭包：在内层函数中访问外层函数的变量

 

def outer():
    a = 10
    def inner():
        print(a)
    inner()
outer()

 

闭包的作用：

1.可以保护变量不受侵害

def outer():
    a = 10  # 函数内部的变量a对于外界是不开放的
    def inner():
        nonlocal a
        a = 20
        print(a)
    inner()

2.可以让一个变量常驻内存

def outer():
    a = 10  # 常驻内存，为了inner执行的时候有值
    def inner():
        print(a)
    return inner
fn = outer()
fn()

可以用closure查看是否闭包：

def func():
    a = 10
    def inner():
        print(a)
    print(inner.__closure__)  # 如果打印的是None,则不是闭包

func()

 9.匿名函数

 匿名函数是函数的一种简略表达，语法为：

lambda 参数: 返回值

# 一般的函数：
def func(n):
    return n * n

ret = func(9)
print(ret)

# 匿名函数:

a = lambda n : n*n
ret = a(9)
print(ret)

匿名函数举例：

suiyi = lambda x, y : (x, y)
print(suiyi(1, 3))

匿名函数还可以进行动态传参：

fn = lambda *args: max(args)

print(fn(1, 2, 7, 9, 22))

 10.函数的递归调用

 函数的递归调用是指在函数体内调用函数本身：

 

# 这是一个函数递归调用的例子，可以用来测试递归深度，官方指出最大1000次递归
count = 1
def func():
    global count
    print('111', count)  


    count = count + 1
    func()
func()