python面试

发表于2020-02-27|更新于2022-09-27|面试题

python面试整理

常见面试题

1.自我介绍（专业技术+项目经验）
2.自己做过的项目中遇到过印象最深（难度最高）的问题，要求详细具体阐述（难点突出）
3.Python的内存管理机制和垃圾清理机制
4.MySQL数据库如何插入或修改一个字段
5.Python2和Python3的区别
6.Python3是用什么编码的，Python3转码的函数
7.Nginx如何用一个IP部署服务器
8.列举列表和字典中的所有方法
9.如何利用js写多线程
10.Django如何实现一个页面的跳转
11.socket编程有哪几种方式，具体如何实现的
12.这里有一支笔，请列举这支笔的10种用途

熟悉PyQt 框架
熟悉numpy pandas matplotlib 数学工具库

mysql事务优化
秒杀
redis
web 网络访问效率
Django屏蔽用户多次恶心请求
获取密码后登录django后台处理
python装饰器
nginx
Django和flask 对比
Python可变与不可变类型区别，都有哪些类型（5’）
可变类型：列表list，字典tuple
不可变类型：数字，字符串，元祖
Python浅拷贝与深拷贝的实现方式与区别（5’）
赋值：只拷贝引用
浅拷贝：可变元素可以改变
深拷贝：包含对象里面的所有对象都拷贝
常见设计模式有哪些（5’）
单例
建造者
工厂
装饰器
观察者
Python编码和解码简要描述（5’）
Python2的默认编码是ASCII,不能识别中文
Python3 的默认编码是Unicode, 可以识别中文
通常在文件开头：# -*- coding:utf-8# 声明编码格式
Python解释器会把源码文件的为二进制数据读入内存
正则匹配邮箱地址（5’）

1 2	#163邮箱 re.match(r “[a-zA-Z0-9]{4,20}@163\.com$”, email)

多进程与多线程的区别（5’）
进程是正在进行的程序，线程是进程的执行单元。
多线程可以共享全局变量，多进程不能。
多线程之间可以直接通信，多进程需要通过共享内存或者pipe, 中间件等通信来进行操作。
多进程中的同一变量，保存在每个进程中，多线程中共享变量。
多进程偏重CPU资源，计算任务多的考虑多进程实现。
多线程偏重于IO输入输出等，考虑多线程实现
python高并发解决方案有哪些（5’）
celery + rabbitmq 并发
分布式服务部署
Nginx部署负载均衡
Redis 内存写入速度快
用一行Python写出1+2+3+…+108（5’）
sum([x for x in range(1, 108+1)])
Python：用递归的方式判断字符串是否为回文（5’）

def is_hui_wen(str):
		if ( len(str) < 2):
			return True
		elif str[0] != str [-1]:
			return False
		return is_hui_wen(str[1:-1])

HTTP连接方式，GET和POST的区别（5’）
请求数据：
GET: 请求参数直接包含在URL
POST: 请求参数需要包含在请求体中
安全性：
POST的安全性更高，get提交的数据直接显示在URL，容易被获取。Post请求参数不会被浏览器或服务器保留。
携带数据长度：
Get通过URL携带数据长度是有具体限制的，而POST无限制
状态码有哪些，200/403/404/500等的含义（5’）
200/201/400/302/500等等
200:客户端请求成功
403: 禁止访问
404: 请求资源未找到
500: 服务器内部错误
’*args‘，**kwargs是什么（5’）
可变参数的两种形式：

*args：多个无名参数，tuple
**kwargs: 多个键对值参数，dict

1.Python中 `*args`和`**kwargs`的区别

1. *args 用于将参数打包给tuple使用
1. **kwargs 用于将参数打包给dict给函数体调用

2. Python中单例模式的几种实现和优化

1. 使用模块
  1
  class singleton
1. 使用装饰器
1. 使用类
1. 基于 __new__ 方法实现（推荐使用，方便）
1. 基于metaclass方式实现

3. python中 `@classmethod` , `@staticmethod`区别

class A(object):
    def foo(self, x):
        print("executing foo(%s,%s)" % (self, x))
        print('self:', self)
    @classmethod
    def class_foo(cls, x):
        print("executing class_foo(%s,%s)" % (cls, x))
        print('cls:', cls)
    @staticmethod
    def static_foo(x):
        print("executing static_foo(%s)" % x)    
a = A()

1. 定义方式

1.普通类方法 foo() 需要通过 self 参数隐式的传递当前类对象的实例。
2.@classmethod修饰的方法 class_foo() 需要通过cls参数传递当前类对象。
3.@staticmethod修饰的方法定义与普通函数是一样的。

2. 绑定对象

3. 调用方式

4. 继承与覆盖普通类函数是一样的

富途python面试

a[]={21,11,45,56,9,66,77,89,78,68,100,120,111}
请查询数组中有没有比它前面元素都大,比它后面的元素都小的数,没有打印-1,有显示其索引。要求时间复杂度和空间复杂度最大都是O(N)。

#[面试题]乱序数组中找比左边都小比右边都大的数
data = [3,4,2,0,1]

def findPos(data):
    for i in range(1, len(data)-1):
        minLeft = min(data[:i])
        maxRight = max(data[i+1:])
        if data[i] < minLeft and data[i] > maxRight:
            return i
    return -1

print(findPos(data))

https://zhuanlan.zhihu.com/p/74769677

10.排序算法简述（常用的冒泡插入选择堆快排归并）说流程，说时间空间复杂度，说改进
https://blog.csdn.net/weixin_41571493/article/details/81875088

5.设计模式举例，单例模式举例
https://blog.csdn.net/Burgess_zheng/article/details/86762248

实现一个单例模式

class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
        pass

    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):

            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = object.__new__(cls)

        return Singleton._instance

class Sun:
    # 定义类属性
    __instance = None
    def __new__(cls, *args, **kwargs):
        # 如果__instance还没有值，就给__instance变量赋值
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            return cls.__instance

3.python 进程线程区别
4.python 多线程通信
5.python 多进程通信
6.集合类的理解
7.堆栈区别
8.TCP UDP HTTP
9.智力题老鼠喝毒药
11.算法题：二叉树中最长路径（递归）——本地IDE写完了发给他文件
12.二叉树的理解（二叉搜索树，AVL树，B树，B+树）
13.智力题随机数生成器，只生成0，1，但是不公平，做一个公平的方案？（）01为0,10为1，其余重来。一开始想多了，后来简化了。
14.算法题：删除单链表的倒数第N个节点，返回新链表（剑指offer原题，快慢指针）——不过我用了一个for和一个while，可以更简化用一个while就好，当时也是让我优化，我一时没反应过来。。。。

Python基础和算法，
问答
算法题。
MySQL的问题，像是索引、乐观锁悲观锁、语句执行慢怎么优化等
MySQL，包括事务、锁(表锁、行锁)、怎么实现乐观锁、索引结构等。

手写算法题，将[1,[2,3],[4,[5,6]]]这样的列表，输出[1,2,3,4,5,6]这样的格式。
二面：模拟出扫雷游戏，在二维矩阵内随机生成地雷，同时在每个单元格标记出周围九宫格内的地雷数，最后返回这个矩阵。

针对算法题的随机生成地雷，
如果要求生成的地雷数比较多，怎么才能避免做重复的随机？
我回答的是用元组单独存储坐标，(x,y)，每次从这个元组列表中随机挑选出一个点来作为地雷，这样可以避免无效的随机。

三面：给了一个抽奖的场景，假如有一等奖5个，二等奖10个，三等奖20个，参与奖若干个，每个用户只能参与一次，从前端访问后端，该怎么设计？
包括前端提交什么数据，格式是什么；
后端怎么处理数据，数据表怎么设计等。

针对你给的答案，面试官还会进行追问，主要是考察Web安全、系统设计等能力。针对我实现的抽奖逻辑，也重点进行了提问，包括怎么优化能让抽奖结果比较公平？奖品的库存该怎么减？然后是针对简历中的项目进行询问，

https://www.kanzhun.com/firm/interview/detail/1nV-2Ny0FFY~.html?ka=com-interview-card-click

北京途游游戏后端开发

