Python最佳面试题合集：哪些问题最常遇到？

Python简介：

Python由 Guido van Rossum 开发并于 1991 年 2 月 20 日首次发布。它是最广泛使用和喜爱的编程语言之一，本质上是解释性的，因此提供了合并动态语义的灵活性。它也是一种免费的开源语言，具有非常简单和干净的语法。这使开发人员可以轻松学习 Python。Python 还支持面向对象的编程，并且最常用于执行通用编程。 

由于其简单的特性以及用更少的代码行实现多种功能的能力，python 的流行度正在大幅增长。Python 还用于机器学习、人工智能、Web 开发、Web 抓取和各种其他领域，因为它能够使用强大的库支持强大的计算。因此，印度和世界各地对 Python 开发人员的需求巨大。公司愿意为这些开发人员提供惊人的福利和福利。 

在本Python最佳面试题合集中，我们将看到最常见的 Python 面试问题和答案，它们将帮助你脱颖而出并获得惊人的工作机会。

我们将它们分为以下几个部分：

• 新生 Python 面试题
• 有经验的 Python 面试题
• Python OOPS 面试题
• Python Pandas 面试题
• Numpy 面试问题
• Python 库面试问题
• Python 编程示例

基础：Python常见面试题有哪些

1.什么是Python？

Python 是一种高级的、解释性的、通用的编程语言。作为一种通用语言，它可用于使用正确的工具/库构建几乎任何类型的应用程序。此外，python 支持对象、模块、线程、异常处理和自动内存管理，这有助于对现实世界的问题进行建模并构建应用程序来解决这些问题。

2、使用Python有什么好处？

• Python 是一种通用编程语言，其语法简单易学，强调可读性，因此降低了程序维护成本。此外，该语言能够编写脚本，完全开源，并支持鼓励模块化和代码重用的第三方包。
• 其高级数据结构与动态类型和动态绑定相结合，吸引了庞大的开发人员社区进行快速应用程序开发和部署。

3. 什么是动态类型语言？

Python面试题解析：在了解动态类型语言之前，我们应该了解什么是类型。打字是指编程语言中的类型检查。在强类型语言（如 Python）中，“1”+2将导致类型错误，因为这些语言不允许“类型强制”（数据类型的隐式转换）。另一方面，弱类型语言，例如 Javascript，将简单地输出“12”作为结果。

类型检查可以在两个阶段完成 -

• 静态- 在执行之前检查数据类型。
• 动态- 在执行期间检查数据类型。

Python 是一种解释型语言，它逐行执行每个语句，因此在执行期间即时完成类型检查。因此，Python 是一种动态类型语言。

4. 什么是解释语言？

解释型语言逐行执行其语句。Python、Javascript、R、PHP 和 Ruby 等语言是解释型语言的主要示例。用解释语言编写的程序直接从源代码运行，没有中间编译步骤。

5. 什么是 PEP 8，它为什么重要？

PEP 代表Python Enhancement Proposal。PEP 是官方设计文档，为 Python 社区提供信息，或描述 Python 或其进程的新功能。PEP 8特别重要，因为它记录了 Python 代码的风格指南。显然，为 Python 开源社区做出贡献需要你真诚而严格地遵循这些风格指南。

6. Python 中的作用域是什么？

Python 中的每个对象都在一个范围内起作用。作用域是一个代码块，其中 Python 中的对象保持相关。命名空间唯一标识程序内的所有对象。但是，这些命名空间也为它们定义了一个范围，你可以在其中使用它们的对象而无需任何前缀。在 Python 中执行代码期间创建的范围的一些示例如下：

• 一个本地范围是指在当前函数可用的本地对象。
• 一个全局范围是指提供整个代码执行自成立以来的对象。
• 一个模块级范围是指在程序访问当前模块的全局对象。
• 一个最外面的范围是指所有内置在程序中调用的名称。最后搜索此范围内的对象以查找引用的名称。

注：本地范围对象可以与诸如使用关键字全球范围内的对象进行同步全球。

7. 什么是列表和元组？两者之间的主要区别是什么？

列表和元组都是可以在 Python 中存储对象集合的序列数据类型。存储在两个序列中的对象可以具有不同的数据类型。列表用方括号 表示['sara', 6, 0.19]，而元组用括号 表示('ansh', 5, 0.97)。
但两者之间的真正区别是什么？两者之间的主要区别在于，虽然列表是可变的，但另一方面，元组是不可变的。对象。这意味着列表可以随时修改、附加或切片，但元组保持不变并且不能以任何方式修改。你可以在 Python IDLE 上运行以下示例以确认差异：

my_tuple = ('sara', 6, 5, 0.97)
my_list = ['sara', 6, 5, 0.97]
print(my_tuple[0])     # output => 'sara'
print(my_list[0])     # output => 'sara'
my_tuple[0] = 'ansh'    # modifying tuple => throws an error
my_list[0] = 'ansh'    # modifying list => list modified
print(my_tuple[0])     # output => 'sara'
print(my_list[0])     # output => 'ansh'

8、Python最佳面试题合集：Python中常见的内置数据类型有哪些？

Python 中有多种内置数据类型。虽然，Python 不要求在变量声明期间显式定义数据类型，如果忽略数据类型的知识及其相互兼容性，则可能会发生类型错误。Python提供type()和isinstance()功能检查这些变量的类型。这些数据类型可以分为以下几类——

• None 类型：
  None关键字表示 Python 中的空值。可以使用这些 NoneType 对象执行布尔相等运算。

班级名称	描述
无类型	表示Python 中的NULL值。

• 数字类型：
  共有三种不同的数字类型 -整数、浮点数和复数。此外，布尔值是整数的子类型。

班级名称	描述
整数	将整数文字存储为整数，包括十六进制、八进制和二进制数
漂浮	将包含十进制值和/或指数符号的文字存储为浮点数
复杂的	在形式（A + BJ）存储复数，并且具有属性：real和imag
布尔值	存储布尔值（真或假）。

注意：标准库还包括分数以存储有理数和小数以存储具有用户定义精度的浮点数。

• 序列类型：
  根据 Python 文档，存在三种基本的序列类型 -列表、元组和范围对象。序列类型定义了in和not in运算符，用于遍历它们的元素。这些运算符与比较操作具有相同的优先级。

班级名称	描述
列表	用于存储项目集合的可变序列。
元组	用于存储项目集合的不可变序列。
范围	表示在执行期间生成的不可变数字序列。
字符串	用于存储文本数据的 Unicode 代码点的不可变序列。

注意：标准库还包括用于处理的其他类型：
1.二进制数据，例如bytearray bytes memoryview，和
2.文本字符串，例如str。

• 映射类型：

映射对象可以将可哈希值映射到 Python 中的随机对象。Mappings 对象是可变的，目前只有一种标准映射类型，字典。

班级名称	描述
字典	存储逗号分隔的键：值对列表

• 集合类型：
  目前，Python 有两种内置的集合类型 - set和freezeset。set类型是可变的，并且支持像add()和这样的方法remove()。frozenset类型是不可变的，创建后不能修改。

班级名称	描述
放	不同可散列对象的可变无序集合。
冻结集	不同的可散列对象的不可变集合。

注意： set是可变的，因此不能用作字典的键。另一方面，它frozenset是不可变的，因此是可散列的，可以用作字典键或另一个集合的元素。

