当前位置： 首页 > news >正文

Python面试题及详细答案150道（01-15） -- 基础语法篇

news 2025/8/7 13:13:34

《前后端面试题》专栏集合了前后端各个知识模块的面试题，包括html，javascript，css，vue，react，java，Openlayers，leaflet，cesium，mapboxGL，threejs，nodejs，mangoDB，SQL，Linux… 。

前后端面试题-专栏总目录

在这里插入图片描述

文章目录

  • 一、本文面试题目录
      • 1. 解释Python的特性（如动态类型、面向对象、可扩展性等）。
      • 2. Python中`is`和`==`的区别是什么？
      • 3. 什么是Python的GIL（全局解释器锁）？它对多线程有什么影响？
      • 4. Python2和Python3的主要区别有哪些？
      • 5. 解释Python中的变量作用域（LEGB规则）。
      • 6. 什么是匿名函数？如何使用`lambda`表达式？
      • 7. `*args`和`**kwargs`的作用是什么？如何使用？
      • 8. Python中的注释有哪几种方式？
      • 9. 什么是Python的“鸭子类型”？举一个例子说明。
      • 10. 解释Python中的缩进规则及其重要性。
      • 11. 如何在Python中实现类型转换？（如`int()`、`str()`、`list()`等）
      • 12. Python中的关键字有哪些？举例说明几个常用关键字的作用。
      • 13. 什么是Python的内置函数？列举5个常用的内置函数并说明用途。
      • 14. 解释`pass`、`break`、`continue`语句的区别。
      • 15. Python中的`None`是什么？它与空字符串、0有何区别？
  • 二、150道Python面试题目录列表

一、本文面试题目录

1. 解释Python的特性（如动态类型、面向对象、可扩展性等）。

Python是一种高级编程语言，具有以下核心特性：

  • 动态类型：变量类型不需要预先声明，解释器会在运行时自动推断。

    x = 10      # 整数
x = "hello" # 无需声明即可变为字符串

  • 面向对象：支持类、继承、多态等面向对象特性，一切皆为对象。

    class Animal:def speak(self):passclass Dog(Animal):def speak(self):return "Woof"

  • 可扩展性：可通过C/C++编写扩展模块，也可嵌入到其他语言中。

  • 简洁易读：使用缩进来划分代码块，语法简洁，接近自然语言。

  • 跨平台：可在Windows、Linux、macOS等多种操作系统上运行。

  • 丰富的库：拥有庞大的标准库和第三方库，覆盖各种应用场景。

  • 解释型：无需编译，直接由解释器执行，开发效率高。

2. Python中is和==的区别是什么？

  • ==：用于比较两个对象的值是否相等（值比较）
  • is：用于判断两个变量是否指向同一个对象（身份比较）

示例：

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密集型任务中多线程效率不高

import threading
import timedef 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是两个不兼容的版本，主要区别包括：

  1. 打印方式：

    # Python2
print "Hello"# Python3
print("Hello")  # 必须使用括号

  2. 字符串类型：

    • Python2：str是字节串，unicode是Unicode字符串
    • Python3：str是Unicode字符串，bytes是字节串

  3. 整数除法：

    # Python2