　1.说一下你开发过的项目，挑一个说下你都做了什么模块与功能
- 1.爬虫项目
- 2.在线生鲜商城　　
　3.如果你需要学习一种新技术，你会怎么做？
分步骤: 1.了解原理，2.掌握使用 3.编码练习 4.项目应用
　5.你会前端吗？你公司前后端分离吗？
　6.你常用的数据库有哪些？　mysql mongodb redis
　7.你开发的这个项目上线了吗？每天的访问量是多少？数据库中有多少用户？　
- 内部项目
　8.python的数据类型？　
string
　9.你之前的项目是在什么开发环境上进行开发的？怎么进行部署的？
Macos 部署上线在ubuntu进行的。
```
　　
```
　10.说一下你的某个项目中，数据库中有哪些表？举例说明表与表是怎么进行关联的？
　1. 网络的七层协议、HTTP、TCP、IP 各在哪一层？　　
　IP协议位于网络层，TCP/UDP协议位于传输层，HTTP位于应用层。
　HTTP 与 TCP 的区别？
　　TCP协议对应于传输层，而HTTP协议对应于应用层，从本质上来说，二者没有可比性。

1，http对应于应用层
2，Tcp协议对应于传输层
3，http协议是在Tcp协议之上建立的，http在发起请求时通过tcp协议建立起连接服务器的通道，请求结束后，立即断开tcp连接

说明：从HTTP/1.1起，默认都开启了Keep-Alive，保持连接特性，
4，Http是无状态的短连接，而TCP是有状态的长连接

socket:
Socket本身并不是协议，而是一个调用接口(API)。Socket的出现只是使得程序员更方便地使用TCP/IP协议栈而已，是对TCP/IP协议的抽象，从而形成了我们知道的一些最基本的函数接口

http协议详解：
HTTP使用统一资源标识符（Uniform Resource Identifiers, URI）来传输数据和建立连接。

HTTP请求格式：
- 请求行（request line）
- 请求头部（header）
- 请求数据
http响应：
- HTTP响应也由四个部分组成，分别是：状态行、消息报头、空行和响应正文。

　2.restful 风格

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。
资源：互联网所有的事物都可以被抽象为资源
资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
分别对应添加、删除、修改、查询。

#传统方式操作资源
http://127.0.0.1/item/queryItem.action?id=1 查询,GET
http://127.0.0.1/item/saveItem.action 新增,POST
http://127.0.0.1/item/updateItem.action 更新,POST
http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

#使用RESTful操作资源
http://127.0.0.1/item/1 查询,GET
http://127.0.0.1/item 新增,POST
http://127.0.0.1/item 更新,PUT
http://127.0.0.1/item/1 删除,DELETE

　3.假如你的数据库版本是1.0的，一张表的字段个数为10个。
那么现在用的版本是1.1的，想要在表中进行增删改查，有哪些方式？
　（我当时懵了，直接说了句我修改了数据库脚本，然后人家就问我除了这种方式，还有呢？)　　
　4.redis 中有哪些数据类型？ hash类型怎么设置值？　　
　5.非关系型数据库，例如Mongodb，怎么去关联两张表？　　
　6.什么是解释器？什么是编译器？
- 解释器：直接执行用编程语言编写的指令的程序 python解释器
- 编译器：把源代码转换成（翻译）低级语言的程序。
  - Java只有两个编译器，javac将源码编译成字节码，JIT将字节码编译成机器码
　7.你用过Python的哪些版本？说一下2.x与3.x的不同
- 1. print() 在py3中是做函数存在的
- 1. nonlocal 非局部变量
- 1. 迭代器
- 1. 整除返回小数
- 1. Unicode （Assical -> UTF-8）
- 1. 数据类型 long型去除
- 1. True 和 False
　9.你怎样理解Python面向对象？
　
　举例说明什么是多态？　　
　说一下你是怎么实现python的封装的？　　
　
10.你在设计接口的时候，需要考虑哪些问题？　　
11.你做过类似优化的工作吗？前端优化，代码优化，数据库优化
（我当时顺口说了句数据库的优化)，那么您是怎么进行数据库的优化的？　　
12.在多个用户同时发起对同一个商品的下单请求时，先查询商品库存，再修改商品库存，会出现资源竞争问题，导致库存的最终结果出现异常。例如：id为16的商品的库存为10，两人同时购买，每人买5件，如果产生并发问题，两人下单都成功，但是库存变成了5。怎么解决这个问题？　
悲观锁
13.GET 与POST 的区别？
　 POST方法可以获取到数据吗？　
　 body与form表单、data的区别？　　
　
14.你用过的常见的算法有哪些?
15.什么是装饰器？利用装饰器的好处? 手写一个装饰器

16.手写一个单例模式　

1
2
3

class singleton(object):
    
    __init__(cls):

16.你打印过 HTTP 吗？

17.你是怎么处理高并发问题的？

例如：商品库存（数据库sql语句加锁处理：

#乐观锁
update goods set number =2 where id = 1 and number =7;                                  
#悲观锁
update goods set number =2 where id = 1 for update;
update goods set number =2 where id = 1 lock in share mode;

celery
负载均衡
使用协程, 事件循环, 高效IO模型(比如多路复用，比如epoll), 三者缺一不可。

18.你的项目是怎么部署的？
说一下一个项目部署的步骤（根据简历的实际情况，我的是，Django+Nginx+Uwsgi）　
　a. 说一下Nginx的特点　　
　b. 一个请求进来的时候，你是怎么保证你的服务器是开启的？　
　c.如果你的服务器是开启的，但是执行sql语句的代码发生了问题，会怎么样？会发生什么？
19.对比一下 Django 和 Flask 有什么优缺点？

实时对战游戏的难点

1. 实时性
  所谓游戏的实时同步，是指玩家在游戏内的操作能够立即得到反馈，并且同步给其他玩家，让其他玩家也能尽快的知道该玩家的操作，所以操作反馈的实时性是衡量同步的实现是否优秀的一个关键指标。玩家的操作反馈越实时，其同步实现就越好。
  不同类型的游戏对操作实时性的要求并不一样，FPS对战类型的游戏，例如《守望先锋》，对操作实时性的要求是最高的，操作反馈延时一般不能超过50毫秒，MOBA类游戏《王者荣耀》，休闲竞技类游戏《球球大作战》，ARPG类型的游戏对实时性的要求也比较高，延迟一般不能超过100毫秒，MMORPG类型的游戏《魔兽世界》对实时性的要求相对低一些，200毫秒以下都能接受。
1. 一致性
  游戏的一致性是指参与游戏的所有玩家看到游戏状态都是一样的。游戏的一致性分为过程一致性和结果一致性。过程一致性是指在游戏过程中，所有参与玩家每一帧的状态都一致；而结果一致性是指在游戏过程中，中间的状态可能不一致，但是游戏结束的时候最终的结果必须一致。所有的实时游戏，都要求结果一致性，但是过程不一定要完全一致。很多的实时同步算法，都会以牺牲一定的过程一致来获取更好的效率。
1. 在弱网环境下的流畅性
  现在很多实时游戏，例如《王者荣耀》都运行在移动终端，例如手机上。手机上的移动网络是一种典型的弱网环境，其质量不稳定，延迟高，还经常有丢包，因此能否在弱网环境下流畅的同步是衡量同步实现是否优秀的一个重要指标。
1. 同步玩家数量
  同一场景内可以支持的玩家数量，也是一个重要的指标，不同类型的游戏一般要求差别比较大。对战类型的游戏，例如《守望先锋》、《王者荣耀》，一般场景内的玩家人数都不超过10人；吃鸡类型的游戏，一般场景内的人数不超过100人；MMORPG游戏，例如《魔兽世界》，同一场景内的人数可以达到上千人。
1. 反作弊性
  大部分玩家都期望游戏是公平的，玩家无法通过作弊来获取不当收益，从而影响游戏的公平性，所以反作弊性是一个重要的指标。游戏作弊一般有两种方式，一种是能够查看一些本来应该对玩家保密的游戏信息，例如战争迷雾，这种作弊方式相对没有这么严重。另外一种是可以直接篡改游戏数据，这种方式就比较严重了，会完全破坏游戏的平衡性，要严格避免。一般来说，游戏的客户端比较容易被第三方软件篡改，所以能否通过直接查看或者修改优秀客户端数据就能进行作弊，是衡量同步实现在反作弊性方面表现是否优秀的一个很重要的评价标准。
  网络流量消耗
  网络流量永远都是稀缺的，能否尽可能的降低流量消耗是步是衡量同步实现是否优秀的一个重要指标。

三种不同方向的技术实现介绍

————————————————
原文链接：https://blog.csdn.net/rovesky/article/details/104016129

深信服Python面试题整理

1.网关的作用

