# sys.exit([n]):此方法可以是当前程序退出，n为0时表示正常退出，其他值表示异常退出。
import sys
for i in range(100):
print(i)
if i ==5:
sys.exit(0)
# sys.path:获取模块搜索路径。
print('\n\nPython 路径为：', sys.path, '\n')
# sys.platform:获取当前系统平台
print(sys.platform)
# sys.version:获取 Python解释程序的版本信息
print(sys.version)
import os
# os.getpid(获取当前进程id
print("当前进程的ID: ",os.getpid())
# os.getppid():获取当前父进程id
print("当前父进程的ID: ", os.getppid())
# os.getcwd():获取当前所在路径
cwd = os.getcwd()
print("当前所在路径为: ",cwd)
# os.chdir(path):改变当前工作目录
os.chdir("c:\")
print("修改后当前所在路径为: ", os.getcwd())
# os.listdir():返回目录下所有文件)
print("当前目录下的文件有: ", os.listdir(cwd))
#os.walk():输出当前路径下的所有文件
for root, dirs, files in os.walk(cwd, topdown=False):
for name in files:
print(os.path.join(root, name))
for name in dirs:
print(os.path.join(root, name))
# os.path模块:主要用于获取文件的属性。
import os
# os.path.abspath(path):返回绝对路径
print("text.txt 的绝对路径为: ",os.path.abspath("text.txt")) # text.txt 为当前文件夹下的一个文件（上一个实验中将当前路径切换为C:\,需要将路径切换回来)
# os.path.exists(path):文件存在则返回True,不存在返回False
print("text.txt是否存在: ",os.path.exists("text.txt"))
# os.path.getsize(path):返回文件大小，如果文件不存在就返回错误
print("text.txt的文件大小: ",os.path.getsize("text.txt"))
# os.path.isfile(path):判断路径是否为文件
print("text.txt是否为文件:",os.path.isfile("text.txt"))
# os.path.isdir(path):判断路径是否为文件夹
print("text.txt是否为文件夹:",os.path.isdir("text.txt"))
import time
#t time.time(:用于获取当前时间戳
time_now = time.time()
print("时间戳:",time_now)
# time.localtime0:获取时间元组
localtime = time.localtime(time_now)
print("本地时间为:" , localtime)
# time.asctime0:获取格式化的时间
localtime = time.asctime(localtime)
print("本地时间为:", localtime)
#time.strftime(format[ t]):接收时间元组，并返回以可读字符串表示的当地时间，格式由参数format决定。
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
class Link_Node(): # 定义链表节点
def __init__(self, data, next_link=None): # 下一节点链接域默认为空值
self.data = data # 表元素域负责存放数据
self.next_link = next_link # 下一节点链接域负责存放下一个链表地址信息
class Link_Manipulate():
def __init__(self): # 初始化链表，设置链表头为空
self._head = None
def isEmpty(self): # 判断表头是否为空值
return self._head is None
def length(self): # 计算链表节点的长度
node = self._head
count = 0
while node:
count += 1
node = node.next_link
return count
def add(self, data): # 在表头添加数据
node = Link_Node(data) # 定义新的链表节点对象
node.next_link = self._head # 将表头的指针地址赋给节点的下一跳
self._head = node # 将原来的节点地址赋给表头
def travel(self): # 遍历所有链表的节点数据
if self._head: # 如果表头节点存在
cur_node = self._head # 利用cur_node改变表头节点的位置
while cur_node: # 当节点不为空值
print(cur_node.data, end=" ") # 打印出节点的数据
cur_node = cur_node.next_link # 跳到节点的下一跳位置
else:
raise ("The Link is empty!") # 否则链表为空为空
def append(self, data):
node = Link_Node(data)
if self._head is None: # 如果链表本身为空，则直接将该节点的值指向头部即可
self._head = node
return
else:
cur_node = self._head
while cur_node:
pre_node, cur_node = cur_node, cur_node.next_link
pre_node.next_link = node
def insert(self, data, index):
if index <= 0: # 插入位置索引小于等于О都是在头部插入
self.add(data)
elif index >= self.length():
# 插入位置索引大于等于链表长度时都是在尾部插入
self.append(data)
else: # 插入位置索引index在1到链表length-1之间
node = Link_Node(data)
cur_node = self._head.next_link
pre_node = self._head
count = 1
while cur_node:
if count == index: # 如果找到了插入的地方，插入后使用break终止
pre.next_link, node.next_link = node, cur_node
break
pre, cur_node = cur_node, cur_node.next_link
# 如果没有找到只更换位置并将计数器加一
count += 1
def remove(self, data):
if self.isEmpty(): # 如果链表为空，则无需查找删除节点
return "Failed because of Empty!"
cur_node = self._head
pre_node = None
while cur_node:
if cur_node.data == data:
if pre_node == None: # 删除的索引为0，删除的节点为表头节点
self._head = cur_node.next_link # 将下一个节点的地址指向表头
else:
pre_node.next_link = cur_node.next_link
# 否则将当前节点的下一个节点指向当前节点的前一个节点
return data
pre_node, cur_node = cur_node, cur_node.next_link
# 移除了了节点之后，后面的所有节点都需要变动位置
raise ("Not found!") # 如果没有找到，需要及时报错
def search(self, data):
if self.isEmpty():
raise ("The Link is empty!")
else:
cur_node = self._head
index = 0
while cur_node:
if cur_node.data == data: # 如果找到了数据，则返回索引号
return index
index += 1
cur_node = cur_node.next_link
return -1
Link_Demo = Link_Manipulate()
Link_Demo.add(1)
Link_Demo.append(2)
Link_Demo.append(3)
Link_Demo.append(4)
Link_Demo.append(5)
print("链表节点是否为空:", str(Link_Demo.isEmpty()))
print("链表节点长度为:", str(Link_Demo.length()))
print("遍历链表:")
Link_Demo.travel()
Link_Demo.insert(6, 2)
print("遍历链表:")
Link_Demo.travel()
Link_Demo.remove(6)
print("遍历链表:")
Link_Demo.travel()
class Double_link_Node(): #定义双向链表节点
def __init__(self, data):
self.data = data
self.next = None #后驱节点默认为空
self.prev = None #前驱节点默认为空
class Double_Link(object): #定义双向链表节点
def __init__(self):
self._head = None
def isEmpty(self): #判断链表是否为空
return self._head == None
def length(self): #返回链表的长度
cur_data = self._head
count = 0
while cur_data != None:
count=count+1
cur_data = cur_data.next
return count
def travel(self): #遍历双链表
cur_data = self._head
while cur_data != None:
print(cur_data.data,end=" ")
cur_data = cur_data.next
print("travel end!!!")
def add(self, data): #在链表头部插入元素
Dnode = Double_link_Node(data)
if self.isEmpty(): #如果是空链表，将_head指向Dnode
self._head = Dnode
else:
Dnode.next = self._head #将node的next指向_head的头节点
self._head.prev = Dnode #将_head的头节点的 prev指向Dnode
self._head = Dnode # #将_head指向node
def append(self, data): #尾部插入元素
Dnode = Double_link_Node(data)
if self.isEmpty(): #如果是空链表，将_head指向node
self._head = Dnode
else:
cur_data = self._head #移动到链表尾部
while cur_data.next != None:
cur_data = cur_data.next
cur_data.next = Dnode #将尾节点cur_data的next 指向node
Dnode.prev = cur_data#将node 的prev指向cur_data
def search(self, data): #查找元素是否存在
cur_data = self._head
while cur_data != None:
if cur_data.data== data:
return True
cur_data = cur_data.next
return False
def insert(self, data, index): #在指定位置添加节点
if index <= 0:
self.add(data)
elif index > (self.length()-1):
self.append(data)
else:
Dnode = Double_link_Node(data)
cur_data = self._head
count = 0
while count < (index-1): #移动到指定位置的前一个位置
count += 1
cur_data = cur_data.next
Dnode.prev = cur_data #将node的prev指向cur_data
Dnode.next = cur_data.next #将node的next指向cur_data的下个节点
cur_data.next.prev = Dnode #t将cur_data的下个节点的prev指向node
cur_data.next = Dnode#将cur_data的next指向node
def remove(self, data): #删除元素
if self.isEmpty():
return
else:
cur_data = self._head
if cur_data.data == data:#如果首节点的元素即是要删除的元素
if cur_data.next == None:#如果链表只有这一个节点
self._head = None
else:
cur_data.next.prev = None #将第二个节点的 prev设置为None
self._head= cur_data.next #将_head指向第二个节点
return
while cur_data != None:
if cur_data.data == data:
#将cur_data的前一个节点的next指向cur_data的后一个节点
cur_data.prev.next = cur_data.next
# 将cur_data的后一个节点的prev指向cur_data的前一个节点
cur_data.next.prev = cur_data.prev
break
cur_data = cur_data.next
Double_Link_Demo = Double_Link()
Double_Link_Demo.add(1)
Double_Link_Demo.append(2)
Double_Link_Demo.append(3)
Double_Link_Demo.append(4)
Double_Link_Demo.append(5)
print("链表节点是否为空:",str(Double_Link_Demo.isEmpty()))
print("链表节点长度为:",str(Double_Link_Demo.length()))
print("遍历链表:")
Double_Link_Demo.travel()
Double_Link_Demo.insert(6,2)
print("遍历链表:")
Double_Link_Demo.travel()
Double_Link_Demo.remove(6)
print("遍历链表:")
Double_Link_Demo.travel()
# BinaryTreeNode:构造二叉树的节点类
# createBinaryTree():构造二叉树的函数
class BinaryTreeNode(object):
def __init__(self):
self.data = '#'
self.leftChild = None
self.rightChild = None
class BinaryTree(object):
def createBinaryTree(self, Root):
data = input('==>')
if data == '#':
Root = None
else:
Root.data = data
Root.leftChild = BinaryTreeNode()
self.createBinaryTree(Root.leftChild)
Root.rightChild = BinaryTreeNode()
self.createBinaryTree(Root.rightChild)
#先序遍历递归算法
def preOrder(self, Root):
if Root is not None:
self.visitBinaryTreeNode(Root)
self.preOrder(Root.leftChild)
self.preOrder(Root.rightChild)
# 中序遍历递归算法
def inOrder(self, Root):
if Root is not None:
self.inOrder(Root.leftChild)
self.visitBinaryTreeNode(Root)
self.inOrder(Root.rightChild)
#后序遍历递归算法
def postOrder(self, Root):
if Root is not None:
self.postOrder(Root.leftChild)
self.postOrder(Root.rightChild)
self.visitBinaryTreeNode(Root)
#遍历二叉树一个结点函数
def visitBinaryTreeNode(self, BinaryTreeNode):
# 值为#的结点代表空结点
if BinaryTreeNode.data is not '#':
print(BinaryTreeNode.data,end="->")
if __name__== '__main__':
bTN = BinaryTreeNode()
bT= BinaryTree()
bT.createBinaryTree(bTN)
print('先序遍历的输出结果为:')
bT.preOrder(bTN)
print('\n中序遍历的输出结果为:')
bT.inOrder(bTN)
print('\n后序遍历的输出结果为:')
bT.postOrder(bTN)
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）