python学习day12和day13（变量（局部/全局），返回值，函数参数，拆包）

一.变量作用域

【一】局部变量

所谓局部变量是定义在函数体内部的变量，即只是函数体内生效

def testA():
   a=100
   print(a)
testA() #100
#print(a) #报错

【1】变量a是定义在testA函数内部的变量，在函数外部访问则立即报错
【2】局部变量的作用：在函数内部，临时保存数据，即当函数调用完成后，则销毁局部变量

【二】全局变量

所谓局部变量，指的是在函数体内，外都能生效的变量
思考：如果一个数据，在函数A和和函数B中都要使用，该怎么办？
答：将这个数据储存在一个全局变量里面。

a = 100
def testA():

   print(a)

def testB():
   print(a*2)
testA() #100
testB() #200

【三】修改全局变量

思考：testB函数需求修改a的值为200

a = 100
def testA():

   print(a)

def testB():
   a=200  #不可以a=a*2，会报错
   print(a)
testA() #100
testB() #200
print(a)  #100

注意：并没有改变全局变量a

思考：如何在函数体内修改全局变量
语法：

global 全局变量名

a = 100
def testA():

   print(a)

def testB():
   global a
   a=200
   print(a)
testA() #  100
testB() #  200
print(a)  #  200

二.多函数程序执行流程

一般在实际开发过程中，一个程序往往有多个函数组成，并且多个函数共享某些数据，如下所示：

【一】共用全局变量

glo_num=0

def test1():
   global glo_num
   glo_num = 100
   

def test2():
   print(glo_num)

test2()
test1()
# 0

区分：

glo_num=0

def test1():
   global glo_num
   glo_num = 100


def test2():
   print(glo_num)
test1()
test2()

# 100

【二】返回值作为参数传递

def test1():
   return 10


def test2(num):
   return num*2
num = test1()
sum = test2(num)
print(sum)
# 20

三.函数的返回值

思考:如果一个函数如写两个返回值，程序如何执行？

def test1():
   return 10
   return 20


def test2(num):
   return num*2
num = test1()
sum = test2(num)
print(sum)
# 20

答：只执行了第一个return返回的值，不执行第二个return
修改：正确写法：

def test1():
   return 10,20

num = test1()

print(num)
# (10, 20)

【1】return a，b写法，返回多个数据的时候默认是元组类型
【2】return后面可以连接列表，元组或字典，以返回多个值

def test1():
   return [10,20]

num = test1()

print(num)
# [10, 20]
def test2():
   return {'age':10,'age1':20}

num = test2()

print(num)
# {'age': 10, 'age1': 20}

四.函数参数

【一】位置参数

位置参数 ：调用函数时根据函数定义的参数位置来传递参数

def user_info(name, age ,gender):
   print(f'你的名字是{name}，年龄是{age}，性别是{gender}')
user_info('TOM',12,'man')
#  你的名字是TOM，年龄是12，性别是man   

注意：传递和定义参数的顺序以及个数必须一致

【二】关键字参数

函数调用，通过“键=值”形式加以指定。可以让函数更加清晰，容易使用，同时 也清除了参数的顺序需求

def user_info(name, age ,gender):
   print(f'你的名字是{name}，年龄是{age}，性别是{gender}')
user_info('TOM',age=12,gender='man')
user_info('lily',gender='woman',age=18)
#  你的名字是TOM，年龄是12，性别是man
# 你的名字是lily，年龄是18，性别是woman

注意：函数调用时，如果有位置参数时，位置参数必修在关键字参数的前面，但关键字参数之间不存在先后顺序

【三】缺省参数

缺省参数也为默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）、

def user_info(name, age ,gender='man'):
   print(f'你的名字是{name}，年龄是{age}，性别是{gender}')
user_info('TOM',12)
user_info('lily',gender='woman',age=18)
#  你的名字是TOM，年龄是12，性别是man
# 你的名字是lily，年龄是18，性别是woman

注意： 函数调用时，如果为缺参数传至则修改默认参数值，否则使用这个默认值

不定长参数

不定长参数也叫作可变参数。用于不确定调用的时候会传递多少个参数的场景。此时，可以用包裹位置参数或者包裹关键字参数，来进行参数传递，会显得非常方便

【一】.包裹位置传递

def user_info(*args):
    print(args)
user_info('TOM')
user_info('TOM',18)
user_info()
#  ('TOM',)
#  ('TOM', 18)
#  ()

注意：传进的所有参数都会被args变量收集，他会根据传进参数的位置合并为一个元组（tuple），args是元组类型，这就是包裹位置传递

【二】.包裹关键字传递

def user_info(**kwargs):
    print(kwargs)
user_info(age=10,age1=20)
user_info(age=10,age1=20,age2=30)
user_info()
# {'age': 10, 'age1': 20}
# {'age': 10, 'age1': 20, 'age2': 30}
# {}

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程

五.拆包和交换变量值

【一】拆包

【一】元组拆包

def user_info():
    return 100,200
num1,num2=user_info()
print(num1,num2) 
# 100 200
num3=user_info()
print(num3)
# (100 200)

【二】字典拆包

dict1={'name':'TOM','age':18}
a,b = dict1
print(a) # name
print(b)  # age

print(dict1[a])  # TOM
print(dict1[b])  #  18

注意：字典拆包拆的是key

【二】交换变量值

需求：有变量a，b交换变量
【方法一】：借助第三方变量

a=10
b=20
c=0
c=a
a=b
b=c
print(f'a={a},b={b}')
#  a=20,b=10

【方法二】：利用拆包进行

a,b=1,2
a,b=b,a
print(f'a={a},b={b}')
#  a=2,b=1

六.引用

我么可以用id（）来判断两个变量是否为同一个值的引用，我们可以将id值理解为那块内存的地址标识

a=1
b=a
print(b)  # 1
print(id(a))  # 140718001362592
print(id(b))  # 140718001362592
a=2
print(id(a))  # 140718001362624

int不可变类型

七.引用当实参

def test1(a):
    print(a)#  100
    print(id(a))#  140717869441792
    a+=a
    print(a)#  200
    print(id(a))#  140717869444992

b=100   # 整型不可变
test1(b)

c=[11,22]  #  列表可变
test1(c)
#  [11, 22]#  2181930548096
#  [11, 22, 11, 22] #  2181930548096

可以当实参

八.可变与不可变

所谓可变与不可变类型：数据能够进行修改，如果直接修改就是可变，否则不可变 【1】可变类型：列表，字典，集合
【2】不可变类型：整型，浮点型，字符串，元组