Python3-76道脚本实例巩固python基础

红太狼 2022-12-26 00:49 131阅读 0赞

# Python3-76道脚本实例巩固python基础 #

**python解释器版本**：`python 3.9`

**实例1：输出"Hello World!"**

print("Hello world!")

**实例2：通过用户输入两个数字，并计算两个数字之和。**

a = float(input("输入第1个数字："))
    b = float(input("输入第2个数字："))
    print("和为：", a+b)

**实例3：通过用户输入一个数字，并计算这个数字的平方根。**

import math
    a = float(input("输入1个数字："))
    b = math.sqrt(a)
    print("%0.3f 的平方根为：%0.3f"%(a, b))

**实例4：通过用户输入数字，并计算二次方程。**

import cmath
    
    a = float(input("输入 a:"))
    b = float(input("输入 b:"))
    c = float(input("输入 c:"))
    
    # 计算delta
    d = (b**2)-4*a*c
    
    # 公式法
    x1 = (-b+cmath.sqrt(d))/(2*a)
    x2 = (-b-cmath.sqrt(d))/(2*a)
    print("方程的解为：", x1, "和", x2)

**实例5：通过用户输入三角形三边长度，并计算三角形的面积**

a = float(input('输入三角形第一边长: '))
    b = float(input('输入三角形第二边长: '))
    c = float(input('输入三角形第三边长: '))
    
    # 计算半周长
    s = (a + b + c) / 2
    
    # 计算面积
    area = (s * (s - a) * (s - b) * (s - c)) ** 0.5
    print('三角形面积为 %0.2f' % area)

**实例6：计算圆的面积**

import math
    r = float(input("输入圆的半径r："))
    s = math.pi*r**2
    print('半径为 %0.2f 的圆的面积为：%0.2f'%(r,s))

**实例7：生成一个随机数**

import random
    print(random.randint(0, 10))

**实例8：将摄氏温度转华氏温度**

# 接收用户输入
    celsius = float(input('输入摄氏温度: '))
    
    # 计算华氏温度
    fahrenheit = (celsius * 1.8) + 32
    print('%0.1f 摄氏温度转为华氏温度为 %0.1f ' % (celsius, fahrenheit))

**实例9：用户输入两个变量，并相互交换**

x = input('输入 x 值: ')
    y = input('输入 y 值: ')
    
    # 创建临时变量，并交换
    temp = x
    x = y
    y = temp
    
    print('交换后 x 的值为: {}'.format(x))
    print('交换后 y 的值为: {}'.format(y))

**实例10：使用 if…elif…else 语句判断数字是正数、负数或零**

num = float(input("输入一个数字: "))
    if num > 0:
       print("正数")
    elif num == 0:
       print("零")
    else:
       print("负数")

**实例11：通过创建自定义函数 is\_number() 方法来判断字符串是否为数字**

def is_number(s):
        try:
            float(s)
            return True
        except ValueError:
            return False
    
    print(is_number(1))
    print(is_number('abong'))

**实例12：判断一个数字是否为奇数或偶数**

# Python 判断奇数偶数
    # 如果是偶数除于 2 余数为 0
    # 如果余数为 1 则为奇数
    
    num = int(input("输入一个数字: "))
    if (num % 2) == 0:
        print("{0} 是偶数".format(num))
    else:
        print("{0} 是奇数".format(num))

**实例13：判断用户输入的年份是否为闰年**

# 公历年份是4的倍数的，且不是100的倍数，为普通闰年
    # 公历年份是整百数的，必须是400的倍数才是世纪闰年
    year = int(input("输入一个年份: "))
    if (year % 4) == 0:
       if (year % 100) == 0:
           if (year % 400) == 0:
               print("{0} 是闰年".format(year))   # 整百年能被400整除的是闰年
           else:
               print("{0} 不是闰年".format(year))
       else:
           print("{0} 是闰年".format(year))       # 非整百年能被4整除的为闰年
    else:
       print("{0} 不是闰年".format(year))

**实例14：使用max()方法求最大值**

print(max(1, 2))    # 两个数比大小
    print(max('a', 'b'))  # 两个字符串比大小
    print(max([1,2,3,4,5]))   # 一个列表中的所有元素比大小
    print(max((1,2,3,4,5)))   # 一个元组中的所有元素比大小

**实例15：质数判断**

