1、一行代码实现1～100之和

```python

sum(range(1, 101))

```

2、如何在一个函数内部修改全部变量

```python

'''global'''

name = "xue"

def test():

global name

name = "73"

print("after change: ", name)

test()

print("now name: ", name)

```

3、列出5个python标准库

```python

sys、io、time、json、pickle、math...

```

4、字典如何删除键和合并两个字典

```python

'''

del : 删除

update : 合并

'''

dic = {"name": "xue", "age": 23, 'sex': 'M'}

del dic["sex"]

print(dic)

dic2 = {'hobby': 'basketball'}

dic.update(dic2)

print(dic)

```

5、谈下python的GIL

6、python实现列表去重的方法

```python

l = [1,1,1,1,2,2,2,2,3,3,5,5,7,5,3,4]

print(l)

l = list(set(l))

print(l)

```

7、fun(*args,**kwargs)中的*args,**kwargs什么意思？

```python

*args : 接收N个位置参数，转换成元组

**kwargs : 接收N个关键字参数，转换成字典的形式

```

8、python2和python3的range(100)的区别

```python

python2返回列表，python3返回迭代器，节约内存

```

9、一句话解释什么样的语言能够用装饰器?

```python

能够把函数当作参数传递的语言

```

10、python内建数据类型有哪些

```python

int、bool、str、list、tuple、dict

```

11、简述面向对象中__new__和__init__区别

12、简述with方法打开处理文件帮我们做了什么？

```python

在处理完文件之后，会帮我们自动关闭文件

```

13、列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25]，并使用列表推导式提取出大于10的数，最终输出[16,25]

```python

def pf(x):

return x**2

l = map(pf, [1,2,3,4,5])

print([i for i in l if i>=16])

```

14、python中生成随机整数、随机小数、0—1之间小数方法

```python

import random

print(random.randint(1,3)) # [1,3]之间的随机整数

print(random.uniform(1,3)) # (1,3)之间的随机浮点数

print(random.random()) # [0,1)之间的随机浮点数

```

15、避免转义给字符串加哪个字母表示原始字符串？

```python

r

```

16、< div class="nam">中国< /div>，用正则匹配出标签里面的内容（“中国”），其中class的类名是不确定的

```python

import re

str = "<div class='nam'>中国</div>"

res = re.findall("<div class='.*'>(.*?)</div>", str)

print(res)

```

17、python中断言方法举例

```python

//assert()方法，断言成功，程序继续执行；断言失败，程序报错

class A(object):

def __init__(self, name):

self.name = name

a = A("xue")

assert type(a.name) is str

print(a.name)

```

18、数据表student有id,name,score,city字段，其中name中的名字可有重复，需要消除重复行,请写sql语句

```python

select distinct name from student

```

19、10个Linux常用命令

```python

cd ls rm mkdir cp pwd touch tree mv cat more grep echo

```

20、python2和python3区别？列举5个

```python

1、python3使用print必须使用小括号包裹打印的内容；python2可以用小括号包裹，也可以用空格来分隔打印内容

2、python2中的range()方法返回的是列表，python3中返回的是迭代器，节约内存

3、python2中使用ASCLL编码，python3中使用UTF-8编码

4、python2中的输入内容的方法是raw_input()，python3中的是input()

5、python2中为正常显示中文，需要引入encoding声明，python3不用

```

21、列出python中可变数据类型和不可变数据类型，并简述原理

```python

不可变类型：数值型、字符串型string和元组tuple

如果变量的值发生了变化，相当于新建了一个对象，而对于相同值的对象，在内存中只有一个地址

可变类型：列表list和字典dict

如果对对象进行了append、+=等这些操作之后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址

```

22、s = “ajldjlajfdljfddd”，去重并从小到大排序输出”adfjl”

```python

s = 'ajldjlajfdljfddd'

j = set(s)

l = list(j)

l.sort(reverse=False) # sort()方法无返回值

print(''.join(l))

```

23、用lambda函数实现两个数相乘

```python

sum = lambda a,b:a*b

print(sum(4,5))

```

