Python面试基础知识

最新推荐文章于 2024-05-02 23:41:03 发布

GouZe1

最新推荐文章于 2024-05-02 23:41:03 发布

阅读量598

点赞数

分类专栏：面试文章标签： Python 基础

本文链接：https://blog.csdn.net/weixin_43734271/article/details/98798084

版权

面试专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Python基本知识的概述

Python中的with语句：
with语句经常适用于对资源进行访问的场合，确保在访问的过程中不管是否发生异常都会指执行必要的清理操作，比如文件的自动关闭以及线程中锁的自动获取与释放。

1.执行 context_expression，生成上下文管理器 context_manager
2.调用上下文管理器的 enter() 方法；如果使用了 as 子句，则将 enter() 方法的返回值赋值给 as 子句中的 target(s)
3.执行语句体 with-body
4.不管是否执行过程中是否发生了异常，执行上下文管理器的 exit() 方法，exit() 方法负责执行“清理”工作，如释放资源等。如果执行过程中没有出现异常，或者语句体中执行了语句 break/continue/return，则以 None 作为参数调用 exit(None, None, None) ；如果执行过程中出现异常，则使用 sys.exc_info 得到的异常信息为参数调用 exit(exc_type, exc_value, exc_traceback)
5.出现异常时，如果 exit(type, value, traceback) 返回 False，则会重新抛出异常，让with 之外的语句逻辑来处理异常，这也是通用做法；如果返回 True，则忽略异常，不再对异常进行处理

1.简述函数式编程
在函数式编程中，函数是基本单位，变量只是一个名称，而不是一个存储单元。除了匿名函数外，Python还使用fliter(),map(),reduce(),apply()函数来支持函数式编程。

2.什么是匿名函数，匿名函数有什么局限性
匿名函数，也就是lambda函数，通常用在函数体比较简单的函数上。匿名函数顾名思义就是函数没有名字，因此不用担心函数名冲突。不过Python对匿名函数的支持有限，只有一些简单的情况下可以使用匿名函数。
3.如何捕获异常，常用的异常机制有哪些？
如果我们没有对异常进行任何预防，那么在程序执行的过程中发生异常，就会中断程序，调用python默认的异常处理器，并在终端输出异常信息。
try…except…finally语句:当try语句执行时发生异常，回到try语句层，寻找后面是否有except语句。找到except语句后，会调用这个自定义的异常处理器。except将异常处理完毕后，程序继续往下执行。finally语句表示，无论异常发生与否，finally中的语句都要执行。
assert语句：判断assert后面紧跟的语句是True还是False，如果是True则继续执行print，如果是False则中断程序，调用默认的异常处理器，同时输出assert语句逗号后面的提示信息。
with语句：如果with语句或语句块中发生异常，会调用默认的异常处理器处理，但文件还是会正常关闭。

3.copy()与deepcopy()的区别
copy是浅拷贝，只拷贝可变对象的父级元素。 deepcopy是深拷贝，递归拷贝可变对象的所有元素。

4.函数装饰器有什么作用（常考）
装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。有了装饰器，就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。

什么是面向切面编程（AOP）
AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。
而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将**其名为“Aspect”，即方面。所谓“方面”，**简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。
切入点（Pointcut）: 指定一个通知将被引发的一系列连接点的集合。

5.简述Python的作用域以及Python搜索变量的顺序
Python作用域简单说就是一个变量的命名空间。代码中变量被赋值的位置，就决定了哪些范围的对象可以访问这个变量，这个范围就是变量的作用域。在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域。Python的变量名解析机制也称为 LEGB 法则：本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）

6.新式类和旧式类的区别,如何确保使用的类是新式类
为了统一类(class)和类型(type)，python在2.2版本引进来新式类。在2.1版本中，类和类型是不同的。

7.为了确保使用的是新式类，有以下方法：
放在类模块代码的最前面 metaclass = type
从内建类object直接或者间接地继承
在python3版本中，默认所有的类都是新式类。

