Python基础知识面试

1、可变与不可变类型

• 不可变类型：
  该对象所指向的内存中的值不能被改变。当改变某个变量时，相当于把原来的值复制一份后再改变，相当于开辟了一个新地址，变量再指向这个地址。

  常见的不可变类型：数字，字符串，元组，不可变集合, int,float,str,tople

• 可变类型：
  该对象所指向的内存中的值可以被改变。当改变某个变量的时候，实际上所指的值直接发生改变，没有发生复制行为。

  常见的不可变类型：列表，字典，可变集合,list,dict,set

  注：python可以用is来判断是否指向同一个地址

2、浅拷贝与深拷贝

• Python中有值类型与引用类型之分（对应可变对象和不可变对象）

• 值类型的对象在内存中占固定内存空间，所以他们的值保存在栈，按值访问数据。

• 引用类型的对象大小不固定，所以只将他们的内存地址存放在栈，由于内存地址指向实际对象，所有引用类型是按引用访问。

• 浅拷贝：
  只复制某个对象的内存地址，新旧变量共享同一内存同一对象
  例：

>>> import copy
>>> alist = [1,2,3,["a","b"]]
>>> c = copy.copy(alist)
>>> print(alist)
[1, 2, 3, ['a', 'b']]
>>> print(c)
[1, 2, 3, ['a', 'b']]
>>> alist[3]
['a', 'b']
>>> alist[3].append('ccc')
>>> print(alist)
[1, 2, 3, ['a', 'b', 'ccc']]
>>> print(c)
[1, 2, 3, ['a', 'b', 'ccc']]

copy浅拷贝，因为没有拷贝子对象，所以原始数据改变，子对象也会改变

• 深拷贝：
  直接复制对象本身，新的对象时独立的，拥有不一样的内存地址，对原对象的修改不影响新对象
  例：

>>> import copy
>>> alist = [1,2,3,["a","b"]]
>>> d = copy.deepcopy(alist)
>>> alist.append(5)

深拷贝包含对象里面的子对象的拷贝，所以原始对象的改变不会造成拷贝里任何子元素的改变

3 、__new__和__init__的区别

• 构造方法包括创建对象和初始化对象，在Python中，分两步执行。
• 先执行__new__方法，然后执行__init__方法。前者可决定是否调用后者。
• __new__是在创建实例之前被调用的，他的任务就是创建实例然后返回该实例，是一个静态方法。
• __init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值。
• 在面向对象编程中，实例化遵循创建X，初始化X，返回X（实例化对象）的顺序，new是创建，init是初始化。
  例：

class A(object):def __init__(self):print(self)print("This is an 'init' method!")def __new__(cls):print(id(cls))print("This is a 'new' method!")ret = object.__new__(cls)print(ret)return retif __name__ == "__main__":a = A()print(id(A))print("------------------------")print(a)

运行结果：

总结：

• __new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供

• __new__必须要有返回值，返回实例化出来的示例，这点在自己实现__new__时，可以return父类__new__出来的示例，或者直接是object的__new__出来的实例

• __init__不需要返回值。__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其他初始化的动作 。

• 如果把类比作一道菜，__new__方法就是去超市买菜，__init__方法就是在厨房烹饪做菜。

4、设计模式

• 什么是设计模式：
  是结果总结，优化后的可重用解决方案。是一种diamante设计思想，不同的模式解决不同的问题。