网关（协议转换器；网间转换器）能够实现跨网络传输（跨网是指不同体系结构的网络或者不同协议之间网络）。
网关可以实现协议转化，路由选择，数据交换等网络兼容功能的设施。
不同协议网络/不同体系结构的网络不能通信的原因在于数据格式，语言，通信协议不同，因此需要一种翻译器进行翻译，网关就是起到这样的作用。
网关收到传输的信息后，会对信息重新打包，达到目的系统的需求。
什么是网关：一般来说LAN接口或者路由器的默认ip地址就是网关，它界定了域网与其他空间网路之间的界限。
在同一局域网内，网络地址相同，则不需要网关进行跨网转化。而对于不同的域网之间的通信，则需要网关

2.python正则表达式

#模块 re
re.match(pattern,string,flags)
#pattern :要匹配字符串的模式
#string: 被匹配的字符串‘
#flags: 控制匹配方式
#返回：一个匹配对象 否则None
#使用.group 获得匹配对象

re.(parttern,str,flags).group()/,group(1)
line = “Cats are smarter than dogs”
matchObj = re.match( r’(.) are (.?) .*’, line, re.M|re.I)
#r:表示非转义的原始字符

#第一个.表示匹配第一组除了换行符之外的字符
#第二个.?采用贪婪模式匹配第二组除了换行符之外的字符
#第三个 .*没有括号，和第一个的作用一样但是结果不计入匹配结果中。

