Python基础知识语法归纳总结（数据类型-2）

Python基础知识&语法归纳总结（数据类型）  

链接: Python基础知识&语法归纳总结（数据类型-1）
  连接上一篇文章，本篇文章接着为大家分析列表的数据结构，比如在列表中如何添加列表数据项、删除列表数据项、列表的排序、列表中再嵌套列表等等知识，希望能帮助到大家学习Python。
 

1、Python中的列表方法

  下面是列表中常见的方法：

• 1、append():在末尾追加一个元素，实例：

# 定义一个lists列表    
lists = ['Python', 'C++', 'Java']
# 在列表末尾添加一个列表数据项
lists.append('JavaScipt')
# 得到列表List的数据项
print(lists)

输出结果：
 
  [‘Python’, ‘C++’, ‘Java’, ‘JavaScipt’]

 

• 2、extend(iterable)：将可迭代对象（如列表、元组、字符串）的元素逐个添加到列表的末尾。参数：iterable指的是可迭代对象；

"""可迭代对象：逐个添加到列表末尾"""
aa = ['2', '5']
bb = ['1', '9']
aa.extend(bb)
aa.extend('Python')
print(aa)

运行结果：
[‘2’, ‘5’, ‘1’, ‘9’, ‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’]

• 3、insert(index, element)：在指定索引位置插入元素，原位置及后续元素右移；index：插入位置的索引；element：要插入的元素；

dd = ['Python', 'C++', 'Java']
dd.insert(3, 'C++')
# 索引超出范围时，插入末尾
dd.insert(9, 'C#')
dd.insert(0, 'JavaScript')
print(dd)

