Python 列表简单使用

最新推荐文章于 2021-08-29 22:46:59 发布
最新推荐文章于 2021-08-29 22:46:59 发布
阅读量281 收藏 3
点赞数 1
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fe_cow/article/details/84800601
版权

Python列表及元组

一、什么是列表？

  • 列表是由一系列按特定顺序排列 元素组成。
  • 在Python中，用方括号（ [ ] ）来表示列表，并用逗号来分隔其中的元素。

1.1、访问列表元素：

  • 列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置或索引告诉Python即可。

    color = ['red', 'green', 'blue', 'black']
print(color[0])
# 输出结果 red

    • 当你请求获取列表元素时，Python只返回该元素，而不包括方括号和引号。

    • 返回的是一个字符串类型, 这时候就可以用title()方法：

      color = ['red', 'green', 'blue', 'black']
print(color[0].title())
# 输出结果： Red

1.2、索引从0而不是1开始：

  • 在Python中，第一个列表元素的索引为0，而不是1。

    color = ['red', 'green', 'blue', 'black']
print(color[0])
print(color[3])
# 输出结果： red  black

  • Python为访问最后一个列表元素提供了一种特殊语法。通过将索引指定为-1。

    color = ['red', 'green', 'blue', 'black']
print(color[-1])
# 输出结果： black
    • 这种语法很有用，因为你经常需要在不知道列表长度的情况下访问最后的元素。这种约定也适用于其他负数索引，例如，索引-2返回倒数第二个列表元素，索引-3返回倒数第三个列表元素，以此类推。

1.3、使用列表中各个值：

  • 可像使用其他变量一样使用列表中的各个值。

    color = ['red', 'green', 'blue', 'black']
message = "My like " + color[0].title()
print(message)
# 输出结果: My like Red

二、修改、添加和删除元素：

  • 你创建的大多数列表都将是动态的，这意味着列表创建后，将随着程序的运行增删元素。
    • 比如：你创建一个游戏，要求玩家射杀从天而降的外星人；为此，可在开始时将一些外星人存储在列表中，然后每当有外星人被射杀时，都将其从列表中删除，而每次有新的外星人出现在屏幕上时，都将其添加到列表中。在整个游戏运行期间，外星人列表的长度将不断变化。

2.1、修改列表元素：

  • 要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。

    color = ['red', 'green', 'blue', 'black']
color[0] = 'pink'
print(color)
# 输出结果： [u'pink', u'green', u'blue', u'black']
    • 可以看出, 第一个索引对应的值变了，其它的没有改变。

2.2、再列表中添加元素：

1：在列表末尾添加元素：

  • 使用方法append()，就可以实现最简单方式将元素附加到列表末尾。

    color = ['red', 'green', 'blue', 'black']
color.append('pink')   # append()方法没有返回值
print(color)
# 输出结果： [u'red', u'green', u'blue', u'black', u'pink']

  • 方法append() 让动态地创建列表易如反掌。

    • 例如，你可以先创建一个空列表，再使用一系列的append() 语句添加元素：

      color = []
color.append('red')
color.append('green')
color.append('blue')
color.append('pink')
print(color)
# 输出结果：[u'red', u'green', u'blue', u'pink']
2：在列表中插入元素：

  • 使用方法insert() 方法可在列表的任何位置添加新元素，你需要指定新元素的索引和值：

    colors = ['red', 'green', 'blue']
