人生苦短，我用python！

语言特性

返回文章顶部

1. 谈谈对 python 和其他语言的区别
答：
python 是一门语法简洁优美，功能强大无比，应用领域非常广泛，具有强大的第三方库，它是一门强类型的可移植、可扩展、可嵌入的解释型编程语言，属于动态语言。

拿 C 语言和 Python 比： Python 的第三方类库比较齐全并且使用简洁,很少代码就能实现一些功能，如果用 C 去实现相同的功能可能就比较复杂。但是对于速度来说 Python 的运行速度相较于 C 就比较慢了。所以有利的同时也有弊端，毕竟我们的学习成本降低了。

2. 简述解释型和编译型语言
答：
解释型语言是在运行程序的时候才翻译，每执行一次，要翻译一次，效率较低。编译型就是直接编译成机型可以执行的，只翻译一次，所以效率相对来说较高。

3. python 的解释器种类以及相关特点
答：

• cpython c 语言开发的，使用最广的解释器
• IPython 基于 CPython 之上的一个交互式计时器，交互方式增强功能和 CPython 一样
• pypy 目标时执行效率，采用 JIT 计数。对 python 代码进行动态编译，提高执行效率
• JPython 运行在 Java 上的解释器，直接把 Python 代码编译成 Java 字节码执行。
• IronPython 运行在微软 .NET 平台上的解释器，把 python 编译成 .NET 的字节码。

4. python3 和 python2 的区别
答： 这里列举五条

• print 在 python3 中是函数必须加括号，python2 中 print 为 class。
• python2 中使用 xrange，python3 使用 range。
• python2 中默认的字符串类型默认是 ASCII，python3 中默认的字符串类型是 Unicode。
• python2 中 / (除) 的结果是整型，python3 中是浮点类型。
• python2 中声明元类：metaclass = MetaClass, python3 中声明元类：class newclass(metaclass = MetaClass): pass。
• 等等……

5. python3 和 python3 中 int 和long 的区别
答：
python2 有 int 和 long 类型。int 类型最大值不能超过 sys.maxint，而这个最大值是平台相关的。可以通过在数字的末尾附上一个 L 来定义长整型，显然，它比 int 类型表示的数字范围更大。在python3 里，只有一种证书类型 int ，大多数情况下，和 python2 中的长整型类似。

6. xrange 和range 的区别
答：
xrange 是在 python2 中的用法，python3 中只有range xrange 用法与 range 完全相同，所不同的是生成的不是一个 list 对象，而是一个生成器。

编码规范

返回文章顶部

1. 什么是PEP8
答：
PEP8 通常听别人提起，但是具体的指什么内容呢，简单介绍一下《python Enhancement Proposal # 8》（8号 python 增强提案）又叫PEP8，它针对的 python 代码格式而编订的风格指南。

2. 了解python之禅
答：
通过 import this 语句可以获取其具体的内容，它告诉大家如何写出高效整洁的代码。
3. 了解DocStrings
答：
DocStrings 文档字符串是一个重要工具，用于解释文档程序，帮助你的程序文档更加简单易懂，主要是解释代码作用的。

4. 了解类型注解
答：
PEP 484 引入了类型提示，这使得可以对 python 代码进行静态类型检查。在使用 Ide 的时候可以获取到参数的类型，更方便传入参数。使用格式如下：

def foo(num:int) -> None:print(f"接收到的数字是：{num}")

介绍下这个简单例子，我们可以在函数的参数部分使用参数名 + ：+ 类型，来指定参数可以接受的类型，这里的话就是 num 参数为 int 类型，然后 -> 接的是返回值的类型。这里返回值为 None，然后通过 fstring 格式化字符串输出传入的数字。

5. 列举你知道 python 对象的命名规范，例如方法或者类等
答：
类：总是使用首字母大写单词串，如 MyClass。内部类可以使用额外的前导下划线连接各个单词。方法名类似 常量：常量名所有字母大写 等

6. python 中的注释有几种
**答：**总体来说分为两种，单行注释 、 多行注释

• 单行注释：重要代码的前面，添加一行解释说明的文字，以符号#开头。
• 多行注释：使用三个单引号 或者 三个双引号，包括要注释的内容；
  1）文档注释：每个 python 文件的开头，以三对双引号包括起来的注释，用于描述当前文件的作用、作者、时间、版本、……等信息。
  2）多行注释：以三对单引号包括起来的一段注释，用于解释说明一行或者多行代码的作用。

7. 如何优雅的给一个函数加注释
答：
可以使用 docstring 配合类型注解。

8. 如何给变量加注释
答：
可以通过变量名：类型的方式如下：

a: str = "this is string type"

9. python 代码缩进中是否支持Tab键和空格混用。
答：
不允许 Tab 键和空格键混用，这种现象在使用 sublime 的时候尤为明显。
一般推荐使用4个空格代替 Tab 键。

10. 是否可以在依据 import 中导入多个库
答：
可以，但是不推荐；因为一次导入多个模块可读性不是很好，所以一行导入一个模块会比较好，同样的尽量少用 from modulename import*，因为判断某个函数或者属性的来源有些困难，不方便调试，可读性也降低 了。

11. 在给 py 文件命名的时候需要注意什么
答：
给文件命名的时候不要和标准库的一些模块重复，比如 abc。另外名字要有意义，不建议数字开头或者中文命名。

12. 列举几个规范 python 代码风格的工具
答：
pylint 和 flake 8

数据类型-字符串

返回文章顶部

