Python面试题（一）

1、为什么学习Python？　

Python是目前市面上，我个人认为是最简洁、最优雅、最有前途、最全能的编程语言，没有之一。

2、通过什么途径学习的Python？

通过自学，包括网上查看一些视频，购买一些相关专业的书籍。

3、Python和Java、PHP、C、C#、C++等其他语言相比？

Python：轻量级、易学、自由/开放源码软件、可移植性、支持面向对象、丰富的库、规范的代码。
Java：优点：开源性，功能强大，库多
         缺点：编译速度 比较慢，不完全
PHP：优点：性能很强，配合简单，稳定，容易部署。
         缺点：函数命名不规范，驼峰法和下划线，传参位置不一。
C：    优点：能操纵底层，能细粒度优化性能。
         缺点：1、是面向过程的，2、运行时类型检查不可用，3、不提供命名空间功能，4、构        
         造函数和析构函数不可用。        
C#：  优点： 强大的.NET Framework托管代码集合类，较简单的语言特性。WEB应用程序    
         开发速度快。
         缺点：底层和高性能不合适，Windows平台以外支持有限。
C++: 优点：性能比较高，可进化型。
         缺点： 难学，门槛高

4、简述解释型和编译型编程语言？

计算机是不能够识别高级语言的，所以当我们运行一个高级语言程序的时候，就需要一个“翻译机”来从事把高级语言转变成计算
机能读懂的机器语言的过程。这个过程分成两类，第一种是编译，第二种是解释。 
编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成集齐语言。运行时就不需要翻译，而直
接执行就可以了，最典型的例子就是C语言。 
解释型语言就没有这个编译过程，而是在程序运行的时候，通过解释器对程序逐行做出解释，然后直接运行，最典型的例子是Ruby。 
通过以上的例子，我们可以来总结一下解释型语言和编译型语言的优缺点，因为编译型语言在程序运行之前就已经对程序做出
了“翻译”，所以在运行时就少掉了“翻译”的过程，所以效率比较高。但是我们也不能一概而论，一些解释型语言也可以通过
解释器的优化来在对程序做出翻译时对整个程序做出优化，从而在效率上超过编译型语言。 

5、Python解释器种类以及特点？　

1、Cpython：最常用的官方版本，使用C语言实现。使用最为广泛。
2、Jpython：Python的Java实现，Jpython会将Python代码动态编译成Java字节码，然后在JVM上运行。
3、IronPython：Python的C#实现，IronPython将Python代码编译成C#字节码，然后再CLR运行（与Jpython类似）
4、PYPY（特殊）： Python实现的Python，将Python的字节码再编译成机器码。

6、位和字节的关系？

1byte等于8bit

7、b、B、KB、MB、GB的关系？

1bytes（B） = 8bits（b）字节
1KB = 1024Bytes = 2的10次方Bytes
1MB = 1024KB = 2的20次方Bytes
1GB = 1024MB = 2的30次方Bytes

8、请至少列举5个PEP8规范（越多越好）

1、缩进，4个空格的缩进（编译器都可以完成此功能），不适用Tab，更不能混合使用Tab和空格
2、每行最大长度为79，换行可以使用反斜杠。最好使用圆括号，换行点再操作符的后边敲回车。
3、不要再一句import中多个库。比如import os，sys（不推荐）
4、模块命名尽量短小，使用全部小写的方式，可以使用下划线。
5、包命名尽量短小，使用全部小写的方式。不可以使用下划线
6、类的命名使用CapWords的方式，模块内部使用的类采用--CapWords的方式。
7、函数命名使用全部小写的方式，可以使用下划线。
8、异常命名使用CapWords+Error后缀的方式。
9、常量命名使用全部大写的方式，可以使用下划线。
10、类的属性（方法和变量）命名使用全部小写的方式，可以使用下划线。
11、类方法第一个参数必须是self，而静态方法第一个参数必须是cls。

9、通过代码实现如下转换：  0b:二进制     0o:八进制     0x:十六进制

