• http://www.codingonway.com/
• https://github.com/revotu/python-interviews
• https://github.com/taizilongxu/interview_python

• 当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。
• 当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。

• Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。
• Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。
• 对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。

• 普通参数

def fun(name):
    print('Hello', name)

fun('World')#Hello World

• 默认参数

def fun(name, age=1):
    print('Hello', name, age, '年')

fun('World')  # Hello World 1 年

• 元组参数，即 *args

def fun(name, age=1, *args):
    print('Hello', name, age, '年')  # Hello World 1 年
    print(args)  # ('I', 'love', 'it')
    for i in args:
        print(i)

fun('World', 1, 'I', 'love', 'it')  
输出结果：
I 
love 
it

• 字典参数，即 **kwargs

def fun(name, age=1, *args, **kwargs):
    print('Hello', name, age, '年')  # Hello World 1 年
    print(args)  # ('I', 'love', 'it')
    for i in args:
        print(i)
    print(kwargs)  # {'my': 'jack', 'like': 'girl'}
    for m in kwargs:
        print(m, ':', kwargs[m])

fun('World', 1, 'I', 'love', 'it', my='jack', like='girl')
输出结果：
Hello World 1 年
('I', 'love', 'it')
I
love
it
{'my': 'jack', 'like': 'girl'}
my : jack
like : girl

1. 赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。
2. 浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）{1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数}
3. 深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）{copy模块的deep.deepcopy()函数}

• copy 仅拷贝对象本身，而不拷贝对象中引用的其它对象。
• deepcopy 除拷贝对象本身，而且拷贝对象中引用的其它对象。
  

  代码实例
  import copy
  a = [1, 2, 3, 4, ['a', 'b']] #原始对象
   
  b = a #赋值，传对象的引用
  c = copy.copy(a) #对象拷贝，浅拷贝
  d = copy.deepcopy(a) #对象拷贝，深拷贝
   
  a.append(5) #修改对象a
  a[4].append('c') #修改对象a中的['a', 'b']数组对象
   
  print 'a = ', a
  print 'b = ', b
  print 'c = ', c
  print 'd = ', d
   
  输出结果：
  a = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
  b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
  c = [1, 2, 3, 4, ['a', 'b', 'c']]
  d = [1, 2, 3, 4, ['a', 'b']]

• 那么对于情况 1 ，函数功能相同，但是参数类型不同，python 如何处理？答案是根本不需要处理，因为 python 可以接受任何类型的参数，如果函数的功能相同，那么不同的参数类型在 python 中很可能是相同的代码，没有必要做成两个不同函数。
• 那么对于情况 2 ，函数功能相同，但参数个数不同，python 如何处理？大家知道，答案就是缺省参数。对那些缺少的参数设定为缺省参数即可解决问题。因为你假设函数功能相同，那么那些缺少的参数终归是需要用的。

• __foo__:一种约定,Python内部的名字,用来区别其他用户自定义的命名,以防冲突.
• _foo:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.
• __foo:这个有真正的意义:解析器用_classname__foo来代替这个名字,以区别和其他类相同的命名.

• 使用模块

# mysingleton.py

class My_Singleton(object):
 def foo(self):
 pass
 
my_singleton = My_Singleton()

# to use
from mysingleton import my_singleton
 
my_singleton.foo()

• 使用类
  

  class Singleton(object):
  
      def __init__(self):
          pass
  
      @classmethod
      def instance(cls, *args, **kwargs):
          if not hasattr(Singleton, "_instance"):
              Singleton._instance = Singleton(*args, **kwargs)
          return Singleton._instance

• 基于__new__方法实现（推荐使用，方便）

import threading
class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
        pass

    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = object.__new__(cls)  
        return Singleton._instance

• 直接创建

• 工厂方法

• fromkeys()方法

• 相同点

• 不同点

• 可变的有：

• 不可变的有：

• 列表(list)推导式

• 字典(dict)推导式

• 集合(set)推导式

• 位置参数
• 默认参数，
• 可变参数,
• 关键字参数

• 类对象

• 实例对象

• 类属性绑定

• 实例属性绑定

• 类属性引用

• 实例属性引用

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。