• 有那些设计模式：

  • 工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪个类。
    适用性：
    当一个类不知道它所必须创建的对象的类的时候。
    当一个类希望由它的子类来指定它所创建的对象的时候。
    当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
    代码实现：

    class Person: #基类(超类)：提供一个抽象的接口来创建一个特定类型的对象def __init__(self, name, gender):self.name = nameself.gender = genderdef getName(self):return self.namedef getGender(self):return self.genderclass Male(Person): #子类1：继承自基类的子类def __init__(self, name, gender):super().__init__(name, gender)print(self.gender, name)class Female(Person): #子类2：继承自基类的子类def __init__(self, name, gender):super().__init__(name, gender)print(self.gender, name)class Factory: #工厂类（简易版可以只提供一个工厂函数）def getPerson(self, name, gender): #工厂方法：是创建类的入口，用于创建用户想要的类if gender == 'M':return Male(name, 'male')if gender == 'F':return Female(name, 'female')factory = Factory()
    male = factory.getPerson("Chetan", "M")
    female = factory.getPerson('Charle', 'F')
    

  • 单例模式 ：保证程序运行时全局环境中只有一个该类的实例
    适用性：
    无论何时何处调用该类，都能使用同一个该类的实例对象。

    class Singleton: #一个通用的单例超类，其他类继承即可（也可通过装饰器实现）def __new__(cls, *args, **kw):if not hasattr(cls, '_instance'):cls._instance = object.__new__(cls)return cls._instanceclass SingleSpam(Singleton):def __init__(self, s):self.s = sdef __str__(self):return self.ss1 = SingleSpam('spam')
    print(id(s1), s1)
    s2 = SingleSpam('spa')
    print(id(s2), s2)
    print(id(s1), s1) #s1被s2替换，永远只有一个SingleSpam实例对象		
    

  • 装饰模式：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。
    代码实现：

  class foo(object): #原类def f1(self):print("original f1")def f2(self):print("original f2")class foo_decorator(object): #装饰类def __init__(self, decorate):self._decorate = decoratedef f1(self): #给原类方法添加功能print("decorated f1") #可以是logging self._decorate.f1()def __getattr__(self, name):return getattr(self._decoratee, name)u = foo()
  v = foo_decorator(u) #通过将实例作为参数传入的方式，动态修改对象的方法
  v.f1()
  v.f2()
  

  • 迭代器模式：提供一种方法顺序访问一个聚合对象中各个元素，而又不需要暴露该对象的内部表示。
    适用性：

    • 访问一个聚合对象的内容而无需暴露它的内部表示。
    • 支持对聚合对象的多种遍历
    • 为遍历不同的聚合结构提供一个统一的接口。

    代码实现：

    class concreIterator():def __init__(self, container):self._a = containerself.index = -1def first(self):return self._a[0] if self._a else Nonedef isDone(self):if self.index + 1 >= len(self._a):return Truereturn Falsedef next(self):try:ret = self._a[self.index+1]self.index += 1return retexcept:return Nonedef currItem(self):return self._a[self.index]i = concreIterator([1,2,3,4,6])while not i.isDone():print(i.next())print(i.next()) # None# 使用magic方法构建迭代器
    class iterable2:def __init__(self,container):self._a = containerself._index= -1def __iter__(self):return selfdef __next__(self):try:ret = self._a[self._index+1]self._index += 1return retexcept:raise StopIterationprint(iterable2([1,2,3]))
    for i in iterable2([1,2,3]):print(i)		
    

5、列表推导式和生成器的优劣

• 列表推导式：
  和列表一样，用方括号[]表示，并用到了一个简写的for循环。
  如：

  print([(x+1,y+1,z**1) for x in range(3) if x%2==0 for y in range(5) for z in range(6)])
  

  结果：

  [(1, 1, 0), (1, 1, 1), (1, 1, 2), (1, 1, 3), (1, 1, 4), (1, 1, 5), (1, 2, 0), (1, 2, 1), (1, 2, 2), (1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 0), (1, 3, 1), (1, 3, 2), (1, 3, 3), (1, 3, 4), (1, 3, 5), (1, 4, 0), (1, 4, 1), (1, 4, 2), (1, 4, 3), (1, 4, 4), (1, 4, 5), (1, 5, 0), (1, 5, 1), (1, 5, 2), (1, 5, 3), (1, 5, 4), (1, 5, 5), (3, 1, 0), (3, 1, 1), (3, 1, 2), (3, 1, 3), (3, 1, 4), (3, 1, 5), (3, 2, 0), (3, 2, 1), (3, 2, 2), (3, 2, 3), (3, 2, 4), (3, 2, 5), (3, 3, 0), (3, 3, 1), (3, 3, 2), (3, 3, 3), (3, 3, 4), (3, 3, 5), (3, 4, 0), (3, 4, 1), (3, 4, 2), (3, 4, 3), (3, 4, 4), (3, 4, 5), (3, 5, 0), (3, 5, 1), (3, 5, 2), (3, 5, 3), (3, 5, 4), (3, 5, 5)]
  

