python基础之面试常问

参考：

python面试常问

---

目录

• python内存管理机制，gc机制的了解，gc回收三种算法。
• lambda函数
• 高级函数 map、reduce、filter、sorted等。
• 简述六种基本数据类型（number、string、list、tuple、dict、set）。
• python中深拷贝与浅拷贝。
• python中is和==的区别。
• python中if __ name ==' main __'有什么含义?
• python命令和python -m命令在执行脚本时的区别？
• python中多进程、多线程、协程。
• python中迭代器、生成器。
• python中装饰器。
• python中单引号、双引号、三引号的应用场景与区别。
• python如何体现面对对象的三大特性。
• python中异常管理的机制。
• python函数闭包。

---

python内存管理机制，gc机制的了解，gc回收三种算法。

python内存管理（原博文——python内存管理）

• python是动态语言，对象与引用分类，一个变量使用不需要事先声明，而在赋值时，变量可以重新赋值为任意值。

• python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。当我们创建多个等于1的引用时，实际上是让所有这些引用指向同一个对象。（可以通过is判断是不是同一个对象）

• 在python中，每个对象都有存有指向该对象的引用总数，即引用计数(reference count)。我们可以使用sys包中的getrefcount()，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。

• python的一个容器对象(container)，比如表、词典等，可以包含多个对象。实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。

• python中对象可以引用对象，对象的相互引用会构成引用环。

• 引用减少的情况：1. del删除某一个对象的引用；2. 如果某个引用指向对象A，当这个引用重新被定义到其他对象时，引用数减少。

python垃圾回收

• 从基本原理上，当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。但是，垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。

• 我们可以通过gc模块的get_threshold()方法，查看该阈值:

  import gc
  print(gc.get_threshold())
  

  返回(700, 10, 10)，后面的两个10是与分代回收相关的阈值，后面可以看到。700即是垃圾回收启动的阈值。可以通过gc中的set_threshold()方法重新设置。我们也可以手动启动垃圾回收，即使用gc.collect()。

• 分代回收： python同时采用了分代(generation)回收的策略。这一策略的基本假设是，存活时间越久的对象，越不可能在后面的程序中变成垃圾。我们的程序往往会产生大量的对象，许多对象很快产生和消失，但也有一些对象长期被使用。出于信任和效率，对于这样一些“长寿”对象，我们相信它们的用处，所以减少在垃圾回收中扫描它们的频率。python将所有的对象分为0，1，2三代。所有的新建对象都是0代对象。当某一代对象经历过垃圾回收，依然存活，那么它就被归入下一代对象。垃圾回收启动时，一定会扫描所有的0代对象。如果0代经过一定次数垃圾回收，那么就启动对0代和1代的扫描清理。当1代也经历了一定次数的垃圾回收后，那么会启动对0，1，2，即对所有对象进行扫描。这两个次数即上面get_threshold()返回的(700, 10, 10)返回的两个10。也就是说，每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收。同样可以用set_threshold()来调整，比如对2代对象进行更频繁的扫描。

• 孤立的引用环： 引用环的存在会给上面的垃圾回收机制带来很大的困难。这些引用环可能构成无法使用，但引用计数不为0的一些对象。比如我们创建了两个表对象，并引用对方，构成一个引用环。删除了a，b引用之后，这两个对象不可能再从程序中调用，就没有什么用处了。但是由于引用环的存在，这两个对象的引用计数都没有降到0，不会被垃圾回收。

  a = []
  b = [a]
  a.append(b)
  
  del a
  del b
  

  为了回收这样的引用环，python复制每个对象的引用计数，可以记为gc_ref。假设，每个对象i，该计数为gc_ref_i。python会遍历所有的对象i。对于每个对象i引用的对象j，将相应的gc_ref_j减1。在结束遍历后，gc_ref不为0的对象，和这些对象引用的对象，以及继续更下游引用的对象，需要被保留。而其它的对象则被垃圾回收。

---

lambda函数

lambda作为一个表达式，定义了一个匿名函数。lambda表达式是起到一个函数速写的作用，允许在代码内嵌入一个函数的定义。例如：

func1 = lambda x,y:x+y

def func2(x,y):
    return x+y

func1和func2其实作用相同。

lambda的优点是代码比较简洁，缺点是易读性不好。

---

高级函数 map、reduce、filter、sorted等。

菜鸟教程——python内置函数

map()

map() 会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

map(function, iterable,...)

返回值：python 2.x返回列表，python3.x返回迭代器。

以python3为例：

a = map(lambda x:x**2,[1,2,3,4])
print(a)
print(list(a))

输出：

<map object at 0x000001EB55F4C710>
[1, 4, 9, 16]

filter()

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

# 第一个参数是判断函数，第二个参数是可迭代对象
filter(function, iterable)

实例：

a = filter(lambda x:x%2==0,[1,2,3,4])
print(a)
print(list(a))

输出：

<filter object at 0x000001EB55F44F60>
[2, 4]

reduce()

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 function，一个可迭代对象，但行为和 map()不同，reduce()传入的函数必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

在python3中，reduce()函数已经从全局函数中移除了，放在fucntools，所以我们首先得导入从fucntools中导入reduce()函数。

reduce(function, iterable)

