Python 面试问题与答案

2025年4月14日 | 42分钟阅读

下面为初学者和有经验者整理了常问的 Python 面试问题及答案。

1) 什么是 Python？

Python 是一种高级的、解释型的编程语言，以其简单性和可读性而闻名。Python 由 Guido Van Rossum 创建，并于 1991 年首次发布。

它是一种面向对象的高级语言，在 Windows、Linux、UNIX 和 Macintosh 上同样运行良好。它内置了高级数据结构，以及动态绑定和动态类型。Python 专注于代码的可读性和表达性，因此吸引了许多开发者用它来进行多种应用开发，包括 Web 开发、数据分析、人工智能、科学计算等。

开发应用程序所需的代码更少，而且简单易学。

它被广泛用于

Web 开发（服务器端）。
软件创建。
数学计算。
系统脚本编写。
数据分析与可视化。
机器学习和人工智能。
游戏开发。
网络爬虫。
桌面 GUI 应用程序。

阅读更多：Python 教程

2) 为什么选择 Python？

Python 是一种具有动态语义的、面向对象的高级解释型编程语言。
Python 适用于 Windows、Mac、Linux、Raspberry Pi 和其他平台。
与其他编程语言相比，Python 允许开发者用更少的代码行编写程序。
庞大的标准库减少了对外部资源的依赖，从而简化了开发。
Python 拥有一个活跃且支持性的社区，提供丰富的资源、建议和庞大的第三方包生态系统。
该软件的跨平台兼容性保证了在不同操作系统上的流畅运行，从而使其更易于访问和使用。
Python 的语法用户友好，易于学习，使其成为初学者和高级开发者的绝佳选择。
因为 Python 在解释器系统上运行，代码可以在编写后立即执行。这有助于快速提供原型。
Python 可以用过程式、面向对象或函数式的方式来描述。
对于所有主流平台，Python 解释器和庞大的标准库都可以免费以二进制或源代码形式分发。

阅读更多：为什么 Python 如此受欢迎

3) Python 可以用于哪些类型的应用程序？

Python 被用于多个软件领域，下面列出了一些。

Web 和互联网游戏，科学和计算应用程序开发，语言开发
图像处理和图形设计应用，企业和商业应用开发
操作系统开发，基于图形用户界面 (GUI) 的桌面应用程序。
Web 应用程序开发 Django、Pyramid 和 Flask 是最知名的 Python Web 框架。
Python 的标准库支持处理电子邮件、FTP、IMAP 和其他互联网协议。
SciPy 和 NumPy 这两个 Python 模块有助于科学和计算应用程序的开发。
Python 的 Tkinter 库支持创建基于桌面的 GUI 应用程序。

阅读更多：Python 编程的应用

4) Python 有什么优点？

Python 的优点是

Python 是一种解释型语言

解释型：Python 是一种解释型语言。它不需要事先编译代码，而是直接执行指令。

它是免费且开源的

免费且开源：它是一个开源项目，可供公众重复使用。可以免费下载。

它是可扩展的

可扩展：它非常灵活，可以与任何模块进行扩展。

它是一种面向对象的编程语言

面向对象：Python 允许实现面向对象的概念来构建应用程序解决方案。

它有内置的数据结构

内置数据结构：元组、列表和字典是该语言提供的有用的集成数据结构。

可读性

可读性： Python 专注于可读性，因此其简单清晰的语法使得代码维护成本更低。开发者无需费力解读代码，因为代码编写和理解都变得更容易，因此程序开发速度更快，错误更少，同时为其实践增添了更广泛的练习和乐趣。

高级语言
跨平台

跨平台： Python 代码可以在不同平台和操作系统上运行而无需更改，例如 Windows、macOS、Linux 和 Unix。这种跨平台兼容性使得 Python 成为需要跨不同操作系统运行的应用程序开发的首选。

可移植：Python 程序可以跨平台运行而不影响其性能。

阅读更多：Python 的优点和应用

5) 什么是 PEP 8？

Python 增强提案，也称为 PEP 8，是一份提供如何编写 Python 代码指导的文件。本质上，它是一套格式化 Python 代码以实现最大可读性的指南。它由 Guido van Rossum、Barry Warsaw 和 Nick Coghlan 于 2001 年编写。

PEP 8 涵盖了 Python 代码格式化的各个方面，包括

缩进
空白字符
命名约定
行长度
注释
导入
函数和方法定义
表达式和语句中的空格

阅读更多：Python 中的 PEP 8

6) 你说的 Python 字面量是什么意思？

字面量可以定义为赋予变量或常量的数据。Python 支持以下字面量

字符串字面量

文本可以包含在单引号或双引号中以创建字符串字面量。例如，字符串字面量是字符串的值。

示例

# in single quotes
single = 'tpointtech'
# in double quotes
double = "tpointtech"
# multi-line String
multi = '''Java 
           T 
               point'''
  
print(single)
print(double)
print(multi)

输出

tpointtech
tpointtech
Java 
           T 
               point

数字字面量

Python 支持三种类型的数字字面量：整数、浮点数和复数。

示例

# Integer literal  
a = 10  
#Float Literal  
b = 12.3   
#Complex Literal   
x = 3.14j  
print(a)
print(b)
print(x)

输出

10
12.3
3.14j

说明

在此代码中：
变量 'a' 存储整数常量 10。
变量 'b' 存储浮点数字面量 12.3。
变量 'x' 是复数字面量 3.14j。
每个变量打印时都会返回其值。对于复数字面量 x，它代表一个实部为 0.0，虚部为 3.14 的复数。

布尔字面量

布尔字面量用于表示布尔值。它只包含 True 或 False。

示例

p = (1 == True)
q = (1 == False)
r = True + 3
s = False + 7
  
print("p is", p)
print("q is", q)
print("r:", r)
print("s:", s)

输出

p is True
q is False
r: 4
s: 7

说明

在给定的 Python 代码中，p 为 True，因为 1 在布尔类型中等同于 True。q 为 False，因为 1 不等于 False。r = 4 且 s = 7，因为在数值上下文中，True 被视为 1，False 被视为 0。

特殊字面量

Python 包含一个独特的字面量，即 'None'。这个特殊的字面量用于定义一个空变量。如果 'None' 与除 'None' 之外的任何东西进行比较，它将返回 false。

示例

word = None
print(word)

输出

None

阅读更多：Python 中的字面量

7) 描述一下 Python 函数？

Python 函数是执行单一操作的命名代码块。它们由 `def` 关键字定义，后跟函数名、括号内的参数和冒号。在函数体内，当函数被调用时执行的代码是缩进的。函数可以接受输入参数，执行操作，并可选择使用 'return' 语句返回结果。它们促进了代码的可重用性、组织性和抽象性。

函数分为三类

内置函数：duplicate()、len()、count() 是一些内置的功能。

用户定义函数：用户定义函数是由用户定义的函数。

匿名函数：因为它们不是使用标准的 def 关键字声明的，所以这些函数也被称为 lambda 函数。

示例： 下面给出了用户定义函数的一般语法。

