【Python】入门到放弃之第七章《列表》

已于 2024-08-15 01:17:51 修改
阅读量1.1k 收藏 16
点赞数 36
分类专栏： Python 文章标签： python windows 网络
于 2024-08-14 21:07:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MP13537560060/article/details/141197713
版权

上一篇：【Python】入门到放弃之第六章《字符串》
下一篇：【Python】入门到放弃之第八章《元组》

文章目录

前言

这是本系列的第七章节内容，《列表》。

一、定义

  • “列表”（List）是计算机科学和数据结构中常用的一个概念，它用于存储一系列的元素，这些元素可以是数字、字符、字符串、对象等，并且这些元素之间是有序的，即它们按照插入的顺序排列。不同的编程语言提供了不同的实现方式和语法来创建和操作列表。
  • 在Python中，列表是一种内置的数据类型，用方括号[]表示。

二、创建列表

1.[ ] 创建

  • 使用一对空的方括号[]来创建一个空列表。
  • 在方括号内，使用逗号（,）分隔的元素来创建一个包含这些元素的列表。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5]  # 包含整数的列表  
mixed_list = [1, 'a', 3.14]  # 包含不同类型元素的列表  
nested_list = [[1, 2], [3, 4], [5, 6]]  # 嵌套列表

2.列表推导式创建

  • 列表推导式提供了一种更简洁的方式来创建列表，特别是根据现有列表或其他可迭代对象生成新列表。

代码如下（示例）：

# 创建一个包含0到9的平方的列表  
squares = [x**2 for x in range(10)]  
print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]  
  
# 创建一个包含0到9之间偶数的列表  
evens = [x for x in range(10) if x % 2 == 0]  
print(evens)  # 输出: [0, 2, 4, 6, 8]

3.list() 函数创建

  • 虽然 list() 函数通常用于将其他可迭代对象（如元组、字符串、集合等）转换为列表，但也可以通过传递一个空的迭代器给它来创建一个空列表。

代码如下（示例）：

# 创建一个空列表
another_empty_list = list()

# 实际上，这更多用于将其他可迭代对象转换为列表
tuple_to_list = list((1, 2, 3))
print(tuple_to_list)  # 输出: [1, 2, 3]

string_to_list = list("hello")
print(string_to_list)  # 输出: ['h', 'e', 'l', 'l', 'o']

三、访问列表元素

  • 列表的元素索引号从零开始，如果尝试访问的索引超出了列表的范围，Python将抛出一个IndexError异常。
  • 负索引用于从列表的末尾开始计数。例如，-1表示最后一个元素，-2表示倒数第二个元素，依此类推。

1.访问单个元素

  • 通过指定索引来访问列表中的单个元素。

代码如下（示例）：

my_list = [1, 2, 3, 'a', 'b', 'c']  
  
# 访问索引为0的元素  
print(my_list[0])  # 输出: 1  
  
# 访问索引为3的元素  
print(my_list[3])  # 输出: a

2.访问多个元素（切片）

  • 使用切片（Slicing）来访问列表中的一段元素，即过指定起始索引和结束索引（不包括结束索引）来完成。

代码如下（示例）：

# 访问索引从1到4（不包括4）的元素  
print(my_list[1:4])  # 输出: [2, 3, 'a']  
  
# 如果省略起始索引，则默认为0  
print(my_list[:3])  # 输出: [1, 2, 3]  
  
# 如果省略结束索引，则默认为列表的长度  
print(my_list[3:])  # 输出: ['a', 'b', 'c']  
  
# 还可以指定步长（Step），用于跳过某些元素  
print(my_list[::2])  # 输出: [1, 3, 'b']，跳过了索引为偶数的元素

3.访问嵌套列表的元素

  • 如果列表中包含其他列表（即嵌套列表），则可以通过组合索引来访问嵌套列表中的元素。

代码如下（示例）：

nested_list = [[1, 2], [3, 4], [5, 6]]  
  
# 访问外层列表的第一个子列表的第一个元素  
print(nested_list[0][0])  # 输出: 1  
  
# 访问外层列表的第二个子列表的第二个元素  
print(nested_list[1][1])  # 输出: 4

