【总结】列表

已于 2023-03-22 19:02:51 修改
阅读量81 收藏
点赞数
文章标签： python
于 2023-03-14 17:06:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50007404/article/details/129533433
版权

列表

1.列表基础

需求：定义变量保存多个学生的成绩

使用推荐：如果要同时处理多个数据。可以考虑列表

scores = [90, 56, 89, 67, 76, 58, 98]

1.1 认识列表（list）

在这里插入图片描述

  • 列表是容器型数据类型（序列）：将[]作为容器的标志，里面多个数据用‘,’隔开：[数据1, 数据2, 数据3, …]

  • 列表是可变的（可变指的是列表中的元素的个数和元素的值可变 - 列表支持增删改）
    列表是有序的（元素有顺序对应的位置信息：元素的顺序影响结果 - 支持索引操作）

  • 列表对元素的要求：没有要求任何类型的数据都可以作为列表对元素

注：元素 - 容器中每一个独立的数据，就是这个容器的元素

1）空列表

# list1和list2都是空列表
list1 = [ ]		# []
list2 = []		# []
print(list1, list2)

2）列表是有序的

print([10, 20, 30] == [30, 20, 10])     # False
print({10, 20, 30} == {30, 20, 10})     # True （集合是无序的，顺序不影响结果）

3）列表元素可以是任何类型的数据

# a. 一个列表中的数据可以是多个相同类型的数据
list1 =[10, 20, 30]
names = ['小米', '小黄', '小康']

# b.一个列表中的数据可以是多个不同类型的数据
list2 = [10, 1.23, True, None, '小红']

# c.列表中的元素也可以是列表
list3 = [10, 20, [20, 30]]

2.列表查操作

  • 查 - 获取列表中元素的值

2.1 查单个 - 获取一个元素

1）语法：

列表[索引] - 获取列表中指定索引对应的元素

2）说明

  • 列表 - 需要获取元素的列表对象（可以是保存一个列表的变量，也可以是具体的列表数据）
  • [] - 固定写法
  • 索引 - 又叫下标，元素在列表中的位置信息
    列表一旦确定，列表中的每一个元素对应的索引
    a. 元素从前往后索引从0开始不断增加
    b. 元素从后往前从-1开始不断减少
num = [10, 20, 30, 40]
print([10, 20, 30, 40][-1])     # 40
print(num[-1])      # 40
print(num[3])       # 40
# print(num[4])       # 报错！索引不能越界

2.2 切片 - 同时获取多个元素（切片的结果是列表）

1）完整语法：

列表[开始下标:结束下标:步长]
  • 说明
  • 列表 - 需要获取元素列表
  • [] - 固定写法
  • 开始下标、结束下表、步长 - 必须是整数
  • 开始下标 - 决定从哪开始取
  • 结束下表 - 去到哪结束
  • 步长 - 决定去的时候怎么取（一个一个按顺序取，还是跳着取；从前往后还是从后往前取）

2）使用切片

a.确定切片结果过程
第一步：先确定结果是否为空，看开始下标对应的位置到结束下标对应的位置法方向和步长的方向是否一致，一致结果不为空，不一致为空
第二步：如果结果不为空，在确定切片的有效范围，开始下标对应的元素能取到，结束下标对应的元素不能取到。
第三步：在有效范围内，按照步长的反方向和绝对值获取元素
方向：步长为正，从开始下表到结束下表从前往后取；步长为负从后往前取
绝对值：绝对值为1，就一个一个取；绝对值为x,就取一个跳x-1个

b.怎么写切片获取指定元素
确定开始下标：需要结果中第一个数据在列表的下标
确定结束下标：结束下标是结果中最后一项的后一个数据或者前一个数据的下标（看方向）
确定步长：正负方向（从前往后还是从后往前）；再看绝对值（看一个一个取还是跳着取）

movies = ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']
print(movies[1:3:1])    # ['霸王别姬', '阿甘正传']
print(movies[3:-1:-1])  # []
print(movies[1:-2:-1])  # []
print(movies[-2:2:-2])  # ['雷神', '蝙蝠侠', '钢铁侠']
print(movies[6:2:-3])   # ['蚁人', '钢铁侠']
print('------------------------------华丽分割线-----------------------------')