def function_name(parameters list):  
    #--- statements---  
    return a_value  

阅读更多：Python 函数

8) Python 中的 zip() 功能是什么？

Python 中的 zip() 函数返回一个 zip 对象，该对象在多个容器之间映射相同的索引。它接受一个可迭代对象，将其转换为迭代器，然后使用传递的可迭代对象来组合元素。它返回一个元组迭代器。

签名 zip(iterator1, iterator2, iterator3, 等等) 参数 iterator1, iterator2, 和 iterator3: 这些是连接在一起的迭代器对象。

返回它返回一个迭代器，该迭代器是两个或多个迭代器的乘积。

注意：如果给定的列表长度不同，当第一个列表结束时，zip 会停止创建元组。这意味着两个列表的长度为三，将产生一个长度为五的三元组。

9) Python 的参数传递系统是什么？

在 Python 中，有两种传递参数的机制

引用传递
值传递

默认情况下，所有参数（parameters）都以“引用传递”方式传递给函数。这样，如果您在函数内部更改了参数的值，这种更改也会反映在调用函数中。它显示的是原始变量。例如，如果一个变量以声明“a = 10”传递给一个函数，并且其值被更改为“a = 20”，那么两个变量都代表相同的值。

值传递是指无论何时我们将参数传递给函数，只有值会传递给函数，而没有引用传递给函数。这使得它不可变。尽管在函数中被修改，但任一变量的原始值保持不变。

Python 有一个默认的参数概念，它有助于使用任意数量的参数调用方法。

10) 在 Python 中，如何重载方法或构造函数？

在 Python 中，方法和构造函数的重载不像在 Java 或 C++ 等语言中那样得到支持。但是，您可以使用各种技术实现类似的功能，例如

通过使用默认参数。
通过使用可变参数。
通过使用函数参数。

示例

class student:  
    def __init__(self, name):  
        self.name = name  
    def __init__(self, name, email):  
        self.name = name  
        self.email = email  
       
# This line will generate an error  
#st = student("rahul")  
  
# This line will call the second constructor  
st = student("rahul", "rahul@gmail.com")  
print("Name: ", st.name)
print("Email id: ", st.email)

输出

Name:  rahul
Email id:  [email protected]

说明

该代码定义了一个名为'Student'的类。
它试图在类中定义两个 __init__ 方法，但由于 Python 的方法覆盖行为，只有最后一个会被采纳。
最后一个 '__init__' 方法接受两个参数：'name' 和 'email'，并相应地为实例属性赋值。
当一个 Student 对象同时使用 name 和 email 参数创建时，它会初始化 name 和 email 变量。
如果只使用 name 参数创建对象，则会抛出错误，因为该类没有默认构造函数。
要解决这个问题，您可以使用默认参数值或可变参数来实现类似构造函数重载的行为。

11) remove() 函数和 del 语句有什么区别？

用户可以使用 remove() 函数删除列表中的特定对象。

示例

list_1 = [ 3, 5, 7, 3, 9, 3 ] 
print(list_1)
list_1.remove(3) 
print("After removal: ", list_1)

输出

[3, 5, 7, 3, 9, 3]
After removal: [5, 7, 3, 9, 3]

说明

在这个例子中，列表 list_1 中第一次出现的 3 在索引 0 处被移除。给定的列表在移除后被修改，然后打印出来。新列表的开头没有值 3。

如果你想删除列表中特定位置（索引）的对象，你可以使用 del 或 pop。

示例

list_1 = [ 3, 5, 7, 3, 9, 3 ] 
print(list_1)
del list_1[2]
print("After deleting: ", list_1)

输出

[3, 5, 7, 3, 9, 3]
After deleting: [3, 5, 3, 9, 3]

说明

在这里，'第2个索引'处的元素（值7）被从list_1中删除，其中index[0]被使用。删除了索引为2的值为'7'的元素后，列表被打印出来，它不再包含值'7'。

注意：您不需要导入任何额外的模块来使用这些函数从列表中移除元素。

我们不能对元组使用这些方法，因为元组与列表不同。

12) Python 中的 swapcase() 函数是什么？

Python 中的 "swapcase()" 函数是一个字符串方法，它会创建一个新字符串，其中大写字符转换为小写，小写字符转换为大写。换句话说，它会切换字符串中每个字符的大小写。原始字符串不会被改变。

这里有一个演示'swapcase()'用法的例子

# Original string
original_string = "Hello World"
# Applying swapcase() function
swapped_string = original_string.swapcase()
# Output
print("Original string:", original_string)  # Output: Original string: Hello World
print("Swapped string:", swapped_string)    # Output: Swapped string: hELLO wORLD

输出

Original String: Hello World
Swapped String: hELLO wORLD

说明

这个例子显示了“swapcase()”函数将给定字符串“Hello World”中的大写字母转换为小写，小写字母转换为大写，从而得到转换后的字符串“hELLO wORLD”。

阅读更多：Python 字符串 swapcase() 方法

13) 如何从 Python 字符串中移除空白字符？

为了消除字符串中的前导和尾随空格，Python 提供了 strip([str]) 内置函数。在移除任何可能存在的空白字符后，此函数返回字符串的一个副本。否则，返回原始字符串。

示例

string = "  tpointtech "
string2 = "    tpointtech        "
string3 = "       tpointtech"
print(string)
print(string2)
print(string3)
print("After stripping all have placed in a sequence:")
print(string.strip())
print(string2.strip())
print(string3.strip())

输出

tpointtech 
    tpointtech        
       tpointtech
After stripping all have placed in a sequence:
tpointtech
tpointtech
tpointtech

说明

在此示例中
字符串 'string', 'string2' 和 `'string3' 在之前和/或之后包含空格。
'strip()' 方法将切掉字符串开头和结尾的这些空白字符。
调用'strip()'后，修改后的字符串被打印出来，它们都按顺序排列，并且字符串的开头和结尾都没有被空格包围。

14) 如何从 Python 字符串中移除前导空白？

我们可以使用 lstrip() 函数来去除字符串中的前导字符。它是一个 Python 字符串函数，带有一个可选的 char 类型参数。如果提供了参数，它会移除该字符。否则，它会剥离字符串的所有前导空格。

示例

string = "  tpointtech " 
string2 = "    tpointtech        "
print(string)
print(string2)
print("After stripping all leading whitespaces:")
print(string.lstrip())
print(string2.lstrip())

输出

tpointtech 
    tpointtech        
After stripping all leading whitespaces:
tpointtech 
tpointtech

说明

在此示例中
字符串 'string', 'string2' 和 `'string3' 在之前和/或之后包含空格。
'strip()' 方法将切掉字符串开头和结尾的这些空白字符。
调用'strip()'后，修改后的字符串被打印出来，它们都按顺序排列，并且字符串的开头和结尾都没有被空格包围。

剥离后，所有空格都被移除，现在字符串看起来像下面这样

阅读更多：如何在 Python 中移除字符串中的所有前导空白

15) 为什么我们在 Python 中使用 join() 函数？