运行结果：
[‘JavaScript’, ‘Python’, ‘C++’, ‘Java’, ‘C++’, ‘C#’]

• 4、remove(element)：删除列表中第一个匹配的元素；element：要删除的元素；注意：若元素不存在，抛出ValueError。

ee = ['2', '56', '90', 'Python']
ee.remove('Python')
print(ee)
try:ee.remove('JavaScript')
except ValueError:print(f'列表中没有这个数据项！！')

运行结果：
[‘2’, ‘56’, ‘90’]
列表中没有这个数据项！！

• 5、pop([index])：删除并返回指定索引的元素（默认删除最后一个元素）；index：可选，默认-1；返回的值是被删除的元素；注意：索引越界时抛出IndexError。

"""删除并返回指定索引的元素"""
"""删除并返回指定索引的元素"""
ff = ['Python', 'C++', 'JavaScript']
cc = ff.pop(0)
print(cc)
try:dd = ff.pop(8)
except IndexError:print("列表中没得这个数据项！！")

运行结果：
Python
列表中没得这个数据项！！

• 6、clear()：清空列表，移除所有元素，返回值为None；

cc = ['1', '9', 'Python']
print(cc.clear())

输出结果：
None

• 7、index(element, start, end)：返回元素第一次出现的索引；element：要查找的元素；start和end（可选，指定搜索的范围）；返回的值是索引值（int）；注意：元素不存在时抛出ValueError。

"""返回元素第一次出现的位置，即索引"""
gg = ['Python', 'C++', 'JavaScript']
gg.append('Python')
gg.insert(7, 'C++')
print(gg.index('C++'))
print(gg.index('C++',2))

运行结果：
1
4

• 8、count(element)：统计元素在列表中出现的次数；element：要统计的元素，返回的值是次数（int）；

"""统计指定元素在列表中出现的次数"""
gg = ['Python', 'C++', 'JavaScript', 'C++', 'C#', 'C++']
print(gg.count('C++'))

运行结果：3

• 9、sort(key = None, reverse = False)：排序列表（默认升序）且是永久性的排序，reverse：排序规则，reverse = True表示降序，reverse = False表示升序（默认）；该方法没有返回值，但是会对这个列表内的数据项进行排序；

"""sort函数的使用"""
a = ['Python', 'C++', 'JavaScript', 'C++', 'C#', 'C++']
b = [2, 5, 10, 23, 4, 1, 6, 9, 21]
c = [1, 4, 'Python']
# 对列表a内的数据项进行排序
a.sort()
print(a)
# 对列表b内的元素进行排序
b.sort()
print(b)
# 对列表c进行排序
c.sort()
print(c)

运行结果：
[‘C#’, ‘C++’, ‘C++’, ‘C++’, ‘JavaScript’, ‘Python’]
[1, 2, 4, 5, 6, 9, 10, 21, 23]

• 10、reverse()反转列表元素的顺序，返回的值为None；

"""反正列表数据项"""
b = [2, 5, 10, 23, 4, 1, 6, 9, 21]
c = [1, 4, 'Python']
b.reverse()
c.reverse()
print(b)
print(c)

运行结果：
[21, 9, 6, 1, 4, 23, 10, 5, 2]
[‘Python’, 4, 1]

• 11、copy()：返回列表的浅拷贝，返回的值是一个新列表（列表数据项与原列表相同）；

解释浅拷贝：

1. 定义列表 a：

   a = ['C++', 'JavaScript', 'C', 'JavaScript', [2, 5, 23, 41]]
   

   这里创建了一个包含四个字符串和一个整数列表的列表 a。

2. 创建 b 作为 a 的浅拷贝：

   b = a.copy()
   

   使用 copy() 方法创建 b，使其成为 a 的浅拷贝。这意味着 b 包含与 a 相同的元素，但它们共享相同的嵌套列表引用。

3. 打印 a 和 b：

   print(a)
   print(b)
   

   此时，a 和 b 的输出会相同，因为它们的顶层元素相同，包括嵌套列表。

4. 修改 a 的第一个元素：

   a[0] = 99
   

   修改 a 的第一个字符串元素为 99。由于 b 是 a 的浅拷贝，修改 a 的元素不会直接影响 b。

5. 修改 a 的最后一个嵌套列表：

   a[4].append(100)
   

   嵌套列表 a[4] 被添加了元素 100。由于 b 中的 a[4] 引用的是同一个列表对象，因此 b[4] 也会包含 100。

6. 再次打印 a 和 b：

   print(a)
   print(b)
   

   打印后，a 和 b 都显示最后一个元素为 [2, 5, 23, 41, 100]，因为修改 a[4] 也影响了 b[4]。

总结：这段代码展示了列表赋值的浅拷贝行为，特别是当列表包含其他可变对象（如列表）时，修改原列表会影响所有共享的可变对象。

 
 

2、列表生成式

  在Python中，列表还可以通过一些特殊的字面量语法来创建，也就是【生成式】，它允许我们以简洁和高效的方式创建列表。下面的是一些列子来说明使用列表生成式，有啥好处；

2.1、生成平方数列表

传统方式：

# 定义一个空的列表
squares = []
for i in range(1,8):squares.append(i ** 2)
print(squares)                       # 输出：[1, 4, 9, 16, 25, 36, 49]

汉字解释：
 

• 定义一个空列表squares；
• 使用for循环来遍历这个左闭右开的整数序列；
• 最后使用函数append()来将这个运算结果i ** 2追加到列表squares中；

 
使用生成式：

# 使用生成式
squares = [i ** 2 for i in range(1, 8)]
print(squares)                       # 输出：[1, 4, 9, 16, 25, 36, 49]

汉字解释：
 

• 使用 for 循环遍历 range(1,8)（生成1到8的数字）；
• 对每个数字 i，计算其平方 i**2；
• 将所有平方结果存储在 squares 列表中；

 
对比：

• 列表生成式将传统for和append相结合，代码更加简洁；
• 列表生成式直接计算所有平方，而传统方式，需要每次迭代调用append；
• 列表生成式更高效，因为它利用了内置函数的优化；

 

2.2 生成奇数列表

传统方式：

# for循环和if的运用
a = []
for i in range(1, 8):if i % 2 != 0:a.append(i)
print(a)# 运行结果：[1, 3, 5, 7]

• 汉字解释：

---

1、初始化空列表：a = []创建一个空列表用于存储奇数；
2、遍历整数序列range(1, 8)：range(1, 8)生成[1, 2, 3, 4, 5, 6, 7]的整数序列；
3、条件判断if i % 2 != 0：如果等于零，则说明是偶数，不将i添加到空列表a中；
4、添加元素：符合条件的数通过append()方法加入列表a中；
5、输出列表a中的数据项：最终列表为[1, 3, 5, 7]；
 
 

列表生成式（更高效简洁）：

• 语法生成式：

[表达式 for 变量 in 可迭代对象 if 条件][expression for item in iterable if condition]

• 语法解释：
  1、expression ：表达式；
  2、item ：变量；
  3、iterable：可迭代对象；
  4、condition：条件；
• 代码呈现：

""" 列表生成式"""
a = [x for x in range(1, 8) if x % 2 != 0]
print(a)"""运行结果：[1, 3, 5, 7]"""

 

• 列表生成式汉字解释：
  1、在for循环后加if x % 2 != 0，自动过滤奇数；
  2、好处：逻辑相对而言，减少缩进层级；

 

2.3 嵌套循环（多层for）

  生成二维坐标列表的例子：
传统方式：

"""嵌套循环（多层for循环）"""
a = []
for i in range(1, 8):for j in range(1, 8):if (i + j) % 2 == 0:a.append((i, j))
print(a)"""运行结果：
[(1, 1), (1, 3), (1, 5), (1, 7), (2, 2), (2, 4), (2, 6), (3, 1),(3, 3), (3, 5), (3, 7), (4, 2), (4, 4), (4, 6), (5, 1), (5, 3), (5, 5), (5, 7), (6, 2), (6, 4), (6, 6), (7, 1), (7, 3), (7, 5), (7, 7)]
"""

1. 汉字解释：
   结构特点：显式的多层for循环，通过控制缩进控制层级，然后使用方法append()追加元素；
   核心步骤：
    （1）、初始化空列表a；
    （2）、外层循环遍历第一个可迭代对象；
    （3）、内存循环遍历第二个可迭代对象；
    （4）、条件判断后追加元素；

 
列表生成式：

"""列表生成式"""
a = [(i, j)for i in range(1, 8)for j in range(1, 8)if (i + j) % 2 == 0
]
print(a)"""运行结果：
[(1, 1), (1, 3), (1, 5), (1, 7), (2, 2), (2, 4), (2, 6), (3, 1),(3, 3), (3, 5), (3, 7), (4, 2), (4, 4), (4, 6), (5, 1), (5, 3), (5, 5), (5, 7), (6, 2), (6, 4), (6, 6), (7, 1), (7, 3), (7, 5), (7, 7)]
"""

• 汉字解释：
  结构特点：
  隐式嵌套，循环顺序与书写顺序一致（外层 ——> 内层），if条件直接过滤元素。
  核心语法：

[元素表达式
for 外层循环 in 外层可迭代对象
for 内层循环 in 内层可迭代对象
if 条件
]

• 性能与可读性对比：

特性	传统嵌套循环	列表生成式嵌套循环
代码长度	较长（需显式循环和追加）	极短（一行代码完成）
执行效率	较慢（每次循环调用append()）	较快（Python底层优化）
可读性	高（逻辑分步清晰）	中（需理解生成式结构）
调试难度	易调试（可逐行检查变量）	难调试（无法逐步跟踪）

 

• 列表生成式适用场景：
  1、简单数据生成：如生成矩阵、坐标、笛卡尔积等结构化的数据；
  2、快速过滤数据：结合条件语句筛选嵌套结构中的元素；
  3、代码简洁性优先的场景：需要快速实现且逻辑简单时使用；

 

• 传统嵌套循环适合：
  1、复杂逻辑处理：如需要中间变量、循环内外混合操作；

"""处理多层列表"""
b = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 将列表b中的元素，是偶数的挑选出来
# 定义一个空列表
c = []
for i in b:temp = []for j in i:if j % 2 == 0:temp.append(j)c.append(temp)
print(c)# 运行结果：[[2], [4, 6], [8]]

 
 2、调试要求高：需要逐步检查循环中的变量状态时；
 3、多层循环嵌套（3层以上）：生成式多层嵌套循环可读性差，传统循环更加清晰；

"""列表生成式：生成四维坐标"""
d = [(x, y, z, j)for x in range(1,3)for y in range(1,3)for z in range(1,3)for j in range(1,3)
]
print(d)"""传统方式"""
d = []
for x in range(1,3):for y in range(1,3):for z in range(1,3):for j in range(1,3):d.append((x, y, z, j))
print(d)# 由比较可知，传统方式更具可读性

• 输出完美的九九乘法表：

"""九九乘法表"""
# 传统方式
for i in range(1,10):for j in range(1, i+1):print(f"{j} * {i} = {i*j:2}", end = "  ")print()

**输出结果**：
1 * 1 =  1   
1 * 2 =  2   2 * 2 =  4   
1 * 3 =  3   2 * 3 =  6   3 * 3 =  9   
1 * 4 =  4   2 * 4 =  8   3 * 4 = 12   4 * 4 = 16   
1 * 5 =  5   2 * 5 = 10   3 * 5 = 15   4 * 5 = 20   5 * 5 = 25   
1 * 6 =  6   2 * 6 = 12   3 * 6 = 18   4 * 6 = 24   5 * 6 = 30   6 * 6 = 36   
1 * 7 =  7   2 * 7 = 14   3 * 7 = 21   4 * 7 = 28   5 * 7 = 35   6 * 7 = 42   7 * 7 = 49   
1 * 8 =  8   2 * 8 = 16   3 * 8 = 24   4 * 8 = 32   5 * 8 = 40   6 * 8 = 48   7 * 8 = 56   8 * 8 = 64   
1 * 9 =  9   2 * 9 = 18   3 * 9 = 27   4 * 9 = 36   5 * 9 = 45   6 * 9 = 54   7 * 9 = 63   8 * 9 = 72   9 * 9 = 81

1. 外层循环 (i)
   • for i in range(1, 10) 控制乘法表的行数
   • 变量i表示乘法表中的第二个乘数（即"*"号后面的数字）
   • 范围1-9对应乘法表的9行
2. 内层循环 (j)
   • for j in range(1, i + 1) 控制每行输出的列数
   • 变量j表示乘法表中的第一个乘数（即"×"号前面的数字）
   • 每行的列数等于当前行号（第1行1列，第2行2列…第9行9列）
3. 格式化输出
   • f"{j}*{i}={i*j:2}" 使用f-string格式化字符串
     • j×i= 显示乘法表达式
     • {i*j:2} 将乘积格式化为2位宽度，实现右对齐
   • end=" " 指定每个乘法式后跟两个空格（不换行）
4. 换行控制
   • print() 在内层循环结束后执行，实现每行输出后的换行

 
高级的写法：

"""高级的写法"""
for i in range(1, 10):# 列表生成式完成row = [f"{j} x {i} = {i*j:3}" for j in range(1, i + 1)]# 使用join来将每行的表达式用三个空格连接，确保末尾无多余的空格print("   ".join(row))

语法解释：
1、外层循环（i）：控制行数，从1到9；
2、内层循环（j）：控制每行的列数，从1到当前行号i；
3、列表生成式：生成每行的所有乘法表达式，格式为j * i = 结果，使其结果右对齐三位（i * j : 3）；
4、字符串拼接：使用join方法将每行的表达式用三个空格连接，确保对齐且无多余的空格；
5、打印输出：每生成一行立即打印，保持格式整齐；
 
 

3、列表的总结

  1、Python列表方法主要用于动态修改、查询和操作列表。掌握这些方法可以高效处理列表数据。注意区分原地操作（如 sort()）与非原地操作（如 sorted() 函数）;
  2、列表生成式与传统Python程序的写法对比，优缺点；

场景	传统方式	列表生成式	核心优势
基本遍历	for + append	[x for x in iterable]	代码更短，执行更快
条件过滤	for + if + append	[x for x in iterable if cond]	逻辑更清晰
嵌套循环	多层 for	[x for a in A for b in B]	减少嵌套，代码紧凑
字符串处理	for + append	[s.upper() for s in strings]	减少临时变量

 

  以上的内容，是本人自学Python，写的笔记，如有错误，请留言哦！！！本人会在第一时间及时更正。如果你觉得有用，请一键三连哦！！