class Foreach:
    def __init__(self,start,end):
        self.start = start
        self.end = end
    def __iter__(self):#返回迭代对象
        return self
    def __next__(self):#返回当前值并更新当前值
        if self.start >= self.end:
            raise StopIteration
        else:
            self.start+=1
            return self.start-1
for i in Foreach(1,6):
    print(i)

# 创建生成器
g=(i for i in range(1,11) if i%2==0)
print(g)
# <generator object <genexpr> at 0x000001DFD0750380>
# 获取数据
print(next(g))#2
for target in g:
    print(target)#4 6 8 10

#定义函数，存储到生成器中并返回
def g():
    for i in range(2,11,2):
        yield i
g=g()
print(g)
print(next(g))
for target in g:
    print(target)

# @property 修饰 获取值的函数
# 获取值的函数名.setter 修饰设置值的函数
# .函数名 当属性名来使用
class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age
    @property
    def get_age(self):
        return self.__age
# 装饰名与函数要一致
    @get_age.setter
    def get_age(self, age):
        self.__age = age
if __name__ == "__main__":
    p=Person('john', 18)
    p.get_age=20
    print(p.get_age)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age
    def get_age(self):
        return self.__age
    def set_age(self, age):
        self.__age = age
    age = property(get_age, set_age)
if __name__ == "__main__":
    p=Person('john', 18)
    p.age=10
    print(p.age)

"""
match默认从前往后匹配，匹配则返回
search是分段找，存在段匹配则返回
compile('正则表达式').sub(替换后的内容，要被替换的字符串)
常用规则
. 代表任意一个字符（\n除外）
\. 取消.的特殊含义，就是一个普通的.
[abc] 代表abc中任意一个字符
[^abc] 代表出了abc外任意的一个字符
\d 代表数字，等价于[0-9]
\D 代表非数字 等价于[^0-9]
* 数量词任意多个字符
+ 匹配前一个字符多次
? 匹配前一个字符0或1次
{m} 匹配前一个字符出现m次
{m,n} 匹配前一个字符出现从m到n次
\s 匹配空白，即空格，tab键
\S 匹配非空白
\w 匹配非特殊字符，如a-z,A-Z,0-9、_、汉字
\W 匹配特殊字符
^ 匹配字符串开头
$ 匹配字符串结尾
| 匹配左右任意一个表达式
(ab)将括号中字符作为一个分组
\num 引用分组num匹配到字符串
(?P<分组名>)设置分组
(?P=分组名)
"""
# \num的使用
res=re.match('<([a-zA-Z]{1,4})>.*</\1>'，html)#匹配标签

# 导入
import re
# 校验
res=re.match('校验规则','被校验字符串')
# 获取数据
info=res.group()

#导入socket模块
import socket
# socket(AddressFamily,Type)
"""
上述创建一个socket对象
参数AddressFamily（地址族）默认选择AF_INET(ipv4），AF_INT6（ipv6）用于进程间通信，
Type表示套接字类型（默认SOCK_STREAM，用于TCP协议；SOCK_DGRAM用于UDP）
"""
#创建Socket对象
socket_obj=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

import socket
# 服务端
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定数据
s.bind(('127.0.0.1', 9092))
# 设置监听数目
s.listen(5)
# 监听等待连接
conn, addr = s.accept()
#发送消息
conn.send(b'Hello, world!')#对英文字符转二进制
#接收信息
data=conn.recv(1024).decode('utf8')
print(data)
#关闭连接
conn.close()

import socket
# 客户端
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定数据
s.connect(('127.0.0.1', 9092))
#发送消息
s.send('你好'.encode('utf-8'))
#接收信息
data=s.recv(1024).decode('utf8')
print(data)
#关闭连接
s.close()

import socket
# 服务端
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定数据
s.bind(('127.0.0.1', 9092))
# 设置监听数目
s.listen(5)
# 监听等待连接
while True:
    try:#防止存在连接错误
        conn, addr = s.accept()
        conn.senda(b'Hello, world!')
        data=conn.recv(1024).decode('utf8')
        print(data)
        conn.close()
    except:
        pass

