Python面试题

Python笔试题

选择题

1. Python不支持的数据类型有：（A）

   A、char

   B、int

   C、float

   D、list

2. 下面程序的输出结果为：（D）

   x = "foo"
   y = 2
   print(x + y)
   

   A、foo

   B、foofoo

   C、foo2

   D、TypeError: cannot concatenate 'str' and 'int' objects

3. 关于字符串下列说法错误的是：（B）

   A、字符应该视为长度为1的字符串

   B、字符串以标志字符串的结束

   C、既可以用单引号，也可以用双引号创建字符串

   D、在三引号字符串中可以包含换行回车符等特殊字符

4. 以下不能创建一个字典的语句是：（C）

   A、dict1 = {}

   B、dict2 = {123:345}

   C、dict3 = {[1,2,3]:”uestc”}

   D、dict4 = {(1,2,3):”uestc”}

5. 以下哪一个是不合法的布尔表达式：（B）

   A、item in range(6)

   B、39 = a

   C、r > 5 and 4 == f

   D、(x-6) > 5

6. 已知 x = 43，ch = “A”，y = 1，则表达式 （x>=y and ch or y）的值是：（D）

   A、0

   B、1

   C、True

   D、‘A’

7. 下列Python语句正确的是（多选）：（A、D）

   A、min = x if x<y else y

   B、max = x > y ? x :y

   C、if(x>y) print(x)

   D、while True:pass

8. 若 flag 为int类型，下面while循环执行的次数为：（A）

   flag = 1000
   while flag > 1:
       print(flag)
       flag = flag / 2
   

   A、9

   B、10

   C、50

   D、100

9. 关于Python中的复数，下列说法错误的是：（B）

   A、表示复数的语法是 real+ image j

   B、实部和虚部都是浮点数

   C、虚部后缀必须为 j 且 j 不区分大小写

   D、方法conjugate返回复数的共轭复数

10. 以下叙述正确的是：（B）

    A、continue语句的作用是结束整个循环

    B、只能在循环体内使用break语句

    C、在循环体内使用break语句或continue语句的作用相同

    D、从多层循环嵌套中退出时，只能使用goto语句

11. 下面的语句哪个会无限循环下去：（B）

    A、for a in range(10):

    ​ time.sleep(10)

    B、while 1 < 10:

    ​ time.sleep(10)

    C、a = [3, -1, “,”]

    ​ for u in a[:]:

    ​ if not a:

    ​ break

    D、while True:

    ​ break

12. Python如何定义一个函数：（C）

    A、class<name>(<type> arg1, <type> arg2, <type> argN)

    B、func <name>(arg1, arg2, argN)

    C、def <name>(arg1, arg2, argN)

    D、def <name>(<type> arg1, <type> arg2, <type>argN)

13. 现有代码 d = {}，在Python3解释器中执行 d[([1, 2])] = “b” 得到的结果为：（A）

    A、TypeError: unhashable type: 'list'

    B、{([1, 2]): 'b'}

    C、{(1): 'b'}

    D、以上说法都不对

14. Python3解释器执行 for x in {'a':'b','c':'d'}:print(x) 的结果是什么？（B）

    A、b c

    B、a c

    C、b d

    D、a b

15. Python3解释器执行下面的示例代码后，L2的结果是（C）：

    >>> import copy
    >>> l1 = [1,2,[3,4]]
    >>> L2 = copy.deepcopy(l1)
    >>> l1[2] = 'a'
    >>> L2
    

    A、[1, 2, ['a', 4]]

    B、[1, 2, 'a']

    C、[1, 2, [3, 4]]

问答题

一、list和tuple的区别

list：列表，有序的集合，允许添加不同类型的元素，通过索引访问列表中元素，可变对象。

tuple：元组，类似list，不同之处在于tuple一旦定义后不能改变，不可变对象。常用于返回多个值，即 return (值1, 值2, 值3 ...)，参数的组包拆包

二、__init__与__new__的区别

__init__:

1. 当实例对象创建完成后被调用的，然后设置对象属性的一些初始值，通常用在初始化一个类实例对象的时候，是一个实例方法
2. 有一个参数self,该self参数就是__new__()返回的实例
3. __init__()在__new__()的基础上完成初始化动作，不需要返回值
4. 若__new__()没有正确返回当前类cls的实例，那__init__()将不会被调用
5. 创建的每个实例都有自己的属性，方便类中的实例方法调用

__new__:

1. 在类准备将自身实例化时调用，并且至少需要传递一个参数cls, 此参数在实例化时由python解释器自动提供
2. 始终是类的静态方法，即使没有被加上静态方法装饰器
3. 必须要有返回值，返回实例化出来的实例；在自己实现__new__()时需要注意：可以return父类（通过super(当前类名，cls)）.__new__出来的实例，
   或者直接是object的__new__出来的实例

三、说说你在项目中单例模式的一个使用场景，手写实现一个示例(说明:导包模块的方式除外)

常见的使用场景：数据库建立连接，日志输出，ssh建立连接等等

示例代码1：装饰器方式实现

def Singleton(cls):
 _instance = {}

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

 return _singleton

示例代码2：基于__new__方法实现

class Singleton:  
 _instance = None  
 def __init__(self, name):  
     self.name = name  
 def __new__(cls, *args, **kwargs):  
     # 只有第一次实例化的时候正常执行, 后面每次实例化, 并不真正的创建一个实例  
     if cls._instance is None:  
         # 进行正常的实例化  并把生成的对象存入到instance里面  
         obj = object.__new__(cls)  
         cls._instance = obj  # 把实例化的对象存起来  
     return cls._instance 