8.简述__new__和__init__的区别
创建一个新实例时调用__new__,初始化一个实例时用__init__,这是它们最本质的区别。
new方法会返回所构造的对象，init则不会。
new函数必须以cls作为第一个参数，而init则以self作为其第一个参数。
在对象生命周期调用结束时，del 方法会被调用，可以将__del__理解为“构析函数”

9.Python垃圾回收机制(常考)
Python GC主要使用引用计数（reference counting）来跟踪和回收垃圾。在引用计数的基础上，通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用问题，通过“分代回收”（generation collection）以空间换时间的方法提高垃圾回收效率。
1 引用计数
PyObject是每个对象必有的内容，其中ob_refcnt就是做为引用计数。当一个对象有新的引用时，它的ob_refcnt就会增加，当引用它的对象被删除，它的ob_refcnt就会减少.引用计数为0时，该对象生命就结束了。
优点: 简单实时性
缺点: 维护引用计数消耗资源循环引用

2 标记-清除机制
基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记，然后清扫一遍内存空间，把所有没标记的对象释放。

3 分代技术
分代回收的整体思想是：将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量。
Python默认定义了三代对象集合，索引数越大，对象存活时间越长。

10.Python中的@property有什么作用?如何实现成员变量的只读属性？
@property装饰器就是负责把一个方法变成属性调用，通常用在属性的get方法和set方法，通过设置@property可以实现实例成员变量的直接访问，又保留了参数的检查。另外通过设置get方法而不定义set方法可以实现成员变量的只读属性。
@property装饰器会再次生成一个装饰器@width.setter装饰器，如果是只读属性不用定义@setter装饰器下的方法

class Screen(object):
@property
def width(self):
    return self.width