s1='你好22hello!'
# 编码
s1.encode('utf-8')
s2=s1.encode('gbk')
# 解码
s2.decode('gbk')

import socket
# 客户端
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定数据
s.connect(('127.0.0.1', 9092))
#发送消息
with open('./data/text.txt', 'rb') as f:
    while True:
        byes = f.read(8192)
        if len(byes) ==0:
            break
        s.send(byes)
# 发送完毕后主动关闭连接
s.shutdown(socket.SHUT_WR)
data=s.recv(1024).decode('utf8')
print(data)
#关闭连接
s.close()

import socket
# 服务端
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定数据
s.bind(('127.0.0.1', 9092))
# 设置监听数目
s.listen(5)
count=0
while True:
    count+=1
    # 监听等待连接
    conn, addr = s.accept()
    try:
        # 关联目的地文件
        with open('./data/'+str(count)+'.txt', 'wb') as dest_f:
        #接收信息
            while True:
                byes=conn.recv(8192)
                # 无数据时说明客户端已断开连接
                if len(byes)==0:
                    break
                dest_f.write(byes)
        print('文件接收成功')
        conn.send('文件上传成功'.encode('utf-8'))
        conn.close()
    except:
         conn.send('文件上传失败'.encode('utf-8'))
         break

# 创建多进程
# 导入进程工具包
import multiprocessing as mp
# 创建实例化对象
m=mp.Process()
# 启动进程
m.start()

# 创建多进程
# 导入进程工具包
import multiprocessing as mp
import time
def reading(name):
    for i in range(1,11):
        time.sleep(0.1)
        print(f'reading {name} in {i}')
def writing(name):
    for i in range(1,11):
        time.sleep(0.1)
        print(f'writing {name} in {i}')
if __name__ == '__main__':
    r=mp.Process(target=reading,args=('book',))
    w=mp.Process(target=writing,args=('title',))
    r.start()
    w.start()
"""
writing title in 1
reading book in 2
writing title in 2
reading book in 3
writing title in 3
reading book in 4
writing title in 4
reading book in 5
writing title in 5
reading book in 6
writing title in 6
reading book in 7
writing title in 7
reading book in 8
writing title in 8
reading book in 9
writing title in 9
reading book in 10
writing title in 10
"""

# 获取当前进程编号 os.getpid()或者mp.current_process().pid
# 获取当前父进程编号os.getppid()
import multiprocessing as mp
import os
import time
def reading(name):
    for i in range(1,11):
        time.sleep(0.1)
        print(f'reading {name} in {i}')
    print(os.getpid(),mp.current_process().pid,os.getppid())
def writing(name):
    for i in range(1,11):
        time.sleep(0.1)
        print(f'writing {name} in {i}')
    print(os.getpid(), mp.current_process().pid, os.getppid())
if __name__ == '__main__':
    r=mp.Process(target=reading,args=('book',))
    w=mp.Process(target=writing,args=('title',))
    r.start()
    w.start()
    r.join()
    w.join()
    print(os.getpid(), mp.current_process().pid, os.getppid())
# 90776 90776 97956
# 92172 92172 97956
# 97956 97956 88604

# 守护进程
进程名.daemon=True
# 主动关闭
进程名.terminate()

import threading as tp
# 创建实例化对象
t=tp.Thread()
# 启动进程
t.start()

t=tp.Thread(daemon=True)

# 创建
mutex=threading.Lock()
# 上锁
mutex.acquire()
# 释放
mutex.release()

def fn():
    num=0
    def fn2():
        nonlocal num #引入外部函数变量
        num=num+1
        print(num)
    return fn2
if __name__ == '__main__':
    f=fn()
    f() #1
    f2=fn()
    f() #2
    f2()#1

