90+ Python 面试问答（2024 版）

90+ Python 面试问答（2024 版）

一、介绍

欢迎来到准备数据科学工作面试的第一步。这里有一个全面而广泛的 Python 面试问题和答案列表，可帮助您在面试中取得好成绩并获得理想的工作！Python 是一种解释型通用编程语言，由于其在人工智能 （AI） 中的使用，如今需求量很大。因此，每个有志于数据科学的人都必须对 Python 中使用的函数有深刻的理解。当您为即将到来的面试深入研究 Python 时，这些 Python 面试问题肯定会引导您走向成功。

二、Python 面试问题

本文涵盖了一些重要且经常被问到的 Python 编码面试问题和 Python 编程面试问题，以帮助有志于数据科学的人很好地掌握该主题。通过这篇文章，您将全面了解 python 面试编码问题。

Python面试问题和Python编码面试问题和答案

2.1 问题1.使用一行代码将给定字符串转换为 int。

答。我们可以使用内置函数 int（） 将给定的字符串转换为整数。例如-

a = ‘5’ print(int(a))
变量“a”是一个字符串，现在已转换为整数，如下所示：

输出：

5

2.2 问题2.编写代码片段以将字符串转换为列表。

下面是在 Python 中将字符串转换为列表的代码。

str1 = “Analytics Vidhya”
print(str1.split(" "))
split（） 函数通过定义的分隔符分隔给定的字符串，即这里的 space（“ ”）。因此，Analytics 和 Vidhya 在列表中分解为两个字符串。

输出：

[‘分析’， ‘Vidhya’]

2.3 问题3.编写代码片段以反转字符串。

答。在这里，我们在不使用任何内置函数的情况下反转了一个字符串。

str1 = “Analytics Vidhya”
str2 = “”
for i in str1:
str2 = i + str2
print("The original string is: ", str1)
print("The reversed string is: ", str2)
上面的代码选择第一个字母，即“A”，然后在开头添加“n”。
此外，“nA”被当作str2，“a”被添加到它之前，依此类推。
然后“anA”变为 str2，下一个字母，即“l”，附加在 str2 的开头，使其成为“lanA”。
这就是上面的代码反转字符串的工作方式。

输出：

ayhdiV scitylanA

2.4 问题4.编写代码片段以在 Python 中对列表进行排序。

答。我们可以使用 sort（） 函数在 Python 中对列表进行排序。以下代码将对此进行说明：

my_list = [3, 2, 1]
my_list.sort()
print(my_list)
上面的代码使用 sort（） 函数对列表进行排序。

输出：

[1, 2, 3]

2.5 问题5.可变和不可变有什么区别？

可变对象：一旦定义，它们就可以更新。例如，列表。
不可变对象：无法更新。例如，元组。

2.6 问题6.如何在 Python 中删除文件？

答。我们可以使用 os 模块在 Python 中删除文件。os 模块的 remove（） 函数用于通过将文件名作为参数传递来删除 Python 中的文件。例如：

import os
os.remove(“txt1.txt”)

2.7 问题7.如何访问列表的元素？

答。可以使用 [index] 访问列表中list_name元素。例如：

给定一个列表 [1， 2， 3， 4]。

列表的索引从 0 开始。

可以使用 list[0] 访问列表的第一个元素，它将打印元素 “1”。

第二个元素可以使用 list[1] 等方式访问。

2.8 问题8.讨论从列表中删除元素的不同方法。

答。有两种方法可以从列表中删除元素：

1.通过使用 remove（） 功能

remove （） 函数从列表中删除提到的元素。

list1 = [1, 2, 3, 4]
list1.remove(2)
print(list1)
输出：

[1, 3, 4]
2.通过使用 pop（） 功能

Pop（） 函数删除列表中特定索引处提到的元素

list1.pop(1)
print(list1)
输出：

[1, 4]

2.9 问题9.编写代码片段以删除整个列表。

答。我们可以使用 clear（） 函数在 Python 中删除列表。以下代码将对此进行说明：

