• 给定列表，找出3个数和为零的所有组合

# 方法1：
l_1 = [2,3,5,-1,-3,0,8,-5]
for i in range(len(l_1)):
    l_2 = l_1[i+1:]
    for j in range(len(l_2)):
        l_3 = l_2[j+1:]
        for k in range(len(l_3)):
            if l_3[k] + l_2[j] + l_1[i] == 0:
                print(f'{l_3[k]},{l_2[j]},{l_1[i]}')
                
# 方法2：列表推导式求解
t =[tuple(sorted((x,y,z))) for x in l for y in l for z in l if x+y+z==0 and (x != y and y!=z and x != z and x!=y!=z)]

• 字符串倒置

s = 'hello'
# 方式一：
s[::-1]
    
# 方式二：
''.join(reversed(s))

• 上下文context，实现__enter__,__exit__方法

  参考链接

class A:
    def __enter__(self):
        print('begin')
        return 'Do something'
        
    def __exit__(self, exc_type, exc_val, exc_tb):
    print(f'异常类型:{exc_type}')
    print(f'详细错误:{exc_val}')
    print(f'堆栈信息:{exc_tb}')
    print('over')

with A() as a:
    print(a)

# 打印结果
# begin
# Do something
# 异常类型:None
# 详细错误:None
# 堆栈信息:None
# over

可迭代对象 迭代器：实现迭代器协议，即同时实现方法 iter,next 可迭代对象不一定是迭代器，迭代器一定是可迭代对象 生成器

# 利用yield实现协程
# 生产 - 消费者模型
def consumer():
    while True:
        i = yield    # 外部调用生成器send(var)方法，将var赋值给i
        print(f'consumer:{i}')

def producer(c):
    c.__next__()    # 启动迭代器
    for i in range(5):
        print(f'producer:{i}')
        c.send(i)    # 未启动生成器，不能往生成器send数据
        print('-' * 30)
    c.close()

c = consumer()
producer(c)

闭包：一个方法中嵌套另一个方法 装饰器

参考链接

# 函数装饰器
from time import sleep,time
from functools import wraps

def duration(func):
    @wraps(func)
    def wrapper(*args,**kwargs):
        start_time = time()
        func(*args,**kwargs)
        end_time = time()
        print(f'耗时：{end_time - start_time}')
    return wrapper

@duration
def do(name):
    for i in range(10):
        print(f'执行{i+1}次，打印传入name：{name}')
        sleep(1)
do('Jim')


# 类装饰器
class Decorator:
    def __init__(self, func):
        self.f = func

    def __call__(self, *args, **kwargs):
        print("__call__,begin")
        self.f(*args, **kwargs)
        print("__call__,end")

@Decorator
def f(a):
    print(f"执行方法 f，传入参数:a，值为:{a}")

f(1)

# 输出
"""
    __call__,begin
    执行方法 f，传入参数:a，值为:1
    __call__,end
"""


# 对象装饰器，比类装饰更灵活，实例对象带参数
class Decorator:
    def __init__(self,x,y):
        self.a = x
        self.b = y


    def __call__(self, f):
        print("__call__,begin")
        def wrap(*args,**kwargs):
            print(f'执行__call__内部方法wrap')
            f(*args,**kwargs)
        print("__call__,end")
        return wrap

@Decorator(1,2)
def f(a):
    print(f"执行方法 f，传入参数:a，值为:{a}")

f(1)

# 输出
"""
    __call__,begin
    __call__,end
    执行__call__内部方法wrap
    执行方法 f，传入参数:a，值为:1
"""

__call__方法

类实现__call__方法后，类实例可作为函数调用

__call__方法内可对实例属性进行更改

class A:
    def __init__(self, ai, bi, ci):
        self.a = ai
        self.b = bi
        self.c = ci
        self.d = None

    def __call__(self, ca, cb):
        self.a = ca
        self.b = cb
        print(f'__call__方法内改变实例属性a:{self.a},b:{self.b}')


