python的练习

一、练习题目

• Hello World 实例
• 数字求和
• 平方根
• 二次方程
• 计算三角形的面积
• 计算圆的面积
• 随机数生成
• 摄氏温度转华氏温度
• 交换变量
• if 语句
• 判断字符串是否为数字
• 判断奇数偶数
• 判断闰年
• 获取最大值函数
• 质数判断
• 输出指定范围内的素数
• 阶乘实例
• 九九乘法表
• 斐波那契数列
• 阿姆斯特朗数
• 十进制转二进制、八进制、十六进制
• ASCII码与字符相互转换
• 最大公约数算法
• 最小公倍数算法
• 简单计算器实现
• 生成日历
• 使用递归斐波那契数列
• 文件 IO
• 字符串判断
• 字符串大小写转换
• 计算每个月天数
• 获取昨天日期
• list 常用操作
• 约瑟夫生者死者小游戏
• 五人分鱼
• 实现秒表功能
• 计算 n 个自然数的立方和
• 计算数组元素之和
• 数组翻转指定个数的元素
• 将列表中的头尾两个元素对调
• 将列表中的指定位置的两个元素对调
• 翻转列表
• 判断元素是否在列表中存在
• 清空列表
• 移除列表中重复的元素
• 复制列表
• 计算元素在列表中出现的次数
• 计算列表元素之和
• 计算列表元素之积
• 查找列表中最小元素
• 查找列表中最大元素
• 移除字符串中的指定位置字符
• 判断字符串是否存在子字符串
• 判断字符串长度
• 使用正则表达式提取字符串中的 URL
• 将字符串作为代码执行
• 字符串翻转
• 对字符串切片及翻转
• 按键(key)或值(value)对字典进行排序
• 计算字典值之和
• 移除字典点键值(key/value)对
• 合并字典
• 将字符串的时间转换为时间戳
• 获取几天前的时间
• 将时间戳转换为指定格式日期
• 打印自己设计的字体
• 二分查找
• 线性查找
• 插入排序
• 快速排序
• 选择排序
• 冒泡排序
• 归并排序
• 堆排序
• 计数排序
• 希尔排序
• 拓扑排序