re.search(parttern,str,flags)
扫描整个字符串并返回第一个成功的匹配
返回：第一个成功匹配字符的位置（元组）
re.match 与re.search的区别
re.match 只匹配字符串的开始位置，开始不符合则直接返回None
而re.search则是整个字符串匹配
re.sub(pattern,repl,string,count=0,flags=0)
repel ：是用于替换的字符串，也可以是一个函数
count:模式匹配的最大次数
re.sub(r’\D’,’ ‘,string)
repel 是函数的情况：
def double(matched):
value = int(matched.group(“value”))
return str(value*2)
A = “A23G4HFD567”
print(re.sub(’(?p\d+)’,double,s)
re.compile():编译正则化表达式，生成正则对象，可被match() 和search()两个函数使用
pattern = re.compile(r’\d+’) 用于匹配至少一个数字
m = pattern.match(“23234ddnn”)[第一个字符为2匹配则返回，若不匹配则None]

3. A,B网站的访问速度

使用ping 命令：ping +URL：ping 命令检测目标网站是否联通，方法是向目标网站发送数据包，并返回数据包的平均送达时间和丢包率情况
tracert：用于追踪从本地到目标网站服务器的过程中途径的一系列网络节点，和每个节点的访问速度，支持显示30个。

4.TCP和UDP的区别

1.TCP 是面向连接的，UDP是面向无连接的
由于TCP有三次握手机制，因此也更容易产生安全问题。
比如说在完成两次握手，接受端等待发送端的第三次握手确认信息时，没有收到确认信息的服务器会一直处于等待状态。大量虚假的ip 伪造请求攻击接受端，此时接受端接受请求后向虚假ip 发送报文信息并等待确认，由于是假ip 因此无法获得确认信息，服务器资源被浪费，甚至造成系统瘫痪。这就是Distributed Denial of Service（DDOS攻击；分布式拒绝服务：让目标服务器停止服务和资源访问防御方法：过滤掉不必要的服务和端口；清洗异常流量）
2.TCP 的首部为20字节，UDP的首部8字节
3.TCP是可靠传输，数据按序到达无差错，不丢失，不重复；
UDP 是不可靠的传输，只保证尽可能交付
4.TCP是面向字节流的，将数据看为一串无结构的字节流，UDP数据以报文形式传输
5.TCP连接是点对点，UDP是一对一，一对多，多对一，多对多。
6.TCP 是全双工通信，UDP是不可信道。

————————————————
原文链接：https://blog.csdn.net/nana13628679472/article/details/108801753

正则表达式,写一个对ip地址的正则表达式

import re
ip ='192.168.1.1'
trueIp =re.search(r'(([01]{0,1}\d{0,1}\d|2[0-4]\d|25[0-5])\.){3}([01]{0,1}\d{0,1}\d|2[0-4]\d|25[0-5])',ip)
print(trueIp)

字符串操作：字符串的匹配问题正则？

有个字符串数组,匹配一个子串是否在这个字符串里面,
比如abcddacabadsa,匹配abc是否在字符串中,而且中间可以有阻隔,
比如说afdbsdc中间有fd和sd阻隔但是也是存在abc的,
然后我就用下标索引的方法匹配,只需要O(n)的时间复杂度就可以.

字符串操作：文章中统计单词的个数

def word_count():
    txt = '''To be successful in a job interview or in almost any interview situation, the applicants houlddemonstrate certain personal and professional qualities.
    　　Most likely, the first and often a lasting impression of a person is determined by the clotheshe wears. The job applicant should take care to appear well-groomed and modestly dressed, avoiding the extremes of too pompous or too casual attire .
    　　Besides care for personal appearance, he should pay close attention to his manner of speaking, which should be neither ostentatious nor familiar but rather straight forward, grammaticallyaccurate, and in a friendly way.
    　　In addition, he should be prepared to talk knowledgeably about the requirements of theposition, for which he is applying in relation to his own professional experience and interests.
    　　And finally, the really impressive applicant must convey a sense of self-confidence andenthusiasm for work, as these are factors all interviewers value highly.
    　　If the job seeker displays the above-mentioned characteristics, he, with a little luck, willcertainly succeed in the typical personnel interview.'''
    　　
    for s in ',.\n ':
        txt = txt.replace(s, ' ')

    txt = txt.lower()
    list = txt.split()
    print(list)

    count = dict()

    for word in list:
        count[word] = count.get(word, 0) + 1
    print(count)

    sort = sorted(count.items(), key=lambda item: item[1], reverse=True)
    print(sort)

PYython排序算法有哪些

如果将一个特别长的一个数字进行逆序,应该怎么做.然后就这样过了第一次面试,

写字符串匹配的问题,
大数据中排序的问题
网络中tcp和udp的区别,
如果用户使用你的网站,有时候感觉到很卡,你认为会是什么样的问题
问了我贪婪算法,
————————————————

原文链接：https://blog.csdn.net/qq_40229995/article/details/101197918

1.extern 用法；

2.虚函数与纯虚函数的区别；

3.两个浮点数如何做比较；

4.结构体能直接使用memcmp比较吗;

5.Printf如何实现可变参的；

6.如果判断单链表是否有环；如何判断两个单链表是否相交，如果找到相交节点。

7.说说单链表和双向链表；

8.如何查找字串最大公共前缀；

9.如何把二叉树变成完全二叉树；

10.进程和线程的区别；

11.进程间通信方式，大概介绍一下；

12.TCP与UDP区别，说说TCP为什么可靠；

13.僵尸进程；

14.自旋锁和互斥锁；

15.会GDB调试吗？

16.内存泄漏你是怎么查找错误的；

2.说说你做的最好的项目(被问到你不会为止)；

3.给你的项目增加了点难度(比如:你的uboot没有任何打印信息，uboot启动死掉了。串口还不让用，问你怎么解决)。

5.Malloc 如果申请了8M的内存实际只写了1字节，实际使用的内存。(当时已经懵了，但是后来知道有虚拟内存映射这回事)。

6.Open和fopen的区别，一直再问你问什么有open还需要fopen；

7.你觉得你还哪方面比较熟悉。(已经被怼到不行，但是还是硬着头皮说操作系统)把自己会的都说了然后结束。(不排除有压力面的因素)。

1.手写memcpy(内存重叠的问题)；

2.手写快速排序；

3.问了些字符串出现异常错误的问题,具体忘记了

4.哈希碰撞如何解决；

————————————————

原文链接：https://blog.csdn.net/weixin_36431535/article/details/114020901

1·生成器和迭代器说说

2·线程和协程。怎么用的，这里问的很多，包括占用资源为啥线程比协程大等

3·闭包。衍生到装饰器

4·tcp 和udp，为啥3次握手，4次挥手等

5.随机报了个http端口号问是什么情况-

6·基本排序知道哪几种，时间复杂度，快排怎么实现

7.init new方法说说

1·链表就地逆置

2·项目说明，各个模块作用，你做的主要是什么

3·redis怎么搭建的？

————————————————

原文链接：https://blog.csdn.net/weixin_40039686/article/details/114707160

redis+消息队列怎么实现的，可以说下过程吗？

队列编号是怎么定义的？
redis+消息队列实现邮件怎么做的？
除此之外，还有什么地方用到redis？
redis宕机怎么处理？redis最大并发量？
redis+事务机制+乐观锁实现订单生成过程？除了乐观锁还知道什么锁？
（答：悲观锁），乐观锁和悲观锁的区别是什么？

事务+回滚怎么实现？版本号如何控制？
在创建订单时，如果此刻redis宕机，如何采用事务+回滚？具体实现？
MySQL事务了解吗？事务是如何执行的？

redis+消息队列怎么实现？你们就拿redis做了个这！！？你还知道redis的其它用法吗？
redis能做缓存，你知道还有什么能做缓存么？
OAuth2.0实现第三方授权登录，实现流程？

道题吧，有一个ip组，分别存有很多IP段，如何将一个IP插入这个组中？如果该ip组存在和这个待插入IP一样的IP，就不在插入，如果没有，将它插在合适位置，怎么实现？（我回答的是现将这个IP组放到一个set中，然后查找set中有没有待插入IP，如果找到，就不插入，如果没找到，就插入该IP，最后做排序即可）这个回答，他好像不满意。

————————————————

原文链接：https://blog.csdn.net/dai_wen/article/details/113746058

提问：字符串拼接，说方法，以及每个方法的优缺点

1.直接通过（+）进行连接；

优缺点：
使用这种方式进行字符串连接的操作效率低下，因为python中使用 + 拼接两个字符串时会生成一个新的字符串，生成新的字符串就需要重新申请内存，当拼接字符串较多时自然会影响效率。

2.通过str.join()方法拼接

优缺点：
这种方式一般常使用在将集合转化为字符串，“join()”其中可以是空字符，也可以是任意其他的字符，当是其他字符时，集合中字符串会被该字符隔开。

3.通过str.format()方法拼接

优缺点：
通过这种方式拼接字符串需要注意的是字符串中{}的数量要和format方法参数数量一致，否则会报错。

4.通过（%）操作符拼接

优缺点：
这种方式与str.format()使用方式基本一致。

5.通过（）多行拼接

优缺点：
python中遇到未闭合的小括号，自动将多行拼接为一行。

6.通过string模块中的Template对象拼接

优缺点：
Template的实现方式是首先通过Template初始化一个字符串。这些字符串中包含了一个个key。通过调用substitute或safe_subsititute，将key值与方法中传递过来的参数对应上。从而实现在指定的位置导入字符串。这种方式的好处是不需要担心参数不一致引发异常。

7.通过F_strings拼接

优缺点：
在python3.6.2版本中，PEP 498 提出一种新型字符串格式化机制，被称为“字符串插值”或者更常见的一种称呼是F-strings,F-strings提供了一种明确且方便的方式将python表达式嵌入到字符串中来进行格式化；

s1 = 'Hello'
s2 = 'World'
print (f'{s1}{s2}!')
输出结果：Hello World！

在F-strings中，我们也可以执行函数：
def power(x):
	return x*x
x = 4
print (f'{x}*{x} = {power(x)}')
输出结果：4*4 = 16

优缺点：F-strings的运行速度很快，比%-string和str.format()这两种格式化方法都快很多。

正则表达式的反向引用

m = re.match(r'(?P<user>\w+)@(?P<website>\w+)\.(?P<extension>\w+)','myname@hackerrank.com')
m.groupdict()

#输出： {'website': 'hackerrank', 'user': 'myname', 'extension': 'com'}

写一个函数实现字符串的左移，要求不开辟额外空间

手写的继承，要求子类和父类有相同的属性，改变子类属性的同时改变父类的属性
有一个文件，这个文件只能被同时打开一个。也就是线程的单单例模式
爬虫怎么破解对方网站上的反爬虫。
比如对方网站上设有检测文件非正常读取的插件。

说说flask-sqlalchemy和pymysql的区别

python字符串常用操作

python字符串常用操作——首字母大写：capitslize()
python字符串常用操作——在一个字符串中计算特定字符的个数：count()
python字符串常用操作——让一个字符串在一行中以特定字符填充使居中：center(num,’-’)
python字符串常用操作——判断一个字符串是否以特定的字符结尾，并返回True或False：endswith()
python字符串常用操作——以列表形式寻找字符串中连续特定字符在字符串中的位置，返回所找字符串在列表的首字母的下标值：find()
python字符串常用操作——字符串格式化，为字符串中的变量赋值，填充字符串：format()
python字符串常用操作——判断一个字符串的格式，结果返回True或False：
全是阿拉伯数字 isalnum() 方法
全是英文字符 isalpha() 方法
全是十进制数 isdecimal() 方法
全是整数 isdigit() 方法
python字符串常用操作——以首字符首字母是否为大写判断字符串是否为文章标题，返回True()或False()：istitle()方法
Python字符常用操作—–获取字符串输出流并按照特定字符拼接字符串：join() 方法

name = "my name is Echo "
print(’+’.join( [‘1’,‘2’,‘3’]) )
#输出
1+2+3

10、Python字符常用操作—–按照规定长度为字符串的左或右填充特定字符：ljust() 、

rjust()
name = "my name is Echo "
print( name.ljust(50,’*’) )
print( name.rjust(50,’-’) )
#输出
my name is Echo **********************************
----------------------------------my name is Echo

11、Python字符常用操作—–将字符输出为小写———lower()方法、大写——— upper()方法

1 2	print( ‘Echo’.lower() ) print( ‘Echo’.upper() )

12、Python字符常用操作—–字符串常用操作——
去掉左边的空格和回车：lstrip()方法
去掉右边的空格和回车：rstrip()方法、
去掉两边的空格和回车：strip()方法

1
2
3

print( ‘\nEcho’.lstrip() )
print( ‘Echo\n’.rstrip() )
print(’\nEcho\n’.strip() )

#输出
Echo
Echo
Echo

13、Python字符常用操作—–替换字符串的特定字符并指定替换次数：replace() 方法

1
2
3

print(‘Echo Echo li’.replace(‘E’,‘e’,2))
#输出
echo echo li

14、Python字符常用操作—–以特定字符切割字符串，并以列表的形式返回：split() 方法

1
2
3

print(‘1+2+3+4’.split(’+’))
#输出
[‘1’, ‘2’, ‘3’, ‘4’]

15、Python字符常用操作—–以换行符切割字符串：splitlines() 方法

1
2
3

print(‘1+2\n+3+4’.splitlines())
#输出
[‘1+2’, ‘+3+4’]

16、Python字符常用操作—–指定字符填充字符串以达到指定的长度和形式：zfill() 方法

1
2
3

print(‘Echo li’.zfill(50))
#输出
0000000000000000000000000000000000000000000Echo li

————————————————

原文链接：https://blog.csdn.net/qq_41891803/article/details/82787112

1python怎么样

3算法，跳台阶，斐波那契数列和dp方式都说了。

4tcp的四次挥手中的time—wait状态何时出现，有什么意义。

5操作系统的fork进程返回什么，应该是子进程号吧。

2为什么选这个岗位

3了解hadoop的哪些组件，全部说了一遍。

4讲一下hdfs的写入过程，发请求给namenode，返回一个地址进行写入，写入完告诉namenode，namenode完成副本备份。

5讲一下项目中的难点，多线程，并发工具，并发容器。

6讲一下如何设计一个高并发的秒杀系统

7python了解么，讲一下线程和协程

协程自带上下文，切换不需要刷新cpu上下文和寄存器。更适合并发。

协程和线程适用场景的区别。
转载于:https://www.cnblogs.com/nowcoder2018/p/9315995.html

Python基础加数据结构:两个数组合并去重，数组迭代删除异常，冒泡排序… ，然后是字符串比较(暗示kmp算法，写思路和next数组)

字典和列表的实现原理(哈希表，链表和数组)

链表和数组的区别

深浅拷贝

孤儿进程僵尸进程

孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。
僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。

如何终止孤儿进程

如何终止进程(linux下kill-9 进程id) 为什么要-9

(kill pid）、（ kill -15 pid）
系统会发送一个SIGTERM的信号给对应的程序。当程序接收到该signal后，将会发生以下的事情

程序立刻停止
当程序释放相应资源后再停止
程序可能仍然继续运行
大部分程序接收到SIGTERM信号后，会先释放自己的资源，然后在停止。但是也有程序可以在接受到信号量后，做一些其他的事情，并且这些事情是可以配置的。如果程序正在等待IO，可能就不会立马做出相应。

也就是说，SIGTERM多半是会被阻塞的、忽略。

kill -9 pid

你不是可以不响应 SIGTERM吗？？那好，我给你下一道必杀令，我看你还不乖乖的。多半admin会用这个命令，用来强制尽快终止一个进程。

概率题：一分钟有车的概率为p，三分钟内有车的概率为？

B+树

B+树和平衡树的区别

平衡树的应用

OSI模型哪七层

TCP/UDP

TCP三次握手

python手写折半查找

mysql引擎
还问了mysql有什么印象深刻的吗？我回答了优化select语法树。

1.闭包

2.lambda

3.迭代器

4.修饰器

5.Python垃圾回收机制，让讲讲原理

6.udp应用场景

7.TCP关闭连接的时候，一般是4次握手，但很多情况下是三次握手，这是什么场景呢

8.算法题：两个链表，每个节点相加，相加结果如果不是一位数，就拆成多个节点

10.逻辑题：10个人分金币，每个人出一个方案，大于等于5个人赞同，则通过该方案，你是第一个人，你的方案是？

前五个人一人2个

python基础

深拷贝和浅拷贝

通常来讲不可变元素包含：
int,float,complex,long,str,unicode,tuple

is和==在操作整形数有什么区别

GIL是什么

答：在Python中GIL是Global Interpreter Lock，即全局解释锁的缩写，保证了同一时刻只有一个线程在一个CPU上执行字节码，无法将多个线程映射到多个CPU上。这是CPython解释器的缺陷，由于CPython是大部分环境下默认的Python执行环境，而很多库都是基于CPython编写的，因此很多人将GIL归结为Python的问题。

标准版本的Python并不能实现真正的多线程并发的直接原因。
简单来说就是，一个Python进程永远不能在同一时刻使用多个CPU核心。GIL被设计来保护线程安全，由于多线程共享变量，如果不能很好的进行线程同步，多线程非常容易将线程改乱。

线程与协程的区别

垃圾回收机制

list和tuple的区别

怎样修改tuple

数据结构

数组和链表的区别

说一下常见排序哪个排序比较快时间复杂度是多少

操作系统

3 进程通信

怎么使用共享内存

堆和栈的区别

怎么用堆多次free会发生什么

网络

http状态码

http在哪一层

说一下五层网络协议

网际层有什么协议

tcp和udp的区别

看我简历写了django: django怎样做用户登录

2.说一下python中的数据结构。可变不可变？

3.知道GIL吗？为什么需要GIL呢？GIL为什么一次只允许解释执行1个线程呢？

4.知道多线程，多进程吗？介绍一下怎样创建多线程，多进程？请问与java的区别是？

5.tcp3次握手？第三次握手失败后会怎样？

6.数据结构都知道哪些？说一下平衡二叉树。怎么构建平衡二叉树呢？

7.看你的简历，你还会做web前端？

8.python装饰器知道吗？装饰器的原理是什么？本质是？闭包？

9.Mysql与MongoDB的区别是？

10.python中的socket?

11.hash算法知道吗?介绍一下你知道的hash算法。hash冲突知道吗？怎么解决hash冲突呢？

12.poll,select,epoll.

13linux指令知道哪些？(这个我说我学过一些，但是背不下来，看笔记的话能够使用)

14.操作系统了解吗？(我不是科班出身，所以这些不会，但是确实有计划要学习)

15.python的内存处理机制有哪些？分别介绍一下。

遇到的重大问题，怎么解决的？

python的深浅拷贝？

往1-100里面放1个重复的数字怎么快速找出来这个重复的

编程题：报数出列，最后一个人是哪个？

linux信号

linux的进程通信(五种)

linux僵尸进程怎么解决

对分布式的理解(项目涉及)

打开浏览器输入一个网址，发生了啥子？(balabala讲一堆，到tcp三次握手的时候

二叉平衡树和数组的查询对比

数组和链表对比

野指针如何解决

c语言操作字符串的方法(回答了strcmp那些)

python的线程同步问题。(详细讲解了GIL的原理)

又问了进程在实际应用中如何通信的(由15问回答多进程替代多线程引申出来的)

问了如何测试程序运行时间(脱口而出print大法哈哈哈，还回答了用装饰器包装函数的效果比较好)

在一个很长的字符串中找出一个字符第一次出现的位置(回答了用正则表达式)

接着问正则表达式

二叉平衡树的查找时间复杂度

原文链接：https://blog.csdn.net/weixin_30925435/article/details/113519836

现在有一个日志表，表中存在n条日志，每条日志是一条字符串，该字符串仅包含小写。当字符串中顺序出现’s’、‘w’、’r’时，视为一次可能存在的攻击，请统计出总共有多少条攻击？

示例1：
输入
2
sawara
rws
输出
1
0
示例2：
输入
wsswrrw
sswwrr
输出
4
8
思路：
统计每个w之前所有的s和之后所有的r的数量。
题解：

lines = int(input())
for line in range(lines):
    log_txt = input()
    dp_s = [0] * (len(log_txt) + 1)
    dp_w = [0] * (len(log_txt) + 1)
    dp_r = [0] * (len(log_txt) + 2)
    count = 0
    #dp = [0] * (len(log_txt))
    for i in range(1, len(log_txt) + 1):
        dp_s[i] = dp_s[i - 1]
        if log_txt[i - 1] == 's':
            dp_s[i] += 1
        if log_txt[i - 1] == 'w':
            dp_w[i] = 1
        dp_r[len(log_txt) - i + 1] = dp_r[len(log_txt) - i + 2]
        if log_txt[len(log_txt) - i] == 'r':
            dp_r[len(log_txt) - i + 1] += 1
    for i in range(1,len(log_txt) + 1):
        if dp_w[i] == 1:
            count += dp_r[i] * dp_s[i]
    count = count % 1000000007
    #print(count, dp_s, dp_w, dp_r)
    print(count)

问题二：小强一次可以跳1级、2级、3级，但如果一次跳3级，那么往后k次都不能再跳3级，比如k = 10 ，那么一次跳3级台阶后，接下来的10次都不能再跳3级。

输入描述：
第一行一个正整数T（T <= 10），表示T个测试样例；对于每个测试样例，输入两个整数N(1 < N < 10000)、K（0 <= K <= 100）。
输出描述：
输出T行，每行一个总数，表示跳法的总数。
结果请对100007取值。
示例1
输入
2
3 0
6 1
输出
4
23

思路：去掉k次限制，就是很简单的爬楼梯问题，但这个k次限制，没有思路。大佬们有想法的话欢迎交流。
————————————————

原文链接：https://blog.csdn.net/AI414010/article/details/109149717

数据库CRUD操作/查询优化以及数据库知识量
框架的对比和了解/项目具体模块的业务逻辑描述
常见排序算法
Linux系统的常用命令和Linux系统了解程度考核
项目部署用到的服务器的配置和了解程度
数据库基本功必须掌握但同时更重要的是理解为什么和是如何实现的，拓展自己知识面
Linux系统的底层原理和了解程度
目前Golang在后端中也逐渐流行，有时间还是需要去掌握
技术没有终点，保持乐于学习和接受新技术的心态，面试官看重技术能力同时也更看重你的心态

Python相关

实现一个单例模式

class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
        pass

    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):

            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = object.__new__(cls)

        return Singleton._instance

实现一个装饰器

# 使用装饰器
def Singleton(cls):
    _instance = {}

    def _singleton(*args, **kwargs):
        _instance[cls] = cls(*args, **kwargs)
        return _instance[cls]

    return _singleton

@Singleton
class A(object):
    a = 1
    def __init__(self):
        pass

用Python实现快排
如果系统中需要很多个Python版本，如何进行Python版本的管理
如何实现一个全局变量?(除了global,还可以通过单例模式)

数据库相关

数据库的数据是实时更新的吗?每点击一次，数据库数据修改一次?
Redis hash的个数
如何修改Redis数据库的库的个数?
Redis数据库如何实现持久化
Redis数据库支持的数据类型
Redis使用AOF方式持久化，aof文件不断增大，如何处理?
Redis数据库如何设置密码
hash表是如何生成的
MySQL数据库如何使用sql语句插入一条数据
MySQL数据库的慢查询有了解过吗
MySQL数据库如何进行查询优化
如何很多请求同时对Redis的同一个键进行访问，如何保证数据安全
说说Redis的淘汰机制
我的MySQL数据库每天晚上12点进行全备份。第二天有员工在9点钟误删除了一个数据库，但在10点钟才被发现。问如何进行恢复被误删除的数据库并同时保留9点到10点钟新增的数据同时不影响业务的正常运行?
当数据越来越多，如何避免hash槽中key出现相同的情况?
MongoDB在哪些场合使用过?
项目部署相关
大家都说Nginx快?快的原因是什么?
对RPC了解吗?
如何在服务器上设置业务进程数?
说说正向代理和反向代理
Linux相关
如何查看剩余内存
如何查看端口是否被占用
如何查看一个程序的PID以及它的所有子进程
如何为一个目录下的所有文件添加权限
如果你对一个目录具有写权限，那么你是否具有对这个目录下的所有文件具有删除权限?
对Linux多路复用的理解
修改IP地址的方法

前端相关

对前端HTML CSS 和 JS了解多少?熟悉吗?
对React和bootstrap了解吗?
如何进行http优化?(响应头设置Content-Encoding: gzip)

网络编程相关

1.说一下实现TCP建立连接的过程以及当时进入了什么状态?为什么建立连接只需要3次，断开连接需要4次?为什么断开连接时第二次和第三次要分开，不能合在一起吗?

项目相关

说一下一个请求过来到返回response的过程
如何实现单点登录
JWT token是如何进行生成和校验的
了解过哪些后端框架?Tornado了解吗?
了解过webapp2吗
Django如何实现csrf攻击保护
说说你项目中遇到的困难以及如何解决
说说你认为自己最有成就感或最深刻的项目
对KAFKA了解吗?用过哪些消息队列?使用过RabbitMQ吗?
项目团队几个人?开发多长时间?
版本控制相关
如何从远程仓库拉取分支到本地
如何进行版本回退

1. Celery的原理和应用场景

2. Elasticsearch 的原理

3. 平时是如何学习的?有关注哪些技术?

4. Docker的了解，常用命令，如何暴露端口

5. 对ERP了解吗?Odoo了解吗?

问的包括计算机网络、数据结构、python魔法方法tcp/ip、python装饰器等，填空题涉及操作系统（线程进程）

编程题第一个签到题：判断一个数是否能被2，5，7整除，三个while搞定（100%）

第二个消消乐，给定字符串context和爆炸数bolm，两个连续相同字符的可以消除，如果消除的文字是爆炸数，可以额外消掉左边右边各一个字符，返回最后剩余字符。（这个一开始看错题了，最后只通过了80%）

谈谈对python中包的了解，用过哪些包（把常用的time、datetime、json、request、os、re…都说了）

谈谈python的import，pyc是什么，具体怎么实现的

哈希表，哈希冲突如何处理

GIL锁，Cpython

谈谈对进程、线程、协程的了解，（信号量，进程池、线程池，最后谈到了aiohttp与asyncio)

算法题：求一篇论文中最频繁出现的10个单词（我答的是用字典存储，再用通过sorted以dict.values排序，面试官不是很满意，正确答案是小顶堆）

插排、快排、选排、冒泡的时间复杂度与优缺点

智力题：烧绳子。N多跟绳子,每一根燃烧的时间都是1小时,如何计算1小时15分钟（面试官点了一下，然后飞快写出来了，感觉挺满意的）

一上来先给了个编程题，求字符串最大回文，然后就关视频去忙去了

GIL锁，
什么时候用多线程、什么时候用多进程、协程是干嘛的
多线程适合io操作密集型的任务（如socket server ，网络并发请求）；
多进程适合cpu密集操作型的任务，主要使用cpu来计算，如大量的数学计算。

I/O多路复用，select epoll,poll的区别
python内存管理，
python内存泄露如何处理

网站测试数据的来源，追问：能否获取一些加密数据
答：会简单的逆向分析，
继续追问：为啥不能获取付费的XX
答：没有什么参考案例，技术也不太行（感觉再说下去我要直接变网安工程师了）
————————————————

原文链接：https://blog.csdn.net/Swing0_0/article/details/109231696

2.数据结构基础

（1）请简述数组与链表的区别链表是一种上一个元素的引用指向下一个元素的存储结构，链表通过指针来连接元素与元素；

链表是线性表的一种，所谓的线性表包含顺序线性表和链表，顺序线性表是用数组实现的，在内存中有顺序排列，通过改变数组大小实现。而链表不是用顺序实现的，用指针实现，在内存中不连续。意思就是说，链表就是将一系列不连续的内存联系起来，将那种碎片内存进行合理的利用，解决空间的问题。
所以，链表允许插入和删除表上任意位置上的节点，但是不允许随即存取。链表有很多种不同的类型：单向链表、双向链表及循环链表。
单向链表包含两个域，一个信息域，一个指针域。单向链表的节点有两部分组成，一部分保存节点本身的信息（信息域），另一部分保存下一个节点的地址（指针域），最后一个节点的指针域为空。
双向链表，每个节点的指针域包含两个指针，分别保存当前指针的前一个节点地址和后一个节点地址。
循环链表，末尾节点的指针域的指针指向首节点。

数组与链表的区别：

链表是链式存储结构，数组是顺序存储结构。
链表通过指针来连接元素与元素，数组则是把所有元素按次序依次存储。
链表的插入删除元素相对数组较为简单，不需要移动元素，且较为容易实现长度扩充，但是寻找某个元素较为困难；
数组寻找某个元素较为简单，但插入与删除比较复杂，由于最大长度需要在编程一开始时指定，故当达到最大长度时，扩充长度不如链表方便。
相同：两种结构均可实现数据的顺序存储，构造出来的模型呈线性结构。

（2）将两个有序链表合并为一个新的有序链表

解答：设两个有序链表为A和B，若A为空链表则返回B，若B为空链表，则返回A。
新链表头节点为headC,初始为空，给定指针变量r始终指向新链表的末尾节点。
第一步，找到A和B中较小的节点，将其值给headC，将已被取出的列表的指针下移到指向下一个节点，如此遍历完两个链表。
实际算法题：
给定长度为n的数组，找出其中出现次数大于等于n/2的元素，并分析所用方法的时间复杂度。（假设改元素一定存在）leetcode原题
如不考虑任何因素，单纯通过python实现，你会如何实现？（面试官解释通过列表的count方法）

给定一个列表，列表中的元素是二元组，该二元组的含义是ip段，形如（“223.98.208.0”, “223.98.223.255”）,ip段之间不相交。

问：给定ip，如何快速定位所属ip段？
答：将ip转换为数字，对列表按左端点排序之后，使用二分查找进行定位。
既然了解将ip转换为数字，是否了解网络字节序与主机字节序的区别。

网络知识：

描述tcp三次握手的过程。

是否了解io多路复用？select与epoll()区别？

python语言考察

如何定义一个类，使得该类支持with语法？

如何在python类中定义私有变量？

python是不含有private关键字的，因此在定义私有变量时，只需要在变量的前面加上双横杠。
虽然加上get，set函数后，可以设置和访问私有属性，但使用起来不是很方便，能否像c#里的语法糖那样方便的对私有属性进行访问呢？当然可以，借助property即可。

python中单下划线与双下划线的区别？

python中线程的缺陷是什么？

python支持协程，请简要描述协程以及应用。

是否了解pep8，请描述一下。

————————————————

原文链接：https://blog.csdn.net/qq_36562999/article/details/106044515

题目大意为给定一个字符串列表，请输出其字符串元素中第n长字符串的长度，若没有第n长，则返回最长字符串元素的长度。

def num_of_car(lyst, n):
    dic = {}
    for i in lyst:
        dic[len(i)] = i
    new_dic = dict(sorted(dic.items(),key=lambda dic:dic[0],reverse=False))  # 字典按键值从小到大排序
    # print(new_dic)
    if n > len(dic):
        return len(dic[max(dic)])
    else:
        return len(new_dic[list(new_dic.keys())[::-1][n - 1]])
def main():
    lyst = ['abcd', 'ab', 'ab']
    n = 2
    length = num_of_car(lyst, n)
    print(length)
if __name__ == '__main__':
    main()

————————————————

原文链接：https://blog.csdn.net/jerryz2017/article/details/101000968

2 sizeof(类) 大小包含虚函数时呢？两个虚函数时呢？每个对象都有一个虚函数指针吗？每个对象都有一个虚函数吗？

3 多态：面试官描述，让你判断会不会形成多态

4 问我什么是纯虚函数？纯虚函数的作用，具有纯虚函数的类能实例化出对象吗？为什么？

5问我什么是接口？我扯的多了，扯到接口继承，和实现继承了。

6 容器？都知道哪些容器？平时都用哪些容器？怎么用？（序列式+ 关联式bulabula）

7 模拟实现STL reverse算法（简单哦）

8 问我 map，怎么遍历map？

我说：借助迭代器，问我怎么定义迭代器？
我说：可以借助C++11提供的auto 关键字来接收，auto 关键字会让编译器自己推导迭代器类型，代替了我们一长串类型的定义
9 情景模拟：一篇英文文章（文件）：问我将来想知道文章中所有单词出现的频率，问我怎么做？
答：选用数据结构 unordered_map<string, int> + 文件指针 +boost库中 boost::splite()函数进行使用，
问我：选哪个文件流？ open ? fopen? sstrean?
我选的fopen()
问我 fopen()的参数是什么？我说文件的path 和打开的方式。因为只读，所以选取 ‘r’ 的方式又问我为什么选 r ？
我说因为已知是英语文章，所以字符将来都是ASIIC表中的，所以不会出现 unicode/UTF-8 所以不必用 rb方式当然用rb方式也没错
问我 r 跟 rb方式的底层实现有什么区别？
我说具体不清楚，但我觉得应该是分两方面：
一：ASIIC部分不做处理
二：非ASICC的unicode 编码应该是安源码情况进行编译。
问我：假如不选取rb方式：会不会出什么错？
我说：如果出现了非ASIIC字符，那么到时候可能会出错的。
问我怎么读取文件？读多长？怎么处理？
fgets() 读一行，先进行处理处理采用splite 函数进行切割，将切割的结果保存在一个容器里，一般情况下，单词之间应该是以空格进行分割的
他又说：一篇文章肯定不会只有一个空格切分啊，我一个空格的话就模糊了吧。
（汗，其实我忘了splite是不是可以定义一组字符方式，我记得好像可以），我就直说说，我记得splite函数好像是可以定义一组划分方式的，用的时候我可以直接man一下确定下。

10 为什么选用 unordered_map(他一直说ordered_map 我纠正了两次unordered_map ,他还是ordered 汗,懒得纠正 )

我就说因为是一篇文件，所以说数据量可能很大，选用 unordered_map可以快速查询到相应单词是否出现，时间复杂度为O(1), 代价是底层维护一段比较大的内存空间. （string作为key其实底层通过哈希函数进行处理过后才存储的）

————————————————

原文链接：https://blog.csdn.net/weixin_44030580/article/details/106590990

shell编程，数据库三范式

b 设计模式，工厂，单例
c 数据库事务的四个特性
d 数据库事务的一致性怎么实现，乐观锁，悲观锁
f 乐观锁的具体实现
g mysql数据表特别大的时候，怎么优化
h mysql数据库使用的引擎

一般会面式2个项目
面试：python自动化运维，

问细节
a python连mysql用的是什么模块
b redis 怎么连接的
c mysql用的什么版本
d linux常用的指令查内存指令，指定端口的命令
f git指令
g githup印象最深的项目

直接面试：
a 介绍项目
b 多线程，多进程区别
c 项目中用到的异步，我答的是celery
d celery 的工作机制
f 异步中的互斥锁
g 解释互斥锁的死锁

最后直接给了一道题，当面做
需求：提供两个列表，一个是ip，一个是对应的权重值
要求随机返回一个ip，返回的ip机率要根据权重值
做完之后直接喊hr过来谈，要的13k，hr砍到11k，第二天就
发offer，效率很高，但是是驻外地，所以放弃

面试：
b python相对于其他语言得优势
c 变量的生命周期
d 线程得生命周期
f 变量作用域及调用优先级
g 引入得模块和内置模块及自己写得模块，调用的优先级
h 匿名函数，优点，平时怎么用的我答的是map函数中用到
i map函数第一个参数有什么限制给自己挖坑了。。
j with 上下文管理为什么不用关，内部怎么实现，优势是什么
k redis 内部运行机制用redis实现异步队列
l 单例不用new方法怎么实现，说出四种。。。
n 数据库的锁

————————————————

原文链接：https://blog.csdn.net/weixin_43094478/article/details/82289499

深拷贝与浅拷贝

浅拷贝：只是对另外一个变量的内存地址的拷贝，这两个变量指向同一个内存地址的变量值。
深拷贝：一个变量对另外一个变量的值拷贝。所以当一个变量改变时候，另一个对象也会改变。

Python中的数据结构

列表list
列表中的每个元素都可变的，意味着可以对每个元素进行修改和删除；
列表是有序的，每个元素的位置是确定的，可以用索引去访问每个元素
元组tuple
Tuple一经初始化，就不能修改，没有List中的append(), insert(), pop()等修改的方法，只能对元素进行查询
字典dict
字典中的数据必须以键值对的形式出现。 key 必须是可哈希的值。其插入和删除的时间复杂度为O(1)。
集合set
集合中每个元素都是无序的、不重复的任意对象。

Python中线程与协程

进程是OS进行资源分配和调度的独立单位；
线程是进程的实体，是CPU调度和分派的基本单位；
协程也是线程，称微线程，自带CPU上下文，是比线程更小的执行单元；
线程执行开销小，但不利于资源的管理和保护；而进程正相反
get和post的区别
GET参数通过URL传递，POST放在Request body中。
Python垃圾回收
Python垃圾回收主要以引用计数为主，分代回收为辅

当你在浏览器地址栏输入一个URL后回车，将会发生的事情？

浏览器向DNS服务器查找输入URL对应的IP地址。
DNS服务器返回网站的IP地址。
浏览器根据IP地址与目标web服务器在80端口上建立TCP连接
浏览器获取请求页面的html代码。
浏览器在显示窗口内渲染HTML。
窗口关闭时，浏览器终止与服务器的连接。

is和==的区别

1 2	is和==都是对对象进行比较判断作用的 is 判断id是否相同，==是判断值

————————————————
版权声明：本文为CSDN博主「wfanyue」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/wfy_1999/article/details/106865722

1、Linux的进程通信方式

管道、信号量、消息队列、信号、共享内存、套接字
参考：https://www.cnblogs.com/liugh-wait/p/8533003.html

2、红黑树

R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。
每个节点或者是黑色，或者是红色。
根节点是黑色。
每个叶子节点（NIL）是黑色。
如果一个节点是红色的，则它的子节点必须是黑色的。
从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。
红黑树的时间复杂度为: O(lgn)。
红黑树一种特殊的二叉查找树。
红黑树是相对是接近平衡的二叉树。
完全二叉树、满二叉树。
参考：https://www.cnblogs.com/xuxinstyle/p/9556998.html

3、HTTP状态码（403）

403 Forbidden是HTTP协议中的一个状态码(Status Code)。可以简单的理解为没有权限访问此站。
参考：https://www.sohu.com/a/162171065_763273

4、压栈

先进后出。

5、给出先序和中序，写出后续

先序确定根中序分左右。

6、阻塞、就绪、异常、运行、退出、僵尸、不可中断、孤儿、死亡进程。

孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。
僵尸进程：一个子进程在其父进程还没有调用wait()或waitpid()的情况下退出。这个子进程就是僵尸进程。
不可中断状态：为了保证进程数据与硬件状态一致，并且正常情况下，不可中断状态在很短时间内就会结束。
阻塞状态：正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)等。
就绪状态：当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。
执行状态：当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。

