脚本宝典收集整理的这篇文章主要介绍了Python 面试题整理，脚本宝典觉得挺不错的，现在分享给大家，也给大家做个参考。

一、语言特性

1、什么是Python？使用Python有什么好处？Python和其他语言的区别？

Python是一种编程语言，它有对象，模块，线程，异常处理和自动内存管理。

好处：开源、简洁、简单、方便、容易扩展、有许多自带的数据结构

2、什么是PEP8？

PEP8是一个编程规范，Python遵从该规范。比如缩进，模块导入顺序（标准，三方，自定义），注释，命名规范

3、Python是如何被解释的？

Python是一种解释性语言，它的源代码可以直接运行。python解释器会将源代码转换成中间语言，之后再翻译成机器码再执行

4、Python是怎样管理内存的？

Python的内存管理是由私有heap空间管理的，分配内存是由Python的内存管理模块进行的。

所有的Python对象和数据结构都在一个私有heap中。程序员没有访问该heap的权限，只有解释器才能对它进行操作。

Python有自带的垃圾回收系统，它回收并释放没有被使用的内存，让它们能够被其他程序使用

5、Python中的命名空间是什么？

命名空间是一个命名系统，用于确保名称是唯一性，以避免命名冲突。

6、Python的主要功能是什么？

Python是一种解释型语言。与c语言等语言不同，Python不需要在运行之前进行编译。

Python是动态语言，当您声明变量或类似变量时，您不需要声明变量的类型。

Python适合面向对象的编程，因为它允许类的定义以及组合和继承。Python没有访问说明（如C ++的public，PRivate）。

在Python中，函数是第一类对象。它们可以分配给变量。类也是第一类对象

编写Python代码很快，但运行比较慢。Python允许基于C的扩展，例如numpy函数库。

Python可用于许多领域。Web应用程序开发，自动化，数学建模，大数据应用程序等等。它也经常被用作“胶水”代码。

7、如何在Python中管理内存？

python中的内存管理由Python私有堆空间管理。所有Python对象和数据结构都位于私有堆中。程序员无权访问此私有堆。python解释器负责处理这个问题。

Python对象的堆空间分配由Python的内存管理器完成。核心API提供了一些程序员编写代码的工具。

Python还有一个内置的垃圾收集器，它可以回收所有未使用的内存，并使其可用于堆空间。

8、当Python退出时，为什么不清除所有分配的内存？

当Python退出时，尤其是那些对其他对象具有循环引用的Python模块或者从全局名称空间引用的对象并没有被解除分配或释放。

无法解除分配C库保留的那些内存部分。

退出时，由于拥有自己的高效清理机制，Python会尝试取消分配/销毁其他所有对象。

9、Python中是否需要缩进？

缩进是Python必需的

10、python是否区分大小写？

是。Python是一种区分大小写的语言。

11、如何在python中写注释？

Python中的注释以＃字符开头。也可以使用doc-strings（三重引号中包含的字符串-多用于多行注释）进行注释。

二、数据类型

1、python内建数据类型有哪些

整型(int),布尔型(bool),字符串(str),列表(list),元组(tuple),字典(dict)

2、Python都有那些自带的数据结构？

Python自带的数据结构分为可变的和不可变的。

可变的有：数组、集合、字典；

不可变的有：字符串、元组、数。

3、什么是Python中的类型转换？

类型转换是指将一种数据类型转换为另一种数据类型。

int()--将任何数据类型转换为整数类型

float()--将任何数据类型转换为float类型

ord()--将字符转换为整数

hex()--将整数转换为十六进制

oct()--将整数转换为八进制

tuple()--此函数用于转换为元组。

set()--此函数在转换为set后返回类型。

list()--此函数用于将任何数据类型转换为列表类型。

dict()--此函数用于将顺序元组（键，值）转换为字典。

str()--用于将整数转换为字符串。

complex(real，imag)--此函数将实数转换为复数（实数，图像）数。

4、Python数组和列表有什么区别？

Python中的数组和列表具有相同的存储数据方式。但是，数组只能包含单个数据类型元素，而列表可以包含任何数据类型元素。

