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位值

    • 含义：

      字符串abcde
      索引01234
      第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

开源鸿蒙跨平台直播｜napigen 开源鸿蒙跨端实践：打通 Flutter 与 ArkTS

avatar AtomGit开源社区
cover

玩转 AtomCode！AtomGit「码动四季・开源同行」夏季征稿获奖名单出炉！

avatar AtomGit开源社区
cover

榜单出炉！AtomGit「源启盛夏」暑期开源成长计划正式收官

avatar AtomGit开源社区