基本数据结构

# 第三章 基本数据结构
## （1）栈定义及实现

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         1_用Python实现栈
# Description:  栈是元素的有序集合，其排序原则被成为LIFO(last-in first-out),即先进后出。基于在集合中的时间来排序。
# Author:       zhaoyaowei
# Date:         2023/2/18 13:15
# -------------------------------------------------------------------------------

# 栈抽象数据类型
"""
1、Stack()：创建1个空栈。无入参，返回1个空栈。
2、push(item)：将1个元素添加至栈的顶端。入参item，无返回值。
3、pop()：将栈顶端元素移除。无入参，返回顶端元素，修改栈内容。
4、peek()：返回栈顶端元素，不移除该元素。无入参，不修改栈内容。
5、isEmpty()：检测栈是否为空。无入参，返回1个布尔值。
6、size()：返回栈中元素的数据。无入参，返回1个整数。
"""


class Stack:
    """
    基于有序集合的Python列表实现栈，假设列表尾部==栈顶端，列表头部==栈底端;
    此外，也可将列表头部==栈顶端，需要修改push()、pop()、peek()方法，见注释部分。
    两种方式性能有差异，其时间复杂度分别为O(1)和O(n)
    """

    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)
        # self.items.insert(0, item)

    def pop(self):
        return self.items.pop()
        # return self.items.pop(0)

    def peek(self):
        return self.items[-1]
        # return self.items[0]

    def size(self):
        return len(self.items)


if __name__ == '__main__':
    # 栈操作示例
    s = Stack()
    print(s.isEmpty())
    print(s.push(4))
    print(s.push("dog"))
    print(s.peek())
    print(s.push(True))
    print(s.size())
    print(s.isEmpty())
    print(s.push(8.4))
    print(s.pop())
    print(s.size())
    print(s.__dict__)

```


## （2）匹配括号和符号

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         2_匹配括号和符号
# Description:  利用栈来实现简单括号匹配、复杂括号匹配
# Author:       zhaoyaowei
# Date:         2023/2/18 15:03
# -------------------------------------------------------------------------------

from pythonds.basic.stack import Stack


def parChecker(n):
    """
    简单括号匹配：
        True:((()))、(()())
        False: (()、()())
    思路：新建1个空栈，从左往右，遇到左括号，将其push压栈，表示稍后需要1个与之匹配都右括号；
        反之，遇到右括号，则调pop移除顶端左括号。只要所有左括号都能遇到与之匹配的右括号，即True。
        若存在任何1个左括号无法找到与之匹配的右括号，则False。若全都匹配，则最终栈应该是空的。
        1、相匹配的右括号与左括号出现的顺序相反（栈）
        2、从左到右，最后打开的左括号必须要匹配最先打开的右括号（次序反转）
        3、当扫描到右括号时，删除栈顶端的左括号，若栈中没有元素返回，则返回True
        4、如果都没有找到，则返回True
    
    :param n: 简单括号字符串
    :return: 布尔值
    """
    s = Stack()
    balanced = True  # 字义平衡，表示匹配成功，2个括号为闭合状态
    index = 0  # 遍历n的下标
    while index < len(n) and balanced:
        i = n[index]
        if i not in ['(', ')']:
            index += 1
            continue  # continue 遇到非括号字符，跳出本次循环；break,终止所有循环
        if i == "（":
            s.push(i)
        else:  # 右括号
            if s.isEmpty():  # 查找有没有左括号，栈是否为空；为空，无左括号，无法闭合匹配
                balanced = False
            else:
                s.pop()  # 删除栈顶端的左括号
        index += 1

    if balanced and s.isEmpty():  # 所有括号匹配，且栈为空
        return True
    return False  # 都没有找到，返回False


def parChecker1(n):
    """
    复杂符号匹配：
        True: {{([][])}()}、[[{{(())}}]]
        False: ([)]、((()]))
    思路：与简单括号相比，区别在于当出现右符号时，必须检测其类型是否与栈顶的左符号类型相匹配（调用辅助函数）。
        若2个符号不匹配，则整个符号串也就不匹配。若处理完成且栈是空的，则说明所有符号正确匹配。
    :param n: 简单括号字符串
    :return: 布尔值
    """
    s = Stack()

    balanced = True
    index = 0
    while index < len(n) and balanced:
        i = n[index]
        if i in "{[(":
            s.push(i)
        else:
            if s.isEmpty():
                balanced = True
            else:
                top = s.pop()
                if not matches(top, i):
                    balanced = False
        index += 1

    if balanced and s.isEmpty():
        return True
    return False


def matches(top, right):
    """
    检测栈顶移除的符号是否与当前的右符号匹配,相同类型
    :param top: 栈顶参数
    :param right:
    :return:
    """
    tops = "{[("
    rights = "}])"

    return tops.find(top) == rights.index(right)


if __name__ == '__main__':
    s = "([)]"
    print(parChecker1(s))

```

