# 单行注释

'''
多行注释（不推荐）
'''

"""
另一种多行注释（推荐）
"""

# 打印多个字符
print('hello world', '你好')
# 默认\n为结尾，可以修改
print('可以修改end', end=',')

age = 18
name = "Wil"
# 保留1位小数就是%.1f，其他同理
height = 170.3
print("我的名字是%s，我的年龄是%d，我的身高是%.1fcm" % (name, age, height))

age = 18
name = "Wil"
print("My name is {}, my age is {}".format(name, age))

age = 18
name = "Wil"
print("My name is {0}, my age is {1}, my brother's name is {0} too".format(name, age))

print("用户名{userName} 密码是{pwd}".format(userName="root", pwd="123"))

age = 18
name = "Wil"
print(f'My name is {name}, my age is {age}')

score = 50
if score>=80:
    print("优秀")
elif 60 <= score < 80:
    print("及格")
else:
    print("不及格")

import random
# 随机输出”石头“、”剪刀“、”布“
myList = ["石头","剪刀", "布"]
print(random.choice(myList))

i = 0
while i < 10:
    print(f"i= {i}")
    if i % 2 == 0:
        print(f"这是偶数：{i}")
    i += 1

for i in range(5):
    print(i)
# 0 1 2 3 4

# 求1——100累加和
sum = 0
for i in range(1, 101):
    sum += i
print(sum)

str1 = "hello world"
stream = str1.encode("utf-8") # 默认utf-8
print(type(stream)) # <class 'bytes'>

s1 = b"hello"
print(type(s1)) # <class 'bytes'>

# decode解码
s2 = b"hha"
print(s2.decode("utf-8"))

s3 = "abcd"
print(s3[0]) # a
print(s3[3]) # d

s3 = "abcd"
print(s3[-1]) # d
print(s3[-2]) # c

name = "class_name_peter"
print(name[6:10:1]) # name
print(name[6:10:2]) # nm
print(name[:]) # class_name_peter
print(name[-1:3:-1]) # retep_eman_s

mytest = "this is my test"
print(mytest.find("this")) # 0
print(mytest.find("hello")) #-1

mytest = "this is my test"
print(mytest.index("this")) # 0
print(mytest.index("hello")) # ValueError: substring not found

mytest = "this is my test"
print(mytest.count("t")) #3
print(mytest.count("hello")) #0

test1 = "this is test1"
print(test1.replace("t", "T")) # This is TesT1
print(test1.replace("t", "T", 1)) # This is test1

test2 = "what a fuck this world"
print(test2.split(" ")) # ['what', 'a', 'fuck', 'this', 'world']
print(test2.split(" ", 1))  # ['what', 'a fuck this world']

test1 = "this is test1"
print(test1.capitalize())  # This is test1

test3 = "HELLO WORLD"
print(test3.lower())  # hello world

test4 = "how are you"
print(test4.upper())  # HOW ARE YOU

test4 = "how are you"
print(test4.title())  # How Are You

test4 = "how are you"
print(test4.islower())  # True
test5 = "How are you"
print(test5.islower())  # False

test3 = "HELLO WORLD"
test5 = "How are you"
print(test3.isupper())  # True
print(test5.isupper())  # False

numStr = "124"
print(numStr.isdigit())  # True
strNum = "3.1E5"
print(strNum.isdigit())  # False

test5 = "How are you"
print(test5.startswith("how"))  # False
print(test5.startswith("How"))  # True

test5 = "How are you"
print(test5.endswith("you"))  # True

code = "python"
print("*".join(code))  # p*y*t*h*o*n

li = ["a", "b", 121, "hello"]
print(li[1])  # b
print(li[-2])  # 121
print(li[10])  # IndexError: list index out of range

li = ["a", "b", 121, "hello"]
for i in li:
    print(i)

li = ["a", "b", 121, "hello"]
i = 0
while i < len(li):
    print(li[i])
    i += 1

language = ["Python", "Java", "C++"]
numList = [1990, 1222, 5554]
language = language + numList
print(language)  # ['Python', 'Java', 'C++', 1990, 1222, 5554]

