初级面试题

字符串常用方法

面试题目

• 级别: L1
• 知识模块: Python 编程语言

请列举字符串常用方法

公司

• 小米

招聘类型

社招

题目解析

本题目主要考察对字符串常用 API 的了解和掌握程度

答案

字符串操作方法有很多，可将字符串方法进行分类如下：

• 统计查找替换类
  • index() 查找子串
  • find() 查找子串，找不到不报错
  • count() 统计子串
• 字符串判断类
  • startswith() 判断是否以指定字符串开头
  • endswith() 判断是否以指定字符串结尾
  • isdigit() 判断是否是数字字符串
  • isupper() 判断是否是全大写字母
  • islower() 判断是否是全小写字母
• 字符串转换类
  • upper() 转大写
  • lower() 转小写
• 字符串对齐类
  • center() 居中对齐
  • ljust() 左对齐
  • rjust() 右对齐
• 字符串去除空白类
  • strip() 去除两端空白字符
• 字符串分割类
  • split() 分割字符串
• 字符串连接类
  • join() 连接字符串
• 编码解码类
  • encode() 编码
  • decode() 解码

字符串逆序

面试题目

• 级别: L1
• 知识模块: Python 编程语言

如何对字符串进行逆序，至少使用两种方式完成

公司

• 美团外包

招聘类型

社招

题目解析

• 题目主要考察对 Python 特性的理解和编程逻辑能力
• 可使用切片、字符串拼接、借助其它类型等方式实现

答案

方式一： 使用切片

s = "hello"
s = s[::-1]
print(s)

方式二：使用字符串拼接

s = 'hello'
rs = ""
for c in s:
    rs = c + rs
print(rs)

方式三：借助列表

s = "hello"
rs = list(s)
rs.reverse()
rs = "".join(rs)
print(rs)

函数返回值

面试题目

• 级别: L1
• 知识模块: Python 编程语言

一个函数可以返回多个值吗？

公司

• 小米外包

招聘类型

社招

题目解析

了解函数返回多个值的机制对于掌握 Python 函数特性和提高代码可读性和效率至关重要。Python 支持函数返回多个值，这种特性可以简化代码，使其更加直观。

def get_name_and_age():
    name = "Alice"
    age = 30
    return name, age

# 调用函数并接收返回的多个值
name, age = get_name_and_age()
print(f"Name: {name}, Age: {age}")

在这个示例中，函数 get_name_and_age 返回了一个包含两个值的元组。在调用函数时，可以使用拆包（unpacking）语法将返回的元组中的值分别赋给多个变量。

答案

• 函数使用 return 语句返回数据
• 一个函数中同时可以包含多个 return 语句，但同一时刻，只能有一个 return 执行
• 函数只能返回一个值
• 在 Python 中允许出现 return 1,2,3 这样的代码，看似同时返回了多个值，实际上 Python 会将多个值自动组包成一个元组类型数据再返回，实际返回的还是一个值
• 结论：一个函数同一时刻只能返回一个数据

交换两个变量的值

面试题目

• 级别: L1
• 知识模块: Python 编程语言

如何不使用中间变量，交换两个变量的值

公司

• 小米外包

招聘类型

社招

题目解析

此题目是对语言的特性和运算符掌握程度的考察，解决方式有多种。

答案

组包解包法（重点掌握）

利用 Python 的组包解包特性，多变量同时赋值时，等号右侧的值会依次赋值给等号左边的变量。

此方法可适用于任何数据类型的变量交换。

a = 5
b = 10

a, b = b, a

加减法

1. 利用数字进行加减运算实现两个变量的数据交换。

2. 只适合数字类型值的交换。

a = 5
b = 10

a = a + b
b = a - b
a = a - b

如何将字符串转化为整型

面试题目

• 级别: L1
• 知识模块: Python 编程语言

Python 中，如何将字符串转化为整型？

公司

• 字节外包

招聘类型

• 社招

题目解析

这个问题考察的是字符串和整型之间的转换，特别是使用内置函数 int() 的能力。需要考虑到输入的有效性，例如输入的字符串是否是有效的数字表示。

在 Python 中，我们可以使用内置的 int() 函数将一个字符串转化为整型。这个函数会尝试解析字符串并返回相应的整型值，如果字符串不包含有效的整型表示，则会引发一个 ValueError 异常。因此，在实际使用中，我们应该捕获可能的异常，以处理无效输入的情况。

示例代码：

def str_to_int(s):
    try:
        return int(s)
    except ValueError:
        print(f"Cannot convert '{s}' to integer.")
        return None

# 示例使用
print(str_to_int("123"))  # 输出: 123
print(str_to_int("abc"))  # 输出: Cannot convert 'abc' to integer. None
print(str_to_int("456"))  # 输出: 456

代码解释

1. 使用 int() 函数: int() 函数用于将字符串转换为整型。
2. 异常处理: 使用 try...except 块捕获可能的 ValueError 异常，以处理无效的输入字符串。
3. 返回结果: 如果转换成功，则返回整型值；如果转换失败，则打印错误信息并返回 None。

答案

1. 问题理解：这个问题考察的是字符串和整型之间的转换，特别是使用内置函数 int() 的能力。需要考虑到输入的有效性，例如输入的字符串是否是有效的数字表示。
2. 解决思路：在 Python 中，我们可以使用内置的 int() 函数将一个字符串转化为整型。这个函数会尝试解析字符串并返回相应的整型值，如果字符串不包含有效的整型表示，则会引发一个 ValueError 异常。因此，在实际使用中，我们应该捕获可能的异常，以处理无效输入的情况。
3. 代码实现：正确编写代码，展示编码能力和细节处理能力。

is和==的区别

面试题目

• 级别: L1
• 知识模块: Python 编程语言

is 与 == 的区别

公司

• 传音控股

招聘类型

社招

题目解析

本题考察对 Python 运算符的理解

答案

而 is 与 == 都作为常用的判断语句去进行使用，这两者之间的主要区别是：

• == 运算符: 只比较两个对象的值，相同返回 True，不同返回 False。
• is 运算符: 比较两个对象的 id，相同返回 True，不同返回 False。

在这种场景下， 两个判断的执行结果均为 True。

a, b = 1,1
# 判断a，b 是否相等
print(a == b)
print(a is b)

在这种场景下， 两个判断的执行结果均为不一致。

a = [1,2,3]
b = [1,2,3]
# 对比值一致，返回True
print(a == b)
# 对比内存地址不一致，返回False
print(a is b)

python中的容器有哪些

面试题目

• 级别: L1
• 知识模块: Python 编程语言

python 中的容器有哪些

公司

• 小米

招聘类型

社招

题目解析

在 Python 中，主要的容器类型包括：

