python常用数据结构讲解

一：序列
二：高级数据结构
- 1.栈
- 2.队列

一：序列

在数学上，序列是被排成一排的对象，而在python中，序列是最基本的数据结构。它的主要特征为拥有索引，每个索引的元素是可迭代对象。都可以进行索引，切片，加，乘，检查成员等操作。在python中，有六种内建的索引，但是常用的是列表，元组，字符串，下面就进行介绍。

1. 列表

定义：列表是把需要的数据类型进行封装，类似c语言的结构体。而且列表是动态可变的。

基本操作方法：

count():统计某个元素在列表中出现的次数。

index():从列表中找出某个值第一个匹配项的索引位置。

append():在列表末尾添加新对象。

extend():在列表末尾一次性追加另一个序列的多个值。

insert():在列表的指定位置插入对象。

pop():移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

remove():移除列表中某个值的第一个匹配项。

reverse():将列表中的元素反向，不重新拷贝一个列表。

reversed():将列表中的元素反向，重新拷贝一个列表。

sort():将列表中的元素排序，不重新拷贝一个列表。

sortd():将列表中的元素排序，重新拷贝一个列表。

copy():浅拷贝，只是给原来的列表贴上了一个新标签，对于一个复杂对象的子对象并不会完全复制，如果有子列表，改变原来的值，新的拷贝对象也会改变。

deepcopy():深拷贝，将复杂对象的每一层复制一个单独的个体出来。就是完全拷贝。

2.元组

定义：元组是不可变的，有时候可以看成不可变的列表。但元组可以进行连接组合与切片，且只含一个值的列表，必须要用","才行。

基本操作方法：

del:删除元组。

3.字符串

字符串是 Python 中最常用的数据类型。用成对引号创建即可。

基本操作方法：

format()：格式化字符串。

4.通用序列操作方法

index：索引，既可以从0开始，也可以从最后一个位置开始。

[:]：分片，用来访问一定范围内的元素。

常用算术操作符：相同类型序列可以进行算术运算或者复制序列。

in：成员操作符，用来检查一个对象是否为某个序列（或者其他类型）的成员（即元素）。

len,max,min：内建函数len、max和min可以返回序列中所包含元素的数量、最大和最小元素。

5.字典

定义：字典是映射，根据哈希表的原则，映射中元素的名字叫键。字典（也叫散列表）是Python中唯一内建的映射类型。字典中的元素的键可以是任何对象，但必须是不可变对象。比如序列中的集合和列表等可变对象，不能作为字典的键。

基本操作方法：

clear():清空字典。

pop(): 移除键，同时返回此键所对应的值。

copy():复制字典，只复制一层(浅拷贝)。

update(DD):将字典 DD 合并到D中，如果键相同，则此键的值取DD的值作为新值。

get(key, default):返回键key所对应的值,如果值不存在，则返回default。

keys():返回可迭代的字典的键的集合对象。

values():返回可迭代的字典的值的集合对象。

items():返回可迭代的字典的键值对的集合对象。

6.集合

定义：集合是由序列（或者其他可迭代的对象）构成的，是一个无序的不重复元素序列。

基本操作方法：

frozenset():创建一个空的固定集合对象。

frozenset(iterable):用可迭代对象创建一个新的固定集合对象。

set():创建一个空的集合对象(不能用{}来创建空集合)。

set(iterable):用可迭代对象创建一个新的集合对象。

add(e):在集合中添加一个新的元素e；如果元素已经存在，则不添加。

remove(e):从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误。

discard(e):从集合S中移除一个元素e,在元素e不存在时什么都不做。

clear():清空集合内的所有元素。

copy():对集合进行一次浅拷贝。

pop():从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常。

update(s2):更新字典。

二：高级数据结构

python还有一些高级数据结构，这些数据结构在进行算法运算时十分有用。下面就进行讲解。

1.栈

