变量名和对象：变量名（如 a）和它指向的对象（如整数 5）是分开的。变量名本身没有存储任何数据，它只是指向数据的一个标签（或者可以说是地址）

a = 5
print(id(a))

# 输出它的地址：140732632101960（每个人的地址不同）

        变量在内存底层的存储方式：第一步：在计算机内存中创建一个整型5（它占用了一块内存空间）。第二步：在栈空间声明一个变量“a” 。第三步：把数据10的内存地址赋值给变量a，形成引用关系。

a=5
b=a
print(id(a))  #140732205462440
print(id(b))  #140732205462440

        当然是一样的，因为a赋值给b，赋值的是地址，b引用的也是5的地址。

a = 5
b = a
a = 5*2

print(a)        #10    
print(id(a))    #140732205462600
print(id(b))    #140732205462440

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

输出的地址为：

a = 10
print(id(a))
a = 100
print(id(a))

三.可变类型与非可变类型在函数中的应用

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

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

变量 = lambda 函数参数:表达式（函数代码 + return返回值）
# 调⽤变量
变量()

具体用法：

funs = lambda : 100
print(funs)      #返回funs的地址
print(funs())    #返回funs的数据
# 输出结果：
# <function <lambda> at 0x000002E0C57404A0>
# 100

编写lambda的表达式：

def fn1():
 return 100
# 调⽤fn1函数
print(fn1) # 返回fn1函数在内存中的地址
print(fn1()) # 代表找到fn1函数的地址并⽴即执⾏

使用lambda表达式进行简化：

fn2 = lambda : 100
print(fn2) # 返回fn2在内存中的地址
print(fn2())

lambda表达式相关应用

        一.带参数的lanbda表达式

# 带参数的lambda
dii = lambda x,y : x*y
print(dii)
print(dii(2,4))

        二.带默认参数的lanbda表达式 

# lambda表达式的默认参数
fn = lambda a, b, c=100 : a + b + c
print(fn(10, 20))

# 带判断的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

fn1 = lambda *args : args
print(fn1(10, 20, 30))

        四.不定长参数：可变参数*kwargs

# 关键字参数lambda
ke = lambda **kel:print(kel)
res=ke(name='John', age=45)
print(res)

fn = lambda a, b : a if a > b else b
print(fn(10, 20))

        列表数据+字典数据排序（重点）

                知识点：列表.sort(key=排序的key索引, reverse=True)

# 利用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内置模块

import 模块名称
或
import 模块名称1, 模块名称2, ...

        然后可以使用模块中封装好的方向：

模块名称.⽅法() 

        使用案例：

import math           #调用mata
print(math.sqrt(8))   #使用mata模块中的sqrt方法

        二：import 模块名 as 别名

        在有些情况下，如导入的模块名称过长，建议使用as关键字对其重命名操作，以后在调用这个模块时，我们就可以使用别名进行操作。

        案例：

import random as rnd    #调用random将它重命名变成rnd
print(rnd.random())

        三：from 模块名 import *

    import代表导入某个或多个模块中的所有功能，但是有些情况下，我们只希望使用这个模块下的某 些方法，而不需要全部导入。这个时候就建议采用from 模块名 import 功能名

from math import sqrt
print(sqrt(18))

        四：from 模块名 import 功能名

from math import *
print(sqrt(57))

sleep（）和  time（）

time.sleep()是 Python 中time模块的一个重要函数，用于控制程序的执行流程，实现线程的暂停或休眠。以下是对它的详细介绍：

sleep（）作用：

        控制执行节奏：在一些需要按照特定时间间隔执行任务的场景中，time.sleep()可以让程序暂停一段时间，然后再继续执行，从而实现定时执行的效果。例如，在一个循环中每隔一定时间执行一次某个操作。

        模拟等待场景：在模拟一些需要等待的情况时非常有用，比如模拟网络请求的等待时间、模拟设备的响应时间等。

sleep（）语法及参数

        语法：time.sleep(seconds)

        参数说明：seconds是一个必需参数，用于指定线程休眠的时间，单位为秒。它可以是整数或浮点数。如果seconds为 0，线程将暂时放弃执行，允许其他线程执行，但具体的休眠时间可能会因操作系统和其他因素而有所不同。

案例：使用sleep方式做出一个倒计时！

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()函数时的时间间隔，单位是秒。

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文件都可以作为⼀个模块，模块的名字就是文件的名字 。也就是说自定义模块名必须要符合标识符命名规则。

特别注意：我们在自定义模块时，模块名称不能为中文，另外我们自定义的模块名称不能和系统中自带的模块名称相冲突，否则系统模块的功能将无法使用。比如不能定义一个叫做os.py模块

def sum_num(num1, num2):
 return num1 + num2

import 模块名称
或
from 模块名称 import 功能名

# 调⽤my_module1模块中⾃定义的sum_num⽅法
print(my_module1.sum_num(10, 20))

        自定义模块中的功能测试：

在我们编写完自定义模块以后，最好在模块中对代码进行提前测试，以防止有任何异常。
测试需求：
① 要求我们可以直接在模块文件中对代码进行直接测试
② 代码测试完毕后，当导入到其他文件时，测试代码要自动失效
引入一个魔术变量： __name__ ，其保存的内容就是⼀个 字符串类型的数据。
随着运行页面的不同，其返回结果也是不同的：
① 如果 __name__ 是在当前页面运行时，其返回结果为 __main__
② 如果 __name__ 在第三方页面导入运行时，其返回结果为模块名称（文件名称）
基于以上特性，我们可以把 __name__ 编写在自定义模块中，其语法如下：

# 定义⼀个main⽅法（⼊⼝⽂件）
def main():
 # 执⾏我们要执⾏的功能
 # ① 打印选择菜单
 # ② 添加学员信息
 # ③ 删除学员信息
 # ...
 
# 调⽤执⾏⼊⼝
if __name__ == '__main__':
 main()

        模块的命名：

注意！模块的命名：在实际项目开发中，一定要特别注意：我们自定义的模块名称一定不能和系统内置的模块名称相同，否则会导致代码无法正常执行。

包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为 __init_ _.py 文件，那么这个文件夹就称之为包。（工具包）