60. 请写一个 Python 逻辑，计算一个文件中的大写字母数量

答：

with open(‘A.txt’) as fs：
count = 0
for i in fs.read()：
if i.isupper()：
count += 1
print(count)

61. 请写一段 Python连接Mongo数据库，然后的查询代码。

小编是一名python开发工程师，这里有我自己整理了一套最新的python系统学习教程，包括从基础的python脚本到web开发、爬虫、数据分析、数据可视化、机器学习等。想要这些资料的可以关注小编，并在后台私信小编：“01”即可领取

答:

import pymongo
db_configs = {
‘type’: ‘mongo’,
‘host’: ‘地址’,
‘port’: ‘端口’,
‘user’: ‘spider_data’,
‘passwd’: ‘密码’,
‘db_name’: ‘spider_data’
}

class Mongo():
def init(self, db=db_configs[“db_name”], username=db_configs[“user”],
password=db_configs[“passwd”]):
self.client = pymongo.MongoClient(f’mongodb://{db_configs[“host”]}:db_configs[“port”]’)
self.username = username
self.password = password
if self.username and self.password:
self.db1 = self.client[db].authenticate(self.username, self.password)
self.db1 = self.client[db]

def find_data(self):
# 获取状态为0的数据
data = self.db1.test.find({“status”: 0})
gen = (item for item in data)
return gen

if name == ‘main’:
m = Mongo()
print(m.find_data())

62.说一说Redis的基本类型

答: Redis 支持五种数据类型： string（字符串） 、 hash（哈希）、list（列表） 、 set（集合） 及 zset(sorted set： 有序集合)。

63. 请写一段 Python连接Redis数据库的代码。

答:

from redis import StrictRedis, ConnectionPool
redis_url=“redis://:xxxx@112.27.10.168:6379/15”
pool = ConnectionPool.from_url(redis_url, decode_responses=True)
r= StrictRedis(connection_pool=pool)

64. 请写一段 Python连接Mysql数据库的代码。

答:

conn = pymysql.connect(host=‘localhost’,
port=3306, user=‘root’,
passwd=‘1234’, db=‘user’, charset=‘utf8mb4’)#声明mysql连接对象
cursor=conn.cursor(cursor=pymysql.cursors.DictCursor)#查询结果以字典的形式
cursor.execute(sql语句字符串)#执行sql语句
conn.close()#关闭链接

65.了解Redis的事务么

答: 简单理解，可以认为 redis 事务是一些列 redis 命令的集合，并且有如下两个特点： 1.事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。 2.事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。 一般来说，事务有四个性质称为ACID，分别是原子性，一致性，隔离性和持久性。 一个事务从开始到执行会经历以下三个阶段：

开始事务
命令入队
执行事务 代码示例:

import redis
import sys
def run():
try:
conn=redis.StrictRedis(‘192.168.80.41’)

Python中redis事务是通过pipeline的封装实现的

pipe=conn.pipeline()  
pipe.sadd('s001','a')  
sys.exit()  
#在事务还没有提交前退出，所以事务不会被执行。  
pipe.sadd('s001','b')  
pipe.execute()  
pass  
1234567

except Exception as err:
print(err)
pass
if name==“main”:
run()

66.了解数据库的三范式么？

答: 经过研究和对使用中问题的总结，对于设计数据库提出了一些规范，这些规范被称为范式 一般需要遵守下面3范式即可: 第一范式（1NF）：强调的是列的原子性，即列不能够再分成其他几列。 第二范式（2NF）：首先是 1NF，另外包含两部分内容，一是表必须有一个主键；二是没有包含在主键中的列必须完全依赖于主键，而不能只依赖于主键的一部分。 第三范式（3NF）：首先是 2NF，另外非主键列必须直接依赖于主键，不能存在传递依赖。即不能存在：非主键列 A 依赖于非主键列 B，非主键列 B 依赖于主键的情况。

67.了解分布式锁么

答: 分布式锁是控制分布式系统之间的同步访问共享资源的一种方式。 对于分布式锁的目标，我们必须首先明确三点：

任何一个时间点必须只能够有一个客户端拥有锁。
不能够有死锁，也就是最终客户端都能够获得锁，尽管可能会经历失败。
错误容忍性要好，只要有大部分的Redis实例存活，客户端就应该能够获得锁。 分布式锁的条件 互斥性：分布式锁需要保证在不同节点的不同线程的互斥 可重入性：同一个节点上的同一个线程如果获取了锁之后，能够再次获取这个锁。 锁超时：支持超时释放锁，防止死锁 高效，高可用：加锁和解锁需要高效，同时也需要保证高可用防止分布式锁失效，可以增加降级。 支持阻塞和非阻塞：可以实现超时获取失败，tryLock(long timeOut) 支持公平锁和非公平锁

分布式锁的实现方案 1、数据库实现（乐观锁） 2、基于zookeeper的实现 3、基于Redis的实现（推荐）

68.用 Python 实现一个 Reids 的分布式锁的功能

答:REDIS分布式锁实现的方式：SETNX + GETSET,NX是Not eXists的缩写，如SETNX命令就应该理解为：SET if Not eXists。 多个进程执行以下Redis命令：

SETNX lock.foo <current Unix time + lock timeout + 1>

如果 SETNX 返回1，说明该进程获得锁，SETNX将键 lock.foo 的值设置为锁的超时时间（当前时间 + 锁的有效时间）。 如果 SETNX 返回0，说明其他进程已经获得了锁，进程不能进入临界区。进程可以在一个循环中不断地尝试 SETNX 操作，以获得锁。

import time
import redis
from conf.config import REDIS_HOST, REDIS_PORT, REDIS_PASSWORD

class RedisLock:
def init(self):
self.conn = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, db=1)
self._lock = 0
self.lock_key = “”
@staticmethod
def my_float(timestamp):
“”"
Args:
timestamp:
Returns:
float或者0
如果取出的是None，说明原本锁并没人用，getset已经写入，返回0，可以继续操作。
“”"
if timestamp:
return float(timestamp)
else:
#防止取出的值为None，转换float报错
return 0

