【Python】Python中的列表，元组，字典

列表

列表是一种批量保存数据的方式，列表使用[]表示

创建列表

• 创建两个空列表

a = []
print(type(a))
b = list()
print(type(b))

• 还可以在创建列表时，给定一些初始值

a = [1, 2, 3]

• 列表中存放的元素可以是不同类型的

b = [1, 'hello', True, 3.14, [1, 2, 3]]

• 可以直接使用print函数打印列表

b = [1, 'hello', True, 3.14, [1, 2, 3]]
print(b)

获取元素

• 可以通过下标的方式来获取指定位置元素，下标访问符[]

a = [1, 2, 3]
print(a[1])

注意：下标是从0开始的，也就是0对应第一个元素，1对应第二个元素

• 如果下标越界，会抛出下标越界异常

a = [1, 2, 3]
print(a[10])

• 可以使用len函数获取列表元素的个数

a = [1, 2, 3, 4]
print(len(a))

• 下标可以是负数，表示倒数第几个元素

a = [1, 2, 3, 4]
# 倒数第一个元素是4
print(a[-1])

修改元素

通过下标的方式可以修改值

a = [1, 2, 3, 4]
# 将倒数第一个元素修改为5
a[-1] = 5
print(a)

添加元素

• 使用append方法进行尾插

a = [1, 2, 3, 4, 5]
a.append(6)
a.append(7)
print(a)
b = list()
b.append(1)
b.append(2)
print(b)

• 使用insert方法向任意位置插入，这里的位置也是下标

a = [1, 2, 3]
# 向下标1插入hello，列表变为1，hello，2，3
a.insert(1, 'hello')
print(a)

查找元素

• 使用in来判断元素是否在列表中

a = [1, 2, 'hello']
print(1 in a)
print(3 in a)
print('hello' in a)
print('world' in a)

• 使用index函数，查找元素在列表中的下标，如果元素不存在，则会抛异常

a = [1, 2, 'hello']
print(a.index('hello'))
print(a.index(2))

元素不存在则抛出异常

a = [1, 2, 'hello']
print(a.index(3))

删除元素

• 使用pop函数可以进行尾删

a = [1, 2, 'hello']
a.pop()
print(a)
a.pop()
print(a)

• 也可以为pop函数传入下标，按照下标删除

a = [1, 2, 3, 'hello']
a.pop(3)
print(a)

• 使用remove函数，按照值删除

a = [1, 2, 3, 'hello']
a.remove(3)
a.remove('hello')
print(a)

列表拼接

• 使用+可以拼接两个列表，使用+拼接，返回的是一个新列表，即原列表不受影响

a = [1, 2, 3]
b = [4, 5, 6]
print(a + b)

• 使用extend方法把一个列表拼接到另一个列表后面，此时会改变拼接的列表

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)
print(b)

说明：将b列表拼接在a列表后面，即a列表发生变化，b列表不变

遍历列表

遍历列表就是从头往后依次获取列表中的每一个元素

• 使用for循环遍历

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for e in a:
    print(e)

• 使用for循环加下标

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in range(0,len(a)):
    print(a[i])

• 使用while循环遍历

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
i = 0
while i < len(a):
    print(a[i])
    i += 1

切片操作

通过下标是一次只能取出一个元素，而通过切片操作一次可取出一组连续的元素

• 使用[:]进行切片操作

a = [1, 2, 3, 4, 5]
print(a[1:3])

说明：[1:3]表示由下标组成为[1,3)区间的下标集合，包含的下标有1，2，不包含3

切片操作也可以省略前后边界

• 省略后边界，表示获取到列表尾部

a = [1, 2, 3, 4, 5]
print(a[1:])

• 省略前边界，表示从列表头开始获取

a = [1, 2, 3, 4, 5]
# 从头开始直到倒数第一个（不包含倒数第一个）
print(a[:-1])

• 前后边界都省略，表示获取整个列表