"""
语法1：
变量名=装饰器名(原有函数名)
变量名()
"""
def add_option(fn):
    def option(txt):
        #增加功能
        print("add option")
        fn(txt)
    return option

def text(txt):
    print(txt)
if __name__ == '__main__':
    txt1 = "Hello World"
    fn_text=add_option(text)
    fn_text(txt1)
# add option
# Hello World

def add_option(fn):
    #增加功能
    def option(txt):
        print("add option")
        fn(txt)
    return option
@add_option
def text(txt):
    print(txt)
if __name__ == '__main__':
    txt1 = "Hello World"
    text(txt1)
# add option
# Hello World

def add_option(fn):
    #增加功能
    def option(*args,**kwargs):
        print("add option")
        return fn(*args,**kwargs)
    return option

def add_option(fn):
    #增加功能
    def option(*args, **kwargs):
        print("add option")
        return fn(*args, **kwargs)
    return option
def add_option1(fn):
    #增加功能
    def option(*args, **kwargs):
        print("add option1")
        return fn(*args, **kwargs)
    return option

def text(txt):
    print(txt)
    return txt
if __name__ == '__main__':
    txt1 = "Hello World"
    text=add_option(text)
    text=add_option1(text)#最靠近调用函数的先执行
    text(txt1)
"""
add option1
add option
Hello World
"""

def add_option(fn):
    #增加功能
    def option(*args, **kwargs):
        print("add option")
        return fn(*args, **kwargs)
    return option
def add_option1(fn):
    #增加功能
    def option(*args, **kwargs):
        print("add option1")
        return fn(*args, **kwargs)
    return option

@add_option
@add_option1
def text(txt):
    print(txt)
    return txt
if __name__ == '__main__':
    txt1 = "Hello World"
    text(txt1)
"""
add option
add option1
Hello World
"""

def choice(flag):
    def add_option(fn):
        # 增加功能
        def option(*args, **kwargs):
            if flag==1:#判断
                print("txt1")
            elif flag==2:
                print("txt2")
            #返回装饰后函数
            return fn(*args, **kwargs)
        #返回内部函数
        return option
    #返回装饰器
    return add_option
@choice(1)
def text(txt):
    print(txt)
    return txt
@choice(2)
def text2(txt):
    print(txt+'2')
    return txt
if __name__ == '__main__':
    txt1 = "Hello World"
    text(txt1)
    text2(txt1)
"""
txt1
Hello World
txt2
Hello World2
"""

def add_option(fn):
    #增加功能
    def option(*args, **kwargs):
        if fn.__name__ == "text":  # 判断
            print("txt1")
        elif fn.__name__ == "text2":
            print("txt2")
        return fn(*args, **kwargs)
    return option
@add_option
def text(txt):
    print(txt)
    return txt
@add_option
def text2(txt):
    print(txt+'2')
    return txt
if __name__ == '__main__':
    txt1 = "Hello World"
    text(txt1)
    text2(txt1)
"""
txt1
Hello World
txt2
Hello World2
"""

class Person:
    def sex(self):
        pass
class Man(Person):#继承
    def __init__(self):
        self.name = 'Man'
    def sex(self):#函数重写
        return self.name
class Woman(Person):
    def __init__(self):
        self.name = 'WoMan'
    def sex(self):
        return self.name
def get_sex(m):#接收不同对象实现不同效果，等同m:Person,但py的弱类型语言，传递非Person类的参数时只会警告
    return  m.sex()
if __name__ == '__main__':
    m1 = Man() #m1:Person=Man() 父类引用指向子类对象
    m2 = Woman()
    print(get_sex(m1))
    print(get_sex(m2))

#私有属性
__属性名
#私有方法
def __方法名():
    ...

class Man:
    def __init__(self,money):
        self.leg=2
        self.eyes=2
        self.__money=money
    def consumption(self,money):
        self.__money+=money
        print(self.__money)
    def get_money(self):
        return self.__money
class Children(Man):
    pass