@staticmethod
def get_lock(cls, key, timeout=10):
cls.lock_key = f"{key}_dynamic_lock"
while cls._lock != 1:
timestamp = time.time() + timeout + 1
cls._lock = cls.conn.setnx(cls.lock_key, timestamp)
# if 条件中，可能在运行到or之后被释放，也可能在and之后被释放
# 将导致 get到一个None，float失败。
if cls._lock == 1 or (
time.time() > cls.my_float(cls.conn.get(cls.lock_key)) and
time.time() > cls.my_float(cls.conn.getset(cls.lock_key, timestamp))):
break
else:
time.sleep(0.3)

@staticmethod
def release(cls):
if cls.conn.get(cls.lock_key) and time.time() < cls.conn.get(cls.lock_key):
cls.conn.delete(cls.lock_key)

def redis_lock_deco(cls):
def _deco(func):
def __deco(*args, **kwargs):
cls.get_lock(cls, args[1])
try:
return func(*args, **kwargs)
finally:
cls.release(cls)
return __deco
return _deco

@redis_lock_deco(RedisLock())
def my_func():
print(“myfunc() called.”)
time.sleep(20)

if name == “main”:
my_func()

69.写一段 Python 使用 mongo 数据库创建索引的代码:

答:

-- coding: utf-8 --

@Time : 2018/12/28 10:01 AM

@Author : cxa

import pymongo
db_configs = {
‘type’: ‘mongo’,
‘host’: ‘地址’,
‘port’: ‘端口’,
‘user’: ‘spider_data’,
‘passwd’: ‘密码’,
‘db_name’: ‘spider_data’
}