obj_a = A(1, 2, 3)
print(f'实例obj_a的属性a:{obj_a.a},b:{obj_a.b},c:{obj_a.c},d:{obj_a.d}')
obj_a(5, 6)  # 类似：obj_a.__call__(5,6)
print(f'调用__call__实例后，实例obj_a的属性a:{obj_a.a},b:{obj_a.b},c:{obj_a.c},d:{obj_a.d}')

# 输出结果
"""
  实例obj_a的属性a:1,b:2,c:3,d:None
  __call__方法内改变实例属性a:5,b:6
  调用__call__实例后，实例obj_a的属性a:5,b:6,c:3,d:None

"""

字典列表排序 通过字典某个关键字进行排序

def sort_data(lst):
    lst.sort(key=lambda d:d['age'],reverse=False)
l = [{'name':'jim','age':15},{'name':'tim','age':13},{'name':'cat','age':21}]
sort_data(l)
print(l)

# 输出结果
# [{'name': 'tim', 'age': 13}, {'name': 'jim', 'age': 15}, {'name': 'cat', 'age': 21}]

• 3.10版本新增match...case...

def compare(time):
    match time:
        case 1:
            print('匹配1')
        case 2:
            print('匹配2')
        case 3:
            print('匹配3')
        case _:
            print('模糊匹配')

compare(4)    # 模糊匹配

• 随机字符生成

import random
from string import ascii_letters
from string import digits
from string import punctuation

print(''.join(random.sample(ascii_letters + digits + punctuation, 16)))        # sXaAv3`0{\%qx7R~

• 向下取整

int(2.6)  # 2

• 浮点数处理

# n 为正，处理小数位
round(12.456,2)  #12.46
# n 为负，处理整数位
round(123,-2)    #100
round(50,-2)     #0
round(50.1,-2)   #100

• 获取方法名

sys._getframe().f_code.co_name

• 时间格式化，带毫秒

datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])   # 2021-07-02 16:26:19.160

• .join()

### .join(可迭代对象)
# 字符串
":".join(hello hi)   #h:e:l:l:o: :h:i
# 元组
":".join(('a','b','c'))   #a:b:c
# 列表
":".join(['a','b','c'])   #a:b:c
# 字段
":".join({"key1":1,"key2":2,"key3":3})  #key1:key2:key3
### .join(目录)
import os
os.path.join('/a','/b/c','/d')  #/a/b/c/d

• string 模板替换

from string import Template

mdt = {'a':123,
       'b':456}

st = "{'k1':$a,'k2':$b}"

res = Template(st).safe_substitute(mdt)
print(res)
# 输出结果
{'k1':123,'k2':456}

• eval()

字符串列表、字符串字典，字符串表达式，转为列表、字典、python可执行代码

s = "{'amount': 100, 'price': 70.4, 'time': None}"
print(type(eval(s)))
# 输出结果
<class 'dict'>
######################################
s = "[{'amount': 100, 'price': 70.4, 'time': None}]"
print(type(eval(s)))
# 输出结果
<class 'list'>

• chardet

查看数据编码格式包

chardet.detect(input).get('encoding')

• 查询包是否已安装

python -c "包名"

如果没报错，则已安装

• 查询环境安装了哪些包

pip freeze

• r'string' 表示原始字符串

s = 'pri\nt'
# 如果不想\发生转义，解决办法如下
s = r'pri\nt'

• 特殊元组声明，字符串后加逗号

tuple = 'string',

• list 排序

dict_1 = {
    'type': 'text',
    'max_length': 300
}
dict_2 = {
    'type': 'html',
    'max_length': 800
}
dict_3 = {
    'type': 'markdown',
    'max_length': 300
}
dict_4 = {
    'type': 'xml',
    'max_length': 600
}
dict_5 = {
    'type': 'json',
    'max_length': 1200
}

dict_list = [dict_1, dict_2, dict_3, dict_4, dict_5]

# —————— dict_list 通过 max_length 排序 ————————
sorted_result = sorted(dict_list, key=lambda x: x['max_length'], reverse=False)
print(sorted_result)
# Output: [{'type': 'text', 'max_length': 300}, {'type': 'markdown', 'max_length': 300}, {'type': 'xml', 'max_length': 600}, {'type': 'html', 'max_length': 800}, {'type': 'json', 'max_length': 1200}]