1. 列举 python 中的基本数据类型
答：
python3 中有六个标准的数据类型：字符串(string) 、数字(Digit) 、列表(List) 、元组(Tuple) 、 集合(set) 、 字典(Dictionar)；
数字 ：整数(int) 、 浮点数(float) 、 复数(complex) 、 布尔类型(bool）

2. 如何区别可变数据类型和不可变数据类型
答： 从对象内存地址方向来说

• 可变数据类型：在内存地址不变的情况下，值可改变（列表和字典是可变类型，但是字典中的 key（键） 必须是不可变类型）
• 不可变数据类型：内存改变，值也跟着改变。（数字，字符串，布尔类型，都是不可变类型）可以通过 id() 方法进行内存地址的检测。

3. 将"hello world"转换为首字母大写"Hello World"
答： 题目要求：首字母大写，空格隔开为一个单词；每个单词的首字母大写。

a = "hello word"
print(a.title())    # Hello Word

4. 如何检测字符串中含有数字
答： 可以通过 isdigit() 方法判断字符串是否全部由数字组成，例子如下：

s1 = "123456".isdigit()
print(s1)   # True
s2 = "123456a".isdigit()
print(s2)   # False

5. 将字符串"ilovechina"进行反转
答： 字符串切片 返取

s1 = "ilovechina"
print(s1[::-1]) # anihcevoli

6. python 中的字符串格式化方式你知道哪些
答：
%s ，format, fstring（python3.6 版本开始才支持，现在推荐的写法）

"""
字符串格式化的展示：
%s 占位符      # python 传统语法中使用较多的一种操作。
S.format()     # python 3.4+ 版本出现的一种字符串格式化展示， %s 的升级版。
f-string       # f-string 3.6+ 版本中出现的一种字符串格式化展示，format 的升级版。
"""# 一、%s 占位符# %s 占位符
# %s 占据一个位置，使用字符串填充【常用】
# %d 占据一个位置，使用整数填充。
# %f 占据一个位置，使用浮点数填充。
name = "zhangsan"
age = 18
pi = 3.1415926535
s1 = 1
s2 = 12
# 传统语法，语法拼接过程非常繁琐
print("自我介绍：姓名:" + name + "，年龄:" + str(age))    # 自我介绍：姓名：zhangsan,年龄：18# ① % 占位符的基本语法
print("自我介绍：姓名：%s,年龄：%s" % (name, age))     # 自我介绍：姓名：zhangsan,年龄：18# ② 占位符-格式化展示：指定宽度和对齐方式
print("姓名：%10s" % name)     # 设置10个宽度，默认右对齐
# 姓名：  zhangsan
print("姓名：%-10s" % name)    # 设置10个宽度，左对齐
# 姓名：zhangsan# ③ 占位符-格式化展示：指定保留小数点后位数。(默认保留.后6位数，最后一位四舍五入。)
print("输出圆周率：%f" % pi)      # 输出圆周率：3.141593    (默认保留.后6位数，最后一位四舍五入。)
print("输出圆周率：%.2f" % pi)    # 输出圆周率：3.14    （保留小数点后的2位数。）# ④ 占位符-格式化展示：输出编号时以0补充操作
print("房间号， %03d" % s1)     # 房间号， 001
print("房间号， %03d" % s2)     # 房间号， 012# 二、format() 格式化方法
name = "lisi"
age = 18
pi = 3.1415926535
# ① format() 基本语法：
print("自我介绍：姓名：{},年龄：{}".format(name,age))
# 自我介绍：姓名：lisi,年龄：18
print("自我介绍：姓名：{b_name}，年龄：{a_age}".format(a_age = age,b_name = name))
# 自我介绍：姓名：lisi，年龄：18# ② format() 格式化：对齐操作{:对齐方式 宽度}
print("姓名：{}".format(name))     # lisi
print("姓名：{:<10}".format(name)) # lisi      |
print("姓名：{:>10}".format(name)) # |      lisi
print("姓名：{:^10}".format(name)) # |   lisi   |
print("姓名：{:^9}".format(name))  # |  lisi   |    (左右不平均时，左少右多、)# ③ format() 格式化：保留小数操作
print("圆周率：{:f}".format(pi))        # 圆周率：3.141593
print("圆周率：{:.2f}".format(pi))      # 圆周率：3.14# 三、f-string 格式化字符串
name = "lisi"
age = 18
pi = 3.1415926535
s1 = 1
s2 = 12
# ① f-string 基本语法，字符串中的大括号中的变量，会自动替换数据
print(f"自我介绍：姓名：{name},年龄{age}")        # 自我介绍：姓名：lisi,年龄18# ② f-string 格式化：宽度和对齐
print(f"姓名：{name}")         # 直接输出
print(f"姓名：{name:10}")      # 占据10个宽度直接输出：默认左对齐。
print(f"姓名：{name:>10}")     # 占据10个宽度直接输出：右对齐。
print(f"姓名：{name:^10}")     # 占据10个宽度直接输出：居中。# ③ f-string 格式化：保留小数位数
print(f"圆周率：{pi}")          # 直接输出-字符串
# 圆周率：3.1415926535
print(f"圆周率：{pi:f}")        # 直接输出-浮点数
# 圆周率：3.141593
print(f"圆周率：{pi:.2f}")      # 直接输出-保留小数
# 圆周率：3.14# ④ f-string 格式化：空闲位置以0补充操作
print(f"房间号：{s1:03}")       # 房间号：001
print(f"房间号：{s2:03}")       # 房间号：012

7. 有一个字符串开头和末尾都有空格，比如" adadkjk "，
要求：写一个函数将字符串前后的空格去掉
答： 因为题目要求的是写一个函数，所以我们不能直接使用 strip()，不过我们可以把它封装到函数。

def strip_func(s1):return s1.strip()s1 = "  sakdjfi  "
print(strip_func(s1))   # sakdjfi

8. 获取字符串" 123456 " 最后的两个字符。
答： 使用字符串切片方法，起始值：4，结束值：默认到最后一位，步长：默认为1。代码如下：

s1 = "123456"
print(s1[4:])   # 56

9. 一个编码为 GBK 的字符串 S，要将其转成 UTF-8 编码的字符串格式，应如何操作
答：

s1 = "S".encode("gbk").decode("utf-8", "ignore")
print(s1)

10. (1) s = “info : xiaozhang 33 shandong” 用正则切分字符串实处[‘info’,‘xiaoZhang’,‘33’,‘shangdong’]
(2) a = "你好 中国 "，去除多余空格只留一个空格。
答：
1）我们需要根据冒号或者空格切分

import re
s1 = "info: xiaoZhang 33 shandong"
res = re.split(r": | ", s1)
print(res)  # ['info', 'xiaoZhang', '33', 'shandong']

2）使用join() 方法进行拼接

s1 = "你好 中国"
print("".join(s1.split()))  # 你好中国

11. (1) 怎样将字符串转换为小写。(2) 单引号、双引号、三引号的区别
答：
1）使用字符串的 lower() 方法。

s1 = "ZhAnGSaN"
print(s1.lower())   # zhangsan

2）在 python 中单独使用单引号和双引号是没什么区别的，但是如果引号里面还需要使用印好的时候，就需要注意的是：单引号嵌套的必须是双引号；双引号嵌套的必须是单引号。否则会导致引号冲突。报错；
三引号：同样的三引号㛑分为三单引号和三双引号，两个都可以声明长的字符串的时候使用，如果使用 docstring 就需要使用三双引号。

数据类型 - 列表

返回文章顶部

1. 已知 Alist = [1,2,3,1,2]，对 Alist 列表元素去重，写出具体过程
答： 列表和集合之间的转换

s1 = [1,2,3,1,2]
print(list(set(s1)))    # [1, 2, 3]

2. 如何实现"1,2,3" 变成 [“1”, “2”, “3”]
答： split() 方法，按指定（","）的内容进行切割

s1 = "1,2,3"
print(s1.split(","))    # ['1', '2', '3']

3. 给定两个 list，A 和 B ，找出相同元素和不同元素
答：

A = [1,2,5,4,3,1,2,4,5,3,2,1,8]
B = [1,2,5,3,1,24,2,1,5,8,9,2,3]
print("A\B中相同的元素：", set(A) & set(B))  # {1, 2, 3, 5, 8}
print("A\B中不相同的元素：", set(A) ^ set(B))  # {4, 9, 24}

4. [[1,2],[3,4],[5,6]] 一行代码展开改列表，得出[1,2,3,4,5,6]
答：

s1 = [[1,2],[3,4],[5,6]]
x = [j for i in s1 for j in i]
print(x)    # [1, 2, 3, 4, 5, 6]

5. 合并列表[1,5,7,9] 和 [2,2,6,8]
答： 使用extend() 和 + 都可以

s1 = [1,5,7,9]
s2 = [2,4,6,8]
# print(s1 + s2)    # [1, 5, 7, 9, 2, 4, 6, 8]
s1.extend(s2)
print(s1)   # [1, 5, 7, 9, 2, 4, 6, 8]

6. 如何打乱一个列表的元素
答： 随机打乱列表中的元素

import random
s1 = [1,2,3,4,5]
random.shuffle(s1)
print(s1)

数据类型 - 字典

返回文章顶部

1. 字典操作中 del 和 pop 有什么区别
答：
del 可以根据索引值来删除元素的，没有返回值。
pop 可以根据索引弹出一个值，有返回值。

2. 按照字典的内的年龄排序
答：

s1 = [{"name":"zs", "age":18},{"name":"ls", "age":28},{"name":"wl", "age":8}
]
print(sorted(s1, key=lambda x: x["age"]))
# [{'name': 'wl', 'age': 8},
# {'name': 'zs', 'age': 18},
# {'name': 'ls', 'age': 28}]

3. 请合并下面两个字典 a = {“A” : 1, “B” : 2}, b = {“C” : 3, “D” : 4}
答： 合并字典的方法很多，可以使用 update() 方法 / 字典解包的方式：

a = {"A":1, "B":2}
b = {"C":3, "D":4}
print({**a, **b})   # {'A': 1, 'B': 2, 'C': 3, 'D': 4}
a.update(b)
print(a)    # {'A': 1, 'B': 2, 'C': 3, 'D': 4}

4. 如何使用生成式的方式生成一个字典，写一段功能代码
答：

# 需求：把字典的key 和 value 值调换
s1 = {"a":1, "b":2}
print({v:k for k, v in s1.items()})

5. 如何把元组 (“a”, “b”) 和元组 (1, 2) ， 编程字典{“a” : 1, “b” : 2}
答： zip() 的使用，但是最后记得把 zip 对象再转换为字典

s1 = ("a","b")
s2 = (1,2)
print(dict(zip(s1, s2)))
# {'a': 1, 'b': 2}

数据类型 - 综合

返回文章顶部

1. 下列字典对象键类型不正确的是

A ：{1 ：0,2：0,3：0}
B ：{“a” : 0,“b” : 0, “c” : 0}
C： {(1,2)：0, (2,3)：0}
D： {[1,2]：0, [2,3]：0}

答： D 因为只有可 hash 的对象才能做字典的键，列表是可变类型不是可 hash 对象，所以不能用列表做为字典的键。

2. 如何交换字典{“A” : 1, “B” : 2} 的键和值
答：

s1 = {"A":1, "B":2}
# 方法一：
print({value:key for key, value in s1.items()})
print({v:k for k, v in s1.items()})
# 方法二：
new_s1 = dict(zip(s1.values(), s1.keys()))
print(new_s1)

3. python 里面如何实现 tuple 和 list 的转换
答：
python 中的类型转换，一般通过类型强转即可完成
tuple 转 list 是 list() 方法、
list 转 tuple 是 tuple() 方法。

4. 我们知道对于列表可以使用切片操作进行部分元素的选择，那么如何对生成器类型的对象事项相同的功能
答： 这个题目考察了 python 标准库的 itertools 模块的掌握情况，该模块提供了操作生成器的一些方法。对于生成器类型我们使用 islice 方法来实现切片的功能。例子如下：

from itertools import islice
gen = iter(range(10))   # 函数用来生成迭代器
# 第一个参数是迭代器，第二个参数是起始索引，第三个参数是结束索引，不支持负数索引
for i in islice(gen,0,4):print(i, end=" ")   # 0 1 2 3

5. 请将 [i for i in range(3)] 改成生成器
答： 通过把列表生成式的括号，改为小括号我们就实现了生成器的功能

x = (i for i in range(3))
print(x)

6. a = “hello” 和 b = “你好” 编码成 bytes 类型
答： 这个题目一共有三种方式，第一种是在字符串的前面加一个 b ，第二种可以使用 bytes 方法， 第三种使用字符串 encode 方法。

a = b"hello"
b = bytes("你好","utf-8")
c = "你好".encode("utf-8")
print(a)    # b'hello'
print(b)    # b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(c)    # b'\xe4\xbd\xa0\xe5\xa5\xbd'

7. 下面的代码输出的结果是什么
a = (1,2,3,[4,5,6,7],8)
a[2] = 2

答： 元组里的元素是不能改变的所以这个题目的答案是出现异常；报错。

8. 下面的代码输出的结果是什么
a = (1,2,3,[4,5,6,7],8)
a[3][0] = 2

答： 元组里的元素是不能改变的，这句话严格来说是不准确的，如果元组里面元素本身就是可变类型，比如列表，那么在操作这个元素里的对象时，其内存地址也是不变的。a[3] 对应的元素是列表，然后对列表第一个元素赋值，所以最后的结果是： (1,2,3,[2,5,6,7],8)

操作类题目

返回文章顶部

1. python 交换两个变量的值
答： 在 python 中交换两个对象的值通过下面的方式即可：

a,b = b,a

但是需要强调的是这并不是元组解包，通过 dis 模块可以发现，这是交换操作的字节码是 ROT_TWO ，意思是在栈的顶端做两个值的互换操作。

2. 在读文件操作的时候会使用 read、readline 或者 readlines, 简述他们各自的作用
答：
.read() 每次读取整个文件，它通常用于将文件内容放到一个字符串变量中；如果希望一行一行的输出那么就可以使用 readline() ，该方法会把文件的内容加载到内存，所以对于大文件的读取操作来说非常消耗内存资源，此时就可以通过 readlines 方法，将文件的句柄生成一个生成器，然后去读就可以了。

3. json 序列化时，可以处理的数据类型有哪些？如何定制支持 datetime 类型？
答：
可以处理的数据类型是 str、int、list、tuple、dict、bool、None，因为 datetime 类不支持 json 序列化，所以我们对他进行拓展。

# 自定义事件序列化
import json
from datetime import datetime, date# JSONEncoder 不知道怎么去把这个数据转换成json字符串的时候，
# 它就回去调 default()函数，所以都是重写这个函数来处理它本身不支持的数据类型，
# default()函数默认是直接报异常的。
class DateTojson(json.JSONEncoder):def default(self, obj):if isinstance(obj, datetime):return obj.strftime("%Y-%m-%d %H:%M:%S")elif isinstance(obj, date):return obj.strftime("%Y-%m-%d")else:return json.JSONEncoder.default(self, obj)d = {"name": "cxa", "data": datetime.now()}
print(json.dumps(d, cls=DateTojson))    # {"name": "cxa", "data": "2020-05-07 15:38:57"}

4. json 序列化时，默认遇到中文会转换成 unicode， 如果想要保留中文怎么办？
答： 可以通过 json.dumps 的 ensure_ascii 参数解决，代码示例如下：

import json
a = json.dumps({"name":"张三"}, ensure_ascii=False)
print(a)    # {"name": "张三"}

5. 有两个磁盘文件 A 和 B ，各存放一行字母，要求把这两个文件中的信息合并(按字母顺序排列)， 输出到一个新文件 C 中。
答： 输出的文件 C 的内容为 ABCDEFFGGGST

# 文件A.txt 内容为 ASDCF
# 文件B.txt 内容为 EFGGTGwith open("A.txt") as f1:f1_txt = f1.readline()
with open("B.txt") as f2:f2_txt = f2.readline()
f3_txt = f1_txt + f2_txtf3_list = sorted(f3_txt)with open("C.txt", "a+") as f:f.write("".join(f3_list))

6. 如果当前的日期为 20200501，要求写一个函数输出 N 天后的日期，(比如 N 为 2， 则输出 20200503)。
答：
这个大题目考察的是 datetime 里面的 timedelta 方法的使用，参数可选，默认值都为0：datetime.timedelta(days = 0, seconds = 0, microseconds = 0, milliseconds = 0, minutes = 0, hours = 0, weeks = 0) 通过这个参数可以指定不同的日期类型进行加减操作，这里我们需要改的是 days，代码如下

import datetimedef datetime_operate(n: int):now = datetime.datetime.now()   # 获取当前时间_new_date = now + datetime.timedelta(days = n)  # 获取指定天书后的新日期new_date = _new_date.strftime("%Y-%m-%d")   # 转换为指定的输出格式return new_dateif __name__ == "__main__":print("当天的日期是：", datetime_operate(0))   # 当天的日期是： 2020-05-07print("两天后的日期是：", datetime_operate(2))  # 两天后的日期是： 2020-05-09

7. 写一个函数，接收整数参数 n ，返回一个函数，函数的功能是吧函数的参数和 n 相乘并把结果返回。
答： 这个题目考查了闭包的使用代码示例如下，返回函数之类型是函数对象。

def func(num):def f(val):return num * valreturn fa = func(8)
print(a(5)) # 40

8. 下面代码会存在什么问题，如何改进
def strappend(num)：
str=‘first’
for i in range(num)：
str+=str(i)
return str

答：
首先不应该使用 python 的内置类似 str 作为变量名这里我把他改为 s ，另外在 python ，str 是个不可变对象，每次迭代都会生成新的存储空间，num 越大，创建的 str 对象就会越多，内存消耗也越大。使用 yield 改成生成器即可，还有一点就是命名规范的位置，函数名为_分割比较好。
完整的代码如下：

def func(num):s = "first"for i in range(num):s += str(i)yield sif __name__ == "__main__":for i in func(3):print(i)

9. 一行代码输出 1 - 100 之间的所有偶数。
答：
可以通过列表生成式，然后使用与操作如果 1 与之后结果为 0 则表明为偶数，等于 1 则为奇数。

# 一行代码输出1 - 100 之间的所有偶数
# 方法1：
print([i for i in range(1, 101) if i%2 == 0])
# 方法2：测试发现方法二效率更高
print(list(range(2,101,2)))
# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26,
# 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50,
# 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76,
# 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]

10. with语句的作用，写一段代码
答：
with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的 “清理” 操作，释放资源，比如文件使用后自动关闭、线程中锁的自动获取和释放等。
其他的内容看下面代码：

# 一般访问文件资源时我们会这样处理：
f = open('c：\test.txt', 'r')
data = f.read()
f.close()
# 这样写没有错，但是容易犯两个毛病：
# 1. 如果在读写时出现异常而忘了异常处理。
# 2. 忘了关闭文件句柄# 以下的加强版本的写法：f = open('c：\test.txt', 'r')
try:data = f.read()
finally:f.close()# 以上的写法就可以避免因读取文件时异常的发生而没有关闭问题的处理了。代码长了一些。
# 但使用 with 有更优雅的写法：with open(r'c：\test.txt', 'r') as f:data = f.read()# with 的实现class Test:def __enter__(self):print('__enter__() is call!')return selfdef dosomething(self):print('dosomethong!')def __exit__(self, exc_type, exc_value, traceback):print('__exit__() is call!')print(f'type：{exc_type}')print(f'value：{exc_value}')print(f'trace：{traceback}')print('__exit()__ is call!')with Test() as sample:pass# 当对象被实例化时，就会主动调用__enter__()方法，任务执行完成后就会调用__exit__()方法，
# 另外，注意到，__exit__()方法是带有三个参数的(exc_type, exc_value, traceback),
# 依据上面的官方说明：如果上下文运行时没有异常发生，那么三个参数都将置为 None,
# 这里三个参数由于没有发生异常，的确是置为了 None, 与预期一致.# 修改后不出异常了
class Test:def __enter__(self):print('__enter__() is call!')return selfdef dosomething(self):x = 1 / 0print('dosomethong!')def __exit__(self, exc_type, exc_value, traceback):print('__exit__() is call!')print(f'type：{exc_type}')print(f'value：{exc_value}')print(f'trace：{traceback}')print('__exit()__ is call!')return Truewith Test() as sample:

11. python 字典和 json 字符串相互转化方法
答：
在 python 中使用 dumps 方法 将 dict 对象转为 json 对象，使用 loads 方法可以将 json 对象转为 dict 对象。

import jsondic = {'a': 123, 'b': "456", 'c': "liming"}
json_str = json.dumps(dic)
dic2 = json.loads(json_str)
print(json_str) # {"a": 123, "b": "456", "c": "liming"}
print(dic2)     # {'a': 123, 'b': '456', 'c': 'liming'}

我们再来看一个特殊的例子

import jsondic = {'a': 123, 'b': "456", 'c': "liming"}
dic_str = json.loads(str(dic).replace("'", "\""))
print(dic_str)      # {'a': 123, 'b': '456', 'c': 'liming'}

下面我解释下上面代码是测试什么：

首先 json.loads(jsonstr) 这里面的参数只能是 jsonstr 格式的字符串.
当我们使用 str 将字典 dic 转化为字符串以后，得到的结果为:"{'a': 123, 'b': '456', 'c': 'liming'}"。
如果直接使用 json.loads(str(dic)) 你会发现出现错误，原因就是，单引号的字符串不符合Json的标准格式所以再次使用了 replace("'", "\"")。
得到字典
其实这个例子主要目的是告诉大家 Json 的标准格式是不支持单引号型字符串的，否则会出现以下错误。
json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

12. 请写一个 python 逻辑，计算一个文件中的大写字母的数量
答：

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

13. 请写一段 python 链接 Mongo 数据库，然后的查询代码
答：

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 = usernameself.password = passwordif 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 genif __name__ == '__main__':m = Mongo()print(m.find_data())

14. 了解 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()passexcept Exception as err:print(err)pass
if __name__=="__main__":run()

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

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

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

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

17. 用 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_PASSWORDclass RedisLock:def __init__(self):self.conn = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, db=1)self._lock = 0self.lock_key = ""@staticmethoddef my_float(timestamp):"""Args:timestamp:Returns:float或者0如果取出的是None，说明原本锁并没人用，getset已经写入，返回0，可以继续操作。"""if timestamp:return float(timestamp)else:#防止取出的值为None，转换float报错return 0@staticmethoddef get_lock(cls, key, timeout=10):cls.lock_key = f"{key}_dynamic_lock"while cls._lock != 1:timestamp = time.time() + timeout + 1cls._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)) andtime.time() > cls.my_float(cls.conn.getset(cls.lock_key, timestamp))):breakelse:time.sleep(0.3)@staticmethoddef 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 __decoreturn _deco@redis_lock_deco(RedisLock())
def my_func():print("myfunc() called.")time.sleep(20)if __name__ == "__main__":my_func()

