python 面试题汇总
2024-10-19 22:22:20
1丶元组(list)和列表(tuple)的区别:
一：共同点：
①： 可以放置任意数据类型的有序集合，都是可以存放数字，字符串，对象等。
②：都支持 负索引，切片，随意嵌套等操作
二：不同点：
①：
列表是动态的，长度大小不固定，可以对元素随意的继续增加，删除，修改等操作
元组是静态的，长度在初始化的时候都已经确定了不能更改，更家无法修改，增加，删除元素
②：
列表和元组的存储方式有差异：
列表：为了能够实时追踪内存的使用情况，当空间不足时以及分配额外空间，额外的多分配了内存，而且还需要存储指针，指向对应的元素
注：如果数据发生变更的可能性不大，就用元组存储，如果数据是需要频繁的进行数据的修改增加，就使用列表
2丶Python的主要功能是什么？
a. python是一种解释型语言，与C语言等语言不同，python不需要在运行之前进行编译 。
b. python是动态语言，当你声明变量或类似变量时，你不需要声明变量的类型
c. python适合面向对象编程，因为他允许类的定义以及组合和继承。python没有访问说明（入C++的public,private）.
d. 在python中，函数是第一类对象，他们可以分配给变量，类也是第一类对象
e. 编写python代码很快，但运行比较慢。python允许基于C的扩展，列入numpy函数库
f. python可用于很多领域：We应用程序开发，自动化，数学建模，大数据的挖掘和处理 等等。它也经常被用作"胶水"语言。
3丶什么是PEP?
PEP全称(Python Enhancement Proposal),它是一组规则，指定如何格式化python代码以获取最大的可读性
4丶python 垃圾回收机制原理
python采用的是引用计数机制为主，标记-清除和分代收集两种机制为辅的策略
4.1 refchain(环状双向链表)
python程序中一旦创建对象都会把该对象添加到refchain链表中，它是保存这所有对象的对象
4.2 引用计数器
在refchain中所有对象内部都有一个ob_refcnt用来保存当前对象的引用计数器，也就是自己被引用的次数
注： 当一个值被多次引用的时候，不会再内存中重复的创建数据，而是 引用计数器 +1 。
当对象被销毁的同时 引用计数器 -1 ，如果引用计数器为 0 ， 则将对象冲refchain的链表中摘除，
同时在内存中进行销毁(特殊情况暂不考虑)
4.3 标记清除&分代收集
引进标记清除的原由：
因为垃圾回收非常的方便和简单，但是存在循环引用的问题，导致无法正常的回收一些数据，
如果这类的代码太多，会导致内存一直会被消耗，知道内存耗尽，程序崩溃
标记清除：
创建特殊链表专门用于保存 列表，元组，字典，集合，自定义类等对象，之后再去检测这个链表中对象是否存在循环引用，如果存在则让双方的引用计数均 -1
分代回收：
对标记清除中的链表进行优化，将那些可能存在循环引用的对象拆分到三个链表，链表称为：0/1/2三代，每代都可以存储对象和阈值
当达到阈值是就会对响应的链表中的每一个对象做一次扫描，除循环引用各自减一并且销毁引用计数为0的对象
5丶http 和 https 的区别?
1. http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议
2. http适合于对传输速度、安全性要求不是很高，且需要快速开发的应用。如web应用，小的手机游戏等等。而https适用于任何场景。
6丶数据结构之堆，栈和队列的理解和实现
栈（stacks）：栈的特点是后进先出。只能通过访问一端来实现数据的储存和检索的线性数据结构。
队列（queue）：队列的特点是先进先出。元素的增加只能在一端，元素的删除只能在另一端。增加的一端称为队尾，删除的一端称为队首。
注意：其实堆栈本身就是栈，只是换了个抽象的名字。
什么是栈溢出？
因为栈一般默认为1-2m，一旦出现死循环或者是大量的递归调用，在不断的压栈过程中，造成栈容量超过1m而导致溢出。
栈溢出的几种情况？
1、局部数组过大。当函数内部数组过大时，有可能导致堆栈溢出。
2、递归调用层次太多。递归函数在运行时会执行压栈操作，当压栈次数太多时，也会导致堆栈溢出。
解决方法：
1、用栈把递归转换成非递归。
2、增大栈空间
7丶爬虫使用多线程好？还是多进程好？为什么？
对于IO密集型代码(文件处理，网络爬虫)，多线程能够有效的提升效率
(单线程下有IO操作会进行IO等待，会造成不必要的时间等待，而开启多线程后，
A线程等待时，会自动切换到线路B,可以不会浪费CPU的资源，从而提升程序的执行和效率)。
在实际的采集过程中，既考虑网速和相应的问题，也需要考虑自身的机器硬件的情况，来设置多进程或者多线程
8丶简述 with 方法打开处理文件帮我们做了什么？
whit 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都睡执行必要的"清理"操作，释放资源，
比如：文件使用后自动关闭线程中 锁的自动获取和释放等
with 语句即："上下文管理器"：在程序中用来表示代码执行过程中所处的前后环境
上下文管理器：含有 enter 和 exit 方法的对象
enter()：语句执行之前执行该方法，通常返回一个实例对象，如果with语句有as目标，则把对象赋值给as目标
exit()：执行语句结束后，自动调用exit()方法，用户释放资源，若此方法返回True,程序会忽略异常
使用环境：文件读写，线程锁的自动释放等
9丶Python获取当前日期
import datetime
now_date = datetime.datetime.now().strftime("%F %T")
print(now_date)
10丶Python之禅
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
=======================================================================
Python 之禅，作者 Tim Peters
优美胜于丑陋（Python 以编写优美的代码为目标）
明了胜于晦涩（优美的代码应当是明了的，命名规范，风格相似）
简洁胜于复杂（优美的代码应当是简洁的，不要有复杂的内部实现）
复杂胜于凌乱（如果复杂不可避免，那代码间也不能有难懂的关系，要保持接口简洁）
扁平胜于嵌套（优美的代码应当是扁平的，不能有太多的嵌套）
间隔胜于紧凑（优美的代码有适当的间隔，不要奢望一行代码解决问题）
可读性很重要（优美的代码是可读的）
即便假借特例的实用性之名，也不可违背这些规则（这些规则至高无上）
不要包容所有错误，除非你确定需要这样做（精准地捕获异常，不写 except:pass 风格的代码）
当存在多种可能，不要尝试去猜测
而是尽量找一种，最好是唯一一种明显的解决方案（如果不确定，就用穷举法）
虽然这并不容易，因为你不是 Python 之父（这里的 Dutch 是指 Guido ）
做也许好过不做，但不假思索就动手还不如不做（动手之前要细思量）
如果你无法向人描述你的方案，那肯定不是一个好方案；反之亦然（方案测评标准）
命名空间是一种绝妙的理念，我们应当多加利用（倡导与号召）
11丶了解 docstring 么？
文档字符串：是一个重要的工具，用于解释文档程序，帮助你的程序国家简单易懂，我们可以在函数体的第一行使用一对
三个单引号或者一对三个双引号 来自定义文档字符串，你可以使用doc调用函数中的文档字符串属性
12丶了解类型注解么？
def list_to_str (param_list:list,connect_str: str = " ") - > str:
paas
python3中注解用来给参数，返回值，变量的类型加上注解，对代码没有影响 Python提供了一个工具方便我们
测试类型注解的正确性：
pip install mypy
mypy mode.py
若无错误则无输出
14丶举例几个规范Python代码风格的工具
pylint, yapf, autopep8, flake8
15丶一个编码为 GBK 的字符串 S，要将其转成 UTF-8 编码的字符串，应如何操作？
demo_str = "demo".encode("gbk")
demo=demo_str.decode('gbk').encode('utf-8'）
16丶用正则切分字符串去除非符号
import re
s="info：xiaoZhang 33 shandong"
re.compile(r'\W').split(s)
output:
['info', 'xiaoZhang', '33', 'shandong']
17丶[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]
question_list = [[1,2],[3,4],[5,6]]
[a for inside in question_list for a in inside]
18丶如何交换字典 {"A"：1,"B"：2}的键和值？
demo_dic = {"A":1,"B":2}
result_dic = {v: k for k, v in demo_dic.items()}
print(result_dic)
output:
{1: 'A', 2: 'B'}
19丶对生成器类型的对象实现切片功能
import itertools
itertools.islice(gener, 10, 20)
20丶关于list tuple copy 和 deepcopy 的区别是什么？
tuple：
a = (1, 2, 3, [4, 5, 6, 7], 8)
a[3] = 3 //typeerror
a[3][3] = 9 // a (1, 2, 3, [4, 5, 6, 9], 8)
列表是可变数据类型，数据的值可以修改的
这里只是修改了元祖子对象的值，而不是修改了元祖的值
修改可变类型的值不会改变内存id，因此元祖的引用还是没有发生变化
可以这么理解，只要不修改元祖中值的内存id，那么就可以进行“修改元祖”操作扩展，
面试官可能会问到：元祖是否可以被修改？
答：元祖是不可变数据类型，因此不能修改元祖中的值，但是如果元组中有可变数据类型，那么可以修改可变数据类型中的值，
修改可变数据类型的值并不会使其内存id发生变化，所以元祖中元素中的内存id也没有改变，因此就做到了“修改元祖”操作
list:
a = [1,2,[3,4]]
b = a
c = a[:]
d = a.copy()
e = copy.deepcopy(a)
id(a), id(b), id(c), id(d), id(e) // 只有a b 是同一个指向
>>> (4398429512, 4398429512, 4398398664, 4398429576, 4398429192)
a.append(5) // 只有b跟着改变
a, b, c,d,e
([1, 2, [3, 4], 5], [1, 2, [3, 4], 5], [1, 2, [3, 4]], [1, 2, [3, 4]], [1, 2, [3, 4]])
a[2][1] = 7 // 除了deepcopy， 其他都跟着变了
a, b, c,d,e
([1, 2, [3, 7], 5], [1, 2, [3, 7], 5], [1, 2, [3, 7]], [1, 2, [3, 7]], [1, 2, [3, 4]])
copy 仅拷贝对象本身，而不拷贝对象中引用的其它对象。
deepcopy 除拷贝对象本身，而且拷贝对象中引用的其它对象。（子对象）
21丶代码中经常遇到的_args, *_kwargs 含义及用法。
args 是 arguments 的缩写，表示位置参数
kwargs 是 keyword arguments 的缩写，表示关键字参数
22丶json 序列化时，默认遇到中文会转换成 unicode，如果想要保留中文怎么办？
print(json.dumps(dict_demo, ensure_ascii=False))
23丶如果当前的日期为 20190530，要求写一个函数输出 N 天后的日期，(比如 N 为 2，则输出 20190601)
from datetime import datetime, timedelta
now_date = "20190530"
now_date = datetime.strptime(now_date, "%Y%m%d").date()
offset = timedelta(days=2)
print((now_date + offset).strftime("%Y%m%d"))
24丶python 字典和 json 字符串相互转化方法
#导包
import json
#json字符串转换成字典
json.loads(json_str)
#字典转换成json字符串
json.dumps(dict)
25丶函数装饰器有什么作用？请列举说明？
1，引入日志
2，函数执行时间统计
3，执行函数前预备处理
4，执行函数后清理功能
5，权限校验等场景
6，缓存
7，事务处理
28丶call 可以调用的对象: 一个特殊的魔术方法可以让类的实例的行为表现的像函数一样
class Entity:
'''调用实体来改变实体的位置。'''
def __init__(self, size, x, y):
self.x, self.y = x, y
self.size = size
def __call__(self, x, y):
'''改变实体的位置'''
self.x, self.y = x, y
e = Entity(1, 2, 3) // 创建实例
e(4, 5) //实例可以象函数那样执行，并传入x y值，修改对象的x y
29丶Python中递归的最大次数1000 ?怎么改
import sys
sys.setrecursionlimit(1500) # set the maximum depth as 1500
30丶列举 5 个 Python 中的异常类型以及其含义
BaseException
+-- SystemExit
+-- KeyboardInterrupt
+-- GeneratorExit
+-- Exception
+-- StopIteration
+-- StopAsyncIteration
+-- ArithmeticError
| +-- FloatingPointError
| +-- OverflowError
| +-- ZeroDivisionError
+-- AssertionError
+-- AttributeError
+-- BufferError
+-- EOFError
+-- ImportError
| +-- ModuleNotFoundError
+-- LookupError
| +-- IndexError
| +-- KeyError
+-- MemoryError
+-- NameError
| +-- UnboundLocalError
+-- OSError
| +-- BlockingIOError
| +-- ChildProcessError
| +-- ConnectionError
| | +-- BrokenPipeError
| | +-- ConnectionAbortedError
| | +-- ConnectionRefusedError
| | +-- ConnectionResetError
| +-- FileExistsError
| +-- FileNotFoundError
| +-- InterruptedError
| +-- IsADirectoryError
| +-- NotADirectoryError
| +-- PermissionError
| +-- ProcessLookupError
| +-- TimeoutError
+-- ReferenceError
+-- RuntimeError
| +-- NotImplementedError
| +-- RecursionError
+-- SyntaxError
| +-- IndentationError
| +-- TabError
+-- SystemError
+-- TypeError
+-- ValueError
| +-- UnicodeError
| +-- UnicodeDecodeError
| +-- UnicodeEncodeError
| +-- UnicodeTranslateError
+-- Warning
+-- DeprecationWarning
+-- PendingDeprecationWarning
+-- RuntimeWarning
+-- SyntaxWarning
+-- UserWarning
+-- FutureWarning
+-- ImportWarning
+-- UnicodeWarning
+-- BytesWarning
+-- ResourceWarning
31丶w、a+、wb 文件写入模式的区别
r : 读取文件，若文件不存在则会报错
w: 写入文件，若文件不存在则会先创建再写入，会覆盖原文件
a : 写入文件，若文件不存在则会先创建再写入，但不会覆盖原文件，而是追加在文件末尾
rb,wb：分别于r,w类似，用于读写二进制文件
r+ : 可读、可写，文件不存在也会报错，写操作时会覆盖
w+ : 可读，可写，文件不存在先创建，会覆盖
a+ ：可读、可写，文件不存在先创建，不会覆盖，追加在末尾
32丶求出列表所有奇数并构造新列表
a = [1,2,3,4,5,6,7,8,9,10]
res = [ i for i in a if i%2==1]
print(res)
33丶用一行python代码写出1+2+3+10248
from functools import reduce
#1.使用sum内置求和函数
num = sum([1,2,3,10248])
print(num)
#2.reduce 函数
num1 = reduce(lambda x,y :x+y,[1,2,3,10248])
print(num1)
34丶Python中变量的作用域？（变量查找顺序)
函数作用域的LEGB顺序
1.什么是LEGB?
L： local 函数内部作用域
E: enclosing 函数内部与内嵌函数之间
G: global 全局作用域
B： build-in 内置作用
python在函数里面的查找分为4种，称之为LEGB，也正是按照这是顺序来查找的
35丶字符串 "123" 转换成 123，不使用内置api，例如 int()
方法一： 利用 str 函数
def atoi(s):
num = 0
for v in s:
for j in range(10):
if v == str(j):
num = num * 10 + j
return num
方法二： 利用 ord 函数
def atoi(s):
num = 0
for v in s:
num = num * 10 + ord(v) - ord('0')
return num
方法三: 利用 eval 函数
def atoi(s):
num = 0
for v in s:
t = "%s * 1" % v
n = eval(t)
num = num * 10 + n
return num
方法四: 结合方法二，使用 reduce，一行解决
from functools import reduce
def atoi(s):
return reduce(lambda num, v: num * 10 + ord(v) - ord('0'), s, 0)
36丶返回该文件夹中所有文件的路径
def print_directory_contents(s_path):
"""
这个函数接收文件夹的名称作为输入参数
返回该文件夹中文件的路径
以及其包含文件夹中文件的路径
"""
import os
for s_child in os.listdir(s_path):
s_child_path = os.path.join(s_path, s_child)
if os.path.isdir(s_child_path):
print_directory_contents(s_child_path)
else:
print(s_child_path)
37丶输入日期， 判断这一天是这一年的第几天？
import datetime
def dayofyear():
year = input("请输入年份: ")
month = input("请输入月份: ")
day = input("请输入天: ")
date1 = datetime.date(year=int(year),month=int(month),day=int(day))
date2 = datetime.date(year=int(year),month=1,day=1)
return (date1-date2).days+1
38丶现有字典 d= {'a':24,'g':52,'i':12,'k':33}请按value值进行排序?
sorted(d.items(),key=lambda x:x[1])
39丶打乱一个排好序的list对象alist？
import random
alist = [1,2,3,4,5]
random.shuffle(alist)
print(alist)
# 下面这段代码是shuffle的实现
items = list(alist)
for i in xrange(len(alist)):
alist[i] = items.pop(self.randrange(len(items)))
40丶字典推导式
# 将字符串 "k:1 |k1:2|k2:3|k3:4"，处理成字典 {k:1,k1:2,...}
# d = {key:value for (key,value) in iterable}
d = {k:int(v) for t in str1.split("|") for k, v in (t.split(":"), )}
41丶请按alist中元素的age由大到小排序
alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
def sort_by_age(list1):
return sorted(alist, key=lambda x:x['age'], reverse=True)
42丶下面代码的输出结果将是什么？
list = ['a','b','c','d','e']
print(list[10:])
代码将输出[], 不会产生IndexError错误，就像所期望的那样，尝试用超出成员的个数的index来获取某个列表的成员。
例如，尝试获取list[10]和之后的成员，会导致IndexError。然而，尝试获取列表的切片，开始的index超过了成员个数不会产生
IndexError，而是仅仅返回一个空列表。这成为特别让人恶心的疑难杂症，因为运行的时候没有错误产生，导致Bug很难被追踪到。
43丶写一个列表生成式，产生一个公差为11的等差数列
print([x*11 for x in range(10)])
44丶给定两个列表，怎么找出他们相同的元素和不同的元素？
list1 = [1,2,3]
list2 = [3,4,5]
set1 = set(list1)
set2 = set(list2)
print(set1 & set2)
print(set1 ^ set2)
45丶统计一个文本中单词频次最高的10个单词？
import re
def test(filepath):
distone = {}
numTen = []
with open(filepath,"r",encoding="utf-8") as f:
for line in f:
line = re.sub("\W","",line)
lineone = line.split()
for keyone in lineone:
if not distone.get(keyone):
distone[keyone]=1
else:
distone[keyone]+=1
numTen = sorted(distone.items(),key=lambda x:x[1],reverse=True)[:10]
numTen =[x[0]for x in numTen]
return numTen
46丶给定一个任意长度数组，实现一个函数
让所有奇数都在偶数前面，而且奇数升序排列，偶数降序排序，如字符串'1982376455',变成'1355798642'
def func1(l):
if isinstance(l,str):
l = list(l)
l = [int(i) for i in l]
l.sort(reverse=True)
for i in range(len(l)):
if l[i] % 2>0:
l.insert(0,l.pop(i))
print(''.join(str(e) for e in l))
47丶写一个函数找出一个整数数组中，第二大的数
def find_Second_large_num(num_list):
"""
找出数组第2大的数字
"""
#直接排序，输出倒数第二个数即可
tmp_list = sorted(num_list)
print ("Second_large_num is :",tmp_list[-2])
#设置两个标志位一个存储最大数一个存储次大数
#two 存储次大值，one存储最大值，遍历一次数组即可，先判断是否大于one，若大于将one的值给two，
#将num_list[i]的值给
#one,否则比较是否大于two,若大于直接将num_list[i]的值给two,否则pass
one = num_list[0]
two = num_list[0]
for i in range(1,len(num_list)):
if num_list[i] > one:
two = one
one = num_list[i]
elif num_list[i] > two:
two = num_list[i]
else:
pass
print("Second_large_num is :",two)
if __name__ == '__main___':
num_list = [34,11,23,56,78,0,9,12,3,7,5]
find_Second_large_num(num_list)
48丶阅读一下代码他们的输出结果是什么？
def multi():
return [lambda x : i*x for i in range(4)]
print([m(3) for m in multi()])
提示: 闭包，作用域 正确答案是[9,9,9,9]，而不是[0,3,6,9]产生的原因是Python的闭包的后期绑定导致的，
这意味着在闭包中的变量是在内部函数被调用的时候被查找的，因为，最后函数被调用的时候，
for循环已经完成, i 的值最后是3,因此每一个返回值的i都是3,所以最后的结果是[9,9,9,9]
49丶统计一段字符串中字符出现的次数
def count_str(str_data):
"""定义一个字符出现次数的函数"""
dict_str = {}
for i in str_data:
dict_str[i] = dict_str.get(i,0)+1
return dict_str
dict_str = count_str("AAABBCCAC")
str_count_data = ""
for k,v in dict_str.items():
str_count_data += k +str(v)
print(str_count_data)
50丶带参数的装饰器?
from functools import wraps
def decorator(*dargs, **dkwargs):
def params_wrapper(func):
@wraps(func)
def wrapper(*args, **kwargs):
func(*args, **kwargs)
return wrapper
return params_wrapper
类装饰器
class decorator(object):
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print('before............')
res = self.func(*args, **kwargs)
print('after............')
return res
51丶阅读一下代码他们的输出结果是什么？
[5, 4, 6, 3, 7, 2, 8, 1, 9]
列表[1, 2, 3, 4, 5, 6, 7, 8, 9]按照元素与5距离从小到大进行排序，其结果是[5, 4, 6, 3, 7, 2, 8, 1, 9]
52丶
最新文章
- RHEL7修改swappiness
- PROTEL DXP原理图编译 常见错误与处理方法
- ACM心情总结
- ASP.NET Web API安全认证
- MVC 基础知识
- Android应用启动时间及启动日志获取方法
- nginx，linux压力测试工具webbench
- jquery ajax异步加载table的方法
- LightOj_1342 Aladdin and the Magical Sticks
- javascript基础学习（四）
- Amlogic开关机按键功能实现
- 《JavaScript设计模式与开发实践》读书笔记之观察者模式
- 一.windows环境下rabbitMQ的的安装和配置
- 南阳OJ-12-喷水装置（二）贪心+区间覆盖
- mysql数据库中的数据导入与导出
- Fiddler和PostMan的使用例子和下载
- Ａ＋ B
- 各大互联网公司java开发面试常问问题
- BitAdminCore框架应用篇：（一）使用Cookiecutter创建应用项目
- api.closeFrame