python容器介绍与常用方法

python 容器

什么是容器？

** 字面上理解：容器就是用来存取东西的，根据不同的东西来使用不同的容器。**

** 那么python的容器是什么？当然也是用来存取东西的，那么存的是什么？存的当然是数据。**

python容器介绍

python的容器拢共有4个：

• 列表（list）：线性表， 底层采用双向循环链表进行实现。
• 元组（tuple）: 元组一旦创建，那么里面的数据保守意义上来说是不可变得，但是如果元祖里面存储的是可变数据类型，那么元祖即又变得可变。
• 集合(set):集合的底层基于hash表实现的，不能重复，无序的。
• 字典(dict):以键值对形式进行数据存储。

容器创建

列表创建：

list1=[“a”,“b”,“c”]

list1=list([“a”,“b”,1,2,3])

元组创建：

t=(“a”,“b”,“c”)

t=tuple()

t=tuple((“a”,“b”,“c”,1,2))

集合创建：

s=set()

s=set({“1”,“2”,“3”,1,2,3})

s={“1”,1,2,3}

字典创建：

d={“name”:“daxian”,“age”:16}

d=dict({“name”:“daxian”,“age”:16})

常见方法介绍

list常见方法：

append()	# 向列表尾部追加元素
insert(index,file)	向指定的位置追加元素
sort()	排序（一般用来排序数字）
index()	查找元素第一次在列表中出现的位置，如果没有这个元素，则抛出异常
reverse()	将列表元素顺序翻转
remove()	通过元素来移除元素，注意，如果元素不存在，则抛出异常
count()	统计元素个数
clear()	清除元素
copy()	浅拷贝对象，是在堆内存中进行对象拷贝的
extend	合并列表
pop()	删除最后元素，并返回这个元素

实例：

list1=list(["a","b","c",1,2,3,"-","&"])
list2=["abc","name","age"]
print(list1)
print(list2)
# append() 向列表尾部添加元素
list1.append("xian")
print(list1)
#insert() 向指定位置添加元素
list1.insert(0,"index")
print(list1)
# list1.sort() sort()方法只能对列表中不存在不同类型的元素进行排序
list2.sort()
print(list2)
# index() 查找元素在列表中第一次出现的位置，如果没有这个元素，则抛出异常
print(list1.index("c"))

#reverse() 将列表元素进行翻转
list1.reverse()
print(list1)

# remove() 通过元素来移除元素，如果元素不存在，则抛出异常
list1.remove("c")
print(list1)

#count() 统计列表中单个元素出现的次数
print(list1.count("b"))

# clear() 清除列表中的所有元素
list2.clear()
print(list2)

# copy() 浅拷贝列表，并返回新的列表
list3=list1.copy()
print(list3)

#extend() 合并列表，将传入的列表元素添加到原有列表中
list3.extend(list1)
print(list3)

#pop():删除最后的元素，并返回
print(list3.pop())

输出结果：

['a', 'b', 'c', 1, 2, 3, '-', '&']
['abc', 'name', 'age']
['a', 'b', 'c', 1, 2, 3, '-', '&', 'xian']
['index', 'a', 'b', 'c', 1, 2, 3, '-', '&', 'xian']
['abc', 'age', 'name']
3
['xian', '&', '-', 3, 2, 1, 'c', 'b', 'a', 'index']
['xian', '&', '-', 3, 2, 1, 'b', 'a', 'index']
1
[]
['xian', '&', '-', 3, 2, 1, 'b', 'a', 'index']
['xian', '&', '-', 3, 2, 1, 'b', 'a', 'index', 'xian', '&', '-', 3, 2, 1, 'b', 'a', 'index']
index

元组常见方法：

index(参数)	根据元素获取下标
count(参数)	获取元组中单独元素存在的个数

实例：

#创建一个元组
tuple1=("a","b","c")
tuple2=(1,2,3,4)
tuple3=(1,['a','b'],2)

print(tuple1)
print(tuple2)
print(tuple3)

#index() 根据元素获取下标
print(tuple1.index("b"))
print(tuple1.index("c"))

#count() 获取元组元素个数
print(tuple1.count("a"))

结果：

('a', 'b', 'c')
(1, 2, 3, 4)
(1, ['a', 'b'], 2)
1
2
1

集合常见方法：

clear()	清除数据
remove()	删除数据
copy()	浅拷贝数据
add()	增加元素
difference()	差集
intersection	交集
union	并集
update()	更新集合，合并集合
discard	移除元素，如果不存在，则不作任何操作

实例：

# 创建一个集合
set1={"1","2","3","a","b","c",1,2,3}
set2=set({"a","b",1,2,3})
set3={}

print(set1)
print(set2)
print(set3)
print(type(set3))  #可以发现set3是一个字典对象，因为set3没有进行赋值，请注意，声明一个集合时，如果没有一个值存在，那么这个集合会变成字典类型
print(type(set2))

