Python基础05_列表&元组（上）

于 2024-09-29 19:36:24 发布
阅读量624 收藏 4
点赞数 22
分类专栏： python基础学习 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l15202833159/article/details/142637878
版权

目录

列表

1、获取列表中的数据---索引

1.正向索引

2.反向索引

3.切片索引

2、更新列表

3、删除列表元素

4、列表操作

1.长度 len()

2.组合

3.重复

4.元素是否存在于列表中

5.嵌套列表

6.列表常用API

操作列表的函数

列表的方法

元组（上）

1、创建元组

2、访问元组

3、修改元组

4、删除元组

列表

列表是用方括号 [ ] 标注，逗号分隔的一组值。列表可以包含不同类型的元素，但一般情况下，各个元素的类型相同。
列表是一种复合数据类型(数据容器)：

x = [10, 20, 3.6, 1+3j, True, "hello", "你好"]
print(x)  # [10, 20, 3.6, (1+3j), True, 'hello', '你好']

1、获取列表中的数据---索引

索引：与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

列表的索引(下标，index)不能超出索引范围(越界)。

1.正向索引
# 正向索引
y1 = x[0]
print(y1)  # 10
2.反向索引
print(x[-1])  # 你好

连续访问：

x = [10, 20, 30, 40, 50, 60]
for i in range(len(x)):
    print(x[i])

# 10
# 20
# 30
# 40
# 50
# 60
3.切片索引

使用下标索引来访问列表中的值，同样也可以使用方括号 [ ] 的形式截取字符。

#切片索引
x = [10, 20, 30, 40, 50, 60, 70, 80]
x2 = x[3:5]  # x2表示从x列表中截取一个片段 得到一个新的列表 [3,5) 不包含最后
print("x2:", x2)  # x2: [40, 50]

x3 = x[2:-2]  # 从左往右取数据 从2对应的元素开始取值 一直取到-2对应的元素
print("x3:", x3)  # x3: [30, 40, 50, 60]

x4 = x[-3:4]  # 从左往右取数据 若切片的范围没能取到任何元素 就会得到一个空列表(不会报错)
print("x4:", x4)  # x4: []

x5 = x[1:100]
print("x5:", x5)  # x5: [20, 30, 40, 50, 60, 70, 80]

x6 = x[50:100]
print("x6:", x6)  # x6: []

x7 = x[:4]  # 省略冒号前面的 就表示从x[0]开始
print("x7:", x7)  # x7: [10, 20, 30, 40]

x8 = x[4:]  # 省略冒号后面的 就表示到len(x)结束
print("x8:", x8)  # x8: [50, 60, 70, 80]

x = [10, 20, 30, 40, 50, 60, 70, 80]
x9 = x[1:6:2]  # 步长为2 x[1] x[3] x[5]
print("x9:", x9)  # x9: [20, 40, 60]

x10 = x[::2]
print("x10:", x10)  # x10: [10, 30, 50, 70]

x11 = x[::-1]  # 倒置
print("x11:", x11)  # x11: [80, 70, 60, 50, 40, 30, 20, 10]

x12 = x[1:5:-1]  # 从1取不到5
print("x12:", x12)  # x12: []
# 步长为负数时，一般不设置起始的索引

# 列表反转
print(x[::-1])  # [80, 70, 60, 50, 40, 30, 20, 10]

2、更新列表

对列表的数据项进行修改或更新。

# 列表反转
print(x[::-1])  # [80, 70, 60, 50, 40, 30, 20, 10]

# 更新列表
x = [10, 20, 30, 40, 50]
x[0] = 100  # 通过下标修改列表数据
print(x)  # [100, 20, 30, 40, 50]
print(x[0])  # 100

# 添加元素到列表的末尾
x.append(60)
print(x)  # [100, 20, 30, 40, 50, 60]