@width.setter
def width(self, width):
    if not isinstance(width, int):
        raise ValueError("type error“）
    if value<0:
        raise ValueError("type error")
    return self.width

@property
def height(self):
    return self.height

@height.setter
def height(self, height):
    if not isinstance(height, int):
        raise ValueError("type error“）
    if value<0:
        raise ValueError("type error")
    return self.width

@property
def resolution(self):
    return self.height*self.width

@wraps 装饰器在实现的时候，被装饰后的函数其实已经是另一个函数（函数名等属性会被改变）为了不影响，Python中的functools包中提供了一种wraps的装饰器来消除副作用。
以下举个例子：
装饰器实现日志功能

from functools import wraps

def login(func):
	@wraps
	def wrappers(*args, **kwargs):
		print(func.__name__, + 'was calles')
	return wrappers

@login
def sum_x(x):
	return x+x

**11.*args and **kwargs
*args代表位置参数，它会接收任意多个参数并把这些参数作为元组传递给函数。**kwargs代表的关键字参数，允许你使用没有事先定义的参数名，另外，位置参数一定要放在关键字参数的前面。

12.有用过with statement吗？它的好处是什么？具体如何实现？
with语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源，比如文件使用后自动关闭、线程中锁的自动获取和释放等。

13.python中哪些对象是可变的，哪些不可变？
可变类型：字典、列表、集合
不可变类型：数字、字符串、元组

从对象的索引角度看待这个问题
这里的可变不可变，是指内存中的那块内容（value）是否可以被改变。如果是不可变类型，在对对象本身操作的时候，必须在内存中新申请一块区域(因为老区域#不可变#)。如果是可变类型，对对象操作的时候，不需要再在其他地方申请内存，只需要在此对象后面连续申请(+/-)即可，也就是它的address会保持不变，但区域会变长或者变短。

14.is和==的区别
对象主要从数值类型和值以及id函数的地址考虑
is是值和类型相同即可，== 需要id()相同

15.Python中迭代器和生成器的区别

**迭代器是一个更抽象的概念，任何对象，如果它的类有 next 方法和 iter 方法返回自己本身，对于 string、list、dict、tuple 等这类容器对象，使用 for 循环遍历是很方便的。**在后台 for 语句对容器对象调用 iter()函数，iter()是 python 的内置函数。iter()会返回一个定义了 next()方法的迭代器对象，它在容器中逐个访问容器内元素，next()也是 python 的内置函数。在没有后续元素时，next()会抛出一个 StopIteration 异常。

生成器（Generator）是创建迭代器的简单而强大的工具。它们写起来就像是正规的函数，只是在需要返回数据的时候使用 yield 语句。每次 next()被调用时，生成器会返回它脱离的位置（它记忆语句最后一次执行的位置和所有的数据值）

区别：生成器能做到迭代器能做的所有事,而且因为自动创建了 iter()和 next()方法,生成器显得特别简洁,而且生成器也是高效的，使用生成器表达式取代列表解析可以同时节省内存。除了创建和保存程序状态的自动方法,当发生器终结时,还会自动抛出 StopIteration 异常

16.Python中的map/ reduce／filter函数
map()函数接收一个函数和一个可迭代对象，返回一个另一个可迭代对象，是该函数依次作用在该对象上的结果
reduce函数接受一个函数和一个可迭代对象，reduce把结果和序列的下一个做累计计算
filter函数接受一个函数和一个序列，和map不同的是filter函数会根据返回的结果是True还是False进行过滤

17.什么是闭包
在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。

18.Python中__slots__方法
用来限制实例属性，只允许对Student实例添加name和age属性。
在这里插入图片描述
19.Python中的I／O多路复用
Python中有一个select模块，其中提供了：select、poll、epoll三个方法，分别调用系统的 select，poll，epoll 从而实现IO多路复用。
https://blog.csdn.net/qq_36126849/article/details/80409009

20.什么是上下文管理器
含有__enter__和__exit__方法的对象就是上下文管理器，所以，简单来说，上下文管理器的目的就是规定对象的使用范围，如果超出范围就采取“处理”。

21.Python中的__add__, radd,__iadd__右加
add，表示‘左加’，及两个类型相加，A中有__add__,A的实例+B的实例，则能够执行，反之报错。
__radd__表示‘右加’,若对象在+左边会报错
__iadd__表示‘+=’

22. object的父类是谁
object类是老大，所以它的父类为None

23. 什么是元类以及元类的应用
https://www.cnblogs.com/piperck/p/5840443.html

25. 谈谈super原理
在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时，我们希望能同时实现父类的功能，这时，我们就需要调用父类的方法了，可通过使用 super 来实现，但是super 其实和父类没有实质性的关联。
事实上，对于你定义的每一个类，Python 会计算出一个方法解析顺序（Method Resolution Order, MRO）列表，它代表了类继承的顺序，我们可以使用下面的方式获得某个类的 MRO 列表：
在这里插入图片描述

其中，cls 代表类，inst 代表实例，上面的代码做了两件事：

获取 inst 的 MRO 列表
查找 cls 在当前 MRO 列表中的 index, 并返回它的下一个类，即 mro[index + 1]
当你使用 super(cls, inst) 时，Python 会在 inst 的 MRO 列表上搜索 cls 的下一个类。

Python中常见的装饰器
@property
使调用类中的方法像引用类中的字段属性一样。被修饰的特性方法，内部可以实现处理逻辑，但对外提供统一的调用方式。遵循了统一访问的原则。

在这里插入图片描述
@staticmethod
将类中的方法装饰为静态方法，即类不需要创建实例的情况下，可以通过类名直接引用。到达将函数功能与实例解绑的效果。

@classmethod
类方法的第一个参数是一个类，是将类本身作为操作的方法。类方法被哪个类调用，就传入哪个类作为第一个参数进行操作。
@wrap
Python装饰器（decorator）在实现的时候，被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变），为了不影响，Python的functools包中提供了一个叫wraps的decorator来消除这样的副作用。写一个decorator的时候，最好在实现之前加上functools的wrap，它能保留原有函数的名称和docstring。

27.Python中常见的魔术方法
init:实例化对象时调用

new:创建类对象时调用
_ _ new __ ()方法始终都是类的静态方法，即使没有被加上静态方法装饰器
new() 方法创建对象，在__init__()方法之前被调用，返回一个self对象，并将该对象传给__init__()的第一个参数。一般不需要复写__new__()方法，如果有需求：例如单例模式可以通过重写__new__方法或者在类创建时进行一些修改

call:为了将一个类实例当做函数调用，我们需要在类中实现__call()__方法。同时不影响实例本身的生命周期（__call()__不影响一个实例的构造和析构）。但是__call()__可以用来改变实例的内部成员的值

_ _ getattr__
拦截点号运算。当对未定义的属性名称和实例进行点号运算时，就会用属性名作为字符串调用这个方法。如果继承树可以找到该属性，则不调用此方法
如果属性查找（attribute lookup）在实例以及对应的类中（通过__dict__)失败，那么会调用到类的__getattr__函数, 如果没有定义这个函数，那么抛出AttributeError异常。由此可见，__getattr__一定是作用于属性查找的最后一步，兜底

_ _ getattribute__
_ _ getattribute__是访问属性的方法，我们可以通过方法重写来扩展方法的功能。
对于python来说，属性或者函数都可以被理解成一个属性，且可以通过_ _ getattribute__获取。
当获取属性时，直接return object._ getattribute_(self,item) 或者使用 super(). _ _ getattribute _ _(item)

首先我们应该已经知道了 getattr 和 getattribute 这两个方法都是截取属性的内置方法。我们来看下这两个方法的区别

在这里插入图片描述
_ _ setattr__
会拦截所有属性的的赋值语句.如果定义了这个方法，self.arrt = value 就会变成self._ _ setattr__(“attr”, value)

class Foo:
    def __setattr__(self, key, value):
        print(key, value)
        self.__dict__[key] = value

f = Foo()
f.name = 'Night'
print(f.name)

name Night
Night

_ _ delattr__
删除属性时调用该方法

_ _ eq__
使用==进行判断，是否相等

__ge__      大于等于
__gt__      大于
__le__      小于等于
__lt__      小于

_ _ getitem__
返回键对应的值

class Foo:
    def __init__(self, item):
        self.item = item

    def __getitem__(self, item):
        print('getitem is run', item)
        return self.item[item]


f1=Foo(['Charm', 'Night', '2018', '加油'])
print(f1[0])

getitem is run 0
Charm

_ _ setitem__
给键设置对应的值

class Foo:
    def __init__(self, item):
        self.item = item

    def __setitem__(self, key, value):
        print('setitem is run')
        self.item[key] = value

    def __repr__(self):
        return '{}'.format(self.item)

f = Foo(['Night', 'so', 'cool'])
f[0] = 'Charm'
print(f)

setitem is run
['Charm', 'so', 'cool']

_ _ delitem__
删除给定键对应的元素

_ _ len__
返回元素的数量

_ _ str__
改变对象的字符串显示，返回值必须是字符串,否则抛出异常

_ _ repr__
改变对象的字符串显示，返回值必须是字符串,否则抛出异常
如果__str__没有被定义,那么就会使用__repr__来代替输出

_ _ format__
自定制格式化字符串

GouZe1

关注

0
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Python面试基础知识

Python基本知识的概述Python中的with语句：with语句经常适用于对资源进行访问的场合，确保在访问的过程中不管是否发生异常都会指执行必要的清理操作，比如文件的自动关闭以及线程中锁的自动获取与释放。1.执行 context_expression，生成上下文管理器 context_manager2.调用上下文管理器的 enter() 方法；如果使用了 as 子句，则将 enter(...
复制链接

扫一扫