9 基本数据类型之列表，元组和字典

基本数据类型之列表，元组和字典

1 列表

1.1 什么是列表

作用：按照索引/位置存放多个值，可读可改
定义: [ ] 内用逗号分隔开多个任意类型的元素

l1 = [1, 'a', 1.2, [1, 2], {'a': 97}]
l1 = list([1, 'a', 1.2, [1, 2], {'a': 97}])
# 定义空列表
l2 = []
l2 = list()

1.2 类型转换

凡是能够被for循环遍历的数据类型都可以当做参数传给list()转换成列表。

print(list())  # []
print(list('abcde'))  # ['a', 'b', 'c', 'd', 'e']
print(list({'a': 97, 'A': 65}))  # ['a', 'A']

1.3 内置方法

1.3.1 按索引存取值

取值包括正向取值和逆向取值，既可以取值也可以改值
索引不存在则报错

l1 = [1, 2, 3]
l1[0]  # 1 正向取值
l1[-1]  # 3 逆向取值
l1[0] = 4  # 修改

1.3.2 切片操作

切片操作是指按照步长，从目标列表中截取出起始索引到结束索引，但不包含结束索引（也就是结束索引减1）的所有元素放入新列表中。
切片操作[:]相当于浅拷贝

l1 = [1, [1]]
l2 = l1[:]
print(id(l1) == id(l2))  # False
print(id(l1[1]) == id(l2[1]))  # True

1.3.3 列表长度 len

获取列表中的元素个数
len(list)

len([1, 2, 3])  # 3

1.3.4 成员运算 in/not in

判断对象是否存在于列表中

'a' in ['A', 'a']  # True

1.3.5 增

1. 追加 append
   在列表末尾添加新的对象
   list.append(obj)
   返回None，但是会修改原来的列表

2. 插入 insert
   用于将指定对象插入列表的指定位置
   list.insert(index, obj)
   index – 对象obj需要插入的索引位置
   obj – 要插入列表中的对象
   返回None，但是会修改原来的列表

3. 扩充 extend
   用于在列表末尾追加另一个序列中的多个值
   list.extend(seq)
   返回None，但是会修改原来的列表

l1 = [1, 2]
l1.extend([3, 4])  # [1, 2, 3, 4]
l1.extend(range(2))  # [1, 2, 3, 4, 0, 1]
l1.extend('abc')  # [1, 2, 3, 4, 0, 1, 'a', 'b', 'c']

1.3.6 删

1. del
   删除指定元素，无返回值，不支持赋值语法(会报错)

2. pop()
   根据索引删除，会返回删除的值
   不指定索引默认删除最后一个元素
   list.pop([index=-1])

3. remove()
   根据参数删除第一个匹配项，返回None
   list.remove(obj)

l1 = list(range(10))  # [0, 1, 2, 3, 4, 5, 6, 7, 8]
del l1[0]
num1 = l1.pop()  # [1, 2, 3, 4, 5, 6, 7, 8]
num2 = l1.pop(1)  # 2 [1, 3, 4, 5, 6, 7, 8]
num3 = l1.remove(5) # [1, 3, 4, 6, 7, 8]
num3 = l1.remove(50)  # 报错

1.3.7 循环遍历

for 变量名 in 列表:
    代码块

1.3.8 重要操作

1. count()
   统计指定元素在列表中出现的次数。
   list.count(obj)

l1 = [1, 1, 2, 1, 2, 3]
print(l1.count(1))  # 3

2. index()
   获取列表中指定元素的第一个匹配项的索引位置。
   找不到会报错。

l1 = [1, 1, 2, 1, 2, 3]
print(l1.index(2))  # 2
print(l1.index(4))  # 报错 ValueError

3. clear()
   删除列表中的所有元素。
   返回None

l1 = [1, 1, 2, 1, 2, 3]
print(l1.clear())  # None
print(l1)  # []

4. reverse()
   不是排序，就是将列表反向
   list.reverse()
   返回None