# —————— dict_list 通过 max_length 排序，再通过type排序 ————————
sorted_result = sorted(dict_list, key=lambda x: (x['max_length'], x['type']), reverse=False)
print(sorted_result)
# Output: [{'type': 'markdown', 'max_length': 300}, {'type': 'text', 'max_length': 300}, {'type': 'xml', 'max_length': 600}, {'type': 'html', 'max_length': 800}, {'type': 'json', 'max_length': 1200}]

• all

list_1 = [5, 7, 2, 9, 0, -1, 10, 3, 2, 1, 20]
list_2 = [1, 4, 2, 6]
list_3 = ['', 0, {}, ()]

# —————— 判断list_1,list_2是否全为True ————————
result_1 = all(list_1)
result_2 = all(list_2)
print(result_1, result_2)
# Output: False True

• any

list_1 = [5, 7, 2, 9, 0, -1, 10, 3, 2, 1, 20]
list_2 = [1, 4, 2, 6]
list_3 = ['', 0, {}, ()]

# —————— 判断list_1,list_2,list_3是否包含真值 ————————
result_1 = any(list_1)
result_2 = any(list_2)
result_3 = any(list_3)
print(result_1, result_2, result_3)
# Output: True True False

• filter 过滤

dict_1 = {
    'type': 'text',
    'max_length': 300
}
dict_2 = {
    'type': 'html',
    'max_length': 800
}
dict_3 = {
    'type': 'markdown',
    'max_length': 300
}
dict_4 = {
    'type': 'xml',
    'max_length': 600
}
dict_5 = {
    'type': 'json',
    'max_length': 1200
}

dict_list = [dict_1, dict_2, dict_3, dict_4, dict_5]

# —————— dict_list 查询 max_length 小于700的数据 ————————
result = filter(lambda x: x['max_length'] < 700, dict_list)
print(list(result))
# Output: [{'type': 'text', 'max_length': 300}, {'type': 'markdown', 'max_length': 300}, {'type': 'xml', 'max_length': 600}]

• map(func,iterable...)

res = map(lambda x: x * 3, (1, 2, 3))
print(list(res))  # [3, 6, 9]

res = map(lambda x,y: x * y, (1, 2, 3),(3,2,1))
print(list(res))  # [3, 4, 3]

序列化、反序列化

import json

# 反序列化
mixin_dict_str = '{"time":"15:09","address":"No 110","phone":"15600000000","count":6}'
print(json.loads(mixin_dict_str))   # 字典必须是双引号
# 输出 {'time': '15:09', 'address': 'No 110', 'phone': '15600000000', 'count': 6}

# 序列化
mixin_dict = {'time': '15:09', 'address': 'No 110', 'phone': '15600000000', 'count': 6}
print(json.dumps(mixin_dict,sort_keys=True))
# 输出 {"address": "No 110", "count": 6, "phone": "15600000000", "time": "15:09"}

信号通信库

blinker

支持1对1、1对多，定制主题，装饰器语法

from blinker import signal

s = signal('demo')


def run(*args):
    print('Dangerous, someone begin running')


def cry(*args):
    print('Dangerous, someone begin crying')


def scream(*args):
    print(f'{args[0]}, someone begin scream')


def custom_theme_match(*args):
    print(f'{args[0]}, 定制主题匹配')


def custom_theme_not_match(*args):
    print(f'{args[0]}, 定制主题不匹配')


@s.connect
def decorate(*args):
    print(f'{args[0]}, 未定制主题装饰器语法')


@s.connect_via('Danger is coming')
def decorate_custom_theme(*args):
    print(f'{args[0]}, 定制主题装饰器语法')


s.connect(run)
s.connect(cry)
s.connect(scream)
s.connect(custom_theme_match, sender='Danger is coming')
s.connect(custom_theme_match, sender='Danger isn\'t coming')

s.send('Danger is coming')

# 结果
# Danger is coming, 未定制主题装饰器语法
# Dangerous, someone begin crying
# Danger is coming, someone begin scream
# Dangerous, someone begin running
# Danger is coming, 定制主题装饰器语法
# Danger is coming, 定制主题匹配