# 一个大于1的自然数，除了1和它本身外，不能被其他自然数（质数）整除（2, 3, 5, 7等）
    # 用户输入数字
    num = int(input("请输入一个数字: "))
    
    # 质数大于 1
    if num > 1:
        # num能整除2...num-1之间的某个整数，则说明num不是质数
        for i in range(2, num):
            if (num % i) == 0:
                print(num, "不是质数")
                print(i, "*", num // i, "=", num)
                break
        else:
            print(num, "是质数")
    # 如果输入的数字小于或等于 1，不是质数
    else:
        print(num, "不是质数")

**实例16：输出指定范围内的所有质数(素数)**

lower = int(input("输入区间最小值: "))
    upper = int(input("输入区间最大值: "))
    
    for num in range(lower, upper + 1):
        # 素数大于 1
        if num > 1:
            for i in range(2, num):
                if (num % i) == 0:
                    break
            else:
                print(num)

**实例17：阶乘实例**

# 通过用户输入数字计算阶乘
    
    # 获取用户输入的数字
    num = int(input("请输入一个数字: "))
    factorial = 1
    
    # 查看数字是负数，0 或 正数
    if num < 0:
        print("抱歉，负数没有阶乘")
    elif num == 0:
        print("0 的阶乘为 1")
    else:
        for i in range(1, num + 1):
            factorial = factorial * i
        print("%d 的阶乘为 %d" % (num, factorial))

**实例18：九九乘法表**

# 九九乘法表
    for i in range(1, 10):
        for j in range(1, i+1):
            print('{}x{}={}\t'.format(j, i, i*j), end='')
        print()

**实例19：斐波那契数列**

# 斐波那契数列：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和。
    # Python 斐波那契数列实现
    
    # 获取用户输入数据
    nterms = int(input("你需要几项？"))
    
    # 第一和第二项
    n1 = 0
    n2 = 1
    count = 2
    
    # 判断输入的值是否合法
    if nterms <= 0:
        print("请输入一个正整数。")
    elif nterms == 1:
        print("斐波那契数列：")
        print(n1)
    else:
        print("斐波那契数列：")
        print(n1, ",", n2, end=" , ")
        while count < nterms:
            nth = n1 + n2
            print(nth, end=" , ")
            # 更新值
            n1 = n2
            n2 = nth
            count += 1

**实例20：阿姆斯特朗数**

# 如果一个n位正整数等于其各位数字的n次方之和,则称该数为阿姆斯特朗数。 例如1^3 + 5^3 + 3^3 = 153。
    # Python 检测用户输入的数字是否为阿姆斯特朗数
    
    # 获取用户输入的数字
    num = int(input("请输入一个数字: "))
    
    # 初始化变量 sum
    sum = 0
    # 指数
    n = len(str(num))
    
    # 检测
    temp = num
    while temp > 0:
        digit = temp % 10    # 个位数、十位数、百位数
        sum += digit ** n    # 个位数的n次方、十位数的n次方、百位数的n次方
        temp //= 10          # 去掉个位数，除以10后的商
    
    # 输出结果
    if num == sum:
        print(num, "是阿姆斯特朗数")
    else:
        print(num, "不是阿姆斯特朗数")

# Python 输出指定范围内的所有阿姆斯特朗数
    
    # 获取用户输入的数字
    a = int(input("输入最小值："))
    b = int(input("输入最大值："))
    
    # 检测
    for num in range(a,b+1):
        sum = 0
        n = len(str(num))
        temp = num
        while temp > 0:
            digit = temp % 10    # 个位数、十位数、百位数
            sum += digit ** n    # 个位数的n次方、十位数的n次方、百位数的n次方
            temp //= 10          # 去掉个位数，除以10后的商
        # 输出结果
        if num == sum:
            print(num, "是阿姆斯特朗数")

**实例21：十进制转二进制、八进制、十六进制**

# 获取用户输入十进制数
    dec = int(input("输入数字："))
    
    print("十进制数为：", dec)
    print("转换为二进制为：", bin(dec))
    print("转换为八进制为：", oct(dec))
    print("转换为十六进制为：", hex(dec))
    
    
    # ================ 运行结果===============
    输入数字：17
    十进制数为： 17
    转换为二进制为： 0b10001
    转换为八进制为： 0o21
    转换为十六进制为： 0x11

**实例22：ASCII码与字符相互转换**

# 用户输入字符
    c = input("请输入一个字符: ")
    
    # 用户输入ASCII码，并将输入的数字转为整型
    a = int(input("请输入一个ASCII码: "))
    
    print(c + " 的ASCII 码为", ord(c))    # 字符转ASCII码
    print(a, " 对应的字符为", chr(a))      # ASCII码转字符
    
    # ================ 运行结果===============
    请输入一个字符: a
    请输入一个ASCII码: 97
    a 的ASCII 码为 97
    97  对应的字符为 a

**实例23：最大公约数算法**

# 定义一个函数
    def hcf(x, y):
        """该函数返回两个数的最大公约数"""
    
        # 获取最小值
        if x > y:
            smaller = y
        else:
            smaller = x
    
        for i in range(1, smaller + 1):
            if ((x % i == 0) and (y % i == 0)):
                hcf = i    # 把能被x和y整数的数都找出来，返回最大的那个
    
        return hcf
    
    
    # 用户输入两个数字
    num1 = int(input("输入第一个数字: "))
    num2 = int(input("输入第二个数字: "))
    
    print(num1, "和", num2, "的最大公约数为", hcf(num1, num2))
    
    
    # ================ 运行结果===============
    输入第一个数字: 6
    输入第二个数字: 15
    6 和 15 的最大公约数为 3

**实例24：最小公倍数算法**

# 定义函数
    def lcm(x, y):
        # 获取最大的数
        if x > y:
            greater = x
        else:
            greater = y
    
        while (True):
            if ((greater % x == 0) and (greater % y == 0)):
                lcm = greater
                break    # 遇到第一个能整除x和y的整数就停止循环，并返回这个整数。
            greater += 1
    
        return lcm
    
    
    # 获取用户输入
    num1 = int(input("输入第一个数字: "))
    num2 = int(input("输入第二个数字: "))
    
    print(num1, "和", num2, "的最小公倍数为", lcm(num1, num2))
    
    
    # ================ 运行结果===============
    输入第一个数字: 3
    输入第二个数字: 5
    3 和 5 的最小公倍数为 15

**实例25：简单计算器实现**

# 定义函数
    def add(x, y):
        """相加"""
    
        return x + y
    
    
    def subtract(x, y):
        """相减"""
    
        return x - y
    
    
    def multiply(x, y):
        """相乘"""
    
        return x * y
    
    
    def divide(x, y):
        """相除"""
    
        return x / y
    
    
    # 用户输入
    print("选择运算：")
    print("1、相加")
    print("2、相减")
    print("3、相乘")
    print("4、相除")
    
    choice = input("输入你的选择(1/2/3/4):")
    
    num1 = int(input("输入第一个数字: "))
    num2 = int(input("输入第二个数字: "))
    
    if choice == '1':
        print(num1, "+", num2, "=", add(num1, num2))
    
    elif choice == '2':
        print(num1, "-", num2, "=", subtract(num1, num2))
    
    elif choice == '3':
        print(num1, "*", num2, "=", multiply(num1, num2))
    
    elif choice == '4':
        print(num1, "/", num2, "=", divide(num1, num2))
    else:
        print("非法输入")

# 运行结果
    选择运算：
    1、相加
    2、相减
    3、相乘
    4、相除
    输入你的选择(1/2/3/4):3
    输入第一个数字: 3
    输入第二个数字: 5
    3 * 5 = 15
    
    进程已结束,退出代码0

**实例26：生成日历**

# 引入日历模块
    import calendar
    
    # 输入指定年月
    yy = int(input("输入年份: "))
    mm = int(input("输入月份: "))
    
    # 显示日历
    print(calendar.month(yy, mm))
    
    
    
    # ================ 运行结果===============
    输入年份: 2020
    输入月份: 12
       December 2020
    Mo Tu We Th Fr Sa Su
        1  2  3  4  5  6
     7  8  9 10 11 12 13
    14 15 16 17 18 19 20
    21 22 23 24 25 26 27
    28 29 30 31

**实例27：使用递归斐波那契数列**

def recur_fibo(n):
        """递归函数 输出斐波那契数列"""
        if n <= 1:
            return n
        else:
            return (recur_fibo(n - 1) + recur_fibo(n - 2))
    
    
    # 获取用户输入
    nterms = int(input("您要输出几项? "))
    
    # 检查输入的数字是否正确
    if nterms <= 0:
        print("输入正数")
    else:
        print("斐波那契数列:")
        for i in range(nterms):
            print(recur_fibo(i),end=' ')
    
            
    # ================ 运行结果=============== 
    您要输出几项? 10
    斐波那契数列:
    0 1 1 2 3 5 8 13 21 34

**实例28：文件 IO**

# 写文件
    with open("test.txt", "wt") as out_file:
        out_file.write("写入文本\n查看内容")
    
    # 读文件
    with open("test.txt", "rt") as in_file:
        text = in_file.read()
    
    print(text)

**实例29：字符串判断**

str = "Abong"
    print(str.isalnum()) # 判断所有字符都是数字或者字母
    print(str.isalpha()) # 判断所有字符都是字母
    print(str.isdigit()) # 判断所有字符都是数字
    print(str.islower()) # 判断所有字符都是小写
    print(str.isupper()) # 判断所有字符都是大写
    print(str.istitle()) # 判断所有单词都是首字母大写，像标题
    print(str.isspace()) # 判断所有字符都是空白字符、\t、\n、\r
    
    
    # ================ 运行结果=============== 
    True
    True
    False
    False
    False
    True
    False

**实例30：字符串大小写转换**

str = "www.baidu.com"
    print(str.upper())          # 把所有字符中的小写字母转换成大写字母
    print(str.lower())          # 把所有字符中的大写字母转换成小写字母
    print(str.capitalize())     # 把第一个字母转化为大写字母，其余小写
    print(str.title())          # 把每个单词的第一个字母转化为大写，其余小写
    
    
    # ================ 运行结果=============== 
    WWW.BAIDU.COM
    www.baidu.com
    Www.baidu.com
    Www.Baidu.Com

**实例31：计算每个月天数**

import calendar
    monthRange = calendar.monthrange(2020,12)
    print(monthRange)

**实例32：获取昨天日期**

# 引入 datetime 模块
    import datetime
    
    
    def getYesterday():
        today = datetime.date.today()
        oneday = datetime.timedelta(days=1)
        yesterday = today - oneday
        return yesterday
    
    
    # 输出
    print(getYesterday())

**实例33：使用join链接list成为字符串**

# 使用join链接list成为字符串
    params = { 1:"a", 2:"b", 3:"c", 4:"d"}
    print(params)
    new_params = ["%s=%s"%(k, v) for k, v in params.items()]
    print(new_params)
    list_params = ';'.join(new_params)
    print(list_params)
    
    
    # ================ 运行结果=============== 
    { 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
    ['1=a', '2=b', '3=c', '4=d']
    1=a;2=b;3=c;4=d

**实例34：约瑟夫生者死者小游戏**

30 个人在一条船上，超载，需要 15 人下船。于是人们排成一队，排队的位置即为他们的编号。报数，从 1 开始，数到 9 的人下船。如此循环，直到船上仅剩 15 人为止，问都有哪些编号的人下船了呢？

people={ }
    for x in range(1,31):
        people[x]=1    # 初始化30个值都是1
    # print(people)
    check=0  # 检查是不是9
    i=1    # 报数
    j=0    # 留下来的人数
    while i<=31:
        if i == 31:   # 报数31，就是报数1
            i=1
        elif j == 15:  # 留下15人就结束循环
            break
        else:
            if people[i] == 0:  # 这个人已经下船了，跳过。
                i+=1
                continue
            else:    # 值是1
                check+=1
                if check == 9:    # 检查报数是不是9
                    people[i]=0  # 是9，报数9的值置为0
                    check = 0    # 重置为0
                    print("{}号下船了".format(i))  # 下船
                    j+=1   # 留下来的人数+1
                else:            # 报数不是9，继续下一个
                    i+=1
                    continue

# ================ 运行结果=============== 
    9号下船了
    18号下船了
    27号下船了
    6号下船了
    16号下船了
    26号下船了
    7号下船了
    19号下船了
    30号下船了
    12号下船了
    24号下船了
    8号下船了
    22号下船了
    5号下船了
    23号下船了

**实例35：N人分鱼（以5人为例）**

A、B、C、D、E 五人在某天夜里合伙去捕鱼，到第二天凌晨时都疲惫不堪，于是各自找地方睡觉。日上三杆，A 第一个醒来，他将鱼分为五份，把多余的一条鱼扔掉，拿走自己的一份。B 第二个醒来，也将鱼分为五份，把多余的一条鱼扔掉拿走自己的一份。 。C、D、E依次醒来，也按同样的方法拿鱼。问他们至少捕了多少条鱼?

def main(n):    # n人分鱼
        fish = 1
        while True:   # 遍历的方式
            total, enough = fish, True   # enough决定鱼够不够分5次
            for _ in range(n):
                if (total - 1) % 5 == 0:
                    total = (total - 1)  //  5 * 4    # 剩余的鱼的数量
                else:
                    enough = False
                    break    # 鱼的数量不足以分鱼5次，就会报鱼不够，跳出for循环
            if enough:   # 当鱼的数量可以分鱼5次，此时enough仍然为True,则输出鱼的数量，并结束while循环
                print(f'总共有{fish}条鱼')
                break
            fish += 1   # 鱼不够就加1,再次判断
    
    
    if __name__ == '__main__':   # main.py脚本
        main(5)

**实例36：实现秒表功能**

import time
    
    print('按下回车开始计时，按下 Ctrl + C 停止计时。')
    while True:
        input("输入回车键开始计时：")
        starttime = time.time()  # 开始时间
        print('开始')
        try:
            while True:
                print('计时: ', round(time.time() - starttime, 0), '秒', end="\r")
                time.sleep(1)   # 等待1s
        except KeyboardInterrupt:    # 键盘输入异常，只能在python控制台按Ctrl+C才可以结束运行。
            print('结束')
            endtime = time.time()    # 结束时间
            print('总共的时间为:', round(endtime - starttime, 2), 'secs')    # 计时
            break

**实例37：计算 n 个自然数的立方和**

# 定义立方和的函数
    def lifangsum(n):
        sum = 0
        for i in range(1, n + 1):
            sum += i * i * i
    
        return sum
    
    
    # 调用函数
    n = 5
    print(lifangsum(n))

**实例38：计算数组元素之和**

# 定义函数,arr为数组,n为数组长度
    def new_sum(arr,n):
        # 使用内置的 sum 函数计算
        return (sum(arr))
    
    # 数组元素
    arr = [12, 3, 4, 15]
    
    # 计算数组元素的长度
    n = len(arr)
    
    ans = new_sum(arr, n)
    
    # 输出结果
    print('数组元素之和为', ans)

**实例39：数组翻转指定个数的元素**

定义一个整型数组，并将指定个数的元素翻转到数组的尾部。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjUyMjA5OQ_size_16_color_FFFFFF_t_70_pic_center]

def leftRotate(arr, d, n):  # 反转d个元素，相当于d次移动1个元素
        for i in range(d):
            leftRotatebyOne(arr, n)
    
    
    def leftRotatebyOne(arr, n):  # 放第一个元素到尾部
        temp = arr[0]
        for i in range(n - 1):
            arr[i] = arr[i + 1]
        arr[n - 1] = temp
    
    arr = [1, 2, 3, 4, 5, 6, 7]
    d = 2
    n = len(arr)
    print("原数组：", arr)
    leftRotate(arr, d, n)
    print("新数组：", arr)

**实例40：将列表中的头尾两个元素对调**

def swapList(newList):
        size = len(newList)
    
        temp = newList[0]
        newList[0] = newList[size - 1]
        newList[size - 1] = temp
    
        return newList
    
    
    newList = [1, 2, 3, 4, 5]
    print(newList)
    print(swapList(newList))

**实例41：将列表中的指定位置的两个元素对调**

def swapList(newList, a, b):
        size = len(newList)
    
        temp = newList[a-1]
        newList[a - 1] = newList[b - 1]
        newList[b - 1] = temp
    
        return newList
    
    
    newList = [1, 2, 3, 4, 5]
    print(newList)
    print(swapList(newList, 2, 4))

**实例42：翻转列表**

# 以下三个函数都可以实现反装列表
    def Reverse(lst):
        return [ele for ele in reversed(lst)]
    
    def Reverse(lst):
        lst.reverse()
        return lst
        
    def Reverse(lst):
        new_lst = lst[::-1]
        return new_lst
         
    lst = [10, 11, 12, 13, 14, 15]
    print(Reverse(lst))

**实例43：判断元素是否在列表中存在**

# 以下两个函数都可以实现
    ''' def num_in(arr, a): for i in arr: if (i == a): print(a, '在列表里') break else: print(a, '不在列表里') '''
    
    
    def num_in(arr, a):
        if a in arr:
            print(a, '在列表里')
        else:
            print(a, '不在列表里')
    
    
    arr = [1, 6, 3, 5, 3, 4]
    num_in(arr, 4)
    num_in(arr, 9)

**实例44：清空列表**

arr = [1, 6, 3, 5, 3, 4]
    print("清空前：", arr)
    arr.clear()
    print("清空后：", arr)

**实例45：复制列表**

arr = [1, 6, 3, 5, 3, 4]
    new_arr = arr[:]    # new_arr = arr
    print("复制前：", arr)
    print("复制后：", new_arr)

**实例46：计算元素在列表中出现的次数**

arr = [1, 6, 3, 5, 3, 4]
    print(arr.count(3))

**实例47：计算列表元素之和**

# 使用for循环、while循环、递归都可以实现
    
    arr = [1, 6, 3, 5, 3, 4]
    total = 0
    for i in range(0, len(arr)):
        total = total + arr[i]
    print("列表元素之和为：", total)

**实例48：计算列表元素之积**

def multiplyList(myList):
        result = 1
        for x in myList:
            result = result * x
        return result
    
    
    list1 = [1, 2, 3, 4, 5]
    
    
    print(multiplyList(list1))

**实例49：查找列表中最小元素**

# 排序sort()和min()都可以实现
    L1 = [2, 3, 1, 7, 9, 5]
    print("最小值：", min(L1))
    
    L1.sort()   # 升序
    print("最小值：", L1[0])

**实例50：查找列表中最大元素**

L1 = [2, 3, 1, 7, 9, 5]
    print("最大值：", max(L1))
    
    L1.sort()  # 升序
    L1.reverse()  # 反序
    print("最大值：", L1[0])

**实例51：移除字符串中的指定位置字符**

def ycstr(str, d):
    	# 输出原始字符串
        print("原始字符串为 : " + str)
        new_str = ""
        for i in range(0, len(str)):
            if i != d-1:
                new_str = new_str + str[i]
        print("字符串移除第",d,"个字符后为：" + new_str)
    
    
    ycstr("abong", 2)

**实例52：判断字符串是否存在子字符串**

def check(string, sub_str):
        if (string.find(sub_str) == -1):   #string.find(sub_str)不存在返回-1
            print("不存在")
        else:
            print("存在！")
    
    
    string = "www.abong.com"
    sub_str1 = "haha"
    sub_str2 = "abong"
    check(string, sub_str1)
    check(string, sub_str2)

**实例53：判断字符串长度**

# 使用len()和循环计算都能实现
    print(len("abong"))

**实例54：使用正则表达式提取字符串中的 URL**

import re
    
    
    def Find(string):
        # findall() 查找匹配正则表达式的字符串
        url = re.findall('https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+', string)
        return url
    
    
    string = 'abong 的网页地址为：https://www.abong.com，Google 的网页地址为：https://www.google.com'
    print("Urls: ", Find(string))

**实例55：将字符串作为代码执行**

def exec_code():
        LOC = """ def factorial(num): fact=1 for i in range(1,num+1): fact = fact*i return fact print(factorial(5)) """
        exec(LOC)   # 将字符串作为代码执行
    
    
    exec_code()

**实例56：字符串翻转**

# 使用字符串切片和reversed()都能实现
    str = 'abong'
    print(str[::-1])
    print(''.join(reversed(str)))

**实例57：字符串切片后翻转**  
给定一个字符串，从头部或尾部截取指定数量的字符串，然后将其翻转拼接。

def rotate(input, d):
        Lfirst = input[0: d]   # 截取前d个字符
        Lsecond = input[d:]
        Rfirst = input[0: len(input) - d]   # 截取后d个字符
        Rsecond = input[len(input) - d:]
    
        print("头部切片翻转 : ", (Lsecond + Lfirst))
        print("尾部切片翻转 : ", (Rsecond + Rfirst))
    
    
    if __name__ == "__main__":
        input = 'abong'
        d = 2  # 截取两个字符
        rotate(input, d)

**实例58：按键(key)或值(value)对字典进行排序**

# 按键排序
    def dictionairy():
        # 声明字典
        key_value = { }
    
        # 初始化
        key_value[2] = 56
        key_value[1] = 2
        key_value[5] = 12
        key_value[4] = 24
        key_value[6] = 18
        key_value[3] = 323
    
        print("按键(key)排序:")
    
        # sorted(key_value) 返回按键升序的键的列表
        # [1, 2, 3, 4, 5, 6]
        # print(sorted(key_value.items()))
        # [(1, 2), (2, 56), (3, 323), (4, 24), (5, 12), (6, 18)] 返回按键升序的元组列表，默认按key升序
        # 字典按键排序
        for i in sorted(key_value):
            print((i, key_value[i]), end=" ")
    
    
    def main():
        # 调用函数
        dictionairy()
    
    
    # 主函数
    if __name__ == "__main__":
        main()

# 按值排序
    def dictionairy():
        # 声明字典
        key_value = { }
    
        # 初始化
        key_value[2] = 56
        key_value[1] = 2
        key_value[5] = 12
        key_value[4] = 24
        key_value[6] = 18
        key_value[3] = 323
        print("按值(value)排序:")
        ''' sorted语法：sorted(iterable, cmp=None, key=None, reverse=False) iterable 可迭代对象，一般是元组列表 cmp 比较的函数，两个参数，按哪个值比较 key 用来比较的元素，一个参数，按哪个值排序 reverse 是否反向排序，默认升序。reverse = True 反向排序，即降序 ， reverse = False 不反向排序，默认升序 '''
        print(sorted(key_value.items(), key=lambda kv: (kv[1], kv[0])))   # (kv[1], kv[0]) = (value,key)
    
    
    def main():
        dictionairy()
    
    
    if __name__ == "__main__":
        main()

**实例59：计算字典值之和**

# 计算字典值的和
    def returnSum(myDict):
        sum = 0
        for i in myDict:
            sum = sum + myDict[i]
    
        return sum
    
    
    dict = { 'a': 100, 'b': 200, 'c': 300}
    print("Sum :", returnSum(dict))

**实例60：移除字典点键值(key/value)对**

# 三种方式移除键值对
    dict = { 1:'a', 2:'b', 3:'c', 4:'d'}
    print("原字典：", dict)
    
    
    removed_value1 = dict[2]
    print("移除值",removed_value1)
    del dict[2]
    print("移除一个键值对后的字典：", dict)
    
    
    removed_value2 = dict.pop(3)
    print("再移除值", removed_value2)
    print("再移除一个键值对后的字典：", dict)
    
    dict = { key:val for key, val in dict.items() if key != 1}
    print("再移除键1")
    print("移除后的字典为：", dict)

**实例61：合并字典**

# 两种方式合并字典
    def merge1(a, b):
        return a.update(b)  # 返回值的None
    
    def merge2(a, b):
        res = { **a, **b}   # 参数以字典的形式传入
        return res
    
    dict1 = { 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
    dict2 = { 'haha': 5, 'xixi': 6}
    
    print(merge1(dict1, dict2))  # 输出None
    print("dict1合并dict2后的字典为：", str(dict1))
    
    print("字典参数传入的方式合并字典，结果为：", merge2(dict1, dict2))

**实例62：将字符串的时间转换为时间戳**

import time
    
    a1 = "2020-12-03 12:40:00"
    # 先转换为时间数组
    timeArray = time.strptime(a1, "%Y-%m-%d %H:%M:%S")
    print(timeArray)
    
    # 转换为时间戳
    timeStamp = int(time.mktime(timeArray))
    print(timeStamp)
    
    
    print("======================= 格式转换 =======================")
    # 格式转换 - 转为 /
    a2 = "2020-12-03 12:40:00"
    
    # 先转换为时间数组
    timeArray = time.strptime(a2, "%Y-%m-%d %H:%M:%S")
    
    # 再将时间数组转换为其他格式
    otherStyleTime = time.strftime("%Y/%m/%d %H:%M:%S", timeArray)
    print(otherStyleTime)

**实例63：获取几天前的时间**

import time
    import datetime
    
    # 先获得时间数组格式的日期
    threeDayAgo = (datetime.datetime.now() - datetime.timedelta(days=3))
    # 转换为时间戳
    timeStamp = int(time.mktime(threeDayAgo.timetuple()))
    # 转换为其他字符串格式
    otherStyleTime = threeDayAgo.strftime("%Y-%m-%d %H:%M:%S")
    print(otherStyleTime)

**实例64：将时间戳转换为指定格式日期**

import time
    
    # 获得当前时间时间戳
    now = int(time.time())
    # 转换为时间数组
    timeArray = time.localtime(now)
    # 转换为其他日期格式,如:"%Y-%m-%d %H:%M:%S"
    otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
    print(otherStyleTime)

**实例65：打印自己设计的字体**

# 26个字母映射到指定字体
    # 逐个匹配输出字体
    name = "abong"
    
    # 接收用户输入
    # name = input("输入你的名字: \n\n")
    
    length = len(name)
    l = ""
    
    for x in range(0, length):
        c = name[x]
        c = c.upper()
    
        if (c == "A"):
            print("..######..\n..#....#..\n..######..", end=" ")
            print("\n..#....#..\n..#....#..\n\n")
    
        elif (c == "B"):
            print("..######..\n..#....#..\n..#####...", end=" ")
            print("\n..#....#..\n..######..\n\n")
    
        elif (c == "C"):
            print("..######..\n..#.......\n..#.......", end=" ")
            print("\n..#.......\n..######..\n\n")
    
        elif (c == "D"):
            print("..#####...\n..#....#..\n..#....#..", end=" ")
            print("\n..#....#..\n..#####...\n\n")
    
        elif (c == "E"):
            print("..######..\n..#.......\n..#####...", end=" ")
            print("\n..#.......\n..######..\n\n")
    
        elif (c == "F"):
            print("..######..\n..#.......\n..#####...", end=" ")
            print("\n..#.......\n..#.......\n\n")
    
        elif (c == "G"):
            print("..######..\n..#.......\n..#.####..", end=" ")
            print("\n..#....#..\n..#####...\n\n")
    
        elif (c == "H"):
            print("..#....#..\n..#....#..\n..######..", end=" ")
            print("\n..#....#..\n..#....#..\n\n")
    
        elif (c == "I"):
            print("..######..\n....##....\n....##....", end=" ")
            print("\n....##....\n..######..\n\n")
    
        elif (c == "J"):
            print("..######..\n....##....\n....##....", end=" ")
            print("\n..#.##....\n..####....\n\n")
    
        elif (c == "K"):
            print("..#...#...\n..#..#....\n..##......", end=" ")
            print("\n..#..#....\n..#...#...\n\n")
    
        elif (c == "L"):
            print("..#.......\n..#.......\n..#.......", end=" ")
            print("\n..#.......\n..######..\n\n")
    
        elif (c == "M"):
            print("..#....#..\n..##..##..\n..#.##.#..", end=" ")
            print("\n..#....#..\n..#....#..\n\n")
    
        elif (c == "N"):
            print("..#....#..\n..##...#..\n..#.#..#..", end=" ")
            print("\n..#..#.#..\n..#...##..\n\n")
    
        elif (c == "O"):
            print("..######..\n..#....#..\n..#....#..", end=" ")
            print("\n..#....#..\n..######..\n\n")
    
        elif (c == "P"):
            print("..######..\n..#....#..\n..######..", end=" ")
            print("\n..#.......\n..#.......\n\n")
    
        elif (c == "Q"):
            print("..######..\n..#....#..\n..#.#..#..", end=" ")
            print("\n..#..#.#..\n..######..\n\n")
    
        elif (c == "R"):
            print("..######..\n..#....#..\n..#.##...", end=" ")
            print("\n..#...#...\n..#....#..\n\n")
    
        elif (c == "S"):
            print("..######..\n..#.......\n..######..", end=" ")
            print("\n.......#..\n..######..\n\n")
    
        elif (c == "T"):
            print("..######..\n....##....\n....##....", end=" ")
            print("\n....##....\n....##....\n\n")
    
        elif (c == "U"):
            print("..#....#..\n..#....#..\n..#....#..", end=" ")
            print("\n..#....#..\n..######..\n\n")
    
        elif (c == "V"):
            print("..#....#..\n..#....#..\n..#....#..", end=" ")
            print("\n...#..#...\n....##....\n\n")
    
        elif (c == "W"):
            print("..#....#..\n..#....#..\n..#.##.#..", end=" ")
            print("\n..##..##..\n..#....#..\n\n")
    
        elif (c == "X"):
            print("..#....#..\n...#..#...\n....##....", end=" ")
            print("\n...#..#...\n..#....#..\n\n")
    
        elif (c == "Y"):
            print("..#....#..\n...#..#...\n....##....", end=" ")
            print("\n....##....\n....##....\n\n")
    
        elif (c == "Z"):
            print("..######..\n......#...\n.....#....", end=" ")
            print("\n....#.....\n..######..\n\n")
    
        elif (c == " "):
            print("..........\n..........\n..........", end=" ")
            print("\n..........\n\n")
    
        elif (c == "."):
            print("----..----\n\n")

**实例66：二分查找**

> 二分搜索是一种在**有序数组**中查找某一特定元素的搜索算法。  
> 搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；  
> 如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。  
> 如果在某一步骤数组为空，则代表找不到。 这种搜索算法每一次比较都使搜索范围缩小一半。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjUyMjA5OQ_size_16_color_FFFFFF_t_70]

""" arr 有序数组，这里用升序数组。 l 最小索引 r 最大索引 x 查找的值 """
    
    
    def binarySearch(arr, l, r, x):
        if r >= l:    # 非空元组
            mid = int(l + (r - l) / 2)    # 中间元素的索引
            if arr[mid] == x:       # 中间元素就是要查找的元素，直接返回
                return mid
            elif arr[mid] > x:      # 要查找的元素小于中间值，此时x应该在左半部分数组中
                return binarySearch(arr, l, mid - 1, x)
            else:                   # 要查找的元素大于中间值，此时x应该在右半部分数组中
                return binarySearch(arr, mid + 1, r, x)
        else:         # 空元组或找到最后数组为空了，则返回-1
            return -1
    
    
    # 测试数组
    arr = [2, 3, 4, 10, 40]
    x = 10
    
    # 函数调用，返回值是所查找元素的索引
    result = binarySearch(arr, 0, len(arr) - 1, x)
    
    if result != -1:
        print("数组的第 %d 个元素是 %d" % (result+1, x))
    else:
        print("元素不在数组中")

**实例67：线性查找**

> 线性查找指按一定的顺序检查数组中每一个元素，直到找到所要寻找的特定值为止。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjUyMjA5OQ_size_16_color_FFFFFF_t_70 1]

