python中函数学习笔记

# 函数的传参
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'