## （3）十进制转任意进制

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         3_十进制转任意进制
# Description:  利用栈的反转特性进行进制的转换，值除以基数，余数进栈，结果出栈
# Author:       zhaoyaowei
# Date:         2023/2/18 17:14
# -------------------------------------------------------------------------------
from pythonds import Stack


def baseConverter(dec_number, base):
    """
    十进制转换为二进制、八进制、十六进制等,基础超过十时，不能再直接使用余数，可采用digits存储对应余数位置上的数字
    :param dec_number: 十进制数值，大于0
    :param base: 进制基础，十进制、二进制、16进制等
    :return: 转换后的base进制数字串
    """
    digits = "0123456789ABCDEF"

    s = Stack()

    while dec_number > 0:
        rem = dec_number % base
        s.push(rem)
        dec_number = dec_number // base
        print(s.peek())

    new_str = ""
    while not s.isEmpty():
        new_str = new_str + digits[s.pop()]
    return new_str


# 附：
# （1）python内置进制转换方法：
num = 20
print(f"十进制 {num} 转 二进制 = {bin(num)}")
print(f"十进制 {num} 转 八进制 = {oct(num)}")
print(f"十进制 {num} 转 十六进制 = {hex(num)}")
num1 = 0b10100
num2 = 0o24
num3 = 0x14
int("0b10100", 2)  # 使用int("String",num)解决，string为其他进制的表示，num为该进制具体进制数
print(f"二进制 {num1}、八进制 {num2}、十六进制 {num3} 转 十进制 分别 = {int(num1)}, {int(num2)}, {int(num3)}")
print(f"二进制 {num1} 分别转八进制 、十六进制 = {oct(num1)}, {hex(num1)}")
# （2）进制转换算法
# 二进制-->十进制:
# 例如将二进制的0b101011转换为十进制的步骤如下：
# 第0位 1 x 2^0 = 1；
# 第1位 1 x 2^1 = 2；
# 第2位 0 x 2^2 = 0；
# 第3位 1 x 2^3 = 8；
# 第4位 0 x 2^4 = 0；
# 第5位 1 x 2^5 = 32；
# 把结果值相加1+2+0+8+0+32=43，即0b101011=43
# 八进制-->十进制:
# 例如将八进制的0o34转换为十进制的步骤如下：
# 第0位 4 x 8^0 = 4；
# 第1位 3 x 8^1 = 24；
# 把结果值相加，4+24=28，即0o34=28
# 十六进制-->十进制
# 例如将十六进制的0x3c转换为十进制的步骤如下：
# 第0位 c x 16^0 = 12；
# 第1位 3 x 16^1 = 48；
# 把结果值相加，12+48=60，即0x3c=60
# 十进制-->二进制
# 例如将十进制的56转换为二制的步骤如下：
# 将商56除以2，商28余数为0；
# 将商28除以2，商14余数为0；
# 将商14除以2，商7余数为0；
# 将商7除以2，商3余数为1；
# 将商3除以2，商1余数为1；
# 将商1除以2，商0余数为1；
# 因为最后一位是经过多次除以2才得到的，因此它是最高位，读数字从最后的余数向前读，111000，所以56=ob111000。
if __name__ == '__main__':
    print(baseConverter(1888, 10))
