02.Python 数据类型详解

# 基本使用
x = 42
y = -17

# 不同进制表示
bin_num = 0b1010  # 二进制表示10
print(f"二进制0b1010表示的十进制数是: {bin_num}")

oct_num = 0o52    # 八进制表示42
print(f"八进制0o52表示的十进制数是: {oct_num}")

hex_num = 0x2A    # 十六进制表示42
print(f"十六进制0x2A表示的十进制数是: {hex_num}")

# 进制转换
num = 42
print(f"数字{num}的二进制表示是: {bin(num)}")
print(f"数字{num}的八进制表示是: {oct(num)}")
print(f"数字{num}的十六进制表示是: {hex(num)}")

# 大数运算示例（计算阶乘）
def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1)

big_factorial = factorial(100)
print(f"100的阶乘是一个{len(str(big_factorial))}位的大数")

# 实际应用：位运算在权限系统中的应用
class Permissions:
    READ = 4    # 二进制：100
    WRITE = 2   # 二进制：010
    EXEC = 1    # 二进制：001

# 授予权限
def grant_permission(current_perm, new_perm):
    return current_perm | new_perm

# 检查权限
def check_permission(perm, check_perm):
    return perm & check_perm == check_perm

# 使用示例
user_perm = 0  # 初始没有任何权限
user_perm = grant_permission(user_perm, Permissions.READ)  # 授予读权限
user_perm = grant_permission(user_perm, Permissions.WRITE)  # 授予写权限

print(f"用户是否有读权限：{check_permission(user_perm, Permissions.READ)}")
print(f"用户是否有执行权限：{check_permission(user_perm, Permissions.EXEC)}")

# 基本使用和精度问题展示
x = 3.14159265359
print(f"圆周率保留5位小数：{x:.5f}")

# 科学计数法
electron_mass = 9.1093837e-31  # 电子质量（千克）
print(f"电子的质量是：{electron_mass:.2e} 千克")

# 浮点数精度问题及解决方案
print("=== 浮点数精度问题演示 ===")
print(0.1 + 0.2)             # 输出0.30000000000000004
print(0.1 + 0.2 == 0.3)      # 输出False

# 1. 使用decimal模块处理精确十进制计算
from decimal import Decimal, getcontext

# 设置精度为4位小数
getcontext().prec = 4

# 金融计算示例
class Money:
    def __init__(self, amount):
        self.amount = Decimal(str(amount))

    def __add__(self, other):
        return Money(self.amount + other.amount)

    def __str__(self):
        return f"¥{self.amount:.2f}"

# 模拟购物车计算
price1 = Money(10.99)
price2 = Money(5.99)
total = price1 + price2
print(f"商品1：{price1}")
print(f"商品2：{price2}")
print(f"总价：{total}")

# 2. 使用round函数处理显示精度
pi = 3.14159265359
print(f"圆周率取整：{round(pi)}")
print(f"圆周率保留2位小数：{round(pi, 2)}")

# 3. 使用math.isclose()比较浮点数
import math

def compare_floats(a, b, rel_tol=1e-9):
    return math.isclose(a, b, rel_tol=rel_tol)

# 实际应用：科学计算
def calculate_circle_area(radius):
    return round(math.pi * radius * radius, 2)

print(f"半径为5的圆的面积是：{calculate_circle_area(5)}平方单位")

import cmath  # 复数数学运算模块

# 创建复数的多种方式
z1 = 3 + 4j
z2 = complex(1, 2)
z3 = complex("5+3j")  # 从字符串创建

print(f"z1 = {z1}，其中实部为{z1.real}，虚部为{z1.imag}")

# 复数运算
print(f"z1 + z2 = {z1 + z2}")        # 复数加法
print(f"z1 * z2 = {z1 * z2}")        # 复数乘法
print(f"|z1| = {abs(z1)}")           # 复数的模
print(f"z1的共轭复数 = {z1.conjugate()}")  # 共轭复数

# 实际应用：求解二次方程
def solve_quadratic(a, b, c):
    """求解二次方程 ax² + bx + c = 0"""
    discriminant = b**2 - 4*a*c
    x1 = (-b + cmath.sqrt(discriminant))/(2*a)
    x2 = (-b - cmath.sqrt(discriminant))/(2*a)
    return x1, x2

# 求解方程 x² + 2x + 5 = 0
a, b, c = 1, 2, 5
x1, x2 = solve_quadratic(a, b, c)
print(f"方程 {a}x² + {b}x + {c} = 0 的解为：")
print(f"x₁ = {x1:.2f}")
print(f"x₂ = {x2:.2f}")

