Python学习笔记一（标识符、关键字、变量、数据类型、关系运算）

Python学习笔记一

• • 标识符
  • 关键字
  • 变量
  • 数据类型
• 列表
• 元组
• 字典
• 集合
• • 关系运算

标识符

命名规则：

1、只能由大小写字母、下划线、数字组成，并且第一个字符不能是数字

2、不能与Python本身使用的语言相同，比如保留字

关键字

类别	关键字
布尔值与空值	True, False, None
流程控制	if, elif, else（条件判断）、for, while, break, continue（循环控制）、pass（占位符）
函数	def, return, lambda（匿名函数）、class（定义器）, yield（生成器)
异常处理	try, except, finally, raise, assert
变量作用域	global（全局变量）, nonlocal（外部变量）
逻辑运算	and, or, not， in, is
资源管理	with, del（删除对象）
异步编程	async, await
模式匹配	match, case

变量

• 无需声明类型：直接写x = 10，Python会默认它是整数
• 类型可变：同一个变量可以先存整数，再存字符串
• 首次赋值就可以创建变量
• 可以在一行内给多个变量赋值

x = 10 # x是整数
print(x)

x = "Hello" # x变成了字符串
print(x)

a,b,c = 1,2,3

数据类型

1. 数字类型：整数（int）、浮点数（float）、布尔值（bool）
2. 文本类型：字符串（str）
3. 序列类型：列表（list）、元组（tuple，创建后不可变）
4. 映射类型：字典（dict）
5. 集合类型：集合（set）

列表

• 元素按插入顺序排列，可以通过索引（位置编号）来访问。
• 创建后，你可以随时修改它（增、删、改），不需要创建新对象。
• 同一个列表中可以存放不同类型的数据（如整数、字符串、甚至其他列表）。
• 允许重复：列表中可以包含多个相同的元素。

# 1、直接创建
numbers = [1,2,3,4,5]
fruits = ["apple","banana","cherry"]
mixed = [1,"Hello",1.23,Ture] # 混合不同类型

# 2、创建空列表
a = []
a = list()

# 3、使用list()转换
a = list("Python") # 结果为['P','y','t','h',o','n']

# 列表正向访问（从0开始），负向访问（从-1开始，表示倒数）
fruits = ["apple","banana","cherry"]
print(fruits[0]) # 输出apple
print(fruits[-1]) # 输出cherry

# 切片访问 [开始:结束] 左闭右开
print(fruits[1:3]) # 输出为['banana'，'cherry']
print(fruits[:2]) # 输出为['apple'，'banana']
print(fruits[::-1]) # 输出为['cherry','banana','apple'] 反转列表

• 添加元素：
  append(x)：在列表末尾添加x
  insert(x)：在I后插入x
  extend(L)：将另一个列表L的所有元素追加进来

fruits.append(x)
fruits.sort(1,"lemon")
fruits.extend(["grape","melon"])

• 删除元素
  remove(x) ：删除第一个匹配x的值
  pop(i)：删除并返回i处的元素（默认删最后一个）
  del：语句
  clear()：清空列表

del fruits[0] # 删除列表中第一个元素
fruits.clear()

• 函数

sort() # 排序（默认升序）
reverse() # 反转
len(list) # 获取长度
count(x) # 统计x出现的次数

元组

元组是一种不可变的有序序列，可以包含任意类型的元素（整数、字符串、列表、甚至其他元组）

• 有序：元素有固定的先后顺序，可以通过索引访问
• 不可变：创建后不能增、删、改其元素
• 允许重复：和列表一样，元组中可以包含重复的元素
• count(x): 统计元素 x 出现的次数
  index(x): 查找元素 x 第一次出现的索引位置

# 用小括号，小括号也可以省略，用逗号分隔
a = (1,2,3)
a = 1,2,3

# 单元素元组必须加逗号
a = (5,)
a = (5) # 这是整数，不是元组

empty = () #空元组

# 用tuple()转换其他类型
t = tuple([1,2,3]) # 输出(1,2,3)
t = tuple("abc") # 输出('a','b','c')

# 访问和列表一样
t = ("apple", "banana", "cherry", "date")

print(t[0])    # 输出: apple
print(t[-1])   # 输出: date
print(t[1:3])  # 输出: ('banana', 'cherry')

