前言

这次简单聊聊剩下的几个数据类型(列表，元组，字典)...

列表

首先List是有[]包括的，每个元素用(逗号)隔开，List中可以嵌套任何数据类型，数据类型可以相互嵌套(set除外)如:

# 定义一个列表

li = [
'a', 
1, True, (
'b', 
'c',), [
1, 
2, 
3], {
'name': 
'咸鱼'}, {
1, 
2}]

# 遍历


for i in li:

    # 打印数据类型和值

    
print(
type(i), i)

列表的取值

# 定义一个列表

li = [
'a', 
1, True, (
'b', 
'c',), [
1, 
2, 
3], {
'name': 
'咸鱼'}, {
1, 
2}]

# 通过索引取值,注意索引从
0开始

temp1 = li[
0]


print(temp1) # a

# 列表中嵌套了列表取值

temp2 = li[
4][
0]


print(temp2) # 
1

# 还记得字符串切片吗？list一样可以,值仍然是列表

temp3 = li[
1:
5:]


print(temp3) # [
1, True, (
'b', 
'c'), [
1, 
2, 
3]]

列表修改

# 还记得可变类型和不可变类型吗?可变就意味某个元素的值可以变化

li = [
'a', 
'b', 
'c']

li[
0] = 
'b'


print(li)



# 用切片更改部分索引的值

li[
0:
2] = [
'c',
'c']


print(li)



#错误示范:不可变的数据类型无法更改某个索引的值

str1 = 
'abc'


print(str1[
0]) # 可以打印某个索引的值

str1[
0] = 
'1' # 更改某个索引的值抛出异常 TypeError: 
'str' object does not support item assignment

列表删除

li = [
'a', 
'b', 
'c']

# 根据索引删除某个元素

del li[
0]


print(li)



# 删除某个索引的元素,并返回删除的值,默认删除最后一个元素

li = [
'a', 
'b', 
'c']

temp1 = li.pop() # 将返回的删除的值赋值一个变量,打印看看


print(li)


print(temp1)

temp2 = li.pop(
0) # 也可以传入要删除的索引


print(li)


print(temp2)



# 按照值删除值 从最左边开始删除一个

li = [
11, 
'22', 
22, 
33, 
44, 
22]

li.
remove(
22)


print(li)



li = [
'a', 
'b', 
'c']

# 清空整个列表

li.clear()


print(li)

列表插入

# 向指定索引位置添加值

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

li.insert(
2, 
'lll') # insert(索引位置,要添加的值)


print(li)



# 向对象后面追加

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

li.
append(
"aaa") # 追加单个元素

li.
append([
11, 
22, 
33]) # 追加的列表作为了一个元素


print(li)



# 扩展列表

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

li.extend(
"aaa") # 将字符串的每个元素添加到原有列表中

li.extend([
11, 
22, 
33]) # 将列表的每个元素添加到原有列表中


print(li)



# 合并两个列表

li1 = [
1, 
2, 
3, 
4]

li2 = [
'a', 
'b', 
'c', 
'd']

li3 = li1+li2

print(li3)

列表查询

# 判断某个值是否存在于列表中,返回bool值

li = [
1, 
2, 
3, 
4]

res = 
2 
in li

print(res)



# 判断某个值在列表中存在几次

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

res = li.
count(
2)


print(res)



# 判断某个值在列表的索引,存在多个返回第一个值的索引

li = [
1, 
2, 
3, 
4]

res = li.index(
2)


print(res)



# 如果不存在抛出异常

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

# res = li.index(
6)

# 
print(res) # 
ValueError: 
6 
is not 
in list

列表反转

li = [
1, 
'a', 
2, 
'b']

li.reverse()

print(li)

列表排序,最大(小)值

# 注意只有相同类型的数据才能排序,取最大,最小值,无法数字与字符串混用

li = [
8, 
2, 
6, 
8, 
5]

li.
sort() # 排序


print(li)





li = [
'b', 
'5', 
'z', 
'y', 
'r', 
'l']

li.
sort()


print(li)

# 最大值


print(
max(li))

# 最小值


print(
min(li))

列表和字符串的相互转换

# 字符串转换为列表

str1 = 
'abcdefg'

li = list(str1)


print(li)



# 列表转换为字符串,注意这种只能列表内全是字符串

li = [
'1', 
'a', 
'c', 
'2']

s1 = 
''.join(li)


print(s1)



# 列表中包含有数字类型的

li = [
1, 
2, 
'a', 
'b']

# 先定义一个空字符串

s1 = 
''

# 遍历列表


for i in li:

  # 将数字类型转换为字符串拼接到之前定义的空字符串

  s1 += str(i)


print(s1)

元组

元组是不可变类型，无法根据索引更改值，无法添加和删除，元组用()包括，如:

tu = (111, "aaa", (11, 22, 33,), [(1, 2, 3)], 222, True, 333,)

元组一样可以索引，切片取值，遍历，这里不再演示

有两个方法:

count(a) 
# 获取指定元素在元组中出现的个数


index(a,start,end)   # 获取指定元素在元组中的索引

小知识:

元组也是小括号,与方法看起来一样,为了方便区分,更加直观,我们一般在后面多加一个逗号,这是一个良好的规范...,如:


tu = (1,2,3,)

字典

字典用{}包括，由key和value组成的键值对，字典是个无序集合 列表、字典不能作为key值，key值只能是唯一的，字典中依然可以嵌套其他的数据类型，如:

dic = {

  
'k1': 
'v1',

  
'k2': 
'v2',

  
'k3': 
'v3',

  
'k2': 
'v4',

  
False: 
"aa",

  
0: 
"bb",

  
'k4': [
1, 
2, 
3, 
4],

  
'k5': {

      
'k1': 
'v1'

  }

}

print(dic)

取值

dic = {

  'k1': 'v1',

  'k2': 'v2',

  'k3': 'v3',

  'k2': 'v4',

  False: "aa",

  0: "bb",

  'k4': [
1, 2, 3, 4],

  'k5': {

      'k1': 'v11'

  }

}

# 字典通过key取值,字典内的列表依然通过索引取值

print(dic[
'k5'][
'k1']) # v11

print(dic[
'k4'][
0]) # 1

print(dic['kkkk']) # 不存在的key抛出异常 KeyError

# 推荐使用get,key存在返回value,不存在返回第二个参数

print(dic.get('kkkk')) # 不抛出异常返回None(默认)

print(dic.get('kkkk', '不存在')) # 此时返回'不存在'

遍历

dic = {

  
'k1': 
'v1',

  
'k2': 
'v2',

  
'k3': 
'v3',

  
'k2': 
'v4',

  False: 
"aa",

  
0: 
"bb",

  
'k4': [
1, 
2, 
3, 
4],

  
'k5': {

      
'k1': 
'v11'

  }

}

# 字典中key相同是后面的覆盖前面的   True是
1 False是
0,可以观察到key只有
false,value是后来覆盖的
'bb'

# 默认循环的是key值


print(
'一:')


for i in dic:

  
print(i)



# 默认循环的是key值


print(
'二:')


for i in dic.keys():

  
print(i)



# 循环的是value值


print(
'三:')


for i in dic.values():

  
print(i)



# 循环key和value

print(
'四:')


for i,j in dic.items():

  
print(i,j)

fromkeys

# 将第一个参数作为key值，第二个参数作为统一的值生成字典

dic0 = dict.fromkeys(
'a') # 第二个参数不写value默认为None,空值,不等同于空字符串(
'')


print(dic0)

dic1 = dict.fromkeys(
'a', 
'b')


print(dic1)

dic2 = dict.fromkeys(
'a', [
1, 
2, 
3]) # 第二个参数作为统一的值生成字典


print(dic2)

dic3 = dict.fromkeys([
'a',
'b',
'c'], [
1,
2,
3])


print(dic3)

添加

dic = {

  
'k1': 
'v1',

  
'k2': 
'v2',

  
'k3': 
'v3'

}



# 已经存在的key会修改对应key的值,没有的key添加相应的值

dic[
'k4'] = 
'v4'


print(dic)



# 已经存在的key返回对应的value,没有则添加key和value

v1 = dic.setdefault(
'k1', 
'v111')


print(dic, v1)

v2 = dic.setdefault(
'k123', 
'v123')


print(dic, v2)

修改

dic = {

  
'k1': 
'v1',

  
'k2': 
'v2',

  
'k3': 
'v3',

  
'k4': 
'v4',

  
'k5': 
'v5'

}



# 利用key只能唯一的特性,将上一个值覆盖

dic[
'k1'] = 
'v111'


print(dic)



# update(传入字典形式的数据)

dic.update({
'k2': 
'v222'})


print(dic)

# 更新多个

dic.update({
'k3': 
'v333',
'k4':
'k4444'})


print(dic)

# 也可以直接写key=value

dic.update(k5=
'k555')


print(dic)

# 更新一个不存在的key就相当于添加了

dic.update(k6=
'k666')


print(dic)

删除

# 删除并获取值pop(参数
1,参数
2)

res = dic.pop(
'k1')


print(dic,res)

# 删除不存在的键不传入第二个参数的话抛出异常

# res = dic.pop(
'k111')

# 
print(dic,res) # KeyError

res = dic.pop(
'k111',
'key不存在')


print(dic,res) # 返回第二个参数

# 删除字典中的最后一对键和值并将键和值返回

k,v = dic.popitem()


print(dic,k,v)

# 清空字典

dic.clear()


print(dic)