python内部的数据结构
2021/11/25 12:10:06
本文主要是介绍python内部的数据结构，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
一。概念
程序使用数据结构处理数据时，瑰石如何组织和保存在内存中，请注意，存储在磁盘中作为永久性存储（如关系表）的一部分数据，在此处不能被称为数据结构。算法是一步一步来处理特定用途数据的指令集合。因此算法以逻辑方式利用各种数据结构来解决特定的计算问题。
数据结构是计算机科学的基本概念。在这里我们了解到一些常用的数据结构的概念，以及它们与某些python数据类型的关系。还有一些特定于python的数据结构，他们将会成为另一个类别。
二。一般的数据结构
1.线性数据结构（依顺序的方式存储数据元素的数据结构）
数组（索引），链表（指向另一个元素的链接及其中的数据），堆栈（LIFO（后进先出），FILO(先进先出)）
队列（FIFO(先进先出)）， 矩阵（二维数据结构，其中数据元素由一对索引引用）
2.非线性数据结构（数据结构中 没有数据元素的顺序连接，任何一对或一组数据都可以相互关联，并且可以在没有严格数序的情况下进行访问）
二叉树：:它是一个数据结构，每个数据元素可以连接到最多两个其他数据元素，并以一个根节点开始。
堆：这是树形数据结构的特殊情况，其中父节点中的数据严格大于/等于子节点或严格小于其子节点。
哈希表：它是一个数据结构，它由使用散列函数相互关联的数组构成。 它使用键而不是数据元素的索引来检索值
图：它是定点和节点的排序，其中一些节点通过来链接彼此连接
Python特定的数据结构
这些数据结构是python语言特有的，它们可以更灵活地存储不同类型的数据，并且在python环境下处理更快。
列表： 除了数据元素可以具有不同的数据类型之外，它与数组类似。可以在Python列表中同时包含数字和字符串数据。
元组： 元组类似于列表，但是它们是不可变的，这意味着元组中的值不能被修改，所以它们只能被读取。
字典：该字典包含键值对作为其数据元素。
三。数组（是一个容器，注意与python中列表的对比，可以用不同的语言声明，索引从0开始，数组长度，每个元素都可以通过索引访问），他可以容纳一定数量的项目，这些项目是相同类型，大部分数据结构都是用数组来实现他们的算法。
1.基本操作
遍历，插入，删除，搜索，更新
2.python语言中数组的实现
from array import *
#b/B/c/i/I/f/d
#1字节有符号整数/1字节无符号整数/1字节字符/2字节符号整数/2字节无符号整数/4字节浮点数/8字节浮点数
arrayName=array('i',[10,20,30,40,50])
for i in arrayName:
print(i)
#访问数组元素
array1=arrayName
print(array1[0])
print(array1[2])
#插入操作（insert）
array1.insert(0,20)
for i in array1:
print(i)
#删除元素
array1.remove(40)
#查找/搜索操作
print(array1.index(20))
#如果该值不再数组中，则返回一个错误
#更新
array1[0]=30
四。列表（列表中的项目不必是相同的类型） 方括号 ， 索引从0开始
1.访问元素：[] , 切片
2.更新：可以通过在赋值运算符的左侧给出切片来更新列表的单个或多个元素，并且可以使用append()方法将其添加到列表中的元素
3.删除元素：del list1[2]
4.重复 ： * ， +
列表很像字符串一样对+和*运算符作出响应; 它们也意味着连接和重复，但它计算返回结果是新列表，而不是字符串。
五。元祖：（） 索引是从0开始
1.访问元素： [] 切片
2.改变元祖：元组是不可变的，这意味着不能更新或改变元组元素的值。但是可以将现有的元组的一部分来创建或重组成新的元组
3.删除元素：删除单个元组元素是不可能的；删除整个元素— del tup
4.元素的基本操作
六。字典（每个键和值之间使用冒号分开，每个项之间使用（，）隔开；整个字典数据用大括号括起来；空字典的话{}；键是字典中唯一的，而值可能是不唯一的，字典的值可以是任何类型，但是键必须是不可变类型）
1.访问操作：[] 如果尝试使用不属于字典的键来访问数据项，那么会得到错误
2.更新字典元素；（添加----[]）
3.删除字典元素：del (字典不再存在) dict.clear() 清空字典，字典存在但为空
注意：键不能重名，重名的话后一个会覆盖掉前一个；键必须是不可变的
七。二维数组（是一个数组的数组，在这种类型的数组中，数据元素的位置有两个索引，而不是一个索引来引用，是一个包含行和列的数据的表，二维数组中每个数组元素本身也是一个数组）
from array import *
T=[[1,2,3,4],[5,6,7,8],[9,12,13,14],[8,7,6,5]]
#用两个索引来访问二维数组中的数据元素，一个索引引用主数组或父数组，另一个索引引用内部数组中的数据元素的位置
#如果只是用一个索引，那么姜维该索引位置打印真个内部数据
print(T[0])
print(T[1][2])
#可以使用for循环打印处整个二维数组，使用行尾来打印处不同行中的值
for r in T:
for c in r:
print(c,end=" ")
print()
#二维数组中插入值
T.insert(2,[0,5,11,13,6])
#更新二维数组中的值，使用数组索引重新复制来更新内部数组或内部数组的某些特定数据元素
T[2]=[11,9]
T[0][3]=7
print('-------------------------------------------')
for r in T:
for i in r:
print(i,end=' ')
print()
#删除二维数组中的值
del T[0][0]
print('---------------------------------------')
for r in T:
for i in r:
print(i,end=' ')
print()
#运行结果 F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py [1, 2, 3, 4] 7 1 2 3 4 5 6 7 8 9 12 13 14 8 7 6 5 ------------------------------------------- 1 2 3 7 5 6 7 8 11 9 9 12 13 14 8 7 6 5 --------------------------------------- 2 3 7 5 6 7 8 11 9 9 12 13 14 8 7 6 5
八。集合（不以任何特定顺序的数据项）
集合中的元素不能重复。
集合中的元素是不可变的(不能被修改)，但集合作为一个整体是可变的。
附加到python集合中的任何元素不需要索引。所以集合不支持任何索引或切片操作
1.创建 ：例子
Days=set([“Mon”,“Tue”,“Wed”,“Thu”,“Fri”,“Sat”,“Sun”])
当打印集合的时候，元素的顺序会发生变化
2.访问集合中的元素
无法访问集合的单个元素，只能访问多有元素，但可以通过遍历打印数单个元素的列表
3.添加元素 add()
4.删除元素 discard(‘元素值’)
5.集合的联合操作 AllDays=DayA|DaysB 包含来自两个集合的所有不同元素的新集合
6.集合的交集
AllDays = DaysA & DaysB
7.差集
AllDays = DaysA - DaysB
#8.比较集合
SubsetRes = DaysA <= DaysB SupersetRes = DaysB >= DaysA
九。矩阵
from array import *
T = [[11, 12, 5, 2], [15, 6,10], [10, 8, 12, 5], [12,15,8,6]]
print(type(T))
array1=array('b', [15, 6,10])
print(type(array1))
import numpy as np
shuzu=np.arange(20)
x=shuzu.reshape(5,4)
print(x)
print('--------------------------------------------------')
print(np.mean(x,axis=1))#1代表行
#删除
print('删除第二列：')
print(np.delete(x,1,axis=1))#所有行的索引为1的元素，及第一列的元素
print(x[1][2])
'''
访问方式
列表：[][]
数组：[][]
矩阵：[][]
'''
十。python节点
在有些情况下，存储数据的内存分配不能位于连续的内存块中。 所以接受指针的帮助，其中数据和数据元素的下一个位置的地址也被存储。 所以从当前数据元素的值中知道下一个数据元素的地址。通常这样的结构被称为指针。 但在Python中，将它们称为节点。
节点是各种其他数据结构 链表和树在python中处理的基础
class daynames:
def __init__(self,dataval=None):
self.dataval=dataval
self.nextval=None
e1=daynames('Mon')
e2=daynames('Tue')
e3=daynames('Wed')
e1.nextval=e3
e3.nextval=e2
2.节点元素的遍历
class daynames:
def __init__(self, dataval=None):
self.dataval = dataval
self.nextval = None
e1 = daynames('Mon')
e2 = daynames('Tue')
e3 = daynames('Wed')
e1.nextval = e3
e3.nextval = e2
thisvalue=e1
while thisvalue:
print(thisvalue.dataval)
thisvalue=thisvalue.nextval
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py Mon Wed Tue Process finished with exit code 0
十一。python链表（单链表）
1.创建链表
#创建
class Node:
def __init__(self,dataval=None):
self.dataval=dataval
self.nextval=None
class SLinkedList:
def __init__(self):
self.headval=None
#遍历的方法
def listprint(self):
printval=self.headval
while printval is not None:
print(printval.dataval)
printval =printval.nextval
#在列表的开头插入
def AtBegining(self,newdata):
NewNode = Node(newdata)
NewNode.nextval = self.headval
self.headval=NewNode
#在列表的尾部插入节点
def AtEnd(self,newdata):
NewNode = Node(newdata)
if self.headval is None:
self.headval=NewNode
return
laste=self.headval
#我觉得这个是精华的所在
while(laste.nextval):
laste=laste.nextval
laste.nextval=NewNode
def Inbetween(self,middle_node,newdata):
if middle_node is None:
print("the mentioned node is absent")
return
NewNode = Node(newdata)
NewNode.nextval=middle_node.nextval
middle_node.nextval = NewNode
list1=SLinkedList()
list1.headval=Node('Mon')
e2=Node('heTue')
e3=Node('Wed')
list1.headval.nextval=e2
e2.nextval=e3
#遍历
list1.listprint()
#在头部插入节点
list1.AtBegining("sum")
print('--------------------------')
list1.listprint()
print('-------------------------------------------')
#在尾部插入节点
list1.AtEnd('Thu')
list1.listprint()
print('-----------------------------------')
#在中间插入
list1.Inbetween(e2,"Fri")
list1.listprint()
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py Mon heTue Wed -------------------------- sum Mon heTue Wed ------------------------------------------- sum Mon heTue Wed Thu ----------------------------------- sum Mon heTue Fri Wed Thu
2.从链表中删除元素
#从链表中删除一个节点
#可以使用该节点的键来删除一个节点，在下面的程序中，找到要删除的节点的前一个节点，然后将该节点的下一个指针指向要删除的节点的下一个节点
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class SLinkedList:
def __init__(self):
self.head = None
def Atbegining(self, data_in):
NewNode = Node(data_in)
#关键点
NewNode.next = self.head
self.head = NewNode
#Function to remove node
#恰好删除的是第一个
def RemoveNode(self, Removekey):
headVal = self.head
if (headVal is not None):
if(headVal.data == Removekey):
self.head = headVal.next
headVal = None
return
#不是第一个的情况
while(headVal is not None):
if headVal.data == Removekey:
break
prev = headVal
headVal = headVal.next
if (headVal == None):
return
#找到哪一个节点后，前一个节点的下一个指向要删除节点的下一个，要删除的节点赋值为空
prev.next = headVal.next
headVal = None
def LListprint(self):
printval = self.head
while (printval):
print(printval.data),
printval = printval.next
list1=SLinkedList()
list1.Atbegining('Mon')
list1.Atbegining('Tue')
list1.Atbegining('Wed')
list1.Atbegining('The')
list1.RemoveNode('Tue')
list1.LListprint()
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py The Wed Mon Process finished with exit code 0
十二。堆（从那一端进，就从那一端出）
表示将对象放在别一个对象上，在这个数据结构中分配内存的方式是一样的。他以类似的方式存储数组元素，类似在厨房中一堆一堆盘子，一个在另一个之上放着，所以堆栈数据结构允许操作的一端可以称为栈顶，可在栈顶上添加元素或仅从堆栈中移除元素。
在堆栈中顺序排列的最后一个元素将首先出现，因为只能从堆栈顶部移除。这种操作称为后进先出。添加和删除元素额操作称为PUSH和POP。在下面的程序中，我们将他们实现为add和remove函数。首先声明一个空列表并使用append()和pop()方法来添加和删除数据元素。
class Stack:
def __init__(self):
self.stack = []
# 添加
def add(self, dataval):
if dataval not in self.stack:
#从尾部添加，后添加的就是后一个
self.stack.append(dataval)
return True
else:
return False
#删除,后进先出
def remove(self):
if len(self.stack) <=0:
return ('no slement in the stack')
else:
return self.stack.pop()
def peek(self):
return self.stack[0]
Astack = Stack()
Astack.add("Mon")
Astack.add("Tur")
print(Astack.peek())
Astack.add('Wed')
Astack.add('The')
print(Astack.remove())
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py Mon The Process finished with exit code 0
十二。队列（从一端进从另一端出）
日常生活中的排队很熟悉。队列结构同样意味着数据元素排列在一个队列中。队列的唯一性在于项目添加和删除的方式。这些对象可以放在最后，但从另一端移除，所以这是一种先进先出的方法。可以使用python list实现队列，可以使用insert()和pop()方法添加和移除元素。他们没有插入，因为数据元素总是添加在队列的末尾。
class Queue:
def __init__(self):
self.queue = list()
def addtop(self,dataval):
if dataval not in self.queue:
self.queue.insert(0,dataval)
return True
return False
def removefromq(self):
if len(self.queue) > 0:
return self.queue.pop()
return ('No element in Queue!')
def size(self):
return len(self.queue)
TheQueue = Queue()
TheQueue.addtop("Mon")
TheQueue.addtop("Tue")
TheQueue.addtop("Wed")
print(TheQueue.size())
print(TheQueue.removefromq())
print(TheQueue.removefromq())
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py 3 Mon Tue Process finished with exit code 0
十三。python双端队列
双端队列（或两端队列）具有从任一端添加和删除元素的功能。Deque模块是集合库的一部分，它具有添加和删除可以直接用参数调用的元素的方法。在下面的程序中，将导入collections模块并声明一个双端队列。不需要任何类，直接使用内置的实现这些方法。
import collections
#Create a deque【关键】
DoubleEnded = collections.deque(["Mon","Tue","Wed"])
#append to the right
print('Adding to the right:')
DoubleEnded.append("Thu")
print(DoubleEnded)
#append to the left
print('adding to the left')
DoubleEnded.appendleft('Sun')
print(DoubleEnded)
#Remove from the right
print("Removing from the right")
DoubleEnded.pop()
print(DoubleEnded)
#Remove from the left
print("Removing from the left:")
DoubleEnded.popleft()
print(DoubleEnded)
#Reverse the dequeue
print("reverse the deque:")
DoubleEnded.reverse()
print(DoubleEnded)
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py Adding to the right: deque(['Mon', 'Tue', 'Wed', 'Thu']) adding to the left deque(['Sun', 'Mon', 'Tue', 'Wed', 'Thu']) Removing from the right deque(['Sun', 'Mon', 'Tue', 'Wed']) Removing from the left: deque(['Mon', 'Tue', 'Wed']) reverse the deque: deque(['Wed', 'Tue', 'Mon']) Process finished with exit code 0
十四。python高级链表（双向链表）
我们看到另一种链接列表，可以向前和向后移动遍历。 这种链表称为双向链表。 以下是双向链表的特点。
1.双向链表包含第一个和最后一个的链接元素
2.每个连接都有一个数字字段和两个称为next和prev的链接字段
3.每个链接都是用其下一个链接与其下一个的链接链接
4.每个链接都是用其上一个链接与之前的链接链接
5.最后一个链接将链接作为空来标记列表的结尾
‘’’
创建双向链表我们使用Node类创建一个双链表。 使用与单链表中相同的方法，
但是除了存在于节点中的数据之外，头指针和下一个指针将用于正确分配以在每个节点中创建两个链接。
‘’’
class Node:
def __init__(self, data):
self.data = data
self.next = None
self.prev = None
class doubly_linked_list:
def __init__(self):
self.head = None
#Adding data elements[头部添加]
def push(self,NewVal):
NewNode = Node(NewVal)
NewNode.next = self.head
if self.head is not None:
self.head.prev=NewNode
self.head = NewNode
#define the insert method to insert the element
def insert(self,prev_node,NewVal):
if prev_node is None:
return
#注意这厮进过了4此链接（1.新节点的后一个指向前一个节点的下一个。2。前一个节点的下一个指向新节点。3.新节点的前一个节点指向前一个。4.前一个节点的下一个节点的前一个指向新节点）
NewNode = Node(NewVal)
NewNode.next = prev_node.next
prev_node.next = NewNode
NewNode.prev = prev_node
if NewNode.next is not None:
NewNode.next.prev = NewNode
#define the append method to add element at the end
def append(self, NewVal):
NewNode = Node(NewVal)
NewNode.next = None
if self.head is None:
NewNode.prev = None
self.head = NewNode
return
last = self.head
while (last.next is not None):
last = last.next
last.next = NewNode
NewNode.prey = last
#print the doubly linked list
def listprint(self, node):
while(node is not None):
print(node.data)
last = node
node = node.next
dlist=doubly_linked_list()
dlist.push(12)
dlist.push(8)
dlist.push(62)
dlist.listprint(dlist.head)
dlist.insert(dlist.head.next.next,13)
dlist.append('30')
dlist.listprint(dlist.head)
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py 62 8 12 62 8 12 13 30 Process finished with exit code 0
十五。哈希表
散列表（也叫哈希表）是一种数据结构，其数据元素的地址或索引值由散列函数生成。这使得访问数据的速度更快。因为索引值是数据值的关键字。换句话说，哈希表存储键值对，但键是通过哈希函数生辰的。因此，数据元素的搜索和插入函数变得跟快，因为键值本身成为储存数据的数组的索引。
在python中，字典数据类型表示哈希表的实现。字典中的键满足以下要求
1.字典的键是可散列的，即通过散列函数生成该散列函数，该散列函数为提供给散列函数的每个唯一值生成唯一结果
2.字典中数据元素的顺序不固定
在字典中访问值 []
更新字典元素
删除字典元素 del 可以删除单个字典元素，也可以清除字典的全部内容。 也可以在一个操作中删除整个字典。 要显式删除整个字典，只需使用del语句 dict.clear()
十六。python搜索数
二叉搜索树（BST）是一棵树，其所有节点都遵循下述属性-节点的左子树的键小于或等于其父节点的键。节点的右子树的键大于其父节点的键。因此，BST将其所有子树分成两部分，左边的子树和右边的子树
left_subtree (keys) ≤ node (key) ≤ right_subtree (keys)
‘’’
在B树搜索的值在树中搜索值涉及比较输入值与退出节点的值。
在这里，也从左到右遍历节点，最后是父节点。
如果搜索到的值与任何退出值都不匹配，则返回未找到的消息，否则返回找到的消息。
‘’’
class Node:
def __init__(self,data):
self.left = None
self.right = None
self.data = data
#Insert method to create nodes
def insert(self,data):
if self.data:
if data<self.data:
if self.left is None:
self.left = Node(data)
else:
self.left.insert(data)
elif data > self.data:
if self.right is None:
self.right = Node(data)
else:
self.right.insert(data)
else:
self.data = data
#findval method to compare the value with nodes
def findval(self,lkpval):
if lkpval < self.data:
if self.left is None:
return str(lkpval)+'not found'
return self.left.findval(lkpval)
elif lkpval > self.data:
if self.right is None:
return str(lkpval)+'not found'
return self.right.findval(lkpval)
else:
print(str(self.data)+' is found')
def PrintTree(self):
if self.left:
self.left.PrintTree()
print(self.data)
if self.right:
self.right.PrintTree()
root = Node(12)
root.insert(6)
root.insert(14)
root.insert(3)
print(root.findval(7))
print(root.findval(14))
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py 7not found 14 is found None Process finished with exit code 0
十七。python堆
堆是一种特殊的树结构，其中每个父节点小于或等于其子节点。然后它被称为最小堆（min heap）.如果每个父节点大于或等于其子节点。则称为最大堆（max heap）.实施优先级队列是非常有用的，在该队列中，具有较高权重的队列项目在处理中具有更高优先级。
1.创建一个堆，通过使用python内建的名称heapq的库创建。该库具有对堆数据结构进行各种操作的相关功能。
heapify 将常规类表转换为堆，在结果堆中，最小的元素被推到索引位置0，但是其余的元素不一定被排序。
heappush 这个函数在堆中添加一个元素而不改变当前堆。
heappop 这个函数返回最小的数据元素
heapreplace 该函数用函数中提供的新值替换最小的数据元素（把最小的删除，剩下的往前推，空出来的就是将要替换的内容补上）
通过简单的使用具有heapify函数的元素列表来创建堆。
import heapq H=[21,1,45,78,3,5] #创建一个堆 heapq.heapify(H) print(H) #插入堆 '''将数据元素插入堆总是在最后一个索引处添加。但是，只有在值最小的情况下，才可以再次应用heapify函数将新添加的元素添加到第一个。''' heapq.heappush(H,8) print(H) #从堆中移除 '''可以使用此功能在第一个索引处一处元素，''' heapq.heappop(H) print(H) #替换堆 '''heapreplace函数总是删除堆栈中最小的元素，并在未被任何顺序修复的地方插入新的传入元素''' heapq.heapreplace(H,6) print(H)
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py [1, 3, 5, 78, 21, 45] [1, 3, 5, 78, 21, 45, 8] [3, 8, 5, 78, 21, 45] [5, 8, 6, 78, 21, 45]
十八。图
图是一种对象通过链接链接的一组对象的图形表示。互连对象由称为定点的点表示，连接定点的链接称为边。
1.基本操作
显示图形顶点
显示图形边缘
添加一个顶点
添加边缘
创建一个图
可以使用python字典数据结构类型轻松呈现图。我们将顶点表示为字典的关键字，顶点之间的链接也成为边界，作为字典中的值
在上面的图中
V={a,b,c,d,e}
E={ab,ac,bd,cd,de}
用python实现这个图
#create the dictionary eith graph elements
graph = {
"a":["b","c"],
"b":["a","d"],
"c":["a","d"],
"d":["e"],
"e":["d"]
}
print(graph)
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py
{'a': ['b', 'c'], 'b': ['a', 'd'], 'c': ['a', 'd'], 'd': ['e'], 'e': ['d']}
Process finished with exit code 0
2.显示图的顶点
要显示图的顶点，简单的找到图字典的关键字，使用keys()方法
class graph:
def __init__(self,gdict=None):
if gdict is None:
gdict = []
self.gdict = gdict
#get the keys of the dictionary
def getVertices(self):
return list(self.gdict.keys())
#create the dictionary with graph elements
graph_elements ={ "a" : ["b","c"],
"b" : ["a", "d"],
"c" : ["a", "d"],
"d" : ["e"],
"e" : ["d"]
}
g=graph(graph_elements)
print(g.getVertices())
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py ['a', 'b', 'c', 'd', 'e'] Process finished with exit code 0
显示图的边缘（后来明白了）
寻找图边缘比顶点少一些，因为必须找到每对顶点之间有一个边缘的顶点。 因此，创建一个空边列表，然后迭代与每个顶点关联的边值。 一个列表形成了包含从顶点找到的不同组的边。
[{‘a’, ‘b’}, {‘c’, ‘a’}, {‘d’, ‘b’}, {‘c’, ‘d’}, {‘d’, ‘e’}]
添加一个顶点
class graph:
def __init__(self,gdict=None):
if gdict is None:
gdict = []
self.gdict = gdict
#get the keys of the dictionary
def getVertices(self):
return list(self.gdict.keys())
#add the vertex as a key
def addVertex(self,vrtx):
if vrtx not in self.gdict:
self.gdict[vrtx] = []
#create the dictionary with graph elements
graph_elements ={ "a" : ["b","c"],
"b" : ["a", "d"],
"c" : ["a", "d"],
"d" : ["e"],
"e" : ["d"]
}
g=graph(graph_elements)
print(g.getVertices())
g.addVertex("f")
print(g.getVertices())
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py ['a', 'b', 'c', 'd', 'e'] ['a', 'b', 'c', 'd', 'e', 'f'] Process finished with exit code 0
添加边
将边添加到现有图，涉及将新顶点视为元组并验证边是否已经存在。如果不存在，则添加边缘
class graph:
def __init__(self,gdict=None):
if gdict is None:
gdict = {}
self.gdict = gdict
def edges(self):
return self.findedges()
#add the new edge
#所谓的添加边，抽象数来就是将其做成一个字典的形式
def AddEdge(self,edge):
edge = set(edge)
(vrtx1,vrtx2) = tuple(edge)
if vrtx1 in self.gdict:
self.gdict[vrtx1].append(vrtx2)
else:
self.gdict[vrtx1] = [vrtx2]
#list the edge names
#打印边，{键:值} 这样的组合就是一个边
def findedges(self):
edgename = []
for vrtx in self.gdict:
for nxtvrtx in self.gdict[vrtx]:
#关键所在
if {nxtvrtx,vrtx} not in edgename:
edgename.append({vrtx,nxtvrtx})
return edgename
# Create the dictionary with graph elements
graph_elements = { "a" : ["b","c"],
"b" : ["a", "d"],
"c" : ["a", "d"],
"d" : ["e"],
"e" : ["d"]
}
g = graph(graph_elements)
g.AddEdge({'a','e'})
g.AddEdge({'a','c'})
print(g.edges())
F:\7-9练习代码\fuxi\venv\Scripts\python.exe F:/7-9练习代码/fuxi/shujujiegou.py
[{'a', 'b'}, {'c', 'a'}, {'a', 'e'}, {'d', 'b'}, {'c', 'd'}, {'e', 'd'}]
Process finished with exit code 0
这篇关于python内部的数据结构的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-02Python编程基础
- 2024-11-01Python 基础教程
- 2024-11-01用Python探索可解与不可解方程的问题
- 2024-11-01Python编程入门指南
- 2024-11-01Python编程基础知识
- 2024-11-01Python编程基础
- 2024-10-31Python基础入门：理解变量与数据类型
- 2024-10-30Python股票自动化交易资料详解与实战指南
- 2024-10-30Python入行：新手必读的Python编程入门指南
- 2024-10-30Python入行：初学者必备的编程指南