language = ["Python", "Java", "C++"]
language.insert(1, "Go")
language.insert(10, "C#")
language.insert(-1, "JS")
language.insert(-10, "html")
print(language)  # ['html', 'Python', 'Go', 'Java', 'C++', 'JS', 'C#']
t = ("Shell", "C")
language.insert(0, t)
print(language)  # [('Shell', 'C'), 'html', 'Python', 'Go', 'Java', 'C++', 'JS', 'C#']

li1 = ["aaa", "bbb"]
li2 = ["ddd", "tttt"]
li1.append(li2)
print(li1)  # ['aaa', 'bbb', ['ddd', 'tttt']]
li1.extend(li2)
print(li1)  # ['aaa', 'bbb', ['ddd', 'tttt'], 'ddd', 'tttt']

breakfast = ["豆浆", "油条"]
breakfast[0] = "豆腐脑"
print(breakfast)  # ['豆腐脑', '油条']

breakfast = ["豆浆", "油条", "包子", "馒头"]
breakfast[1:4] = ["鸡蛋"]  # 左闭右开
print(breakfast)  # ['豆浆', '鸡蛋']

breakfast = ["豆浆", "油条", "包子", "馒头"]
breakfast[2:2] = ["鸡蛋"]  # 左闭右开
print(breakfast)  # ['豆浆', '油条', '鸡蛋', '包子', '馒头']

r = list("hello")
print(r)  # ['h', 'e', 'l', 'l', 'o']
del r[0]
print(r)  # ['e', 'l', 'l', 'o']
del r[0:2]  # 左闭右开
print(r)  # ['l', 'o']
del r
print(r)  # NameError: name 'r' is not defined

nums = [1, 2, 3, 4, 5]
p = nums.pop()
print(p)  # 5
print(nums)  # [1, 2, 3, 4]

mm = ["Hello", "world", "you"]
mm.remove("you")
print(mm)  # ['Hello', 'world']

mm = ["Hello", "world", "you"]
mm.clear()
print(mm)  # []

find = ["Hello", "world", "you"]
print("he" in find)  # False
print("you" in find)  # True
print("lla" not in find)  # True

find = ["Hello", "world", "you"]
print(find.index("he"))  # ValueError: 'he' is not in list

kk = [1, 2, 3, 4]
kk.reverse()
print(kk)  # [4, 3, 2, 1]

hh = [5, 2, 65, 4, 8, 1]
hh.sort()  # 默认从小到大
print(hh)  # [1, 2, 4, 5, 8, 65]
hh.sort(reverse=True)  # 从大到小
print(hh)  # [65, 8, 5, 4, 2, 1]

ff = [1, 4, 2, 9, 3]
ff1 = sorted(ff)
print(ff)  # [1, 4, 2, 9, 3]
print(ff1)  # [1, 2, 3, 4, 9]

# 给列表中的每个元素都乘以2
dd = [1, 2, 3, 4]
print([i * 2 for i in dd])  # [2, 4, 6, 8]

# 元组的定义
tup = (1, 3, 4)
# 定义单个元素的元组时要加逗号
tup1 = (1)
print(type(tup1))  # <class 'int'>
tup1 = (1,)
print(type(tup1))  # <class 'tuple'>

tup1 = (1,)
print(len(tup1))  # 1

tt = (3, 5, [99, 88, 77], 6)
tt[2][0] = 66
print(tt)  # (3, 5, [66, 88, 77], 6)

# 定义字典
dic1 = {}
dic2 = {"name": "ll", "age": 18}
dic3 = dict()

dic3 = dict()

# 添加元素
dic3["id"] = 1
dic3["name"] = "Lucy"
print(dic3)  # {'id': 1, 'name': 'Lucy'}

# 修改元素
dic3["name"] = "Peter"
print(dic3)  # {'id': 1, 'name': 'Peter'}

# 查找
print(dic3["name"])  # Peter

# 删除元素
del dic3["name"]
print(dic3)  # {'id': 1}