```

## （4）前序、中序和后序表达式

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         4_前序、中序和后序表达式
# Description:  计算运算符和操作数的不同相对位置的表达式，其中中序需要()来消除歧义。
# 前序和后序表达式中的运算顺序完全由运算符的位置决定。
# 任意复杂的中序表达式转前序或者后序：1、写成完全括号表达式 2、括号内的运算符移动到左（右）括号，并去掉右（左）括号即可。
# Author:       zhaoyaowei
# Date:         2023/3/4 17:49
# -------------------------------------------------------------------------------

from pythonds.basic import Stack
import string


def infixToPostfix(infixexpr):
    """
    用Python实现从中序到后序表达式的转换
    解题思路：转换过程中，由于运算符右侧的操作数还未出现，需要先保存。其次运算符之间有不同的优先级，需要反转。
            综上，使用栈来处理。
    解题步骤：
        （1）创建1个保存运算符的空栈opstack,以及1个用于保存结果的空列表
        （2）假设中序表达式以空格分割，使用split转换成标记列表
        （3）从左往右，扫描此标记列表
            a. 如果标记是操作数，将其添加制结果列表的末尾
            b. 如果标记是左括号，将其压入opstack栈
            c. 如果标记是右括号，反复从opstack栈中移除元素，直至遇到对应的左括号。
    :param infixexpr:
    :return:
    """
```

Python数据结构和算法分析（三）

算法分析


# 第二章 算法分析
## （1）大O记法

```python
# 数量级（order of magnitude）常被称作大O记法（order），记作O(f(n))

# 示例：
def order(n):
    """
    T(n) = 3 + 3n2 + 2n + 1, 时间复复杂度是O(n2)
    :param n:
    :return:
    """
    a = 5
    b = 6
    c = 10
    for i in range(n):
        for j in range(n):
            x = i * i
            y = j * j
            z = i * j
    for k in range(n):
        w = a * k + 45
        v = b * b
    d = 33

```

## （2） 异序词检测

```python
"""
展示不用数量级算法的经典例子：异序词检测
题目：如果一个字符串只是重排了另一个字符串的字符，那么这个字符串就是另一个的异序词。长度相同，小写字母。
"""


def anagramSolution1(s1, s2):
    """
    方法一：清点法，时间复杂度0(n2)
    思路：清点s1，判断是否都出现在list(s2)。通过用python中的特殊值None替换s2字符实现。但str不可修改，所以需要先转换成列表。
    :param s1:
    :param s2:
    :return: 布尔值，是否为异序词
    """
    s2list = list(s2)

    pos1 = 0
    still_ok = True
    while pos1 < len(s1) and still_ok:
        pos2 = 0
        found = False
        while pos2 < len(s2list) and not found:
            if s1[pos1] == s2list[pos2]:
                found = True
            else:
                pos2 += 1
        if found:
            s2list[pos2] = None
        else:
            still_ok = False
        pos1 += 1
    return still_ok


def anagramSolution2(s1, s2):
    """
    方法二：排序法，时间复杂度O(n2)或者O(nlogn)
    思路：字符串转换成列表，再使用sort()排序
    :param s1:
    :param s2:
    :return:
    """
    s1list = list(s1)
    s2list = list(s2)

    s1list.sort()
    s2list.sort()

    pos = 0
    matches = True
    while pos < len(s1list) and matches:
        if s1list[pos] == s2list[pos]:
            pos += 1
        else:
            matches = False
    return matches


def anagramSolution3(s1, s2):
    """
    方法三：计数法，时间复杂度O(n),空间换时间
    思路：数每个字符出现的次数，26种字符对应26个计数器，每遇到1个字符，计算器+1；最后判断2个列表是否相等
    :param s1:
    :param s2:
    :return: 布尔值，是否为异序词
    """
    c1, c2 = [0] * 26, [0] * 26

    for i in range(len(s1)):
        pos = ord(s1[i]) - ord('a')
        c1[pos] += 1

    for i in range(len(s2)):
        pos = ord(s2[i]) - ord('a')
        c2[pos] += 1

    if c1 == c2:
        return True
    else:
        return False



s1 = 'earjj'
s2 = 'jearj'
print(anagramSolution3(s1, s2))

```