print(movies[1:-1:1])       # ['霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神']
print(movies[-1:1:-2])      # ['复仇者联盟', '蚁人', '蜘蛛侠', '阿甘正传]
print(movies[-2:5:2])       # []
print(movies[0:-2:4])       # ['肖生克的救赎', '蜘蛛侠']
print(movies[5:-1:2])       # ['蝙蝠侠', '雷神']
print(movies[6:-6:-1])      # ['蚁人', '蝙蝠侠', '蜘蛛侠']

print('------------------------------华丽分割线-----------------------------')
# ['肖生克的救赎', '钢铁侠', '蚁人']
print(movies[0:-2:3])
# ['复仇者联盟', '雷神', '蚁人', '蝙蝠侠']
print(movies[-1:4:-1])
# ['钢铁侠', '霸王别姬']
print(movies[3:0:-2])
# ['雷神', '蝙蝠侠', '钢铁侠']
print(movies[-2:2:-2])
# ['霸王别姬', 蝙蝠侠']
print(movies[1:6:4])

3）切片省略写法

  • 省略步长 - 步长为1

    列表[开始下标:结束下标]

  • 省略开始下标 - 获取元素时从头开始（步长为正，从第一个开始；步长为负，从最后一个开始）

    列表[:结束下标:步长]

  • 省略结束下标 - 0获取元素的时候从开始下标开始，取完为止（可能是第一个也可能是最后一个）

    列表[开始下标::步长]

movies = ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']
print(movies[1:4])      # ['霸王别姬', '阿甘正传', '钢铁侠']
print(movies[-1:1])     # []

print(movies[:-2:2])    # ['肖生克的救赎', '阿甘正传', '蜘蛛侠', '蚁人']
print(movies[:2:-2])    # ['复仇者联盟', '蚁人', '蜘蛛侠']
print(movies[:4])       # ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠']

print(movies[2::2])     # ['阿甘正传', '蜘蛛侠', '蚁人', '复仇者联盟']
print(movies[4::-1])    # ['蜘蛛侠', '钢铁侠', '阿甘正传', '霸王别姬', '肖生克的救赎']
print(movies[3:])       # ['钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']

print(movies[::-2])     # ['复仇者联盟', '蚁人', '蜘蛛侠', '阿甘正传', '肖生克的救赎']

2.3 遍历 - 一个一个的获取列表中所有元素

1）方法1：

for 变量 in 列表:
    循环体（变量依次获取到的是列表中的每个元素）

2）方法2: - 通过获取所有元素的下标来获取元素

for 变量 in range(len(列表))
    循环体(列表[变量])

注：len(列表) - 获取列表长度

3）方法3:

for 变量1,变量2 in enumerate(列表):
    循环体(变量1依次获取到下标，变量2依次获取到每个元素)

scores = [90, 89, 87, 81, 79, 93, 67, 56, 43, 99]

# 方法1：
for x in scores:
    print(x)

# 求总分
sum1 = 0
for x in scores:
    sum1 += x
print('总分：', sum1)

# 统计90分以上学生人数
count = 0
for x in scores:
    if x >= 90:
        count += 1
print(count)

print('------------------------------华丽分割线-----------------------------')
list1 = [
    [10, 20],
    [100, 200],
    [1, 2]
]
for x in list1:
    print('x', x, x[-1])

print('------------------------------华丽分割线-----------------------------')
# 方法2
scores = [90, 89, 87, 81, 79, 93, 67, 56, 43, 99]
for x in range(len(scores)):
    print(x, scores[x])

print('------------------------------华丽分割线-----------------------------')
# 方法3：
for index, item in enumerate(scores):
    print('index:', index, 'item:', item)

3. 列表的增删改

3.1 增 - 添加元素

1）列表.append(元素) - 在指定列表后面添加指定元素（不会产生新列表，而是在原列表中添加）

heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']
print(heroes)
heroes.append('剑圣')
print(heroes)

案列：

# 案例：提取scores中所有不及格分数
scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
scores1 = []
for x in scores:
    if x < 60:
        scores1.append(x)
print(scores1)      # [45, 29, 59]

print('------------------------------华丽分割线-----------------------------')