• 模块：
  模块是 Python 解释器支持的附加内置类型。它支持一种特殊操作，即属性访问: mymod.myobj，其中mymod是一个模块，而myobj引用在 m 的符号表中定义的名称。模块的符号表驻留在模块__dict__ 的一个非常特殊的属性中，但是直接分配给这个模块既不可能也不推荐。
• 可调用类型：
  可调用类型是可以应用函数调用的类型。它们可以是用户定义的函数、实例方法、生成器函数以及其他一些内置函数、方法和类。有关可调用类型的详细视图，
  请参阅docs.python.org上的文档。

9. Python 中的 pass 是什么？

该pass关键字表示Python中的空操作。它通常用于填充可能在运行时执行但尚未编写的空代码块。如果没有以下代码中的pass语句，我们可能会在代码执行过程中遇到一些错误。

def myEmptyFunc():
   # do nothing
   pass
myEmptyFunc()    # nothing happens
## Without the pass keyword
# File "<stdin>", line 3
# IndentationError: expected an indented block

10. Python 中的模块和包是什么？

Python 包和 Python 模块是两种允许在 Python 中进行模块化编程的机制。模块化有几个优点——

• 简单性：处理单个模块可以帮助你专注于手头问题的相对较小的部分。这使得开发更容易，更不容易出错。
• 可维护性：模块旨在加强不同问题域之间的逻辑边界。如果它们以减少相互依赖性的方式编写，则模块中的修改不太可能影响程序的其他部分。
• 可重用性：模块中定义的函数可以很容易地被应用程序的其他部分重用。
• 范围：模块通常定义一个单独的命名空间，这有助于避免来自程序其他部分的标识符之间的混淆。

模块通常只是带有 .py 扩展名的 Python 文件，可以定义和实现一组函数、类或变量。它们可以使用该import语句导入和初始化一次。如果需要部分功能，请使用from foo import bar.

包允许使用点符号对模块命名空间进行分层结构化。由于模块有助于避免全局变量名称之间的冲突，以类似的方式，包有助于避免模块名称之间的冲突。
创建包很容易，因为它利用了系统固有的文件结构。因此，只需将模块放入一个文件夹中即可，文件夹名称作为包名称。从此包中导入模块或其内容需要包名称作为模块名称的前缀，并用点连接。

注意：从技术上讲，你也可以导入包，但遗憾的是，它不会将包中的模块导入本地命名空间，因此实际上没有用。

11. Python 中的 global、protected 和 private 属性是什么？

• 全局变量是在全局范围内定义的公共变量。要在函数内的全局范围内使用变量，我们使用global关键字。
• 受保护的属性是用下划线作为前缀定义的属性，例如。_萨拉。它们仍然可以从定义它们的类的外部访问和修改，但负责任的开发人员应该避免这样做。
• 私有属性是在其标识符前带有双下划线的属性，例如。__ansh。它们不能直接从外部访问或修改，如果进行此类尝试，将导致 AttributeError。

12. Python 中的 self 是什么？

Self是 Python 中的一个关键字，用于定义类的对象的实例。在 Python 中，它被明确用作第一个参数，这与在 Java 中它是可选的不同。它有助于将类的方法和属性与其局部变量区分开来。

13.什么是__init__？

__init__是 Python 中的构造方法，在创建新对象/实例时自动调用以分配内存。所有的类都有一个与之关联的__init__方法。它有助于将类的方法和属性与局部变量区分开来。

# class definition
class Student:
   def __init__(self, fname, lname, age, section):
       self.firstname = fname
       self.lastname = lname
       self.age = age
       self.section = section
# creating a new object
stu1 = Student("Sara", "Ansh", 22, "A2")

14. Python 中的break、continue 和pass 是什么？

休息	break 语句立即终止循环，控制流向循环体之后的语句。
继续	continue 语句终止语句的当前迭代，跳过当前迭代中的其余代码，并且控制流向循环的下一次迭代。
经过	如上所述，Python 中的 pass 关键字一般用于填充空块，类似于 Java、C++、Javascript 等语言中用分号表示的空语句。

pat = [1, 3, 2, 1, 2, 3, 1, 0, 1, 3]
for p in pat:
   pass
   if (p == 0):
       current = p
       break
   elif (p % 2 == 0):
       continue
   print(p)    # output => 1 3 1 3 1
print(current)    # output => 0

15. Python 中的单元测试是什么？

• 单元测试是 Python 的单元测试框架。
• 单元测试意味着分别测试软件的不同组件。你能想出为什么单元测试很重要吗？想象一个场景，你正在构建使用三个组件（即 A、B 和 C）的软件。现在，假设你的软件在某个时间点出现故障。你将如何找到导致软件损坏的组件？也许是组件 A 失败了，而组件 B 又失败了，这实际上使软件失败了。可以有很多这样的组合。
• 这就是为什么有必要正确测试每个组件，以便我们知道哪个组件可能对软件的故障负有很大责任。

16. Python 中的文档字符串是什么？

• 文档字符串或文档字符串是用于记录特定代码段的多行字符串。
• 文档字符串应该描述函数或方法的作用。

17. Python 中的切片是什么？

• 顾名思义，“切片”就是其中的一部分。
• 切片的语法是[start : stop : step]
• start是对列表或元组进行切片的起始索引
• stop是结束索引或停止位置。
• step是跳跃的步数。
• start 的默认值是 0，stop是项目数，step是 1。
• 可以对字符串、数组、列表和元组进行切片。

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(numbers[1 : : 2])  #output : [2, 4, 6, 8, 10]

18. 解释如何在 Unix 上制作 Python 脚本可执行文件？

• 脚本文件必须以#!/usr/bin/env python开头

19. Python 数组和列表有什么区别？

• python中的数组只能包含相同数据类型的元素，即数组的数据类型应该是同类的。它是 C 语言数组的薄包装器，比列表消耗的内存少得多。
• python中的列表可以包含不同数据类型的元素，即列表的数据类型可以是异构的。它有消耗大内存的缺点。

import array
a = array.array('i', [1, 2, 3])
for i in a:
    print(i, end=' ')    #OUTPUT: 1 2 3
a = array.array('i', [1, 2, 'string'])    #OUTPUT: TypeError: an integer is required (got type str)
a = [1, 2, 'string']
for i in a:
   print(i, end=' ')    #OUTPUT: 1 2 string

有经验的 Python 面试题

20. Python 中是如何管理内存的？

• Python 中的内存管理由Python Memory Manager处理。管理器分配的内存采用专用于 Python的私有堆空间的形式。所有 Python 对象都存储在这个堆中并且是私有的，程序员无法访问它。尽管如此，python 确实提供了一些核心 API 函数来处理私有堆空间。
• 此外，Python 有一个内置的垃圾收集器，可以为私有堆空间回收未使用的内存。

21. 什么是 Python 命名空间？为什么使用它们？

Python面试题解析：Python 中的命名空间确保程序中的对象名称是唯一的，并且可以在没有任何冲突的情况下使用。Python 将这些命名空间实现为字典，其中“名称作为键”映射到相应的“对象作为值”。这允许多个命名空间使用相同的名称并将其映射到单独的对象。命名空间的一些示例如下：

• 本地命名空间包括函数内的本地名称。命名空间是为函数调用临时创建的，并在函数返回时被清除。
• 全局命名空间包括来自当前项目中正在使用的各种导入包/模块的名称。该命名空间是在脚本中导入包时创建的，并持续到脚本执行为止。
• 内置命名空间包括核心 Python 的内置函数和各类异常的内置名称。

命名空间的生命周期取决于它们映射到的对象的范围。如果对象的作用域结束，该命名空间的生命周期也就结束了。因此，不可能从外部命名空间访问内部命名空间对象。