## （3）性能分析

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         3_性能分析
# Description:  Python数据结构的性能分析
# Author:       zhaoyaowei
# Date:         2023/2/17 20:54
# -------------------------------------------------------------------------------
from timeit import Timer
import random


# 生成列表的4种方式
def test1():
    """
    第一种：列表连接
    :return:
    """
    a = []
    for i in range(1000):
        a = a + [i]


def test2():
    """
    第一种：列表追加
    :return:
    """
    a = []
    for i in range(1000):
        a.append(i)


def test3():
    """
    第二种：列表解析式
    :return:
    """
    a = [i for i in range(1000)]


def test4():
    """
    第三种：列表构造器调用range函数
    :return:
    """
    a = list(range(1000))


number = 1000
# from __main__ import test1 将test1()从__main__命名空间导入值timeit设置计时的命名空间
# 构造函数接收计时的语句、用于设置的语句和计时器函数。
t1 = Timer("test1()", "from __main__ import test1")
print(f"列表连接运行{number}次耗时：", t1.timeit(number=number), "毫秒")
t2 = Timer("test2()", "from __main__ import test2")
print(f"列表追加运行{number}次耗时：", t2.timeit(number=number), "毫秒")
t3 = Timer("test3()", "from __main__ import test3")
print(f"列表解析式运行{number}次耗时：", t3.timeit(number=number), "毫秒")
t4 = Timer("test4()", "from __main__ import test4")
print(f"列表构造器运行{number}次耗时：", t4.timeit(number=number), "毫秒")

# 比较列表和字段的包含操作
for i in range(10000, 1000001, 20000):
    t = Timer("random.randrange(%d) in x" % i, "from __main__ import random, x")
    x = list(range(i))
    lst_time = t.timeit(number=number)

    x = {j: None for j in range(i)}
    dct_time = t.timeit(number=number)

    print("%d, %10.3f, %10.3f" % (i, lst_time, dct_time))

```

Python数据结构和算法分析（二）

基础部分


# 第一章 基础部分
## （1）牛顿迭代法求解平凡根

```python
def squareroot(n):
    root = n/2
    for i in range(20):
        root = (1/2) * (root + (n / root))
    return root

if __name__ == '__main__':
    print(squareroot(n=4563))
```

## （2）Fraction类
```python
class Fraction:
    """
    构建分数类
    """
    # 定义构造方法
    """
    self 是一个总是指向对象本身的特殊参数，它必须是第一个形参。
    然而，在调用方法时，从来不需要提供相应的实际参数。分数需要分子与分母两部分状态数据。
    构造方法中的 self.num 定义了 Fraction 对象有一个叫作 num 的内部数据对象作为其状态的一部分。
    同理，self.den 定义了分母。这两个实际参数的值在初始时，赋给了状态，使得新创建的 Fraction 对象能够知道其初始值。
    """
    def __init__(self, top, bottom):
        self.num = top
        self.den = bottom

    # 定义输出方法
    def show(self):
        return str(self.num) + "/" + str(self.den)

    def __str__(self):
        return str(self.num) + "/" + str(self.den)

    # 定义分数加法
    def __add__(self, other):
        new_num = self.num * other.den + self.den * other.num
        new_den = self.den * other.den
        return Fraction(new_num, new_den)