18. 写一段 python 使用 mongo 数据库创建索引的代码
答：

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 = usernameself.password = passwordif 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())

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

20.请写一段 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)

21.请写一段 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()#关闭链接

高级特性

返回文章顶部

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

from functools import wrapsdef 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 _wrapreturn 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()

2. python 垃圾回收机制
答：
python 不像 c++ ，Java 等语言一样，它们可以不用事先声明变量类型而直接对变量进行赋值。对 python 语言来讲，对象的类型和内存都是在运行时确定的。这也是为什么称 python 语言为动态类型的原因。

主要体现在下面三个方法：
1、引用计数机制 2、标记-清除 3、分带回收

3. 魔法函数 call 怎么使用
答： call 可以把类实例当做函数调用。使用实例如下：

class Bar:def __call__(self, *args, **kwargs):print('in call')if __name__ == '__main__':b = Bar()b()

4. 如何判断一个对象是函数韩式方法
答：

from types import MethodType, FunctionTypeclass Bar:def foo(self):passdef foo2():passdef 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

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

def iget_no_of_instance(ins_obj)：return ins_obj.__class__.no_instclass Kls(object)：no_inst = 0def __init__(self)：Kls.no_inst = Kls.no_inst + 1ik1 = Kls()
ik2 = Kls()
print(iget_no_of_instance(ik1))

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

IND = 'ON'class Kls(object)：def __init__(self, data)：self.data = data@staticmethoddef 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()

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

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

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

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

