a = 10
a.bit_length # 4 有效的二进制长度
#10进制转2进制
bin_a = bin(a) # 0b100
# 2进制转10进制
a_2_10 = int("0b100",2)
# 10进制转8进制
oct_a = oct(a) # 0o12
# 8进制转10进制
a_8_10 = int("0o12",8)
# 10进制转16进制
hex_a = hex(a) #0xa
# 16进制转10进制
a_16_10 = int("0xa",16)

s1 = "asd高兴qqe"
s1.strip("asdqe") # 高兴
s2 = "1 2 3"
s2_list = s2.split() # ["1", "2", "3"]

s3 = "1:2:3"
s3_list = s3.split(":") # ["1", "2", "3"]
s3_str = ":".join(s3_list)  "1:2:3"

s4 = "aaabbbcdefff sdf"
s4.count("a")  # 3

s4.isalnum() # 是否全部由 字母 或数字  组成
s4.isalpha() # 是否全部由 字母 组成
s4.isdecimal() # 是否只由十进制（数字）组成

s4.capitalize() # 首字母大写，其余小写
s4.swapcase()  # 大小写反转
s4.title() # 每个单词首字母大写，空格分隔
s4.center(100,"3") #  center(width,filer) 居中，宽度，填充字符
s4.find("a")  # 找不到返回-1
s4.find("a",1,4) # find(target, start, end)
s4.index("a") # 找不到抛异常

s1 = " "
b_s1 = bool(s1)  # True
s2 = ""
b_s2 = bool(s2) # False

# 强制转化
# False: 0，"",(),[],{},set(),None
# True : 其他

item = list.pop()  #  默认删最后，有返回值
list.remove("aaa")  # 指定元素删除，如果有重名元素，默认删除从左边第一个，无返回值
list.clear() # 全部删除
del list[-1]
del list[0:6:1]
list[2:] = "asdf"  # [x,x,"a","s","d","f"] #迭代修改

list1 = [11,22,33,44,55]
#删除奇数index元素
# 1、del
del list1[1::2]
# 2、 倒序删除
for index in range(len(list1)-1,-1,-1)
	if index % 2 == 1:
        list1.pop(index)
# 3、 新建列表，取奇数
temp = []
for index in range(len(list1)):
    if index %2 ==0:
        temp.append(list1[index])
list1 = temp

a,b = (1,2)  # 元组的拆包  a==1,b==2
a,b = 1,2   

tup = (1,) # 无逗号非元组，type为原数据对应的类型

#创建
d1 = dict((("one",1), ("two",2),("three",3)))
d2 = dict(one=1,two=2,three=3)
d3 = dict({"one":1,"two":2,"three":3})
d4 = dict.fromkeys("abc",100) # {"a":100,"b":100,"c":100}
d4 = dict.fromkeys([1,2,3],100) # {1:100,2:100,3:100}
d5 = dict.fromkeys([1,2,3],[]) # {1:[],2:[],3:[]} # 可变类型值共用同一地址
d5[1] = ["a","b"]   # d5 == {1:["a","b"],2:["a","b"],3:["a","b"]}

d1.setdefault("three",44) # 有则不变，无则增加

#删
ret = dic.pop("one")  # ret = 1  返回的是value ;不存在则会抛异常
ret2 = dic.pop("ten","查无此键") # 不存在则返回备用值
ret3 = dic.popitem()

dic.clear() # 清空
del dic["age"]  # 不存在会抛异常

dic.update(nine=9,ten=10) # 迭代添加或更新 
dic.update(("nine",9),("ten",10))
dic2 = {"eleven":11,"thirteen":13}
dic.update(dic2)

# 查
value = dic.get("key","else")

dic.keys()  #type :  <class "dict_keys"> ,可以强转为list： list(dic.keys())
dic.values()
dic.items() # [("one",1),("two",2),("three",3)] 

# 循环迭代时不能直接改变字典大小
dic = {"k1":1,"k2":2,"k3":3}
for key in dic:  # 或者dic.keys()
    if "k" in key:
        dic.pop(key)    # Exception dictionary changed size during iteration

# 强转为list可正常删除
for key in list(dic.keys()):
    if "k" in key:
        dic.pop(key)   

# 集合是无序的
# 内部元素只能是不可变类型；本身是可变类型；
t = {} # type(t) 为dict
set0 = set()  
set1 = set({1,3,"aaa","bbb"})

set1.add("ccc")
set1.update("asd") #迭代增加，类似于extend {1,3,"aaa","bbb", "a","d","s","ccc"}

set1.remove("aaa")
set1.pop() # 随机删除，不支持制定索引

# 去重
list_1 = [1,1,2,3,4]
unique_list_1 = list(set(list_1))

# 差集、并集、交集
set1 = {1,2,3,4,5}
set2 = {2,3,4,5,6}
set3 = {2,3,4}
set1 & set2 #交集 {2,3,4,5}
set1.intersection(set2)

set1 | set2 # 并集 {1,2,3,4，5,6}
set1.union(set2)

set1 - set2 # 差集 {1}
set1.difference(set2)

set1 ^ set2 # 反交集，异或集  {1,6}
set1.symmetric_difference(set2)

set3 < set2 # set3 是set2子集
set3.issubset(set2)

set2 > set3 # set2是set3 超集
set2.issuperset(set3)

while condition:
	pass
    #break
else:
    print("3")
    
# 1 3
# 当break中断while时，else不执行

for variables in iterable:
    pass
	#break
else:
    pass
# 当break中断for时，else不执行
list = ["a","b","c"]
for i enumerate(list,start=100): # 默认start为0
    print(i)  
#(100,"a")   
#(101,"b") 
#(102,"c")

# %占位符   s -->str   |   d ->int
# %% 转义 %
name = "a"
age = 11
msg = """
name: %s,
age: %s,
job: %s
进度: 1%%  
""" % (name, age, "hunter")

