Python-变量

作业回顾-1

# 4、写一个函数,传递的参数是[4, 55], 返回值是[55, 4]
# 交换函数
def swag(lst):
    print("交换位置前：", lst)
    # 将位置1上的数 存储起来
    temp = lst[1]  # temp = 4
    # 将0位置上的数 赋值给 1位置上的数 【55,55】
    lst[1] = lst[0]
    # 将temp赋值给位置0
    lst[0] = temp   # [4,55]
    print("交换位置后：", lst)


#     0   1
swag([5, 48])

作业回顾-2

# 5、写一个函数,传递的参数是[2, 5, 3], 把最大的值 放在第一个位置 [5, 2, 3]
def bubble_sort(lst):

    if lst[0] > lst[1]:
        temp = lst[0]  # temp = 2
        lst[0] = lst[1]  # [5,5,3]
        lst[1] = temp  # [5,2,3]

    if lst[1] > lst[2]:
        temp = lst[1]  # temp = 5
        lst[1] = lst[2]  # [2,3,3]
        lst[2] = temp  # [2,3,5]

    print(lst)


# 把最大的数放到最后面
bubble_sort([25, 55, 3])

 作业回顾-3

# 5、写一个函数,传递的参数是[2, 5, 3], 把最大的值 放在第一个位置 [5, 2, 3]
def bubble_sort(lst):
    # if lst[0] > lst[1]:
    #     temp = lst[0]  # temp = 2
    #     lst[0] = lst[1]  # [5,5,3]
    #     lst[1] = temp  # [5,2,3]
    #
    # if lst[1] > lst[2]:
    #     temp = lst[1]  # temp = 5
    #     lst[1] = lst[2]  # [2,3,3]
    #     lst[2] = temp  # [2,3,5]

    # 列表长度
    length = len(lst)
    # 循环次数为列表长度-1
    for i in range(length - 1):
        # 0 1
        # 每次循环 两个位置进行比较
        if lst[i] > lst[i+1]:
            temp = lst[i]  # temp = 2
            lst[i] = lst[i+1]  # [5,5,3]
            lst[i+1] = temp  # [5,2,3]

    print(lst)


# 把最大的数放到最后面
bubble_sort([25, 55, 3, 1, 6, 8])

 作业回顾-4

# 5、写一个函数,传递的参数是[2, 5, 3], 把最大的值 放在第一个位置 [5, 2, 3]
def bubble_sort(lst):
    # if lst[0] > lst[1]:
    #     temp = lst[0]  # temp = 2
    #     lst[0] = lst[1]  # [5,5,3]
    #     lst[1] = temp  # [5,2,3]
    #
    # if lst[1] > lst[2]:
    #     temp = lst[1]  # temp = 5
    #     lst[1] = lst[2]  # [2,3,3]
    #     lst[2] = temp  # [2,3,5]

    # 列表长度
    length = len(lst)
    # # 循环次数为列表长度-1
    # for i in range(length - 1):
    #     # 0 1
    #     # 每次循环 两个位置进行比较
    #     if lst[i] > lst[i+1]:
    #         temp = lst[i]  # temp = 2
    #         lst[i] = lst[i+1]  # [5,5,3]
    #         lst[i+1] = temp  # [5,2,3]

    for j in range(length - 1):
        # j = 0,1,2,3,4,5
        # 循环次数为列表长度-1
        for i in range(length - j - 1):
            # 0 1
            # 每次循环 两个位置进行比较
            if lst[i] > lst[i + 1]:
                temp = lst[i]  # temp = 2
                lst[i] = lst[i + 1]  # [5,5,3]
                lst[i + 1] = temp  # [5,2,3]
    print(lst)
# 把最大的数放到最后面
bubble_sort([25, 55, 3, 1, 6, 8])