5、如何在python中使用三元运算符？

三元运算符是用于显示条件语句的运算符。这包含true或false值。

三、容器(列表 字典 元组 集合)

1、字典推导式和列表推导式是什么？

推导式是一种可以轻松创建字典和列表的语法结构

2、数组和元组之间的区别是什么？

数组内容是可以被修改的

元组内容是只读的

3、Python中的字典是什么？

Python中的内置数据类型称为字典。它定义了键和值之间的一对一关系。字典包含一对键及其对应的值。字典由键索引。

4、如何将值添加到python数组？

可以使用append()，extend()和insert(i，x)函数将元素添加到数组中。

5、如何删除python数组的值？

可以使用pop()或remove()方法删除数组元素。这两个函数之间的区别在于前者返回已删除的值，而后者则不返回。

6、python2和python3的range(100)的区别

python2返回列表，python3返回迭代器，节约内存。

7、字典如何删除键和合并两个字典

del和update方法

四、字符串（☆☆☆☆☆）

1、如何在Python中随机化列表中的元素

使用shuffle函数进行随机列表元素

2、如何反转数组或序列的顺序

[:: -1]

3、避免转义给字符串加哪个字母表示原始字符串？

r , 表示需要原始字符串，不转义特殊字符。

4、sort和sorted的区别是什么？

sort是在本来list的基础上修改，无返回值；sorted 有返回值是新的list。

5、常见的函数

upper()字母变为大写

lower()字母变成小写

strip()去掉末尾的空格

6、len()函数有什么作用？

len()函数可用于确定字符串，列表，数组等的长度。

7、is、not和in各有什么功能？

is：当2个操作数为true时返回true（例如：“a”是'a'）

not：返回布尔值的倒数

in：检查某个元素是否存在于某个序列中

8、splIT()，sub()，subn()的定义

如果要修改字符串，Python的“re”模块提供了3种方法。他们是：

split() - 使用正则表达式模式将给定字符串“拆分”到列表中。

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

subn() - 它类似于sub()，并且还返回新字符串。

9、如何把字符串的第一个字母大写？

在Python中，capitalize()函数可以将字符串的第一个字母大写。如果字符串在开头已经包含大写字母，那么它将返回原始字符串。

10、如何将字符串转换为全小写？

要将字符串转换为小写，可以使用lower()函数。

11、什么是pickling和unpickling？

Pickle模块接受任何Python对象并将其转换为字符串表示形式，并使用dump函数将其转储到文件中，此过程称为pickling。从存储的字符串中检索原始Python对象的过程称为unpickling。

12、一行代码实现1--100之和

# sum()函数求和 
sum(range(1, 101)

13、字符串的查询替换

# python的find和replace函数
string = 'life is short, I use python'
# 返回的为0或正数时，为其索引号
>>> string.find('life')
string.replace('short','long')
# replace 将short替换为long
>>> life is long, I use python

14、s = "ajldjlajfdljfddd"，去重并从小到大排序输出"aDFjl" set去重，去重转成list,利用sort方法排序，reeverse=False是从小到大排

s = "ajldjlajfdljfddd"
s = set(s)
s = list(s)
s.sort(reverse=False)
res = ''.join(s)
print(res)

15、字典根据键从小到大排序

dic = {"name": "zs", "age": 18, "city": "深圳", "tel": "1362626627"}
lis = sorted(dic.items(), key=lambda i: i[0], reverse=False)
print(lis)

16、利用collections库的Counter方法统计字符串每个单词出现的次数"kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"

From collections import Counter

a = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
res = Counter(a)
print(res)

17、字符串a = "not 404 found 张三 99 深圳"，每个词中间是空格，用正则过滤掉英文和数字，最终输出"张三 深圳"

import re

a = "not 404 found 张三 99 深圳"
list = a.split(" ")
print(list)
res = re.findall('d+|[a-zA-Z]+', a)
for i in res:
    if i in list:
        list.remove(i)
new_str = " ".join(list)
print(res)
print(new_str)

18、filter方法求出列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def fn(a):
    return a % 2 == 1

newlist = filter(fn, a)
newlist = [i for i in newlist]
print(newlist)

19、列表推导式求列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

res = [i for i in a if i % 2 == 1]

20、两个列表[1,5,7,9]和[2,2,6,8]合并为[1,2,2,3,6,7,8,9]

list1 = [1, 5, 7, 9]
list2 = [2, 2, 6, 8]
list1.extend(list2)
print(list1)
list1.sort(reverse=False)
print(list1)

21、给定一串排好序的列表，打乱这个函数?

# random模块中的shuffle(洗牌函数)  
import random

list = [1, 2, 3, 4]
random.shuffle(list)
print(list)

22、list=[2,3,5,4,9,6]，从小到大排序，不许用sort，输出[2,3,4,5,6,9]

list = [2, 3, 5, 4, 9, 6]
new_list = []


def get_min(list):
    a = min(list)
    list.remove(a)
    new_list.append(a)
    if len(list) > 0:
        get_min(list)
    return new_list


new_list = get_min(list)
print(new_list)

23、给定一串字典(或列表),找出指定的（前N个）最大值？最小值？

# python内的heapq模块的nlargest() 和 nsmallest()
import heapq
portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}
]
# 参数3为最大的3个值(最小的3个值)，对每个元素进行对比的时候，会以price的值进行比较。
cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])