7、列表推导式、filter() 、zip()。

#列表推导式
array1 = [x for x in range(6) if x % 2 == 0]
print(array1)

[0, 2, 4]

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

1
2
3

# filter(function, iterable)
# function -- 判断函数。
# iterable -- 可迭代对象。

def is_odd(n):
    return n % 2 == 1
array3 = list(filter(is_odd, array2))
print(array3)

[1, 3, 5]

参考：https://www.runoob.com/python/python-func-filter.html

#zip()函数
#函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
#如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a = [1, 2, 3]
b = {4, 5, 6}
zipped = list(zip(a, b))
print(zipped)
up_zip = list(zip(*zipped))
print(up_zip)

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

参考：https://www.runoob.com/python/python-func-zip.html

8、init和new的区别？

用法不同：new()在__init__()在之前被调用，用于创建实例，是类级别的方法，是静态方法。init()在创建实例后调用，用于初始化实例，是实例级别的方法，用于设置对象属性的一些初始值。
传入参数不同：new()至少有一个参数cls，init()至少有一个参数self。
返回值不同：new()必须有返回值，返回实例对象。init()不需要返回值。
作用不同：__new__是用来创造一个类的实例，__init__是用来初始化实例的。

编程题1：有随机数m，一桌有n个程序员，从0号程序员开始报数，到第m-1个程序员唱歌。然后从第m个程序员继续报数，直到只剩一个程序员时，输出程序员的编号。