四、列表长度

  • 使用内置的len()函数来获取列表（List）的长度，即列表中元素的数量。

代码如下（示例）：

# 定义一个列表  
my_list = [1, 2, 3, 4, 5]  
  
# 使用len()函数获取列表的长度  
list_length = len(my_list)  
  
# 打印列表的长度  
print(list_length)  # 输出: 5

五、列表元素的添加

1.append() 方法

  • append() 方法用于在列表的末尾添加一个元素。但是，只能添加一个元素。

代码如下（示例）：

my_list = [1, 2, 3]  
my_list.append(4)  # 现在 my_list 变成了 [1, 2, 3, 4]

2.insert() 方法

  • insert() 方法用于在列表的指定位置插入一个元素。它接收两个参数：第一个是索引（即位置），第二个是要插入的元素。

代码如下（示例）：

my_list = [1, 2, 4]  
my_list.insert(2, 3)  # 现在 my_list 变成了 [1, 2, 3, 4]

3. + 操作符（或 extend() 方法）

  • 虽然直接使用 + 操作符来“添加”列表，实际上是创建了一个新的列表。

代码如下（示例）：

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# 合并列表，等同 list1.extend(list2)
combined_list = list1 + list2  # 得到 [1, 2, 3, 4, 5, 6]

六、列表元素的删除

1.remove() 方法

  • remove()方法用于删除列表中第一个出现的指定元素。如果元素不存在，则抛出ValueError异常。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5, 4]  
my_list.remove(4)  # 删除第一个出现的4  
print(my_list)  # 输出: [1, 2, 3, 4, 5]  
  
# 如果尝试删除不存在的元素，会抛出异常  
# my_list.remove(6)  # ValueError: list.remove(x): x not in list

2.pop() 方法

  • pop()方法用于删除列表中的指定索引位置的元素（默认为最后一个元素），并返回该元素的值。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5]  
last_element = my_list.pop()  # 删除并返回最后一个元素  
print(last_element)  # 输出: 5  
print(my_list)  # 输出: [1, 2, 3, 4]  
  
# 删除指定索引的元素  
second_element = my_list.pop(1)  # 删除索引为1的元素（即2）  
print(second_element)  # 输出: 2  
print(my_list)  # 输出: [1, 3, 4]

3.del 语句

  • del 语句可以用于删除列表中的元素，可以通过索引或切片来指定要删除的元素或元素范围。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5]  
del my_list[2]  # 删除索引为2的元素（即3）  
print(my_list)  # 输出: [1, 2, 4, 5]  
  
# 删除一个范围的元素  
del my_list[1:3]  # 删除索引1到2的元素（不包括索引3的元素）  
print(my_list)  # 输出: [1, 5]  
  
# 也可以删除整个列表  
del my_list  # 现在my_list不再存在，尝试访问会引发NameError  
# print(my_list)  # NameError: name 'my_list' is not defined

七、列表的切片

1.基本切片

代码如下（示例）：

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

# 获取列表的前三个元素
print(my_list[:3])  # 输出: [1, 2, 3]

# 获取列表从索引3到索引7（不包含索引7）的元素
print(my_list[3:7])  # 输出: [4, 5, 6, 7]

2.省略起始索引或结束索引

代码如下（示例）：

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

# 省略起始索引，从列表开头开始切片
print(my_list[:5])  # 输出: [1, 2, 3, 4, 5]

# 省略结束索引，切片到列表末尾
print(my_list[5:])  # 输出: [6, 7, 8, 9]

3.使用步长

代码如下（示例）：

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

# 每隔一个元素取一个元素
print(my_list[::2])  # 输出: [1, 3, 5, 7, 9]

# 逆序切片（结合步长为-1）
print(my_list[::-1])  # 输出: [9, 8, 7, 6, 5, 4, 3, 2, 1]

4.切片赋值

  • 切片不仅用于获取列表的一部分，还可以用于修改列表的这一部分。

代码如下（示例）：

my_list[2:5] = [10, 11, 12]  # 替换索引2到4的元素  
print(my_list)  # 输出: [1, 2, 10, 11, 12, 6, 7, 8, 9]

