目录
变量与引用
数据类型
赋值、深浅拷贝
控制流结构
逻辑操作符
is 与 ==
dir()
关键字（Python 3.11 ）
https://www.cnblogs.com/qianfanwaer/p/14783204.html
变量与引用
变量是原来存储数据的一个标识符，可被看作是内存的一个位置，用于保存程序运行期间可能会改变的数据值；
变量：存放对象的引用（即对象的地址），因此所需存储空间大小一致，与类型无关（变量无类型），可指向任何对象；
对象：分配的内存及存储的值，对象有地址（id），类型（type）、值（value）；python中一切皆对象，一个列表，值，函数，类等都可以成为对象；
引用：建立了变量和对象之间的关系，即变量指向对应对象；同个对象可以被多个变量引用，对象引用计数及回收机制；
如代码message=‘hello world’，python解释器完成了三件事：
- 创建一个对象并开辟一块空间，对象id为0x020，type为str，存储的value为hello world；
- 创建一个变量message，并保存了对象的地址；
- 将变量和对象，通过指针链接起来；
可变对象和不可变对象
- 可变对象，list、dict、set等，对变量的编辑是对本身进行编辑，不产生新对象；
- 不可变对象，int、float、str、tuple，对变量的编辑会创建新对象；
数据类型
动态类型，变量类型在运行时自动确定，不是在编译时确定，无需预先声明变量的类型；灵活、易用、快速开发，在运行时类型检查，难以调试且会损失性能；
动态类型特性：
- 无需类型声明；
- 类型自动推断；
- 类型可变；
- 类型在运行时检查；
数据类型：
- int，整形，在python中无固定最大值限制（除非内存耗尽）；
- 如10；
- float，浮点数，使用IEEE 754标准的双精度格式表示；
- 如3.14；
- bool，布尔值，用于表示逻辑值
True和False；- str，字符串，用于表示文本，可以使用单引号或双引号；
- 如'hello'；
- list，列表，有序项目集合（有序是插入顺序），可包含不同类型元素，可改变（如添加、删除、更改）；
- 如[1, 'two', 3.0]；
- tuple，元组，类似列表，但不可改变；
- 如(1, 'two', 3.0)；
- dict，字典，存储键值对的集合，键不可改变，值可是任意类型；
- 如{'name': 'Alice', 'age': 25}；
- set，集合，存储唯一元素的集合，是无序的，不支持索引；
- 如{1, 2, 3}；
- None，特殊类型对象，表示没有任何值，常用于表示函数没有返回值或变量尚未被赋值；
- complex，复杂数，表示复数，如3+4j；
Python还提供了内置函数来转换数据类型，如：
int(): 将其他类型转换为整数；float(): 将其他类型转换为浮点数；str(): 将其他类型转换为字符串；list(): 将其他类型转换为列表；tuple(): 将其他类型转换为元组；dict(): 将其他类型转换为字典；set(): 将其他类型转换为集合；
##str字符串
s = "hello 'world' !" #创建字符串
s[0] #访问字符
s[7:12] #字符串切片
#字符串方法
s.upper() #输出: HELLO, WORLD!
s.lower() #输出: hello, world!
s.split(", ") #输出: ['Hello', 'world!']
#字符串拼接
message = "Hello" + ", " + "Alice" + "!" #输出: Hello, Alice!
#替换字符串
s.replace("world", "Python") #输出: Hello, Python!
#检查子字符串
"world" in s #输出: True
s.startswith("Hello") #输出: True
s.endswith("!") #输出: True
#字符串格式化
name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.") #输出: My name is Alice and I am 25 years old.##list列表
mylist = [1,3.14,'hello'] #创建列表
mylist[0] #访问列表
mylist[0] = 10 #修改列表
#列表方法
mylist.append('world') #追加列表
mylist.insert(1,2) #插入列表
mylist.pop() #尾删列表
mylist.remove(2) #删除列表
mylist.clear() #清空列表
mylist.reverse() #反转列表
repeatlist = mylist*2 #重复列表
otherlist = mylist.copy() #复制列表，id不同
otherlist.extend(mylist) #扩展列表
mylist + otherlist #列表相加
len(mylist) #计算长度
del mylist[-1] #删除列表元素
mylist.count(1) #统计指定元素的个数
mylist.sort() #排序列表
mylist.index(3.14,2) #查找指定元素在列表中的位置
##tuple元组
t = (1,) #创建单个元素的元组
t = (1,3.14,'tu') #创建多个元素的元组
t = tuple([1,3.14,'tu']) #使用构造器创建元组
my_tuple[0] #访问元素
my_tuple[1:3] #切片
#合并元组
combined_tuple = t + (6, 7, 8) #输出: (1,3.14,'tu', 6, 7, 8)
#重复元组
repeated_tuple = t * 2 #输出: (1, 3.14, 'tu', 1, 3.14, 'tu')
len(my_tuple) #计算长度
my_tuple.count(3) #计算元素次数
my_tuple.index(4) #查找元素索引##dict字典
my_dict = {'key1': 'value1', 'key2': 'value2'} #创建字典
my_dict = dict(key1='value1', key2='value2') #使用构造器创建字典
my_dict = dict([('key1', 'value1'), ('key2', 'value2')]) #从列表创建字典
my_dict['name'] #访问值
my_dict['job'] = 'Engineer' #添加元素
my_dict['age'] = 26 #修改值
del my_dict['city'] #删除元素
#获取字典的键、值和项
for key, value in my_dict.items():
print(f"{key}: {value}")
#使用 get() 方法，获取值（可设置默认值）
my_dict.get('city', 'Unknown') #输出: Unknown
#更新字典
another_dict = {'age': 27, 'country': 'USA'}
my_dict.update(another_dict)
print(my_dict) # 输出: {'name': 'Alice', 'age': 27, 'job': 'Engineer', 'country': 'USA'}
'name' in my_dict #检查键是否存在
copied_dict = my_dict.copy() #复制字典
my_dict.clear() #清空字典
##set集合
my_set = {1, 2, 3, 4, 5} #创建集合
my_set = set([1, 2, 3]) #使用构造器从列表中创建集合
my_set = set(range(5)) #使用构造器从迭代器中创建集合
empty_set = set() #创建空集合
my_set.add(6) #添加元素
my_set.remove(2) #删除元素
my_set.discard(-1) #删除元素，元素不存在不会抛异常
my_set.pop() #头删
my_set.update({0,5,6}) #更新集合
#集合运算
another_set = {4, 5, 6, 7, 8}
union_set = my_set.union(another_set) #输出: {1, 3, 4, 5, 6, 7, 8}
intersection_set = my_set.intersection(another_set) # 输出: {4, 5}
difference_set = my_set.difference(another_set) # 输出: {1, 3}
symmetric_diff_set = my_set.symmetric_difference(another_set) # 输出: {1, 3, 6, 7, 8}
3 in my_set #检查元素是否存在
my_set.issubset(copy_set) #检查一个集合是否是另一个集合的子集
my_set.issuperset(copy_set) #检查一个集合是否是另一个集合的超集
copy_set = my_set.copy() #复制集合
copy_set.clear() #清理集合赋值、深浅拷贝
变量赋值，可理解为别名，如a=b，两变量都存放同一地址；
- 不可变对象赋值，不会影响其他变量；
- 可变对象赋值，会影响其他变量；
为防止可变对象赋值影响，有了深浅拷贝；
- 浅拷贝，会创建新对象，但只拷贝最外层内部引用没有拷贝，其存储的值或引用，与原对象相同（但id不同）；
- 深拷贝，会对每一层都完全拷贝为新对象，相互间完全不影响；
控制流结构
选择结构
- if ... elif ... else ...
- match
#使用 if 语句
x = 10
if x > 0:
print("x is positive")
elif x < 0:
print("x is negative")
else:
print("x is zero")#使用 match 语句
status_code = 200
match status_code:
case 200:
print("OK")
case 404:
print("Not Found")
case _:
print("Unknown status code")循环结构
- while
- for
#使用 while 循环
count = 0
while count < 5:
print(count)
count += 1#字符串格式化
for i in range(20):
mode = 3
print('{0}%{1}={2}'.format(i, mode, i%mode))控制流关键字
break：立即退出循环。continue：跳过当前循环的剩余部分，并继续下一次循环。pass：不做任何操作，常用于占位或作为占位符。
逻辑操作符
- and 且，优先级次之；
- 如第一个操作数为假，则不会计算第二个操作数，因为无论第二个操作数的值如何，整个表达式的结果都将是假；
- or 或，优先级最低；
- 如第一个操作数为真，则不会计算第二个操作数，因为无论第二个操作数的值如何，整个表达式的结果都将是真；
- not 非，优先级最高；
is 与 ==
is：比较对象的身份，即检查两个对象是否是同一个对象；==：比较对象的值，即检查两个对象的内容是否相等；
#使用 is 进行身份比较
a = [1, 2, 3]
b = a
c = [1, 2, 3]
print(a is b) # 输出: True
print(a is c) # 输出: False
#使用 == 进行值比较
print(a == c) # 输出: True
#NoneType 的特殊用法
none_obj = None
print(none_obj is None) # 输出: Truedir()
- 有参数，则列出指定参数对象的所有属性和方法；
- 无参数，返回当前作用域内的名称列表，可以是变量、函数或类等；
关键字（Python 3.11 ）
import | 用于导入模块； |
from | 用于从模块导入特定对象； |
as | 用于导入模块时指定别名； |
global | 用于声明变量为全局作用域； |
nonlocal | 用于声明变量为外部作用域，但不是全局作用域； |
None | 用于表示没有值或空值的对象； |
False/True | 用于表示布尔值的 False/True； |
if | 用于创建条件语句； |
elif | 用于 |
else | 用于 if 和 for/while 循环中，表示没有匹配条件或循环正常结束时的代码块； |
while | 用于创建无限循环或条件循环； |
for | 用于创建循环； |
break | 用于立即退出循环； |
|
| 用于跳过当前循环的剩余部分，并继续下一次循环； |
pass | 用于表示一个占位符或空操作； |
return | 用于从函数返回值； |
and | 逻辑与操作符； |
or | 逻辑或操作符； |
|
| 逻辑非操作符； |
in | 用于检查成员资格或用于迭代； |
is | 用于比较对象的身份； |
class | 用于定义类； |
def | 用于定义函数； |
del | 用于删除对象； |
lambda | 用于定义匿名函数； |
try | 用于测试异常处理的代码块； |
except | 用于捕获异常； |
raise | 用于抛出异常； |
finally | 用于确保某些代码无论如何都会被执行，通常用于清理操作； |
assert | 用于调试目的，在运行时检查条件是否为真； |
async | 用于定义异步函数； |
await | 用于等待异步函数的结果； |
with | 用于创建上下文管理器； |
yield | 用于定义生成器函数； |
