python中字符串、列表、元组与字典的操作

目录

字符串操作

列表操作

元组操作

字典操作

字符串操作

字符串是编程中非常常用的数据类型，用于存储文本信息。以下是一些常见的字符串操作：

1. 创建字符串

单引号：

my_string = 'Hello, World!'

双引号：

my_string = "Hello, World!"

三引号（用于多行字符串）：
 

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

 2. 访问字符串中的字符

使用索引访问单个字符：

my_string = "Hello, World!"
print(my_string[0])  # 输出：H
print(my_string[-1])  # 输出：!

使用切片访问子字符串：

 

print(my_string[7:12])  # 输出：World
print(my_string[:5])    # 输出：Hello
print(my_string[7:])    # 输出：World!
print(my_string[::2])   # 输出：Hlo ol!

3. 修改字符串

字符串是《不可变类型》，不能直接修改某个字符。如果需要修改，可以创建一个新的字符串：

 

my_string = "Hello, World!"
new_string = my_string[:7] + "Python"
print(new_string)  # 输出：Hello, Python

4. 常用字符串方法

4.1 字符串拼接

使用 + 操作符：

str1 = "Hello"
str2 = "World"
result = str1 + " " + str2
print(result)  # 输出：Hello World

使用 join() 方法：

 

words = ["Hello", "World", "Python"]
result = " ".join(words)
print(result)  # 输出：Hello World Python

 4.2 字符串格式化

使用 % 格式化：

name = "Alice"
age = 25
print("My name is %s and I am %d years old." % (name, age))

使用 str.format() 方法：

 

print("My name is {} and I am {} years old.".format(name, age))

使用 f-string（Python 3.6+）：

 

print(f"My name is {name} and I am {age} years old.")

4.3 字符串长度

使用 len() 函数：

my_string = "Hello, World!"
print(len(my_string))  # 输出：13

4.4 字符串大小写转换

upper() 方法：

将字符串中的所有字符转换为大写。

 

print(my_string.upper())  # 输出：HELLO, WORLD!

lower() 方法：

将字符串中的所有字符转换为小写。

  

print(my_string.lower())  # 输出：hello, world!

capitalize() 方法：

将字符串的第一个字符转换为大写，其余字符转换为小写。

print(my_string.capitalize())  # 输出：Hello, world!

title() 方法 ：

将字符串中每个单词的首字母转换为大写。

 

print(my_string.title())  # 输出：Hello, World!

4.5 字符串查找

find(substring) 方法 ：

返回子字符串首次出现的索引，如果未找到返回  -1 。

print(my_string.find("World"))  # 输出：7
print(my_string.find("Python"))  # 输出：-1

index(substring) 方法 ：

返回子字符串首次出现的索引，如果未找到会抛出  ValueError 。

  

print(my_string.index("World"))  # 输出：7
# print(my_string.index("Python"))  # 抛出 ValueError

count(substring) 方法 ：

返回子字符串在字符串中出现的次数。

 

print(my_string.count("o"))  # 输出：2

4.6 字符串替换

replace(old, new) 方法 ：

将字符串中的 old 替换为 new 。

my_string = "Hello, World!"
new_string = my_string.replace("World", "Python")
print(new_string)  # 输出：Hello, Python!

4.7 字符串分割

split(separator) 方法 ：

将字符串按照指定分隔符分割成列表，默认分隔符为空白字符（空格、换行 `\n`、制表符 `\t` 等）。

 

my_string = "Hello, World! Welcome to Python."
words = my_string.split()
print(words)  # 输出：['Hello,', 'World!', 'Welcome', 'to', 'Python.']
words = my_string.split(",")
print(words)  # 输出：['Hello', ' World! Welcome to Python.']

4.8 去除空白字符

strip() 方法 ：

去除字符串首尾的空白字符。

 

my_string = "   Hello, World!   "
print(my_string.strip())  # 输出：Hello, World!

lstrip() 方法 ：

去除字符串开头的空白字符。

 

print(my_string.lstrip())  # 输出：Hello, World!   

rstrip() 方法 ：

去除字符串末尾的空白字符。

 

print(my_string.rstrip())  # 输出：   Hello, World!

4.9 检查字符串

isdigit() 方法 ：

检查字符串是否只包含数字。

 

print("12345".isdigit())  # 输出：True
print("123abc".isdigit())  # 输出：False

isalpha() 方法 ：

检查字符串是否只包含字母。

 

print("abcde".isalpha())  # 输出：True
print("abc123".isalpha())  # 输出：False

isalnum() 方法 ：