24、使用字符串拼接达到字幕滚动效果？

import os
import time

def main():
    content = '曹查理的python面试集-基础篇'
    while True:
        # 清理屏幕上的输出
        os.System('cls')  # os.system('clear')
        print(content)
        # 休眠200毫秒
        time.sleep(0.2)
        content = content[1:] + content[0]


if __name__ == '__main__':
    main()

25、对list排序foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4],使用lambda函数从小到大排序

foo = [-5, 8, 0, 4, 9, -4, -20, -2, 8, 2, -4]
a = sorted(foo, key=lambda x: x)
print(a)

26、使用lambda函数对list排序foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]，输出结果为[0,2,4,8,8,9,-2,-4,-4,-5,-20]，正数从小到大，负数从大到小】（传两个条件，x<0和abs(x)）

foo = [-5, 8, 0, 4, 9, -4, -20, -2, 8, 2, -4]
a = sorted(foo, key=lambda x: (x < 0, abs(x)))
print(a)

27、列表嵌套字典的排序，分别根据年龄和姓名排序

foo = [{"name": "zs", "age": 19}, {"name": "ll", "age": 54}, {"name": "wa", "age": 17}, {"name": "df", "age": 23}]
age = sorted(foo, key=lambda x: x['age'], reverse=True)
name = sorted(foo, key=lambda x: x['age'])
print(age)
print(name)

28、列表嵌套元组，分别按字母和数字排序

foo = [("zs", 19), ("ll", 54), ("wa", 17), ("df", 23)]
letter = sorted(foo, key=lambda x: x[1], reverse=True)
num = sorted(foo, key=lambda x: x[0])
print(letter)
print(num)

29、列表嵌套列表排序，年龄数字相同怎么办？

foo = [["zs", 19], ["ll", 54], ["wa", 17], ["df", 23], ["xf", 23]]
letter = sorted(foo, key=lambda x: (x[1], x[0]))
num = sorted(foo, key=lambda x: x[0])
print(letter)
print(num)

30、根据键对字典排序（方法一，zip函数）

dic = {"name": 'zs', 'sex': 'man', 'city': 'bj'}
foo = zip(dic.keys(), dic.values())
foo = [i for i in foo]
print('字典转成列表嵌套元组', foo)
boo = sorted(foo, key=lambda x: x[0])
print('字典嵌套元组排序，根据键排序', boo)
new_dict = {i[0]: i[1] for i in boo}
print('字典推导式构造新字典', new_dict)

31、根据键对字典排序（方法二，不用zip)

dic = {"name": 'zs', 'sex': 'man', 'city': 'bj'}
print(dic.items())
boo = sorted(dic.items(), key=lambda x: x[0])
print("根据键排序", boo)
new_dict = {i[0]: i[1] for i in boo}
print('字典推导式构造新字典', new_dict)

32、列表推导式、字典推导式、生成器

import random