class Mongo():
def init(self, db=db_configs[“db_name”], username=db_configs[“user”],
password=db_configs[“passwd”]):
self.client = pymongo.MongoClient(f’mongodb://{db_configs[“host”]}:{db_configs[“port”]}’)
self.username = username
self.password = password
if self.username and self.password:
self.db1 = self.client[db].authenticate(self.username, self.password)
self.db1 = self.client[db]

def add_index(self):
“”"
通过create_index添加索引
“”"
self.db1.test.create_index([(‘name’, pymongo.ASCENDING)], unique=True)

def get_index(self,):
“”"
查看索引列表
“”"
indexlist=self.db1.test.list_indexes()
for index in indexlist:
print(index)

if name == ‘main’:
m = Mongo()
m.add_index()
print(m.get_index())

高级特性

70. 函数装饰器有什么作用？请列举说明？

答： 装饰器就是一个函数，它可以在不需要做任何代码变动的前提下给一个函数增加额外功能，启动装饰的效果。 它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。 下面是一个日志功能的装饰器

from functools import wraps
def log(label)：
def decorate(func)：
@wraps(func)
def _wrap(*args,**kwargs)：
try：
func(*args,**kwargs)
print(“name”,func.name)
except Exception as e：
print(e.args)
return _wrap
return decorate

@log(“info”)
def foo(a,b,c)：
print(a+b+c)
print(“in foo”)

#decorate=decorate(foo)

if name == ‘main’：
foo(1,2,3)
#decorate()

71. Python 垃圾回收机制？

答：Python 不像 C++，Java 等语言一样，他们可以不用事先声明变量类型而直接对变量进行赋值。对 Python 语言来讲，对象的类型和内存都是在运行时确定的。这也是为什么我们称 Python 语言为动态类型的原因。

主要体现在下面三个方法：

1.引用计数机制 2.标记-清除 3.分代回收

72. 魔法函数 _call_怎么使用?

答： call 可以把类实例当做函数调用。 使用示例如下

class Bar：
def call(self, *args, **kwargs)：
print(‘in call’)

if name == ‘main’：
b = Bar()
b()

73. 如何判断一个对象是函数还是方法？

答：看代码已经结果就懂了

from types import MethodType, FunctionType

class Bar：
def foo(self)：
pass

def foo2()：
pass

def run()：
print(“foo 是函数”, isinstance(Bar().foo, FunctionType))
print(“foo 是方法”, isinstance(Bar().foo, MethodType))
print(“foo2 是函数”, isinstance(foo2, FunctionType))
print(“foo2 是方法”, isinstance(foo2, MethodType))

if name == ‘main’：
run()

输出

foo 是函数 False
foo 是方法 True
foo2 是函数 True
foo2 是方法 False

74. @classmethod 和 @staticmethod 用法和区别

答： 相同之处：@staticmethod 和@classmethod 都可以直接类名.方法名()来调用，不用在示例化一个类。 @classmethod 我们要写一个只在类中运行而不在实例中运行的方法。如果我们想让方法不在实例中运行，可以这么做：

def iget_no_of_instance(ins_obj)：
return ins_obj.class.no_inst

class Kls(object)：
no_inst = 0

def init(self)：
Kls.no_inst = Kls.no_inst + 1

ik1 = Kls()
ik2 = Kls()
print(iget_no_of_instance(ik1))

@staticmethod 经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法

IND = ‘ON’

class Kls(object)：
def init(self, data)：
self.data = data

@staticmethod
def check_ind()：
return (IND == ‘ON’)

def do_reset(self)：
if self.check_ind()：
print(‘Reset done for：’, self.data)

def set_db(self)：
if self.check_ind()：
self.db = ‘New db connection’
print('DB connection made for： ', self.data)

ik1 = Kls(12)
ik1.do_reset()
ik1.set_db()

75. Python 中的接口如何实现？

答： 接口提取了一群类共同的函数，可以把接口当做一个函数的集合，然后让子类去实现接口中的函数。但是在 Python 中根本就没有一个叫做 interface 的关键字，如果非要去模仿接口的概念，可以使用抽象类来实现。抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化。使用 abc 模块来实现抽象类。

76. Python 中的反射了解么?

答：Python 的反射机制设定较为简单，一共有四个关键函数分别是 getattr、hasattr、setattr、delattr。

77. metaclass 作用？以及应用场景？

答： metaclass 即元类，metaclass 是类似创建类的模板，所有的类都是通过他来 create 的(调用new)，这使得你可以自由的控制创建类的那个过程，实现你所需要的功能。 我们可以使用元类创建单例模式和实现 ORM 模式。

78. hasattr()、getattr()、setattr() 的用法

答：这三个方法属于 Python 的反射机制里面的，hasattr 可以判断一个对象是否含有某个属性，getattr 可以充当 get 获取对象属性的作用。而 setattr 可以充当 person.name = "liming"的赋值操作。代码示例如下：

class Person()：
def init(self)：
self.name = “liming”
self.age = 12

def show(self)：
print(self.name)
print(self.age)

def set_name(self)：
setattr(Person, “sex”, “男”)

def get_name(self)：
print(getattr(self, “name”))
print(getattr(self, “age”))
print(getattr(self, “sex”))

def run()：
if hasattr(Person, “show”)：
print(“判断 Person 类是否含有 show 方法”)

Person().set_name()
Person().get_name()

if name == ‘main’：
run()

79. 请列举你知道的 Python 的魔法方法及用途。

答：

1 init：
类的初始化方法。它获取任何传给构造器的参数（比如我们调用 x = SomeClass(10, ‘foo’) ， __init__就会接到参数 10 和 ‘foo’ 。 __init__在 Python 的类定义中用的最多。

2 new：
__new__是对象实例化时第一个调用的方法，它只取下 cls 参数，并把其他参数传给 init 。 __new__很少使用，但是也有它适合的场景，尤其是当类继承自一个像元组或者字符串这样不经常改变的类型的时候.

3 del：
__new__和 __init__是对象的构造器， __del__是对象的销毁器。它并非实现了语句 del x (因此该语句不等同于 x.del())。而是定义了当对象被垃圾回收时的行为。 当对象需要在销毁时做一些处理的时候这个方法很有用，比如 socket 对象、文件对象。但是需要注意的是，当 Python 解释器退出但对象仍然存活的时候，__del__并不会 执行。 所以养成一个手工清理的好习惯是很重要的，比如及时关闭连接。

80. 如何知道一个 Python 对象的类型？

答：可以通过 type 方法

81. Python 的传参是传值还是传址？

答：Python 中的传参即不是传值也不是传地址，传的是对象的引用。

82. Python 中的元类 (metaclass) 使用举例

答：可以使用元类实现一个单例模式，代码如下

class Singleton(type)：
def init(self, *args, **kwargs)：
print(“in init”)
self.__instance = None
super(Singleton, self).init(*args, **kwargs)

def call(self, *args, **kwargs)：
print(“in call”)
if self.__instance is None：
self.__instance = super(Singleton, self).call(*args, **kwargs)
return self.__instance

class Foo(metaclass=Singleton)：
pass # 在代码执行到这里的时候，元类中的__new__方法和__init__方法其实已经被执行了，而不是在 Foo 实例化的时候执行。且仅会执行一次。

foo1 = Foo()
foo2 = Foo()
print(foo1 is foo2)

83. 简述 any() 和 all() 方法

答： any(x)：判断 x 对象是否为空对象，如果都为空、0、false，则返回 false，如果不都为空、0、false，则返回 true。 all(x)：如果 all(x) 参数 x 对象的所有元素不为 0、’’、False 或者 x 为空对象，则返回 True，否则返回 False。

84. filter 方法求出列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

答

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(filter(lambda x： x % 2 == 1, a)))