# 练习；利用append删除列表中所有偶数
num = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
new_num = []
for x in num:
    if x % 2 != 0:
        new_num.append(x)
print(new_num)

print('------------------------------华丽分割线-----------------------------')

# 练习2：将scores中所有不及格的分数改成'补考'
scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
# [89, '补考', 99, 65, 93, 81, '补考', 88, 76, '补考', 66]
new_num1 = []
for x in scores:
    if x >= 60:
        new_num1.append(x)
    else:
        new_num1.append('补考')
print(new_num1)

2）列表.insert(下标, 元素) - 将指定元素插入列表中指定下标对应的元素前

heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']
heroes.insert(-1, '亚索')
print(heroes)   # ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '亚索', '蛇女']
heroes.insert(0, '石头人')
print(heroes)   # ['石头人', '寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '亚索', '蛇女']

3.2 删 - 删除元素

1）del 列表[下标] - 删除列表中指定下标对应元素

heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']

del heroes[1]
print(heroes)       # ['寒冰射手', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']

del heroes[1]
print(heroes)       # ['寒冰射手', '金克斯', '小法', '卡牌', '蛇女']

2）列表.remove(元素) - 删除列表中指定元素（如果元素不存在会报错，如果元素有多个，智慧删除前面那个）

heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']

heroes.remove('小炮')
print(heroes)       # ['寒冰射手', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']

# '维鲁斯'有多个的情况删除，只会删除前面那个
heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '维鲁斯', '蛇女']
heroes.remove('维鲁斯')
print(heroes)       # ['寒冰射手', '小炮', '金克斯', '小法', '卡牌', '维鲁斯', '蛇女']

3）pop

  • 列表.pop() - 取出列表最后一个元素
  • 列表.pop(下标) - 取出列表中指定下标对应元素，并且返回
heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '维鲁斯', '蛇女']

heroes.pop()
print(heroes)   # ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '维鲁斯']

result1 = heroes.pop(0)
print(heroes, result1)   # ['小炮', '维鲁斯', '金克斯', '小法', '卡牌', '维鲁斯']寒冰射手

3.3 改 - 修改元素的值

  • 列表[下标] = 新元素 - 将列表中指定下标对应的元素改成新元素
heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '维鲁斯', '蛇女']

heroes[1] = '孙悟空'
print(heroes)   # ['寒冰射手', '孙悟空', '维鲁斯', '金克斯', '小法', '卡牌', '维鲁斯', '蛇女']

练习：将scores中所有低于60分的成绩修改成0分（使用改来完成）

scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
# 方法1：
for index in range(len(scores)):
    if scores[index] < 60:
        scores[index] = 0
print(scores)       # [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]

# 方法2：
for index, item in enumerate(scores):
    if item < 60:
        scores[index] = 0
print(scores)

4. 列表的相关操作

4.1 列表加法运算

  • 列表1 + 列表2 - 将两个列表合并成一个新列表
A = [10, 20, 30]
B = [100, 200]
C = A + B
print(C)        # [10, 20, 30, 100, 200]

4.2 列表乘法运算

  • 列表 * N (N * 列表) - 将列表中元素重复N次产生一个新列表
C = A * 2
print(C)            # [10, 20, 30, 10, 20, 30]
print(B * 3)        # [100, 200, 100, 200, 100, 200]
print(['小米', '小花'] * 2)     # ['小米', '小花', '小米', '小花']

4.3 列表比较运算

1）比较是否相等： ==、!=

列表是有序的

# 列表是有序的
print([10, 20, 30] == [10, 20, 30])     # True
print([10, 20, 30] == [10, 30, 20])     # False

2）比较大小： >、<、>=、<=

列表1 > 列表2

两个列表比较大小，比较多是第一对不相等的元素（相同位置上的元素是一对）

print(10 in [10, 20, 30])       # True
print(10 in [[10, 20], 30])     # False
print([10, 20] in [10, 20, 30]) # False

练习：已知列表A和B，打印列表A、B的公共元素

A = ['后裔', '甄姬', '鲁班七号', '赵云']
B = ['小乔', '孙悟空', '猪八戒', '后裔', '盾山', '赵云']
C = []
for x in A:
    if x in B:
        C.append(x)
print(C)            # ['后裔', '赵云']