# 信号处理示例：计算傅里叶变换
import numpy as np

def simple_fft_example():
    # 创建一个简单的信号
    t = np.linspace(0, 1, 100)
    signal = np.sin(2 * np.pi * 10 * t)  # 10Hz的正弦波

    # 计算傅里叶变换
    fft_result = np.fft.fft(signal)

    # 获取频率分量
    frequencies = np.fft.fftfreq(len(t), t[1] - t[0])

    return frequencies, fft_result

# 注：实际运行需要安装numpy库

# 列表的创建和基本操作
fruits = ['苹果', '香蕉', '橙子']
prices = [5.5, 2.8, 3.5]

# 列表推导式
discounted_prices = [price * 0.9 for price in prices]  # 打九折
print(f"原价：{prices}")
print(f"折后价：{discounted_prices}")

# 列表切片操作
print(f"前两种水果：{fruits[:2]}")
print(f"反转列表：{fruits[::-1]}")

# 列表方法示例
fruits.append('葡萄')           # 添加元素
fruits.insert(1, '梨')          # 插入元素
fruits.remove('香蕉')           # 删除元素
print(f"更新后的水果列表：{fruits}")

# 实际应用：购物车系统
class ShoppingCart:
    def __init__(self):
        self.items = []

    def add_item(self, name, price, quantity=1):
        self.items.append({
            'name': name,
            'price': price,
            'quantity': quantity
        })

    def remove_item(self, name):
        self.items = [item for item in self.items if item['name'] != name]

    def get_total(self):
        return sum(item['price'] * item['quantity'] for item in self.items)

    def show_cart(self):
        print("=== 购物车 ===")
        for item in self.items:
            print(f"{item['name']} x {item['quantity']} = ¥{item['price'] * item['quantity']:.2f}")
        print(f"总计：¥{self.get_total():.2f}")

# 使用购物车
cart = ShoppingCart()
cart.add_item('苹果', 5.5, 3)
cart.add_item('香蕉', 2.8, 2)
cart.show_cart()

# 元组的创建和基本操作
point = (3, 4)
print(f"点的坐标：x = {point[0]}, y = {point[1]}")

# 元组解包
x, y = point
print(f"解包后：x = {x}, y = {y}")

# 命名元组
from collections import namedtuple

# 创建一个表示矩形的命名元组
Rectangle = namedtuple('Rectangle', ['width', 'height'])
rect = Rectangle(width=10, height=20)
print(f"矩形的宽度：{rect.width}，高度：{rect.height}")

# 实际应用：坐标系统
class CoordinateSystem:
    def __init__(self):
        self.points = []

    def add_point(self, x, y):
        self.points.append((x, y))

    def calculate_distance(self, point1, point2):
        x1, y1 = point1
        x2, y2 = point2
        return ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5

    def find_nearest_points(self):
        if len(self.points) < 2:
            return None

        min_distance = float('inf')
        nearest_pair = None

        for i, p1 in enumerate(self.points):
            for p2 in self.points[i+1:]:
                distance = self.calculate_distance(p1, p2)
                if distance < min_distance:
                    min_distance = distance
                    nearest_pair = (p1, p2)

        return nearest_pair, min_distance

# 使用坐标系统
coords = CoordinateSystem()
coords.add_point(0, 0)
coords.add_point(1, 1)
coords.add_point(2, 2)
coords.add_point(5, 5)

nearest_points, distance = coords.find_nearest_points()
print(f"最近的两个点是：{nearest_points}，距离为：{distance:.2f}")

# 字典的创建和基本操作
student = {
    'name': '张三',
    'age': 20,
    'scores': {'语文': 85, '数学': 92, '英语': 88}
}

# 访问和修改字典元素
print(f"学生姓名：{student['name']}")
print(f"数学成绩：{student['scores']['数学']}")

student['age'] = 21  # 修改值
student['class'] = '高三(1)班'  # 添加新键值对

# 字典方法示例
print(f"所有键：{list(student.keys())}")
print(f"所有值：{list(student.values())}")
print(f"所有键值对：{list(student.items())}")

# 安全地获取值
grade = student.get('grade', '未知')  # 如果键不存在，返回默认值
print(f"年级：{grade}")

# 字典推导式
squares = {x: x**2 for x in range(5)}  # 创建平方数字典
print(f"平方数字典：{squares}")