其实现在不推荐使用 filter,map 等方法了，一般列表生成式就可以搞定了。

85. 什么是猴子补丁？

答： 猴子补丁（monkey patching)：在运行时动态修改模块、类或函数，通常是添加功能或修正缺陷。猴子补丁在代码运行时内存中）发挥作用，不会修改源码，因此只对当前运行的程序实例有效。因为猴子补丁破坏了封装，而且容易导致程序与补丁代码的实现细节紧密耦合，所以被视为临时的变通方案，不是集成代码的推荐方式。大概是下面这样的一个效果

def post()：
print(“this is post”)
print(“想不到吧”)

class Http()：
@classmethod
def get(self)：
print(“this is get”)

def main()：
Http.get=post #动态的修改了 get 原因的功能，

if name == ‘main’：
main()
Http.get()

86. 在 Python 中是如何管理内存的？

答： 垃圾回收：Python 不像 C++，Java 等语言一样，他们可以不用事先声明变量类型而直接对变量进行赋值。对 Python 语言来讲，对象的类型和内存都是在运行时确定的。这也是为什么我们称 Python 语言为动态类型的原因（这里我们把动态类型可以简单的归结为对变量内存地址的分配是在运行时自动判断变量类型并对变量进行赋值）。

引用计数：Python 采用了类似 Windows 内核对象一样的方式来对内存进行管理。每一个对象，都维护这一个对指向该对对象的引用的计数。当变量被绑定在一个对象上的时候，该变量的引用计数就是 1，(还有另外一些情况也会导致变量引用计数的增加)，系统会自动维护这些标签，并定时扫描，当某标签的引用计数变为 0 的时候，该对就会被回收。