24、字典根据键从小到大排序dict={“name”:”zs”,”age”:18,”city”:”深圳”,”tel”:”1362626627”}

```python

dic = {"name": "zs", 'age': 18, 'city': "深圳", 'tel': "1362626627"}

print(dic.items())

l = sorted(dic.items(), key=lambda i:i[0], reverse=False)

print(l)

```

25、利用collections库的Counter方法统计字符串每个单词出现的次数”kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h”

```python

from collections import Counter

a = 'kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h'

res = Counter(a)

print(res)

```

26、字符串a = “not 404 found 张三 99 深圳”，每个词中间是空格，用正则过滤掉英文和数字，最终输出”张三 深圳”

```python

import re

a = "not 404 found 张三 99 深圳"

l = a.split()

print(l)

res = re.findall("\d+|[A-Za-z]+", a)

print(res)

for i in res:

if i in l:

l.remove(i)

new_str = " ".join(l)

print(new_str)

```

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

```python

'''

filter(function, iterable)

funtion: 判断函数

iterable: 可迭代对象

return: 迭代器对象

将可迭代对象的每个元素作为参数传递给函数，然后筛选出返回了True的元素

'''

def is_odd(n):

return n%2 == 1

print(list(filter(is_odd, [1,2,3,4,5,6,7,8,9])))

```

28、列表推导式求列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

```python

a = [1,2,3,4,5,6,7,8,9,10]

b = [i for i in a if a%2==1]

print(b)

```

29、正则re.complie作用

```python

将正则表达式编译成一个对象，加快速度，并重复使用

```

30、a=（1，）b=(1)，c=(“1”) 分别是什么类型的数据？

```python

元组、int、str

```

31、两个列表[1,5,7,9]和[2,2,6,8]合并为[1,2,2,3,6,7,8,9]

```python

a = [1,5,7,9]

b = [2,2,6,8]

print(a)

a.extend(b)

print(a)

```

32、用python删除文件和用linux命令删除文件方法

```python

python: os.remove(file_name)

linux: rm file_name

```

33、log日志中，我们需要用时间戳记录error,warning等的发生时间，请用datetime模块打印当前时间戳 “2018-04-01 11:38:54”

```python

import datetime

a = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + " 星期" + str(datetime.datetime.now().isoweekday())

print(a)

```

34、数据库优化查询方法

```python

外键、索引、联合查询、选择特定字段等等

```

35、请列出你会的任意一种统计图（条形图、折线图等）绘制的开源库，第三方也行

36、写一段自定义异常代码

```python

class XueException(Exception):

def __init__(self, msg):

self.msg = msg

try:

raise XueException("my error")

except XueException as e:

print(e)

```

37、正则表达式匹配中，（.）和（.?）匹配区别？

```python

'.'是匹配除了'\n'之外的任意一个字符

'?'是匹配前一个字符1次或0次

```

38、简述Django的orm

39、[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]

```python

a = [[1,2],[3,4],[5,6]]

x = [j for i in a for j in i]

print(x)

```

40、x=”abc”,y=”def”,z=[“d”,”e”,”f”],分别求出x.join(y)和x.join(z)返回的结果

```python

x = 'abc'

y = 'def'

z = ['d', 'e', 'f']

print(x.join(y)) # dabceabcf

print(x.join(z)) # dabceabcf

```

41、举例说明异常模块中try except else finally的相关意义

```python

try...except...else 没有捕获到异常，执行else语句

try...except...finally 不管有没有捕获到异常，都执行finally语句

```

42、python中交换两个数值

```python

a,b = b,a

```

43、举例说明zip（）函数用法

```python

#zip()函数在运算时，会以一个或多个序列(可迭代对象)作为参数，返回一个元组的列表，同时将这些序列中对应的元素配对。

#当两个参数的长度不同时，zip会以最短序列长度为基准截取，获得元组。

a = [1,2]

b = [3,4]

res = [i for i in zip(a,b)]

print(res) # [[1,3],[2,4]]

a = (1,2)

b = (3,4)

res = [i for i in zip(a,b)]

print(res) # [(1,3),(2,4)]

a = "ab"

b = "xyz"

res = [i for i in zip(a,b)]

print(res) # [('a','x'),('b','y')]

```

