*args和**kwargs：
*args接收可变数量的位置参数（元组）
**kwargs接收可变数量的关键字参数（字典）
grep查找a.txt文件中某字符，并打印该字符的位置.-n显示行号，-o仅输出匹配字符，-b显示字节偏移量
grep -nob '目标字符' a.txt
is和==的区别：
==
比较值是否相等；is比较内存地址（是否为同一对象）。
例：a = [1]，b = [1]，则a == b为True，a is b为False
None和空字符串""、空列表[]的区别？
| 特性 | None | ""（空字符串） | []（空列表） |
| ---- | --------- | -------- | ------- |
| 类型 | NoneType | str | list |
| 用途 | 标记未定义或缺失值 | 文本处理 | 动态集合 |
| 比较 | 必须用is | 可用== | 可用== |
| 方法 | 无方法 | 支持字符串方法 | 支持列表方法 |
几种内置的数据类型
str、int、float、bool、list、dict、tuple
Python2与Python3中range()函数的区别（如返回类型、内存占用）
python2 返回list
python3 返回生成器
Python中的数据结构(队列、堆栈、hashmap之类的)
1. 队列（Queue）
队列是一种先进先出（FIFO）的数据结构。Python中可以使用queue模块中的Queue类来实现队列。
使用queue.Queue
import queue
q = queue.Queue()
q.put('item1')
q.put('item2')
print(q.get()) # 输出: item1
print(q.get()) # 输出: item2
2. 堆栈（Stack）
堆栈是一种后进先出（LIFO）的数据结构。Python中可以使用列表（list）来实现堆栈，通过列表的append()和pop()方法。
使用列表实现堆栈
stack = []
stack.append('item1')
stack.append('item2')
print(stack.pop()) # 输出: item2
print(stack.pop()) # 输出: item1
3. 哈希映射（HashMap/Dictionary）
哈希映射是一种存储键值对的数据结构，其中每个键映射到一个值。在Python中，字典（dict）是实现哈希映射的标准方式。
使用字典
d = {'key1': 'value1', 'key2': 'value2'}
d['key3'] = 'value3'
print(d['key1']) # 输出: value1
print('key2' in d) # 输出: True
del d['key2']
print(d) # 输出: {'key1': 'value1', 'key3': 'value3'}
4. 优先队列（Heap）
优先队列是一种特殊的队列，其中每个元素都有优先级，元素按照优先级进行排序。Python中可以使用heapq模块来实现堆（heap）。
使用heapq实现优先队列
import heapq
heap = []
heapq.heappush(heap, (5, 'write code'))
heapq.heappush(heap, (1, 'sleep'))
heapq.heappush(heap, (4, 'eat'))
print(heapq.heappop(heap)) # 输出: (1, 'sleep')
5. 双端队列（Deque）
双端队列是一种允许从两端添加或删除元素的队列。Python中可以使用collections模块中的deque类来实现双端队列。
使用collections.deque
from collections import deque
d = deque(['item1', 'item2', 'item3'])
d.append('item4') # 在右侧添加元素
d.appendleft('item0') # 在左侧添加元素
print(d.pop()) # 输出: item4，从右侧弹出元素
print(d.popleft()) # 输出: item0，从左侧弹出元素
字典合并
# 方法1：update() 原地修改
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2) # dict1变为 {'a':1, 'b':3, 'c':4}
# 方法2：解包操作符（Python 3.5+）
merged = {**dict1, **dict2} # 新建字典 {'a':1, 'b':3, 'c':4}
# 方法3：collections.ChainMap（逻辑合并）
from collections import ChainMap
chained = ChainMap(dict1, dict2) # 不创建新字典
# 方法4：Python 3.9+ 合并运算符
merged = dict1 | dict2 # 新建字典 {'a':1, 'b':3, 'c':4}
列表去重
# 方法1：使用set() - 最简单但无序
original_list = [3, 5, 2, 3, 8, 5]
unique_list = list(set(original_list))
# 方法2：保持原始顺序（Python 3.7+）
unique_ordered = list(dict.fromkeys(original_list))
简述面向对象中__new__和__init__区别
__new__:
负责创建对象。
返回一个新对象的实例。
是一个静态方法。
__init__:
负责初始化对象的属性。
不返回新对象，只返回 None。
是一个实例方法。
collections模块中的defaultdict、OrderedDict、deque有什么用？
1. defaultdict（默认字典）
用途：自动处理字典中不存在的键，避免KeyError异常
核心功能：
初始化时需指定默认值工厂（如int、list、set或自定义函数
访问缺失键时自动生成默认值（如int对应0，list对应空列表[]）
典型场景：
统计词频时无需手动初始化计数器
分组数据（如按类别存储多个条目）
2. OrderedDict（有序字典）
用途：保留键值对的插入顺序，适用于需要顺序一致性的场景
核心功能：
元素遍历顺序与插入顺序一致
支持move_to_end()方法调整键的位置
典型场景：
缓存淘汰策略（如LRU缓存
需要顺序记录的配置或日志处理
3. deque（双端队列）
用途：高效的两端插入/删除操作，适用于队列和栈结构
核心功能：
支持appendleft()、popleft()等操作，时间复杂度为O(1)
线程安全，适合多线程任务
典型场景：
广度优先搜索（BFS）算法
实时数据流处理（如滑动窗口）
list.sort()和sorted()的区别？
| 特性 | list.sort() | sorted() |
| --------- | ----------- | ------------------- |
| 作用对象 | 仅限列表（原地修改） | 任何可迭代对象（字符串、元组、字典等） |
| 返回值 | 无（直接修改原列表） | 返回新排序后的列表 |
| 原数据是否改变 | 是 | 否 |
| 方法类型 | 列表的成员方法 | 内置函数 |
列表的append()和extend()的区别？
方法 参数类型 结果行为 示例
append() 任意类型（单个元素） 将参数作为单个元素追加 [1, 2].append([3]) → [1, 2, [3]]
extend() 可迭代对象（如列表） 将参数展开合并到原列表 [1, 2].extend([3]) → [1, 2, 3]
如何遍历字典的键值对？d.items()
for key, value in d.items():
print(key, value) # 直接获取键值对
Python面向对象编程中常用的内置方法（魔法方法）
对象生命周期控制
__new__(cls)：类实例化时首先调用的方法，负责创建并返回实例对象，常用于单例模式等场景
__init__(self)：初始化方法，在__new__之后自动调用，用于设置对象初始属性
__del__(self)：对象销毁时触发，用于资源清理操作
对象表示与转换
__str__(self)：定义print(obj)或str(obj)时的输出内容
__repr__(self)：返回对象的官方字符串表示，通常用于调试
__format__(self)：控制format()函数的格式化输出
比较运算相关
__eq__(self, other)：定义==运算符行为
__lt__(self, other)
__gt__(self, other)：定义<和>比较
__le__(self, other)
__ge__(self, other)：定义<=和>=比较
容器类型模拟
__len__(self)：定义len()函数的返回值
__getitem__(self, key)：实现下标访问（如obj[key]）
__setitem__(self, key, value)：实现下标访问（如obj[key]）
__iter__(self)：使对象可迭代
__next__(self)：使对象可迭代
属性访问控制
__getattr__(self, name)：访问不存在的属性时触发
__setattr__(self, name, value)：设置属性时触发
__getattribute__(self, name)：访问任何属性时都会触发
其他重要方法
__call__(self)：使实例可像函数一样调用（如obj()）
__enter__(self) ：实现上下文管理器协议（with语句）
__exit__(self)：实现上下文管理器协议（with语句）
__hash__(self)：定义hash()函数的返回值
列表、字典、集合常用方法
列表
1 list.append(obj) 在列表末尾添加新的对象
2 list.count(obj) 统计某个元素在列表中出现的次数
3 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4 list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj)将对象插入列表
6 list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7 list.remove(obj) 移除列表中某个值的第一个匹配项
8 list.reverse() 反向列表中元素
9 list.sort( key=None, reverse=False) 对原列表进行排序
10 list.clear() 清空列表
11 list.copy() 复制列表
字典
1 dict.clear() 删除字典内所有元素
2 dict.copy() 返回一个字典的浅复制
3 dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4 dict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
5 key in dict 如果键在字典dict里返回true，否则返回false
6 dict.items() 以列表返回一个视图对象
7 dict.keys() 返回一个视图对象
8 dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 dict.update(dict2) 把字典dict2的键/值对更新到dict里
10 dict.values() 返回一个视图对象
11 dict.pop(key[,default]) 删除字典 key（键）所对应的值，返回被删除的值。
12 dict.popitem() 返回并删除字典中的最后一对键和值。
集合
| add() | 为集合添加元素
| ----------------------------- | -----------------------------------------------
| clear() | 移除集合中的所有元素
| copy() | 拷贝一个集合
| difference() | 返回多个集合的差集
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。
| discard() | 删除集合中指定的元素
| intersection() | 返回集合的交集
| intersection_update() | 返回集合的交集。
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
| issubset() | 判断指定集合是否为该方法参数集合的子集。
| issuperset() | 判断该方法的参数集合是否为指定集合的子集
| pop() | 随机移除元素
| remove() | 移除指定元素
| symmetric_difference() | 返回两个集合中不重复的元素集合。
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
| union() | 返回两个集合的并集
| update() | 给集合添加元素
| len() | 计算集合元素个数
浙公网安备 33010602011771号