一. 引用变量
引用变量： 值的传递通常可以分为两种方式，一种是值的传递 ，一种是引用地址传递，在Python中一般都是用引用地址传递
变量名和对象： 变量名（如 a）和它指向的对象（如整数 5）是分开的。变量名本身没有存储任何数据，它只是指向数据的一个标签（或者可以说是地址）
python
a = 5
print(id(a))
# 输出它的地址：140732632101960（每个人的地址不同）**变量在内存底层的存储方式：**第一步：在计算机内存中创建一个整型5（它占用了一块内存空间）。第二步：在栈空间声明一个变量"a" 。第三步：把数据10的内存地址赋值给变量a，形成引用关系。
如果我把a=5，再把a赋值给b，b当然也会是5，那b的地址会与a一样吗？
python
a=5
b=a
print(id(a)) #140732205462440
print(id(b)) #140732205462440当然是一样的，因为a赋值给b，赋值的是地址，b引用的也是5的地址。
总结：由以上运⾏结果可知，当我们把⼀个变量赋予给另外⼀个变量时，其两者指向的内存地址相同。 就说明a和b指向了同⼀块内存空间
如果当我把a赋值给了b，然后又将a改变，a和b会有什么样的变化呢？
python
a = 5
b = a
a = 5*2
print(a) #10
print(id(a)) #140732205462600
print(id(b)) #140732205462440
总结：不可变数据类型（数值）在赋值以后，其中⼀个值的改变不影响另外⼀个变量，因为两者指向空 间地址不同。
二.Python中的可变、非可变类型
Python中的数据类型：数值（int整型，float浮点型），字符型（str），bool型（True，False），元组（），列表[ ] ，字典{ } ，集合{ }
在Python中将其分为两类：可变类型，不可变类型。
**可变类型（内存地址一旦固定，其值是可以发生改变）：**列表，字典，集合（数据序列中除了元组其他都能改变）
**不可变类型（内存地址一旦固定，其值就不能发生改变）：**数值，字符型，bool类型，元组
现在我们了解了可变类型与不可变类型，但是我们如何区分可变类型与不可变类型呢？
可变类型就是在内存中，其内存地址一旦固定，其变量的值是可以发生改变的
python
a = [1, 2, 3]
print(id(a))
# 向内存中追加新数据（对数据进⾏改变只能通过数据类型.⽅法()实现）
a.append(4)
print(id(a))输出的地址为：
非可变类型就是在内存中，内存地址一旦固定，其变量的值就没办法发生任何改变了
python
a = 10
print(id(a))
a = 100
print(id(a))
三.可变类型与非可变类型在函数中的应用
可变类型：
python
# 定义⼀个函数
def func(names):
names.append('赵六')
# 定义⼀个全局变量
names = ['张三', '李四', '王五']
# 调⽤函数
func(names)
print(names)
综上所述：可变类型在函数中，如果在全局或局部中对可变类型进⾏增删改操作，其外部和内部都会受到影响。
不可变类型：
python
def func(num):
num += 1
print(num)
# 定义⼀个全局变量
a = 10
# 调⽤函数
func(a)
# 在全局作⽤域中打印a
print(a)
综上所述：不可变类型在函数中，局部或全局的改变对外部和内部都没有任何影响。
二. lambda表达式
在Python中，函数是⼀个被命名的、独⽴的完成特定功能的⼀段代码，并可能给调⽤它的程序⼀个返回值。
所以在Python中，函数⼤多数是有名函数 => 普通函数。但是有些情况下，我们为了简化程序代码，也可以定义匿名函数 => lambda表达式
注意事项！
lambda 表达式中的表达式只能是单个表达式，不能包含多条语句或复杂的逻辑。如果需要实现复杂的功能，还是应该使用普通的函数定义。
lambda 表达式通常用于定义简单的、一次性使用的函数。对于复杂的、需要重复使用的函数，使用普通函数定义会使代码更易读和维护。
lambda表达式应用场景： 如果⼀个函数有⼀个返回值，并且只有⼀句代码，可以使⽤ lambda简化
lambda表达式基本语法：
python
变量 = lambda 函数参数:表达式（函数代码 + return返回值）
# 调⽤变量
变量()具体用法：
python
funs = lambda : 100
print(funs) #返回funs的地址
print(funs()) #返回funs的数据
# 输出结果：
# <function <lambda> at 0x000002E0C57404A0>
# 100编写lambda的表达式：
python
def fn1():
return 100
# 调⽤fn1函数
print(fn1) # 返回fn1函数在内存中的地址
print(fn1()) # 代表找到fn1函数的地址并⽴即执⾏
使用lambda表达式进行简化：
python
fn2 = lambda : 100
print(fn2) # 返回fn2在内存中的地址
print(fn2())lambda表达式相关应用
一.带参数的lanbda表达式
python
# 带参数的lambda
dii = lambda x,y : x*y
print(dii)
print(dii(2,4))二.带默认参数的lanbda表达式
python
# lambda表达式的默认参数
fn = lambda a, b, c=100 : a + b + c
print(fn(10, 20))
python
# 带判断的lambda
ft = lambda a,b,c=100:a+b+c if a%2==0 and b%2==0 and c%2==0 else print('错误')
print(fn(10,20))三.不定长参数：可变参数*arg
python
fn1 = lambda *args : args
print(fn1(10, 20, 30))四.不定长参数：可变参数*kwargs
python
# 关键字参数lambda
ke = lambda **kel:print(kel)
res=ke(name='John', age=45)
print(res)五.带if判断（三目运算符）的lambda表达式
python
fn = lambda a, b : a if a > b else b
print(fn(10, 20))列表数据+字典数据排序（重点）
知识点：列表.sort(key=排序的key索引, reverse=True)
python
# 利用sort和lambda对数据排列
people = [{'name': 'John', 'age': 45},
{'name': 'Diana', 'age': 32},
{'name': 'Zoe', 'age': 25}
]
# 升序
people.sort(key=lambda x:x['name'])
print(people)
people.sort(key=lambda y:y['age'])
print(people)三. Python内置模块
Python 内置模块是 Python 标准库的一部分，它们随 Python 解释器一起安装，无需额外安装即可直接使用，为开发者提供了丰富的功能和工具
模块的分类： 在Python中模块通常可以分为两⼤类，内置模块(目前使⽤的) 和 自定义模块
模块的导入方式：
一：import 模块名
二：import 模块名 as 别名
三：from 模块名 import *
四：from 模块名 import 功能名
一：使用import 模块名
基本语法：
python
import 模块名称
或
import 模块名称1, 模块名称2, ...然后可以使用模块中封装好的方向：
python
模块名称.⽅法() 使用案例：
python
import math #调用mata
print(math.sqrt(8)) #使用mata模块中的sqrt方法二：import 模块名 as 别名
在有些情况下，如导入的模块名称过长，建议使用as关键字对其重命名操作，以后在调用这个模块时，我们就可以使用别名进行操作。
案例：
python
import random as rnd #调用random将它重命名变成rnd
print(rnd.random())三：from 模块名 import *
import代表导入某个或多个模块中的所有功能，但是有些情况下，我们只希望使用这个模块下的某 些方法，而不需要全部导入。这个时候就建议采用from 模块名 import 功能名
python
from math import sqrt
print(sqrt(18))四：from 模块名 import 功能名
这个导入方式代表导入这个模块的所有功能（等价于import 模块名）
python
from math import *
print(sqrt(57))sleep（）和 time（）
time.sleep()是 Python 中time模块的一个重要函数，用于控制程序的执行流程，实现线程的暂停或休眠。以下是对它的详细介绍：
sleep（）作用：
控制执行节奏 ：在一些需要按照特定时间间隔执行任务的场景中，time.sleep()可以让程序暂停一段时间，然后再继续执行，从而实现定时执行的效果。例如，在一个循环中每隔一定时间执行一次某个操作。
模拟等待场景：在模拟一些需要等待的情况时非常有用，比如模拟网络请求的等待时间、模拟设备的响应时间等。
sleep（）语法及参数
语法 ：time.sleep(seconds)
参数说明 ：seconds是一个必需参数，用于指定线程休眠的时间，单位为秒。它可以是整数或浮点数。如果seconds为 0，线程将暂时放弃执行，允许其他线程执行，但具体的休眠时间可能会因操作系统和其他因素而有所不同。
案例：使用sleep方式做出一个倒计时！
python
import time
def countdown(seconds):
while seconds > 0:
print(f"倒计时: {seconds} 秒")
time.sleep(1)
seconds -= 1
print("倒计时结束！")
# 设置倒计时的总秒数
countdown_time = 10
countdown(countdown_time)time.time（）的作用：
time.time()是 Python 中time模块的一个重要函数，用于获取当前时间的时间戳。以下是对它的详细介绍：
功能：
获取时间戳：time.time()的主要功能是返回从 1970 年 1 月 1 日 00:00:00 UTC（协调世界时）到当前时刻所经过的秒数，这个数值就是时间戳。它是一个浮点数，包含了整数部分和小数部分，整数部分表示从 1970 年到现在的整秒数，小数部分表示不足一秒的剩余时间。
精确计时：由于时间戳能够精确到秒甚至更高的精度（取决于系统时钟的精度），因此可以用于精确测量代码的执行时间。通过在代码片段的开始和结束处分别调用time.time()，计算两个时间戳的差值，就能得到代码执行所花费的时间，这对于性能分析和优化非常有帮助。
语法及返回值：
语法 ：time.time()，该函数没有参数，直接调用即可返回当前时间的时间戳。
返回值 ：返回一个浮点数，表示从 1970 年 1 月 1 日 00:00:00 UTC 到调用time.time()函数时的时间间隔，单位是秒。
案例：统计一个函数花费的时间
python
import time
kaishi = time.time() # 开始时间
num=0
for i in range(100000):
num = num + i
# print(num)
jieshu = time.time() #结束时间
print('结束时间-开始时间为:',jieshu - kaishi)四. Python中的自定义模块
在python中有系统给的内置系统模块，当然也有自定义模块
模块的本质：在Python中，模块的本质就是⼀个Python的独⽴⽂件（后缀名.py），⾥⾯可以包含 全局变量、函数以及类。
注：在Python中，每个Python文件都可以作为⼀个模块，模块的名字就是文件的名字 。也就是说自定义模块名必须要符合标识符命名规则。
特别注意：我们在自定义模块时，模块名称不能为中文，另外我们自定义的模块名称不能和系统中自带的模块名称相冲突，否则系统模块的功能将无法使用。比如不能定义一个叫做os.py模块
自定义一个模块： 在Python项⽬中创建⼀个自定义文件，在文件中创建函数，在原文件中导入自定义模块。
python
def sum_num(num1, num2):
return num1 + num2
python
import 模块名称
或
from 模块名称 import 功能名
python
# 调⽤my_module1模块中⾃定义的sum_num⽅法
print(my_module1.sum_num(10, 20))自定义模块中的功能测试：
在我们编写完自定义模块以后，最好在模块中对代码进行提前测试，以防止有任何异常。
测试需求：
① 要求我们可以直接在模块文件中对代码进行直接测试
② 代码测试完毕后，当导入到其他文件时，测试代码要自动失效
引入一个魔术变量： name ，其保存的内容就是⼀个 字符串类型的数据。
随着运行页面的不同，其返回结果也是不同的：
① 如果 name 是在当前页面运行时，其返回结果为 main
② 如果 name 在第三方页面导入运行时，其返回结果为模块名称（文件名称）
基于以上特性，我们可以把 name 编写在自定义模块中，其语法如下：
name 魔术方法除了可以在自定义模块中测试使⽤，还可以用于编写程序的人口：
Python程序⼀般都是从入口开始执行的：
python
# 定义⼀个main⽅法（⼊⼝⽂件）
def main():
# 执⾏我们要执⾏的功能
# ① 打印选择菜单
# ② 添加学员信息
# ③ 删除学员信息
# ...
# 调⽤执⾏⼊⼝
if __name__ == '__main__':
main()模块的命名：
注意！模块的命名：在实际项目开发中，一定要特别注意：我们自定义的模块名称一定不能和系统内置的模块名称相同，否则会导致代码无法正常执行。
五. Python中的Package包
包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为 _init _.py 文件，那么这个文件夹就称之为包。（工具包）
这样就是一个包 
里面存放着一些模块
包的制作：
所有的包文件中都会默认自带一个 _init _.py 文件
在包的文件中创建多个模块：
python
print('my_module1')
def func1():
print('mypackage包中的my_module1模块的func1⽅法')
python
print('my_module2')
def func2():
print('mypackage包中的my_module2模块的func2⽅法')可以在其他的项目中使用模块：
使用import调用包，模块：
python
import mokuai #import 包名.模块名
print(mokuai.mum(1,2))
# 调⽤模块中的⽅法
包名.模块名.⽅法名()使用form调用包，模块：
python
from bao_mokuai12_24.mokuai import mum
print(mum(3,5))注意：必须在 init.py 文件中添加 all = [ ] ，控制允许导入的模块列表。这种方式， 只能针对from 包名 import *有效！