Python AI开发（python篇）学习笔记 – 第四章 – 字符串与列表序列详解

第四章：字符串与列表序列

此文章是作者学习ai的完整笔记，在现在ai快速发展的时期，鼓励大家一起学习python！！！

目录

2.6 序列

2.6.1 什么是序列

由一系列字符组成的不可变序列，存储的是字符的编码值；Python的字符串类型为一种可迭代对象。

  • 线性结构；
  • 树形结构；
  • 图形结构等；

2.6.2 str字符串序列

1. 字符串拼接运算符
运算符 定义  对应重载方法
+ 字符串拼接  __add__​
* 重复拼接对应次数的字符串  __mul__​

📌字符串的 + 运算与数字类型对象的 + 运算不一样！

  • +使用方法

    • 含义：将若干个字符串对象拼接为一个新的字符串对象；

    • 使用方法：

      a = '123'
b = 'abc'
print(a+b) # 拼接两个字符串

       '123abc' # id值不相同为 新字符串

  • *使用方法

    • 含义：在当前字符串对象基础上拼接若干次该字符串；

    • 使用方法：

      a = '123'
print(a * 3) # 将字符串*3次，怕拼接为新的字符串

      'abcabcabcabcabc'# id值不相同为 新字符串
2. 字符串的成员运算符
运算符 定义 
in 判断某字符**是否存在于**该字符串，存在，返回**True **
not in 判断某字符**是否不存在于**该字符串，不存在，返回**True **

in或not in判断某字符是否存在于字符串序列中

  • 使用方法：

    li = "abc"
print("a" in a) # 判断"a"是否存在于li字符串序列中

    True # 是

  • 使用if判断：

    li = "abc"
if "d" in a:  # 使用if判断
    print("存在")
else：
    print("不存在")

    不存在
3. 字符串对象构造操作

将传入的任意合法类型的对象构造为一个字符串对象

 print(1+1)      # 默认为int类型，可以直接计算
 print(str(1) + str(1)) # # 将1转化为str类型相加

2
11
4.字符串的索引

  • **len()**计算序列的长度

    • 使用方法

      strs = 'abcde'
print(len(strs))# 统计字符串长度


      5 # 长度为5

  • 索引

    • 索引是序列类型对象中每一个存在的数据元素的唯一标识符；

    • 一个序列的数据元素的索引值总是从0开始计算，每个数据元素的索引值+1；

    • 使用方法：

      strs = 'abcdefg'
strs[0]  # 索引序列中的第0位



      a  # 输出strs的第0位值

    • 含义：

      字符串 a b c d e
      索引 0 1 2 3 4
      第0 位为"a"
5. 字符串的索引切片

  • 语法：

    字符串 [ 开始 : 结束 : 步长(可选) ]

  • 作用：

    从字符串中截取指定长度的字符串片段;

    步长：默认为1

  • 使用方法1：

    strs = "hello world"
print(strs[0:4])  # 截取第0到第4位内容

    hello

    📌所有序列第一位都是以0开始增序

  • 使用方法2：

     strs = "hello world"
 strs[:3]  # 结束为3，表示3前面所有


    hel

  • 使用方法3：

     strs = "hello world"
 strs[2::1]  # 以2开始，没有结尾，步长为1


    llo world

  • 使用方法4：

     strs = "hello world"
 strs[:]  # 所有


    hello world

  • 使用方法5(反向)：

     strs = "hello world"
 strs[::-1]  # 反向截取所有


    dlrow olleh

  • 使用方法6(索引修改)：

     strs = "hello world"
 strs[5] = "22222" # 替换列表的第5位为22222
 print(strs) 


    hello22222world
6. 字符串常用函数

  1. len():

    • 语法：

      results = len(str)

    • 作用：

      获取一个字符串的长度，即字符串对象中字符的个数；

    • 使用方法：

      strs = "ksnb" 
print(len(strs)) 


      4

  2. max()/min():

    • 语法：

      results = max(str)
results = min(str)

    • 作用：

      获取该字符串中值最大/最小的字符；

      • 如果是中文、英文、符号字符串，则依据unicode编码获取编码值最大/小的字符；
      • 如果是数值型字符串，则依据字符对应的整型数值对象字面值大小获得最大/小的字符；

    • 使用方法：

      strs = "ksnb" 
print(max(strs)) 


      s
7. 字符串的遍历

方式一： 直接遍历该字符串（可迭代对象）的字符对象：

strs = "hello world"
for i in strs:
    print(i)


h
e
l
l
o

w
o
r
l
d

方式二： 遍历该字符串（可迭代对象）的索引值：

strs = "hello world"
for i in range(len(strs)):  # 以字符串序列的长度为遍历次数
    print(strs[i])


h
e
l
l
o