td_list = [i for i in range(10)]
print("列表推导式", td_list, type(td_list))
ge_list = (i for i in range(10))
print("生成器", ge_list)
dic = {k: random.randint(4, 9) for k in ['a', 'b', 'c', 'd']}
print("字典推导式", dic, type(dic))

33、根据字符串长度排序，看排序是否灵活运用

s = ['ab', 'abc', 'a', 'djkl']
b = sorted(s, key=lambda x: len(x))
print(b, s)
s.sort(key=len)
print(s)

34、s="info:xiaoZhang 33 shandong",用正则切分字符串输出['info', 'xiaoZhang', '33', 'shandong']

import re

s = "info:xiaoZhang 33 shandong"
res = re.split(r":| ", s)
print(res)

35、用两种方法去空格

str = 'hello world ha ha'
res = str.replace(' ', '')
print(res)

list = str.split(' ')
res = "".join(list)
print(res)

五、函数&amp;面向对象

1、Python中的函数是什么？

函数是一个代码块，只有在被调用时才会执行。要在Python中定义函数，需要使用def关键字。

2、什么是__init__?

__init__是Python中的方法或者结构。在创建类的新对象/实例时，将自动调用此方法来分配内存。所有类都有__init__方法。

3、简述面向对象中__new__和__init__区别

① __init__是初始化方法，创建对象后，就立刻被默认调用了，可接收参数

② __new__至少要有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别。

③ __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类（通过super(当前类名, cls)）__new__出来的实例，或者直接是object的__new__出来的实例。

④ __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值。

⑤ 如果__new__创建的是当前类的实例，会自动调用__init__函数，通过return语句里面调用的__new__函数的第一个参数是cls来保证是当前类实例，如果是其他类的类名，；那么实际创建返回的就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数。

4、类的初始化：new() 和 init()?

new()方法用来实例化最终的类对象，在类创建之前被调用，它在类的主体被执行完后开始执行。

init()方法是在类被创建之后被调用，用来执行其他的一些输出化工作

当我们构造元类的时候，通常只需要定一个init()或new()方法，但不是两个都定义。但是，如果需要接受其他的关键词参数的话，这两个方法就要同时提供，并且都要提供对应的参数签名。

5、列出几种魔法方法并简要介绍用途

__init__:对象初始化方法

__new__:创建对象时候执行的方法，单列模式会用到

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

__del__:删除对象执行的方法

6、什么是lambda函数？

lambda函数也叫匿名函数，该函数可以包含任意数量的参数，但只能有一个执行操作的语句。

7、用lambda函数实现两个数相乘

sum=lambda a,b:a*b
print(sum(2,3))

8、Python中的self是什么？

self是类的实例或对象。在Python中，self包含在第一个参数中。但是，Java中的情况并非如此，它是可选的。它有助于区分具有局部变量的类的方法和属性。init方法中的self变量引用新创建的对象，而在其他方法中，它引用其方法被调用的对象。

9、Python中的局部变量和全局变量是什么？

全局变量：在函数外或全局空间中声明的变量称为全局变量。这些变量可以由程序中的任何函数访问。

局部变量：在函数内声明的任何变量都称为局部变量。此变量存在于局部空间中，而不是全局空间中。

10、如何在一个函数内部修改全局变量

函数内部global声明 修改全局变量

11、fun(*args,**kwargs)中的*args,**kwargs什么意思？

*args,**kwargs主要用于函数定义，可以将不定量的参数传递给一个函数，这里的不定意思是预先并不知道函数使用者会传递几个参数，*args是用来发送一个非键值对的可变数量的参数列表给一个函数。**kwargs允许你将不定长的键值对，作为参数传递给一个函数，如果你想在一个函数里处理带名字的参数，应该使用**kwargs。

12、Python中help()和dir()函数的用法是什么？

Help()和dir()这两个函数都可以从Python解释器直接访问，并用于查看内置函数的合并转储。

help()函数：help()函数用于显示文档字符串，还可以查看与模块，关键字，属性等相关的使用信息。

dir()函数：dir()函数用于显示定义的符号

13、区分break，continue和pass？

Break 跳出并结束当前整个循环 执行循环后的语句