5.切片与列表推导式结合

  • 切片可以与列表推导式结合使用，以进行更复杂的操作，如筛选或转换元素。

代码如下（示例）：

# 将列表中的偶数元素加倍  
doubled_evens = [x * 2 for x in my_list if x % 2 == 0]  
print(doubled_evens)  # 输出: [2, 12, 14, 16, 18]（注意：基于原始my_list的修改）  
  
# 或者，如果只想在切片上操作  
sliced_and_doubled = [x * 2 for x in my_list[::2]]  # 只考虑索引为偶数的元素  
print(sliced_and_doubled)  # 输出: [2, 6, 12, 18]（基于原始my_list的索引为偶数的元素）

八、列表的遍历

1.for 循环遍历

  • 最直接的方式是使用for循环直接遍历列表中的每个元素。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5]
for item in my_list:
    print(item)

输出如下（示例）：

1
2
3
4
5

2.索引遍历

  • 使用索引来遍历列表，这在需要同时访问元素和它们的索引时特别有用。

代码如下（示例）：

my_list = ['a', 'b', 'c', 'd', 'e']  
for i in range(len(my_list)):  
    print(f"Index: {i}, Item: {my_list[i]}")

输出如下（示例）：

Index: 0, Item: a
Index: 1, Item: b
Index: 2, Item: c
Index: 3, Item: d
Index: 4, Item: e

3.enumerate() 函数

  • enumerate() 函数可以同时获取索引和元素。

代码如下（示例）：

my_list = ['花', '凝', '雨']
for index, item in enumerate(my_list):
    print(f"Index: {index}, Item: {item}")

输出如下（示例）：

Index: 0, Item: 花
Index: 1, Item: 凝
Index: 2, Item: 雨

4.map() 函数

  • map() 函数可以对列表中的每个元素应用一个函数。虽然它主要用于映射操作，但也可以看作是一种遍历列表的方式。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5]  
def square(x):  
    return x ** 2  
  
squared_list = list(map(square, my_list))  
print(squared_list)  # 输出: [1, 4, 9, 16, 25]

5.filter() 函数（筛选）

  • 虽然filter() 函数主要用于筛选列表中的元素，但它同样基于遍历列表中的每个元素。

代码如下（示例）：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
def is_even(x):  
    return x % 2 == 0  
  
even_numbers = list(filter(is_even, my_list))  
print(even_numbers)  # 输出: [2, 4, 6, 8, 10]

九、列表的排序

1.sort() 方法

  • sort()方法是列表的一个内置方法，它会直接修改原列表，按照指定的规则进行排序。默认情况下，它会按照升序对列表中的元素进行排序。

代码如下（示例）：

my_list = [3, 1, 4, 1, 5, 9, 2]  
my_list.sort()  
print(my_list)  # 输出: [1, 1, 2, 3, 4, 5, 9]  
  
# 降序排序  
my_list.sort(reverse=True)  
print(my_list)  # 输出: [9, 5, 4, 3, 2, 1, 1]

2.sorted()函数

  • 与 sort() 方法不同，sorted() 函数会返回一个新的列表，原列表不会被修改。sorted() 函数同样可以接受 reverse 参数来控制排序顺序。

代码如下（示例）：

my_list = [3, 1, 4, 1, 5, 9, 2]  
sorted_list = sorted(my_list)  
print(sorted_list)  # 输出: [1, 1, 2, 3, 4, 5, 9]  
print(my_list)  # 输出: [3, 1, 4, 1, 5, 9, 2]，原列表未变  
  
# 降序排序  
sorted_list_desc = sorted(my_list, reverse=True)  
print(sorted_list_desc)  # 输出: [9, 5, 4, 3, 2, 1, 1]

3.自定义排序规则

  • 无论是sort()方法还是sorted()函数，都可以接受一个key参数来自定义排序规则。key参数应该是一个函数，该函数会在每个元素上调用，其返回值作为排序的依据。

代码如下（示例）：

# 根据字符串长度排序  
words = ['banana', 'pie', 'Washington', 'book']  
words.sort(key=len)  
print(words)  # 输出: ['pie', 'book', 'banana', 'Washington']  
  