list1 = [1, 2, 3, 4]
list1.clear()
它将删除整个列表。

2.10 问题10.编写代码片段以反转数组。

答。反转数组的两种方法如下：

1.使用 flip（） 功能

import numpy as np
arr1 = np.array([1, 2, 3, 4])
arr2 = np.flip(arr1)
print(arr2)
输出：

[4, 3, 2, 1]
2.不使用任何功能

import numpy as np
arr1 = np.array([1, 2, 3, 4])
arr2 = arr1[::-1]
print(arr2)
输出：

[4,3,2,1]

2.11 问题11.编写代码片段以获取元素、删除元素和更新数组中的元素。

答：访问：我们可以使用 array_name[index] 访问数组的元素。

print(arr[index])
删除：我们可以使用 delete（） 函数删除数组的元素。

import numpy as np
arr2 = [1, 2, 3, 4]
x = np.delete(arr2, 0)
print(x)
输出：

[2,3,4]
更新：我们可以使用以下语法更新数组的元素：

array_name[index] = element

2.12 问题12.编写代码片段以连接列表。

答：假设，给定两个列表是：

List1= [“W”, “a”, “w”,”b”]List2 = [“e”, “ “,”riting”,”log”]
输出应为：

[‘我们’， ‘一个’， ‘写作’， ‘博客’]
这可以使用 zip（） 函数连接两个列表，该函数遍历两个列表并按索引组合它们。