""" arr 无序数组 n 数组的元素个数 x 查找值 """
    
    
    def search(arr, n, x):
        for i in range(0, n):  # 一个一个找，找到则返回，找完还找不到就返回-1
            if (arr[i] == x):
                return i
        return -1
    
    
    # 在数组 arr 中查找字符 D
    arr = ['A', 'B', 'C', 'D', 'E']
    x = 'D'
    n = len(arr)
    result = search(arr, n, x)
    
    if result == -1:
        print("元素不在数组中")
    else:
        print("元素在数组中的索引为", result)

**实例68：插入排序**

> 插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。  
> ![在这里插入图片描述][20201203152042531.gif_pic_center]

""" arr 无序数组 """
    
    
    def insertionSort(arr):
        for i in range(1, len(arr)):  # 一个一个插入排序
            key = arr[i]   # 待排序的元素，从左到右
            j = i - 1      # 待排序元素的前一个元素
            while j >= 0 and key < arr[j]:  # 如果待排序的元素小于前一个元素，则往前挪
                arr[j + 1] = arr[j]  # 此时arr[j]是没有值的，等待填充
                j -= 1
            arr[j + 1] = key       # 找到合适的位置，将key放入
    
    
    arr = [12, 11, 13, 5, 6]
    insertionSort(arr)
    print("排序后的数组:")
    for i in range(len(arr)):
        print("%d" % arr[i], end=' ')