44、a=”张明 98分”，用re.sub，将98替换为100

```python

import re

a = "张明 98分"

b = re.sub("[0-9]+", '100', a)

print(b)

```

45、写5条常用sql语句

```python

show databases;

show tables;

desc tb_name;

select * from tb_name;

delete from tb_name where id=5;

update tb_name set name="xue", age=23 where id=5;

```

46、a=”hello”和b=”你好”编码成bytes类型

```python

a = b"hello"

b = "哈哈".encode()

print(a, b)

print(type(a), type(b))

```

47、[1,2,3]+[4,5,6]的结果是多少？

```python

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

```

48、提高python运行效率的方法

```python

1、使用生成器，因为可以节约大量内存

2、循环代码优化，避免过多重复代码的执行

3、核心模块用Cython、PyPy等，提高效率

4、多进程、多线程、协程

5、多个if else条件判断，可以把最有可能发生的条件放在前面写，这样可以减少程序的判断次数，提高效率

```

49、简述mysql和redis区别

```python

redis: 内存型非关系数据库，数据保存在内存中，速度快

mysql: 关系型数据库，数据保存在磁盘中，速度相对慢

```

50、遇到bug如何处理

```python

1、细节上的错误，通过print()打印，能执行到print()说明一般上面的代码没什么问题，分段检测程序是否有问题，如果是js的话使用alert或console.log

2、如果涉及一些第三方框架的话，查官方文档或技术博客

3、对于bug的管理和归类总结

```

51、1、正则匹配，匹配日期2018-03-20

url=’;dateType=recent1&device=1&token=ff25b109b&_=1521595613462‘

```python

import re

s = "url=’;dateType=recent1&device=1&token=ff25b109b&_=1521595613462‘"

res = re.findall("[0-9]*-[0-9]*-[0-9]*", s)

#res = re.findall(r'dateRange(.*?)%7C(.*?)&', s)

print(res)

```

52、list=[2,3,5,4,9,6]，从小到大排序，不许用sort，输出[2,3,4,5,6,9]

```python

l = [2,3,5,4,9,6]

new_l = []

def pai(l):

a = min(l)

l.remove(a)

new_l.append(a)

if len(l)>0:

pai(l)

return new_l

pai(l)

print(new_l)

```

53、写一个单列模式

54、保留两位小数

题目本身只有a=”%.03f”%1.3335,让计算a的结果，为了扩充保留小数的思路，提供round方法（数值，保留位数）

```python

a = "%.03f" % 1.3335

print(a, type(a))

b = round(float(a), 1)

print(b)

b = round(float(a), 2)

print(b)

```

55、求三个方法打印结果

```python

def fn(k,v,dic={}):

dic[k] = v

print(dic)

fn("one", 1) # 直接将键值对传给字典

fn('two', 2) # 因为字典在内存中是可变数据类型，所以指向同一个地址，传了新的参数之后，会相当于给字典增加键值对

fn('three', 3, {}) # 因为新传了一个字典，所以不再是原来默认参数的字典

```

56、列出常见的状态码和意义

```python

200 OK: 请求正常处理完毕

204 No Content: 请求成功处理，没有实体的主体返回

206 Partial Content: GET范围请求已成功处理

301 Moved Permanently: 永久重定向，资源已永久分配新URI

302 Found: 临时重定向，资源已临时分配新URI

303 See Other: 临时重定向，期望使用GET定向获取

304 Not Modified: 发送的附带条件请求未满足

307 Temporary Redirect: 临时重定向，POST不会变成GET

400 Bad Request: 请求报文语法错误或者参数错误

401 Unauthorized: 需要通过HTTP认证，或认证失败

403 Forbidden: 请求资源被拒绝

404 Not Found: 无法找到请求资源(服务器无理由拒绝)

500 Internal Server Error: 服务器故障或Web应用故障

503 Service Unavailable: 服务器超负载或停机维护

```

57、分别从前端、后端、数据库阐述web项目的性能优化

58、使用pop和del删除字典中的”name”字段，dic={“name”:”zs”,”age”:18}

