Python2022年面试题总结

✅作者简介&＃xff1a;大家好我是编程ID
&＃x1f4c3;个人主页&＃xff1a;编程ID的csdn博客
系列专栏&＃xff1a;Python
&＃x1f4ac;推荐一款Python编程题刷题神器&＃x1f449;点击跳转进入网站

一. Python基础

1&＃xff09;字典推导式

d &＃61; {key:value for (key,value) in iterable}


2&＃xff09;反转字符串 “aStr”

print("aStr"[::-1])


3&＃xff09;将字符串 “k:1 |k1:2|k2:3|k3:4”&＃xff0c;处理成字典 {k:1,k1:2,…}

str1 &＃61; "k:1|k1:2|k2:3|k3:4"
def str2dict(str1): dict1 &＃61; {} for iterms in str1.split(&＃39;|&＃39;): key,value &＃61; iterms.split(&＃39;:&＃39;) dict1[key] &＃61; value return dict1
#字典推导式
d &＃61; {k:int(v) for t in str1.split("|") for k, v in (t.split(":"), )}


4&＃xff09;下面代码的输出结果将是什么

list &＃61; [&＃39;a&＃39;,&＃39;b&＃39;,&＃39;c&＃39;,&＃39;d&＃39;,&＃39;e&＃39;]
print(list[10:])


代码将输出[],不会产生IndexError错误&＃xff0c;就像所期望的那样&＃xff0c;尝试用超出成员的个数的index来获取某 个列表的成员。例如&＃xff0c;尝试获取list[10]和之后的成员&＃xff0c;会导致IndexError。然而&＃xff0c;尝试获取列表的切 片&＃xff0c;开始的index超过了成员个数不会产生IndexError&＃xff0c;而是仅仅返回一个空列表。这成为特别让人恶 心的疑难杂症&＃xff0c;因为运行的时候没有错误产生&＃xff0c;导致Bug很难被追踪到。

5&＃xff09;给定两个列表&＃xff0c;怎么找出他们相同的元素和不同的元素

list1 &＃61; [1,2,3]
list2 &＃61; [3,4,5]
set1 &＃61; set(list1)
set2 &＃61; set(list2)
print(set1 & set2)
print(set1 ^ set2)


6&＃xff09;Python元组和列表的区别
答&＃xff1a;列表可变&＃xff0c;元组不可变。

如果只能回答上面的答案在大厂面试中一定会挂&＃xff0c;下面进行详细解答&＃xff1a;

元组(tuple)不可变是指它的内存地址不可变&＃xff0c;如果元组内的元素是可变类型的值&＃xff08;例如&＃xff1a;dict&＃xff09;&＃xff0c;那其中的元素是可以改变的。例如&＃xff1a;

a &＃61; (1, {&＃39;key&＃39;: 1})
a[1][&＃39;key&＃39;] &＃61; 2
print(&＃39;改变之后的a的值&＃39;, a)


输出结果

改变之后的a的值 (1, {&＃39;key&＃39;: 2})


除此之外&＃xff0c;元组占用的内存空间更小&＃xff1a;

a &＃61; [1, 2, 3, 4, 5, 6]
print(&＃39;列表的空间大小为&＃xff1a;&＃39;, a.__sizeof__())
b &＃61; (1, 2, 3, 4, 5, 6)
print(&＃39;元组的空间大小为&＃xff1a;&＃39;, b.__sizeof__())


输出结果

列表的空间大小为&＃xff1a; 136
元组的空间大小为&＃xff1a; 72


元组可以作为字典的key&＃xff0c;而列表不能&＃xff1a;

列表作为字典的key时会报错&＃xff01;

a &＃61; {[&＃39;a&＃39;]:1}


输出结果

TypeError: unhashable type: &＃39;list&＃39;


元组作为字典的key时则不会报错

a &＃61; {(&＃39;a&＃39;,):1}


另外&＃xff0c;元组的元素必须用逗号分隔&＃xff0c;哪怕只有一个元素&＃xff1a;

(‘a’,)
元组和列表的区别总结如下&＃xff1a;

