Python字符串、列表、元组、集合和字典_简述下python中的字符串、列表、元组和字典

字符串、列表、元组、集合和字典

1.字符串（str）

字符串是Python中的文本数据类型，它是由零个或多个字符组成的不可变序列。字符串字面值可以用单引号、双引号或三引号括起来，也可以用反斜杠\转义字符的方式输入特殊字符

str1 = 'Hello, World!'  

str2 = "Hello, World!"  

str3 = '''Hello,
World!'''
1
2
3
4
5
6
'
运行
运行

获取单个字符可以通过在方括号[]中使用索引来访问，索引从0开始，例如str[0]表示字符串中的第一个字符。Python也允许从字符串的两端使用索引，例如str[-1]表示字符串中的最后一个字符。

str = 'Hello, World'  

print(str[0])  # 输出：H 
print(str[7])  # 输出：W
print(str[-1]) # 输出：d
1
2
3
4
5
'
运行
运行

除了获取单个字符外，还可以通过指定一个范围来获取多个字符，也就是一个子串或片段。例如str[start:end]表示从字符串str中的start索引开始到end索引（不包含该索引）的子串。需要注意的是，Python字符串是不可变的，因此不能通过对其某一位置进行赋值而改变字符。

str = 'Hello, World!'  

print(str[0:3])  # 输出：Hel
1
2
3
'
运行
运行

2.列表（list）

列表是一种有序的集合，可以随时添加和删除其中的元素。列表中的元素不需要是同一类型，可以是整数、浮点数、字符串、布尔值等等。

以下是创建和访问列表的基本语法：

my_list = [1, 2, 3, 'a', 'b', 'c']  
print(my_list[0])  # 输出：1  
print(my_list[3])  # 输出：'a'  
print(my_list[-1])  # 输出：'c'
1
2
3
4
'
运行
运行

列表的主要特点如下：

1. 有序性：列表是有序的，这意味着我们可以使用索引访问列表中的每个元素，从0开始编号。
2. 可变性：列表是可变的，这意味着我们可以添加、删除或改变列表中的元素。
3. 可重复性：列表中的元素可以重复出现。

以下是一些使用列表的例子：

# 创建一个列表  
my_list = [1, 2, 3, 'a', 'b', 'c']  
  
# 访问列表的元素  
print(my_list[0])  # 输出：1  
print(my_list[3])  # 输出：'a'  
print(my_list[-1])  # 输出：'c'  
  
# 添加元素到列表中  
my_list.append(4)  # 在列表末尾添加一个元素  
print(my_list)  # 输出：[1, 2, 3, 'a', 'b', 'c', 4]  
  
# 在指定位置插入元素  
my_list.insert(2, 'x')  # 在索引为2的位置插入字符串'x'  
print(my_list)  # 输出：[1, 2, 'x', 3, 'a', 'b', 'c', 4]  
  
# 删除列表中的元素  
del my_list[0]  # 删除索引为0的元素  
print(my_list)  # 输出：[2, 'x', 3, 'a', 'b', 'c', 4]  
  
# 删除多个元素  
del my_list[2:5]  # 删除索引为2到4的元素（不包括5）  
print(my_list)  # 输出：[2, 'x', 4]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
'
运行
运行

此外，Python中的列表还支持很多其他操作，例如排序、合并、分割等。可以使用内置函数如append()、extend()、insert()、remove()等来操作列表。

3.元组（tuple）

元组是Python中的一种数据类型，它是一种有序的、不可变的、可重复的元素集合。元组的元素可以是不同类型的，包括数字、字符串、列表等。

t = (1, 'a', [2, 3, 4]) #创建了一个名为t的元组，包含三个元素：整数1、字符串'a'和一个列表[2, 3, 4]
1
'
运行
运行

元组的主要特点如下：

1. 有序性：元组的元素按照它们在元组中出现的顺序排列，这意味着我们可以使用索引访问元组中的每个元素，类似于列表。
2. 不可变性：元组是不可变的，这意味着一旦创建了一个元组，就不能再添加或删除它的元素，或者改变它的元素的值。但是，我们可以创建一个新的元组，包含原有元组中的部分元素。
3. 可重复性：元组是不可重复的，这意味着它的每个元素只能出现一次。但是，如果元组包含其他元组，那么这些子元组可以重复出现。

下面是一些使用元组的例子：

# 创建一个元组  
t = (1, 'a', [2, 3, 4])  

# 访问元组的元素  
print(t[0])  # 输出：1  
print(t[1])  # 输出：'a'  
print(t[2][0])  # 输出：2  

# 创建一个新的元组  
t2 = t[0], t[2]  
print(t2)  # 输出：(1, [2, 3, 4])  