二、代码概览

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
# @Date : 2024/4/19 14:21
# @Author : water
"""
正则表达式：
    正则表达式（Regular Expression，简称 regex）是一种用于模式匹配和文本处理的强大工具，它定义了一种字符串匹配的模式，能够快速有效地搜索、替换、提取或验证文本中的特定字符串或字符序列。以下是正则表达式的主要规则和组成部分：
    基本规则和概念：
    字符匹配：
        普通字符：大多数字母、数字、标点符号等直接匹配自身。
        特殊字符（元字符）：具有特殊意义的字符，如 ., ^, $, *, +, ?, {}, (, ), [, ], \ 等，它们不直接匹配自身，而是用于构建更复杂的模式。
    量词：
        ?：前一个元素可选，出现0次或1次。
        *：前一个元素出现0次或任意多次。
        +：前一个元素出现至少1次，最多无限次。
        {n}：前一个元素精确出现n次。
        {n,}：前一个元素至少出现n次。
        {n,m}：前一个元素至少出现n次，至多出现m次。
    位置匹配：
        ^：匹配字符串的开始位置。
        $：匹配字符串的结束位置。
        \b：匹配单词边界（空格、标点符号与字母数字之间的位置）。
        \B：匹配非单词边界。
    字符类：
        [abc]：匹配括号内任何一个字符，如a、b或c。
        [^abc]：否定字符类，匹配任何不在括号内的字符。
        [a-zA-Z]：范围表示，匹配指定范围内任意字符。
        \d：等价于 [0-9]，匹配任意数字。
        \D：等价于 [^0-9]，匹配任意非数字字符。
        \w：等价于 [a-zA-Z0-9_]，匹配字母、数字或下划线。
        \W：等价于 [^a-zA-Z0-9_]，匹配非字母、数字或下划线的字符。
        \s：匹配任意空白字符，包括空格、制表符、换页符等。
        \S：匹配任意非空白字符。
    预定义字符类（POSIX 字符类）：
        [:alnum:]：字母和数字。
        [:alpha:]：字母。
        [:digit:]：数字（等同于\d）。
        [:lower:]：小写字母。
        [:upper:]：大写字母。
        [:space:]：空白字符（等同于\s）。
        [:punct:]：标点符号。
        [:xdigit:]：十六进制数字（0-9、A-F、a-f）。
    转义字符：
        \（反斜杠）用于转义特殊字符，使其失去特殊意义，如 \\ 匹配反斜杠本身，\. 匹配句点。
    分组与捕获：
        (pattern)：将 pattern 分为一个子表达式或捕获组，可以用于重复、后向引用、条件匹配等。
        (?P<name>pattern)：命名捕获组，为捕获组赋予名称，便于后续引用。
    非捕获组：
        (?:pattern)：不捕获匹配结果，只用于分组逻辑，不影响捕获组编号。
    后向引用：
        \number 或 (?P=name)：引用先前定义的捕获组内容，number 是捕获组编号，name 是命名捕获组的名称。
    零宽断言（Lookaround）：
        (?=pattern)：正向先行断言，要求pattern出现在当前位置之后，但不计入匹配结果。
        (?!pattern)：负向先行断言，要求pattern不出现于当前位置之后。
        (?<=pattern)：正向后发断言，要求pattern出现在当前位置之前，但不计入匹配结果。
        (?<!pattern)：负向后发断言，要求pattern不出现于当前位置之前。
    选择（|）、连字符（-）与区间：
        A|B：匹配 A 或 B。
        [a-z]：在字符类中，- 表示一个连续的字符区间，如 [a-z] 匹配任何小写字母。
    其他高级特性（取决于具体实现）：
        条件匹配（如 (?:(?(id/name)yes-pattern|no-pattern))）：根据先前捕获组是否匹配执行不同的模式。
        嵌套捕获组：在一个捕获组内部可以定义另一个捕获组。
        原子组（如 (?>(pattern))）：防止回溯影响到组内的匹配。
        注释（如 (?#comment)）：在正则表达式中添加注释。
    使用正则表达式的常见操作：
        匹配验证：检查字符串是否符合某个模式。
        搜索：在文本中查找符合模式的所有子串。
        替换：将符合模式的子串替换为另一字符串。
        提取：从文本中提取符合模式的部分，通常与捕获组配合使用。
    注意事项：
        正则表达式的行为可能因不同的编程语言或库而有所不同，应参考相关文档了解具体实现细节。
        正则表达式引擎通常支持多种匹配模式，如贪婪匹配（默认）、懒惰匹配（使用量词后加 ?，如 *?, +?, {n,m}?）等。
        掌握这些规则后，您可以构造出复杂而精确的模式，用于处理各种文本数据问题。


"""
import calendar
import cmath
import datetime
import math
import random
import re
import time
from collections import deque
from functools import reduce


