一 数据容器：str(字符串)

1.1 字符串初识

• 字符串也是数据容器的一员，字符串是一种数据容器，用于存储和处理文本数据。
• 字符串是字符的容器，一个字符串可以存放任意数量的字符，可以包含字母、数字、标点符号、空格等字符。
• 在Python中，字符串被表示为引号（单引号或双引号）括起来的文本。
  
  字符串也可以通过下标进行访问
• 从前向后，下标从0开始
• 从后向前，下标从-1开始

my_str = "itheima and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素，。值是：{value},取下标为-16的元素。值是：{value2}")

• 同元组一样，字符串是一个：无法修改的数据容器。 所以，以下的操作均无法完成，如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改。
  • 修改指定下标的字符 （如：字符串[0] = “a”）
  • 移除特定下标的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）
  • 追加字符等 （如：字符串.append()）

1.2 字符串常用操作

1. 字符串创建：可以使用单引号或双引号创建字符串

   single_quoted_str = 'Hello, I am a single-quoted string.'
   double_quoted_str = "Hello, I am a double-quoted string."
   

2. 多行字符串：需要创建跨越多行的字符串，可以使用三引号（三个连续的单引号或双引号）

   multi_line_str = '''This is a multi-line
   string created using triple quotes.'''
   

3. 字符串拼接：通过加号运算符将多个字符串连接在一起

   str1 = "Hello, "
   str2 = "world!"
   combined_str = str1 + str2
   print(combined_str)  # Output: "Hello, world!"
   

4. 字符串格式化：

   • Python中的字符串格式化可以使用format方法或f-strings（从Python 3.6开始）：

   name = "John"
   age = 30
   formatted_str = "My name is {} and I am {} years old.".format(name, age)
   print(formatted_str)  # Output: "My name is John and I am 30 years old."# 使用 f-strings
   formatted_str_fstring = f"My name is {name} and I am {age} years old."
   print(formatted_str_fstring)  # Output: "My name is John and I am 30 years old."
   

5. 字符串索引和切片：

   • 字符串中的每个字符都有一个索引，可以使用索引来访问单个字符。索引是从0开始的整数。还可以使用切片来获取字符串的子串

   my_str = "Hello, world!"
   print(my_str[0])     # Output: "H"
   print(my_str[7:])    # Output: "world!"
   print(my_str[:5])    # Output: "Hello"
   

1.3 字符串常用方法

方法	描述	示例
len(str)	返回字符串的长度（字符数）	len("Hello, world!") -> 13
str.lower()	将字符串中的所有字母转换为小写形式	"Hello, World!".lower() -> “hello, world!”
str.upper()	将字符串中的所有字母转换为大写形式	"Hello, World!".upper() -> “HELLO, WORLD!”
str.strip()	去除字符串两边的空格（或指定的字符）	" Hello, world! ".strip() -> “Hello, world!”
str.split(sep)	将字符串按照指定的分隔符拆分成一个列表	"apple,banana,orange".split(",") -> [‘apple’, ‘banana’, ‘orange’]
str.join(iterable)	将一个字符串列表（或可迭代对象）连接成一个字符串，使用当前字符串作为连接符	",".join(['apple', 'banana', 'orange']) -> “apple,banana,orange”
str.replace(old, new)	替换字符串中的指定子串	"Hello, world!".replace("world", "Python") -> “Hello, Python!”
str.startswith(prefix)	检查字符串是否以指定的子串开头	"Hello, world!".startswith("Hello") -> True
str.endswith(suffix)	检查字符串是否以指定的子串结尾	"Hello, world!".endswith("world!") -> True
str.find(sub)	查找子串在字符串中的索引位置	"Hello, world!".find("world") -> 7
str.index(sub)	查找子串在字符串中的索引位置	"Hello, world!".index("world") -> 7
str.count(sub)	统计子串在字符串中出现的次数	"abracadabra".count("a") -> 5

---

• 字符串常用的内置字符串方法演示

1. len(): 获取字符串的长度（字符数）。

   my_str = "Hello, world!"
   print(len(my_str))  # Output: 13
   

   • 数字（1、2、3…）、字母（abcd、ABCD等）、符号（空格、!、@、#、$等）、中文均算作1个字符

2. str.lower(): 将字符串中的所有字母转换为小写形式。

   my_str = "Hello, World!"
   print(my_str.lower())  # Output: "hello, world!"
   

