不使用函数的问题:
- 1.同样的功能,相同的代码需要重复写很多次
- 2.当功能发生改变了,需要修改多处代码
怎么解决这些问题:使用函数!
1.函数的定义
- a.定义
函数就是对实现某一特定功能的代码段的封装 - b.分类
函数可以分为内置函数和自定义函数-
内置函数:python已经声明好了,程序员直接调用的函数。print函数, input函数,max等
相当于已经造好的机器,程序员只需要知道机器的功能和使用方法
-
自定义函数: 程序员自己声明,自己实现功能的函数。可以提供给别人用,也可以自己用。
相当于自己设置和创建机器。
-
2.函数的声明
a.语法:
def 函数名(形参列表):
函数说明文档
函数体-
b.说明:
- def - python中声明函数的关键字
- 函数名 -自己命名;
要求:标识符, 不能是关键字
PEP8,名字中的字母小写,多个单词之间用下划线隔开
见名知义(看到函数名,大概知道函数的功能) - () - 固定写法
- 形参列表 - 形参名1,形参名2... (可以有一个参数,也可以有多个参数,也可以没有参数)
形参的作用:从函数的外部,向函数内部传递数据 - : - 固定写法
- 函数说明文档 - 用来对函数的功能进行说明的注释。这个注释需要使用是三个双引号引起来
- 函数体 - 实现函数功能的代码段
-
c.初学者函数声明的步骤
- 第一步:确定函数的功能
- 第二步:根据函数的功能,确定函数名
- 第三步:确定参数,看实现函数的功能,需不需要额外的数据。需要几个数据,就需要几个参数
- 第四步:实现函数的功能
- 第五步:确定返回值
# 声明一个函数,求两个数的和,并且打印出来
def my_sum(num1, num2):
print(num1 + num2)
# 声明一个函数,打印10个'*'
def print_star():
print('*'*10)
# 声明一个函数,求1+2+3+...+n
def my_sum2(n):
sum1 = 0
for x in range(1, n+1):
sum1 += x
print(sum1)
2.函数的调用
函数在声明的时候不会执行函数体,只有在调用函数的时候才会执行函数体
def say_hello():
print("hello")
say_hello() #hello
1.函数的调用过程(重点)
-
def 函数名(形参):
函数体函数名(实参)
-
a.物理过程
- 第一步:回到函数声明的位置
- 第二步:用实参给形参赋值(传参);要保证每个形参都有值
- 第三步:执行函数体
- 第四步:获取返回值
- 第五步:回到函数调用的位置
b.函数调用的过程是一个压栈的过程
当函数调用的时候,系统会自动在内存中栈区间开辟空间,存储函数调用过程中产生的数据
(这的数据包括参数和在函数的声明的变量)。当函数调用完成后,对应的内存空间会自动销毁。
a = 10
b = 20
def change(a, b):
a, b = b, a
print(a, b) #20 10
change(a, b)
print("函数外", a, b) #函数外 10 20
3.函数的参数
1.根据实参分为位置参数和关键字参数(都需要保证每个参数有值)
- a.位置参数
实参的位置和形参的位置一一对应 - b.关键字参数
实参以 “形参名 = 值”形式来传参 - c.位置参数和关键字参数混合使用
- 前提:
1.保证每个参数都有值;
2.位置参数一定要在关键字参数前面
- 前提:
def function(a,b,c):
print(a,b,c)
function(100,c=200,b=2)
2.从函数声明的角度又有:参数默认值,不定长参数,参数类型说明
- a.参数默认值
声明函数的时候可以给参数设置默认值,- 语法:参数名 = 默认值
注意:设置默认值除了可以给参数一个默认的值,更多的时候可能只是想要对参数的类型进行说明。
如果函数声明的时候参数有默认值,调用函数的时候,有默认值的参数可以不用赋值。
有默认值得参数要在没有默认值的参数后面
- 语法:参数名 = 默认值
def function2(b,c="a",a=1):
print(a,b,c)
function2(1,"e",5) #5,1,"e"
3.不定长参数
不定长参数:声明函数的时候,函数的参数不确定
- a.在声明函数的时候,参数名前加一个 * ,会将这个参数变为元组,来获取多个实参的值。
练习:声明一个函数,功能是求多个数的和
def num_sum(*num):
print(sum(num)) #45
print(num) #(5, 9, 8, 7, 8, 8)
num_sum(5,9,8,7,8,8)
a=(5,9,8,7,8)
print(sum(a)) #37
a,*b = [1,5,6,9,8,7]
print(b) #[5, 6, 9, 8, 7]
- b.在声明函数的时候,参数名前加一个 ** ,会将这个参数变为字典,来获取多个实参的值(必须使用关键字来传参)
def func5(**num):
print(num)
func5(a=1,b=2,c=3) #{'a': 1, 'b': 2, 'c': 3}
func5() #{}
func5(name="asd",age=18) #{'name': 'asd', 'age': 18}
#如果不是调用不定长关键字参数(产生前面加两颗*),调用的时候关键字可以随便命名。
- c.一颗 * 和两颗 * 一起使用 - 用来表示不定长参数,
调用时候更灵活,可以用位置参数传参,也可以关键字参数传参。
要求:一颗的参数要放在两颗的前面
def func7( * args, ** kwargs):
print(args,kwargs)
func7() #() {}
func7(8,9,10,20) #(8, 9, 10, 20) {}
func7(a=10,b=20) #() {'a': 10, 'b': 20}
func7(8,9,10,a=50,b=97) #(8, 9, 10) {'a': 50, 'b': 97}
练习:求多个数的和,要求:调用函数的时候可以多样性。
def sum1_num(*args,**kwargs):
sum = 0
sum = sum(args)+sum(kwargs.values())
print(sum)
sum1_num(8,9,10,60,a=10,b=20)
4.参数类型的说明
参数类型说明,只是对参数类型进行提示,不能限制参数的类型
- a.设置默认值
- b.参数名:类型名
注意:类型说明除了说明类型以外,还可以做相应类型对应的语法提示
def func8(a1,a:str="sd",b=20):
print(a1,a,b)
func8(1) #1,“sd”,20
4.函数的返回值
1.返回值
a.函数的返回值就是return关键字后面表达式的值,就是函数调用表达式的值。
b.python中所有的函数都有返回值,默认是None
return - 关键字(只能用在函数体中);返回返回值;结束函数(当函数在执行的过程中遇到了return就结束函数)
如果函数体重没有return,函数会在函数体执行完成后将None作为返回值函数调用表达式 -调用函数的语句;当函数调用完成后,函数调用表达式会有一个结果,结果就是函数的返回值。
def func1(m,n):
print(m,n)
#将100作为函数func1的返回值
return 100 #rtunrn - 关键字 100- 返回值
def func2(m,n):
return m+n #m+n的结果就是返回值
def func3(m,n):
return None # 将None作为返回值,在这儿结束函数。函数体后面的其他语句不会执行
print(m,n)
看一个函数的返回值,永远只看是否能遇到return,遇到了就是return后面的值,遇不到就是None
def func4(m):
if m%2==0:
return "偶数"
func4(2) # "偶数"
- 返回值的作用:就是讲函数内部产生的数据,传递到函数的外面。防止函数调用完成后被销毁
- 什么时候使用返回值:如果实现函数的功能会产生新的数据,一般都会将这个数据返回。
2.同时返回多个返回值
python的函数中支持返回多个值
- 语法:
return 返回值1,返回值2...,返回值3 - 实质是以元组的形式返回
写一个函数,功能是求多个数的和以及平均值
def func7(*args):
a=sum(args)
b=sum(args)/len(args)
return a,b
a,b =func7(1,3,5,7,9) #func7 =>(25,5.0)
print(a,int(b)) #25 5.0
5.返回值的应用
返回值能做的事情,函数调用表达式都可以做
1.用函数调用表达式给变量赋值
def func1():
return 'hello'
# str1 = 'hello'
str1 = func1()
print(str1) # 'hello'
2.通过函数调用表达式使用相应的方法
def func2():
return [1, 2]
# print([1, 2][0])
item = func2()[0]
print(item)
item = func2().append(3) # item获取的是append函数的返回值,append函数没有返回值
print(item)
list1 = func2()
list1.append(3)
print(list1)
3.将函数调用表达式作为容器的元素,函数的参数,函数的返回值
def func3():
print('hello')
return 100
# 作为值惨叫运算
print(func3() + 3) # print(100 + 3)
# 作为列表元素
list2 = [func3(), 'abc']
print('list2:',list2) # [100, 'abc']
# 作为字典的key和value
dict1 = {func3(): func3()} # {100:100}
print(dict1)
# 作为函数的返回值
def func4(m):
print(m)
return func3()
# 作为函数的实参
re = func4(func3()) # func4(100)
print(re) # 100
6.匿名函数
匿名函数还是函数,除了声明的语法以外,函数其他的语法匿名函数都支持
1.匿名函数的声明
a.语法:
函数名 = lambda 参数列表:返回值-
b.说明:
- 函数名 - 变量名
- lambda - 关键字
- 参数列表 - 和普通函数的参数列表的作用和要求一样
- 返回值 - 相当于普通函数retrun关键字后面的表达式
注意:匿名函数中冒号后面的语句属于函数体。在声明的时候不会执行
匿名函数的调用和普通函数一模一样
# 用匿名函数求两个数的和
def my_sum(num1, num2=0):
return num1 + num2
print(my_sum(10, 20))
print(my_sum(num1=1, num2=2))
my_sum1 = lambda num1, num2=0: num1+num2
print(my_sum1(100, 200))
print(my_sum1(num1=11, num2=22))
练习:写一个匿名函数,求两个数的最大值
my_max = lambda x, y: max(x, y)
print(my_max(100, 200))
补充:python中的三目运算符
- a.
C中的三目运算符: 条件语句?值1:值2 - 条件语句为True,整个表达式的结果是值1,否则是值2
int x = 10, y = 20;
max = x>y?x:y;
- b.
python中的三目运算符:值1 if 条件语句 else 值2 - 条件语句为True,整个表达式的结果是值1,否则是值2
x = 10
y = 20
max1 = x if x > y else y
"""
x = 100
y = 20
max1 = x if x > y else y
print(max1)
my_max2 = lambda num1, num2: num1 if num1 > num2 else num2
print(my_max2(20, 89))
print(my_max2(200, 89))
练习:写一个匿名函数,获取字典中指定的key对应的值
get_value = lambda dict1, key: dict1.get(key)
print(get_value({'a': 100, 'b': 200}, 'a'))
def func1(item: dict):
return item['age']
list1.sort(key=func1)
list1 = [
{'name': '张三', 'age': 20},
{'name': '李四', 'age': 10},
{'name': '王五', 'age': 30}
]
list1.sort(key=lambda item: item['age'])
print()
print(list1)
def key(item):
return item["age"]
print(key({'name': '张三', 'age': 20}))