2020-04-29 12:01:29 +08:00
## Python面试宝典 - 基础篇 - 2020
#### 题目001: 在Python中如何实现单例模式。
2020-05-05 19:37:11 +08:00
> **点评**： ， ， ， ， ， ，
2020-04-29 12:01:29 +08:00
方法一：使用装饰器实现单例模式。
```Python
from functools import wraps
def singleton(cls):
"""单例类装饰器"""
instances = {}
@wraps (cls)
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper
@singleton
class President:
pass
```
> **扩展**： ， ， ， ， ， ， （ ： ， ，
方法二：使用元类实现单例模式。
```Python
class SingletonMeta(type):
"""自定义单例元类"""
def __init__ (cls, *args, * *kwargs):
cls.__instance = None
super().__init__(*args, **kwargs)
def __call__ (cls, *args, * *kwargs):
if cls.__instance is None:
cls.__instance = super().__call__(*args, **kwargs)
return cls.__instance
class President(metaclass=SingletonMeta):
pass
```
> **扩展**： ， ， ， ， ， ，
2020-05-05 19:37:11 +08:00
> **补充**：关于单例模式，在面试中还有可能被问到它的应用场景。通常一个对象的状态是被其他对象共享的，就可以将其设计为单例，例如项目中使用的数据库连接池对象和配置对象通常都是单例，这样才能保证所有地方获取到的数据库连接和配置信息是完全一致的；而且由于对象只有唯一的实例，因此从根本上避免了重复创建对象造成的时间和空间上的开销，也避免了对资源的多重占用。再举个例子，项目中的日志操作通常也会使用单例模式，这是因为共享的日志文件一直处于打开状态，只能有一个实例去操作它，否则在写入日志的时候会产生混乱。
2020-04-29 12:01:29 +08:00
#### 题目002： ，
2020-05-05 19:37:11 +08:00
>**点评**： ， ， ， ，
2020-04-29 12:01:29 +08:00
方法一：
```Python
a = a ^ b
b = a ^ b
a = a ^ b
```
方法二：
```Python
a, b = b, a
```
> **扩展**：需要注意，`a, b = b, a`这种做法其实并不是元组解包， ， ， ， ，
#### 题目003： ，
> **点评**： ， ， ，
```Python
def dedup(items):
no_dup_items = []
seen = set()
for item in items:
if item not in seen:
no_dup_items.append(item)
seen.add(item)
return no_dup_items
```
如果愿意也可以把上面的函数改造成一个生成器，代码如下所示。
```Python
def dedup(items):
seen = set()
for item in items:
if item not in seen:
yield item
seen.add(item)
```
> **扩展**： ，
#### 题目004： ，
> **点评**： ， ，
```Python
a, b, c, d = 1, 1, 1000, 1000
print(a is b, c is d)
def foo():
e = 1000
f = 1000
print(e is f, e is d)
g = 1
print(g is a)
foo()
```
运行结果：
```
True False
True False
True
```
上面代码中`a is b`的结果是`True`但`c is d`的结果是`False`， ，
CPython底层为了进一步提升性能还做了另一个设定，
> **扩展**： （ ， ， ， ， ） ，
#### 题目005： ，
> **点评**： ， ， ， ，
Lambda函数也叫匿名函数， ， ， ，
> **扩展**： ， ， ： ，
>
> ```Python
> fac = lambda x: __import__('functools').reduce(int.__mul__, range(1, x + 1), 1)
> gcd = lambda x, y: y % x and gcd(y % x, x) or x
> ```
Lambda函数其实最为主要的用途是把一个函数传入另一个高阶函数（
```Python
items = [12, 5, 7, 10, 8, 19]
items = list(map(lambda x: x ** 2, filter(lambda x: x % 2, items)))
print(items) # [25, 49, 361]
```
> **扩展**：用列表的生成式来实现上面的代码会更加简单明了，代码如下所示。
>
> ```Python
> items = [12, 5, 7, 10, 8, 19]
> items = [x ** 2 for x in items if x % 2]
> print(items) # [25, 49, 361]
> ```
#### 题目006：
> **点评**：这个题目本身出现的频率非常高，但是就题论题而言没有什么技术含量。对于这种面试题，在**回答的时候一定要让你的答案能够超出面试官的预期**，这样才能**获得更好的印象分**。所以回答这个题目的要点不仅仅是能够说出浅拷贝和深拷贝的区别， ， ， ，
浅拷贝通常只复制对象本身， ， ： ， ；
`deepcopy` 函数的本质其实就是对象的一次序列化和一次返回序列化，面试题中还考过用自定义函数实现对象的深拷贝操作，显然我们可以使用`pickle`模块的`dumps`和`loads`来做到，代码如下所示。
```Python
import pickle
my_deep_copy = lambda obj: pickle.loads(pickle.dumps(obj))
```
列表的切片操作`[:]`相当于实现了列表对象的浅拷贝，而字典的`copy`方法可以实现字典对象的浅拷贝。对象拷贝其实是更为快捷的创建对象的方式。在Python中， ， ， ， ， （ ） ， ， ， ，
```Python
import copy
class PrototypeMeta(type):
"""实现原型模式的元类"""
def __init__ (cls, *args, * *kwargs):
super().__init__(*args, **kwargs)
# 为对象绑定clone方法来实现对象拷贝
cls.clone = lambda self, is_deep=True: \
copy.deepcopy(self) if is_deep else copy.copy(self)
class Person(metaclass=PrototypeMeta):
pass
p1 = Person()
p2 = p1.clone() # 深拷贝
p3 = p1.clone(is_deep=False) # 浅拷贝
```
#### 题目007： ？
> **点评**： ， ： ？ ， ， ，
Python提供了自动化的内存管理， ， ， ， ：
**引用计数**： ， ，
```C
typedef struct _object {
_PyObject_HEAD_EXTRA
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;
} PyObject;
```
以下情况会导致引用计数加`1`：
- 对象被创建
- 对象被引用
- 对象作为参数传入到一个函数中
- 对象作为元素存储到一个容器中
以下情况会导致引用计数减`1`：
- 用`del`语句显示删除对象引用
- 对象引用被重新赋值其他对象
- 一个对象离开它所在的作用域
- 持有该对象的容器自身被销毁
- 持有该对象的容器删除该对象
可以通过`sys`模块的`getrefcount`函数来获得对象的引用计数。引用计数的内存管理方式在遇到循环引用的时候就会出现致命伤，因此需要其他的垃圾回收算法对其进行补充。
**标记清理**： （ ） ： ， ， （ ） ， ； ， ， ， ， （ ） ， （ ） ， ， ， ， ） ； ） ， ， ； ，
**分代回收**： ， ， ， ， ， ，
#### 题目008：
> **点评**：很多人面试者都会写迭代器和生成器，但是却无法准确的解释什么是迭代器和生成器。如果你也有同样的困惑，可以参考下面的回答。
2020-05-05 19:37:11 +08:00
迭代器是实现了迭代器协议的对象。跟其他编程语言不通， ， ， ，
2020-04-29 12:01:29 +08:00
2020-05-05 19:37:11 +08:00
> **扩展**：面试中经常让写生成斐波那契数列的迭代器，大家可以参考下面的代码。
>
> ```Python
> class Fib(object):
>
> def __init__(self, num):
> self.num = num
> self.a, self.b = 0, 1
> self.idx = 0
>
> def __iter__(self):
> return self
>
> def __next__(self):
> if self.idx < self.num:
> self.a, self.b = self.b, self.a + self.b
> self.idx += 1
> return self.a
> raise StopIteration()
> ```
>
> 如果用生成器的语法来改写上面的代码，代码会简单优雅很多。
>
> ```Python
> def fib(num):
> a, b = 0, 1
> for _ in range(num):
> a, b = b, a + b
> yield a
> ```
2020-04-29 12:01:29 +08:00
#### 题目009： ？
> **点评**： ， ， ，
`match` 方法是从字符串的起始位置进行正则表达式匹配，返回`Match`对象或None。`search`方法会扫描整个字符串来找寻匹配的模式，
#### 题目010：
```Python
def multiply():
return [lambda x: i * x for i in range(4)]
print([m(100) for m in multiply()])
```
运行结果：
```
[300, 300, 300, 300]
```
上面代码的运行结果很容易被误判为`[0, 100, 200, 300]`。首先需要注意的是`multiply`函数用生成式语法返回了一个列表， ， （ ） ， ，
如果想得到`[0, 100, 200, 300]`这个结果，可以按照下面几种方式来修改`multiply`函数。
方法一：使用生成器，让函数获得`i`的当前值。
```Python
def multiply():
return (lambda x: i * x for i in range(4))
print([m(100) for m in multiply()])
```
或者
```Python
def multiply():
for i in range(4):
yield lambda x: x * i
print([m(100) for m in multiply()])
```
方法二：使用偏函数，彻底避开闭包。
```Python
from functools import partial
from operator import __mul__
def multiply():
return [partial(__mul__, i) for i in range(4)]
print([m(100) for m in multiply()])
```
#### 题目011： ？
> **点评**： ， ， （ ） ， ， ， ， ，
首先Python是解释型语言， ， ， ， ， ，
#### 题目012：
> **点评**： ，
下面的代码仅供参考：
```Python
def my_max(*args, key=None, default=None):
"""
获取可迭代对象中最大的元素或两个及以上实参中最大的元素
:param args: 一个可迭代对象或多个元素
:param key: 提取用于元素比较的特征值的函数，
:param default: 如果可迭代对象为空则返回该默认值，
:return: 返回可迭代对象或多个元素中的最大元素
"""
if len(args) == 1 and len(args[0]) == 0:
if default:
return default
else:
raise ValueError('max() arg is an empty sequence')
items = args[0] if len(args) == 1 else args
max_elem, max_value = items[0], items[0]
if key:
max_value = key(max_value)
for item in items:
value = item
if key:
value = key(item)
if value > max_value:
max_elem, max_value = item, value
return max_elem
```
#### 题目013：
> **点评**：送人头的题目，不解释。
```Python
def count_letters(items):
result = {}
for item in items:
if isinstance(item, (int, float)):
result[item] = result.get(item, 0) + 1
return result
```
也可以直接使用Python标准库中`collections`模块的`Counter`类来解决这个问题，`Counter`是`dict`的子类，它会将传入的序列中的每个元素作为键，元素出现的次数作为值来构造字典。
```Python
from collections import Counter
def count_letters(items):
counter = Counter(items)
return {key: value for key, value in counter.items() \
if isinstance(key, (int, float))}
```
#### 题目014：
> **点评**：基本也是送人头的题目，只要用过`os`模块就应该知道怎么做。
Python标准库`os`模块的`walk`函数提供了遍历一个文件夹的功能，它返回一个生成器。
```Python
import os
g = os.walk('/Users/Hao/Downloads/')
for path, dir_list, file_list in g:
for dir_name in dir_list:
print(os.path.join(path, dir_name))
for file_name in file_list:
print(os.path.join(path, file_name))
```
> **说明**：
#### 题目015： ， ， ？
> **点评**： ： ， ， ？ ， ，
```Python
from functools import lru_cache
@lru_cache ()
def change_money(total):
if total == 0:
return 1
if total < 0:
return 0
return change_money(total - 2) + change_money(total - 3) + \
change_money(total - 5)
```
> **说明**：在上面的代码中，我们用`lru_cache`装饰器装饰了递归函数`change_money`，如果不做这个优化，上面代码的渐近时间复杂度将会是$O(3^N)$，而如果参数`total`的值是`99`，这个运算量是非常巨大的。`lru_cache`装饰器会缓存函数的执行结果，这样就可以减少重复运算所造成的开销，这是空间换时间的策略，也是动态规划的编程思想。
#### 题目016： ，
> 例如： ， ：
>
> ```
> 1 2
> 4 3
> ```
>
> 例如： ， ：
>
> ```
> 1 2 3
> 8 9 4
> 7 6 5
> ```
这个题目本身并不复杂，下面的代码仅供参考。
```Python
def show_spiral_matrix(n):
matrix = [[0] * n for _ in range(n)]
row, col = 0, 0
num, direction = 1, 0
while num < = n ** 2:
if matrix[row][col] == 0:
matrix[row][col] = num
num += 1
if direction == 0:
if col < n - 1 and matrix [ row ] [ col + 1 ] = = 0:
col += 1
else:
direction += 1
elif direction == 1:
if row < n - 1 and matrix [ row + 1 ] [ col ] = = 0:
row += 1
else:
direction += 1
elif direction == 2:
if col > 0 and matrix[row][col - 1] == 0:
col -= 1
else:
direction += 1
else:
if row > 0 and matrix[row - 1][col] == 0:
row -= 1
else:
direction += 1
direction %= 4
for x in matrix:
for y in x:
print(y, end='\t')
print()
```
#### 题目017： ，
```Python
items = [1, 2, 3, 4]
print([i for i in items if i > 2])
print([i for i in items if i % 2])
print([(x, y) for x, y in zip('abcd', (1, 2, 3, 4, 5))])
print({x: f'item{x ** 2}' for x in (2, 4, 6)})
print(len({x for x in 'hello world' if x not in 'abcdefg'}))
```
> **点评**： （ ） ， ，
```
[3, 4]
[1, 3]
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
{2: 'item4', 4: 'item16', 6: 'item36'}
6
```
#### 题目018：
```Python
class Parent:
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
```
> **点评**：运行上面的代码首先输出`1 1 1`，这一点大家应该没有什么疑问。接下来，通过`Child1.x = 2`给类`Child1`重新绑定了属性`x`并赋值为`2`，所以`Child1.x`会输出`2`，而`Parent`和`Child2`并不受影响。执行`Parent.x = 3`会重新给`Parent`类的`x`属性赋值为`3`，由于`Child2`的`x`属性继承自`Parent`，所以`Child2.x`的值也是`3`；而之前我们为`Child1`重新绑定了`x`属性，那么它的`x`属性值不会受到`Parent.x = 3`的影响，还是之前的值`2`。
```
1 1 1
1 2 1
3 2 3
```
#### 题目19：
> **点评**： ， ， ，
| 模块名 | 介绍 |
| ---------------------------- | ------------------------------------------------------------ |
| sys | 跟Python解释器相关的变量和函数， ：
| os | 和操作系统相关的功能，例如：`os.listdir()`、`os.remove()` |
| re | 和正则表达式相关的功能，例如：`re.compile()`、`re.search()` |
| math | 和数学运算相关的功能，例如：`math.pi`、`math.e`、`math.cos` |
| logging | 和日志系统相关的类和函数，例如：`logging.Logger`、`logging.Handler` |
| json / pickle | 实现对象序列化和反序列的模块，例如：`json.loads`、`json.dumps` |
| hashlib | 封装了多种哈希摘要算法的模块，例如：`hashlib.md5`、`hashlib.sha1` |
| urllib | 包含了和URL相关的子模块， ：
| itertools | 提供各种迭代器的模块，例如：`itertools.cycle`、`itertools.product` |
| functools | 函数相关工具模块，例如：`functools.partial`、`functools.lru_cache` |
| collections / heapq | 封装了常用数据结构和算法的模块，例如：`collections.deque` |
| threading / multiprocessing | 多线程/多进程相关类和函数的模块，例如：`threading.Thread` |
| concurrent.futures / asyncio | 并发编程/异步编程相关的类和函数的模块，例如：`ThreadPoolExecutor` |
| base64 | 提供BASE-64编码相关函数的模块， ：
| csv | 和读写CSV文件相关的模块， ：
| profile / cProfile / pstats | 和代码性能剖析相关的模块，例如：`cProfile.run`、`pstats.Stats` |
| unittest | 和单元测试相关的模块，例如：`unittest.TestCase` |
#### 题目20：
Python中调用构造器创建对象属于两阶段构造过程， （ ） ，
#### 题目21： ，
方法一：不使用标准库中的模块和函数。
```Python
def is_leap_year(year):
"""判断指定的年份是不是闰年， ，
return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
def which_day(year, month, date):
"""计算传入的日期是这一年的第几天"""
# 用嵌套的列表保存平年和闰年每个月的天数
days_of_month = [
[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
[31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
]
days = days_of_month[is_leap_year(year)][:month - 1]
return sum(days) + date
```
方法二：使用标准库中的`datetime`模块。
```Python
import datetime
def which_day(year, month, date):
end = datetime.date(year, month, date)
start = datetime.date(year, 1, 1)
return (end - start).days + 1
```
#### 题目22：
> **点评**：静态代码分析工具可以从代码中提炼出各种静态属性，这使得开发者可以对代码的复杂性、可维护性和可读性有更好的了解，这里所说的静态属性包括：
>
> 1. 代码是否符合编码规范， ：
> 2. 代码中潜在的问题，包括：语法错误、缩进问题、导入缺失、变量覆盖等。
> 3. 代码中的坏味道。
> 4. 代码的复杂度。
> 5. 代码的逻辑问题。
工作中静态代码分析主要用到的是[Pylint](< https: / / www . pylint . org / > )和[Flake8](< https: / / flake8 . pycqa . org / en / latest / > )。Pylint可以检查出代码错误、坏味道、不规范的代码等问题， ， （ ） （ ） （ ） ，
#### 题目23：
> **点评**： ， ，
| 魔术方法 | 作用 |
| ------------------------------------------------------------ | ------------------ |
| `__new__` 、`__init__`、`__del__` | 创建和销毁对象相关 |
| `__add__` 、`__sub__`、`__mul__`、`__div__`、`__floordiv__`、`__mod__` | 算术运算符相关 |
| `__eq__` 、`__ne__`、`__lt__`、`__gt__`、`__le__`、`__ge__` | 关系运算符相关 |
| `__pos__` 、`__neg__`、`__invert__` | 一元运算符相关 |
| `__lshift__` 、`__rshift__`、`__and__`、`__or__`、`__xor__` | 位运算相关 |
| `__enter__` 、`__exit__` | 上下文管理器协议 |
| `__iter__` 、`__next__`、`__reversed__` | 迭代器协议 |
| `__int__` 、`__long__`、`__float__`、`__oct__`、`__hex__` | 类型/进制转换相关 |
| `__str__` 、`__repr__`、`__hash__`、`__dir__` | 对象表述相关 |
| `__len__` 、`__getitem__`、`__setitem__`、`__contains__`、`__missing__` | 序列相关 |
| `__copy__` 、`__deepcopy__` | 对象拷贝相关 |
| `__call__` 、`__setattr__`、`__getattr__`、`__delattr__` | 其他魔术方法 |
#### 题目24：
Python中，
#### 题目25：
2020-05-05 19:37:11 +08:00
> **点评**：高频面试题，也是最简单的装饰器，面试者**必须要掌握的内容**。
2020-04-29 12:01:29 +08:00
方法一：用函数实现装饰器。
```Python
from functools import wraps
from time import time
def record_time(func):
@wraps (func)
def wrapper(*args, **kwargs):
start = time()
result = func(*args, **kwargs)
print(f'{func.__name__}执行时间: {time() - start}秒')
return result
return wrapper
```
方法二：用类实现装饰器。类有`__call__`魔术方法，该类对象就是可调用对象，可以当做装饰器来使用。
```Python
from functools import wraps
from time import time
class Record:
def __call__ (self, func):
@wraps (func)
def wrapper(*args, **kwargs):
start = time()
result = func(*args, **kwargs)
print(f'{func.__name__}执行时间: {time() - start}秒')
return result
return wrapper
```
> **说明**：装饰器可以用来装饰类或函数，为其提供额外的能力，属于设计模式中的**代理模式**。
> **扩展**：
```Python
from functools import wraps
from time import time
def record_time(output):
"""可以参数化的装饰器"""
def decorate(func):
@wraps (func)
def wrapper(*args, **kwargs):
start = time()
result = func(*args, **kwargs)
output(func.__name__, time() - start)
return result
return wrapper
return decorate
```
#### 题目26： （ ） ？
鸭子类型是动态类型语言判断一个对象是不是某种类型时使用的方法，也叫做鸭子判定法。简单的说，鸭子类型是指判断一只鸟是不是鸭子，我们只关心它游泳像不像鸭子、叫起来像不像鸭子、走路像不像鸭子就足够了。换言之，如果对象的行为跟我们的预期是一致的（能够接受某些消息），我们就认定它是某种类型的对象。
在Python语言中， （ ： ） （ ： ） （ ： ） ， ， ，
> **说明**：动态语言的鸭子类型使得设计模式的应用被大大简化。
#### 题目27：
Python中有四种作用域， （ ） （ ） （ ） （ ） ， ，
#### 题目28：
闭包是支持一等函数的编程语言（ ） ， （ ） ， ， ，
#### 题目29：
线程是操作系统分配CPU的基本单位， ， ， ； ， （ ） ， ， ， ， （ ）
多线程适合那些会花费大量时间在I/O操作上， （ ： ）
> **扩展**： ， ， ，
#### 题目30：
> **点评**：这种问题千万不要背所谓的参考答案，说一些自己最熟悉的就足够了。
1. Python 2中的`print`和`exec`都是关键字，
2. Python 3中没有`long`类型，整数都是`int`类型。
3. Python 2中的不等号`< >`在Python 3中被废弃，
4. Python 2中的`xrange`函数在Python 3中被`range`函数取代。
5. Python 3对Python 2中不安全的`input`函数做出了改进，废弃了`raw_input`函数。
6. Python 2中的`file`函数被Python 3中的`open`函数取代。
7. Python 2中的`/`运算对于`int`类型是整除，
8. Python 3中改进了Python 2捕获异常的代码，
9. Python 3生成式中循环变量的作用域得到了更好的控制，
10. Python 3中的`round`函数可以返回`int`或`float`类型，
11. Python 3的`str`类型是Unicode字符串， ，
12. Python 3中的比较运算符必须比较同类对象。
13. Python 3中定义类的都是新式类， （ ） （ ） ， ，
14. Python 3对代码缩进的要求更加严格，
15. Python 3中字典的`keys`、`values`、`items`方法都不再返回`list`对象，而是返回`view object`，内置的`map`、`filter`等函数也不再返回`list`对象，而是返回迭代器对象。
16. Python 3标准库中某些模块的名字跟Python 2是有区别的； ， ，
2020-05-04 00:21:43 +08:00
####题目31： （ ）
“猴子补丁”是动态类型语言的一个特性， （ ） ， ，
在使用`gevent`库的时候，我们会在代码开头的地方执行`gevent.monkey.patch_all()`，这行代码的作用是把标准库中的`socket`模块给替换掉，这样我们在使用`socket`的时候，不用修改任何代码就可以实现对代码的协程化，达到提升性能的目的，这就是对猴子补丁的应用。
另外，如果希望用`ujson`三方库替换掉标准库中的`json`，也可以使用猴子补丁的方式，代码如下所示。
```Python
import json, ujson
json.__name__ = 'ujson'
json.dumps = ujson.dumps
json.loads = ujson.loads
```
单元测试中的`Mock`技术也是对猴子补丁的应用，
#### 题目32：
```Python
class A:
def who(self):
print('A', end='')
class B(A):
def who(self):
super(B, self).who()
print('B', end='')
class C(A):
def who(self):
super(C, self).who()
print('C', end='')
class D(B, C):
def who(self):
super(D, self).who()
print('D', end='')
item = D()
item.who()
```
> **点评**：这道题考查到了两个知识点：
>
> 1. Python中的MRO（ ） ， ， ， （ ） （ ） ， ， ； （ ） ，
> 2. `super()`函数的使用。在使用`super`函数时，可以通过`super(类型, 对象)`来指定对哪个对象以哪个类为起点向上搜索父类方法。所以上面`B`类代码中的`super(B, self).who()`表示以B类为起点， （ ）
```
ACBD
```
#### 题目33： ，
> **点评**：
```Python
import operator
class Stack:
"""栈（ ）
def __init__ (self):
self.elems = []
def push(self, elem):
"""入栈"""
self.elems.append(elem)
def pop(self):
"""出栈"""
return self.elems.pop()
@property
def is_empty(self):
"""检查栈是否为空"""
return len(self.elems) == 0
def eval_suffix(expr):
"""逆波兰表达式求值"""
operators = {
'+': operator.add,
'-': operator.sub,
'*': operator.mul,
'/': operator.truediv
}
stack = Stack()
for item in expr.split():
if item.isdigit():
stack.push(float(item))
else:
num2 = stack.pop()
num1 = stack.pop()
stack.push(operators[item](num1, num2))
return stack.pop()
```
#### 题目34： ？
Python中实现字符串替换大致有两类方法：
方法一：使用字符串的`replace`方法。
```Python
message = 'hello, world!'
print(message.replace('o', 'O').replace('l', 'L').replace('he', 'HE'))
```
方法二：使用正则表达式的`sub`方法。
```Python
import re
message = 'hello, world!'
pattern = re.compile('[aeiou]')
print(pattern.sub('#', message))
```
> **扩展**：还有一个相关的面试题，对保存文件名的列表排序，要求文件名按照字母表和数字大小进行排序，例如对于列表`filenames = ['a12.txt', 'a8.txt', 'b10.txt', 'b2.txt', 'b19.txt', 'a3.txt'] `，排序的结果是`['a3.txt', 'a8.txt', 'a12.txt', 'b2.txt', 'b10.txt', 'b19.txt']`。提示一下，可以通过字符串替换的方式为文件名补位，根据补位后的文件名用`sorted`函数来排序，大家可以思考下这个问题如何解决。
#### 题目35： ？
剖析代码性能可以使用Python标准库中的`cProfile`和`pstats`模块，`cProfile`的`run`函数可以执行代码并收集统计信息，创建出`Stats`对象并打印简单的剖析报告。`Stats`是`pstats`模块中的类，它是一个统计对象。当然，也可以使用三方工具`line_profiler`和`memory_profiler`来剖析每一行代码耗费的时间和内存， ， ， （ ）
下面是使用`cProfile`剖析代码性能的例子。
`example.py`
```Python
import cProfile
def is_prime(num):
for factor in range(2, int(num ** 0.5) + 1):
if num % factor == 0:
return False
return True
class PrimeIter:
def __init__ (self, total):
self.counter = 0
self.current = 1
self.total = total
def __iter__ (self):
return self
def __next__ (self):
if self.counter < self.total:
self.current += 1
while not is_prime(self.current):
self.current += 1
self.counter += 1
return self.current
raise StopIteration()
cProfile.run('list(PrimeIter(10000))')
```
如果使用`line_profiler`三方工具，可以直接剖析`is_prime`函数每行代码的性能，需要给`is_prime`函数添加一个`profiler`装饰器，代码如下所示。
```Python
@profiler
def is_prime(num):
for factor in range(2, int(num ** 0.5) + 1):
if num % factor == 0:
return False
return True
```
安装`line_profiler`。
```Bash
pip install line_profiler
```
使用`line_profiler`。
```Bash
kernprof -lv example.py
```
运行结果如下所示。
```
Line # Hits Time Per Hit % Time Line Contents
==============================================================
1 @profile
2 def is_prime(num):
3 86624 48420.0 0.6 50.5 for factor in range(2, int(num ** 0.5) + 1):
4 85624 44000.0 0.5 45.9 if num % factor == 0:
5 6918 3080.0 0.4 3.2 return False
6 1000 430.0 0.4 0.4 return True
```
#### 题目36：
> **点评**： ， ， ，
1. `random.random()` 函数可以生成`[0.0, 1.0)`之间的随机浮点数。
2. `random.uniform(a, b)` 函数可以生成`[a, b]`或`[b, a]`之间的随机浮点数。
3. `random.randint(a, b)` 函数可以生成`[a, b]`或`[b, a]`之间的随机整数。
4. `random.shuffle(x)` 函数可以实现对序列`x`的原地随机乱序。
5. `random.choice(seq)` 函数可以从非空序列中取出一个随机元素。
6. `random.choices(population, weights=None, *, cum_weights=None, k=1)` 函数可以从总体中随机抽取（有放回抽样）出容量为`k`的样本并返回样本的列表，可以通过参数指定个体的权重，如果没有指定权重，个体被选中的概率均等。
7. `random.sample(population, k)` 函数可以从总体中随机抽取（无放回抽样）出容量为`k`的样本并返回样本的列表。
> **扩展**：
#### 题目37：
2020-05-05 19:37:11 +08:00
> **点评**： ， ，
2020-05-04 00:21:43 +08:00
线程池是一种用于减少线程本身创建和销毁造成的开销的技术， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ， ，
一般线程池都必须具备下面几个组成部分：
1. 线程池管理器：用于创建并管理线程池。
2. 工作线程和线程队列：线程池中实际执行的线程以及保存这些线程的容器。
3. 任务接口：将线程执行的任务抽象出来，形成任务接口，确保线程池与具体的任务无关。
4. 任务队列：线程池中保存等待被执行的任务的容器。
#### 题目38：
举一个简单的例子，变量`a`是一个字典，执行`int(a['x'])`这个操作就有可能引发上述三种类型的异常。如果字典中没有键`x`，会引发`KeyError`；如果键`x`对应的值不是`str`、`float`、`int`、`bool`以及`bytes-like`类型，在调用`int`函数构造`int`类型的对象时，会引发`TypeError`；如果`a[x]`是一个字符串或者字节串，而对应的内容又无法处理成`int`时，将引发`ValueError`。
#### 题目39：
```Python
def extend_list(val, items=[]):
items.append(val)
return items
list1 = extend_list(10)
list2 = extend_list(123, [])
list3 = extend_list('a')
print(list1)
print(list2)
print(list3)
```
2020-05-05 19:37:11 +08:00
> **点评**： ， ， ， ，
2020-05-04 00:21:43 +08:00
```
[10, 'a']
[123]
[10, 'a']
```
#### 题目40： ， ， ？
很显然4G内存要一次性的加载大小为8G的文件是不现实的，
```Python
with open('...', 'rb') as file:
for data in iter(lambda: file.read(2097152), b''):
pass
```
在Linux系统上，
```Bash
split -b 512m filename
```
如果愿意， 也可以将名为`filename`的文件切割为10个文件，
```Bash
split -n 10 filename
```
> **扩展**：外部排序跟上述的情况非常类似，由于处理的数据不能一次装入内存，只能放在读写较慢的外存储器（通常是硬盘）上。“**排序-归并算法**”就是一种常用的外部排序策略。在排序阶段，先读入能放在内存中的数据量，将其排序输出到一个临时文件，依此进行，将待排序数据组织为多个有序的临时文件，然后在归并阶段将这些临时文件组合为一个大的有序文件，这个大的有序文件就是排序的结果。
2020-04-29 12:01:29 +08:00
2020-05-05 19:37:11 +08:00
#### 题目41：
每个Python文件就是一个模块， ， ， ，
#### 题目42：
> **点评**： ， ， ， ，
1. 空格的使用
- 使用空格来表示缩进而不要用制表符（ ）
- 和语法相关的每一层缩进都用4个空格来表示。
- 每行的字符数不要超过79个字符， ，
- 函数和类的定义，代码前后都要用两个空行进行分隔。
- 在同一个类中，各个方法之间应该用一个空行进行分隔。
- 二元运算符的左右两侧应该保留一个空格，而且只要一个空格就好。
2. 标识符命名
- 变量、函数和属性应该使用小写字母来拼写，如果有多个单词就使用下划线进行连接。
- 类中受保护的实例属性，应该以一个下划线开头。
- 类中私有的实例属性，应该以两个下划线开头。
- 类和异常的命名，应该每个单词首字母大写。
- 模块级别的常量，应该采用全大写字母，如果有多个单词就用下划线进行连接。
- 类的实例方法，应该把第一个参数命名为`self`以表示对象自身。
- 类的类方法，应该把第一个参数命名为`cls`以表示该类自身。
3. 表达式和语句
- 采用内联形式的否定词，而不要把否定词放在整个表达式的前面。例如：`if a is not b`就比`if not a is b`更容易让人理解。
- 不要用检查长度的方式来判断字符串、列表等是否为`None`或者没有元素，应该用`if not x`这样的写法来检查它。
- 就算`if`分支、`for`循环、`except`异常捕获等中只有一行代码，也不要将代码和`if`、`for`、`except`等写在一起，分开写才会让代码更清晰。
- `import` 语句总是放在文件开头的地方。
- 引入模块的时候，`from math import sqrt`比`import math`更好。
- 如果有多个`import`语句， ，
#### 题目43： ， ，
```Python
class A:
def __init__ (self, value):
self.__value = value
@property
def value(self):
return self.__value
obj = A(1)
obj.__value = 2
print(obj.value)
print(obj.__value)
```
> **点评**：这道题有两个考察点，一个考察点是对`_`和`__`开头的对象属性访问权限以及`@property`装饰器的了解，另外一个考察的点是对动态语言的理解，不需要过多的解释。
```
1
2
```
> **扩展**：如果不希望代码运行时动态的给对象添加新属性，可以在定义类时使用`__slots__`魔法。例如，我们可以在上面的`A`中添加一行`__slots__ = ('__value', )`， ，
#### 题目44：
```Python
prices = {
'AAPL': 191.88,
'GOOG': 1186.96,
'IBM': 149.24,
'ORCL': 48.44,
'ACN': 166.89,
'FB': 208.09,
'SYMC': 21.29
}
```
> **点评**： ，
```Python
sorted(prices, key=lambda x: prices[x], reverse=True)
```
#### 题目45：
> **点评**： ， ，
在使用面向对象编程语言的时候， ， ， ， ， ， ， ，
```Python
from collections import namedtuple
Card = namedtuple('Card', ('suite', 'face'))
card1 = Card('红桃', 13)
card2 = Card('草花', 5)
print(f'{card1.suite}{card1.face}')
print(f'{card2.suite}{card2.face}')
```
命名元组与普通元组一样是不可变容器，一旦将数据存储在`namedtuple`的顶层属性中，数据就不能再修改了，也就意味着对象上的所有属性都遵循“一次写入，多次读取”的原则。和普通元组不同的是，命名元组中的数据有访问名称，可以通过名称而不是索引来获取保存的数据，不仅在操作上更加简单，代码的可读性也会更好。
命名元组的本质就是一个类，所以它还可以作为父类创建子类。除此之外，命名元组内置了一系列的方法，例如，可以通过`_asdict`方法将命名元组处理成字典，也可以通过`_replace`方法创建命名元组对象的浅拷贝。
```Python
class MyCard(Card):
def show(self):
faces = ['', 'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
return f'{self.suite}{faces[self.face]}'
print(Card) # < class ' __main__ . Card ' >
card3 = MyCard('方块', 12)
print(card3.show()) # 方块Q
print(dict(card1._asdict())) # {'suite': '红桃', 'face': 13}
print(card2._replace(suite='方块')) # Card(suite='方块', face=5)
```
总而言之，命名元组能更好的组织数据结构，让代码更加清晰和可读，在很多场景下是元组、字典和数据类的替代品。在需要创建占用空间更少的不可变类时，命名元组就是很好的选择。
#### 题目46：
> **要求**： ， ，
```Python
def more_than_half(items):
temp, times = None, 0
for item in items:
if times == 0:
temp = item
times += 1
else:
if item == temp:
times += 1
else:
times -= 1
return temp
```
> **点评**： ， ， ， ，
#### 题目47：
> **要求**：写一个函数，传入的参数是一个列表（列表中的元素可能也是一个列表），返回该列表最大的嵌套深度。例如：列表`[1, 2, 3]`的嵌套深度为`1`，列表`[[1], [2, [3]]]`的嵌套深度为`3`。
```Python
def list_depth(items):
if isinstance(items, list):
max_depth = 1
for item in items:
max_depth = max(list_depth(item) + 1, max_depth)
return max_depth
return 0
```
> **点评**：看到题目应该能够比较自然的想到使用递归的方式检查列表中的每个元素。
#### 题目48：
> **要求**：有一个通过网络获取数据的函数（可能会因为网络原因出现异常），写一个装饰器让这个函数在出现指定异常时可以重试指定的次数，并在每次重试之前随机延迟一段时间，最长延迟时间可以通过参数进行控制。
方法一：
```Python
from functools import wraps
from random import random
from time import sleep
def retry(*, retry_times=3, max_wait_secs=5, errors=(Exception, )):
def decorate(func):
@wraps (func)
def wrapper(*args, **kwargs):
for _ in range(retry_times):
try:
return func(*args, **kwargs)
except errors:
sleep(random() * max_wait_secs)
return None
return wrapper
return decorate
```
方法二：
```Python
from functools import wraps
from random import random
from time import sleep
class Retry(object):
def __init__ (self, *, retry_times=3, max_wait_secs=5, errors=(Exception, )):
self.retry_times = retry_times
self.max_wait_secs = max_wait_secs
self.errors = errors
def __call__ (self, func):
@wraps (func)
def wrapper(*args, **kwargs):
for _ in range(self.retry_times):
try:
return func(*args, **kwargs)
except self.errors:
sleep(random() * self.max_wait_secs)
return None
return wrapper
```
> **点评**： ， ， ，
#### 题目49： ，
> **点评**：烂大街的题目，基本上算是送人头的题目。
方法一：反向切片
```Python
def reverse_string(content):
return content[::-1]
```
方法二：反转拼接
```Python
def reverse_string(content):
return ''.join(reversed(content))
```
方法三：递归调用
```Python
def reverse_string(content):
if len(content) < = 1:
return content
return reverse_string(content[1:]) + content[0]
```
方法四：双端队列
```Python
from collections import deque
def reverse_string(content):
q = deque()
q.extendleft(content)
return ''.join(q)
```
方法五：反向组装
```Python
from io import StringIO
def reverse_string(content):
buffer = StringIO()
for i in range(len(content) - 1, -1, -1):
buffer.write(content[i])
return buffer.getvalue()
```
方法六：反转拼接
```Python
def reverse_string(content):
return ''.join([content[i] for i in range(len(content) - 1, -1, -1)])
```
方法七：半截交换
```Python
def reverse_string(content):
length, content= len(content), list(content)
for i in range(length // 2):
content[i], content[length - 1 - i] = content[length - 1 - i], content[i]
return ''.join(content)
```
方法八：对位交换
```Python
def reverse_string(content):
length, content= len(content), list(content)
for i, j in zip(range(length // 2), range(length - 1, length // 2 - 1, -1)):
content[i], content[j] = content[j], content[i]
return ''.join(content)
```
> **扩展**：这些方法其实都是大同小异的，面试的时候能够给出几种有代表性的就足够了。给大家留一个思考题，上面这些方法，哪些做法的性能较好呢？我们之前提到过剖析代码性能的方法，大家可以用这些方法来检验下你给出的答案是否正确。
#### 题目50：
> **要求**：列表中有`1000000`个元素，取值范围是`[1000, 10000)`，设计一个函数找出列表中的重复元素。
```Python
def find_dup(items: list):
dups = [0] * 9000
for item in items:
dups[item - 1000] += 1
for idx, val in enumerate(dups):
if val > 1:
yield idx + 1000
```
> **点评**：这道题的解法和[计数排序](<https://www.runoob.com/w3cnote/counting-sort.html>)的原理一致，虽然元素的数量非常多，但是取值范围`[1000, 10000)`并不是很大， ， ，