元组内存地址不可变&＃xff0c;列表内存地址可变&＃xff1b;
元组占用空间比列表更少&＃xff1b;
元组是不可变参数&＃xff0c;所以可以作为字段的key&＃xff0c;而列表&＃xff08;可变参数&＃xff09;不能&＃xff1b;
元组的元素必须用逗号分隔&＃xff0c;哪怕只有一个元素&＃xff1b;
7&＃xff09;如何在一个函数内部修改全局变量
可以使用global修改&＃xff1a;

a &＃61; 1def test():globals()[&＃39;a&＃39;] &＃61; 2print(&＃39;原来的a值&＃xff1a;&＃39;, a)
test()
print(&＃39;修改后的a值&＃xff1a;&＃39;, a)


输出结果

原来的a值&＃xff1a; 1
修改后的a值&＃xff1a; 2


函数也可以改成这样&＃xff1a;

def test():global aa&＃61;2


8&＃xff09;解释一下Python的GIL
GlL是 python的全局解释器锁,同一进程中假如有多个线程运行,一个线程在运行python程序的时候会霸占 python解释器(加了一把锁即GIL),使该进程內的其他线程无法运行,等该线程运行完后其他线程才能运行。如果线程运行过程中遇到耗时操作,则解释器锁解开,使其他线程运行。所以在多线程中,线程的运行仍是有先后顺序的,并不是同时进行。多进程中因为每个进程都能被系统分配资源,相当于每个进程有了ー个 python解释器,所以多进程可以实现多个进程的同时运行,缺点是进程系统资源开销大。

9&＃xff09;Python列表去重
通过集合的方式去重&＃xff1a;

a &＃61; [1, 2, 2, 3, 3, 6]
a &＃61; set(a) # 先转为集合进行去重
a &＃61; list(a) # 然后再转换为列表
print(&＃39;去重后的列表&＃39;, a)


手写去重代码&＃xff1a;

a &＃61; [1, 2, 2, 4, 4, 6, 7]
b &＃61; []
for i in a:if i not in b:b.append(i)print(&＃39;去重后的列表&＃39;, b)


10&＃xff09;列出 python中可变数据类型和不可变数据类型,并简述原理
不可变数据类型&＃xff1a;数值型(int)、字符串型(str)和元组(tuple)不允许变量的值发生变化,如果改变了变量的值,相当于是新建了一个对象,而对于相同的值的对象,在内存中则只有一个对象(一个地址)&＃xff1a;

a &＃61; 3
b &＃61; 3
print(&＃39;a的内存地址为&＃39;, id(a))
print(&＃39;b的内存地址为&＃39;, id(b))


输出结果

a的内存地址为 1658574891376
b的内存地址为 1658574891376


可变数据类型&＃xff1a;列表(list)和字典(dict)&＃xff0c;允许变量的值发生变化,即如果对变量进行 append、&＃43;&＃61;等这种操作后,只是改变了变量的值,而不会新建一个对象,变量引用的对象的地址也不会变化,不过对于相同的值的不同对象,在内存中则会存在不同的对象,即每个对象都有自己的地址,相当于内存中对于同值的对象保存了多份,这里不存在引用计数,是实实在在的对象:

a &＃61; [1,2]
b &＃61; [1,2]
print(&＃39;a的内存地址为&＃39;, id(a))
print(&＃39;b的内存地址为&＃39;, id(b))


输出结果

a的内存地址为 2122512488768
b的内存地址为 2122512662720
6&＃xff09;python2和 python3区别
Python3使用 print必须要以小括号包裹打印内容,而在Python2既可以使用带小括号的方式,也可以使用一个空格来分隔打印内容:
print("hello world") #pyton3和python2都可
print "hello world" #python2
python2 range(1,10)返回列表, python3中返回迭代器,节约内存&＃xff1b;
python2中使用asci编码, python中使用utf-8编码&＃xff1b;
python2中 unicode表示字符串序列,str表示字节序列python3中st表示字符串序列,byte表示字节序列 &＃xff1b;
python2中为正常显示中文,引入 coding声明, python3中不需要&＃xff1b;
python2中是 raw input0函数, python3中是 Input0函数&＃xff1b;