内存池机制 Python 的内存机制以金字塔行，1、2 层主要有操作系统进行操作

第 0 层是 C 中的 malloc，free 等内存分配和释放函数进行操作

第 1 层和第 2 层是内存池，有 Python 的接口函数 PyMem_Malloc 函数实现，当对象小于 256K 时有该层直接分配内存

第 3 层是最上层，也就是我们对 Python 对象的直接操作

在 C 中如果频繁的调用 malloc 与 free 时,是会产生性能问题的.再加上频繁的分配与释放小块的内存会产生内存碎片。Python 在这里主要干的工作有：

如果请求分配的内存在 1~256 字节之间就使用自己的内存管理系统,否则直接使用 malloc。  

这里还是会调用 malloc 分配内存，但每次会分配一块大小为 256k 的大块内存。  
123

经由内存池登记的内存到最后还是会回收到内存池，并不会调用 C 的 free 释放掉以便下次使用。对于简单的 Python 对象，例如数值、字符串，元组（tuple 不允许被更改)采用的是复制的方式(深拷贝?)，也就是说当将另一个变量 B 赋值给变量 A 时，虽然 A 和 B 的内存空间仍然相同，但当 A 的值发生变化时，会重新给 A 分配空间，A 和 B 的地址变得不再相同。

87. 当退出 Python 时是否释放所有内存分配？

答：不是的，循环引用其他对象或引用自全局命名空间的对象的模块，在 Python 退出时并非完全释放。

另外，也不会释放 c 库保留的内存部分
正则表达式

88. （1）使用正则表达式匹配出<h1>www.baidu.com中的地址（2）a=“张明 98 分”，用 re.sub，将 98 替换为 100

答： 第一问答案

import re

source = “

www.baidu.com