# 更新切片 不会修改原列表(深拷贝)
x = [10, 20, 30, 40, 50, 60]
x2 = x[:]
print("x:", x)  # x: [10, 20, 30, 40, 50, 60]
print("x2:", x2)  # x2: [10, 20, 30, 40, 50, 60]
print(id(x), id(x2))  # 2355473587904 2355473588096
x2[0] = 100
print("x2的下标对应的元素被修改后：", x2)  # [100, 40, 50]
print("x的下标对应的元素被修改后：", x)  # [10, 20, 30, 40, 50, 60]

关于浅拷贝、深拷贝：

浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。

x = [10, 20, 30]
x2 = x
print(x)
print(x2)
print(id(x), id(x2))  # 1513955235648 1513955235648

深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。

x = [10, 20, 30]
x2 = [x[0], x[1], x[2]]
print(x)
print(x2)
x2[0] = 50
print(x)  #[10, 20, 30]
print(x2)  #[50, 20, 30]

注意：切片得到的是一个新的列表，且切片是取值操作，不能赋值。

# x[2:3] = 100  是错误语句

同时列表的切片的元素是一种浅拷贝过来的元素，切片后，新列表中的元素和原列表中的切片范围的元素 “长得一样”是通过浅拷贝得到的。

x = [10, -20, "hello", True, None, 1000, [10, 20, 30, 40]]


# 列表的切片的元素是一种浅拷贝过来的元素
x3 = x[3:]

x4 = x3[-1]

x4[0] = 99999
print("x:", x)  # x: [10, -20, 'hello', True, None, 1000, [99999, 20, 30, 40]]
print("x3:", x3)  # x3: [True, None, 1000, [99999, 20, 30, 40]]
print("x4:", x4)  # x4: [99999, 20, 30, 40]

3、删除列表元素

可以使用 del 语句来删除列表的的元素。

x = [10, 20, 30, 40, 50]
del x[2]
print(x)  # [10, 20, 40, 50]

4、列表操作

1.长度 len()
2.组合
x = [10, 20, 30, 40, 50]
x2 = x + [60]
print(x2)  # [10, 20, 40, 50, 60]
3.重复
x3 = x*2
print(x3)  # [10, 20, 40, 50, 10, 20, 40, 50]
x3 = x*0
print(x3)  # []
4.元素是否存在于列表中
x = [[10, 20], [20, 30], 90, 100]
x2 = [10, 20]
re = x2 in x  # x2变量中保存的数据 在x中有没有“一样”的元素（数据一样就行不需要一定是同一个元素）
print(re)  # True
x2[0] = 100
print(x2, x)  # [100, 20] [[10, 20], [20, 30], 90, 100]

5.嵌套列表

即在列表里创建其它列表。

# 嵌套列表
x = [1, 2, 3, 4]
x2 = ["a", "b", "c"]
x3 = [x, x2]
print(x3)  # [[1, 2, 3, 4], ['a', 'b', 'c']]
x4 = x3[0]
print(x4)  # [1, 2, 3, 4]
print(x4[3])  # 4
print(x3[0][3])  # 4

6.列表常用API

操作列表的函数
  • len(list) 返回列表元素个数
  • max(list) 返回列表元素最大值
  • min(list) 返回列表元素最小值
x = [10, 20, 30, 40, 50, 100]
print(len(x))  # 6
print(max(x))  # 100
print(min(x))  # 10
  • list(seq)将可迭代数据转化为列表
# list(seq)将可迭代数据转化为列表
re = range(10)
x = list(re)
print(x)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
re = "hello"
x = list(re)
print(x)  # ['h', 'e', 'l', 'l', 'o']
re = (10, 20, 30)
x = list(re)
print(x)  # [10, 20, 30]

常见的官方提供的迭代数据：range、字符串、元组、列表

列表的方法
  • list.append() 在列表末尾添加新的对象。

以一道易错题为例：

# list.append() 在列表末尾添加新的对象
x = [10, 20, 30, 40]
for i in range(len(x)):
   temp = x[i]
   del x[i]
   x.append(temp)
print(x)  # [20, 40, 30, 10]

输出结果是[20, 40, 30, 10]而并非是简单的[40, 30, 20, 10]，建议将每一步循环结果列出。

  • list.count() 统计某个元素在列表中出现的次数
