# 基本示例
a = 10  # 二進制: 1010
b = 4   # 二進制: 0100
print(f"a = {a} (二進制: {bin(a)})")
print(f"b =  (二進制: {bin(b)})")
# 1. 按位與 (&) - 兩個位都為1時，結果才為1
print(f"a & b = {a & b} (二進制: {bin(a & b)})")  # 1010 & 0100 = 0000 (0)
# 2. 按位或 (|) - 兩個位有一個為1時，結果就為1
print(f"a | b = {a | b} (二進制: {bin(a | b)})")  # 1010 | 0100 = 1110 (14)
# 3. 按位異或 (^) - 兩個位不同時，結果為1
print(f"a ^ b = {a ^ b} (二進制: {bin(a ^ b)})")  # 1010 ^ 0100 = 1110 (14)
# 4. 按位取反 (~) - 每個位取反
print(f"~a = {~a} (二進制: {bin(~a & 0b1111)})")  # ~1010 = 0101 (5) 但需要注意Python的補碼表示
# 5. 左移 (<<) - 所有位向左移動，右側補0
print(f"a << 2 = {a << 2} (二進制: {bin(a << 2)})")  # 1010 << 2 = 101000 (40)
# 6. 右移 (>>) - 所有位向右移動，左側補0（對正整數(shù)）
print(f"a >> 1 = {a >> 1} (二進制: {bin(a >> 1)})")  # 1010 >> 1 = 0101 (5)

# 1. 檢查奇偶性
def is_even(n):
    return (n & 1) == 0
print(f"5是偶數(shù)嗎？{is_even(5)}")  # False
print(f"8是偶數(shù)嗎？{is_even(8)}")  # True
# 2. 檢查是否是2的冪
def is_power_of_two(n):
    return n > 0 and (n & (n - 1)) == 0
print(f"8是2的冪嗎？{is_power_of_two(8)}")  # True
print(f"10是2的冪嗎？{is_power_of_two(10)}")  # False
# 3. 交換兩個數(shù)的值（不使用臨時變量）
x, y = 5, 9
print(f"交換前: x={x}, y={y}")
x ^= y
y ^= x
x ^= y
print(f"交換后: x={x}, y={y}")
# 4. 獲取最低位的1
def get_lowest_set_bit(n):
    return n & -n
print(f"12的最低位的1: {get_lowest_set_bit(12)} (二進制: {bin(get_lowest_set_bit(12))})")
# 5. 移除最低位的1
def clear_lowest_set_bit(n):
    return n & (n - 1)
print(f"移除12的最低位的1: {clear_lowest_set_bit(12)} (二進制: {bin(clear_lowest_set_bit(12))})")
# 6. 統(tǒng)計二進制中1的個數(shù)
def count_set_bits(n):
    count = 0
    while n:
        n &= (n - 1)  # 每次移除最低位的1
        count += 1
    return count
print(f"12的二進制中1的個數(shù): {count_set_bits(12)}")
# Python內置方法
print(f"Python內置方法統(tǒng)計12的二進制中1的個數(shù): {bin(12).count('1')}")

# 使用掩碼操作特定位
# 1. 設置某一位為1
def set_bit(n, pos):
    return n | (1 << pos)
num = 0b1010  # 10
print(f"將第1位設置為1: {bin(set_bit(num, 1))}")  # 0b1010 -> 0b1010 | 0b0010 = 0b1010 (不變)
print(f"將第2位設置為1: {bin(set_bit(num, 2))}")  # 0b1010 -> 0b1010 | 0b0100 = 0b1110 (14)
# 2. 清除某一位（設置為0）
def clear_bit(n, pos):
    return n & ~(1 << pos)
print(f"清除第1位: {bin(clear_bit(num, 1))}")  # 0b1010 & ~0b0010 = 0b1010 & 0b1101 = 0b1000 (8)
# 3. 切換某一位（0變1，1變0）
def toggle_bit(n, pos):
    return n ^ (1 << pos)
print(f"切換第1位: {bin(toggle_bit(num, 1))}")  # 0b1010 ^ 0b0010 = 0b1000 (8)
print(f"切換第2位: {bin(toggle_bit(num, 2))}")  # 0b1010 ^ 0b0100 = 0b1110 (14)
# 4. 檢查某一位是否為1
def check_bit(n, pos):
    return (n & (1 << pos)) != 0