1. 列表（List）
2. 元组（Tuple）
3. 字典（Dictionary）
4. 集合（Set）
5. 字符串（String）

下面分别介绍各种容器：

1. 列表（List）

   • 定义: 列表是一个有序的可变序列，可以存储任意类型的元素。
   • 语法: 使用方括号 [] 创建。
   • 特性:
     • 元素可重复。
     • 支持索引和切片。
     • 支持添加、删除和修改操作。

示例:

my_list = [1, 2, 3, 4, 5]
my_list.append(6)
print(my_list)  # 输出：[1, 2, 3, 4, 5, 6]

1. 元组（Tuple）

   • 定义: 元组是一个有序的不可变序列，可以存储任意类型的元素。
   • 语法: 使用圆括号 () 创建。
   • 特性:
     • 元素可重复。
     • 支持索引和切片。
     • 不可修改（不可变性保证数据的安全性和稳定性）。

示例:

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[1])  # 输出：2
# my_tuple[1] = 6  # 会引发错误：TypeError: 'tuple' object does not support item assignment

1. 字典（Dictionary）

   • 定义: 字典是一个无序的键值对集合。
   • 语法: 使用花括号 {} 创建。
   • 特性: - 键必须唯一且不可变。 - 值可以是任意类型。 - 支持快速查找、添加、修改和删除操作。

示例:

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['d'] = 4
print(my_dict)  # 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

1. 集合（Set）

   • 定义: 集合是一个无序的、元素唯一的集合。
   • 语法: 使用花括号 {} 或 set() 函数创建。
   • 特性:
     • 元素必须唯一且不可变。
     • 支持集合运算（并集、交集、差集等）。
     • 适用于需要存储不重复元素的场景。

示例:

my_set = {1, 2, 3, 4, 5}
my_set.add(6)
print(my_set)  # 输出：{1, 2, 3, 4, 5, 6}

1. 字符串（String）

   • 定义: 字符串是一个有序的字符序列。
   • 语法: 使用单引号 '' 或双引号 "" 创建。
   • 特性:
     • 不可变。
     • 支持索引和切片。
     • 内置了丰富的字符串操作方法。

示例:

my_string = "hello"
print(my_string[1])  # 输出：e
# my_string[1] = 'a'  # 会引发错误：TypeError: 'str' object does not support item assignment

答案

Python 提供了丰富的容器类型，包括列表、元组、字典、集合等。每种类型都有其独特的特性和适用场景。列表和元组用于有序数据的存储，字典用于键值对的快速查找，集合用于存储唯一元素，字符串用于文本数据的操作。选择合适的容器类型可以提高代码的可读性和性能。

各数据结构特点区别

面试题目

• 级别: L1
• 知识模块: Python 编程语言

各数据结构特点、区别。

公司

• 字节外包

招聘类型

• 社招

题目解析

了解和掌握各类数据结构的特点和区别是编写高效代码的基础。常用的数据结构包括列表、元组、集合和字典。每种数据结构都有其独特的特性和使用场景。

1. 列表（List）

   • 特点: 有序，可变，允许重复元素。列表中的元素可以是不同类型的。
   • 使用场景: 需要存储顺序关系的数据，并且需要频繁修改或访问元素的场景。

my_list = [1, 2, 3, 4]
my_list.append(5)  # 添加元素
my_list.remove(2)  # 删除元素
print(my_list[0])  # 访问元素

1. 元组（Tuple）

   • 特点: 有序，不可变，允许重复元素。元组中的元素可以是不同类型的。
   • 使用场景: 需要存储不可变的序列数据，或者作为字典键的场景。

my_tuple = (1, 2, 3, 4)
print(my_tuple[0])  # 访问元素
# my_tuple[1] = 5  # 不可变，不能修改元素

1. 集合（Set）

   • 特点: 无序，不可重复。集合中的元素必须是可哈希的。
   • 使用场景: 需要存储不重复的元素并且对其进行集合操作（如并集、交集）的场景。

my_set = {1, 2, 3, 4}
my_set.add(5)  # 添加元素
my_set.remove(3)  # 删除元素
print(1 in my_set)  # 搜索元素

1. 字典（Dictionary）

   • 特点: 无序（Python 3.7+ 中插入顺序被保留），键值对存储，键必须是可哈希的且唯一，值可以是任意类型。
   • 使用场景: 需要通过键快速查找值的场景。

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['d'] = 4  # 插入元素
del my_dict['b']  # 删除元素
print(my_dict['a'])  # 访问元素

答案

1. 列表: 有序且可变，适合存储顺序关系的数据。

2. 元组: 有序且不可变，适合存储不可变的序列数据。

3. 集合: 无序且不可重复，适合存储不重复元素并进行集合操作。

4. 字典: 无序（Python 3.7+ 保留插入顺序），键值对存储，键唯一且可哈希。

列表的数据结构

面试题目

• 级别: L1
• 知识模块: Python 编程语言

列表的数据结构

公司

• 字节外包

招聘类型

社招

题目解析

Python 列表是一种非常灵活且功能强大的数据结构。它的特点和使用方式如下：

1. 定义和创建：列表使用方括号 [] 定义，元素之间用逗号分隔。

my_list = [1, 2, 3, 4, 5]

1. 有序性： 列表中的元素是有序的，每个元素都有一个索引，从 0 开始。

first_element = my_list[0]  # 获取第一个元素，输出 1

1. 可变性：列表是可变的，可以在原有列表上添加、删除或修改元素。

my_list.append(6)  # 在末尾添加元素 6
my_list[2] = 99    # 将索引 2 处的元素修改为 99

1. 混合数据类型：列表可以包含不同类型的元素。

mixed_list = [1, "hello", 3.14, True]

1. 嵌套列表：列表可以包含其他列表，形成多维数组或嵌套列表。

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

1. 常用操作：

   • 添加元素：append(), insert()
   • 删除元素：remove(), pop(), del
   • 切片操作：获取子列表
   • 列表推导式：生成新的列表

sublist = my_list[1:3]  # 获取子列表 [2, 99]
squared_list = [x**2 for x in my_list if isinstance(x, int)]

答案

列表是有序的数据集合，可以存储任意类型的数据，动态添加删除列表中的数据，列表通过索引访问元素，并且可以对列表进行切片操作。

列表常用方法有， append() 、 insert()、 remove()、index()、sort() 等方法。

由于列表的顺序存储特性，可利用列表中的方法，实现队列，栈等数据结构。

什么是字典

面试题目

• 级别: L1
• 知识模块: Python 编程语言

什么是字典

公司

• 小米

招聘类型

社招

题目解析