22. Python 中的作用域解析是什么？

有时，同一作用域内的对象具有相同的名称但功能不同。在这种情况下，范围解析会自动在 Python 中发挥作用。这种行为的一些例子是：

• Python模块，即“数学”和“CMATH”有很多是共同的他们两个功能- ，，等。要解决这种不确定性，有必要以各自的模块前缀它们，就像和。log10()acos()exp()math.exp()cmath.exp()
• 考虑下面的代码，对象 temp 已全局初始化为 10，然后在函数调用时初始化为 20。但是，函数调用并未全局更改 temp 的值。在这里，我们可以观察到 Python 在全局变量和局部变量之间划清了界限，将它们的命名空间视为单独的身份。

temp = 10   # global-scope variable
def func():
     temp = 20   # local-scope variable
     print(temp)
print(temp)   # output => 10
func()    # output => 20
print(temp)   # output => 10

可以使用global函数内的关键字覆盖此行为，如以下示例所示：

temp = 10   # global-scope variable
def func():
     global temp
     temp = 20   # local-scope variable
     print(temp)
print(temp)   # output => 10
func()    # output => 20
print(temp)   # output => 20

23. Python 中的装饰器是什么？

Python 中的装饰器本质上是将功能添加到 Python 中现有函数的函数，而不改变函数本身的结构。它们@decorator_name在 Python中表示，并以自底向上的方式调用。例如：

# decorator function to convert to lowercase
def lowercase_decorator(function):
   def wrapper():
       func = function()
       string_lowercase = func.lower()
       return string_lowercase
   return wrapper
# decorator function to split words
def splitter_decorator(function):
   def wrapper():
       func = function()
       string_split = func.split()
       return string_split
   return wrapper
@splitter_decorator # this is executed next
@lowercase_decorator # this is executed first
def hello():
   return 'Hello World'
hello()   # output => [ 'hello' , 'world' ]

装饰器的美妙之处在于，除了为方法的输出添加功能外，它们甚至可以接受函数的参数，并且可以在将其传递给函数本身之前进一步修改这些参数。该内部嵌套函数，即“包装”功能，在这里扮演一个显著的作用。它的实现是为了强制封装，从而将自身隐藏在全局范围之外。

# decorator function to capitalize names
def names_decorator(function):
   def wrapper(arg1, arg2):
       arg1 = arg1.capitalize()
       arg2 = arg2.capitalize()
       string_hello = function(arg1, arg2)
       return string_hello
   return wrapper
@names_decorator
def say_hello(name1, name2):
   return 'Hello ' + name1 + '! Hello ' + name2 + '!'
say_hello('sara', 'ansh')   # output => 'Hello Sara! Hello Ansh!'

24. Python常见面试题有哪些：什么是 Dict 和 List 推导式？

Python 推导式与装饰器一样，是语法糖结构，可帮助从给定的列表、字典或集合构建更改和过滤的列表、字典或集合。使用推导式可以节省大量时间和可能更冗长的代码（包含更多代码行）。让我们看看一些例子，其中理解可以真正有益：

• 对整个列表执行数学运算

my_list = [2, 3, 5, 7, 11]
squared_list = [x**2 for x in my_list]    # list comprehension
# output => [4 , 9 , 25 , 49 , 121]
squared_dict = {x:x**2 for x in my_list}    # dict comprehension
# output => {11: 121, 2: 4 , 3: 9 , 5: 25 , 7: 49}

• 对整个列表进行条件过滤操作

my_list = [2, 3, 5, 7, 11]
squared_list = [x**2 for x in my_list if x%2 != 0]    # list comprehension
# output => [9 , 25 , 49 , 121]
squared_dict = {x:x**2 for x in my_list if x%2 != 0}    # dict comprehension
# output => {11: 121, 3: 9 , 5: 25 , 7: 49}

• 将多个列表合并为一个

推导式允许多个迭代器，因此可用于将多个列表合并为一个。 

a = [1, 2, 3]
b = [7, 8, 9]
[(x + y) for (x,y) in zip(a,b)]  # parallel iterators
# output => [8, 10, 12]
[(x,y) for x in a for y in b]    # nested iterators
# output => [(1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9)] 

• 扁平化多维列表

嵌套迭代器的类似方法（如上）可用于展平多维列表或处理其内部元素。 

my_list = [[10,20,30],[40,50,60],[70,80,90]]
flattened = [x for temp in my_list for x in temp]
# output => [10, 20, 30, 40, 50, 60, 70, 80, 90]

注意：列表推导式与其他语言中的 map 方法具有相同的效果。它们遵循数学集合构建器符号，而不是 Python 中的映射和过滤函数。

25. Python 中的 lambda 是什么？为什么使用它？

Lambda 是 Python 中的匿名函数，可以接受任意数量的参数，但只能有一个表达式。它通常用于在短时间内需要匿名函数的情况。Lambda 函数可以通过以下两种方式之一使用：

• 将 lambda 函数分配给变量：

mul = lambda a, b : a * b
print(mul(2, 5))    # output => 10

• 将 lambda 函数包装在另一个函数中：

def myWrapper(n):
 return lambda a : a * n
mulFive = myWrapper(5)
print(mulFive(2))    # output => 10

26. Python 中如何复制对象？

在 Python 中，赋值语句（=运算符）不会复制对象。相反，它会在现有对象和目标变量名称之间创建绑定。要在 Python 中创建对象的副本，我们需要使用copy模块。此外，有两种使用复制模块为给定对象创建副本的方法-

浅拷贝是对象的按位拷贝。创建的复制对象具有原始对象中值的精确副本。如果其中一个值是对其他对象的引用，则仅复制相同对象的引用地址。
Deep Copy递归地将所有值从源对象复制到目标对象，即它甚至复制源对象引用的对象。

from copy import copy, deepcopy
list_1 = [1, 2, [3, 5], 4]
## shallow copy
list_2 = copy(list_1) 
list_2[3] = 7
list_2[2].append(6)
list_2    # output => [1, 2, [3, 5, 6], 7]
list_1    # output => [1, 2, [3, 5, 6], 4]
## deep copy
list_3 = deepcopy(list_1)
list_3[3] = 8
list_3[2].append(7)
list_3    # output => [1, 2, [3, 5, 6, 7], 8]
list_1    # output => [1, 2, [3, 5, 6], 4]

27. Python 中的 xrange 和 range 有什么区别？

xrange()和range()在功能方面非常相似。它们都生成一个整数序列，唯一的区别是range()返回一个Python 列表，而xrange()返回一个xrange 对象。

那么这有什么不同呢？确实如此，因为与 range() 不同，xrange() 不会生成静态列表，它会随时随地创建值。这种技术通常与对象类型生成器一起使用，并被称为“屈服”。

在内存受到限制的应用程序中，屈服是至关重要的。在 range() 中创建静态列表可能会导致Memory Error在这种情况下，而 xrange() 可以通过为生成器使用足够的内存来最佳地处理它（相比之下要少得多）。

for i in xrange(10):    # numbers from o to 9
   print i       # output => 0 1 2 3 4 5 6 7 8 9
for i in xrange(1,10):    # numbers from 1 to 9
   print i       # output => 1 2 3 4 5 6 7 8 9
for i in xrange(1, 10, 2):    # skip by two for next
   print i       # output => 1 3 5 7 9

注意：从Python 3.x开始，xrange已被弃用。现在与Python 2.x 中过去所做的完全相同，因为在Python 2.x中使用 xrange() 比使用原始 range() 函数要好得多。rangexrange