**实例69：快速排序**

> 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）**分为较小和较大的2个子序列**，然后**递归地排序两个子序列**。  
> **步骤为：**  
> **①挑选基准值**：从数列中挑出一个元素，称为"基准"（pivot）;  
> **②分割**：重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与基准值相等的数可以到任何一边）。在这个分割结束之后，对基准值的排序就已经完成;  
> **③递归排序子序列**：递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。  
> 递归到最底部的判断条件是数列的大小是零或一，此时该数列显然已经有序。  
> ![在这里插入图片描述][20201203152600141.gif_pic_center]

def partition(arr, low, high):
        """ arr 无序属组 low 最小索引，即0 high 最大索引，即n-1 """
        i = (low - 1)  # low = 0,high = n-1,i = -1
        pivot = arr[high]   # 索引最大的值,将该值作为基准，假设最后一个元素是最大值
        for j in range(low, high):
            if arr[j] <= pivot:   # 遍历整个数组
                i = i + 1
                arr[i], arr[j] = arr[j], arr[i]  # 小于等于基准的，从左往右交换数组元素位置，保持前面的部分元素是较小的
    
        arr[i + 1], arr[high] = arr[high], arr[i + 1]
        return (i + 1)  # 返回值为i+1
    
    
    
    # 快速排序函数
    def quickSort(arr, low, high):
        if low < high:
            pi = partition(arr, low, high)
            quickSort(arr, low, pi - 1)   # 分治，快速排序
            quickSort(arr, pi + 1, high)  # 分治，快速排序
    
    
    arr = [10, 7, 8, 9, 1, 5]
    n = len(arr)
    quickSort(arr, 0, n - 1)
    print("排序后的数组:")
    for i in range(n):
        print("%d" % arr[i],end=" ")

