暑假第六天打卡

离散：

极小项：

（1）简单合取式

（2）每个字母只出现一次

（3）按字典顺序排列

（4）成真赋值，且化为十进制

极大项

（1）简单析取式

（2）每个字母只出现一次

（3）按字典排序

（4）成假赋值，且化为十进制

主析取范式：由极小项构成

主合取范式：由极大项构成

求主析取范式方法

（1）化为析取范式，常用德摩根律，蕴含等值式，分配律等

（2）针对每个简单合取式，如果字母不齐，利用同一律再“合”一个“1”

（3）取极小值

（4）合并，重复消去

求主合取范式方法

（1）化为合取范式，常用德摩根律，蕴含等值式，分配律等

（2）针对每个简单析取式，如果字母不齐，利用同一律再“析”一个“0”

（3）取极大值

（4）合并，重复消去

Python

（1）集合

update（）会将字符串“23”拆分成字符‘2’和‘3’插入集合

add（）会将字符串“23”插入集合

（2）函数：

①参数

顺序：

位置参数、关键字参数、默认参数

斜杠左侧必须用位置参数，不能用关键字参数

收集参数：

*args:将参数打包成元组

**args：将参数打包成字典

def abc(a, *, b, c):

       print(a, b, c)

如果调用abc(1, 2, 3)报错，因为*是收集参数

应该这么调用abc(1, b = 2, c = 3)

解包：

def myfunc(a, b, c, d):

       print(a, b, c, d)

args = (1, 2, 3, 4)

要想将args传入myfunc，使用元组的解包：

myfunc(*args)

②LEGB原则

③闭包：

嵌套函数的外层作用域会被保存下来

例子：

def outer():

       x = 0

       y = 0

       def inner(x1, y1):

              nonlocal x, y         #内层函数可以修改外层函数作用域的变量

              x += x1

              y += y1

              print(f'现在x = {x}, y = {y}')

       return inner

move = outer()

move(1, 2)

move(2, 3)

开发时可以用来记住角色位置移动

④装饰器

import time

def time_master(func):

    def call_func():

        print("开始运行程序")

        start = time.time()

        func()

        stop = time.time()

        print("结束程序运行")

        print(f"一共耗费了{(stop - start):.2f}秒")

    return call_func

@time_master    #装饰器

def myfunc():

    time.sleep(2)

    print("I love fishc")

myfunc()

调用myfunc（）函数时不是直接调用，而是将其作为参数放入time_master装饰器中，然后调用这个装饰器

多个装饰器用在一个参数上：

def add(func):

    def inner():

        x = func()

        return x + 1

    return inner

def cube(func):

    def inner():

        x = func()

        return x * x * x

    return inner

def square(func):

    def inner():

        x = func()

        return x * x

    return inner

@add

@cube

@square

def test():

    return 2

print(test())

装饰器调用顺序是从下往上

给装饰器传递参数

import time

def logger(msg):

    def time_master(func):

        def call_func():

            start = time.time()

            func()

            stop = time.time()

            print(f"[{msg}]一共耗费了{(stop - start):.2f}秒")

        return call_func

    return time_master

@logger(msg = "A")

def funA():

    time.sleep(1)

    print("正在调用funA...")

@logger(msg = "B")

def funB():

    time.sleep(1)

    print("正在调用funB...")

funA()

funB()

上面写法等价于不用装饰器的话

funA = logger(msg = “A”)(funA) #先把参数传入，再把函数传入，因为第一次调用返回的是中间层函数，第二次调用才返回最内层函数

lambda表达式

mapped = map(lambda x : ord(x) + 10, "Fishc")

print(list(mapped))

⑤生成器：

def counter():

    i = 0

    while i <= 5:

        yield i

        i += 1

for i in counter():

print(i)

counter()：作用：每次执行到yield时提供一个数据，暂停并保留一个状态，下一次调用从i+=1开始

生成器不支持下标索引

算法：

https://blog.csdn.net/m0_72805195/article/details/131615600?spm=1001.2014.3001.5501