其他操作如排序、反转等，通常使用内置函数 sorted() 或切片来实现，这会返回一个新的列表或元组，而不是修改原数据

因为元组是不可变的（可哈希），它可以作为字典的键（Key），而列表不行。

# 合法：使用元组作为键
locations = {
    (35.68, 139.69): "Tokyo",
    (31.23, 121.47): "Shanghai"
}

字典

字典存储的是键值对（Key-Value）键必须唯一且不可变：

唯一：同一个字典里不能有两个相同的键。如果重复定义，后面的会覆盖前面的。

不可变：键只能是字符串、数字、元组等不可变类型，不能是列表。

可变性：字典创建后，可以随时添加、修改或删除键值对。

# 1、直接创建（最常用）
person = {
    "name": "Alice",
    "age": 25,
    "city": "Beijing"
}

# 2、创建空字典
empty_dict = {}

# 3、使用 dict() 函数
# 注意：这种写法键会自动变成字符串
student = dict(name="Bob", age=20)

# 4. 使用 fromkeys() 创建默认值字典
# 创建一个键为 a, b, c，初始值都为 0 的字典
scores = dict.fromkeys(['a', 'b', 'c'], 0)

• 访问

person = {"name": "Alice", "age": 25}

# 1、直接通过键访问
# 如果键不存在，会报错 KeyError
print(person["name"]) 

# 2、使用 get() 方法
# 如果键不存在，返回 None，也可以指定默认值
print(person.get("age"))        # 输出: 25
print(person.get("job"))        # 输出: None
print(person.get("job", "Unemployed")) # 输出: Unemployed

• 改

person = {"name": "Alice"}

person["name"] = "Alicia" # 修改已存在的键
person["age"] = 26 # 添加新的键值对
person.update({"city": "Shanghai", "age": 27}) # 批量更新，使用 update()
# age 被更新为 27，city 被添加

• 删

person = {"name": "Alice", "age": 25, "city": "Beijing"}

age = person.pop("age") # 删除并返回值
del person["city"] # del语句删除指定键
person.popitem() # popitem()删除最后一个键值对
person.clear() # clear()清空整个字典

• 遍历

person = {"name": "Alice", "age": 25, "city": "Beijing"}

for key in person: # 默认遍历键
    print(key)
    
for value in person.values(): # 遍历值
    print(value)

for key, value in person.items(): # 同时遍历键和值
    print(f"{key}: {value}")

集合

• 去重：集合中不允许存在重复的元素
• 无序性：集合中的元素没有固定的顺序，不能通过索引访问，每次打印集合时，元素的显示顺序可能不同
• 可变性：集合本身是可变的（可以添加或删除元素），但集合里的元素必须是不可变类型（如数字、字符串、元组），不能包含列表或字典。

# 1、使用花括号创建（注意：会自动去重）
fruits = {"apple", "banana", "apple", "cherry"}
print(fruits) 
# 输出结果可能是 {'banana', 'cherry', 'apple'}，重复的 apple 消失了

# 2、使用 set() 函数创建（常用于将列表转为集合）
nums = set([1, 2, 2, 3, 4])
print(nums) # 输出: {1, 2, 3, 4}

# 特别注意：创建空集合
# 错误示范：empty = {}  <-- 这会创建一个空字典！
empty_set = set() 

• 增
  add(x)：添加单个元素
  update(iterable)：批量添加元素（可以是列表、元组或其他集合

s = {1, 2, 3}
s.add(4)          # {1, 2, 3, 4}
s.update([5, 6])  # {1, 2, 3, 4, 5, 6}

• 删

s = {1,2,3,4,5}
remove(1) # 删除元素1，如果1不存在报错
discard(1) # 删除元素1，如果1不存在不报错
s.pop() # 删除某一个元素
s.clear() # 清空集合

在列表中查找元素（x in list）的速度比较慢（尤其是数据量大时），而在集合中查找是瞬间完成的（时间复杂度为 O(1)）。如果你需要进行大量的"是否存在"判断，建议先将列表转换为集合
可以直接用 & (交集)、| (并集) 处理数据关系

关系运算

关系运算用于对常量与表达式的比较，结果返回一个布尔值

# Pythony允许像数学一样连写
x = 5 # 判断x是否在0到10之间
print(0 < x < 10)  # 输出: True

# 相当于 (0 < x) and (x < 10)