python基础面试都问什么问题_基本 Python 面试问题

def Stack(object):

def __init__(self):

self.stack = []

def push(self,value):

# 进栈

self.stack.append(value)

def pop(self):

# 出栈

if self.stack:

self.stack.pop()

else:

raise LookupError('stack is empty!')

def is_empty(self):

# 查看stack是否为空

reture bool(self.stack)

def top(self):

# 取出stack中最新的值

return self.stack[-1]

50、常用字符串格式化哪几种？

1、%s %d

2、format格式化输出

3、print(f'内容{变量名}')

51、简述生成器、迭代器、可迭代对象以及应用场景？

生成器：在 Python 中，一边循环一边计算的机制，称为生成器（generator），

通过next()取值，两种表现形式1、将列表生成式的[]改为()2、含有yield关键字的函数

应用场景：优化代码，节省内存

迭代器：是访问集合元素的一种方式。迭代器同时实现了__iter__和__next__方法

可迭代对象：只要实现了__iter__方法的对象就是可迭代对象

52、用Python实现一个二分查找的函数。

lis = [0, 1, 3, 4, 5, 6, 7, 9, 10, 11,12,16,17]

def binary_search(li, val):

low = 0

high = len(li)-1

while low <= high:

mid = (low + high) // 2

if li[mid] < val:

low = mid + 1

elif li[mid] > val:

high = mid - 1

else:

return mid

return None

53、谈谈你对闭包的理解？

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

一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。

但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。

54、os和sys模块的作用？

os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;

sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

55、如何生成一个随机数？

import random

def rdm(n):

lis= []

for i in range(n):

n= random.randint(1,9)

lis.append(str(n))

s = ''.join(lis)

return int(s)

56、如何使用python删除一个文件？

import os

os.remove(r'path')

57、谈谈你对面向对象的理解？

面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，

不存在的也可以创造出来。对象是特征和技能的结合，其中特征和技能分别对应对象的数据属性和方法属性。

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，

面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地

58、Python面向对象中的继承有什么特点？

1：在继承中基类的构造(__init__()方法)不会被自动调用，它需要在其派生类的构造中亲自专门调用。

2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。

区别于在类中调用普通函数时并不需要带上self参数

3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。

(先在本类中查找调用的方法，找不到才去基类中找)。

59、面向对象深度优先和广度优先是什么？

Python的类可以继承多个类，那么其寻找类方法的方式有两种：

当类是经典类时(主要在python2版本中的没有主动继承object的类)，多继承情况下，会按照深度优先方式查找

当类是新式类时(python3版本中的所有类和python2中主动继承object的类)，多继承情况下，会按照广度优先方式查找

简单点说就是：经典类是纵向查找，新式类是横向查找

60、面向对象中super的作用？

1、super在面向对象继承类中代指父类，书写方法super(类名,self).属性或者方法或super().属性或者方法

2、super方法可以增加类之间调用的灵活性，当父类名发生变化时不必修改

3、super方法在类的多继承时可以简化代码，避免代码冗余

4、super机制里可以保证公共父类仅被执行一次，执行的顺序遵循MRO，广度优先查询方法

61、是否使用过functools中的函数？其作用是什么？

functools用于高阶函数：指那些作用于函数或者返回其他函数的函数。通常情况下，只要是

可以被当做函数调用的对象就是这个模块的目标。

62、列举面向对象中带双下划线的特殊方法，如：new、init

__new__：构造方法，创建一个对象，实例化时第一个被执行，返回一个创建好的对象及__init__(self)的self，

只有继承了object的类才会有这个方法

__init__：初始化方法，__init__在__new__的基础上完成一些其它初始化的动作，__init__没有返回值

63、如何判断是函数还是方法？

函数和方法都封装了一些独立的功能，如果在类中定义的函数那就是方法(对象或者类名点方法名调用)，否则就是函数(函数名()直接调用)

64、静态方法和类方法区别？

静态方法：是既不是用类中的属性又不使用对象中的属性，由类或者对象调用的方法，依赖python装饰器@staticmethod来实现

类方法：只使用类中的静态变量，一般都是由类调用，依赖python装饰器@classmethod来实现

65、列举面向对象中的特殊成员以及应用场景？

__call__：对象的构造方法，对象加上()，可以触发这个类的__call__方法。

__len__：内置函数的len函数是依赖类中的__len__方法

