位运算： 计算56及-18的所有位运算符结果，并使在注释中体现计算过程
python
# 定义两个操作数
a = 56
b = -18
# -------------------------- 1. 按位与（&）：对应位都为1时结果为1，否则为0 --------------------------
# 56的32位二进制：00000000 00000000 00000000 00111000
# -18的32位补码：11111111 11111111 11111111 11101110
# 按位与计算：
# 00000000 00000000 00000000 00111000
# & 11111111 11111111 11111111 11101110
# = 00000000 00000000 00000000 00101000 （对应十进制40）
bit_and = a & b
print(f"56 & -18 = {bit_and}")
# -------------------------- 2. 按位或（|）：对应位有一个为1时结果为1，否则为0 --------------------------
# 56的32位二进制：00000000 00000000 00000000 00111000
# -18的32位补码：11111111 11111111 11111111 11101110
# 按位或计算：
# 00000000 00000000 00000000 00111000
# | 11111111 11111111 11111111 11101110
# = 11111111 11111111 11111111 11111110 （对应十进制-2）
bit_or = a | b
print(f"56 | -18 = {bit_or}")
# -------------------------- 3. 按位异或（^）：对应位不同时结果为1，相同时为0 --------------------------
# 56的32位二进制：00000000 00000000 00000000 00111000
# -18的32位补码：11111111 11111111 11111111 11101110
# 按位异或计算：
# 00000000 00000000 00000000 00111000
# ^ 11111111 11111111 11111111 11101110
# = 11111111 11111111 11111111 11010110 （对应十进制-42）
bit_xor = a ^ b
print(f"56 ^ -18 = {bit_xor}")
# -------------------------- 4. 按位取反（~）：对每一位取反（0变1，1变0） --------------------------
# 注意：Python中~x = -(x+1)，基于无限精度补码
# （1）~56
# 56的二进制：...00000000 00111000
# 按位取反：...11111111 11000111 （对应十进制-57，即 -(56+1)）
bit_not_a = ~a
print(f"~56 = {bit_not_a}")
# （2）~(-18)
# -18的补码：...11111111 11101110
# 按位取反：...00000000 00010001 （对应十进制17，即 -(-18+1) = 17）
bit_not_b = ~b
print(f"~(-18) = {bit_not_b}")
# -------------------------- 5. 左移（<<）：整体左移n位，右侧补0，等价于乘以2^n --------------------------
# （1）56 << 1：左移1位，等价于56*2=112
# 56二进制：00111000 → 左移1位：01110000（十进制112）
left_shift_a1 = a << 1
print(f"56 << 1 = {left_shift_a1}")
# （2）56 << 2：左移2位，等价于56*4=224
left_shift_a2 = a << 2
print(f"56 << 2 = {left_shift_a2}")
# （3）-18 << 1：左移1位，等价于-18*2=-36
# -18补码：...11101110 → 左移1位：...11011100（十进制-36）
left_shift_b1 = b << 1
print(f"-18 << 1 = {left_shift_b1}")
# （4）-18 << 2：左移2位，等价于-18*4=-72
left_shift_b2 = b << 2
print(f"-18 << 2 = {left_shift_b2}")
# -------------------------- 6. 右移（>>）：正数左补0，负数左补1，等价于整除2^n --------------------------
# （1）56 >> 1：右移1位，等价于56//2=28
# 56二进制：00111000 → 右移1位：00011100（十进制28）
right_shift_a1 = a >> 1
print(f"56 >> 1 = {right_shift_a1}")
# （2）56 >> 2：右移2位，等价于56//4=14
right_shift_a2 = a >> 2
print(f"56 >> 2 = {right_shift_a2}")
# （3）-18 >> 1：右移1位，等价于-18//2=-9（负数右移补1，结果向下取整）
# -18补码：...11101110 → 右移1位：...11110111（十进制-9）
right_shift_b1 = b >> 1
print(f"-18 >> 1 = {right_shift_b1}")
# （4）-18 >> 2：右移2位，等价于-18//4=-5（-18/4=-4.5，向下取整为-5）
right_shift_b2 = b >> 2
print(f"-18 >> 2 = {right_shift_b2}")完成文件读取功能，任意读取某个文件内容时，请编写装饰器，实现写出文件时增加当前系统时间，并打印至控制台最后一行
python
import datetime
def add_datetime_to_file(func):
def wrapper(file_path, write_path="output_with_time.txt"):
original_content = func(file_path)
current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
new_content = f"{original_content}\n\n===== 当前系统时间：{current_time} ====="
try:
with open(write_path, "w+", encoding="utf-8") as f:
f.write(new_content)
print(f"带时间的内容已成功写入：{write_path}")
except Exception as e:
print(f"写入文件失败：{e}")
return original_content
print(f"\n控制台打印：当前系统时间 -> {current_time}")
return new_content
return wrapper
@add_datetime_to_file
def read_file_content(file_path):
with open(file_path, "r", encoding="utf-8") as f:
content = f.read()
print(f"成功读取原始文件：{file_path}")
return content
read_file_content("../test.txt")给定一个包含n+1个整数的数组nums，其数字在1到n之间(包含1和n),可知至少存在一个重复的整数 假设只有一个重复的整数，请找出这个重复的数
python
def find_duplicate_binary(nums):
left = 1
right = len(nums) - 1 # 数组长度n+1，元素范围1~n
while left < right:
mid = (left + right) // 2 # 中间值（不是数组索引，是元素值）
count = 0
# 统计数组中<=mid的元素个数
for num in nums:
if num <= mid:
count += 1
# 判断重复数所在区间
if count > mid:
right = mid # 重复数在左半区间
else:
left = mid + 1 # 重复数在右半区间
return left # left==right时，即为重复数
# 测试示例
nums1 = [1,3,4,2,2]
nums2 = [3,1,3,4,2]
print(f"二分查找法找重复数（nums1）：{find_duplicate_binary(nums1)}")
print(f"二分查找法找重复数（nums2）：{find_duplicate_binary(nums2)}")完成登录系统，登录时数据使用序列化和反序列化.
python
import pickle
import os
# 定义用户数据文件路径
USER_DATA_FILE = "users.data"
# 定义用户类（存储用户名和密码）
class User:
def __init__(self, username, password):
self.username = username
self.password = password
def __str__(self):
return f"用户：{self.username}"
# -------------------------- 序列化/反序列化工具函数 --------------------------
def save_users(users):
"""将用户字典序列化并写入文件"""
try:
with open(USER_DATA_FILE, "wb") as f: # 二进制模式写入（pickle要求）
pickle.dump(users, f)
print("用户数据已保存！")
except Exception as e:
print(f"保存用户数据失败：{e}")
def load_users():
"""从文件中反序列化读取用户字典"""
# 如果文件不存在，返回空字典
if not os.path.exists(USER_DATA_FILE):
return {}
try:
with open(USER_DATA_FILE, "rb") as f: # 二进制模式读取（pickle要求）
users = pickle.load(f)
print("用户数据已加载！")
return users
except Exception as e:
print(f"加载用户数据失败：{e}")
return {}
# -------------------------- 登录/注册功能 --------------------------
def register():
"""用户注册功能"""
# 加载已有用户数据
users = load_users()
# 获取注册信息
username = input("请输入注册用户名：").strip()
# 判断用户名是否已存在
if username in users:
print(f"错误：用户名「{username}」已存在！")
return
password1 = input("请输入注册密码：").strip()
password2 = input("请再次输入密码：").strip()
# 验证两次密码是否一致
if password1 != password2:
print("错误：两次输入的密码不一致！")
return
# 创建新用户对象
new_user = User(username, password1)
# 添加到用户字典（key=用户名，value=用户对象）
users[username] = new_user
# 序列化保存到文件
save_users(users)
print(f"恭喜！用户「{username}」注册成功！")
def login():
"""用户登录功能"""
# 加载已有用户数据
users = load_users()
if not users:
print("暂无注册用户，请先注册！")
return
# 获取登录信息
username = input("请输入用户名：").strip()
password = input("请输入密码：").strip()
# 验证用户名是否存在
if username not in users:
print(f"错误：用户名「{username}」不存在！")
return
# 验证密码是否正确
user = users[username]
if user.password == password:
print(f"登录成功！欢迎你，{user.username}！")
else:
print("错误：密码输入错误！")
# -------------------------- 主程序入口 --------------------------
def main():
while True:
# 打印菜单
print("\n===== 登录系统 =====")
print("1. 用户注册")
print("2. 用户登录")
print("3. 退出系统")
choice = input("请选择功能（1/2/3）：").strip()
# 处理用户选择
if choice == "1":
register()
elif choice == "2":
login()
elif choice == "3":
print("感谢使用，再见！")
break
else:
print("无效选择，请输入1/2/3！")
if __name__ == "__main__":
main()