检查字符串是否只包含字母和数字。

 

print("abc123".isalnum())  # 输出：True
print("abc!123".isalnum())  # 输出：False

isspace() 方法 ：

检查字符串是否只包含空白字符。

 

print("   ".isspace())  # 输出：True
print("abc".isspace())  # 输出：False

4.10 检查字符串的前缀和后缀

startswith(prefix) 方法 ：

检查字符串是否以指定的前缀开头。

 

print(my_string.startswith("Hello"))  # 输出：True
print(my_string.startswith("World"))  # 输出：False

endswith(suffix) 方法：

检查字符串是否以指定的后缀结尾。

print(my_string.endswith("World!"))  # 输出：True
print(my_string.endswith("Python"))  # 输出：False

 

4.11 字符串编码和解码

encode(encoding) 方法：

将字符串编码为字节对象。

 

my_string = "你好，世界！"
encoded_string = my_string.encode("utf-8")
print(encoded_string)  # 输出：b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'

decode(encoding) 方法：

将字节对象解码为字符串。

 

decoded_string = encoded_string.decode("utf-8")
print(decoded_string)  # 输出：你好，世界！

总结

字符串是不可变类型，因此所有字符串操作都会返回一个新的字符串，而不是修改原字符串。掌握这些常用操作可以帮助你高效地处理字符串数据。

列表操作

列表（List）是一种非常常用的数据结构，用于存储有序的元素集合。以下是一些常见的列表操作，以 Python 为例进行详细说明：

1. 创建列表

空列表：

 

my_list = []

初始化列表：

 

my_list = [1, 2, 3, 4, 5]
my_list = ["apple", "banana", "cherry"]

2. 访问列表中的元素

使用索引访问元素：

 

my_list = [1, 2, 3, 4, 5]
print(my_list[0])  # 输出：1
print(my_list[-1])  # 输出：5（负索引从列表末尾开始计数）

使用切片访问子列表：

 

print(my_list[1:3])  # 输出：[2, 3]（从索引1到索引3，不包括索引3）
print(my_list[:3])   # 输出：[1, 2, 3]（从开头到索引3，不包括索引3）
print(my_list[3:])   # 输出：[4, 5]（从索引3到末尾）
print(my_list[::2])  # 输出：[1, 3, 5]（每隔一个元素取一个）

3. 修改列表

修改特定位置的元素：

 

my_list[0] = 10
print(my_list)  # 输出：[10, 2, 3, 4, 5]

使用切片修改多个元素：

 

my_list[1:3] = [20, 30]
print(my_list)  # 输出：[10, 20, 30, 4, 5]

4. 添加元素

append() 方法：

在列表末尾添加一个元素。

 

my_list.append(6)
print(my_list)  # 输出：[10, 20, 30, 4, 5, 6]

extend() 方法：

将另一个列表的所有元素添加到当前列表末尾。

my_list.extend([7, 8])
print(my_list)  # 输出：[10, 20, 30, 4, 5, 6, 7, 8]

insert(index, value) 方法：

在指定位置插入一个元素。
 

my_list.insert(2, "new")
print(my_list)  # 输出：[10, 20, 'new', 30, 4, 5, 6, 7, 8]

5. 删除元素

-remove(value) 方法：

删除第一个匹配的值。如果值不存在，会抛出 `ValueError`。

my_list.remove("new")
print(my_list)  # 输出：[10, 20, 30, 4, 5, 6, 7, 8]

pop(index) 方法：

删除并返回指定索引位置的元素。如果不指定索引，默认删除并返回最后一个元素。

 

removed_element = my_list.pop(2)
print(removed_element)  # 输出：30
print(my_list)  # 输出：[10, 20, 4, 5, 6, 7, 8]

del 关键字：

删除指定索引位置的元素或整个列表。

 

del my_list[1]
print(my_list)  # 输出：[10, 4, 5, 6, 7, 8]
del my_list  # 删除整个列表

6. 清空列表

clear() 方法：

清空列表中的所有元素。
 

my_list = [10, 20, 30]
my_list.clear()
print(my_list)  # 输出：[]

7. 列表推导式

 

squares = [x * x for x in range(1, 6)]
print(squares)  # 输出：[1, 4, 9, 16, 25]

8. 复制列表

copy() 方法：

my_list = [1, 2, 3]
new_list = my_list.copy()
print(new_list)  # 输出：[1, 2, 3]

使用切片复制列表：
 

new_list = my_list[:]
print(new_list)  # 输出：[1, 2, 3]

9. 排序

sort() 方法：