myfraction = Fraction(4, 8)
print(myfraction.show())
print(myfraction)
f1 = Fraction(2, 3)
f2 = Fraction(3, 4)
print(f1 + f2)
```

## （3）逻辑门

```python
# 继承：逻辑门与电路

class LogicGate:
    """
    超类LogicGate(逻辑门)的通用特性：标签、输出
    子类：2个输入的逻辑门BinaryGate(二元门)、1个输入的逻辑门UnaryGate(一元闸)
    """

    def __init__(self, n):
        self.label = n
        self.output = None

    def getLabel(self):
        return self.label

    def getOutput(self):
        # perfromGateLogin 进行自己的逻辑运算
        self.output = self.perfromGateLogin()
        return self.output


class BinaryGate(LogicGate):
    """
    子类BinaryGate
    """
    # 常用模式：子类的构造方法需要先使用super函数调用父类的构造方法，再初始化子类独有的数据
    # 创建子类的实例时，首先要初始化所有从父类继承的数据项（如逻辑门的标签），接着构造方法添加子类输入
    def __init__(self, n):
        super().__init__(n)

        self.pinA = None
        self.pinB = None

    # 如果pinA或pinB无任何逻辑门连接，默认用户输入；如有连接，访问该连接并且获取fromgate值
    def getPinA(self):
        if self.pinA is None:
            return int(input(self.getLabel() + "：输入 pinA = "))
        else:
            # Connector类实例化时，运行tgate.setNextPin(self)并向其中传递类自己的示例
            # setNextPin()中的source=Connector类实例==self.pinA,因此可调用getFrom()
            return self.pinA.getFrom().getOutput()

    def getPinB(self):
        if self.pinB is None:
            return int(input(self.getLabel() + "：输入 pinB = "))
        else:
            return self.pinB.getFrom().getOutput()

    # 连接器选择
    # 如果2个都无连接，默认选择pinA; 如果pinA已经有了连接，则选择pinB; 如果2个都有连接，则无法连接逻辑门
    def setNextPin(self, source):
        if self.pinA is None:
            self.pinA = source
        else:
            if self.pinB is None:
                self.pinB == source
            else:
                raise RuntimeError("Error: No Empty Pins")


class UnaryGate(LogicGate):
    """
    子类UnaryGate
    """
    def __init__(self, n):
        super().__init__(n)

        self.pin = None

    def getPin(self):
        return int(input(self.getLabel() + "：输入pin = "))

    def setNextPin(self, source):
        if self.pin is None:
            self.pin = source
        else:
            raise RuntimeError("Error: No Empty Pins")


class AndGate(BinaryGate):
    """
    提供perfromGateLogin方法，与门运算实现
    """
    def __init__(self, n):
        super().__init__(n)

    def perfromGateLogin(self):
        a = self.getPinA()
        b = self.getPinB()
        if a == 1 and b == 1:
            return 1
        else:
            return 0


class OrGate(BinaryGate):
    """
    提供perfromGateLogin方法，或门运算实现
    """
    def __init__(self, n):
        super().__init__(n)

    def perfromGateLogin(self):
        a = self.getPinA()
        b = self.getPinB()
        if a == 1 or b == 1:
            return 1
        else:
            return 0


class NotGate(UnaryGate):
    """
    提供perfromGateLogin方法，非门运算实现
    """
    def __init__(self, n):
        super().__init__(n)

    def perfromGateLogin(self):
        a = self.getPin()
        if a == 1:
            return 0
        else:
            return 1


class Connector:
    """

    """
    def __init__(self, fgate, tgate):
        self.fromgate = fgate
        self.togate = tgate

        tgate.setNextPin(self)

    def getFrom(self):
        return self.fromgate

    def getTo(self):
        return self.togate