w
o
r
l
d
常用方法​
方法  描述
string .count(str) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string .find(str)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如   果是返回开始的索引值，否则返回-1
string .islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，   则返回 True，否则返回 False
string .isdigit() 如果 string 只包含数字则返回 True 否则返回 False
string .isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，   则返回 True，否则返回 False
string .join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string .lower() 转换 string 中所有大写字符为小写
string .replace(str1, str2) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string .split(str=“”) 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
string .upper() 转换 string 中的小写字母为大写
string .lower() 转换 string 中的小写字母为小写

2.6.3 list 序列

1. 定义

一系列数据对象组成的可变序列，存储的是任意类型的对象；Python的列表类型为一种可迭代对象。

  • 语法

    # 1.定义空列表
list = [] 

    # 2.定义有元素列表
list = [n1,n2,n3,...]
2. 列表对象构造操作

  • 语法：

    # 将字符串转化为列表序列类型
l = list('12345')  
print(l)

    ["1" ,"2" ,"3" ,"4" ,"5"]

  • 2.1列表与字符串

    • 字符串**：因为字符串对象为不可变对象**
      解析**：对象一旦创建则无论对其做拼接、切片等操作时，结果均返回一个新的字符串**对象；
      即：结果对象所赋值的变量的** id 值与原字符串变量的 id值​不同**
    • 列表**：因为列表对象为可变对象**
      解析：对象创建完毕后允许对其内部结构做修改，且这个过程不会产生一个新的列表对象；
      **即：对象所赋值的变量的 **id 值不发生改变
3. 列表拼接运算符

  • 拼接运算符

    运算符​ 定义​
    + 列表拼接
    * 重复拼接对应次数的列表

    📌注意：列表的 + 运算是多个列表拼接

  • 拼接运算符

    **列表的+**运算符会构造一个新的列表对象

    📌不同对象的id值不同：id(对象)

    • 使用方法：

      li1 = [1, 2, 3]
li2 = [4, 5, 6]
print(li1 + li2)

      [1, 2, 3, 4, 5, 6]

      li1 = [1, 2, 3]
