【内置容器篇】

容器篇

一.内置容器分别有：

1.线性表;

2.哈希表;

3.树;

4.图;

二.具体情况如下

1.线性表(线性数据结构)：

线性结构是一种有序数据项的集合，其中每个数据项都有唯一的前驱和后继。除了第一个没有前驱，最后一个没有后继，新的数据项加入到数据集中时，只会加入到原有某个数据项之前或之后，具有这种性质的数据集，就称为线性结构。（简单来说就是有序列的容器）

（1）有序的序列容器

●数组（array）：

一段连续的内存空间（地址）：

弱数据类型编程语言没有数组，即便是它叫数组，也不是数组；

●链表（list）:是指采用链式结构来存储数据元素的线性表；

       可能是不连续的内存组成。

 ●栈（stack）：是一个有次序的数据集，每个数据项仅从“栈顶”一端加入到数据集中、 从数据集中移除，栈具有后进先出LIFO 和先进先出FILO。

●队列（queue）：队列（Queue）是一个有次序的数据集合，数据项仅添加到“尾rear” 端，而且仅从“首front”端移除；Queue具有FIFO的操作次序。

1.1  list（链表、列表）：

列表，python官方提供的内置的线性表

底层实现：基于双向链表结构实现

（1）定义列表：

age = [] # 中括号在python代表的就是列表

age = [18, 16, 20, 30]

names = list()

names = list("张三", "李四", "王五")

（2）操作列表中的元素（element）：

通过下标可以访问元素

列表[index]

注意：   index：从0开始；

最大值： 列表的总长度 - 1

（3）获取列表的长度：

len(Iterable) # 返回这个可迭代对象的长度

（4）列表的遍历：

●for循环

Code：

for 临时变量 in Iterable:

# 每一次得到的元素会放在临时变量中

●while循环；

（5）列表的常见方法：

['append', 'clear', 'copy', 'count', 'extend', 'index',

'insert', 'pop', 'remove', 'reverse', 'sort']

这些方法都是用来操作列表的CRUD（增删改查）

|-- append(ele) # 在尾部追加新的元素

|-- insert(index, ele) # 在特定的位置添加元素

|-- extend(list) # 合并列表

|-- clear() # 清空列表

|-- remove(ele) # 删除指定元素

|-- pop() # 删除最后一个元素

|-- index(ele) # 返回查找到的一个元素位置

|-- count(ele) # 返回元素的数量

|-- reverse() # 翻转列表顺序

|-- sort() # 排序

|-- copy() # 拷贝、复制，对象拷贝，对象浅拷贝

1. Set：哈希表（hash table）

所有的元素之间没有任何关系。元素的存储位置，是利用元素的关键字通过某个函数直接计算出来的。这个一一对应的关系函数称为散列函数或Hash函数。

（1）哈希算法的实现：能够将任何事物映射为一个特定的值

特点：     ●元素不能重复

                ●无序的

（2）定义set：

s = set(Iterable)

ss = {1,2,3,4,} #“{}”中必须有值，如果没有值，则默认是dict，不是set（原因是 set与dict都是用花括号”{}”存储的）

注意：set的元素无法通过下标访问

（3）set的常见方法：

['add', 'clear', 'copy', 'difference', 'difference_update',

'discard', 'intersection', 'intersection_update', 'isdisjoint',

'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference',

'symmetric_difference_update', 'union', 'update']

|-- add(ele) # 添加元素

|-- clear() # 清空列表

|-- copy() # 浅拷贝

|-- difference(set) # 差集

|-- intersection(set) # 交集

|-- union(set) # 并集

|-- update(set) # 合并两个集合

|-- discard(ele) # 移除元素，如果该元素不存在，则什么都不做

|-- remove(ele) # 移除元素，如果该元素不存在，则抛出异常

|-- pop() # 删除最后一个元素

|--update () #更新数据

|--union #返回两个集合的并集

注意：set没有办法使用while 遍历数据，只能使用for循环

3.tuple（元组）：

是一种不可变数据类型，基本数据类型也是不可变数据类型，不可变数据类型中如果存在了可变数据类型，这个子对象是可以发生变化的，所以表示的就是的固定的值，固定的一组值，可以通过下标来访问。

（注意：元组的元素一旦定义，就无法修改！！！）

（1）常用方法：

|-- count(ele) # 返回元素的数量

|-- index (ele) # 返回查找到的一个元素位置

4.字典（dict）:

字典和集合一样，底层实现就是一个hash table

（1）最终的表示方式：

键值对：一个唯一键对应一个值，一一对应的关系

●python中字典：

d = {}

d = {"id": 2, "name": "刘慧", "age": 17}

dd = dict({"id": 2, "name": "刘慧", "age": 17})

●获取字典中的值：

d[key] # 就可以获取字典中，key对应的值，如果不存在，则抛出异常

●字典对象.get(key,default) # 就可以获取字典中，key对应的值，如果不存在，则返回None

（2）字典对象的常见方法：

 ['clear', 'copy', 'fromkeys', 'get', 'items', 'keys',

 'pop', 'popitem', 'setdefault', 'update', 'values']

|-- clear() # 清空列表

|-- copy() # 浅拷贝

|-- get(key, [defaul]) # 在key参数不是字典键时返回

|-- setdefault() # 如果键在字典中，返回这个键所对应的值。

如果键不在字典中，向字典 中插入这个键，并且以default为这 个键的值，并返回 default。default的默认值为None

|-- keys() # 获取所有的键

|-- values() #获取当前字典中所有键值对中的值

|-- items() # 返回列表

|-- pop(key) # 通过key，删除键值对

|-- popitem() # 随机返回并删除字典末尾一组键值对

|-- update() # 合并字典  等价于 {**对象, **对象}

|-- fromkeys(iterable) # 生成一个新的字典对象

（3）如何遍历字典：

●for i in 对象.keys():

print(i, 对象[i])

●for i in 对象:

print(i, 对象[i])

●for item in 对象.items():

print(item[0], item[1])

●for (key, value) in 对象.items():

print(key, value)

●for key, value in 对象.items():

print(key, value)

• 排序：

为了方便大量数据的查找，一般会先排序这些数据，这个优秀的查找算法都是针对有序数据的

1.冒泡排序：

冒泡排序是同通过把列表内的元素两两之间进行比较，每一次把最大的值或者最小的值移动到列表的相对的最左边或者最右边的位置，

代码实现如下：

num = [8,5,2,3,7,4,6,1,9]

for i in range(0,len(num)-1):

  for j in range(0,len(num)-1-i):

  if num[j] >= num[j+1]:

   num[j],num[j+1] = num[j+1],num[j]

print(num)   

1. 选择排序：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

代码实现如下：

num = [8,5,2,3,7,4,6,1,9]

for i in range(0,len(num)):

  for j in range(i+1,len(num)):

   if num[i] >= num[j]:

    num[i],num[j] = num[j],num[i]

print(num)

1. 插入排序：

插入排序是一种简单直观的排序方法，其基本思想在于每次将一个待排序的记录，按照其关键字大小插入到前面已经排好序的子序列中，直到全部记录插入完成。

代码实现如下：

num = [8,5,2,3,7,4,6,1,9]

for i in range(0,len(num)):

for j in range(i,0,-1):

   if num[j] <= num[j-1]:

    num[j],num[j-1] = num[j-1],num[j]

print(num)