class Person()：def __init__(self)：self.name = "liming"self.age = 12def 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()

10. 请列举你知道的 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__并不会 执行。 所以养成一个手工清理的好习惯是很重要的，比如及时关闭连接。

11. 如何知道一个 python 对象的类型
答： 可以通过 type 方法

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

13. python 中的元类 (metaclass) 使用举例
答： 可以使用元类实现一个单例模式，代码如下

class Singleton(type)：def __init__(self, *args, **kwargs)：print("in __init__")self.__instance = Nonesuper(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.__instanceclass Foo(metaclass=Singleton)：pass  # 在代码执行到这里的时候，元类中的__new__方法和__init__方法其实已经被执行了，而不是在 Foo 实例化的时候执行。且仅会执行一次。foo1 = Foo()
foo2 = Foo()
print(foo1 is foo2)

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

15. 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 方法了，一般列表生成式就可以搞定了。

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

def post()：print("this is post")print("想不到吧")class Http()：@classmethoddef get(self)：print("this is get")def main()：Http.get=post #动态的修改了 get 原因的功能，if __name__ == '__main__'：main()      Http.get()

17. 在 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.如果请求分配的内存在 1 ~ 256 字节之间就使用自己的内存管理系统，否则直接使用 malloc。2. 这里还是会调用 malloc 分配内存，但每次会分配一块大小为 256k 的大块内存。
  

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

18. 当退出 python 时是否释放所有内存分配
答： 不是的，循环引用其他对象或引用自全局变量命名空间的对象的模块，在 python 退出时并非完全释放。
另外，也不会释放 c 库保留的内存部分。

正则表达式

返回文章顶部

**1. (1) 使用正则表达式匹配出 www.baidu.com （<html><h1\>www.baidu.com</h1></html>）中的地址 (2) a = “张三 98分”, 用re.sud， 将98 替换为100
答：
（1）

import resource = "<html><h1>www.baidu.com</h1></html>"
pat = re.compile("<html><h1>(.*?)</h1></html>")
print(pat.findall(source)[0])

（2）

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

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

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

   import res = "<html><div>文本 1</div><div>文本 2</div></html>"pat1 = re.compile(r"\<div>(.*?)\</div>")
   print(pat1.findall(s))pat2 = re.compile(r"\<div>(.*)\</div>")
   print(pat2.findall(s))# 输出结果：
   # ['文本 1', '文本 2']
   # ['文本 1</div><div>文本 2']
   

2. 写一段匹配邮箱的正则表达式**
   答： 关于邮箱的匹配这个还真的是一个永恒的话题。

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

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

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

r"^[a-zA-Z0-9]+[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"

下面解释上面的表达式

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

import replt=re.compile(r"^[a-zA-Z0-9]+[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$")
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-]*[a-z0-9])?\.)+[a-z0-9](?：[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])+)\])

其他内容

返回文章顶部

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

def func():pass  # 占位符

2. 简述你对 input() 函数的理解
答：
在 Python3 中 input 函数可以接收用户输入的字符串。
然后根据程序的需要转换成所需格式即可。

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

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

1.介于数字-5 和 256 之间的整数
2.字符串仅包含字母、数字或下划线

4. python 中的作用域
答：

Python 中，一个变量的作用域总是由在代码中被赋值的地方所决定当 Python 遇到一个变量的话它会按照这的顺序进行搜索本地作用域(Local)--->当前作用域被嵌入的本地作用域(Enclosing locals)--->全局/模块作用域(Global)--->内置作用域(Built-in)

5. 三元运算写法和应用场景
答：
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

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

from string import ascii_lowercases = ascii_lowercasefor index, value in enumerate(s)：print(index, value)

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

8. 如何在函数中设置一个全局变量
答：

# 通过使用 global 对全局变量进行修改。
n = 0def foo():global n    # 改变全局变量n = 100foo()
print(n)    # 打印改变后的全局变量    # 100

9. pathlib 的用法举例
答：
pathlib 可以对文件以及文件的其他属性进行操作。比较喜欢的一点是路径拼接符"/"的使用。

10. python 中的异常处理，写一个简单的应用场景
答：
比如在计算除法中出现为 0 的情况出现异常

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

11. python 中递归的最大次数，那如何突破呢
答：
Python 有递归次数限制，默认最大次数为 1000。通过下面的代码可以突破这个限制

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

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

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

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

print(isinstance(True,int))

14. 什么是断言？应用场景
答：
在 Python 中是断言语句 assert 实现此功能，一般在表达式为 True 的情况下，程序才能通过。

#assert（）方法，断言成功，则程序继续执行，断言失败，则程序报错
# 断言能够帮助别人或未来的你理解代码，
# 找出程序中逻辑不对的地方。一方面，
# 断言会提醒你某个对象应该处于何种状态，
# 另一方面，如果某个时候断言为假，
# 会抛出 AssertionError 异常，很有可能终止程序。def foo(a)：assert a==2,Exception("不等于 2")print("ok",a)if __name__ == '__main__'：foo(1)

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

a = [('a',1),('b',2),('c',3),('d',4)]
a_1 = list(map(lambda x:x[0],a))
print(a_1)      # ['a', 'b', 'c', 'd']

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

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

18. 一个包里有单个模块，demo1.py 、demo2.py 、demo3.py，但使用 from tools import *导入 模块时，如何保证只有 demo1 、demo3 被导入了
答： 增加_init_.py 文件，并在文件中增加：

__all__ = ['demo1','demo3']

19. 列举 5 个python 中的一场类型以及其含义

AttributeError 对象没有这个属性NotImplementedError 尚未实现的方法StopIteration 迭代器没有更多的值TypeError 对类型无效的操作IndentationError 缩进错误

20. copy 和 deepcopy 的区别是什么
答：
copy.copy()浅拷贝，只拷贝父对象，不会拷贝对象的内部的子对象。 copy.deepcopy()深拷贝，拷贝对象及其子对象。

21. 代码中经常遇到的*args，kwargs 含义及用法
答：
在函数定义中使用 *args 和**kwargs 传递可变长参数。 *args 用来将参数打包成 tuple 给函数体调用。 **kwargs 打包关键字参数成 dict 给函数体调用。

22. python 中会有函数或成员变量包含单下划线前缀和结尾，和双下划綫前缀和结尾，区别是什么。
答：
“单下划线” 开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量； “双下划线” 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。

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

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

class Person："""docstring for ClassName"""def __init__(self)：self.__age = 12self._sex = 12def _sex(self)：return "男"def set_age(self,age)：self.__age = agedef 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)

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

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

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

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

26. pprint 模块是干什么的
答：pprint 是 print 函数的美化版，可以通过 import pprint 导入。示例如下

import pprint
pprint.pprint("this is pprint")# 对于特别长的数据打印，print()输出结果都在一行，不方便查看，而pprint()采用分行打印输出，所以对于
# 数据结构比较复杂、数据长度较长的数据，适合采用pprint()打印方式。一般情况多数采用print()。

27. 解释一下 python 中的赋值运算符
答： 通过下面的代码列举出所有的赋值运算符

a=7
a+=1    # 自加 1
print(a)    # 8
a-=1    # 自减 1
print(a)    # 7
a*=2    # 自乘 2
print(a)    # 14
a/=2    # 自除 2
print(a)    # 7.0
a**=2   # 求幂
print(a)    # 49.0
a//=3   # 取整
print(a)    # 16.0
a%=4    # 取余
print(a)    # 0.0

28. 解释一下 python 中的逻辑运算符
答： Python 中有三个逻辑运算符：and、or、not

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

29. 讲讲 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

30. 在 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

31. 怎样声明多个变量并赋值
答： Python 是支持多个变量赋值的，代码示例如下

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

算法和数据结构

返回文章顶部

1. 已知：
答：

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)。

2. 用 python 实现一个二分查找的函数
答：

def binary_search(arr, target):n = len(arr)left = 0right = n - 1while left <= right:mid = (left + right) // 2if arr[mid] < target:left = mid + 1elif arr[mid] > target:right = mid - 1else:print(f"index：{mid},value：{arr[mid]}")return Truereturn Falseif __name__ == '__main__':l = [1, 3, 4, 5, 6, 7, 8]binary_search(l, 8)

3. python 单例模式的实现方法
答： 实现单例模式的方法有多种，之前再说元类的时候用 call 方法实现了一个单例模式，另外 Python 的模块就是一个天然的单例模式，这里我们使用 new 关键字来实现一个单例模式。

"""
通过 new 函数实现简单的单例模式。
"""class Book:def __new__(cls, title):if not hasattr(cls, "_ins"):cls._ins = super().__new__(cls)print('in __new__')return cls._insdef __init__(self, title):print('in __init__')super().__init__()self.title = titleif __name__ == '__main__':b = Book('The Spider Book')b2 = Book('The Flask Book')print(id(b))print(id(b2))print(b.title)print(b2.title)# in __new__
# in __init__
# in __new__
# in __init__
# 2225894852808
# 2225894852808
# The Flask Book
# The Flask Book

4. 使用 python 实现一个斐波那契数列
答： 斐波那契数列：数列从第 3 项开始，每一项都等于前两项之和。

def fibonacci(num):"""获取指定位数的列表：param num：：return："""a, b = 0, 1l = []for i in range(num):a, b = b, a + bl.append(b)return lif __name__ == '__main__':print(fibonacci(10))

5. 找出列表中的重复数字
答：

"""
从头扫到尾，只要当前元素值与下标不同，就做一次判断,numbers[i]与 numbers[numbers[i]]，
相等就认为找到了重复元素，返回 true,否则就交换两者，继续循环。直到最后还没找到认为没找到重复元素。
"""# -*- coding：utf-8 -*-
class Solution:def duplicate(self, numbers):""":param numbers::return:"""if numbers is None or len(numbers) <= 1:return Falseuse_set = set()duplication = {}for index, value in enumerate(numbers):if value not in use_set:use_set.add(value)else:duplication[index] = valuereturn duplicationif __name__ == '__main__':s = Solution()d = s.duplicate([1, 2, -3, 4, 4, 95, 95, 5, 2, 2, -3, 7, 7, 5])print(d)    # {4: 4, 6: 95, 8: 2, 9: 2, 10: -3, 12: 7, 13: 5}