colors.insert(1, 'black')
print(colors)
# 输出结果： [u'red', u'black', u'green', u'blue']
    • insert(1，'black')方法： 1就是新元素的在列表中索引的位置，'black’就是值。
    • 这种操作将列表中既有的每个元素都右移一个位置(不包括’red’， 因为它的索引是0，'black’在它的后面)。

2.3、在列表中删除元素：

1：使用del语句删除元素

  • 如果要知道要删除的元素在列表中的位置，可使用del语句：

    colors = ['red', 'green', 'blue']
del colors[1]  # 使用del 语句 删除colors 列表索引为1的元素
print(colors)
# 输出结果：[u'red', u'blue']
    • 使用del 可删除任何位置处的列表元素，条件是知道其索引。
    • 使用del 语句将值从列表中删除后，你就无法再访问它了。
2：使用方法pop()删除元素：

  • 方法pop() 可删除列表末尾的元素，并让你能够接着使用它。

    • 列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。
    colors = ['red', 'green', 'blue', 'pink']
print(colors)
color = colors.pop()  # 我们从这个列表中弹出一个值，并将其存储到变量color
print(colors)   # 我们打印这个列表，以核实从其中删除了一个值 
print(color) # 我们打印弹出的值，以证明我们依然能够访问被删除的值 
# 输出结果：
"""
[u'red', u'green', u'blue', u'pink']
[u'red', u'green', u'blue']
pink
"""
3：弹出列表中任何位置处的元素：

  • 可以使用pop() 来删除列表中任何位置的元素。

    colors = ['red', 'green', 'blue', 'pink']
color = colors.pop(1)  # pop()括号内是列表中的索引位置
print(colors)
print(color)
# 输出结果如下：
[u'red', u'blue', u'pink']
green
    • 别忘了，每当你使用pop() 时，被弹出的元素就不再在列表中了。

  • 如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del 语句；如果你要在删除元素后还能继续使用它，就使用方法pop() 。

4：根据值删除元素:

  • 如果你只知道要删除的元素的值，可使用方法remove()。

    colors = ['red', 'green', 'blue', 'pink']
colors.remove('red')
print(colors)
# 输出结果 [u'green', u'blue', u'pink']

  • 使用remove()从列表中删除元素时，也可接着使用它的值。

    colors = ['red', 'green', 'blue', 'pink']
print(colors)
red_color = 'red'  # 将要删除的值，赋值给一个变量
no_red = colors.remove(red_color)  # 删除这个变量  remove()是没有返回值的 
print(no_red)  #输出结果None
print(colors)
message = 'My like {}'.format(red_color)  # 不过这个值还在变量中
print(message)
# 输出结果：
[u'red', u'green', u'blue', u'pink']
[u'green', u'blue', u'pink']
My like red

  • 注意：方法remove() 只删除第一个指定的值。

三、组织列表：

3.1、使用方法Sort()对列表进行永久性排序：

  • Python方法sort() 让你能够较为轻松地对列表进行排序。

    colors = ['red', 'green', 'blue', 'black', 'pink']
colors.sort()
print(colors)
# 输出结果： [u'black', u'blue', u'green', u'pink', u'red']  # 是按字母进行排序

  • 还可以按与字母顺序相反的顺序排列列表元素，为此，只需向sort() 方法传递参数reverse=True。

    colors = ['red', 'green', 'blue', 'black', 'pink']
colors.sort(reverse=True)
print(colors)
# 输出结果： [u'red', u'pink', u'green', u'blue', u'black']

  • 列表元素排列顺序的修改是永久性的

3.2、使用函数sorted()对列表进行临时排序：

  • 函数sorted() 让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。

    colors = ['red', 'green', 'blue', 'black', 'pink']
print(colors)  # 按照列表显示顺序
print(sorted(colors))  # 在按字母进行排序显示顺序
print(colors)  #  特定顺序显示列表后，我们进行核实，确认列表元素的排列顺序与以前相同
# 输出结果：
[u'red', u'green', u'blue', u'black', u'pink']
[u'black', u'blue', u'green', u'pink', u'red']
[u'red', u'green', u'blue', u'black', u'pink']
    • 注意：调用函数sorted() 后，列表元素的排列顺序并没有变。
    • 如果你要按与字母顺序相反的顺序显示列表，也可向函数sorted() 传递参数reverse=True。

3.3、倒着打印列表：

  • 要反转列表元素的排列顺序，可使用方法reverse()

    colors = ['red', 'green', 'blue', 'black', 'pink']
colors.reverse()
print(colors)
# 输出结果：[u'pink', u'black', u'blue', u'green', u'red']

    • 注意，reverse() 不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序。

    • 方法reverse() 永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse() 即可。

      colors = ['red', 'green', 'blue', 'black', 'pink']
colors.reverse()
colors.reverse()
print(colors)
# 输出结果：[u'red', u'green', u'blue', u'black', u'pink']

3.4、确定列表的长度：

  • 用函数len()可快速获悉列表的长度

    colors = ['red', 'green', 'blue', 'black', 'pink']
print(len(colors))
# 5

  • 如何对列表进行永久性排序方法sort()，以及如何为展示列表而进行临时排序函数sorted()。

四、操作列表：

4.1、遍历整个列表(for循环)：

  • 你经常需要遍历列表的所有元素，对每个元素执行相同的操作。

    colors = ['red', 'green', 'blue', 'black', 'pink']  # 定义一个列表
for color in colors:  #定义一个for 循环
    print(color)  # 对列表中每个名字，python都将重复执行
# 输出结果如下：
red
green
blue
black
pink
4.1.1、列表循环：

  • 循环这种概念很重要，因为它是让计算机自动完成重复工作的常见方式之一。

    colors = ['red', 'green', 'blue', 'black', 'pink']  # Python 会首先读取第一行代码
for color in colors:  # 第一个值'red' 存储到变量 color中，读取下一行代码, 下一行的时候读取的是'green'， 鉴于该列表还包括其他的值，
    print(color)  # 对列表中每个名字，python都将重复执行
    • 在这个过程中，for 循环后面没有其他的代码，因此程序就此结束。
4.1.2、再for循环中执行更多的操作：

  • 在for 循环中，可对每个元素执行任何操作。

    colors = ['red', 'green', 'blue', 'black', 'pink']
for color in colors:
    print('My like {}'.format(color).title() + ', too')
# 输出结果如下：
My Like Red, too
My Like Green, too
My Like Blue, too
My Like Black, too
My Like Pink, too
    • 每个缩进的代码行都是循环的一部分，且将针对列表中的每个值都执行一次。因此，可对列表中的每个值执行任意次数的操作。
    • 在for 循环中，想包含多少行代码都可以。
4.1.3、再for循环结束后执行一些操作：

  • 下面将print()打印放到跟for循环并列的行中。

    colors = ['red', 'green', 'blue', 'black', 'pink']
for color in colors:
    print('My like {}'.format(color).title() + ', too')
print('finish')
# 输出结果如下：
My Like Red, too
My Like Green, too
My Like Blue, too
My Like Black, too
My Like Pink, too
finish
    • 可以看出，再for循环结束后，程序会继续往下走。

4.2、避免缩进错误：

4.2.1、忘记缩进：

  • 对于位于for 语句后面且属于循环组成部分的代码行，一定要缩进。如果你忘记缩进，Python会提醒你：

    colors = ['red', 'green', 'blue', 'black', 'pink']
for color in colors:
print('My like {}'.format(color).title() + ', too')
# 会提示你错误信息：
  File "C:/Users/lh9/PycharmProjects/request/my_test01.py", line 138
    print('My like {}'.format(color).title() + ', too')
        ^
IndentationError: expected an indented block
    • 通常，将紧跟在for 语句后面的代码行缩进，可消除这种缩进错误。

4.3、创建数值列表：

4.3.1、使用函数range()：

  • Python函数range() 让你能够轻松地生成一系列的数字。

    for value in range(1, 5):
    print(value)
# 输出结果如下：
1
2
3
4
    • 函数range() 让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值（这里为5）。
4.3.2、使用range()创建数字列表：

  • 要创建数字列表，可使用函数list() 将range()的结果直接转换为列表。

    numbers = list(range(1, 5))
print(numbers)
# 输出结果：[1, 2, 3, 4]

  • 使用range()时，还可以指定步长：

    numbers = list(range(2, 11, 2))
print(numbers)
# 输出结果如下： 打印2~10的 偶数
[2, 4, 6, 8, 10]

  • 使用函数range()几乎能够创建任何需要的数字集

    squares = []   # 首先创建一个空列表
for value in range(1, 11):  # 然后循环数值 1, 10
    square = value**2  # value的平方
    squares.append(square)  # 依次加入列表中
print(squares)  # 打印列表中的结果
# 输出结果：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 还可以简写为：
squares = []
for value in range(1, 11):
    squares.append(value**2)
print(squares)  # 得到的结果跟上面是一样的
4.3.3、对数字列表执行简单的统计计算：

  • 数字列表的最大值max()、最小值min()和总和sum()。

    digits = [0, 11, 22, 33, 44, 11, 22, 33, 100]
print(max(digits))
print(min(digits))
print(sum(digits))
# 输出结果如下
100
0
276
4.3.4、列表解析：

  • 常说的列表推到式：

    squares = [value**2 for value in range(1, 11)]
print(squares) 
# 输出结果: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    • 在这个示例中，表达式为value**2 ，它计算平方值。
    • 接下来，编写一个for 循环，用于给表达式提供值，再加上右方括号。在这个示例中，for 循环为for value in range(1,11) ，它将值1~10提供给表达式value**2
    • 请注意，这里的for 语句末尾没有冒号。

4.4、使用列表的一部分：

  • 处理列表的部分元素——Python称之为切片
4.4.1 切片：

  • 要创建切片，可指定要使用的第一个元素和最后一个元素的索引\

  • 与函数range() 一样，Python在到达你指定的第二个索引前面的元素后停止。

  • 要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0 、1 和2 的元素。

    colors = ['red', 'green', 'blue', 'pink', 'black', 'yellow']
print(colors[0:3]) # 该列表有一个切片, 切的是前三位, 0,1,2  不包括3, 所以去列表中取0,1,2的索引
# 输出结果：[u'red', u'green', u'blue']

  • 要输出列表中1~3的元素

    colors = ['red', 'green', 'blue', 'pink', 'black', 'yellow']
print(colors[1:4])
# 输出结果：[u'green', u'blue', u'pink']

  • 如果没有指定第一个索引，Python将自动从列表开头开始

    colors = ['red', 'green', 'blue', 'pink', 'black', 'yellow']
print(colors[:4])
# 输出结果：[u'red', u'green', u'blue', u'pink']

  • 提取从第3个元素到列表末尾的所有元素

    colors = ['red', 'green', 'blue', 'pink', 'black', 'yellow']
print(colors[3:])
# 输出结果：[u'pink', u'black', u'yellow']

  • 负数索引返回离列表末尾相应距离的元素

    colors = ['red', 'green', 'blue', 'pink', 'black', 'yellow']
print(colors[-3:])
# 输出结果：[u'pink', u'black', u'yellow']
4.4.2、遍历切片：

  • 遍历列表的部分元素，可在for 循环中使用切片

    colors = ['red', 'green', 'blue', 'pink', 'black', 'yellow']
for color in colors[:3]:
    print(color)
# 输出结果如下：
red
green
blue
4.4.3、复制列表：

  • 要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:] ）

    colors = ['red', 'green', 'blue', 'pink', 'black', 'yellow'] # 1.首先创建了一个colors列表
