myapp

深色浅色模式切换

python使用 ​

更新时间: 2025/7/23 本章字数: 0 字 预计阅读时长: 0 分钟

本章总结

查看python版本 ​

sh
python --version

常用关键字 ​

类别关键字说明
逻辑值True布尔真值
False布尔假值
None空值
逻辑运算and同时满足多个条件
or满足一个条件即可
not不包含某个条件
条件控制if（如果）条件判断语句
elif（否则如果）不满足第一个条件判断是否满足第二个
else（否则）不满足条件时
循环for迭代语句（它可以遍历任何可迭代对象，如列表或字符串。）
while条件循环（满足条件循环，不满足的时候退出）
break跳出循环
continue跳出当前循环部分，进入下一次迭代
异常处理try执行代码如果没有异常可以处理接下来的代码
except捕获异常
finally无论是否发生异常都会执行的代码块
raise抛出异常
函数def定义函数
return函数返回值
类class定义类
模块import导入模块
from导入模块特定功能
as为导入的模块重新命名

说明

逻辑值、逻辑运算、条件控制为常用，大部分三者都在一起使用

逻辑值、逻辑运算、条件控制 ​

python
if True:    # 如果条件为真，那么打印一个1
    print(1)
python
a = None
if a:    # 因为a是None所以不是True，因此会打印2
    print(1)
else:
    print(2)
python
a = 1
if a<0:    # 因为a不小于1，因此返回False，进入下一步判断
    print(1)
elif a == 0:    # 因为a也不等于0，同样返回False
    print(2)
else:       # 上述条件都不满足，那么就打印一个3
    print(3)

逻辑运算 ​

python
a = 1
b = 2
if a >0 and b >=2   # 需要同时满足a大于0和b大于或等于2
    print(1)
python
a = 1
b = 2
if a >0 or b >2   # 需要同时满足a大于0或者b大于2，只要满足一个既可
    print(1)
python
a = 1
if not a == 2:  # a == 2为False，但是前面使用了not，所以它将False变成了True
    print(1)

循环 ​

python
a = "12345"  # 定义一个字符串变量 a，内容是 "12345"
for i in a:  # 遍历字符串 a 中的每一个字符
    print(i)  # 打印当前字符
python
a = 0   # 定义一个a为0
while a <10:    # 如果a小于10，开始循环
    a += 1  # 每次循环a +1
    print(a)    # 打印a，那么就是打印1-10
python
a = 0
while a < 10:
    a += 1
    if a == 5:  # 当a等于5时
        print("遇到5，循环终止")
        break    # 立即退出循环
    print(a)
print("循环结束")
python
a = 0
while a < 10:
    a += 1
    if a == 5:  # 当a等于5时
        print("跳过5")
        continue  # 跳过本次循环，也就是a=5的时候，直接打印"跳过5"，那么最终打印就是1，2，3，4，跳过5，6，7，8，9，10
    print(a)
print("循环结束")

异常处理 ​

python
try:
    print(int("0")) # 打印使用int()将字符串转为整数0
except Exception as e:
    print(1)
finally:
    print(2)    # 不管如何都会执行
# 最终的结果就是打印0和2

# 换一种
try:
    print(int("0a")) # 打印使用int()将字符串转为整数0，因为0a不是有效数字，因此不能转换会报错
except Exception as e:  # 捕获错误，并且将Exception重命名为e
    print(e)    # 把错误打印
finally:
    print(2)    # 不管如何都会执行
# 最终的结果就是打印：invalid literal for int() with base 10: '0a'和2

函数 ​

python
def index():
    return 0

函数接收参数

python
def index(text):
    return text

运算符 ​

运算符说明示例
+相加1+1 输出2，也可以字符串"he" + "llo" 输出"hello"
-相减少1-1 输出0
*乘以1*1 输出1
/除以1/1 输出1
%返回除法的余数25%7 输出4
**幂1**21 为1的21次方，输出1

比较运算符 ​

运算符说明示例
==等于，比较两个对象是否相同1==1，返回True
!=不等于，比较两个对象是否不同1!=1，返回False
>大于1>1 返回False
>=大于等于1>=1 返回为True
<小于1<1 返回False
<=小于等于1<=1 返回为True

赋值运算符 ​

运算符说明示例
=赋值给某个值a=1，那么a的值就是1
+=加法赋值运算符a=0，a+=1，等同于a = a+1
-=减法赋值运算符a=1，a-=1，等同于a = a-1
*=乘法赋值运算符a=1，a*=1，等同于a = a*1
/=除法赋值运算符a=1，a/=1，等同于a = a/1
%=取模赋值运算符a=1，a%=1，等同于a = a%1

