《前后端面试题》专栏集合了前后端各个知识模块的面试题，包括html，javascript，css，vue，react，java，Openlayers，leaflet，cesium，mapboxGL，threejs，nodejs，mangoDB，SQL，Linux... 。
文章目录
- 一、本文面试题目录
-
-
- [1. 解释Python的特性（如动态类型、面向对象、可扩展性等）。](#1. 解释Python的特性（如动态类型、面向对象、可扩展性等）。)
- [2. Python中`is`和`==`的区别是什么？](#2. Python中
is和==的区别是什么？) - [3. 什么是Python的GIL（全局解释器锁）？它对多线程有什么影响？](#3. 什么是Python的GIL（全局解释器锁）？它对多线程有什么影响？)
- [4. Python2和Python3的主要区别有哪些？](#4. Python2和Python3的主要区别有哪些？)
- [5. 解释Python中的变量作用域（LEGB规则）。](#5. 解释Python中的变量作用域（LEGB规则）。)
- [6. 什么是匿名函数？如何使用`lambda`表达式？](#6. 什么是匿名函数？如何使用
lambda表达式？) - [7. `*args`和`**kwargs`的作用是什么？如何使用？](#7.
*args和**kwargs的作用是什么？如何使用？) - [8. Python中的注释有哪几种方式？](#8. Python中的注释有哪几种方式？)
- [9. 什么是Python的"鸭子类型"？举一个例子说明。](#9. 什么是Python的“鸭子类型”？举一个例子说明。)
- [10. 解释Python中的缩进规则及其重要性。](#10. 解释Python中的缩进规则及其重要性。)
- [11. 如何在Python中实现类型转换？（如`int()`、`str()`、`list()`等）](#11. 如何在Python中实现类型转换？（如
int()、str()、list()等）) - [12. Python中的关键字有哪些？举例说明几个常用关键字的作用。](#12. Python中的关键字有哪些？举例说明几个常用关键字的作用。)
- [13. 什么是Python的内置函数？列举5个常用的内置函数并说明用途。](#13. 什么是Python的内置函数？列举5个常用的内置函数并说明用途。)
- [14. 解释`pass`、`break`、`continue`语句的区别。](#14. 解释
pass、break、continue语句的区别。) - [15. Python中的`None`是什么？它与空字符串、0有何区别？](#15. Python中的
None是什么？它与空字符串、0有何区别？)
-
- 二、150道Python面试题目录列表
一、本文面试题目录
1. 解释Python的特性（如动态类型、面向对象、可扩展性等）。
Python是一种高级编程语言，具有以下核心特性：
-
动态类型：变量类型不需要预先声明，解释器会在运行时自动推断。
pythonx = 10 # 整数 x = "hello" # 无需声明即可变为字符串 -
面向对象：支持类、继承、多态等面向对象特性，一切皆为对象。
pythonclass Animal: def speak(self): pass class Dog(Animal): def speak(self): return "Woof" -
可扩展性：可通过C/C++编写扩展模块，也可嵌入到其他语言中。
-
简洁易读：使用缩进来划分代码块，语法简洁，接近自然语言。
-
跨平台：可在Windows、Linux、macOS等多种操作系统上运行。
-
丰富的库：拥有庞大的标准库和第三方库，覆盖各种应用场景。
-
解释型：无需编译，直接由解释器执行，开发效率高。
2. Python中is和==的区别是什么？
==：用于比较两个对象的值是否相等（值比较）is：用于判断两个变量是否指向同一个对象（身份比较）
示例：
python
a = [1, 2, 3]
b = a # b引用a指向的列表
c = [1, 2, 3] # c指向一个新的列表，值与a相同
print(a == b) # True - 值相等
print(a == c) # True - 值相等
print(a is b) # True - 指向同一个对象
print(a is c) # False - 指向不同对象
# 查看对象的内存地址（身份标识）
print(id(a)) # 例如：140523467858560
print(id(b)) # 与a相同：140523467858560
print(id(c)) # 不同：140523467859072注意：对于小整数(-5到256)和短字符串，Python有缓存机制，可能导致is判断为True，但不应依赖此特性。
3. 什么是Python的GIL（全局解释器锁）？它对多线程有什么影响？
GIL（Global Interpreter Lock） 是Python解释器（如CPython）中的一种机制，确保同一时刻只有一个线程执行Python字节码。
对多线程的影响：
- 在CPU密集型任务中，多线程无法真正利用多核CPU，因为GIL限制了并行执行。
- 在IO密集型任务中（如网络请求、文件操作），多线程仍能提高效率，因为IO操作时GIL会被释放。
示例：CPU密集型任务中多线程效率不高
python
import threading
import time
def count(n):
while n > 0:
n -= 1
# 单线程
start = time.time()
count(100000000)
end = time.time()
print(f"单线程: {end - start:.2f}秒")
# 多线程
start = time.time()
t1 = threading.Thread(target=count, args=(50000000,))
t2 = threading.Thread(target=count, args=(50000000,))
t1.start()
t2.start()
t1.join()
t2.join()
end = time.time()
print(f"多线程: {end - start:.2f}秒") # 时间与单线程接近甚至更长解决方法：对于CPU密集型任务，可使用multiprocessing模块的多进程。
4. Python2和Python3的主要区别有哪些？
Python2和Python3是两个不兼容的版本，主要区别包括：
-
打印方式：
python# Python2 print "Hello" # Python3 print("Hello") # 必须使用括号 -
字符串类型：
- Python2：
str是字节串，unicode是Unicode字符串 - Python3：
str是Unicode字符串，bytes是字节串
- Python2：
-
整数除法：
python# Python2 print(3 / 2) # 1（整数除法） print(3 // 2) # 1 # Python3 print(3 / 2) # 1.5（浮点除法） print(3 // 2) # 1（地板除法） -
range与xrange：
- Python2：
range()返回列表，xrange()返回生成器 - Python3：
range()功能相当于Python2的xrange()
- Python2：
-
异常处理：
python# Python2 try: 1/0 except ZeroDivisionError, e: # 逗号分隔 print e # Python3 try: 1/0 except ZeroDivisionError as e: # as关键字 print(e) -
输入函数：
- Python2：
raw_input()返回字符串，input()执行输入的代码 - Python3：只有
input()，返回字符串
- Python2：
-
迭代器方法：
- Python2：
next()方法和.__next__() - Python3：只有
.__next__()方法，使用next()内置函数
- Python2：
5. 解释Python中的变量作用域（LEGB规则）。
Python中变量的作用域遵循LEGB规则，即变量查找顺序为：
- L（Local，局部作用域）：当前函数或代码块内定义的变量
- E（Enclosing，嵌套作用域）：外层嵌套函数中的变量
- G（Global，全局作用域）：模块级别定义的变量
- B（Built-in，内置作用域）：Python内置的变量和函数
示例：
python
# 内置作用域（B）：Python自带的len函数
# 全局作用域（G）
x = 10
def outer():
# 嵌套作用域（E）
y = 20
def inner():
# 局部作用域（L）
z = 30
print(x + y + z) # 10 + 20 + 30 = 60
inner()
outer()修改全局变量需使用global关键字：
python
x = 10
def func():
global x # 声明使用全局变量x
x = 20
func()
print(x) # 输出20修改嵌套作用域变量需使用nonlocal关键字：
python
def outer():
x = 10
def inner():
nonlocal x # 声明使用嵌套作用域的x
x = 20
inner()
print(x) # 输出20
outer()6. 什么是匿名函数？如何使用lambda表达式？
匿名函数是没有名称的函数，使用lambda关键字定义，语法为：
lambda 参数: 表达式特性：
- 只能包含一个表达式
- 表达式的结果即为返回值
- 无需使用
return语句
示例：
python
# 定义匿名函数
add = lambda a, b: a + b
print(add(3, 5)) # 输出8
# 结合高阶函数使用
numbers = [1, 3, 5, 2, 4]
# 按每个元素的平方排序
sorted_numbers = sorted(numbers, key=lambda x: x**2)
print(sorted_numbers) # [1, 2, 3, 4, 5]
# 过滤偶数
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # [2, 4]
# 计算每个元素的平方
squares = list(map(lambda x: x**2, numbers))
print(squares) # [1, 9, 25, 4, 16]适用场景：简单的函数逻辑，尤其是作为高阶函数的参数使用，避免定义单行的命名函数。
7. *args和**kwargs的作用是什么？如何使用？
*args和**kwargs用于处理函数的可变参数：
*args：接收任意数量的位置参数，返回一个元组**kwargs：接收任意数量的关键字参数，返回一个字典
示例1：使用*args
python
def sum_numbers(*args):
print(type(args)) # <class 'tuple'>
total = 0
for num in args:
total += num
return total
print(sum_numbers(1, 2, 3)) # 6
print(sum_numbers(10, 20, 30, 40)) # 100示例2：使用**kwargs
python
def print_info(**kwargs):
print(type(kwargs)) # <class 'dict'>
for key, value in kwargs.items():
print(f"{key}: {value}")
print_info(name="Alice", age=30, city="New York")
# 输出：
# name: Alice
# age: 30
# city: New York示例3：同时使用
python
def func(a, b, *args, **kwargs):
print(f"a: {a}, b: {b}")
print(f"args: {args}")
print(f"kwargs: {kwargs}")
func(1, 2, 3, 4, 5, x=10, y=20)
# 输出：
# a: 1, b: 2
# args: (3, 4, 5)
# kwargs: {'x': 10, 'y': 20}注意：参数顺序必须是：位置参数 → *args → 关键字参数 → **kwargs
8. Python中的注释有哪几种方式？
Python支持三种注释方式：
1.** 单行注释 **：使用#，从#开始到行尾的内容都是注释
python
# 这是一条单行注释
x = 10 # 这也是一条单行注释，用于解释代码2.** 多行注释 **：使用三个单引号(''')或三个双引号(""")包裹
python
'''
这是多行注释
可以跨越多行
通常用于函数、类或模块的文档说明
'''
"""
这也是多行注释
功能与单引号版本相同
选择哪种取决于个人习惯
"""3.** 文档字符串（Docstring）**：特殊的多行注释，用于解释模块、函数、类或方法的功能，可通过__doc__属性访问
python
def add(a, b):
"""
计算两个数的和
参数:
a: 第一个加数
b: 第二个加数
返回:
两个数的和
"""
return a + b
print(add.__doc__) # 打印文档字符串良好的注释习惯有助于提高代码的可读性和可维护性。
9. 什么是Python的"鸭子类型"？举一个例子说明。
"鸭子类型"（Duck Typing）是一种编程风格，关注对象的行为（方法和属性）而非其类型。其理念是："如果它走路像鸭子，叫起来像鸭子，那么它就是鸭子"。
在Python中，不需要显式继承某个类或实现某个接口，只要对象具有所需的方法或属性，就可以被使用。
示例：
python
class Duck:
def quack(self):
print("Quack!")
def fly(self):
print("Duck is flying")
class Goose:
def quack(self):
print("Honk!") # 鹅的叫声与鸭子不同，但有quack方法
def fly(self):
print("Goose is flying")
class Airplane:
def fly(self):
print("Airplane is flying") # 飞机能飞，但不能叫
def make_it_quack(animal):
animal.quack() # 只要对象有quack方法，就能调用
def make_it_fly(thing):
thing.fly() # 只要对象有fly方法，就能调用
duck = Duck()
goose = Goose()
plane = Airplane()
make_it_quack(duck) # Quack!
make_it_quack(goose) # Honk!
# make_it_quack(plane) # 报错：'Airplane' object has no attribute 'quack'
make_it_fly(duck) # Duck is flying
make_it_fly(goose) # Goose is flying
make_it_fly(plane) # Airplane is flying鸭子类型提高了代码的灵活性和复用性，是Python动态类型特性的体现。
10. 解释Python中的缩进规则及其重要性。
在Python中，缩进用于表示代码块的结构，而不是像其他语言那样使用大括号{}。
缩进规则：
- 代码块（如
if、for、while、函数、类等）后的语句需要缩进 - 同一代码块中的语句必须保持相同的缩进量
- 通常使用4个空格作为缩进（推荐），也可使用制表符
Tab，但不要混合使用 - 缩进深度表示代码块的嵌套层次
示例：
python
if x > 10:
print("x is greater than 10") # 缩进，属于if代码块
if x > 20:
print("x is greater than 20") # 更深的缩进，属于嵌套的if代码块
else:
print("x is less than or equal to 10") # 与if同级的缩进
for i in range(5):
print(i) # 属于for循环代码块
if i % 2 == 0:
print("even") # 嵌套在for循环中的if代码块重要性：
- 强制代码具有良好的可读性和一致性
- 明确表示代码的逻辑结构和执行顺序
- 是Python语法的一部分，缩进错误会导致
IndentationError
错误示例：
python
if x > 10:
print("x is greater than 10") # 错误：缺少缩进
print("Another line") # 错误：缩进不一致11. 如何在Python中实现类型转换？（如int()、str()、list()等）
Python提供了多种内置函数用于类型转换，常见的有：
-
数值类型转换：
python# 转为整数 print(int("123")) # 123 print(int(45.67)) # 45（向下取整） print(int(True)) # 1 print(int(False)) # 0 # 转为浮点数 print(float("12.34")) # 12.34 print(float(56)) # 56.0 # 转为复数 print(complex(3, 4)) # (3+4j) print(complex("5+6j")) # (5+6j) -
字符串转换：
pythonprint(str(123)) # "123" print(str(45.67)) # "45.67" print(str(True)) # "True" print(str([1, 2, 3])) # "[1, 2, 3]" -
容器类型转换：
python# 转为列表 print(list("hello")) # ['h', 'e', 'l', 'l', 'o'] print(list((1, 2, 3))) # [1, 2, 3] print(list({4, 5, 6})) # [4, 5, 6]（顺序不确定） # 转为元组 print(tuple([1, 2, 3])) # (1, 2, 3) print(tuple("hello")) # ('h', 'e', 'l', 'l', 'o') # 转为集合 print(set([1, 2, 2, 3])) # {1, 2, 3}（自动去重） print(set("abac")) # {'a', 'b', 'c'} # 转为字典（需传入键值对序列） print(dict([("name", "Alice"), ("age", 30)])) # {'name': 'Alice', 'age': 30} -
布尔值转换：
python# 以下值会被转为False print(bool(0)) # False print(bool("")) # False print(bool(None)) # False print(bool([])) # False print(bool({})) # False # 其他值通常转为True print(bool(1)) # True print(bool("hello")) # True print(bool([0])) # True
注意：不是所有类型之间都能直接转换，不兼容的转换会抛出TypeError或ValueError。
12. Python中的关键字有哪些？举例说明几个常用关键字的作用。
Python有一系列保留关键字，这些词不能用作变量名、函数名或其他标识符。常用关键字及作用：
-
if、elif、else：条件判断pythonx = 10 if x > 10: print("x > 10") elif x == 10: print("x == 10") else: print("x < 10") -
for、while：循环控制python# for循环 for i in range(5): print(i) # while循环 count = 0 while count < 5: print(count) count += 1 -
def：定义函数pythondef add(a, b): return a + b -
class：定义类pythonclass Person: def __init__(self, name): self.name = name -
return：从函数返回值pythondef square(x): return x * x -
import、from：导入模块pythonimport math from datetime import datetime -
try、except、finally：异常处理pythontry: 1 / 0 except ZeroDivisionError: print("Cannot divide by zero") finally: print("This always runs") -
in：检查成员关系pythonprint(3 in [1, 2, 3]) # True print("a" in "apple") # True -
is：检查对象身份pythona = [1, 2, 3] b = a print(a is b) # True -
global、nonlocal：声明变量作用域pythonx = 10 def func(): global x x = 20
完整关键字列表可通过keyword.kwlist查看：
python
import keyword
print(keyword.kwlist)13. 什么是Python的内置函数？列举5个常用的内置函数并说明用途。
内置函数（Built-in Functions）是Python解释器自带的函数，无需导入即可直接使用。以下是5个常用内置函数：
-
print()：输出信息到控制台pythonprint("Hello, World!") # 输出：Hello, World! print(1, 2, 3, sep=", ") # 输出：1, 2, 3 -
len()：返回对象的长度或元素个数pythonprint(len("hello")) # 5（字符串长度） print(len([1, 2, 3])) # 3（列表元素数） print(len({"a": 1, "b": 2})) # 2（字典键值对数量） -
range()：生成一个整数序列pythonprint(list(range(5))) # [0, 1, 2, 3, 4] print(list(range(2, 8))) # [2, 3, 4, 5, 6, 7] print(list(range(1, 10, 2))) # [1, 3, 5, 7, 9]（步长为2） -
input()：接收用户输入pythonname = input("请输入你的名字：") print(f"你好，{name}！") -
sorted()：对可迭代对象进行排序，返回新列表pythonnumbers = [3, 1, 4, 1, 5] print(sorted(numbers)) # [1, 1, 3, 4, 5]（升序） print(sorted(numbers, reverse=True)) # [5, 4, 3, 1, 1]（降序） print(sorted(["apple", "banana", "cherry"], key=len)) # 按长度排序
其他常用内置函数：type()（查看类型）、int()/str()等（类型转换）、max()/min()（求最大/最小值）、sum()（求和）等。
14. 解释pass、break、continue语句的区别。
pass、break和continue都是用于控制程序流程的语句，但用途不同：
-
pass：空语句，用作占位符，不执行任何操作- 用于语法上需要语句但逻辑上不需要做任何事情的地方
pythonif x > 10: pass # 暂时不实现，留待以后补充 else: print("x is small") class MyClass: pass # 空类，等待后续实现 -
break：终止当前循环，跳出循环体- 用于提前结束循环
pythonfor i in range(10): if i == 5: break # 当i等于5时，终止循环 print(i) # 输出：0 1 2 3 4 -
continue：跳过当前循环中的剩余语句，直接进入下一次循环- 用于跳过不符合条件的迭代
pythonfor i in range(10): if i % 2 == 0: continue # 跳过偶数 print(i) # 输出：1 3 5 7 9
总结：
pass：什么都不做，保持语法完整break：彻底终止循环continue：跳过当前迭代，继续下一次迭代
15. Python中的None是什么？它与空字符串、0有何区别？
None是Python中的一个特殊常量，表示"无"或"空"，是NoneType类型的唯一实例。
特性：
- 用于表示变量没有值
- 与任何其他值都不相等（除了它自己）
- 不能被修改
- 作为函数的默认返回值（当函数没有
return语句时）
与空字符串("")、0的区别：
-
类型不同：
pythonprint(type(None)) # <class 'NoneType'> print(type("")) # <class 'str'> print(type(0)) # <class 'int'> -
布尔值不同：
- 三者在布尔判断中都为
False
pythonprint(bool(None)) # False print(bool("")) # False print(bool(0)) # False - 三者在布尔判断中都为
-
含义不同：
None：表示没有值，变量未被赋值或函数无返回""：表示空字符串，是字符串类型的一个实例0：表示整数0，是整数类型的一个实例
-
比较结果不同：
pythonprint(None == "") # False print(None == 0) # False print("" == 0) # False print(None == None) # True
示例：
python
# 函数无返回值时默认返回None
def func():
x = 10
result = func()
print(result) # None
# 作为可选参数的默认值
def greet(name=None):
if name is None:
print("Hello, stranger!")
else:
print(f"Hello, {name}!")
greet() # Hello, stranger!
greet("Alice") # Hello, Alice!注意：判断变量是否为None时，推荐使用is None而非== None，因为is检查身份，更准确。