Python基础之数据类型详解（2）

今天继续昨天的python基本数据类型详解，按照上一篇博文的格式，接下来讲解列表、元组、字典以及集合。

列表

1.用途
按位置存放多个值
2.定义
在[]内用逗号分割开多个任意类型的元素

# 定义列表
# 列表中可以是整型、浮点型、字符串、列表、字典等
msg = [123] # msg = list(123)
msg = [1,23,3.4,"as",[1,3,1],{"name":"zhang"}]

# 列表转换，凡是可以for循环遍历的都可以转换
msg = list("123")
msg = list({"name":"zhang","age":18})

3、常用操作+内置的方法

• 索引取值，可以正向和反向取，也可以根据索引修改列表

# 索引取值与索引改值
msg = [1,2.3,4]
msg[0] # 取到1
msg[2] = 3 # 将2号索引的值修改为3
# msg[4] = 5 # 如果索引超过了字符串的长度，会报错

• 切片，list[开始:结束:步长]

# 切片，只能取到结束位置-1的长度
msg = [1,2,3,4]
msg[0:2:1] # 从0号索引取到1号索引，步长为1
msg[-1:-3:-1] # 反向取值
msg[:] # 默认取完，步长为1

【补充】
使用列表切片也可以实现列表元素的增删！

# 替换列表中的元素
l1 = [1,2,3,4]
l1[0:2] = ["a","b"] # 将l1中的[1,2]换成["a","b"]>>>["a","b",3,4]
l1[:] = ["hhh"] # 将整个列表元素换成"hhh"
l1[10:] = ["wwww"] # 如果切片的起始位置超过了列表的索引，代表在列表最后添加元素
l1[len(l1):] = ["插入"] # 相当于在列表末尾插入元素
# 在列表中插入元素
l1 = [1,2,3,4]
l1[1:1] = ["kkk"] # 在1号索引处插入"kkk"这个元素
l1[10:10] = ["hahaha"] # 如果索引超过列表的长度，在末尾插入元素
l1[len(l1):len(l1)] = ["xiha","heiheihei"] # 在末尾插入元素
print(l1)
# 删除
l1 = [1,2,3,4]
l1[0:2] = [] # 如果赋值的列表为空，则相当于删除元素

• 长度len()，计算列表内的元素个数，即列表的长度

# 列表长度
msg = [1,2,3,4]
len(msg) # 返回列表长度：4

• 成员运算in 和 not in

# 成员运算 in 和 not in
msg = [1,2,3,4]
1 in msg # 判断1在不在列表内，返回逻辑值：True

• 添加元素

# 添加元素
msg = [1,2,3,4]
msg.append(7) # 在列表后面添加指定的值，没有返回值
msg.insert(0,3) # 两个参数为索引位置，需要添加的值，按照索引位置插入，不是改变，没有返回值
print(msg)

• 删除元素

# 删除
msg = [1,2,3,4,5]
msg.remove(3) # 移除指定元素，没有返回值
# msg.remove(7) # 如果指定值不存在，就会报错
x = msg.pop(1) # 按照索引取走相应的值，有返回值，索引超过列表长度不会报错

• 添加元素

# 删除
msg = [1,2,3,4,5]
msg.remove(3) # 移除指定元素，没有返回值
# msg.remove(7) # 如果指定值不存在，就会报错
x = msg.pop(1) # 按照索引取走相应的值，有返回值，索引超过列表长度会报错
print(x)

• 循环

# 与for循环结合遍历
list1 = [111,222,333,444]
for i in list1:
    print(i)

• 其他需要掌握的方法

# count 计算列表中出现了多少次指定对象，有一个参数
list1 = [111,222,333,333,333,444,555]
print(list1.count(333)) # 333在列表中出现了3次

# reserve 颠倒原有元素的顺序，不会产生新的列表
list1= [99,33,22,11,-3,87]
list1.reverse()
print(list1)

# clear 清除列表里的元素
list1 = [111,222,333,333,333,444,555]
list1.clear()

# index()查找字符串子字符串第一次出现的位置索引，可以指定开始位置，和结束位置
msg = [1,2,3,4]
print(msg.index(2,0,3)) # 返回1
# msg.index(8) # 如果字符串中没有，会报错

# sort()根据参数进行排序
#cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
#key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
#reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）
lis = [1,2,3,4,]
lis.sort(reverse=True)

# extend()函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）,没有返回值
list_1 = [1,2,3,4]
list_2 = [5,6]
list_1.extend(list_2) # list_1添加了list_2：[1,2,3,4,5,6]

4.总结
能存放多个值
可变类型

元组

1.用途
存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读
2.定义
在()内用逗号分隔开多个任意类型的元素

# 元组定义
x = (10,)  #  x= tuple(...)
print(x,type(x))
# tuple数据类型转换：任意能够被for循环遍历的类型都可以交给tuple转成元组
print(tuple("hello"))

3.常用操作+内置的方法

元组的常用方法与列表及其相似

#1、按索引取值(正向取+反向取)：只能取
t = (111,222,333,[44,555])
print(t[0])
t[0]=6666

#2、切片(顾头不顾尾，步长)
t = (111,222,333,[44,555])
print(t[0:3])

#3、长度
t = (111,222,333,[44,555])
print(len(t))

#4、成员运算in和not in
t = (111,222,333,[44,555])
print([44,555] in t)

#5、循环
t = (111,222,333,[44,555])
for x in t:
    print(x)

#需要掌握的操作：
t = (111,222,333,[44,555])
t.index()
t.count()

4.总结
能存放多个值
不可变类型

字典