l1 = [1, 2, 3]
print(l1.reverse())  # None
print(l1)  # [3, 2, 1]

5. sort()
   用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
   列表内元素必须是同种类型才可以排序。
   list.sort( key=None, reverse=False)
   key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
   reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）

l1 = list('Hello, world')
print(l1)  # ['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd']
print(l1.sort())  # None 默认升序
print(l1)  # [' ', ',', 'H', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
l1.sort(reverse=True)  # 降序
print(l1)  # ['w', 'r', 'o', 'o', 'l', 'l', 'l', 'e', 'd', 'H', ',', ' ']

1.3.9 补充

1. 比较大小
   字符串可以比较大小
   按照对应的位置的字符从第一个字符开始依次比较字符的ASCII值的大小。
   字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的
   列表也可以比较大小，原理同字符串一样，但是对应位置的元素必须是同种类型。

str1 = 'aAc'
str2 = 'aa'
print(str1 < str2)  # True a--97; A--65 => A < a

l1 = [1, 'aAc']
l2 = [1, 'aa']
print(l1 < l2)  # True

2. 队列和堆栈

队列
FIFO，先入先出

l1 = []
# 入队
l1.append(1)
l1.append(2)
l1.append(3)
# 出队 先入先出
num1 = l1.pop(0)  # 1
num2 = l1.pop(0)  # 2
num3 = l1.pop(0)  # 3

堆栈
LIFO，后入先出

l1 = []
# 入栈
l1.append(1)
l1.append(2)
l1.append(3)
# 出栈 先入先出
#  pop() 不指定索引默认删除最后一个元素
num1 = l1.pop()  # 3
num2 = l1.pop()  # 2
num3 = l1.pop()  # 1

3. 空语句
   pass是空语句，不做任何事情，一般用做占位语句。
   python3 中可以使用…代替pass语句
4. 解压赋值

for x, y, z in ['abc', [2, 3, 4]]:  # 解压赋值
    print(x)  # 先是a，然后是2
for x, y, z in [1, 2, 3]:  # 报错
    ...

2 元组

2.1 什么是元组

元组可以理解为不可变的列表
作用：按照索引/位置存放多个值，只用于读不用于改
定义: ( ) 内用逗号分隔开多个任意类型的元素

t1 = (1, 1.3, 'aa')
t1 = tuple((1, 1.3, 'aa'))
# 定义空元组
t2 = ()
t2 = tuple()

注意，一个小括号代表包含的意思
如果元组中只有一个元素，小括号会被当作运算符使用，因此必须加逗号。

t1 = (1)
print(type(t1))  # int
t2 = (1,)
print(type(t2))  # tuple

元组不可修改的是元组内存储的元素与内存地址的对应关系。

t = (1, [2, 3])  
# 索引0->值1的内存地址
# 索引1->列表[2, 3]的内存地址

t[1][1] = 4  # 列表中的元素可以修改
print(t)  # (1, [2, 4])

2.2 类型转换

print(tuple())  # ()
print(tuple('abcde'))  # ('a', 'b', 'c', 'd', 'e')
print(tuple({'a': 97, 'A': 65}))  # ('a', 'A')

2.3 内置方法

2.3.1 按索引取值

取值包括正向取值和逆向取值
索引不存在则报错

t1 = (1, 2, 3)
t1[0]  # 1 正向取值
t1[-1]  # 3 逆向取值
t1[0] = 4  # 不能修改，报错

2.3.2 切片操作

切片操作是指按照步长，从目标元组中截取出起始索引到结束索引，但不包含结束索引（也就是结束索引减1）的所有元素放入新元组中。

t1 = (1, [1])
t2 = l1[:]
print(id(t1) == id(t2))  # True 元组是不可变数据类型
print(id(t1[1]) == id(t2[1]))  # True

2.3.3 元组长度 len

获取元组中的元素个数
len(tuple)

len((1, 2, 3))  # 3

2.3.4 成员运算 in/not in

判断对象是否存在于元组中