join() 被定义为一个字符串方法，它返回一个字符串值。它与一个可迭代对象的元素连接起来。它提供了一种灵活的方式来连接字符串。请看下面的例子。

示例

str = "Rohan"
str2 = "ab"
# Calling function  
str2 = str.join(str2)  
# Displaying result  
print(str2)

输出

aRohanb

说明

在此示例中
将 "Rohan" 的每个字符与 "ab" 的每个元素连接起来。
得到的字符串是 "aRohanb"，其中 "Rohan" 的字符位于 "ab" 的字符之间。

阅读更多：Python 字符串 join() 方法

16) 举一个 shuffle() 方法的例子？

给定的字符串或数组使用此技术进行打乱。数组中的项目因此变得随机。random 模块包含了这个方法。因此，我们必须在调用函数之前导入它。它每次调用函数时都会重新排列组件并产生不同的结果。

示例

# import the random module
import random
# declare a list
sample_list1 = ['Z', 'Y', 'X', 'W', 'V', 'U']
print("Original LIST1: ")
print(sample_list1)
# first shuffle 
random.shuffle(sample_list1)
print("\nAfter the first shuffle of LIST1: ")
print(sample_list1)
# second shuffle
random.shuffle(sample_list1)
print("\nAfter the second shuffle of LIST1: ")
print(sample_list1)

输出

Original LIST1: 
['Z', 'Y', 'X', 'W', 'V', 'U']

After the first shuffle of LIST1: 
['V', 'U', 'W', 'X', 'Y', 'Z']

After the second shuffle of LIST1: 
['Z', 'Y', 'X', 'U', 'V', 'W']

说明

在此示例中
在原始'sample_list1'上执行的'print'过程的关联是'sample_list1'。
函数'shuffle()'用于打乱'sample_list1'中的元素。
打印第一次洗牌的结果。
再次使用'shuffle()'函数为列表中的元素提供一个随机顺序。
第二次洗牌后，列表再次被打印，每次都显示元素的不同排列。

阅读更多：Python 中的 Shuffle

17) break 语句的用途是什么？

在 Python 中，break 语句用于在满足指定条件时，在循环迭代结束前退出或终止循环。当在循环（例如 "for" 或 "while"）内部使用时，"break" 语句会导致循环立即终止，无论循环的条件或迭代顺序如何。

'break' 语句的主要用例包括

提前终止： Break 语句是编程流程的重要组成部分，它有助于在循环执行期间满足特定条件时中断循环，从而避免不必要的后续迭代。
退出无限循环： 当循环意图无限运行直到某个条件成功时，使用 break 语句退出循环。

示例

list_1 = ['X', 'Y', 'Z']
list_2 = [11, 22, 33]
for i in list_1:
    for j in list_2:
        print(i, j)
        if i == 'Y' and j == 33:
            print('BREAK')
            break
    else:
        continue
    break

输出

2
X 11
X 22
X 33
Y 11
Y 22
Y 33
BREAK

说明

外层循环应用于'list_1'的元素，以'X'作为起始值。
对于'i'的每个值，内层循环会逐个遍历'list_2'的元素。
在循环之间，首先打印 'i' 和 'j' 的组合。
当 i 为 'Y' 且 'j' 为 33 时，条件 if i == 'Y' and j == 33: 满足。
代码输出'BREAK'并使用break语句继续执行外层循环。
break 语句只退出内层循环，而不是外层循环。因此，外层循环仍然有效。由于循环通过 break 终止，内层定义下的 else 块没有被执行到。
外层循环继续并遇到 break，从而立即中断循环。

阅读更多：Python break 语句

18) Python 中的元组是什么？

元组是一种内置的数据集合类型。它允许我们将值存储在一个分组中。因为它不能被修改，所以原始数据不会反映任何更改。元组使用 () 括号创建，而不是 [] 方括号。我们无法移除任何元素，但可以在元组中找到它。索引允许我们获取元素。它同样允许使用负索引来反向导航元素。有多种元组方法，包括 Len()、max()、sum() 和 sorted()。

要创建一个元组，我们可以如下声明它。

示例

# Declaring tuple
tup = (2,4,6,8)
# Displaying value
print(tup)

# Displaying Single value
print(tup[2])

输出

(2, 4, 6, 8)
6

解释

元素对 'tup' 是 2, 4, 6, 和 8。
当我们执行函数 'print(tup)' 时，会显示由'(2, 4, 6, 8)'组成的元组。
'tup[2]' 使用索引从元组中访问单个值，结果为 6，这是元组值中索引为 2 的元素。

它是不可变的。所以更新元组会导致错误。

示例

# Declaring tuple
tup = (2,4,6,8)
# Displaying value
print(tup)

# Displaying Single value
print(tup[2])

# Updating by assigning new value
tup[2]=22
# Displaying Single value
print(tup[2])

输出

tup[2]=22 
TypeError: 'tuple' object does not support item assignment 
(2, 4, 6, 8)

说明

当调用 print(tup) 和 tup[2] 时，它们分别给出元组和索引的值（索引 2 处为 6），然后代码通过赋值 tup[2] = 22 将索引 2 处的值更改为 22。
然而，这个例子会产生一个 'TypeError'，因为元组具有不可变的特性，元素一旦创建就不能被改变。

阅读更多：Python 元组

19) Python 中有哪些与文件相关的库/模块？

您可以借助 Python 的库和模块来操作文件系统上的二进制和文本文件。它使得创建、编辑、复制和删除文件变得更加容易。

这些库是 os、os.path 和 shutil。其中，os 和 os.path - 模块包含一个用于访问文件系统的函数，而 shutil - 模块使您能够复制和删除文件。

阅读更多：Python 模块

阅读更多：Python 中的库

20) Python 支持哪些不同的文件处理模式？

在 Python 中有四种打开文件的方式。读写 (rw)、只写 (w)、追加 (a) 和只读 (r) 模式。'r' 用于以只读模式打开文件；'w' 用于以只写模式打开文件；'rw' 用于以读写模式打开；'a' 用于以追加模式打开文件。如果未指定模式，默认情况下文件以只读模式打开。

只读 (r) 模式：通过打开文件来读取文件。这是默认设置。
只写模式（w）：打开一个文件进行写入。如果文件包含数据，数据将会丢失。同时也会创建一个新文件。
读写 (rw) 模式：在写模式下打开一个文件进行读取。这意味着更新模式。
追加模式（a）：如果文件存在，则打开它进行写入，并在文件末尾追加内容。

21) Python 中的运算符是什么？

运算符是一种应用于某些值并产生输出的特定符号。操作数是运算符的作用对象。操作数是具有某些值的字面量或变量。运算符可以是单目、双目或三目的。三目运算符、双目运算符、三目运算符和单目运算符分别是需要三个或更多操作数、两个操作数和一个操作数的运算符的例子。

示例

# Unary Operator
A = 12
B = -(A)
print (B)
# Binary Operator
A = 12
B = 13
print (A + B)
print (B * A)
#Ternary Operator
A = 12
B = 13
min = A if A < B else B
  