这个问题考察的是对 Python 中字典数据结构的理解。字典是 Python 中一种常用的数据结构，具有快速查找、插入和删除的特点，用键值对存储数据，可以通过键快速定位值。

定义：在 Python 中，字典（dictionary）是一种内置的数据结构，用于存储键值对（key-value pairs）。每个键值对中的键是唯一的，字典通过键来快速查找对应的值。字典使用大括号 {} 表示，键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。

字典的特点

1. 无序性: 在 Python 3.7 之前，字典是无序的，从 Python 3.7 开始，字典是有序的（插入顺序）。
2. 键唯一性: 字典中的键必须是唯一的，如果同一个键被赋值多次，最后的赋值会覆盖之前的值。
3. 可变性: 字典是可变的，支持动态添加、修改和删除键值对。
4. 高效性: 字典的查找、插入和删除操作的时间复杂度平均为 O(1)，非常高效。

示例代码：

# 创建一个字典
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

# 访问字典中的值
print(person["name"])  # 输出: Alice

# 更新字典中的值
person["age"] = 31

# 添加新的键值对
person["email"] = "alice@example.com"

# 删除键值对
del person["city"]

# 遍历字典
for key, value in person.items():
    print(f"{key}: {value}")

# 输出:
# name: Alice
# age: 31
# email: alice@example.com

答案

• 字典是一种可变容器模型
• 以键值对形式做为元素保存数据
• 键必须是不可变数据，值可以是任意数据类型。

python中元组长度大小可变吗

面试题目

• 级别: L1
• 知识模块: Python 编程语言

python 中元组长度大小可变吗

公司

• 小米外包

招聘类型

社招

题目解析

元组是 Python 中的一种数据类型，主要用于存储不可变的数据序列。元组的不可变性是其核心特性，这意味着一旦元组被创建，其长度和内容都不能改变。理解元组的不可变性对于掌握 Python 中的数据结构和编写健壮的代码至关重要。

元组（tuple）是 Python 中的一种内置数据类型，用于存储一组有序的元素。元组的元素可以是任意类型，并且可以包含重复的元素。

不可变性

元组的一个重要特性是不可变性（immutable）。这意味着一旦元组被创建，其长度和内容都不能修改。这与列表（list）不同，列表是可变的，可以动态地添加、删除或修改元素。

示例：

# 创建一个元组
my_tuple = (1, 2, 3, 4, 5)

# 尝试修改元组中的元素
# my_tuple[0] = 10  # 会引发错误：TypeError: 'tuple' object does not support item assignment

# 尝试改变元组的长度
# my_tuple.append(6)  # 会引发错误：AttributeError: 'tuple' object has no attribute 'append'

如何理解元组的不可变性

1. 内存分配: 元组的不可变性使得其内容在创建后不能被改变。这意味着元组的大小在内存中是固定的，不能动态扩展或缩减。
2. 使用场景: 元组通常用于存储不需要改变的数据，例如作为函数参数和返回值、数据库记录等。其不可变性保证了数据的一致性和安全性。

答案

元组的一个重要特性是不可变性（immutable）。这意味着一旦元组被创建，其长度和内容都不能修改。

列表和元组的区别

面试题目

• 级别: L1
• 知识模块: Python 编程语言

列表和元组的区别

公司

• 小米

招聘类型

社招

题目解析

列表和元组是 Python 中的两种常见数据结构，它们在存储和操作数据时有不同的特性和用途。理解它们的区别对于编写高效、可维护的 Python 代码非常重要。

1. 可变性：

   • 列表（List）: 可变的数据结构，可以动态地添加、删除或修改元素。
   • 元组（Tuple）: 不可变的数据结构，一旦创建，就不能修改其内容。

2. 语法和创建：

   • 列表: 使用方括号 [] 创建。
   • 元组: 使用圆括号 () 创建。

3. 使用场景：

   • 列表: 适用于需要频繁修改数据的场景，比如需要动态添加或删除元素。
   • 元组: 适用于数据不需要修改的场景，比如定义常量组，或者作为字典的键，因为元组是不可变的。

4. 性能：

   • 因为元组是不可变的，其在某些场景下的性能可能比列表更高，尤其是在需要大量不变数据的情况下。
   • 列表的灵活性带来了额外的开销，所以操作频繁时性能可能稍逊于元组。

5. 内存使用：

   • 元组的不可变性使得其内存使用通常比列表更高效。

6. 内置方法：

   • 列表: 提供了丰富的方法来修改内容，如 append(), remove(), pop() 等。
   • 元组: 提供的方法较少，只有 count() 和 index() 两个基本方法。

简短示例代码

• 列表

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出: [1, 2, 3, 4]

• 元组

my_tuple = (1, 2, 3)
# my_tuple[0] = 0  # 会引发 TypeError
print(my_tuple)  # 输出: (1, 2, 3)

答案

• 元组是不可变的,使用 () 表示，不可以进行增删改操作，一旦定义，无法修改。
• 列表是可变的，使用 [] 表示，可以对列表中的元素进行增删改操作，空列表有实际意义。
• 元组和列表在 Python 中，都是有序的，可迭代的数据结构。
• 元组和列表都是异构的，都可以存放不同数据类型的元素
• 由于元组与列表内部的实现机制不同，在相同元素和个数的情况下，元组占用内存空间更小。

json和dict的区别

面试题目

• 级别: L1
• 知识模块: Python 编程语言

json 和 dict 的区别?

公司

• 字节外包

招聘类型

• 社招

题目解析

1. JSON（JavaScript Object Notation）

   • 定义: JSON 是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。
   • 用途: 常用于在客户端和服务器之间传输数据，尤其是在 Web 应用程序中。
   • 格式: JSON 是一个字符串，具有特定的语法，包括键值对、数组、字符串、数字、布尔值和 null。
   • 表示: 在 Python 中，JSON 数据通常表示为一个字符串，可以通过内置的 json 模块进行处理。

示例代码：

import json

# JSON 字符串
json_str = '{"name": "Alice", "age": 25, "city": "New York"}'

# 将 JSON 字符串解析为 Python 字典
data = json.loads(json_str)
print(data)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York'}

# 将 Python 字典转换为 JSON 字符串
json_output = json.dumps(data)
print(json_output)  # 输出：{"name": "Alice", "age": 25, "city": "New York"}

1. dict（字典）

   • 定义: 字典是 Python 中的一种内置数据类型，用于存储键值对。
   • 用途: 主要用于在程序内部存储和处理数据，适用于需要快速查找和修改数据的场景。
   • 格式: 字典是一种数据结构，使用花括号 {} 表示，键值对之间用逗号分隔，键和值之间用冒号分隔。
   • 表示: 在 Python 中，字典是一个实际的对象，具有自己的内存空间和方法。

