# 左移、右移、上移、下移、发射子弹、爆炸....
# 左移1次 右移1次 左移2次 右移3次 左移2次 右移2次
# 1.没有函数的时候的问题: a.同样的代码要写多次(冗余) b.功能发生改变的时候需要修改多个位置的代码
# 2.解决问题: 用函数
# 3.函数的作用: 封装
def func1():
sum1 = 0
for x in range(101):
sum1 += x
print(sum1)
def func2():
age = 19
if age >= 18:
print('成年')
def left():
print('==============左移=================')
print('看后视镜')
print('向左打方向盘')
# print('踩油门')
print('回正方向盘')
def right():
print('==============右移=================')
print('看后视镜')
print('向右打方向盘')
# print('踩油门')
print('回正方向盘')
left()
right()
left()
left()
right()
right()
right()
left()
left()
right()
right()
# print('==============左移=================')
# print('看后视镜')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('==============右移=================')
# print('看后视镜')
# print('向右打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('==============左移=================')
# print('看后视镜')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('==============左移=================')
# print('看后视镜')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('==============右移=================')
# print('看后视镜')
# print('向右打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('==============右移=================')
# print('看后视镜')
# print('向右打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('==============右移=================')
# print('看后视镜')
# print('向右打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('==============左移=================')
# print('看后视镜')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('==============左移=================')
# print('看后视镜')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('==============右移=================')
# print('看后视镜')
# print('向右打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('==============右移=================')
# print('看后视镜')
# print('向右打方向盘')
# # print('踩油门')
# print('回正方向盘')
1.什么是函数
1)函数的定义
函数就是对实现某一特定功能的代码的封装2)函数的分类
系统函数 - 系统(语言系统)已经声明好，程序员可以直接使用的函数(别人造好的机器). 例如:print、input、hex、bin、oct、chr、ord...
自定义函数 - 开发者自己声明的函数(自己造机器).
2.函数的声明(定义函数) - 造机器
1)语法:
def 函数名(参数列表):
函数说明文档
函数体2)说明
def - 关键字;固定写法
函数名 - 和变量的要求一样（机器名）
(): - 固定写法
参数列表 - 这儿的参数又叫形参; 以'参数名1,参数名2,参数名3,...'的形式存在, 参数名其实就是变量名
作用: 将函数外面的数据传到函数里面
函数说明文档 - 本质就是一段注释; 必须在第一行有效当代码的前面, 需要使用三个双引号引起来（机器的说明书）
函数体 - 和def保持一个缩进的一条或者多条语句；实现函数功能代码3)初学者声明函数的步骤
a.确定函数的功能
b.根据函数的功能确定函数名
c.确定参数(形参), 看实现函数的功能需不需要额外的数据, 需要几个就设置几个形参
d.实现函数的功能
e.写说明文档
注意: 声明函数的时候不会执行函数!!（重要!）
1).声明一个函数，打印两个数的和
def yt_sum(num1, num2):
"""
（函数功能说明区）求两个数的和
:param num1: 提供第一个数；数字
:param num2: 提供第二个数；数字
:return: (返回值)
"""
# num1=10; num2=20
print(num1 + num2) # print(10+20) print(30)
2).声明一个函数，求N!
def factorial(n):
"""
求N的阶乘
:param n: 数字N的值
:return: None
"""
# n=5; n=10
sum1 = 1
for x in range(1, n+1):
sum1 *= x
print('%d的阶乘是:%d' % (n, sum1))
3.函数的调用(使用机器)
1)语法:
函数(实参列表)2)说明
函数 - 已经声明的函数
() - 固定写法
实参列表 - 多个数据用逗号隔开; 需要传递到函数中使用的具体的数据, 用来形参赋值的3)函数的调用过程(非常重要)
a.回到函数声明的位置
b.传参 - 用实参给形参赋值(必须保证每个形参都有值)
c.执行函数体
d.确定返回值
e.回到函数调用的位置，接着往后执行
yt_sum(10, 20)
factorial(5)
factorial(10)
1.根据实参的传值方式将实参分为: 位置参数、关键字参数
- 1）位置参数 - 直接让实参的值和形参一一对应
- 2）关键字参数 - 调用函数的时候以'形参名1=值1,形参名2=值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) # a:10,b:20,c:30
# 关键参数
func1(a=100, b=200, c=300) # a:100,b:200,c:300
func1(c=33, a=11, b=22) # a:11,b:22,c:33
# 混用
func1(100, c=300, b=200) # a:100,b:200,c:300
# func1(b=22,a=11, 33) # SyntaxError: positional argument follows keyword argument
# func1(10, 20, b=30) # TypeError: func1() got multiple values for argument 'b'
2. 参数默认值(形参)
声明函数的时候，可以通过'参数名=值'的形式给参数默认值; 有默认值的参数在调用的时候可以不传参
关键参数的使用场景: 想要跳过前面有默认值的参数直接给后面参数赋值的时候，必须使用关键字参数
注意: 有默认值的参数必须放在没有默认值参数的后面
# 给所有的参数赋默认值
def func2(a=1, b=2, c=3):
# a=10, b=20
print('a:{},b:{},c:{}'.format(a, b, c))
func2()
func2(10)
func2(10, 20)
func2(b=200)
def func3(a, b, c=3):
print('a:{},b:{},c:{}'.format(a, b, c))
3. 参数类型说明
- 1)给参数赋默认值
- 2)形参: 类型名
- 3)返回值类型说明 -> 类型
def func4(z: list, y: str, x=10) -> str:
"""
功能; x -> int z是列表
:param x:
:return:
"""
# z.append(10)
print(z)
# func4('abc', 100)
4.不定长参数
声明函数的时候，参数个数不确定（不定长参数）
1)声明函数的时候在参数名前加*, 这个参数就会变成一个元祖，元祖中的元素就是对应的多个实参
注意:
a.调用的时候只能使用位置参数
b.不定长参数后面如果有其他的定长参数，那么它后面的其他参数必须使用关键字参数传参2)声明函数的时候在参数名前加**, 这个参数就会变成字典，字典中的元素-> 关键字:实参值
注意:
a.调用的时候只能使用关键字参数
b. *和**同时使用时这个函数参数个数不确定，只能可以同时使用位置参数和关键参数；写的时候*要在**的前面
# 写一个函数，求多个数的和
def yt_sum(*x):
sum1 = 0
for num in x:
sum1 += num
print(sum1)
yt_sum()
yt_sum(10)
yt_sum(10, 20)
yt_sum(1, 2, 3)
yt_sum(1, 23, 4, 5, 6, 7, 8)
def func5(name, *scores, gender):
print(name, scores, gender)
# gender必须使用关键字参数
func5('余婷', gender='男')
func5('余婷', 29, 90, 89, 78, gender='女')
print('===================加**=================')
def func6(**x):
print(x)
func6(x=100)
func6(a=1, b=2)
func6(a=10, b=3, x=20, y=100)
print('=================同时使用*和**==================')
def func7(*args, **kwargs):
print(args)
print(kwargs)
func7()
func7(1, 2)
func7(a=10, b=20, c=30)
func7(12, a=10)