5.列表相关函数

5.1 sum(数字序列)

求数字序列中所有元素的数值的和

scores = [98, 23, 56, 88, 90, 79]
result = sum(scores)
print(result)

print(sum(range(101)))

5.2 max、min

  • max(序列) - 求序列中最大元素
  • min(序列) - 求序列中最小元素
scores = [98, 23, 56, 88, 90, 79]
result = max(scores)
result1 = min(scores)
print(result, result1)

用非函数方法求最大值和最小值

补充：求最大值的逻辑

scores = [50, 98, 23, 56, 88, 99, 79]
max1 = scores[0]
for x in scores[1:]:
    if x > max1:
        max1 = x
print(max1)

求最小值的逻辑

min1 = scores[0]
for x in scores[1:]:
    if x < min1:
        min1 = x
print(min1)

5.3 sorted

1）sorted(序列) - 将序列中元素按照从小到大的方式排序，创建一个新的序列(不会在原序列上排序)，并返回

scores = [50, 98, 23, 56, 88, 99, 79]
result = sorted(scores)
print(result)       # [23, 50, 56, 79, 88, 98, 99]

2）sorted(序列, reverse=True) - 将序列中的元素按照从大到小的方式排序，创建一个新的序列(不会在原序列上排序)，并返回

result = sorted(scores, reverse=True)
print(result)       # [99, 98, 88, 79, 56, 50, 23]

5.4 len

  • len(序列) - 统计序列中元素个数
print(len(scores))          # 7
print(len('agh39yf!'))      # 8
print(len(range(1, 100, 2)))    # 50

5.5 list

  • list(序列) - 将制定序列转换为列表(任何序列都可以转化为列表，转化的时候直接将序列的元素作为列表对元素)
result = list('sdn345')
print(result)       # ['s', 'd', 'n', '3', '4', '5']

result = list(range(5))
print(result)       # [0, 1, 2, 3, 4]

6.列表相关方法

列表.xxx()

6.1 列表.clear() - 清空列表

nums = [10, 9, 89, 7, 8, 3]
nums.clear()
print(nums)     # []

6.2 列表.count(元素) - 统计列表中指定元素的个数

nums = [10, 9, 8, 7, 8, 3]
print(nums.count(100))      # 0
print(nums.count(8))        # 2
print(nums.count(9))        # 1

6.3 列表.extend(序列) - 将序列中的元素全部添加到列表中

# 添加一个元素
list1 = [10, 20]
list1.append([100, 200])
print(list1)    # [10, 20, [100, 200]]

# 一次添加多个元素
list1 = [10, 20]
list1.extend([100, 200])
print(list1)    # [10, 20, 100, 200]

list1.extend('abc')
print(list1)    # [10, 20, 100, 200, 'a', 'b', 'c']

6.4 列表.index(元素)

  • 获取列表中指定元素对应下标(返回的是从0开始的下标值)

  • 若指定元素有两个对应下标，返回的是第一个

nums = [10, 9, 89, 23, 10]
print(nums.index(89))       # 2
print(nums.index(10))       # 0

6.5 列表.reverse() - 将列表倒序

nums = [10, 9, 89, 23, 50]
nums.reverse()
print(nums)     # [50, 23, 89, 9, 10]

6.6 sort

1）列表.sort() - 将列表中元素从小到大排序（直接修改原列表中顺序）

2）列表.sort(reverse=True) - 将列表的元素从大到小排序

nums = [10, 9, 89, 23, 50]
result = nums.sort()
print(result)       # None
print(nums)         # [9, 10, 23, 50, 89]

3）sort和sorted区别

  • 列表.sort - 直接修改原列表中顺序
  • sorted() - 不修改原列表中元素顺序，而是创建一个新列表
nums = [10, 9, 89, 23, 50]
nums.sort()
print(nums)			# [9, 10, 23, 50, 89]

nums = [10, 9, 89, 23, 50]
result = sorted(nums)
print(nums)         # [10, 9, 89, 23, 50]
print(result)       # [9, 10, 23, 50, 89]

7.列表赋值问题

补充：python中变量保存数据，保存的是数据在内存中的地址（Python中的比那里全部都是指针变量）

7.1 拷贝和直接赋值