对列表进行原地排序（会修改原列表）。
 

my_list = [3, 1, 4, 1, 5, 9]
my_list.sort()
print(my_list)  # 输出：[1, 1, 3, 4, 5, 9]

sorted() 函数：

返回排序后的列表副本，不修改原列表。
 

my_list = [3, 1, 4, 1, 5, 9]
sorted_list = sorted(my_list)
print(sorted_list)  # 输出：[1, 1, 3, 4, 5, 9]
print(my_list)  # 输出：[3, 1, 4, 1, 5, 9]

10. 反转

reverse() 方法：

对列表进行原地反转（会修改原列表）。
 

my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list)  # 输出：[5, 4, 3, 2, 1]

使用切片反转列表：
 

reversed_list = my_list[::-1]
print(reversed_list)  # 输出：[5, 4, 3, 2, 1]

11. 统计

len() 函数：

返回列表的长度。

print(len(my_list))  # 输出：5

count(value) 方法：

返回指定值在列表中出现的次数。
 

print(my_list.count(1))  # 输出：2

12. 查找

- 使用 `in` 和 `not in` 操作符检查元素是否存在：
 

print(1 in my_list)  # 输出：True
print(6 not in my_list)  # 输出：True

使用 index(value) 方法：

返回指定值在列表中首次出现的索引。如果值不存在，会抛出 `ValueError`。
 

print(my_list.index(3))  # 输出：2

13. 列表的其他操作

连接两个列表：

  

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2
print(combined_list)  # 输出：[1, 2, 3, 4, 5, 6]

重复列表：

 

repeated_list = [1, 2, 3] * 3
print(repeated_list)  # 输出：[1, 2, 3, 1, 2, 3, 1, 2, 3]

总结

这些是列表的常用操作，涵盖了创建、访问、修改、排序、统计、查找等常见需求。掌握这些操作可以帮助你高效地使用列表来处理数据。

元组操作

元组（Tuple）是一种不可变的数据结构，用于存储有序的元素集合。与列表不同，元组一旦创建，其内容不能被修改。以下是一些常见的元组操作，以 Python 为例进行详细说明：

1. 创建元组

空元组：

my_tuple = ()

单个元素的元组（注意末尾的逗号）：

single_element_tuple = (42,)

多个元素的元组：

my_tuple = (1, 2, 3, 4, 5)
my_tuple = "apple", "banana", "cherry"  # 也可以省略括号

2. 访问元组中的元素

- 使用索引访问单个元素：

  

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

- 使用切片访问子元组：

 

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

3. 修改元组

- **不可变性**：元组是不可变的，不能直接修改元组中的元素。如果需要修改，可以通过创建一个新的元组来实现。
 

my_tuple = (1, 2, 3)
new_tuple = my_tuple[:2] + (4,)  # 创建一个新的元组
print(new_tuple)  # 输出：(1, 2, 4)

4. 元组的常用方法

4.1 计算元组长度

使用 len() 函数：

 

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

4.2 查找元素

使用 in 和 not in 操作符检查元素是否存在：

print(3 in my_tuple)  # 输出：True
print(6 not in my_tuple)  # 输出：True