**实例70：选择排序**

> 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。  
> ![在这里插入图片描述][20201203152610388.gif_pic_center]

A = [64, 25, 12, 22, 11]
    
    for i in range(len(A)):
    
        min_idx = i                 # 假设第一个数是最小的
        for j in range(i + 1, len(A)):
            if A[min_idx] > A[j]:   # 递归找最小
                min_idx = j
    
        A[i], A[min_idx] = A[min_idx], A[i]   # 找到的最小放到最前面
    
    print("排序后的数组：")
    for i in range(len(A)):
        print("%d" % A[i], end=" ")

**实例71：冒泡排序**

> 冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。  
> ![在这里插入图片描述][20201203152855723.gif_pic_center]

def bubbleSort(arr):
        n = len(arr)
        for i in range(n):    # 遍历所有数组元素
            for j in range(0, n - i - 1):  # 每次找到一个最大值，就放到最后
                if arr[j] > arr[j + 1]:
                    arr[j], arr[j + 1] = arr[j + 1], arr[j]  # 前面大于后面，就交换位置
    
    
    arr = [64, 34, 25, 12, 22, 11, 90]
    
    bubbleSort(arr)
    
    print("排序后的数组:")
    for i in range(len(arr)):
        print("%d" % arr[i], end=" ")

**实例72：归并排序**