print(min)

输出

# Unary Operator
-12
# Binary Operator
25
156
# Ternary Operator
12

说明

一元运算符 - 将 'A' 的负值赋给 'B'，将 'B' 设置为 -12。
二元运算符对 'A' 和 'B' 执行加法和乘法运算。结果是 'A + B 25'，'B * A 156'。
三元运算符 - 检查'A'是否小于'B'。如果为真，则'min_value'的值为'A'；否则，赋值为'B'。在这种情况下，'min_value'为12，因为'A'小于'B'。

阅读更多：Python 运算符

22) Python 中有哪些不同类型的运算符？

Python 语言的运算符可以根据其功能进行大致分类。这些包括

算术运算符
赋值运算符
关系运算符/比较运算符
逻辑运算符
成员运算符
按位运算符
身份运算符

1. 算术运算符： 执行数学运算，包括加法(+)、减法(-)、乘法(*)、除法(/)、取模(%)。

示例

# Adding two values
print(12+23)
# Subtracting two values
print(12-23)
# Multiplying two values
print(12*23)
# Dividing two values
print(12/23)

输出

35
-11
276
0.5217391304347826

说明

+ 运算符将值 12 和 23 相加，结果为 35。
- 运算符从 23 中减去 12，结果值为 -11。
* 运算符将 12 与 23 相乘，我们得到结果 276。
/ 运算符将 12 除以 2，结果为 0.5217391304347826。

2. 关系运算符： 用于比较值。这些运算符测试条件，然后返回一个布尔值，即 True 或 False。

示例

a, b = 10, 12
print(a==b) # False
print(a<b) # True
print(a<=b) # True
print(a!=b) # True

输出

False
True
True
True

说明

a == b 检查 a 是否与 b 相同，结果为 False。
a < b 检查 a 是否远小于 b，结果为 True。
a <= b 测试 a 是否远小于或等于 b，结果为 True。
a != b 测试 a 是否不等于 b，结果为 True。

3. 赋值运算符 将值赋给变量并修改它们的值。这些包括简单赋值 (=) 以及复合赋值运算符，如 +=, -=, *=, /=, 等。

示例

# Examples of Assignment operators
a=12
print(a) # 12
a += 2
print(a) # 14
a -= 2
print(a) # 12
a *=2
print(a) # 24
a **=2
print(a) # 576

输出

说明

a = 2 将 a 的费用增加 2，结果 a 为 14。
a -= 2 将 a 的成本减少 2，结果 a 为 12。
a *= 2 将 a 的费用乘以 2，结果 a 为 24。
a **= 2 将 a 的值增加到 2 的幂，结果 a 为 576。

4. 逻辑运算符 用于执行逻辑运算，如与、或、非。请看下面的例子。

示例

# Logical operator examples
a = True
b = False
print(a and b) # False
print(a or b) # True
print(not b) # True

输出

False
True
True

5. 位运算符： 对整数的二进制表示进行操作，操纵单个位。请看下面的例子

示例

a = 10   # Binary: 1010
b = 12   # Binary: 1100
# Bitwise AND
print(a & b)  # Output: 8 (Binary: 1000)
# Bitwise OR
print(a | b)  # Output: 14 (Binary: 1110)
# Bitwise XOR
print(a ^ b)  # Output: 6 (Binary: 0110)
# Bitwise NOT
print(~a)     # Output: -11 (Binary: -1011)

输出

8 (Binary: 1000)
14 (Binary: 1110)
6 (Binary: 0110)

说明

a & b: 对 a 和 b 的二进制表示执行按位与操作。
a | B：对 a 和 b 的二进制表示执行按位或运算。
a^b：是对 a 和 b 的二进制表示进行按位异或运算。
~a：对 a 执行按位非运算，这会移动所有位并由于二的补码表示而将结果加 1，结果为 -11。

23) 如何在 Python 中创建 Unicode 字符串？

在 Python 3 中，旧的 Unicode 类型已被“str”类型取代，字符串自然被视为 Unicode。使用 art.title.encode("utf-8") 函数，我们可以创建一个 Unicode 字符串。

示例

unicode_1 = ("\u0123", "\u2665", "\U0001f638", "\u265E", "\u265F", "\u2168")
print (unicode_1)

输出

unicode_1: ('ģ', '♥', '?', '♞', '♟', 'Ⅸ')

24) Python是解释型语言吗？

是的，python 是一种解释型语言。这意味着代码由 python 解释器逐行执行，而不是预先编译成机器码。

与 Java 和 C 不同，Python 在运行前不需要编译。

25) Python 是如何管理内存的？

Python 中的内存管理由 Python 运行时环境处理，涉及几个关键组件和技术

自动内存管理： Python 能够通过自动内存管理或垃圾回收来记录内存分配和重用。因此，内存分配和释放由 Python 解释器在运行时自动进行，这实际上是一个特性。
引用计数： 通过使用引用计数，python 跟踪每个对象的引用数量。每个 Python 对象都有一个引用计数，即当前对该对象的引用数，当有新引用时增加，当引用超出范围或被显式删除时减少。当引用计数降至零时，对象会以这种方式失去其分配的内存，因为计数为零。
垃圾回收： 除了引用计数的概念，Python 还使用垃圾回收来回收未完全引用对象的内存区域，例如循环依赖或循环引用。垃圾回收会频繁扫描堆，以识别被丢弃的对象，并在该区域被清除以用作当前对象的缓冲区之前进行识别。
内存池： Python 实施了一个内存池，以便在为小对象分配和释放内存方面实现最佳性能。内存池通过重用此池的内存块来减少内存分配和释放的频率。
动态分配： 对象属于整数、字符串等数据类型，这些被称为数据类型。Python 是一种动态语言，能够在程序执行期间根据需要分配内存。内存，即为进程堆获取的内存，由 Python 运行时环境处理。
优化： Python 的代码优化可以提供多种好处。首先，Python 对小整数和字符串进行内部化处理，这优化了内存使用并提高了性能，从而避免了在内存中创建重复对象。其次，Python 感知可达和不可达对象，并回收不可达对象占用的内存。

阅读更多：Python 内存管理

26) 什么是 Python 装饰器？

装饰器是 Python 中一个有用的工具，它允许程序员向现有代码添加功能。它们非常强大。因为程序的某个组件试图在编译时修改另一个组件，这也被称为元编程。它允许客户端包装另一个函数，以扩展被包装函数的行为，而无需永久更改它。

示例

def function_is_called():
    def function_is_returned():
        print("tpointtech")
    return function_is_returned
new_1 = function_is_called()
# Outputs "tpointtech"
new_1()

输出

tpointtech

函数 vs. 装饰器

函数是执行特定任务的代码块，而装饰器是修改其他函数的函数。

说明

定义并呈现了 'function_is_called()' 函数。
在'function_is_called()'的范围内，还有另一个函数将被定义为'function_is_returned()'。
在使用嵌套函数'function_is_returned()'后，将显示tpointtech。
'function_is_called()' 函数包含被返回的 'function_is_returned()' 函数。
返回的函数被传递给'new_1'。
调用函数 new_1()，随后调用'function_is_returned()'函数，最终显示消息“tpointtech”。
因此，当您输入'new_1'后，控制台会打印“tpointtech”。

