python--容器入门

python–容器入门

定义：
什么是容器：
容器就是一种数据类型，复合数据类型，存储多个变量；容器就是对象，对象都是存储在堆中的；Python中万物皆对象
python 中为了方便一部分相似数据的处理，提供了各种组合类型，常见的如列表、元组、字典等组合数据类型。

list：
有序的数列
在程序中，线性表：数组、链表、栈、队列
python的list底层就是基于双向链表结构设计的
列表的定义
​ 1、借助若数据类型语言的特点：直接赋值
eg：

ls = [1,2,3,4,5]
ls
[1, 2, 3, 4, 5]

type(ls)
<class ‘list’>

2、全局函数list
利用helo（）查看list()函数的帮助文档

help(list)
Help on class list in module builtins:
ls = list()
ls = list([1,23,3,4,4554])

3、访问list中的元素（element）
线性表，都是具有下标（索引）的
列表对象[下标]
注意：下标从0开始，注意下标越界问题！！！
print(ls[4]) # 访问ls中的第五个元素
ls[1] = 100 # 将ls列表中的第二个元素值修改为100

4、获取list中元素的个数
​ len的全局函数 可以接收可迭代对象
​ len(ls) # 获取元素的个数
**>>> user
[1，2，3，4，5]

len(user)
5

5、遍历列表
使用循环遍历
for index in ls2:
print(index)

# 使用while循环遍历列表
index = 0
while index < len(ls2):
    print(ls2[index])
    index += 1

6、list的常见方法：
[‘append’, ‘clear’, ‘copy’, ‘count’, ‘extend’, ‘index’,
‘insert’, ‘pop’, ‘remove’, ‘reverse’, ‘sort’]

|-- append(元素)		# 在列表尾部追加元素
|-- insert(index, 元素)		# 在6、应索引为插入元素
|-- remove(元素)		# 移除元素，如果不存在，则报错
|-- pop(index=-1)		# 默认移除最后一个元素，如果存在参数，则该参数就是要移除的下标，注意：下标有误，会抛出异常 
|-- clear()			# 清空列表
|-- reverse()			# 翻转列表元素顺序
|-- sort()			# 排序
|-- index(元素)			# 查找元素的位置
|-- count(元素)			# 统计元素的数量
|-- extend			# 合并列表
|-- copy()			# 复制列表对象，其本质是浅拷贝

7、全局函数：

len(list)可以获取列表中数据的数量

max(list) 可以获得列表中最大的数据

min(list) 可以获得列表中最小的数据

list(seq) 将一个序列数据转换成列表

ls = [1,2,3,4,5]
len(ls)
5

max(ls)
5

min(ls)
1

lis = list([1,2,3])
lis
[1, 2, 3]

set（集合）
特点：1、无序的；2、不能重复
底层使用的hash表（哈希表）的结构设计的
定义
1、借助弱数据类型语言的特点
注意：必须要存在值，否则默认空{}是字典类型，而不是set
s = {1,2,4}
2、全局set函数
s = set()

集合的遍历

set = {“eichi”,“yichen”,“yichentong”}
for i in set:
… print(i)
…
eichi
yichen
yichentong

常见方法：
‘add’, ‘clear’, ‘copy’, ‘difference’, ‘difference_update’,
‘discard’, ‘intersection’, ‘intersection_update’,
‘isdisjoint’, ‘issubset’, ‘issuperset’, ‘pop’,
‘remove’, ‘symmetric_difference’,
‘symmetric_difference_update’, ‘union’, ‘update’]

|-- add() # 添加元素
|-- clear() # 清除列表
|-- copy() # 浅拷贝对象
|-- difference() # 差集
|-- intersection() # 交集
|-- union() # 并集
|-- remove(元素) # 移除元素，如果不存在，则报错
|-- pop(元素) # 随机（arbitrary）移除，不存在，则报错
|-- discard(元素) # 随机（arbitrary）移除，不存在，则什么都不做

tuple（元组）
不可变数据类型，就是说，它里面的元素是不允许被修改的！！

元组定义
t = (1,3,4,4,5)
tt = tuple((1,3,4,4,5))

常见方法：
|-- count # 统计元素个数
|-- index # 查看某个值的位置 如存在多个元素，默认查询第一次出现的元素

当元组中只存在一个元素时，类型就不是tuple

t = (10)
type(t)
<class ‘int’>

t=(10,)
type(t)
<class ‘tuple’>

元组的遍历
与列表、集合类似，采用for循环来进行遍历

t
(1, 2, 3, 4, 55, 5, 4, 4, 3, 2)

for i in t:
… print(i)

字典：
语法结构：
字典变量名称={“变量 1”:”值 1”, “变量 2”:”值 2”, “变量 3”:”值 3”,}

定义的时候以键值对的形式定义存在，相当于给每个值取了名字
d = {}
d = {k1: v1, k2: v2}
d = dict({…})

可以使用key访问到key对应的值
d[“k1”]
d.get(“k2”)

p[“name”] = “lisi” # 增加键值对

常见方法：
clear’, ‘copy’, ‘fromkeys’, ‘get’, ‘items’,
‘keys’, ‘pop’, ‘popitem’, ‘setdefault’,
‘update’, ‘values’]
|-- clear
|-- copy
|-- get
|-- keys() # 将所有的key返回
|-- values() # 将所有的值返回
|-- setdefault
|-- items() # 一对一对的返回
|-- pop(key) # 通过key删除对应键值对
|-- popitem() # 安装 LIFO (last-in, first-out) order 删除键值对

字典的遍历方式：
1、
for key in p:
print(key, p[key])

2、
for key in p.keys():
print(key , p.get(key))

3、
for key, value in p.items():
print(key, value)
for (key, value) in p.items():
print(key, value)
for t in p.items():
print(t[0], t[1])

比较
元组 Tuple 是存放固定的数据
集合 Set 中的数据插入和遍历的时间，随数据增多而变慢
列表 List 中的数据插入和查询的时间，随数据的增多而变慢
字典 Dict 中的数据插入和查询的速度非常快，不会因为数据太多而变慢
元组、集合和列表占用内存较少，字典占用内存较多，字典是一种通过占用空间来换取
操作速度的一种数据类型。