> 归并排序（英语：Merge sort，或mergesort），是创建在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。  
> 分治法:  
> 分割：递归地把当前序列平均分割成两半。  
> 集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。  
> ![在这里插入图片描述][20201203153150729.gif_pic_center]

def merge(arr, l, m, r):
        """ 合并函数，合并的是有序数组 arr 无序属组 l 第一个索引，一般是0 m 中间索引位置 r 最后一个索引，一般是len(arr)-1 """
        n1 = m - l + 1
        n2 = r - m
    
        # 创建临时数组
        L = [0] * (n1)
        R = [0] * (n2)
    
        # 拷贝数据到临时数组 arrays L[] 和 R[]
        for i in range(0, n1):
            L[i] = arr[l + i]
    
        for j in range(0, n2):
            R[j] = arr[m + 1 + j]
    
            # 归并临时数组到 arr[l..r]
        i = 0  # 初始化第一个子数组的索引
        j = 0  # 初始化第二个子数组的索引
        k = l  # 初始归并子数组的索引
    
        while i < n1 and j < n2:
            # 两个子数组逐个比较，取较小的填入arr中
            if L[i] <= R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1
    
        # 拷贝 L[] 的保留元素
        while i < n1:
            arr[k] = L[i]
            i += 1
            k += 1
    
        # 拷贝 R[] 的保留元素
        while j < n2:
            arr[k] = R[j]
            j += 1
            k += 1
    
    
    def mergeSort(arr, l, r):
        """ 归并排序函数 arr 无序属组 l 最小索引 r 最大索引 """
        if l < r:
            m = int((l + (r - 1)) / 2)   # 中间位置的索引
            mergeSort(arr, l, m)       # 递归下钻，直到每个数组的元素只有1个
            mergeSort(arr, m + 1, r)   # 递归下钻，直到每个数组的元素只有1个
            merge(arr, l, m, r)        # 合并两个1个元素的数组为一个2个元素的数组。合并2个2个元素的数组为1个4个元素的数组，直至所有分组合并完成。
    
    
    arr = [12, 11, 13, 5, 6, 7]
    n = len(arr)
    print("给定的数组")
    for i in range(n):
        print("%d" % arr[i],end=" ")
    
    mergeSort(arr, 0, n - 1)
    print("\n\n排序后的数组")
    for i in range(n):
        print("%d" % arr[i],end=" ")