lst1 = [‘W’, ‘a’, ‘w’, ‘b’]
lst2 = [‘e’, ’ ', ‘riting’, ‘log’]
lst3 = [x + y for x, y in zip(lst1, lst2)]
print(lst3)
输出：

[‘我们’， ‘一个’， ‘写作’， ‘博客’]

2.13 问题13.编写代码片段以生成列表每个元素的平方。

答。首先，创建一个空列表。我们使用 for 循环遍历列表的每个元素，并将元素乘以元素本身以生成它的平方。然后，将其附加到新生成的列表中。

lst = [1, 2, 3, 4]
lst_final = []
for x in lst:
lst_final.append(x * x)
print(lst_final)
for 循环获取第一个元素，即 1，将其与自身相乘，然后将其附加到列表中。然后，它获取第二个元素，即 2，将其乘以自身，将其附加到列表中，依此类推。

输入：[1， 2， 3， 4]

输出：[1、4、9、16]

2.14 问题14.range 和 xrange 有什么区别？

答。在 Python 2 中，range（） 返回一个列表，xrange（） 返回一个迭代器。但在 Python 3 中，xrange（） 不再存在，而 range（） 返回一个迭代器。

2.15 问题15.Python 中的酸洗和拔酸是什么？

Pickling 是将 Python 对象（列表、字典、函数等）转换为字节流（0 和 1），而 unpickling 是将字节流转换回 python 对象。它用于传输和存储各种 Python 对象。为此，我们可以使用 pickle 或 dill Python 包。

2.16 问题16.Python 中的 init 是什么？

答：init 方法在 Python 中用于在创建对象时初始化对象的属性。因此，它类似于 Java 或 C++ 中的构造函数。它在类中声明为保留方法。

2.17 问题17.什么是 PEP-8 风格指南？

答。这是推荐的编码约定指南，以便于代码的可读性。由于多人在同一个项目上工作，因此最好遵循相似的风格，以获得更好的可读性和一致性。但是，如果有必要偏离惯例，我们可以用我们的判断来遵循什么风格。

2.18 问题18.Python 列表和 Numpy 数组哪个更快，为什么？

答：NumPy 数组在数值运算方面明显比 Python 列表快。NumPy 是一个开源库，专为 Python 中的高效数组操作而设计，利用 C 语言中的优化实现。与解释的 Python 列表不同，NumPy 数组是以编译语言执行的，从而显着提高了它们的性能。

Python 还包括一个用于基本操作的内置模块，可以使用 导入。arrayimport array as arr

2.19 问题19.Python 列表和元组有什么区别？

答。在 Python 中，列表是可以具有不同类型的对象的有序集合。列表是可变的，这意味着您可以更改列表元素的值，或者在列表中添加或删除元素。列表是使用方括号和逗号分隔的值列表创建的。

元组也是对象的有序集合，但它是不可变的，这意味着您不能更改元组元素的值，也不能在元组中添加或删除元素。

列表使用方括号 （[ ‘’ ]） 定义，而元组使用括号 （（‘’， ）） 定义。

列表具有多种用于添加、删除和操作元素的内置方法，而元组则没有这些方法。

通常，元组比 Python 中的列表快。

2.20 问题20.什么是 Python 集？解释集合的一些属性。

答。在 Python 中，集合是唯一对象的无序集合。集合通常用于存储不同对象的集合并执行成员资格测试（即，检查对象是否在集合中）。使用大括号（{ 和 }）和逗号分隔的值列表定义集合。

以下是 Python 中集合的一些关键属性：

集合是无序的：集合没有特定的顺序，因此您不能像使用列表或元组那样对它们进行索引或切片。
集合是唯一的：集合只允许唯一的对象，因此，如果尝试将重复的对象添加到集合中，则不会添加该对象。
集合是可变的：可以使用 add 和 remove 方法在集合中添加或删除元素。
集不编制索引：集不支持索引或切片，因此无法使用索引访问集的单个元素。
集合不可散列：集合是可变的，因此它们不能用作字典中的键或其他集合中的元素。如果需要将可变对象用作集合中的键或元素，则可以使用元组或冻结集合（集合的不可变版本）。

2.21 问题21.split 和 join 有什么区别？

Split 和 join 都是 Python 字符串的函数，但在功能方面完全不同。

split 函数用于从基于某些分隔符的字符串创建列表，例如空格。

a = ‘This is a string’
li = a.split(’ ')
print(li)
输出： [‘This’， ‘is’， ‘a’， ‘string’]

join（） 方法是 Python str 类的内置函数，它将字符串列表连接成一个字符串。它对分隔符字符串调用，并使用要联接的字符串列表进行调用。当字符串连接时，分隔符字符串将插入到列表中的每个字符串之间。

下面是如何使用 join（） 方法的示例：

“ “.join(li)
输出： 这是一个字符串

在这里，列表与中间的空格连接起来。

2.22 问题22.解释 Python 中的逻辑操作。

答。在 Python 中，逻辑运算 and、or 和 not 可用于对真值（True 和 False）执行布尔运算。

如果两个操作数均为 True，则 and 运算符返回 True，否则返回 False。

如果任一操作数为 True，则 or 运算符返回 True，如果两个操作数均为 False，则返回 False。

not 运算符反转其操作数的布尔值。如果操作数为 True，则不返回 False，如果操作数为 False，则不返回 True。

2.23 问题23.解释用于 Python 字符串的前 5 个函数。

答。以下是排名前 5 位的 Python 字符串函数：

len（）： 此函数返回字符串的长度。
s = ‘Hello, World!’
print(len(s))
13
条（）： 此函数从字符串中删除前导和尾随空格。
s = ’ Hello, World! ’
print(s.strip())
‘Hello, World!’
替换（）： 此函数将指定字符串的所有匹配项替换为另一个字符串。
s = ‘Hello, World!’
print(s.replace(‘World’, ‘Universe’))
‘Hello, Universe!’
分裂（）： 此函数根据分隔符将字符串拆分为子字符串列表。
s = ‘Hello, World!’
print(s.split(‘,’))
[‘Hello’, ’ World!']
upper（） 和 lower（）： 这些函数分别将字符串转换为大写或小写。
s = ‘Hello, World!’
print(s.upper())
‘HELLO, WORLD!’
s.lower()
‘hello, world!’
除了它们之外，string 还有 capitalize、isalnum、isalpha 和其他方法。

2.24 问题24.Python 中 pass 关键字有什么用？

答：Pass 是一个 null 语句，不执行任何操作。它通常用作占位符，其中在语法上需要语句，但不需要执行任何操作。例如，如果要定义函数或类，但尚未决定它应该做什么，则可以将传递用作占位符。

2.25 问题25.python 中 continue 关键字有什么用？

答：在循环中使用 Continue 来跳过当前迭代并转到下一个迭代。当遇到 continue 时，循环的当前迭代将终止，下一个迭代将开始。

2.26 问题26.什么是不可变和可变数据类型？

答。在 Python 中，不可变对象是创建后状态无法修改的对象。这意味着，一旦创建了不可变对象，就无法更改其值。Python 中不可变对象的示例包括数字（如整数、浮点数和复数）、字符串和元组。

另一方面，可变对象是创建后可以修改其状态的对象。这意味着您可以在创建可变对象后更改其值。Python 中可变对象的示例包括列表和字典。

了解 Python 中不可变对象和可变对象之间的区别非常重要，因为它会影响您在代码中使用和操作数据的方式。例如，如果您有一个数字列表，并且想要按升序对列表进行排序，则可以使用内置的 sort（） 方法来执行此操作。但是，如果您有一个数字元组，则不能使用 sort（） 方法，因为元组是不可变的。相反，您必须从原始元组创建新的排序元组。

2.27 问题27.python 中的 try 和 except 块有什么用？

答。Python 中的 try 和 except 块用于处理异常。异常是在程序执行过程中发生的错误。

try 块包含可能导致引发异常的代码。except 块包含在 try 块执行期间引发异常时执行的代码。

使用 try-except 块将保存代码，使其免于发生错误，并且可以使用我们想要的 except 块中的消息或输出来执行。

2.28 问题28.在 Python 中命名 2 种可变数据类型和 2 种不可变数据类型。

答：2 种可变数据类型是 Dictionary 和 List。您可以更改/编辑 Python 字典和列表中的值。没有必要创建一个新列表，这意味着它满足可变性属性。

2 种不可变数据类型是 Tuples 和 String。创建元组中的字符串或值后，无法对其进行编辑。您需要将值分配给元组或创建一个新元组。

2.29 问题29.什么是 Python 函数，它们如何帮助代码优化？

答。在 Python 中，函数是可以由程序的其他部分调用的代码块。函数很有用，因为它们允许您重用代码并将代码划分为可以单独测试和维护的逻辑块。

要在 Python 中调用函数，只需使用函数名称后跟一对括号和任何必要的参数即可。该函数可能会也可能不会返回一个值，该值取决于 turn 语句的用法。

函数还可以帮助代码优化：

代码重用：函数允许你通过将代码封装在单个位置并从程序的不同部分多次调用代码来重用代码。这有助于减少冗余，使代码更简洁、更易于维护。
提高可读性：通过将代码划分为逻辑块，函数可以使代码更具可读性和更易于理解。这样可以更轻松地识别错误并更改代码。
更轻松的测试：函数允许您单独测试单个代码块，从而更轻松地查找和修复错误。
改进性能：函数还允许使用优化的代码库或允许 Python 解释器更有效地优化代码，从而帮助提高代码的性能。

2.30 问题30.为什么NumPy在数据科学领域大受欢迎？

NumPy（Numerical Python 的缩写）是 Python 中流行的科学计算库。它在数据科学社区中广受欢迎，因为它为处理大型数组和数值数据矩阵提供了快速高效的工具。

NumPy 提供对数值数据数组和矩阵的快速高效操作。它在后台使用优化的 C 和 Fortran 代码来执行这些操作，这使得它们比使用 Python 内置数据结构的等效操作快得多。它为处理大型数组和数值数据矩阵提供了快速高效的工具。

NumPy 提供了大量用于对数组和矩阵执行数学和统计运算的函数。

它允许您有效地处理大量数据。它提供了用于处理不适合内存的大型数据集的工具，例如用于在磁盘上读取和写入数据以及一次仅将数据集的一部分加载到内存中的函数。

NumPy 与 Python 中的其他科学计算库很好地集成，例如 SciPy（科学 Python）和 pandas。这使得将 NumPy 与其他 Python 库一起使用以执行更复杂的数据科学任务变得容易。

2.31 问题31.解释列表理解和听写理解。

答：列表推导和字典推导都是从现有可迭代对象创建新列表或词典的简洁方法。

列表推导是创建列表的简洁方法。它由方括号组成，其中包含一个表达式，后跟一个 for 子句，然后是零个或多个 for 或 if 子句。结果是一个新列表，该列表在 for 和 if 子句的上下文中计算表达式。

Dict comprehension 是创建词典的简洁方法。它由包含键值对的大括号组成，后跟一个 for 子句，然后是零个或多个 for 或 if 子句。结果是一个新字典，用于在 for 和 if 子句的上下文中计算键值对。

2.32 问题32.Python 中的全局变量和局部变量是什么？

答。在 Python 中，在任何函数或类外部定义的变量是全局变量，而在函数或类内部定义的变量是局部变量。

可以从程序中的任何位置访问全局变量，包括函数和类内部。但是，局部变量只能在定义它的函数或类中访问。

需要注意的是，可以对全局变量和局部变量使用相同的名称，但局部变量将优先于定义全局变量的函数或类中的全局变量。

# This is a global variable
x = 10
def func():
    # This is a local variable
    x = 5
    print(x)
func()
print(x)

输出： 这将打印 5 个，然后打印 10 个

在上面的示例中，func（） 函数中的 x 变量是局部变量，因此它优先于全局变量 x。因此，当 x 在函数内部打印时，它打印 5;当它在函数之外打印时，它会打印 10。

2.33 问题33.什么是有序词典？

答。有序字典（也称为 OrderedDict）是内置 Python 字典类的子类，用于维护添加这些字典的元素的顺序。在常规字典中，元素的顺序由其键的哈希值决定，随着字典的发展和演变，这些哈希值会随着时间的推移而变化。另一方面，有序字典使用双链表来记住元素的顺序，因此无论字典如何更改，都会保留元素的顺序。

2.34 问题34.return 和 yield 关键字有什么区别？

答：Return 用于退出函数并向调用方返回值。当遇到 return 语句时，函数会立即终止，并且 return 语句后面的表达式的值将返回给调用方。

另一方面，Yield 用于定义生成器函数。生成器函数是一种特殊的函数，它一次生成一个值序列，而不是返回单个值。当遇到 yield 语句时，生成器函数会生成一个值并暂停其执行，从而保存其状态以供以后使用。

2.35 问题35.Python 中的 lambda 函数是什么，为什么它们很重要？

答：Python 支持 lambda 函数，这是一个小型匿名函数。当您不想使用 def 关键字定义函数时，可以使用 lambda 函数。

当您在短时间内需要小型函数时，Lambda 函数非常有用。它们通常与高阶函数结合使用，例如 map（）、filter（） 和 reduce（）。

下面是 Python 中 lambda 函数的示例：

a = lambda x: x + 10
a(5)

15

在此示例中，lambda 函数接受一个参数 （x） 并向其添加 10。lambda 函数在调用时返回此操作的结果。

Lambda 函数非常重要，因为它们允许您以简洁的方式创建小型匿名函数。它们通常用于函数式编程，这是一种强调使用函数解决问题的编程范式。

2.36 问题36.Python 中“assert”关键字有什么用？

答。在 Python 中，assert 语句用于测试条件。如果条件为 True，则程序继续执行。如果条件为 False，则程序将引发 AssertionError 异常。

assert 语句通常用于检查程序的内部一致性。例如，在对列表执行二进制搜索之前，可以使用 assert 语句来检查列表是否已排序。

请务必注意，assert 语句用于调试目的，而不是用作处理运行时错误的方法。在生产代码中，应使用 try 和 except 块来处理运行时可能引发的异常。

2.37 问题37.Python 中的装饰器是什么？

答。在 Python 中，装饰器是一种在不更改源代码的情况下修改或扩展函数、方法或类的功能的方法。装饰器通常实现为将另一个函数作为参数并返回具有所需行为的新函数的函数。

我们可以通过在使用@decorator_function语法应用的函数之前添加它来使用 decorator 函数。

2.38 问题38.Python 中的内置数据类型是什么？

答。Python 中的 5 种内置数据类型是：None 类型、数值类型（int、float、complex、bool）、序列类型（list、tuple、range、str）、Map 类型（字典）和 Set 类型（set、frozenset）。

2.39 问题39.套装和冷冻套装有什么区别？

答。冻结集是集合的不可变变体，就像元组是不可变的变体列表一样。

2.40 问题40.我们在哪里可以使用元组而不是列表？

答。我们可以将元组用作字典键，因为它们是可哈希的。由于元组是不可变的，因此如果我们不希望值更改，则使用元组会更安全。元组速度更快，内存更少，因此我们可以使用元组仅访问元素。

2.41 问题41.在 Python 列表中删除第一项或最后一项所需的时间是否相同？

答：不，删除最后一项是 O（1），而删除第一项是 O（n）

2.42 问题42.我们如何有效地从列表中删除任何元素？

答。我们可以使用集合模块中的 deque，该模块作为双向链表实现，以更快地删除任何索引中的元素。

2.43 问题43.什么是负索引？

答：Python 序列数据类型可以使用正数和负数访问。对于负索引，-1 表示最后一个元素，-2 表示倒数第二个元素，依此类推。

2.44 问题44.为什么浮点计算在 Python 中看起来不准确？

答。虽然在十进制系统中表示浮点数（如 2.5）更容易，但在二进制系统中表示浮点数需要大量信息。由于位数有限，浮点计算中可能存在舍入误差。

2.45 问题45.Python 中的文档字符串是什么？

Docstring 是文档字符串的缩写形式。它是一种字符串类型，用于记录函数或类的工作原理、其各种输入参数以及函数或类用法的任何示例。它用三引号（“”“）括起来。编写良好的文档字符串可帮助人们理解函数或类的用法。

2.46 问题46.Python 中的 args 和 *kwargs 是什么？

args 和 *kwargs 是分别用于表示可变长度参数和可变长度关键字参数的语法。这里和 * 代表语法，而 args 和 kwargs 是约定俗成的词。我们也可以使用其他词。

2.47 问题47.Python 中的生成器是什么？

答。Python 中的生成器返回一个迭代器，该迭代器一次生成一个值序列。我们使用 yield 关键字来生成值。

2.48 问题48.生成器在 Python 中有什么用？

答。由于生成器不会同时生成所有值，因此如果我们使用生成器处理值序列而无需保存初始值，则可以节省内存。

2.49 问题49.我们如何同时遍历多个列表？

答。我们可以使用 zip（） 函数聚合多个列表并返回元组的迭代器，其中每个元组包含同一索引的不同列表的元素。

2.50 问题50.向列表添加元素有哪些方法？

答。以下是向列表添加元素的各种方法：

我们可以使用 insert（） 将给定的索引添加到现有列表中。
我们可以使用 append（） 在列表末尾添加单个项目。
我们可以使用 extend（） 在列表末尾分别添加可迭代（列表、元组或集合）的每个元素。
我们还可以使用 + 运算符连接两个列表，类似于 extend，但它仅适用于一个列表到另一个列表，而不适用于一个列表到另一个元组或集。
问题51.编写一个程序来检查一个数字是否是质数。
答。

from math import sqrt

def prime_or_not(number):
    for i in range(2, int(sqrt(number)) + 1):
        if number % i == 0:
            return 0
    return 1

2.52 问题52.上述程序的时间复杂度是多少，有没有更快的方法？

答。它的时间复杂度为 O（sqrt（n））。我们可以用埃拉托色尼的筛子更快地做到这一点。

2.53 问题53.交换两个元素值的方法有哪些？

答。一种方法是使用第三个变量

temp = a
a = b
b = temp
在 Python 中，我们也可以在不使用第三个变量的情况下做到这一点

a， b = b， a

2.54 问题54.用 Python 编写一个程序，使用递归返回给定数字的阶乘。

答。

def factorial(n):
if n == 1:
return n
else:
return n * factorial(n - 1)

2.55 问题55.有没有办法比上面更快地计算阶乘？

答。我们可以使用分而治之算法技术来更快地计算。它是在内置的数学库中实现的，带有 math.factorial（）。

2.56 问题56.如何使用 lambda 函数在列表中找到最小值？

答。

from functools import reduce

reduce(lambda x, y: x if x < y else y, b)

这将给出列表中的最小值。

2.57 问题57.编写代码以将字符列表转换为以逗号分隔的字符串。

答。

‘,’.join(list)

2.58 问题58.编写代码以使用列表推导仅选择奇数。

答。

[i for i in range(n) if i%2 != 0]

2.59 问题59.del 和 remove on lists 有什么区别？

答：‘Remove’ 删除给定元素的第一个出现项。“Del”根据给定的索引删除元素。

2.60 问题60.编写代码以获取字典中的最小值。

答。

dict_[min(dict_.keys(), key=(lambda k: dict_[k]))

2.61 问题61.编写一个程序以返回元组的平均值。

答。

def mean_tuple(numbers):
    result = [sum(x) / len(x) for x in zip(*numbers)]
    return result

2.62 问题62.self 在 Python 中有什么用？

答：Self 用于表示类的实例。有了这个，我们可以使用对象访问类的属性和方法。它将对象的属性与给定的参数绑定。自我不是一个关键词。我们也可以使用任何其他非关键字，但最好遵循惯例。

2.63 问题63.Python OOP 中有哪些不同类型的变量？

答：Python OOP（面向对象编程）中的 3 种不同类型的变量是：

类变量：它们在类内部定义，但在其他方法之外定义，并且可用于类的任何实例访问。
实例变量：它们分别为类的每个实例定义，并可由该类实例访问。
局部变量：它们在方法内部定义，并且只能在该方法中访问。

2.64 问题64.Python OOP 中有哪些不同类型的方法？

答：Python OOP 中的 3 种不同类型的方法是：

类方法：它们只能访问类变量，并用于修改类状态。
实例方法：它们可以访问类和实例变量，并用于修改对象（类的实例）状态。
静态方法：它们不能访问类或实例变量，并且可用于适合在不访问类或实例变量的情况下位于类中的函数。

2.65 问题65.什么是继承，它有什么用？

答。通过继承，我们可以在子类中使用父类的属性和方法。我们还可以修改父类方法以适应子类。

2.66 问题66.什么是访问说明符？

答。我们可以使用 （underscore） 或 _（double underscore） 来表示受保护变量和私有变量。它们可用于限制对类属性的访问。

2.67 问题67.在numpy中，array[：， 0]与array[：[0]]有何不同？

答：array[：， 0] 返回第 1 列作为一维数组。

array[：， [0]] 返回第一列作为多维数组。

2.68 问题68.我们如何检查只有零的数组？

答。我们可以使用数组的 size 方法来检查它是否返回 0。那么这意味着数组只能包含零。

2.69 问题69.我们如何连接两个数组？

答。我们可以使用连接方法。

import numpy as np

a = np.array([[10, 4], [8, 12]])
b = np.array([[15, 6]])
c = np.concatenate((a, b), axis=0)

结果将是
[[10， 4]
[8， 12]
[15， 6]]

您也可以观看 Python 面试问答视频

2.70 问题70.我们如何检查数组的局部最大值？

答。局部最大值是比其两侧的两个相邻点大的点。在给定数组中，以下代码可以生成局部最大值点。

np.where((arr[1:-1] > arr[0:-2]) * (arr[1:-1] > arr[2:]))[0] + 1

2.71 问题71.split（） 和 array_split（） 有什么区别？

答。split（） 函数用于将数组拆分为 n 个相等的部分。如果无法将其拆分为相等数量的部分，则 split（） 会引发错误。另一方面，array_split（） 将数组拆分为 n 个不相等的部分。

2.72 问题72.编写代码以在数组中所有元素的字符之间插入逗号。

答。

resulted_arr = np.char.join(“,”, array)

2.73 问题73.如何将 1 添加到现有数组的所有边？

答。我们可以使用 numpy 的 pad 方法。

New_arr = np.pad(existing_arr, pad_width=1, mode=‘constant’,
constant_values=1)

2.74 问题74.我们如何交换 numpy 数组的轴？

答。我们可以使用 swapaxes 方法。

np.swapaxes(arr,0,1)

2.75 问题75.如何获取给定数组中 n 个最大值的索引？

argsort（） 方法返回可以对数组进行排序的索引。

array.argsort( ) [ -N: ][: : -1]
这给出了 n 个最大值的索引。

2.76 问题76.什么是熊猫中的分类数据？

答。当一个变量采用有限数量的可能值时，我们可以为该变量使用类别数据类型，该变量在内部用数字表示，因此处理速度更快。

2.77 问题77.如何在数据帧中将 true/false 值转换为 1/0？

答。

df[“column”] = df[“column”].astype(int)

2.78 问题78.loc（） 和 iloc（） 有何不同？

答：loc（） 用于使用标签访问行或列，而 iloc（） 用于使用基于位置的索引进行访问。

2.79 问题79.如何按两列对数据帧进行排序？

答。

df.sort_values(by=[‘col1’, ‘col2’])

2.80 问题80.查找具有给定列的最大值的行。

答。为此，我们可以使用 idmax 方法。

df[‘column’].idxmax()
这将返回具有指定列的最大值的行索引。

2.81 问题81.如何将包含字符串的列拆分为多列？

答。

df[‘column’].str.split(pat=” ”, expand=True)
在这里，我们可以指定使用 pat 参数拆分列的模式。

2.82 问题82.map（） 和 applymap（） 有什么区别？

答。虽然它们可以用于元素操作，但 map（） 用于系列，而 applymap（） 用于数据帧。

2.83 问题83.如何将查询的 True 值转换为 False，反之亦然？

答。我们可以使用波浪号（~）运算符将True值转换为False，反之亦然。

2.84 问题84.我们如何找到从一行到另一行的百分比变化？

答。我们可以使用以下代码来查找上一行与当前行之间的百分比变化。

df.pct_change(periods=1)

2.85 问题85.我们如何找到数据框列的方差系数？

答。由于方差系数是标准差除以平均值，因此我们可以使用 df.std（）/df.mean（）

2.86 问题86.我们如何删除字符串的前导空格？

答。我们可以使用 .lstrip（） 方法删除字符串的前导空格。

2.87 问题87.Python 中的 enumerate（） 是什么？

答：Python 中的 enumerate（） 会迭代一个序列并返回索引位置及其对应值。

2.88 问题88.什么是深拷贝和浅拷贝？

答：Deepcopy 将对象的内容复制到另一个位置。在一个对象中所做的更改不会影响另一个对象。在浅拷贝中，仅复制引用。因此，在一个对象中所做的更改会影响另一个对象。

2.89 问题89.Python 中的可调用对象是什么？

答。可以调用进程的对象是可调用的对象。它使用 call 方法。函数就是这方面的例子。可调用对象的末尾有 （），而不可调用方法的末尾没有 （）。

2.90 问题90.如何使用 Numpy 找到列表的唯一元素和值计数？

答。我们可以使用 numpy.unique（list， return_counts=True）
这将返回两个数组中的值及其计数。

2.91 问题91.NumPy 中的索引和切片有什么区别？

答：索引创建索引，而切片创建浅拷贝。可以进行不同类型的索引，但没有切片类别。