'a' in ('A', 'a')  # True

2.3.5 循环遍历

for 变量名 in 元组:
    代码块

2.3.6 重要操作

1. count()
   统计指定元素在元组中出现的次数。
   tuple.count(obj)

t1 = (1, 1, 2, 1, 2, 3)
print(t1.count(1))  # 3

2. index()
   获取元组中指定元素的第一个匹配项的索引位置。
   找不到会报错。

t1 = (1, 1, 2, 1, 2, 3)
print(t1.index(2))  # 2
print(t1.index(4))  # 报错 ValueError

3 字典

3.1 什么是字典

作用：按照键值对的方式存放多个值，可读可改，无序
定义: 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号分割，整个字典包括在花括号 { } 中

3.2 字典定义方式 (4种)

1. 定义字典方式1

d1 = {1: '1', 'a': 94, (1, 2, 3): [1, 2, 3]}
# 定义空字典
d2 = {}
d2 = dict()

2. 定义字典方式2

d = dict(a=97, A=65)

3. 定义字典方式3

l = [['a', 97], ('A', 65)]
d = dict(l)

4. 定义字典方式4 fromkeys
   快速初始化一个字典
   dict.fromkeys(seq[, value])
   以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值
   seq – 字典键值列表
   value – 可选参数, 设置键序列（seq）对应的值，默认为 None

seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)  # {'name': None, 'age': None, 'sex': None}
dict = {}.fromkeys(seq, 10)  # {'name': 10, 'age': 10, 'sex': 10}

注意：
参数default一般为None，也可以是不可变数据类型，
若是可变数据类型，则所有的键都指向同一片内存空间，不再相互独立。

seq = ('name', 'age')
dict = dict.fromkeys(seq, [])
print(id(dict['name']) == id(dict['age']))  # True 指向同一片内存空间
dict['name'].append('Tom')
print(dict['age'])  # ['Tom'] 不再相互独立

fromkeys产生新字典，对原字典无影响

dict1 = {1: 'a', 2: 'b'}
dict2 = {}.fromkeys([1, 2])
print(dict1)  # {1: 'a', 2: 'b'}
print(dict2)  # {1: None, 2: None}

3.3 内置方法

3.3.1 按键存取值

如果键存在，则返回/修改对应的值
如果将不存在，则添加新的键值对

d1 = {'a': 97}
print(d1['a'])
d1['a'] = '97'  # {'a': '97'}
d1['A'] = '65'  # {'a': '97', 'A': '65'}

3.3.2 字典长度len

d = {'a': '97', 'A': '65'}
print(len(d))  # 2

3.3.3 成员运算 in/not in

针对字典的键

d = {'a': '97', 'A': '65'}
print('a' in d)  # True

3.3.4 删除

1. del

d = {'a': '97', 'A': '65'}
del d['a']

2. pop()
   根据字典的键key删除元素，返回删除的值value

d = {'a': '97', 'A': '65'}
print(d.pop('A'))  # 65 dict.pop(key)

# 对比 列表
l = [1, 2, 3]
print(l.pop(0))  # 1 list.pop(key)

3. popitem()
   随机删除字典中的一个键值对，以(key,value)的形式返回该键值对，
   如果字典为空，调用了此方法后会报出KeyError异常。

d = {'a': '97', 'A': '65'}
print(d.popitem())

3.3.5 键keys()，值values()，键值对items()

Python 3 中返回一个可迭代对象，可以使用 list() 来转换为列表
Python 2 中是直接返回列表

d = {'a': '97', 'A': '65'}
print(d.keys())  # dict_keys(['a', 'A'])
print(d.values())  # dict_values(['97', '65'])
print(d.items())  # dict_items([('a', '97'), ('A', '65')])
print(list(d.items()))  # [('a', '97'), ('A', '65')]

与for循环配合使用

d = {'a': '97', 'A': '65'}
for each_key in d.keys():  # 与'for each_key in d:'效果一样
	代码块

