三、字符串和列表

3.1 字符串的基本操作和常用方法

在Python中，字符串是一种基本的数据类型，它用于表示文本数据。字符串是不可变的，也就是说，一旦创建了字符串，就不能再修改它的值。下面是一些字符串的基本操作和常用方法。

3.1.1. 定义字符串

在Python中，可以使用单引号、双引号或三引号来定义字符串。单引号和双引号是等价的，可以根据需要选择使用。三引号用于定义多行字符串。

str1 = 'Hello, World!'
str2 = "Hello, World!"
str3 = '''
Hello,
World!
'''

3.1.2. 字符串的索引和切片

字符串中的每个字符都有一个索引，从0开始。可以使用索引来访问字符串中的单个字符，也可以使用切片来访问字符串的一部分。

str = 'Hello, World!'

# 使用索引访问单个字符
print(str[0])  # 输出：H
print(str[7])  # 输出：W

# 使用切片访问字符串的一部分
print(str[0:5])  # 输出：Hello
print(str[7:])   # 输出：World!
print(str[:5])   # 输出：Hello
print(str[-6:])  # 输出：World!

3.1.3. 字符串的拼接和重复

可以使用加号来拼接字符串，也可以使用乘号来重复一个字符串。

str1 = 'Hello'
str2 = 'World'

# 字符串的拼接
str3 = str1 + ', ' + str2 + '!'
print(str3)  # 输出：Hello, World!

# 字符串的重复
str4 = str1 * 3
print(str4)  # 输出：HelloHelloHello

3.1.4. 字符串的长度和包含判断

可以使用len函数来获取字符串的长度，也可以使用in关键字来判断一个字符串是否包含另一个字符串。

str = 'Hello, World!'

# 获取字符串的长度
print(len(str))  # 输出：13

# 判断一个字符串是否包含另一个字符串
print('World' in str)  # 输出：True
print('world' in str)  # 输出：False

3.1.5. 字符串的常用方法

Python中的字符串还有很多常用方法，例如：

• str.lower()：将字符串中的所有字母转换为小写字母。
• str.upper()：将字符串中的所有字母转换为大写字母。
• str.strip()：去掉字符串开头和结尾的空格。
• str.startswith(prefix)：判断字符串是否以prefix开头。
• str.endswith(suffix)：判断字符串是否以suffix结尾。
• str.split(sep=None, maxsplit=-1)：将字符串按照sep分隔成一个列表。
• str.join(iterable)：将一个可迭代对象中的所有字符串连接起来，中间用str作为分隔符。

str = ' Hello, World! '

# 将字符串中的所有字母转换为小写字母
print(str.lower())  # 输出： hello, world! 

# 去掉字符串开头和结尾的空格
print(str.strip())  # 输出：Hello, World!

# 判断字符串是否以Hello开头
print(str.startswith('Hello'))  # 输出：False

# 将字符串按照逗号分隔成一个列表
print(str.split(','))  # 输出：[' Hello', ' World! ']

# 将一个列表中的所有字符串连接起来，中间用逗号作为分隔符
list = ['Hello', 'World']
print(','.join(list))  # 输出：Hello,World

3.1.6. 格式化字符串

在Python中，可以使用字符串的format方法来进行字符串的格式化。格式化字符串可以用于将变量的值插入到字符串中。

name = 'Alice'
age = 20

# 将变量的值插入到字符串中
print('My name is {} and I am {} years old.'.format(name, age))
# 输出：My name is Alice and I am 20 years old.

在格式化字符串中，大括号{}表示占位符，可以在其中插入变量的值。如果需要指定变量的类型，可以在大括号中使用冒号:来进行格式化。

pi = 3.1415926

# 将浮点数格式化为两位小数的字符串
print('The value of pi is {:.2f}.'.format(pi))
# 输出：The value of pi is 3.14.

3.1.7. 字符串的编码和解码

在Python中，字符串的编码和解码是一个常见的操作。Python默认使用UTF-8编码，可以使用encode方法将字符串编码为字节数组，使用decode方法将字节数组解码为字符串。

str = '你好，世界！'

# 将字符串编码为字节数组
bytes = str.encode('utf-8')
print(bytes)  # 输出：b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'

# 将字节数组解码为字符串
str2 = bytes.decode('utf-8')
print(str2)  # 输出：你好，世界！

3.1.8. 字符串的格式化输出

在Python中，可以使用字符串的f-string来进行格式化输出。f-string是Python 3.6引入的一种新的字符串格式化方式，可以将变量的值直接插入到字符串中。

name = 'Alice'
age = 20

# 使用f-string进行格式化输出
print(f'My name is {name} and I am {age} years old.')
# 输出：My name is Alice and I am 20 years old.