# list.count() 统计某个元素在列表中出现的次数
x = [[10, 20], 10, 20, [10, 20]]
n = x.count(10)  # 查看x列表中的每一个元素有几个10
print(n)  # 1
print(x.count([10,20]))  # 2
  • list.extend() 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
# list.extend() 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
x = [10, 20, 30, 40]
x2 = [10, 1, 2, 3, 3]
x.extend(x2)  # 会直接修改x列表  只能传入可迭代数据(列表、字符串、元组、range)
print(x)  # [10, 20, 30, 40, 10, 1, 2, 3, 3]
x.extend(range(2,9,3))
print(x)  # [10, 20, 30, 40, 10, 1, 2, 3, 3, 2, 5, 8]
  • list.index() 从列表中找出某个值第一个匹配项的索引位置
x = [10, 20, 30, 40]
print(x.index(30))  # 2
  • list.insert(index, obj) 将对象插入列表
x = [10, 20, 30, 40]
x.insert(2, 50)
print(x)  # [10, 20, 50, 30, 40]
x.insert(100, 666)
print(x)  # [10, 20, 50, 30, 40, 666]  # 插入元素到指定位置时，若越界则插入到开头或者末尾

x.insert(len(x), 100)
print(x)  # [10, 20, 50, 30, 40, 666, 100]
  • list.pop(index=-1) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
x = [10, 20, 30]
re = x.pop(0)  # 移除指定的下标对应的元素，并返回这个移除的元素，默认移除最后一个元素
# 移除元素的下标不能越界
print(re)  # 10
print(x)  # [20, 30]

  • list.remove(obj) 移除列表中某个值的第一个匹配项

# list.remove(obj) 移除列表中某个值的第一个匹配项
x = [10, 20, 30, 40, 50]
re = x.remove(10)  # 移除的元素必须在列表中
print(re)  # None
print(x)  # [20, 30, 40, 50]

  • list.clear() 清空列表

# list.clear() 清空列表
x = [10, 20, 30]
x.clear()
print(x)  # []

  • list.copy() 复制列表

x = [10, 20, 30]
x2 = x.copy()
print("x:", x)  # x: [10, 20, 30]
print("x2:", x2)  # x2: [10, 20, 30]
print(x is x2)  # False
x2[0] = 100
print(x, x2)  # [10, 20, 30] [100, 20, 30]  # 深拷贝

x = [[10, 20, 30], 20, 30]
x2 = x.copy()
x2[0][0] = 50  # 注意区别
print(x, x2)  # [[50, 20, 30], 20, 30] [[50, 20, 30], 20, 30]

  • list.reverse() 反向列表中元素

# list.reverse() 反向列表中元素
x = [10, 20, 30]
x2 = x[::-1]  # 创建新的变量空间
print(x, x2)  # [10, 20, 30] [30, 20, 10]
x3 = x.reverse()  # 在原有列表上修改
print(x3)  # None
print(x)  # [30, 20, 10]
  • list.sort(key=None,reserve=False) 对原列表进行排序
# list.sort(key=None,reserve=False) 对原列表进行排序
x = [3, 5, 7, 8, 1, 2, 9]
# 按绝对值大小顺序排列
x.sort(key = lambda a:abs(a), reverse=False)
print(x)  # [1, 2, 3, 5, 7, 8, 9]
x.sort(key = lambda a:abs(a), reverse=True)
print(x)  # [9, 8, 7, 5, 3, 2, 1]

例题：在列表里再生成100行、80列的列表（一行80个元素，共100行）

import random
x = []
for j in range(100):
    row = []
    for i in range(80):
        row.append(int(random.random() * 100))
    x.append(row)
print(x)

元组（上）

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

1、创建元组

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

# 元组(tuple)

x = (1, 2, 3)
print(x)  # (1, 2, 3)

 也可以不使用括号：

# 不使用括号
x = "a", "b", "c", "d"
print(x)  # ('a', 'b', 'c', 'd')

元组中只包含一个元素时，需要在元素后面添加逗号 ，否则括号会被当作运算符使用：