msg = "我叫{}，今年{}岁，性别{}".format("大壮",15,"男")
msg2 = "我叫{0}，今年{1}岁，性别{2},so 我是{0}".format("大壮",15,"男")
msg3 = "我叫{name}，今年{age}岁，性别{sex}".format(name="大壮",age=15,sex="男")

# 3.6特性
# 不能出现 ! , : {} ; 
name = "jack"
school = {"city":"beijing","grade":"2"}
# 支持多种数据类型
msg = f"我是{name}，今年在{school['city']}上学，已经{school['grade']}年级了"
msg2 = f"我的名字大写是{name.upper()}"
# 结合表达式或函数
def _sum(a,b):
    return a+b
msg3 = f"1 +2 = {_sum(1,2)}"

# x or y   x为真，值就是x；x为假，值就是y
# x and y  x为真，值是y；x为假，值是x
print(1 and 2 or 3 and 4)
# 2
print(1>2 and 3 or 6)
# 6

#str -> byte  (unicode -> 非unicode)
str_1 = "中国"
byte_1 = str_1.encode("utf-8")    #编码 b'\xe4\xb8xxxxx' <class "bytes">
str_2 = byte_1.decode("utf-8")    # 解码

# gbk -> utf-8
b_gbk = b"\xerxxxxx"
s = b_gbk.decode("gbk")
b_utf8 = s.encode("utf-8")

i1 =200
i2 = 200
i1 is i2 # True

i1 = 2000
i2 = 2000
i1 is i2  # False

l1 = [1,2,3,["a","b"]]
l2 = l1  
l1 is l2 # 两者对象id相等，对象变化两者皆变

import copy
l2 = l1.copy() # id不等，但是元素id相等，元素的可变类型变化均会变化
l2 = copy.copy(l1) # 浅拷贝另一个写法

l2 = copy.deepcopy(l1) # id不等，元素可变对象id不等，不可变对象沿用之前的；可变元素重新创建一份

f1 = open("xxx",encoding="utf-8", mode="r")  
# encoding 不写默认使用系统编码 
# windows :GBK
# linux/macos : utf-8

# mode  r/w/rb/wb
# r 不存在报错，无法创建新文件
# w 不存在则创建;存在则先清空，后写入
# a  不存在则创建，存在则追加
# r+ 不存在报错，无法创建新文件；根据当前偏移量读取或写入
#
# 读  r /rb/r+/r+b
# 写 w/ wb/w+ /w+b
# 追加 a / ab/ a+ /a+b
content = f1.read() 
f1.readline() # 带换行符
f1.readlines() # list ,元素带换行符
f1.read(5) # 字符

for line in f:  # f 文件句柄为迭代器，适合大文件读取
    print(line)
f.close()

f1.tell() # 返回当前偏移量值,单位为字节
f1.seek(0) #  调整偏移量的值,单位为字节
f1.flush()  # 强制刷新

with open("a.txt") as f1,open("b.txt", "w") as f2:
    content = f1.read()
    f2.write(content)

def func(age,name="jack", *args, **kwargs): # 位置参数，默认参数，可变参数(元组)，关键字参数(字典)
#    return 1,2,3  # 返回多个值时以元组方式返回
	return "我喜欢%s、 %s 、%s" % args   

#必选参数–>可变参数–>默认参数–>命名关键字参数–>关键字参数
#默认参数也可以在可变参数之前，谁在前谁优先拿到值；
def foo(x,y=1,*args):
     pass
foo (1,2,3,4,5) // 其中的x为1，y=1的值被2替换，3,4,5都给args，即args=(3,4,5)

def foo(x,*args,y=1):  # y:命名关键字参数 （仅限关键字）
    print(x,args,y)
foo(1, 2, 3, 4, 5) # 其中的x为1，2, 3, 4, 5都给args，即args = (2, 3, 4, 5), y始终为1
#1 (2, 3, 4, 5) 1
foo(1, 2, 3, 4, y=5) # 其中的x为1，2, 3, 4都给args，即args = (2, 3, 4), y为5
#1 (2, 3, 4) 5


a,*b = (1,2,3,4,5,6,7) #或 [1,2,3,4,5,6,7]
# a= 1   b = [2,3,4,5,6,7]  列表
a,*b, c =  (1,2,3,4,5,6,7) #或 [1,2,3,4,5,6,7]
# a=1 b = [2,3,4,5,6] c=7

func([1,2,3],[5,6,7])  # ([1,2,3],[5,6,7])   {}
func(*[1,2,3],*[5,6,7])  # (1,2,3,5,6,7)    {}
func({"name":1},{"age":2}) #({'name': 1}, {'age': 2})   {}
func(**{"name":1}, **{"age":2}) # () {'name': 1, 'age': 2}

count = 1
def func():
    count += 2
    print(count)
func()
# Exception:UnboundLocalError: local variable 'count' referenced before assignment
# 局部作用于无法改变全局作用域的变量；
# 当python解释器读取到局部作用域时，发现对一个变量进行修改的操作时，会认为在局部已经定义过这个局部变量了，但是在局部中无法找到该变量就报错

def func():
    count = 1
    def inner():
        print(count)  # 可以读取使用
        count += 1    # 无法改变，改变抛异常，异常原因同上
    inner()
func()

list_1 = [33,2,5,51,7,-4,-9]
filter(lambda x:x>3, list_1)  # 返回迭代器 ,可通过list转换

map(lambda x:x**2 ,list_1)   # 返回迭代器  ,可通过list转换

from functools import reduce  # python3
reduce(lambda x,y: x+y, list_1 ) # 返回迭代器,可通过list转换

