Python进阶-实验（2个lab）

1.常用标准库

1.1 sys模块

# 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)

1.2 os模块

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"))

1.3 time模块

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()))

2.数据结构

2.1 单链表

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()

2.2 双链表

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()

2.3 二叉树

# 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)