li2 = [4, 5, 6]
li3 = li1 + li2)   # 两个列表拼接
li4 = li3*3        # 拼接3次
print(li3)
print(li4)

      [1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
4. 列表的成员运算符
运算符 含义
in 判断某数据对象是否存在于该列表，存在，返回True 
not in 判断某数据对象是否不存在于该列表，不存在，返回True

  • 使用方法：

    li1 = [7, 8, 9]
print(8 in li1) # 判断8是否存在于li1列表中

    True  # 存在
5. 列表的索引

序列的长度是指该序列类型对象中数据**元素对象的个数**

li1 = [1, 2, 3, 4]
print(len(li1))

4

  • 列表的索引取值

    li1 = [1, 2, 3, 4]
value = li1[1]  # 索引li1列表的第1位
print(value)

    2
6. 列表的索引切片

  • 语法:

    列表[ 开始值 : 结束值 : 步长(可选)]

  • 返回值： 新的列表对象

  • 使用方法1：

    li1 = [1, 2, 3, 4, 5, 6, 7]
li2 = li1[0:4]  # 截取0～4位
print(li2)  


    [1, 2, 3, 4]  # 输出新列表

  • 使用方法2：

    li1 = [1, 2, 3, 4, 5, 6, 7]
print(li1[5:])  # 截取第5位开始后面所有值

    [6, 7]  # 输出新列表

  • 使用方法3：

    li1 = [1, 2, 3, 4, 5, 6, 7]
print(li1[:])  # 截取所有

    [1, 2, 3, 4, 5, 6, 7]

  • 使用方法4：

    li1 = [1, 2, 3, 4, 5, 6, 7]
print(li1[::-1])  # 取反

    [7, 8, 6, 5, 4, 3, 2, 1]

  • 使用方法5**(索引修改)****：** ​

    li1 = [1, 2, 3, 4, 5, 6, 7]
li1[2] = 80  # 将第2位的元素替换为80
print(li1)

    [1, 2, 80, 4, 5, 6, 7]

  • max()/min()函数

    # 提取最大值
li1 = [2, 50, 152, 7]
print(max(li1))

    152

    # 提取最小值
li1 = [2, 50, 152, 7]
print(min(li1))

    2
7. 列表的遍历

方式一： 直接遍历该列表（可迭代对象）的数据对象：

li1 = [1, 2, 3, 4, 5]
for i in li1:
    print(i)


1
2
3
4
5

方式二： 遍历该列表（可迭代对象）的索引值：

li1 = [1, 2, 3, 4, 5]
for i in range(len(li1)):  # 以字符串序列的长度为遍历次数
    print(li1[i])


1
2
3
4
5
8. 列表对象常用方法

  • list.append(obj):

    • 作用：向列表的末尾添加一个新的数据对象；

    • obj： 添加的元素

    • 使用方法：

      li1 = ["hello", 20, True, 50]
print(li1)
li1.append("BMW")  # 添加BWN字符串
print(li1)

      ["hello", 20, True, 50]
["hello", 20, True, 50, "BMW"]

  • list.count(obj):

    • 作用：统计某个元素在列表中出现的次数；

    • obj： 需要计数元素

    • 使用方法：

      li1 = [20, 30, 20, 20, 30 ,50, 40]
print(f"20的个数：{li1.count(20)} 个")
print(f"30的个数：{li1.count(30)} 个")
print(f"40的个数：{li1.count(40)} 个")
print(f"50的个数：{li1.count(50)} 个")


      20的个数：3 个
30的个数：2 个
40的个数：1 个
50的个数：1 个

  • list.index(obj):

    • 作用：返回某个数据对象的第一个匹配结果的索引值；

    • obj： 需要返回的元素

    • 返回值：该数据对象的第一个匹配结果的索引值，int类型；

    • 使用方法：

      li1 = [20, 30, 20, 20, 30 ,50, 40]
# 该元素在序列中第一次出现的位置的索引值
print(f"元素“30”的第一个索引位置是：{lis1.index(30)}")

      元素“30”的第一个索引位置是：1
# 列表中第1位是30这个元素在列表中第一次出现的位置

  • list.insert(index,obj):

    • 作用：返回某个数据对象的第一个匹配结果的索引值；

    • index：索引位，即要插入到哪里，int类型；

    • obj：需要插入的数据对象

    • 使用方法：

      li1 = ["hello", 20, 30, 50]
# 将li1的第2位后面插入元素“world”
li1.insert(2, "world")
print(li1)

      ["hello", 20, "world", 30, 50]

  • list.pop([index=-1]):

    • 作用：移除列表中某个数据对象，默认移除最后一位

      📌在数据结构与算法的概念中，该方法对应：栈结构的末尾出栈操作；

    • index：可选，索引位，默认为 -1 ，int类型 ;

    • -1：默认删除列表最后一位元素

    • 返回： 返回删除的元素

    • 使用方法：

      li1 = ["hello", 20, 30, 50]
li1.pop(2)  # 删除第2位元素
print(li1)

      ["hello", 20, 50]  # 删除30

  • list.remove(obj):

    • 作用：移除列表中某个数据对象的第一个匹配结果；

    • obj： 列表内需要删除的元素

    • 使用方法：

      li1 = ["hello", 20, 30, 50, 30]
# 删除li1中的30元素，仅删除第一次出现的地方的元素
li1.remove(30)
print(li1)li1 = ["hello", 20, 30, 50]
li1.(30)  # 删除第2位元素
print(li1)

      ["hello", 20, 50, 30]

      📌remove没有返回值，pop有返回值

    • 即:

      • pop:

        # pop
li1 = ["hello", 20, 30, 50]
# 变量 v 可以获取pop删除的返回值
v = li1.pop(2)  # 删除li1[2]元素
print(li1)
print(f"删除了：{v}")

        ["hello", 20, 50]
删除了：20

      • remove:

        # remove
li1 = ["hello", 20, 30, 50]
v = li1.remove(20)  # 删除元素20
print(li1)
print(f"删除了：{v}")

        ["hello", 30, 50]
删除了：None  # remove执行后没有返回值，为空

  • list.reverse():

    • 作用：将列表中的数据对象进行反序；

    • 使用方法：

      li1 = ["hello", 20, 30, 50, 30]
li1.reverse()
print(li1)
li1.(30)  # 删除第2位元素
print(li1)

      [30, 50, 30, 20, "hello"]

  • list.sort([reverse=False]):

    • 作用：将列表中的数据对象进行排序，默认为升序排序；

    • reverse： 可选，是否降序排序，默认为 False ，代表升序排序；

    • 使用方法：

      li1 = [30, 20, 30, 50, 30]
li1.sort(True)  # 降序
print(li1)
li1.(30)  # 删除第2位元素
print(li1)

      [50, 30, 30, 20]
9. 列表推导式

  • 语法：

    # 简化列表对象构造过程
lists = [关于 循环变量 的表达式 for 循环变量 in 可迭代对象 [if 过滤条件]]

  • 使用方法：

    # 2 ** i为每次循环执行的表达式
# for i in range(1,5) 遍历次数
# 解析：生成偶数数列
l1 = [2 ** i for i in range(1,5)]

     [2, 4, 8, 16]

    # 2 ** 3为每次循环执行的表达式
# for i in range(5) 遍历次数
# 解析：生成2 ** 3数列
l1 = [2 ** 3 for i in range(5)]

     [8, 8, 8, 8, 8]

  • 列表推导式的嵌套：

    lists = [关于 循环变量1&循环变量2 的表达式 for 循环变量1 in 可迭代对象1 for 循环变量2 in 可迭代对象2]

  • 使用方法：

    l = [x ** y for x in range(1,5) for y in range(1,5)]
print(l)


    [1, 1, 1, 1, 2, 4, 8, 16, 3, 9, 27, 81, 4, 16, 64, 256]

-进阶用法-

  • 推导式嵌套

    # 生成三个（1，10）的列表
li = [[x for x in range(1,10)] for i in range(3)]
print(li)


    [[1, 2, 3, 4, 5, 6, 7, 8, 9],
 [1, 2, 3, 4, 5, 6, 7, 8, 9],
 [1, 2, 3, 4, 5, 6, 7, 8, 9]]

  • 序列解包

    # 生成三个（1，6）的列表
li = [[x for x in range(1,6)] for i in range(3)]
print(li)
# 遍历li序列的二层列表每一位元素
for x,y,z,m,n in li:
    print(x,y,z,m,n)


    [[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5]]
# 遍历二层列表每一位元素
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
    • x = 1
    • y = 2
    • z = 3
    • m = 4
    • n = 5
      这种写法在处理结构化数据时非常清晰，比如：
    • 二维坐标点：for x, y in points:
    • 键值对列表：for key, value in dict_items:
    • 多维数组的固定列数：for name, age, city in table_rows:

  • **zip**枚举

    将多个可迭代对象（如列表、元组、字符串）中相同索引位置的元素打包成一个个元组，然后返回一个迭代器。

    使用1： 并行组合

    li1 = [1, 2, 3]
li2 = [4, 5, 6]

for x,y in zip(li1,li2)
    print(x,y)


    1 4
2 5
3 6

    使用2： 并行运算

    a = [1, 2, 3]
b = [4, 5, 6]

result = [x + y for x, y in zip(a, b)]
print(result) 


    [5, 7, 9]

    使用3： 元组组合

    names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]