__eq__：判断值是否相等的时候依赖__eq__方法

__hash__:判断hash值是否相等的时候依赖__hash__方法(拓展：set的去重机制其实就是根据__hash__和__eq__方法实现的)

__str__：和str() print() %s 都是息息相关的，返回值一定是字符串类型

__repr__：和 repr() %r都是息息相关的，在没有__str__方法时，__repr__可以完全取代__str__。

__del__ 析构方法，对应着一个对象的删除之前执行的内容

66、1、2、3、4、5 能组成多少个互不相同且无重复的三位数

count = 0

for i in range(1,6):

for j in range(1,6):

for k in range(1,6):

if (i != j) and (i != k) and (j != k):

count += 1

if count % 6:

print(f'{i}{j}{k}', end='|')

else:

print(f'{i}{j}{k}')

print(count)

67、什么是反射？以及应用场景？

定义：通过用字符串数据类型的变量名来访问这个变量的值，在python面向对象中的反射,通过字符串的形式操作对象相关的属性或方法.

应用场景：用于处理通过用户输入，文件读取，或者网络传输所得到的字符串形式的指令来完成对应的操作

68、metaclass作用？以及应用场景？

metaclass，直译为元类，简单的解释就是：当我们定义了类以后，就可以根据这个类创建出实例，

所以：先定义类，然后创建实例。但是如果我们想创建出类呢？那就必须根据metaclass创建出类，

所以：先定义metaclass，然后创建类。换句话说，你可以把类看成是metaclass创建出来的“实例”

69、用尽量多的方法实现单例模式。

1、基于__new__()方法

class Person:

def __new__(cls, *args, **kwargs):

if not hasattr(cls,cls._instance):

# cls._instance = object.__new__(cls)

cls._instance = super().__new__(cls)

return cls._instance

2、基于模块导入方式，现在一个py文件中写好一个类，实例化一个对象。以后用这个类直接导入这个模块就是单例模式。

3、基于装饰器方法实现

def singleton(cls, *args, **kwargs):

instance_dic = {}

def inner(*args, **kwargs):

if cls not in instance_dic:

instance_dic['cls'] = cls(*args, **kwargs)

return instance_dic['cls']

return inner

@singleton

class Person:

pass

70、装饰器的写法以及应用场景。

装饰器的写法：

def wrapper(func):

def inner(*args,**kwargs):

'被装饰之前的操作'

ret = func(*args,**kwargs)

'被装饰之后的操作'

return ret

return inner

装饰器的应用场景：

比如注册登录、插入日志，性能测试，事务处理，缓存等等场景

71、异常处理写法以及如何主动跑出异常（应用场景）

异常处理的常规写法：

try:

执行的主体函数

except Exception as e:

print(str(e))

主动抛出异常：

raise TypeError('出现了不可思议的异常')#TypeError可以是任意的错误类

72、什么是面向对象的mro

MRO(Method Resolution Order 方法解析顺序)是面向对象中用于查询类的多继承的继承顺序的方法，它是基于算法来实现的，不同的算法实现的MRO的顺序不同

73、isinstance作用以及应用场景？

isinstance作用是来判断一个对象是否是一个已知的类型

74、写代码并实现：

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,

return [0, 1]

代码实现

def func(li,target):

try:

for i in range(0,len(li)):

num = target-li[i]

if num in li:

return [i,li.index(num)]

except:print('li类型为数组类型，内的元素需是整型，target也为整型，请检查')

else:return None

75、json序列化时，可以处理的数据类型有哪些？如何定制支持datetime类型？

1、可以处理的数据类型是 string、int、list、tuple、dict、bool、null

2、定制支持datetime类型

--------------------------官方文档的memo-----------------------------------------------

>>>import json

>>>class ComplexEncoder(json.JSONEncoder):

... def default(self, obj):

... if isinstance(obj, complex):

... return [obj.real, obj.imag]

... return json.JSONEncoder.default(self, obj)

...

>>>dumps(2 + 1j, cls=ComplexEncoder)

'[2.0, 1.0]'

>>>ComplexEncoder().encode(2 + 1j)

'[2.0, 1.0]'

>>>list(ComplexEncoder().iterencode(2 + 1j))

['[', '2.0', ', ', '1.0', ']']

----------------------------------------------------------------------------------------

import json

import datetime

ret = datetime.datetime.now()