if __name__=="__main__":
    c1=Children(100)
    # print(c1.__money) 报错
    print(c1.get_money()) # 100

class Parent:
    def __init__(self,money):
        self.money=money
    def consumption(self,money):
        self.money-=money
        print(self.money)
class Children(Parent):
    pass
if __name__=="__main__":
    c1=Children(100)
    c1.consumption(100) #0

class Parent:
    def __init__(self,money):
        self.money=money
    def consumption(self,money):
        self.money-=money
        print(self.money)
class Man:
    def __init__(self):
        self.leg=2
        self.eyes=2
class Children(Parent,Man):
    def __init__(self,money):#初始化所有父类
        Parent.__init__(self, money)
        Man.__init__(self)
if __name__=="__main__":
    c1=Children(100)
    c1.consumption(100)
    print(Children.mro())
    print(c1.eyes)
"""
0
[<class '__main__.Children'>, <class '__main__.Parent'>, <class '__main__.Man'>, <class 'object'>]
2
"""

class Parent:
    def __init__(self,money):
        self.money=money
    def consumption(self,money):
        self.money-=money
        print(self.money)
class Man:
    def __init__(self):
        self.leg=2
        self.eyes=2
class Children(Parent,Man):
    def __init__(self,money):
        Parent.__init__(self, money)
        Man.__init__(self)
        self.leg=1
if __name__=="__main__":
    c1=Children(100)
    c1.consumption(100)
    print(c1.leg,c1.eyes) #优先使用自身属性
# 0
# 1 2

class Parent:
    def __init__(self,money):
        self.money=money
    def consumption(self,money):
        self.money-=money
        print(self.money)
class Man:
    def __init__(self,money):
        self.leg=2
        self.eyes=2
        self.money=money
    def consumption(self,money):
        self.money+=money
        print(self.money)
class Children(Parent,Man):
    def __init__(self,money):
        Parent.__init__(self, money)
        Man.__init__(self, money)
        self.leg=1
    def man_consumption(self,money):
        Man.consumption(self,money)
if __name__=="__main__":
    c1=Children(100)
    c1.man_consumption(100)#200

class Person:
    pass
p1=Person()
p1.name="Jack"
p1.sex='male'
print(p1.__dict__) #特殊属性，字典形式存储对象属性
# {'name': 'Jack', 'sex': 'male'}

class Person:
    def __init__(self,name,sex):
        self.name=name
        self.sex=sex
p1=Person('Jack','male')

class Person:
    def __init__(self,name,sex):
        self.name=name
        self.sex=sex
    def work(self):
        print(f'{self.name} are working')
    def relax(self):
        print(f'{self.name} are relaxed')
p1=Person('Jack','male')
p1.work()
p1.relax()

#初始化方法
__init__
#字符串表示的方法,即定义该方法并存在返回值时，将该对象转为该返回值
__str__
#比较两个对象是否相等，判断两个实例对象是否相等时，调用该方法
__eq__
#支持比较对象的大小（小于、小于等于、大于、大于等于），同上理
__lt__、__le__、__gt__、__ge__
#删除对象时调用，或py执行文件结束
__del__

class Person:
    leg=2
    def __init__(self,name,sex):
        self.name=name #实例属性
        self.sex=sex
        if name=='Jack':
            self.leg=1
    def work(self):
        print(f'{self.name} are working')
    def relax(self):
        print(f'{self.name} are relaxed')
p1=Person('Jack','male')
p2=Person('Mary','male')
print(p1.leg,p2.leg) #1,2

class Person:
    water=False
    @classmethod
    def drink(cls):
        cls.water=True
    @staticmethod
    def talk():
        print('I am Person')
    def run(self):
        pass
if __name__ == '__main__':
    P1 = Person()
    P1.drink()
    print(P1.water)
    print(Person.water)
    """
    True
    True
    """

# 语法
try：
    ...#可能会异常的代码