28、Python最佳面试题合集：什么是pickling和unpickling？

Python 库提供了一个特性——开箱即用的序列化。序列化一个对象是指将它转换成可以存储的格式，以便以后可以将其反序列化以获得原始对象。在这里，pickle模块开始发挥作用。

pickling：

• Pickling 是 Python 中序列化过程的名称。Python 中的任何对象都可以序列化为字节流并作为文件转储到内存中。pickling 的过程很紧凑，但pickling 对象可以进一步压缩。此外，pickle 会跟踪它已序列化的对象，并且序列化可以跨版本移植。
• 用于上述过程的函数是pickle.dump()。

unpickling：

• unpickling是pickling的完全逆过程。它反序列化字节流以重新创建存储在文件中的对象并将对象加载到内存中。
• 用于上述过程的函数是pickle.load()。

注意： Python 有另一个更原始的序列化模块marshall，它的存在主要是为了支持Python 中的.pyc 文件，与 pickle 有很大不同。

29. Python 中的生成器是什么？

生成器是一种函数，它以一种设定的方式返回一个可迭代的项目集合，一次一个。生成器通常用于通过不同的方法创建迭代器。他们使用yield关键字而不是return返回生成器对象。
让我们尝试为斐波那契数构建一个生成器 -

## generate fibonacci numbers upto n
def fib(n):
   p, q = 0, 1
   while(p < n):
       yield p
       p, q = q, p + q
x = fib(10)    # create generator object 
 
## iterating using __next__(), for Python2, use next()
x.__next__()    # output => 0
x.__next__()    # output => 1
x.__next__()    # output => 1
x.__next__()    # output => 2
x.__next__()    # output => 3
x.__next__()    # output => 5
x.__next__()    # output => 8
x.__next__()    # error
 
## iterating using loop
for i in fib(10):
   print(i)    # output => 0 1 1 2 3 5 8

30. Python 中的 PYTHONPATH 是什么？

PYTHONPATH 是一个环境变量，你可以设置它来添加额外的目录，Python 将在其中查找模块和包。这对于维护你不希望安装在全局默认位置的 Python 库特别有用。

31. help() 和 dir() 函数有什么用？

Python 中的help()函数用于显示模块、类、函数、关键字等的文档。如果没有参数传递给help()函数，则在控制台上启动交互式帮助实用程序。
dir()函数尝试返回它所调用对象的有效属性和方法列表。它对不同的对象表现不同，因为它旨在生成最相关的数据，而不是完整的信息。

• 对于模块/库对象，它返回包含在该模块中的所有属性的列表。
• 对于类对象，它返回所有有效属性和基本属性的列表。
• 没有传递参数，它返回当前范围内的属性列表。

32..py和.pyc文件有什么区别？

• .py 文件包含程序的源代码。而 .pyc 文件包含程序的字节码。我们在编译 .py 文件（源代码）后得到字节码。不会为你运行的所有文件创建 .pyc 文件。它仅为你导入的文件创建。
• 在执行 python 程序之前，python 解释器会检查编译后的文件。如果文件存在，虚拟机就会执行它。如果没有找到，它会检查 .py 文件。如果找到，则将其编译为 .pyc 文件，然后 python 虚拟机执行它。
• 拥有 .pyc 文件可以节省编译时间。

33. Python 是如何解释的？

• Python 作为一种语言不被解释或编译。解释或编译是实现的属性。Python 是一种通常被解释的字节码（解释器可读指令集）。
• 源代码是一个扩展名为 .py 的文件。
• Python 将源代码编译为一组用于虚拟机的指令。Python 解释器是该虚拟机的实现。这种中间格式称为“字节码”。
• .py 源代码首先被编译为 .pyc，它是字节码。这个字节码可以被官方的 CPython 或 PyPy 编译的 JIT（即时编译器）解释。

34.python中参数是如何按值或按引用传递的？

• 按值传递：传递实际对象的副本。更改对象副本的值不会更改原始对象的值。
• 通过引用传递：传递对实际对象的引用。更改新对象的值将更改原始对象的值。

在 Python 中，参数是通过引用传递的，即传递对实际对象的引用。

def appendNumber(arr):
   arr.append(4)
arr = [1, 2, 3]
print(arr)  #Output: => [1, 2, 3]
appendNumber(arr)
print(arr)  #Output: => [1, 2, 3, 4]

35. Python 中的迭代器是什么？

• 迭代器是一个对象。
• 它记住它的状态，即它在迭代期间的位置（参见下面的代码以了解如何）
• __iter__() 方法初始化一个迭代器。
• 它有一个 __next__() 方法，该方法返回迭代中的下一项并指向下一个元素。到达可迭代对象的末尾时 __next__() 必须返回 StopIteration 异常。
• 它也是自迭代的。
• 迭代器是我们可以迭代可迭代对象（如列表、字符串等）的对象。

class ArrayList:
   def __init__(self, number_list):
       self.numbers = number_list
   def __iter__(self):
       self.pos = 0
       return self
   def __next__(self):
       if(self.pos < len(self.numbers)):
           self.pos += 1
           return self.numbers[self.pos - 1]
       else:
           raise StopIteration
array_obj = ArrayList([1, 2, 3])
it = iter(array_obj)
print(next(it)) #output: 2
print(next(it)) #output: 3
print(next(it))
#Throws Exception
#Traceback (most recent call last):
#...
#StopIteration

36.解释如何在Python中删除文件？

使用命令os.remove(file_name)

import os
os.remove("ChangedFile.csv")
print("File Removed!")

37.解释Python中的split()和join()函数？

• 你可以使用split()函数将基于分隔符的字符串拆分为字符串列表。
• 你可以使用join()函数根据分隔符连接字符串列表以给出单个字符串。

string = "This is a string."
string_list = string.split(' ') #delimiter is ‘space’ character or ‘ ‘
print(string_list) #output: ['This', 'is', 'a', 'string.']
print(' '.join(string_list)) #output: This is a string.

38. *args 和 **kwargs 是什么意思？

*args

• *args 是函数定义中用于传递可变长度参数的特殊语法。
• “*”表示可变长度，“args”是约定俗成的名称。你可以使用任何其他。

def multiply(a, b, *argv):
   mul = a * b
   for num in argv:
       mul *= num
   return mul
print(multiply(1, 2, 3, 4, 5)) #output: 120

**kwargs

• **kwargs 是函数定义中用于传递可变长度关键字参数的特殊语法。
• 在这里，“kwargs”也只是按照惯例使用。你可以使用任何其他名称。
• 关键字参数是指在传递给函数时具有名称的变量。
• 它实际上是一个变量名称及其值的字典。

def tellArguments(**kwargs):
   for key, value in kwargs.items():
       print(key + ": " + value)
tellArguments(arg1 = "argument 1", arg2 = "argument 2", arg3 = "argument 3")
#output:
# arg1: argument 1
# arg2: argument 2
# arg3: argument 3

39. 什么是负索引，为什么使用它们？

• 负索引是从列表或元组或字符串末尾开始的索引。
• Arr[-1]表示数组Arr[]的最后一个元素

arr = [1, 2, 3, 4, 5, 6]
#get the last element
print(arr[-1]) #output 6
#get the second last element
print(arr[-2]) #output 5

Python OOPS 面试题

40. 你如何在 Python 中创建一个类？

要在 python 中创建一个类，我们使用关键字“class”，如下例所示：