'''
分析过程：
遍数    比较次数
j      length - j - 1
0       length - 1
1       length - 2
2       length - 3

1  l -1
2  l-2
3  l-3
j  l -j

多层for循环
1、看最底层怎么实现 用最小的案例取演算一下
2、扩大范围，看扩大之后的规律，然后使用第一层for循环
4、按照上面的规律往上走...
'''

局部变量

# 局部变量
def func():
    # a就是局部变量 函数内部的变量
    a = "下雨了"
    print(a)


func()
# name 'a' is not defined
# 函数外部不能使用函数内部地变量
# print(a)

全局变量

# 全局变量
a = 100


def print_a():
    # 函数内部可以使用全局变量a
    print(a)


print_a()
# 函数外部也可以使用全局变量
print(a)

共享全局变量

# 定义一个全局变量
glo_num = 0
def change_num():
    # 全局变量全局化 可以使得函数内部可以修改全局变量 起到函数之间共享全局变量的作用
    # 如果没有 全局化，函数内部只能使用全局变量 但不能修改
    global glo_num
    # 修改全局变量
    glo_num = 100

def print_num():
    # 打印全局变量
    print(glo_num)

change_num()
# 如果修改成功 则打印100
# 但实际情况是 没有修改成功 两个函数无法共享全局变量
print_num()

函数返回值作为参数

# 函数的返回值作为参数进行传递
# function 函数 f(x)
def func1():
    return "我给你一大脚丫子"


def func2(var):
    # var = result = "我给你一大脚丫子"
    print("你说：", var)


# result = "我给你一大脚丫子"
result = func1()
print(result)
# result 传递给var
func2(result)

拆包元组

def tuple_func():
    return 100, 200


# t1 = (100, 200) 返回值是一个元组
t1 = tuple_func()
print(t1, type(t1))

# 将元组拆包成两个数值
num1, num2 = tuple_func()
# num1 = 100, num2 = 200
print(num1, num2, type(num1), type(num2))

拆包字典

# 拆包字典
name_dict = {"name": "", "professional": "搬砖"}
# 将字典拆开 接收的是键 不是值
# a = name, b = professional
a, b = name_dict
print(a, b)

# 通过拆包之后的键 获取字典的值
print(name_dict[a])
print(name_dict[b])

递归

# 1、函数调用另外一个函数
# def func():
#     print("我在益阳职业等你哦")
# def main():
#     # 函数内部 调用另外一个函数
#     func()
# main()
# 2、递归特点一、函数自己调用自己
# def main():
#     # 函数内部 调用另外一个函数
#     print("我想去成都")
#     main()

'''
RecursionError: maximum recursion depth exceeded while calling a Python object
自己调用自己 出现无法终止程序的特点，导致递归的深度超过限制
所以说 递归需要一个出口
'''
# main()

# 3、递归特点二、函数必须要有出口
# 打印10,9,8,...2,1
def print_num(num):
    print(num, end=" ")
    # 递归出口 当num=1时 结束递归
    if num == 1:
        return
    # 自己调用自己
    print_num(num-1)

# num = int()
print_num(10)

使用递归实现

# result = 1 + 2 + 3 + ... 99 + 100
def sum_num(num):
    # 递归出口
    if num == 1:
        return 1
    # 返回值 自己调用自己
    return num + sum_num(num-1)

print(sum_num(100))
'''
函数调用分析       
num = 1, sum_num(1) = 1
num = 2, sum_num(2) = num + sum_num(num-1) = 2 + sum_num(1) = 2 + 1 = 3
num = 3, sum_num(3) = num + sum_num(num-1) = 3 + sum_num(2) = 3 + 3 = 6
num = 4, sum_num(4) = num + sum_num(num-1) = 4 + sum_num(3) = 4 + 6 = 10
...
num = 100, sum_num(100) = num + sum_num(num-1) = 100 + sum_num(99) = 100 + 4950 = 5050

作业y
1、使用递归实现斐波那契数列
0 1 1 2 3 5 8 13 21 ... 
2、使用递归实现 0 - 100的偶数相加
0 + 2 + 4 + ... + 100
'''