列表 ​

说明

序列是 Python 中最基本的数据结构。

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

列表写法如下：

python
a = [1, 2, 3, 4, 5]

更新列表 ​

python
a = [1, 2, 3, 4, 5]
a[0] = 100

删除列表 ​

python
a = [1, 2, 3, 4, 5]
del list[2] # 删除第二个，a的值就是如下
a = [1, 2, 4, 5]

列表长度 ​

python
a = [1, 2, 3, 4, 5]
len(a) # 获取a的长度

列表组合 ​

python
a = [1, 2, 3] + [4, 5, 6]
print(a) # 获取a的长度
# 结果如下
[1, 2, 3, 4, 5, 6]

元素是否存在于列表中 ​

python
a = [1, 2, 3]
print(3 in a) # 获取a的长度
# 结果如下
True

迭代 ​

python
a = [1, 2, 3]
for x in a:
    print(x)
# 结果如下
1, 2, 3

列表内置函数 ​

python
a = [1, 2, 3]
len(a)   # 列表元素个数
max(a)   # 返回列表元素最大值
min(a)   # 返回列表元素最小值
a.append(4) # 在列表后面追加一个元素
a.index(2) # 从列表中找出某个值第一个匹配项的索引位置

装饰器 ​

说明

装饰器是 Python 中的一种高级功能，它允许你动态地修改函数或类的行为。

装饰器是一种函数，它接受一个函数作为参数，并返回一个新的函数或修改原来的函数。

python
def myapp(func):
    def wrapper():
        a = 0
        if a == 1:
            func()
        else:
            print("这个hello()函数不会执行")
    return wrapper

@myapp
def hello():
    print("Hello!")
    
hello()

os模块 ​

python
import os   # 引入os模块

a = os.getcwd()     # 获取当前工作目录
print("当前工作目录:", a)
files = os.listdir(a)   # 获取目录下所有的文件
print("目录下的文件:", files)
for i in files:     # 循环遍历目录下的文件
    if "i" in i:       # 如果文件名包含i
        print(i)    # 那么就输出这个文件名

random 模块 ​

说明

random模块用于生成随机数

random.random(): 返回一个在[0, 1]范围内的随机浮点数。

python
import random
print(random.random())

random.uniform(a, b): 返回一个在[a, b]范围内的随机浮点数。

python
import random
print(random.uniform(10, 20))

random.randint(a, b): 返回一个在[a, b]范围内的随机整数。

python
import random
print(random.randint(10, 20))

random.shuffle(x): 将序列x中的元素随机打乱。

python
import random
items = [1, 2, 3, 4, 5, 6]
random.shuffle(items)
print(items)

字典 ​

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号: 分割，每个对之间用逗号,分割，整个字典包括在花括号 {} 中

python
a = {'name': 'name', 'age': 18}

访问字典数据 ​

python
a = {'name': 'name', 'age': 18}
print(a['name'])

通过值（value）访问键（key） ​

通过key可以轻松访问到value,那么反过来，通过value访问key

python
a = {'name': 'name', 'age': 18}
b = {v: k for k, v in a.items()}    # 将key和value互换
print(b[18])

稍微复杂一点 ​

假设，要对常用语句使用别名例如你好,需要用你好、nihao、hello

python
ditcs = {
    "你好": ["你好", "nihao", "hello"]
}

def dictionary(text):
    for occupation in ditcs.keys():
        if text in ditcs[occupation]:
            return occupation
    else:
        return "未匹配到字符串"
print(dictionary("nihao"))    # 打印出`你好`
print(dictionary("123"))  # 打印出`未匹配到字符串`

datetime模块 ​

说明

datetime 模块是用于处理日期和时间的标准库模块。它提供了多种类和函数，可以帮助我们轻松地处理日期、时间、时间差等操作。

获取当前日期和时间 ​

python
from datetime import datetime

now = datetime.now()
print("当前时间:", now)

创建特定时间 ​

python
from datetime import datetime

specific_time = datetime(2025, 7, 23, 8, 0, 0)
print("你创建的时间:", specific_time)
# 打印的结果就是
# 你创建的时间: 2025-07-23 08:00:00

格式化时间 ​

python
from datetime import datetime

# 获取当前时间
now = datetime.now()

# 格式化输出
formatted_time = now.strftime("%Y-%m-%d %H:%M:%S")
print("格式化时间:", formatted_time)

