注意：只有必答题部分计算分值，补充题不计算分值。
第一部分 必答题
-
简述 OSI 7层模型及其作用？（2分）
应用层（应用层，表示层，会话层）
在应用层中封装实际的消息数据（HTTP,HTPPS,FTP）
传输层：
封装端口 指定传输的协议（TCP/UDP）
网络层：
封装ip 版本ipv4/ipv6
数据链层：
封装mac地址 指定链路层协议：arp（通过ip >mac ）/rarp（通过mac ->ip）
物理层：
打成数据包，变成二进制的字节流通过网络进行传输 -
简述 TCP三次握手、四次回收的流程。（3分）
SYN 创建连接
ACK 确认连接
FIN 断开连接
#三次握手
客户端发送一个消息，请求建立连接
服务端接受客户的响应，并且发出与客户端建立连接的请求
客户端接受服务端响应，回应服务端请求
接下来就可以发送数据
#四次挥手
客户端发送一个消息，请求断开连接
服务端接受客户响应，回应请求
等到所有数据接收发完毕之后
服务端发送端开连接的请求
客户端接受服务端响应，回应请求
等到2msl最大报文生存时间过后
客户端和服务端彻底断开连接 -
TCP和UDP的区别？（3分）
TCP:需要建立连接，可靠，速度慢，能传递的数据长度不限
UDP：不需要建立连接，不可靠，速度快，能传递的数据长度有线 -
什么是黏包？（2分）
黏包：
tcp协议数据因为无边界的特点，导致都分开发送的数据粘合在一起变成了一条
现象：
#情况1：
在发送端，数据小，时间间隔短，容易几个数据粘合在一起
#情况2：
在接受端，接受数据慢，在缓存区，导致几个数据粘合在一起
# 解决:
使用struct:
# pack (数据长度在21个亿左右)
"""把任意长度的数字转换成具有4个字节固定长度的字节流"""
res = struct.pack("i",2100000000) #代表当前转化的数据是整型
# unpack
"""把4个字节值恢复成原来的数据,返回的是一个元组"""
tup = struct.unpack("i",res)[0] # 把rev转换成整型int
思路方面:
计算接下来要发送的数据大小是多少
通过pack转化固定4个字节发送给接受段
然后在发送真实数据
接受段需要接受2次,第一次接受转换成的真实数据大小,放recv参数中
第二次在接受真实的数据,才能保证不黏包
场景:
用在及时通讯类中,如果是上传下载不需要. -
什么 B/S 和 C/S 架构？（2分）
B/S:(网站，小程序)
B:browser 浏览器
S：server 服务端
C/S：（软件）
C：client 客户端
S：server 服务端 -
请实现一个简单的socket编程（客户端和服务端可以进行收发消息）（3分）
# 一.TCP 服务端
import socket
# 1.创建一个socket对象
sk = socket.socket()
# 2.绑定ip和端口(注册网络)
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind( ("127.0.0.1",9000) )
# 3.开启监听
sk.listen()
# 4.建立三次握手
conn,addr = sk.accept()
# 5.处理收发数据逻辑
# 接受数据
msg = conn.recv(1024)
msg.decode("utf-8")
# 发送数据
conn.send(b"abc")
conn.send("我好帅哦".encode())
# 6.四次挥手
conn.close()
# 7.退还端口
sk.close()
# 二.TCP 客户端
# 1.创建一个socket对象
sk = socket.socket()
# 2.与服务器进行连接
sk.connect( ("127.0.0.1",9000) )
# 3.收发数据的逻辑
# 发送
sk.send(b"abc")
# 接受
sk.recv(1024)
# 4.关闭链接
sk.close()
# 三.TCP / socketserver 支持TCP的并发操作
import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
conn = self.request
if __name__ == "__main__":
server = socketserver.ThreadingTCPServer( ("127.0.0.1",9000) , MyServer )
server.serve_forever()
# 四.UDP服务端
import socket
# 1.创建一个socket对象
sk = socket.socket(type=socket.SOCK_DGRAM)
# 2.绑定地址
sk.bind( ("127.0.0.1",9000) )
# 3.处理收发数据的逻辑(服务器一定第一次是接受数据)
# 接受
msg , cli_addr = sk.recvfrom(1024)
# 发送
sk.sendto(b"abc" , cli_addr)
# 4.关闭udp连接
sk.close()
# 五.UDP客户端
# 1.创建一个socket对象
sk = socket.socket(type=socket.SOCK_DGRAM)
# 2.收发数据
sk.sendto("你好".encode("utf-8") , ("127.0.0.1",9000) )
sk.recvfrom(1024)
# 3.关闭udp连接
sk.close()
"""
最大的网络传输数据包大小 (MTU 1500Byte)
一般路由器网络转发数据的数据包大小不超过1500B
超过这个范围,该数据会进行拆包和打包的过程
""" -
简述进程、线程、协程的区别？（3分）
进程:资源分配的最小单位,进程之间的数据彼此隔离,可以并发并行
from multiprocessing import Process
线程:程序调度的最小单位,进程里面包含线程,共享同一份进程资源,只能并发(GIL锁)
from threading import Thread
协程:实现单线程在多任务之间的自由切换,是线程执行任务的一种方式
import gevent;from gevent import monkey
monkey.pathch_all() # 识别所有模块中的阻塞
g2 = gevent.spawn(play) -
什么是GIL锁？（2分）
并发:同一时间,一个cpu执行多个任务
并行:同一时间,多个cpu执行多个任务
GIL:全局解释器锁,为了保证数据安全,只让多线程并发,不能并行
在后台一个个的程序都是由一个个的cpython解释器执行的,每个解释器运行的程序都是单独的进程
但是同一时间,程序中的多个线程只能由一个cpu执行
解决办法:
1.换个jpython等其他解释器,又可能出现兼容性问题
2.用多进程的方式间接实现多线程,资源开销较大
历史遗留问题,无法彻底解决 -
进程之间如何进行通信？（2分）
IPC：
1.管道Pipe（进程和进程之间只能单向通信）
2.Queue（进程和进成之间可以双向通信）
3.文件（共享数据）
q = Queue(3)
put get
put_nowait get_nowait (linux有兼容性问题)
empty full qsize(队列长度) -
Python如何使用线程池、进程池？（2分）
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
# (1)创建进程池/线程池对象 8个
p = ProcessPoolExecutor() # 参数:cpu的逻辑处理器数量
p = ThreadPoolExecutor() # 参数:cpu的逻辑处理器数量 * 5
# (2)提交异步任务submit
res = p.submit(func,参数1,参数2,...)
# (3)获取返回值 result (里面有阻塞)
res_new = res.result()
# (4)等待所有子进程执行完毕 shutdown
p.shutdown() -
请通过yield关键字实现一个协程？ （2分）
# 创建生成器
（1）生成器表达式：gen = （i for i in range(10)）
（2）生成器函数：函数内含有yield，需要初始才能使用
def producer():
for i in range(100):
n = yield i
print("结果:%s",n)
def consumer():
# 生成器函数的初始化
g = producer()
# send可以类比next,但是第一次调用时,必须给None,send可以给yield发送数据(上一个yield)
g.send(None)
for i in range(10):
res = g.send(i)
print(res)
consumer() -
什么是异步非阻塞？ （2分）
同步：
代码从上到下按顺序，依次执行
异步：
无需等待当前程序中的代码是否执行完毕
该代码又开启另外一个进程/线程中执行
阻塞：imput ， time， sleep
非阻塞：依次执行，无需等待 -
什么是死锁？如何避免？（2分）
from threading import Lock
互斥锁,死锁,递归锁
只上锁不解锁是死锁
例如:
lock = Lock()
# 1
lock.acquire()
lock.acquire()
lock.acquire()
# 2
进程1
a.acquire()
b.acquire()
b.release()
a.release()
进程2
b.acquire()
a.acquire()
a.release()
b.release()
进程1 拿着A锁抢B锁
进程2 拿着B锁抢A锁
# 使用递归锁,快速应急,解决服务器死锁问题
a = b = RLock()
a.acquire()
a.acquire()
a.acquire()
a.release()
a.release()
a.release()
多次上锁的次数和多次解锁的次数相同,就能达到解锁的目的;
以后使用锁时,尽力不用锁嵌套; -
程序从flag a执行到falg b的时间大致是多少秒？（2分）
import threading
import time
def _wait():
time.sleep(60)
# flag a
t = threading.Thread(target=_wait)
t.setDeamon(False)
t.start()
# flag b
守护进程: 守护的是主进程
守护线程: 守护的是所有线程;
# 0~1秒 -
程序从flag a执行到falg b的时间大致是多少秒？（2分）
import threading
import time
def _wait():
time.sleep(60)
# flag a
t = threading.Thread(target=_wait)
t.setDeamon(True)
t.start()
# flag b
#0点几秒 -
程序从flag a执行到falg b的时间大致是多少秒？（2分）
import threading
import time
def _wait():
time.sleep(60)
# flag a
t = threading.Thread(target=_wait)
t.start()
t.join()
# flag b
#60 -
读程序，请确认执行到最后number是否一定为0（2分）
import threading
loop = int(1E7)
def _add(loop:int = 1):
global number
for _ in range(loop):
number += 1
def _sub(loop:int = 1):
global number
for _ in range(loop):
number -= 1
number = 0
ta = threading.Thread(target=_add,args=(loop,))
ts = threading.Thread(target=_sub,args=(loop,))
ta.start()
ta.join()
ts.start()
ts.join()
# 类型注解 python3.6版本以上
"""
def add(x:int,y:int) -> int:
return x+y
res = add(10,20)
print(res)
"""
# 对 是0
import threading
loop = int(1E7) # 1 * 10的7次幂 10000000
def _add(loop:int = 1):
global number
for _ in range(loop): # for _ in range(10000000)
number += 1
def _sub(loop:int = 1):
global number
for _ in range(loop):
number -= 1
number = 0
ta = threading.Thread(target=_add,args=(loop,))
ts = threading.Thread(target=_sub,args=(loop,))
ta.start()
ta.join()
ts.start()
ts.join() -
读程序，请确认执行到最后number是否一定为0（2分）
import threading
loop = int(1E7)
def _add(loop:int = 1):
global number
for _ in range(loop):
number += 1
def _sub(loop:int = 1):
global number
for _ in range(loop):
number -= 1
number = 0
ta = threading.Thread(target=_add,args=(loop,))
ts = threading.Thread(target=_sub,args=(loop,))
ta.start()
ts.start()
ta.join()
ts.join()
#不一定 -
MySQL常见数据库引擎及区别？（3分）
myisam : 5.5之前的默认存储引擎 , 只支持表级锁(读写互相阻塞)
innodb : 5.5版本之后,默认的存储引擎,支持事务,行级锁,外键,能够抗住更大的并发量(全表扫描,存在表级锁)
memory : 把数据存储在内存里,一般做缓存
blackhole : 黑洞,用来同步数据,应该在主从数据库当中 -
简述事务及其特性？ （3分）
A.原子性:
同一个事务当中可能执行多条sql语句,要么全部成功,要么直接回滚,这个过程看成一个整体,一个不能再分割的最小个体
C.一致性:
a,i,d 都是为了保证数据的一致性提出来的
比如必须按照约束要求插入数据,保证每跳数据类型的一致性
事务角度上,防止脏读,幻读,不可重读,最终决定当前客户端和当前的数据库状态一致
I.隔离性:
lock + isolation锁,来处理事务的隔离级别;
一个事务和另外一个事务在工作过程中彼此隔离独立
如果同时更改同一个数据,因为锁机制的存在,先执行的先改,其他事务需要等待,保证数据安全
D.持久性:
把数据写在磁盘上,保证数据的持久化存储;持久性，隔离性，一致性，原子性 -
事务的隔离级别？（2分）
脏读: 没提交的数据读出来的 (查)
不可重读: 前后多次读取,数据内容不一样(同一个会话中,在不进行修改或者删除的时候,永远看到的是同一套数据)
幻读:前后多次读取,数据内容不一样(从添加的角度上说的)
# 开始事务
begin:
# 处理sql
# commit 提交数据
# rollback 回滚数据
# 数据的隔离级别
RU(READ_UNCOMMITTED) : 读未提交 : 脏读,不可重读,幻读
RC(READ_COMMITTED) : 读已提交 : 防止脏读,会出现不可重复还有幻读
RR(REPEATABLE_READ) : 可重复读 : 防止脏读,不可重复读,可能会出现幻读(默认隔离级别)
SR(SERLALIZABLE) : 可序列化 : 什么都能防止(多个窗口同步,不能并发,性能差)
# 查看默认的隔离级别
select @@tx_isolation
# 查询是否自动提交数据
select @@autocommit
# 找到my.ini 配置文件
autocommit=0 # 关闭自动提交数据
transaction_isolation = READ_UNCOMMITTED # 设置隔离级别
# 打开窗口1
begin;
update t1 set name = "abc" where id = 1
# commit;
# 打开窗口2
select * from t1; -
char和varchar的区别？（2分）
char 定长,速度快
varchar 变长,速度慢,节省空间(内容的开头会有1~2个字节存储数据长度) -
mysql中varchar与char的区别以及varchar(50)中的50代表的含义。（2分）
varchar(50) 最多存50个字符
(字符长度如果小于255个,前头用1个字节存长度
字符长度如果大于255个,前头用2个字节存长度
1111 1111 => 255
1111 1111 1111 1111 => 65535
255 ~ 65535 字符长度
) -
MySQL中delete和truncate的区别？（2分）
delete:清空表数据但不能重置
truncate：清空表并且重置 -
where子句中有a,b,c三个查询条件, 创建一个组合索引abc(a,b,c)，以下哪种会命中索引（3分）
(a) 命中
(b) 不行
(c) 不行
(a,b) 命中
(b,c) 不行
(a,c) 命中
(a,b,c) 命中 -
组合索引遵循什么原则才能命中索引？（2分）
最左前缀原则,条件不能使用范围,可以使用and
# where a>1 and b=1 and c = 100 不能命中
# where b=1 and c = 100 or a = 10 不能命中 -
列举MySQL常见的函数？ （3分）
count
avg
sum
max
min
now()
concat
concat_ws
user => select user()
databases => select databases()
group_concat
year(),month,day(),hour,minute,second week...
password -
MySQL数据库 导入、导出命令有哪些？ （2分）
# 导出 (\q退出数据库)
mysqldump -uroot -p123 db1 > db1.sql
mysqldump -uroot -p123 db1 表1 表2 表3 > ceshi100.sql
# 导入 (进入到mysql,选好数据库)
source /home/wangwen/work/abc.sq -
什么是SQL注入？（2分）
sql注入:通过注入一些特殊的字符,绕开sql的判断机制
# 使用预处理机制,可以尽量避免sql注入
execute 默认参数是一条sql语句,如果加入参数元组,就等于开启预处理
语法:execute(sql,(参数1,参数2,参数3......))
import pymysql
user = input("user>>>:").strip()
pwd = input("password>>>:").strip()
conn = pymysql.connect(host="127.0.0.1",user="root",password="",database="db2")
# 创建游标对象
cursor = conn.cursor()
# 方法一
"""
user>> sdfsd
password>> sdfsdf' or 10=10 -- sdfsdfsf
sql = "select * from usr_pwd where username = '%s' and password='%s' " % (user,pwd)
res = cursor.execute(sql)
print(res) #返回条数
"""
# 方法二
sql = "select * from usr_pwd where username = %s and password=%s"
res = cursor.execute(sql,(user,pwd))
if res:
print("登录成功")
else:
print("登录失败") -
简述left join和inner join的区别？（2分）
left join : 左联 以左表为主,右表为辅,完整查询左表所有数据,右表不存在的数据拿null来补
inner join : 内联 查询左表右表共同存在的数据 select * from a,b where a.cid = b.id -
SQL语句中having的作用？（2分）
一般和 Group by配和使用，将分组之后的数据进行二次过滤用having -
MySQL数据库中varchar和text最多能存储多少个字符？（2分）
varchar 存的是字符 21845 最大字节数 65535
text 存的是字符 65535 最大字节数 65535 * 3 -
MySQL的索引方式有几种？（3分）
主键primary key 唯一索引 unique 普通索引 index
联合主键primary key(字段1,字段2,...)
联合唯一索引 unique(字段1,字段2,..)
联合普通索引 index(a,b,c)
innodb(聚集索引) : 一个表只有一个聚集索引,和多个辅助索引,排序速度比较快
myisam(辅助索引) : 只能有多个辅助索引,没有聚集索引
myisam 和innodb 使用索引数据结构都是b+树,只是叶子节点存储的数据不同
innodb文件结构中只有.frm 和 .ibd, 直接把数据塞到叶子节点上
myisam文件结构中只有.frm .myd .myi 叶子节点存储的该数据的地址(映射关系) -
什么时候索引会失效？（有索引但无法命中索引）（3分）
1.如果查询的是一个大范围内的数据(like in > < ....) 不能命中索引(
2.索引字段参与运算,不能命中,select * from s1 where id*3 = 600
3.如果有or相连,索引字段的判断条件在or的后面,不能命中索引
4.类型不匹配,不能命中 select * from s1 where first_name = 1000
5.联合索引中,不符合最左前缀原则的,不能命中索引
6.like以%开头 -
数据库优化方案？（3分）
1.读写分离（主从数据库，主数据库查询，从数据库负责增删改）
2.分库分表（将字段数量过多的表进行拆分）
3.合理优化数据类型,尽量少的占用空间以合理改善聚集索引b+树的高度(追求矮胖结构) -
什么是MySQL慢日志？（2分）
设定一个时间阀值,执行sql的时间超过该阈值,把该sql记录在日志文件里,就是慢查询日志
# 查看日志开启状态
show variables like 'slow_query_log';
# 开启慢查询日志
set global slow_query_log = "ON";
# 查看时间阈值
show variables like "long_query_time"
# 设置时间的阈值
set global long_query_time = 5
....
# 参考: https://www.cnblogs.com/Yang-Sen/p/11384440.html -
设计表，关系如下: 教师, 班级, 学生, 科室。（4分） 科室与教师为一对多关系, 教师与班级为多对多关系, 班级与学生为一对多关系, 科室中需体现层级关系。
1. 写出各张表的逻辑字段
2. 根据上述关系表
a.查询教师id=1的学生数
b.查询科室id=3的下级部门数
c.查询所带学生最多的教师的id
teacher 老师
id name post_id
1 王老师 1
2 张老师 1
3 金角大王 2
class 班级
id name
1 python1班
2 python2班
3 python3班
t_c_relation 多对多关系
id tid cid
1 1 1
2 1 2
3 3 1
4 3 2
student 学生
id name class_id
1 李四 1
2 张三 2
post 部门
id name parent_id
1 教务部 0
2 python部 1
3 linux部 1
# a
select
count(*)
from
t_c_relation as tc,student as s
where
tc.cid = s.class_id
and
tc.tid = 1
# b
select
count(*)
from
post
where
parent_id = 3
# c
select
tc.tid,count(*) as c
from
t_c_relation as tc,student as s
where
tc.cid = s.class_id
and
tc.tid = 1
group by
tc.tid
order by
c desc
limit 1 -
有staff表,字段为主键Sid,姓名Sname,性别Sex(值为"男"或"女"),课程表Course,字段为主键Cid,课程名称Cname,关系表SC_Relation,字段为Student表主键Sid和Course表主键Cid,组成联合主键,请用SQL查询语句写出查询所有选"计算机"课程的男士的姓名。（3分）
staff
sid sname sex
1 张三 男
2 李四 女
course
cid cname
1 计算机
2 美术
sc_relation
sid cid
1 1
# as 起别名
select
s.sname
from
staff as s,
course as c,
sc_relation as sc
where
sc.sid = s.sid
and c.cid = sc.cid
and c.cname = "计算机"
and s.sex = "男"
# as 可以省略
select
s.sname
from
staff s,
course c,
sc_relation sc
where
sc.sid = s.sid
and c.cid = sc.cid
and c.cname = "计算机"
and s.sex = "男" -
根据表关系写SQL语句（10分）
-
查询所有同学的学号、姓名、选课数、总成绩；
-
查询姓“李”的老师的个数；
-
查询平均成绩大于60分的同学的学号和平均成绩；
-
查询有课程成绩小于60分的同学的学号、姓名
-
删除学习“叶平”老师课的score表记录；
-
查询各科成绩最高和最低的分：以如下形式显示：课程ID，最高分，最低分；
-
查询每门课程被选修的学生数；
-
查询出只选修了一门课程的全部学生的学号和姓名；
-
查询选修“杨艳”老师所授课程的学生中，成绩最高的学生姓名及其成绩；
-
查询两门以上不及格课程的同学的学号及其平均成绩；
-
第二部分 补充题
-
什么是IO多路复用？
内部的实现是异步非阻塞,通过单个线程管理多个socket连接,而不是创建大量的多进程/多线程,节省资源,提升效率
这些网络io操作都会被selector(内部使用linux的epoll多路复用接口实现的)暂时挂起,推入内存队列
此时服务端可以任意处理调度里面的网络io,
当连接的socket有数据的时候,自然会把对应的socket告诉你然后进行读写,而不至于一直阻塞等待 -
async/await关键字的作用？
asyncio 是在io密集型任务中,处理协程异步并发的工具模块,目的是加快通信的速度,减少阻塞等待
async def 关键字定义异步的协程函数
await 关键字加载需要等待的操作前,控制一个可能发生io阻塞任务的切入和切出 -
MySQL的执行计划的作用？
执行计划 在一条sql执行之前,制定执行的方案
"""desc/emplain + sql"""
desc select * from t1;
把执行计划的类型,优化级别从低->高
all > index > range > ref > eq_ref > const > system
目标: 至少达到range , ref;
range 索引范围扫描(注意点:如果范围太大,不能命中索引)
ref 普通索引查询(非唯一) -
简述MySQL触发器、函数、视图、存储过程？
参考： https://www.cnblogs.com/Eva-J/articles/10435035.html -
数据库中有表：t_tade_date
id tade_date
1 2018-1-2
2 2018-1-26
3 2018-2-8
4 2018-5-6
...
输出每个月最后一天的ID
select
id,max(tade_date)
from
t_tade_date
group by
month(tade_date) -
浙公网安备 33010602011771号