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、总结
可以存放多个值
可变类型

上一篇:python--字典的排序


下一篇:基本数据类型