# clear() 清除数据
set2.clear()
print(set2)
print(type(set2))
set2=set({"a","b",1,2,3})


#copy()浅拷贝数据
set4=set1.copy()
print(set4)

#add() 增加元素
set4.add("agb")
print(set4)    #set 集合自动排序
set5={"f","w","c","a"}
print(set5)

# set5.add(0,"sfdf")  因为set集合底层是hash实现，所以没有下标这一说

#difference() 差集 ，将两个集合进行比较，返回一个新的集合
print(set1)
print(set4)
set6=set1.difference(set4)   #difference() 不能对浅拷贝的对象进行比较？
print(set6)
set7=set1.difference(set2)
print(set7)

#intersection 对两个集合进行比较 返回元素相同的内容 重新返回一个集合

set8=set1.intersection(set2)
print(set8)
set9=set1.intersection(set4)   #可以对浅拷贝对象使用，差集比较返回的是set() 不知道为什么
print(set9)   

#union()  并集，合并两个集合，相同元素只会出现一次，并返回新的集合
sss1=set1.union(set4)
print(sss1)

#update() 更新集合，将两个集合进行合并，不会返回新的集合
set1.update(set4)
print(set1)

#discard() 移除元素，如果元素不存在，不会报错
set1.discard("agb")
print(set1)

输出结果：

{1, 2, '2', 3, 'b', '1', '3', 'a', 'c'}
{1, 2, 3, 'b', 'a'}
{}
<class 'dict'>
<class 'set'>
set()
<class 'set'>
{1, 2, '2', 3, 'b', '1', '3', 'a', 'c'}
{1, 2, '2', 3, 'b', '1', 'agb', '3', 'a', 'c'}
{'f', 'w', 'c', 'a'}
{1, 2, '2', 3, 'b', '1', '3', 'a', 'c'}
{1, 2, '2', 3, 'b', '1', 'agb', '3', 'a', 'c'}
set()
{'3', '2', 'c', '1'}
{1, 2, 3, 'b', 'a'}
{1, 2, 3, '2', 'b', '1', '3', 'a', 'c'}
{1, 2, '2', 3, 'b', '1', 'agb', '3', 'a', 'c'}
{1, 2, '2', 3, 'b', '1', 'agb', '3', 'a', 'c'}
{1, 2, '2', 3, 'b', '1', '3', 'a', 'c'}

字典常见方法：

clear	清除元素
copy	浅拷贝
get	根据键获取值，如果没有则返回None
keys	返回所有的键 返回值：<class ‘dict_keys’>
values	返回所有的值 返回值：<class ‘dict_values’>
setdefault	setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
items	Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组 返回值<class ‘dict_items’>
pop	通过key删除键值对
popitem	移除一个键值对，移除规则是LIFO（后进先出）last in first out 并返回移除的键值对
update()	更新字典，或者添加元素，如果已有键，那么根据键更新元素value，如果没有，则添加元素

实例：

#创建一个字典：
dict1={"name":"wangdaxian","age":100,"gender":"男"}
dict2=dict({"喜好":"女","擅长":"睡觉"})

#clrar() 清除元素
dict2.clear()
print(dict2)

dict2=dict({"喜好":"女","擅长":"睡觉"})
#copy（）
dict3=dict2.copy()
print(dict3)

#get() 根据键获取值 如果没有则返回None
print(dict1.get("name"))
print(dict1.get("fdfd"))

# keys()返回所有的键   返回值：<class 'dict_keys'>
keys=dict1.keys()
print(type(keys))
print(keys)


#values()返回所有的值  返回值 <class 'dict_values'>
values=dict1.values()
print(type(values))
print(values)


#setdefault() 设置默认值
dict1.setdefault("wangdaxian")
dict1.update({"country":""})
dict1.setdefault("","wangdaxian")
dict1.setdefault("","")
print(dict1)

#字典的键与值都可以为空


# items() 返回一个键值对
list1=dict1.items()
print(type(list1))   #<class 'dict_items'>
print(list1)


#pop()通过key删除键值对
dict1.pop("age")
print(dict1)

#popitem() 移除一个键值对，移除规则是LIFO 后进先出，尾部移除  并返回移除的键值对
print(dict1.popitem())

执行结果：

{}
{'喜好': '女', '擅长': '睡觉'}
wangdaxian
None
<class 'dict_keys'>
dict_keys(['name', 'age', 'gender'])
<class 'dict_values'>
dict_values(['wangdaxian', 100, '男'])
{'name': 'wangdaxian', 'age': 100, 'gender': '男', 'wangdaxian': None, 'country': '', '': 'wangdaxian'}
<class 'dict_items'>
dict_items([('name', 'wangdaxian'), ('age', 100), ('gender', '男'), ('wangdaxian', None), ('country', ''), ('', 'wangdaxian')])
{'name': 'wangdaxian', 'gender': '男', 'wangdaxian': None, 'country': '', '': 'wangdaxian'}
('', 'wangdaxian')