Continue 结束档次循环 继续执行后续次数循环

Break continue 可以与 for 和 while 搭配使用

pass:该语句什么也不做 是为了保持程序结构的完整性。常用在语法上需要一条语句但是不需要任何操作的情况。

14、举例说明异常模块中try except else finally的相关意义

try..except..else没有捕获到异常，执行else语句。

try..except..finally不管是否捕获到异常，都执行finally语句。

15、IOError、AttributeError、ImportError、IndentationError、IndexError、KeyError、SyntaxError、NameError分别代表什么异常

IOError：输入输出异常

AttributeError：试图访问一个对象没有的属性

ImportError：无法引入模块或包，基本是路径问题

IndentationError：语法错误，代码没有正确的对齐

IndexError：下标索引超出序列边界

KeyError：试图访问你字典里不存在的键

SyntaxError：Python代码逻辑语法出错，不能执行

NameError：使用一个还未赋予对象的变量

16、python中断言方法举例

assert（）方法，断言成功，则程序继续执行，断言失败，则程序报错。

17、python的面向对象？

类是对象的蓝图和模板，而对象是类的实例。类是抽象的概念，而对象是具体的东西。在面向对象编程的世界中，一切皆为对象，对象都有属性和行为，每个对象都是独一无二的，而且对象一定属于某个类（型）。当我们把一大堆拥有共同特征的对象的静态特征（属性）和动态特征（行为）都抽取出来后，就可以定义出一个叫做“类”的东西。面向对象有三大支柱：封装、继承和多态。

18、什么是python迭代器？

迭代器是可以遍历或迭代的对象

19、什么是生成器？

返回可迭代项集的函数称为生成器。

20、装饰器？

装饰器是一个函数，接收一个函数返回另一个函数。

函数可以作为参数传递的语言，可以使用装饰器。

21、深拷贝和浅拷贝有什么区别？

在创建新实例类型时使用浅拷贝，并保留在新实例中复制的值。浅拷贝用于复制引用指针，就像复制值一样。这些引用指向原始对象，并且在类的任何成员中所做的更改也将影响它的原始副本。浅拷贝允许更快地执行程序，它取决于所使用的数据的大小。

深拷贝用于存储已复制的值。深拷贝不会将引用指针复制到对象。它引用一个对象，并存储一些其他对象指向的新对象。原始副本中所做的更改不会影响使用该对象的任何其他副本。由于为每个被调用的对象创建了某些副本，因此深拷贝会使程序的执行速度变慢。

浅拷贝没有拷贝子对象，所以原对象发生改变，其子对象也发生了改变，而深拷贝拷贝了子对象，原对象发生改变，其本身也不会改变。

22、多线程？

多线程可以共享进程的内存空间，因此要实现多个线程之间的通信相对简单，比如设置一个全局变量，多个线程共享这个全局变量。但是当多个线程共享一个资源的时候，可能导致程序失效甚至崩溃，如果一个资源被多个线程竞争使用，那么对临界资源的访问需要加上保护，否则会处于“混乱”状态，比如银行存100块钱，最终很可能存不到一百块多个线程得到的余额状态都是0，所有操作都是在0上面加1，从而导致错误结果。这种情况下，锁就可以得到用处了。多线程并不能发挥cpu多核特性，因为python解释器有一个gil锁，任何线程执行前必须获得GIL锁，然后每执行100条字节码，解释器就会自动释放GIL锁让别的线程有机会执行。

23、如何在Python中实现多线程？

Python有一个多线程库，但是用多线程来加速代码的效果并不是那么的好，

Python有一个名为Global Interpreter Lock（GIL）的结构。GIL确保每次只能执行一个“线程”。一个线程获取GIL执行相关操作，然后将GIL传递到下一个线程。

虽然看起来程序被多线程并行执行，但它们实际上只是轮流使用相同的CPU核心。

所有这些GIL传递都增加了执行的开销。这意味着多线程并不能让程序运行的更快。

24、python内存管理？

python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数，当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收。所有这些都是自动完成，不需要像C一样，人工干预，从而提高了程序员的效率和程序的健壮性。

