python 常用数据结构-列表

list 列表

列表定义与使用
列表常用方法
列表嵌套
列表推导式

列表定义

列表是有序的可变元素的集合，使用中括号[]包围，元素之间用逗号分隔
列表是动态的，可以随时扩展和收缩
列表是异构的，可以同时存放不同类型的对象
列表中允许出现重复元素

列表使用：创建

创建列表
- 通过构造函数创建
- 中括号创建并填充
- 列表推导式

# 1、通过构造函数创建
li1 = list()  # 空列表
li1 = list('hogwarts')  # 字符串
li1 = list((1, 2, 3))  # 元组
li1 = list({4, 5, 6})  # 集合
li1 = list({'a': 7, 'b': 8})  # 字典
print(type(li1), li1)

# 2、中括号创建并填充元素
li2 = []  # 空列表
li2 = [1, 2, 3]  # 直接填充对象
print(type(li2), li2)

列表使用：索引

索引
- 默认正向索引，编号从 0 开始。
- 支持反向索引，编号从-1 开始。

li = [1, 2, 3, 4, 5]

# 1、正向索引
print(li[0])  # 打印1
print(li[3])  # 打印4

# 2、反向索引
li = [1, 2, 3, 4, 5]
print(li[-1])  # 打印 5

列表使用：索引示意图

在这里插入图片描述

列表使用：切片

切片 [start: stop: step]
- start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
- stop 值: 指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取列表允许的最大索引值；
- step 值: 步长值指示每一步大小，如果没有指定，则默认步长值为 1。
- 三个值都是可选的，非必填

列表使用：切片示意图

在这里插入图片描述

列表使用：切片实例

# 切片基本用法
li = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']
print(li[0:5:2])  # 打印['h', 'g', 'a']
print(li[2:4])  # 省略了step，打印['g', 'w']
print(li[:4])  # 省略了start和step，打印['h', 'o', 'g', 'w']
print(li[2:])  # 省略了stop和step，打印['g', 'w', 'a', 'r', 't', 's']
print(li[::2])  # 省略start和stop，打印['h', 'g', 'a', 't']
print(li[::-1])  # 特殊的切片写法：逆序打印['s', 't', 'r', 'a', 'w', 'g', 'o', 'h']

