基本数据类型之列表,元组和字典
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 增
-
追加 append
在列表末尾添加新的对象
list.append(obj)
返回None,但是会修改原来的列表 -
插入 insert
用于将指定对象插入列表的指定位置
list.insert(index, obj)
index – 对象obj需要插入的索引位置
obj – 要插入列表中的对象
返回None,但是会修改原来的列表 -
扩充 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 删
-
del
删除指定元素,无返回值,不支持赋值语法(会报错) -
pop()
根据索引删除,会返回删除的值
不指定索引默认删除最后一个元素
list.pop([index=-1]) -
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 重要操作
- count()
统计指定元素在列表中出现的次数。
list.count(obj)
l1 = [1, 1, 2, 1, 2, 3]
print(l1.count(1)) # 3
- index()
获取列表中指定元素的第一个匹配项的索引位置。
找不到会报错。
l1 = [1, 1, 2, 1, 2, 3]
print(l1.index(2)) # 2
print(l1.index(4)) # 报错 ValueError
- clear()
删除列表中的所有元素。
返回None
l1 = [1, 1, 2, 1, 2, 3]
print(l1.clear()) # None
print(l1) # []
- reverse()
不是排序,就是将列表反向
list.reverse()
返回None
l1 = [1, 2, 3]
print(l1.reverse()) # None
print(l1) # [3, 2, 1]
- 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 补充
- 比较大小
字符串可以比较大小
按照对应的位置的字符从第一个字符开始依次比较字符的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
- 队列和堆栈
队列
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
- 空语句
pass是空语句,不做任何事情,一般用做占位语句。
python3 中可以使用…代替pass语句 - 解压赋值
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 重要操作
- count()
统计指定元素在元组中出现的次数。
tuple.count(obj)
t1 = (1, 1, 2, 1, 2, 3)
print(t1.count(1)) # 3
- 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
d1 = {1: '1', 'a': 94, (1, 2, 3): [1, 2, 3]}
# 定义空字典
d2 = {}
d2 = dict()
- 定义字典方式2
d = dict(a=97, A=65)
- 定义字典方式3
l = [['a', 97], ('A', 65)]
d = dict(l)
- 定义字典方式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 删除
- del
d = {'a': '97', 'A': '65'}
del d['a']
- 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)
- 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 重要方法
- clear()
用于删除字典内所有元素
dict.clear()
d = {'a': '97', 'A': '65'}
d.clear()
- 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'}
- 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
- 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)