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、< figure class="nam">中国< /figure>，用正则匹配出标签里面的内容（“中国”），其中class的类名是不确定的
```python
import re
str = "<figure class='nam'>中国</figure>"
res = re.findall("<figure class='.*'>(.*?)</figure>", 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=’https://sycm.taobao.com/bda/tradinganaly/overview/get_summary.json?dateRange=2018-03-20%7C2018-03-20&dateType=recent1&device=1&token=ff25b109b&_=1521595613462‘
```python
import re
s = "url=’https://sycm.taobao.com/bda/tradinganaly/overview/get_summary.json?dateRange=2018-03-20%7C2018-03-20&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:www.test.com与https:www.test.com 协议不同
http:www.test.com与http:www.admin.com域名不同
http:www.test.com与http:www.test.com:8081 端口不同
只要不满足其中任意一个要求，就不符合同源策略，就会出现“跨域”
```
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#39;, 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]#34;, 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>www.itcast.cn< /h1>< /html>
```python
import re
labels = ["<html><h1>www.itcast.cn</h1></html>", "<html><h1>www.itcast.cn</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的优势
```
本文到此讲解完毕了，希望对大家有帮助。
相关资讯
