每一级缩进使用4个空格。

空格是首选的缩进方式。

行限制的最大字符数为79

使用下划线分隔的小写字母

类名一般使用首字母大写的约定

异常名后面加上“Error”后缀

全局变量前加下划线的方式（表明这些全局变量是模块内非公有）。

函数名应该小写

None这样的单例对象进行比较的时候应该始终用 is 或者 is not

使用with 表达式来确保这个资源使用完后被清理干净。用try/finally也可以

  998层 

  获取：sys.getrecursionlimit()

  设置：sys.setrecursionlimit(3000)

 ASCII 码一共规定了128个字符的编码

 Unicode 当然是一个很大的集合，现在的规模可以容纳100多万个符号

 UTF-8 就是在互联网上使用最广的一种 Unicode 的实现方式。其他实现方式还包括 UTF-16（字符用两个字节或四个字节表示）和 UTF-32（字符用四个字节表示），不过在互联网上基本不用。重复一遍，这里的关系是，UTF-8 是 Unicode 的实现方式之一。

 GBK是在国家标准GB2312基础上扩容后兼容GB2312的标准（好像还不是国家标准）。GBK编码专门用来解决中文编码的，是双字节的。不论中英文都是双字节的

v1 = 1 or 3   # v1=1

v1 = 1 and 3  # v1=3

v1 = 0 and 2 and 1     # v1 = 0

v1 = 0 and 2 or 1     # v1 = 1

v1 = 0 and 2 or 1 or 4    # v1 =1

v1 = 0 or False and 1    # v1 = False

为真时的结果 if 判断条件 else 为假时的结果（注意，没有冒号）

a = 4

r = a if a>2 else 0

 python2：

 range返回真实的列表，有时会很长，占用空间

 xrange返回一个列表生成器，每次遍历内部会调用.next()函数拿到下一个元素

 python3：

 range就是python2中的xrange

<open file './test.txt', mode 'r' at 0x7f024288fe40>               # xreadlines   返回一个生成器

['1111111\n', '222222\n', '333333\n', '4444444\n', '5555555\n', '6666666\n', '7777777\n', '88888888\n']       # readlines    返回一个列表

string:

string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

    string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

    string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

    string.format() 格式化字符串

    string.index(str, beg=0, end=len(string))  跟find()方法一样，只不过如果str不在 string中会报一个异常.

    string.join(seq)  以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

    string.replace(str1, str2,  num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

    string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串

string.strip([obj]) 在 string 上执行 lstrip()和 rstrip()

list:

    list.append(obj)  在列表末尾添加新的对象

    list.count(obj) 统计某个元素在列表中出现的次数

    list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

    list.index(obj) 从列表中找出某个值第一个匹配项的索引位置

    list.insert(index, obj) 将对象插入列表

    list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

    list.remove(obj) 移除列表中某个值的第一个匹配项

    list.reverse() 反向列表中元素

tuple:

    min(tuple) 返回元组中元素最小值。

    tuple(seq) 将列表转换为元组。

    len(tuple) 计算元组元素个数。

cmp(tuple1, tuple2) 比较两个元组元素。

dict:

dict.clear() 删除字典内所有元素

    dict.copy() 返回一个字典的浅复制

    dict.fromkeys(seq[, val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值

    dict.get(key, default=None)  返回指定键的值，如果值不在字典中返回default值

    dict.has_key(key)  如果键在字典dict里返回true，否则返回false

    dict.items() 以列表返回可遍历的(键, 值) 元组数组

    dict.keys() 以列表返回一个字典所有的键

    dict.values() 以列表返回字典中的所有值

    dict.update(dict2)把字典dict2的键/值对更新到dict里

lambda 参数(可以没有):返回值

应用场景：

不需要被重复调用的函数

*arg会把多出来的位置参数转化为tuple

**kwarg会把关键字参数转化为dict

def exmaple2(required_arg, *arg, **kwarg):

    if arg:

        print "arg: ", arg

    if kwarg:

        print "kwarg: ", kwarg

exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo")

>> arg:  (1, 2, 3)

>> kwarg:  {'keyword2': 'foo', 'keyword1': 'bar'}

is 判断id是否一样

== 判断值是否相等

浅拷贝指仅仅拷贝数据集合的第一层数据，深拷贝指拷贝数据集合的所有层。所以对于只有一层的数据集合来说深浅拷贝的意义是一样的，比如字符串，数字，还有仅仅一层的字典、列表、元祖等.

直接赋值: 其实就是对象的引用(别名),赋值的两边指向的是同一个对象

浅拷贝(copy): 拷贝父对象,不会拷贝对象的内部的子对象

深拷贝(deepcopy):拷贝父对象,同时会开辟空间,逐层拷贝内部子对象

Python垃圾回收主要以引用计数为主，分代回收为辅。引用计数法的原理是每个对象维护一个ob_ref，用来记录当前对象被引用的次数，也就是来追踪到底有多少引用指向了这个对象，当发生以下四种情况的时候，该对象的引用计数器+1

对象被创建  a=14

对象被引用  b=a

对象被作为参数,传到函数中   func(a)

对象作为一个元素，存储在容器中   List={a,”a”,”b”,2}

与上述情况相对应，当发生以下四种情况时，该对象的引用计数器-1

当该对象的别名被显式销毁时  del a

当该对象的引别名被赋予新的对象，   a=26

一个对象离开它的作用域，例如 func函数执行完毕时，函数里面的局部变量的引用计数器就会减一（但是全局变量不会）

将该元素从容器中删除时，或者容器被销毁时。

当指向该对象的内存的引用计数器为0的时候，该内存将会被Python虚拟机销毁

参考：http://python.jobbole.com/87843/

可变类型（mutable）：列表，字典

变量对应的值中的数据可以被修改，但内存地址保持不变

不可变类型（unmutable）：数字，字符串，元组，字符串，int

变量对应的值中的数据是不能被修改，如果修改就会生成一个新的值从而分配新的内存空间

{'k1': [666], 'k2': [666]}

{'k1': 777, 'k2': [666]}

解释：初始k1,k2的value都是[]，两个[]实际指向同一个内存地址,[]是可变类型，一个修改另一个也会随之变化，所以k1,k2的value都变成了[666]，

而v['k1'] = 777,将k1 vlaue的地址指向了777,而k2的内存地址指向不变

filter用法:返回执行结果为TRUE的入参（入参是列表字符元组）

print filter(lambda x:x*x-4,range(10))   #结果：[0, 1, 3, 4, 5, 6, 7, 8, 9]

map的用法：对列表入参依次执行函数。入参为列表，有多少个列表，就应该有多少个入参。

print map(lambda x:x*x-4,range(10)) #结果：[-4, -3, 0, 5, 12, 21, 32, 45, 60, 77]

reduce用法：先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给fuction,最终返回一个结果值

print reduce(lambda x,y:x*y-4,range(4))  # 结果：-40

贪婪匹配：正则表达式一般趋向于最大长度匹配。

非贪婪匹配：匹配到结果就好。

默认是贪婪模式。在量词后面直接加一个问号？就是非贪婪模式

a:[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

b:<generator object <genexpr> at 0x0000008CB5BD7BA0>  # 生成器

a:1     b:2   c:False  d:True

# 注意：True表示1，Flase表示0

a = '1,2,3'

b= a.split(',')

print(b)

a = ['1','2','3']

print([int(i) for i in a])

list1 = [i ** 2 for i in range(1, 11)]

print(list1)

list2 = [1,2,3,4,4,5,5,6,6,7]

print(list(set(list2)))

def f():

    global x

    x = 1

f()

print(x)

栈：先进后出，后进先出

用列表来实现：

class MyStack():

    def __init__(self):

        self.stack = []

    def push(self, item):

        return self.stack.append(item)

    def pop(self):

        return self.stack.pop()

    def is_empty(self):

        return False if self.stack else True

    def size(self):

        return len(self.stack)

    def clear(self):

        self.stack.clear()

生成器: 常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行

    应用：通过生成器表达器完成对文件的读完跟操作

迭代器：可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator

(x for x in range(10))

可迭代对象：

list、dict、str

把list、dict、str等可迭代对象变成迭代器可以使用iter()函数：

isinstance(iter([]), Iterator)

True

isinstance(iter('abc'), Iterator)

True

def BinarySearch(seq, num):

    if not len(seq):

        print('list is none')

    if len(seq) == 1:

        if seq[0] == num:

            print('find:{}'.format(num))

        else:

            print('{} not exist'.format(num))

            return

    middle = len(seq) // 2

    if seq[middle - 1] == num:

        print("find:{}".format(num))

    elif seq[middle] < num:

        BinarySearch(seq[middle::], num)

    else:

        BinarySearch(seq[0:middle], num)

闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境)

闭包可以根据外部作用域的局部变量来得到不同的结果，这有点像一种类似配置功能的作用，我们可以修改外部的变量，闭包根据这个变量展现出不同的功能。比如有时我们需要对某些文件的特殊行进行分析，先要提取出这些特殊行

os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;

sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

继承更多了是为了多态，也可提升代码的复用程度。

特点：

在继承中基类的构造（init()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用；

Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）；

当出现多重继承并产生菱形交叉时查找属性或方法路径顺序。

python2中多继承是深度优先，python3找那个多继承是广度优先

super() 函数是用于调用父类(超类)的一个方法。

　　super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

　　MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

　　Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx

__init__ 构造方法，当类被实例化的时候执行

__new__ 工厂函数，在类被实例前执行

__del__ 析构方法，当一个对象没有任何引用时执行，用于销毁对象

__call__ 允许一个类的实例像函数一样被调用

在使用静态方法时，类中的self将不会再进行传值，此时，静态方法已经和类没什么关系了。   用@staticmethod 声明

类方法只能访问类变量，不能访问实例变量。

都能被实例和类调用

count = 0

for i in range(1, 6):

    for j in range(1, 6):

        for k in range(1, 6):

            if i != j and i != j and j != k:

                print('{}{}{}'.format(i, j, k))

                count += 1

print(count)

getattr()

它接收2个参数，前面的是一个对象或者模块，后面的是一个字符串，注意了！是个字符串

例子，用户输入储存在inp中，这个inp就是个字符串，getattr函数让程序去commons这个模块里，寻找一个叫inp的成员（是叫，不是等于），这个过程就相当于我们把一个字符串变成一个函数名的过程。然后，把获得的结果赋值给func这个变量，实际上func就指向了commons里的某个函数。最后通过调用func函数，实现对commons里函数的调用。这完全就是一个动态访问的过程，一切都不写死，全部根据用户输入来变化。

#1. 装饰器实现

def Singleton(cls):

    _instance = {}

    def wrapper(*args, **kwargs):

        if cls not in _instance:

            _instance[cls] = cls(*args, **kwargs)

        return _instance[cls]

    return wrapper

@Singleton

class A(object):

    def __init__(self, a):

        self.a = a

        print self.a

#2. 重新__new__方法    (有坑，__init__会执行多次)

import threading

class B(object):

    lock = threading.Lock()

    _instance = None

    def __init__(self):

        self.b = {}

    def __new__(cls, *args, **kwargs):

        if not B._instance:

            with B.lock:

                if not B._instance:

                    B._instance = object.__new__(cls)

        return B._instance

#3. 元类实现

class SingletonType(type):

    def __init__(self, *args, **kwargs):

        super(SingletonType, self).__init__(*args, **kwargs)

    def __call__(cls, *args, **kwargs):  # 这里的cls，即Foo类

        print('cls', cls)

        obj = cls.__new__(cls, *args, **kwargs)

        cls.__init__(obj, *args, **kwargs)  # Foo.__init__(obj)

        return obj

metaclass = SingletonType

class Foo():  # 指定创建Foo的type为SingletonType

    def __init__(self, name):

        self.name = name

    def __new__(cls, *args, **kwargs):

        return object.__new__(cls)

#4.模块实现

a.py

class A(object):

    def __init__(self, a):

        self.a = a

        print self.a

objA = A('aaa')

print(id(objA))

b.py

from a import objA

print(id(objA))

#闭包的形式，接受一个函数，返回内部函数，内湖函数中有对接受的函数的处理。装饰器可以在不影响原函数的情况下拓展自定义功能，提代码的复用性。

def output_current_time(func):

    def warpper(*args,**kargs):

        import datetime

        now_time = datetime.datetime.now()

        print(now_time)

        res = func()

        return res

    return warpper

@output_current_time

def task():

    print('do task')

try:

    可能出现异常的代码块

except Exception as es:

    出现的异常的处理方式

主动抛出异常：raise

python中至少有三种不同的MRO:

经典类(calssic class)，深度优先遍历

在python2.2中提出了type和class的统一，出现了一个内建类型以及自定义类的公共祖先object，即新式类(new-style class)预计算

python2.3之后新式类的C3算法，这是python3唯一支持的方式

isinstance用于类型判断：

接受两个参数：第一个为:object对象，第二个为类型类型

比如，要判断3是不是int类型：

isinstance(3,int)

如果时返回True，否则返回False

# 例子:

#nums = [2,7,11,15],target=9

#因为nums[0]+nums[1]=2+7=9

#所以返回[0,1]

# code：

list1 = [1, 4, 6, 8, 9]

target_num = 15

def twoSum(listobj, target_num):

    d = {}# 用来存放元素与下标的对应关系

    for i, v in enumerate(listobj):

        if target_num - v in d:

            return [d[target_num - v], i]

        d[v] = i

print(twoSum(list1, target_num))

# 可以处理 : list,dict,int,str,float,object

# 支持datetime?

#关键在于重写JSONEncoder的default方法

import json

from json import JSONEncoder

from datetime import datetime

class ComplexEncoder(JSONEncoder):

    def default(self, obj):

        if isinstance(obj, datetime):   #  如果obj是datatime类型 就将obj格式化为字符串

            return obj.strftime('%Y-%m-%d %H:%M:%S')

        else:  # 否则交给父类的delault处理

            return super(ComplexEncoder, self).default(obj)

d = {'name': 'alex', 'data': datetime.now()}

print(json.dumps(d, cls=ComplexEncoder))

# 这是因为json.dumps 序列化时对中文默认使用的ascii编码

jsonData = json.dumps({'name': '小明同学'}, ensure_ascii=False)

print(jsonData)

# Python的assert是用来检查一个条件，如果它为真，就不做任何事。如果它为假，则会抛出AssertError并且包含错误信息。例如：

x = 23

assert x > 0, "x is not zero or negative"

assert x%2 == 0, "x is not an even number"

#场景：

"""

　　☆防御型的编程

　　☆运行时检查程序逻辑

　　☆检查约定

　　☆程序常量

　　☆检查文档

"""

# 在unittest中很常用

# with语句的作用是通过某种方式简化异常处理，它是所谓的上下文管理器的一种

# 例如：

with open(filepath,'r')  as f :

    ·······

# 自动管理文件关闭 不用我们先open再close

import os

for file in os.listdir():

    if os.path.isfile(file):

        print(file)