class InterviewbitEmployee:
   def __init__(self, emp_name):
       self.emp_name = emp_name

要从上面创建的类实例化或创建一个对象，我们执行以下操作：

emp_1=InterviewbitEmployee("Mr. Employee")

要访问 name 属性，我们只需使用点运算符调用该属性，如下所示：

print(emp_1.name)
# Prints Mr. Employee

为了在类内部创建方法，我们将方法包含在类的范围内，如下所示：

class InterviewbitEmployee:
   def __init__(self, emp_name):
       self.emp_name = emp_name
       
   def introduce(self):
       print("Hello I am " + self.emp_name)

init 和introduce 函数中的self 参数表示对当前类实例的引用，用于访问该类的属性和方法。self 参数必须是在类中定义的任何方法的第一个参数。可以访问类InterviewbitEmployee的方法，如下所示：

emp_1.introduce()

整个程序将如下所示：

class InterviewbitEmployee:
   def __init__(self, emp_name):
       self.emp_name = emp_name
       
   def introduce(self):
       print("Hello I am " + self.emp_name)
       
# create an object of InterviewbitEmployee class
emp_1 = InterviewbitEmployee("Mr Employee")
print(emp_1.emp_name)    #print employee name
emp_1.introduce()        #introduce the employee

41.python中的继承是如何工作的？用一个例子来解释它。

继承赋予一个类访问另一个类的所有属性和方法的权力。它有助于代码的可重用性，并帮助开发人员在没有冗余代码的情况下维护应用程序。从另一个类继承的类是子类或也称为派生类。子类从其派生成员的类称为父类或超类。

Python 支持不同种类的继承，它们是：

• 单一继承：子类派生一个父类的成员。

# Parent class
class ParentClass:
    def par_func(self):
         print("I am parent class function")

# Child class
class ChildClass(ParentClass):
    def child_func(self):
         print("I am child class function")

# Driver code
obj1 = ChildClass()
obj1.par_func()
obj1.child_func()

• 多级继承：父类A的成员由子类继承，子类再由另一个子类B继承。基类和派生类的特征进一步继承到新的派生类C .这里，A是C班的祖父班。

# Parent class
class A:
   def __init__(self, a_name):
       self.a_name = a_name
   
# Intermediate class
class B(A):
   def __init__(self, b_name, a_name):
       self.b_name = b_name
       # invoke constructor of class A
       A.__init__(self, a_name)

# Child class
class C(B):
   def __init__(self,c_name, b_name, a_name):
       self.c_name = c_name
       # invoke constructor of class B
       B.__init__(self, b_name, a_name)
       
   def display_names(self):
       print("A name : ", self.a_name)
       print("B name : ", self.b_name)
       print("C name : ", self.c_name)

#  Driver code
obj1 = C('child', 'intermediate', 'parent')
print(obj1.a_name)
obj1.display_names()
 

• 多重继承：这是当一个子类从多个父类派生成员时实现的。父类的所有特性都在子类中继承。

# Parent class1
class Parent1:
   def parent1_func(self):
       print("Hi I am first Parent")

# Parent class2
class Parent2:
   def parent2_func(self):
       print("Hi I am second Parent")

# Child class
class Child(Parent1, Parent2):
   def child_func(self):
       self.parent1_func()
       self.parent2_func()

# Driver's code
obj1 = Child()
obj1.child_func()

• 层次继承：当一个父类由多个子类派生时，称为层次继承。

# Base class
class A:
     def a_func(self):
         print("I am from the parent class.")

# 1st Derived class
class B(A):
     def b_func(self):
         print("I am from the first child.")

# 2nd Derived class
class C(A):
     def c_func(self):
         print("I am from the second child.")
 
# Driver's code
obj1 = B()
obj2 = C()
obj1.a_func()
obj1.b_func()    #child 1 method
obj2.a_func()
obj2.c_func()    #child 2 method

42.如何访问子类中的父成员？

以下是你可以在子类中访问父类成员的方法：

• 通过使用父类名称：你可以使用父类的名称来访问属性，如下例所示：

class Parent(object):  
   # Constructor
   def __init__(self, name):
       self.name = name    
 
class Child(Parent): 
   # Constructor
   def __init__(self, name, age):
       Parent.name = name
       self.age = age
 
   def display(self):
       print(Parent.name, self.age)
 
# Driver Code
obj = Child("Interviewbit", 6)
obj.display()

• 通过使用 super()：可以使用 super 关键字在子类中访问父类成员。

class Parent(object):
   # Constructor
   def __init__(self, name):
       self.name = name    
 
class Child(Parent):
   # Constructor
   def __init__(self, name, age):         
       ''' 
       In Python 3.x, we can also use super().__init__(name)
       ''' 
       super(Child, self).__init__(name)
       self.age = age
 
   def display(self):
      # Note that Parent.name cant be used 
      # here since super() is used in the constructor
      print(self.name, self.age)
  
# Driver Code
obj = Child("Interviewbit", 6)
obj.display()

43.python中是否使用了访问说明符？

Python 没有使用像私有、公共、受保护等这样的访问说明符。但是，它不会将其剥夺给任何变量。它的概念是通过使用单个（受保护的）或双下划线（私有）作为变量名称的前缀来模仿变量的行为。默认情况下，没有前缀下划线的变量是公共的。
例子：

# to demonstrate access specifiers
class InterviewbitEmployee:
   
    # protected members
    _emp_name = None
    _age = None
    
    # private members
    __branch = None
    
    # constructor
    def __init__(self, emp_name, age, branch): 
         self._emp_name = emp_name
         self._age = age
         self.__branch = branch
    
    #public member
    def display():
        print(self._emp_name +" "+self._age+" "+self.__branch)

44.是否可以在不创建实例的情况下调用父类？

是的，如果基类由其他子类实例化或者基类是静态方法，则是可能的。

45.python中如何创建一个空类？

空类中没有定义任何成员。它是通过使用 pass 关键字创建的（pass 命令在 python 中什么都不做）。我们可以在类之外为这个类创建对象。
例如-

class EmptyClassDemo:
   pass
obj=EmptyClassDemo()
obj.name="Interviewbit"
print("Name created= ",obj.name)

输出：
名称创建 = Interviewbit

46. 区分新修饰符和覆盖修饰符。

new 修饰符用于指示编译器使用新实现而不是基类函数。Override 修饰符对于覆盖子类中的基类函数很有用。

47. Python常见面试题有哪些：为什么要用finalize？

Finalize 方法用于在调用垃圾收集方法之前释放非托管资源并进行清理。这有助于执行内存管理任务。

48.python中的init方法是什么？

该初始化方法适用于Java中的构造相似。一旦对象被实例化，该方法就会运行。它对于在实例化时初始化对象的任何属性或默认行为非常有用。
例如：

class InterviewbitEmployee:

   # init method / constructor
   def __init__(self, emp_name):
       self.emp_name = emp_name

   # introduce method
   def introduce(self):
       print('Hello, I am ', self.emp_name)

emp = InterviewbitEmployee('Mr Employee')    # __init__ method is called here and initializes the object name with "Mr Employee"
emp.introduce()

49. 你将如何检查一个班级是否是另一个班级的孩子？

这是通过使用python 提供的称为issubclass()的方法来完成的。该方法通过相应地返回 true 或 false 来告诉我们任何类是否是另一个类的子类。
例如：

class Parent(object):
   pass   
 
class Child(Parent):
   pass   
 
# Driver Code
print(issubclass(Child, Parent))    #True
print(issubclass(Parent, Child))    #False