```python

dic = {'name': 'xue', 'age': 18}

del dic['name']

print(dic)

dic2 = {'name': 'jack', 'age': 20}

re = dic2.pop('name')

print(re)

print(dic)

```

59、列出常见MYSQL数据存储引擎

60、计算代码运行结果，zip函数历史文章已经说了，得出[(“a”,1),(“b”,2),(“c”,3),(“d”,4),(“e”,5)]

```python

x = ['a','b','c','d','e']

y = [1,2,3,4,5]

z = [i for i in zip(x,y)]

print(z)

```

61、简述同源策略

```python

同源策略需要同时满足以下三点要求：

1、协议相同

2、域名相同

3、端口相同

ex:

http:与https: 协议不同

http:与http:域名不同

http:与http: 端口不同

只要不满足其中任意一个要求，就不符合同源策略，就会出现“跨域”

```

62、简述cookie和session的区别

```python

1、session在服务器端，cookie在客户端(浏览器)

2、session的运行依赖seesion id，而session id 是存在cookie中的，也就是说，如果浏览器禁用cookie，同时session也会失效，存储session时，键与cookie中的sesson id相同，值是开发人员设置的键值对信息，进行了base64编码，过期时间由开发人员设置

3、cookie安全性比session差

```

63、简述多线程、多进程

```python

进程：

1、操作系统进行资源分配和调度的基本单位，多个进程之间相互独立

2、稳定性好，如果一个进程崩溃，不影响其他进程，但是进程消耗资源大，开启的进程数量有限

线程：

1、CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能够独立运行的基本单位，一个进程下的多个进程可以共享该进程的所有资源

2、如果IO操作密集，则可以多个线程运行，效率高，缺点是如果一个线程崩溃，就会造成进程崩溃

应用：

IO密集的用多线程，在用户输入sleep的时候，可以切换到其它线程执行，减少等待时间

CPU密集的用多进程，如果IO操作少，勇夺线程的话，因为线程共享 一个全局解释器锁，当前运行的线程会霸占DIL，其他线程没有DIL，就不能充分利用多核CPU的优势

```

64、简述any()和all()方法

```python

any(): 只要迭代器中有一个元素为真就为真

all(): 迭代器中所有的判断项返回都是真，结果才是真

python中为假的元素：0、空字符串、空列表、空元组、None、False

```

65、IOError、AttributeError、ImportError、IndentationError、IndexError、KeyError、SyntaxError、NameError分别代表什么异常

```python

IOError: 输入输出异常

AttributeError: 试图访问一个对象没有的属性

ImportError: 无法引入模块或包，基本是路径问题

IndentationError: 语法错误，代码没有正确的对齐

IndexError: 下标索引超出序列边界

KeyError: 试图访问你字典里不存在的键

SyntaxError: Python代码逻辑语法出错，不能执行

NameError: 使用一个还未赋予对象的变量

```

66、python中copy和deepcopy区别

```python

1、当复制不可变数据类型时(数值、字符串、元组)

不管是copy还是deepcopy，都和赋值的情况一样，对象的id和原来的值一样，都指向同一块内存地址

2、当复制可变的数据类型时(列表、字典)

对于浅拷贝copy来说，分两种情况

第一种情况，当复制的对象中无复杂的子对象时，原来值的改变并不会影响浅复制的值的改变，浅复制的值的改变也不会影响原来的值，浅复制的id和原来的id不同

第二种情况，当复制的对象中有复杂的子对象时，改变原来值中的复杂子对象的值，会影响浅复制的值，原来的id和浅拷贝的id相同

对于深拷贝deepcopy来说，完全复制独立，包括内层列表和字典

```

67、列出几种魔法方法并简要介绍用途

```python

__init__: 对象初始化的方法

__del__: 删除对象执行的方法

__str__: 当用print输出对象的时候，如果自己定义了__str__(self)方法，就会打印从这个方法中return的数据

__new__: 创建对象会执行的方法，单例模式会用到

```

68、C:\Users\ry-wu.junya\Desktop>python 1.py 22 33命令行启动程序并传参，print(sys.argv)会输出什么数据？