class CJsonEncoder(json.JSONEncoder):

def default(self, obj):

if isinstance(obj, datetime.date):

return obj.strftime('%Y-%m-%d %H:%M:%S')

else:

return json.JSONEncoder.default(self, obj)

print(json.dumps(ret,cls=CJsonEncoder))

76、json序列化时，默认遇到中文会转换成unicode，如果想要保留中文怎么办？

在序列化是将json.dumps中的默认参数ensure_ascii改为False就可以保留中文了

json.dumps(obj,ensure_ascii=False)

77、什么是断言？应用场景？

assert 条件,'自定义错误提示(可有可无)' 例：assert 1 == 0,'这是一个低级的错误'

合约式设计是断言的经典应用，在一个正确的程序里，所有的前置条件和后置条件都将得到处理。

78、使用代码实现查看列举目录下的所有文件。

方法一：递归处理

import os

url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\前段学习'

def check_file(url,li = []):

if os.path.isdir(url):

file_list = os.listdir(url)

for ret in file_list:

base_url = os.path.join(url,ret)

if os.path.isfile(base_url):

li.append(ret)

else: check_file(base_url)

return li

else:return os.path.basename(url)

方法二：堆栈的思想处理

import os

url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\python基础'

lis = [url]

while lis:

url = lis.pop()

ret_list = os.listdir(url)

for name in ret_list:

abs_path = os.path.join(url,name)

if os.path.isdir(abs_path):

lis.append(abs_path)

else:print(name)

79、简述 yield和yield from关键字。

yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器当你调用这个函数的时候，

函数内部的代码并不立马执行，这个函数只是返回一个生成器对象，当你使用for进行迭代的时候，

函数中的代码才会执行

yield from 的主要功能是打开双向通道，把最外层的调用方与最内层的子生成器连接起来，

这样二者可以直接发送和产出值，还可以直接传入异常，而不用在位于中间的协程中添加大量处理异常的样板代码。

有了这个结构，协程可以通过以前不可能的方式委托职责。

更多解析详见：http://blog.gusibi.com/post/python-coroutine-yield-from/

80、代码实现六位随机验证码

import random

s = ''

for i in range(6):

num = random.randint(0,9)

alpha1 = chr(random.randint(65,90))

alpha2 = chr(random.randint(97,122))

ret = random.choice([num,alpha1,alpha2])

s += str(ret)

print(s)

81、代码实现随机发红包功能

import random

def red_packge(money,num):

li = random.sample(range(1,money*100),num-1)

li.extend([0,money*100])

li.sort()

return [(li[index+1]-li[index])/100 for index in range(num)]

ret = red_packge(100,10)

print(ret)

--------------------------生成器版-------------------------------------------

import random

def red_packge(money,num):

li = random.sample(range(1,money100),num-1)

li.extend([0,money100])

li.sort()

for index in range(num):

yield (li[index+1]-li[index])/100

ret = red_packge(100,10)

print(ret)

补充

1、请尽可能列举python列表的成员方法，并给出列表操作的答案：

（1） a=[1, 2, 3, 4, 5], a[::2]=？ a[-2:]=？

a[::2]=[1,3,5],

a[-2:] = [4,5]

（2）一行代码实现对列表a中的偶数位置的元素进行加3后求和？

sum([i+3 for i in a[::2]])

（3）将列表a的元素顺序打乱，再对a进行排序得到列表b，然后把a和b按元素顺序构造一个字典d。

import random

random.shuffle(a)

b=a.sort()

d={}

for i in range(len(a)):d[a[i]] = b[i]

2、 Python自省

自省就是面向对象的语言所写的程序在运行时，就能知道对象的类型。也就是程序运行时能够获得对象的类型。比如type()，dir()，getattr()，hasattr()，isinstance()。

3、Python是如何进行内存管理的？

从三个方面来说,一对象的引用计数机制,二垃圾回收机制,三内存池机制

一、对象的引用计数机制

Python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。

引用计数增加的情况：

1，一个对象分配一个新名称

2，将其放入一个容器中（如列表、元组或字典）

引用计数减少的情况：

1，使用del语句对对象别名显示的销毁

2，引用超出作用域或被重新赋值

sys.getrefcount( )函数可以获得对象的当前引用计数

多数情况下，引用计数比你猜测得要大得多。对于不可变数据（如数字和字符串），解释器会在程序的不同部分共享内存，以便节约内存。