list_1 = [("a",11),("b",2),("c",1)]
sorted(list_1,key=lambda x: x[1]) # [("c",1), ("b",2),("a",11)]
sorted(list_1,key=lambda x: x[1] ,reverse=True) # 降序

list_1 = [33,2,5,51,7,-4,-9]
min(list_1,key=abs)  # 按绝对值取最小
min(list_1,key=lambda x: (x % 10)+1)  # 模10的余数 取最小

dic = {"a":3, "b":2, "c":1}
min(dic, key= lambda x: dic[x]) # 字典的值取最小的键   return   c

list_1 = [("a",11),("b",2),("c",1)]
min(list_1)  # ("a",11)  
min(list_1,key=lambda x: x[1])  #("c",1)

list_1 = ["a","b","c", "d"]
tuple_2 = (1,2,3)
str_3 = "qwe"
obj = zip(list_1, tuple_2, str_3)  # zip object
list(obj)  #  [("a",1,"q"), ("b",2,"w"), ("c",3,"e")]

list_1 = [1,2,3]
new_obj = reversed(list_1)   # new_obj 是个迭代器 generator
print(list(new_obj))  # [3,2,1]

list_1 = [1,2,3]
sum(list_1, 100)  # 106

def print(self, *args, sep=" ", end="\n", file=None)
# sep 多个值之间的分隔符
# end 每一次直接的结尾自动添加（默认为换行符）

ord("a") # 97  ASCII
ord("中")  # 20013 unicode

chr(97)
chr(20013)

s1 = "不错"
b1 = s1.encode("utf-8")   # b'\xe4\xb8\x8d\xe9\x94\x99'
b2 = bytes(s1,encoding="utf-8") #b'\xe4\xb8\x8d\xe9\x94\x99'
b1 == b2  # True   

pow(2,3)  # 2**3 == 8
pow(2,3,4) # 2**3   % 4

round(3.1415)  # 3
round(3.1415926,2)  # 3.14

divmod(10,3)  # (3,1)  商3余1

a = 10
bin_a = bin(a) # 0b100
# 2进制转10进制
a_2_10 = int("0b100",2)
# 10进制转8进制
oct_a = oct(a) # 0o12
# 8进制转10进制
a_8_10 = int("0o12",8)
# 10进制转16进制
hex_a = hex(a) #0xa
# 16进制转10进制
a_16_10 = int("0xa",16)

def wrapper():
    count = 1
    def inner():
        nonlocal count
        count += 1
    print(count)   # 1
    inner()
    print(count)   # 2
wrapper()

iterator = iter(obj) # 可迭代对象转化为迭代器   ,obj.______iter______()
item1 = next(iterator)  # iterator.______next______()
item2 = next(iterator)
throw StopIteration Exception

def func():
    list_1 = [1,2,3]
    list_2 = [6,7,8]
    yield list_1   #list [1,2,3]
    yield from list_1 # 1,2,3 转化为迭代器
    yield from list_2 # 6,7,8
ret = func()
while 1:
    print(next(ret))
# [1, 2, 3]
# 1
# 2
# 3
# 6
# 7
# 8
# StopIteration Exception

list_1 = [i for i in range(1,11)]
list_2 = [item for iter2 in fisrt_iter for item in iter2 if item.count("e") == 2]

list1 = ["a","b","c"]
list2 = [1,2,3]
dic = {list1[i]:list2[i] for i in range(len(list1))}

lst = [1,2,3,-1,-3,9]
s = {abs(i) for i in lst}

def wrapper(a,b):
    def inner():
        print(a,b)
    return inner
ret = wrapper(1,2)
print(ret.__code__.co_freevars)  # 打印函数中的自由变量

def wrapper(func):
    def inner(*args, **kwargs):
        ret = func(*args, **kwargs)
        return ret
    return inner
@wrapper
functions(a,b,c)

# 带参数的装饰器
def out(*args1, **kwargs1):
  def wrapper(func):
    def inner(*args2, **kwargs2):
        ret = func(*args2, **kwargs2)
        return ret
    return inner
  return wrapper

@out(args1=1,args2=2)
function(a,b,c)

# 时间戳  <=> 时间对象  <=> 字符串

time.time()  # 时间戳，从时间元年到现在经过的秒数   1970.1.1 0:0:0    java是毫秒数

# class time.struct_time   结构化时间对象  named tuple  
# time.struct_time(tm_year=2020, tm_mon=10, tm_mday=4, tm_hour=1, tm_min=16, tm_sec=6, tm_wday=6, tm_yday=278, tm_isdst=0)  tm_wday 0~6

# 时间戳 -> 结构化时间对象
time.gmtime() # 当前格林尼治时间的结构化时间对象，
time.localtime() # 当地时间的结构化时间对象 +8
time.localtime(timestamp) # 入参时间戳

# 结构化时间对象  -> 时间戳
time.mktime(time.localtime()) 

# 结构化时间对象  -> 字符串
time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # 将时间对象转化为str，第二个参数为结构化时间对象
# 2020-10-04 10:27:15
"""
    %Y  Year with century as a decimal number.
    %y Year without century as a decimal number [00,99]. 
    %m  Month as a decimal number [01,12].
    %d  Day of the month as a decimal number [01,31].
    %H  Hour (24-hour clock) as a decimal number [00,23].
    %M  Minute as a decimal number [00,59].
    %S  Second as a decimal number [00,61].
    %z  Time zone offset from UTC.
"""
# 字符串  转为  结构化时间对象
time.strptime("2020 10 10", "%Y %m %d")  # 将str转化为 结构化时间对象
# time.struct_time(tm_year=2020, tm_mon=10, tm_mday=10, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=284, tm_isdst=-1)

from datetime import date, time, datetime, timedelta
#date  年月日
d = datetime.date(2020,10,11)  # 2020-10-11  <class 'datetime.date'>
d.year # 2020
d.month # 10
d.day # 11

