聊聊python中的变量

一、变量的作用域

1、什么是变量的作用域

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用），主要分为两类：全局作用域与局部作用域。

其实作用域的划分比较简单，在函数内部定义范围就称之为局部作用域，在函数外部（全局）定义范围就是全局作用域

# 全局作用域
def func():
    # 局部作用域

2、局部变量与全局变量

在Python中，定义在函数外部的变量就称之为全局变量；定义在函数内部变量就称之为局部变量。

# 定义在函数外部的变量（全局变量）
num = 10
# 定义一个函数
def func():
    # 函数体代码
    # 定义在函数内部的变量（局部变量）
    num = 100

3、变量作用域的作用范围

全局变量：在整个程序范围内都可以直接使用

str1 = 'hello'
# 定义一个函数
def func():
    # 在函数内部调用全局变量str1
    print(f'在局部作用域中调用str1变量：{str1}')
​
# 直接调用全局变量str1
print(f'在全局作用域中调用str1变量：{str1}')
# 调用func函数
func()

局部变量：在函数的调用过程中，开始定义，函数运行过程中生效，函数执行完毕后，销毁

# 定义一个函数
def func():
    # 在函数内部定义一个局部变量
    num = 10
    print(f'在局部作用域中调用num局部变量：{num}')
​
# 调用func函数
func()
# 在全局作用域中调用num局部变量
print(f'在全局作用域中调用num局部变量：{num}')

运行结果：

普及小知识：计算机的垃圾回收机制

4、global关键字的应用场景

思考一个问题：我们能不能在局部作用域中对全局变量进行修改呢？

# 定义全局变量num = 10
num = 10
# 定义一个函数func
def func():
    # 尝试在局部作用域中修改全局变量
    num = 20
​
# 调用函数func
func()
# 尝试访问全局变量num
print(num)

最终结果：弹出10，所以由运行结果可知，在函数体内部理论上是没有办法对全局变量进行修改的，所以一定要进行修改，必须使用global关键字。

# 定义全局变量num = 10
num = 10
# 定义一个函数func
def func():
    # 尝试在局部作用域中修改全局变量
    global num
    num = 20
​
# 调用函数func
func()
# 尝试访问全局变量num
print(num)

记住：global关键字只是针对不可变数据类型的变量进行修改操作（数值、字符串、布尔类型、元组类型），可变类型可以不加global关键字。

二、函数的参数进阶

def func(参数1, 参数2, 参数3):

​ ...

func(10, 20, 30)

1、函数的参数

在函数定义与调用时，我们可以根据自己的需求来实现参数的传递。在Python中，函数的参数一共有两种形式：① 形参 ② 实参

==形参：在函数定义时，所编写的参数就称之为形式参数==

==实参：在函数调用时，所传递的参数就称之为实际参数==

def greet(name):  # name就是在函数greet定义时，所编写的参数（形参）
    return name + '，您好'
​
# 调用函数
name = '老王'
greet(name)  # 在函数调用时，所传递的参数就是实际参数

注意：虽然我们在函数传递时，喜欢使用相同的名称作为参数名称。但是两者的作用范围是不同的。name = '老王'，代表实参。其是一个全局变量，而greet(name)函数中的name实际是在函数定义时才声明的变量，所以其实一个局部变量。

2、函数的参数类型(调用)

☆ 位置参数

理论上，在函数定义时，我们可以为其定义多个参数。但是在函数调用时，我们也应该传递多个参数，正常情况，其要一一对应。

def user_info(name, age, address):
    print(f'我的名字{name}，今年{age}岁了，家里住在{address}')
    
# 调用函数
user_info('Tom', 23, '美国纽约')

注意事项：位置参数强调的是参数传递的位置必须一一对应，不能颠倒

☆ 关键词参数（Python特有）

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

def user_info(name, age, address):
    print(f'我的名字{name}，今年{age}岁了，家里住在{address}')
    
# 调用函数（使用关键词参数）
user_info(name='Tom', age=23, address='美国纽约')

3、函数定义时缺省参数（参数默认值）

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

def user_info(name, age, gender='男'):
    print(f'我的名字{name}，今年{age}岁了，我的性别为{gender}')
​
​
user_info('李林', 25)
user_info('振华', 28)
user_info('婉儿', 18, '女')

谨记：我们在定义缺省参数时，一定要把其写在参数列表的最后侧

4、不定长参数

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

☆ 不定长元组（位置）参数

def user_info(*args):
    # print(args)  # 元组类型数据，对传递参数有顺序要求
    print(f'我的名字{args[0]}，今年{args[1]}岁了，住在{args[2]}')
​
# 调用函数，传递参数
user_info('Tom', 23, '美国纽约')

☆ 不定长字典（关键字）参数

def user_info(**kwargs):
    # print(kwargs)  # 字典类型数据，对传递参数没有顺序要求，格式要求key = value值
    print(f'我的名字{kwargs["name"]}，今年{kwargs["age"]}岁了，住在{kwargs["address"]}')
​
# 调用函数，传递参数
user_info(name='Tom', address='美国纽约', age=23)