```python

['1.py', '22', '33']

```

69、请将[i for i in range(3)]改成生成器

```python

g = (i for i in range(3))

```

70、a = “ hehheh “,去除收尾空格

```python

a = " hehheh "

a.strip()

```

71、举例sort和sorted对列表排序，list=[0,-1,3,-10,5,9]

```python

list = [0,-1,3,-10,5,9]

list.sort() # list.sort在list的基础上修改，无返回值

print(list)

print(sorted(list)) # sorted有返回值，是新的list

```

72、对list排序foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4],使用lambda函数从小到大排序

```python

foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]

res = sorted(foo, key=lambda x:x)

print(res)

```

73、使用lambda函数对list排序foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]，输出结果为

[0,2,4,8,8,9,-2,-4,-4,-5,-20]，正数从小到大，负数从大到小

```python

foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]

res = sorted(foo, key=lambda x:(x<0, abs(x)))

print(res)

```

74、列表嵌套字典的排序，分别根据年龄和姓名排序

```python

foo = [{'name': 'zs', 'age': 19}, {'name': 'li', 'age': 54},

{'name': 'wa', 'age': 17},{'name': 'df', 'age': 23}]

a = sorted(foo, key=lambda x:x['age'], reverse=True) # 年龄从大到小

print(a)

b = sorted(foo, key=lambda x:x['name']) # name从小到大

print(b)

```

75、列表嵌套元组，分别按字母和数字排序

```python

foo = [('zs', 19), ('li', 54),

('wa', 17),('df', 23)]

a = sorted(foo, key=lambda x:x[1], reverse=True)

print(a)

b = sorted(foo, key=lambda x:x[0])

print(b)

```

76、列表嵌套列表排序，年龄数字相同怎么办？

```python

foo = [['zs', 19], ['li', 54],

['wa', 17], ['df', 23], ['as', 17]]

a = sorted(foo, key=lambda x:(x[1], x[0]))

print(a)

b = sorted(foo, key=lambda x:x[0])

print(b)

```

77、根据键对字典排序（方法一，zip函数）

```python

dic = {"name": "zs", "sex": "man", "city": 'bj'}

foo = zip(dic.keys(), dic.values()) # 字典转列表嵌套元组

foo = [i for i in foo]

print(foo)

b = sorted(foo, key=lambda x:x[0]) # 字典嵌套元组排序

print(b)

new_dic = {x[0]:x[1] for x in b} # 排序完构造新字典

print(new_dic) # 字典不是无序的吗？输出的结果顺序不是未知的吗？

```

78、根据键对字典排序（方法二,不用zip)

```python

dic = {"name": "zs", "sex": "man", "city": 'bj'}

b = sorted(dic.items(), key=lambda x:x[0]) # 字典嵌套元组排序

print(b)

new_dic = {x[0]:x[1] for x in b} # 排序完构造新字典

print(new_dic) # 字典不是无序的吗？输出的结果顺序不是未知的吗？

```

79、列表推导式、字典推导式、生成器

```python

import random

x = [i for i in range(10)] # 列表推导式

y = (i for i in range(10)) # 生成器

z = {k:random.randint(4,9) for k in ['a', 'b', 'c', 'd']} # 字典推导式

```

80、最后出一道检验题目，根据字符串长度排序，看排序是否灵活运用

```python

s = ['ab', 'sbc', 'a', 'sdfg']

b = sorted(s, key=lambda x:len(x)) # sorted有返回值，不改变s本身

print(s, b)

s.sort(key=len) # sort无返回值，在s自身修改

print(s)

```

81、举例说明SQL注入和解决办法

```python

```

82、s=”info:xiaoZhang 33 shandong”,用正则切分字符串输出[‘info’, ‘xiaoZhang’, ‘33’, ‘shandong’]

```python

import re

s='info:xiaoZhang 33 shandong'

x = re.split(':| ', s)

print(x)

```

83、正则匹配以163.com结尾的邮箱

```python

import re

s = ["1595@163.com", "18921@qq.com", "18923@163.comfd", "318391893@gg.com"]

for email in s:

x = re.match('[\w]{4,20}@163\.com$', email)

if x:

print(x.group())

```