#time  时分秒
t = datetime.time(11,12,13) # 11:12:13   <class 'datetime.time'>
t.hour # 11
t.minute # 12
t.second # 13

# datetime
dt = datetime.datetime(2020,10,11,12,13,14) # 2020-10-11 12:13:14  <class 'datetime.datetime'>

# timedelta
# 可以与 date,datetime,timedelta运算，  不能与time运算

td = datetime.timedelta(days=1) # <class 'datetime.timedelta'>
res = datetime.date(2020,10,1) - datetime.timedelta(days=1) # 2020-09-30 <class 'datetime.date'>
res2 = datetime.datetime(2020,10,1,8,59,59) + datetime.timedelta(seconds=3)  #2020-10-01 09:00:02  <class 'datetime.datetime'>

random.random() # [0.0,1.0) 范围内的浮点数
random.randint(a,b) #[a,b]  范围内的整数
random.uniform(a,b) # [a,b)范围内的浮点数
random.shuffle(x)  # 乱序排列 ，x必须是个可变类型
random.sample(x,k) # 从x中随机抽取k个数据（不重复），返回一个列表
random.choice(seq) # 从seq随机选一个
random.choices(seq,k=n) #从seq随机选k个（可重复），返回一个列表

shutil.copy2(src_file,dst_file) # 拷贝文件
shutil.copytree(src_path, dst_path,
                ignore=shutil.ignore_patterns("*.mp3"))  #拷贝目录（忽略部分）
shutil.rmtree(src_path ignore_errors=True) # 删除目录（可删除非空目录）！不进回收站
shutil.move(src_file, dst_file, copy_function=shutil.copy2) # 移动文件/目录（剪切）
total, used, free = shutil.disk_usage(".") # 查看磁盘空间
shutil.mack_archive("out_z","zip",src_path) # 压缩 将src_path压缩为 out_z.zip
shutil.unpack_archive(src_file, dst_path) # 解压到某路径，默认为当前路径

# 操作系统相关
# 1、文件操作相关
os.remove(filepath) # 删除文件，程序删除不进回收站
os.removedirs(path) # 删除文件夹，程序删除不进回收站  （必须是空目录）
import shutil
shutil.rmtree(path)  #删除目录

os.rename(src, dst)  # 将src改名为dst

# 2、路径相关
__file__  # 当前文件的绝对路径
os.path.dirname(__file__)  # 获取当前文件的父路径，不判断路径是否存在
os.path.basename(__file__) # 获取当前文件的文件名
os.path.split(path) # 将path的路径名和文件名切分，返回一个2元素元组  (路径名, 文件名)
os.path.join("d:\\","aaa","bbb")  # d:\aaa\bbb

os.path.isabs("a.txt")  # False 判断是否是绝对路径
os.path.isdir("E:\\work")  # True 判断路径是否存在，同时判断是否是路径
os.path.exists("E:\\work\\python.exe")  # True 判断文件是否存在，同时判断是否是文件

os.getpid()   #当前进程pid
os.getppid()  # 当前进程父进程pid

# 解释器相关
sys.argv  # list， 第0个元素为当前执行文件的绝对路径， 其他为字符串类型的执行参数   ['E:/work/workspace/daily-work/test_pytest.py', "1", "a"]

# 解释器寻包路径： 内存-> 内置 -> sys.path
sys.path.append(os.path.dirname(__file__)+"/temp")# return list sys.path[0]为当前文件的路径

# 特点：部分python类型不支持；无法直接一次读写多个数据；跨语言通用

# 序列化： 从内存数据类型转化为 字符串，用于网络传输
# 反序列化:从 字符串 转化为内存数据类型
# json序列化  
#	列表，元组 ->列表(数组)   (反序列化时转为列表，无法还原为元组) ; 
#   set 不支持转化；
#   True/False -> true/false
#   None -> null
#   dict -> object

jsoned = json.dumps((1,2,3))  # "[1,2,3]"
jsoned = json.dumps((1,2,3,"中文"),ensure_ascii=False)  # "[1,2,3,'中文']"
json.loads(jsoned) # 反序列化时  

# 文本格式 
with open("a.txt",mode="w",encoding="utf-8") as f:
	json.dump((1,2,3), f)    # 序列化并写入文件
#  	json.dump((4,5,6), f)    # 可以写入，结果为[1, 2, 3][5, 6, 7]， 会导致无法直接load
# 如果需要一次性的对读写多个数据，需要写入时写入 分隔标识，读取时分隔读取；

with open("a.txt",encoding="utf-8") as f:
	content = json.load(f)   # 从文件反序列化

# 特点：所有python类型(包括变量和对象)都支持；可以直接一次读写多个数据；不能跨语言

# 序列化： 从内存数据类型转化为 字节串 ，用于网络传输
# 反序列化：从 字节串 转化为内存数据类型
# 支持任意python类型： 支持元组

pickle.dumps()
pickle.loads()

# 需要用二进制格式
with open("a.txt",mode="wb") as f:
	pickle.dump((1,2,3), f)    # 序列化并写入文件
  pickle.dump((4,5,6), f)    # 序列化并写入文件 ,支持连续写入
with open("a.txt", mode="rb") as f:
	content = pickle.load(f)   # 从文件反序列化  (1, 2, 3)
  content2 = pickle.load(f)   # 从文件反序列化 (4, 5, 6)，支持连续读取

m = hashlib.md5() # 获取一个加密对象
m.update("abc中文".encode("utf-8")) # 对加密对象(只能字节类型)进行加密，可以多次加密
res = m.hexdigest() # 通过hexdigest获取16进制加密结果 1af98e0571f7a24468a85f91b908d335 32位

m = hashlib.md5("abc中文".encode("utf-8")) 
res = m.hexdigest()  # 1af98e0571f7a24468a85f91b908d335