二进制转换成十进制：v = “0b1111011”：

先将V变成字符串，然后print(int("0b1111011",2)),结果是123

十进制转换为二进制：v = 18

Print（bin（v））：0b10010

八进制转换为十进制：v = "011"

Print（int（v，8）） 结果是：9

十进制转换成八进制：v = 30

Print（oct（v））结果是：0o36

十六进制转换成十进制：v = ”0x12“

v = "0x12"
s = str(v)
print(int(s,16))
#18

十进制转换成十六进制：v = 87

v = 87
print(hex(v))
#0x57

10、请编写一个函数实现将IP地址转换成一个整数。

如 10.3.9.12 转换规则为：

10   00001010

3    00000011

9    00001001

12   00001100

再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？

def bian(number):
    a = str(bin(number))[2:]
    if len(a) % 8:
        b = ['0' for _ in range(8 - len(a) % 8)]
        b.append(a)
        return ''.join(b)

a = bian(10)
b = bian(10)
c = bian(10)
d = bian(10)

d = int(a + b + c + d, 2)
print(d)
#168430090

11、python递归的最大层数？

def fun(n):
    print(n)
    n += 1
    fun(n)
print(fun(1))

998层，之后就报错了，允许最大数字在3925 - 3929之间浮动 ，和计算机的性能有关系。

12、求结果：

v1 = 1 or 3      1
v2 = 1 and 3     3
v3 = 0 and 2 and 1   0
v4 = 0 and 2 or 1   1
v5 = 0 and 2 or 1 or 4    1
v6 = 0 or Flase and 1    Flase

13、ascii、unicode、utf-8、gbk区别？

Ascii：早期编码，只支持英文字母和一些符号
Unicode：万国码，能表示多种符号，在PY2中可以指定4字节或2字节表示一个字符，PY3中默认4字节
UTF-8: 用最短的方式表示unicode，一个英文字符占一字节
Gbk：中文编码。

14、字节码和机器码的区别？

机器码：是电脑CPU直接读取运行的机器指令，运行速度最快，但是非常难懂，比较难编写，一般人接触不到。
字节码：是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。

15、三元运算规则以应用场景？

一行书中写，代码非常精炼，执行效率更高，可以代替if...else这样的流行语句。

16、列举Python2和Python3的区别?

print：
在PY2中，被视为一个语句，而不是一个函数
在PY3中，被显示为一个函数。
整数的除法：
PY2中，整数是强类型的。比如5/2 结果是2
PY3中，5/2  结果是2.5
Unicode：
PY2中前缀加u代表Unicode。
PY3中默认使用Unicode，如果想让3兼容2，可以通过字符串的前面保留‘u’来实现。
后续发展：
PY3和PY2之间最大的区别不是在语法上，而是事实上PY2在2020年后将失去支持，PY3将继续开发更多的功能，和修复更多的错误。

17、用一行代码实现数值交换：

a = 1
b = 2
a,b = b,a

18、Python3和Python2中int和long的区别？

long整数类型，被PY3废弃，统一使用int。

19、xrange和range的区别？

PY2中的range返回的是列表，xrange返回的是生成器
PY3中的range返回的是迭代器（测试是class）

20、文件操作时：xreadlines和readlines的区别？

返回类型不同。xreadlines返回的是生成器，readlines返回的是列表

21、列举布尔值为False的长简值？

"" , 0, false, [], (), {}

22、字符串、列表、元祖、字典、每个常用的5个方法？

字符串：
.upper()      #首字母大写
.lower()       #所有字母大写
.strip()        #去除首尾空格
.replace()    #替换
.split()        #分割

列表：
.append()    #在列表尾部追加一个值
.insert()        # 指定位置插入数据
.reverse()    #反转
.remove()    #删除制定元素
.pop()         #删除指定元素

元祖：
.index()        #查看元素下标是多少
.len()            #计算元祖元素个数
.min()           #返回元祖中元素最小值
.max()          #返回元祖元素最大值
.tuple()         #将列表转换为元祖