实例：

from functools import reduce
sum = reduce(lambda x,y:x+y,[1,3,5,7,9])
print(sum)

输出：

25

sorted()

sorted() 函数对所有可迭代的对象进行排序操作。

sort与sorted的区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted(iterable, key=None, reverse=False)

• iterable -- 可迭代对象。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

实例：

nums = [[2,1],[3,4],[5,2],[4,10]]
# 将二维数组按第一列逆序排列
sorted(nums, key = lambda x:x[0], reverse = True)

输出：

[[5, 2], [4, 10], [3, 4], [2, 1]]

---

简述六种基本数据类型（number、string、list、tuple、dict、set）。

数字number菜鸟教程——python3数字

Python 支持三种不同的数值类型：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

python数字类型转换：

• int(x) 将x转换为一个整数。

• float(x) 将x转换到一个浮点数。

• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

字符串string菜鸟教程——python3字符串

• 创建：可以用单引号或者双引号创建。

• 切片：string类型支持切片。

• 拼接：可以用加号拼接两个字符串。

• ...（内容比较多，参考上面的链接）

列表list菜鸟教程——python3列表

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

其他的参见上面的链接。

元组tuple菜鸟教程——python3元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号（但是访问元组中的元素用中括号，例如：tuple[0]），列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

注意：元组中只有一个元素时，需要在该元素后面加一个逗号，如下：

tuple1 = (1)
tuple2 = (1,)
print(type(tuple1),type(tuple2))

输出：

<class 'int'> <class 'tuple'>

• 元组允许两个元组相加得到新的元组。（tuple1 + tuple2 = tuple3）

• 元组中元素不能删除，但是可以删除整个元组。（del tuple）

• 元组很多方法跟列表都是互通的。

字典dict菜鸟教程——python3字典

• 字典是另一种可变容器模型，且可存储任意类型对象。

• 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号{}中。

• 键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

• 字典方法很多，参见链接。

集合set菜鸟教程——python3集合

• 集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

• 方法参见链接。

---

python中深拷贝与浅拷贝。

原博文——python 深拷贝与浅拷贝

• Python中对象的赋值都是进行对象引用（内存地址）传递
• 使用copy.copy()，可以进行对象的浅拷贝，它复制了对象，但对于对象中的元素，依然使用原始的引用。
• 如果需要复制一个容器对象，以及它里面的所有元素（包含元素的子元素），可以使用copy.deepcopy()进行深拷贝。
• 对于非容器类型（如数字、字符串、和其他'原子'类型的对象）没有被拷贝一说
• 如果元祖变量只包含原子类型对象，则不能深拷贝

例如：

import copy
a = [1, [1,2]]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
print(b is a, c is a, d is a)
print('判断copy函数浅拷贝之后，容器内部的对象是不是地址一致：',c[1] is a[1],c[0] is a[0])

a[1][1] = 3
print(a, b, c, d)

输出：

True False False
判断copy函数浅拷贝之后，容器内部的对象是不是地址一致： True True
[1, [1, 3]] [1, [1, 3]] [1, [1, 3]] [1, [1, 2]]

---

python中is和==的区别。

原博文——python中is和==的区别

Python中对象包含的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)。

• ==是python标准操作符中的比较操作符，用来比较判断两个对象的value(值)是否相等。

• is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同。

例如：

a = [1]
c = [1]
print(a == c, a is c)

输出：

True False

• 事实上Python 为了优化速度，使用了小整数对象池，避免为整数频繁申请和销毁内存空间。而Python 对小整数的定义是 [-5, 257)，只有数字在-5到256之间它们的id才会相等，超过了这个范围就不行了，同样的道理，字符串对象也有一个类似的缓冲池，超过区间范围内自然不会相等了。 总的来说，只有数值型和字符串型，并且在通用对象池中的情况下，a is b才为True，否则当a和b是int，str，tuple，list，dict或set型时，a is b均为False。

例如：

a = 2
c = 2
print(a == c, a is c)

输出：

True True

---

python中if __ name ==' main __'有什么含义?

---

python命令和python -m命令在执行脚本时的区别？

---

python中多进程、多线程、协程。

---

python中迭代器、生成器。

菜鸟教程——python3迭代器与生成器

迭代器：

• 迭代是Python最强大的功能之一，是访问集合元素（字符串、列表、元组、集合、字典）的一种方式。迭代器是一个可以记住遍历的位置的对象。

• 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。（迭代器可以使用for语句进行遍历）

• 迭代器有两个基本的方法：iter() 和 next()。

实例：

a =[1, 2, 3, 4]
b = iter(a)
print(type(b))
while True:
    try:
        print(next(b))
    except:
        print('over')
        break

输出：

<class 'list_iterator'>
1
2
3
4
over

生成器：

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。调用一个生成器函数，返回的是一个迭代器对象。

实例：

def helper(n):
    i = 0
    while i<n:
        yield i
        i += 1

f = helper(5)
while True:
    try:
        print(next(f))
    except:
        print('over')
        break

输出：

0
1
2
3
4
over

---

python中装饰器。

---

python中单引号、双引号、三引号的应用场景与区别。

---

python如何体现面对对象的三大特性。

---

python中异常管理的机制。

---

python函数闭包。