# 元组可以包含其他元组  
t3 = (1, (2, 3), [4, 5, (6, 7)])  
print(t3)  # 输出：(1, (2, 3), [4, 5, (6, 7)])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'
运行
运行

4.集合（set）

集合（set）是一种无序且不重复的数据集合，它可以用于存储各种类型的元素，例如数字、字符串、列表等。

下面是集合的基本语法：

my_set = {1, 2, 3, 4, 'a', 'b', 'c'} #建了一个名为my_set的集合，包含三个元素：整数1、2、3和字符串'a'、'b'、'c'
1
'
运行
运行

集合的主要特点如下：

1. 无序性：集合中的元素没有固定的顺序，即集合中元素的顺序是不重要的。
2. 不可重复性：集合中的元素不能重复，即每个元素只能出现一次。
3. 元素唯一性：集合中的元素是唯一的，即集合中不存在重复的元素。
4. 可变性：集合是可变的，也就是说，我们可以添加、删除或更改集合中的元素。
5. 运算符限定符：集合支持一些运算符，如并集（Union）、交集（Intersection）、差集（Difference）和对称差集（Symmetric Difference）等。
6. 集合推导式：可以使用集合推导式创建新的集合。

以下是一些使用集合的例子：

# 创建一个集合  
my_set = {1, 2, 3, 'a', 'b', 'c'}  
  
# 访问集合的元素  
print(my_set)  # 输出：{1, 2, 3, 'a', 'b', 'c'}  
print(len(my_set))  # 输出：6  
  
# 添加元素到集合中  
my_set.add(4)  # 向集合中添加一个元素  
print(my_set)  # 输出：{1, 2, 3, 'a', 'b', 'c', 4}  
  
# 删除集合中的元素  
my_set.remove(1)  # 从集合中删除一个元素  
print(my_set)  # 输出：{2, 3, 'a', 'b', 'c', 4}  
  
# 检查元素是否在集合中  
print(3 in my_set)  # 输出：True  
print('a' in my_set)  # 输出：True  
print('d' in my_set)  # 输出：False  
  
# 集合运算  
set1 = {1, 2, 3}  
set2 = {3, 4, 5}  
print(set1 | set2)  # 输出：{1, 2, 3, 4, 5}  
print(set1 & set2)  # 输出：{3}  
print(set1 - set2)  # 输出：{1, 2}  
print(set1 ^ set2)  # 输出：{1, 2, 4, 5}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
'
运行
运行

集合还支持并集、交集、差集等数学运算。例如，可以使用union()方法来计算两个集合的并集，使用intersection()方法来计算两个集合的交集，使用difference()方法来计算两个集合的差集等。

5.字典（dictionary）

字典是一种内置的数据类型，它是一种关联数组（associative array），用于存储键值对（key-value pairs），是一个无序的键值对序列。字典由键和值组成，每个键对应一个值，键和值之间用冒号分隔，键值对之间用逗号分隔，整个字典包含在花括号{}中。

以下是创建和访问字典的基本语法：

my_dict = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}  #创建了一个名为my_dict的字典，包含三个键值对。
           
print(my_dict['name'])  # 输出：'Alice'
1
2
3
'
运行
运行

字典的主要特点如下：

1. 无序性：字典中的键值对是无序的，即键值对的顺序是不重要的。
2. 可变性和不可变性：字典是可变的，也就是说，我们可以添加、删除或更改字典中的键值对。但是，一旦一个键被分配了一个值，就不能更改该键关联的值，除非使用del语句删除该键值对并重新分配一个新值。
3. 键唯一性：字典中的键是唯一的，即每个键只能出现一次。但是，可以使用多个键关联同一个值。
4. 可包含不同类型的值：字典可以包含各种类型的值，包括数字、字符串、列表、元组、集合等。
5. 字典推导式：可以使用字典推导式创建新的字典。

以下是一些使用字典的例子：

# 创建一个字典  
my_dict = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}  
  
# 访问字典中的元素  
print(my_dict['name'])  # 输出：'Alice'  
print(my_dict['age'])  # 输出：25  
print(my_dict['city'])  # 输出：'Beijing'  
  
# 添加键值对到字典中  
my_dict['country'] = 'China'  
print(my_dict)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'Beijing', 'country': 'USA'}  
  
# 删除字典中的键值对  
del my_dict['age']  
print(my_dict)  # 输出：{'name': 'Alice', 'city': 'Beijing', 'country': 'China'}  
  
# 检查键是否在字典中存在  
print('age' in my_dict)  # 输出：False  
print('city' in my_dict)  # 输出：True  
  
# 遍历字典中的键和值  
for key, value in my_dict.items():  
    print(key, value)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
'
运行
运行

字典是无序的，即键值对的顺序没有固定的顺序。但是，字典是可变的，可以动态地添加、删除或更改键值对。