一.字符串String

字符串是不可变的、有序的

字符串中元素不可修改

字符串使用单引号、双引号或三重引号定义

字符串中每个值都有对应的位置值，称为索引或下标，索引从起始0开始向后逐个递增，并且从末尾从-1开始逐个向前递减

1.创建字符串

使用单引号或双引号创建字符串

字符串可以用单引号（'）或双引号（"）定义。两种方式效果相同，选择取决于是否需要字符串中包含引号字符。

str1 = 'Hello, World!'  
str2 = "Python Programming"  
 

使用三引号创建多行字符串

三引号（'''或"""）可以定义跨越多行的字符串，适合长文本或保留格式（如换行符）。

multiline_str = """This is a  
multi-line  
string."""  
 

使用 str() 构造函数

通过 str() 可将其他数据类型（如数字、列表）转换为字符串。

num_str = str(123)  
list_str = str([1, 2, 3])  
 

2.访问字符串

s = "Hello"
print(s[0])  # 输出 'H'
print(s[4])  # 输出 'o'
print(s[-1])  # 输出 'o'
print(s[-2])  # 输出 'l'

s = "Python"
print(s[1:4])    # 输出 'yth'（索引1到3）
print(s[:3])     # 输出 'Pyt'（从开头到索引2）
print(s[2:])     # 输出 'thon'（索引2到末尾）
print(s[::2])    # 输出 'Pto'（步长为2）
print(s[::-1])   # 输出 'nohtyP'（反转字符串）
 

3.字符串加法和乘法

str1 = "Hello"
str2 = "World"
result = str1 + " " + str2  # 输出 "Hello World"
 

text = "Hi"
result = text * 3  # 输出 "HiHiHi"
 

4.检查成员是否为字符串元素

通过in或not in运算符判断子字符串或字符是否存在于字符串中。

s = "apple"
print('a' in s)     # 输出 True
print('z' not in s) # 输出 True
 

5.原始字符串

原始字符串（raw string）是编程中一种特殊的字符串表示形式，其内容不会被转义字符（如 \n、\t）解析。通常以前缀 r 或 R 标记，例如 r"path\to\file"。

# 普通字符串与原始字符串对比  
normal_str = "Hello\nWorld"  # 换行符生效  
raw_str = r"Hello\nWorld"    # 输出字面量 \n  

print(normal_str)  # 输出两行  
print(raw_str)     # 输出 "Hello\nWorld"  
 

6.常用函数

Python字符串常见函数总结

函数名	描述	示例
str.lower()	将字符串转换为小写	"HELLO".lower() → "hello"
str.upper()	将字符串转换为大写	"hello".upper() → "HELLO"
str.capitalize()	将字符串首字母大写	"hello".capitalize() → "Hello"
str.title()	将每个单词的首字母大写	"hello world".title() → "Hello World"
str.strip()	移除字符串两端的空白字符	" hello ".strip() → "hello"
str.lstrip()	移除字符串左侧的空白字符	" hello ".lstrip() → "hello "
str.rstrip()	移除字符串右侧的空白字符	" hello ".rstrip() → " hello"
str.replace(old, new，max])	替换字符串中的子串，如果指定max，则替换不超过max次	"hello".replace("l", "L") → "heLLo"
str.split(sep)	根据分隔符将字符串拆分为列表，还有个rsplit就是从右边开始分割	"a,b,c".split(",") → ["a", "b", "c"]
str.join(iterable)	将可迭代对象中的元素连接为字符串	",".join(["a", "b", "c"]) → "a,b,c"
str.startswith(prefix)	检查字符串是否以指定前缀开头	"hello".startswith("he") → True
str.endswith(suffix)	检查字符串是否以指定后缀结尾	"hello".endswith("lo") → True
str.find(sub)	返回子串首次出现的索引，未找到返回-1	"hello".find("l") → 2
str.rfind(sub)	返回子串最后一次出现的索引，未找到返回-1	"hello".rfind("l") → 3
str.count(sub)	返回子串出现的次数	"hello".count("l") → 2
str.isalpha()	检查字符串是否只包含字母	"hello".isalpha() → True
str.isdigit()	检查字符串是否只包含数字	"123".isdigit() → True
str.isalnum()	检查字符串是否只包含字母或数字	"hello123".isalnum() → True
str.islower()	检查字符串是否全部为小写	"hello".islower() → True
str.isupper()	检查字符串是否全部为大写	"HELLO".isupper() → True
str.zfill(width)	在字符串左侧填充零，直到达到指定长度	"42".zfill(5) → "00042"
str.format()	格式化字符串	"{} {}".format("hello", "world") → "hello world"
str.encode()	将字符串编码为字节	"hello".encode("utf-8") → b'hello'

补充：

len(str) #返回长度
max(str) #返回ascll最大值
min(str) #返回ascll最小值

index和find区别

主要区别

• 未找到子字符串时的行为：

  • index 会抛出 ValueError 异常。
  • find 返回 -1，不会引发异常。

• 适用场景：

  • index 适用于确定子字符串必须存在的场景，需配合异常处理。
  • find 适用于不确定子字符串是否存在的场景，可通过返回值判断。

s = "hello world"

# 使用 find
print(s.find("world"))  # 输出: 6
print(s.find("python")) # 输出: -1

# 使用 index
print(s.index("world")) # 输出: 6
print(s.index("python")) # 抛出 ValueError
 

7.格式化字符串方法

使用 f-string
f-string 提供简洁直观的字符串格式化方式，变量直接嵌入大括号内：

name = "Alice"
age = 30
print(f"{name} is {age} years old.")  # 输出: Alice is 30 years old.
 

str.format() 方法
通过位置或关键字参数插入变量，支持复杂格式化：

print("{0} is {1} years old.".format("Bob", 25))  # 位置参数
print("{name} is {age} years old.".format(name="Charlie", age=40))  # 关键字参数
 

二.元组

元组（Tuple）是Python中一种不可变的序列类型，用于存储有序的元素集合。与列表（List）不同，元组一旦创建，其内容不可修改，这种特性使得元组在某些场景下更具优势，但是元素也是可以重复的，元组中元素可以是不同类型，使用方法和列表类似。

元组使用小括号 () 定义，元素之间用逗号分隔。即使只有一个元素，也需要在元素后加逗号，例如 (1,)。

1.创建元组

tup1 = (1, 2, 3, 'a', 'b')
tup2 = (4,) #单个元素要，结尾

使用推导式创建元组对象

tup1 = (i*2 for i in range(5)) #这里创建的是生成器对象
tuple(tup1) #此时创建了元组
print(tup1)

使用内置tuple()函数

可以通过tuple()函数将其他可迭代对象（如列表、字符串等）转换为元组：

list_to_tup = tuple([1, 2, 3])
str_to_tup = tuple('hello')
 

2.访问元组元素

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[1:3])  # 输出: (2, 3)
print(my_tuple[:3])   # 输出: (1, 2, 3)
print(my_tuple[2:])   # 输出: (3, 4, 5)
 

3.元组相加或相乘

tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
result = tuple1 + tuple2 #本质创建了新的对象
print(result)  # 输出: (1, 2, 3, 'a', 'b', 'c')
 

tuple1 = (1, 2)
result = tuple1 * 3
print(result)  # 输出: (1, 2, 1, 2, 1, 2)
 

4.检查成员是否为元组中的元素

my_tuple = (1, 2, 3, 4, 5)
element = 3

if element in my_tuple:
    print(f"{element} 存在于元组中")
else:
    print(f"{element} 不存在于元组中")
 

my_tuple = ("apple", "banana", "cherry")
element = "orange"

if element not in my_tuple:
    print(f"{element} 不存在于元组中")
else:
    print(f"{element} 存在于元组中")
 

5.获取元组长度

my_tuple = (1, 2, 3, 4, 5)
length = len(my_tuple)
print(length)  # 输出: 5
 

6.求元组中元素的最大值、最小值、加和

t = (3, 1, 4, 1, 5, 9)
max_value = max(t)
print(max_value)  # 输出: 9
 
min_value = min(t)
print(min_value)  # 输出: 1

sum_value = sum(t)
print(sum_value)  # 输出: 23

7.元组的遍历

使用for循环遍历元组

直接使用for循环可以依次访问元组中的每个元素：

tup = (1, 2, 3, 'a', 'b')
for item in tup:
    print(item)
 

使用索引遍历元组

通过索引访问元组中的元素，结合range()和len()函数：

tup = (10, 20, 30, 40)
for i in range(len(tup)):
    print(tup[i])
 

使用enumerate()遍历元组

如果需要同时获取索引和元素值，可以使用enumerate()函数：

tup = ('x', 'y', 'z')
for index, value in enumerate(tup):
    print(index, value)
 

8.元组的不可变

元素不可修改：元组中的元素不能被重新赋值。尝试修改元组中的元素会引发TypeError。

t = (1, 2, 3)
t[0] = 4  # 引发 TypeError: 'tuple' object does not support item assignment
 

• 长度不可变：元组创建后，不能添加或删除元素。没有类似列表的append()、extend()或remove()方法。

哈希性：由于元组是不可变的，它可以作为字典的键（key），而列表则不行。

valid_dict = {(1, 2): "value"}  # 合法
invalid_dict = {[1, 2]: "value"}  # 引发 TypeError: unhashable type: 'list'
 

9.元组相关函数

以下是Python中元组（tuple）常用函数的总结表格：

元组常用函数及方法

函数/方法	描述	示例
len(tuple)	返回元组中元素的数量	len((1, 2, 3)) 返回 3
tuple.count(x)	返回元组中指定值 x 出现的次数	(1, 2, 2, 3).count(2) 返回 2
tuple.index(x)	返回元组中第一个值为 x 的元素的索引，若未找到会引发 ValueError	(1, 2, 3).index(2) 返回 1
max(tuple)	返回元组中最大的元素	max((1, 2, 3)) 返回 3
min(tuple)	返回元组中最小的元素	min((1, 2, 3)) 返回 1
sum(tuple)	返回元组中所有数值元素的和（仅适用于数值型元组）	sum((1, 2, 3)) 返回 6
sorted(tuple)	返回一个排序后的列表（元组本身不可变，需转换为列表）	sorted((3, 1, 2)) 返回 [1, 2, 3]
tuple1 + tuple2	拼接两个元组	(1, 2) + (3, 4) 返回 (1, 2, 3, 4)
tuple * n	重复元组 n 次	(1, 2) * 2 返回 (1, 2, 1, 2)
x in tuple	检查元素 x 是否存在于元组中	2 in (1, 2, 3) 返回 True
x not in tuple	检查元素 x 是否不存在于元组中	4 not in (1, 2, 3) 返回 True

注意事项

• 元组是不可变类型，因此没有直接修改元素的方法（如 append、remove 等）。
• 若需修改元组内容，通常需要转换为列表后再转回元组。

三.集合set

集合是无序的，且不包含重复元素

集合使用{}定义，数据之间使用，分隔，也可以使用set()定义

集合没有索引，所以不可以通过切片方式访问集合元素

集合中元素可以是不同的类型

集合可以进行数学上的集合操作，如交集、并集和差集

集合适用于需要快速成员检查、消除重复项和集合运算的场景

1.创建集合

使用大括号直接创建
在Python中，可以通过大括号{}直接创建一个集合。集合中的元素必须是不可变类型（如整数、字符串、元组等），且会自动去重。

my_set = {1, 2, 3, 4, 4}  # 重复的4会被自动去重
print(my_set)  # 输出: {1, 2, 3, 4}
 

使用set()构造函数
可以通过set()函数将其他可迭代对象（如列表、元组、字符串）转换为集合。

my_list = [1, 2, 2, 3]
my_set = set(my_list)  # 转换为集合并去重
print(my_set)  # 输出: {1, 2, 3}
 

创建空集合
直接使用{}会创建一个空字典，而非空集合。创建空集合必须使用set()函数。

empty_set = set()  # 正确方式
print(type(empty_set))  # 输出: <class 'set'>
 

集合推导式
类似于列表推导式，可以通过集合推导式动态生成集合。

squares = {x**2 for x in range(5)}  # 生成0到4的平方集合
print(squares)  # 输出: {0, 1, 4, 9, 16}
 

2.向集合中添加元素

使用 add() 方法向集合中添加单个元素：

my_set = {1, 2, 3}
my_set.add(4)
 

使用 update() 方法添加多个元素：

my_set.update([5, 6, 7])
 

3.从集合中删除元素

使用 remove() 方法删除指定元素，若元素不存在会抛出 KeyError；使用 discard() 方法删除元素，若元素不存在则不会报错。

my_set = {1, 2, 3, 4}
my_set.remove(3)  # 删除元素 3
my_set.discard(5)  # 尝试删除不存在的元素 5，不会报错
 

4.检查成员是否为集合中的元素

Python 提供了 in 关键字来检查某个元素是否存在于集合中。语法简单且高效，适用于所有可迭代对象。

my_set = {1, 2, 3, 4, 5}
element = 3

if element in my_set:
    print(f"{element} 是集合中的成员")
else:
    print(f"{element} 不是集合中的成员")
 

5.获取集合的长度，最大值，最小值，加和

set1 = {1,2,3,4}
len(set1)
max(set1)
min(set1)
sum(set1)

6.遍历集合

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
 

7.集合常用函数

集合常见函数及方法

以下是Python中集合（set）类型的常用函数和方法，以表格形式整理：

方法/函数	描述	示例
add(element)	向集合中添加一个元素	s = {1, 2}; s.add(3) → {1, 2, 3}
update(iterable)	将可迭代对象中的元素添加到集合，添加的可以是列表、元组、字符串、字典等可迭代对象	s = {1, 2}; s.update([3, 4]) → {1, 2, 3, 4}
remove(element)	移除指定元素，若元素不存在则抛出KeyError	s = {1, 2}; s.remove(2) → {1}
discard(element)	移除指定元素，若元素不存在不报错	s = {1, 2}; s.discard(3) → {1, 2}
pop()	随机移除并返回一个元素，集合为空时抛出KeyError	s = {1, 2}; s.pop() → 可能返回1或2
clear()	清空集合	s = {1, 2}; s.clear() → set()
copy()	返回集合的浅拷贝	s = {1, 2}; t = s.copy() → t为{1, 2}
union(*others)	返回与其他集合的并集，他会创建一个新的对象	{1, 2}.union({2, 3}) → {1, 2, 3}
intersection(*others)	返回与其他集合的交集	{1, 2}.intersection({2, 3}) → {2}
difference(*others)	返回与其他集合的差集	{1, 2}.difference({2, 3}) → {1}
symmetric_difference()	返回与其他集合的对称差集（仅存在于一个集合中的元素）	{1, 2}.symmetric_difference({2, 3}) → {1, 3}
issubset(other)	判断当前集合是否为另一个集合的子集	{1}.issubset({1, 2}) → True
issuperset(other)	判断当前集合是否包含另一个集合的所有元素	{1, 2}.issuperset({1}) → True
isdisjoint(other)	判断两个集合是否无交集	{1}.isdisjoint({2}) → True
len(s)	返回集合中元素的数量	len({1, 2, 3}) → 3
in / not in	检查元素是否属于集合	1 in {1, 2} → True

集合操作符

集合支持以下操作符，功能与对应方法一致：（他是创建新的对象，而非在原集合上改动）

操作符	等价方法	示例
|	union()	{1, 2} | {2, 3}
&	intersection()	{1, 2} & {2, 3}
-	difference()	{1, 2} - {2, 3}
^	symmetric_difference()	{1, 2} ^ {2, 3}

注意事项

• 集合中的元素必须是不可变类型（如数字、字符串、元组等）。
• 集合不支持索引或切片操作。
• 使用frozenset可创建不可变集合，适用于需要哈希的场景（如作为字典的键）。

四.字典

以健值对形式存储数据

无序，不能通过下标定位元素，不能进行切片操作

一般通过key获取value

通过{}定义字典，字典中的键值对用：进行分割，多个健值对用逗号分隔

可变的（key：要求使用不可变类型     value：可以改变）

1.创建字典

通过花括号 {} 直接定义键值对，键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
 

通过 dict() 函数传入键值对参数或可迭代对象创建字典。

# 传入键值对参数
my_dict = dict(name='Alice', age=25, city='New York')

# 传入可迭代对象（如列表或元组）
my_dict = dict([('name', 'Alice'), ('age', 25), ('city', 'New York')])
 

通过推导式快速生成字典，适用于从其他数据结构转换或动态生成键值对。

# 从列表生成字典
keys = ['name', 'age', 'city']
values = ['Alice', 25, 'New York']
my_dict = {k: v for k, v in zip(keys, values)}

# 动态生成键值对
my_dict = {x: x**2 for x in range(5)}
 

2.访问字典

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 通过键访问值
print(my_dict["name"])  # 输出: Alice

# 使用 get() 方法访问值
print(my_dict.get("age"))  # 输出: 25
 

3.字典的添加

直接赋值添加键值对
通过指定新键并赋值，可直接向字典添加元素。例如：

my_dict = {'a': 1, 'b': 2}
my_dict['c'] = 3  # 添加新键值对
print(my_dict)    # 输出: {'a': 1, 'b': 2, 'c': 3}
 

使用 update() 方法合并字典
通过传入另一个字典或可迭代的键值对，批量添加元素。若键已存在，则更新其值。

my_dict = {'a': 1}
my_dict.update({'b': 2, 'c': 3})  # 合并字典
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}
 

使用 setdefault() 方法安全添加
仅当键不存在时添加键值对，并返回当前值（若键存在则不修改）。

my_dict = {'a': 1}
value = my_dict.setdefault('b', 100)  # 添加新键
print(value)  # 输出: 100
print(my_dict)  # 输出: {'a': 1, 'b': 100}
 

4.修改字典中的元素

直接通过键修改值

my_dict = {'name': 'Alice', 'age': 25}
my_dict['age'] = 26  # 将'age'对应的值修改为26
 

使用update()方法批量更新

my_dict = {'name': 'Alice', 'age': 25}
my_dict.update({'age': 26, 'city': 'New York'})  # 更新'age'并添加新键值对
 

用setdefault()方法修改或添加默认值

my_dict = {'name': 'Alice', 'age': 25}
my_dict.setdefault('age', 30)  # 如果键存在则不修改，不存在则设置为30
 

5.检查成员是否是字典中的key

使用 in 关键字
通过 key in dict 语法直接判断键是否存在，返回布尔值。

my_dict = {'a': 1, 'b': 2}
if 'a' in my_dict:
    print("Key exists")
 

方法二：调用 dict.get() 方法
通过 dict.get(key, default) 检查，若键不存在则返回 None 或指定的默认值。

value = my_dict.get('c', 'Key not found')
print(value)  # 输出: Key not found
 

6.删除字典中的元素

使用 del 语句

通过指定键名，可以直接删除字典中的键值对。如果键不存在，会引发 KeyError 异常

my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['a']
print(my_dict)  # 输出: {'b': 2, 'c': 3}
 
#del整个字典就会删除整个字典
del my_dict #my_dict字典会被删除

使用 pop() 方法

pop() 方法可以删除指定键并返回对应的值。如果键不存在，可以提供一个默认值以避免错误。

my_dict = {'a': 1, 'b': 2, 'c': 3}
value = my_dict.pop('b')
print(value)  # 输出: 2
print(my_dict)  # 输出: {'a': 1, 'c': 3}

# 使用默认值避免 KeyError
value = my_dict.pop('d', 'Key not found')
print(value)  # 输出: 'Key not found'
 

7. 字典常用方法

对字典进行遍历

dict1 = {"唐僧"："迟重瑞" ， "孙悟空"："六小龄童" ， "八戒"："马德华" ， "沙和尚"："国怀里"}

#遍历所有key

keys = dict1.keys()

for key in keys

     print(key)

#遍历所有value

values = dict.values()

for value in values:

     print(value)

#遍历所有k-v

for k in dict1.keys():

     print(k,dict1[k])

for k,v in dict.items():

     print(k,v)

五.列表、元组、字典、集合的区别表格