一、变量
01-变量的引用
1.1 引用的概念
1.变量和数据是分开存储的
2.数据保存在内存的一个位置，变量存储着数据在内存中的地址
3.变量中纪录数据的地址就叫做引用
# 使用id()函数可以查看变量中保存数据所在的地址
注意：如果变量已被定义，当给一个变量赋值的时候，本质上就是修改了数据的引用
eg: 定义a = 1，id(1) 得出1的内存地址为0032
id(a)得出a的内存地址也为0032
定义b = a，id(b)得出b的地址也为0032
修改引用为a = 2，id(a)与id(2)得出内存地址都为0064，而id(b)依旧为0032
所以我的理解是，原本的数据在内存中有一个固定的位置，而变量就是一个标签，上面写着要引用数据的地址
变量 a 上面写着1的内存地址0032，变量 b 因为赋值 a 所以也是0032，而之后 a 赋值2，于是 a 上面写着2的内存地址0064，b则因为没有操作依然为0032
1.2 函数的参数和返回值的传递
1.调用函数的，本质上传递的是实参保存数据的地址，而不是实参保存的数据
2.函数的返回值，返回的是数据的地址，而不是数据本身
3.如果函数有返回值，但是没有定义变量接收，程序不会报错，但是无法获得返回结果
eg:def test(num):
print("%d的地址是%d" % (num, id(num)))
result = "hello"
print("%s的地址是%d" % (result, id(result)))
return result
a = 10
print("a的地址是%d" % id(a))
r = test(a)
print("%s的地址是%d" % (r, id(r)))
02-可变和不可变类型
不可变类型：内存中数据不允许被修改
数字类型：int，bool，float，complex，long(2.x)
字符串：str
元组：tuple
可变类型：内存中的数据可以被修改，即分配空间之后，仍然可以使用方法来修改类型中的内容，而不会改变内存地址
列表、字典
eg:定义一个列表变量 a = [1, 2, 3]，id(a)为70272，我们在其中利用append方法追加数据，变成 a = [1, 2, 3, 999]，id(a)为70272
即使是clear方法清空后，id(a)仍为70272，但是如果赋值 a = []，id(a)为64352，发生改变。字典同理
# 如果给一个可变类型的变量，赋值一个新的数据，则变量不再引用之前的数据，改为引用新的数据
注意：字典的 key 只能使用不可变类型的数据，value 可以是任意类型的数据
哈希（hash）
python中的内置函数hash(o)，用于接收一个 不可变类型 的数据作为 参数，而 返回 结果是一个 整数
哈希是一种 算法，其作用就是提取数据的 特征码（指纹），即相同的内容 得到 相同的结果，不同的内容 得到 不同的结果
在Python中，设置字典的 键值对 时，会首先对 key 进行 hash，保证内存中保存字典的数据得到优化，方便 后续 对字典的操作：增、删、改、查
03-局部变量和全局变量
局部变量 是在 函数内部 定义的变量，只能在函数内部使用
全局变量 是在 函数外部定义 的变量（没有定义在某一个函数内），所有函数 内部 都可以使用这个变量
3-1 局部变量
1.局部变量 是在 函数内部 定义的变量，只能在函数内部使用
2.函数执行结束后，函数内部的局部变量，会被系统回收
3.不同的函数，可以定义相同的名字的局部变量，但是 彼此之间 不会产生影响
作用：临时保存函数内部需要的数据
生命周期：变量从被创建到被系统回收的过程
1.局部变量 在 函数执行时 才会被创建
2.函数执行结束后 局部变量 被系统回收
3.局部变量在生命周期 内，可以用来存储 函数内部临时使用到的数据
3-2 全局变量
1) 函数不能直接修改 全局变量的引用，但所有的函数内部都可以使用这个变量
# 若在函数内部定义的变量与全局变量同名，只认为是局部变量，不会修改全局变量
2) 在函数内部修改全局变量的值，需要使用 global 关键字进行声明
# global关键字会告诉解释器后面的变量是全局变量，再使用赋值语句就不会创建局部变量
3) 全局变量定义的位置
# 为了保证所有的函数都能够正确使用到全局变量，应该将全局变量定义在其他函数的上方，否则即使编写时不会出错，编译函数时也会报错
4) 全局变量命名的建议
为了避免局部变量和全局变量出现混淆，在定义全局变量时，可以适当添加前缀，如 g_ 或 gl_ 等
注意：
函数执行变量顺序：局部变量 ==> 全局变量 ==> 报错
代码顺序：shebang ==> import模块 ==> 全局变量 ==> 函数定义 ==> 执行代码
二、函数
01-函数的参数与返回值
外界通过参数将数据传递到函数内部进行处理，而函数通过返回值向外界报告函数结果，以此可分为四种类型：无参数，无返回值；无参数，有返回值；有参数，无返回值；有参数，有返回值
1.1 无参数，无返回值
02-函数的返回值（进阶）
要返回多个结果时，可以用元组来返回多个数据
def measure():
print("开始测量...")
temp = 37
wetness = 50
print("结束测量...")
return temp, wetness
# 返回类型是元组时，小括号可以省略
result = measure()
在python中可以将一个元组通过赋值语句同时赋给多个变量，要求变量数量和赋值顺序必须和元组一致
gl_temp, gl_wetness = result
拓展1：交换数字顺序
a = 6， b = 100
1.使用其他变量
c = a
a = b
b = c
2.不使用其他变量
a = a + b
b = a - b
a = a - b
3.python专属，元组
a, b = b, a
03-函数的参数（进阶）
3-1 可变参数和不可变参数
1.只要针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用
def demo(num, num_list):
num = 100
num_list = [1, 2, 3]
print("在内部是以下结果:")
print(num)
print(num_list)
gl_num = 99
gl_list = [4, 5, 6]
demo(gl_num, gl_list)
print("在外部是以下结果")
print(gl_num, gl_list)
2.如果传递的可变参数，在函数内部使用方法进行修改，同样会影响到外部数据
def mutable(num_list):
num_list.extend([4, 5])
print("在函数内部是:")
print(num_list)
gl_num_list = [1, 2, 3]
mutable(gl_num_list)
print(gl_num_list)
拓展2：+=在列表中的操作
在python中，对列表的+=操作本质上是执行列表的 extend 方法，没有修改引用，会影响外部数据
而先+后=分开操作，则会修改引用，不改变外部数据
def demo(num, num_list):
num += num
num_list += num_list # 外部为[1, 2, 3, 1, 2, 3]
num_list = num_list + num_list # 外部为[1, 2, 3]
print("函数内部的代码是:")
print(num)
print(num_list)
print("函数结束")
gl_num = 1
gl_list = [1, 2, 3]
demo(gl_num, gl_list)
print(gl_num)
print(gl_list)
3-2 缺省参数
介绍
定义函数时，给某个参数指定一个默认值，具有默认属性的参数就叫做缺省参数
在调用函数时，如果没有传入缺省参数的值，则在函数内部定义函数时指定的参数默认值
函数的缺省参数，将常见的值设置为参数的缺省值，从而 简化函数的调用
gl_num_list = [6, 3, 9]
# 默认就是升序排序，因为这种应用需求更多
gl_num_list.sort()
# 只有当需要降序排序时，才需要传递 `reverse` 参数，在这里reverse就是缺省参数，默认缺省值为False，降序时才传入True
gl_num_list.sort(reverse=True)
指定函数的缺省参数
在参数后使用赋值语句，可以指定参数的缺省值
def print_info(name, gender=True):
gender_text = "男生"
if not gender:
gender_text = "女生"
print("%s是%s" % (name, gender_text))
# 注意
1. 缺省参数，需要使用最常见的值作为默认值
2. 如果一个参数的值不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递
缺省参数的注意事项
(1) 带有默认值的缺省参数必须定义在参数列表末尾
(2) 在调用具有多个缺省参数的函数时，需要指定参数名
def print_info(name, title="", gender=True):
gender_text = "男生"
if not gender:
gender_text = "女生"
print("%s[%s]是%s" % (name, title, gender_text))
print_info("小明")
print_info("小明", title="班长")
print_info("小美", gender=False)
3-3 多值参数（了解）
1.定义支持多值的参数的函数
有时需要一个函数能处理的参数是不确定的，则需要使用多值参数
参数前一个 * 可以接收元组，常命名为 *args # arguments缩写，意为变量
参数前两个 * 可以接收字典，常命名为 **kwargs # keywordarguments的缩写，记忆键值对参数
eg:def demo(num, *args, **kwargs):
print(num)
print(args)
print(kwargs)
demo(1, 2, 3, 4, 5, name="小明", age=18)
2.案例演练——计算任意多数字的和
将所有传递的数字累加，并返回累加结果
def sum_numbers(*args):
num = 0
for i in args:
num += i
return num
print(sum_numbers(1, 2, 3))
3-4 元组和字典的拆包（了解）
在调用带有多值参数的函数时，为了让元组变量直接传递给args，字典变量直接传递给kwargs，则要使用拆包，否则只能一个一个传递元素
即在元组变量前添加 * ，在字典变量前添加 **
eg:def demo(*args, **kwargs):
print(args)
print(kwargs)
gl_num = (1, 2, 3)
gl_dict = {"name": "小明", "age": 18}
demo(*gl_num, **gl_dict)
如果不添加*和**，则字典变量同样会传入元组中
04-函数的递归
1.一个函数自己调用自己称为递归，递归需要一个出口，否则会陷入死循环
eg:def sum_numbers(num):
print(num)
if num == 1:
return
sum_numbers(num - 1)
sum_numbers(3)
2.案例——计算数字累加
eg:def demo(num):
if num == 1:
return 1
temp = demo(num - 1)
return num + temp
print(demo(100))
# 这里demo(100) = 100 + demo(99)，demo(99) = 99 + demo(98)，以此类推，最后demo(1) = 1，随后又依次返回，相当于 100 + 99 + 98…… = 5050
在处理不确定的循环条件（如：遍历整个文件目录的结构），递归则非常有用