python的练习

该博客主要围绕 Python 展开,包含众多基础练习题目,如数字求和、平方根计算、字符串操作等,还涉及列表、字典的常用操作。同时,介绍了多种排序算法,如插入排序、快速排序等,为 Python 学习提供了丰富的实践案例。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、练习题目

  • 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
评论 6
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值