print(3 / 2)   # 1（整数除法）
print(3 // 2)  # 1# Python3
print(3 / 2)   # 1.5（浮点除法）
print(3 // 2)  # 1（地板除法）

  4. range与xrange：

    • Python2：range()返回列表，xrange()返回生成器
    • Python3：range()功能相当于Python2的xrange()

  5. 异常处理：

    # Python2
try:1/0
except ZeroDivisionError, e:  # 逗号分隔print e# Python3
try:1/0
except ZeroDivisionError as e:  # as关键字print(e)

  6. 输入函数：

    • Python2：raw_input()返回字符串，input()执行输入的代码
    • Python3：只有input()，返回字符串

  7. 迭代器方法：

    • Python2：next()方法和.__next__()
    • Python3：只有.__next__()方法，使用next()内置函数

5. 解释Python中的变量作用域（LEGB规则）。

Python中变量的作用域遵循LEGB规则，即变量查找顺序为：

  1. L（Local，局部作用域）：当前函数或代码块内定义的变量
  2. E（Enclosing，嵌套作用域）：外层嵌套函数中的变量
  3. G（Global，全局作用域）：模块级别定义的变量
  4. B（Built-in，内置作用域）：Python内置的变量和函数

示例：

# 内置作用域（B）：Python自带的len函数# 全局作用域（G）
x = 10def outer():# 嵌套作用域（E）y = 20def inner():# 局部作用域（L）z = 30print(x + y + z)  # 10 + 20 + 30 = 60inner()outer()

修改全局变量需使用global关键字：

x = 10def func():global x  # 声明使用全局变量xx = 20func()
print(x)  # 输出20

修改嵌套作用域变量需使用nonlocal关键字：

def outer():x = 10def inner():nonlocal x  # 声明使用嵌套作用域的xx = 20inner()print(x)  # 输出20outer()

6. 什么是匿名函数？如何使用lambda表达式？

匿名函数是没有名称的函数，使用lambda关键字定义，语法为：

lambda 参数: 表达式

特性：

  • 只能包含一个表达式
  • 表达式的结果即为返回值
  • 无需使用return语句

示例：

# 定义匿名函数
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

def sum_numbers(*args):print(type(args))  # <class 'tuple'>total = 0for num in args:total += numreturn totalprint(sum_numbers(1, 2, 3))        # 6
print(sum_numbers(10, 20, 30, 40)) # 100

示例2：使用**kwargs

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：同时使用

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.** 单行注释 **：使用#，从#开始到行尾的内容都是注释

# 这是一条单行注释
x = 10  # 这也是一条单行注释，用于解释代码

2.** 多行注释 **：使用三个单引号(''')或三个双引号(""")包裹

'''
这是多行注释
可以跨越多行
通常用于函数、类或模块的文档说明
'''"""
这也是多行注释
功能与单引号版本相同
选择哪种取决于个人习惯
"""

3.** 文档字符串（Docstring）**：特殊的多行注释，用于解释模块、函数、类或方法的功能，可通过__doc__属性访问

def add(a, b):"""计算两个数的和参数:a: 第一个加数b: 第二个加数返回:两个数的和"""return a + bprint(add.__doc__)  # 打印文档字符串

良好的注释习惯有助于提高代码的可读性和可维护性。

9. 什么是Python的“鸭子类型”？举一个例子说明。

“鸭子类型”（Duck Typing）是一种编程风格，关注对象的行为（方法和属性）而非其类型。其理念是：“如果它走路像鸭子，叫起来像鸭子，那么它就是鸭子”。

在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中，缩进用于表示代码块的结构，而不是像其他语言那样使用大括号{}。

缩进规则：

  1. 代码块（如if、for、while、函数、类等）后的语句需要缩进
  2. 同一代码块中的语句必须保持相同的缩进量
  3. 通常使用4个空格作为缩进（推荐），也可使用制表符Tab，但不要混合使用
  4. 缩进深度表示代码块的嵌套层次

示例：

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代码块

重要性：

  1. 强制代码具有良好的可读性和一致性
  2. 明确表示代码的逻辑结构和执行顺序
  3. 是Python语法的一部分，缩进错误会导致IndentationError

错误示例：

if x > 10:
print("x is greater than 10")  # 错误：缺少缩进print("Another line")      # 错误：缩进不一致

11. 如何在Python中实现类型转换？（如int()、str()、list()等）

Python提供了多种内置函数用于类型转换，常见的有：

  1. 数值类型转换：

    # 转为整数
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)

  2. 字符串转换：

    print(str(123))        # "123"
print(str(45.67))      # "45.67"
print(str(True))       # "True"
print(str([1, 2, 3]))  # "[1, 2, 3]"

  3. 容器类型转换：

    # 转为列表
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}

  4. 布尔值转换：

    # 以下值会被转为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有一系列保留关键字，这些词不能用作变量名、函数名或其他标识符。常用关键字及作用：

  1. if、elif、else：条件判断

    x = 10
if x > 10:print("x > 10")
elif x == 10:print("x == 10")
else:print("x < 10")

  2. for、while：循环控制

    # for循环
for i in range(5):print(i)# while循环
count = 0
while count < 5:print(count)count += 1

  3. def：定义函数

    def add(a, b):return a + b

  4. class：定义类

    class Person:def __init__(self, name):self.name = name

  5. return：从函数返回值

    def square(x):return x * x

  6. import、from：导入模块

    import math
from datetime import datetime

  7. try、except、finally：异常处理

    try:1 / 0
except ZeroDivisionError:print("Cannot divide by zero")
finally:print("This always runs")

  8. in：检查成员关系

    print(3 in [1, 2, 3])  # True
print("a" in "apple")  # True

  9. is：检查对象身份

    a = [1, 2, 3]
b = a
print(a is b)  # True

  10. global、nonlocal：声明变量作用域

    x = 10
def func():global xx = 20

完整关键字列表可通过keyword.kwlist查看：

import keyword
print(keyword.kwlist)

13. 什么是Python的内置函数？列举5个常用的内置函数并说明用途。

内置函数（Built-in Functions）是Python解释器自带的函数，无需导入即可直接使用。以下是5个常用内置函数：

  1. print()：输出信息到控制台

    print("Hello, World!")  # 输出：Hello, World!
print(1, 2, 3, sep=", ")  # 输出：1, 2, 3

  2. len()：返回对象的长度或元素个数

    print(len("hello"))    # 5（字符串长度）
print(len([1, 2, 3]))  # 3（列表元素数）
print(len({"a": 1, "b": 2}))  # 2（字典键值对数量）

  3. range()：生成一个整数序列

    print(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）

  4. input()：接收用户输入

    name = input("请输入你的名字：")
print(f"你好，{name}！")

  5. sorted()：对可迭代对象进行排序，返回新列表

    numbers = [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都是用于控制程序流程的语句，但用途不同：

  1. pass：空语句，用作占位符，不执行任何操作

    • 用于语法上需要语句但逻辑上不需要做任何事情的地方
    if x > 10:pass  # 暂时不实现，留待以后补充
else:print("x is small")class MyClass:pass  # 空类，等待后续实现

  2. break：终止当前循环，跳出循环体

    • 用于提前结束循环
    for i in range(10):if i == 5:break  # 当i等于5时，终止循环print(i)  # 输出：0 1 2 3 4

  3. continue：跳过当前循环中的剩余语句，直接进入下一次循环

    • 用于跳过不符合条件的迭代
    for 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的区别：

  1. 类型不同：

    print(type(None))   # <class 'NoneType'>
print(type(""))     # <class 'str'>
print(type(0))      # <class 'int'>

  2. 布尔值不同：

    • 三者在布尔判断中都为False
    print(bool(None))   # False
print(bool(""))     # False
print(bool(0))      # False

  3. 含义不同：

    • None：表示没有值，变量未被赋值或函数无返回
    • ""：表示空字符串，是字符串类型的一个实例
    • 0：表示整数0，是整数类型的一个实例

  4. 比较结果不同：

    print(None == "")   # False
print(None == 0)    # False
print("" == 0)      # False
print(None == None) # True

示例：

# 函数无返回值时默认返回None
def func():x = 10result = 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检查身份，更准确。

二、150道Python面试题目录列表

文章序号Python面试题150道
1Python面试题及详细答案150道（01-15）
2Python面试题及详细答案150道（16-30）
3Python面试题及详细答案150道（31-40）
4Python面试题及详细答案150道（41-55）
5Python面试题及详细答案150道（56-70）
6Python面试题及详细答案150道（71-80）
7Python面试题及详细答案150道（81-90）
8Python面试题及详细答案150道（91-100）
9Python面试题及详细答案150道（101-115）
10Python面试题及详细答案150道（116-125）
11Python面试题及详细答案150道（126-135）
12Python面试题及详细答案150道（136-150）
http://www.lryc.cn/news/612349.html

相关文章：

  • 译 | 在 Python 中从头开始构建 Qwen-3 MoE
  • 三轴云台之机械结构篇
  • ubuntu server 工业环境部署手册[2025-08-06]
  • 查看ubuntu server 的基本信息
  • Node.js从入门到精通完整指南
  • 服务器重启后mysql5.7启动失败问题
  • [激光原理与应用-163]：光机械件 - 光机械件的工程技术难点
  • .Net下载共享文件夹中的文件
  • NCD57080CDR2G 安森美onsemi 通用驱动器, SOIC, 8针, 20V电源, 8 A输出NCD57080CDR2电流隔离式栅极驱动器
  • C++11之智能指针
  • harmonyOS学习 - rcp请求
  • 文字转语音tts
  • 鹧鸪云：光伏电站的“智慧中枢”，精准调控逆变器
  • OpenCV校准双目相机并测量距离
  • 10.MTK充电之mt6358-gauge驱动
  • Linux发行版分类与Centos替代品
  • 媒体资产管理系统和OCR文字识别的结合
  • 笔试——Day30
  • 简单介绍cgroups以及在K8s中的应用
  • 小程序中，给一段富文本字符串文案特殊内容加样式监听点击事件
  • 无人机遥控器舵量技术解析
  • cad c#二次开发 图层封装 获取当前层
  • 无人机遥控器波特率技术解析
  • 基于AI的自动驾驶汽车（AI-AV）网络安全威胁缓解框架
  • 开疆智能ModbusTCP转Profinet网关连接EPSON机器人配置案例
  • Docker国内可用镜像（2025.08.06测试）
  • 深入理解数据库连接池（Connection Pool）：原理、优势与常见实现
  • wordpress网站的“管理员邮箱地址”有什么用？
  • Linux86 sheel流程控制前瞻4 判断vsftpd服务启动，如果启动，打印端口号，进程id
  • 系统运维之LiveCD详解