['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

__delattr__: 删除属性
__dir__: 返回一个包含有所有属性名和方法名的有序列表
__eq__: 用来判断两个对象实例是否相等
__format__: 格式化实例时使用
__getattribute__: 属性访问拦截器，就是当这个类的属性被实例访问时，会自动调用类的__getattribute__方法
__ge__: 对象比较大小使用，相当于>=
__gt__: 对象比较大小使用，相当于>
__hash__: 生成唯一id，唯一标记对象
__init_subclass__: 当子类定义之后触发,
第一个参数是 cls 而不是常见的 self ，这是因为这个方法隐式地被 @classmethod 装饰（PEP-487）。
__init__ : 构造函数，在生成对象时调用
__le__: 对象比较大小使用，相当于<=
__lt__: 对象比较大小使用，相当于>=
@staticmethod __new__: 创建类实例的静态方法，优先 __init__() 初始化方法被调用
__ne__: 对象比较大小使用，相当于!=
__reduce_ex__: 用于pickle，可以指定版本
__reduce__: 用于pickle，不能指定版本
__repr__ : 打印，转换
__setattr__: 在对一个属性设置值的时候，会调用到这个函数
__sizeof__: 
__str__: str(self)
@classmethod __subclasshook__: 接收两个类，判断一个类是不是另一个类的子类
__class__: 类的实例当成函数调用
__dict__: 类的静态函数、类函数、普通函数、全局变量以及一些内置的属性
__doc__: 注释内容
__module__: 对象在哪个模块

class A:
    def __init__(self, value):
        self.__value = value

    @property
    def value(self):
        return self.__value

obj = A(1)
obj.__value = 2
print(obj.value)
print(obj.__value)
print(obj._A__value)

1
2
1

class A:
    def who(self):
        print('A', end='')

class B(A):
    def who(self):
        super(B, self).who()
        print('B', end='')

class C(A):
    def who(self):
        super(C, self).who()
        print('C', end='')

class D(B, C):
    def who(self):
        super(D, self).who()
        print('D', end='')

item = D()
item.who()

__annotations__: 参数和返回值注解
__closure__: 函数闭包，自由变量的绑定（通常为None）
__code__: 编译成字节码的函数元数据和函数定义体
__defaults__: 形式参数的默认值
__get__: 实现只读描述符协议
__global__: 函数所在模块中的全局变量
__kwdefaults__: 仅限关键字形式参数的默认值
__name__: 函数名称
__qualname__: 函数限定名称

命令：re.sub(pattern, repl, string, count=0, flags=0)
re.sub 用于替换字符串的匹配项。如果没有匹配到规则，则原字符串不变。

第一个参数：规则 
第二个参数：替换后的字符串 
第三个参数：字符串 
第四个参数：替换个数。默认为0，表示每个匹配项都替换

问题描述：假设我有这样两个list，
          一个是list1，list1 = [1, 2, 3, 4, 5]
          一个是list2，list2 = [1, 4, 5] 
          我们如何得到一个新的list，list3，
          list3中包括所有不在list2中出现的list1中的元素。
          即：list3 = list1 - list2
          
解决方案：我们可以用set（集合）操作
          list3 = list(set(list1) - set(list2))
          
          set操作会将一个list转换成一个集合。
          假设：list_t = [1, 2, 3, 1]
          那么：list(set(list_t)) = [1, 2, 3]
          是的，重复的项会被删除。

其他方案：list3 = [i for i in list1 if i not in list2]       #可用于list分片
          这样写也很直观。
          但是在list很大的时候，没有set方法快。

额外知识：a = [[i,j] for i in range(2) for j in range(3)]
          这个和“其他方案”非常相似，
          都是在[]里面进行判断和计算。
          感觉很方便，至少比下面这样要方便、要快：
          a = []
          for i in range(2):
              for j in range(3):
                  a.append([i,j])

某些问题：如果list_tmp = [[1,2],[2,3]]
          即list里面不是单独的元素组成，而是list，
          那么set(list_tmp)会出问题。

nums = [1, 2, 3, 4, 5]
num_iter = iter(nums)
for o, e in zip_longest(*([num_iter] * 2), fillvalue=0):
    print(o, e)

pip download -d . --only-binary=:all: --platform manylinux1_x86_64 --python-version 36 sklearn==0.0

def extend_list(val, items=[]):
    items.append(val)
    return items

list1 = extend_list(10)
list2 = extend_list(123, [])
list3 = extend_list('a')
print(list1)
print(list2)
print(list3)

[10, 'a']
[123]
[10, 'a']

import timeit
from functools import lru_cache

@lru_cache()
def f1(n):
    return 0 if n == 0 else(1 if n == 1 else f1(n - 1) + f1(n - 2))
def f2(n):
    return 0 if n == 0 else(1 if n == 1 else f2(n - 1) + f2(n - 2))
print(timeit.timeit('f2(40)', globals=globals(), number=1))

class Solution(object):
    def f(self, x: int, y: int) -> int:
        x = x ^ y
timeit.timeit(partial(s.f, x, y))

def accumulate(iterable, func=operator.add):
    'Return running totals'
    # accumulate([1,2,3,4,5]) --> 1 3 6 10 15
    # accumulate([1,2,3,4,5], operator.mul) --> 1 2 6 24 120
    it = iter(iterable)
    try:
        total = next(it)
    except StopIteration:
        return
    yield total
    for element in it:
        total = func(total, element)
        yield total

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

  事情的起因是这样的，近日接到一个需求要将md转doc，于是用到了pandoc这个库，首先我本地安装了pandoc，使用体验不错，顺便学习了md的标准法。
  本地使用pycharm，在python中使用pypandoc来进行文件转换，结果发现内存暴涨的问题，后面看了pypandoc代码，发现是使用subprocess.Popen调用linux下pandoc相应命令来运行，所以理论上应该和再shell中调用pandoc命令效果一致才对。
  接下来查看进程详情才发现python使用的是/bin/sh，而我自己用的是/bin/bash，于是将/bin/sh的软链接改成了/bin/bash，但是问题仍未解决，最后抱着试一试的态度在命令行中运行了python脚本，结果发现竟然问题解决了。
  后面本地将/bin/sh软链接恢复后发现问题解决，最终确定问题根源只有pycharm。
  总结：虽然上面的例子中的问题根源不是由python调用linux命令引起，但是在定位问题的过程中能发现python调用linux命令是会指定某个shell来运行命令的，这可能会导致一些问题，需要我们额外注意。

class Watermelon:
    def __init__(self):
        self.say_it_hook = None

    def register_say_it_hook(self, say_it_hook):
        self.say_it_hook = say_it_hook

    def say_it(self, content):
        if self.say_it_hook is not None:
            self.say_it_hook(content)
        print('so big')


watermelon = Watermelon()
watermelon.register_say_it_hook(lambda x: print(x))
watermelon.say_it('have fun')

next((_ for _ in range(100) if _ %2 == 0), 1))