6. 找出列表中的单个数字
答：

def find_single(l: list):result = 0for v in l:result ^= vif result == 0:print("没有落单元素")else:print("落单元素", result)if __name__ == '__main__':l = [1, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6]find_single(l)

7. 写一个冒泡排序
答：

"""
冒泡排序
"""def bubble_sort(arr):n = len(arr)for i in range(n - 1):for j in range(n - i - 1):if arr[j] > arr[j + 1]:arr[j], arr[j + 1] = arr[j + 1], arr[j]if __name__ == '__main__':l = [1, 2, 3, 4, 5, 55, 6, 3, 4, 5, 6]bubble_sort(l)print(l)

8. 写一个快速排序
答：

"""
快速排序
"""def quick_sort(arr, first, last)：if first >= last：returnmid_value = arr[first]low = firsthigh = lastwhile low < high：while low < high and arr[high] >= mid_value：high -= 1  # 游标左移arr[low] = arr[high]while low < high and arr[low] < mid_value：low += 1arr[high] = arr[low]arr[low] = mid_valuequick_sort(arr, first, low - 1)quick_sort(arr, low + 1, last)if __name__ == '__main__'：l = [1, 2, 3, 4, 5, 55, 6, 3, 4, 5, 6]quick_sort(l, 0, len(l) - 1)print(l)

9. 写一个拓扑排序
答：

"""
拓扑排序
对应于该图的拓扑排序。每一个有向无环图都至少存在一种拓扑排序。"""
import pysnooper
from typing import Mapping@pysnooper.snoop()
def topological_sort(graph： Mapping)：# in_degrees = {'a'： 0, 'b'： 0, 'c'： 0, 'd'： 0, 'e'： 0, 'f'： 0}in_degrees = dict((u, 0) for u in graph)for u in graph：for v in graph[u]：  # 根据键找出值也就是下级节点in_degrees[v] += 1  # 对获取到的下级节点的入度加 1# 循环结束之后的结果： {'a'： 0, 'b'： 1, 'c'： 1, 'd'： 2, 'e'： 1, 'f'： 4}Q = [u for u in graph if in_degrees[u] == 0]  # 入度为 0 的节点in_degrees_zero = []while Q：u = Q.pop()  # 默认从最后一个移除in_degrees_zero.append(u)  # 存储入度为 0 的节点for v in graph[u]：in_degrees[v] -= 1  # 删除入度为 0 的节点，以及移除其指向if in_degrees[v] == 0：Q.append(v)return in_degrees_zeroif __name__ == '__main__'：# 用字典的键值表示图的节点之间的关系，键当前节点。值是后续节点。graph_dict = {'a'： 'bf',  # 表示 a 指向 b 和 f'b'： 'cdf','c'： 'd','d'： 'ef','e'： 'f','f'： ''}t = topological_sort(graph_dict)print(t)

10. python 实现一个二进制计算
答：

"""
二进制加法
"""
def binary_add(a： str, b： str)：return bin(int(a, 2) + int(b, 2))[2：]if __name__ == '__main__'：num1 = input("输入第一个数，二进制格式：\n")num2 = input("输入第二个数，二进制格式：\n")print(binary_add(num1, num2))

11. 有一组 “+” 和 “-” 符号，要求将 “+” 排到右边，写出具体的实现方法
答：

"""
有一组“+”和“-”符号，要求将“+”排到左边，“-”排到右边，写出具体的实现方法。如果让+等于 0，-等于 1 不就是排序了么。
"""
from collections import deque
from timeit import Timers = "++++++----+++----"# 方法一
def func1()：new_s = s.replace("+", "0").replace("-", "1")result = "".join(sorted(new_s)).replace("0", "+").replace("1", "-")return result# 方法二
def func2()：q = deque()left = q.appendleftright = q.appendfor i in s：if i == "+"：left("+")elif i == "-"：right("-")def func3()：data = list(s)start_index = 0end_index = 0count = len(s)while start_index + end_index < count：if data[start_index] == '-'：data[start_index], data[count - end_index - 1] = data[count - end_index - 1], data[start_index]end_index += 1else：start_index += 1return "".join(data)if __name__ == '__main__'：timer1 = Timer("func1()", "from __main__ import func1")print("func1", timer1.timeit(1000000))timer2 = Timer("func2()", "from __main__ import func2")print("func2", timer2.timeit(1000000))timer3 = Timer("func3()", "from __main__ import func3")print("func3", timer3.timeit(1000000))# 1000000 测试结果
# func1 1.39003764
# func2 1.593012875
# func3 3.3487415590000005
# func1 的方式最优，其次是 func2

12. 单链表反转
答：

"""
单链表反转
"""class Node：def __init__(self, val=None)：self.val = valself.next = Noneclass SingleLinkList：def __init__(self, head=None)："""链表的头部"""self._head = headdef add(self, val： int)："""给链表添加元素：param val： 传过来的数字：return："""# 创建一个节点node = Node(val)if self._head is None：self._head = nodeelse：cur = self._headwhile cur.next is not None：cur = cur.next  # 移动游标cur.next = node  # 如果 next 后面没了证明以及到最后一个节点了def traversal(self)：if self._head is None：returnelse：cur = self._headwhile cur is not None：print(cur.val)cur = cur.nextdef size(self)："""获取链表的大小：return："""count = 0if self._head is None：return countelse：cur = self._headwhile cur is not None：count += 1cur = cur.nextreturn countdef reverse(self)："""单链表反转思路：让 cur.next 先断开即指向 none，指向设定 pre 游标指向断开的元素，然后cur.next 指向断开的元素，再把开始 self._head 再最后一个元素的时候.：return："""if self._head is None or self.size() == 1：returnelse：pre = Nonecur = self._headwhile cur is not None：post = cur.nextcur.next = prepre = curcur = postself._head = pre  # 逆向后的头节点if __name__ == '__main__'：single_link = SingleLinkList()single_link.add(3)single_link.add(5)single_link.add(6)single_link.add(7)single_link.add(8)print("对链表进行遍历")single_link.traversal()print(f"size：{single_link.size()}")print("对链表进行逆向操作之后")single_link.reverse()single_link.traversal()

13. 交叉链表求交点
答：

# Definition for singly-linked list.
class ListNode：def __init__(self, x)：self.val = xself.next = Noneclass Solution：def getIntersectionNode(self, headA, headB)："""：tye head1, head1： ListNode：rtye： ListNode"""if headA is not None and headB is not None：cur1, cur2 = headA, headBwhile cur1 != cur2：cur1 = cur1.next if cur1 is not None else headAcur2 = cur2.next if cur2 is not None else headBreturn cur1

cur1、cur2，2 个指针的初始位置是链表 headA、headB 头结点，cur1、cur2 两个指针一直往后遍历。 直到 cur1 指针走到链表的末尾，然后 cur1 指向 headB； 直到 cur2 指针走到链表的末尾，然后 cur2 指向 headA； 然后再继续遍历； 每次 cur1、cur2 指向 None，则将 cur1、cur2 分别指向 headB、headA。 循环的次数越多，cur1、cur2 的距离越接近，直到 cur1 等于 cur2。则是两个链表的相交点。

14. 用队列实现栈
答： 下面代码分别使用 1 个队列和 2 个队列实现了栈。

from queue import Queue#使用 2 个队列实现
class MyStack：def __init__(self)："""Initialize your data structure here."""# q1 作为进栈出栈，q2 作为中转站self.q1 = Queue()self.q2 = Queue()def push(self, x)："""Push element x onto stack.：type x： int：rtype： void"""self.q1.put(x)def pop(self)："""Removes the element on top of the stack and returns that element.：rtype： int"""while self.q1.qsize() > 1：self.q2.put(self.q1.get())  # 将 q1 中除尾元素外的所有元素转到 q2 中if self.q1.qsize() == 1：res = self.q1.get()  # 弹出 q1 的最后一个元素self.q1, self.q2 = self.q2, self.q1  # 交换 q1,q2return resdef top(self)："""Get the top element.：rtype： int"""while self.q1.qsize() > 1：self.q2.put(self.q1.get())  # 将 q1 中除尾元素外的所有元素转到 q2 中if self.q1.qsize() == 1：res = self.q1.get()  # 弹出 q1 的最后一个元素self.q2.put(res)  # 与 pop 唯一不同的是需要将 q1 最后一个元素保存到 q2 中self.q1, self.q2 = self.q2, self.q1  # 交换 q1,q2return resdef empty(self)："""Returns whether the stack is empty.：rtype： bool"""return not bool(self.q1.qsize() + self.q2.qsize())  # 为空返回 True，不为空返回 False#使用 1 个队列实现
class MyStack2(object)：def __init__(self)："""Initialize your data structure here."""self.sq1 = Queue()def push(self, x)："""Push element x onto stack.：type x： int：rtype： void"""self.sq1.put(x)def pop(self)："""Removes the element on top of the stack and returns that element.：rtype： int"""count = self.sq1.qsize()if count == 0：return Falsewhile count > 1：x = self.sq1.get()self.sq1.put(x)count -= 1return self.sq1.get()def top(self)："""Get the top element.：rtype： int"""count = self.sq1.qsize()if count == 0：return Falsewhile count：x = self.sq1.get()self.sq1.put(x)count -= 1return xdef empty(self)："""Returns whether the stack is empty.：rtype： bool"""return self.sq1.empty()if __name__ == '__main__'：obj = MyStack2()obj.push(1)obj.push(3)obj.push(4)print(obj.pop())print(obj.pop())print(obj.pop())print(obj.empty())

15. 找出数据类的中位数
答：
对于一个升序排序的数组，中位数为左半部分的最大值，右半部分的最小值，而左右两部分可以是无需的，只要保证左半部分的数均小于右半部分即可。因此，左右两半部分分别可用最大堆、最小堆实现。