# 元组 只包含一个元素时
# 需要在元素后面添加逗号
x = (10,)
print(x)  # (10,)

x = 20,
print(x)  # (20,)

a = 100
x = a,
print(x)  # (100,)

# 这种括号不是元组的圆括号，它是括号运算符
x = (10)
print(x)  # 10

2、访问元组

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

# 访问元组
x = (10, 20, "hello", True, 3.14, -7.8)
print(x[0])  # 10
print(x[1:3])  # (20, 'hello')
print(x[2:])  # ('hello', True, 3.14, -7.8)
print(x[:4])  # (10, 20, 'hello', True)

3、修改元组

元组中的元素值是不允许修改的，但可以对元组进行连接组合

# 修改元组
x = 10, 20, 30
print(x[-1:])  # (30,)

x = (10, 20, "hello")
a, b, c = x  # a = x[0]  b = x[1]  c = x[2]
print(a, b, c)  # 10 20 hello

x = 10, 20
x2 =30, 40
x3 = x + x2
print(x3)  # (10, 20, 30, 40)

4、删除元组

元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组

# 删除元组
x = (10, 20, "hello", True, 3.14, -7.8)
print(x)  # (10, 20, 'hello', True, 3.14, -7.8)
del x
print(x)  # NameError: name 'x' is not defined