m = hashlib.md5()
m.update("abc".encode("utf-8")) # 分段hash，与全部hash结果一致
m.update("中文".encode("utf-8"))
res = m.hexdigest() #  1af98e0571f7a24468a85f91b908d335 

from collections import namedtuple #命名元组
from collections import defaultdict #默认值字典
from collections import Counter # 计数器

Rectangle = namedtuple("rectangle_class", ["length","width"])
r = Rectangle(10,5) # <class '__main__.rectangle_class'>
r.length # 10
r[0] # 10
r.width # 5
r[1] # 5

d = defaultdict(int, key1="value1", key2="value2")
d["key1"] #  value1
d["key2"]  # value2
d["key_not_exist"] # 0

c = Counter("abddccc") # Counter({'c': 3, 'd': 2, 'a': 1, 'b': 1})
c.most_common(2) # [('c', 3), ('d', 2)] 最多的n个元素及其个数 元组组成的列表

#正则
# 贪婪算法、 回溯算法
# 非贪婪 .*?   \d??

# 分组： (?:) 取消分组获取（分组转义符）
#    findall 按照正则匹配规则，取所有符合条件的
#            如果有分组，则优先只获取括号中匹配到的内容
#    search 按照正则匹配规则，group()（等价于group(0)）获取匹配到的内容
#          如果有分组，则.group(n)...通过传参获取第n个分组的内容

ret1 = re.findall("2\d+","1234abc4321") # ["234“,”21“]
ret2 = re.search("2\d+","1234abc4321") #<re.Match object; span=(1, 4), match='234'>
ret2.group()  # 234

ret1_1 = re.findall("2(\d)\d","1234abc43211") # ['3', '1']
ret2_1 = re.search("2(\d)\d","1234abc43211") # <re.Match object; span=(1, 4), match='234'>
ret2_1.group() # 234 ret2_1.group(0) 
ret2_1.group(1) # 3
ret2_1.groups() # ("3",)

ret3_1 = re.search("2(\d)(\d)","1234abc4321") 
print(ret3_1) #<re.Match object; span=(1, 4), match='234'>
print(ret3_1.group()) #234 ret3_1.group(0)
print(ret3_1.group(1)) #3
print(ret3_1.group(2)) #4
print(ret3_1.groups()) # ('3', '4')



# split  注：会将正则规则也添加进数据中
ret = re.split("\d", "abc123efg")  # ["abc","123","efg"]

# sub  sub(regex, replace_str, origin, replace_count) 返回结果字符串
ret = re.sub("\d+", "H", "abc123efg456",1) # "abcHefg456"

# subn subn(regex, replace_str,origin)   返回元组 (结果，替换次数)
ret = re.sub("\d+","H", "abc123efg456")  # ("abcHefgH", 2)
 
# match  规定字符串必须是什么样，检测是否满足正则规则，具体用法同search
ret = re.match("\d", "abc123") #None
ret2 = re.match("\d", "123abc") # <re.Match object; span=(0, 1), match='1'>

# compile 避免重复编译，节省编译时间
#finditer 迭代器，节约空间
regex = re.compile("\d")
rets = re.finditer("\d","abc123efg456")
rets2 = regex.finditer("abc123efg456")
for i in rets:
  print(i.group()) # 123  \n   456
for j in rets2:
    print(j.group()) # 123  \n   456
   
# 分组 别名(?P<group_name>regex)
#     约束前后一致 (?P<group_name>regx)xxxx(?P=group_name) 
#     使用第N个分组 \1 \2 ，需要转义 r"(?P<group_name>regx)xxxx(\1)"
ret = re.search("(?P<first>\d+).*?(?P<second>\d+).*?(?P<third>\d+)","abc123efg456hij789")
ret.group()
ret.group(1) #123
ret.group(2) #456
ret.group(3) #789
ret.group("first") #123
ret.group("second") #456
ret.group("third") #789

logging.debug()
logging.info()
logging.warning()
logging.error()
logging.critical()

from logging import handlers

fh = logging.FileHandler("log.log", encoding="utf-8")  # 文件输出流(写入单个文件)
rfh = handlers.RotatingFileHandler("log2.log", maxBytes=1024, backupCount=5)  # 按大小做切割 ,最大文件maxBytes，最多存在backupCount个
tfh = handlers.TimedRotatingFileHandler("log3.log", when="s", interval=5, encoding="utf-8")  # 按时间做切割
sh = logging.StreamHandler()  # 屏幕输出流

logging.basicConfig(
    format="%(asctime)s- %(name)s - %(levelname)s - %(module)s[%(lineno)d]: %(message)s",  # 日志格式
    datefmt="%Y-%m-%d %H:%M:%S",  # 时间格式
    level=logging.INFO,  # 输出等级
    handlers=[rfh, tfh, sh]  # 流控制
)
logging.warning("warning")

class Animal:
    pass

class Foo:
  def __init__(self):
    self.func()
   
  def func(self):
    print("in foo")
class Son(Foo,Animal):
  def func(self):
    print("in son")
t = Son() #  in son  ， 传递的self指向实例对象

Son.__bases__ # 类.__bases__(<class '__main__.Foo'>, <class '__main__.Animal'>)
Son.__base__ #<class '__main__.Foo'>
Son.__class__ # <class 'type'>
Son.__name__ # Son


isinstance(t, Son) #True
isinstance(t, Foo) #True
type(t) # <class '__main__.Son'>

Son.func #函数 <function Son.func at 0x109685ef0>
t.func  #绑定方法 <bound method Son.func of <__main__.Son object at 0x101c4a090>>
isi

from types import FunctionType,MethodType
isinstance(Son.func, FunctionType) # 函数
isinstance(t.func, MethodType) # 方法



# 抽象类
from abc import ABCMeta, abstractclassmethod