'''
list = ["red","green","blue","yellow","white","black"]
"""
正向索引：step为正数
"""
# 正向索引：start_index为0到end_index为6
print(list[0:6]) # ['red', 'green', 'blue', 'yellow', 'white', 'black']

# start_index没有填写，默认从第一个开始,一直取到end_index=6
print(list[:6]) # ['red', 'green', 'blue', 'yellow', 'white', 'black']

# step没有填写，默认是1，start_index为0,一直取到end_index=2
print(list[0:2])  #['red', 'green']

# step没有填写，默认是1，start_index为1,一直取到end_index=4
print(list[1:4])  # ['green', 'blue', 'yellow']

# start_index为1,一直取到end_index=5，step是2
print(list[1:5:2])  # ['green', 'yellow']

'''
反向索引：step为负数
'''
print("反向索引=============")
# step=1，反向索引，从start_index=-6开始，一直取到end_index=0为止。
print(list[-6::])  #['red', 'green', 'blue', 'yellow', 'white', 'black']

# step=-1，反向索引，从start_index=3开始，一直取到end_index=0为止。
print(list[3:0:-1])  #['yellow', 'blue', 'green']

# step=-2，反向索引，从start_index=6开始，一直取到end_index=0为止。
print(list[6::-2])  #['black', 'yellow', 'green']

# step=-3，反向索引，从start_index=5开始，一直取到end_index=2为止。
print(list[5:2:-3])  #['black']

# step=-1，反向索引，从start_index=-3开始，一直取到end_index=-5为止。
print(list[-3:-5:-1])  #['yellow', 'blue']

# start_index > end_index时，取出的结果为空
print(list[4:2])  #[]
print(list[-5:-3:-1])  # []

'''多层切片'''
list = ["red","green","blue","yellow","white","black"]
# 链式列表切片
print(list[:6][2:5][-1:])

'''上边的链式列表与下边的步骤是相等的'''
list2 = list[:6]
# ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(list2)
list3 = list2[2:5]
# ['blue', 'yellow', 'white']
print(list3)
list4 = list3[-1:]
# ['white']
print(list4)

列表使用：运算符

重复
- 使用 * 运算符可以重复生成列表元素。
合并
- 使用 + 加号运算符，可以将两个列表合二为一。

# 1、重复
li = [1] * 5
print(li)  # 打印[1, 1, 1, 1, 1]

# 2、合并
li1 = [1, 2, 3]
li2 = [99, 100]
print(li1 + li2)  # 打印[1, 2, 3, 99, 100]

列表使用：成员检测

in：检查一个对象是否在列表中，如果在则返回 True，否则返回 False。
not in：检查一个列表是否不包含某个元素。如果不在返回 True，否则返回 False。

li = [1, 2, 3]

# in
print(1 in li)  # 返回True
print(100 in li)  # 返回False

# not in
print(1 not in li)  # 返回False
print(100 not in li)  # 返回True

列表方法

append()
extend()
insert()
pop()
remove()
sort()
reverse()

列表方法 append()

append(item)：将一个对象 item 添加到列表的末尾。
入参：对象 item
返回：None

# 添加元素
# 添加元素
li = []
li.append(1)
li.append(3.14)
li.append("hogwarts")
li.append([6, 6, 6])
li.append((1.2, 1.5))
li.append({'msg': "Hello"})

print(li)  # 打印列表
print(len(li))  # 获取列表元素个数

列表方法 extend()

extend(iterable)：将一个可迭代对象的所有元素，添加到列表末尾。
入参：可迭代对象 iterable
返回：None

# extend()的用法

li = []
li.extend('hogwarts')  # 添加的是字符串的所有字母
li.extend([1, 2, 3])  # 接收列表的所有元素
li.extend((4, 5, 6))  # 接收元组的所有元素
li.extend({'a': 1, 'b': 2})  # 接收字典的所有key值
print(li)

列表方法 insert()

insert(index, item)：将一个对象插入到指定的索引位置
入参：索引值 index ，一个对象 item
返回：None
原索引位置及后面的元素后移一位

li = [0, 1, 2]
print("插入前: ", li)  # 打印 [0, 1, 2]

# 在索引0的位置插入元素
li.insert(0, 'hogwarts')
print("插入后: ", li)  # 打印 ['hogwarts', 0, 1, 2]

列表方法 pop()

pop(index) 或 pop()
弹出并返回所指定索引的元素。
入参：索引值 index，可不传
返回：指定索引的元素
返回：未指定索引则返回末尾元素
如果索引值不正确，或者列表已经为空，则引发 IndexError 错误

letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']

# 传入索引3，弹出元素 w
n1 = letters.pop(3)
print(n1)  # 打印 w

# 不传参数，默认弹出末尾元素
n2 = letters.pop()
print(n2)  # 打印 s

列表方法 remove()

remove(item)
移除列表中第一个等于 item 的元素
入参：指定元素 item
返回：None
目标元素必须已存在，否则会报 ValueError

li = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']
print(len(li))  # 打印 8

# 1、删除指定元素'h'
li.remove('h')
print(li)  # 打印 ['o', 'g', 'w', 'a', 'r', 't', 's']
print(len(li))  # 打印 7

# 2、移除第一个2
li = [1, 2, 3, 2, 1]
li.remove(2)
print(li)  # 打印 [1, 3, 2, 1]

# 3、删除不存在的元素，会报ValueError错误
li = [1, 2, 3]
li.remove(100)

列表方法 sort()

sort(key=None, reverse=False)
对列表进行原地排序，只使用 < 来进行各项间比较。
入参：支持 2 个关键字参数：
- key：指定带有一个参数的函数，用于从每个列表元素中提取比较键。
- reverse：默认值为 False 表示升序，为 True 表示降序
返回：None

nums = [2, 4, 3, 1, 5]

# 1、不传参数，默认升序，数字从小到大排列
nums.sort()
print(nums)  # 打印 [1, 2, 3, 4, 5]

# 2、指定key=len，按元素的长度排序
words = ['Python', 'Java', 'R', 'Go']
words.sort(key=len)
print(words)  # 打印 ['R', 'Go', 'Java', 'Python']

# 3、指定reverse=True，降序
nums = [2, 4, 3, 1, 5]
nums.sort(reverse=True)
print(nums)  # 打印 [5, 4, 3, 2, 1]

列表方法 reverse()

reverse()：将列表中的元素顺序反转
参数：无
返回：None
反转只是针对索引值，元素之间不相互比较。

# 反转顺序
nums = [8, 1, 5, 2, 77]
nums.reverse()
print(nums)  # 打印[77, 2, 5, 1, 8]

book_a = [
    ('yuwen',20),
    ('yingyu',18),
    ('shuxue',30)
]
b = []
for x in book_a:
    b.append(x[::-1])
print(sorted(b))

列表嵌套

嵌套列表是指在列表里存放列表
列表的常用方法都适用于嵌套列表

# 1、创建嵌套列表
li_2d = [['a', 'b', 'c'], [1, 2, 3]]
print(type(li_2d))  # 打印<class 'list'>
print(len(li_2d))  # 打印 2

# 2、访问嵌套列表中的元素
print(li_2d[0][2])  # 打印 'c'

列表推导式

列表推导式是指循环创建列表，相当于 for 循环创建列表的简化版
语法：[x for x in li if x ...]

"""
实例：将 1-10 中的所有偶数平方后组成新的列表
"""

# 1、传统解决方案
result = []
for ele in range(1, 11):
    if ele % 2 == 0:
        result.append(ele ** 2)
print(result)  # 打印 [4, 16, 36, 64, 100]

# 2、使用列表推导式
result = [ele ** 2 for ele in range(1, 11) if ele % 2 == 0]
print(result)  # 打印 [4, 16, 36, 64, 100]

使用range()创建数字列表

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

numbers = list(range(1,6))
# [1, 2, 3, 4, 5]
print(numbers)

使用函数range()时，还可指定步长。为此，可给这个函数指定第三个参数，Python将根据这个步长来生成函数。
例如，下面的代码打印1~10的偶数：

numbers = list(range(2,11,2))
# [2, 4, 6, 8, 10]
print(numbers)

打印1~10的平方：

list_squra = []
for i in list(range(1,11)):
    list_squra.append(i**2)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
print(list_squra)

# 使用列表推导式：
list_squra = [i**2 for i in list(range(1,11))]
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
print(list_squra)

遍历切片：

如果想要遍历列表的部分元素，可在for循环中可使用切片，下面的示例是遍历前三个元素，并打印出来：

list = ["a","b","c","d","e","f","g"]
for i in list[0:3]:
    print(i)

在这里插入图片描述

复制列表

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

my_foods = ["apple","pear","cake","pizza"]
friend_foods = my_foods[:]
print(my_foods)
print(friend_foods)

在这里插入图片描述

python 常用数据结构-列表

list 列表

列表定义

列表使用：创建

列表使用：索引

列表使用：索引示意图

列表使用：切片

列表使用：切片示意图

列表使用：切片实例

列表使用：运算符

列表使用：成员检测

列表方法

列表方法 append()

列表方法 extend()

列表方法 insert()

列表方法 pop()

列表方法 remove()

列表方法 sort()

列表方法 reverse()

列表嵌套

列表推导式

使用range()创建数字列表

遍历切片：

复制列表

相关文章