十一、有C/C++/Java基础，迅速掌握Python，B站黑马2022版教程笔记（自用）

本文链接：https://blog.csdn.net/zhiaidaidai/article/details/128478470

每篇必看前言：

该笔记适用于有C/C++/Java基础的想要迅速掌握Python语法的人。

该笔记是以B站黑马2022版教程为背景，所作的笔记。

往期链接：

一、http://t.csdn.cn/SxJd9

二、http://t.csdn.cn/iQyaJ

三、http://t.csdn.cn/paJPt

四、http://t.csdn.cn/WbHMB

五、http://t.csdn.cn/uwENV

六、http://t.csdn.cn/aaKAb

七、http://t.csdn.cn/CGAsX

八、http://t.csdn.cn/1xzHO

九、http://t.csdn.cn/Tuwd3

十、http://t.csdn.cn/sNoca

闭包：

简单闭包的使用：

分析：fn1实际上是inner函数的对象，这么做的好处是得到一个logo固定的inner函数对象。那么接下来无论给该函数对象传入什么参数，都只会改变inner里面的msg，而不会改变outer中的logo。

nonlocal关键字：

nonlocal用来声明外部函数的变量值可以被修改

def outer(num1):
    def inner(num2):
        nonlocal num1
        # 如果不加第三行，num1+=num2会报错
        num1+=num2
        print(num1)
    return inner

fn=outer(10)
fn(10)
fn(10)

装饰器：

也是一种闭包，功能是再不破坏目标函数的原有代码和功能下，为目标函数增加新功能。

装饰器的一般写法：

譬如现有函数sleep()，我们想在其执行前加一句输出“我要睡觉了”，在其执行完毕后加一句输出“我起床了”。

def sleep():
    import random
    import time
    print("睡眠中")
    a = random.randint(1, 5)
    time.sleep(a)
    print(f"我睡了{a}秒钟")

则可以改造成如下：

def sleep():
    import random
    import time
    print("睡眠中")
    a = random.randint(1, 5)
    time.sleep(a)
    print(f"我睡了{a}秒钟")


def outer(func):
    def inner():
        print("我要睡觉了")
        func()
        print("我起床了")
    return inner

fn = outer(sleep)
fn()

装饰器的快捷写法：


def outer(func):
    def inner():
        print("我要睡觉了")
        func()
        print("我起床了")
    return inner

@outer
def sleep():
    import random
    import time
    print("睡眠中")
    a = random.randint(1, 5)
    time.sleep(a)
    print(f"我睡了{a}秒钟")

sleep()

设计模式：

除了面向对象外，在编程中有许多既定的模式可以方便开发，我们称之为设计模式，常见的设计模式有：

单例模式、工厂模式、解释器模式、中介模式、模板模式、代理模式等等。

单例模式：

在某些场景下，我们需要一个类无论获取多少次类对象，都仅仅提供一个具体的实例从而节省内存开销。譬如对于某些工具类而言。这便称之为单例模式。

其实现：保证一个类只有一个实例并提供一个访问它的全局访问点。

例子：

工厂模式：

当需要大量创建多个继承子类的实例时，可以使用工厂模式，即另外定义一个工厂类，和get（）方法去创建具体的类对象。

其优点为：大批量创建对象的时候有统一的入口，易于代码维护

当发生修改，仅修改工厂类的创建方法即可

符合现实世界的模式，即由工厂来制作产品（对象）

例子：

class Person:
    pass

class Student(Person):
    pass

class Worker(Person):
    pass

class Teacher(Person):
    pass

class Factory:
    def get_person(self, p_type):
        if p_type == 'w':
            return Worker()
        elif p_type == 's':
            return Student()
        else:
            return Teacher()

factory = Factory()
worker = factory.get_person('w')
student = factory.get_person('s')
teacher = factory.get_person('t')

多线程（讲的太浅了，自己再多看）：

进程、线程：

进程：就是一个程序，运行在系统之上。

线程：线程是归属于进程的，一个进程可以开启多个线程，执行不同的工作，是进程的实际工作最小单位。

进程就好比一家公司，是操作系统对程序进行运行管理的单位

线程就好比公司的员工，进程可以有多个线程（员工），是进程实际的工作者

操作系统中可以运行多个进程，即多任务运行

一个进程内可以运行多个线程，即多线程运行

现代操作系统windows,linux等基本都是多任务的。

进程之间是内存隔离的，即不同的进程拥有各自的内存空间。

线程之间是内存共享的。

多线程简单实现：

import threading
import time


def sing(msg):
    while True:
        print(msg)
        time.sleep(1)

def dance(msg):
    while True:
        print(msg)
        time.sleep(1)

if __name__ == '__main__':
    sing_thread = threading.Thread(target=sing, args=("我在唱歌……", ))
    # 注意元组只有单个参数时也需要保留逗号和空格，否则不会识别成元组
    dance_thread = threading.Thread(target=dance, kwargs={"msg": "我在跳舞……"})
    
    sing_thread.start()
    dance_thread.start()