# 清空字典
dic3.clear()
print(dic3)  # {}

map = {"id": 2}
print(len(map))  # 1

map = {"id": 2, "age": 20, "name": "MyName"}
keys = map.keys()
for k in keys:
    print(k)

values = map.values()
for v in values:
    print(v)

map = {"id": 2, "age": 20, "name": "MyName"}
items = map.items()
for key, value in items:
    print(key, value)

# 输出如下
# id 2
# age 20
# name MyName

# 定义集合
s1 = {10, 20, 30}
print(type(s1))  # <class 'set'>
# 字符串转集合
s2 = set("hello")
print(s2)  # {'h', 'l', 'o', 'e'}
# 定义一个空集合
s3 = set()

s3 = set()
s3.add("zoo")
s3.add(1)
s3.add(1)  # 自动去重
print(s3)  # {'zoo', 1}

s4 = set()
s4.update([10, 11])
s4.update((12, 56))
print(s4)  # {56, 10, 11, 12}
s4.update({"name": "Pe"})
print(s4)  # {56, 10, 11, 12, 'name'}

l = {1, 2, 3, 4}
m = {3, 4, 5, 6}
# 求交集
print(l & m)  # {3, 4}
# 求并集
print(l | m)  # {1, 2, 3, 4, 5, 6}

int = 5
# 整数转为字符串
s = str(5)
# 字符串转为list
l = list(s)
# 字符串转为元组
tu = tuple(s)
# 字符串转为集合
set1 = set(s)
# list转为字符串
se = str(l)
# list转元组
tu1 = tuple(l)
# list转集合
se1 = set(tu1)

# 转字典（特殊）
x = ["a1", "b1", "c1", "d1"]
y = ["a2", "b2", "b3"]
z = zip(x, y)
print(dict(z))

a = 10
b = 10
print(id(a))  # 140705617148632
print(id(b))  # 140705617148632
s = "hello"
t = "hello"
print(id(s))  # 2905618815600
print(id(t))  # 2905618815600

l = [1, 2, 3]
m = l
print(id(l))  # 2221094530688
print(id(m))  # 2221094530688

import copy

u = [1, 2, 3]
v = copy.copy(u)
print(id(u))  # 2444626097664
print(id(v))  # 2444626493056

# 定义函数
def sayHello():
    print("Hello world")


# 函数的调用
sayHello()


# 函数的返回值
def funa():
    return 10


print(funa())


# 多返回值
def funb():
    return 10, {"name": "Pe"}, [1, 2, 3]


f = funb()
print(type(f))  # <class 'tuple'>

# 必填参数
def add(x, y):
    return x + y


# 默认参数
def encodefun(string, character="utf-8"):
    return string.encode(character)


# 不定长参数
def func(*args):
    print(type(args))  # <class 'tuple'>


func(1, 22, 4, 2)


# 关键字参数
def fund(**kwargs):
    print(kwargs)
    print(type(kwargs))


fund(name="Peter", age=18)


# 命名关键字参数
def person(name, age, *, city, job):
    print(name, age, city, job)


person("Peter", 19, city="beijing", job="coder")

cup = 100  # 全局变量


def fune():
    cup = 200  # 局部变量
    print(f"fune print {cup}")  # fune print 200


def funf():
    print(f"funf print {cup}")  # funf print 100


fune()
funf()

cup = 100  # 全局变量


def fune():
    global cup
    cup = 200  # 全局变量
    print(f"fune print {cup}")  # fune print 200


def funf():
    print(f"funf print {cup}")  # funf print 200


fune()
funf()

water = 500


def fung():
    water = 700

    def funh():
        nonlocal water  # 申明water为外层的局部变量 即water=700
        print(f"funh print {water}")  # funh print 700
        water = 900

    funh()
    print(f"fung print {water}")  # fung print 900


fung()
print(f"water={water}")  # water=500

funadd = lambda x, y: x + y
print(funadd(4, 5))  # 9

funk = lambda x, y: x if x > y else y
print(funk(4, 5))  # 5

