Python函数 - 技术栈

1.函数

1.1 函数概述

函数定义和优势
- 不同形状正方形打印

python 复制代码

# 2个
for i in range(0, 2):
    for j in range(0, 2):
        print("*", end="")
    print()
# 3个
for i in range(0, 3):
    for j in range(0, 3):
        print("*", end="")
    print()
# 4个
for i in range(0, 4):
    for j in range(0, 4):
        print("*", end="")
    print()

改写后：

python 复制代码

# 定义函数，函数名称为print_xx
def print_xx(x):
    for i in range(0, x):
        for j in range(0, x):
            print("*", end="")
        print("")
        
# 函数调用
print_xx(2)
print_xx(3)
print_xx(4)

优点有哪些？

1.2 函数定义和调用

函数定义

函数调用

格式：函数名([参数列表])
调用过程：
1. 程序在调用函数的位置暂停执行。
2. 将数据传递给函数参数。
3. 执行函数体中的语句。
4. 程序回到暂停处继续执行。

作业1:改写

改写平均数成def
改写闰年判断

python 复制代码

# 改写平均数练习，要求是三个数字的平均数
# 定义求平均数的函数
def avg_input(x, y, z):
    avg = (x + y + z) / 3
    print(f"平均数是：{avg}")


# 定义判断闰年的函数
def judge_rn(year):
    # 1.能被400整除
    if year % 400 == 0:
        print(f"{year}是闰年")
    # 2.能被4整除但不能被100整除
    elif year % 4 == 0 and year % 100 != 0:
        print(f"{year}是闰年")
    else:
        print(f"{year}不是闰年")


judge_rn(2008)
print("----------")
# 调用函数
avg_input(1, 2, 3)
print("----------")
# a = eval(input("a="))
# b = eval(input("b="))
# c = eval(input("c="))
# avg_input(a, b, c)

1.3 参数传递

形参：定义函数时的参数
实参：调用函数时使用的参数
参数传递：实参------>形参

位置参数传递：

概念：第一个实参传递给第一个形参，将第二个实参传递给第二个形参

关键字参数传递：

概念：调用函数（形参=实参）形式

默认参数传递：

默认参数：指的是形参的默认值

参数的打包与解包

打包

函数在定义时无法确定需要接收多少个数据 ，那么可以在定义函数时为形参添加""或"**"：
- *------ 接收以元组形式打包的多个值
python 复制代码
```
#定义
def test(*args):
    print(args)
#调用
test(11, 22, 33, 44, 55)
#结果
#(11, 22, 33, 44, 55)
```
- **------ 接收以字典形式打包的多个值
python 复制代码
```
#定义
def test(**kwargs):
    print(kwargs)
#调用
test(a=11, b=22, c=33, d=44, e=55)
#结果
#{'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55}
```

解包

实参是元组 → 可以使用"*"拆分成多个值 → 按位置参数传给形参

形参已经知道有多少个参数

python 复制代码

#定义
def test(a, b, c, d, e):
    print(a, b, c, d, e)
#调用
nums = (11, 22, 33, 44, 55)
test(*nums)
#结果
#{'a': 11, 'b': 22, 'c': 311 22 33 44 553, 'd': 44, 'e': 55}

实参是字典 → 可以使用"**" 拆分成多个键值对 → 按关键字参数传给形参

python 复制代码

#定义
def test(a, b, c, d, e):
    print(a, b, c, d, e)

#函数调用
nums = {"a":11, "b":22, "c":33, "d":44, "e":55}
test(**nums)
#结果
#11 22 33 44 55

作业2：

python 复制代码

# 平均数:计算n个参数的平均值
# 定义函数计算平均值
def avg_input(*args):
    sum = 0
    for i in args:
        sum += i
    avg = sum / len(args)
    print(f"和是{sum},有{len(args)}个数字，平均值是：{avg}")


avg_input(1)
avg_input(1, 2)
avg_input(1, 2, 3)
avg_input(1, 2, 3, 4)

作业3：

python 复制代码

# 从键盘一直获取数字，当输入0000退出，
# 计算之前获取的值的平均值

def avg_input(mylist):
    sum = 0
    for i in mylist:
        sum += i
    avg = sum / len(mylist)
    print(f"和是{sum},有{len(mylist)}个数字，平均值是：{avg}")


def gain_input():
    # 1. 从键盘一直获取数字，当输入0000退出
    while (True):
        # #int()转化为整数数字
        # x = int(input("请输入数字："))
        x = eval(input("请输入数字："))
        if x == 0000:
            break
        else:
            # list_nums.insert(0, x)
            list_nums.append(x)


list_nums = []
gain_input()
print(list_nums)
# 2. 计算之前获取的值的平均值
avg_input(list_nums)

混合传递

优先级：
1. 优先按位置参数传递的方式。
2. 然后按关键字参数传递的方式。
3. 之后按默认参数传递的方式。
4. 最后按打包传递的方式。

注意事项

text 复制代码

在定义函数时：
带有默认值的参数必须位于普通参数之后。
带有"*"标识的参数必须位于带有默认值的参数之后。
带有"**"标识的参数必须位于带有"*"标识的参数之后

作业4：

1.4 函数的返回值

return函数：

python 复制代码

# 屏蔽关键字这个功能
def filter_key(str):
    # 2 使用字符串的替换功能，把要替换关键字替换为目标对象
    str = str.replace("山寨", "**")
    return str


# 1 准备一个字符串
key = "手机的山寨的！"
# 调用过滤函数
key = filter_key(key)
# 3 打印替换后的结果
print("key=", key)