• 生成器表达式：
  惰性计算，延迟求值。不会再生成器表达式被执行时就像列表生成器一样把整个列表返回出来，而只会在你需要列表中某个元素的时候在进行计算并返回。且生成器有自己的命令，用next命令返回生成器的下一个值。
  如：

  a=[x*x for x in range(5)]
  b=(x*x for x in range(5))
  print(a,b)
  print(next(b),next(b))
  

  结果：

  [0, 1, 4, 9, 16] <generator object <genexpr> at 0x0000020EB9169408>
  0 1
  

• 推导式：它将所有元素一次性加载到内存中，适合数量小的元素集合表示

• 生成器：本质是迭代器，只能遍历使用，每次返回一个元素，没有下一个元素时抛出异常。适合大数据量的处理。

6、什么是装饰器，如何在函数之后进行装饰？

• Python装饰器就是用于拓展原来函数功能的一种函数，这个函数的特殊之处在于它的返回值也是一个函数，使用装饰器的好处就是不用在更改原函数的代码的前提下给函数增加新的功能。

• 要在函数后进行装饰，只需要新增一个函数或类，将原函数作为参数传入新函数/类的方法中，在中其执行原函数，并在执行前后添加想要的功能即可。

• Python装饰器的4种类型：

  • 1、函数装饰函数

  	def wrapFun(func):def inner(a,b):print('function name:',func.__name__)r = func(a,b)return inner@wrapFundef myadd(a,b):return a+bif __name__ == "__main__":print(myadd(2,3))
  

  • 2、函数装饰类

  	def wrapClass(cls):def inner(a):print('class name:', cls.__name__)return cls(a)return inner@wrapClassclass Foo():def __init__(self,a):self.a = a def fun(self):print('self.a =', self.a)if __name__ == "__main__":m = Foo('xiemanR')m.fun()
  

  • 3、类装饰类

  	class ShowClassName(object):def __init__(self, cls):self._cls = clsdef __call__(self, a):print('class name:', self._cls.__name__)return self._cls(a)@ShowClassNameclass Foobar(object):def __init__(self, a):self.value = adef fun(self):print(self.value)a = Foobar('xiemanR')a.fun()
  

  • 4、类装饰函数

  	class ShowClassName(object):def __init__(self, cls):self._cls = clsdef __call__(self, a):print('class name:', self._cls.__name__)return self._cls(a)@ShowClassNameclass Foobar(object):def __init__(self, a):self.value = adef fun(self):print(self.value)a = Foobar('xiemanR')a.fun()
  

7、使用装饰器的单例模式和其他方法（如new方法，或者单文件实现的单例）相比，有何区别？

使用装饰器实现不会重新初始化对象，它是直接放回之前的对象；
而其他方法会再执行一次init方法，这也是装饰器实现单例的好处。

8、谈谈线程与进程的区别

• 进程：一个在内存中运行的应用程序。每个进程都有自己独立的内存空间，一个进程可以有多个线程。
• 线程：进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可以共享数据。线程又被成为轻量级进程。
• 从四个方面分析两者的区别：
  • 调度：进程是操作系统资源分配的基本单位，线程是处理器任务调度和执行的基本单位。
  • 开销：创建一个进程需要系统单独分配新的地址空间，代价昂贵；而创建新的线程可以直接使用进程的存储空间，所以进程开销大于线程。
  • 通信方式：进程间通信一般通过HTTP，RPC方式；而同一进程下的不同线程间是共享全局变量的，通信更加便捷。
  • 健壮性：单个进程死掉不会影响其他进程，而单个线程死掉会导致整个进程死掉。
  • 包含关系：如果一个进程内有多个线程，则执行过程不是一条线的，而是多线程共同完成的； 线程是进程的一部分，所以线程被称为轻量级进程。
  • 执行过程：每个进程都有程序运行的入口，顺序执行序列和程序出口。但线程不能独立运行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发进行。