25、什么是PYTHONPATH？

它是导入模块时使用的环境变量。每当导入模块时，也会查找PYTHONPATH以检查各个目录中是否存在导入的模块。解释器使用它来确定要加载的模块。

26、range＆xrange有什么区别？

在大多数情况下，xrange和range在功能方面完全相同。它们都提供了一种生成整数列表的方法，唯一的区别是range返回一个Python列表对象，x range返回一个xrange对象。这就表示xrange实际上在运行时并不是生成静态列表。它使用称为yielding的特殊技术根据需要创建值。该技术与一种称为生成器的对象一起使用。因此如果你有一个非常巨大的列表，那么就要考虑xrange。

27、提高python运行效率的方法

① 使用生成器，因为可以节约大量内存

② 循环代码优化，避免过多重复代码的执行

③ 核心模块用Cython PyPy等，提高效率

④ 多进程、多线程、协程

⑤ 多个if elif条件判断，可以把最有可能先发生的条件放到前面写，这样可以减少程序判断的次数，提高效率

28、python实现单例模式？

# 方法1,实现__new__方法
# 并在将一个类的实例绑定到类变量_instance上,
# 如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回
# 如果cls._instance不为None,直接返回cls._instance
class Singleton(object):
    def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            orig = super(Singleton, cls)
            cls._instance = orig.__new__(cls, *args, **kw)
        return cls._instance


class MyClass(Singleton):
    a = 1


one = MyClass()
two = MyClass()

two.a = 3
print(one.a)  # 3
# one和two完全相同,可以用id(), ==, is检测
print(id(one))  # 29097904
print(id(two))  # 29097904
print(one == two)  # True
print(one is two)  # True
print('--------------------------------------')


# 方法2,共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法)
# 同一个类的所有实例天然拥有相同的行为(方法),
# 只需要保证同一个类的所有实例具有相同的状态(属性)即可
# 所有实例共享属性的最简单最直接的方法就是__dict__属性指向(引用)同一个字典(dict)
# 可参看:http://code.activestate.COM/recipes/66531/
class Borg(object):
    _state = {}

    def __new__(cls, *args, **kw):
        ob = super(Borg, cls).__new__(cls, *args, **kw)
        ob.__dict__ = cls._state
        return ob


class MyClass2(Borg):
    a = 1


one = MyClass2()
two = MyClass2()

# one和two是两个不同的对象,id, ==, is对比结果可看出
two.a = 3
print(one.a)  # 3
print(id(one))  # 28873680
print(id(two))  # 28873712
print(one == two)  # False
print(one is two)  # False
# 但是one和two具有相同的（同一个__dict__属性）,见:
print(id(one.__dict__))  # 30104000
print(id(two.__dict__))  # 30104000

print('--------------------------------------')


# 方法3:也是方法1的升级（高级）版本,
# 使用装饰器(decorator),
# 这是一种更pythonic,更elegant的方法,
# 单例类本身根本不知道自己是单例的,因为他本身(自己的代码)并不是单例的
def singleton(cls, *args, **kw):
    instances = {}

    def _singleton():
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]

    return _singleton


@singleton
class MyClass4(object):
    a = 1

    def __init__(self, x=0):
        self.x = x


one = MyClass4()
two = MyClass4()

two.a = 3
print(one.a)  # 3
print(id(one))  # 29660784
print(id(two))  # 29660784
print(one == two)  # True
print(one is two)  # True
one.x = 1
print(one.x)  # 1
print(two.x)  # 1

29、设计一个函数返回给定文件名的后缀?

def get_suffix(filename, has_dot=False):
    """
    获取文件名的后缀名

    :param filename: 文件名
    :param has_dot: 返回的后缀名是否需要带点

    :return: 文件的后缀名
    """
    pos = filename.rfind('.')
    if 0 < pos < len(filename) - 1:
        index = pos if has_dot else pos + 1
        return filename[index:]
    else:
        return ''

30、写一段自定义异常代码

def fn():
    try:
        for i in range(5):
            if i > 2:
                raise Exception("数字大于2")
    except Exception as ret:
        print(ret)
fn()

31、简述多线程、多进程