解题思路：循环队列

编程题2：给定字符串context和爆炸数bolm，两个连续相同字符的可以消除，如果消除的文字是爆炸数，可以额外消掉左边右边各一个字符，返回最后剩余字符。

解题思路：字符串对比及切片拼接。
技术一面
正则表达式（纯汉字）

 #用 '[\u4e00-\u9fa5]‘ 匹配中文
import re
s = input()
answer = re.findall(r'[\u4e00-\u9fa5]', s)
print(answer)

参考：https://www.jb51.net/article/187420.htm

Python的垃圾回收机制

Python垃圾回收主要以引用计数为主，分代回收为辅。
引用计数器**+1**
对象被创建 a=14
对象被引用 b=a
对象被作为参数,传到函数中 func(a)
对象作为一个元素，存储在容器中 List={a,”a”,”b”,2}
引用计数器**-1**
当该对象的别名被显式销毁时 del a
当该对象的引别名被赋予新的对象 a=26
一个对象离开它的作用域，例如 func函数执行完毕时，函数里面的局部变量的引用计数器就会减一（但是全局变量不会）
将该元素从容器中删除时，或者容器被销毁时。
当指向该对象的内存的引用计数器为0的时候，该内存将会被Python虚拟机销毁

参考：https://blog.csdn.net/xiongchengluo1129/article/details/80462651