9、谈谈Python垃圾回收机制

垃圾回收机制属于python内存管理机制中的一种。

• Python内存管理机制有三种：
  • 引用计数机制
  • 垃圾回收机制
  • 内存池机制

引用计数机制

Python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数，当对象被创建时就创建一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收。
特性：

• 当给一个对象分配一个新名称或者将一个对象放入一个容器（列表，元组，字典）时，该对象的引用计数都会增加。
• 当使用del对对象显示销毁或者引用超出作用域或者被重新赋值时，该对象的引用计数就会减少。
• 可以使用sys.gettrefcount()函数来获取对象的当前引用计数。多数情况下，引用计数要比我么猜测的大得多。对于不可变数据（数字，字符串），解释器会在程序的不同部分共享内存，以便节约内存。

垃圾回收机制

作用：
从经过引用计数器机制后还没有被释放掉内存的对象中，找到循环引用对象，并释放掉其内存、

• 1、引用计数
  引用计数也是一种垃圾收集机制。当某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。
  缺点：不能处理一种特殊情况，即循环引用，这种情况需要另外一种机制，即标记清除。

• 2、标记清除
  属于一种追踪式收集法，与引用计数不同，一般在已申请内存空间达到阀值时触发。若垃圾回收后仍然内存不足，就报错。
  原理：从位于内存中的一个根集开始，找到所有可达的对象集合，剩下不可达的对象都是待回收的垃圾。
  过程：
  1.从根集开始，标记所有可达对象（这一步将进行循环引用的的拆除，然后可以识别真正的垃圾对象）
  2.遍历所有对象，回收未标记对象（不可达对象）占用的内存。（不可达：用户无法调用，且引用计数不为0的对象）
  带来新问题：当内存中的对象较多时，而真正需要的回收的对象又很少的时候，对这些可达对象的检测是很耗时的，
  若生存周期较长的对象占比较大，那么每次垃圾回收就是低效率高耗时的操作，有较大优化空间，这时候又引入分代回收机制。

• 3、分代回收
  从前面“标记-清除”这样的垃圾收集机制来看，这种垃圾收集机制所带来的额外操作实际上与系统中总的内存块的数量是相关的，当需要回收的内存块越多时，垃圾检测带来的额外操作就越多，而垃圾回收带来的额外操作就越少；反之，当需回收的内存块越少时，垃圾检测就将比垃圾回收带来更少的额外操作。

import sys,gcgc.set_debug(gc.DEBUG_STATS | gc.DEBUG_LEAK) #开启gc调试
a = []
b = []
a.append(b)
print(sys.getrefcount(a)) # 2，但a真实的引用计数应该是2-1=1 ,这个函数获取的计数包含一个引用副本
b.append(a)
print(sys.getrefcount(a)) # 3
print(a) # [[[...]]]del a,b #显式删除变量，对应变量引用计数应该清零，但由于循环引用，其引用计数仍然为一。#print(sys.getrefcount(a))  #显式删除后无法再调用变量，此步异常unreachable_count = gc.collect() #执行垃圾回收（用的就是标记-清除算法），得到所有的不可达对象（垃圾）print(666, gc.garbage)  # [] 查看待回收的垃圾对象列表
print(unreachable_count) #检测此刻内存中的不可达对象的数量，所谓不可达：用户无法调用，且引用计数不为0，这也是内存泄露的原因之一print(gc.collect()) # 0，即垃圾回收成功

10、*args and **kwargs 如何使用

*args代表位置参数，它会接收任意多个参数并把这些参数作为元组传递给函数。（将数据解析为元组）
**kwargs代表的关键字参数，允许你使用没有事先定义的参数名，kwargs是一个dict；（将数据解析为字典）
此外，位置参数一定要放在关键字参数的前面。