3. str.upper(): 将字符串中的所有字母转换为大写形式。

   my_str = "Hello, World!"
   print(my_str.upper())  # Output: "HELLO, WORLD!"
   

4. str.strip(): 去除字符串两边的空格（或指定的字符）。

   my_str = "   Hello, world!   "
   print(my_str.strip())  # Output: "Hello, world!"
   

   my_str = "12Hello and world21"
   new_my_str = my_str.strip("12")
   print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")
   # 字符串12itheima and itcast21被strip('12')后，结果：hello and world
   

   • 使用 strip() 方法来移除字符串开头和结尾的字符。传入了参数 “12” 给 strip() 方法，这意味着它会移除字符串开头和结尾处的所有 “1” 和 “2”。

5. str.split(): 将字符串按照指定的分隔符拆分成一个列表。

   my_str = "apple,banana,orange"
   fruits_list = my_str.split(",")
   print(fruits_list)  # Output: ['apple', 'banana', 'orange']
   

6. str.join(): 将一个字符串列表（或可迭代对象）连接成一个字符串，使用当前字符串作为连接符。

   fruits_list = ['apple', 'banana', 'orange']
   my_str = ",".join(fruits_list)
   print(my_str)  # Output: "apple,banana,orange"
   

7. str.replace(): 替换字符串中的指定子串。

   my_str = "Hello, world!"
   new_str = my_str.replace("world", "Python")
   print(new_str)  # Output: "Hello, Python!"
   

8. str.startswith(), str.endswith(): 检查字符串是否以指定的子串开头或结尾。

   my_str = "Hello, world!"
   print(my_str.startswith("Hello"))  # Output: True
   print(my_str.endswith("world!"))   # Output: True
   

9. str.find(), str.index(): 查找子串在字符串中的索引位置。

   my_str = "Hello, world!"
   print(my_str.find("world"))   # Output: 7
   print(my_str.index("world"))  # Output: 7
   

10. str.count(): 统计子串在字符串中出现的次数。

    my_str = "abracadabra"
    print(my_str.count("a"))  # Output: 5
    

• 字符串类型在Python中是不可变的，这意味着字符串的值一旦创建就不能更改。因此，许多字符串方法都返回新的字符串副本，而不会改变原始字符串。

• 字符串是Python中非常重要且常用的数据容器，它们用于处理文本和字符数据，并且有许多内置方法和操作可以使得字符串的处理更加灵活和便捷。

1.4 字符串的特点

作为数据容器，字符串有如下特点：

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下标索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等）
• 支持for循环

基本和列表、元组相同

• 不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。
• 不同于列表，相同于元组的在于：字符串不可修改

二 数据容器(序列)的切片

2.1 认识序列和切片

• 序列是指：内容连续、有序，可使用下标索引的一类数据容器。列表、元组、字符串，均可以可以视为序列。
  

• 切片是一种用于从序列中获取子序列的操作，它可以轻松地获取序列的一部分，而不必修改原始序列。切片使用索引来指定子序列的起始和结束位置。

• 序列支持切片，即：列表、元组、字符串，均支持进行切片操作

2.2 切片语法

• 切片的语法如下：

  sequence[start:stop:step]
  

  • start：切片的起始位置（包含该位置的元素）。如果省略，则默认从序列的开头开始。
  • stop：切片的结束位置（不包含该位置的元素）。如果省略，则默认到序列的末尾结束。
  • step：切片的步长（可选参数）。它表示每隔多少个元素取一个元素。默认为1，表示每个元素都取。为负数表示反向取（注意，起始下标和结束下标也要反向标记）

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]      # 步长默认是1，所以可以省略不写
print(f"结果1：{my_list}")
print(f"结果1：{result1}")

• 切片操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

---

2.3 切片演示

以下是一些切片的示例：

1. 使用切片获取列表的子列表：

   my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
   sub_list = my_list[2:6]  # 从索引2开始到索引6（不包含6）
   print(sub_list)  # Output: [3, 4, 5, 6]
   

2. 使用切片获取元组的子元组：

   my_tuple = (10, 20, 30, 40, 50)
   sub_tuple = my_tuple[1:4]  # 从索引1开始到索引4（不包含4）
   print(sub_tuple)  # Output: (20, 30, 40)
   

   # 对tuple进行切片，从头开始，到最后结束，步长1
   my_tuple = (0, 1, 2, 3, 4, 5, 6)
   result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
   print(result2) # (0, 1, 2, 3, 4, 5, 6)
   