需求：已知一个列表：现在需要创建和原列表一模一样的新列表

nums = [10, 20, 30, 40]

1）直接赋值

一个变量直接给另外一个变量赋值，赋的是地址，赋值后两个变量指向都是同一个内存

nums2 = nums
print('nums2:', nums2)

2）拷贝

一个变量通过拷贝的方式给另外一个变量赋值，赋值的时候会先复制原来变量中的数据，创建一个新的数据，然后将新的数据对应的地址给新的变量

nums3 = nums*1
print('nums3:', nums3)

nums4 = nums + []
print('nums4:', nums4)

nums5 = nums[:]
print('nums5:', nums5)

nums6 = nums.copy()
print('nums6:', nums6)

  • 如果对原nums进行修改，直接赋值的nums2会跟着改变，而拷贝的不会跟着改变

    nums.append(100)
print('nums:', nums)        # nums: [10, 20, 30, 40, 100]
print('nums2:', nums2)      # nums2: [10, 20, 30, 40, 100]
print('nums3:', nums3)      # nums3: [10, 20, 30, 40]
print('nums4:', nums4)      # nums4: [10, 20, 30, 40]
print('nums5:', nums5)      # nums5: [10, 20, 30, 40]
print('nums6:', nums6)      # nums6: [10, 20, 30, 40]

在这里插入图片描述

8. 列表推导式

列表推导式的作用：快速创建列表表达式（代码简洁）

8.1 列表推导式结构1

1）语法：

[表达式 for 变量 in 序列]

2）让变量去序列中取值，一个一个取，取完为止，每取一个值就计算一次表达式结果，并且将计算结果作为列表的一个元素

result = [10 for x in range(5)]
print(result)       # [10, 10, 10, 10, 10]

result = [x*2 for x in range(5)]
print(result)       # [0, 2, 4, 6, 8]

# 案例1：将nums中所有元素乘2
nums = [10, 23, 89, 67]
nums1 = [x*2 for x in nums]
print(nums1)        # [20, 46, 178, 134]

# 案例2：获取nums中所有元素的个位数
nums = [103, 130, 89, 67]
nums1 = [x % 10 for x in nums]
print(nums1)        # [3, 0, 9, 7]

8.2 列表推导式结构2

1）语法：

[表达式 for 变量 in 序列 if 条件语句]

2）变量去序列中取值，一个一个的取，取完为止，没去一个值就判断一次条件是否成立，如果成立就计算表达式的值作为列表元素

result = [x * 2 for x in range(5) if x % 2 == 0]
print(result)       # [0, 4, 8]

# 案例1：删除scores中所有不及格的分数
scores = [80, 99, 23, 67, 56, 82, 76, 45]
result = [x for x in scores if x >= 60]
print(result)       # [80, 99, 67, 82, 76]

# 案例2：提取nums中所有奇数个位数
nums = [103, 130, 89, 67, 78]
result = [x % 10 for x in nums if x % 2 != 0]
print(result)       # [3, 9, 7]
8]

# 案例1：将nums中所有元素乘2
nums = [10, 23, 89, 67]
nums1 = [x*2 for x in nums]
print(nums1)        # [20, 46, 178, 134]

# 案例2：获取nums中所有元素的个位数
nums = [103, 130, 89, 67]
nums1 = [x % 10 for x in nums]
print(nums1)        # [3, 0, 9, 7]

8.2 列表推导式结构2

1）语法：

[表达式 for 变量 in 序列 if 条件语句]

2）变量去序列中取值，一个一个的取，取完为止，没去一个值就判断一次条件是否成立，如果成立就计算表达式的值作为列表元素

result = [x * 2 for x in range(5) if x % 2 == 0]
print(result)       # [0, 4, 8]

# 案例1：删除scores中所有不及格的分数
scores = [80, 99, 23, 67, 56, 82, 76, 45]
result = [x for x in scores if x >= 60]
print(result)       # [80, 99, 67, 82, 76]

# 案例2：提取nums中所有奇数个位数
nums = [103, 130, 89, 67, 78]
result = [x % 10 for x in nums if x % 2 != 0]
print(result)       # [3, 9, 7]

9.三目运算符

三目运算符 - 运算对象有三个的运算符就是三目运算符