• 我们可以使用isinstance()方法检查对象是否是类的实例：

obj1 = Child()
obj2 = Parent()
print(isinstance(obj2, Child))    #False 
print(isinstance(obj2, Parent))   #True 

Python Pandas 面试题

50.你对Pandas了解多少？

• Pandas 是一个基于 Python 的开源库，用于需要高性能的数据操作应用程序。该名称源自具有多维数据的“面板数据”。这是由 Wes McKinney 于 2008 年开发的，用于数据分析。
• Pandas 可用于执行数据分析的 5 个主要步骤 - 加载数据、清理/操作、准备、建模和分析数据。

51. 定义Pandas数据框。

数据框是一种二维可变和表格结构，用于表示用轴（行和列）标记的数据。
创建数据框的语法：

import pandas as pd
dataframe = pd.DataFrame( data, index, columns, dtype)

在哪里：

• 数据 - 代表各种形式，如系列、地图、ndarray、列表、字典等。
• index - 表示行标签索引的可选参数。
• columns - 列标签的可选参数。
• Dtype - 每列的数据类型。再次可选。

52. 你将如何组合不同的 Pandas 数据框？

Python面试题解析：可以使用以下方法组合数据框：

• append() 方法：用于水平堆叠数据帧。句法：

df1.append(df2)

• concat() 方法：用于垂直堆叠数据帧。当数据框具有相同的列和相似的字段时，最好使用这种方法。句法：

pd.concat([df1, df2]) 

• join() 方法：该方法用于从具有一个或多个公共列的各种数据帧中提取数据。

df1.join(df2)

53.你能用pandas中的字典对象创建一个系列吗？

能够存储不同数据类型的一维数组称为系列。我们可以从字典对象创建Pandas系列，如下所示：

import pandas as pd    
dict_info = {'key1' : 2.0, 'key2' : 3.1, 'key3' : 2.2}  
series_obj = pd.Series(dict_info)    
print (series_obj)    
Output:
x     2.0
y     3.1
z     2.2
dtype: float64

如果输入法中未指定索引，则字典的键按升序排序以构建索引。如果传递了索引，则将从字典中提取索引标签的值。

54. 你将如何识别和处理数据框中的缺失值？

我们可以使用 isnull() 和 isna() 方法来识别数据帧是否有缺失值。

missing_data_count=df.isnull().sum()

我们可以通过将列中的值替换为 0 来处理缺失值，如下所示：

df[‘column_name’].fillna(0)

或者用列的平均值替换它

df[‘column_name’] = df[‘column_name’].fillna((df[‘column_name’].mean()))

55.在pandas中重新索引你是怎么理解的？

重新索引是使用可选的填充逻辑使数据帧符合新索引的过程。如果前一个索引中缺少这些值，则将 NaN/NA 放置在该位置。除非生成与当前索引等效的新索引，否则将返回一个新对象。复制值设置为 False。这也用于更改数据框中行和列的索引。

56.如何给pandas数据框添加新列？

一个新列可以添加到Pandas数据框中，如下所示：

import pandas as pd      
data_info = {'first' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),    
       'second' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}    
  
df = pd.DataFrame(data_info)    
#To add new column third
df['third']=pd.Series([10,20,30],index=['a','b','c'])    
print (df)    
#To add new column fourth
df['fourth']=df['first']+info['third']    
print (df)    

57. 如何从数据框中删除索引、行和列？

删除索引：

• 执行del df.index.name以按名称删除索引。
• 或者，df.index.name可以将 分配给 None。
• 例如，如果你有以下数据框：

                Column 1
   Names             
   John               1
   Jack               2
   Judy               3
   Jim                4

• 要删除索引名称“Names”：

df.index.name = None
# Or run the below:
# del df.index.name
print(df)
        Column 1
John          1
Jack          2
Judy          3
Jim           4

从数据框中删除行/列：

• drop() 方法用于从数据框中删除行/列。
• 轴参数传递给 drop 方法，如果值为 0，则表示删除/删除行，如果值为 1，则必须删除列。
• 此外，我们可以尝试通过将 inplace 的值设置为 True 来删除原地的行/列。这可确保无需重新分配即可完成工作。
• 可以使用该drop_duplicates()方法删除行/列中的重复值。

58.你能买到A系列的商品，而B系列没有吗？

这可以通过使用~（非/否定符号）和isin()方法来实现，如下所示。

import pandas as pd
df1 = pd.Series([2, 4, 8, 10, 12])
df2 = pd.Series([8, 12, 10, 15, 16])
df1=df1[~df1.isin(df2)]
print(df1)
"""
Output:
0    2
1    4
dtype: int64
"""

59. 你将如何获得给定系列 A 和 B 不共同的项目？

我们可以通过首先执行两个系列的并集，然后取两个系列的交集来实现这一点。然后我们遵循获取交集列表中不存在的联合项目的方法。

以下代码演示了这一点：

import pandas as pd
import numpy as np
df1 = pd.Series([2, 4, 5, 8, 10])
df2 = pd.Series([8, 10, 13, 15, 17])
p_union = pd.Series(np.union1d(df1, df2))  # union of series
p_intersect = pd.Series(np.intersect1d(df1, df2))  # intersection of series
unique_elements = p_union[~p_union.isin(p_intersect)]
print(unique_elements)
"""
Output:
0     2
1     4
2     5
5    13
6    15
7    17
dtype: int64
"""

60.pandas库在导入不同来源的数据时，能否识别日期？

是的，他们可以，但需要一些帮助。我们需要在从源读取数据时添加 parse_dates 参数。考虑一个我们从 CSV 文件读取数据的示例，我们可能会遇到不同的日期时间格式，这些格式无法被 Pandas 库读取。在这种情况下，pandas 可以在 lambda 函数的帮助下灵活地构建我们的自定义日期解析器，如下所示：

import pandas as pd
from datetime import datetime
dateparser = lambda date_val: datetime.strptime(date_val, '%Y-%m-%d %H:%M:%S')
df = pd.read_csv("some_file.csv", parse_dates=['datetime_column'], date_parser=dateparser)

Numpy 面试问题

61、你对NumPy的理解是什么？

NumPy 是最流行的、易于使用的、通用的、开源的、基于 python 的通用包之一，用于处理数组。NumPy 是 NUMerical PYthon 的缩写。它以其高度优化的工具而闻名，这些工具可带来高性能和强大的 N 维数组处理功能，这些功能专门设计用于处理复杂的数组。由于它的流行和强大的性能以及执行三角运算、代数和统计计算等各种运算的灵活性，它最常用于执行科学计算和各种广播功能。下图展示了 NumPy 的应用：

62. NumPy 数组比 Python 列表有什么优势？

• python的列表数据结构非常高效，能够执行各种功能。但是，当涉及到处理元素乘法和加法的向量化运算的计算时，它们有严重的局限性。python 列表还需要有关每个元素的类型的信息，这会导致开销，因为每次对任何元素执行任何操作时都会执行类型调度代码。这是 NumPy 数组出现的地方，因为 Python 列表的所有限制都在 NumPy 数组中处理。
• 此外，随着 NumPy 数组大小的增加，NumPy 变得比 Python List 快 30 倍左右。这是因为 Numpy 数组由于其同质性而在内存中密集排列。这确保内存释放也更快。

63. 创建一维、二维和三维数组的步骤是什么？

• 一维数组创建：

import numpy as np
one_dimensional_list = [1,2,4]
one_dimensional_arr = np.array(one_dimensional_list)
print("1D array is : ",one_dimensional_arr) 