二、垃圾回收

1，当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。

2，当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。

三、内存池机制

Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。

1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。

2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。

3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

4、介绍一下except的用法和作用？

try…except…except…[else…][finally…]

-- 执行try下的语句，如果引发异常，则执行过程会跳到except语句。对每个except分支顺序尝试执行，如果引发的异常与except中的异常组匹配，执行相应的语句。如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。

-- try下的语句正常执行，则执行else块代码。如果发生异常，就不会执行

-- 如果存在finally语句，最后总是会执行。

5、如何用Python来进行查询和替换一个文本字符串？

可以使用re模块中的sub()函数或者subn()函数来进行查询和替换，比replace的功能更强大！！！

格式：sub(replacement, string[,count=0])（replacement是被替换成的文本，string是需要被替换的文本，count是一个可选参数，指最大被替换的数量）

import re

p=re.compile("blue|white|red")

print(p.sub('colour','blue socks and red shoes'))

print(p.sub('colour','blue socks and red shoes',count=1))

subn()方法执行的效果跟sub()一样，不过它会返回一个二维数组，包括替换后的新的字符串和总共替换的数量

6、有没有一个工具可以帮助查找python的bug和进行静态的代码分析？

PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告

Pylint是另外一个工具可以进行codingstandard检查

python基础面试都问什么问题_基本 Python 面试问题相关推荐

面试官问面向对象特点_最好的面试官有什么共同点？
面试官问面向对象特点 by Aline Lerner 通过艾琳·勒纳(Aline Lerner) 最好的面试官有什么共同点? 我们查看了成千上万的真实访谈以找出答案. (What do the bes ...
大厂前端面试都问些什么问题？入职爱奇艺年薪48万，面试经验总结
前言 "金九银十"跳槽季,又到了面试求职的高峰期.好多小伙伴都会跳槽去找工作.如果你不跳槽,也建议把这篇文章看完,毕竟金九银十之后,就是金三银四了,总是逃不掉的? 你在面试的时候, ...
重温Python基础，都是最基础的知识点
前言最近有很多朋友刚接触python学的还是有点模糊还有的朋友就是想重温一下基础内容,毕竟基础不牢地动山摇行吧,就总结了以下的一些知识点,可以都看看哈一.开发环境搭建更多学习资料.点击领取即 ...
python基础-PyCharm设置作者信息模板_修改解释器_设置软件UTF-8编码
python基础-PyCharm设置作者信息模板_修改解释器_设置软件UTF-8编码一.PyCharm 设置作者信息模板 1.File---Settings---在搜索框中搜索:File and C ...
Redis 为什么面试都问我却不懂？因为它快吗？它为什么快？
Redis 为什么面试都问我却不懂?因为它快吗?它为什么快? Redis 已经成为越多越多企业与个人的效率选择文章目录 Redis 为什么面试都问我却不懂?因为它快吗?它为什么快? 一.Redis ...
python基础知识面试题-干货满满--亲身经历的 Python 面试题
写在之前这是首发在我公众号 "Python空间" 的第 2 篇文章. 如果看过我第一篇文章(三个月自学拿到 python 开发 offer!)的朋友可能知道,我来上海一个多星期, ...
python中format函数用法简书_从Python安装到语法基础，这才是初学者都能懂的爬虫教程...
Python和PyCharm的安装:学会Python和PyCharm的安装方法变量和字符串:学会使用变量和字符串的基本用法函数与控制语句:学会Python循环.判断语句.循环语句和函数的使用 Py ...
解析底层原理！月薪20k+的Android面试都问些什么？深夜思考
正文 Android行业主要问题是初级Android太多了,会写xml和Activity的程序员太多了,初中级程序员面临很大的竞争,现状也就偏于高级开发者.越来越多的初中级Android程序员找不到满 ...
腾讯3轮面试都问了Android事件分发，论程序员成长的正确姿势
前言这些题目是网友去美团等一线互联网公司面试被问到的题目.笔者从自身面试经历.各大网络社交技术平台搜集整理而成,熟悉本文中列出的知识点会大大增加通过前两轮技术面试的几率. 主要分为以下几部分: (1 ...

python基础面试都问什么问题_基本 Python 面试问题

python基础面试都问什么问题_基本 Python 面试问题相关推荐

最新文章

热门文章