list_bigger = [x for x in list_nums if x > 0]
dict_bigget = {k: v for k, v in dict_nums.items() if v > 0}
set_two = {x for x in set_nums if not x % 2}
min_pairs = min(zip(prices.values(),prices.keys()))
sorted_pairs = sorted(zip(prices.values(),prices.keys()))
sorted_keys = sorted(prices,prices.get)
# zip 创建的对象只能访问一次

from collections import namedtuple


stuendt = namedtuple("Student", ["name", "age", "sex"])


s1 = stuendt(name="12", age=12, sex="female")
s2 = stuendt(name="12", age=12, sex="male")

import re
from collections import Counter


nums = [5, 2, 2, 3, 1, 5, 1, 3, 2, 4]


times = Counter(nums)
com = times.most_common(3)




text = """If operators with different priorities are used, consider adding
whitespace around the operators with the lowest priority(ies). Use
your own judgment; however, never use more than one space, and
always have the same amount of whitespace on both sides of a binary
operator."""
times = Counter(re.split(r"\W+",text))
com = times.most_common(3)

nums = {0: 9, 1: -3, 2: -8, 3: 6, 4: -4, 5: -4, 6: -7, 7: -8, 8: 7, 9: -3}
res = sorted(nums.items(), key=lambda x: x[1])

from functools import reduce


a = {'b': 7, 'f': 3, 'e': 9}
b = {'d': 8, 'b': 2, 'f': 8, 'e': 10, 'g': 6}
c = {'h': 2, 'e': 7, 'b': 11}


res = reduce(lambda x, y: x & y, map(dict.keys, [a, b, c]))

from collections import OrderedDict


order = OrderedDict()
for x in sample("abcdefgh", randint(3, 6)):
    order[x] = randint(4,10)

import re


text = """If\roperators\r\n with\different<<priorities are\vused, consider adding
whitespace around the operators with the lowest priority(ies). Use
your own judgment;;\however, never use more than one space, and
always have}the\\same amount of whitespace on both sides of a binary
operator."""


res = re.split(r"[\r\n\t\v\\}; .<]+",text)

## 使用了正则的捕获组
import re
text = "07/20/2019"


res = re.sub(r"(\d{2})\/(\d{2})\/(\d{4})", r"\3-\1-\2", text)

from itertools import chain




nums1 = [1, 5, 4, 5]
nums2 = [2, 3, 3]
nums3 = [4, 3, 3, 5, 7, 8, 3]


## 并行遍历
for x, y, z in zip(nums1, nums2, nums3):
    print(x, y, z)
## 串行遍历
for x in chain(nums1, nums2, nums3):
    print(x)

class Control(object):
    def __init__(self, value):
        self.value = value


    def get_value(self):
        return self.value


    def set_value(self, num: int):
        if not isinstance(num, (int, float)):
            raise ValueError("please enter num")
        self.value = num


    r = property(get_value, set_value)

from functools import total_ordering
from abc import ABCMeta, abstractmethod




@total_ordering
class Shape(object):


    @abstractmethod
    def area(self):
        pass


    def __lt__(self, obj):
        if not isinstance(obj, Shape):
            raise TypeError("obj is not a shape")
        return self.area() < obj.area()


    def __eq__(self, obj):
        if not isinstance(obj, Shape):
            raise TypeError("obj is not a shape")
        return self.area() == obj.area()




class Cirlcle(Shape):
    def __init__(self, radius):
        self.radius = radius


    def area(self):
        return 3.14*self.radius**2




class Rect(Shape):
    def __init__(self, weight, height):
        self.weight = weight
        self.height = height


    def area(self):
        return self.weight*self.height




cricle = Cirlcle(3)
rect = Rect(3, 4)
print(cricle >= rect)

class Attr(object):
    def __init__(self, name, type_):
        self.name = name
        self.type_ = type_


    def __get__(self, instance, cls):
        return instance.__dict__[self.name]


    def __set__(self, instance, value):
        if not isinstance(value, self.type_):
            raise TypeError("expect a {}".format(self.type_))
        instance.__dict__[self.name] = value


    def __delete__(self, instance):
        del instance.__dict__[self.name]




class Monkey(object):
    name = Attr("name", str)
    age = Attr("age", int)
    gender = Attr("gender", str)

from operator import methodcaller




class MethonCall(object):
    def get_value(self, value: int, value2: int):
        return 12*value*value2




mc = MethonCall()
fun = methodcaller("get_value", 2, -1)
print(fun(mc))

from functools import wraps, update_wrapper


def add_cache(fun):
    cache = dict()


    @wraps(fun)
    def handler(*arg):
        if arg not in cache:
            cache[arg] = fun(*arg)
        return cache[arg]
    ## update_wrapper(handler, fun, ("__name__", "__doc__"), ("__dict__",))
    return handler


@add_cache
def fibonacci(n):
    if n <= 1:
        return 1
    return fibonacci(n-1)+fibonacci(n-2)


print(fibonacci(89))

import time
import logging
from random import randint




def warn(timeout):
    timeout = [timeout]


    def decorator(fun):
        def wrapper(*args, **kwargs):
            start = time.time()
            res = fun(*args, **kwargs)
            end = time.time()
            used = end-start
            if used > timeout[0]:
                logging.warn("{}:{} > {}".format(fun.__name__, used, timeout[0]))
            return res


        def set_timeout(k):
            timeout[0] = k
        wrapper.set_timeout = set_timeout


        return wrapper


    return decorator




@warn(1)
def test():
    print("正在测试")
    while randint(0, 1):
        time.sleep(0.5)




for i in range(20):
    test()


test.set_timeout(1.2)


for i in range(20):
    test()

import heapq


class PriorityQueue(object):
    def __init__(self):
        self._queue = []
        self._index = 0


    def push(self, item, priority):
        heapq.heappush(self._queue, (-priority, self._index, item))
        self._index += 1


    def pop(self):
        return heapq.heappop(self._queue)[-1] if self._queue else None

from collections.abc import Iterable


def flatten(items, ignore_types=(str, bytes)):
    for x in items:
        if isinstance(x, Iterable) and not isinstance(x, ignore_types):
            yield from flatten(x)
        else:
            yield x




items = [1, 2, [3, 4, (5, 6), 7], 8, "temp", "core", {-1, -2, -4, -6}]


for x in flatten(items):
    print(x)

with open('d:/work/test.txt', 'wt') as f:
    print('Hello World!', file=f)


# 文件必须以文本格式打开

with open('somefile', 'xt') as f:
    f.write('Hello\n')

def recv(maxsize, *, block):
    'Receives a message'
    pass


recv(1024, True) # TypeError
recv(1024, block=True) # Ok

import json
from datetime import datetime

from bson.json_util import default


def compare_2_dict(dict_1, dict_2):
    return json.dumps(dict_1, default=default, sort_keys=dict.keys) == json.dumps(dict_2, default=default, sort_keys=dict.keys)


dicta = {"a": datetime.now(), "b": 2}
dictb = {"a": datetime.now(), "b": 2}

print(compare_2_dict(dicta, dictb))