python 复制代码

#函数定义
def move(x, y, step):
    nx = x + step
    ny = y - step
    return nx, ny     # 使用return语句返回多个值
#函数调用
result = move(100, 100, 60)  	
print(result)
#结果
#(160, 40)

作业1：

使用正则表达式完成屏蔽关键字的功能

1.5 变量作用域

概念：其访问权限取决于变量定义的位置，其所处的有效范围称为变量的作用域。

1.5.1 局部变量

定义位置：在函数内部
特点：
- 只能在函数内部被使用
- 函数执行结束后，无法再进行访问

python 复制代码

def test_one():
    number = 10    	              # 局部变量
    print(number) 	              # 函数内部访问局部变量
test_one()
print(number)     	              # 函数外部访问局部变量

不同函数内部可以包含同名的局部变量

```python
def test_one():
    number = 10      
    print(number)             # 访问test_one()函数的局部变量number
def test_two():
    number = 20
    print(number)             # 访问test_two()函数的局部变量number
test_one()
test_two()
```

1.5.1 全局变量

定义位置：函数外面，单独定义

python 复制代码

number = 10         			# 全局变量
def test_one():
    print(number)   			# 函数内部访问全局变量
test_one()
print(number)       			# 函数外部访问全局变量

特点：全局变量在函数内部只能被访问，无法直接修改

python 复制代码

# 定义全局变量
number = 10
def test_one():
    number
    print(number) 
    number += 1
test_one()
print(number)

1.5.1 关键字global和nonlocal

（掌握）global关键字可以将局部变量声明为全局变量

python 复制代码

number = 10                    # 定义全局变量
def test_one():
    global number              # 使用global声明变量number为全局变量
    number += 1
    print(number)
test_one()
print(number)

（了解）nonlocal关键字:局部作用域中修改嵌套作用域中定义的变量

python 复制代码

def test():
    number = 10
    def test_in():
        nonlocal number
        number = 20
    test_in()
    print(number)
test()

作业2：

练习以上PPT案例：从变量作用域开始，到global关键字结束

1.6 实训案例

角谷猜想

tex 复制代码

以一个正整数n为例，如果n为偶数，就将它变为n/2，如果除后变为奇数，则将它乘3加1（即3n+1）。不断重复这样的运算，经过有限步后，必然会得到1。
本实例要求编写代码，计算用户输入的数据按照以上规律经多少次运算后可变为1。

python 复制代码

def guess_nums(guess):
    i = 0  # 统计重复多少次
    # 2 按照规则重复进行，=1 不再重复
    while (guess != 1):
        i += 1
        if guess % 2 == 0:
            guess /= 2
        else:
            guess = 3*guess+1
    # 3 打印结果
    print(f"经过{i}次得到1")


# 1 获取用户输入输入的数据
x = eval(input("x="))
# 调用函数
guess_nums(x)

python 复制代码

# 全局变量
dict_goods = {"可口可乐": 2.5, "百事可乐": 3, "健力宝": 5}
# 展示功能


def show():
    print("饮品自动售货机")
    # 展示商品
    for key, value in dict_goods.items():
        print(f"{key}:{value}元")
    print("输入q完成购买")

# 购买功能


def buy():
    money = 0
    x = input("请输入购物的商品：")
    # 省略步骤判断输入的商品在不在货架上
    # 计算金额
    while (x != "q"):
        count = eval(input("请输入购物的数量："))
        # 计算金钱
        money += dict_goods[x] * count
        # 下次的购物商品
        x = input("请输入购物的商品：")
    print(f"需要支付金额{money}元")


# 函数调用
show()
buy()

1.7 特殊函数

1.7.1 递归函数

概念：函数自己调用自己
格式：

python 复制代码

#阶乘案例：
def func(num):
     if num == 1: 
         return 1
     else:
         return num * func(num - 1)
num = int(input("请输入一个整数："))
result = func(num)
print("5!=%d"%result)

1.7.2 匿名函数

概念：

关键字lambda 来创建，并可以赋给一个变量供调用，没有名字的函数。
用于定义简单的、能够在一行内表示的函数

python 复制代码

示例：
sum = lambda a,b=100:a+b    #允许带默认参数
print("变量之和为:",sum(100,200))
print("变量之和为:",sum(100))

#下面是等价形式：
def sum_nums(a,b=100):
    return a+b
print("变量之和为:",sum_nums(100,200))
print("变量之和为:",sum_nums(100))

1.7.3 特殊函数

map函数

功能：单参数函数依次作用到一个序列对象的每个元素
案例：

python 复制代码

#示例：
#定义函数sqr（x）
def sqr(x):
    return x**2
#列表
item1=[1,2,3,4,5]
#使用map函数
for i in map(sqr,item1):   
    print(i,end=' ')
#结果
#1 4 9 16 25

reduce函数
功能：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，以此类推，最后得到一个结果

python 复制代码

from functools import reduce #需要导入模板
def add(x,y):
     return x+y
print("累加结果:",end=' ')
print(reduce(add, [1,2,3,4]))
#结果10

filter函数

功能：，其作用是将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的列表、元组或字符串

python 复制代码

#定义函数判断奇数
def is_odd(n):
      return n%2==1
newlist1 = filter(is_odd,range(1,11))         
  #通过自定义函数构造过滤器
print("奇数序列为:",end=' ')
for i in  newlist1:
      print(i,end=' ')
#奇数序列为: 1 3 5 7 9