3. 使用切片获取字符串的子字符串：

   my_str = "Hello, world!"
   sub_str = my_str[7:]  # 从索引7开始到末尾
   print(sub_str)  # Output: "world!"
   

4. 使用切片来进行反转操作：

   my_list = [1, 2, 3, 4, 5]
   reversed_list = my_list[::-1]  # 从末尾到开头，每次取一个元素
   print(reversed_list)  # Output: [5, 4, 3, 2, 1]
   

   # 对str进行切片，从头开始，到最后结束，步长-1
   my_str = "01234567"
   result4 = my_str[::-1]       
   print(result4) # 76543210
   

5. 使用切片和步长来间隔地获取元素：

   my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
   step_list = my_list[::2]  # 从开头到末尾，每隔一个元素取一个
   print(step_list)  # Output: [1, 3, 5, 7, 9]
   

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}") # [3, 2]# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}") # (6, 4, 2, 0)

• 切片是Python中非常强大和实用的功能，它允许您以一种简洁的方式获取序列中的子序列，并支持许多灵活的用法。

三 数据容器：set(集合)

3.1 集合的定义格式

• 在Python中，集合（Set）是一种无序、不重复的数据容器，用于存储一组唯一的元素。集合中的元素必须是不可变类型，例如数字、字符串、元组等。集合不支持索引和切片，因为其元素没有固定的顺序。

• 集合使用花括号 {} 来定义，或者使用 set() 函数来创建一个空集合。如果在花括号中包含一些元素，那么就会创建一个包含这些元素的集合。

以下是几种创建集合的定义格式：

1. 使用花括号 {} 定义集合：

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

2. 使用 set() 函数定义集合：

   my_set = set([1, 2, 3, 4, 5])
   

• 注意，如果使用空的花括号 {} 创建一个对象，Python会将其解释为一个空的字典而不是一个空的集合。因此，要创建一个空集合，必须使用 set() 函数。
• 使用 set() 函数创建空集合：

  empty_set = set()
  

• 需要注意的是，由于集合是无序的，每次打印集合时，元素的顺序可能不同。因为集合中元素的位置不重要，只要确保其中的元素是唯一的。

3.2 集合的特点

Python集合有以下几个主要特点：

1. 唯一性：集合中的元素是唯一的，不允许重复。如果尝试将重复的元素添加到集合中，它们将被忽略。

2. 无序性：集合中的元素没有固定的顺序，因此不能通过索引访问或切片操作来获取元素。这是因为集合内部使用哈希表实现，而哈希表是无序的数据结构。

3. 可变性：集合是可变的，可以添加、删除元素。可以使用add()方法向集合中添加元素，使用remove()或discard()方法删除元素。

4. 不支持索引和切片：由于集合是无序的，因此不能通过索引或切片来访问集合中的元素。

5. 支持数学集合操作：集合支持并集、交集、差集等数学集合操作。可以使用相应的方法如union()（并集）、intersection()（交集）、difference()（差集）来执行这些操作。

6. 可用于去重：由于集合中的元素是唯一的，可以使用集合来对序列中的元素进行去重操作。

7. 使用花括号 {} 或 set() 函数来定义：集合可以使用花括号 {} 来定义，或者使用set()函数来创建。当使用花括号创建集合时，注意不要与字典的花括号混淆，因为它们的格式相同。

例如，下面是一些使用集合的示例：

# 定义集合
my_set = {1, 2, 3, 4, 5}# 添加元素
my_set.add(6)# 删除元素
my_set.remove(3)# 并集操作
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)  # 结果为 {1, 2, 3, 4, 5}# 交集操作
intersection_set = set1.intersection(set2)  # 结果为 {3}# 差集操作
difference_set = set1.difference(set2)  # 结果为 {1, 2}

• 总之，Python集合是一个非常有用的数据结构，特别适用于需要存储唯一元素或执行集合操作的情况。

3.3 集合常用操作

