Python课堂15——函数初识

---

前言

Python的数据结构到此就学习完了，接下来我们将进入Python的另一大类的学习，它们就是函数，它可以帮我们更加简化Python的代码，让我们的效率更加提高。

---

一、函数是什么？

示例引入：

# 编写一个登录程序
username = input('请输入账号：')
if username == 'Abner':
    print('登录成功!')
else:
    print('登录失败！')
# 问题：代码重复，不好进行修改，因此，我们就引入了函数这个功能。

在Python中，函数是一组语句的集合，用于执行特定的任务。函数可以被调用和重复使用，以便在程序中完成相同或类似的任务。如果在开发程序的时候，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数。

函数的定义以关键字"def"开始，然后是函数的名称，紧接着是一对括号内的参数列表（如果有参数的话），最后是一个冒号。函数的主体包含在缩进的块中，可以包含一系列的语句来完成特定的任务。

原则：先定义后调用

示例：

def login():
    username = input('请输入账号：')
    if username == 'Abner':
        print('登录成功!')
    else:
        print('登录失败！')
# 我的淘宝
login()  # 这样可以很方便的帮助我们用来调用函数
# 收藏夹
login()

二、基本操作

1.语法

'''
def 函数名():    函数名见名知意即可
	主体代码
函数名()  函数体的执行
'''

示例如下：

# 定义函数
def func():
    print('func函数里的print哈哈哈')   定义函数只检测函数体代码的正确性，不会执行。
print(func)  # # <function func at 0x000002171B5075E8>  直接打印函数名会拿到这个函数的内存地址。

# 调用函数
func()  # func函数里的print哈哈哈   只有调用之后函数体内的代码才会执行。

注意:定义函数之后一定要进行调用。

实例展示：（写一个函数，计算1-100的累计和）

def cumulative_sum():
    sum = 0
    for i in range(101):
        sum += i
    print('1-100的累加和是：',sum)
cumulative_sum()

2.函数的参数

1. 形式参数和实际参数
   形式参数：函数定义阶段的参数（形参）
   实际参数：在函数调用的时候传入的数值（实参）

为了满足用户个性化的需求，我们引入了函数的参数：
实例展示：（用户在调用函数的时候给到一个数字并计算1 - 这个数字的和）

def cumulative_sum(num):
    sum = 0
    for i in range(num + 1):
        sum += i
        print(f'计算1-{num}的累加和是：', sum)


cumulative_sum(50)

两个形参也同样适用：

def func(a, b):
    print(a, b)


func('a', 'b')
func(['a', 'b'], {'c': 1})
x = 50
func(x, x + 50)

x = 50
y = 100
func(x, x if x > y else y)  # a = 50 b = 100  可以用三目运算符

形参和实参的关系
1.在调用阶段，实参会绑定给形参，绑定关系在调用的时候生效，函数调用结束会解除绑定关系，函数空间会被回收。
2.绑定关系只能在函数体内进行使用。

2. 必备参数和默认参数
   必备参数：写了几个形式参数就要传入几个实参
   特点：传递的实参和定义的形参顺序和个数必须保持一致
   示例演示：

def print_info(name, age, sex):
    print(f'姓名：{name}')
    print(f'年龄：{age}')
    print(f'性别：{sex}')
print_info('Abner',21,'man')

那么我们能否为特定的参数进行传参？

关键字参数：关键字参数，传递实参的时候可以按照形参 =  实参的形式为指定的参数进行传递参数，不需要按照顺序来传递
print_info(sex='man', age=21, name='Abner')

默认参数：给某个参数指定一个默认值。

特点：在定义函数的时候，给形参赋默认值，意味着在调用函数传递实参的时候就不需要再传递值也不会出现报错的情况，传递则会修改默认值

应用场景：函数有多个参数，经常需要改变参数定义为必备参数，而值改变比较少的定义为默认参数

实例展示

def print_info(name, age, sex='man'):
    print(f'姓名：{name}')
    print(f'年龄：{age}')
    print(f'性别：{sex}')


print_info('Abner', 21)
print_info('小红', 18, 'women')  # 可以灵活进行修改

注意：默认参数必须在非默认参数之后

3. 可变参数和可变关键字参数

可变参数
语法：*args （并不是固定的，但是是约定俗成的）
作用：溢出的位置实参都会以元组的形式进行保存，赋值给args
实例展示

def func(a, b, *args):
    print(a, b)   # 1 2
    print(args)   # (3, 4, 5, 6, 3)


func(1, 2, 3, 4, 5, 6, 3)

应用场景：计算传入所有数字的和

def func(*args):
    sum = 0
    for i in args:
        sum += i
    print(sum) # 55
    
func(1,2,3,4,5,6,7,8,9,10)

可变关键字参数
语法：**keargs
作用：溢出的数据会以字典的形式进行保存，赋值给kwargs
实例展示

def func(a, b, **kwargs):
    print(a, b)  # 1 2
    print(kwargs)  # {'c': 3, 'd': 4}   溢出的数据会储存为字典的形式


func(a=1, b=2, c=3, d=4)