for each_value in d.values():
	代码块

for each_key, each_value in d.items():
	代码块

3.3.6 重要方法

1. clear()
   用于删除字典内所有元素
   dict.clear()

d = {'a': '97', 'A': '65'}
d.clear()

2. update()
   把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里
   dict.update(dict2)
   dict2 – 添加到指定字典dict里的字典

d = {'a': '97', 'A': '65'}
d.update({'A': '65', 'B': '66'})
print(d)  # {'a': '97', 'A': '65', 'B': '66'}

3. get()
   函数返回字典中指定键的值，如果键不存在则返回默认值
   dict.get(key, default=None)

d = {'a': '97', 'A': '65'}
print(d.get('a'))  # 97
print(d.get('b'))  # None
print(d.get('b', '98'))  # 98

d['b']  # 键不存在则报错 KeyError

4. setdefault()
   如果键不存在于字典中，将会添加键并将值设为默认值
   dict.setdefault(key, default=None)

d = {'a': '97', 'A': '65'}
print(d.setdefault('a'))  # 97
print(d.setdefault('b'))  # None
print(d.setdefault('c', '99'))  # 99
print(d)  # {'a': '97', 'A': '65', 'b': None, 'c': '99'}

4 元组

4.1

列表 [‘alex’, 49, [1900, 3, 18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量

l1 = ['alex', 49, [1900, 3, 18]]
name = l1[0]
age = l1[1]
birth_year = l1[2][0]
birth_month = l1[2][1]
birth_date = l1[2][2]

4.2

用列表的insert与pop方法模拟队列

l1 = []
# 先入先出
# 入队
l1.insert(len(l1), 0)
l1.insert(len(l1), 1)
l1.insert(len(l1), 2)
print(l1)
# 出队
n0 = l1.pop(0)
n1 = l1.pop(0)
n2 = l1.pop(0)
print(n0, n1, n2)

4.3

用列表的insert与pop方法模拟堆栈

l1 = []
# 后入先出
# 入栈
l1.insert(len(l1), 0)
l1.insert(len(l1), 1)
l1.insert(len(l1), 2)
print(l1)
# 出栈
n0 = l1.pop()
n1 = l1.pop()
n2 = l1.pop()
print(n0, n1, n2)

4.4 简单购物车，要求如下：

实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数以三元组形式加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　
msg_dic = {
‘apple’: 10,
‘tesla’: 100000,
‘mac’: 3000,
‘lenovo’: 30000,
‘chicken’: 10,
}

msg_dic = {
    'apple': 10,
    'tesla': 100000,
    'mac': 3000,
    'lenovo': 30000,
    'chicken': 10,
}
shop_list = []
while 1:
    input_name = input('请输入商品名：')
    if input_name in msg_dic:
        while 1:
            input_cnt = input('请输入购买数量：')
            if input_cnt.isdigit():
                temp_tuple = (input_name, msg_dic[input_name], input_cnt)  # 商品名，价格，购买个数
                shop_list.append(temp_tuple)
                break
            else:
                print('请重新输入购买数量整数：')
    elif input_name in ['q', 'Q']:
        print('购物车内商品为{}'.format(shop_list))
        break
    else:
        print('输入商品名不存在，请重新输入。')

4.5

有如下值集合 [11, 22, 33, 44, 55, 66, 77, 88, 99, 90…]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
即： {‘k1’: 大于66的所有值, ‘k2’: 小于66的所有值}

l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
dict1 = {'k1': [], 'k2': []}
for each_num in l1:
    if each_num >= 66:
        dict1['k1'].append(each_num)
    else:
        dict1['k2'].append(each_num)

print(dict1)

4.6

统计s = 'hello alex alex say hello sb sb’中每个单词的个数

s = 'hello alex alex say hello sb sb'
str_list = s.split(' ')
cnt_dict = {}
temp_set = set(str_list)
for each_key in temp_set:
    cnt_dict[each_key] = str_list.count(each_key)
print(cnt_dict)