视频链接：
https://space.bilibili.com/70431433?spm_id_from=333.1007.0.0
代码链接：
https://github.com/zyf-ngu/Qmatter
变量
变量就是给程序中的数据，对象等取一个简单易懂的名字，一般用英文名和下划线组成，尽可能清晰表示变量的意义。
命名注意点：
- 变量名只能包含字母、数字和下划线。
- 变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。
- 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。
- 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print，class等。
数据结构
程序的本质就是使用代码对数据进行操作，代码是对数据操作的逻辑，数据在高级代码语言里需要有一定的组织结构，Python中最基础常用的几种就是：
字符串str：
用引号（单双引号均可）括起来的部分，可以描述自然语言；str(参数)可以将参数如数字等转化为字符串。
列表list：
用中括号括起来的部分，中间每一项用逗号（,）隔开，每一项的数据类型都可以不同，按特定顺序排列；
元组tuple：
用小括号括起来的部分，中间每一项也是用逗号（,）隔开，
字典dict：
用大括号括起来的部分，每一项包括2个子项，键key和值value，键一般是字符串，键值对用冒号（：）分开，每一项也是用逗号（，）分开。
对数据结构进行的最基本的操作就是在创建之后的增删查改（不可变对象如字符串和元组的增删改都是返回新的对象），增就是添加，删就是删除，查就是获取对象，包括单个和多个元素的获取（切片），改就是修改，下面具体地介绍一下各个数据结构的基本操作。
对应数据结构的基本操作方法，直接使用名称.方法名（参数）即可。
字符串
注意字符串是不可变对象，增删改后返回的是新的字符串；即使没有实际改变，也会创建新对象。
创建：使用引号括起来的部分为字符串，可以为中文，英文，数字等符号。
str1=' string'
join（）方法：在实际项目中创建字符串常用的一个方法是join（），用于将序列（如列表、元组、字符串、字典、集合等）中的元素以指定的字符串连接起来生成一个新的字符串。
语法：str.join(sequence)，序列中的元素必须是字符串类型。如果序列中包含非字符串元素，则会抛出TypeError。
与使用 + 操作符进行字符串拼接相比，join() 方法在性能上具有显著优势，特别是在处理大量字符串时。
由于字符串是不可变对象，每次使用 + 操作符都会创建一个新的字符串对象。而 join() 方法只需要在最后创建一次新字符串，大大减少了内存分配和复制操作。
import time
使用 + 操作符拼接（效率低）
start_time = time.time()
result = ""
for i in range(10000):
result += str(i)
end_time = time.time()
print(f"使用 + 操作符耗时: {end_time - start_time:.4f} 秒")
使用 join() 方法拼接（效率高）
start_time = time.time()
parts = []for i in range(10000):
parts.append(str(i))
result = "".join(parts)
end_time = time.time()
print(f"使用 join() 方法耗时: {end_time - start_time:.4f} 秒")
增（添加）：直接使用加号（+）来合并添加字符串，
str2=str1+' abc '
删（替换）：使用 replace() 方法删除特定字符或子串
text = "Hello, World!"# 删除逗号
new_text = text.replace(",", "")
print(new_text) # 输出: Hello World!
rstrip()剔除字符串末尾的空格，lstrip()剔除字符串开头的空格，strip()同时剔除字符串两端的空格。也可以指定删除特定字符。
str5=str4.lstrip()
str6=str4.rstrip()
str7=str4.strip()
查（获取单个元素）：使用字符串名加下标str[i]即可。
str_single=str1[5]
查（切片） ：同时获取多个元素，名称加区间索引值str[i:j]，实际获取的数据区间是左闭右开，要输出列表中的前三个元素，需要指定下标索引0~3。
str_split=str1[0:5]
查（遍历）：
数据结构都是可迭代对象（后面详细介绍），可以使用for循环进行遍历取值for str in str1:
print(str)
改：字符串不能直接使用下标更改特定值，只能使用切片拼接的方法。
text = "hello"
尝试修改字符串中的字符会引发错误
try:
text[0] = "H" # 这会引发 TypeError
except TypeError as e:
print(f"错误: {e}")
正确的方法是创建新字符串#
方法1: 使用切片和连接
new_text = "H" + text[1:]
print(f"方法1结果: {new_text}")
方法2: 转换为列表再转回字符串
text_list = list(text)
text_list[0] = "H"
new_text = "".join(text_list)
print(f"方法2结果: {new_text}")
upper()将字符串改为全部大写;lower()全部小写，title()将每个单词的首字母都改为大写。
str3=str2.upper()
str4=str3.lower()
求长度：直接使用len()函数
str_size=len(str1)
列表
列表中的元素不需要是同一种数据类型 ，可以创建包含数字，字符串，列表，元组等的列表；也可以将任何类实例化的对象加入列表中，其中的元素之间可以没有任何关系。
列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的
创建：一般的创建方式有2种，一种是创建一个空列表，在实际操作中不断添加；另一种是直接把已知的数据内容创建出来，如下：
list1=[]
list2=[1,'a',list1]
列表解析创建
在实际项目中另一种经常使用的列表创建方法就是解析创建，一般方法生成列表squares的方式包含三行代码，
squares = []
for value in range(1,11):
squares.append(value**2)
而列表解析只需编写一行代码就能生成这样的列表。列表解析将for循环和创建新元素的代码合并成一行，并自动附加新元素。
squares = [value**2 for value in range(1,11)]
要使用这种语法，首先指定一个描述性的列表名，如squares；后面使用中括号括起来，里面先定义一个表达式（如value**2用于计算平方值），用于生成要存储到列表中的值。接下来，编写一个for循环（for value in range(1,11)），用于给表达式提供变量。请注意，这里的for语句末尾没有冒号。
转化列表：除了直接创建，实际操作中还经常进行数据类型间的转化，方法很简单，即用list（var）
str1='abc'
list3=list(str1)
转换数值列表
range(a,b)来生成[a,b)区间的数字（左闭右开）；使用函数list(range(a,b))将range(a,b)的结果直接转换为列表。
使用函数range()时，还可指定步长。list(range(2,11,2))，在这个示例中，函数range()从2开始数，然后不断地加2，直到达到或超过终值（11）。
对数字列表执行简单的统计计算
有几个专门用于处理数字列表的Python函数。例如，数字列表的最大值max(lists)、 最小值min(lists)和总和sum(lists)：
添加：在列表末尾 ：append()将元素动态地附加到列表末尾。即先创建一个空列表，再使用一系列的append()语句添加元素。
list1.append(1)
在列表中插入元素 ： insert()可在列表的任何位置添加新元素。只需要指定新元素的索引和值。索引后面的列表值都将右移一个单位。
获取单个元素:列表名称+[下标]
temp=list1[1]
列表切片：
同时获取多个元素，变量名后加区间索引值list[i:j]，实际获取的数据区间是左闭右开，要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0、1和2的元素；
list_split=list2[0:2]
一般这种区间的都是左闭右开，如range(i,j)
（1）省略第一个索引i，Python将自动从列表开头开始;省略终止索引j，切片终止于列表末尾;
（2）负数索引返回离列表末尾相应距离的元素，例如，如果要输出列表的最后三个元素，可使用切片lists[-3:]；
（3）要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:]）。 这让Python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表，而且这两个列表是独立的。
遍历列表：
数据结构都是可迭代对象（后面详细介绍），可以使用for循环进行遍历取值，
for list in lists
如果要遍历部分元素，可在for循环中使用切片。使用单数和复数式名称，可帮助判断代码段处理的是单个元素还是整个数据结构。
修改列表元素：指定列表名和要修改的元素的索引，再指定该元素的新值。
list2[0]=10
删除列表元素
del语句：可删除任何位置的列表元素，条件是知道其索引。del list[0]
pop()可删除列表末尾的元素，并可以用变量接收以接着使用，
list0=list2.pop()
术语弹出（pop）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。实际上，你可以使用pop()来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可。
remove()：根据值删除元素，若不知道要从列表中删除的值所处的位置。只知道要删除的元素的值，可使用方法remove()，list.remove(value1)
求列表长度：
直接使用len()函数，len(list)
列表排序
使用方法 sort()对列表进行永久性排序 ，使用完之后列表中元素的顺序永久改变。
使用函数 list.sorted()对列表进行临时排序，可以保留列表元素原来的排列顺序，同时以特定的顺序呈现它们。
逆序：方法 list.reverse()永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse()即可。
元组
Python将不能修改的值称为不可变的，而不可改变单元素的列表被称为元组，使用小括号来标识。元组内的元素也可以是任何数据类型。因此，普通创建，切片，遍历方法都是相同的，但是添加，删除，更改等变动元组内部元素的情况是不可行的。元组在深度学习中经常用于定义数据张量的形状。
创建元组：直接在小括号内写上元素或空。
tuple1=()
tuple2 = (False,3+4j,"aaa",456)
获取元素:元组名称+[下标]
temp=tuple1[1]
元组切片：
同时获取多个元素，名称后加区间索引值tuplet[i:j]，实际获取的数据区间是左闭右开，要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0、1和2的元素；
tuple_split=tuple1[:2]
重定义元组
虽然不能修改元组的元素，但可以给存储元组的变量赋值，即对同一个变量重新定义整个元组；如下，同一个变量名称重新赋值。
tuple3=(1,2,3)
tuple3=(4,5,6)
字典
字典是大括号括起来的一系列键值对，键值之间用冒号隔开，键值对之间用逗号隔开。
创建：直接使用大括号，键可以为字符串，数值，元组，但不可以为列表和字典（非哈希类型），值可以为任意数据类型。
dict1={'abc':'value1',1:[1,2],(1,2):{ }}
添加:只需要dict[键key]=value。
dict1['key']='value2'
删除：Python 中的字典（dict）提供了两种删除元素的方法：popitem() 和 pop()，两种方法都会从字典中移除指定的元素，并返回被删除的值。
del1=dict1.pop(1,None)
print('del1:',del1)
del2=dict1.popitem()
print(('del2:',del2))
# 键不存在时，报KeyError: 2
del3=dict1.pop(2)
二者的主要区别为：
|-------------------|---------------------------------------|
| popitem() | pop( key,default ) |
| 无需参数 | 必须指定键（key）参数 |
| 删除最后插入的元素（有序） | 删除指定键对应的元素 |
| 若字典为空，抛出 KeyError | 若键不存在：- 无默认值时抛出 KeyError - 有默认值时返回默认值 |
获取：名称后加key值dict[key]，注意字典的key是什么数据类型，中括号内也要写什么数据类型（如字符串，元组等）
temp=dict1[(1,2)]
遍历：
数据结构都是可迭代对象（后面详细介绍），可以使用for循环进行遍历取值，for key,value in dict.itms()：注意这时字典是同时取得键值对的。
单独遍历键
for key in dic.keys() 可省略keys（）
单独遍历值
for value in dic.values()
更新update：
update()方法用于更新字典，使用方式为字典名.update(dict)，传入参数即为另外一个字典或键值对的可迭代对象。将它们的元素添加到当前字典中。 如果键存在，则更新其值；如果键不存在，则添加键值对。
基本使用，参数为另一个字典
dict1 = {'name': 'Alice', 'age': 25}
dict2 = {'age': 26, 'city': 'New York'}
dict1.update(dict2)
print("更新后的字典:", dict1) # {'name': 'Alice', 'age': 26, 'city': 'New York'} #键存在，更新值；不存在，添加键值对；
使用关键字参数
dict3 = {'a': 1, 'b': 2}
dict3.update(c=3, d=4)
print("使用关键字参数更新:", dict3) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
使用可迭代对象
dict4 = {'x': 1}
dict4.update([('y', 2), ('z', 3)])
print("使用可迭代对象更新:", dict4) # {'x': 1, 'y': 2, 'z': 3}
共性操作
1.元素获取：
列表，字符串，元组都是有序结构，因此可以直接使用名称后加下标索引str[i]&&list[i]&&tuple[i]，str/list/tuple为数据结构变量名，i为下标；第一个元素的索引为0，而不是1。
访问最后一个元素可通过将索引指定为-1，倒数第2个索引为-2，以此类推。
字典则是使用名称后加key值dict[key]。
实战小技巧：
下标索引和key值都是用中括号。这里一个值得注意的点：像这种获取元素，赋值等数据结构的操作一般使用中括号[]，而对于函数名后的传参操作等一般使用小括号()。
if语句
if语句是一个条件测试，满足则执行if下的语句，不满足则跳过，一般用一个等式来表示。若要检查多个条件，仅需把多个条件用and 连接，则所有条件都需要满足才为true。用or则是只需要一个条件满足即可。
检查特定值是否在列表里，可以用（not）in。
if else 结构
if elif else结构
while循环
while循环 直到不满足条件时才退出。break直接退出循环。continue退出本次循环，回到循环开头。