class Payment(metaclass=ABCMeta):
    @abstractclassmethod
    def pay(cls, money):
        pass

class ApplePay(Payment):
    pass


apple = ApplePay() # TypeError: Can't instantiate abstract class ApplePay with abstract methods pay


super().func() #  mro顺序，只能在新式类中使用，python3 可不带参数 或 带参数（用法同python2）
super(子类名, self).func() # python2的新式类必须要带参数 （经典类无mro，无法使用）

class User:
    __pwd = "asd" #私有变量，无法直接获取
    def get_pwd():
        return self.__pwd    # 内部使用时，会自动将类名拼接在私有变量前，实际是访问  _User__pwd
User._User__pwd  # asd  

class Foo:
    def __init__(self):
        self.func()
    def func(self):
        print("in foo")
class Son(Foo):
    def func(self):
        print("in son")
Son().__dir__() #['func', ...]
Son() # in son


class Foo:
    def __init__(self):
        self.__func()  # 等价于  self._Foo__func(),因此父类私有方法，无法直接被子类使用
    def __func(self):
        print("in foo")
class Son(Foo):
    def __func(self):
        print("in son")
Son().__dir__() #['_Son__func',...]
Son() # in foo    

# vs java
#public   公有，类内类外都能用，父类子类都能用           python支持
#protect  保护，类内能用，父类子类能用； 类外不能用      python不支持
#private  私有，类内能用； 其他不能用          python支持

class Goods:
    discount = 0.8

    def __init__(self, origin_price):
        self.__price = origin_price

    @property
    def price(self):
        return self.__price * self.discount

    @price.setter
    def price(self, new_value):
        if isinstance(new_value, int):
            self.__price = new_value
    @price.deleter
    def price(self):
        print("要删除我了")
        del self.__price

apple = Goods(10)
print(apple.price)  #8.0
apple.price = 100.0
print(apple.price) # 8.0
apple.price = 100
print(apple.price) # 80.0
del apple.price

class Goods:
    __discount = 0.8

    def __init__(self, origin_price):
        self.__price = origin_price

    @property
    def price(self):
        return self.__price * self.__discount

    @classmethod
    def change_discount(cls, new_discount):
        cls.__discount = new_discount


Goods.change_discount(0.9)




import time
class MDate:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day
    
    @classmethod
    def today(cls):
        struct_t = time.localtime()
        date = cls(struct_t.tm_year, struct_t.tm_mon, struct_t.tm_mday)
        return date

date_today = MDate.today() # 通过classmethod创建对象

# mysingleton.py
class Singleton(object):
    def foo(self):
        pass
singleton = Singleton(

from a import singleton

def Singleton(cls):
    _instance = {}

    def _singleton(*args, **kargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kargs)
        return _instance[cls]

    return _singleton


@Singleton
class A(object):
    a = 1

    def __init__(self, x=0):
        self.x = x


a1 = A(2)
a2 = A(3)

class Singleton(object):

    def __init__(self):
        pass

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

obj1 = Singleton.instance()
obj2 = Singleton.instance()

import time
import threading
class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
       pass

    @classmethod
    def instance(cls, *args, **kwargs):
      if not hasattr(Singleton, "_instance"):
          with Singleton._instance_lock:    # 优化:先判断，未实例化再加锁；避免已经单例的对象需要执行锁
              if not hasattr(Singleton, "_instance"):  # 加锁后再判断避免并发问题
                  Singleton._instance = Singleton(*args, **kwargs)
      return Singleton._instance

import threading
class Singleton:
    _instance_lock = threading.Lock()

    def __init__(self):
        pass


    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = object.__new__(cls)  
        return Singleton._instance

obj1 = Singleton()
obj2 = Singleton()

"""
1.类由type创建，创建类时，type的__init__方法自动执行，类() 执行type的 __call__方法(类的__new__方法,类的__init__方法)
2.对象由类创建，创建对象时，类的__init__方法自动执行，对象()执行类的 __call__ 方法
"""
class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        pass

obj = Foo()
# 执行type的 __call__ 方法，调用 Foo类（是type的对象）的 __new__方法，用于创建对象，然后调用 Foo类（是type的对象）的 __init__方法，用于对对象初始化。

obj()    # 执行Foo的 __call__ 方法 

import threading

class SingletonType(type):
    _instance_lock = threading.Lock()
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            with SingletonType._instance_lock:
                if not hasattr(cls, "_instance"):
                    cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
        return cls._instance

class Foo(metaclass=SingletonType):
    def __init__(self,name):
        self.name = name


obj1 = Foo('name')
obj2 = Foo('name')
print(obj1,obj2)

class A:
    def __new__(cls, *args, **kwargs):
        print("in new")
        # return object.__new__(cls)  实际是调用object
        return super().__new__(cls)

    def __init__(self):
        print("in init")


obj = A()
#in new     ；  构造方法,创建对象
#in init    ；   初始化实例

#单例1
class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,"_instance"):
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance
      
# 等价于下面方法
class Singleton:
    __instance = None

    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            cls.__instance = super().__new__(cls, *args, **kwargs)
        return cls.__instance
# 单例2: 模块导入
import xxx