ag = AndGate("与门运算")
print(ag.getOutput())
og = OrGate("或门运算")
print(og.getOutput())
ng = NotGate("非门运算")
print(ng.getOutput())
c1 = Connector(ag, og)
c2 = Connector(ag, ng)
print(c1, c2)
```

Python数据结构和算法分析（一）

This package has installed:
	•	Node.js v16.14.0 to /usr/local/bin/node
	•	npm v8.3.1 to /usr/local/bin/npm
Make sure that /usr/local/bin is in your $PATH.

 sudo -s Mac获取root权限

 sudo chmod -R 755 文件夹 设置最高权限
	
 给文件夹下所有文件开放权限。右键-显示简介-应用到所有


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

maven安装：
1:官网下载
2.打开终端，vi ~/.bash_profile
3.添加这两行，并保存
第一行是你的maven所在路径
export MAVEN_HOME=/Applications/开发工具/apache-maven-3.8.6
export PATH=$PATH:$MAVEN_HOME/bin
4: esc, :wq退出
5.终端输入，source ~/.bash_profile. 生效
6.终端输入mvn -v 查看是否安装成功


mysql安装：https://zhuanlan.zhihu.com/p/360858309

export PATH=$PATH:/usr/local/mysql/bin
export PATH=$PATH:/usr/local/mysql/support-files
由于mac系统的升级，新的环境变量读取方式走zsh的就会存在以上问题。zsh的配置文件没有加载~/.bash_profile的配置项


Mac mysqlERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password:yes)问题：

1、进入终端输入（cd /usr/local/mysql/bin/）回车
2、输入（sudo su）回车以获取管理员权限
3、输入（./mysqld_safe --skip-grant-tables &）回车以禁止mysql验证功能，mysql会自动重启，偏好设置中的mysql状态会变成running。
4、输入命令（./mysql）回车
5、输入命令（flush privileges;）分号别忘记输了
6、重置密码：SET PASSWORD FOR 'zhaoyaowei@localhost'=(root) ；
7、执行 quit；退出mysql
8、执行 exit；退出sudo
9、密码重置已完毕，可以试试登陆mysql。
————————————————
https://blog.csdn.net/qq_41184530/article/details/105327810


python环境配置：
http://t.zoukankan.com/jasmine0112-p-14233303.html

Linux和Mac环境变量设置
https://www.cnblogs.com/hi3254014978/p/15172400.html

vim ~/.bash_profile
PATH="/usr/local/bin:${PATH}" 
export PATH
PATH="/Library/Frameworks/Python.framework/Versions/3.9/bin:${PATH}" 
export PATH
alias python="/Library/Frameworks/python.framework/Versions/3.9/bin/python3" 


cffi==1.14.4
MarkupSafe==1.1.1
python -m pip install MarkupSafe==1.1.1


Mac 安装yarn
curl -o- -L https://yarnpkg.com/install.sh | bash
sudo npm install yarn -g

curl -o- -L https://yarnpkg.com/install.sh | bash

open ~/.bash_profile

// 文件最后一行添加
export PATH="/Users/用户/.yarn/bin:$PATH"

// 添加后输入该命令
source ~/.bash_profile

yarn -v


使用chown解除文件夹的超级权限限制
sudo chown -R zhaoyaowei ~/.npm
sudo chown -R zhaoyaowei ~/.config



zsh: command not found: 解决方法
思路：把 bash shell 中.bash_profile 全部环境变量加入zsh shell中
第一步：open .zshrc
第二步：添加 source ~/.bash_profile
第三步执行：source .zshrc








Mac软件安装

一、创建 model.py

    from tortoise.models import Model

    class Tournament(Model):
        id = fields.IntField(pk=True)
        name = fields.TextField()
        created = fields.DatetimeField(auto_now_add=True)

        def __str__(self):
            return self.name


    class Event(Model):
        id = fields.IntField(pk=True)
        name = fields.TextField()
        tournament = fields.ForeignKeyField('models.Tournament', related_name='events')
        participants = fields.ManyToManyField('models.Team', related_name='events', through='event_team')
        modified = fields.DatetimeField(auto_now=True)
        prize = fields.DecimalField(max_digits=10, decimal_places=2, null=True)

        def __str__(self):
            return self.name


    class Team(Model):
        id = fields.IntField(pk=True)
        name = fields.TextField()

         class Meta:
            abstract = True  # 设置为True表明这是一个抽象类
            table = "team"  # 设置表名
            table_description = ""  # 设置此项可为为当前模型创建的表生成注释消息
                    unique_together = ()  # 指定unique_together为列集设置复合唯一索引，其为元组的元组（列表很好）
            indexes = ()  # 指定indexes为列集设置复合非唯一索引，它应该是元组的元组（列表很好）
                    ordering = []  # 指定ordering为给定模型设置默认排序。.order_by(...)它应该可以迭代以与接收相同的方式格式化的字符串。如果查询是GROUP_BY使用默认排序的子句构建的，.annotate(...)则不应用。

                    manager = tortoise.manager.Manager  # 指定manager覆盖默认管理器。它应该是实例tortoise.manager.Manager或子类。
            
2、 多表关联

    from tortoise.models import Model
    from tortoise import fields


    class Tournament(Model):
        id = fields.IntField(pk=True)
        name = fields.CharField(max_length=255)

        events: fields.ReverseRelation["Event"]

        def __str__(self):
            return self.name


    class Event(Model):
        id = fields.IntField(pk=True)
        name = fields.CharField(max_length=255)
        tournament: fields.ForeignKeyRelation[Tournament] = fields.ForeignKeyField(
            "models.Tournament", related_name="events"
        )
        participants: fields.ManyToManyRelation["Team"] = fields.ManyToManyField(
            "models.Team", related_name="events", through="event_team"
        )

        def __str__(self):
            return self.name


    class Team(Model):
        id = fields.IntField(pk=True)
        name = fields.CharField(max_length=255)

        events: fields.ManyToManyRelation[Event]

        def __str__(self):
            return self.name
3、字段
3.1 数据字段
    Field（source_field = None , generated = False , pk = False , null = False , default = None , unique = False , index = False , description = None , model = None , validators = None , ** kwargs
    
    参数：
    source_field (Optional[str]) ： 如果 DB 列名称需要是特定的而不是从字段名称中生成，则提供 source_field 名称。
    generated (bool) ： 该字段是否由数据库生成
    pk (bool) ：该字段是否为主键
    null (bool) ：主键是否可以为空
    default (Optional[Any])：该字段的默认值
    unique (bool) ：该字段的值是否唯一
    index (bool)：设置该字段是否为索引
    description (Optional[str]) ：字段描述，也将出现在Tortoise.describe_model() 生成的 DDL 中并作为 DB 注释出现。
    validators (Optional[List[Union[Validator, Callable]]]) ：此字段的验证器

   3.2 关系字段
   ForeignKeyField( model_name , related_name = None , on_delete = 'CASCADE' , db_constraint = True , ** kwargs )
   
    参数：
    model_name：关联模型的名称{app}.{models}
    related_name：相关模型上的属性名称，用于反向解析外键
    on_delete：
    field.CASCADE：表示如果相关模型被删除，该模型应该被级联删除
    field.RESTRICT：表示只要有外键指向，相关模型删除就会受到限制
    field.SET_NULL：将字段重置为 NULL，以防相关模型被删除。仅当字段已设置时才能null=True设置
    field.SET_DEFAULT：将字段重置为default值，以防相关模型被删除。只能设置是字段有一个default集合
    to_field：建立外键关系的相关模型上的属性名。如果未设置，则使用 pk
    db_constraint： 控制是否应在数据库中为此外键创建约束。默认值为 True，这几乎可以肯定是您想要的；将此设置为 False 可能对数据完整性非常不利

   
   ManyToManyField(model_name, through=None, forward_key=None, backward_key='', related_name='', on_delete='CASCADE', db_constraint=True, **kwargs)
   
    参数：
    through：通过中间表进行连接
    forward_key： 直通表上的正向查找键。默认值通常是安全的
    backward_key： 通表上的向后查找键。默认值通常是安全的
  
   OneToOneField( model_name , related_name = None , on_delete = 'CASCADE' , db_constraint = True , ** kwargs )

4、 查询
4.1 基础
模型本身有几种方法可以启动查询：

filter(*args, **kwargs)：使用给定的过滤器创建 QuerySet

exclude(*args, **kwargs)：使用给定的排除过滤器创建 QuerySet

all()：创建不带过滤器的查询集

first()：创建仅限于一个对象的查询集并返回实例而不是列表

annotate()： 使用额外的函数/聚合对结果进行再过滤

此方法返回QuerySet对象，允许进一步过滤和一些更复杂的操作

模型类也有这个方法来创建对象：

create(**kwargs)：使用给定的 kwargs 创建对象
get_or_create(defaults, **kwargs)：获取给定 kwargs 的对象，如果未找到，则使用默认字典中的其他 kwargs 创建它
模型本身的实例也有这些方法：

save()：更新实例，或者插入它，如果它以前从未保存过
delete()：从数据库中删除实例
fetch_related(*args)：获取与实例相关的对象。它可以获取 key关系、backward-key 关系。

    values()  # 返回queryset里面字段的值
    values_list()  # 返回queryset里面字段的值，同时，内部可以指定需要返回的字段的值

    events = await Event.filter(id__in=[1,2,3]).values('id', 'name', tournament_name='tournament__name')  
    
    使用values()或values_list()生成更有效的查询

filter可以指定的对象：

not
in：检查字段的值是否在传递列表中
not_in
gte：大于或等于传递的值
gt：大于传递值
lte：低于或等于传递的值
lt：低于通过值
range：介于和给定两个值之间
isnull：字段为空
not_isnull：字段不为空
contains：字段包含指定的子字符串
icontains：不区分大小写contains
startswith：如果字段以值开头
istartswith：不区分大小写startswith
endswith：如果字段以值结尾
iendswith：不区分大小写endswith
iexact：不区分大小写等于
search：全文搜索

    使用示例：
    from tortoise.functions import Count, Trim, Lower, Upper, Coalesce

    # This query will fetch all tournaments with 10 or more events, and will
    # populate filed `.events_count` on instances with corresponding value
    await Tournament.annotate(events_count=Count('events')).filter(events_count__gte=10)
    await Tournament.annotate(clean_name=Trim('name')).filter(clean_name='tournament')
    await Tournament.annotate(name_upper=Upper('name')).filter(name_upper='TOURNAMENT')
    await Tournament.annotate(name_lower=Lower('name')).filter(name_lower='tournament')
    await Tournament.annotate(desc_clean=Coalesce('desc', '')).filter(desc_clean='')

4.2 Q 对象
Q 对象非常通用，一些示例用例：

创建 OR 过滤器
嵌套过滤器
倒置过滤器
结合以上任何一种来简单地编写复杂的多层过滤器
比如：

Q( * args , join_type = 'AND' , ** kwargs )

    参数：
    join_type：连接类型，OR\AND
    args ( Q) ：Q要包装的内部表达式
    kwargs ( Any) ：此 Q 对象应封装的过滤语句

    found_events = await Event.filter(
        Q(Q(name='Event 1'), Q(name='Event 2'), join_type="OR")  # Q(name='Event 1') | Q(name='Event 2')


4.3 F 表达式
F对象表示模型字段的值。它可以引用模型字段值并使用它们执行数据库操作，而无需将它们从数据库中拉出到 Python 内存中

    from tortoise.expressions import F
    await User.filter(id=1).update(balance = F('balance') - 10)
    await User.filter(id=1).update(balance = F('balance') + F('award'), award = 0)

    # or use .save()
    user = await User.get(id=1)
    user.balance = F('balance') - 10
    await user.save(update_fields=['balance'])