zipped = zip(names, scores)
print(list(zipped))


    [('Alice', 85), ('Bob', 92), ('Charlie', 78)]

    使用4： 格式化字符串拼接

    names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]

info = [f"{name} is {age} years old." for name, age in zip(names, ages)]
print(info)


    ['Alice is 25 years old.', 'Bob is 30 years old.', 'Charlie is 35 years old.']

    使用5： 条件筛选

    a = [10, 3, 8, 1]
b = [5, 6, 8, 2]

larger_a = [x for x, y in zip(a, b) if x > y]
print(larger_a) 


    [10]

  • enumerate用法

    它专门用于在遍历可迭代对象（如列表、元组、字符串）时，同时获取元素及其对应的索引（计数），从而避免手动维护计数器变量。

    它返回一个 enumerate 对象，该对象是一个迭代器，每次迭代产生一个 (index, item) 的元组。

    • 案例1：返回索引值和元素

      fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")


       0: apple
1: banana
2: cherry

    • 案例2： 自定义起始序号

      fruits = ["apple", "banana", "cherry"]

for idx, fruit in enumerate(fruits, start=1):
    print(f"{idx}. {fruit}")


      1. apple
2. banana
3. cherry

    • 案例3： 快速构建带编号的标签

      items = ["A", "B", "C"]
labeled = [f"{i}: {v}" for i, v in enumerate(items, 1)]
print(labeled)  

      ['1: A', '2: B', '3: C']

  • 场景一： 处理多行文本，输出行号

    text = """Hello
World
Python"""

for line_no, line in enumerate(text.splitlines(), 1):
    print(f"{line_no:03d}: {line}")


    001: Hello
002: World
003: Python

  • 场景二： 循环中需要知道位置

    numbers = [2, 4, 6, 8]
for i, num in enumerate(numbers):
    if num % 4 == 0:
        print(f"Found multiple of 4 at index {i}: {num}")
        numbers[i] = num * 10  # 直接通过索引修改

print(numbers)


    [2, 40, 6, 80]

  • 场景三： 同时遍历多个列表并记录步数

    names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]

for i, (name, score) in enumerate(zip(names, scores), 1):
    print(f"Rank {i}: {name} scored {score}")


    Rank 1: Alice scored 85
Rank 2: Bob scored 92
Rank 3: Charlie scored 78
# python # 学习 # 人工智能 # 考研 # 改行学it # 学习方法
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

AtomGit 首发开源｜光轮智能发布全球首个十万小时级全模态人类行为开源数据集 EgoSuite-Open100K

avatar AtomGit开源社区
cover

CANN 开发者 Meetup 南京站圆满落幕：轻量开发专场，硬核技术面对面

avatar AtomGit开源社区
cover

AtomCode 全新上线万亿代码模型 LongCat-2.0。限时 7 天免费体验！

avatar AtomGit开源社区