① 进程：

• • 操作系统进行资源分配和调度的基本单位，多个进程之间相互独立。
  • 稳定性好，如果一个进程崩溃，不影响其他进程，但是进程消耗资源大，开启的进程数量有限制。

② 线程：

• • CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能独立运行的基本单位，一个进程下的多个线程可以共享该进程的所有资源。
  • 如果IO操作密集，则可以多线程运行效率高，缺点是如果一个线程崩溃，都会造成进程的崩溃。

③ 应用：

• • IO密集的用多线程，在用户输入，sleep 时候，可以切换到其他线程执行，减少等待的时间。
  • CPU密集的用多进程，因为假如IO操作少，用多线程的话，因为线程共享一个全局解释器锁，当前运行的线程会霸占GIL，其他线程没有GIL，就不能充分利用多核CPU的优势。

六、模块／包／正则．．．

1、什么是python模块？Python中有哪些常用的内置模块？

Python模块是包含Python代码的.py文件。此代码可以是函数类或变量。一些常用的内置模块包括：sys、math、random、data time、JSON。

2、什么是Python包？

Python包是包含多个模块的命名空间

3、python的seArch和match的区别?

search和match都在re模块中，match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None。search匹配整个字符串，直到找到一个匹配。

4、正则表达式匹配中，（.*）和（.*?）匹配区别？

（.*）是贪婪匹配，会把满足正则的尽可能多的往后匹配

（.*?）是非贪婪匹配，会把满足正则的尽可能少匹配

5、正则匹配不是以4和7结尾的手机号

re.match("1d{9}[0-3,5-6,8-9]", tel)

6、正则匹配中文

re.compile(r'[u4e00-u9fa5]+')

7、python的filter方法？

filter就像map,reduce,apply,zip等都是内置函数，用C语言实现，具有速度快，功能强大等 优点。

用于过滤与函数func()不匹配的值, 类似于SQL中select value != ‘a’

相当于一个迭代器，调用一个布尔函数func来迭代seq中的每个元素，返回一个是bool_seq返 回为True的序列

第一个参数: function or None, 函数或None

第二个参数: sequence,序列

8、python字典和json字符串相互转化方法

json.dumps()字典转json字符串，json.loads()json转字典

9、列出5个python标准库

os：提供了不少与操作系统相关联的函数

sys：通常用于命令行参数

re：正则匹配

math：数学运算

datetime：处理日期时间

10、简述with方法打开处理文件帮我我们做了什么？

with方法帮我们实现了finally中f.close

11、LOG日志中，我们需要用时间戳记录error,warning等的发生时间，请用datetime模块打印当前时间戳 “2018-04-01 11:38:54”，顺便把星期的代码也贴上。

import datetime

a = str(datetime.datetime.now().strftime('%y-%m-%d %H:%M:%S')) + ' 星期' + str(datetime.datetime.now().isoweekday())
print(a)

12、如何在Python中删除文件？

要在Python中删除文件，您需要导入OS模块。之后，您需要使用Os.remove()函数。

13、如何在Python中生成随机数？

random模块是用于生成随机数的标准模块

randrange(a,b)：它选择一个整数并定义[a，b]之间的范围。它通过从指定范围中随机选择元素来返回元素。它不构建范围对象。

uniform(a,b)：它选择一个在[a，b)范围内定义的浮点数

normalVARiate(mean,sdev)：它用于正态分布，其中mean是平均值，sdev是用于标准偏差的sigma。

使用和实例化的Random类创建一个独立的多个随机数生成器。

14、python垃圾回收机制

python垃圾回收主要以引用计数为主，标记-清除和分代清除为辅的机制，其中标记-清除和分代回收主要是为了处理循环引用的难题。

引用计数算法

当有1个变量保存了对象的引用时，此对象的引用计数就会加1；

当使用del删除变量指向的对象时，如果对象的引用计数不为1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除。

脚本宝典总结

以上是脚本宝典为你收集整理的Python 面试题整理全部内容，希望文章能够帮你解决Python 面试题整理所遇到的问题。

如果觉得脚本宝典网站内容还不错，欢迎将脚本宝典推荐好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。