my_colors = colors[:]  #2.再不指定任何索引的情况下,从列表colors中提取切片, 创建了my_colors, 通过变量传递给了my_colors
print(colors)
print(my_colors)

# 输出结果如下：
[u'red', u'green', u'blue', u'pink', u'black', u'yellow']
[u'red', u'green', u'blue', u'pink', u'black', u'yellow']

  • 核实我们确实是2个列表, 而不是一个列表

    colors = ['red', 'green', 'blue', 'pink', 'black', 'yellow']
my_colors = colors[:]
colors.append('white')
my_colors.append('orange')
print(colors)
print(my_colors)
#输出结果如下:
[u'red', u'green', u'blue', u'pink', u'black', u'yellow', u'white']
[u'red', u'green', u'blue', u'pink', u'black', u'yellow', u'orange']

  • 下面演示不使用切片的情况下，进行列表的复制

    colors = ['red', 'green', 'blue', 'pink', 'black', 'yellow']
my_colors = colors #1.colors赋值给了my_colors， 而不是将colors副本给了my_colors
# 这种语法是python 将新变量my_colors关联到包含再colors中, 因此两个变量都指向同一个列表
colors.append('white')
my_colors.append('orange')
print(colors)
print(my_colors)
# 输出结果如下：
[u'red', u'green', u'blue', u'pink', u'black', u'yellow', u'white', u'orange']
[u'red', u'green', u'blue', u'pink', u'black', u'yellow', u'white', u'orange']

