python常用数据结构讲解，数据结构python

python常用数据结构讲解，数据结构python

目录

• 一：序列
  • 1. 列表
  • 2.元组
  • 3.字符串
  • 4.通用序列操作方法
  • 5.字典
  • 6.集合
• 二：高级数据结构
  • 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的常用数据结构的知识，还有其他不太常用的数据结构但经常会和算法相结合，实现事半功倍的效果，这些数据结构在之后会向大家展示。

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