字典：
.clear()         #删除字典所有项
.get()           #获取字典中指定键的值
.keys()         #以列表的形式返回字典中所有键
.values()       #以列表的形式返回字典中所有值
.items()        #以列表的形式返回字典中的键值

23、lambda表达式格式以及应用场景？

lambda x:x + 2
应用场景：函数式编程，闭包

24、pass的作用？

1、空格局。2、保证格式完整性。3、语义完整

25、*arg和**kwarg作用？

*arg：接受额外的位置参数
**kwarg接受额外的关键字参数

26、is和==的区别？

is判断的是ID的地址
==判断的是数值

27、简述Python的深浅拷贝以及应用场景？

浅拷贝：拷贝最外层容器
深拷贝：拷贝的最外层容器，还拷贝容器中的元素
对于不可变元素，使用浅拷贝

28、Python垃圾回收机制？

1、回收计数引用为0的对象，释放其占用空间
2、循环垃圾回收器。释放循环引用对象

29、Python的可变类型和不可变类型？

可变类型：list、dict、set、可变集合
不可变类型：string、int、float、tuple、不可变集合

30、求结果

v = dict.fromkeys(['k1','k2'],[])v[‘k1’].append(666)print(v)v[‘k1’] = 777print(v)

1 、{'k1': [666], 'k2': [666]}
2、{'k1': 777, 'k2': [666]}
3、因为value是可变对象，并且使用append来添加元素，所有value的对象引用不变。

31、求结果

def num():
    return[lambda x:i*x for i in range(4)]
 print([m(2) for m in num()])
#[6,6,6,6]
#将return返回生成器表达式就返回[0,2,4,6]

32、列举常见的内置函数？

len、bin、hex、oct、dir、max、min、type

33、filter、map、reduce的作用？

filter：清晰函数
map：对函数里的每个内容，执行方法
reduce：累加函数
配合lambda函数来进行使用

34、一行代码实现9*9乘法表

print('\n'.join([' '.join([f'{y} * {x} = {x * y}' for y in range(1, x+1)]) for x in range(1,10)]))

35、如何安装第三方模块？以及用过哪些第三方模块？

使用官方推荐的setuptools的包管理工具，easy -- install和pip。
requests模块

36、至少列举8个常用模块都有哪些？

sys:用于提供对解释器相关的访问以及维护，并有很强的交互功能
time： 时间模块
os：用于提供操作系统模块
hashlib：用于加密相关的操作
random：生成随机变量
pickle：用于python特有的类和pthon的数据类型间进行转换
datetime：date和time的结合体
re：正则表达式模块

37、re的match和search区别？

match与search函数功能一样，match匹配字符串开始的第一个位置，search是在字符串全局匹配第一个符合规则的。

38、什么是正则的贪婪匹配？

尽可能的去匹配符合规则的字符，非贪婪模式后面加？（尽可能少的匹配）

39、求结果：

a.[i % 2 for i in range(10)] 
b.(i % 2 for i in range(10))
a = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
b = 是生成器表达式（generator）

40、求结果：

a. 1 or 2    b.  1 and 2      c. 1 < (2 == 2)     d. 1< 2 == 2
a = 1 、 b = 2 、c = false 、d = True

41、def func(a,b=[])这种写法有什么坑？

因为b是可变类型，每次调用这个方法b不会每次都初始化[].而是调用相同的[].

42、如何实现”1，2，3“变成['1', '2', '3']?

a = "1 , 2 ,3"

a. split(",")

43、如何实现['1', '2' , '3']变成[1, 2,, 3]?

a = ["1", "2", "3"]
b = [int(x) for x in a]
print(list(map(lambda x: int(x), a)))

44、比较：a = [1, 2, 3]和b = [(1), (2), (3)]  以及b2 = [(1,), (2,), (3,)]的区别？

1、a和b相同，因为只有一个元素的元祖需要加，来表示（1,）
2、b1表示的列表元素为整数，b2表示的是列表元素是元祖