**实例73：堆排序**

> 堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。  
> ![在这里插入图片描述][20201203153201720.gif_pic_center]

def heapify(arr, n, i):
        """ arr 无序数组 n 数组元素的长度 i 最大索引 """
        largest = i    # 最大索引
        l = 2 * i + 1  # left = 2*i + 1 左节点索引
        r = 2 * i + 2  # right = 2*i + 2 右节点索引
    
        if l < n and arr[i] < arr[l]:
            largest = l    # 如果最大索引小于左节点索引，则左节点索引为最大索引
    
        if r < n and arr[largest] < arr[r]:
            largest = r    # 如果顶点小于右节点，则右节点索引为二叉树顶点索引
    
        if largest != i:
            arr[i], arr[largest] = arr[largest], arr[i]  # 交换
    
            heapify(arr, n, largest)
    
    
    def heapSort(arr):    # 堆排序
        n = len(arr)
    
        # 建立一个最大堆，顶点最大
        for i in range(n, -1, -1):
            heapify(arr, n, i)
    
        # 交换元素
        for i in range(n - 1, 0, -1):
            arr[i], arr[0] = arr[0], arr[i]
            heapify(arr, i, 0)
    
    
    arr = [12, 11, 13, 5, 6, 7]
    heapSort(arr)
    n = len(arr)
    print("排序后")
    for i in range(n):
        print("%d" % arr[i], end=" ")