# 使用lambda表达式作为key  
words.sort(key=lambda word: word[::-1])  # 按字符串逆序排序  
print(words)  # 输出: ['banana', 'Washington', 'pie', 'book']

4.复杂对象的排序

  • 对于包含复杂对象的列表，比如字典列表或自定义对象列表，可以通过在key参数中指定一个函数来访问对象的某个属性或调用某个方法来作为排序的依据。

代码如下（示例）：

# 字典列表，按值排序  
dict_list = [{'name': 'Tom', 'age': 20}, {'name': 'Jerry', 'age': 15}, {'name': 'Bob', 'age': 25}]  
dict_list.sort(key=lambda x: x['age'])  
print(dict_list)  # 按年龄升序排序  
  
# 自定义对象列表  
class Person:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
  
    def __repr__(self):  
        return f"{self.name}: {self.age}"  
  
people = [Person('Tom', 20), Person('Jerry', 15), Person('Bob', 25)]  
people.sort(key=lambda person: person.age)  
print(people)  # 按年龄升序输出

输出如下（示例）：

[{'name': 'Jerry', 'age': 15}, {'name': 'Tom', 'age': 20}, {'name': 'Bob', 'age': 25}]
[Jerry: 15, Tom: 20, Bob: 25]

十、列表的列表（嵌套列表）

  • Python的嵌套列表（Nested List）是指列表中包含其他列表的情况。这种结构允许用户以二维（或更多维）的方式来组织和访问数据。嵌套列表在处理表格数据、矩阵、图结构等方面非常有用。

1.创建嵌套列表

代码如下（示例）：

# 创建一个简单的嵌套列表  
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  
  
# 访问嵌套列表中的元素  
print(nested_list[0])  # 输出: [1, 2, 3] ， 访问第一个子列表  
print(nested_list[1][2])  # 输出: 6 ， 访问第二个子列表中的第三个元素

2.遍历嵌套列表

  • 遍历嵌套列表时，则需要使用嵌套的循环来访问每个子列表中的元素。

代码如下（示例）：

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

# 遍历嵌套列表  
for sublist in nested_list:
    for item in sublist:
        print(item, end=' ')
    print()  # 打印换行符以分隔每个子列表的输出

输出如下（示例）：

1 2 3 
4 5 6 
7 8 9

3.修改嵌套列表

代码如下（示例）：

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  
  
# 修改子列表中的元素  
nested_list[1][1] = 55  
print(nested_list)  # 输出: [[1, 2, 3], [4, 55, 6], [7, 8, 9]]  
  
# 添加新的子列表  
nested_list.append([10, 11, 12])  
print(nested_list)  # 输出: [[1, 2, 3], [4, 55, 6], [7, 8, 9], [10, 11, 12]]  
  
# 删除子列表  
del nested_list[0]  
print(nested_list)  # 输出: [[4, 55, 6], [7, 8, 9], [10, 11, 12]]

4.列表推导式与嵌套列表

代码如下（示例）：

# 使用列表推导式创建嵌套列表  
nested_list = [[x*y for y in range(1, 4)] for x in range(1, 4)]  
print(nested_list)  # 输出: [[1, 2, 3], [2, 4, 6], [3, 6, 9]]  
  
# 修改嵌套列表（创建一个新列表）  
modified_list = [[item*2 for item in sublist] for sublist in nested_list]  
print(modified_list)  # 输出: [[2, 4, 6], [4, 8, 12], [6, 12, 18]]

总结

以上，就是Python中列表的全部内容。Python的列表非常灵活和强大，支持多种操作来管理元素和子列表。好好学，好好做。