四、装饰器模式的应用场景？手写实现一个统计函数运行时间的装饰器函数

• 附加功能
• 日志管理
• 异常捕获
• 输出格式化
• 类型检查
• ...

示例代码：

import time

# 这是装饰函数
def timer(func):
   def wrapper(*args, **kw):
     t1=time.time()
     # 这是函数真正执行的地方
     func(*args, **kw)
     t2=time.time()
     # 计算下时长
     cost_time = t2-t1 
     print("花费时间：{}秒".format(cost_time))
   return wrapper

@timer
def want_sleep(sleep_time):
    time.sleep(sleep_time)

want_sleep(10)

五、工作中使用的单步调试工具是什么？列出你经常使用的命令及对应的说明

• IDE工具自带：Pycharm、Vscode的相关插件等等
• 命令行下面：pdb，使用时 import pdb;pdb.set_trace() 启动程序后进入，或者 python –m pdb 脚本文件名 直接进入调试环境
  • list: 列出当前断点所在代码位置
  • next: 下一步
  • continue: 继续
  • s: 进入函数内部逻辑
  • q: 退出断点调试模式
  • p 变量名: 查看指定变量相关信息

六、re正则模块中search()和match()的区别？

• search()函数会在整个字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
• match()函数只检测字符串开头位置是否匹配，匹配成功才会返回结果，否则返回None

七、列出你所知道的PEP8编码规范，说说你对编码规范的理解

• 每一级缩进使用4个空格
• 所有行限制的最大字符数为79
• 顶层函数和类的定义，前后用两个空行隔开
• 类里的方法定义用一个空行隔开
• 永远不要使用字母‘l’（小写的L），‘O’（大写的O），或者‘I’（大写的I）作为单字符变量名
• 类名一般使用首字母大写的约定
• 函数名应该小写，如果想提高可读性可以用下划线分隔
• 和像None这样的单例对象进行比较的时候应该始终用 is 或者 is not，永远不要用等号运算符
• 使用 is not 运算符，而不是 not … is 。虽然这两种表达式在功能上完全相同，但前者更易于阅读，所以优先考虑
• ...

八、Python中没有switch/case语句，说说你在项目中如何实现类似switch/case的功能

• 可以使用if…elif…elif..else序列来代替switch/case语句，这是大家最容易想到的办法。但是随着分支的增多和修改的频繁，这种代替方式并不很好调试和维护。

• 可以使用字典实现switch/case这种方式易维护，同时也能够减少代码量。如下是使用字典模拟的switch/case实现：

  def num_to_string(num):
      numbers = {
          0 : "zero",
          1 : "one",
          2 : "two",
          3 : "three"
      }
  
      return numbers.get(num)
  
  if __name__ == "__main__":
      print num_to_string(2)
      print num_to_string(5)
  

九、Python如何读取一个10GB大小的的文件BigData.txt，手写代码实现(说明:当前代码运行的机器内存8GB)

示例代码：

def read_file(file_path):
 BLOCK_SIZE = 1024
 with open(file_path, 'rb') as fp:
     while True:
         block = fp.read(BLOCK_SIZE)
         if not block:
             break    
         yield block

十、下面代码的输出结果是什么？

# -*- coding: utf-8 -*-

def num():
    return [lambda x: i*x for i in range(4)]

print([m(2) for m in num()])

输出结果：

[6, 6, 6, 6]

十一、下面代码的输出结果是什么？

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# create time : 2021/9/1 21:01
class Vector2D(object):

    def __init__(self, x, y):
        self.__x = float(x)
        self.__y = float(y)

    @property
    def x(self):
        return self.__x

    @property
    def y(self):
        return self.__y


if __name__ == "__main__":
    v = Vector2D(3, 4)
    print(v.x, v.y)

输出结果：

3.0 4.0

十二、下面代码的输出结果是什么？

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# create time : 2021/9/1 21:01

elements = {i:str(i+3) for i in range(3)}
result = "-".join([element[1] for element in elements.items()])
print(result)

输出结果：

3-4-5

十三、下面代码的输出结果是什么？

# -*- coding: utf-8 -*-


matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]


def matrix_transpose(matrix):
    length = len(matrix)
    for i in range(length):
        for j in range(i):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
    return matrix


if __name__ == '__main__':
    ret = matrix_transpose(matrix)
    print(ret)

输出结果：

[
 [1, 5, 9, 4], 
 [2, 6, 10, 8], 
 [3, 7, 11, 12]
]

十四、下面两个print()分别输出什么？

# -*- coding: utf-8 -*-

a = [1, 2, 3, 4, 5, 6, 7]
b = filter(lambda x: x > 5, a)
print(list(b))

a = map(lambda x: x * 2, [1, 2, 3])
print(list(a))

输出结果：

[6, 7]
[2, 4, 6]

十五、下面代码的输出结果是什么？

# -*- coding: utf-8 -*-

ip2errcode_info = {
    "101.103.112.221": "boot_err01",
    "101.103.112.222": "boot_err01",
    "101.103.112.223": "boot_err02",
}
errcode2ip_info = {v: [k] for k, v in ip2errcode_info.items()}

for ip, err_code in ip2errcode_info.items():
    for code in errcode2ip_info.keys():
        if err_code == code and ip not in errcode2ip_info[err_code]:
            errcode2ip_info[err_code].append(ip)

print(errcode2ip_info)

输出结果:

{
 'boot_err01': ['101.103.112.222', '101.103.112.221'], 
 'boot_err02': ['101.103.112.223']
}