11&＃xff09;python中内置的数据结构有几种
整型 int、 长整型 long、浮点型 float、 复数 complex
字符串 str、 列表 list、 元祖 tuple
字典 dict 、 集合 set
Python3 中没有 long&＃xff0c;只有无限精度的 int
12&＃xff09;下面代码的输出结果将是什么

a &＃61; [1,2]
print(a[3:])


代码将输出[],不会产生IndexError错误&＃xff0c;就像所期望的那样&＃xff0c;尝试用超出成员的个数的index来获取某个列表的成员。例如&＃xff0c;尝试获取list[10]和之后的成员&＃xff0c;会导致IndexError。然而&＃xff0c;尝试获取列表的切片&＃xff0c;开始的index超过了成员个数不会产生IndexError&＃xff0c;而是仅仅返回一个空列表。这成为特别让人恶心的疑难杂症&＃xff0c;因为运行的时候没有错误产生&＃xff0c;导致Bug很难被追踪到。

*13&＃xff09;Python代码中_args, _kwargs 含义及用法&＃xff1f;
args&＃xff1a; arguments 的缩写&＃xff0c;表示位置参数

kwargs&＃xff1a; keyword arguments 的缩写&＃xff0c;表示关键字参数

14&＃xff09;请列出 5 个 python 标准库&＃xff1f;
os&＃xff1a;提供了不少与操作系统相关联的函数
sys: 通常用于命令行参数
re: 正则匹配
math: 数学运算
datetime:处理日期时间
15&＃xff09;Python的可变数据类型和不可变数据类型分别有&＃xff1f;
可变数据类型&＃xff1a;列表、字典、集合

不可变数据类型&＃xff1a;数字、字符串、元组

16&＃xff09;Python 中魔法方法和其用途&＃xff1f;
init&＃xff1a;对象初始化方法

new&＃xff1a;创建对象时候执行的方法&＃xff0c;单列模式会用到

str:当使用print输出对象的时候&＃xff0c;只要自己定义了__str__(self)方法&＃xff0c;那么就会打印从在这个方法中return的数据

del&＃xff1a;删除对象执行的方法

17&＃xff09;Python 中os和sys模块的作用分别是&＃xff1f;
os模块&＃xff1a;负责程序与操作系统的交互&＃xff0c;提供了访问操作系统底层的接口。sys模块&＃xff1a;负责程序与python解释器的交互&＃xff0c;提供了一系列的函数和变量&＃xff0c;用于操控python的运行时环境。

18&＃xff09;简述Python引用计数机制&＃xff1f;
python垃圾回收主要以引用计数为主&＃xff0c;标记-清除和分代清除为辅的机制&＃xff0c;其中标记-清除和分代回收主要是为了处理循环引用的难题。

19&＃xff09;Python赋值、浅拷贝和深拷贝的区别&＃xff1f;
Python 有 3 种赋值方式&＃xff1a;直接赋值、浅拷贝、深拷贝&＃xff1b;

直接赋值&＃xff1a;就是对象的引用。&＃xff08;相当于给原来的对象起个别名&＃xff09;&＃xff0c;比如有个人叫张三&＃xff0c;外号叫小张&＃xff0c;对象的引用就是类似&＃xff0c;虽然换个名字&＃xff0c;但是两个名字指的是同一个人。

浅拷贝&＃xff0c;拷贝的是父对象&＃xff0c;不会拷贝到内部的子对象。&＃xff08;单从浅字就可以看出拷贝的东西不深&＃xff0c;可以理解为只拷贝一层&＃xff09; { 1、完全切片方法&＃xff1b;2、工厂函数&＃xff0c;如 list()&＃xff1b;3、copy 模块的 copy()函数 }

深拷贝&＃xff0c;包含对象里面的自对象的拷贝&＃xff08;可以理解为克隆&＃xff0c;全拷贝过去但是两者没有任何关系了&＃xff0c;各自是各自的&＃xff09;&＃xff1b;所以原始对象的改变不会造成深拷贝里任何子元素的改变 { copy 模块的 deep.deepcopy()函数 }

请阐述在Python中split()&＃xff0c;sub()&＃xff0c;subn()的功能分别是什么&＃xff1f;
split()&＃xff1a; 使用正则表达式模式将给定字符串“拆分”到列表中。