84、递归求和

```python

def digui(x):

if x>=1:

res = x+digui(x-1)

else:

res = 0

return res

print(digui(100))

```

85、python字典和json字符串相互转化方法

```python

json.dumps()将字典转换成json字符串，json.loads()将json字符串转字典

```

86、MyISAM 与 InnoDB 区别：

```python

```

87、统计字符串中某字符出现次数

```python

str = "张三 李四 王五 张三 张三张三李四"

res = str.count("李四")

print(res)

```

88、字符串转化大小写

```python

str = "hello world!"

str2 = "HELLO"

s = str.upper()

s2 = str2.lower()

print(s, s2)

```

89、用两种方法去空格

```python

str = "hello world hello world"

res = str.replace(" ", "")

print(res)

str2 = "hello world hello world"

res2 = str2.split(" ")

r = "".join(res)

print(r)

```

90、正则匹配不是以4和7结尾的手机号

```python

import re

tels = ["16855827681", "16855827684", "16855827687", "16855827683", "10086"]

for tel in tels:

r = re.match("\d{10}[0-3,5-6,8-9]$", tel)

if r:

print(r.group())

```

91、简述python引用计数机制

```python

#python垃圾回收主要以引用计数为主，标记清除和分代清除为辅，其中标记清除和分代清除主要是为了处理循环引发的难题。

import time

class Animal(object):

# 创建完对象之后会自动被调用

def __init__(self, name):

print("__init__方法被调用")

self.__name = name

def __del__(self):

print("__del__方法被调用")

print("%s对象马上被干掉了" % self.__name)

cat = Animal("bosimao")

cat2 = cat

cat3 = cat

print(id(cat), id(cat2), id(cat3)) # 输出结果是内存地址相同

del cat

del cat2

del cat3 # __del__方法只有在对象真正被删除的时候才调用，也就是cat3被删除的时候

# 引用计数算法

# 当一个变量保存了对象的引用时，此对象的引用计数就会+1

# 当使用del去删除变量指向的对象时，如果对象的引用计数不为1，比如3,那么此时只会让引用计数-1，即变为2,再次调用变为1,再次调用，此时会真的把对象删除

```

92、int(“1.4”),int(1.4)输出结果？

```python

int("1.4")报错

int(1.4)输出1

```

93、列举3条以上PEP8编码规范

```python

```

94、正则表达式匹配第一个URL

```python

```

95、正则匹配中文

```python

import re

title = "你好，hello，世界"

pattern = re.compile(r'[\u4e00-\u9fa5]+')

result = pattern.findall(title)

print(result)

```

96、简述乐观锁和悲观锁

```python

悲观锁，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每一次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里面就用到了很多这种锁机制，比如行锁、表锁、读锁、写锁等，都是在做操作之前先上锁。

乐观锁，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制，乐观锁适合于多读的应用类型，这样可以提高吞吐量

```

97、r、r+、rb、rb+文件打开模式区别

```python

r: 以只读方式打开文件。文件的指针将放在文件的开头。这是默认模式。

w: 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果文件不存在，创建新文件。

a: 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果文件不存在，创建新的文件进行写入。

rb: 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。

wb: 以二进制格式打开一个文件只用于写入。如果文件已存在则将其覆盖。如果文件不存在，创建新文件。

ab: 以二进制格式打开一个文件用于追加。如果文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容会被写入到已有内容之后。如果文件不存在，创建新文件进行写入。

r+: 打开一个文件用于读写。文件指针将会放在文件开头。

w+: 打开一个文件用于读写。如果文件已存在则将其覆盖。如果文件不存在，创建新文件。

a+: 打开一个文件用于读写。如果文件已存在，文件指针将会放在文件结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

rb+: 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。

wb+: 以二进制格式打开一个文件用于读写。如果文件已存在则将其覆盖。如果文件不存在，创建新文件。

ab+: 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

```

98、Linux命令重定向 > 和 >>