五、 元组操作：

  • Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组

5.1、定义元组：

  • 元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

    my_tuple = (0, 100)  # 首先定义了元组, 使用的是()括号，
print(my_tuple[0])  # 接下来使用[0]索引来获取各个元素, 跟列表是一样的
print(my_tuple[1])
# 输出结果如下： 
0
100

  • 接下来, 修改元组中的元素

    my_tuple = (0, 100)
my_tuple[0] = 50
print(my_tuple)
# 会出现如下错误信息：
Traceback (most recent call last):
  File "C:/Users/lh9/PycharmProjects/request/my_test01.py", line 177, in <module>
    my_tuple[0] = 50
TypeError: 'tuple' object does not support item assignment
    • 修改第一个元素的值，导致Python返回类型错误消息。
    • 由于试图修改元组的操作是被禁止的，因此Python指出不能给元组的元素赋值

5.2、遍历元组中所有的值：

  • 像列表一样，也可以使用for 循环来遍历元组中的所有值

    my_tuple = (0, 100)
for value in my_tuple:
    print(value)
# 输出结果如下：
0
100

5.3、修改元组的变量：

  • 虽然不能修改元组的元素，但可以给存储元组的变量赋值

    my_tuple = (0, 100)
for value in my_tuple:
    print(value)

my_tuple = (200, 300)
for value in my_tuple:
    print(value)