# 实际应用：学生成绩管理系统
class GradeSystem:
    def __init__(self):
        self.students = {}

    def add_student(self, student_id, name):
        if student_id not in self.students:
            self.students[student_id] = {
                'name': name,
                'scores': {}
            }
            return True
        return False

    def add_score(self, student_id, subject, score):
        if student_id in self.students:
            self.students[student_id]['scores'][subject] = score
            return True
        return False

    def get_average_score(self, student_id):
        if student_id in self.students:
            scores = self.students[student_id]['scores'].values()
            if scores:
                return sum(scores) / len(scores)
        return None

    def get_student_report(self, student_id):
        if student_id in self.students:
            student = self.students[student_id]
            print(f"=== 学生成绩单 ===")
            print(f"学号：{student_id}")
            print(f"姓名：{student['name']}")
            print("成绩详情：")
            for subject, score in student['scores'].items():
                print(f"{subject}: {score}")
            avg = self.get_average_score(student_id)
            if avg is not None:
                print(f"平均分：{avg:.2f}")

# 使用成绩管理系统
grades = GradeSystem()
grades.add_student('001', '张三')
grades.add_score('001', '语文', 85)
grades.add_score('001', '数学', 92)
grades.add_score('001', '英语', 88)
grades.get_student_report('001')

# 集合的创建和基本操作
numbers = {1, 2, 3, 4, 5}
fruits = set(['苹果', '香蕉', '橙子'])

# 集合的唯一性（自动去重）
duplicates = {1, 2, 2, 3, 3, 3}
print(f"去重后的集合：{duplicates}")  # 输出：{1, 2, 3}

# 集合运算
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

print(f"并集：{set1 | set2}")  # 或使用 set1.union(set2)
print(f"交集：{set1 & set2}")  # 或使用 set1.intersection(set2)
print(f"差集：{set1 - set2}")  # 或使用 set1.difference(set2)
print(f"对称差集：{set1 ^ set2}")  # 或使用 set1.symmetric_difference(set2)

# 集合推导式
squares = {x**2 for x in range(10) if x % 2 == 0}
print(f"偶数的平方集合：{squares}")

# 集合的方法
fruits.add('葡萄')      # 添加元素
fruits.remove('香蕉')   # 删除元素（如果不存在会报错）
fruits.discard('梨')    # 删除元素（如果不存在不会报错）

# 实际应用：标签系统
class TagSystem:
    def __init__(self):
        self.tags = {}

    def add_tags(self, item_id, *tags):
        if item_id not in self.tags:
            self.tags[item_id] = set()
        self.tags[item_id].update(tags)

    def remove_tags(self, item_id, *tags):
        if item_id in self.tags:
            self.tags[item_id].difference_update(tags)

    def get_items_by_tag(self, tag):
        return {item_id for item_id, item_tags in self.tags.items()
                if tag in item_tags}

    def get_items_by_all_tags(self, *tags):
        tag_set = set(tags)
        return {item_id for item_id, item_tags in self.tags.items()
                if tag_set.issubset(item_tags)}

    def get_items_by_any_tags(self, *tags):
        tag_set = set(tags)
        return {item_id for item_id, item_tags in self.tags.items()
                if not tag_set.isdisjoint(item_tags)}

# 使用标签系统
tags = TagSystem()
tags.add_tags('article1', 'Python', '编程', '教程')
tags.add_tags('article2', 'Python', '数据分析')
tags.add_tags('article3', 'Java', '编程')

print("\n=== 标签系统示例 ===")
print(f"包含'Python'标签的文章：{tags.get_items_by_tag('Python')}")
print(f"同时包含'Python'和'编程'标签的文章：{tags.get_items_by_all_tags('Python', '编程')}")
print(f"包含'Python'或'Java'标签的文章：{tags.get_items_by_any_tags('Python', 'Java')}")

# 性能优化建议
'''
1. 使用集合进行成员检查比列表更快：O(1) vs O(n)
2. 大量数据去重时使用集合而不是循环判断
3. 对于需要频繁进行并集、交集操作的场景，优先使用集合
4. 如果元素数量较大，考虑使用frozenset（不可变集合）作为字典的键
'''

# 最佳实践示例：高效的重复数据检查
def find_duplicates(items):
    seen = set()
    return {x for x in items if x in seen or seen.add(x)}

numbers = [1, 2, 3, 2, 4, 3, 5]
print(f"\n重复的数字：{find_duplicates(numbers)}")