如果有奇数个数，则中位数放在左半部分；如果有偶数个数，则取左半部分的最大值、右边部分的最小值之平均值。

分两种情况讨论： 当目前有偶数个数字时，数字先插入最小堆，然后选择最小堆的最小值插入最大堆（第一个数字插入左半部分的最小堆）。

当目前有奇数个数字时，数字先插入最大堆，然后选择最大堆的最大值插入最小堆。 最大堆：根结点的键值是所有堆结点键值中最大者，且每个结点的值都比其孩子的值大。 最小堆：根结点的键值是所有堆结点键值中最小者，且每个结点的值都比其孩子的值小。

# -*- coding：utf-8 -*-
from heapq import *class Solution：def __init__(self)：self.maxheap = []self.minheap = []def Insert(self, num)：if (len(self.maxheap) + len(self.minheap)) & 0x1：  # 总数为奇数插入最大堆if len(self.minheap) > 0：if num > self.minheap[0]：  # 大于最小堆里的元素heappush(self.minheap, num)  # 新数据插入最小堆heappush(self.maxheap, -self.minheap[0])  # 最小堆中的最小插入最大堆heappop(self.minheap)else：heappush(self.maxheap, -num)else：heappush(self.maxheap, -num)else：  # 总数为偶数 插入最小堆if len(self.maxheap) > 0：  # 小于最大堆里的元素if num < -self.maxheap[0]：heappush(self.maxheap, -num)  # 新数据插入最大堆heappush(self.minheap, -self.maxheap[0])  # 最大堆中的最大元素插入最小堆heappop(self.maxheap)else：heappush(self.minheap, num)else：heappush(self.minheap, num)def GetMedian(self, n=None)：if (len(self.maxheap) + len(self.minheap)) & 0x1：mid = self.minheap[0]else：mid = (self.minheap[0] - self.maxheap[0]) / 2.0return midif __name__ == '__main__'：s = Solution()s.Insert(1)s.Insert(2)s.Insert(3)s.Insert(4)print(s.GetMedian())

16. 二叉搜索中第 K 小的元素
答：   二叉搜索树(Binary Search Tree)，又名二叉排序树(Binary Sort Tree)。   二叉搜索树是具有有以下性质的二叉树：

• 若左子树不为空，则左子树上所有节点的值均小于或等于它的根节点的值。
• 若右子树不为空，则右子树上所有节点的值均大于或等于它的根节点的值。
• 左、右子树也分别为二叉搜索树。

二叉搜索树按照中序遍历的顺序打印出来正好就是排序好的顺序。所以对其遍历一个节点就进行计数，计数达到 k 的时候就结束。

class TreeNode：def __init__(self, x)：self.val = xself.left = Noneself.right = Noneclass Solution：count = 0nodeVal = 0def kthSmallest(self, root, k)："""：type root： TreeNode：type k： int：rtype： int"""self.dfs(root, k)return self.nodeValdef dfs(self, node, k)：if node != None：self.dfs(node.left, k)self.count = self.count + 1if self.count == k：self.nodeVal = node.val# 将该节点的左右子树置为 None,来结束递归，减少时间复杂度node.left = Nonenode.right = Noneself.dfs(node.right, k)

爬虫类

返回文章顶部

1. 在 requests 模块中，requests.content 和 requests.text 什么区别
答： requests.content 获取的是字节，requests.text 获取的是文本内容。

2. 简要写一下 lxml 模块的使用方法框架
答：