在f-string中，同样使用大括号{}表示占位符，可以在其中插入变量的值。如果需要指定变量的类型，可以在大括号中使用冒号:来进行格式化。

pi = 3.1415926

# 将浮点数格式化为两位小数的字符串
print(f'The value of pi is {pi:.2f}.')
# 输出：The value of pi is 3.14.

3.1.9. 字符串的常用函数

Python中的字符串还有很多常用的函数，例如：

• str.count(sub[, start[, end]])：返回字符串中子串sub出现的次数。
• str.find(sub[, start[, end]])：返回子串sub在字符串中第一次出现的位置，如果没有找到，则返回-1。
• str.replace(old, new[, count])：将字符串中的所有old子串替换为new子串。
• str.isalpha()：判断字符串是否只包含字母。
• str.isdigit()：判断字符串是否只包含数字。
• str.isalnum()：判断字符串是否只包含字母和数字。
• str.islower()：判断字符串中所有字母是否都是小写字母。
• str.isupper()：判断字符串中所有字母是否都是大写字母。

str = 'Hello, World!'

# 返回字符串中子串o出现的次数
print(str.count('o'))  # 输出：2

# 返回子串Wo在字符串中第一次出现的位置
print(str.find('Wo'))  # 输出：7

# 将字符串中的所有l替换为x
print(str.replace('l', 'x'))  # 输出：Hexxo, Worxd!

# 判断字符串是否只包含字母
print(str.isalpha())  # 输出：False

# 判断字符串是否只包含数字
print(str.isdigit())

3.2 列表的基本操作和常用方法

列表是Python中常用的一种数据类型，用于存储一组有序的元素。列表可以存储任意类型的元素，包括数字、字符串、布尔值、甚至其他列表等。本节我们将介绍列表的基本操作和常用方法。

3.2.1 创建列表

可以使用方括号[]来创建一个空列表，也可以在方括号中添加元素来创建一个非空列表。

# 创建一个空列表
list1 = []

# 创建一个包含3个元素的列表
list2 = [1, 'hello', True]

# 创建一个包含5个数字的列表
list3 = [2, 4, 6, 8, 10]

3.2.2 访问列表元素

可以通过下标来访问列表中的元素。列表的下标从0开始，可以为负数，表示从列表末尾倒数第几个元素。

# 访问列表中的第一个元素
print(list2[0])  # 输出：1

# 访问列表中的最后一个元素
print(list2[-1])  # 输出：True

3.2.3 修改列表元素

可以通过下标来修改列表中的元素。

# 修改列表中的第二个元素
list2[1] = 'world'
print(list2)  # 输出：[1, 'world', True]

3.2.4 列表的切片操作

列表的切片操作可以获取列表中的一个子列表。切片操作使用方括号和冒号[start:end]表示，其中start表示起始下标，end表示结束下标（不包含在切片中）。

# 获取列表list3中下标为1到3的子列表
sub_list = list3[1:4]
print(sub_list)  # 输出：[4, 6, 8]

如果省略start，则默认从列表开头开始；如果省略end，则默认一直切片到列表末尾。

# 从列表list3中获取前3个元素
sub_list = list3[:3]
print(sub_list)  # 输出：[2, 4, 6]

# 从列表list3中获取从下标为2开始到末尾的所有元素
sub_list = list3[2:]
print(sub_list)  # 输出：[6, 8, 10]

3.2.5 列表的拼接和重复

可以使用加号+来将两个列表拼接成一个列表。

# 将列表list2和list3拼接成一个新的列表
new_list = list2 + list3
print(new_list)  # 输出：[1, 'world', True, 2, 4, 6, 8, 10]

可以使用乘号*来将一个列表重复多次。

# 将列表list3重复3次
new_list = list3 * 3
print(new_list)  # 输出：[2, 4, 6, 8, 10, 2, 4, 6, 8, 10, 2, 4, 6, 8, 10]

3.2.6 列表的常用方法

Python中的列表还有很多常用的方法，例如：

• list.append(x)：在列表末尾添加一个元素x。
• list.insert(i, x)：在列表的第i个位置插入一个元素x。
• list.pop([i])：删除列表的第i个元素，并返回该元素的值。如果不指定i，则默认删除末尾元素。
• list.index(x)：返回元素x在列表中的下标。如果x不在列表中会抛出ValueError异常。
• list.count(x)：返回元素x在列表中出现的次数。
• list.sort()：将列表中的元素按照升序排序。
• list.reverse()：将列表中的元素逆序排列。
• list.copy()：返回一个列表的浅拷贝。浅拷贝是指创建一个新的列表，新列表中的元素和原列表相同，但是新列表和原列表指向的对象是不同的。
• list.clear()：删除列表中的所有元素。
• list.remove(x)：删除列表中第一个值为x的元素。如果x不在列表中会抛出ValueError异常。
• list.extend(iterable)：将可迭代对象中的元素添加到列表末尾。可迭代对象可以是列表、元组、集合、字典等。
• list.pop()：删除列表末尾的元素，并返回该元素的值。
• list.sort(reverse=True)：将列表中的元素按照降序排序。
• list.reverse()：将列表中的元素逆序排列。