a = [1, 2, 3, 4, 5]
print(a[:])

• 切片操作还可以指定步长，表示访问一个元素，下标增加几步

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 从下标1开始直到8（不包含8）,每隔两个长度打印
print(a[1:8:2])

• 切片操作的步长还可以是负数，表示从后往前取元素

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 此时下标范围为[8,1)（从后往前）
print(a[8:1:-2])

• 如果切片操作中的数字越界了，不会有负面影响，会尽可能把满足条件的元素获取到

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[8:100])

元组

元组和列表相似，只是列表中的元素可以被修改，而元组中的元素不可修改，也就是元组一旦确定，就只能进行读操作，不可以进行修改操作，元组使用()表示

创建元组

# 创建两个空元组
a = ()
b = tuple()

在创建元组时进行初始化

a = (1, 2, 'hello', 3.14, True)

元组中的操作

元组与列表类似，只是元组一旦定义则不能修改其中的元素

• 像读操作，比如切片操作，遍历，in，index，+等，元组是支持的
• 像写操作，比如添加元素，删除元素，修改元素，extend等，元组是不支持的

对于读之类的操作，和上述列表操作类似，此处不过多介绍，具体操作参照上述列表操作

• 元组在Python中很多时候是默认的集合类型，如函数返回多个值时

def method():
    return 10, 20
ret = method()
print(type(ret))

有了列表，为什么还需要元组？

• 你有一个列表，现在需要调用一个函数进行一些处理，但是你有不是特别确认这个函数是否会
  把你的列表数据弄乱，那么这时候传一个元组就安全很多
• 马上要介绍的字典，是一个键值对结构，要求字典的键必须是 “可hash对象” (字典本质上也
  是一个hash表)，而一个可hash对象的前提就是不可变，因此元组可以作为字典的键，但是列表
  不行

字典

字典是一个存储键值对key: value的结构，字典用{}表示

创建字典

键值对：键:值，多个键值对用，分割

# 创建两个空字典
a = {}
b = dict()

可以在创建的时候指定初始值，也可以使用print打印字典

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
print(a)

添加/修改元素

使用[]可以根据key来增加元素或者修改元素

• 如果key不存在，则为新增键值对

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
# class不存在，则为新增
a['class'] = 3
print(a)

• 如果key存在，则为修改

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
a['name'] = '李四'
print(a)

删除元素

使用pop方法根据key删除键值对

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
a.pop('name')
print(a)

查找

• 使用in可以判断key是否在字典中存在

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
print('name' in a)
print('class' in a)

• 基于[]使用key来获取value的值

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
print(a['name'])
print(a['age'])

• 如果key在字典中不存在，则会抛异常

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
print(a['class'])

字典的遍历

• 使用for循环获取到key，再通过key获取到value

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
for key in a:
    print(key, a[key])

• 使用keys方法可以获取字典中所有的key

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
print(a.keys())

说明：dict_keys是一个特殊的类型，专门用来表示字典所有的key

• 使用values方法可以获取字典中所有的value

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
print(a.values())

说明：dict_values和dict_keys类似，专门用来表示字典中所有的value

• 使用items方法可以获取到字典中所有的键值对

a = {
    'name': '张三',
    'gender': 'm',
    'age': 20
}
print(a.items())

说明：dict_items和dict_keys类似，专门用来表示字典中所有的键值对

合法的key类型

字典本质上是一个哈希表，而哈希表的key值是要求是“可哈希的”，也就是可以通过这个key计算出哈希值

1. 可以使用hash函数计算出哈希值
2. 可以计算出哈希值的类型就可以作为key

• int，float，str，bool，元组类型的走可以计算出哈希值，可以作为key

print(hash(3))
print(hash('hello'))
print(hash(True))
print(hash((1, 2, 3)))

• 列表不可以计算哈希值，不可以作为key

print(hash([1, 2, 3]))

• 字典不可以计算哈希值，无法作为key

print(hash({'name': 'zs', 'age': 10}))