45、如何用一行代码生成[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]?

print([x ** 2 for x in range(1, 11)])

46、一行代码实现删除列表中重复的值？

使用list（set（））

47、如何在函数中设置一个全部变量？

Global变量名

48、logging模块的作用？以及应用场景？

提供了通用的日志系统。
应用场景，做项目的时候打印日志，或者是异常

49、请用代码简答实现stack

# Stack()：创建一个新的空栈
class Stack():
    def __init__(self):
        self.items = []

    # 判断栈是否为空
    def is_empty(self):
        return self.items == []

    # 添加一个新的元素，item到栈顶
    def push(self, item):
        self.items.append(item)

    # 弹出栈顶元素
    def pop(self):
        return self.items.pop()

    # 返回栈顶元素
    def peek(self):
        return self.items[len(self.items) - 1]

    # 返回栈的元素个数
    def size(self):
        return len(self.items)

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

%、format、f

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

1、生成器是迭代器的一种，需要时yiled关键字
2、迭代器实现了__next__方法
3、可迭代对象实现了__iter__,__next__方法
4、可迭代对象调用__iter__方法后，返回一个迭代器。

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

def search(datset, find_num):
    if len(datset) > 1:
        mid = int(len(datset) / 2)
        if datset[mid] == find_num:
            print(datset[mid])
        elif datset[mid] > find_num:
            return search(datset[0: mid], find_num)
        else:
            return search(datset[mid + 1:], find_num)
    else:
        if datset[0] == find_num:
            print(datset[0])
        else:
            print("不好意思，没有这个数字：", find_num)

search(data, 20)

View Code

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

内层函数引用了外层函数的变量，然后返回内层函数的情况，成为闭包。

54、os和sys模块的作用？

os：系统有关。
sys：解释器有关。

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

使用random模块里的random.random。

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

os.remove(path),删除文件path。如果path是一个目录，抛出osError错误。如果要删除目录，请使用rmdir（）方法。

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

体现在三个方面： 封装、继承、多态
继承有两种方式：
                    1、将同一类的方法封装到类中
                    2、将数据封装到对象中
继承：子类拥有父类的所有方法和属性，
        好处：抽取重复代码，减少代码冗余。
        坏处：耦合性太强。
多态：对于不同的类可以有同名的方法，同名的方法应用到不同的类可以有不同行为。

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

1、在继承中基类的构造（__init__()方法）不会被调用，它需要在其派生类的构造亲自调用，有别于C#.
2、在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量，区别于在类中调用普通函数不需要带上self参数。
3、Python总是首先查找对应类型的方法，如果它不能再派生类中找到对应的方法，它才开始到基类中逐个查找。
4、Python里边可以继承多个类，C#、 Java不可以多继承（如果继承多个类，继承顺序为从左到右）

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

深度优先：不全部保留节点，占用空间小，有回溯操作（即有入栈/出栈操作），运行速度慢。
广度优先：保留全部节点，占用空间大；无回溯操作（既无入栈、出栈操作）、运行速度快。

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

super()函数是用于调用父类的一个方法。用来解决多重继承问题的。

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

用过。
作用：把一个函数的某些参数给固定住，返回一个新的函数，调用这个新函数会更简单。

61、列举面向对象中带双下划线的特殊方法，如：__new__ 、 __init__

__new__：可以调用其它类的构造方法或者直接返回别的对象来作为本类的实例。
__init__： 负责类的实例化
__call__：对象后边加括号，出发执行
__str__：print打印一个对象时。
__doc__：类的注释，该属性是无法继承的。
__getattr__：在使用调用属性（方式、属性）不存在的时候触发
__setattr__：添加/修改属性会触发它的执行
__dellattr__：删除属性的时候会触发
__delete__：采用del删除属性时，触发

View Code

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

函数：是封装了一些独立的功能。可以直接调用，python内置了许多函数，同时可以自建函数来使用。
方法：和函数类似，同样封装了独立的功能，但是方法是需要通过对象来调用的，表示针对这个对象要做的操作。

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

