基本数据类型之容器类型

一. 列表

作用：存多个值，并且是索引对应值
定义：l = [] # 用逗号分开，可以放任意多个值
类型转换：但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表list()底层相当于for循环，字符串，列表，字典
内置方法：

优先掌握的方法：

按照索引取值（正向取+反向取）:即可取，可改

l = [111, 'egon', 'hello']
# 正向取
print(l[0])
# 反向取
print(l[-1])
# 可以取也可以改
l[0] = 222    # 修改行为，索引存在则修改对应的值
print(l)  # 索引不存在则报错，无论取还是赋值

切片(顾头不顾尾，步长)

l = [111, 'egon', 'hello', 'a', 'b', [1, 2, 3]]
print(l[0:3])
print(l[0:5:2])  # 指定步长为2

len长度

print(l[0:len(l)])
print(l[:])
new_l = l[:]  # 切片等同于拷贝行为，而且是浅拷贝

成员运算

print('aaa' in ['aaa', 'bb', 111])
# 返回True
print('aaa', in ['aa', 'b', 'c'])
# 返回False

往列表中添加值

追加

l = [111, 'egon', 'hello']
l.aapend(333)
l.append(444)
print(l)

.append（）

插入值

l = [111, 'egon', 'hello']
l.inster(0,'alex') # inster(索引，插入的值)

.inster()

extend()

l.extend(l1) # 把l1里面的逐个添加到l中去，底层相当于调用了一个for循环

删除

方式一：del 删通用的删除方式只是单纯的删除，没有返回值

方式二：pop()根据索引删除，会返回删除的值，不指定默认删除最后一个

方式三：remove('egon')指定元素删除，会返回删除的值，不指定默认删除最后一个

方式四：clerar()清空列表

需要掌握的操作：

count 统计元素个数 print(l.conut('egon')) 返回这个值存在列表中有几个值
reverese():不是排序，就是将列表倒过来
sort：排序，列表的元素必须是同种类型才可以排序，默认升序

sort(reversee = True) # 从大到小排序，设置为降序

了解：字符串可以比大小，按照对应的位置以此pk，字符串的大小是按照ASCII码表的先后顺序以区别，表中排在后面的字符大于前面的

了解：列表也可以比大小，原理同字符串一样，但是对应的位置的元素必须是同种类型

队列：FIFO 先进先出
```
l = []
# 入队操作
l.append('firset')
l.append('second')
l.append('third')
print(l)
#  出队操作
print(l.pop())
print(l.pop())
print(l.pop())
```

二. 元组类型

作用：按照索引存放多个值，适用于读不用于改
定义：()内用逗号分隔多个任意类型的元素
```
t = (1, 3, 'aa')  # t =tuple((1, 3, 'aa'))
print(t.type(e))
x = (10)  # 单独一个括号代表包含的意思
t = (10,)  # 如果元组钟只有一个元素必须为逗号
t = (1， 1.3, [1, 2, 3])
```
元组内地址不可变，如果存放列表放元组，列表的内存地址不表，但是列表的值能改的是列表里面值的内存地址，没有更改列表的内存地址
类型转换:tuple

内置地址

按照索引取值(正向取+反向取)：只能取

t = ('aaa', 'bbb', 'cc')
print(t[0])
print(t[-1])

切片(顾头不顾尾，步长)

t = ('aa', 'bbb',  ('c', 'dd', 'eee'))
print(t[0:3])
print(t[::-1])

长度

t = ('aa', 'bbb', 'ccc', 'dd', 'eee')
print(len(t))

成员运算

print('aa' in t)
循环
```
for x in t:
	print(x)
```

方法

t = (1, 2, 3)
t.index(111) # 查看起始的索引
t.count()  # 统计类型里面有多少个值

三.字典

作用：存放多个值的，key对应value对应值，key为不可变类型

定义：{}内用逗号分割开多个key：value，其中value可以使用任意类型，但是key，必须是不可变类型

d = {'k1':111, (1,2,3):222}
print(d['k1'])
print(d[(1,2,3)])
print(type(d))

定义字典的方式二：

