#cmp_to_key
from functools import cmp_to_key
a = [(9, 4), (2, 10), (4, 3), (3, 6),(9, 2)]
def cmp(x,y):
    if x[0] < y[0]:
        return 1
    elif x[0] > y[0]:
         return -1
    else:
        if x[1] > y[1]:
            return 1
        else:
            return -1
print(sorted(a,key=cmp_to_key(cmp)))

# reduce(function, sequence[, initial]) -> value
"""
Apply a function of two arguments cumulatively to the items of a sequence,
from left to right, so as to reduce the sequence to a single value.
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
of the sequence in the calculation, and serves as a default when the
sequence is empty.
"""
from functools import reduce 
reduce(lambda x,y: x+y, [1, 2, 3]) 
#输出 6 
reduce(lambda x, y: x+y, [1,2,3], 9) 
#输出 15 
reduce(lambda x,y: x+y, [1, 2, 3], 7) 
#输出 13

#functools.partial
import functools

def add(a, b):
    print("当前结果值", a+b)

add = functools.partial(add, 1)
add(2)

#functools.wraps
from functools import wraps

def wrapper(func):
    @wraps(func)
    def inner_function():
        pass
    return inner_function

@wrapper
def wrapped():
    pass

print(wrapped.__name__)
# wrapped

"""
给定一个类，这个类定义了一个或者多个比较排序方法，这个类装饰器将会补充其余的比较方法，减少了自己定义所有比较方法时的工作量。

被修饰的类必须至少定义  __lt__()， __le__()，__gt__()，__ge__() 中的一个，同时，被修饰的类还应该提供 __eq__()方法。
"""
from functools import total_ordering


@total_ordering
class Person:
    # 定义相等的比较函数
    def __eq__(self, other):
        return ((self.lastname.lower(), self.firstname.lower()) ==
                (other.lastname.lower(), other.firstname.lower()))

    # 定义小于的比较函数
    def __lt__(self, other):
        return ((self.lastname.lower(), self.firstname.lower()) <
                (other.lastname.lower(), other.firstname.lower()))


p1 = Person()
p2 = Person()

p1.lastname = "123"
p1.firstname = "000"

p2.lastname = "1231"
p2.firstname = "000"

print(p1 < p2)
print(p1 <= p2)  #
print(p1 == p2)
print(p1 > p2)
print(p1 >= p2)  #

'''
True
True
False
False
False
'''

from collection import Counter
L = ['red', 'blue', 'red', 'green', 'blue', 'blue'] 
Counter(L)
#{'red': 2, 'blue': 3, 'green': 1}
Counter(L).most_common(2)
#{'red': 2, 'blue': 3}

s = 'mississippi'
d = defaultdict(int)
for k in s:
    d[k] += 1
sorted(d.items())
#[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

from collections import namedtuple

Color = namedtuple("Color", "r g b alpha")

a=Color(r=50, g=205, b=50, alpha=0)
b=Color(50, 0, 0, 0)
print(a.r) #打印指定元素

c=b._asdict() #转为dict形式
tuple(b) #转为tuple形式

d=b._replace(b=100) #从已有元组构建出新的元组

print(c._fields) #返回元素名


Color1 = namedtuple("Color", c)#从dict中创建namedtuple
e = Color1(**c)


Account = namedtuple('Account', ['type', 'balance','c'], defaults=[1,0]) #设置默认值
print(Account._field_defaults) #{'balance': 1, 'c': 0}
print(Account('premium')) #Account(type='premium', balance=1, c=0)

from collections import ChainMap 
baseline = {'music': 'bach', 'art': 'rembrandt'}
adjustments = {'art': 'van gogh', 'opera': 'carmen'}
NewMap = ChainMap(adjustments, baseline)

print(NewMap)
#ChainMap({'art': 'van gogh', 'opera': 'carmen'}, {'music': 'bach', 'art': 'rembrandt'})
print(list(ChainMap(adjustments, baseline)))
#['music', 'art', 'opera']
#存在重复元素时，也不会去重

NewMap1=NewMap.new_child(m={'key_new':888}) #把NewMap作为父节点并添加新的字典并创建子节点ChainMap
#ChainMap({'key_new': 888}, {'art': 'van gogh', 'opera': 'carmen'}, {'music': 'bach', 'art': 'rembrandt'})

NewMap1.parents #返回父节点

NewMap1['art']='abc' #只会改变第一个字典
#ChainMap({'key_new': 888, 'art': 'abc'}, {'art': 'van gogh', 'opera': 'carmen'}, {'music': 'bach', 'art': 'rembrandt'})

print(NewMap1['art']) #'abc'
#按字典顺序、映射顺序依次搜索，搜索第一个key即停止

text1 = "hello"
text2 = "ciallo"
diff = difflib.ndiff(text1, text2)#得到的是如何操作可以由text1变为text2的过程，逐字符比较
print('\n'.join(diff))
similarity = difflib.SequenceMatcher(None, text1, text2).ratio()#计算字符串相似度

with open('file1.txt') as file1, open('file2.txt') as file2:
    diff = difflib.ndiff(file1.readlines(), file2.readlines())
    print('\n'.join(diff))  ##逐行比较文件差异

import difflib
list1 = ['apple', 'a','banana', 'cherry']
list2 = ['apple', 'b','banana', 'kiwi']
diff = difflib.ndiff(list1, list2)#得到的是如何操作可以由list1变为list2的过程

import difflib
text1 = "hello world"
text2 = "there asd hello "
blocks = difflib.SequenceMatcher(None, text1, text2).get_matching_blocks()
#[Match(a=0, b=10, size=6), Match(a=11, b=16, size=0)] 
#可以用blocks[0].a来访问
lcs = difflib.SequenceMatcher(None, text1, text2).find_longest_match(0, len(text1), 0, len(text2))
#返回最大相似块 Match(a=0, b=10, size=6)

name = "Alice"
age = 20
print("Hello, %s. You are %d years old." % (name, age))
# Hello, Alice. You are 20 years old.

name = "Bob"
age = 21
print("Hello, {}. You are {} years old.".format(name, age))
# Hello, Bob. You are 21 years old.
print("Hello, {0}. You are {1} years old.".format(name, age))
# Hello, Bob. You are 21 years old.
print("Hello, {name}. You are {age} years old.".format(name=name, age=age))
# Hello, Bob. You are 21 years old.

num = 0.123456
print("%.2f%%" % num) # 输出0.12%

name = "Charlie"
age = 22
print(f"Hello, {name}. You are {age} years old.")
# Hello, Charlie. You are 22 years old.

num = 0.123456
print("{:.2f}%".format(num)) # 输出0.12%
print(f"{num:.2f}%") # 输出0.12%