以下是一些常用方法的示例：

# 创建一个包含3个元素的列表
list1 = [1, 2, 3]

# 在列表末尾添加一个元素
list1.append(4)
print(list1)  # 输出：[1, 2, 3, 4]

# 在列表的第二个位置插入一个元素
list1.insert(1, 5)
print(list1)  # 输出：[1, 5, 2, 3, 4]

# 删除列表中的第三个元素，并返回该元素的值
value = list1.pop(2)
print(value)  # 输出：2
print(list1)  # 输出：[1, 5, 3, 4]

# 返回元素3在列表中的下标
index = list1.index(3)
print(index)  # 输出：2

# 返回元素1在列表中出现的次数
count = list1.count(1)
print(count)  # 输出：1

# 将列表中的元素按照升序排序
list1.sort()
print(list1)  # 输出：[1, 3, 4, 5]

# 将列表中的元素按照降序排序
list1.sort(reverse=True)
print(list1)  # 输出：[5, 4, 3, 1]

3.2.7 列表的高级操作

Python中的列表还有一些高级的操作，例如列表推导式、map函数和filter函数。

3.2.7.1 列表推导式

列表推导式是一种简洁的语法，用于快速创建一个列表。列表推导式的基本语法为[expression for item in iterable]，其中expression表示每个元素的表达式，item表示可迭代对象中的每个元素，iterable表示可迭代对象。

例如，可以使用列表推导式来创建一个包含1到10的平方的列表：

# 使用列表推导式创建一个包含1到10的平方的列表
squares = [x**2 for x in range(1, 11)]
print(squares)  # 输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

3.2.7.2 map函数

map函数是一种高阶函数，用于将一个函数应用于可迭代对象中的每个元素，并返回一个新的可迭代对象。map函数的基本语法为map(function, iterable)，其中function表示要应用的函数，iterable表示可迭代对象。

例如，可以使用map函数将列表中的所有元素转换为字符串：

# 将列表中的所有元素转换为字符串
list1 = [1, 2, 3]
str_list = list(map(str, list1))
print(str_list)  # 输出：['1', '2', '3']

3.2.7.3 filter函数

filter函数是一种高阶函数，用于过滤可迭代对象中的元素，并返回一个新的可迭代对象。filter函数的基本语法为filter(function, iterable)，其中function表示用于过滤的函数，iterable表示可迭代对象。

例如，可以使用filter函数过滤列表中的偶数：

# 过滤列表中的偶数
list1 = [1, 2, 3, 4, 5, 6]
even_list = list(filter(lambda x: x % 2 == 0, list1))
print(even_list)  # 输出：[2, 4, 6]

3.2.8 总结

本节介绍了Python中的列表，包括列表的创建、访问、切片、修改、常用方法、高级操作等。列表是Python中非常常用的数据类型之一，具有灵活、易用的特点，可以在许多场景下使用。

需要注意的是，列表是可变的数据类型，即可以修改列表中的元素。在对列表进行修改时，需要注意不要改变列表的大小，否则可能会导致索引错误。此外，在对列表进行循环操作时，最好使用for-in循环，不要使用while循环和索引。

除了列表，Python中还有其他的数据类型，例如元组、集合、字典等，它们各自具有不同的特点和用途，可以根据不同的场景选择合适的数据类型。

3.3 列表和字符串的高级操作

在Python中，列表和字符串都是序列类型，具有很多相似的操作。本节将介绍一些列表和字符串的高级操作。

3.3.1 列表和字符串的切片操作

切片操作是指从一个序列中获取子序列的操作。在Python中，可以使用切片操作来获取列表和字符串的子序列。切片操作的基本语法为[start:stop:step]，其中start表示起始位置（默认为0），stop表示终止位置（默认为序列的长度），step表示步长（默认为1）。

例如，可以使用切片操作来获取列表中的一段子序列：

# 创建一个包含10个元素的列表
list1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取列表中的前3个元素
sub_list1 = list1[:3]
print(sub_list1)  # 输出：[0, 1, 2]

# 获取列表中的第4到第6个元素
sub_list2 = list1[3:6]
print(sub_list2)  # 输出：[3, 4, 5]

# 获取列表中的倒数3个元素
sub_list3 = list1[-3:]
print(sub_list3)  # 输出：[7, 8, 9]