# 单例3：元类
#class Singleton(type):
#    _instances = {}
#
#    def __call__(cls, *args, **kwargs):
#        if cls not in cls._instances:
#            cls._instances[cls] = super().__call__(*args, **kwargs)
#        return cls._instances[cls]
class Singleton(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instances"):
            cls._instances = super().__call__(*args, **kwargs)
        return cls._instances

class MySQLDriver(metaclass=Singleton):
    #元类中的__new__方法和__init__方法其实已经被执行了，而不是在MySQLDriver实例化的时候执行。且仅会执行一次

    def __init__(self):
        print('MySQLDriver init.....')
m1 = MySQLDriver()   # MySQLDriver init.....
m2 = MySQLDriver()   # 无输出
m1 is m2 # True

class A:
  def __call__(self, *args, **kwargs):
      print("func call")

obj = A()
callable(obj)  # True
obj()  # func call   ;实例() 相当于 实例.__call__()

try:
  pass
except exception1 as e:
  pass
except exception2 as e:
  pass
except (exception3, exception4) as e: # 元组方式捕获异常
  pass
except Exception as e: # 捕获所有异常
  pass 
else:
  pass # 如果被检测的子代码块没有异常，则执行else
finally:
  pass # 无论是否有异常都会执行
	

import socket
1 ss = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建服务器套接字
2 ss.bind(ip_port)      #把地址绑定到套接字
3 ss.listen(int)      #监听链接;backlog半链接池
4 inf_loop:      #服务器无限循环
5     cs = ss.accept() #接受客户端链接
6     comm_loop:         #通讯循环
7         cs.recv()/cs.send() #对话(接收与发送)
8     cs.close()    #关闭客户端套接字
9 ss.close()        #关闭服务器套接字(可选)

1 cs = socket.socket(socket.AF_INET,socket.SOCK_STREAM)    # 创建客户套接字
2 cs.connect(serverip_port)    # 尝试连接服务器
3 comm_loop:        # 通讯循环
4     cs.send()/cs.recv()    # 对话(发送/接收)
5 cs.close()            # 关闭客户套接字

1 ss = socket()   #创建一个服务器的套接字
2 ss.bind()       #绑定服务器套接字
3 inf_loop:       #服务器无限循环
4     cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)
5 ss.close()                         # 关闭服务器套接字

# example
import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
phone.bind(("127.0.0.1",8081))

while True:
    data, client_addr = phone.recvfrom(1024) # bytes
    print(data)
    phone.sendto(data.upper(),client_addr)

phone.close()

cs = socket()   # 创建客户套接字
comm_loop:      # 通讯循环
    cs.sendto()/cs.recvfrom()   # 对话(发送/接收)
cs.close()                      # 关闭客户套接字

# example
import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  
while True:
    content = input("输入发送内容").strip()
    phone.sendto(content.encode("utf-8"),("127.0.0.1",8081))

    data = phone.recvfrom(1024)
    print(data[0].decode("utf-8"))

phone.close()

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

参数介绍：
1 group参数未使用，值始终为None
2 target表示调用对象，即子进程要执行的任务
3 args表示调用对象的位置参数元组，args=(1,2,'asdf',)
4 kwargs表示调用对象的字典,kwargs={'name':'asdf','age':18}
5 name为子进程的名称


p.terminate()   # 杀死当前进程（通知操作系统，有延迟）
p.is_alive()  # 判断当前进程是否存活

p.deamon = True # 守护进程
p.start()
p.join() 

from multiprocessing import Process
import time


def task(name):
    print(f"{name} is running")
    time.sleep(3)
    print(f"{name} is over")


class MyProcess(Process):
    def run(self):
        print("process is running")
        time.sleep(3)
        print("process is over")


if __name__ == '__main__':
    p = Process(target=task, args=("jaccorot",))
    p.start()

    mp = MyProcess()
    mp.start()

from multiprocessing import Lock
mutex = Lock()
mutex.acquire()
xxx
mutex.release()

#队列
from multiprocessing import Queue, JoinableQueue
#q = Queue(5)
q = Queue()
q.put(123)
q.get()
q.get(timeout=3)# 超时无法获取数据抛异常_queue.Empty
q.get_nowait()  # 没有数据直接抛异常_queue.Empty
q.full()
q.empty()


#JoinableQueue
q2 = JoinableQueue() # 维护内部计数器

q2.put(xxx)   #   ；内部计数器+1
q2.task_done() # 内部计数器减一
q2.join()  # 类似进程join，但是：当队列为空时，解除阻塞，继续执行

def producer(q):
    q.put("1")
    print("producer")

def comsumer(q):
    print(f"comsumer : {q.get()}")
    
if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer,args=(q,))
    p2 = Process(target=comsumer,args=(q,))
    p1.start()
    p2.start()
    # print(q.get())

def producer(q):
  q.put(xxx)
  

def comsumer(q):
  q.get()
  q.task_done()
  
if __name__ == '__main__':
    q2 = JoinableQueue() #
    p1 = Process(target=producer,args=(q2,))
    p2 = Process(target=comsumer,args=(q2,))
    p2.deamon = True
    
    p1.join()
    q2.join()   #消费完，q2内部计数为0，解除阻塞；  主进程结束，守护进程伴随关闭；

money = 100

def change_money():
    global money
    money = 999
    print(f"in change_money: {money}")


if __name__ == '__main__':
    t = Thread(target=change_money)
    t.start()
    t.join()
    print(f"in main :{money}")
#in change_money: 999
#in main :999
# 线程可以改变全局变量  （共享）

from threading import Lock
mutex = Lock()
mutex.acquire()
xxx
mutex.release()


#example
money = 100
mutex = Lock()

def change_money():
    global money
    mutex.acquire()
    time.sleep(0.01)
    money -=1
    print(f"in change_money: {money}")
    mutex.release()
    
if __name__ == '__main__':
    thread_list = []
    for i in range(100):
        t = Thread(target=change_money)
        t.start()
        thread_list.append(t)
    for i in thread_list:
        i.join()
    print(money)

"""
1. GIL并不是Python的特性，它是在CPython解释器实现时所引入的一个概念
2. 在cpython中内存管理是线程不安全的，GIL是保证解释器级别的数据安全
3. GIL本质是解释器级别的互斥锁
4. GIL会导致同一个进程下的多个线程无法同时运行
5. 针对不同的数据还是要加不同的锁处理
6. 解释型语言共同缺陷：同一个进程下多线程无法利用多核优势
"""

