Python面试(网编+数据库)

必答题

1，简述 OSI 7层模型及其作用？（2分）

应用层(应用层, 表示层, 会话层)
在应用层中封装实际的消息数据(HTTP, HTTPS, FTP)
传输层:
封装端口
指定传输的协议(TCP / UDP)
网络层:
封装ip
版本ipv4 / ipv6
数据链路层:
封装mac地址
指定链路层协议: arp(通过ip->mac) / rarp(通过mac->ip)
物理层:
打成数据包, 变成二进制的字节流通过网络进行传输

2，简述 TCP三次握手、四次回收的流程。（3分）

SYN
创建连接
ACK
确认响应
FIN
断开连接

# 三次握手
客户端发送一个消息, 请求建立连接
服务端接受客户端的响应, 并且发出与客户端建立连接的请求
客户端接受服务端响应, 回应服务端请求
接下来就可以发送数据...

# 四次挥手
客户端发送一个消息, 请求断开连接
服务端接受客户端响应, 回应请求
等到所有数据收发完毕之后
服务端发送断开连接的请求
客户端接受服务端响应, 回应请求
等到2msl
最大报文生存时间过后
客户端和服务端彻底断凯连接

3，TCP和UDP的区别？（3分）

# tcp
    需要建立连接, 传输可靠, 速度慢, 消息面向字节流无边界
# udp
    不需要建立连接, 可靠性差, 速度快, 消息面向数据报(报文),有边界

4，什么是黏包？（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参数中
第二次在接受真实的数据, 才能保证不黏包

场景:
用在及时通讯类中, 如果是上传下载不需要.

5，什么 B/S 和 C/S 架构？（2分）

网络开发的两大架构:
c / s: client server
    软件
b / s: Brower server
    网站, 小程序

6，请实现一个简单的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
    超过这个范围,该数据会进行拆包和打包的过程