python

9.1 单目运算符：not；

9.2 双目运算符：+、-、*、…、>、<、…、and、or、…；

print(10 + 20)

9.3 python的三目运算符

表达式1 if 条件语句 else 表达式2

先判断条件语句是否成立，如果成立整个运算结果就是表达式1的值，否则就是表达式2的值

age = 6
result = '成年' if age >= 18 else '未成年'
print(result)

C语言三目运算符 - ?:

条件语句?值1:值2

如果条件语句为真整个运算结果是表达式1的结果，否则是表达式2的结果

路u
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python列表总结.pdf
03-11
Python列表总结.pdf
Python列表(List)知识点总结
09-19
在本篇文章中小编给大家分享了关于Python列表(List)知识点一直对应的实例内容，需要的朋友们学习下。
python列表总结
weixin_42226195的博客
09-10 3181
序列（列表） 文章目录序列（列表）一、序列是什么？二、列表2.1 列表的语法2.2 列表的创建2.2.1 基本语法创建2.2.2 list()创建2.2.3 range()创建整数列表2.2.4 推导式生成列表2.3列表元素的增加和删除2.3.1 添加元素 append()2.3.2 运算符操作2.3.3 extend()方法2.3.4 insert()插入元素2.3.5 乘法扩展2.3.6 列表元素的删除2.3.7 pop()方法2.3.8 remove()方法2.4 列表元素访问和计数2.5 index
Python列表小总结
ClementCXL的博客
04-26 4914
Python学习第二天列表七十二变1.0、关于列表的方法入门合集1.0.0、用下标访问列表元素①、什么是列表的下标②、index方法查找下标③、什么是切片1.0.1、对列表进行添加元素①、使用append()方法对列表末尾添加元素②、insert()方法对列表任意位置添加元素，（格式为：列表名.insert(下标,'元素'）1.0.2、删除列表元素①、使用del []永久删除列表元素，可以使用de...
序列总结：元组和列表、字典和集合之间的关系
纸飞机的博客
03-04 3766
序列 序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放多个值的连续的内存空间。比如一个整数序列[10,20,30,40]，可以这样示意表示： 由于 Python3 中一切皆对象，在内存中实际是按照如下方式存储的： a = [10,20,30,40] 从图示中，我们可以看出序列中存储的是整数对象的地址，而不是整数对象的值。 python中常用的序列结构： 序列解包： ...
总结列表显示ListView知识点
weixin_30537451的博客
11-15 2057
全选ListView的item条目 单选ListView的条目 多选ListView的item条目 自定义ArrayAdapter动态改变ListView的不同item样式 动态增加和删除ListView的条目 使用SimpleAdapter为ListView创建适配器（SimpleAdapter可以使ListView中的每一个item条目视图的内容更加个性化，例如可以动态地增加图像） ...
postgresql 常用知识点总结列表
blue0bird的专栏
11-19 1254
postgresql 常用知识点总结
python列表索引总结
热门推荐
06-03 4万+
Python包含6种内建序列： 列表 元组 字符串 Unicode字符串 buffer对象 xrange对象 1.数据结构 数据结构是以某种方式（如通过编号）组合起来的数据元素（如数、字符乃至其他数据结构）集合。在Python中，最基本的数据结构为序列（sequence）。序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，依此类推。在有些编程语...
五种生成列表方式总结
weixin_42618420的博客
12-20 2051
五种生成列表方式总结 ##利用timeit测算各个方法的速度，其中 ‘’+’'效率最低。 ```python # 加法　''+'' def t1(): li = [] for i in range(10001): li += [i] # ''append'',note:append 只能单个元素往里添加 def t2(): li = [] for ...
总结列表，元组，字典，集合的区别
weixin_30237281的博客
09-20 1万+
1.列表，元组，字典是有顺序的，而集合是没顺序的 2.列表是以方括号形式表示，元组是以圆括号表示，字典以花括号表示，集合则是以[()]的形式表示 3.列表是可变对象,它支持在原处修改的操作.也可以通过指定的索引和分片获取元素。区别于元组，可动态增加，删除，更新。 4.元组和列表在结构上没有什么区别，唯一的差异在于元组是只读的，不能修改。元组用“()”表示。元组一旦定义其长度和内容都是固定的。...
Python列表，元组，字典，集合的比较总结【表格对比】
土豆
12-29 1164
区别总结 列表，元组，字典，集合，都用于存放数据，它们区别总结如下： 项目 列表 元组 字典 集合 关键字 list tuple dict set 是否可变 可变 不可变 可变 可变 是否有序 有序 有序 无序 无序 元素是否重复 可重复 可重复 键不可重复 不可重复 定义符号 [] () {key:value} {} 创建 []直接创建
列表的函数总结
huyafangSTORM的博客
02-01 1258
列表的函数总结 #coding=bgd #列表的各种函数方法 langueges=["english","chinese","japenese","spanish","korean"] #添加元素 langueges.append('finnish')#在列表末尾添加新元素 langueges.insert(2,'indian')#在任何位置添加新元素，2是索引 #删除元素 del langueg...
python列表方法总结
12-22
append() 方法用于在列表末尾添加新的对象。 语法 list.append(obj) 参数 obj：添加到列表末尾的对象。 返回值 该方法无返回值，但是会修改原来的列表。 实例 list1 = ['hello', 'world', 'python'] list1.append('...
Python列表解析操作实例总结
12-20
本文实例讲述了Python列表解析操作。分享给大家供大家参考，具体如下： 列表解析 Python 的强大特性之一是其对 list 的解析，它提供一种紧凑的方法，可以通过对 list 中的每个元素应用一个函数，从而将一个 list ...
Python列表List基础知识点总结
12-21
Python列表List基础知识点总结 #!/usr/bin/env python # -*- coding:utf-8 -*- # @Time : 2020/4/16 21:38 # @Author: xuhui # @File : List.py print() print("`````aaaaaaaaa`````") print() # 创建一个列表list1...
【Python】Python中变量或者函数加下划线‘_‘的含义
yangweipeng708的博客
05-14 678
理解这些约定可以帮助Python开发者编写更清晰、更Pythonic的代码，并理解其他Python代码中的命名习惯。）通常用来指示特定的编程约定或用法，这些约定主要关乎变量和函数的可访问性以及预期的使用范围。在Python中，变量或函数前面加一个下划线（
python数据分析numpy基础之intersect1d求数组交集
最新发布
sinat_34735632的博客
05-19 195
python的numpy库的intersect1d(x,y)函数，计算x和y的公共元素，并返回去重后的有序结果。相当于求两个数组中的交集，并且进行去重和排序。numpy.intersect1()查找两个数组的公共元素，并且返回去重后的有序结果。ar1，ar2：必选，列表、元组、数组；如果是多维则自动转一维数组；assume_unique：可选，bool，默认False，若为True则可以加快计算素材，此时ar1和ar2需为元素唯一的数组，否则结果不会去重；
windows11 Django环境安装
云深海阔专栏
05-15 162
3）在这个文件夹中使用manager.py和runserver命令运行开发 web 服务器。2）使用 django-admin 工具创建一个名为“mytestsite”的新框架站点。浏览器上访问http://localhost:800。2、windows10 虚拟环境设置。1、验证python和pip3环境。1）创建文件夹及项目目录。4）web浏览器上验证。3、安装Django。
python数据分析——时间序列
qq_74013365的博客
05-14 1996
时间序列是按照时间顺序排列的一系列随时间变化而变化的数据点或观测值。时间序列可以是离散的，例如每月的销售数据，也可以是连续的，例如气温和股票价格等。时间序列常用于预测和分析未来的趋势，例如经济增长、股票走势、天气变化等。时间序列分析是数据分析中的重要部分，它涉及到对随时间变化的数据进行研究，以揭示其内在规律、趋势和周期性变化。Python作为一种强大的编程语言，拥有众多的数据处理和可视化库，如pandasnumpymatplotlib和seaborn等，这些库在处理时间序列数据时表现出色。
python如何根据姓名从总结表分出来不同的列表和内容
05-28
假设总结表的格式为一个包含多个字典的列表，每个字典包含姓名和其他信息，可以使用以下代码根据姓名从总结表分出不同的列表和内容： ```python summary = [ {'姓名': '张三', '年龄': 30, '性别': '男'}, {'姓名...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值