day09

1. 什么是函数

函数: 对代码块和功能的封装和定义

    while 1:
        print("首先, 打开手机")
        print("打开陌陌")
        print("找一个看着还不错的某一某")
        print("出来约一约.开开心心")
        print("各回各家,各找各妈")
    # 需要把上面这个功能进行定义或者封装. 在需要的时候.随时拿过来执行, 封装的这个东西就是函数
    
    # 定义一个功能叫yue
    def yue():
        # 函数体,代码块
        print("首先, 打开手机")
        print("打开陌陌")
        print("找一个看着还不错的某一某")
        print("出来约一约.开开心心")
        print("各回各家,各找各妈")

     # 函数的调用, 函数名()
    yue()   # 执行函数  # 第一次调用
    print("正常上班")
    yue()   # 第二次调用

2. 函数的返回值

# 执⾏完函数之后. 我们可以使⽤return来返回结果. 
   
    函数中return的使⽤:
        (1) 函数中遇到return, 此函数结束, 不再继续执⾏.
        def yue():
            print("约你")
            print("约我")
            print("约他")
            return
            print("约谁呀") # 这句话不会被执⾏
        yue()

        (2) retrun 返回值  
        # 当函数结束的时候. 给调用方一个结果
        def yue():
            print("约你")
            print("约我")
            print("约他")
            return "m美女一枚"
        girl = yue()
        print(girl)

        # 函数的返回值可以有多个结果,但是在接收的位置接收到的是tuple(元组)类型的数据
        def yue():
            print("打开陌陌")
            print("大阳哥出马")
            return "大妈", "萝莉", "模特"
            print("我还要约")
        girl = yue()
        print(type(girl)) # tuple

        a, b, c = yue() # 多个返回值在接收的位置接收到的是tuple类型的数据
        print(a)
        print(b)
        print(c)

总结⼀下: 
    1. 遇到return. 此函数结束, 函数后⾯的东⻄将不会再执⾏
    2. return 返回值   
    
    关于返回值:
        1. 什么都不写. 不写return. 返回None
        2. 写了return, 返回Nnone
        3. return 值. 有一个返回值.
        4. return 值1, 值2, 值3....多个返回值. 接收的是元组(不可变),调⽤者可以直接解构成多个变量

3. 函数的参数

# 参数: 在函数执行的时候给函数传递的信息
# 形参: 在函数声明的位置. 声明出来变量
# 实参: 在函数调用的时候. 实际你给函数传递的值
# 传参: 把实参交给形参的过程
# 函数的参数个数是没有要求的 但是,在运行的时候. 形参和实参要匹配. 按照位置把实参赋值给形参
def yue(fangshi, age):   # 形参
    print("打开手机")
    print("打开%s" % fangshi)
    print("找一个漂亮的妹子")
    print("年龄最好是%s" % age)
    print("出来约一约")

# 在函数调用的地方给的具体的值: 实参
yue("微信")
yue("探探",38)
yue("陌陌",26)

参数:
    形参:
        1. 位置参数
        2. 默认值参数
        3. 动态传参
    实参:
        1. 位置参数,记住位置
        2. 关键字参数, 记住名字
        3. 混合参数, 顺序: 先位置后关键字

# 实参
def chi(good_food, no_good_food, drink, ice_cream): # 形参的位置参数
    print(good_food, no_good_food, drink, ice_cream)
    
    # 位置参数, 当函数的参数很多的时候, 必须要记住每一个位置是什么
    chi("大白梨","法国大蜗牛","卫龙辣条","哈根达斯")  # 实参的位置参数
    
    # 关键字参数, 按照形参的名字给形参传值
    chi(drink="神仙水",ice_cream="老冰棍",good_food="盖浇饭",no_good_food="锅包肉")  # 实参的关键字参数
    
    # 混合参数, 既用位置参数, 也用关键字参数. 位置参数必须在关键字参数前面
    chi("盖浇饭","汉堡",ice_cream="巧乐兹",drink="营养快线")  # 混合参数,顺序:先位置后关键字

# 形参
def regist(id, name,):  # id name位置参数
    print("录入学生信息:id是%s, 名字是%s." % (id, name,))

regist(1, "大阳哥")
regist(2, "徐卫星")

def func(n = "男"):  # n="男" 默认值参数
    print("录入性别:%s" % n)
func()

def regist(id, name, sex="男"):# 混合参数,默认值参数必须在参数列表的最后
    print("录入学生信息:id是%s, 名字是%s, 性别是:%s" % (id, name, sex))

regist(1, "大阳哥")
regist(2, "徐卫星")
regist(3, "毛尖妹妹", "女")

参数的分类:
    站在实参的角度:
            1. 位置参数, 当函数的参数很多的时候, 必须要记住每一个位置是什么
            2. 关键字参数, 按照形参的名字给形参传值
            3. 混合参数, 既用位置参数, 也用关键字参数. 位置参数必须在关键字参数前面
    站在形参的角度:
            1. 位置参数
            2. 默认值参数
            3. 默认值参数和位置参数混合使用. 顺序: 先写位置参数. 然后写默认值参数

3. 函数的实际应用

# 1. 输入一个数,计算从1累加到这个数的结果
# 1+2+4+5+..+n = ?
# 对功能的封装
def sum(n):
    s = 0
    count = 1
    while count <= n:
        s = s + count
        count = count + 1
        return s
ret = sum(5)  # 这个数是5
print(ret)

# 2. 计算n是奇数还是偶数?
def fn(n):
    if n%2 == 0:
        return "偶数"
    else:
        return "奇数"
ret = fn(456)
print(ret)
print(fn(456))

4. 冒泡排序(bubble)

lst = [1, 8, 16, 2, 5, 7]
    # 通过交换的方式. 把列表中最大的值移动到最右端

for abc in range(len(lst)):  # 控制内部移动的次数,需要完成6个数的右移
    n = 0
    while n < len(lst) - 1:  # 每次都需要从第一个数开始比较,比5次,完成一个数的右移.
        if lst[n] > lst[n+1]:
            lst[n], lst[n+1] = lst[n+1], lst[n]
        n = n + 1
print(lst)