except [异常类型 as 变量名]:#选写，不写的话默认捕获所有异常，写的话就匹配异常
    ...#异常处理代码
[finally:
    ...]#不管是否有异常，都会执行的代码

def fn(...arg):
    ....
    return ...
fn(arg)

def fn(List):
    """
    :param List:传入需要去重排序的列表
    ：return L:处理后的列表
    """
    L=[*{*List}]
    L.sort()
    return L
List=fn([1,1,5,3,3,5,6,22,6])
help(fn)# 查看函数说明文档
print(List)

def fn_a(List1,List2):
    """
    :param List1: 待合并数组1
    :param List2: 待合并数组2
    :return: 处理后列表
    """
    return fn_b([*List1,*List2])

def fn_b(List):
    """
    :param List: 待去重列表
    :return: 处理后列表
    """
    return fn_c([*{*List}])

def fn_c(List):
    """
    :param List: 待排序列表
    :return: 处理后列表
    """
    L=List
    L.sort()
    return L
res=fn_a([1,2,3,4,5,6,7,8,9],[19,33,42,1,3,4])
print(res)

num=1
def fn():
    num=10
    print(num) 
fn() #10
print(num)#1

# use global
num=1
def fn():
    global num
    num=10
    print(num) 
fn() #10
print(num)#10

def fn(a=1):
    print(a)
fn()#1
fn(10)#10

def fn(*args):
    print(*args)#解包
fn(1,2,3,4,5)
#1,2,3,4,5

def fn(*args,**kwargs):
    print(*args)#解包
    if kwargs.get('a'):
        print(kwargs['a'])
fn(1,2,3,4,5,a=6)
#1,2,3,4,5
#6

def fn(x,y,oper):
    return oper([x,y])
print(fn(1,2,sum))
#3

"""
语法：lambda 参数列表：函数体
"""
fn=lambda x,y:x+y
fn(1,2)#3

def fn(L):
    """
    可将列表内元素根据字符长度排序
    :param L:待排序列表
    :return:处理后列表
    """
    L.sort(key=lambda item:len(item))
    return L
res=fn(['cs','s','uiwhe','qwh'])
print(res)
# ['s', 'cs', 'qwh', 'uiwhe']

num:int=9
str_list:list[str]=list('abc')
dict_s_i:dict[str,int]=dict({'abc':1})
print(dict_s_i)
print(str_list)
# {'abc': 1}
# ['a', 'b', 'c']

def fn(l:list[str])->list[str]:
    """
    可将列表内元素根据字符长度排序
    :param L:待排序列表
    :return:处理后列表
    """
    l.sort(key=lambda item:len(item))
    return l
res=fn(['cs','s','uiwhe','qwh'])
print(res)

import 模块名
import 模块名 as 别名
from 模块名 import 功能名
from 模块名 import 功能名 as 别名
from 模块名 import *

if __name__=='__main__':
    # 测试代码
    ...

from 模块名 import *#中的*导入了模块内__all__指定的功能，如无定义时则默认为所有功能,相当于导出功能

import 包名.模块名
from 包名 import 模块名
from 包名 import *#这个必须要在__init__.py中设置__all__变量指定导入的模块名，否则无法导入
from 包名.模块名 import 功能名
from 包名.模块名 import *

#__init__.py
__version__='v1.0.0'
__author__='YX'
__all__=[...]

admin_name='admin'
admin_password='123456'
while True:
    username = input("Enter your username: ")
    password = input("Enter your password: ")
    if username == admin_name and password == admin_password:
        print("Login Successful")
        break
    elif username == admin_name and password != admin_password:
        print("Wrong Password")
    else:
        print("Wrong Username")

while True:
    class_id = input('Please enter your class ID: ')
    match class_id:
        case "101":
            print('Class ID: 101')
            break
        case "102":
            print('Class ID: 102')
            break
        case "103":
            print('Class ID: 103')
            break
        case _: #other match
            print('Class ID Not Found')