print(f"第1位是1嗎？{check_bit(num, 1)}")  # True (0b1010 & 0b0010 = 0b0010 ≠ 0)
print(f"第2位是1嗎？{check_bit(num, 2)}")  # False (0b1010 & 0b0100 = 0)
# 5. 提取多個位
def extract_bits(n, start, length):
    mask = (1 << length) - 1
    return (n >> start) & mask
num = 0b11011010  # 218
print(f"提取第2-5位: {bin(extract_bits(num, 2, 4))}")  # 0b1101

# 1. 只出現(xiàn)一次的數(shù)字（其他數(shù)字都出現(xiàn)兩次）
def single_number(nums):
    result = 0
    for num in nums:
        result ^= num
    return result
print(f"只出現(xiàn)一次的數(shù)字: {single_number([4, 1, 2, 1, 2])}")  # 4
# 2. 子集生成（使用位掩碼）
def generate_subsets(nums):
    n = len(nums)
    subsets = []
    for mask in range(1 << n):  # 2^n 種可能
        subset = []
        for i in range(n):
            if mask & (1 << i):  # 檢查第i位是否為1
                subset.append(nums[i])
        subsets.append(subset)
    return subsets
nums = [1, 2, 3]
subsets = generate_subsets(nums)
print(f"{nums}的所有子集:")
for subset in subsets:
    print(subset)
# 3. 計算兩個整數(shù)的和（不使用+和-）
def add_without_operator(a, b):
    while b != 0:
        carry = a & b  # 計算進位
        a = a ^ b      # 計算無進位和
        b = carry << 1  # 進位左移
    return a
print(f"5 + 7 = {add_without_operator(5, 7)}")

import time
# 比較乘除2的運算速度
def test_performance():
    n = 10000000
    start = time.time()
    # 使用算術運算
    result1 = 0
    for i in range(n):
        result1 = i * 2
    mid = time.time()
    # 使用位運算
    result2 = 0
    for i in range(n):
        result2 = i << 1
    end = time.time()
    print(f"算術運算時間: {mid - start:.6f}秒")
    print(f"位運算時間: {end - mid:.6f}秒")
    print(f"時間差: {(mid - start) - (end - mid):.6f}秒")
# test_performance()

# 1. Python中整數(shù)的位數(shù)是動態(tài)的，沒有固定位數(shù)限制
large_num = 1 << 1000
print(f"1 << 1000 的位數(shù): {large_num.bit_length()}")
# 2. 處理負數(shù)時需要注意
negative_num = -10
print(f"-10 的二進制表示: {bin(negative_num)}")
print(f"-10 >> 1 = {-10 >> 1} (二進制: {bin(-10 >> 1)})")
# 3. 與0xFF等掩碼配合使用可以限制位數(shù)
value = 300
print(f"300的16位表示: {value & 0xFFFF} (二進制: {bin(value & 0xFFFF)})")

# 1. 空列表
empty_list = []
empty_list2 = list()
# 2. 包含元素的列表
numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'cherry']
mixed = [1, 'hello', 3.14, True]
# 3. 使用 list() 構造函數(shù)
list_from_string = list('hello')  # ['h', 'e', 'l', 'l', 'o']
list_from_range = list(range(5))  # [0, 1, 2, 3, 4]
list_from_tuple = list((1, 2, 3))  # [1, 2, 3]
# 4. 列表推導式
squares = [x**2 for x in range(10)]  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
even_numbers = [x for x in range(20) if x % 2 == 0]  # [0, 2, 4, ..., 18]
print("創(chuàng)建的各種列表:")
print(f"numbers: {numbers}")
print(f"fruits: {fruits}")
print(f"mixed: {mixed}")
print(f"list_from_string: {list_from_string}")
print(f"squares: {squares}")

# 創(chuàng)建示例列表
fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']
# 1. 索引訪問（從0開始）
print(fruits[0])      # apple
print(fruits[2])      # cherry
# 2. 負數(shù)索引（從末尾開始）
print(fruits[-1])     # elderberry
print(fruits[-2])     # date
# 3. 切片訪問 [start:end:step]
print(fruits[1:3])    # ['banana', 'cherry']   # 包含1，不包含3
print(fruits[:3])     # ['apple', 'banana', 'cherry']  # 從頭開始
print(fruits[2:])     # ['cherry', 'date', 'elderberry']  # 到末尾
print(fruits[::2])    # ['apple', 'cherry', 'elderberry']  # 每隔一個
print(fruits[::-1])   # 反轉列表
# 4. 長度
print(len(fruits))    # 5
# 5. 檢查元素是否存在
print('banana' in fruits)    # True
print('grape' in fruits)     # False
# 6. 遍歷列表
print("遍歷列表:")
for fruit in fruits:
    print(fruit)
