python知识点

new和init

1. __new__是一个静态方法,而__init__是一个实例方法；
2. __new__方法会返回一个创建的实例,而__init__什么都不返回；
3. 只有在__new__返回一个cls的实例时后面的__init__才能被调用；
4. 当创建一个新实例时调用__new__,初始化一个实例时用__init__；

继承中的_ init _

当在Python中出现继承的情况时，一定要注意初始化函数_init_的行为:

1.如果子类没有定义自己的初始化函数，父类的初始化函数会被默认调用；但是如果要实例化子类的对象，则只能传入父类的初始化函数对应的参数，否则会出错。
2.如果子类定义了自己的初始化函数，而在子类中没有显示调用父类的初始化函数，则父类的属性不会被初始化
3.如果子类定义了自己的初始化函数，在子类中显示调用父类，子类和父类的属性都会被初始化

赋值、切片、浅拷贝与深拷贝

• 赋值不可变对象要看是否有缓存机制来决定是否是同一对象；
• 赋值可变对象相当于引用，完全不拷贝，仅仅是加了一个标签；
• 切片相当于浅拷贝；
• 对可变对象进行浅拷贝，直接修改一个不会不会影响另一个，但对其可变子元素的修改会影响另一个；
• 深拷贝得到的对象和原对象互不相干，修改一个不会影响另一个，这里指任何修改；

参考文章：
1、https://www.jianshu.com/p/5cf2aebdf7c5
2、https://www.jianshu.com/p/9a7cf6825ac4

def rotate(self, nums, k):
    """
    :type nums: List[int]
    :type k: int
    :rtype: None Do not return anything, modify nums in-place instead.
    """
    if k != 0:
        n = len(nums)
        k = k % n
        nums[:] = nums[k + 1:] + nums[:k + 1]
		# 原nums值改变

def rotate(self, nums, k):
    """
    :type nums: List[int]
    :type k: int
    :rtype: None Do not return anything, modify nums in-place instead.
    """
    if k != 0:
        n = len(nums)
        k = k % n
        nums = nums[k + 1:] + nums[:k + 1]
        # 原nums值不改变

可迭代对象、迭代器、生成器

• 可迭代的对象
  含iter 方法，每次都实例化一个新的迭代器。

• 迭代器
  要实现 next 方法，返回单个元素，此外还要实现 iter 方法，返回迭代器本身。
  因此，迭代器是可迭代的，但是，可迭代对象不是迭代器。

• 生成器
  是一种特殊的迭代器，它不需要再像上面的类一样写 iter()和 next()方法了，只需要一个 yiled关键字。生成器一定是迭代器，反之不成立。

• 生成器表达式
  是列表推倒式的生成器版本，看起来像列表推导式，但是它返回的是一个生成器对象而不是列表对象。

闭包、装饰器

闭包
外部函数FunOut()里面包含一个内部函数FunIn(),并且外部函数返回内部函数的对象FunIn，内部函数存在对外部函数的变量的引用。那么这个内部函数FunIn就叫做闭包。
在闭包中，由于内部函数存在对外部函数的变量的引用，所以即使外部函数执行完毕，该变量依然存在。

def line_conf(a, b):
    def line(x):
        return ax + b
    return line
 
line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5), line2(5))

这个例子中，函数line与环境变量a,b构成闭包。在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个环境变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。

装饰器
装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。装饰器接受其他函数为参数并返回一个装饰过的函数（或其他对象）。

# 函数式装饰器 带参数
def decoratorFunctionWithArguments(arg1, arg2, arg3):
    def wrap(f):
        print "Inside wrap()"

        def wrapped_f(*args):
            print "Inside wrapped_f()"
            print "Decorator arguments:", arg1, arg2, arg3
            f(*args)
            print "After f(*args)"

        return wrapped_f

    return wrap


@decoratorFunctionWithArguments("hello", "world", 42)
def sayHello(a1, a2, a3, a4):
    print 'sayHello arguments:', a1, a2, a3, a4


print "After decoration"
print "Preparing to call sayHello()"
sayHello("say", "hello", "argument", "list")
print "after first sayHello() call"
sayHello("a", "different", "set of", "arguments")
print "after second sayHello() call"

Inside wrap()
After decoration
Preparing to call sayHello()
Inside wrapped_f()
Decorator arguments: hello world 42
sayHello arguments: say hello argument list
After f(*args)
after first sayHello() call
Inside wrapped_f()
Decorator arguments: hello world 42
sayHello arguments: a different set of arguments
After f(*args)
after second sayHello() call

实现单例

def singleton(cls):
    instances = {}

    def _singleton():
        if cls not in instances:
            instances[cls] = cls()

        return instances[cls]

    return _singleton


class Singleton(object):
    __instance = None

    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            cls.__instance = object.__new__(*args, **kwargs)
        return cls.__instance

map reduce filter sorted

1.map(func, list)是python中的高阶函数，它接收一个函数 f 和一个集合 list，它会把每个list里面的元素带到函数 f 中 进行计算并返回一个新的list，并不会改变原来list。

2.reduce(func, list)函数接收的参数和map函数类似，也是一个函数 f 和一个集合 list,，但是每次必须传入2个参数，并返回最终结果值

3.filter(func list)函数也是接收一个函数 f 和一个集合 list, 它会对集合里面的每一个元素进行判断返回True和False，自动过滤掉不符合条件的元素，筛选出符合条件的元素组成新的集合

4.sorted(list)可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入的两个的元素 x, y，如果 x应该排在 y 的前面，返回 -1，如果 x应该排在 y 的后面，返回 1。如果 x和 y 相等，返回 0。
例： 按字典值倒序排序
sorted(dict.items(), key=lambda x: x[1], reverse=True)