1、静态方法：相当于普通函数
2、类方法：通过类调用，第一个参数默认是类本身。

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

__new__ : 可以调用其他类的构造方法或者直接返回别的对象来作为本类的实例。
__init__ : 负责类的实例化
__call__对象后边加括号，触发执行
__str__ : print打印一个对象时。
__doc__ : 类的注释，该属性是无法继承的。
__getattr__ : 在使用调用属性（方式，属性）不存在的时候触发
__setattr__ : 添加/修改属性会触发它的执行
__dellattr__ : 删除属性的时候会触发
__delete__ : 采用del删除属性时，触发

View Code

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

5*4*3

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

利用字符串获取对象的属性或方法。
web框架的CBV配置文件获取类

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

metaclass是类的产生类，而并非继承类，
通过它来控制类的产生，以及类实例化的操作。Wtform中实例化自定义form类是执行了其元类的__call__方法。

68、用尽量多的方法实现单利模式。

#使用类
class Singleton(object):
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
            return cls._instance

# 使用装饰器
from functools import wraps

def singleton(cls):
    instances = {}

    @wraps(cls)
    def getinstance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
            return instances[cls]

    return getinstance
@singleton
class MyClass(object):
    a = 1

#使用元类
class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
            return cls._instances[cls]
class MyClass(metaclass=Singleton)
    pass

View Code

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

from functools import wraps

def outer(func):
    @wraps(func)
    def inner(*args, **kwargs):
        """我就是装饰器里的函数"""
        func(*args, **kwargs)
        return inner

#应用场景：Django的csrf，缓存，Falsk中的许多装饰器

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

try:
    """执行语句"""
except: #异常类型
    """触发异常后执行的语句"""
finally:
    """有没有异常都执行的语句"""
# 主动抛出异常
raise  #异常类实例

71、什么是面向对象的mro

方法查找的顺序

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

判断一个对象是不是某个类的实例

73、写代码实现：

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]、

nums = [2, 7, 11, 15]

class Solution(object):
    def twoSum(self, nums, target):
        """
        :param nums:  list[int]
        :param target:  int
        :return: List[int]
        """
        if len(nums) <= 1:
            return False
        buff_dict = {}
        for i in range(len(nums)):
            if nums[i] in buff_dict:
                return [buff_dict[nums[i]], i]
            else:
                buff_dict[target - nums[i]] = i

View Code

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

#字符串、字典、列表、数字、布尔值、None、、自定义class类
import json
import datetime

class MyEncoder(json.JSONEncoder):
    def default(self, o):  # o是数据类型
        if isinstance(o, datetime.datetime)
            return o.strftime('%Y-%m-%d')
        else:
            return super(MyEncoder, self).default(o)

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

断言条件为真时，代码继续执行，负责抛出异常，这个异常通常不会去捕获他，我们设置一个断言目的就是要求必须实现某个条件。

76、有用过with statement吗？它的好处是什么?

文件操作时使用过，with语句下代码完成后调用求值语句返回对象的__exit__方法，可以实现一些操作，比如关闭文件。

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

# 递归方法
def print_directory_contents(sPath):
    import os
    for sChild in os.listdir(sPath):
        sChildPath = os.path.join(sPath,sChild)
        if os.path.isdir(sChildPath):
            print_directory_contents(sChildPath)
        else:
            print(sChildPath)

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

yield：生成器函数关键字
yield from：相当于 for i in obj ： yield i

79、Tornado 的核是什么 。

Tornado 的核心是 ioloop 和 iostream 这两个模块，前者提供了一个高效的I/O事件循环，后者则封装了 一个无阻塞的 socket 。
通过向 ioloop 中添加网络 I/O 事件，利用无阻塞的 socket ，再搭配相应的回调 函数，便可达到梦寐以求的高效异步执行。

 

 参考：https://www.cnblogs.com/chengdajing/p/9250400.html

 更多：https://www.cnblogs.com/yujianbao/p/6911275.html