"""
多进程：计算密集型
多线程：IO密集型
"""

from threading import Lock,RLock
mutex = RLock()
mutex.acquire()
mutex.acquire()
mutex.release()
mutex.release()

from threading import Semaphore
sm = Semaphore(5)
sm.acquire()
sm.release()

from threading import Event
event = Event()
def light():
    print("红灯亮")
    time.sleep(3)
    print("绿灯亮")
    event.set()


def car(name):
    print(f"{name}  在等红灯")
    event.wait()
    print(f"{name} 走了")


if __name__ == '__main__':
    t = Thread(target=light)
    t.start()

    for i in range(20):
        t = Thread(target=car, args=(i,))
        t.start()

import queue
q_fifo = queue.Queue()
q_fifo.put(1)
q_fifo.put(2)
print(q_fifo.get())

q_lifo = queue.LifoQueue()
q_lifo.put(1)
q_lifo.put(2)
print(q_lifo.get())

q_priority = queue.PriorityQueue() #优先级队列
q_priority.put((10, "111")) # 元组（优先级，内容）
q_priority.put((100, "222"))
q_priority.put((0, "333"))
q_priority.put((-5, "444"))
print(q_priority.get())  # 优先获取优先级最小的

from  concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
# 线程池和进程池用法相同（鸭子类型）
thread_pool = ThreadPoolExecutor(n) # 不传值时，默认创建(os.cpu_count() * 5)个线程
process_pool = ProcessPoolExecutor(n) # 不传值时，默认创建(os.cpu_count())个线程


def task(n):
    time.sleep(1)
    print(f"in {n}")
    return n
  
def call_back(res):  # 定义回调函数
    	print(f"call back {res.result()}")
    
thread_pool = ThreadPoolExecutor(3)

if __name__ == '__main__':

		for i in range(10):
        thread_pool.submit(task,i).add_done_callback(call_back)  # 异步提交,异步回调
		#    in 0in 2in 1

		#call back 2

		#call back 0
		#call back 1
		#in 3
		#call back 3
		#in 4
		#call back 4

    
    for i in range(5):
        thread_pool.submit(task,i)  # 异步提交，无回调结果
    print("异步提交")
    # 异步提交
    # in 1
    # in 0
    # in 2

    # in 3
    # in 4


    for i in range(5):
        res = thread_pool.submit(task,i)  
        print(res.result())  # 调用.result(),则由并发变成串行，串行执行 + 串行获取返回的结果
    print("串行执行")
    # in 0
    # 0
    # in 1
    # 1
    # in 2
    # 2
    # in 3
    # 3
    # in 4
    # 串行执行

    result_list = []
    for i in range(5):
        res = thread_pool.submit(task, i)
        result_list.append(res)
    for t in result_list:
        print(t.result())
    print("异步提交，并立即获取结果")
    # in 0
    # in 1
    # in 2
    # 0
    # 1
    # 2
    # in 3
    # in 4
    # 3
    # 4
    # 异步提交，并立即获取结果


    result_list = []
    for i in range(5):
        res = thread_pool.submit(task, i)
        result_list.append(res)
    thread_pool.shutdown()  # 线程池全部执行结束（阻塞等待）
    for t in result_list:
        print(t.result())
    print("异步提交，最终获取所有结果")
    # in 0
    # in 2 in 1
    # 
    # in 3
    # in 4
    # 0
    # 1
    # 2
    # 3
    # 4
    # 异步提交，最终获取所有结果

from gevent import monkey;monkey.patch_all()  # 自动监测io切换
from gevent import spawn  # 使用协程
import time


def heng():
    print('heng')
    time.sleep(2)
    print('heng')


def ha():
    print('ha')
    time.sleep(3)
    print('ha')


if __name__ == '__main__':
    start = time.time()
    # heng()
    # ha()
    # end =time.time()
    # print(end-start)  # 5.0s

    g1 = spawn(heng)
    g2 = spawn(ha)
    g1.join()
    g2.join()
    end = time.time()
    print(end - start)  # 3.0s

# 服务端
import socket
import time

server=socket.socket()
server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
server.bind(('127.0.0.1',8083))
server.listen(5)

server.setblocking(False)
r_list=[]
w_list={}

while 1:
    try:
        conn,addr=server.accept()
        r_list.append(conn)
    except BlockingIOError:
        # 强调强调强调：！！！非阻塞IO的精髓在于完全没有阻塞！！！
        # time.sleep(0.5) # 打开该行注释纯属为了方便查看效果
        print('在做其他的事情')
        print('rlist: ',len(r_list))
        print('wlist: ',len(w_list))


        # 遍历读列表，依次取出套接字读取内容
        del_rlist=[]
        for conn in r_list:
            try:
                data=conn.recv(1024)
                if not data:
                    conn.close()
                    del_rlist.append(conn)
                    continue
                w_list[conn]=data.upper()
            except BlockingIOError: # 没有收成功，则继续检索下一个套接字的接收
                continue
            except ConnectionResetError: # 当前套接字出异常，则关闭，然后加入删除列表，等待被清除
                conn.close()
                del_rlist.append(conn)


        # 遍历写列表，依次取出套接字发送内容
        del_wlist=[]
        for conn,data in w_list.items():
            try:
                conn.send(data)
                del_wlist.append(conn)
            except BlockingIOError:
                continue


        # 清理无用的套接字,无需再监听它们的IO操作
        for conn in del_rlist:
            r_list.remove(conn)

        for conn in del_wlist:
            w_list.pop(conn)



#客户端
import socket
import os

client=socket.socket()
client.connect(('127.0.0.1',8083))

while 1:
    res=('%s hello' %os.getpid()).encode('utf-8')
    client.send(res)
    data=client.recv(1024)

    print(data.decode('utf-8'))