print("帶索引遍歷:")
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")
print("反向遍歷:")
for fruit in reversed(fruits):
    print(fruit)

fruits = ['apple', 'banana', 'cherry']
# 1. 修改單個元素
fruits[1] = 'blueberry'
print(f"修改后: {fruits}")  # ['apple', 'blueberry', 'cherry']
# 2. 修改多個元素（切片賦值）
fruits[1:3] = ['blackberry', 'cantaloupe']
print(f"切片修改后: {fruits}")  # ['apple', 'blackberry', 'cantaloupe']
# 3. 添加元素
fruits.append('date')          # 末尾添加
print(f"append 后: {fruits}")  # ['apple', 'blackberry', 'cantaloupe', 'date']
fruits.insert(1, 'apricot')    # 在指定位置插入
print(f"insert 后: {fruits}")  # ['apple', 'apricot', 'blackberry', 'cantaloupe', 'date']
# 4. 擴展列表
more_fruits = ['elderberry', 'fig']
fruits.extend(more_fruits)     # 添加多個元素
print(f"extend 后: {fruits}")
# 也可以使用 + 或 +=
fruits += ['grape', 'honeydew']
print(f"+= 后: {fruits}")

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig', 'grape']
# 1. del 語句
del fruits[1]                    # 刪除索引為1的元素
print(f"del 后: {fruits}")      # ['apple', 'cherry', 'date', 'elderberry', 'fig', 'grape']
del fruits[2:4]                  # 刪除切片
print(f"del 切片后: {fruits}")  # ['apple', 'cherry', 'fig', 'grape']
# 2. pop() - 刪除并返回指定位置的元素
popped = fruits.pop()            # 默認刪除最后一個
print(f"pop() 后: {fruits}, 彈出的元素: {popped}")
popped = fruits.pop(1)           # 刪除指定位置
print(f"pop(1) 后: {fruits}, 彈出的元素: {popped}")
# 3. remove() - 刪除第一個匹配的元素
fruits.remove('apple')
print(f"remove('apple') 后: {fruits}")
# 4. clear() - 清空列表
fruits.clear()
print(f"clear() 后: {fruits}")  # []

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
# 1. count() - 統(tǒng)計元素出現(xiàn)次數(shù)
print(f"5出現(xiàn)的次數(shù): {numbers.count(5)}")  # 3
# 2. index() - 查找元素首次出現(xiàn)的索引
print(f"第一個5的索引: {numbers.index(5)}")  # 4
print(f"從索引6開始找5: {numbers.index(5, 6)}")  # 9
# 3. sort() - 原地排序
numbers.sort()
print(f"升序排序: {numbers}")
numbers.sort(reverse=True)
print(f"降序排序: {numbers}")
# 4. sorted() - 返回新排序列表（不改變原列表）
unsorted = [3, 1, 4, 1, 5]
sorted_list = sorted(unsorted)
print(f"原列表: {unsorted}")
print(f"排序后新列表: {sorted_list}")
# 5. reverse() - 原地反轉
numbers.reverse()
print(f"反轉后: {numbers}")
# 6. copy() - 淺拷貝
original = [1, 2, [3, 4]]
copied = original.copy()
original[2][0] = 99
print(f"淺拷貝: 原列表 {original}, 拷貝列表 {copied}")  # 注意嵌套列表被共享
# 7. 深拷貝
import copy
deep_copied = copy.deepcopy(original)
original[2][1] = 100
print(f"深拷貝: 原列表 {original}, 深拷貝列表 {deep_copied}")

# 1. 基本推導式
squares = [x**2 for x in range(10)]
print(f"平方數(shù): {squares}")
# 2. 帶條件的推導式
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(f"偶數(shù)的平方: {even_squares}")
# 3. 嵌套循環(huán)推導式
pairs = [(x, y) for x in range(3) for y in range(3)]
print(f"坐標對: {pairs}")
# 4. 嵌套列表推導式（矩陣轉置）
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = [[row[i] for row in matrix] for i in range(3)]
print(f"矩陣轉置: {transposed}")
# 5. 條件表達式（類似三元表達式）
labels = ['偶數(shù)' if x % 2 == 0 else '奇數(shù)' for x in range(10)]
print(f"奇偶標簽: {labels}")
# 6. 嵌套推導式展平列表
nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flattened = [item for sublist in nested for item in sublist]
print(f"展平嵌套列表: {flattened}")