• 二维数组创建：

import numpy as np
two_dimensional_list=[[1,2,3],[4,5,6]]
two_dimensional_arr = np.array(two_dimensional_list)
print("2D array is : ",two_dimensional_arr)

• 3D阵列创建：

import numpy as np
three_dimensional_list=[[[1,2,3],[4,5,6],[7,8,9]]]
three_dimensional_arr = np.array(three_dimensional_list)
print("3D array is : ",three_dimensional_arr) 

• ND 数组创建：这可以通过提供 ndmin 属性来实现。下面的示例演示了 6D 数组的创建：

import numpy as np
ndArray = np.array([1, 2, 3, 4], ndmin=6)
print(ndArray)
print('Dimensions of array:', ndArray.ndim)

64. 给你一个 numpy 数组和一个新列作为输入。你将如何删除第二列并用新的列值替换该列？

示例：
给定数组：

[[35 53 63]
[72 12 22]
[43 84 56]]

新列值：

[  
   20 
   30 
   40
]

解决方案：

import NumPy as np
#inputs
inputArray = np.array([[35,53,63],[72,12,22],[43,84,56]])
new_col = np.array([[20,30,40]])
# delete 2nd column
arr = np.delete(sampleArray , 1, axis = 1)
#insert new_col to array
arr = np.insert(arr , 1, new_col, axis = 1)
print (arr) 

65. 如何有效地从文本文件中加载数据？

我们可以使用numpy.loadtxt()自动读取文件的页眉和页脚行以及注释（如果有）的方法。

这种方法效率很高，即使感觉这种方法效率较低，也应该以更有效的格式表示数据，例如 CSV 等。 根据所使用的 NumPy 版本，可以考虑各种替代方案。

以下是支持的文件格式：

• 文本文件：这些文件通常很慢、很大但可移植并且是人类可读的。
• 原始二进制文件：此文件没有任何元数据且不可移植。但他们很快。
• Pickle：这些是临界速度和便携性，但取决于 NumPy 版本。
• HDF5：这被称为 High-Powered Kitchen Sink 格式，它支持 PyTables 和 h5py 格式。
• .npy：这是 NumPy 的原生二进制数据格式，非常简单、高效和可移植。

66. 你将如何在 NumPy 中将 CSV 数据读入数组？

这可以通过使用 genfromtxt() 方法通过将分隔符设置为逗号来实现。

from numpy import genfromtxt
csv_data = genfromtxt('sample_file.csv', delimiter=',')

67. 你将如何根据第 N 列对数组进行排序？

例如，考虑一个数组 arr。

arr = np.array([[8, 3, 2],
          [3, 6, 5],
          [6, 1, 4]])

让我们尝试按第二列对行进行排序，以便我们得到：

[[6, 1, 4],
[8, 3, 2],
[3, 6, 5]]

我们可以通过在 numpy 中使用 sort() 方法来做到这一点：

import numpy as np
arr = np.array([[8, 3, 2],
          [3, 6, 5],
          [6, 1, 4]])
#sort the array using np.sort
arr = np.sort(arr.view('i8,i8,i8'),
       order=['f1'],
       axis=0).view(np.int)

我们还可以通过执行以下操作来执行排序和就地排序：

arr.view('i8,i8,i8').sort(order=['f1'], axis=0)

68. 如何在给定的 numpy 数组中找到最近的值？

我们可以使用 numpy 的 argmin() 方法，如下所示：

import numpy as np
def find_nearest_value(arr, value):
   arr = np.asarray(arr)
   idx = (np.abs(arr - value)).argmin()
   return arr[idx]
#Driver code
arr = np.array([ 0.21169,  0.61391, 0.6341, 0.0131, 0.16541,  0.5645,  0.5742])
value = 0.52
print(find_nearest_value(arr, value)) # Prints 0.5645

69.你将如何使用一行代码反转numpy数组？

这可以按如下所示完成：

reversed_array = arr[::-1]

其中arr = 原始给定数组，reverse_array 是反转输入中的所有元素后的结果。

70. 你将如何找到任何给定 NumPy 数组的形状？

我们可以使用 numpy 数组的 shape 属性来查找形状。它根据数组的行数和列数返回数组的形状。

import numpy as np
arr_two_dim = np.array([("x1","x2", "x3","x4"),
             ("x5","x6", "x7","x8" )])
arr_one_dim = np.array([3,2,4,5,6])
# find and print shape
print("2-D Array Shape: ", arr_two_dim.shape)
print("1-D Array Shape: ", arr_one_dim.shape)
"""
Output:
2-D Array Shape:  (2, 4)
1-D Array Shape:  (5,)
"""

Python 库面试问题

71. 区分python中的包和模块。

该模块是一个单独的 python 文件。一个模块可以将其他模块（其他 python 文件）作为对象导入。而包是不同子包和模块所在的文件夹/目录。

通过保存扩展名为.py. 该文件将包含可在代码中以及跨模块重用的类和函数。

按照以下步骤创建python包：

• 创建一个目录并给出一个代表其操作的有效名称。
• 将一种模块放在此目录中。
• __init__.py在此目录中创建文件。这让 python 知道我们创建的目录是一个包。此包的内容可以跨其他包中的不同模块导入以重用功能。

72. Python最佳面试题合集：Python 中最常用的内置模块有哪些？

Python 模块是具有 Python 代码的文件，可以是函数、变量或类。这些通过 .py 扩展名进行。最常用的内置模块是：

• 操作系统
• 数学
• 系统
• 随机的
• 关于
• 约会时间
• JSON

73. 什么是 lambda 函数？

Lambda 函数通常是由单个表达式表示的内联匿名函数。它们用于在运行时创建函数对象。它们可以接受任意数量的参数。它们通常用于仅在短时间内需要功能的地方。它们可以用作：

mul_func = lambda x,y : x*y
print(mul_func(6, 4))
# Output: 24

74.如何生成随机数？

Python 提供了一个叫做 random 的模块，我们可以使用它生成随机数。

• 我们必须导入一个随机模块并调用random()如下所示的方法：
  • random() 方法随机生成介于 0 和 1 之间的浮点值。

 import random
 print(random.random())

• 要在指定范围之间生成自定义随机数，我们可以使用randrange()方法
  语法：randrange(beginning, end, step)
  例如：

import random
print(random.randrange(5,100,2))

75. 你能轻松检查给定字符串中的所有字符是否都是字母数字吗？

这可以通过使用 isalnum() 方法轻松完成，该方法在字符串只有字母数字字符的情况下返回 true。

例如 -

"abdc1321".isalnum() #Output: True
"xyz@123$".isalnum() #Output: False

另一种方法是使用match()re (regex) 模块中的方法，如下所示：

import re
print(bool(re.match('[A-Za-z0-9]+$','abdc1321'))) # Output: True
print(bool(re.match('[A-Za-z0-9]+$','xyz@123$'))) # Output: False

76、pickling和unpickling有什么区别？

pickling是将 python 对象转换为二进制形式。而 unpickling 是将二进制形式的数据转换为 Python 对象。腌制对象用于存储在磁盘或外部存储器位置。Unpickled 对象用于将数据作为 python 对象取回，然后可以在 python 中进行处理。

Python 提供了一个pickle模块来实现这一点。Pickling 使用该pickle.dump()方法将 python 对象转储到磁盘中。Unpickling 使用该pickle.load()方法将数据作为 python 对象取回。

77. 定义 GIL。