from lxml import html
source='''
<div class="nam"><span>中国</span></div>
root=html.fromstring(source)
_content=root.xpath("string(//div[@class='nam'])")if _content and isinstance(_content,list)：content=_content[0]
elif isinstance(_content,str)：content=_content
print(content)

3. 说一说 scrapy 的工作流程
答：
首先还是先看张图：

以 www.baidu.com 为例： 首先需要知道的事各个模块之间调用都是通过引擎进行的。

• spider 把百度需要下载的第一个 url：www.baidu.com 交给引擎。
• 引擎把 url 交给调度器排序入队处理。
• 调度器把处理好的 request 返回给引擎。
• 通过引擎调动下载器，按照下载中间件的设置下载这个 request。
• 下载器下载完毕结果返回给引擎（如果失败：不好意思，这个 request 下载失败，然后引擎告诉调度器，这个 request 下载失败了，你记录一下，我们待会儿再下载。）
• 引擎调度 spider，把按照 Spider 中间件处理过了的请求，交给 spider 处理。
• spider 把处理好的 url 和 item 传给引擎。
• 引擎根据不同的类型调度不同的模块，调度 Item Pipeline 处理 item。
• 把 url 交给调度器。 然后从第 4 步开始循环，直到获取到你需要的信息。

注意！ 只有当调度器中不存在任何 request 了，整个程序才会停止。

4. scrapy 的去重原理
答：
scrapy 本身自带一个去重中间件，scrapy 源码中可以找到一个 dupefilters.py 去重器。里面有个方法叫做 request_seen，它在 scheduler(发起请求的第一时间)的时候被调用。它代码里面调用了 request_fingerprint 方法（就是给 request 生成一个指纹）。

就是给每一个传递过来的 url 生成一个固定长度的唯一的哈希值。但是这种量级千万到亿的级别内存是可以应付的。

5. scrapy 中间件有几种类，你用过哪些中间件
答：
scrapy 的中间件理论上有三种(Schduler Middleware,Spider Middleware,Downloader Middleware)。在应用上一般有以下两种

• 爬虫中间件 Spider Middleware：主要功能是在爬虫运行过程中进行一些处理。
• 下载器中间件 Downloader Middleware：这个中间件可以实现修改 User-Agent 等 headers 信息，处理重定向，设置代理，失败重试，设置 cookies 等功能。

6. 你写爬虫的时候都遇到过什么？反爬虫措施，你是怎么解决的？
答：

• Headers： 从用户的 headers 进行反爬是最常见的反爬虫策略。Headers 是一种区分浏览器行为和机器行为中最简单的方法，还有一些网站会对 Referer （上级链接）进行检测（机器行为不太可能通过链接跳转实现）从而实现爬虫。 相应的解决措施：通过审查元素或者开发者工具获取相应的 headers 然后把相应的 headers 传输给 Python 的 requests，这样就能很好地绕过。
• IP 限制 一些网站会根据你的 IP 地址访问的频率，次数进行反爬。也就是说如果你用单一的 IP 地址访问频率过高，那么服务器会在短时间内禁止这个 IP 访问。

解决措施：构造自己的 IP 代理池，然后每次访问时随机选择代理（但一些 IP 地址不是非常稳定，需要经常检查更新）。

• UA 限制 UA 是用户访问网站时候的浏览器标识，其反爬机制与 ip 限制类似。

解决措施：使用随机 UA

• 验证码反爬虫或者模拟登陆 验证码：这个办法也是相当古老并且相当的有效果，如果一个爬虫要解释一个验证码中的内容，这在以前通过简单的图像识别是可以完成的，但是就现在来讲，验证码的干扰线，噪点都很多，甚至还出现了人类都难以认识的验证码。

相应的解决措施：验证码识别的基本方法：截图，二值化、中值滤波去噪、分割、紧缩重排（让高矮统一）、字库特征匹配识别。（Python 的 PIL 库或者其他），复杂的情况需求接入打码平台。

• Ajax 动态加载 网页的不希望被爬虫拿到的数据使用 Ajax 动态加载，这样就为爬虫造成了绝大的麻烦，如果一个爬虫不具备 js 引擎，或者具备 js 引擎，但是没有处理 js 返回的方案，或者是具备了 js 引擎，但是没办法让站点显示启用脚本设置。基于这些情况，ajax 动态加载反制爬虫还是相当有效的。

Ajax 动态加载的工作原理是：从网页的 url 加载网页的源代码之后，会在浏览器里执行 JavaScript 程序。这些程序会加载出更多的内容，并把这些内容传输到网页中。这就是为什么有些网页直接爬它的 URL 时却没有数据的原因。

处理方法：找对应的 ajax 接口，一般数据返回类型为 json。

• cookie 限制 一次打开网页会生成一个随机 cookie，如果再次打开网页这个 cookie 不存在，那么再次设置，第三次打开仍然不存在，这就非常有可能是爬虫在工作了。

解决措施：在 headers 挂上相应的 cookie 或者根据其方法进行构造（例如从中选取几个字母进行构造）。如果过于复杂，可以考虑使用 selenium 模块（可以完全模拟浏览器行为）。

7. 为什么会用到代理
答：
如果使用同一个 ip 去不断的访问的网站的话,会很容易被封 ip，严重的永久封禁，导致当前的访问不了该网站。不只是通过程序，通过浏览器也无法访问。

8. 代理失效了怎么处理
答： 一般通过大家代理池来实现代理切换等操作，来实现时时使用新的代理 ip，来避免代理失效的问题。

9. 列出你知道 header 的内容以及信息
答： User-Agent：User-Agent 的内容包含发出请求的用户信息。 Accept：指定客户端能够接收的内容类型。 Accept-Encoding：指定浏览器可以支持的 web 服务器返回内容压缩编码类型。 Accept-Language：浏览器可接受的语言。 Connection：表示是否需要持久连接。（HTTP 1.1 默认进行持久连接）。 Content-Length：请求的内容长度。 If-Modified-Since：如果请求的部分在指定时间之后被修改则请求成功，未被修改则返回 304 代码。 Referer：先前网页的地址，当前请求网页紧随其后，即来路。

10. 说一说打开浏览器访问 www.baidu.com 获取到结果，整个流程
答： 浏览器向 DNS 服务器发送 baidu.com 域名解析请求。 DNS 服务器返回解析后的 ip 给客户端浏览器，浏览器想该 ip 发送页面请求。 DNS 服务器接收到请求后，查询该页面，并将页面发送给客户端浏览器。 客户端浏览器接收到页面后，解析页面中的引用，并再次向服务器发送引用资源请求。 服务器接收到资源请求后，查找并返回资源给客户端。 客户端浏览器接收到资源后，渲染，输出页面展现给用户。

11. 爬取速度过快出现了验证码怎么处理
答： 一般在爬取过程中出现了验证码根据不同的情况，处理不一样。 如果在一开始访问就有验证码,那么就想办法绕开验证码,比如通过 wap 端或者 app 去发现其他接口等，如果不行就得破解验证码了，复杂验证码就需要接入第三方打码平台了。 如果开始的时候没有验证码，爬了一段时间才出现验证码，这个情况就要考虑更换代理 ip 了。 可能因为同一个访问频率高导致的。

12. scrapy 和 scrapy-redis 有什么区别？为什么选择 redis 数据库？
答： scrapy 是一个 Python 爬虫框架，爬取效率极高，具有高度定制性，但是不支持分布式。而 scrapy-redis 一套基于 redis 数据库、运行在 scrapy 框架之上的组件，可以让 scrapy 支持分布式策略，Slaver 端共享 Master 端 redis 数据库里的 item 队列、请求队列和请求指纹集合。

为什么选择 redis 数据库，因为 redis 支持主从同步，而且数据都是缓存在内存中的，所以基于 redis 的分布式爬虫，对请求和数据的高频读取效率非常高。

13. 分布式爬虫主要解决什么问题
答： 使用分布式主要目的就是为了给爬虫加速。解决了单个 ip 的限制，宽带的影响，以及 CPU 的使用情况和 io 等一系列操作

14. 写爬虫是用多进程好？还是多线程好？为什么
答： 多线程，因为爬虫是对网络操作属于 io 密集型操作适合使用多线程或者协程。

15. 解析网页的解析器使用最多的是那几个
答： lxml，pyquery

16. 需要登录的网页，如何解决同时显示 ip , cookie, session （其中有一些是动态生成的）在不适用动态爬取的情况下
答： 解决限制 IP 可以搭建代理 IP 地址池、adsl 拨号使用等。

不适用动态爬取的情况下可以使用反编译 JS 文件获取相应的文件，或者换用其他平台（比如手机端）看看是否可以获取相应的 json 文件，一般要学会习惯性的先找需要爬取网站的 h5 端页面，看看有没有提供接口，进而简化操作。

17. 验证码的解决
答： 图形验证码：干扰、杂色不是特别多的图片可以使用开源库 Tesseract 进行识别，太过复杂的需要借助第三方打码平台。 点击和拖动滑块验证码可以借助 selenium、无图形界面浏览器（chromedirver 或者 phantomjs）和 pillow 包来模拟人的点击和滑动操作，pillow 可以根据色差识别需要滑动的位置。

18. 使用最多的数据库（mysql , mongodb , redis 等），对他的理解
答： MySQL 数据库：开源免费的关系型数据库，需要实现创建数据库、数据表和表的字段，表与表之间可以进行关联（一对多、多对多），是持久化存储。

mongodb 数据库：是非关系型数据库，数据库的三元素是，数据库、集合、文档，可以进行持久化存储，也可作为内存数据库，存储数据不需要事先设定格式，数据以键值对的形式存储。

redis 数据库：非关系型数据库，使用前可以不用设置格式，以键值对的方式保存，文件格式相对自由，主要用与缓存数据库，也可以进行持久化存储。

网络编程

返回文章顶部

1. TCP 和 UDP 的区别

答： UDP 是面向无连接的通讯协议，UDP 数据包括目的端口号和源端口号信息。

优点：UDP 速度快、操作简单、要求系统资源较少，由于通讯不需要连接，可以实现广播发送。

缺点：UDP 传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收，也不重复发送，不可靠。

TCP 是面向连接的通讯协议，通过三次握手建立连接，通讯完成时四次挥手。

优点：TCP 在数据传递时，有确认、窗口、重传、阻塞等控制机制，能保证数据正确性，较为可靠。

缺点：TCP 相对于 UDP 速度慢一点，要求系统资源较多。

2. 简要介绍三次握手和四次挥手

答： 三次握手 第一次握手：主机 A 发送同步报文段（SYN）请求建立连接。 第二次握手：主机 B 听到连接请求，就将该连接放入内核等待队列当中，并向主机 A 发送针对 SYN 的确认 ACK，同时主机 B 也发送自己的请求建立连接（SYN）。 第三次握手：主机 A 针对主机 BSYN 的确认应答 ACK。

四次挥手 第一次挥手：当主机 A 发送数据完毕后，发送 FIN 结束报文段。 第二次挥手：主机 B 收到 FIN 报文段后，向主机 A 发送一个确认序号 ACK（为了防止在这段时间内，对方重传 FIN 报文段）。 第三次挥手：主机 B 准备关闭连接，向主机 A 发送一个 FIN 结束报文段。 第四次挥手：主机 A 收到 FIN 结束报文段后，进入 TIME_WAIT 状态。并向主机 B 发送一个 ACK 表示连接彻底释放。

除此之外经常看的问题还有，为什么 2、3 次挥手不能合在一次挥手中？ 那是因为此时 A 虽然不再发送数据了，但是还可以接收数据，B 可能还有数据要发送给 A，所以两次挥手不能合并为一次。

3. 什么是粘包？socket 中造成粘包的原因是什么？那些情况会发生粘包现象？
答： TCP 是流式协议，只有字节流，流是没有边界的，根部就不存在粘包一说，一般粘包都是业务上没处理好造成的。

但是在描述这个现象的时候，可能还得说粘包。TCP 粘包通俗来讲，就是发送方发送的多个数据包，到接收方后粘连在一起，导致数据包不能完整的体现发送的数据。

导致 TCP 粘包的原因，可能是发送方的原因，也有可能是接受方的原因。

发送方 由于 TCP 需要尽可能高效和可靠，所以 TCP 协议默认采用 Nagle 算法，以合并相连的小数据包，再一次性发送，以达到提升网络传输效率的目的。但是接收方并不知晓发送方合并数据包，而且数据包的合并在 TCP 协议中是没有分界线的，所以这就会导致接收方不能还原其本来的数据包。

接收方 TCP 是基于“流”的。网络传输数据的速度可能会快过接收方处理数据的速度，这时候就会导致，接收方在读取缓冲区时，缓冲区存在多个数据包。在 TCP 协议中接收方是一次读取缓冲区中的所有内容，所以不能反映原本的数据信息。

一般的解决方案大概下面几种：

• 发送定长包。如果每个消息的大小都是一样的，那么在接收对等方只要累计接收数据，直到数据等于一个定长的数值就将它作为一个消息。
• 包尾加上\r\n 标记。FTP 协议正是这么做的。但问题在于如果数据正文中也含有\r\n，则会误判为消息的边界。
• 包头加上包体长度。包头是定长的 4 个字节，说明了包体的长度。接收对等方先接收包体长度，依据包体长度来接收包体。

并发

返回文章顶部

1. 举例说明 concurrent.future 的中线程池的用法
答：

from concurrent.futures import ThreadPoolExecutor
import requests
URLS = ['http：//www.163.com', 'https：//www.baidu.com/', 'https：//github.com/']
def load_url(url)：req= requests.get(url, timeout=60)print(f'{url} page is {len(req.content))} bytes')
with ThreadPoolExecutor(max_workers=3) as pool：pool.map(load_url,URLS)
print('主线程结束')

2. 说一说多线程，多进程 和 协程的区别
答： 概念：
进程：

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,
进程是系统进行资源分配和调度的一个独立单位。每个进程都有自己的独立内存空间，
不同进程通过进程间通信来通信。由于进程比较重量，占据独立的内存，
所以上下文进程间的切换开销（栈、寄存器、虚拟内存、文件句柄等）比较大，但相对比较稳定安全。

线程：

线程是进程的一个实体,是 CPU 调度和分派的基本单位,
它是比进程更小的能独立运行的基本单位.
线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),
但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据。

协程：

协程是一种用户态的轻量级线程，协程的调度完全由用户控制。
协程拥有自己的寄存器上下文和栈。
协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，
直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

区别： 进程与线程比较： 线程是指进程内的一个执行单元,也是进程内的可调度实体。线程与进程的区别：

1) 地址空间：线程是进程内的一个执行单元，进程内至少有一个线程，它们共享进程的地址空间，
而进程有自己独立的地址空间
2) 资源拥有：进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源
3) 线程是处理器调度的基本单位,但进程不是
4) 二者均可并发执行
5) 每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口，
但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制

协程与线程进行比较：

1) 一个线程可以多个协程，一个进程也可以单独拥有多个协程，这样 Python 中则能使用多核 CPU。
2) 线程进程都是同步机制，而协程则是异步
3) 协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态

3. 简述 GIL
答： GIL：全局解释器锁。每个线程在执行的过程都需要先获取 GIL，保证同一时刻只有一个线程可以执行代码。

线程释放 GIL 锁的情况：在 IO 操作等可能会引起阻塞的 systemcall 之前,可以暂时释放 GIL，但在执行完毕后, 必须重新获取 GIL，Python3.x 使用计时器（执行时间达到阈值后，当前线程释放 GIL）或 Python2.x，tickets 计数达到 100 。

Python 使用多进程是可以利用多核的 CPU 资源的。

多线程爬取比单线程性能有提升，因为遇到 IO 阻塞会自动释放 GIL 锁。

4. 进程之间如何通信
答： 可以通过队列的形式，示例如下

from multiprocessing import Queue, Process
import time, random# 要写入的数据
list1 = ["java", "Python", "JavaScript"]def write(queue)："""向队列中添加数据：param queue：：return："""for value in list1：print(f"正在向队列中添加数据-->{value}")# put_nowait 不会等待队列有空闲位置再放入数据，如果数据放入不成功就直接崩溃,比如数据满了。put 的话就会一直等待queue.put_nowait(value)time.sleep(random.random())def read(queue)：while True：# 判断队列是否为空if not queue.empty()：# get_nowait 队列为空，取值的时候不等待，但是取不到值那么直接崩溃了value = queue.get_nowait()print(f'从队列中取到的数据为-->{value}')time.sleep(random.random())else：breakif __name__ == '__main__'：# 父进程创建出队列，通过参数的形式传递给子进程#queue = Queue(2)queue = Queue()# 创建两个进程 一个写数据 一个读数据write_data = Process(target=write, args=(queue,))read_data = Process(target=read, args=(queue,))# 启动进程 写入数据write_data.start()# 使用 join 等待写数据结束write_data.join()# 启动进程  读取数据print('*' * 20)read_data.start()# 使用 join  等待读数据结束read_data.join()print('所有的数据都写入并读取完成。。。')

5. IO 多路复用的作用
答： 阻塞 I/O 只能阻塞一个 I/O 操作，而 I/O 复用模型能够阻塞多个 I/O 操作，所以才叫做多路复用。

I/O 多路复用是用于提升效率，单个进程可以同时监听多个网络连接 IO。 在 IO 密集型的系统中， 相对于线程切换的开销问题，IO 多路复用可以极大的提升系统效率。

6. select、poll、epoll 模型的区别
答： select，poll，epoll 都是 IO 多路复用的机制。I/O 多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。

select 模型： select 目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点。select 的一 个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在 Linux 上一般为 1024，可以通过修改宏定义甚至重新编译内核的方式提升这一限制，但 是这样也会造成效率的降低。

poll 模型： poll 和 select 的实现非常类似，本质上的区别就是存放 fd 集合的数据结构不一样。select 在一个进程内可以维持最多 1024 个连接，poll 在此基础上做了加强，可以维持任意数量的连接。

但 select 和 poll 方式有一个很大的问题就是，我们不难看出来 select 是通过轮训的方式来查找是否可读或者可写，打个比方，如果同时有 100 万个连接都没有断开，而只有一个客户端发送了数据，所以这里它还是需要循环这么多次，造成资源浪费。所以后来出现了 epoll 系统调用。

epoll 模型： epoll 是 select 和 poll 的增强版，epoll 同 poll 一样，文件描述符数量无限制。但是也并不是所有情况下 epoll 都比 select/poll 好，比如在如下场景：在大多数客户端都很活跃的情况下，系统会把所有的回调函数都唤醒，所以会导致负载较高。既然要处理这么多的连接，那倒不如 select 遍历简单有效。

7. 什么是并发和并行
答： “并行是指同一时刻同时做多件事情，而并发是指同一时间间隔内做多件事情”。

并发与并行是两个既相似而又不相同的概念：并发性，又称共行性，是指能处理多个同时性活动的能力；并行是指同时发生的两个并发事件，具有并发的含义，而并发则不一定并行，也亦是说并发事件之间不一定要同一时刻发生。

并发的实质是一个物理 CPU(也可以多个物理 CPU) 在若干道程序之间多路复用，并发性是对有限物理资源强制行使多用户共享以提高效率。 并行性指两个或两个以上事件或活动在同一时刻发生。在多道程序环境下，并行性使多个程序同一时刻可在不同 CPU 上同时执行。

并行，是每个 CPU 运行一个程序。

8. 一个线程 1 让线程 2 去调用一个函数怎么实现
答：

import threadingdef func1(t2)：print('正在执行函数func1')t2.start()def func2()：print('正在执行函数func2')if __name__ == '__main__'：t2 = threading.Thread(target=func2)t1 = threading.Thread(target=func1, args=(t2,))t1.start()

9. 解释什么是异步非阻塞
答： 异步 异步与同步相对，当一个异步过程调用发出后，调用者在没有得到结果之前，就可以继续执行后续操作。当这个调用完成后，一般通过状态、通知和回调来通知调用者。对于异步调用，调用的返回并不受调用者控制。

非阻塞 非阻塞是这样定义的，当线程遇到 I/O 操作时，不会以阻塞的方式等待 I/O 操作的完成或数据的返回，而只是将 I/O 请求发送给操作系统，继续执行下一条语句。当操作系统完成 I/O 操作时，以事件的形式通知执行 I/O 操作的线程，线程会在特定时候处理这个事件。简答理解就是如果程序不会卡住，可以继续执行，就是说非阻塞的。

10. threading.local 的作用
答： threading.local()这个方法是用来保存一个全局变量，但是这个全局变量只有在当前线程才能访问，如果你在开发多线程应用的时候，需要每个线程保存一个单独的数据供当前线程操作，可以考虑使用这个方法，简单有效。代码示例

import threading
import timea = threading.local()#全局对象def worker()：a.x = 0for i in range(200)：time.sleep(0.01)a.x += 1print(threading.current_thread(),a.x)for i in range(20)：threading.Thread(target=worker).start()

Git面试题

返回文章顶部

1. 说说你知道的 Git 命令
答： git init：该命令将创建一个名为 .git 的子目录,这个子目录含有你初始化的 Git 仓库中所有的必须文件,这些文件是 Git 仓库的骨干 git clone url：将服务器代码下载到本地 git pull：将服务器的代码拉到本地进行同步，如果本地有修改会产生冲突。 git push：提交本地修改的代码到服务器 git checkout -b branch：创建并切换分支 git status：查看修改状态 git add 文件名：提交到暂存区 git commit -m “提交内容”：输入提交的注释内容 git log：查看提交的日志情况

2. Git 如何查看某次提交修改的内容
答： 我们首先可以 git log 显示历史的提交列表 之后我们用 git show 便可以显示某次提交的修改内容 同样 git show filename 可以显示某次提交的某个内容的修改信息。

返回文章顶部

---

1. ↩︎

python 中常见的面试练习题相关推荐

1. Python 中常见的配置文件写法

   相信学习Python或者正在进行Python工作的小伙伴都会有一个疑问,为什么要写配置文件呢?在开发过程中,我们常常会用到一些固定参数或者是常量.对于这些较为固定且常用到的部分,往往会将其写到一个固定 ...

2. Python中常见的配置文件写法分享！

   相信学习Python或者正在进行Python工作的小伙伴都会有一个疑问,为什么要写配置文件呢?在开发过程中,我们常常会用到一些固定参数或者是常量.对于这些较为固定且常用到的部分,往往会将其写到一个固定 ...

3. Python中常见的语法糖

   Python中常见的语法糖 知识点导航: 1. 横线分隔符 2. 交换两个变量的值 3. 判断变量是否在范围内 4. 字符串的乘法 5. 列表相加 6. 列表切片 7. 解压序列赋值给多个变量 8. ...

4. python中常见的几种错误

   python中常见的几种错误: 1.end前面一定加逗号 2.命令输入错误 3.冒号中英文切换 4.命令缩进错误 5.等于号要双等于,否则一个等于号是赋值 6.命令之间正确搭配

5. python打开是什么颜色-Python中常见颜色记录

   python中常见绘图的颜色选择 常见颜色 可选的颜色库 颜色名称对应的颜色码 names = { 'aliceblue': '#F0F8FF', 'antiquewhite': '#FAEBD7', ...

6. Python中常见的__init__.py是什么意思？详解Python import的方式和原理

   Python中常见的__init__.py是什么意思?详解Python import的方式和原理 1 什么是模块化编程? 2 __init__.py文件的作用 3 Python如何import第三方库 ...

7. Python中常见的调色板： 颜色 color

   Python中常见的调色板: 颜色 color 这个人对颜色的总结,非常到位哈! https://blog.csdn.net/weixin_42943114/article/details/81811 ...

8. linux运维培训后面试,Linux运维岗位面试中常见的面试问题汇总

   今天小编要跟大家分享的文章是关于Linux运维岗位面试中常见的面试问题汇总.正准备参加Linux运维面试的小伙伴们来和小编一起看一看吧,希望本篇文章能够对正在从事Linux运维工作的小伙伴们有所帮助. ...

9. Python中常见的关键字

   Python中常见的关键字 什么是关键字 简单的我们可以把关键字看作古代朝廷的官衔,每一个当官的人可能不一样,但每一个官衔都对应着不同的职位,不同的职责. Python内部自带的用于处理业务逻辑的特殊 ...

最新文章

1. 图像腐蚀 java_OpenCV3 图像膨胀 dilate、腐蚀 erode、提取图像中的条形码 JAVA 实现...
2. CentOS搭建FTP服务器
3. 数模国赛要点与注意事项全分享！
4. c语言修仙受控可看吗,强推三本神奇到爆的小说，c语言修仙，程序员与修真会擦出什么火花...
5. winform TopMost
6. 細微之處看看mysql與sql server的一些差別
7. Iphone NSMutableArray,NSMutableDictionary AND 动态添加按钮
8. Tomcat的部署+第一个Servlet
9. 如何使用命令强制DC的复制
10. 远程电脑备份与还原数据库
11. python中pickle模块讲解
12. php挂马检测工具,网站挂马检测工具,网站被挂马在线检测工具 | 帮助信息-动天数据...
13. MT7658芯片组资料,MT7658处理器参数介绍
14. 关于常用颜色小聚:有据说是令人舒服的颜色值,有R G B 常用颜色列表
15. 51实现todos-完整js
16. [英语] It_be_XXX_that_YYY强调句句式
17. RACI 责任分配矩阵
18. asp.net的aspx页面＜% %＞、＜%@ %＞、＜%# %＞、＜%= %＞、＜%$ %＞的用法
19. PHPCMS网站关站了打不开-站长真的凉了吗？
20. win7 explorer.exe 服务器运行失败,Win7系统Explorer.exe错误问题的解决方法

热门文章

1. Adobe PhotoShop CS6 下载及安装 以及 error:16的解决
2. [内附完整源码和文档] 基于Java的电脑销售系统
3. 非VR环境下使用Nolo手柄进行交互应用开发
4. 最新英国签证申请过程--2020.1
5. 文华财经指标公式 拿大趋势吃大利润公式指标软件，多空买卖点趋势加密WH6破解wh7随身行
6. 0606算法比赛_字符串处理_抓住问题的关键
7. 访问网站出现Access denied for user 'root'@'%' to database 'xxx'
8. 网络信息系统应急响应
9. 关于scrapy爬取51job网以及智联招聘信息存储文件的设置
10. python中min(x)是什么意思,Python的min/max的C等价性是什么