1.用途
按key：value的方式存储多个值
2.定义
在{}内用逗号分隔开多个元素，每个元素都是key:value的格式，其中value可以是任意类型，而key必须是不可变类型，通常是str类型，而且key不能重复

# 字典定义
dic = {111:6666,"k1":777,(1,2,3):8888,[1,2,3]:3333}   # dic = dict(...)
dic = {111:6666,"k1":777,(1,2,3):8888,"k1":99999999}

# dict数据类型转换
info = [('k1',111),('k2',222),('k3',3333)]
dic=dict(info)
print(dic)

3.常用操作+内置的方法

1. 按照key取值，可存可取

# 按照key取值
dic = {"name":"egon","age":18}
x = dic["name"] # 取"name"下存储的值："egon"
dic["age"] = 20 # 按照key修改字典里的值，将age下的值修改为20

1. 长度len()

# 长度len()
dic = {"name":"egon","age":18}
x = len(dic) # 返回字典内键值对的个数：2
print(x)

1. 成员运算in 和 not in，以key为准

#3、成员运算in和not in: 以key为准
dic = {"name":"egon","age":18}
print('name' in dic)

1. 删除

# 取走，有返回值
v = dic.pop("name") # 删除指定的键值对，两个参数，在删除内容不存在时返回第二个参数，否则报错
m = dic.pop("dscjasjdb","None") # 要删除的内容不存在，所以最后返回"None"
print(v)

x = dic.popitem() # 随机删除字典中的一个键值对，并且返回该键值对，(key,value)形式
print(x)

1. 键keys()，值values()，键值对items()

#5、键keys()，值values()，键值对items()
dic = {"name":"zhang","age":18,"gender":"male","money":1000}
v = dic.keys() # 返回所有的key的列表
x = dic.values() # 返回所有value的列表
m = dic.items() # 返回(key，value)组成的列表

1. 循环

# 循环
dic = {"name":"zhang","age":18,"gender":"male","money":1000}
for i in dic: # 遍历的是key值
    print(i)

for i in dic.keys(): # 遍历的也是key值
    print(i)

for i in dic.values(): # 遍历的是value值
    print(i)

for i in dic.items(): # 遍历得到的是(key,value)的键值对
    print()

1. get()

# get()
dic = {"name": "egon", "age": 18}
print(dic['namexxxx'])
print(dic.get("namexxxx")) # 取key对应的值

1. 一些需要掌握的操作

# update(),如果增加的键值对不存在，则添加，如果key已存在，则更新对应的value
dic = {"name": "egon", "age": 18}
dic.update({'gender':"male","age":19}) # 添加"gender":"male",更新"age"的值为19
print(dic)

# 快速创建字典
dic = {}.fromkeys(["name","age","gender"],[])
print(dic) # 创建字典：{'name': [], 'age': [], 'gender': []}
dic['name'].append(1111) # {'name': [1111], 'age': [1111], 'gender': [1111]}
                         # 因为使用的是同一个列表，所以改变其中一个其他的都会改变
print(dic)

dic = {}.fromkeys(["name","age","gender"],None) # {'name': None, 'age': None, 'gender': None}
print(dic)

# setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
v = dic.setdefault('name',"xxx")
print(dic)
print(v)

4、总结
可以存多个值
可变类型

元组

1、用途

• 关系运算
• 去重（不常用）

2、定义方式
在{}内用逗号分隔开多个元素，需要注意的是几何必须满足：

• 集合内的元素必须是不可变类型
• 集合的元素无序
• 集合的元素没有重复
  空集合定义：

s = set()
x = {} # 代表的是空字典

3、常用操作+内置的方法

# 交集
a & b # 返回一新集合，集合共有的元素
a.intersection(b) # 同&
a.intersection_update(b), # 在原有的列表上移除非共有元素

# 并集，合并两个集合的所有元素
a | b # 返回一个新列表，合并了两个列表内的所有元素
a.union(b) # 同|
a.update(b) # 用此集合和其他集合的并集来更新集合,没有返回值
# 注意，update不仅可以合并集合，其中的参数还可以指定字符串、元组、列表、字典。
a.update("hahaha") # 将hahaha添加进a
a.update([123,345]) # 将列表的元素遍历添加进a
a.update({"hhh":"hh","kkk":"kk"}) # 遍历字典的key，并添加进集合

# 差集，移除两个列表中共有的元素
a - b # 返回一个新的集合
a.difference(b) # 同-
a.difference_update(b) # 在原集合上移除两个列表中共有的元素

# 对称差集，两个集合合并，去除共有的元素
(a -b) | (b -a)
a ^ b
a.symmetric_difference() # 同上
a.symmetric_difference_update() # 插入此集合和另一个集合的对称差集,不返回新的集合

# 添加元素
a.add("12c") # 添加指定元素
a.update("app") # update也可以用来添加元素

#  删除元素
# a.remove("1")   remove可以删除指定元素，但是指定元素不存在时，会报错
a.discard() # 删除指定项目，指定元素不存在时，返回None，不会报错
a.pop() # 没有参数，随机删除

# 复制、清除
a.clear() # 没有参数，清除集合
a.copy() # 复制集合，浅层拷贝

# isdisjoint()
a.isdisjoint(b) # 判断两个集合有没有交集，返回布尔值

# 子集与夫集
x = {1,2,3}
y = {1,2}

y <= x # 判断y是不是x的子集，返回布尔值
y.issubset(x) # 判断子集

x >= y # 判断x是不是y的父集，返回布尔值
x.issuperset(y) # 判断父集，返回布尔值

4、总结
可以存放多个值
可变类型