a = [1, 2, 3, 4]
b = ["a", "b", "c", "d"]
z = zip(a, b)
# 然后就可以将z转成各种数据类型
print(dict(z))  # 转map {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
# print(list(z))#转list [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
# print(set(z))  # 转集合 {(4, 'd'), (2, 'b'), (3, 'c'), (1, 'a')}

funm = lambda x: x * x
li = [1, 2, 4, 8]
print(list(map(funm, li)))  # [1, 4, 16, 64]

from functools import reduce

li = [1, 2, 3, 4]
funadd = lambda x, y: x + y
print(reduce(funadd, li))  # 10

li = [1, 2, 3, 4]
for i, num in enumerate(li):
    print(i, num)

# 拆包
def funl():
    return 1, 2, 3


a, b, c = funl()  # funl() 返回的是一个元组类型，这里将元组进行拆包
print(a, b, c)

# 元组拆包升级版
tu = (1, 2, 3, 4)
a, *b, c = tu  # 多变量赋值
print(f"a={a}")  # a=1
print(f"b={b}")  # b=[2, 3]
print(f"c={c}")  # c=4

# 列表拆包
li = [1, 2, 3, 4]
a, *b, c = li
print(f"a={a}")  # a=1
print(f"b={b}")  # b=[2, 3]
print(f"c={c}")  # c=4

# 字典拆包
map = {"name": "Peter", "age": 18}
a, b = map  # 对字典拆包只有键，没有值
print(a, b)  # name age

# 异常捕获
def funm():
    print(hsfgss)


try:
    funm()
except Exception as e:
    print(f"发生异常：{e}")
else:
    print("没有发生异常，就会执行else模块")
finally:
    print("不管是否发生异常，都会执行的模块")

def inputpwd():
    pwd = input("请输入长度超过6位的密码：")
    if (len(pwd) < 6):
        raise Exception("密码长度不足6位")
    return pwd


try:
    pwd = inputpwd()
    print(f"用户输入的密码为：{pwd}")
except Exception as e:
    print("发生异常：", e)

# 查看内置模块
import builtins

print(dir(builtins))

# 自定义模块
import tools.Timetools as timetools

print(timetools.now())
print(timetools.my_time_zone)

# 0——x累加
def funa(x):
    if x == 0:
        return 0
    return funa(x - 1) + x

print(funa(3))

def funa(x):
    if x == 0:
        return 0
    return funa(x - 1) + x

print(funa(3))
res = funa  # 函数引用，就相当于给funa起了个别名
print(res(3))

def logger(func):
    def wrapper(*args):
        print(f"开始执行函数 {func.__name__}")
        return func(*args)

    print(f"函数 {func.__name__} 执行完毕")
    return wrapper  # 装饰器必须返回内部方法名

def add(x, y):
    return x + y

fn = logger(add)
print(fn(10, 20))

def logger(func):
    def wrapper(*args):
        print(f"开始执行函数 {func.__name__}")
        return func(*args)

    print(f"函数 {func.__name__} 执行完毕")
    return wrapper  # 装饰器必须返回内部方法名

@logger
def add(x, y):
    return x + y
@logger
def printm(x, y, z):
    print(x, y, z)

print(add(10, 20))
printm(1, 2, 3)

call = lambda: print("call")

def funx(fun, *args):
    print(f"处理逻辑 {args}")
    # 处理完毕调用回调函数
    fun()

funx(call)

class Hero(object):
    name = "Hero"  # 属性

    def info(self):  # self表示实例本身（相当于Java的this？）
        print("I am the class Hero")

hero = Hero()
print(hero.name)  # Hero
hero.info()  # I am the class Hero

class Student():
    name = "Peter"

    def info(self):
        print("xxx")


print(Student.__dict__)  # 查看类的属性
print(Student.__dict__["name"])  # 查看单个属性
print(Student.name)  # 查看属性
Student.age = 18  # 新增属性
Student.name = "Lucy"  # 修改属性
del Student.age  # 删除属性

class Order:
    def __init__(self, id, costprice, sellprice):  # 构造函数
        self.id = id
        self.costprice = costprice
        self.sellprice = sellprice

    def getprofit(self):
        return self.sellprice - self.costprice