”
pat = re.compile("

(.*?)

")
print(pat.findall(source)[0])

第二问答案

import re
s = “张明 98 分”
print(re.sub(r"\d+",“100”,s))

89. 正则表达式匹配中(.)和(.?)匹配区别？

答：(.) 为贪婪模式极可能多的匹配内容 ,(.?) 为非贪婪模式又叫懒惰模式，一般匹配到结果就好，匹配字符的少为主，示例代码如下

import re

s = “

文本 1

文本 2

”

pat1 = re.compile(r"<div>(.*?)</div>")
print(pat1.findall(s))

pat2 = re.compile(r"<div>(.*)</div>")
print(pat2.findall(s))

输出

[‘文本 1’, ‘文本 2’]
[‘文本 1

文本 2’]

90. 写一段匹配邮箱的正则表达式

答：关于邮箱的匹配这个还真的是一个永恒的话题。

电子邮件地址有统一的标准格式：用户名@服务器域名。用户名表示邮件信箱、注册名或信件接收者的用户标识，@符号后是你使用的邮件服务器的域名。@可以读成“at”，也就是“在”的意思。整个电子邮件地址可理解为网络中某台服务器上的某个用户的地址。

用户名，可以自己选择。由字母 a～z(不区分大小写)、数字 0～9、点、减号或下划线组成；只能以数字或字母开头和结尾。
与你使用的网站有关，代表邮箱服务商。例如网易的有@163.com 新浪有@vip.sina.com 等。

网上看到了各种各样的版本，都不确定用哪个，于是自己简单的总结了一个。大家有更好的欢迎留言。

r"1+[a-zA-Z0-9_.±]+@[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+#34;

下面解释上面的表达式

首先强调一点关于\w 的含义，\w 匹配英文字母和俄语字母或数字或下划线或汉字。
注意[]和[]的区别，[]表示字符集合，[]表示已[]内的任意字符集开始，[]表示。
[a-zA-Z0-9]+：这里注意[]和[]的,第一个表示已什么开头，第二个[]的^表示不等于[]内。所以这段表示以英文字母和数字开头，后面紧跟的+，限定其个数>=1 个。
[a-zA-Z0-9.±]+：表示匹配英文字母和数字开头以及.±, 的任意一个字符，并限定其个数>=1 个。为了考虑@前面可能出现.±（但是不在开头出现）。
@就是邮箱必备符号了
@[a-zA-Z0-9-]+.：前面的不用说了，后面的.表示.转义了,也是必备符号。
[ a-zA-Z0-9-.]+：$符表示以什么结束,这里表示以英文字和数字或 -. 1 个或多个结尾。

来个例子验证一波：

import re
plt=re.compile(r"2+[a-zA-Z0-9_.±]+@[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+#34;)
b=plt.findall(‘adas+fefe.we@qq.com.cn’)
print(b)

网上找了个验证邮件地址的通用正则表达式（符合 RFC 5322 标准）

(?：[a-z0-9!#%&'*+/=?^_`{|}~-]+(?：\.[a-z0-9!#%&’+/=?^_`{|}~-]+)|"(?：[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\[\x01-\x09\x0b\x0c\x0e-\x7f])")@(?：(?：a-z0-9?.)+a-z0-9?|[(?：(?：25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(?：25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-][a-z0-9]：(?：[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\[\x01-\x09\x0b\x0c\x0e-\x7f])+)])

其他内容

91. 解释一下 Python 中 pass 语句的作用？

答：pass 实际上就是一个占位符，在写一个函数但是不确定里面写啥的时候，这个时候可以使用 pass。示例如下

def foo()：
pass

92. 简述你对 input()函数的理解

答：在 Python3 中 input 函数可以接收用户输入的字符串。

然后根据程序的需要转换成所需格式即可。

93. Python 中的 is 和==

答：先说==它的作用是判断两个对象的值是否相同，然后说 is。is 表示的谁是谁，这也就意味着对象完全相等。我们知道一个对象有各自的内存地址和对应的值，当内存地址和值都相同的时候使用 is 可以得到结果 True。另外需要注意的下面两点特殊的情况。

这些变量很可能在许多程序中使用。 通过池化这些对象，Python 可以防止对一致使用的对象进行内存分配调用。

1.介于数字-5 和 256 之间的整数

2.字符串仅包含字母、数字或下划线

94. Python 中的作用域

答：

Python 中，一个变量的作用域总是由在代码中被赋值的地方所决定

当 Python 遇到一个变量的话它会按照这的顺序进行搜索

本地作用域(Local)—>当前作用域被嵌入的本地作用域(Enclosing locals)—>全局/模块作用域(Global)—>内置作用域(Built-in)

95. 三元运算写法和应用场景？

答：Python 中的三元运算又称三目运算，是对简单的条件语句的简写。 是一种比较 Pythonic 的学法，形式为：val = 1 if 条件成立 else 2 代码示例如下：

a = 2
b = 5

普通写法

if a > b：
val = True
else：
val = False

改为三元运算符后

val = a if a > b else b
print(val) # 5

96. 了解 enumerate 么？

答：enumerate 可以在迭代一个对象的时候，同时获取当前对象的索引和值。 代码示例如下

from string import ascii_lowercase

s = ascii_lowercase

for index, value in enumerate(s)：
print(index, value)

97. 列举 5 个 Python 中的标准模块

答： pathlib：路径操作模块，比 os 模块拼接方便。 urllib：网络请求模块，包括对 url 的结构解析。 asyncio： Python 的异步库，基于事件循环的协程模块。 re：正则表达式模块。 itertools：提供了操作生成器的一些模块。

98. 如何在函数中设置一个全局变量

答：

通过使用 global 对全局变量进行修改。

n = 0
def foo()：
global n
n = 100
foo()
print(n)
x = 0

之前我在视频教程中对这块做了个讲解，具体点击下方链接 https：//www.bilibili.com/video/av50865713

99. pathlib 的用法举例

答：pathlib 可以对文件以及文件的其他属性进行操作。比较喜欢的一点是路径拼接符"/"的使用，之前在公众号中写过 pathlib 一些其他的用法这里就不一一例举了。

100. Python 中的异常处理，写一个简单的应用场景

答： 比如在计算除法中出现为 0 的情况出现异常

try：
1 / 0
except ZeroDivisionError as e：
print(e.args)

101. Python 中递归的最大次数，那如何突破呢？

答：Python 有递归次数限制，默认最大次数为 1000。通过下面的代码可以突破这个限制

import sys
sys.setrecursionlimit(1500) # set the maximum depth as 1500

另外需要注意的是 sys.setrecursionlimit() 只是修改解释器在解释时允许的最大递归次数，此外，限制最大递归次数的还和操作系统有关。

102. 什么是面向对象的 mro

答：Python 是支持面向对象编程的，同时也是支持多重继承的。一般我们通过调用类对象的 mro()方法获取其继承关系。

103. isinstance 作用以及应用场景？

答：isinstance 是判断一个对象是否为另一个对象的子类的，例如我们知道在 Python3 中 bool 类型其实是 int 的子类，所以我们可以对其检测。

print(isinstance(True,int))

104. 什么是断言？应用场景？

答：在 Python 中是断言语句 assert 实现此功能，一般在表达式为 True 的情况下，程序才能通过。

#author：陈祥安
#公众号：Python 学习开发

#assert（）方法，断言成功，则程序继续执行，断言失败，则程序报错

断言能够帮助别人或未来的你理解代码，

找出程序中逻辑不对的地方。一方面，

断言会提醒你某个对象应该处于何种状态，

另一方面，如果某个时候断言为假，

会抛出 AssertionError 异常，很有可能终止程序。

def foo(a)：
assert a==2,Exception(“不等于 2”)
print(“ok”,a)

if name == ‘main’：
foo(1)

105. lambda 表达式格式以及应用场景？

答：lambda 表达式其实就是一个匿名函数,在函数编程中经常作为参数使用。 例子如下

a = [(‘a’,1),(‘b’,2),(‘c’,3),(‘d’,4)]
a_1 = list(map(lambda x：x[0],a))

106. 新式类和旧式类的区别

答：Python 2.x 中默认都是经典类，只有显式继承了 object 才是新式类，Python 3.x 中默认都是新式类，经典类被移除，不必显式的继承 object。 新式类都从 object 继承，经典类不需要。 新式类的 MRO(method resolution order 基类搜索顺序)算法采用 C3 算法广度优先搜索，而旧式类的 MRO 算法是采用深度优先搜索。 新式类相同父类只执行一次构造函数，经典类重复执行多次。

107. dir()是干什么用的？

答：当在使用某一个对象不知道有哪些属性或者方法可以使用时，此时可以通过 dir() 方法进行查看。

108. 一个包里有三个模块，demo1.py、demo2.py、demo3.py，但使用 from tools import *导入模块时，如何保证只有 demo1、demo3 被导入了。

答： 增加_init_.py 文件，并在文件中增加：

all = [‘demo1’,‘demo3’]

109. 列举 5 个 Python 中的异常类型以及其含义

答：

AttributeError 对象没有这个属性

NotImplementedError 尚未实现的方法

StopIteration 迭代器没有更多的值

TypeError 对类型无效的操作

IndentationError 缩进错误

110. copy 和 deepcopy 的区别是什么？

答： copy.copy()浅拷贝，只拷贝父对象，不会拷贝对象的内部的子对象。 copy.deepcopy()深拷贝，拷贝对象及其子对象。

111. 代码中经常遇到的*args, **kwargs 含义及用法。

答： 在函数定义中使用 *args 和**kwargs 传递可变长参数。 *args 用来将参数打包成 tuple 给函数体调用。 **kwargs 打包关键字参数成 dict 给函数体调用。

112. Python 中会有函数或成员变量包含单下划线前缀和结尾，和双下划线前缀结尾，区别是什么?

答： “单下划线” 开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量； “双下划线” 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。

以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用“from xxx import *”而导入；以双下划线开头的（__foo）代表类的私有成员；

以双下划线开头和结尾的（_foo）代表 Python 里特殊方法专用的标识，如 _init（）代表类的构造函数。

代码示例

class Person：
“”“docstring for ClassName”""
def init(self)：
self.__age = 12
self._sex = 12
def _sex(self)：
return “男”
def set_age(self,age)：
self.__age = age

def get_age(self)：
return self.__age

if name == ‘main’：
p=Person()
print(p._sex)
#print(p.__age)
#Python 自动将__age 解释成 _Person__age,于是我们用 _Person__age 访问，这次成功。
print(p._Person__age)

113. w、a+、wb 文件写入模式的区别

答： w 表示写模式支持写入字符串，如果文件存在则覆盖。 a+ 和 w 的功能类型不过如果文件存在的话内容不会覆盖而是追加。 wb 是写入二进制字节类型的数据。

114. 举例 sort 和 sorted 的区别

答： 相同之处 sort 和 sorted 都可以对列表元素排序，sort() 与 sorted() 的不同在于，sort 是在原位重新排列列表，而 sorted() 是产生一个新的列表。 sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

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

115. 什么是负索引？

答：负索引一般表示的是从后面取元素。

116. pprint 模块是干什么的？

答：pprint 是 print 函数的美化版，可以通过 import pprint 导入。示例如下

import pprint
pprint.pprint(“this is pprint”)

117. 解释一下 Python 中的赋值运算符

答：通过下面的代码列举出所有的赋值运算符

a=7
a+=1
print(a)
a-=1
print(a)
a*=2
print(a)
a/=2
print(a)
a**=2
print(a)
a//=3
print(a)
a%=4
print(a)

118. 解释一下 Python 中的逻辑运算符

答：Python 中有三个逻辑运算符：and、or、not

print(False and True) #False
print(7<7 or True) #True
print(not 2==2) #False

119. 讲讲 Python 中的位运算符

答：按位运算符是把数字看作二进制来进行计算的。Python 中的按位运算法则如下：

下表中变量 a 为 60，b 为 13，二进制格式如下：

a = 0011 1100
b = 0000 1101

a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011

enter image description here

120. 在 Python 中如何使用多进制数字？

答： 我们在 Python 中，除十进制外还可以使用二进制、八进制和十六进制

二进制数字由 0 和 1 组成，我们使用 0b 或 0B 前缀表示二进制数

print(int(0b1010))#10

使用 bin()函数将一个数字转换为它的二进制形式

print(bin(0xf))#0b1111

八进制数由数字 0-7 组成，用前缀 0o 或 0O 表示 8 进制数

print(oct(8))#0o10

十六进数由数字 0-15 组成，用前缀 0x 或者 0X 表示 16 进制数

print(hex(16))#0x10
print(hex(15))#0xf

121. 怎样声明多个变量并赋值？

答：Python 是支持多个变量赋值的，代码示例如下

#对变量 a,b,c 声明并赋值
a,b,c = 1,2,3

算法和数据结构

122. 已知：

AList = [1,2,3]
BSet = {1,2,3}

(1) 从 AList 和 BSet 中 查找 4，最坏时间复杂度哪个大？ (2) 从 AList 和 BSet 中 插入 4，最坏时间复杂度哪个大？

答： (1) 对于查找，列表和集合的最坏时间复杂度都是 O(n)，所以一样的。 (2) 列表操作插入的最坏时间复杂度为 o(n),集合为 o(1)，所以 Alist 大。 set 是哈希表所以操作的复杂度基本上都是 o(1)。