**实例74：计数排序**

> 计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。  
> ![在这里插入图片描述][202012031534140.gif_pic_center]

def countSort(arr):
        """ 适用于量大，但数值范围较小的场景 output和count的长度 """
        # 初始化三个数组output count
        output = [0 for i in range(256)]   # 输出数组
    
        count = [0 for i in range(256)]    # 计数数组
    
        ans = [0 for i in range(len(arr))]  # 最后输出结果
    
        for i in arr:
            # 如读取到5，就在count[4]上加1，读取到9，就在count[8]上加1，读取完，此时的count数组已经计数完成。
            count[i-1] += 1
    
        # 读取count中的数据
        i = 0
        for j in range(len(count)):
            while count[j]>0:
                output[i] = j+1
                i+=1
                count[j]-=1
        # 排完序后重写入到arr中
        for i in range(len(arr)):
            ans[i] = output[i]
    
        return ans
    
    arr = [3,3,4,4,2,5,7,1,1,2,3,4,3,6,7,9,9,6,5,3,20]
    print(arr)
    print(countSort(arr))

**实例75：希尔排序**

> 希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。  
> 希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。  
> ![在这里插入图片描述][20201203153508580.gif_pic_center]

def shellSort(arr):
        n = len(arr)
        gap = int(n / 2)  # 初始化gap 间隔,也称为子序列组数。若gap=2,则分为2组子序列，索引为0 2 4 6 8为一组，1 3 5 7 9为另一组
    
        while gap > 0:
    
            for i in range(gap,n):   # 对每一组子序列做插入排序
                # 以下是插入排序
                temp = arr[i]
                j = i
                while j >= gap and arr[j - gap] > temp:    # 同一个子序列中，前一个元素大于当前元素，则把前一个元素放到当前元素位置，直到当前元素找到合适的位置插入
                    arr[j] = arr[j - gap]
                    j -= gap
                arr[j] = temp   # 找到合适的位置放入该值
            gap = int(gap / 2)    # 调小gap值
    
    
    arr = [12, 34, 54, 2, 3]
    
    n = len(arr)
    print("排序前:")
    for i in range(n):
        print(arr[i],end=" ")
    
    shellSort(arr)
    
    print("\n排序后:")
    for i in range(n):
        print(arr[i],end=" ")

**实例76：拓扑排序**

> 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。  
> 在图论中，由一个有向无环图的顶点组成的序列，当且仅当满足下列条件时，称为该图的一个拓扑排序（英语：Topological sorting）：每个顶点出现且只出现一次；若A在序列中排在B的前面，则在图中不存在从B到A的路径。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjUyMjA5OQ_size_16_color_FFFFFF_t_70 2]

from collections import defaultdict
    
    # 定义一个Graph类
    class Graph:
        def __init__(self, vertices):    # 构造函数，vertices为顶点个数
            self.graph = defaultdict(list)  # 
            self.V = vertices
    	# 添加边，u是起始顶点 v末尾顶点
        def addEdge(self, u, v):
            self.graph[u].append(v)
    	# 
        def topologicalSortUtil(self, v, visited, stack):
    
            visited[v] = True
    
            for i in self.graph[v]:
                if visited[i] == False:
                    self.topologicalSortUtil(i, visited, stack)
    
            stack.insert(0, v)
    	# 
        def topologicalSort(self):
            visited = [False] * self.V
            stack = []
    
            for i in range(self.V):
                if visited[i] == False:
                    self.topologicalSortUtil(i, visited, stack)
    
            print(stack)
    
    # 实例
    g = Graph(6)
    g.addEdge(5, 2);
    g.addEdge(5, 0);
    g.addEdge(4, 0);
    g.addEdge(4, 1);
    g.addEdge(2, 3);
    g.addEdge(3, 1);
    
    print("拓扑排序结果：")
    g.topologicalSort()

**参考地址**：[菜鸟教程][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjUyMjA5OQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/ca1b2749ad114136920b7dd5b7bb0115.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjUyMjA5OQ_size_16_color_FFFFFF_t_70]: /images/20221120/930c472810524be9b38c7131c84bb783.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjUyMjA5OQ_size_16_color_FFFFFF_t_70 1]: /images/20221120/7943d7758e1c41958718c9bf239a3b1b.png
[20201203152042531.gif_pic_center]: /images/20221120/5136a6bd842c4b21b3d7119e81ffe3bd.png
[20201203152600141.gif_pic_center]: /images/20221120/acc1dc7537144e0588efb858e5302918.png
[20201203152610388.gif_pic_center]: /images/20221120/823ee8fe55144af6af80c0f9dc5a6362.png
[20201203152855723.gif_pic_center]: /images/20221120/05317b1cf9d749a39217eca04d0a7a40.png
[20201203153150729.gif_pic_center]: /images/20221120/c421e848695646d2a6abd9baff4f37f6.png
[20201203153201720.gif_pic_center]: /images/20221120/e726b9dba83e467fae82a3c9cd6013ac.png
[202012031534140.gif_pic_center]: /images/20221120/d614b7c596314fab8ebd4a483fdb0324.png
[20201203153508580.gif_pic_center]: /images/20221120/e9508e8053664a6a96cf122dad1c1f28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjUyMjA5OQ_size_16_color_FFFFFF_t_70 2]: /images/20221120/72c9b4b6e93e447e97b1a236736c02de.png
[Link 1]: https://www.runoob.com/python3/python3-examples.html