注意:*args必须在**kwargs之前

3.函数的返回值

含义：在调用一个函数的时候，该函数会给我们一个返回值
关键字：return

示例演示

def func(a):
    print(f'函数体代码 ---> {a}')   # 函数体代码 ---> 55

print(func(55))  # 打印函数的调用者，也就是查看函数的返回值   # None
# 函数的默认返回值是None

def func(a):
    print(f'函数体代码 ---> {a}')   # 函数体代码 ---> 55
    return 'hhh'
print(func(55))  # 现在的返回值就是hhh

# 把函数的返回值赋值给变量，用变量保存该函数的返回值
res = func(55)
print(res)

那么我们可以用函数的返回值来做什么

应用实例一

def func():
    capitals = {'湖南': '长沙', '湖北': '武汉', '广东': '广州', '广西': '南宁', '河北': '石家庄', '河南': '郑州',
                '山东': '济南', '山西': '太原',
                '江苏': '南京', '浙江': '杭州', '江西': '南昌', '黑龙江': '哈尔滨', '新疆': '乌鲁木齐', '云南': '昆明',
                '贵州': '贵阳', '福建': '福州',
                '吉林': '长春', '安徽': '合肥',
                '四川': '成都', '西藏': '拉萨', '宁夏': '银川', '辽宁': '沈阳', '青海': '西宁', '甘肃': '兰州',
                '陕西': '太原',
                '内蒙古': '呼和浩特', '台湾': '台北', '北京': '北京', '上海': '上海', '天津': '天津', '重庆': '重庆',
                '香港': '香港', '澳门': '澳门'}

    while True:
        data = input('请输入：')
        if not data:
            break
        if data not in capitals.keys():
            print('输入错误')
        else:
            print(f'{data}省会城市是：', capitals[data])
            return capitals[data]   # 返回值是省会城市
print(func())

应用实例二

# 登录功能
def login():
    # 函数体是完成某一个功能的代码块

    user = input('请输入账号')
    if user == 'abc':
        # print(True)  # 把结果输出在控制台
        return True
    else:
        return False

    # 登录完成才能购物 购物功能


def shop():
    """购物功能"""
    res = login()
    # 调用登录功能的时候 为真继续购物，为假不继续购物
    if res:
        print('继续购物，输入要购买的商品！')
    else:
        print('未登录成功 不能购物')

返回值的作用
1.给函数调用者返回一个结果
2.在函数中遇到return会立刻结束掉函数

代码解释：

def func():
    print('abc')
    return 'over'   # 之后的代码将不会再执行 
    print('c')
func()

注意：函数返回值的类型不会限制，个数也不会限制，如果返回多个值以元组的形式进行储存
练习:自己编写一个代码，实现len()函数的功能

4.函数的作用域

1. 补充定义

名称空间：

• 运行一个Python文件，启动解释器，先加载一个内建名称空间，存放内置函数，eg：lem(),min()等等
• 运行Python文件，直到执行完毕，在这个过程中文件执行产生的数据会存放该名称空间 全局名称空间
• 函数级别名称空间，在调用某个函数的时候，产生一个局部的名称空间，储存函数里定义的变量

查找顺序：局部名称空间 全局名称空间 内建名称空间
区别：
局部名称空间：在函数体代码执行完毕，调用即销毁
全局名称空间：在py文件执行创建，运行完毕销毁
内建名称空间：启动Python解释器时创建，关闭是销毁

2. 局部变量和全局变量

• 局部变量：在函数内部定义，仅在函数体内生效
• 全局变量：在函数外部定义（在设计程序的时候尽量减少全局变量的使用，过度使用全局变量会使代码的维护难度加大，尽量使用函数的参数和返回值来传递和共享参数）

代码演示

b = 98  # 全局变量
def func():
    a = 100  # 局部变量
    print(b)  # 可以在局部空间中找到全局变量
# print(a)  # 不能再全局访问局部变量
# 注意：两个函数的局部名称空间是独立的，不能互相进行访问

修改全局变量

• 可变全局变量 可以直接进行修改
  代码演示：

li = []
def func():
    li.append('l')
func()
print(li)

• 不可变全局变量,不可直接被修改，要想修改，需要用到关键字global
  作用：通过global声明后的变量，可以在函数内部直接进行修改全局变量

代码演示：

a = 99
def func():
    global a  # 进行声明之后，a就是全局变量的a，可以进行修改
    a = 1


func()
print(a)  # 1

3. 嵌套函数
   代码演示：

def func():
    a = 99
    def inner():
        print('内部函数')
    inner()  # 只有在函数内部才可以被调用
func()

如何进行修改嵌套函数中的上一级函数中的变量？
这就需要用到另一个关键字nonlocal

代码演示：

def func():
    a = 99

    def inner():
        nonlocal a  # 如果上一级函数不存在该局部变量，那么程序会报错
        a = 1
        print('内部函数')

    inner()  # 只有在函数内部才可以被调用
    print(a)  # 1


func()

---

总结

不飞则已，一飞冲天；不鸣则已，一鸣惊人。——《韩非子》

加油，少年！！！