阅读更多：Python 装饰器

27) Python 中局部变量和全局变量的规则是什么？

全局变量

在函数外部或全局空间中声明的变量称为全局变量。

每当在函数内部给一个变量赋予新值时，我们必须明确地将其声明为“全局”，因为它默认是局部的。必须使用 global 关键字来声明一个变量，使其成为全局变量。

任何函数都可以访问和修改全局变量的值，这些变量在程序的任何地方都可以访问。

示例

A = "tpointtech"
def my_function():
  print(A)
my_function()

输出

tpointtech

说明

变量'A'被赋值为"tpointtech"。
定义了函数'my_function()'，该函数打印变量'A'的值。
函数'my_function()'被调用。
变量 A 的值在函数 'my_function()' 中被打印，即 "tpointtech"。
所以，当你运行这段代码时，它会在控制台打印“tpointtech”。

局部变量

局部变量是在函数内部声明的任何变量。该变量存在于局部空间，而不是全局空间。

如果一个变量在函数体内的任何地方被赋予一个新值，那么它就被认为是局部的。

只有局部主体可以访问局部变量。

示例

def my_function2():
    K = "tpointtech Local"
    print(K)
my_function2() 

输出

tpointtech Local

说明

函数'my_function2()'被定义。
在'my_function2()'中定义了一个值为"tpointtech Local"的局部变量'K'。
打印局部变量 'K' 的值。
调用函数'my_function2()'。
在函数调用期间，会打印局部变量 K 的值，即“tpointtech Local”。

阅读更多：Python 中局部变量和全局变量的区别

28) Python 中的命名空间是什么？

命名空间是组织和构建代码的基本概念，在大型项目中更为有用。然而，如果你是编程新手，可能有点难以理解。因此，我们试图让命名空间更容易理解一些。

命名空间被定义为控制程序中名称的简单系统。它确保不会发生冲突，并且每个名称都是唯一的。

此外，Python 将命名空间作为字典执行，并维护名称到对象的映射，其中名称充当键，对象充当值。

阅读更多：Python 中的命名空间

29) Python 中的迭代器是什么？

在 python 中，迭代器是表示数据流的对象，可用于重复开始一个过程。它们提取了一种迭代元素的方式，这些元素可以包含在成对的物品、元组、字典或字符串中，一次一个项目。迭代器实现了迭代器协议，该协议由两个主要方法组成

__iter__(): 这个方法同样是迭代器对象，在迭代器初始化时被称为实例的 init 方法。

__next__(): 因此，此方法给出集合中的另一个元素。当没有更多项目可返回或流程中断时，它会以 StopIteration 异常 进一步终止代码。

30) Python 中的生成器是什么？

在 Python 中，生成器是一种确定如何执行迭代器的方式。除了它在函数中产生表达式之外，它是一个正常的函数。它消除了 __itr__ 和 next() 方法，并减少了额外的开销。

如果一个函数至少包含一个 yield 语句，它就变成了一个生成器。通过保存其状态，yield 关键字会暂停当前执行，并允许在需要时恢复执行。

阅读更多：Python 生成器

31) Python 中的切片是什么？

切片是一种可以在 Python 中使用的技术，用于使用索引范围切出序列的一部分（例如列表、元组或字符串）。切片将使您能够组合一个新的序列，该序列由从原始序列中提取的元素组成，从规定的起始索引开始，到建议的结束索引之前结束。

示例

my_list=[1,2,3,4,5]
# Get a slice from index 1 to index 3 (exclusive)
print(my_list[1:3])   
# Get a slice from index 2 to the end of the list
print(my_list[2:])    
# Get a slice from the beginning to index 3 (exclusive)
print(my_list[:3])   
# Get a slice of every second element
print(my_list[::2])  

输出

说明

我们从一个名为 'my_list' 的列表开始，它包含元素 [1, 2, 3, 4, 5]。
第一个 'print()' 语句使用切片提取从索引 1 到索引 3 的元素，打印并返回一个新列表。
第二个'print()'语句使用切片从索引2的元素切到列表末尾，然后打印结果。
第四个 `print()` 语句将列表的开头元素切片到索引 3（不含），并打印结果，即 `List[:3]`。
最后一个'print()'函数排除了列表的第二个值，并使用步长为2的切片来打印结果。

32) Python 中的字典是什么？

Python 字典是一种内置数据类型。它在键和值之间建立了一对一的关系。字典包含成对的键及其值。它以键值对的形式存储组件。值可以重复，而键是唯一的。字典元素通过键来访问。

键索引字典。

示例

以下示例包含一些键，如 Country、Hero 和 Cartoon。它们对应的值分别是 India、Modi 和 Rahul。

dict = {'Country': 'India', 'Hero': 'Modi', 'Cartoon': 'Rahul'}
print ("Country: ", dict['Country'])  
print ("Hero: ", dict['Hero'])
print ("Cartoon: ", dict['Cartoon'])

输出

Country:  India
Hero:  Modi
Cartoon:  Rahul

说明

一个名为'dict'的字典被显示为一个包含键值对的字典。
'print()'函数用于显示不同字典中键的值。
dict['Country'] 给出键 'Country' 的值并将其打印到控制台。
dict['Hero'] 返回与键 'Hero' 相关联的值，并打印输出
dict['Cartoon'] 检索与键 'Cartoon' 关联的值并显示它。
出口将显示与字典中键'Country'、'Hero'和'Cartoon'相匹配的值。

阅读更多：Python 字典

33) Python 中的 Pass 是什么？

Pass 指定一个无操作的 Python 语句。它在复合语句中作为占位符。为了创建一个空的类或函数，pass 关键字有助于在不报错的情况下传递控制权。

示例

class Student: 
    pass # Passing class  
class Student:  
    def info():
        pass # Passing function

说明

给出了两个名为“Student”的类定义。第一个类是空的，用作占位符。第二个类包含一个名为“info()”的空方法，该方法由关键字“def”后跟“pass”定义。两者都可以根据需要用材料和技术进行扩展。

阅读更多：Python Pass 语句

34) 解释 Python 中的文档字符串？

Python 文档字符串是模块、函数、类或方法定义中的第一个语句，是一个字符串字面量。它使得将文档链接在一起变得更容易。

“属性文档字符串”是在顶部简单赋值后立即出现的字符串字面量。

“附加文档字符串”是紧跟在另一个文档字符串之后的字符串字面量。

尽管文档字符串可以放在一行上，但 Python 使用三引号来创建它们。

docstring 中的短语以句点 (.) 结尾，并且可以包含多行。它可以包含像空格这样的特殊字符。

示例

# One-line docstrings
def hello():
    """A function to greet."""
    return "hello"

说明