定义：栈是一种线性表，只允许从一端插入和删除数据，栈的插入和删除只能在栈顶进行。栈有两种存储方式，即线性存储和链接存储（链表）。所以每次删除的元素都是最后进栈的元素，故栈也被称为后进先出（LIFO）表。每个栈都有一个栈顶指针，它初始值为-1，且总是指向最后一个入栈的元素。

栈有两种处理方式，即进栈（push）和出栈（pop），进栈时只需要移动一个变量存储空间，时间复杂度为O(1)；但是对于出栈分两种情况，栈未满时，时间复杂度也为O(1)，但是当栈满时，需要重新分配内存，并移动栈内所有数据，所以此时的时间复杂度为O(n) 。

python中栈：在python中，栈其实可以用更加简单的列表实现，用append在末尾进行增加元素操作，用pop进行删除元素操作。

列表简单实现：

stack = []

# 向栈顶插入元素

stack.append(1)

stack.append(2)

stack.append(3)

# 删除栈顶的元素

print(stack.pop())

print(stack.pop())

print(stack.pop())

普通方法实现：

class MyStack(object):

    def __init__(self):

        self.stack_list = []	# 自定义一个列表

        self.count = 0			# 创建一个计数器，模拟栈顶指针

    # 创建一个栈

    def create_one_stack(self):

        return self.stack_list

    # 在栈顶添加元素

    def push(self, value):

        self.stack_list.insert(0,value)

        self.count += 1			# 计数器加一

    # 删除栈顶元素

    def pop(self):

        self.stack_list.pop(0)

        self.count -= 1			# # 计数器减一

    # 返回栈顶元素值

    def stack_num(self):

        if self.count:

            return self.stack_list[0]

    #打印栈内容

    def show_all(self):

        for s in self.stack_list:

            print(s)

if __name__ == '__main__':

    m = MyStack()

    m.create_one_stack()

    # 增加栈顶元素

    m.push(1)

    m.push(2)

    m.push(3)

    print('栈顶元素为:',m.stack_num())

    print('之前的元素为:')

    m.show_all()

    # 删除栈顶元素

    m.pop()

    print('之后的元素为:')

    m.show_all()

2.队列

定义：队列是一种特殊的线性表，和栈类似，但是在允许表的前面进行删除操作，而在表的后面进行插入操作，也是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。分为顺序队列和循环队列。这里先讨论顺序队列。

普通队列实现：

class Queue(object):

	def __init__(self):

		self.__list = []	# 创建一个列表

	def inQueue(self,item):

		# 从队尾入队，从队头出队

		self.__list.append(item)

	def outQueue(self):

		# 从队头出队

		return self.__list.pop(0)

if __name__ == '__main__':

	m = Queue()

	# 从队头入队

	m.inQueue(1)

	m.inQueue(2)

	# 从队尾出队

	print(m.outQueue())

	print(m.outQueue())

双端队列实现：

class Queue(object):

	def __init__(self):

		self.__list = []	# 创建一个列表

	def add_Front(self,x):

		#在列表头部添加

		self.__list.insert(0,x)

	def add_End(self,x):

		#在队列尾部添加元素

		self.__list.append(x)

	def pop_Front(self):

		#在头部删除元素

		return self.__list.pop(0)

	def pop_End(self):

		#在尾部删除元素

		return self.__list.pop()

if __name__ == '__main__':

	m = Queue()

	# 在队列头部添加元素

	m.add_Front(1)

	m.add_Front(2)

	m.add_Front(3)

	m.add_Front(4)

	# 在队列尾部添加元素

	m.add_End(5)

	m.add_End(6)

	m.add_End(7)

	m.add_End(8)

	# 在列表头部和尾部删除元素

	print(m.pop_Front())

	print(m.pop_Front())

	print(m.pop_End())

	print(m.pop_End())

以上就是python的常用数据结构的知识，还有其他不太常用的数据结构但经常会和算法相结合，实现事半功倍的效果，这些数据结构在之后会向大家展示。

如果你喜欢这篇文章，不妨进行点赞，或者点击右面的打赏功能，多多支持作者，谢谢，希望大家在技术的海洋里慢慢发现美和快乐。