Python中的基础数据类型(List,Tuple,Dict)及其常用用法简析

前言

 上次咱们简单的认识了String，Number，这次简单聊聊剩下的几个数据类型(列表，元组，字典)...

列表

 首先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', 1, True, ('b', 'c',), [1, 2, 3], {'name': '咸鱼'}, {1, 2}]
# 推荐使用
for i in li:
  print(i)


# 利用索引加列表的长度遍历,这里用了while循环
j = 0 # 从0索引开始
while j < len(li): # 索引小于列表的长度
  print(li[j])   # 打印当前索引的值
  j += 1   # 索引+1 等同于 j = j + 1,开始下次循环

列表修改

# 还记得可变类型和不可变类型吗?可变就意味某个元素的值可以变化
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)

小结

可能不是很完整,有些可能遗忘了...set集合单独再写吧...