# 1. 列表拼接
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print(f"列表拼接: {combined}")
# 2. 重復列表
repeated = [1, 2] * 3
print(f"列表重復: {repeated}")
# 3. 解包列表
first, *middle, last = [1, 2, 3, 4, 5]
print(f"first: {first}, middle: {middle}, last: {last}")
# 4. 列表比較（按元素逐個比較）
print([1, 2, 3] < [1, 2, 4])  # True
print([1, 2, 3] < [1, 2])     # False
# 5. 過濾列表
numbers = [1, 2, 3, 4, 5, 6]
filtered = list(filter(lambda x: x % 2 == 0, numbers))
print(f"過濾偶數(shù): {filtered}")
# 6. 映射列表
mapped = list(map(lambda x: x * 2, numbers))
print(f"映射加倍: {mapped}")
# 7. zip多個列表
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")
# 8. 使用any()和all()
print(any(x > 5 for x in [1, 3, 5, 7]))  # True
print(all(x > 5 for x in [1, 3, 5, 7]))  # False

# 1. 創(chuàng)建二維列表（矩陣）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
# 2. 訪問元素
print(f"矩陣[1][2]: {matrix[1][2]}")  # 6
# 3. 遍歷二維列表
print("逐行遍歷:")
for row in matrix:
    print(row)
print("逐個元素遍歷:")
for row in matrix:
    for element in row:
        print(element, end=' ')
    print()
# 4. 列表推導式創(chuàng)建二維列表
matrix_5x5 = [[0 for _ in range(5)] for _ in range(5)]
print(f"5x5零矩陣: {matrix_5x5}")
# 5. 注意事項：錯誤的方式創(chuàng)建多維列表
wrong_matrix = [[0] * 5] * 3  # 這種方式會創(chuàng)建共享的引用
wrong_matrix[0][0] = 1
print(f"錯誤的多維列表創(chuàng)建: {wrong_matrix}")  # 所有行的第一列都變成了1

import time
# 1. append() vs insert(0)
def test_performance():
    n = 10000
    # 在末尾添加元素 - O(1)
    start = time.time()
    lst = []
    for i in range(n):
        lst.append(i)
    end = time.time()
    print(f"append() 耗時: {end-start:.6f}秒")
    # 在開頭插入元素 - O(n)
    start = time.time()
    lst = []
    for i in range(n):
        lst.insert(0, i)
    end = time.time()
    print(f"insert(0) 耗時: {end-start:.6f}秒")
test_performance()
# 2. 成員檢查性能比較
def membership_test():
    lst = list(range(10000))
    s = set(range(10000))
    # 列表查找 - O(n)
    start = time.time()
    print(9999 in lst)  # 最壞情況
    end = time.time()
    print(f"列表成員檢查耗時: {end-start:.6f}秒")
    # 集合查找 - O(1)
    start = time.time()
    print(9999 in s)
    end = time.time()
    print(f"集合成員檢查耗時: {end-start:.6f}秒")
membership_test()

# 1. 去重（保持順序）
def deduplicate(lst):
    seen = set()
    result = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result
numbers = [1, 2, 2, 3, 4, 4, 5, 1, 2]
print(f"去重后: {deduplicate(numbers)}")
# 2. 統(tǒng)計頻率
def frequency_counter(lst):
    freq = {}
    for item in lst:
        freq[item] = freq.get(item, 0) + 1
    return freq
words = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
print(f"頻率統(tǒng)計: {frequency_counter(words)}")
# 3. 列表分塊
def chunk_list(lst, chunk_size):
    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
numbers = list(range(10))
print(f"分塊 (大小3): {chunk_list(numbers, 3)}")
# 4. 列表旋轉
def rotate_list(lst, k):
    k = k % len(lst)  # 處理k大于列表長度的情況
    return lst[-k:] + lst[:-k]
print(f"旋轉列表 [1,2,3,4,5] (k=2): {rotate_list([1,2,3,4,5], 2)}")