order = Order(1, 32.1, 68.2)
print(f"订单 {order.id} 的利润是{order.getprofit()}")

class Person:
    def __init__(self, name):
        self.name = name

    def __del__(self):  # 析构函数
        print(f"{self.name}被销毁了")


person = Person("kk")

class Person:
    def __init__(self, name):
        self.name = name

    def __del__(self):
        print(f"{self.name}被销毁了")


person = Person("kk")

del person

class A:
    _name = "LL"
    __age = 18  # 私有属性

    def get_age(self):
        return self.__age

    def set_sex(self, sex):
        self.__sex = sex

    def get_sex(self):
        return self.__sex

    def __printfoo(self):  # 私有方法
        print("foo")

    def printsth(self):
        self.__printfoo()  # 调用私有方法
        print("sth.")


a = A()
print(A._name)  # LL
# print(A.__age)  # AttributeError: type object 'A' has no attribute '__age'. Did you mean: '_A__age'?
print(a._name)  # LL
# print(a.__age)  # AttributeError: 'A' object has no attribute '__age'. Did you mean: '_A__age'?
print(a.get_age())  # 正确访问私有属性的方式
a.printsth()
a.set_sex("男")
print(a.get_sex())

class B(A):
    pass  # 什么都不写


b = B()
b.printsth()

class A1:
    def printa1(self):
        print("a1")


class B(A, A1):
    pass  # 什么都不写


b = B()
b.printsth()
b.printa1()

class C:
    def printc(self):
        print("c")
class C1(C):

    def printc1(self):
        print("c1")
class C2(C1):
    pass

c2 = C2()
c2.printc()
c2.printc1()

class Animal:
    def say(self):
        print("")

    def eat(self):
        print("Eat meat")


class Dog(Animal):
    def say(self):
        print("Wangwang")

    def eat(self):
        super().eat() #通过super()调用父类方法
        print("Eat noodle")

class A:
    def foo(self):
        print("A foo")
class B:
    def foo(self):
        print("B foo")
class C(A, B):
    pass
c = C()
c.foo()  # A foo
# 查看类的执行顺序
print(C.__mro__)  # (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

# 1. +的多态性
print(1 + 2)  # 此处表示数学相加
print("hello" + "world")  # 此处表示字符串拼接
# 2. len函数的多态性
print(len("world"))
print(len([1, 2, 3]))

class E:
    def process(self):
        pass


class E1(E):
    def process(self):
        print("process E1")


class E2(E):
    def process(self):
        print("process E2")


def process(e, x, y):
    print(f"process {x}")
    e.process()
    print(f"process {y}")


e1 = E1()
process(e1, 1, 2)

e2 = E2()
process(e2, 3, 4)

class F:
    foo = "foo"

    @classmethod  # 类方法必须使用该注解申明
    def run(cls):  # 类方法的第一个参数必须时cls
        print(f"run {cls.foo}")

# 调用方式
F.run()  # run foo
f = F()
f.run()  # run foo

class F:
    foo = "foo"

    @classmethod
    def get_foo(cls):
        return cls.foo

    @classmethod
    def set_foo(cls, foo):
        cls.foo = foo

class M:
    @staticmethod  # 静态方法申明方式
    def foo(x, y):
        print(f"process {x} and {y}")

class N(object):
    def __new__(cls, *args, **kwargs):
        print("创建对象前执行")
        return object.__new__(cls)  # 如果不返回，则实例不会初始化，即不能执行__init__方法

    def __init__(self):
        print("初始化对象前执行")


n = N()
"""
运行结果：
创建对象前执行
初始化对象前执行
"""

class DateUtil(object):
    ins = None

    def __new__(cls, *args, **kwargs):
        if cls.ins is None:
            cls.ins = super().__new__(cls)
        return cls.ins

d1 = DateUtil()
d2 = DateUtil()
print(id(d1))
print(id(d2))