示例代码：

# 创建一个字典
my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 访问字典中的值
print(my_dict["name"])  # 输出：Alice

# 修改字典中的值
my_dict["age"] = 26
print(my_dict)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York'}

区别：

1. 类型:

   • JSON: 是一个字符串，通常用作数据传输格式。
   • dict: 是 Python 的内置数据类型，用于在内存中存储数据。

2. 用途:

   • JSON: 主要用于数据交换，比如在 Web 应用中从服务器向客户端传递数据。
   • dict: 主要用于程序内部的数据处理和操作。

3. 格式转换:

   • JSON: 可以通过 json 模块进行解析和生成，方法包括 json.loads() 和 json.dumps()。
   • dict: 是直接在 Python 中使用的对象，不需要额外的解析或生成步骤。

4. 存储方式:

   • JSON: 以字符串形式存储，通常保存在文件或通过网络传输。
   • dict: 存储在内存中，可以直接进行操作和修改。

答案

JSON 和字典在 Python 编程中各有用途。JSON 适用于数据传输和存储，而字典适用于程序内部的数据操作和管理。理解它们之间的区别和联系，有助于选择合适的工具来处理不同的编程任务。

集合和字典的区别

面试题目

• 级别: L1
• 知识模块: Python 编程语言

集合和字典的区别

公司

• 字节外包

招聘类型

社招

题目解析

理解集合和字典的区别对于掌握 Python 数据结构非常重要。集合和字典都是内置的数据类型，各自有不同的特性和用途。面试者需要清楚地解释两者的概念、用法和适用场景，并能够举例说明。

集合（Set）和字典（Dictionary）的主要区别:

1. 定义:

   • 集合（Set）: 无序、不重复元素的集合。
   • 字典（Dictionary）: 键值对（key-value pairs）的集合。

2. 创建方式:

集合:

my_set = {1, 2, 3, 4}
my_set = set([1, 2, 3, 4])

字典：

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict = dict(a=1, b=2, c=3)

1. 元素访问:

集合: 由于集合是无序的，不能通过索引访问元素，只能通过迭代或使用 in 关键字检查元素是否存在。

if 1 in my_set:
    print("1 is in the set")

字典: 可以通过键访问对应的值。

value = my_dict['a']

1. 存储特性:

集合: 只存储不重复的元素，适用于去重操作。

my_set = {1, 2, 2, 3, 4}
print(my_set)  # 输出: {1, 2, 3, 4}

字典: 存储键值对，每个键必须是唯一的，值可以重复。

my_dict = {'a': 1, 'b': 2, 'c': 2}

1. 常用操作:

集合:

• 添加元素: add()
• 删除元素: remove(), discard()
• 集合运算: 并集（union）、交集（intersection）、差集（difference）

my_set.add(5)
my_set.remove(3)
union_set = my_set.union({6, 7})

字典: - 添加/更新键值对: 通过赋值操作 - 删除键值对: del、pop() - 获取所有键: keys() - 获取所有值: values()

my_dict['d'] = 4
del my_dict['a']
keys = my_dict.keys()
values = my_dict.values()

答案

集合是无序的数据集合，只能保存可哈希的不可变数据 字典是键值对的数据集合，可以通过键访问值。

dict和tuple及list的区别

面试题目

• 级别: L1
• 知识模块: Python 编程语言

dict 和 tuple 及 list 的区别?

公司

• 字节外包

招聘类型

• 社招

题目解析

1. dict（字典）

2. 定义: 字典是一种无序的键值对集合。

3. 语法: 使用花括号 {} 或者 dict() 函数创建。
4. 特性:
   • 键唯一: 每个键在字典中是唯一的。
   • 可变性: 字典是可变的，可以动态添加、修改和删除键值对。
   • 插入顺序: 从 Python 3.7 开始，字典保持插入顺序。

示例:

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['d'] = 4
print(my_dict)  # 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

1. tuple（元组）

2. 定义: 元组是一个不可变的有序集合。

3. 语法: 使用圆括号 () 或者 tuple() 函数创建。
4. 特性:
   • 不可变性: 一旦创建，元组的元素不能修改。这使得元组在需要一个固定数据集合的场景中非常有用。
   • 有序性: 元组中的元素是有序的，可以通过索引访问。
   • 性能: 元组的访问和遍历速度比列表更快，适用于不需要修改的静态数据

示例:

my_tuple = (1, 2, 3)
print(my_tuple[1])  # 输出：2
# my_tuple[1] = 4  # 会引发错误：TypeError: 'tuple' object does not support item assignment

1. list（列表）

2. 定义: 列表是一个可变的有序集合。

3. 语法: 使用方括号 [] 或者 list() 函数创建。
4. 特性:
   • 可变性: 列表是可变的，可以动态添加、修改和删除元素。
   • 有序性: 列表中的元素是有序的，可以通过索引访问。

示例:

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出：[1, 2, 3, 4]

答案

• 用途不同: 字典用于存储键值对，适合快速查找；元组用于存储不可变的数据，适合需要固定集合的场景；列表用于存储可变的有序元素，适合动态数据。
• 可变性: 字典和列表是可变的，而元组是不可变的。
• 有序性: 列表和元组是有序的，而字典在 Python 3.7 及之后的版本中保持插入顺序。

字典新添加数据的插入顺序

面试题目

• 级别: L1
• 知识模块: Python 编程语言

字典新添加数据的插入顺序

公司

• 小米外包

招聘类型

社招

题目解析

在 Python 中，字典（dict）是一种用于存储键值对的数据结构。了解字典插入顺序的变化对于理解和使用 Python 字典非常重要。自 Python 3.7 起，字典开始保持插入顺序，这意味着元素按插入的顺序存储和访问。

示例代码：

# 创建一个字典并插入数据
my_dict = {}
my_dict['a'] = 1
my_dict['b'] = 2
my_dict['c'] = 3

# 输出字典
print(my_dict)
# 输出：{'a': 1, 'b': 2, 'c': 3}

# 插入新数据
my_dict['d'] = 4

# 输出更新后的字典
print(my_dict)
# 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

答案

在 Python 3.7 及其之后的版本中，字典（dict）会按照元素插入的顺序来维护键值对。这一行为是 Python 语言规范的一部分，因此字典在保持插入顺序方面是可靠和稳定的。在 Python 3.6 中，这一特性已经作为实现细节存在，但并未作为语言规范的一部分正式保证。

深拷贝和浅拷贝

面试题目

• 级别: L1
• 知识模块: Python 编程语言

深拷贝和浅拷贝

公司

• 字节外包

招聘类型

社招

题目解析

题目主要考察对这两个概念的理解以及它们在实际编程中的应用。