在提供的 Python 函数代码中，为函数 'hello()' 定义了一个单行文档字符串。在文档字符串内部，一个单引号文本“A function to greet.”直接位于函数定义上方。它提供了对功能的简短描述。文档字符串访问器可以通过 '__doc__' 属性获取。

35) Python 中的负索引是什么，为什么使用它们？

Python 的序列被索引并包含正数和负数。正数使用 '0' 作为第一个索引，'1' 作为第二个索引，以此类推。

负数的索引从'-1'开始，表示序列的最后一个索引，到'-2'结束，表示序列的倒数第二个索引。

负索引用于去除字符串中的任何换行空格，并使字符串能够包含除最后一个字符之外的所有字符，即 S[:-1]。负索引也用于显示索引代表字符串的正确顺序。

36) Python 中的 pickling 和 unpickling 是什么？

一个名为 Python pickle 的模块，可以将任何 Python 对象转换为字符串表示形式。利用 dump 函数，它将 Python 对象复制到文件中；这个过程称为 Pickling。

Unpickling 是从存储的字符串表示中获取原始 Python 对象的过程。

阅读更多：Python 的 Pickle 模块

37) Java 和 Python 之间哪个编程语言是更好的选择？

Java 和 Python 都是面向对象的编程语言。让我们根据下面给出的一些标准来比较两者

标准	Java	Python
易用性	好	非常好
编码速度	平均数	优秀
数据类型	静态类型	动态类型
数据科学和机器学习应用	平均数	非常好

阅读更多：Java vs. Python

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

Python 中的 'help()' 和 'dir()' 函数用于内省和文档目的

help(): 'help()' 函数通常让您访问模块、类、函数和方法的内置 Python 文档（文档字符串）。不带参数调用时，它会启动一个交互式帮助会话。如果将对象作为参数，它会显示其文档。
dir(): 'dir()' 调用返回一个可应用于给定对象的所有有效属性的列表。这是探索对象具有的属性和方法的方式，包括内置属性 - '__doc__' 和 '__name__' - 以及任何用户定义的属性。

这两个函数对于探索和理解 Python 对象、模块和库都很有用。事实上，它们是学习和调试的绝佳工具

阅读更多：Python dir() 函数

阅读更多：Python help() 函数

39) Python 2.x 和 Python 3.x 有什么区别？

Python 2.x 是一个以前的版本。Python 3.x 是最新的版本。Python 2.x 现在已经过时了。这门语言现在和将来都是 Python 3.x。

Python2 和 Python3 之间最明显的区别在于 print 语句（函数）。在 Python 2 中，它看起来像 print "Hello"，而在 Python 3 中，它看起来像 print("Hello")。

Python2 中的字符串是隐式 ASCII，而在 Python3 中是 Unicode。

xrange() 方法已从 Python 3 版本中移除。错误处理引入了一个全新的关键字。

阅读更多：python2.x 和 python3.x 之间的重要区别

40) Python 是如何进行编译时和运行时代码检查的？

在 Python 中，大部分对类型、名称等的检查是在编译时完成的。被推迟到代码执行时。因此，如果 Python 代码引用了一个不存在的用户定义函数，它将成功编译。但有一个例外，当执行路径缺失时，Python 代码将失败。

41) 打开文本文件并显示其内容的最短方法是什么？

打开文本文件的最短方法是使用“with”命令，如下所示

示例

with open("FILE NAME", "r") as fp:
    fileData = fp.read()  
# To print the contents of the file   
print(fileData)

输出

"The data of the file will be printed."

说明

该命令的代码将使名为“文件名”的目标文件在上下文管理器内以读取模式打开。
它读取整个文件内容，包括头部信息，并将其存储在变量 fileData 中。
最后一个任务是在控制台中打印存储的文件内容 (fileData)。

注意：您应该将“文件名”替换为您要读取的文件的实际名称（如果需要，还包括路径名）。

42) Python 中 enumerate () 函数的用法是什么？

enumerate() 函数用于遍历序列，同时检索索引位置及其对应的值。

示例

list_1 = ["A","B","C"]
s_1 = "tpointtech" 
# creating enumerate objects
object_1 = enumerate(list_1)
object_2 = enumerate(s_1)
 
print ("Return type:",type(object_1))
print (list(enumerate(list_1)))
print (list(enumerate(s_1)))

输出

Return type: <class 'enumerate'>
[(0, 'A'), (1, 'B'), (2, 'C')]
[(0, 'J'), (1, 'a'), (2, 'v'), (3, 'a'), (4, 't'), (5, 'p'), (6, 'o'), (7, 'i'), (8, 'n'), (9, 't')]

说明

定义了两个序列：'list_1' 列表和 's_1' 字符串。
enumerate() 函数分别为列表和字符串创建了 object_1 和 object_2。
'type()' 函数有助于确定枚举对象的类型，这些类型被打印到控制台。
'list()' 函数用于将枚举对象转换为列表，同时这些列表被打印在控制台中。
输出指示了元素的创建，以成对的形式显示在列表和字符串中，其中每个元素都有索引。

阅读更多：Python enumerate() 函数

43) 给出这个例子的输出：A[3] if A=[1,4,6,7,9,66,4,94].

由于索引从零开始，第 3 个索引处的元素是 7。所以，输出是 7。

44) Python 中的类型转换是什么？

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

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

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

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

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

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

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

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

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

dict() - 该函数用于将(键,值)顺序的元组转换为字典。

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

complex(real,imag) - 该函数将实数转换为复数(real,imag)。

阅读更多：Python 中的类型转换

45) 如何用 Python 语言发送电子邮件？

Python 拥有 smtplib 和 email 模块用于发送电子邮件。将这些模块导入到创建的邮件脚本中，并通过确认客户端来发送邮件。

它有一个方法 SMTP(smtp-server, port)。它需要两个参数来建立 SMTP 连接。

下面给出了一个发送电子邮件的简单示例。

示例

import smtplib  
# Calling SMTP  
s = smtplib.SMTP('smtp.gmail.com', 587)  
# TLS for network security  
s.starttls()  
# User email Authentication  
s.login("sender@email_id", "sender_email_id_password")  
# Message to be sent  
message = "Message_sender_need_to_send"  
# Sending the mail  
s.sendmail("sender@email_id ", "receiver@email_id", message)  

说明

smtplib 模块被导入以帮助发送电子邮件。
通过定义 GMail SMTP 服务器 ('smtp.gmail.com') 和端口 ('587') 来初始化一个 's' SMTP 对象。
使用'starttls()'加密网络安全以开始TLS。
用户需要通过'login()'方法，使用发件人的电子邮件地址和密码，对发件人的电子邮件账户进行身份验证。
定义要发送的消息内容。
使用 'sendmail()' 发送电子邮件，指明发件人的电子邮件地址、收件人的电子邮件地址和消息。
在'quit()'的帮助下关闭连接。

阅读更多：使用 SMTP 的 Python 发送电子邮件

阅读更多：Python 中的 Email 模块

46) Python 数组和列表有什么区别？

在 Python 中，数组和列表都用于存储元素集合，但它们有一些区别

1. 数据类型