flag=True
while flag:
    class_id = input('Please enter your class ID: ')
    match class_id:
        case "101":
            print('Class ID: 101')
            flag -= 1
        case "102":
            print('Class ID: 102')
            flag -= 1
        case "103":
            print('Class ID: 103')
            flag -= 1
        case _: #other match
            print('Class ID Not Found')
else:
    print('Found Class ID')

class_room=[]
class_num=101
for i in range(3):
    class_room.append(class_num)
    class_num+=1
class_id=input("Enter Class ID")
for i in class_room:
    if i==int(class_id):
        print("Class ID",class_id)
        break
    elif i==class_room[len(class_room)-1]:
        print("Class ID Not Found")
else:
    print('End')

data_arr=[]
data=input('Please enter the number of rows: ')
now_data=''
for i in data:
    if i!=',':
        now_data+=i
    else:
        data_arr.append(int(now_data))
        now_data=''
else:
    if now_data:
        data_arr.append(int(now_data))
    for i in range(len(data_arr)):
        for j in range(len(data_arr)-1-i):
            if data_arr[j]>data_arr[j+1]:
                data_arr[j],data_arr[j+1]=data_arr[j+1],data_arr[j]
print(data_arr)

list_type=[1,2,3,2]
del list_type[0]
list_type.append(3)
print(list_type)

list_type=[1,2,3,2,873,2,10,1,2,46,2,56]
print(list_type[2:9:2])# [3, 873, 10, 2]

data_arr=[]
data=input('Please enter the number of rows: ')
now_data=''
for i in data:
    if i!=',':
        now_data+=i
    elif now_data:
        data_arr.append(int(now_data))
        now_data=''
else:
    if now_data:
        data_arr.append(int(now_data))
    data_arr.sort()
    print(data_arr[0],data_arr[-1],sum(data_arr)/len(data_arr))

list1=[0,1,12,34,5]
list2=[1,2,3,4,5]
list1=[*list1,*list2]# 解组包操作
list3=[]
for i in list1:
   if i not in list3:
       list3.append(i)
list3.sort()
print(list3)

t0=(1,2,5,3,21,78,2)
t1=() #tuple()
t3=(1,) #t3=(1)会被认为多余括号
t0[1] #2
t0.index(2) #1 获取第一个ele的索引
t0.count(2) #2

t0=1,2,3 #t0=(1,2,3)
a,b,c=t0 #a=1,b=2,c=3，数目对应
x,*y=t0 #x=1,y=[2,3],会生成列表

s1={1,2,3}
s2=set()#定义空集合，不可使用s2={},{}是空字典

list1=[0,1,12,34,5]
list2=[1,2,3,4,5]
list1=[*{*list1,*list2}]
list1.sort()
print(list1)

d1={} #d1=dict()
d2={'Jay':100,'John':90,'Bob':97}
d2['Jay'] # 100

d0=dict()
d0['a'],d0['b']=10,20
d0.pop('a')
del d0['b']
d0['c'],d0['d']=30,30
d0['c']=20
print(d0.get('c'),d0.keys(),d0.values(),d0.items())
# 20 dict_keys(['c', 'd']) dict_values([20, 30]) dict_items([('c', 20), ('d', 30)])

num = 1
print(num)# 1
print(f'num:{num}') # print('num:',num)
print(type(num)) # int
print(isinstance(num,int)) # True

str1="str1"
str2='str2'
str3="""
s
t
r
3
"""

str1='It\'s' #单引号
str2="It\"s"
str3='\n' #换行
str4='\t' #增加缩进tab

str='str1'+'str2'
Str='str3'
print('str:'+str+',Str'+Str)

str='str1'+'str2'
Str='str3'
print('str:%s,Str:%s'%(str,Str))
print(f'str:{str},Str:{Str}')

in_put=input('input somthing')
print(in_put)

x=float(input('input x')) #0.5
y=float(input('input y')) #0.4
print(x-y) #0.09999999999999998