sub()&＃xff1a; 查找正则表达式模式匹配的所有子字符串&＃xff0c;然后用不同的字符串替换它们

subn()&＃xff1a; 它类似于sub()&＃xff0c;并且还返回新字符串。

20&＃xff09;举例 sort 和 sorted方法的区别&＃xff1f;
使用 sort()方法对 list 排序会修改 list 本身,不会返回新 list&＃xff0c;sort()不能对 dict 字典进行排序&＃xff1b;

sorted 方法对可迭代的序列排序生成新的序列&＃xff0c;对 dict 排序默认会按照 dict 的 key 值进行排序&＃xff0c;最后返回的结果是一个对 key 值排序好的list&＃xff1b;

sorted 对 tuple&＃xff0c; dict 依然有效&＃xff0c;而 sort 不行&＃xff1b;

21&＃xff09;解释 Python 中的可变类型和不可变类型&＃xff1f;
1.Python中的可变类型有list,dict&＃xff1b;不可变类型有string&＃xff0c;number,tuple.

2.当进行修改操作时&＃xff0c;可变类型传递的是内存中的地址&＃xff0c;也就是说&＃xff0c;直接修改内存中的值&＃xff0c;并没有开辟新的内存。

3.不可变类型被改变时&＃xff0c;并没有改变原内存地址中的值&＃xff0c;而是开辟一块新的内存&＃xff0c;将原地址中的值复制过去&＃xff0c;对这块新开辟的内存中的值进行操作。

22&＃xff09;Python 中类方法、类实例方法、静态方法有何区别&＃xff1f;
类方法: 是类对象的方法&＃xff0c;在定义时需要在上方使用 &＃64;classmethod 进行装饰,形参为cls&＃xff0c;表示类对象&＃xff0c;类对象和实例对象都可调用

类实例方法: 是类实例化对象的方法,只能由实例对象调用&＃xff0c;形参为self,指代对象本身;

静态方法: 是一个任意函数&＃xff0c;在其上方使用 &＃64;staticmethod 进行装饰&＃xff0c;实例对象和类对象都可以调用。但是方法体中不能使用类或实例的任何属性和方法。

二. 企业面试题

6&＃xff09;python新式类和经典类的区别

在python里凡是继承了object的类&＃xff0c;都是新式类
Python3里只有新式类
Python2里面继承object的是新式类&＃xff0c;没有写父类的是经典类
经典类目前在Python里基本没有应用
保持class与type的统一对新式类的实例执行a.class与type(a)的结果是一致的&＃xff0c;对于旧式类来说就不一样了。
对于多重继承的属性搜索顺序不一样新式类是采用广度优先搜索&＃xff0c;旧式类采用深度优先搜索。
7&＃xff09;python中内置的数据结构有几种

整型 int、 长整型 long、浮点型 float、 复数 complex
字符串 str、 列表 list、 元祖 tuple
字典 dict 、 集合 set
Python3 中没有 long&＃xff0c;只有无限精度的 int
8&＃xff09;python如何实现单例模式?请写出两种实现方式
8.1 第一种方法:使用装饰器

def singleton(cls):instances &＃61; {}def wrapper(*args, **kwargs):if cls not in instances:instances[cls] &＃61; cls(*args, **kwargs)return instances[cls]return wrapper
&＃64;singleton
class Foo(object):pass
foo1 &＃61; Foo()
foo2 &＃61; Foo()
print(foo1 is foo2) # True

结束语&＃x1f947;&＃x1f947;&＃x1f947;

**结束语 &＃x1f947;&＃x1f947;&＃x1f947;**
> 发现非常好用的一个刷题网站!大家一起努力&＃xff01;加油&＃xff01;&＃xff01;&＃xff01;
> 题目难度可以自行选择
> 在线编程出答案&＃xff0c;&＃xff08;也可自行查看答案&＃xff09;非常方便
> 程序员刷题神器网站[点击链接注册即可刷题 ](https://www.nowcoder.com/link/pc_csdncpt_bcid_python)
> 祝大家早日找到满意的工作