Python装饰器

# 装饰器
def fun(func):
    def wrapper():
        print("Hello", end=" ")
        func()
        return func
    return wrapper
    
@fun
def hello_world():
    print("World")
hello_world()

参考：https://www.cnblogs.com/lianyingteng/p/7743876.html

# 带参数的装饰器
def outer(out_args):
    def middle(func):
        def wrapper(*args, **kwargs):
            print(out_args)
            wrapper_result = func(*args, **kwargs)
            print(wrapper_result)
            return wrapper_result
        return wrapper
    return middle
@outer("hello")
def foo(a, b):
    return a + b
foo(2, 3)

参考：https://blog.csdn.net/e15273/article/details/78617498

python内置的数据结构

列表、元组、字符串、集合、字典、数字

字符串间隔逆序输出z

1 2	a = "123456789" print(a[::-2])

# 字典输出所有的值
dict1 = {"Beijing": 1, "Nanjing": 2, "Dongjing": 3}
# 打印所有的键
print(dict1.keys())
# 打印所有的值
print(dict1.values())

str(a)和print(a)的区别
str()：用于将对象转化为适于人阅读的字符串的形式；
repr()：用于将对象转化为可供解释器读取的字符串形式；
print()：将对象打印并输出，省去引号；

python最吸引你的地方