1. 深拷贝：

   • 深拷贝是指在复制对象时，会递归地复制所有的子对象，包括子对象的子对象，以确保复制的对象和原始对象完全独立，修改其中一个对象不会影响另一个对象。深拷贝通常会消耗更多的时间和内存，但可以完全独立地操作数据。
   • 深拷贝使用 copy 模块中的 deepcopy() 方法实现

2. 浅拷贝：

   • 浅拷贝是指只复制对象本身和对象中的直接子对象，而不会递归复制子对象的子对象。因此，浅拷贝可能会导致复制的对象和原始对象共享某些子对象，修改一个对象的子对象可能会影响另一个对象。浅拷贝通常执行速度更快，但在某些情况下可能不够安全。
   • 对象的 copy() 方法，copy 模块的 copy() 方法，工厂方法，切片等方式得到的都是浅拷贝对象。

答案

深拷贝和浅拷贝是日常工作中经常用到的两种数据拷贝方式，深拷贝和浅拷贝的主要区别在于拷贝后的对象是否共享内存。

• 浅拷贝是创建一个新对象，新对象中的数据与原对象中的数据具有相同的地址，也就是说新对象中的一部分数据是共享原对象中的数据的地址。如果原对象中的某些数据被改变，那么新对象中共享该数据的部分也会发生改变。
• 深拷贝是创建一个新对象，新对象中的数据与原对象中的数据地址不同，也就是说新对象中的所有数据都是独立的。如果原对象中的某些数据被改变，那么新对象中不会受到影响。

for和else的执行逻辑

面试题目

• 级别: L1
• 知识模块: Python 编程语言

for 和 else 的执行逻辑

公司

• 传音控股

招聘类型

社招

题目解析

在 Python 中，for循环和else语句结合使用的逻辑可能初看之下有些反直觉，但它遵循了清晰的逻辑原则。这种用法允许else块在for循环正常结束（即没有通过break语句提前退出）时执行。

基本逻辑

for i in range(5):
    if i == 3:
        break  # 提前终止循环
    print(i)
