# 函数的传参
def func1(name, age, *args, **kwargs):
# print(kwargs['skills'])
tall, weight, sex = args
skills = kwargs['skills']
print('我叫做{}，我今年{}岁，身高：{},体重：{},性别：{},我学过{}等等'.format(name, age, tall, weight, sex, ','.join(skills)))
func1('Brigham', 31, 171, 60, '男', skills=['java', 'js', 'python', 'AE'])
求随机数的函数
import random
def generate_random():
for i in range(10):
ran = random.randint(1, 20)
print(ran, end=' ')
generate_random()
str1 = 'abc'
str2 = str1
str1 = str1.replace('b','')
print(str1)
函数：
增加代码复用性，减少代码冗余
定义函数：
def 函数名([形参,...]):
函数体
例：
定义：
def add(实参):
result = 1+3
print(result)
调用：
add() ---->4
* 固定参数个数：
定义:
def add(a, b):
pass
# 调用
add(1, 3)
# 可变参数
# 定义方式
# 形式一
def add(*args):
print(args)
add() # ---->空元祖
add(1, 2) # ----> (1,2)
add(1, 2, 3, 4) # ----> (1,2,3,4)
# 混合形式一
# 可变参数必须在固定参数的后面
# 错误：
def add(*args, name):
print(args, name) # 报错
# 正确：
def add(name, age, *args):
print(args, name, age)
# 混合形式二:可变参数+关键字参数（key=value）
def add(a, b=10): # 关键字参数
result = a + b
print(result)
add(5) # ---->15
add(4, 7) # ---->11
def add(a, b=10, c=4):
result = a + b + c
print(result)
add(2, c=6) # ---->18
# 拆包与装包：调用的时候两个*的装用是拆包，定义的时候两个*的作用是装包
# def aa(**kwargs):
# print(kwargs)
#
#
# dict1 = {'a': 1, 'b': 'hello', 'c': 'tom'}
#
# aa(**dict1) # a=1,b='hello',c='tom' 两个*的作用在这里是拆包
# def bb(a, b, *c, **d):
# print(a, b, c, d)
#
#
# bb(1, 2) # ----> 1 2 () {}
# bb(1, 2, 3, 4) # ----> 1 2 (3, 4) {}
# bb(1, 2, x=100, y=200) # ----> 1 2 () {'x':100,'y':200}
# bb(1, 2, 3, x=100) # ----> 1 2 (3,) {'x':100}
# bb(1, 2, x=100, 5, 6) # ---->报错 （）
# def func(a, *args):
# print(a, args)
#
#
# func(2, 3, 4, 5) # ----> 2 (3,4,5)
# func(2, [1, 2, 3, 4]) # ----> 2 ([1,2,3,4],)
# func(2, 3, [1, 2, 3, 4, 5]) # ----> 2 (3,[1,2,3,4,5])
# func(5, 6, (4, 5, 7), 9) # ----> 5 (6,(4,5,7),9)
# def func(a, b=10, c=3, **kwargs):
# print(a, b, c, kwargs)
#
#
# func(1) # ----> 1 10 3 {}
# func(2, b=10) # ----> 2 10 3 {}
# func(3, 5, 7, a=1, b=2) # ----> 报错 不能重复给b传参
def func(a, *args, **kwargs):
print(a, args, kwargs)
def func2(a, b, *args, **kwargs):
print(a, b, args, kwargs)
t = (1, 2, 3, 4)
func(1, t) # ---->1 ((1,2,3,4),) {}
func2(1, t) # ----> 1 (1,2,3,4) () {}
list1 = [2, 5, 8]
# func(1, list1, a=9, b=6) # ----> 报错 不能重复给a传参
func(1, list1, x=9, y=6) # ----> 1 ([2,5,8],) {'x':9,'y':6}
func2(1, list1, x=9, y=6) # ----> 1 [2,5,8] () {'x':9,'y':6}
dict1 = {'1': 'a', '2': 'b', '3': 'c'}
# 列表类型的参数用一个 * 拆包，字典类型的参数用两个 * 拆包
# 案例一
# list1 通过一个*拆包变成 2，5，8这种形式的参数，dict1通过两个*拆包成 '1'='a','2'='b','3'='c'这种形式的参数
# func(1, *list1, **dict1) # ----> 1 (2, 5, 8) {'1': 'a', '2': 'b', '3': 'c'}
#
#
# func(1, 2, 3, 4, 5, dict1) # 1 (2,3,4,5,{'1': 'a', '2': 'b', '3': 'c'}) {}
# func(1, 2, 3, 4, 5, **dict1) # 1 (2,3,4,5) {'1': 'a', '2': 'b', '3': 'c'}
# 案例二
def func1(name, *args):
if len(args) > 0:
for i in args:
print('{}学过了{}'.format(name, i))
else:
print('没有学过任何编程知识！')
course = ['html', 'mysql', 'python']
# 调用函数
func1('lucy', course) # ----> lucy学过了['html', 'mysql', 'python']
# func1('lucy', *course) #拆包
# 结果：
# lucy学过了html
# lucy学过了mysql
# lucy学过了python
总结：
无参数函数：
1.普通函数
def func(name,age):
pass
func('aa',18) ---->形参和实参的个数要一致
2.可变参数
A.def func(*args):
pass
func() ----> 函数调用时，参数的个数可以没有，也可以多个 *不能是关键字参数
B.def func(**kwargs):
pass
func('a'=1,'b'=2) ---->函数调用时，实参的个数可以没有，也可以多个 **必须是关键字参数
C.def func(*args,**kwargs):
pass
list1=[1,3]
dict1=['1':'a','2':'b']
func(*list1,**dict1) # func(1,3,'1'='a','2'='b')
D. 混用
def func(name,*args,**kwargs):
pass
func('tom') ---->必须赋值
3.默认值+关键字
def func(name,age=18):
pass
func('tom') ----> tom 18
func('tom',age=18) ----> 关键字赋值
# return 返回值
# 1. return 后面可以是一个参数，在调用的时候可以用一个变量来接收
# 2. return 后面页可以是多个参数，如果是多个参数则底层会将多个参数放在一个元组中，将元组作为一个整体返回
# 3. 接收的时候也可以是多个：return 'hello'，'world' x,y = ('hello','world') ----> x='hello' y='world'