花凝雨
关注
专栏目录
【Python】入门到放弃之第五章《运算符》
MP13537560060的博客
08-12 1179
这是本系列的第五章节内容，《运算符》。这又是一篇长文章。运算符（Operator）是一种告诉编译器执行特定数学或逻辑操作的符号，用于表示针对数据的特定操作，也称之为操作符。根据不同的分类标准，运算符可以分为多种类型。以上，就是Python中运算符的全部内容。了解这些运算符及其优先级对于编写正确和高效的 Python 代码至关重要。不得不再次感叹：这也太长了吧。
【Python】入门到放弃之第八章《元组》
MP13537560060的博客
08-15 779
这是本系列的第八章节内容，《元组》。元组（Tuple）是Python中的一种基本数据结构，用于存储一系列的元素，这些元素可以是不同类型的数据。与列表（List）不同，元组是不可变的，这意味着一旦创建了一个元组，就不能更改其内部元素的顺序或值。以上，就是Python中元组的全部内容。
【Python】入门到放弃之第九章《字典》
MP13537560060的博客
08-15 761
这是本系列的第九章节内容，《字典》。在Python中，字典（Dictionary）是一种内置的数据结构，用于存储键值对（key-value pairs）。字典是可变的，意味着你可以在创建字典后添加、删除或修改其中的元素。字典的键（key）必须是唯一的，并且是不可变的（即，它们必须是不可变数据类型，如字符串、数字或元组，但不能是列表或字典等可变类型）。字典的值（value）则可以是任何数据类型，包括列表、元组、字典等。以上，就是Python中字典的全部内容。
【Python】入门到放弃之第三章《数据类型》
MP13537560060的博客
08-10 1338
这是本系列的第三章节内容，《数据类型》。以上，就是Python中数据类型的全部内容。本想着简单写点就午睡的，不知不觉写了这么长，好累好困，就这样吧，从入门到放弃。
【Python】入门到放弃之第六章《字符串》
MP13537560060的博客
08-13 1024
这是本系列的第六章节内容，《字符串》。不是串串，是字符串。字符串（String）是编程中常用的数据类型，用于表示文本数据。在Python中，字符串是不可变的（immutable），即一旦字符串被创建，就不能改变其内部的内容，但可以对字符串进行各种操作，如拼接、分割、查找、替换等，以生成新的字符串。字符串是字符的有序集合，可以通过索引来访问字符串中的单个字符。在Python中，字符串可以用单引号（‘）、双引号（"）或三引号（’''或"“”）来表示。
【Python】入门到放弃之第四章《数据类型转换》
MP13537560060的博客
08-11 1055
这是本系列的第四章节内容，为《数据类型转换》。数据类型转换（Type Conversion）是编程中常见的一个概念，它指的是将一种数据类型的值转换为另一种数据类型的过程。这种转换可以是隐式的（自动完成），也可以是显式的（需要程序员手动指定）。不同的编程语言在数据类型转换上有着不同的规则和函数。Python是一种动态类型语言，这意味着变量的类型是在运行时确定的。因此，Python中不存在传统的数据类型转换语法，如C或Java中的类型转换。但是，Python提供了多种内置函数来实现数据类型之间的转换。
神仙级python入门教程(非常详细)，从零基础入门到精通，从看这篇开始！
热门推荐
程序猿赵高的博客
10-13 35万+
坚持到了这儿，恭喜你，表示你有做开发的潜力，其实我想说的上面的内容还是刚刚开始，刚开始大家不需要多么精通了解这些内容，除了Python方面的知识，每个部分掌握一点儿能进行基本开发就好，主要是不断练习，让自己跳出「舒适区」，进入「学习区」，但是又不进入「恐慌区」，不断给自己「喂招」。
python从入门到放弃之二_python从入门到放弃（二）
weixin_36415835的博客
02-03 78
编码类型ASCII码：主要用来显示英文和其余西欧语言，用8位来表示，也就是一个字节，最多只能显示256个符号UNICODE：也叫万国码，为了解决传统的字符编码方案的局限而产生的，它为每种语言的每一个字符都设定了二进制编码，最少用16位来表示，也就是两个字节UTF-8：是unicode的压缩版，能够显示中文，占用的内存少python2.x版本使用的是ascii码python3.x版本使用的是utf-...
【Python】入门到放弃之第十一章《函数》
MP13537560060的博客
08-15 269
这是本系列的第十一章节内容，《函数》。在Python中，函数是一段具有特定功能的、可重用的代码块。它允许用户封装一段代码，以便在其他地方重复使用，从而提高代码的可读性和可维护性。函数是一种功能的抽象，它封装了一段代码，用于完成特定的任务。Python中的函数可以分为四类：内置函数、标准库函数、第三方库函数和自定义函数。使用def关键字来定义函数。"""向用户打招呼"""以上，就是Python中函数的全部内容。
Python入门到放弃系列一
幸运小侯子
06-21 865
目录 初衷 基本概念 前言 第一部分：基础知识 第一章 起步 安装&配置部分 第二章 变量和简单数据类型 注释学习 代码自动补全 初衷 考虑到很多的地方都说要会python，shell，之类的。 java已经基本熟练， c语言也是简单的语法知道（考研的时候学习了一部分吧) shell属于会用 python目前一窍不通。 正好趁这段时间学习下这个Python语言看看如何。 学习地址：http://c.biancheng.net/view/4136.h...
Python入门到放弃系列五
幸运小侯子
06-22 270
第二部分 项目-数据可视化 第十六章 下载数据 读取CSV数据的头行信息 import csv filename = '../data/csv_sitka_weather_07-2014.csv' with open(filename) as f: reader = csv.reader(f) header_row = next(reader) print(header_row) 输出信息： ['AKDT', 'Max TemperatureF', 'Mean Tem.
Python入门到放弃系列六
幸运小侯子
06-22 476
第二部分 项目-Web应用 第十八章 Django 入门 Django-helloworld 第一块搞什么虚拟环境？ 大致了解了下是为了不同版本冲突或者维护独立可运行环境的一个控制手段。 https://blog.csdn.net/godot06/article/details/81079064 hello-world版本，先无脑按照书上来一遍看看效果，增加下性趣。 ruishens-MacBook-Pro:python_work ruishen$ mkdir learning_log...
Python实战案例汇总，带你轻松从入门到实战
请大家直接把问题写在评论区或留言，不要只说一句"你好 或 在吗"，我会尽快回复的。
06-15 1万+
python从入门到实战，带你轻轻松松学会python
Python入门与进阶之NumPy库应用——元胞自动机
weixin_44386638的博客
02-15 4950
1   旅行居家必备之利器 NumPy   Numpy的名字来源于Numerical & Python。    作为功能强大的 Python 库可谓是 Python 进行科学计算，数据分析的旅行居家必备之利器(大雾)，主要用于提供，存储，计算 N 维数组, 它可以完成诸如机器学习模型，图像处理和一些数学任务。   本次笔者分享的是通过例子介绍一下 NumPy 在机器学习和图...
Python世界：力扣29题两数相除算法实践
最新发布
来知晓的博客
09-13 186
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
蒙特卡罗方法——布丰投针实验近似计算圆周率python代码实现
2301_79376014的博客
09-09 451
蒙特卡罗——布丰实验
Python实现多线程、多进程及协程
qq_42568323的博客
09-09 1047
本文详细介绍了 Python 中多线程、多进程和协程的并发模型及其实现方式，并通过具体场景演示了如何使用面向对象思想实现这些模型。在实际应用中，应根据任务的类型和需求选择合适的并发模型，从而优化程序的性能和资源利用率。本文将详细介绍 Python 中的多线程、多进程和协程的概念及其实现方式，并通过具体场景展示如何在 Python 中使用面向对象的思想实现这些并发模型。接下来，我们通过一个计算密集型任务的示例来演示多进程的实现：计算一系列大数字的阶乘。主程序中创建并启动了多个计算进程，并使用。
pip-tools：打造可重复、可控的 Python 开发环境，解决依赖关系，让代码更稳定
weixin_53707653的博客
09-09 810
是一个强大且易用的工具，可以帮助开发者轻松管理 Python 项目的依赖关系，确保代码的可重复性和稳定性。是一组命令行工具，旨在简化 Python 依赖关系的管理，确保项目环境的稳定性和可重复性。可以确保每次构建环境时都使用相同的依赖项版本，从而避免由于依赖项版本不一致导致的错误，提高代码可重复性和稳定性。自动化了依赖关系管理过程，节省了开发者的时间和精力，可以将更多时间投入到实际的开发工作中。文件中的信息，更新虚拟环境，安装、升级或卸载所需的软件包，确保虚拟环境与。命令可以从你的项目配置文件中生成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值