# 不要时分秒
formatted_times = now.strftime("%Y-%m-%d")
print("格式化时间:", formatted_times)
'''
formatted_time和formatted_times
都是字符串类型
'''

n天以后 ​

python
from datetime import datetime, timedelta


# 获取当前时间
now = datetime.now()

# 计算 100 天后的时间
future_time = now + timedelta(days=100)
# 格式化时间
future_times = future_time.strftime("%Y-%m-%d %H:%M:%S")
print("100 天后的时间:", future_times)

两个日期相差的天数 ​

python
from datetime import date

# 创建两个日期
date1 = date(2026, 1, 1)
date2 = date(2025, 7, 23)

# 计算天数差
delta = date1 - date2
print("距离2026年元旦还剩余:", delta.days)

今天距离n天还剩余 ​

python
from datetime import datetime, date


now = datetime.now()
# 创建两个日期
'''
now.year-----获取年份，数据类型int
now.month-----获取月份，数据类型int
now.day-----获取日期，数据类型int
'''
date1 = date(2026, 1, 1)
date2 = date(now.year, now.month, now.day)

# 计算天数差
delta = date1 - date2
print("今天距离2026年元旦还剩余:", delta.days)

获取星期几 ​

python
from datetime import datetime

# 获取当前时间
now = datetime.now()

# 格式化输出
formatted_time = now.strftime("%A")
print(formatted_time)

这里输出是英文，如果要换成中文，可以使用字典

python
from datetime import datetime

dicts = {
    "Monday": "星期一",
    "Tuesday": "星期二",
    "Wednesday": "星期三",
    "Thursday": "星期四",
    "Friday": "星期五",
    "Saturday": "星期六",
    "Sunday": "星期天"
}
# 获取当前时间
now = datetime.now()

# 格式化输出
formatted_time = now.strftime("%A")
print(dicts[formatted_time])

异步 ​

asyncio模块 ​

安装 ​

sh
pip install asyncio

使用 ​

python
import asyncio

async def a():   # 前面加上async 就是异步函数
    print("1")
    await asyncio.sleep(1)  # 异步等待一秒钟
    print("2")
asyncio.run(a())    # 异步函数使用需要使用asyncio.run()

JSON使用 ​

python
import json

# Python 字典类型转换为 JSON 对象
data = {
    'name': "abc",
    'age': 18,
}

json_str = json.dumps(data)
print("Python 原始数据：", repr(data))
print("JSON 对象：", json_str)

# 将 JSON 对象转换为 Python 字典
data2 = json.loads(json_str)
print("data2['name']: ", data2['name'])
print("data2['age']: ", data2['age'])

二分查找 ​

python
def binarySearch(array, l, r, i):
    # 基本判断
    if r >= l:
        mid = int(l + (r - l) / 2)
        # 元素整好的中间位置
        if array[mid] == i:
            return mid
            # 元素小于中间位置的元素，只需要再比较左边的元素
        elif array[mid] > i:
            return binarySearch(array, l, mid - 1, i)
            # 元素大于中间位置的元素，只需要再比较右边的元素
        else:
            return binarySearch(array, mid + 1, r, i)
    else:
        # 不存在
        return -1


# 测试数组
arr = [2, 3, 4, 10, 40]
x = 10

# 函数调用
result = binarySearch(arr, 0, len(arr) - 1, x)

if result != -1:
    print("元素在数组中的索引为 %d" % result)
else:
    print("元素不在数组中")

排序 ​

python
def partition(arr, low, high):
    i = (low - 1)  # 最小元素索引
    pivot = arr[high]

    for j in range(low, high):

        # 当前元素小于或等于 pivot
        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


# arr[] --> 排序数组
# low  --> 起始索引
# high  --> 结束索引

# 快速排序函数
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]
print(arr)
n = len(arr)
quickSort(arr, 0, n - 1)
print("排序后的数组:")
print(arr)

match-case ​

match、case是python3.10引入的新特性。

python
a = 1
match a:
    case 0:
        print(0)
    case 1:
        print(1)
    case 2:
        print(2)
    case 3:
        print(3)
    case _:
        print(-1)

把星期函数改一下

python
from datetime import date


def week(a):
    match a:
        case "Monday":
            return "星期一"
        case "Tuesday":
            return "星期二"
        case "Wednesday":
            return "星期三"
        case "Thursday":
            return "星期四"
        case "Friday":
            return "星期五"
        case "Saturday":
            return "星期六"
        case "Sunday":
            return "星期天"
        case _:
            return "没有匹配星期信息。"
date = date(2026, 1, 1)
formatted_times = date.strftime("%A")
print(week(formatted_times))