操作	描述	示例
创建集合	使用花括号 {} 或 set() 函数来创建集合	my_set = {1, 2, 3} another_set = set([4, 5, 6])
添加元素	使用 add() 方法向集合中添加元素	my_set = {1, 2, 3} my_set.add(4)
删除元素	使用 remove() 或 discard() 方法从集合中删除元素	my_set = {1, 2, 3} my_set.remove(2) my_set.discard(4)
随机移除并返回元素	使用pop()方法从集合中移除并返回元素	my_set={1,2,3} my_set.pop()
并集	使用 union() 方法或 `	` 操作符求两个集合的并集
交集	使用 intersection() 方法或 & 操作符求两个集合的交集	set1 = {1, 2, 3} set2 = {3, 4, 5} intersection_set = set1.intersection(set2) # 或者 intersection_set = set1 & set2
差集	使用 difference() 方法或 - 操作符求两个集合的差集	set1 = {1, 2, 3} set2 = {3, 4, 5} difference_set = set1.difference(set2) # 或者 difference_set = set1 - set2
对称差集	使用 symmetric_difference() 方法或 ^ 操作符求两个集合的对称差集	set1 = {1, 2, 3} set2 = {3, 4, 5} symmetric_difference_set = set1.symmetric_difference(set2) # 或者 symmetric_difference_set = set1 ^ set2
判断子集和超集	使用 issubset() 方法或 <= 操作符判断一个集合是否是另一个集合的子集	set1 = {1, 2} set2 = {1, 2, 3, 4} is_subset = set1.issubset(set2) # 或者 is_subset = set1 <= set2
	使用 issuperset() 方法或 >= 操作符判断一个集合是否是另一个集合的超集	set1 = {1, 2} set2 = {1, 2, 3, 4} is_superset = set2.issuperset(set1) # 或者 is_superset = set2 >= set1
长度和清空集合	使用 len() 函数获取集合的长度（元素个数）	my_set = {1, 2, 3, 4} length = len(my_set)
	使用 clear() 方法清空集合中的所有元素	my_set = {1, 2, 3, 4} my_set.clear()

以下是Python集合的一些常见操作演示：

1. 创建集合：使用花括号 {} 或 set() 函数来创建集合。

   my_set = {1, 2, 3}
   another_set = set([4, 5, 6])
   

2. 添加元素：使用add()方法向集合中添加元素。

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

3. 删除元素：

   • 使用remove()或discard()方法从集合中删除元素。
   • remove()方法在元素不存在时会引发KeyError异常，而discard()方法则不会。

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

4. 随机移除并返回元素

   • 集合的 pop() 方法用于移除并返回集合中的一个任意元素。由于集合是无序的，因此无法确定哪个元素会被移除，因此 pop() 方法返回的元素是不确定的。

   my_set = {1, 2, 3, 4, 5}
   removed_element = my_set.pop()  # 移除并返回集合中的一个任意元素
   print(removed_element)  # Output: 1 或 2 或 3 或 4 或 5（不确定哪个元素被移除）
   print(my_set)           # Output: 剩下的元素（可能为 {2, 3, 4, 5} 等）
   

   • 注意：当集合为空时，调用 pop() 方法会引发 KeyError 异常，因为集合中没有元素可以被移除。在使用 pop() 方法前，请确保集合不为空或添加异常处理机制来处理空集合的情况。

5. 集合运算：

   • 并集：使用union()方法或|操作符求两个集合的并集。
   • 交集：使用intersection()方法或&操作符求两个集合的交集。
   • 差集：使用difference()方法或-操作符求两个集合的差集。
   • 对称差集：使用symmetric_difference()方法或^操作符求两个集合的对称差集。

   set1 = {1, 2, 3}
   set2 = {3, 4, 5}
   union_set = set1.union(set2)            # 或者 union_set = set1 | set2
   intersection_set = set1.intersection(set2)  # 或者 intersection_set = set1 & set2
   difference_set = set1.difference(set2)  # 或者 difference_set = set1 - set2
   symmetric_difference_set = set1.symmetric_difference(set2)  # 或者 symmetric_difference_set = set1 ^ set2
   

6. 判断子集和超集：

   • 使用issubset()方法或<=操作符判断一个集合是否是另一个集合的子集。
   • 使用issuperset()方法或>=操作符判断一个集合是否是另一个集合的超集。

   set1 = {1, 2}
   set2 = {1, 2, 3, 4}
   is_subset = set1.issubset(set2)      # 或者 is_subset = set1 <= set2
   is_superset = set2.issuperset(set1)  # 或者 is_superset = set2 >= set1
   

7. 长度和清空集合：

   • 使用len()函数获取集合的长度（元素个数）。使用clear()方法清空集合中的所有元素。

   my_set = {1, 2, 3, 4}
   length = len(my_set)
   my_set.clear()