else:
    print("Loop completed normally")`

1. for循环执行：首先，for循环会按照其定义的迭代逻辑执行，遍历给定的序列（如列表、元组、字典的键或值的迭代器等）。
2. 正常结束：如果for循环中的代码执行完毕，且没有遇到break语句导致循环提前退出，那么for循环将正常结束。
3. else语句执行：当for循环正常结束后，紧跟在for循环后面的else语句块将被执行。这里的“正常结束”指的是循环体中的所有迭代都完成了，而不是因为某种条件而提前结束（比如通过break）。
4. break与else：如果在for循环的某个迭代中执行了break语句，那么循环将提前终止，并且不会执行else语句块。

答案

当 for 循环正常结束时，会执行 else 语句块；如果在循环中有 break 语句跳出，则不会执行 else。

回文数之和

面试题目

• 级别: L1
• 知识模块: Python 编程语言

使用你最熟悉的编程语言写一个 1-9999 之间的回文数之和的程序?

公司

• 字节外包

招聘类型

• 社招

题目解析

回文数是指正读和反读都相同的数字，例如 121、1331 等。题目要求计算 1 到 9999 之间所有回文数的和。这涉及到生成指定范围的数字，检查它们是否为回文数，然后求和。

要解决这个问题，我们需要完成以下几个步骤：

1. 生成 1 到 9999 之间的所有数字。
2. 检查每个数字是否是回文数。
3. 将所有回文数相加。

def is_palindrome(num):
    # 将数字转换为字符串
    num_str = str(num)
    # 检查字符串是否为回文
    return num_str == num_str[::-1]

def sum_of_palindromes(limit):
    total_sum = 0
    for num in range(1, limit + 1):
        if is_palindrome(num):
            total_sum += num
    return total_sum

# 计算1到9999之间所有回文数的和
result = sum_of_palindromes(9999)
print(f"The sum of palindromic numbers between 1 and 9999 is: {result}")

代码解释:

1. is_palindrome 函数:

   • 将数字转换为字符串，检查字符串是否为回文（即正序与反序相同）。

2. sum_of_palindromes 函数:

   • 初始化总和为 0。
   • 遍历 1 到指定范围内的所有数字，使用 is_palindrome 函数检查每个数字是否为回文数。
   • 若是回文数，则将其加到总和中。

3. 计算结果:

   • 调用 sum_of_palindromes(9999) 计算 1 到 9999 之间所有回文数的和，并输出结果。

答案

def is_palindrome(num):
    # 将数字转换为字符串
    num_str = str(num)
    # 检查字符串是否为回文
    return num_str == num_str[::-1]

def sum_of_palindromes(limit):
    total_sum = 0
    for num in range(1, limit + 1):
        if is_palindrome(num):
            total_sum += num
    return total_sum

# 计算1到9999之间所有回文数的和
result = sum_of_palindromes(9999)
print(f"The sum of palindromic numbers between 1 and 9999 is: {result}")

代码：python斐波那契+1

面试题目

• 级别: L1
• 知识模块: Python 编程语言

代码：python 斐波那契+1 (2，2，4，6，10....)

公司

• 小米

招聘类型

社招

题目解析

题目主要考察考生对数列规律的理解、编程逻辑等方面的能力

斐波那契函数原理

递归实现：

def fibonacci_recursive(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)

# 测试递归函数
for i in range(10):
    print(fibonacci_recursive(i), end=" ")

迭代实现：

def fibonacci_iterative(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

# 测试迭代函数
for i in range(10):
    print(fibonacci_iterative(i), end=" ")

答案

编写一个函数，实现斐波那契数列每个数字加 1 的功能。

递归实现：

def fibonacci_recursive(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci_recursive(n-1) + fibonacci_recursive(n-2) + 1

# 测试递归函数
for i in range(10):
    print(fibonacci_recursive(i), end=" ")

迭代实现：

def fibonacci_iterative(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b + 1

# 测试迭代函数
for i in range(10):
    print(fibonacci_iterative(i), end=" ")

求列表中有哪些是成对的，已经有几对

面试题目

• 级别: L1
• 知识模块: Python 编程语言

[a,a,a,b,c,c,d,d,d]中，两个相邻的且相同的数字为一对。 比如上述 a 有两对，第一个 a 和第二个 a 是一对，第二个 a 和第三个 a 也是一对，所以 a 有两对、c 有一对、d 有两对。求有哪些是成对的，已经有几对？

公司

• 字节外包

招聘类型

• 社招

题目解析

这个问题要求我们遍历列表，找出所有相邻且相同的元素对，并统计每个元素的对数。使用一个字典来记录每个元素出现的对数是一个有效的解决方案。

代码实现：

def count_pairs(lst):
    pair_counts = {}

    for i in range(1, len(lst)):
        if lst[i] == lst[i - 1]:
            if lst[i] in pair_counts:
                pair_counts[lst[i]] += 1
            else:
                pair_counts[lst[i]] = 1

    return pair_counts

# 示例使用
lst = ['a', 'a', 'a', 'b', 'c', 'c', 'd', 'd', 'd']
result = count_pairs(lst)
print(result)  # 输出: {'a': 2, 'c': 1, 'd': 2}

代码解释

1. 初始化字典：创建一个空字典 pair_counts 来存储每个元素的对数。
2. 遍历列表：从索引 1 开始遍历列表，因为我们需要比较当前元素和前一个元素。
3. 检查相邻元素：如果当前元素 lst[i] 和前一个元素 lst[i - 1] 相同，就更新 pair_counts 字典。
4. 返回结果：最终返回记录对数的字典。

答案

1. 问题理解：这个问题要求我们遍历列表，找出所有相邻且相同的元素对，并统计每个元素的对数。
2. 解决思路：使用一个字典来记录每个元素出现的对数是一个有效的解决方案，我们可以使用一个字典来记录每个元素的对数。在遍历列表时，如果当前元素和前一个元素相同，就增加这个元素在字典中的计数。
3. 代码实现：正确编写代码，展示编码能力和细节处理能力。

如何对列表中的元素去重

面试题目

• 级别: L1
• 知识模块: Python 编程语言

题目描述

• 如何对列表中的元素去重？
• 如果使用集合自己如何处理？
• 如果使用字典的方式如何处理

公司

• 美团外包

招聘类型

社招

题目解析

题目主要考察对字典，集合以及唯一性的理解

1. 列表中的元素都是不可变类型数据, 可以使用将列表转换成集合的方式实现去重。
2. 也可以使用字典，将列表中的元素做为字典中的 key 实现去重，因为 key 具有唯一性。
3. 如果列表中的数据是可变数据数据，需要通过遍历方式，根据数据的某一特性进行去重

答案

1. 转集合方法

data = [1,1,2,2,2,3,3,"a","a",(1,1),(1,1)]
new_list = list(set(data))
print(new_list)

1. 字典方法

data = [1,1,2,2,2,3,3,"a","a",(1,1),(1,1)]
new_list = list(dict.fromkeys(data))
print(new_list)
# dict.fromkeys() 是一个用于创建新字典的静态方法，该字典的键来自一个可迭代对象，由于字典key值唯一的特性
# 旧列表相同的key值只会出现一次
# list()再将这个字典转换回列表

1. 遍历配合字典方式

data = [1,1,2,2,2,3,3,"a","a",(1,1),(1,1)]
new_data = {}
for k in data:
    new_data[k] = k
new_list = list(new_data.keys())
print(new_list)

python中列表删除元素有哪几种方法

面试题目

• 级别: L1
• 知识模块: Python 编程语言

python 中列表删除元素有哪几种方法

公司

• 小米外包

招聘类型

社招

题目解析

在 Python 中，列表是一种常用的数据结构，支持多种操作，包括删除元素。删除元素的方法有很多，具体选择哪种方法取决于实际需求和场景。常见的方法包括使用 remove()、pop()、del 语句以及列表推导式等。

在 Python 中，有多种方法可以删除列表中的元素，每种方法有不同的适用场景：

1. remove() 方法

   • 用途: 根据值删除元素。
   • 特点: 只删除第一次出现的指定值。如果该值不在列表中，会引发 ValueError。

示例：

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

1. pop() 方法

   • 用途: 根据索引删除元素，并返回该元素。
   • 特点: 如果不指定索引，默认删除并返回最后一个元素。如果指定的索引超出范围，会引发 IndexError。

示例:

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

1. del 语句

   • 用途: 根据索引删除元素，或者删除列表的一个切片。
   • 特点: 可以删除列表中的一个或多个元素，甚至可以删除整个列表。

示例:

my_list = [1, 2, 3, 4, 5]
del my_list[1]
print(my_list)  # 输出：[1, 3, 4, 5]

del my_list[1:3]
print(my_list)  # 输出：[1, 5]

1. 列表推导式

   • 用途: 根据条件删除多个元素，生成新的列表。
   • 特点: 不会修改原列表，而是生成一个新的列表。

示例:

my_list = [1, 2, 3, 4, 5]
my_list = [x for x in my_list if x != 3]
print(my_list)  # 输出：[1, 2, 4, 5]

1. clear() 方法

   • 用途: 清空列表中的所有元素。
   • 特点: 不删除列表对象，但列表变为空。

示例:

my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)  # 输出：[]

答案

在 Python 中，列表是一种常用的数据结构，支持多种操作，包括删除元素。删除元素的方法有很多，具体选择哪种方法取决于实际需求和场景。常见的方法包括使用 remove()、pop()、del 语句以及列表推导式等。

交换两个变量的值

面试题目

• 级别: L1
• 知识模块: Python 编程语言

如何不使用中间变量，交换两个变量的值

公司

• 小米外包

招聘类型

社招

题目解析

此题目是对语言的特性和运算符掌握程度的考察，解决方式有多种。

答案

组包解包法（重点掌握）

利用 Python 的组包解包特性，多变量同时赋值时，等号右侧的值会依次赋值给等号左边的变量。

此方法可适用于任何数据类型的变量交换。

a = 5
b = 10

a, b = b, a

加减法

1. 利用数字进行加减运算实现两个变量的数据交换。

2. 只适合数字类型值的交换。

a = 5
b = 10

a = a + b
b = a - b
a = a - b

列表原地删除重复出现的元素

面试题目

• 级别: L1
• 知识模块: Python 编程语言

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

公司

• 字节外包

招聘类型

• 社招

题目解析

这道题目要求我们在一个排序数组中原地删除重复的元素，使得每个元素只出现一次，并返回移除后数组的新长度。因为需要在原地操作，不能使用额外的数组空间，我们可以利用双指针方法来解决这个问题。

一个指针（slow）用于记录处理后的数组的最后一个唯一元素的位置，另一个指针（fast）用于遍历数组。当我们遇到与当前唯一元素不相同的元素时，就将其移动到慢指针的下一个位置。

def remove_duplicates(nums):
    if not nums:
        return 0

    slow = 0
    for fast in range(1, len(nums)):
        if nums[fast] != nums[slow]:
            slow += 1
            nums[slow] = nums[fast]

    return slow + 1

# 示例使用
nums = [1, 1, 2, 2, 3, 4, 4, 5]
new_length = remove_duplicates(nums)
print(f"新的长度: {new_length}")  # 输出: 新的长度: 5
print(f"处理后的数组: {nums[:new_length]}")  # 输出: 处理后的数组: [1, 2, 3, 4, 5]

代码解释

1. 初始检查：首先检查输入的数组是否为空，如果为空则返回 0。
2. 双指针初始化：初始化慢指针 slow 为 0，遍历指针 fast 从 1 开始。
3. 遍历数组：使用 fast 遍历数组，当 nums[fast] 与 nums[slow] 不相同时，说明遇到了一个新的唯一元素。
4. 更新数组：将新的唯一元素赋值到 slow + 1 位置，并移动慢指针。
5. 返回新长度：最终返回 slow + 1 作为移除重复元素后的新长度。

答案

1. 问题理解：这道题目要求我们在一个排序数组中原地删除重复的元素，使得每个元素只出现一次，并返回移除后数组的新长度。因为需要在原地操作，不能使用额外的数组空间，我们可以利用双指针方法来解决这个问题。
2. 解决思路：一个指针（slow）用于记录处理后的数组的最后一个唯一元素的位置，另一个指针（fast）用于遍历数组。当我们遇到与当前唯一元素不相同的元素时，就将其移动到慢指针的下一个位置。
3. 代码实现：正确编写代码，展示编码能力和细节处理能力。

找出最长的不重复的字符串

面试题目

• 级别: L1
• 知识模块: Python 编程语言

找出最长的不重复的字符串：比如 asdddfaceddfdf，返回 faced

公司

• 字节外包

招聘类型

• 社招

题目解析

此题目要求找出字符串中最长的不包含重复字符的子串。解决这个问题的高效方法是使用滑动窗口技术，这种方法能在线性时间内解决问题。

答案

为了解决这个问题，我们可以使用滑动窗口技术。滑动窗口是一种用于子数组或子字符串问题的算法，可以在一次遍历中解决问题。具体步骤如下：

1. 使用两个指针（或索引）表示窗口的起始位置和结束位置。
2. 使用一个集合来记录窗口内的字符。
3. 移动右指针来扩展窗口，并将字符添加到集合中。
4. 如果遇到重复字符，则移动左指针来缩小窗口，直到窗口内没有重复字符为止。
5. 在每次扩展窗口时，记录当前窗口的长度，并更新最长不重复子串的长度和起始位置。

def longest_unique_substring(s):
    char_set = set()
    left = 0
    max_length = 0
    start = 0  # 记录最长不重复子串的起始位置

    for right in range(len(s)):
        # 如果当前字符在集合中，说明遇到了重复字符
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1
        # 将当前字符加入集合
        char_set.add(s[right])
        # 更新最大长度和起始位置
        if right - left + 1 > max_length:
            max_length = right - left + 1
            start = left

    return s[start:start + max_length]

# 示例
input_str = "asdddfaceddfdf"
result = longest_unique_substring(input_str)
print(result)  # 输出：faced

解释：

1. 使用一个集合 char_set 来记录当前窗口内的字符。
2. 用 left 指针表示窗口的起始位置，right 指针遍历字符串。
3. 如果当前字符 s[right] 在 char_set 中，说明有重复字符，此时移动 left 指针，直到没有重复字符为止。
4. 在每次扩展窗口时，更新最长不重复子串的长度 max_length 和起始位置 start。
5. 最后返回最长不重复子串。

整型数组的最大连续子数组累加和

面试题目

• 级别: L1
• 知识模块: Python 编程语言

给定一个整型数组，求其连续子数组中所有元素的累加和最大值。

公司

• 字节外包

招聘类型

• 社招

题目解析

这个问题通常被称为“最大子数组和问题”（Maximum Subarray Sum），可以使用 Kadane’s Algorithm 来解决。

答案

解决这个问题的最优算法是 Kadane’s Algorithm。该算法通过一次遍历数组，动态地计算当前子数组的和，并在每一步更新最大和。具体步骤如下：

1. 初始化两个变量：max_current 表示当前子数组的最大和，max_global 表示全局最大和。
2. 遍历数组，对于每个元素，计算包含该元素的当前子数组的和。如果当前子数组的和小于该元素，则重新开始计算子数组。
3. 在每一步更新全局最大和。

代码实现如下：

def max_subarray_sum(nums):
    # 初始化当前最大和和全局最大和
    max_current = max_global = nums[0]

    for num in nums[1:]:
        # 计算当前子数组的最大和
        max_current = max(num, max_current + num)
        # 更新全局最大和
        if max_current > max_global:
            max_global = max_current

    return max_global

# 示例
input_array = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
result = max_subarray_sum(input_array)
print(result)  # 输出：6，对应的子数组为 [4, -1, 2, 1]

解释：

1. 初始化 max_current 和 max_global 为数组的第一个元素。
2. 遍历数组的剩余元素，对于每个元素，更新 max_current 为当前元素和前一个 max_current 之和的最大值。
3. 如果 max_current 大于 max_global，则更新 max_global。
4. 最终，max_global 即为最大子数组和。

算法：写一个数组排序

面试题目

• 级别: L1
• 知识模块: Python 编程语言

算法：写一个数组排序

公司

• 快手

招聘类型

社招

题目解析

使用常见的排序算法如快速排序、冒泡排序、插入排序等对数组进行排序。

答案

可以用 Python 编写快速排序算法来对数组进行排序，也可以使用内置的 sorted()函数来排序

Python 编写快速排序示例：

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

# 使用示例
numbers = [3, 6, 8, 10, 1, 2, 1]
print(quicksort(numbers))  # 输出: [1, 1, 2, 3, 6, 8, 10]

使用内置的 sorted()函数示例：

# 使用示例
numbers = [3, 6, 8, 10, 1, 2, 1]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 6, 8, 10]

形参和实参

面试题目

• 级别: L1
• 知识模块: Python 编程语言

形参和实参

公司

• 小米外包

招聘类型

社招

题目解析

形参（Formal Parameters）：

1. 形参是在函数定义时声明的变量。
2. 形参在函数体内被使用，等待实参传递进来。
3. 形参在函数定义的括号内列出，并且在函数调用之前没有实际的值。

def add(a, b):  # 这里的 a 和 b 是形参
    return a + b

实参（Actual Parameters）：

1. 实参是在函数调用时传递给函数的实际值。
2. 实参赋值给对应的形参，在函数体内使用。
3. 实参可以是任何表达式，包括变量、字面值、甚至是另一个函数的返回值。

result = add(2, 3)  # 这里的 2 和 3 是实参
print(result)  # 输出结果为 5

形参和实参的匹配：在函数调用时，Python 会将实参按照位置或关键字传递给形参。

def greet(name, message):
    print(f"Hello, {name}! {message}")

greet("Alice", "Good morning!")  # 输出：Hello, Alice! Good morning!

位置参数：按照顺序将实参传递给形参。

def greet(name, message):
    print(f"Hello, {name}! {message}")

greet("Alice", "Good morning!")  # 输出：Hello, Alice! Good morning!

关键字参数：使用参数名进行传递，顺序可以不一致。

greet(message="Good evening!", name="Bob")  # 输出：Hello, Bob! Good evening!

默认参数值：在函数定义时，可以为形参设置默认值，如果调用时没有提供对应的实参，形参将使用默认值。

def greet(name, message="Hello!"):
    print(f"{message}, {name}")

greet("Charlie")  # 输出：Hello!, Charlie
greet("Dave", "Hi")  # 输出：Hi, Dave

可变数量的参数：Python 允许函数接受可变数量的参数，使用 *args 和 **kwargs。

• *args 用于接收多个位置参数，作为一个元组传递。

def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3, 4))  # 输出：10

• **kwargs 用于接收多个关键字参数，作为一个字典传递。

def print_details(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_details(name="Eve", age=25, city="New York")
# 输出：
# name: Eve
# age: 25
# city: New York

答案

实参全称实际参数，是在调用函数时传入的数据，实参可以是变量，可以是数值，可以是一切可被赋值的数据。

形参全称形式参数，是在函数定义时圆括号中定义的变量，形参用来接收在函数调用时传入的对应的实参数据，当没有产生函数调用时，形参不代表任何值

可变参数的区别

面试题目

• 级别: L1
• 知识模块: Python 编程语言

* 和 ** 的区别。

公司

• 字节外包

招聘类型

• 社招

题目解析

在Python中，* 和 ** 都是用于处理函数参数的特殊符号。它们在函数定义和调用中有不同的作用。

• *：用于定义接收可变数量的位置参数，也可以用于函数调用时将列表或元组拆开。
• **：用于定义接收可变数量的关键字参数，也可以用于函数调用时将字典拆开。

这两个符号的主要区别在于它们处理参数的方式和类型：* 处理位置参数，** 处理关键字参数。

详解：

1. *（星号）

定义位置参数：在函数定义中使用 * 可以接收不定数量的位置参数。这些参数会以元组的形式传递给函数。

def func(*args):
    for arg in args:
        print(arg)

在上面的示例中，*args可以接受任意数量的位置参数，这些参数会被收集到一个元组中。

调用时拆解：在函数调用时，*可以用来解包列表或元组，将它们的元素作为位置参数传递给函数。

def func(a, b, c):
    print(a, b, c)

args = (1, 2, 3)
func(*args)  # 输出: 1 2 3

1. **（双星号）

定义关键字参数：在函数定义中使用**可以接收不定数量的关键字参数，这些参数会以字典的形式传递给函数。

def func(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

在上面的示例中，**kwargs可以接受任意数量的关键字参数，这些参数会被收集到一个字典中。

调用时拆解：在函数调用时，** 可以用来解包字典，将它们的键值对作为关键字参数传递给函数。

def func(a, b, c):
    print(a, b, c)

kwargs = {'a': 1, 'b': 2, 'c': 3}
func(**kwargs)  # 输出: 1 2 3

答案

在Python里， * 和 ** 用来处理参数。 * 用来接收不定数量的位置参数，也就是你可以传入多个值，它们会被收集到一个元组里。比如，你可以传入任意数量的值，函数会把它们当作一个整体来处理。

** 用来接收不定数量的关键字参数，也就是你可以传入多个键值对，函数会把这些键值对收集到一个字典里。这样你就可以在函数里根据键来访问对应的值。

简单来说， * 处理位置参数， ** 处理关键字参数。

什么是可变参数

面试题目

• 级别: L2
• 知识模块: Python 编程语言

什么是可变参数？

公司

• 字节外包

招聘类型

• 社招

题目解析

可变参数是指在函数定义中允许接收可变数量的参数。在 Python 中，这主要有两种实现方式：

1. *args: 当你在函数定义中使用 *args 时，它会收集所有位置参数（非关键字参数），并将它们存储在一个元组中。这使得函数能够处理不同数量的位置参数。

def example_function(*args):
    for arg in args:
        print(arg)

example_function(1, 2, 3)
# 输出:
# 1
# 2
# 3

在上面的代码中，*args 使得 example_function 可以接受任意数量的位置参数，并将它们打印出来。

1. **kwargs: 当你在函数定义中使用 **kwargs 时，它会收集所有的关键字参数（即以 key=value 形式传入的参数），并将它们存储在一个字典中。这使得函数能够处理不同数量的关键字参数。

def example_function(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

example_function(name="Alice", age=30)
# 输出:
# name: Alice
# age: 30

在这个例子中，**kwargs 使得 example_function 可以接受任意数量的关键字参数，并将它们以键值对的形式打印出来。

答案

1. *args: 用于接收位置参数的可变数量。*args 让你能够传递任意数量的位置参数给函数，这些参数会被收集到一个元组中。
2. **kwargs: 用于接收关键字参数的可变数量。**kwargs 允许你传递任意数量的关键字参数，这些参数会被收集到一个字典中。

什么是装饰器

面试题目

• 级别: L2
• 知识模块: Python 编程语言

什么是装饰器？

公司

• 字节外包

招聘类型

• 社招

题目解析

装饰器是一种设计模式，用于修改或扩展函数或方法的行为，而无序修改其实际代码。装饰器通常以函数的形式存在，接收一个函数作为参数，并返回一个新的函数。装饰器在 Python 中提供了一种简洁的方式来添加额外的功能，例如日志记录、权限检查、计时等。

装饰器的工作原理是通过将一个函数包装在另一个函数中来实现功能的扩展。Python 提供了一个便捷的语法来应用装饰器，这就是 @ 符号。

装饰器的基本示例：

def decorator_function(original_function):
    def wrapper_function():
        print("Wrapper executed this before {}".format(original_function.__name__))
        return original_function()
    return wrapper_function

@decorator_function
def display():
    return "Display function executed."

print(display())
# 输出:
# Wrapper executed this before display
# Display function executed.

在这个示例中，decorator_function 是一个装饰器，它接受一个函数 original_function 作为参数，并返回一个新的函数 wrapper_function。wrapper_function 在调用 original_function 之前执行了一些额外的操作。通过使用 @decorator_function 语法，我们将 display 函数装饰起来，添加了装饰器中的行为。

答案

在 Python 中，装饰器是一种用于扩展或修改函数或方法行为的工具。装饰器本质上是一个接受函数作为参数并返回一个新函数的函数。通过这种方式，装饰器可以在不改变原函数代码的情况下，添加额外的功能或修改其行为。