小白的python之旅（十二）--函数的参数，返回值，全局变量和局部变量

小白的python之旅（十二）–函数的参数，返回值，全局变量和局部变量

1，函数的参数

# 1. 位置参数和关键字参数(实参分类)
"""
1)位置参数
实参直接写(直接将多个数据用逗号隔开)，让实参和形参从位置上一一对应
"""


def func1(a, b, c):
    print(f'a:{a}, b:{b}, c:{c}')


# 单独使用位置参数传参
func1(20, 30, 40)

"""
2) 关键字参数
以：形参名1=值1,形参名2=值2,.... 的形式传参

注意: 要保证每个参数都有值
"""
# 单独使用关键字参数传参
func1(a=20, b=30, c=40)
func1(b=30, c=40, a=20)

"""
3)位置参数和关键字参数混合
要求: 位置参数必须在关键字参数的前面
"""
func1(10, c=30, b=20)    # a:10, b:20, c:30
func1(10, 20, c=30)    # a:10, b:20, c:30
# func1(a=10, 20, 30)  # SyntaxError: positional argument follows keyword argument

# 2.参数默认值(形参)
"""
定义函数的时候可以以： 形参名=值  的形式给参数赋默认值, 调用函数的时候有默认值的参数可以不用传参

注意: 没有默认值的参数必须放在有默认值参数的前面
"""


# 所有的参数都有默认值
def func2(x=10, y=20, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


func2()     # x:10, y:20, z:30
func2(100)   # x:100, y:20, z:30
func2(y=200)  # x:10, y:200, z:30


def func3(y, x=10, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


# 3. 不定长参数(定义)
"""
定义参数的时候参数个数不确定就可以使用不定长参数

1) 在形参前加 * 
带一个*的形参，本质就是一个元组，对应的实参会作为这个元组的元素。
这种不定长参数的函数只能用位置参数传参

2) 在形参前加 **
带两个*的形参，本质就是一个字典，对应的实参会作为这个字典的值。
这种不定长参数的函数只能用关键字参数传参
"""


# 例子：定义一个函数可以求多个数的和
def yt_sum(*num):
    sum1 = 0
    for x in num:
        sum1 += x
    print(sum1)


yt_sum(1)
yt_sum(10, 20)
yt_sum(1, 2, 3, 4, 5)


def yt_sum2(**num):
    print(num)


yt_sum2(a=10, b=20)

2，函数返回值

"""
返回值是从函数里面传递到函数外面的数据

1) 怎么返回数据
返回值就是 return 关键字后面的表达式的值

语法：
return 表达式1,表达式2,....

说明:
return - 关键字，只能出现在函数体中
         a.将数据从函数内容扔到函数的外部   b. 结束函数(执行函数的时候只要遇到return函数直接结束)
         
表达式  - 可以一个都没有(相当于 None)，可以有一个(返回值就是指定数据)，也可以有多个(本质返回的是一个元组)

注意： 如果一个函数中没有return（或者执行函数体的时候没有遇到 return）那么这个函数的返回值就是 None

2) 怎么在外部使用返回值返回的数据
返回值就是函数调用表达式的值

"""
# 2.什么时候需要返回值（初学者）
"""
看实现函数的功能会不会产生新的数据，如果产生了新的数据，就将新的数据作为返回值返回
"""


def yt_sum(n):
    # n = 5
    sum1 = 0
    for x in range(n+1):
        sum1 += x
    # print(sum1)
    # return None
    return sum1


# 普通数据能做的事情函数调用表达式都可以做
# a = 10
a = yt_sum(10)
print('a:', a)

# print(10)
print(yt_sum(10))

# print(10 * 2)
print(yt_sum(10) * 2)

# list1 = [10, 20, 30]
list1 = [yt_sum(10), 20, 30]
print(list1)


def fun1():
    return [1, 2, 3]


print(fun1()[1])    # print([1, 2, 3][1])

# 3. 函数调用过程（非常重要！）
"""
第一步：回到函数定义的位置
第二步：传参(用实参给形参赋值；传参的时候必须保证每个参数都有值)
第三步：执行函数体
第四步：执行完函数体(a.执行完函数体中的最后一条语句  b.遇到了return)，确定函数返回值(看执行完函数体有没有遇到return,如果遇到了函数的返回值就是return后面的值，否则是 None)
第五步：回到函数调用的位置接着往后执行(这个时候函数调用表达式的值就是函数的返回值)
"""
print('=======')
# print(sum1)
print(yt_sum(5))    # 15
print('+++++++')
# print(sum1)

3，全局变量和局部变量

# 1. 函数调用过程中内存的变化
"""
每次在调用函数的时候，系统会自动为这个函数创建一个独立的栈区间，用来保存函数运行过程中产生的数据(函数的参数；函数中声明的变量)；当函数调用结束后这个栈区间会自动销毁。（压栈）
"""

# 2.全局变量和局部变量
"""
1）全局变量
没有定义在函数里面或者类里面的变量就是全局变量

作用域：从定义开始到程序结束的任何位置都可以使用
"""
# 变量 a 是全局变量
a = 10

print(a)

for _ in range(5):
    print('循环中：', a)


def func1():
    print('函数中:', a)


func1()

# 变量b、c都是全局变量
for b in range(5):
    c = 10
    print('b循环中', b, c)

print('b循环外:', b, c)


def func2():
    print('b函数中:', b, c)


func2()


"""
2) 局部变量
定义在函数中的变量就是局部变量(形参是局部变量，注意：定义函数的时候给形参赋的默认值其实是保存在堆里面的)

作用域：从定义开始到函数结束的任何位置都可以使用
"""


def func3():
    # 变量x是局部变量
    x = 100
    print(x)
    for _ in range(3):
        print('x2:', x)


func3()
# print(x)    # NameError: name 'x' is not defined

# 面试题：问以下程序结束后打印结果是多少
def func3(list1=[10, 20, 30]):
    # list1 = [10, 20, 30]
    list1.append(100)    #  list1 = [10, 20, 30, 100]
    return list1


scores = func3()   #  scores = [10, 20, 30, 100]
scores = func3()   #  scores = [10, 20, 30, 100]
print(scores)      #  [10, 20, 30, 100, 100]


# 3. global 和 nonlocal
"""
1) global：在函数中声明指定的变量是全局变量
作用：a. 在函数中修改全局变量的值   b. 在函数中定义一个全局变量
注意：声明必须放在使用变量前
"""

name = '张三'


def change():
    # 在函数中修改全局变量name的值
    global name

    print(name)
    name = '李四'

    # 在函数中定义全局变量 age
    global age
    age = 18


change()
print(name)
print(age)


"""
2) nonlocal(了解)
如果希望在局部的局部中去修改局部变量的值，就可以用 nonlocal 进行说明
"""


def func4():
    m = 100

    def func5():
        nonlocal m
        m = 200
        print('m1:', m)

    func5()
    print('m2:', m)


func4()