# 输出结果如下：
0
100
200
300
    • 如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。
Fe_cow丿
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python第三章——操作列表、数值列表、切片、元组
一枚硬币的博客
05-09 744
# 操作列表 # 1：for循环 # 现在创建一个颜色列表 利用for循环分别把列表中的元素打印出来 colores=['red','yellow','black','orange','blue'] for color in colores: print(color) # 解释，定义一个列表 ，然后定义一个for循环，第二行，这行代码让python从colors中取出一个颜色，并将其储存到...
python colorlist_Python list的常用操作
weixin_39729272的博客
12-17 2155
Python list列表的用法：序列是Python中常用的数据结果，主要用于存放数据(同一个序列可以存放不同类型的数据)。1. 序列的常用操作：1.1 索引1.2 分片1.3 相加1.4 长度、最小值和最大值1.5 list()函数、del 关键字2. 序列的常用方法：2.1 append()2.2 count()2.3 extend()2.4 index()2.5 insert()2.6 po...
列表（list）元组（tuple）字典（dictionary）集合（set）
weixin_30667649的博客
06-20 123
1.列表 列表是python内置的数据类型，是一个可变容器模型，可以储存任意类型的变量。 list简单来说就是两个中括号[ ]包起来的有序集合，里面的元素可以使任意类型。 1.1创建列表 一共有两种方式 1 colors = ["red","green","yellow","blue"] 2 3 colors = list(["red","green","yellow","...
Python学习笔记（6）- 列表的切片
也许我太傻
11-10 750
切片 python中的一个说法，简单点来说几句是列表的部分元素。列表的切片也是一个列表，可以按照你想要的内容生成不同的列表。colors = ['red','blue','gray','yellow','white','black'] print(colors[1:4])这里提取的是列表中的第2-4个元素，如果你想要1-3个，可以设置为color[0-3]colors = ['red','blue
Datawhale ----7 days for Python(任务一)
小波大叔
01-03 181
学习内容1 1.使用anaconda搭建python的环境（跳过第一章，去网络上搜索anaconda3的教程） Anaconda3详细安装使用教程及问题总结 2.完成系统变量的设置，通过在命令行输入python3检验一下python3有没有装成功。 python 3.6 3.解释什么是变量，变量命名规则。(第二章) 每个变量都存储了一个值 ——与变量相关联的信息变量名只能包含字母、数字和下划线。 ...
python list 列表简单使用
marc_chen的博客
08-29 133
列表是在一个连续的内存空间，使用索引查找值非常快，不建议插入和删除，可以最后加入，不影响 创建列表 l1 = [] l2 = list(range(3)) l3 = [1,2,‘abc’,str] l4 = [1,[2,3],None] 使用索引查找值（注意超界问题） l5 = [1,2,3,4,5] l5[0] #从左边往右边，从0开始，最长为len(l5)-1 1 l5[4] 5 l5[-1] #从右边往做左边，从-1开始，最长为-len(l5) 5 l5
python对列表的简单操作
qq_43070795的博客
05-13 58
本文展示对列表的简单操作，废话少说直接上代码 注意点： A：python中读取数据从0开始计数如下图所示 首先创建列表并对其进行输出（属性名随意） bicycles=['1','2','3'] print(bicycles) print(bicycles[0].title()) print(bicycles[-1].title()) print(bicycles[-5].title()) 运行结果如下 前三个可以正常输出，但第四个出现问题，原因是你要找的数据超出范围。取负数的时候，从最后一个往前数 B：
python 列表推导式使用详解
09-18
Python 列表推导式是Python编程语言中一种高效、简洁的创建列表的方式。它允许开发者用一行代码完成原本需要使用循环和条件判断才能实现的列表构建任务，从而提高代码的可读性和效率。列表推导式的语法结构使得代码...
python列表返回重复数据的下标
09-17
首先，我们需要理解Python列表的基本操作。列表是Python中最常用的数据结构之一，它允许存储任意类型的元素，并且可以进行动态扩展和收缩。列表中的每个元素都有其唯一的索引，索引是从0开始的整数，用于访问和修改...
python列表推导式操作解析
09-18
Python列表推导式是Python语言中的一个强大特性，它提供了一种简洁且高效的方式来创建新的列表。通过在一行内表达循环和条件判断，列表推导式可以极大地减少代码的复杂性和体积，使得代码更加易读。 列表推导式的...
python3列表推导式
12-23
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。 每个列表推导式都在 for 之后跟一个表达式...
Python列表元素常见操作简单示例
01-20
Python列表是Python编程语言中最常用的数据结构之一，它允许存储一系列有序的元素，可以是任意类型，如整数、字符串、浮点数甚至是其他列表。列表的灵活性和强大的操作功能使其成为处理序列数据的理想选择。以下是...
Java基础总结1
weixin_30394981的博客
02-05 99
1、存在成员变量（全局变量）的类用于多线程时是不安全的，不安全体现在这个成员变量可能发生非原子性的操作，而变量定义在方法内也就是局部变量是线程安全的。 2、在调用wait方法时，都是用while判断条件的，而不是if，在wait方法说明中，也推荐使用while，因为在某些特定的情况下，线程有可能被假唤醒，使用while会循环检测更稳妥。 　　wait和notify方法必须工作于synchron...
Python while循环
Fe_cow的博客
12-07 5537
Python while循环 1、while 循环简介 for 循环用于针对集合中的每个元素都一个代码块，而while循环不断的运行，直到指定的条件不满足为止。 1.1、使用while 循环： 循环从1数到5： number = 1 # 指定从1开始数 while number &lt;= 5: # 只要number小于或等于5 就接着运行这个循环 print(number)...
Python 中的 列表跟元组 存储方式和性能的差异 、使用的场景
Fe_cow的博客
12-01 3479
Python 中的 列表跟元组 的使用 一、列表和元组基础： 列表和元组，都是一个可以放置任意数据类型的有序集合。 在很多语言中，集合的数据类型必须一致。不过，对于 Python 的列表和元组来说，并无此要求： my_list = [66, 77, 'fe', 'cow'] # 列表中同时含有int和string类型的元素 print(my_list) # 输出结果： [66, 77, 'fe'...
Python 枚举 类型的详解
Fe_cow的博客
06-28 2567
Python 枚举 类型详解 一、枚举的优势： Python 的原生类型中并不包含枚举类型。为了提供更好的解决方案，Python 通过在 3.4 版本中添加了enum 标准库。 枚举类型可以看作是一种标签或是一系列常量的集合，通常用于表示某些特定的有限集合。 枚举类可以方便地表示星期，月份等常数类型，如果你不用枚举类，那么你只能用数字或者字符串。如果你使用数字，用1-7来表示星期数，但一...
Python 抽象基类的理解
Fe_cow的博客
07-03 2003
Python 抽象基类的理解 一、抽象基类的特点： 1.规定继承类必须具有抽象基类指定的方法 2.抽象基类无法实例化 以上两个特点，主要用于接口设计 注意：Python中并没有提供抽象类与抽象方法，但是提供了内置模块abc来模拟实现抽象类 二、使用场景: 1.判断某个对象的类型： class ColorObj(object): """创建一个颜色的类""" def __init_...
Python如何更好的使用变量名
Fe_cow的博客
06-05 1506
变量用的好与不好，和代码的质量有着非常重要的联系。 如何为变量起名 在编程中起的最多的名字，还数各种的变量。给变量起一个好的名字很重要，因为好的变量命名可以极大的提高代码整体的可读性。 1.变量名具有描述性 比如： 正确的变量名：start_time 错误的变量名：time 2.变量名最好能简单易懂，一下就能猜出类型 布尔类型变量最大特点：只存在是 或 不...
Python 可迭代对象、迭代器、生成器的详解
Fe_cow的博客
07-11 1102
Python 可迭代对象、迭代器、生成器的详解 一、判断可迭代对象、迭代器： 使用模块from collections import Iterable, Iterator，可以检测该对象是可迭代对象还是迭代器。 Iterable: 检查是否可迭代对象 Iterator：检查是否迭代器 举个例子，判断可迭代对象(Iterable)： from collections import Iterable...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值