GIL 代表全局解释器锁。这是一个互斥锁，用于限制对 python 对象的访问，并通过避免死锁来帮助有效的线程同步。GIL 有助于实现多任务（而不是并行计算）。下图展示了 GIL 的工作原理。

根据上图，共有三个线程。First Thread 首先获取 GIL 并开始 I/O 执行。当 I/O 操作完成时，线程 1 释放获取的 GIL，然后由第二个线程占用。该过程重复进行并且 GIL 由不同的线程交替使用，直到线程完成它们的执行。没有 GIL 锁的线程进入等待状态，只有在获得锁时才恢复执行。

78. 定义 PYTHONPATH。

它是一个环境变量，用于在导入模块或包期间合并其他目录。PYTHONPATH 用于检查导入的包或模块在现有目录中是否可用。不仅如此，解释器还使用这个环境变量来确定需要加载哪个模块。

79. 定义PIP。

PIP 代表 Python 安装程序包。顾名思义，它用于安装不同的python模块。它是一个命令行工具，为安装不同的 python 模块提供了一个无缝的界面。它在 Internet 上搜索软件包并将它们安装到工作目录中，而无需与用户进行任何交互。其语法是：

pip install <package_name>

80.python中是否有识别bug和进行静态分析的工具？

是的，有像 PyChecker 和 Pylint 这样的工具，它们分别用作静态分析和 linting 工具。PyChecker 有助于查找 Python 源代码文件中的错误，并针对代码问题及其复杂性发出警报。Pylint 检查模块的编码标准并支持不同的插件以启用自定义功能以满足此要求。

81.区分深拷贝和浅拷贝。

• 浅拷贝的任务是创建存储原始元素引用的新对象。这不会通过递归来创建嵌套对象的副本。它只是复制嵌套对象的参考细节。
• 深拷贝创建对象的一个​​独立的新副本，甚至递归地复制原始元素的所有嵌套对象。

82.python中的main函数是什么？你如何调用它？

在编程语言的世界中，main 被认为是程序执行的入口点。但是在python中，众所周知，解释器是逐行串行解释文件的。这意味着python没有main()明确提供函数。但这并不意味着我们不能模拟 main 的执行。这可以通过定义用户定义main()函数和使用__name__python 文件的属性来完成。这个__name__变量是一个特殊的内置变量，指向当前模块的名称。这可以按如下所示完成：

def main():
   print("Hi Interviewbit!")
if __name__=="__main__":
   main()

Python常见面试题有哪些？Python 编程示例

83. 编写接受可变数量参数的 python 函数。

接受可变参数的函数称为函数原型。句法：

def function_name(*arg_list)

例如：

def func(*var):
   for i in var:
       print(i)
func(1)
func(20,1,6)

函数参数中的 * 表示函数中的可变参数。

84. WAP（编写程序），它采用一系列数字并检查所有数字是否唯一。

你可以通过使用 set() 方法将列表转换为集合并将此集合的长度与原始列表的长度进行比较来完成此操作。如果发现相等，则返回 True。

def check_distinct(data_list):
 if len(data_list) == len(set(data_list)):
   return True
 else:
   return False;
print(check_distinct([1,6,5,8]))     #Prints True
print(check_distinct([2,2,5,5,7,8])) #Prints False

85. 编写一个程序来计算给定文本文件的每个字符的数量。

这个想法是使用集合和 pprint 模块，如下所示：

import collections
import pprint
with open("sample_file.txt", 'r') as data:
 count_data = collections.Counter(data.read().upper())
 count_value = pprint.pformat(count_data)
print(count_value)

86. 编写一个程序来检查和返回给定数组 A 的和值等于目标值 N 的对。

这可以通过使用散列现象轻松完成。我们可以使用哈希映射来检查数组的当前值 x。如果映射的值为 (Nx)，那么就有我们的对。

def print_pairs(arr, N):
   # hash set
   hash_set = set()
    
   for i in range(0, len(arr)):
       val = N-arr[i]
       if (val in hash_set):    #check if N-x is there in set, print the pair
           print("Pairs " + str(arr[i]) + ", " + str(val))
       hash_set.add(arr[i])

# driver code
arr = [1, 2, 40, 3, 9, 4]
N = 3
print_pairs(arr, N)

87. 编写一个程序，在不使用加号运算符的情况下将两个大于 0 的整数相加。

我们可以使用按位运算符来实现这一点。

def add_nums(num1, num2):
   while num2 != 0:
       data = num1 & num2
       num1 = num1 ^ num2
       num2 = data << 1
   return num1
print(add_nums(2, 10))

88. 假设 a,b,c,m,n,o 是常数，编写一个程序来求解给定的方程：

ax + by = c
mx + ny = o

通过求解方程，我们得到：

a, b, c, m, n, o = 5, 9, 4, 7, 9, 4
temp = a*n - b*m
if n != 0:
   x = (c*n - b*o) / temp
   y = (a*o - m*c) / temp
   print(str(x), str(y))

89. 编写一个程序来匹配包含字母“a”后跟 4 到 8 个“b”的字符串。

Python面试题解析：这里我们可以使用python的re模块进行正则表达式的比较。

import re
def match_text(txt_data):
       pattern = 'ab{4,8}'
       if re.search(pattern,  txt_data):    #search for pattern in txt_data
           return 'Match found'
       else:
           return('Match not found')
print(match_text("abc"))         #prints Match not found
print(match_text("aabbbbbc"))    #prints Match found

90. 编写程序将日期从 yyyy-mm-dd 格式转换为 dd-mm-yyyy 格式。

我们可以再次使用 re 模块来转换日期字符串，如下所示：

import re
def transform_date_format(date):
   return re.sub(r'(\d{4})-(\d{1,2})-(\d{1,2})', '\\3-\\2-\\1', date)
date_input = "2021-08-01"
print(transform_date_format(date_input))

你还可以使用 datetime 模块，如下所示：

from datetime import datetime
new_date = datetime.strptime("2021-08-01", "%Y-%m-%d").strftime("%d:%m:%Y")
print(new_data)

91. 编写一个程序来组合两个不同的字典。合并时，如果找到相同的键，则可以将这些相同键的值相加。输出新字典

我们可以使用 collections 模块中的 Counter 方法

from collections import Counter
d1 = {'key1': 50, 'key2': 100, 'key3':200}
d2 = {'key1': 200, 'key2': 100, 'key4':300}
new_dict = Counter(d1) + Counter(d2)
print(new_dict)

92. 你将如何访问存储在 Google Drive 中的 CSV 格式的公开共享电子表格的数据集？

https://docs.python.org/3/我们可以使用 io 模块中的 StringIO 模块从 Google Drive 链接中读取，然后我们可以使用获得的数据源使用 Pandas 库。

from io import StringIO
import pandas
csv_link = "https://docs.google.com/spreadsheets/d/..."
data_source = StringIO.StringIO(requests.get(csv_link).content))
dataframe = pd.read_csv(data_source)
print(dataframe.head())

结论：

在本Python最佳面试题合集中，我们看到了 Python 开发人员的常见面试问题。这些问题以及定期的问题练习将帮助你破解任何基于 Python 的面试。多年来，python 因其简单性和支持强大计算的能力而在开发人员社区中广受欢迎。因此，对优秀 Python 开发人员的需求不断增长。尽管如此，值得一提的是，成为一名 Python 开发人员的福利真的很好。除了 Python 的理论知识外，还强调编写高质量代码的能力。所以，继续学习，继续练习问题，毫无疑问，你可以破解任何面试。