"""

7，简述进程、线程、协程的区别？（3分）

进程: 资源分配的最小单位, 进程之间的数据彼此隔离, 可以并发并行
from multiprocessing import Process

线程: 程序调度的最小单位, 进程里面包含线程, 共享同一份进程资源, 只能并发(GIL锁)
from threading import Thread

协程: 实现单线程在多任务之间的自由切换, 是线程执行任务的一种方式
import gevent;
from gevent import monkey

monkey.pathch_all()  # 识别所有模块中的阻塞
g2 = gevent.spawn(play)

8，什么是GIL锁？（2分）

GIL: 全局解释器锁, 为了保证数据安全, 只让多线程并发, 不能并行
在后台一个个的程序都是由一个个的cpython解释器执行的, 每个解释器运行的程序都是单独的进程
但是同一时间, 程序中的多个线程只能由一个cpu执行

解决办法:
1.换个jpython等其他解释器, 又可能出现兼容性问题
2.用多进程的方式间接实现多线程, 资源开销较大
历史遗留问题, 无法彻底解决

9，进程之间如何进行通信？（2分）

IPC:
1.管道Pipe(进程和进程之间只能单向通信)(了解)
2.Queue(进程和进程之间可以双向通信)
3.文件(共享数据)

10，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()
print("主进程执行结束 .. ")

11，请通过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()

12，什么是异步非阻塞？ （2分）

异步非阻塞:
场景发生在多进程 / 多线程之间,没有任何io阻塞或者等待,同时执行设置setblocking(False)(设置非阻塞了解)

同步:
代码从上到下按照顺序, 依次执行
异步:
无需等待当前程序中的代码是否执行完毕,
该代码又开启另外一个进程 / 线程中执行

阻塞: input, time, sleep, recv...
非阻塞: 依次执行, 无需等待

详解

13，什么是死锁？如何避免？（2分）

# 死锁
    # 只上锁不解锁是死锁

# 避免
    # 使用递归锁,快速应急,解决服务器死锁问题
    # 多次上锁的次数和多次解锁的次数相同, 就能达到解锁的目的
    # 以后使用锁时, 尽力不用锁嵌套

14，程序从flag a执行到falg b的时间大致是多少秒？（2分）

import threading
import time
def _wait():
    time.sleep(60)
# flag a
t = threading.Thread(target=_wait)
t.setDaemon(False)
t.start()
# flag b

0~1秒

"""
守护进程: 守护的是主进程
守护线程: 守护的是所有线程;
"""

15，程序从flag a执行到falg b的时间大致是多少秒？（2分）

import threading
import time
def _wait():
    time.sleep(60)
# flag a
t = threading.Thread(target=_wait)
t.setDaemon(True)
t.start()
# flag b

0~1秒

16，程序从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秒

17，读程序，请确认执行到最后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()

一定为0

18，读程序，请确认执行到最后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()

不一定

19，MySQL常见数据库引擎及区别？（3分）

myisam: 5.5
之前的默认存储引擎, 只支持表级锁(读写互相阻塞)
innodb: 5.5
版本之后, 默认的存储引擎, 支持事务, 行级锁, 外键, 能够抗住更大的并发量(全表扫描, 存在表级锁)
memory: 把数据存储在内存里, 一般做缓存
blackhole: 黑洞, 用来同步数据, 应该在主从数据库当中

20，简述事务及其特性？ （3分）

A.原子性:
同一个事务当中可能执行多条sql语句, 要么全部成功, 要么直接回滚, 这个过程看成一个整体, 一个不能再分割的最小个体
C.一致性:
a, i, d
都是为了保证数据的一致性提出来的
比如必须按照约束要求插入数据, 保证每跳数据类型的一致性
事务角度上, 防止脏读, 幻读, 不可重读, 最终决定当前客户端和当前的数据库状态一致
I.隔离性:
lock + isolation锁, 来处理事务的隔离级别;
一个事务和另外一个事务在工作过程中彼此隔离独立
如果同时更改同一个数据, 因为锁机制的存在, 先执行的先改, 其他事务需要等待, 保证数据安全
D.持久性:
把数据写在磁盘上, 保证数据的持久化存储

21，事务的隔离级别？（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;

拓展

22，char和varchar的区别？（2分）

char
定长, 速度快
varchar
变长, 速度慢, 节省空间(内容的开头会有1~2个字节存储数据长度)

23，mysql中varchar与char的区别以及varchar(50)中的50代表的含义。（2分）

char
定长, 速度快
varchar
变长, 速度慢, 节省空间(内容的开头会有1~2个字节存储数据长度)

varchar(50)
最多存50个字符
(字符长度如果小于255个, 前头用1个字节存长度
 字符长度如果大于255个, 前头用2个字节存长度
 1111 1111 = > 255
 1111 1111 1111 1111 = > 65535
 255 ~ 65535 字符长度
 )

24，MySQL中delete和truncate的区别？（2分）

# delete
    删除数据
# truncate
    重置表(删除数据 + 重置自增id)

25，where子句中有a,b,c三个查询条件, 创建一个组合索引abc(a,b,c)，以下哪种会命中索引（3分）、

(a)    # 命中
(b)
(c)
(a,b)    # 命中
(b,c)
(a,c)    # 命中
(a,b,c)    # 命中

26，组合索引遵循什么原则才能命中索引？（2分）

最左前缀原则, 条件不能使用范围, 可以使用and
# where a>1 and b=1 and c = 100 不能命中
# where b=1 and c = 100 or a = 10 不能命中

27，列举MySQL常见的函数？ （3分）

count    # 计数
avg    # 平均数
sum    # 和
max    # 最大值
min    # 最小值
year    # 年份
mouth    # 月份

28，MySQL数据库 导入、导出命令有哪些？ （2分）

# 导出 (\q退出数据库)
mysqldump - uroot - p123 db1 > db1.sql
mysqldump - uroot - p123 db1 表1 表2 表3 > ceshi100.sql
# 导入 (进入到mysql,选好数据库)
source / home / wangwen / work / abc.sql

29，什么是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("登录失败")

详解

30，简述left join和inner join的区别？（2分）

left join: 左联
以左表为主, 右表为辅, 完整查询左表所有数据, 右表不存在的数据拿null来补
inner join: 内联
查询左表右表共同存在的数据
select * from a, b where a.cid = b.id

31，SQL语句中having的作用？（2分）

一般和group by 配合使用, 将分组之后的数据进行二次过滤用having

32，MySQL数据库中varchar和text最多能存储多少个字符？（2分）

# varchar
存的是字符21845
最大字节数65535
# text
存的是字符65535
最大字节数65535 * 3

33，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
叶子节点存储的该数据的地址(映射关系)

34，什么时候索引会失效？（有索引但无法命中索引）（3分）

1.
如果查询的是一个大范围内的数据(like in > < ....)不能命中索引
2.
索引字段参与运算, 不能命中, select * from s1 where id * 3 = 600
3.
如果有or相连, 索引字段的判断条件在or的后面, 不能命中索引
4.
类型不匹配, 不能命中
select * from s1 wherefirst_name = 1000
5.
联合索引中, 不符合最左前缀原则的, 不能命中索引
6.
like以 % 开头

35，数据库优化方案？（3分）

1.读写分离(主从数据库, 主数据库查询, 从数据库负责增删改)
2.分库分表(将字段数量过多的表进行拆分)
3.合理优化数据类型, 尽量少的占用空间以合理改善聚集索引b + 树的高度(追求矮胖结构)

36，什么是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

37，设计表，关系如下: 教师, 班级, 学生, 科室。（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

# 二，代码
# aselect count(*)from t_c_relation as tc, student as s where tc.cid = s.class_id and tc.tid = 1；

# bselect count(*) from post where parent_id = 3；

# cselect 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；

38，有staff表,字段为主键Sid,姓名Sname,性别Sex(值为"男"或"女"),课程表Course,字段为主键Cid,课程名称Cname,关系表SC_Relation,字段为Student表主键Sid和Course表主键Cid,组成联合主键,请用SQL查询语句写出查询所有选"计算机"课程的男士的姓名。（3分）

# 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 = "男"

39，根据表关系写SQL语句（10分）

查询所有同学的学号、姓名、选课数、总成绩；

select score.student_id,sum(score.num),count(score.student_id),student.sname from score left join student on score.student_id = student.sid group by score.student_id；

查询姓“李”的老师的个数；

select count(tid) from teacher where tname like '李%'；

查询平均成绩大于60分的同学的学号和平均成绩；

select student_id,avg(num) from score group by student_id having avg(num) > 60

查询有课程成绩小于60分的同学的学号、姓名

select sid,sname from student where sid in (select distinct student_id from score where num < 60)；

删除学习“叶平”老师课的score表记录；

delete from score where course_id in (select cid from course left join teacher on course.teacher_id = teacher.tid where teacher.name = '叶平')；

查询各科成绩最高和最低的分：以如下形式显示：课程ID，最高分，最低分；

select course_id, max(num) as max_num, min(num) as min_num from score group by course_id;

查询每门课程被选修的学生数；

select course.cname,count(1) from score left join course on score.course_id = course.cid group by course_id;

查询出只选修了一门课程的全部学生的学号和姓名；

select student.sid, student.sname, count(1) from score left join student on score.student_id  = student.sid group by course_id having count(1) = 1；

查询选修“杨艳”老师所授课程的学生中，成绩最高的学生姓名及其成绩；

select sname,num from score left join student on score.student_id = student.sid where score.course_id in (select course.cid from course left join teacher on course.teacher_id = teacher.tid where tname='张磊老师') order by num desc limit 1;

查询两门以上不及格课程的同学的学号及其平均成绩；

select student_id,count(1) from score where num < 60 group by student_id having count(1) > 2；

补充题

1，什么是IO多路复用？

内部的实现是异步非阻塞, 通过单个线程管理多个socket连接, 而不是创建大量的多进程 / 多线程, 节省资源, 提升效率
这些网络io操作都会被selector(内部使用linux的epoll多路复用接口实现的)
暂时挂起, 推入内存队列
此时服务端可以任意处理调度里面的网络io,
当连接的socket有数据的时候, 自然会把对应的socket告诉你然后进行读写, 而不至于一直阻塞等待

2，async/await关键字的作用？

asyncio
是在io密集型任务中, 处理协程异步并发的工具模块, 目的是加快通信的速度, 减少阻塞等待

async def 关键字定义异步的协程函数

await 关键字加载需要等待的操作前, 控制一个可能发生io阻塞任务的切入和切出

3，MySQL的执行计划的作用？

执行计划
在一条sql执行之前, 制定执行的方案
"""desc/emplain + sql"""
desc select * from t1;

把执行计划的类型, 优化级别从低->高
all > index > range > ref > eq_ref > const > system
目标: 至少达到range, ref;
range索引范围扫描(注意点: 如果范围太大, 不能命中索引)
ref普通索引查询(非唯一)

4，简述MySQL触发器、函数、视图、存储过程？

触发器：触发器是一个特殊的存储过程，它是MySQL在insert、update、delete的时候自动执行的代码块。

函数：MySQL中提供了许多内置函数，还可以自定义函数（实现程序员需要sql逻辑处理）

视图：视图是由查询结果形成的一张虚拟表，是表通过某种运算得到的一个投影

存储过程：把一段代码封装起来，当要执行这一段代码的时候，可以通过调用该存储过程来实现（经过第一次编译后再次调用不需要再次编译，比一个个执行sql语句效率高）

详细讲解链接

5，数据库中有表：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)