class JsonUtil(object):
    instance = None

    @classmethod
    def get_instance(cls):
        if cls.instance is None:
            cls.instance = super().__new__(cls)
        return cls.instance


j1 = JsonUtil.get_instance()
j2 = JsonUtil.get_instance()
print(id(j1))
print(id(j2))

def outer(fn):
    _ins = {}

    def inner():
        if fn not in _ins:
            _ins[fn] = fn()
        return _ins[fn]

    return inner


@outer
class XxxUtil(object):
    pass


xx1 = XxxUtil()
xx2 = XxxUtil()
print(id(xx1))
print(id(xx2))

class A(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, "ins"):
            cls.ins = super().__new__(cls)
        return cls.ins


a1 = A()
a2 = A()
print(id(a1))
print(id(a2))

class B(object):
    def __call__(self, *args, **kwargs):
        print("这是call方法")


B()()  # 这是call方法

# 相对路径
f1 = open("Test.txt", "rb")
try:
    txt = f1.read()
    print(txt.decode("utf-8"))
finally:
    f1.close()

# 绝对路径
f2 = open(r"D:\Foo.txt", "rb")  # windows下用r转义
try:
    content = f2.read()
    print(content.decode("utf-8"))
finally:
    f2.close()

with open("Foo2.txt", encoding="utf-8") as f:
    while True:
        txt = f.readline()
        if not txt:
            break
        print(txt, end="")

with open("Foo2.txt", encoding="utf-8") as f:
    print(f.readlines())  # ['追加一段文字\n', '追加一段文字\n', '追加一段文字\n', '追加一段文字\n', '追加一段文字\n']

# 以二进制覆盖写
f3 = open("Foo.txt", "wb")
try:
    content = """
    这是中文，
    This is English
    """
    f3.write(content.encode(encoding="utf-8"))
finally:
    f3.close()

print("*" * 50)
# 以二进制读出来
f4 = open("Foo.txt", "rb")
try:
    print(f4.read().decode(encoding="utf-8"))
finally:
    f4.close()

f3 = open("Foo.txt", "ab")
try:
    content = "追加一段文字\n"
    f3.write(content.encode(encoding="utf-8"))
finally:
    f3.close()

with open("Foo.txt", "rb") as f5:
    print(f5.read().decode(encoding="utf-8"))

# 查看f5的关闭状态
print(f5.closed)  # True

with open("Foo.txt", "rb") as f:
    print(f.read(12).decode(encoding="utf-8"))  # 注意这里一个汉字4字节
    print(f.tell())  # tell方法返回当前指针所在位置 12

    f.seek(0, 0)  # 第一个0是偏移量，第二个0是指针指向的开始位置
    print(f.tell())  # 0

class CopyFile:
    @staticmethod
    def copy(filepath):
        index = filepath.rfind(".")
        new_file_path = None
        if index == -1:
            new_file_path = filepath + "(备份)"
        else:
            new_file_path = filepath[:index] + "(备份)" + filepath[index:]
        print(new_file_path)
        f1 = open(filepath, "rb")
        f2 = open(new_file_path, "wb")
        try:
            while True:
                content = f1.read(1024)
                if len(content) == 0:
                    break
                f2.write(content)
        finally:
            f1.close()
            f2.close()

import os

# 文件（夹）重命名
os.rename("Foo2.txt", "Foo2.txt")
# 创建文件夹
os.mkdir("D:/wilia")  # 只能创建一层
# 删除文件
os.remove("D:/wilia")
# 获取当前目录
print(os.getcwd())
# 改变默认路径
os.chdir("../")
# 获取目录列表
print(os.listdir())

from collections.abc import Iterable

print(isinstance([1, 2], Iterable))  # True

list = [1, 4, 5, 2]
it = iter(list)
print(it.__next__())
print(next(it))  # next()方法内部调用了__next__方法

from collections.abc import Iterable, Iterator

class Person:
    def __iter__(self):
        self.n = 1
        return self

    def __next__(self):
        self.n += 1
        return self.n


print(isinstance(Person(), Iterator))  # True

