数据结构与python
‘壹’ python自带及pandas、numpy数据结构(一)
1.python自带数据结构：序列（如list）、映射（如字典）、集合（set）。
以下只介绍序列中的list：
创建list：
list1 = []
list1 = [1,2,3,4,5,6,7,8,9] #逗号隔开
list2 = [[1,2],[3,4],[5,6],[7,8]] #list2长度(len(list2))为2,list2[0] = [1,2]
liststring = list(“thisisalist”) #只用于创建字符串行表
索引list：
e = list1[0] #下标从零开始，用中括号
分片list：
es = list1[0:3]
es = list1[0:9:2] #步长在第二个冒号后
list拼接（list1.append(obj)、加运算及乘运算）：
list长度：
list每个元素乘一个数值：
list2 = numpy.dot(list2,2)
list类似矩阵相乘（每个元素对应相乘取和）：
list3 = numpy.dot(list1,list1)
#要求相乘的两个list长度相同
list3 = numpy.dot(list2,list22)
#要求numpy.shape(list2)和numpy.shape(list22)满足“左行等于右列”的矩阵相乘条件，相乘结果numpy.shape(list3)满足“左列右行”
2.numpy数据结构：
Array：
产生array：
data=np.array([[1, 9, 6], [2, 8, 5], [3, 7, 4]])
data=np.array(list1)
data1 = np.zeros(5) #data1.shape = (5,),5列
data1 = np.eye(5)
索引array:
datacut = data[0,2] #取第零行第二列，此处是6
切片array：
datacut = data[0:2,2] # array([6, 5])
array长度：
data.shape
data.size
np.shape(data)
np.size(data)
len(data)
array拼接：
#括号内也有一个括号（中括号或者小括号）！
d = np.concatenate((data,data))
d = np.concatenate((data,data),axis = 1) #对应行拼接
array加法：逐个相加
array乘法：
d = data data #逐个相乘
d = np.dot(data,data) #矩阵相乘
d = data 3 #每个元素乘3
d = np.dot(data,3) #每个元素乘3
array矩阵运算：
取逆 : np.linalg.inv(data)
转置：data.T
所有元素求和 : np.sum(data)
生成随机数：np.random.normal(loc=0, scale=10, size=None)
生成标准正态分布随机数组：np.random.normal(size=(4,4))
生成二维随机数组：
np.random.multivariate_normal([0,0],np.eye(2))
生成范围在0到1之间的随机矩阵(M,N)：
np.random.randint(0,2,(M,N))
Matrix:
创建matrix：
mat1 = np.mat([[1, 2, 3], [4, 5, 6]])
mat1 = np.mat(list)
mat1 = np.mat(data)
matrix是二维的，所有+，-，*都是矩阵操作。
matrix索引和分列：
mat1[0:2，1]
matrix转置：
np.transpose(mat1)
mat1.transpose()
matrix拼接：
np.concatenate([mat1,mat1])
np.concatenate([mat1,mat1],axis = 1)
numpy数据结构总结：对于numpy中的数据结构的操作方法基本相同：
创建：np.mat(list),np.array(list)
矩阵乘：np.dot(x,y)
转置：x.T or np.transpose(x)
拼接：np.concatenate([x,y],axis = 1)
索引：mat[0:1,4],ary[0:1,4]
3.pandas数据结构:
Series:
创建series：
s = pd.Series([[1,2,3],[4,5,6]],index = [‘a’,‘b’])
索引series：
s1 = s[‘b’]
拼接series：
pd.concat([s1,s1],axis = 1) #也可使用s.append(s)
DataFrame:
创建DaraFrame:
df = pd.DataFrame([[1,2,3],[1,2,3]],index = ['a','b'],columns = ['x','y','z'])
df取某一列：
dfc1 =df.x
dfc1 = df[‘x’]
dfc2 = df.iloc[:,0] #用.iloc方括号里是数字而不是column名！
dfc2 = df.iloc[:,0:3]
df取某一行：
dfr1 = df.iloc[0]
df1 = df.iloc[0:2]
df1 = df[0:2] #这种方法只能用于取一个区间
df取某个值：
dfc2 = df.iloc[0,0]
dfc2 = df.iloc[0:2,0:3]
‘贰’ PYTHON的数据结构和算法介绍
当你听到数据结构时，你会想到什么？
数据结构是根据类型组织和分组数据的容器。它们基于可变性和顺序而不同。可变性是指创建后改变对象的能力。我们有两种类型的数据结构，内置数据结构和用户定义的数据结构。
什么是数据算法-是由计算机执行的一系列步骤，接受输入并将其转换为目标输出。
列表是用方括号定义的，包含用逗号分隔的数据。该列表是可变的和有序的。它可以包含不同数据类型的混合。
months=['january','february','march','april','may','june','july','august','september','october','november','december']
print(months[0])#print the element with index 0
print(months[0:7])#all the elements from index 0 to 6
months[0]='birthday #exchange the value in index 0 with the word birthday
print(months)
元组是另一种容器。它是不可变有序元素序列的数据类型。不可变的，因为你不能从元组中添加和删除元素，或者就地排序。
length, width, height =9,3,1 #We can assign multiple variables in one shot
print("The dimensions are {} * {} * {}".format(length, width, height))
一组
集合是唯一元素的可变且无序的集合。它可以让我们快速地从列表中删除重复项。
numbers=[1,2,3,4,6,3,3]
unique_nums = set(numbers)
print(unique_nums)
models ={'declan','gift','jabali','viola','kinya','nick',betty' }
print('davis' in models)#check if there is turner in the set models
models.add('davis')
print(model.pop())remove the last item#
字典
字典是可变和无序的数据结构。它允许存储一对项目(即键和值)
下面的例子显示了将容器包含到其他容器中来创建复合数据结构的可能性。
* 用户定义的数据结构*
使用数组的堆栈堆栈是一种线性数据结构，其中元素按顺序排列。它遵循L.I.F.O的机制，意思是后进先出。因此，最后插入的元素将作为第一个元素被删除。这些操作是:
溢出情况——当我们试图在一个已经有最大元素的堆栈中再放一个元素时，就会出现这种情况。
下溢情况——当我们试图从一个空堆栈中删除一个元素时，就会出现这种情况。
队列是一种线性数据结构，其中的元素按顺序排列。它遵循先进先出的F.I.F.O机制。
描述队列特征的方面
两端:
前端-指向起始元素。
指向最后一个元素。
有两种操作:
树用于定义层次结构。它从根节点开始，再往下，最后的节点称为子节点。
链表
它是具有一系列连接节点的线性数据。每个节点存储数据并显示到下一个节点的路由。它们用来实现撤销功能和动态内存分配。
图表
这是一种数据结构，它收集了具有连接到其他节点的数据的节点。
它包括:
算法
在算法方面，我不会讲得太深，只是陈述方法和类型:
原文：https://www.tuicool.com/articles/hit/VRRvYr3
‘叁’ python的基本数据结构有哪些
全国计算机等级考试二级操作题部分采用计算机自动评分方式，其中有的题型采用比照标准答案集进行评分，有的题型用一定的算法对程序的输出结果进行检测来评分。简笑改
一、Python语言的基本语法元素
1、程序的基本语法元素：程序的格式框架、缩进、注释、变量、命名、保留字、数据类型、赋值语句、引用；
2、基本输入输出函数：input()、eval()、print();
3、源程序的书写风格；
4、Python语言的特点。
二、基本数据类型
1、数字类型：整数类型、浮点数类型和复数类型；
2、数字类型的运算：数值运算操作符、数值运算函数；
3、字符串类型及格式化：索引、切片、基本的format()格式化方法；
4、字符升数串类型的操作：字符串操作符、处理函数和处理方法；
5、类型判断和类型间转换。
三、程序控制结构
1、程序的三种控制结构；
2、程序的分支结构：单分支结构、二分支结构、多分支结构；
3、程序的循环结构：拦判遍历循环、无限循环、break和continue循环控制；
4、程序的异常处理：try-except。
‘肆’ python基础数据结构：序列、映射、集合
参考资料：http://www.cnblogs.com/jeffwongishandsome/archive/2012/08/05/2623660.html
Python中常见的数据结构可以统称为容器（container）。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。
一、序列（列表、元组和字符串）
序列中的每个元素都有自己的编号。Python中有6种内建的序列。其中列表和元组是最常见的类型。其他包括字符串、Unicode字符串、buffer对象和xrange对象。下面重点介绍下列表、元组和字符串。
1、列表
列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。
（1）、创建
通过下面的方式即可创建一个列表：
输出：
['hello', 'world']
[1, 2, 3]
可以看到，这中创建方式非常类似于javascript中的数组。
（2）、list函数
通过list函数（其实list是一种类型而不是函数）对字符串创建列表非常有效：
输出：
['h', 'e', 'l', 'l', 'o']
2、元组
元组与列表一样，也是一种序列，唯一不同的是元组不能被修改（字符串其实也有这种特点）。
（1） 、创建
输出：
(1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,)
从上面我们可以分析得出：
a、逗号分隔一些值，元组自动创建完成；
b、元组大部分时候是通过圆括号括起来的；
c、空元组可以用没有包含内容的圆括号来表示；
d、只含一个值的元组，必须加个逗号（,）；
（2）、tuple函数
tuple函数和序列的list函数几乎一样：以一个序列（注意是序列）作为参数并把它转换为元组。如果参数就算元组，那么该参数就会原样返回：
输出：
(1, 2, 3)
('j', 'e', 'f', 'f')
(1, 2, 3)
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in
t4=tuple(123)
TypeError: 'int' object is not iterable
3、字符串
（1）创建
输出：
Hello world
H
H
e
l
l
o
w
o
r
l
d
（2）、格式化
format（）：
print(‘{0} was {1} years old when he wrote this book’. format(name,age) )
print(‘{} was {} years old when he wrote this book’. format(name,age) )
print(‘{name} was {age} years old when he wrote this book’. format(name=’Lily’,age=’22’) )
#对于浮点数“0.333”保留小数点后三位
print(‘{0 : .3f}’.format(1.0/3) )
结果：0.333
#使用下划线填充文本，并保持文字处于中间位置
#使用^定义‘_____hello_____’字符串长度为11
print(‘{0 : ^_11}’.format(‘hello’) )
结果：_____hello_____
% :
格式化操作符的右操作数可以是任何东西，如果是元组或者映射类型（如字典），那么字符串格式化将会有所不同。
输出：
Hello,world
Hello,World
注意：如果需要转换的元组作为转换表达式的一部分存在，那么必须将它用圆括号括起来：
输出：
Traceback (most recent call last):
File "F:\Python\test.py", line 2, in
str1='%s,%s' % 'Hello','world'
TypeError: not enough arguments for format string
如果需要输出%这个特殊字符，毫无疑问，我们会想到转义，但是Python中正确的处理方式如下：
输出：100%
对数字进行格式化处理，通常需要控制输出的宽度和精度：
输出：
3.14
3.141593
3.14
字符串格式化还包含很多其他丰富的转换类型，可参考官方文档。
4、通用序列操作（方法）
从列表、元组以及字符串可以“抽象”出序列的一些公共通用方法（不是你想象中的CRUD），这些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及检查某个元素是否属于序列的成员。除此之外，还有计算序列长度、最大最小元素等内置函数。
（1）索引
输出
H
2
345
索引从0（从左向右）开始，所有序列可通过这种方式进行索引。神奇的是，索引可以从最后一个位置（从右向左）开始，编号是-1：
输出：
o
3
123
（2）分片
分片操作用来访问一定范围内的元素。分片通过冒号相隔的两个索引来实现：
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4]
[6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[7, 8]
[7, 8, 9]
不同的步长，有不同的输出：
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8]
[0, 3, 6, 9]
[]
（3）序列相加
输出：
Hello world
[1, 2, 3, 2, 3, 4]
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in
print str1+num1
TypeError: cannot concatenate 'str' and 'list' objects
（4）乘法
输出：
[None, None, None, None, None, None, None, None, None, None]
HelloHello
[1, 2, 1, 2]
Traceback (most recent call last):
File "F:\Python\test.py", line 5, in
print str1*num1
TypeError: can't multiply sequence by non-int of type 'list'
（5）成员资格
in运算符会用来检查一个对象是否为某个序列（或者其他类型）的成员（即元素）：
输出：
False
True
True
（6）长度、最大最小值
通过内建函数len、max和min可以返回序列中所包含元素的数量、最大和最小元素。
输出：
5
o
H
5
123
1
二、映射（字典）
映射中的每个元素都有一个名字，如你所知，这个名字专业的名称叫键。字典（也叫散列表）是Python中唯一内建的映射类型。
1、键类型
字典的键可以是数字、字符串或者是元组，键必须唯一。在Python中，数字、字符串和元组都被设计成不可变类型，而常见的列表以及集合（set）都是可变的，所以列表和集合不能作为字典的键。键可以为任何不可变类型，这正是Python中的字典最强大的地方。
输出：
{1: 1}
Traceback (most recent call last):
File "F:\Python\test.py", line 6, in
d[list1]="Hello world."
TypeError: unhashable type: 'list'
2、自动添加
即使键在字典中并不存在，也可以为它分配一个值，这样字典就会建立新的项。
3、成员资格
表达式item in d（d为字典）查找的是键（containskey），而不是值（containsvalue）。
三、集合
集合（Set）在Python 2.3引入，通常使用较新版Python可直接创建，如下所示：
strs=set(['jeff','wong','cnblogs'])
nums=set(range(10))
看上去，集合就是由序列（或者其他可迭代的对象）构建的。集合的几个重要特点和方法如下：
1、副本是被忽略的
集合主要用于检查成员资格，因此副本是被忽略的，如下示例所示,输出的集合内容是一样的。
输出如下：
set([0, 1, 2, 3, 4, 5])
set([0, 1, 2, 3, 4, 5])
2、集合元素的顺序是随意的
这一点和字典非常像，可以简单理解集合为没有value的字典。
输出如下：
set(['wong', 'cnblogs', 'jeff'])
3、集合常用方法
a、并集union
输出：
set([1, 2, 3])
set([2, 3, 4])
set([1, 2, 3, 4])
union操作返回两个集合的并集，不改变原有集合。使用按位与（OR）运算符“|”可以得到一样的结果：
输出和上面union操作一模一样的结果。
其他常见操作包括&（交集）,<=,>=,-,()等等，这里不再列举。
输出如下：
set([1, 2, 3])
set([2, 3, 4])
set([2, 3])
True
set([1, 2, 3])
False
b、add和remove
和序列添加和移除的方法非常类似，可参考官方文档：
输出：
set([1])
set([1, 2])
set([1])
set([1])
False
Traceback (most recent call last):
File "F:\Python\test.py", line 9, in
set1.remove(29) #移除不存在的项
KeyError: 29
4、frozenset
集合是可变的，所以不能用做字典的键。集合本身只能包含不可变值，所以也就不能包含其他集合：
输出如下：
Traceback (most recent call last):
File "F:\Python\test.py", line 3, in
set1.add(set2)
TypeError: unhashable type: 'set'
可以使用frozenset类型用于代表不可变（可散列）的集合：
输出：
set([1, frozenset([2])])
‘伍’ 《数据结构与算法Python语言描述》pdf下载在线阅读全文，求百度网盘云资源
《数据结构与算法Python语言描述》网络网盘pdf最新全集下载:
链接: https://pan..com/s/13XAS0SLNmxior29Jdxkutw
简介：数据结构与算法Python语言描述基于Python语言介绍了数据结构与算法的基本知识，主要内容包括抽象数据类型和Python面向对象程序设计、线性表、字符串、栈和队列、二叉树和树、集合、排序以及算法的基本知识。本书延续问题求解的思路，从解决问题的目标来组织教学内容，注重理论与实践的并用。
‘陆’ 利用Python进行数据分析笔记：3.1数据结构
元组是一种固定长度、不可变的Python对象序列。创建元组最简单的办法是用逗号分隔序列值：
tuple 函数将任意序列或迭代器转换为元组：
中括号 [] 可以获取元组的元素， Python中序列索引从0开始 ：
元组一旦创建，各个位置上的对象是无法被修改的，如果元组的一个对象是可变的，例如列表，你可以在它内部进行修改：
可以使用 + 号连接元组来生成更长的元组：
元组乘以整数，则会和列表一样，生成含有多份拷贝的元组：
将元组型的表达式赋值给变量，Python会对等号右边的值进行拆包：
拆包的一个常用场景就是遍历元组或列表组成的序列：
*rest 用于在函数调用时获取任意长度的位置参数列表：
count 用于计量某个数值在元组中出现的次数：
列表的长度可变，内容可以修改。可以使用 [] 或者 list 类型函数来定义列表：
append 方法将元素添加到列表尾部：
insert 方法可以将元素插入到指定列表位置：
（ 插入位置范围在0到列表长度之间 ）
pop 是 insert 的反操作，将特定位置的元素移除并返回：
remove 方法会定位第一个符合要求的值并移除它：
in 关键字可以检查一个值是否在列表中；
not in 表示不在：
+ 号可以连接两个列表：
extend 方法可以向该列表添加多个元素：
使用 extend 将元素添加到已经存在的列表是更好的方式，比 + 快。
sort 方法可以对列表进行排序：
key 可以传递一个用于生成排序值的函数，例如通过字符串的长度进行排序：
bisect.bisect 找到元素应当被插入的位置，返回位置信息
bisect.insort 将元素插入到已排序列表的相应位置保持序列排序
bisect 模块的函数并不会检查列表是否已经排序，因此对未排序列表使用bisect不会报错，但是可能导致不正确结果
切片符号可以对大多数序列类型选取子集，基本形式是 [start:stop]
起始位置start索引包含，结束位置stop索引不包含
切片还可以将序列赋值给变量：
start和stop可以省略，默认传入起始位置或结束位置，负索引可以从序列尾部进行索引：
步进值 step 可以在第二个冒号后面使用， 意思是每隔多少个数取一个值：
对列表或元组进行翻转时，一种很聪明的用法时向步进值传值-1：
dict(字典)可能是Python内建数据结构中最重要的，它更为常用的名字是 哈希表 或者 关联数组 。
字典是键值对集合，其中键和值都是Python对象。
{} 是创建字典的一种方式，字典中用逗号将键值对分隔：
你可以访问、插入或设置字典中的元素,:
in 检查字典是否含有一个键：
del 或 pop 方法删除值， pop 方法会在删除的同时返回被删的值，并删除键：
update 方法将两个字典合并：
update方法改变了字典元素位置，对于字典中已经存在的键，如果传给update方法的数据也含有相同的键，则它的值将会被覆盖。
字典的值可以是任何Python对象，但键必须是不可变的对象，比如标量类型（整数、浮点数、字符串）或元组（且元组内对象也必须是不可变对象）。
通过 hash 函数可以检查一个对象是否可以哈希化（即是否可以用作字典的键）：
集合是一种无序且元素唯一的容器。
set 函数或者是用字面值集与大括号，创建集合：
union 方法或 | 二元操作符获得两个集合的联合即两个集合中不同元素的并集：
intersection 方法或 & 操作符获得交集即两个集合中同时包含的元素：
常用的集合方法列表：
和字典类似，集合的元素必须是不可变的。如果想要包含列表型的元素，必须先转换为元组：
‘柒’ python基础教程-数据类型详解
python提供了多种的数据类型，用来存放数据。其中数据类型中又包括：字符串，布尔类型指销，整数，浮点数，数字，列表，元组，字典，日期。
1、字符串
a='this is string'print aa="this is string"print aa='''this is stringthis is stringthis is string'''print a
布尔类型
常见的用橡逗陆于循环判断中
整数
a=int(80.9741)print a
浮点数
a= float(80.974)print a
字符类型的转换
int(x [,base]) 将x转换为一个整数
float(x ) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象x转换为字符串
repr(x) 将对象x转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列s转换为一个元组
list(s) 将序列s转换为一个列表
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串
列表
L1 = [1,2,3]print L1L2 = ['abc']print L2L3 = ["a","b","c"]print L3L = list("Python")print Lprint L[0]print L[3]print L[-1]
Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号()，列表使用方括号[]；元组创建很简单，只需要在括号中添加元素，并使用逗号(,)隔开即可，例如：
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "梁顷d";
字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};
时间日期
import time, datetime;localtime = time.localtime(time.time())today = datetime.date.today()print "Local current time :", today
‘捌’ Python数据结构之Array用法实例
Python数据结构之Array用法实例
这篇文章主要介绍了Python数据结构之Array用法实例,较为详细的讲述了Array的常见用法,具有很好的参考借鉴价值,需要的朋友可以参考下
import ctypes
class Array:
def __init__(self, size):
assert size > 0, "Array size must be > 0 "
self._size = size
pyArrayType = ctypes.py_object * size
self._elements = pyArrayType()
self.clear(None)
def clear(self, value):
for index in range(len(self)):
self._elements[index] = value
def __len__(self):
return self._size
def __getitem__(self, index):
assert index >= 0 and index < len(self), "index must >=0 and <= size"
return self._elements[index]
def __setitem__(self, index, value):
assert index >= 0 and index < len(self), "index must >=0 and <= size"
self._elements[index] = value
def __iter__(self):
return _ArrayIterator(self._elements)
class _ArrayIterator:
def __init__(self, theArray):
self._arrayRef = theArray
self._curNdr = 0
def __next__(self):
if self._curNdr < len(theArray):
entry = self._arrayRef[self._curNdr]
sllf._curNdr += 1
return entry
else:
raise StopIteration
def __iter__(self):
return self
class Array2D :
def __init__(self, numRows, numCols):
self._theRows = Array(numCols)
for i in range(numCols):
self._theRows[i] = Array(numCols)
def numRows(self):
return len(self._theRows)
def numCols(self):
return len(self._theRows[0])
def clear(self, value):
for row in range(self.numRows):
self._theRows[row].clear(value)
def __getitem__(self, ndxTuple):
assert len(ndxTuple) == 2, "the tuple must 2"
row = ndxTuple[0]
col = ndxTuple[1]
assert row>=0 and row <len(self.numRows())
and col>=0 and col<len(self.numCols),
"array subscrpt out of range"
theArray = self._theRows[row]
return theArray[col]
def __setitem__(self, ndxTuple, value):
assert len(ndxTuple)==2, "the tuple must 2"
row = ndxTuple[0]
col = ndxTuple[1]
assert row >= 0 and row < len(self.numRows)
and col >= 0 and col < len(self.numCols),
"row and col is invalidate"
theArray = self._theRows[row];
theArray[col] = value
希望本文所述对大家的Python程序设计有所帮助。
‘玖’ Python数据结构与算法-哈希map的实现及原理
1-collections.MutableMapping
1.1 概念：这是什么？
大家可能想知道这一串英文是什么意思？其实只需要了解在collections库当中有一个非常重要的抽象基类MutableMappin
g，专门用于实现map的一个非常有价值的工具。后边我们会用到它。
2-我们的map基类
2.1 实现这个类
这个基类其实也就是确定了键值对的属性，并且存储了基本的比较方法。它的对象就是一个键值对咯。这个很好理解。有点类似object的感觉。
3-通过map基类实现的无序映射
给大家看一个上边的例子，这个例子来源于网络，自己改了改，能用，更加详细而已，凑合看.
4-Python哈希表的实现的基类
4.1 咱有话直说：上才（代）艺（码）
如果还不知道哈希表概念的同xio，请参考 python进阶之数据结构与算法–中级-哈希表（小白piao分享） 。废话不多说，咱们撸代码：
OK了，基本的哈希表就实现了，其实仔细想想很容易，但是自己要能实现还是要理解哈希表的本质哦，外加一定量的练习才可以熟练掌握，练习的目的就是为了熟练而已。
5-分离链表实现的具体哈希map类
说明：这玩意只是一种降低冲突的手段，上一节提过，降低冲突最好的地方是发生在元组进入桶的时候，所以想必大家猜到了，接下来的分离链表也就是为了self._bucket_xxxxxxx系列方法做准备。这里之所以在上边使用@abstractmethod就是为了继承实现，目的可以实现多种将冲突的哈希表。分离链表的概念上一节也有的。
“见码入面”（借鉴：见字如面这个电视节目，有兴趣可以看看，还不错的）：
6-用线性探测处理冲突的哈希map类
这种方式的好处不需要再去借助其他额外的赋值结构来表示桶。结构更加简单。不会再像上一种方法还要让桶是一个UnsortedTableMap的对象。
代码如下：
‘拾’ python有哪些数据结构
python三种核心数据结构如下：
1、列表尘态。list是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。列表中的项目。列表中的项目应该包括在方括号中，这样python就知道你是在指明一个列表。一旦你创建了一个列表，你就可以添加，删除，或者是搜索列表中的项目。由于你可以增加或删除项目，我们说列表是可变的数据类型，即这种类型是可以被改变的，并且列表是可以嵌套的。
2、元组。元组和列表十分相似，不过元组是不可变的。即你不能修改元组。元组通过圆括号中用逗号分隔的项目定义。元组通常用在使语句或用户定义的函数能够安派让源全的采用一组值的时候，即被使用的元组的值不会改变。元组可以嵌套。
3、字典。字典类似于你通过联系人名称查找地址和联系人详细情况的滑锋地址簿，即，我们把键（名字）和值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。
学习Python的注意事项。
1、打好基础。已经选择了Python这一门学科，就要坚定学下去的决心，打好基础很重要。也许一开始会觉得这也不懂那也不懂，硬着头皮坚持下去。因为Python是一个有条理的、强大的面向对象的程序设计语言，学好基础知识是前提。
2、Python的基础知识包括：下载、安装、导入库、字符串处理、函数使用等等。如果你的英语不是很好，可以通过“译中文文档”这个网站进行翻译整理。当然翻译很麻烦，如果想省掉翻译环节，可以报一个培训班，进行中文无障碍教学。