class Example:

    def hello_wolrd(self):
        """
        # >>> print("hello world!")
        hello world!

        """
        return 'hello world!'

    def sum_num(self, *keys):
        """
        求和
        # >>> print(sum(keys))
        """
        return sum(keys)

    def square_root(self, num):
        """
        平方根
        # >>> print(math.sqrt(num))
        """
        return math.sqrt(num)

    def quadratic_equation(self, equation):
        """
        求二次方程
        # >>> print(x.quadratic_equation())
        """
        # 两种解法
        # 1.
        y = equation.split(' ')
        a, b, c = y[0], y[2], y[4]
        a = float(1 if a.split('x^2')[0] == '' else a.split('x^2')[0])
        b = float(1 if b.split('x')[0] == '' else b.split('x')[0])
        c = float(c.split('=')[0])
        x1 = (-b + cmath.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
        x2 = (-b - cmath.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
        # ，format()方法用于将x1和x2的值分别插入到字符串中对应的占位符{0}和{1}处。占位符的序号（0和1）对应于format()方法括号内传入的变量顺序
        print("结果 {0}，和 {1}".format(x1, x2))

    def triangle_area(self, a, h):
        """
        求三角形面积
            a : 底长
            h：高
        """
        return a * h / 2

    def triangle_area_s(self, a, b, c):
        """
        求三角形面积  :  通过半周长求面积
            a : 左边长
            b: 有变长
            c: 底边长
        """
        # 计算半周长
        h = (a + b + c) / 2
        return math.sqrt(h * (h - a) * (h - b) * (h - c))

    def circle_area(self, r):
        """
        求圆面积
            r : 半径
        """
        return math.pi * r ** 2

    def ramdom_num(self, n):
        """
        随机数
            n : 截止数
        """
        # random.randint(a, b) 用于返回一个介于 a 和 b 之间的整数（包括 a 和 b）
        return random.randint(1, n)

    def celsius_fahrenheit_temperature(self, fahrenheit_temperature):
        """
        华氏温度转摄氏温度
            fahrenheit_temperature :华氏温度
        """
        # 摄氏温度 = (华氏温度 - 32) * 5 / 9
        return (fahrenheit_temperature - 32) * 5 / 9

    def fahrenheit_celsius_temperature(self, celsius_temperature):
        """
        摄氏温度转华氏温度
            celsius_temperature :摄氏温度
        """
        # 华氏温度 = 摄氏温度 * 9 / 5 +32
        return celsius_temperature * 9 / 5 + 32

    def exchange_variable(self):
        """
        交换两个变量的值
        """
        a = 1
        b = 2
        print("交换前：a =", a, "b =", b)
        a, b = b, a
        print("交换后：a =", a, "b =", b)

    def if_statement(self):
        """
        if语句
        """
        a = 1
        b = 2
        if a > b:
            print("a > b")
        elif a < b:
            print("a < b")

    def determain_str_is_num(self, string):
        """
        判断字符串是否为数字
        """
        if string.isdigit():
            return True
        else:
            return False

    def determain_ood_even_num(self, num):
        """
        判断数字是否为奇数、偶数
        """
        if num % 2 == 0:
            return "偶数"
        else:
            return "奇数"

    def determine_leap_year(self, year):
        """
        判断是否为闰年
            普通闰年：可以被4整除，但不能被100整除
            实际闰年：必须被400整除
        """
        if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
            return "闰年"
        else:
            return "平年"

    def determine_max_value(self, *keys):
        """
        求最大值
            keys : 传入的数字
        """
        return max(keys)

    def determine_prime(self, num):
        """
        判断质数（素数），质数必须大于1，即1既不是质数也不是合数
            num: 输入的数字
        """
        if num <= 1:
            return "不是质数"
        for i in range(2, num):
            if num % i == 0:
                return "不是质数"
        #  必须全部循环完，才算质数
        return "是质数"

    def out_prime_num(self, num):
        """
        输出所有小于或等于n的素数。
            num : 指定范围的数字
        """
        prime_lst = []
        if num < 2:
            return "不是素数"
        for i in range(2, num):
            flag = True
            for j in range(2, i):
                if i % j == 0:
                    flag = False
                    break
                else:
                    continue

            if flag is False:
                print(i, "不是素数")
            else:
                print(i, "是素数")
                prime_lst.append(i)
        return prime_lst

    def out_prime_num_new(self, num):
        """
        输出所有小于或等于n的素数。
            num : 指定范围的数字
        """
        prime_lst = []
        for i in range(2, num):
            for j in range(2, i):
                if i % j == 0:
                    break
            # 当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码，如果在循环过程中遇到了 break 语句，则会中断循环，此时不会执行 else 子句。
            else:
                prime_lst.append(i)
        return prime_lst

    def factorial(self, n):
        """
        阶乘
        """
        if n < 0:
            return "n 必须大于 0"
        elif n == 0:
            return 1
        else:
            return n * self.factorial(n - 1)

    def multiplication_table(self):
        """
            九九乘法表
        """
        for i in range(1, 10):
            for j in range(1, i + 1):
                print('%d*%d=%d' % (j, i, i * j), end='\t')
            print()

    def fibonacci(self, n):
        """
        斐波那契数列
        """
        a, b = 0, 1
        while True:
            # print(a, end=' ')
            yield a
            # print(a)
            # print(a, end=' ')
            a, b = b, a + b
            if a > n:
                break

    def armstrong_number(self, number):
        """
        检查一个数是否为阿姆斯特朗数。

        参数:
            number (int): 待检查的正整数。
        返回值:
            bool: 如果是阿姆斯特朗数，返回True；否则返回False。
        """
        if number < 0:
            return "n 必须大于 0"
        elif number == 0:
            return 0
        else:
            # 将数字转换为字符串，便于获取各个位上的数字
            digits = [int(digit) for digit in str(number)]
            # 计算数字的位数
            num_digits = len(digits)

            # 计算各位数字的幂之和
            sum_of_powers = sum(digit ** num_digit