"""
D:/Foo.txt中的内容如下：
Hello world
Hello Python
你好中国
你好
Hello u
hello mimi
"""
def search(filepath, word):
    with open(filepath, encoding="utf-8") as f:
        for item in f:
            if word in item:
                yield item


t = search("D:/Foo.txt", "Hello")
print(next(t), end="")
print(next(t), end="")
print(next(t), end="")
# print(next(t), end="")  # 读结束时，报异常StopIteration

# 列表推导式
list1 = [i * 2 for i in range(3)]
print(list1)  # [0, 2, 4]

# 创建生成器表达式
list2 = (i * 2 for i in range(3))
print(next(list2))
print(next(list2))
print(next(list2))

import time
def sum1():
    s1 = time.time()
    print(sum([i for i in range(10000000)]))
    print(f"sum1执行时间: {time.time() - s1}")  # sum1执行时间: 0.40175843238830566


def sum2():
    s1 = time.time()
    print(sum((i for i in range(10000000))))
    print(f"sum2执行时间: {time.time() - s1}")  # sum2执行时间: 0.3052406311035156


sum1()
sum2()

tasklist
# 然后ctl+shift+F搜索

from multiprocessing import Process
list1 = []
def listadd():
    for i in range(10):
        list1.append(i)
    print(list1)
def listprint():
    print(list1)
if __name__ == "__main__":
    p1 = Process(target=listadd)
    p2 = Process(target=listprint)
    p1.start()
    p1.join()
    p2.start()
"""
运行结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[]
"""

from queue import Queue

q = Queue(3)  # 队列：先进先出
q.put("消息1")  # put用来往队列放数据
q.put("消息2")
print(q.full())  # full判断队列是否满了
q.put("消息3")
print(q.full())

print(q.get())  # get用来取出队列中的数据
print(q.get())
print(q.get())
print(q.empty())  # empty判断队列是否为空
print(q.qsize())  # qsize 返回队列当前大小

from multiprocessing import Process, Queue
def write(queue, list):
    for i in list:
        if not queue.full():
            queue.put(i)
        else:
            raise Exception("队列已满")


def read(queue):
    while not queue.empty():
        print(queue.get())


if __name__ == "__main__":
    queue = Queue(100)
    li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
    p1 = Process(target=write, args=(queue, li))
    p2 = Process(target=read, args=(queue,))
    p1.start()
    p1.join()  # 如果这里不等待p1执行完毕，有时候p2先执行会读不到数据
    p2.start()

from multiprocessing import Manager

queue = Manager().Queue()

# 下载greenlet包
pip install greenlet

from greenlet import greenlet
def process():
    print(f"save user")
    # 切换到g2协程中执行process2
    g2.switch("pdf", "word")
    print(f"save order")
def process2(a, b):
    print(f"read {a}")
    print(f"read {b}")
    # 执行完process2后继续切回g1执行process
    g1.switch()
g1 = greenlet(process)
g2 = greenlet(process2)
# 先执行g1
g1.switch()

# 下载gevent包
pip3 install gevent

import gevent
def funa(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # sleep用来模拟一个耗时操作，注意要用gevent的sleep
        gevent.sleep(1)


g3 = gevent.spawn(funa, 2)
g4 = gevent.spawn(funa, 2)
g5 = gevent.spawn(funa, 2)
# 启动协程
g3.join()

def patch_all(socket=True, dns=True, time=True, select=True, thread=True, os=True, ssl=True,
              subprocess=True, sys=False, aggressive=True, Event=True,
              builtins=True, signal=True,
              queue=True, contextvars=True,
              **kwargs):
    pass

import gevent, time
from gevent import monkey
monkey.patch_all()

def funa(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # 因为前面申明了monkey.patch_all()，所以这里的time.sleep方法被自动替换成了gevent下非阻塞的同名实现函数
        time.sleep(1)

g3 = gevent.spawn(funa, 2)
g4 = gevent.spawn(funa, 2)
g5 = gevent.spawn(funa, 2)

g3.join()

import code04_logging

logger = code04_logging.logger
logger.info("这里能不能打日志")