语法优美
丰富强大的库
开发效率高

wsgi，写一个符合wsgi的接口

1
2
3

def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return '<h1>Hello, web!</h1>'

上面的application()函数就是符合WSGI标准的一个HTTP处理函数，它接收两个参数：
environ：一个包含所有HTTP请求信息的dict对象；
start_response：一个发送HTTP响应的函数。
参考：https://www.liaoxuefeng.com/wiki/897692888725344/923057027806560

python容器有哪些

字符串容器
列表容器
元组容器
字典容器

http状态码
类别原因
1XX Informational（信息性状态码）接收的请求正在处理
2XX Success（成功状态码）请求正常处理完毕
3XX Redirection（重定向状态码）需要进行附加操作以完成请求
4XX Client Error（客户端错误）服务器无法处理请求
5XX Server Error（服务端错误）服务器处理请求出错
2XX成功

参考：https://blog.csdn.net/hualf/article/details/78989618

原文链接：https://blog.csdn.net/qq_29537269/article/details/108801488

原文链接：https://blog.csdn.net/weixin_39829166/article/details/111425372

Python工程师推荐的书籍和资料：

Python核心编程（第2版）
Python源代码

python入门：网易云课堂、python高效开发实战（还有一些杂牌书）
python进阶：流畅的python、python网络编程、python核心编程
框架：官网 Django 1.8手册、B站黑马程序员、git上各路神仙的源码
网络：图解HTTP、计算机网络、网络协议分析
操作系统：操作系统原理
mysql：mysql深入浅出、mysql必知必会
Redis: Redis设计与实现
前端：锋利的Jquery 、 JavaScript DOM编程艺术、Head First HTML与CSS

文章作者: WinkyQin

文章链接: http://winkyqin.com/2020/02/27/00-Python/python%E9%9D%A2%E8%AF%95%E9%A2%98/

python

python面试整理

常见面试题

1.Python中 *args和**kwargs的区别

2. Python中单例模式的几种实现和优化

3. python中 @classmethod , @staticmethod区别

1. 定义方式

2. 绑定对象

3. 调用方式

4. 继承与覆盖普通类函数是一样的

富途python面试

北京途游游戏后端开发

实时对战游戏的难点

三种不同方向的技术实现介绍

深信服Python面试题整理

1.网关的作用

2.python正则表达式

3. A,B网站的访问速度

4.TCP和UDP的区别

正则表达式,写一个对ip地址的正则表达式

字符串操作：字符串的匹配问题 正则 ？

字符串操作：文章中统计单词的个数

PYython排序算法有哪些

如果将一个特别长的一个数字进行逆序,应该怎么做.然后就这样过了第一次面试,

原文链接：https://blog.csdn.net/qq_40229995/article/details/101197918

1.extern 用法；

2.虚函数与纯虚函数的区别；

3.两个浮点数如何做比较；

4.结构体能直接使用memcmp比较吗;

5.Printf如何实现可变参的；

6.如果判断单链表是否有环；如何判断两个单链表是否相交，如果找到相交节点。

7.说说单链表和双向链表；

8.如何查找字串最大公共前缀；

9.如何把二叉树变成完全二叉树；

10.进程和线程的区别；

11.进程间通信方式，大概介绍一下；

12.TCP与UDP区别，说说TCP为什么可靠；

13.僵尸进程；

14.自旋锁和互斥锁；

15.会GDB调试吗？

16.内存泄漏你是怎么查找错误的；

2.说说你做的最好的项目(被问到你不会为止)；

3.给你的项目增加了点难度(比如:你的uboot没有任何打印信息，uboot启动死掉了。串口还不让用，问你怎么解决)。

5.Malloc 如果申请了8M的内存实际只写了1字节，实际使用的内存。(当时已经懵了，但是后来知道有虚拟内存映射这回事)。

6.Open和fopen的区别，一直再问你问什么有open还需要fopen；

7.你觉得你还哪方面比较熟悉。(已经被怼到不行，但是还是硬着头皮说操作系统)把自己会的都说了然后结束。(不排除有压力面的因素)。

1.手写memcpy(内存重叠的问题)；

2.手写快速排序；

3.问了些字符串出现异常错误的问题,具体忘记了

4.哈希碰撞如何解决；

原文链接：https://blog.csdn.net/weixin_36431535/article/details/114020901

1·生成器和迭代器说说

2·线程和协程。怎么用的，这里问的很多，包括占用资源为啥线程比协程大等

3·闭包。衍生到装饰器

4·tcp 和udp，为啥3次握手，4次挥手等

5.随机报了个http端口号问是什么情况-

6·基本排序知道哪几种，时间复杂度，快排怎么实现

7.init __new__方法说说

1·链表就地逆置

2·项目说明，各个模块作用，你做的主要是什么

3·redis怎么搭建的？

原文链接：https://blog.csdn.net/weixin_40039686/article/details/114707160

redis+消息队列怎么实现的，可以说下过程吗？

原文链接：https://blog.csdn.net/dai_wen/article/details/113746058

提问： 字符串拼接，说方法，以及每个方法的优缺点

1.直接通过（+）进行连接；

2.通过str.join()方法拼接

3.通过str.format()方法拼接

4.通过（%）操作符拼接

5.通过（）多行拼接

6.通过string模块中的Template对象拼接

7.通过F_strings拼接

正则表达式的反向引用

写一个函数实现字符串的左移，要求不开辟额外空间

说说flask-sqlalchemy和pymysql的区别

python字符串常用操作

原文链接：https://blog.csdn.net/qq_41891803/article/details/82787112

1python怎么样

3算法，跳台阶，斐波那契数列和dp方式都说了。

4tcp的四次挥手中的time—wait状态何时出现，有什么意义。

5操作系统的fork进程返回什么，应该是子进程号吧。

1.Python中 `*args`和`**kwargs`的区别

3. python中 `@classmethod` , `@staticmethod`区别

字符串操作：字符串的匹配问题正则？

7.init new方法说说

提问：字符串拼接，说方法，以及每个方法的优缺点

孤儿进程僵尸进程

说一下常见排序哪个排序比较快时间复杂度是多少

怎么用堆多次free会发生什么