kw = keyword + args

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

Python组包：就是把多个数据组成元组或者字典的过程。

案例：Python中数据的传递案例

def func(*args, **kwargs):
    print(args)
    print(kwargs)
​
​
# 定义一个元组（也可以是列表）
tuple1 = (10, 20, 30)
# 定义一个字典
dict1 = {'first': 40, 'second': 50, 'third': 60}
# 需求：把元组传递给*args参数，字典传递给**kwargs
# ① 如果想把元组传递给*args，必须在tuple1的前面加一个*号
# ② 如果想把字典传递给**kwargs，必须在dict1的前面加两个**号
func(*tuple1, **dict1)

三、可变与非可变数据类型

1、引用变量

在大多数编程语言中，值的传递通常可以分为两种形式“值传递与引用（地址）传递”，但是在Python中变量的传递基本上都是引用（地址）传递。

☆ 聊聊变量在内存底层的存储形式

a = 10

第一步：首先在计算机内存中创建一个数值10（占用一块内存空间）

第二步：在栈空间中声明一个变量，如a

第三步：把数值10的内存地址赋予给变量小a，形成所谓的==“引用关系”==

☆ 如何验证Python中变量的引用关系

答：可以使用内置方法id()，其参数就是要显示的变量信息 => id(变量名称)

a = 10
print(id(a))

☆ 把一个变量赋予给另外一个变量的影响

a = 10
b = a
print(id(a))
print(id(b))

运行结果：

说明：由以上运行结果可知，当我们把一个变量赋予给另外一个变量时，其两者指向的内存地址相同。就说明a和b指向了同一块内存空间，原理图如下：

思考：如果在b = a以后，我们改变了变量a的值，问变量b是否会受到影响？

# a = 10
# print(id(a))
​
a = 10
b = a
​
a = 100
print(b)  # 10 或 100
​
print(id(a))
print(id(b))

原理图：

总结：不可变数据类型（数值）在赋值以后，其中一个值的改变不影响另外一个变量，因为两者指向空间地址不同。

2、Python中可变和非可变数据类型

☆ 问题1：在Python中一共有几种数据类型？

答：7种，数值（int整型、float浮点类型）、bool类型（True和False）、字符串类型（str）、元组（tuple 1,2,3）、列表（list [1, 2, 3]）、字典（dict {key:value})、集合（set {1, 2})

在Python中，我们可以把7种数据类型分为两大类：可变类型 + 非可变类型

① 不可变类型（内存地址一旦固定，其值就不能发生改变）

数值（int整型、float浮点类型）

bool类型（True和False）

字符串类型（str）

元组（tuple 1,2,3）

② 可变类型（内存地址一旦固定，其值是可以发生改变）

列表（list [1, 2, 3]）

字典（dict {key:value})

集合（set {1, 2})

☆ 问题2：如何判断一个数据类型是可变类型还是非可变类型？

在Python中，可变类型与非可变类型主要是通过这个数据类型在内存中的表现形式来进行定义的。

==① 可变类型就是在内存中，其内存地址一旦固定，其变量的值是可以发生改变的==

a = [1, 2, 3]
print(id(a))
​
# 向内存中追加新数据（对数据进行改变只能通过数据类型.方法()实现）
a.append(4)
print(id(a))

原理图：

==② 非可变类型就是在内存中，内存地址一旦固定，其变量的值就没办法发生任何改变了==

a = 10
print(id(a))
​
a = 'hello'
print(id(a))

原理图：

3、可变类型与非可变类型在函数中的应用

☆ 可变类型

# 定义一个函数
def func(names):
    names.append('赵六')
    
# 定义一个全局变量
names = ['张三', '李四', '王五']
# 调用函数
func(names)
​
print(names)  # ???

原理图：

综上所述：可变类型在函数中，如果在全局或局部中对可变类型进行增删改操作，其外部和内部都会受到影响。

☆ 不可变类型

# 定义一个函数
def func(num):
    num += 1
    print(num)
    
# 定义一个全局变量
a = 10
# 调用函数
func(a)
# 在全局作用域中打印a
print(a)

综上所述：不可变类型在函数中，局部或全局的改变对外部和内部都没有任何影响。

四、扩展：元组拆包

1、什么是拆包？

简单来说就是把一个元组中的数据一个一个拆解出来的过程，就称之为叫做拆包操作。

2、基本语法

tuple1 = (10, 20)
# 拆包
num1, num2 = tuple1
​
以上代码可以简写为
num1, num2 = (10, 20)
​
还可以进一步简写
num1, num2 = 10, 20

3、拆包典型案例

实现两个变量值的交换

① 引入第三方变量实现数值交换

c1 = '可乐'
c2 = '牛奶'
​
# 经过一系列Python操作，把c1和c2中的值进行交换
temp = c1
c1 = c2
c2 = temp
​
print(c1)  # 牛奶
print(c2)  # 可乐

② 使用元组拆包实现两个变量值交换

c1 = '可乐'
c2 = '牛奶'
​
c1, c2 = (c2, c1)
​
print(c1)  # 牛奶
print(c2)  # 可乐