baijin_cha
关注
专栏目录
零基础学python 第二章 列表和元组
12-21
Python编程语言中，列表（List）和元组（Tuple）都是序列类型的数据...理解列表和元组的区别及各自的应用场景，是掌握Python基础的重要一环。在实际编程中，根据需求选择适当的数据结构，可以有效地组织和处理数据。
list用法
denglilou8688的博客
10-21 172
list: 特点: 有序 可变 创建list: a = list(“hello”) a = [1,2,3,4] 空list a=list() / a=[] 方法： a = [1,2,3,4] append 在列表末尾添加新的对象 In [11]: a.append(6) In [12]: a Ou...
python列表知识点_Python列表List基础知识点总结
weixin_30302513的博客
02-03 627
#!/usr/bin/env python# -*- coding:utf-8 -*-# @Time : 2020/4/16 21:38# @Author: xuhui# @File : List.pyprint()print("`````aaaaaaaaa`````")print()# 创建一个列表list1；初始其中有三个元素，分别为："R1", "0.0.0.0", 11print("`...
python练习题__列表
逆境清醒的博客
04-04 1039
python练习题__列表
Python list列表添加元素的3种方法
sinat_40572875的博客
11-11 536
实际开发中，经常需要对列表进行更新，包括向列表中添加元素、修改表中元素以及删除元素。本节先来学习如何向列表中添加元素。《》一节告诉我们，使用+运算符可以将多个序列连接起来；列表是序列的一种，所以也可以使用+进行连接，这样就相当于在第一个列表的末尾添加了另一个列表。请看下面的演示：运行结果：从运行结果可以发现，使用+会生成一个新的列表，原有的列表不会被改变。+更多的是用来拼接列表，而且执行效率并不高，如果想在列表中插入元素，应该使用下面几个专门的方法。
Python之列表（list）基础知识点
酒酿小圆子呀～
02-07 3259
del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等，但不能是单个的数字。需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。使用+运算符可以将多个序列连接起来；当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。
python列表基础_列表_python_
09-30
本教程将深入探讨Python列表的基础知识，包括创建、访问、修改和操作列表。 ### 创建列表 创建一个列表非常简单，只需将元素放在方括号内并用逗号分隔即可。例如： ```python my_list = [1, 2, "three", 4.5] ``` #...
Python程序基础：列表和元组.pptx
06-06
列表和原组;列表（list）是包含0个或多个元素的有序...Python提供的元组内置函数有len()、max()、min()和tuple()。 tuple()函数的功能是以一个序列为参数，并把它转换为元组，如果参数本身是元组，则原样返回该参数。
元组列表字典（莫烦python基础）
09-19
在Python编程语言中，数据结构是非常重要的组成部分，其中包括列表、元组和字典。这些数据结构各有特点，分别适用于不同的场景。接下来我们将详细介绍这三种数据结构，并通过示例代码进行说明。 首先，元组（Tuple...
Python程序基础：列表和元组典型案例.pptx
06-06
列表与元组综合案例 例：编写一个简易计算器，要求根据输入的数字和四则运算符号，计算运算结果并输出。 operator_list = ['+','-','*','/'] #创建列表并赋值四则运算符 number_1 = float(input("请输入第一个操作数...
为什么应尽量从列表的尾部进行元素的增加与删除操作？
qq_29023939的博客
04-21 8358
什么是列表： 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。 列表的数据项不需要具有相同的类型 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示： list1=[1,2,3,4,5] list2=['name','people'] 原因： 当列表从中间或从头增加或删除元素时，列表对象自动进行内存扩展或收缩，从而保证元素之间没有缝隙...
3、Python学习笔记 - 列表基本操作
南宫柒的博客
03-15 588
对字符串列表进行排序时，先对大写字母排序，再对小写字母排序。若不区分大小写，则需要添加 key=str.lower对列表中的中文内容进行排序时，不能直接使用sort()方法。如果指定的元素没有在列表中，则会报错。在使用时需要先判断列表中是否有该元素。反转后列表不会自动回复成原来的格式，需要再次进行反转操作才行。默认删除列表最后一个元素，如果加上索引则删除对应索引的元素。key:表示指定一个从每个列表元素中提取出一个用于比较的键。也可以对要统计的列表进行切片操作。listname:要排序的列表名。
python中list[1啥意思_详解Python中list[::-1]的几种用法
weixin_29571873的博客
03-02 6233
本文主要介绍了Python中list[::-1]的几种用法，分享给大家，具体如下：s = "abcde"list的[]中有三个参数，用冒号分割list[param1:param2:param3]param1，相当于start_index，可以为空，默认是0param2，相当于end_index，可以为空，默认是list.sizeparam3，步长，默认为1。步长为-1时，返回倒序原序列举例说明pa...
python机考真题篇（一）
u011176725的博客
09-24 2092
题库by：南昌工学院-公共课python。相对非常基础的内容。未完待续..........下篇。
Python 基础知识4 列表操作
qq_36071362的博客
02-26 364
# 列表定义 list1 = ['Google', 'Runoob', 1997, 2000] list2 = [1, 2, 3, 4, 5, 6, 7] print("list1[0]: ", list1[0]) print("list2[1:5]: ", list2[1:5]) # 修改列表元素值 list1[0] = 2000 print("list1[0]: ", list1[0]...
python基础(一)、列表的创建和操作
热门推荐
weixin_36670529的博客
12-06 1万+
目录 一、列表是什么 1、访问列表元素 2、索引从0而不是1开始 3、使用列表中的各个值 二、修改、添加和删除元素 1、修改列表元素 2、在列表中添加元素 1、列表末尾添加元素 2、在列表中插入元素 3、从列表中删除元素 1.使用del语句删除元素 2、使用方法pop删除元素 3、弹出列表中的人位置处的元素 4、根据值删除元素 三、组织列表 1、使用s...
Python--列表
墨上烟雨
06-20 9039
一、列表的创建。
python list的函数
dili8870的博客
04-04 625
1. list.append(obj) 在列表末尾添加新的对象 2. list.count(obj) 统计某个元素在列表中出现的次数 3. list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） 4. list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 5. list.insert(index,ob...
Python 中如何向列表或数组添加元素
最新发布
Python热爱者的博客
07-08 2393
编程中的数组是一个有序的项目集合，所有的项目都需要是相同的数据类型。然而，与其它编程语言不同，数组在 Python 中不是一个内置的数据结构。Python 使用列表取代传统的数组。列表本质上是动态数组，是 Python 中最常见的和最强大的数据结构之一。你可以把它们想象成有序的容器。它们将同类相关的数据存储和组织在一起。存储在一个列表中的元素可以是任何数据类型。可以有整数列表、浮点数列表、字符串列表，以及任何其它内置 Python 数据类型的列表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值