列表可以包含非常不同数据类型的对象（例如，整数、字符串、浮点数）。
一个典型的数组包含相同类型的元素，并存储在连续的位置。在 Python 中，数组来自 array 模块，创建数组时应指定元素的数据类型。

2. 功能性

Python 中的列表是作为动态数组实现的，这意味着它们会随着元素的添加或移除而相应地扩大和缩小。它们还拥有大量用于操作的内置方法，如 'append()', 'remove()', 'pop()' 等。
数组不仅能够执行较少的操作，而且这比列表更真实。它们提供基本的程序，如数组访问、插入、删除和迭代。其他函数，如排序和搜索，需要使用 'numpy' 函数。

3. 效率

数组通常使用更少的内存并且速度更快，尽管在处理大量同类数据类型的数据集时最显著。这是因为数组具有固定大小，为特定数据类型的元素分配，而列表在需要时动态创建空间。
列表由于其各种特性和可用性而提供了更大的灵活性和便利性，但由于动态调整大小和支持异构数据类型，它们对于特定操作可能效率较低。

阅读更多：Python 数组

阅读更多：Python 列表

47) Python 中的 lambda 函数是什么？

在 Python 中，lambda 函数是一个由关键字'lambda'匿名定义的小函数。它可以有任意数量的参数，但只能有一个表达式。当函数定义非常简单且不够复杂时，通常会使用 Lambda 函数来代替完整的'def'语句。

语法

阅读更多：Python Lambda 函数

48) 为什么 Python 中的 lambda 形式没有语句？

由于该语句用于创建新的函数对象并在运行时返回它，因此 Python 中的 lambda 形式不包含它。

49) Python 中的函数是什么？

在 Python 中，函数是独立的、模块化的代码块，它们完成一项工作。它们接受两个输入（参数），执行这些操作，然后返回一个输出。函数有助于将代码组织成可重用的独立单元，从而提高了可读性、调试性和可维护性。

示例

def New_func():
    print ("Hi, Welcome to tpointtech")
New_func() #calling the function

输出

Hi, Welcome to tpointtech

说明

'def' 关键字将函数定义为 'New_func'。
在函数内部，指定了单个语句以显示消息“Hi, Welcome to tpointtech”。
在函数名定义之后，通过函数名后跟括号来调用函数，即 '(New_func())'。
该函数在被调用时执行其主体内的语句。

50) 什么是 init？

__init__ 是 Python 中的一个方法或构造函数。当创建类的新对象/实例时，此方法会自动调用以分配内存。所有类都有 __init__ 方法。

示例

class Employee_1:
    def __init__(self, name, age,salary):
        self.name = name
        self.age = age
        self.salary = 20000
E_1 = Employee_1("pqr", 20, 25000)
# E1 is the instance of class Employee.
#__init__ allocates memory for E1. 
print(E_1.name)
print(E_1.age)
print(E_1.salary)

输出

pqr
20
25000

说明

Employee_1 类包含一个 __init__，它用属性 name、age 和 salary 封装了新实例。
'Employee_1' 类的一个实例 'E_1' 是用提供的值创建的：分别为 "pqr"、20 和 2500。
当创建'E_1'时，会执行'__init__'方法作为内存分配和属性初始化。
打印'E_1'实例的组件会显示提供的姓名和年龄值，但薪水仍然是'20000'，因为它存储在init方法中。

阅读更多：Python 中的 __ init __

51) Python 中的 self 是什么？

Self 是一个类的实例或对象。在 Python 中，这被明确设置为第一个参数。然而，在 Java 中并非如此，它是可选的。它有助于区分类的方法和属性与局部变量。

新创建的对象在 init 方法中被称为 self 变量，而在其他方法中，则指的是调用其方法的对象。

阅读更多：Python 中的 Self 关键字

52) 在 Python 中，如何生成随机数？

不规则模块是用于生成不规则数的标准模块。术语“方法”指的是

import random
random.random

random.random() 策略语句返回范围在 [0, 1) 内的浮点数。浮点数由函数随机生成。隐藏实例的绑定方法是与随机类一起使用的方法。随机实例可用于演示生成不同线程实例的多线程应用程序。以下是在此使用的其他随机生成器

range (a, b): 它选择一个数字并定义在 [a, b) 之间的范围。它通过从指定的范围内随机选择元素来返回元素。它不会创建 range 对象。
uniform, a 和 b： 它从 [a,b] 范围中选择一个浮点数，并返回下一个浮点数：normalvariate(mean, sdev) 它用于正态分布，其中 mu 表示均值，sdev 表示标准差。

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

阅读更多：生成随机数的 Python 程序

53) 什么是 PYTHONPATH？

PYTHONPATH 是一个环境变量，在导入模块时使用。每当导入一个模块时，也会查找 PYTHONPATH，以查看导入的模块是否在不同的目录中。解释器用它来选择加载哪个模块。

阅读更多：Python 中的 PYTHONPATH 环境变量是什么

54) Python 中的模块是什么？说出一些常用的 Python 内置模块？

Python 中的模块是包含创建函数、类和变量的 Python 代码的文件。通过将相关功能划分到单独的文件中，可以实现代码组织、可重用性和可维护性，这是它们的主要特性。任何 Python 脚本或模块都可以使用'import'语句导入模块。

一些常用的内置模块是

os
sys
math
随机
data time
JSON

55) range 和 xrange 有什么区别？

在大多数方面，xrange 和 range 的功能是相同的。您可以使用它们中的任何一个以任何您喜欢的方式生成一个整数列表。主要区别在于 reach 返回一个 Python 列表项，而 x reach 返回一个 xrange 对象。

这表明与 range 不同，xrange 在运行时实际上不会产生静态列表。它使用一种称为 yielding 的独特策略，根据您的需要创建值。生成器是一种可以从此方法中受益的对象。这意味着如果要为一个非常大的范围（例如十亿）创建列表，则应使用 xrange 函数。

这在处理内存敏感的系统（如手机）时尤其如此，因为 range 会尽可能多地使用内存来创建您的整数数组，这可能会导致内存错误并导致您的程序崩溃。它是一个需要内存的野兽。

阅读更多：range() vs. Xrange() Python

56) NumPy 数组相对于（嵌套的）Python 记录有什么好处？

Python 中的列表作为通用容器效果很好。由于 Python 的列表推导式，它们易于构建和操作，并且它们以相当有效的方式支持插入、删除、追加和连接。

它们在某些方面受到限制：因为它们可以包含不同类型的对象，所以 Python 必须为每个元素存储类型信息，并在对每个元素进行操作时执行类型分派代码，因为它们不支持像按元素加法和乘法这样的“向量化”操作。

NumPy 不仅更有效，而且也更有用。许多自由的向量和矩阵运算使我们有时可以避免不必要的工作。此外，它们的实现效率很高。

NumPy 阵列更快，而且我们通过 NumPy 内置了很多功能，例如 FFT、卷积、快速查找、基本统计、线性代数、直方图等等。

57) 说出 Django 模板由什么组成。

