深入探索Python数据容器：绚丽字符串、神奇序列切片与魔幻集合奇遇

￡神魔★判官ぃ 2024-03-23 19:04 16阅读 0赞

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

### 1.1 字符串初识 ###

*  字符串也是数据容器的一员，字符串是一种数据容器，用于存储和处理文本数据。
 *  字符串是字符的容器，一个字符串可以存放任意数量的字符，可以包含字母、数字、标点符号、空格等字符。
 *  在Python中，字符串被表示为引号（单引号或双引号）括起来的文本。  
    ![在这里插入图片描述][39a72d93565a40648a8349b04da19896.png]  
    字符串也可以通过下标进行访问
 *  从前向后，下标从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 字符串常用方法 ###

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

--------------------

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

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 认识序列和切片 ###

*  序列是指：**内容连续、有序，可使用下标索引的一类数据容器**。**列表、元组、字符串，均可以可以视为序列**。  
    ![在这里插入图片描述][2711850fedcf41f59e5a219be109059c.png]
 *  切片是一种**用于从序列中获取子序列的操作，它可以轻松地获取序列的一部分，而不必修改原始序列**。切片使用索引来指定子序列的起始和结束位置。
 *  **序列支持切片，即：列表、元组、字符串，均支持进行切片操作**

### 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}

1.  使用 `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 集合常用操作 ###

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

以下是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()

[39a72d93565a40648a8349b04da19896.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c308782a782e47518d2541d89260d9bc.png
[2711850fedcf41f59e5a219be109059c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/52d8c0b31ec54dd0ba92f5c0ea1aba28.png