```python

linux允许将命令执行结果，重定向到一个文件

将本应显示在终端上的内容，输出/追加到指定文件中

>表示输出，会覆盖文件原来的内容

>>表示追加，会将内容追加到已有文件的末尾

用法示例：

将 echo 输出的信息保存到 1.txt 里：echo Hello Python > 1.txt

将 tree 输出的信息追加到 1.txt 文件的末尾：tree >> 1.txt

```

99、正则表达式匹配出< html>< h1>; /h1>< /html>

```python

import re

labels = ["<html><h1>;/h1></html>", "<html><h1>;/h2></html>"]

for label in labels:

ret = re.match(r"<(\w*)><(\w*)>.*?</\2></\1>", label)

if ret:

print(ret.group())

```

100、python传参数是传值还是传址？

```python

python中函数参数是引用传递(注意不是值传递)。对于不可变类型(数值型、字符串、元组)，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型(列表、字典)来说，函数体运算可能会更改传入的参数变量。

def selfAdd(a):

a += a

x = 1 # 不可变

selfAdd(x)

print(x)

l = [1,2] # 可变

selfAdd(l)

print(l)

```

101、求两个列表的交集、差集、并集

```python

l1 = [1,4,5,7,3,6,7,9]

l1 = set(l1)

l2 = set([3,5,9,10])

l = list(l1 & l2)

print(l)

l = list(l1 | l2)

print(l)

l = list(l1 - l2)

print(l)

```

102、生成0-100的随机数

```python

import random

res1 = 100*random.random()

res2 = random.choice(range(0,101))

res3 = random.randint(0,100)

print(res1, res2, res3)

```

103、lambda匿名函数好处

```python

精简代码，lambda省去了定义函数

```

104、常见的网络传输协议

```python

tcp、udp、ftp、http、smtp等

```

105、单引号、双引号、三引号用法

```python

1、单引号和双引号没有什么区别，不过单引号不用按shift键，打字稍微快一点。表示字符串的时候，单引号里面可以用双引号，而不用转义字符，反之亦然。

2、但是如果直接用单引号括住单引号，则需要转义

3、三引号可以直接书写多行，通常用于大段，大篇幅的字符串

```

106、python垃圾回收机制

```python

python垃圾回收主要以引用计数为主，标记-清除和分代回收为辅的机制

```

107、HTTP请求中get和post区别

```python

1、GET请求是通过URL直接请求数据，数据信息可以在URL中直接看到，比如浏览器访问；而POST请求是放在请求头中的，我们是无法直接看到的

2、少量的数据提交用GET，大量的数据提交用POST。GET提交的数据大小的限制，一般不超过1024个字节，而这种说法不完全正确，HTTP协议并没有设定URL字节长度的上限，而浏览器做了些处理，所有长度依据浏览器的不同有所不同；POST请求在HTTP协议中也没有做说明，一般来说是没有设置限制的，但是实际上浏览器也有默认值。

3、GET请求的数据参数是直接显示在URL中的，可以直接看到的，POST请求的数据参数放在请求头中，所以安全度比GET高一点，但是两者都是不安全的，数据参数都是可以被提取出来的。在实际中，涉及登录操作的时候，尽量使用HTTPS请求，安全性更好。

```

108、python中读取Excel文件的方法

```python

import pandas as pd # 应用数据分析库pandas

df = pd.read_excel("1.xlsx")

print(df)

```

109、简述多线程、多进程

```python

进程：

1、操作系统进行资源分配和调度的基本单位，多个进程之间相互独立

2、稳定性好，如果一个进程崩溃，不影响其他进程，但是进程消耗资源大，开启的进程数量有限制

线程：

1、CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能独立运行的基本单位，一个进程下的多个线程可以共享该进程的所有资源

2、如果IO操作密集，则可以用多进程，运行效率高，缺点是如果一个线程崩溃，都会造成进程的崩溃

应用：

IO密集的用多线程，在用户输入，sleep的时候，可以切换到其它线程执行，减少等待时间

CPU密集的用多进程，因为如果IO操作少，用多线程的话，因为线程共享一个全局解释器锁，当前运行的线程会霸占GIL，其它线程没有GIL，就不能充分利用多核CPU的优势

```