20230422-Python-函数-day10

Day10-函数

4月21-22

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

一、函数的使用步骤

定义一个函数

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None

def 函数名(参数):
    "函数文档字符串"
    代码1
    代码2
    ......

函数的调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

函数必须调用才会进行执行

# 函数名(参数)

不同的需求，参数可有可⽆。

在Python中，函数必须先定义后使⽤。

# 定义函数
def demo():
   print("我是dmeo函数")
 
# 调用函数
demo()

二、函数的参数作⽤

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。调用demo()函数，你必须传入一个参数，不然会出现语法错误：

完成需求如下：⼀个函数完成两个数1和2的加法运算，如何书写程序？

# 定义函数
def demo():
 result = 1 + 2
 print(result)
# 调⽤函数
demo()

上述demo函数只能完成数字1和2的加法运算，如果想要这个函数变得更灵活，可以计算任何⽤户指定的两个数字的和，如何书写程序？

# 定义函数时同时定义了接收⽤户数据的参数a和b
def demo2(a, b):
    result = a + b
    print(result)
# 调⽤函数时传⼊了真实的数据10 和 20
demo2(10, 20)

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

def demo3(name,age):
    print(f"我是{name},今年{age}岁")
    
name = "张三"
age = 18
# 函数在调用的时候将定义好的name和age传递进去
demo3(name,age)

默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入

def demo1(name="张三",age=18):
    print(f"大家好，我是{name},今年{age}岁了")
    
demo1()
# 大家好，我是张三,今年18岁了
demo1(name="李四",age=19)
# 大家好，我是李四,今年19岁了

不定长参数

python自定义函数中有两种不定长参数，第一种是*XXX，在传入额外的参数时可以不用指明参数名，直接传入参数值即可。第二种是**XXX，这种类型返回的是字典，传入时需要指定参数名。

def demo2(*args):
    print(args)

demo2(1,2,3,4,4,5)

**加了一个星号 * 不定长参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。加了两个星号 ** 的参数会以字典的形式导入，存放已命名的变量参数

def demo2(num, *args, **kwargs):
    print(num)
    print(args)
    print(kwargs)

demo2(11, 22, 33, a=18, b=19, c=20)

三、函数的返回值作⽤

return语句[表达式]退出函数

def demo1():
    for i in range(1,10):
        return i

print(demo1())

四、变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。

• 全局变量
• 局部变量

# 全局变量
num = 10
def demo():
    result = num+20
    print(result)

demo()

def demo2():
    global num    # 声明num为全局变量
    num = 10      # 局部变量

demo2()
result = num+20
print(result)

五、函数嵌套使用

所谓函数嵌套调⽤指的是⼀个函数⾥⾯⼜调⽤了另外⼀个函数

def demo1():
    demo2()
    print("你好呀，这里是demo1")


def demo2():
    demo3()
    print("你好呀，这里是demo2")


def demo3():
    print("你好呀，这里是demo3")


demo1()

#输出结果
你好呀，这里是demo3
你好呀，这里是demo2
你好呀，这里是demo1

六、多函数程序执行流程

• 共用全局变量

# 1. 定义全局变量
num = 0
def test1():
     global num
	 # 修改全局变量
     num = 100
def test2():
     # 调⽤test1函数中修改后的全局变量
     print(num)
 

test1()

test2() # 100

• 返回值作为参数传递

def test1():
    return 50
    
def test2(num):
     print(num)
# 1. 保存函数test1的返回值
result = test1()
# 2.将函数返回值所在变量作为参数传递到test2函数
test2(result) # 50

七、拆包和交换变量值

• 拆包-元组

t1 = (1,2,3)
a,b,c = t1
print(a)
print(b)
print(c)

• 函数返回多个值

def return_num():
    return 100, 200
    
num1, num2 = return_num()
print(num1) # 100
print(num2) # 200

八、递归

函数内部⾃⼰调⽤⾃⼰

必须有出⼝

1,2,3数字的累加和

def sum_numbers(num):
    if num == 1:
        return 1
    result = num + sum_numbers(num-1)
    return result


print(sum_numbers(3))

执行流程

递归三原则：

• 递归必须有停止条件
• 递归必须改变其状态并向停止条件靠近
• 递归必须递归地调用自己

九、lambda 表达式

lambda表达式，又名匿名函数

如果⼀个函数有⼀个返回值，并且只有⼀句代码，可以使⽤ lambda简化。

语法:

 lambda 参数列表 ： 表达式

• 注意

lambda表达式的参数可有可⽆，函数的参数在lambda表达式中完全适⽤。

lambda函数能接收任何数量的参数，但只能返回⼀个表达式的值

快速上手

# 函数
def fn1():
    return 200

print(fn1())

# lambda表达式
fn2 = lambda: 100
print(fn2())

夹带参数

# 函数
def add(a, b):
     return a + b
    
result = add(1, 2)
print(result)

# lambda表达式
fn = (lambda a, b: a + b)(1, 2)
print(fn)

十、lambda的参数形式

• 无参数

fn = (lambda: 100)()
print(fn)

• 一个参数

fn = (lambda a: a)("hello python")
print(fn)

• 默认参数

fn = (lambda a, b, c=100: a + b + c)(10, 20)
print(fn)

• 不定长参数

fn1 = (lambda *args: args)(10, 20, 30)
print(fn1)

fn2 = (lambda **kwargs: kwargs)(name='python', age=20)
print(fn2)

• 待判断的lambda

fn = (lambda a, b: a if a > b else b)(1000, 500)
print(fn)

• 列表数据按字典key的值排序

students = [
     {'name': '张三', 'age': 20},
     {'name': '李四', 'age': 19},
     {'name': '王五', 'age': 22}
 ]
# 按age值升序排列
students.sort(key=lambda x: x['age'], reverse=True)
print(students)

十一、内置函数

• abs()

abs() 函数可以完成对数字求绝对值计算。

def add_num(a, b):
     return abs(a) + abs(b)
result = add_num(-1, 2)
print(result) # 3

• map(function, iterable)，

将传⼊的函数变量function作⽤到iterable变量的每个元素中，并将结果组成新的列表

• function – 函数
• iterable – 序列

实例

list1 = [1, 2, 3, 4, 5]
def func(x):
    return x ** 2

result = map(func, list1)
print(result)
print(list(result))

• filter()

filter(func, lst)函数⽤于过滤序列, 过滤掉不符合条件的元素, 返回⼀个 fifilter 对象,。如果要转换为列表

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
    return x % 2 == 0

result = filter(func, list1)
print(result)
print(list(result))