使用 `index(value) 方法：

返回指定值首次出现的索引。如果值不存在，会抛出 `ValueError`。

print(my_tuple.index(3))  # 输出：2
# print(my_tuple.index(6))  # 抛出 ValueError

4.3 统计元素出现次数

使用 count(value) 方法：

返回指定值在元组中出现的次数。

 

my_tuple = (1, 2, 2, 3, 4, 2)
print(my_tuple.count(2))  # 输出：3

5. 元组的解包（Unpacking）

- 将元组中的值解包到多个变量中：

 

my_tuple = ("Alice", 25, "New York")
name, age, city = my_tuple
print(name)  # 输出：Alice
print(age)   # 输出：25
print(city)  # 输出：New York

6. 元组的比较

- 元组可以使用比较运算符（`==`, `!=`, `<`, `>`, `<=`, `>=`）进行比较。比较时从左到右逐个比较元素。

 

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
print(tuple1 < tuple2)  # 输出：True
print(tuple1 == tuple2)  # 输出：False

7. 元组的连接和重复

连接两个元组：

 

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # 输出：(1, 2, 3, 4, 5, 6)

重复元组：

 

repeated_tuple = (1, 2, 3) * 3
print(repeated_tuple)  # 输出：(1, 2, 3, 1, 2, 3, 1, 2, 3)

8. 元组的其他操作

8.1 最大值和最小值

- 使用内置函数 `max()` 和 `min()`：

 

my_tuple = (1, 2, 3, 4, 5)
print(max(my_tuple))  # 输出：5
print(min(my_tuple))  # 输出：1

8.2 转换为列表

- 使用 `list()` 函数将元组转换为列表：

 

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # 输出：[1, 2, 3]

8.3 转换为字符串

- 使用 `str()` 函数将元组转换为字符串：

 

my_tuple = (1, 2, 3)
my_string = str(my_tuple)
print(my_string)  # 输出：'(1, 2, 3)'

总结

元组的主要特点是**不可变性**，这使得元组在某些场景下（如用作字典的键、存储不可变数据等）非常有用。掌握这些常用操作可以帮助你高效地使用元组来处理数据。

字典操作

字典是 Python 中非常灵活且强大的数据结构，用于存储键值对（key-value pairs）。以下是一些常见的字典操作，帮助你更好地理解和使用字典。

1. 创建字典

1.1 空字典
 

my_dict = {}

1.2 使用花括号初始化字典
 

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

1.3 使用 `dict()` 函数
 

my_dict = dict(name="Alice", age=25, city="New York")

1.4 从键列表创建字典

 

keys = ["name", "age", "city"]
my_dict = dict.fromkeys(keys, "Unknown")
print(my_dict)  # 输出：{'name': 'Unknown', 'age': 'Unknown', 'city': 'Unknown'}

2. 访问字典中的值

2.1 使用键访问

 

print(my_dict["name"])  # 输出：Alice

2.2 使用 get() 方法（避免 KeyError）

 

print(my_dict.get("name"))  # 输出：Alice
print(my_dict.get("gender", "Unknown"))  # 如果键不存在，返回默认值 "Unknown"

3. 添加或修改键值对

3.1 添加新键值对
 

my_dict["gender"] = "Female"
print(my_dict)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York', 'gender': 'Female'}

3.2 修改现有键的值
 

my_dict["age"] = 26
print(my_dict)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York', 'gender': 'Female'}

4. 删除键值对

4.1 使用 del 关键字
 

del my_dict["city"]
print(my_dict)  # 输出：{'name': 'Alice', 'age': 26, 'gender': 'Female'}

4.2 使用 pop() 方法（返回被删除的值）
 

removed_value = my_dict.pop("age")
print(removed_value)  # 输出：26
print(my_dict)  # 输出：{'name': 'Alice', 'gender': 'Female'}

4.3 使用 `popitem() 方法（随机删除一个键值对，Python 3.7+ 按插入顺序删除最后一个）
 

my_dict = {"name": "Alice", "age": 26, "gender": "Female"}
removed_item = my_dict.popitem()
print(removed_item)  # 输出：('gender', 'Female')
print(my_dict)  # 输出：{'name': 'Alice', 'age': 26}

5. 遍历字典

5.1 遍历键
 

for key in my_dict.keys():
    print(key)
# 输出：
# name
# age

5.2 遍历值
 

for value in my_dict.values():
    print(value)
# 输出：
# Alice
# 26

5.3 遍历键值对
 

for key, value in my_dict.items():
    print(f"{key}: {value}")
# 输出：
# name: Alice
# age: 26

6. 检查键是否存在
 

print("name" in my_dict)  # 输出：True
print("city" in my_dict)  # 输出：False

7. 字典的常用方法

7.1 clear()：

清空字典
 

my_dict.clear()
print(my_dict)  # 输出：{}

7.2 copy()：

创建字典的浅拷贝
 

my_dict = {"name": "Alice", "age": 26}
new_dict = my_dict.copy()
print(new_dict)  # 输出：{'name': 'Alice', 'age': 26}

7.3 update()：

更新字典
 

my_dict = {"name": "Alice", "age": 25}
my_dict.update({"age": 26, "city": "New York"})
print(my_dict)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York'}

7.4 setdefault()：

设置默认值
 

my_dict = {"name": "Alice", "age": 25}
my_dict.setdefault("city", "New York")
print(my_dict)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York'}

8. 字典推导式
 

squares = {x: x * x for x in range(1, 6)}
print(squares)  # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

9. 字典的其他操作

9.1 合并两个字典
 

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
dict1.update(dict2)
print(dict1)  # 输出：{'a': 1, 'b': 3, 'c': 4}

9.2 获取字典的长度
 

print(len(my_dict))  # 输出：3

总结

字典是 Python 中非常强大的数据结构，适用于存储键值对数据。掌握这些常用操作可以帮助你高效地使用字典来处理各种数据。如果你有更具体的问题或需要进一步的示例，请随时告诉我！