d = {}  # 默认定义的是空字典
print(d,type(d)
d = dict(x = 1, y= 2, z = 3)

类型转换

info = [
['name':'egon']
('age':18)
['gender':'male']
]
d = {}
# 转换1
for i in info:
	d[i[0]] = i[1]
print(d)
# 转换2
for k,v in info:
	d[k] = v
print(d)
# 转换3
res = dict(info)
print(res)

造字典的方式

keys = ['name', 'age', 'gender']
d = {}
for k in keys:
	d[k] = None
print(d)

d = {}.fromkeys(keys,None)  # 快速初始化字典
print(d)

内置方法

按key存取值：key存在，则修改

d = {'k1':111}
# 针对复制操作：key存在，则修改
d['k1'] = 222
print(d)
d['k2'] = 333  #针对复制操作：key存在，则修改，key不存在则创建新值
print(d)

长度len

d = {'k1':111, 'k2':222, 'k1:333,'k1':4444}
print(d)  # 强调：key必须是不可变类型，却不能重复，重复则修改了

成员运算in和not in:根据key

d = {'k1':111, 'k2':222}
print('k1' in d)  # in 是根据key来判断的
print(111 in d)  # False

删除

d = ['k1':111, 'k2':222]
# 通用删除
del d['k1']
print(d)
# pop删除
d.pop('k1') # 按照key来删除
res = print(d)  print(res) # 返回删除key对应的那个value值
# popitem删除： 随机删除，返回元组(删除key,删除的value)

键keys(), 值values(),键值对items()

for 循环

for k in d.keys(): # 取出key
	print(k)
for k in d:    # 不加keys也是取出字典的key
	print(k)
for v in d.values():  # 取出字典的value值
	print(v)
for k,v in d.items(): #取出字典的key，value两个，所以接收也是两个
    print(k,v)

需要掌握的内置方法

d.clear() 清空字典
d.update() 更新字典新字典更新老字典，一切按新字典为准，有就更新，没有就添加
d.get()

print(d['k2'] key 不存在则报错

print(d.get('k2')) key不存在不报错，返回None
d.setdefault() 如果key存在则不懂，key不存在，则添加

d =
d.setdefault ('k1',222) 返回key对应值

print(d)

四.基本数据类型之集合

作用

关系运算

frineds1 = ['zero', 'kevin', 'jason', 'egon']
friends2 = ['jy', 'ricky', 'jason', 'egon']
l = []
for x in friends1:
	if x in friends2:
		l.append(x)
print(l)

定义:在{}内用逗号分隔开多个元素，多个元素满足一下三个条件

集合内元素必须为不可变类型
集合内元素无序

集合内元素没有重复

s = {1,[1,2]}  # 集合内元素必须为不可变类型，存在可变类型直接报错
s = {1，'a', 'z', 'b', 4, 7} # 集合内元素无序
s = {1,1,1,1,1,1,'a', 'b'}  # 集合内元素没有重复
print(s)  

# 了解
s = {}  # 默认是空字典
print(type(s))
# 定义空集合
# s = set()
# print(s, type(s))

类型转换

set = ({1, 2, 3})
res = set('hellolllllll')
print(res)  # 转换成集合之后无序且自动把重复去重

内置方法

关系运算


frineds1 = ['zero', 'kevin', 'jason', 'egon']
friends2 = ['jy', 'ricky', 'jason', 'egon']
# 1.取交集:两者共同好友
res = friends1 & friends2  # 符号取交集
print(res)
print(friends1.intersection(friends2))  # 内置方法取
# 2.取并集，合集：两者所有的好友
print(friends1 | friends2) # 符号取合集
print(friends1.union(friends2)) # 内置方法取合集
# 3.取差集:取friends1独有的好友、
print(friends1 - friends2) # 符号取
print(friends1.difference(friends2)) # 内置方法取 
# 4.对称差集：求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2)
print(friends1.symmetric_difference(friends2))
# 5.父子集:包含的关系
s1 = {1,2,3}
s2 = {1,2,4}
print(s1 > s2) # False

s1 = {1,2,3}
s2 = {1,2}
print(s1 > s2) # 当s1大于或等于s2时，才能说s1是s2的爹
print(s1.issuperset(s2))  # 等同于大于
print(s2.issuperset(s1))  # 等同于小于

去重

# 1.只能针对不可变类型去重
print(set([1,1,1,1,1,]))
# 2.无法保证原来的顺序
l = [1, 'a', 'z', 1, 1, 1, 2]
s = set(l)
print(list(set(l)))
print(l)

l = [
    {'name':'lili','age':18,'sex':'male'}
    {'name':'jack','age':73,'sex':'male'}
    {'name':'tom','age':20,'sex':'female'}
    {'name':'lili','age':18,'sex':'male'}
    {'name':'lili','age':18,'sex':'male'}
]
new_l = []
for dic in l:
    if dic not in new_l:
        new_l.append(dic)
print(new_l)

其他操作

# 1.长度
>>> s={'a','b','c'}
>>> len(s)
3

# 2.成员运算
>>> 'c' in s
True

# 3.循环
>>> for item in s:
...     print(item)
... 
c
a
b

其他内置方法

s = {1,2,3}
# 需要掌握的内置方法1：discard
s.discard(4) # 删除元素不存在do nothing
print(s)

s.remove(4) # 删除元素不存在则报错

# 需要掌握的内置方法2：update
s.update({1, 3, 5})  # 更新集合
print(s)


s.difference_update({3, 4, 5}) # s = s.difference({3, 4, 5}) 
print(s)

# 需要掌握的内置方法3：pop
res = s.pop()  # 随机删除，集合没有索引没有key，pop里面放不了
print(res)

# 需要掌握的内置方法4：add
s.add(4) # 往集合里面添加单个元素
print(s)

s.isdisjoint() # 两个集合完全独立，没有共同部分，往回True

posted @ 2023-07-24 01:09 捡破烂的小L 阅读(29) 评论(0) 收藏举报

刷新页面返回顶部

SolsticeUp