一、函数的概论
1.什么是函数
函数：对实现特定功能的代码的封装
def func():
sum1 = 0
for num in range(100):
sum1 += num
return sum1, sum1 / 100
2.函数的分类
- 系统函数（内置函数）
系统已经声明好的函数（类似已经造好的机器），程序员会用就行
例如：print\input\sum\max\hen\len\id\type等 - 自定义函数
程序员自己声明的函数（自己造机器）
3.声明函数（造机器）
1）语法：
def 函数名(形参列表):
函数说明文档
函数体
2）说明：
def —— python中声明函数的关键字（固定写法）
函数名——和变量名的要求一样
():——固定写法
形参列表——以'变量名1, 变量名2, 变量名3, ...'的形式存在，每个变量就叫形参，形参的个数根据情况可以没有也可以多个。形参的作用是将函数外面的数据传递到函数里面
函数说明文档——用三个双引号引起来的字符串；作用是对函数功能进行说明
函数体——和def保持一个缩进的一行或者多行语句。（实现函数功能的多条语句）
3）初学者声明函数的步骤
a.确定函数的功能
b.根据函数功能确定函数名
c.确定函数的参数：看实现函数的功能需不需要从外面传值，需要几个？
d.实现函数的功能
# 写一个函数，求两个数的和并且打印
def sum1(num1, num2):
"""
函数功能说明部分
:param num1: 参数说明，数字1
:param num2: 参数说明，数字2
:return: 返回值说明
"""
result = num1 + num2
return result
print(max('hello'))
print(func()[0], func()[1])
4.函数的调用（调用函数相当于使用机器）
1）语法
函数名(实参列表)
2）说明
函数名——已经声明过的函数的函数名
()——固定写法
实参列表——以'值1, 值2, 值3, ...'形式存在；这儿的每个值就叫实参，实参是用来给形参赋值的
def sum1(num1, num2):
"""
函数功能说明部分
:param num1: 参数说明，数字1
:param num2: 参数说明，数字2
:return: 返回值说明
"""
result = num1 + num2
return result
# 调用函数
print(sum1(2, 3))
# sum1(10)
# TypeError: sum1() missing 1 required positional argument: 'num2'
# sum1(10, 20, 30)
# TypeError: sum1() takes 2 positional arguments but 3 were given
# 同一个函数可以调用多次
print(sum1(2, 7))
二、函数调用过程
1）语法
'函数名(形参列表)'
2）调用函数的作用
作调用函数的作用：执行函数体；获取返回值
3）函数调用过程：
第一步：回到函数声明的位置
第二步：传参（用实参给形参赋值）
第三步：执行函数体
第四步：执行完函数体就确定返回值
第五步：回到函数调用的位置接着往后执行
# 练习：声明一个函数，实现求1+2+3+...N的和
def sum1(n):
# n = 3
result = 0
for x in range(1, n+1):
result += x
return result
print(sum1(3))
# 练习：是声明一个函数，实现m+m+1+m+2+...+n的和
def sum2(m, n):
# m = 2, n = 5
# print('n: %d, m: %d' % (n, m))
result = 0
for x in range(m, n+1):
result += x
return result
print(sum2(2, 5))
# 练习：声明一个函数，打印字符串中所有的字母字符
def print_char(str1):
# str1 = 'q3wdo902cmjffh4558ff#2!'
for char in str1:
if char.isalpha():
print(char, end='')
print()
# new_str = ''
# for char in str1:
# if 'A' <= char <= 'Z' or 'a' <= char <= 'z':
# new_str += char
# print(new_str)
print_char('q3wdo902cmjffh4558ff#2!')
# 练习：声明一个函数，在指定的字符串中数字字符后添加一个指定的字符
# 'abc123', '*' -> 'abc1*2*3*'
# 'h2wo4end', '=' -> h2=wo4=end
def append_char(str1, char1):
# str1, char1 = 'how1are2you3?', '='
new_str = ''
for char in str1:
new_str += char
if char.isdigit():
new_str += char1
# if '0' <= char <= '9':
# new_str += char1
return new_str
print(append_char('how1are2you3?', '='))
三、函数的参数
1.位置参数和关键字参数（针对实参）
根据调用函数的时候传参的方式将参数分为位置参数和关键字参数
1）位置参数：
让实参和形参在位置上一一对应（第一个实参给第一个形参赋值，第二个实参给第二个形参赋值...）
2）关键字参数
关键字参数：以'形参名=值'形式传递
注意：位置参数和关键字参数可以一起使用，但是一起用的时候要求位置参数必须在关键字参数的前面
3）什么时候使用关键字参数
在需要跳过前面某个参数或几个参数，直接给后面某个参数赋值的的时候必须使用关键字参数
def func1(a, b, c):
# a = 10, b = 20, c = 30
print('a:{}, b:{}, c:{}'.format(a, b, c))
# 位置参数传参
func1(10, 20, 30)
# 关键字参数传参
func1(a=100, c=300, b=200)
# 位置参数和关键字参数同时使用
func1(10, b=20, c=10)
2.参数默认值（形参）
- 声明函数的时候，形参可以设置默认值，设置默认值后调用函数的时候有默认值的参数可以不用传参
- 一个函数可以给所有的参数设置默认值，也可以给部分参数设置默认值；必须保证没有默认值的参数必须放在有默认值参数的前面
# def func2(x=11, y, z=33):
# SyntaxError: non-default argument follows default argument
# def func2(x, y=22, z=33):
# def func2(x=11, y=22, z=33):
def func2(x, y, z=33):
print('x:{}, y: {}, z:{}'.format(x, y, z))
func2(100, 200, 30)
func2(100, 200)
# func2(100, z=300) # 参数都有默认值，跳过一些参数，给指定参数赋值
3.参数类型说明
1）给参数赋默认值，默认值的类型就是参数的类型
2）以'参数名： 类型名'的形式声明函数
def func3(a: int, b: str, c=[1, 2]):
print('a:{}, b:{}, c:{}'.format(a, b, c))
# func3(90, 'que', [12, 45])
def func4(x: list):
x.append(100)
4.不定长参数
1）在形参的前面加*，那么这个参数就可以同时接受多个实参；带*的参数会作为一个元组，对应的多个参数就是元组中的元素
2）在形参前加**，那么这个参数也可以接受多个参数（关键字参数，关键字自己随便命名）
将**的参数作为一个字典，将关键字参数的关键字作为key，实参作为value存储在字典中。
def func(*args, **kwargs)，这个函数的*args和**kwargs的作用：为了不定长参数传参的时候，既可以使用位置参数，也可以使用关键字参数
# 写一个函数计算多个数的和
# sum1(1), sum1(2, 45), sum1(2, 3, 4, 5, 6), ...
def func5(*nums):
print(nums)
print(sum(nums))
func5(10, 90, 89, 90)
# func5(89, 'hu', [12, 5])
func5(89, 9, 34.8)
# func5(a=10, b=20) # 带*的不定长参数，不能使用关键字参数传参
def func6(x, y, *nums):
print(x, y, nums)
func6(1, 2, 3, 4, 5, 6, 7)
# student = ('小明', 18, '男', 89, 90, 170, 70)
# name, age, gender, *scores = student
# a, *b, c = student
def func7(**nums):
print(nums)
# func7(1, 2)
# TypeError: func7() takes 0 positional arguments but 2 were given
func7(a=1, b=2, c=3)
func7(a=3)
# *args 和 **kwargs一起用是为了保证
# 不定长参数传参的时候
# 既可以使用位置参数也可以使用关键字参数
def func8(*args, **kwargs):
print(args, kwargs)
print(func8(1, 23))
print(func8(a=1, c=90, k=34))
print(func8(2, 4, x=2, y=89))
补充：*的用法：
*列表/*元祖 -> 直接取出列表/元组中所有的元素
**字典 -> 直接取出字典中所有元素
list1 = [89, 90, 89]
print(*list1) # 89, 90, 90 ->print(89, 90, 89)
def func9(x, y):
print(x, y)
func9(1, 2)
list2 = [10, 20]
# func9(list2)
# TypeError: func9() missing 1 required positional argument: 'y'
func9(*list2)
dict1 = {'a': 1, 'b': 2} # 'a': 1, 'b': 2
# a = 1, b = 2
# print(**dict1)
# TypeError: 'a' is an invalid keyword argument for print()
# def func10(x, y):
# print(y, x)
# TypeError: func10() got an unexpected keyword argument 'a'
def func10(b, a):
print(a, b)
func10(**dict1)
# 练习：声明一个函数，求多个数的差
# differ(1, 2) -> -1 differ(10, 2, 3) -> 5 differ(10, 20, 30) -> -40
def differ(*args):
print('============求不定个数的数字的差============')
num1 = args[0]
length = len(args)
for x in range(length):
if x != 0:
num1 -= args[x]
return num1
# if not args:
# print(0)
# else:
# sum1 = args[0]
# for num in args[1:]:
# sum1 -= num
# return sum1
print(differ(1, 2))
print(differ(10, 2, 3))
print(differ(10, 20, 30))
四、函数的返回值
1.什么是返回值
- 返回值就是return关键字后表达式的值（怎么确定函数的返回值）
- 返回值就是函数调用表达式的值（怎么获取函数的返回值）(python中所有函数都有返回值，默认是None)
1）什么是return
return是函数体中的关键字（只能在函数中使用），作用有两个，结束函数/确定函数返回值
a.结束函数：执行函数体的时候只要遇到return函数直接结束
b.确定函数返回值：return 返回值（可以是具体的数据，声明过的变量，运算表达式）
2）什么是函数调用表达式
- 函数调用语句就是函数表达式，例如：func1(10), max([1, 2])
- 每个调用函数的语句都有结果，就是调用这个函数得到的返回值
def func1():
for x in range(10):
if x == 2:
return
break
print(x)
print('里面：函数结束')
print('func1: ', func1())
func1()
def func2():
print('====')
print('++++')
return
print('----')
print('func2: ', func2())
func2()
def func3():
if False:
return 10
func3()
print('func3: ', func3())
def func4():
return 100
func4()
print('func4', func4())
2.怎么使用返回值
- 想要用函数的返回值，就使用函数调用表达式的值
- 普通数据能做的事情，函数调用表达式都可以做
# 100
func4()
num = 100
num1 = func4()
print(num, num1)
list1 = [100, 200]
list2 = [func4(), 200]
print(list1, list2)
print(100 > 200, 100*2)
print(func4() > 200, func4()*2)
3.什么时候需要返回值
初学者：看实现函数的功能会不会产生新的数据
return 返回值1, 返回值2, ...