# 获取列表中的偶数元素
sub_list4 = list1[::2]
print(sub_list4)  # 输出：[0, 2, 4, 6, 8]

可以看到，切片操作非常方便，可以快速获取列表中的子序列。

同样地，也可以使用切片操作来获取字符串中的子串：

# 创建一个字符串
str1 = "Hello, World!"

# 获取字符串的前5个字符
sub_str1 = str1[:5]
print(sub_str1)  # 输出：Hello

# 获取字符串中的"World"子串
sub_str2 = str1[7:12]
print(sub_str2)  # 输出：World

# 获取字符串中的倒数6个字符
sub_str3 = str1[-6:]
print(sub_str3)  # 输出：World!

# 获取字符串中的奇数位置字符
sub_str4 = str1[::2]
print(sub_str4)  # 输出：Hlo ol!

可以看到，字符串的切片操作与列表的切片操作基本相同。

3.3.2 列表和字符串的拼接操作

在Python中，可以使用加号（+）来对两个序列进行拼接。例如，可以使用加号来将两个列表拼接在一起：

# 拼接两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = list1 + list2
print(list3)  # 输出：[1, 2, 3, 4, 5, 6]

同样地，也可以使用加号来对两个字符串进行拼接：

# 拼接两个字符串
str1 = "Hello,"
str2 = " World!"
str3 = str1 + str2
print(str3)  # 输出：Hello, World!

3.3.3 列表和字符串的重复操作

在Python中，可以使用星号（*）来对一个序列进行重复操作。例如，可以使用星号将一个列表重复多次：

# 将一个列表重复3次
list1 = [1, 2, 3]
list2 = list1 * 3
print(list2)  # 输出：[1, 2, 3, 1, 2, 3, 1, 2, 3]

同样地，也可以使用星号将一个字符串重复多次：

# 将一个字符串重复3次
str1 = "Hello"
str2 = str1 * 3
print(str2)  # 输出：HelloHelloHello

3.3.4 列表和字符串的成员运算

在Python中，可以使用in和not in运算符来判断一个元素是否在一个序列中。例如，可以使用in运算符来判断一个元素是否在列表中：

# 判断一个元素是否在列表中
list1 = [1, 2, 3, 4, 5]
if 3 in list1:
    print("3 is in the list")
else:
    print("3 is not in the list")

同样地，也可以使用in运算符来判断一个子串是否在字符串中：

# 判断一个子串是否在字符串中
str1 = "Hello, World!"
if "World" in str1:
    print("World is in the string")
else:
    print("World is not in the string")

3.3.5 列表和字符串的长度计算

在Python中，可以使用len函数来计算一个序列的长度。例如，可以使用len函数来计算一个列表的长度：

# 计算列表的长度
list1 = [1, 2, 3, 4, 5]
length1 = len(list1)
print(length1)  # 输出：5

同样地，也可以使用len函数来计算一个字符串的长度：

# 计算字符串的长度
str1 = "Hello, World!"
length2 = len(str1)
print(length2)  # 输出：13

3.3.6 列表和字符串的排序操作

在Python中，可以使用sort方法来对一个列表进行排序。sort方法可以接受一个可选的key参数，用于指定排序规则。例如，可以使用sort方法对一个列表进行升序排序：

# 对列表进行升序排序
list1 = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
list1.sort()
print(list1)  # 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

同样地，可以使用sort方法对一个列表进行降序排序：

# 对列表进行降序排序
list1 = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
list1.sort(reverse=True)
print(list1)  # 输出：[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

在Python中，可以使用sorted函数来对一个序列进行排序，返回一个新的排序后的序列。例如，可以使用sorted函数对一个字符串进行排序：

# 对字符串进行排序
str1 = "hello, world!"
str2 = ''.join(sorted(str1))
print(str2)  # 输出： !,dehllloorw

可以看到，sorted函数返回了一个新的字符串，其中的字符按照字母顺序进行了排序。

3.3.7 列表和字符串的反转操作

在Python中，可以使用reverse方法来对一个列表进行反转操作。例如，可以使用reverse方法对一个列表进行反转：

# 对列表进行反转操作
list1 = [1, 2, 3, 4, 5]
list1.reverse()
print(list1)  # 输出：[5, 4, 3, 2, 1]

同样地，也可以使用切片操作对一个字符串进行反转操作：

# 对字符串进行反转操作
str1 = "Hello, World!"
str2 = str1[::-1]
print(str2)  # 输出：!dlroW ,olleH

可以看到，切片操作可以方便地对一个字符串进行反转操作。

到这里，我们介绍了列表和字符串的一些高级操作，这些操作可以让我们更加方便地处理列表和字符串。