一个简单的文本文件作为模板。任何基于文本的格式，包括 XML、CSV 和 HTML，都可以由它创建。一个布局包含在布局评估时被替换为值的变量，以及控制布局逻辑的标签（% tag %）。

阅读更多：Django 模板

58) 解释 Django 框架中 session 的用法？

Django 提供了一个会话，允许客户端按每个网站访问者的基础存储和检索数据。通过在客户端放置一个会话 ID cookie 并在服务器端存储所有相关数据，Django 抽象了 cookie 的发送和接收。

所以，数据本身不存储在客户端。从安全角度来看，这是好的。

阅读更多：Django 教程

基于面试的 Python 多项选择题

1) 以下关于 Python 编程语言的陈述中，哪一项/些是有效的？

陈述 1：Python 是一种高级、通用、解释型的编程语言。

陈述 2：为了快速开发和部署应用程序，Python 提供了动态绑定和类型化以及高级数据结构。

陈述 3：Python 是一种具有静态类型代码的编程语言。

选项

仅陈述 1
陈述 1 和 2
陈述 1 和 3
所有陈述都正确

答案： B：陈述 1 和 2

解释： Python 是一种高级、通用、解释型编程语言。作为一种解释型语言，它逐行执行每个代码块，因此类型检查是在执行代码时完成的。因此，它是一种动态类型语言。

此外，Python 提供了无可否认的高级数据结构，以及动态限制和撰写，允许庞大的工程师社区进行快速应用程序改进和组织。

2) PEP 的全称是什么？

选项

Python 增强提案
Python 魅力提案
编程增强建议
Python 充实计划

答案： A：Python 增强提案

解释： 一个 PEP，也称为 Python 改进提案，是一份官方设计文档，为 Python 开发者社区提供信息，或描述 Python 或其方法的新功能。

3) 以下关于 Python 内存管理的陈述中，哪些是错误的？

第一条声明：Python 的内存管理由 Python 内存管理器处理。

第二条陈述：作为 Python 的垃圾收集方法，使用了 CMS（并发标记清除）方法。

陈述 3：为了回收私有堆空间的空闲内存，Python 提供了一个核心的垃圾回收功能。

选项

仅陈述 3
陈述 1 和 3
陈述 2 和 3
仅陈述 2

答案： D：仅陈述 2

解释： Python 使用引用计数算法作为其垃圾回收方法。这种方法易于使用且非常有效；但是，它无法识别引用循环。因此，引用循环是 Python 的分代循环 (GC) 算法唯一关注的焦点。

4) 关于 Python 命名空间，以下哪个陈述是正确的或错误的？

第一条声明：Python 将命名空间作为数组执行。

第二条陈述：Python 命名空间有三种类型：局部、全局和内置。

陈述 3：Python 命名空间保证每个对象的名称都是唯一的，并且可以在不产生不一致的情况下使用。

选项

仅陈述 1
仅陈述 3
陈述 1 和 2
陈述 1 和 3

答案： A：仅陈述 1

解释： Python 中的命名空间是作为字典实现的，其中“键”表示“名称”，映射到对应的“值”，表示“对象”。

5) 就变量名而言，以下哪个是无效的？

选项

_mystr = "Hello World!"
__mystr = "Hello World!"
__mystr__ = "Hello World!"
以上都不是

答案： D: 以上都不是

解释： 每个语句都能成功执行。尽管如此，代码的可读性也会因此降低。

6) 关于 Python 中的作用域，以下哪个（些）陈述是正确的？

陈述 1： 在函数内部创建的变量属于局部作用域，并且可以在该函数外部使用。

陈述 2： 局部作用域指的是自代码创建以来，在整个执行过程中都存在的对象。

陈述 3： 局部作用域指的是存在于当前函数中的局部对象。

选项

仅陈述 2
陈述 1 和 3
仅陈述 3
所有陈述都正确

答案： C: 仅陈述 3

解释： 局部作用域，也称为函数作用域，是 Python 中任何函数的代码块或主体。我们在函数内部指定的名称构成了这个作用域。只有该函数的代码能够看到这些名称。因为局部作用域是在函数调用时创建的，而不是在函数定义时创建的，所以对函数的每次调用都会产生一个不同的局部作用域。无论同一个函数被多次调用还是递归调用，这都成立。每次调用都会返回一个新的局部作用域。

7) 以下代码片段将打印什么？

编码

# assigning a variable
myint = 10

# defining a function
def myfunction():
    # reassigning a variable
    myint = 20

# calling the function
myfunction()

# printing the value of the variable
print(myint)

选项

10
20
0
回溯错误 (Traceback Error)

答案： A: 10

解释： 打印出 10。

每当我们在函数局部作用域内重新分配一个全局变量时，这个改动只在局部作用域内有效。当代码返回到全局作用域时，该变量会恢复其全局值。

8) 以下代码片段将产生什么结果？

编码

# assigning a variable
myint = 21

# using if False statement
if False:
    # reassigning a variable
    myint = 34

# defining a function
def myfunction():
    if True:
        # reassigning a variable
        myint = 65

# calling the function
myfunction()

# printing the value of the variable
print(myint)

选项

65
回溯错误 (Traceback Error)
21
34

答案： C: 21

解释： 打印出 21。

一开始，变量 myint 被赋值为 21。由于 if False 语句的判断结果为 False，所以 myint = 34 的重新赋值操作从未发生。在 myfunction() 函数中发生的重新赋值操作是在局部作用域内，而不是在全局作用域内。因此，当我们试图访问全局作用域中的变量 myint 时，它的值仍然是 21。

9) 在以下关于列表和元组区别的陈述中，哪一个是正确的？

陈述 1： 列表是序列数据结构，而元组不是。

陈述 2： 列表是不可变的；然而，元组是可变的。

陈述 3： 元组是序列数据结构，而列表不是。

陈述 4： 元组是不可变的；然而，列表是可变的。

选项

陈述 1
陈述 4
陈述 2
陈述 3

答案： B: 陈述 4

解释： 除了许多相似之处外，两者之间的一个巨大区别是列表是可变的，而元组是不可变的。这个陈述意味着我们可以更改或修改列表的值；但是，我们不能更改元组的值。

10) 以下代码片段的输出将是什么？

编码

# defining a list
my_list = [7, 9, 8, 2, 5, 0, 1, 3, 6]

# using the pop() function
my_list.pop(2)

# printing the final list
print(my_list)

选项

1. [7, 9, 2, 5, 0, 1, 3, 6]
2. [7, 9, 8, 2, 5, 0, 3, 6]
3. [7, 8, 2, 5, 0, 1, 3, 6]
4. [7, 9, 8, 2, 5, 0, 1, 6]

答案： A: [7, 9, 2, 5, 0, 1, 3, 6]

解释： pop() 函数用于从列表中移除元素。该函数的参数 n 是要从列表中移除的数据元素的索引值。

因此，pop(n) 函数会移除列表中的第 n 个元素。在上面的例子中，索引号是 2。因此，pop(2) 函数从 my_list 中移除了元素 8。

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview