Python程序设计

# 单引号创建

s1 = 'Hello'

# 双引号创建

s2 = "World"

# 三引号创建多行字符串

s3 = '''Hello

World''' # 包含换行符

s4 = """Hello

World""" # 效果同三单引号

s = "Python"

print(s[0])   # 'P'  正向索引，从 0 开始

print(s[-1])  # 'n'  反向索引，从 - 1 开始

s = "Python"

print(s[0:3])    # 'Pyt'  [开始：结束)，左闭右开区间

print(s[:3])     # 'Pyt'  省略开始，从 0 开始

print(s[3:])     # 'hon'  省略结束，到字符串末尾

print(s[0:6:2])  # 'Pto'  [开始：结束：步长]

print(s[::-1])   # 'nohtyP'  步长为 - 1，逆序字符串

s = "Hello,World,Python"

print(s.split(','))    # ['Hello', 'World', 'Python']

print(s.split(',', 1)) # ['Hello', 'World,Python']  限制分割次数

lst = ['Hello', 'World', 'Python']

print(','.join(lst))   # 'Hello,World,Python'

s = "Hello World"

print(s.replace('World', 'Python'))  # 'Hello Python'

print(s.replace('o', '0', 1))         # 'Hell0 World'  限制替换次数

s = "   Hello World   "

print(s.strip())   # 'Hello World'  去除两端空白

print(s.lstrip())  # 'Hello World   '  去除左端空白

print(s.rstrip())  # '   Hello World'  去除右端空白

# 补充内容：可以指定要去除的字符

s = "###Hello World###"

print(s.strip('#'))  # 'Hello World'

s = "Hello World"

print(s.upper())      # 'HELLO WORLD'  转换为大写

print(s.lower())      # 'hello world'  转换为小写

print(s.find('o'))    # 4  查找子串首次出现的索引

print(s.rfind('o'))   # 7  查找子串最后出现的索引

print(s.startswith('Hello'))  # True  判断是否以指定子串开头

print(s.endswith('World'))    # True  判断是否以指定子串结尾

# 位置参数

print("Hello, {0}! I'm {1}.".format("World", "Python"))  # 'Hello, World! I'm Python.'

# 关键字参数

print("Hello, {name}! I'm {lang}.".format(name="World", lang="Python"))  # 'Hello, World! I'm Python.'

# 格式化数字

print("Pi is approximately {:.2f}".format(3.14159))  # 'Pi is approximately 3.14'  保留两位小数

print("Number: {:05d}".format(123))  # 'Number: 00123'  补零至 5 位

print("Percent: {:.1%}".format(0.75))  # 'Percent: 75.0%'  百分比格式

name = "World"

lang = "Python"

print(f"Hello, {name}! I'm {lang}.")  # 'Hello, World! I'm Python.'

pi = 3.14159

print(f"Pi is approximately {pi:.2f}")  # 'Pi is approximately 3.14'

print("Hello, %s! I'm %s." % ("World", "Python"))  # 'Hello, World! I'm Python.'

print("Pi is approximately %.2f" % 3.14159)  # 'Pi is approximately 3.14'

# 连接

print("Hello" + " " + "World")  # 'Hello World'

# 重复

print("Hello" * 3)  # 'HelloHelloHello'

s = "Hello World"

print('Hello' in s)    # True

print('Python' in s)   # False

print('Hello' not in s)  # False

# int () - 转换为整数

print(int(3.14))     # 3  小数转整数，向下取整

print(int("123"))     # 123  字符串转整数

print(int("0x10", 16))  # 16  指定基数

# float () - 转换为浮点数

print(float(3))       # 3.0

print(float("3.14"))   # 3.14

# bool () - 转换为布尔值

print(bool(0))        # False

print(bool(1))        # True

print(bool(""))       # False

print(bool("Hello"))  # True

# complex () - 转换为复数

print(complex(1))     # (1+0j)

print(complex(1, 2))  # (1+2j)

# str () - 转换为字符串

print(str(123))       # '123'

print(str([1, 2, 3])) # '[1, 2, 3]'

# repr () - 转换为表达式字符串

print(repr('Hello'))  # "'Hello'"

# eval () - 执行字符串表达式

print(eval('1 + 2'))  # 3

print(eval('"Hello" + "World"'))  # 'HelloWorld'

# chr () - ASCII 码转字符

print(chr(65))        # 'A'

# ord () - 字符转 ASCII 码

print(ord('A'))       # 65

# hex () - 转换为十六进制字符串

print(hex(16))        # '0x10'

# oct () - 转换为八进制字符串

print(oct(8))         # '0o10'

import math

# 数值函数

print(abs(-10))      # 10  绝对值

print(min(1, 2, 3))  # 1  最小值

print(max(1, 2, 3))  # 3  最大值

print(math.sqrt(16))  # 4.0  平方根

print(math.ceil(3.14))  # 4  向上取整

print(math.floor(3.14))  # 3  向下取整

# 字符串函数

s = "Hello World"

print(len(s))         # 11  字符串长度

print(s.upper())      # 'HELLO WORLD'  转换为大写

print(s.lower())      # 'hello world'  转换为小写

print(s.find('o'))    # 4  查找子串首次出现的索引

print(s.replace('o', '0'))  # 'Hell0 W0rld'  替换字符串

print(s.strip())      # 'Hello World'  去除两端空白

lst1 = [1, 2, 3]

lst2 = [1, 'a', True, [1, 2]]  # 元素可以是任何类型，类型可不同

lst1 = list()         # 空列表

lst2 = list("Python")  # 从字符串创建：['P', 'y', 't', 'h', 'o', 'n']

lst3 = list((1, 2, 3))  # 从元组创建：[1, 2, 3]

# 基本形式

lst1 = [x for x in range(5)]  # [0, 1, 2, 3, 4]

# 带条件

lst2 = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

# 嵌套

lst3 = [x + y for x in 'AB' for y in '12']  # ['A1', 'A2', 'B1', 'B2']

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

print(lst[0])    # 1  正向索引

print(lst[-1])   # 5  反向索引

print(lst[1:4])  # [2, 3, 4]  切片

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

for item in lst:

    print(item)

lst = ['a', 'b', 'c']

for index, item in enumerate(lst):

    print(index, item)

# 输出：

# 0 a

# 1 b

# 2 c

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

i = 0

while i < len(lst):

    print(lst[i])

    i += 1

lst = [1, 2, 3]

lst.append(4)

print(lst)  # [1, 2, 3, 4]

lst1 = [1, 2, 3]

lst2 = [4, 5, 6]

lst1.extend(lst2)

print(lst1)  # [1, 2, 3, 4, 5, 6]

lst = [1, 2, 3]

lst.insert(1, 'a')  # 在索引 1 位置插入 'a'

print(lst)  # [1, 'a', 2, 3]

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

del lst[0]      # 删除索引 0 位置的元素

print(lst)      # [2, 3, 4, 5]

del lst[1:3]    # 删除切片

print(lst)      # [2, 5]

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

print(lst.pop())    # 5  删除并返回最后一个元素

print(lst)          # [1, 2, 3, 4]

print(lst.pop(1))   # 2  删除并返回指定位置的元素

print(lst)          # [1, 3, 4]

lst = [1, 2, 3, 2, 4]

lst.remove(2)    # 删除第一个出现的 2

print(lst)       # [1, 3, 2, 4]

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

lst.clear()

print(lst)  # []

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

lst[0] = 'a'     # 修改单个元素

print(lst)       # ['a', 2, 3, 4, 5]

lst[1:3] = [6, 7]  # 修改切片

print(lst)       # ['a', 6, 7, 4, 5]

lst = [3, 1, 4, 1, 5, 9]

lst.sort()          # 默认升序

print(lst)          # [1, 1, 3, 4, 5, 9]

lst.sort(reverse=True)  # 降序

print(lst)          # [9, 5, 4, 3, 1, 1]

lst = [3, 1, 4, 1, 5, 9]

sorted_lst = sorted(lst)  # 返回新列表，原列表不变

print(sorted_lst)   # [1, 1, 3, 4, 5, 9]

print(lst)          # [3, 1, 4, 1, 5, 9]

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

print(len(lst))       # 5  列表长度

print(lst.count(1))   # 1  元素出现次数

print(lst.index(3))   # 2  元素首次出现的索引

print(sum(lst))       # 15  元素求和

print(min(lst))       # 1  最小值

print(max(lst))       # 5  最大值

print(lst.copy())     # [1, 2, 3, 4, 5]  浅拷贝

lst.reverse()         # 反转列表

print(lst)            # [5, 4, 3, 2, 1]

# 圆括号创建

t1 = (1, 2, 3)

# 省略圆括号

t2 = 1, 2, 3

# 单个元素元组，必须加逗号

t3 = (1,)

# 使用 tuple () 函数

t4 = tuple([1, 2, 3])

t = (1, 2, 3, 4, 5)

print(t[0])    # 1  索引访问

print(t[1:4])  # (2, 3, 4)  切片

t = (1, 2, 3, 4, 5)

print(len(t))       # 5  长度

print(t.count(1))   # 1  元素出现次数

print(t.index(3))   # 2  元素首次出现的索引

print(sum(t))       # 15  求和

print(min(t))       # 1  最小值

print(max(t))       # 5  最大值

# 基本解包

t = (1, 2, 3)

a, b, c = t

print(a, b, c)  # 1 2 3

# 扩展解包（Python 3+）

t = (1, 2, 3, 4, 5)

a, b, *rest = t

print(a, b, rest)  # 1 2 [3, 4, 5]

# 交换变量

a, b = 1, 2

a, b = b, a  # 交换 a 和 b 的值

print(a, b)  # 2 1

d1 = {'name': 'Tom', 'age': 18}

d2 = {}  # 空字典

# 创建空字典

d1 = dict()

# 利用序列创建字典

d2 = dict([('name', 'Tom'), ('age', 18)])

# 利用 zip 创建字典

d3 = dict(zip(['name', 'age'], ['Tom', 18]))

# 利用关键字参数创建字典

d4 = dict(name='Tom', age=18)

d = {'name': 'Tom', 'age': 18}

print(d['name'])  # 'Tom'

print(d['gender'])  # KeyError: 'gender'  键不存在会引发异常

d = {'name': 'Tom', 'age': 18}

print(d.get('name'))       # 'Tom'

print(d.get('gender'))     # None  键不存在返回 None

print(d.get('gender', 'Unknown'))  # 'Unknown'  键不存在返回默认值

d = {'name': 'Tom', 'age': 18}

d['gender'] = 'Male'

print(d)  # {'name': 'Tom', 'age': 18, 'gender': 'Male'}

d = {'name': 'Tom', 'age': 18}

d['age'] = 19

print(d)  # {'name': 'Tom', 'age': 19}

d = {'name': 'Tom', 'age': 18, 'gender': 'Male'}

# pop () 方法 - 删除并返回值

age = d.pop('age')

print(age, d)  # 18 {'name': 'Tom', 'gender': 'Male'}

# clear () 方法 - 清空字典

d.clear()

print(d)  # {}

# del 命令 - 删除键值对或字典

d = {'name': 'Tom', 'age': 18}

del d['name']

print(d)  # {'age': 18}

del d

d = {'name': 'Tom', 'age': 18, 'gender': 'Male'}

for key in d:

    print(key)  # name age gender

for key in d.keys():

    print(key)  # name age gender

d = {'name': 'Tom', 'age': 18, 'gender': 'Male'}

for value in d.values():

    print(value)  # Tom 18 Male

d = {'name': 'Tom', 'age': 18, 'gender': 'Male'}

for key, value in d.items():

    print(key, value)  # name Tom  age 18  gender Male

# 花括号创建

set1 = {1, 2, 3}

# 注意：直接 {} 创建的是空字典，不是空集合

empty_set = set()

# set () 函数创建

set2 = set([1, 2, 3, 3])  # {1, 2, 3}  自动去重

set3 = set("Hello")  # {'H', 'e', 'l', 'o'}  字符串转集合

set1 = {1, 2, 3}

set1.add(4)  # {1, 2, 3, 4}

set1 = {1, 2, 3, 4}

set1.remove(3)  # {1, 2, 4}  元素不存在会引发 KeyError

set1.discard(5)  # {1, 2, 4}  元素不存在不会引发异常

set1.pop()  # 1  随机删除并返回一个元素

set1.clear()  # {}  清空集合

set1 = {1, 2, 3, 4}

set2 = {3, 4, 5, 6}

# 交集

print(set1 & set2)  # {3, 4}

print(set1.intersection(set2))  # {3, 4}

# 并集

print(set1 | set2)  # {1, 2, 3, 4, 5, 6}

print(set1.union(set2))  # {1, 2, 3, 4, 5, 6}

# 差集

print(set1 - set2)  # {1, 2}

print(set1.difference(set2))  # {1, 2}

# 对称差集

print(set1 ^ set2)  # {1, 2, 5, 6}

print(set1.symmetric_difference(set2))  # {1, 2, 5, 6}

set1 = {1, 2, 3}

set2 = {2, 3}

print(len(set1))  # 3  集合长度

print(set2.issubset(set1))  # True  set2 是否是 set1 的子集

print(set1.issuperset(set2))  # True  set1 是否是 set2 的超集

print(set1.copy())  # {1, 2, 3}  浅拷贝

# 使用 frozenset () 函数创建不可变集合

fs = frozenset([1, 2, 3])

# fs.add(4)  # AttributeError: 'frozenset' object has no attribute 'add'

# 输入输出

print("Hello World")  # 输出

name = input("请输入姓名：")  # 输入

# 数值函数

print(abs(-10))      # 10  绝对值

print(divmod(10, 3))  # (3, 1)  商和余数

print(round(3.14159, 2))  # 3.14  四舍五入

print(pow(2, 3))     # 8  幂运算

print(sum([1, 2, 3]))  # 6  求和

print(min(1, 2, 3))  # 1  最小值

print(max(1, 2, 3))  # 3  最大值

# 类型转换

print(int(3.14))     # 3

print(float(3))       # 3.0

print(str(123))       # '123'

print(list((1, 2, 3)))  # [1, 2, 3]

print(tuple([1, 2, 3]))  # (1, 2, 3)

print(dict(name='Tom', age=18))  # {'name': 'Tom', 'age': 18}

print(set([1, 2, 3, 3]))  # {1, 2, 3}

# 序列函数

print(range(5))  # range(0, 5)

print(len([1, 2, 3]))  # 3

print(sorted([3, 1, 2]))  # [1, 2, 3]

print(list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4])))  # [2, 4]

print(list(map(lambda x: x * 2, [1, 2, 3])))  # [2, 4, 6]

# 其他

print(id(1))  # 对象 ID

print(type(1))  # <class 'int'>  对象类型

def greet(name):

    """这是一个问候函数"""

    return f"Hello, {name}!"

# 调用

print(greet("Tom"))  # 'Hello, Tom!'

def func(a, b):

    a += 1

    b.append(4)

    return a, b

x = 1

y = [1, 2, 3]

x, y = func(x, y)

print(x)  # 2  不可变对象，值不变

print(y)  # [1, 2, 3, 4]  可变对象，值改变

def func(a, b=10):

    return a + b

print(func(5))    # 15  使用默认值 b=10

print(func(5, 20))  # 25  使用传入值 b=20

def func(a, b):

    return a + b

print(func(a=5, b=10))  # 15

print(func(b=10, a=5))  # 15  关键字参数可以改变顺序

print(func(5, b=10))    # 15  混合使用位置参数和关键字参数

# print (func (a=5, 10))  # SyntaxError  位置参数必须在关键字参数之前

# *args - 接收任意数量的位置参数，返回元组

def func(*args):

    return args

print(func(1, 2, 3))  # (1, 2, 3)

# **kwargs - 接收任意数量的关键字参数，返回字典

def func(**kwargs):

    return kwargs

print(func(name='Tom', age=18))  # {'name': 'Tom', 'age': 18}

# 组合使用

def func(a, *args, **kwargs):

    return a, args, kwargs

print(func(1, 2, 3, name='Tom', age=18))  # (1, (2, 3), {'name': 'Tom', 'age': 18})

# 基本形式

add = lambda x, y: x + y

print(add(5, 10))  # 15

# 作为参数使用

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

print(list(map(lambda x: x * 2, lst)))  # [2, 4, 6, 8, 10]

print(list(filter(lambda x: x % 2 == 0, lst)))  # [2, 4]

def func():

    x = 10  # 局部变量

    print(x)

func()  # 10

# print(x)  # NameError: name 'x' is not defined

x = 10  # 全局变量

def func():

    print(x)  # 访问全局变量

func()  # 10

# 修改全局变量

def func():

    global x  # 声明 x 为全局变量

    x = 20

func()

print(x)  # 20

def factorial(n):

    """计算n的阶乘"""

    if n == 0:

        return 1

    else:

        return n * factorial(n - 1)

print(factorial(5))  # 120

def main():

    print("这是主函数")

if __name__ == "__main__":

    main()

class Person:

    """人这个类"""

    # 类属性

    species = "人类"

    # 构造函数

    def __init__(self, name, age):

        # 实例属性

        self.name = name

        self.age = age

    # 实例方法

    def greet(self):

        return f"你好，我是{self.name}，今年{self.age}岁。"

# 创建对象

p = Person("Tom", 18)

print(p.greet())  # ' 你好，我是 Tom，今年 18 岁。'

class Person:

    def __init__(self, name, age):

        self.name = name  # 公有属性

        self._age = age   # 保护属性

        self.__salary = 5000  # 私有属性

    # 访问私有属性的方法

    def get_salary(self):

        return self.__salary

p = Person("Tom", 18)

print(p.name)  # 'Tom'

print(p._age)  # 18  可以访问，但不推荐

# print (p.__salary)  # AttributeError  无法直接访问

print(p.get_salary())  # 5000  通过方法访问私有属性

class Person:

    def __init__(self, name, age):

        self.name = name

        self._age = age

    @property

    def age(self):

        return self._age

    @age.setter

    def age(self, value):

        if value > 0 and value < 120:

            self._age = value

        else:

            raise ValueError("年龄必须在0-120之间")

    @age.deleter

    def age(self):

        del self._age

p = Person("Tom", 18)

print(p.age)  # 18  访问属性

p.age = 20    # 修改属性

print(p.age)  # 20

# p.age = 150  # ValueError: 年龄必须在 0-120 之间

del p.age     # 删除属性

# print(p.age)  # AttributeError: 'Person' object has no attribute '_age'

class Person:

    count = 0  # 类属性

    def __init__(self, name):

        self.name = name

        Person.count += 1

print(Person.count)  # 0

p1 = Person("Tom")

print(Person.count)  # 1

p2 = Person("Jerry")

print(Person.count)  # 2

class Person:

    def __init__(self, name):

        self.name = name

p = Person("Tom")

p.age = 18  # 动态添加属性

print(p.age)  # 18

import types

p.greet = types.MethodType(lambda self: f"你好，我是{self.name}", p)  # 动态添加方法

print(p.greet())  # ' 你好，我是 Tom'

# 动态删除属性

del p.age

# print(p.age)  # AttributeError

# 使用 setattr 和 delattr

setattr(p, "gender", "男")

print(p.gender)  # ' 男'

delattr(p, "gender")

# print(p.gender)  # AttributeError

class Person:

    def __init__(self, name):

        self.name = name

    def greet(self):  # 实例方法，第一个参数是 self

        return f"你好，我是{self.name}"

p = Person("Tom")

print(p.greet())  # ' 你好，我是 Tom'

class Person:

    count = 0

    def __init__(self, name):

        self.name = name

        Person.count += 1

    @classmethod

    def get_count(cls):  # 类方法，第一个参数是 cls

        return cls.count

p1 = Person("Tom")

p2 = Person("Jerry")

print(Person.get_count())  # 2  直接通过类调用

print(p1.get_count())  # 2  通过实例调用

class Person:

    @staticmethod

    def say_hello():

        return "Hello!"

print(Person.say_hello())  # 'Hello!'  直接通过类调用

p = Person()

print(p.say_hello())  # 'Hello!'  通过实例调用

class Person:

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def __str__(self):

        return f"Person(name='{self.name}', age={self.age})"

    def __repr__(self):

        return f"Person('{self.name}', {self.age})"

    def __len__(self):

        return self.age

    def __call__(self):

        return f"{self.name}被调用了"

p = Person("Tom", 18)

print(p)  # Person (name='Tom', age=18)  调用__str__

print(repr(p))  # Person ('Tom', 18)  调用__repr__

print(len(p))  # 18  调用__len__

print(p())  # Tom 被调用了  调用__call__

import types

class Person:

    def __init__(self, name):

        self.name = name

# 动态添加实例方法

def greet(self):

    return f"你好，我是{self.name}"

p = Person("Tom")

p.greet = types.MethodType(greet, p)

print(p.greet())  # ' 你好，我是 Tom'

# 动态添加类方法

@classmethod

def get_class_name(cls):

    return cls.__name__

Person.get_class_name = get_class_name

print(Person.get_class_name())  # 'Person'

# 动态添加静态方法

@staticmethod

def say_hello():

    return "Hello!"

Person.say_hello = say_hello

print(Person.say_hello())  # 'Hello!'

# 动态删除方法

del p.greet

del Person.get_class_name

del Person.say_hello

class Vector:

    def __init__(self, x, y):

        self.x = x

        self.y = y

    def __add__(self, other):

        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):

        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):

        return Vector(self.x * scalar, self.y * scalar)

    def __eq__(self, other):

        return self.x == other.x and self.y == other.y

    def __str__(self):

        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)

v2 = Vector(3, 4)

v3 = v1 + v2  # 调用__add__

print(v3)  # Vector(4, 6)

v4 = v1 - v2  # 调用__sub__

print(v4)  # Vector(-2, -2)

v5 = v1 * 2  # 调用__mul__

print(v5)  # Vector(2, 4)

print(v1 == v2)  # False  调用__eq__

class Animal:

    def __init__(self, name):

        self.name = name

    def eat(self):

        return f"{self.name}在吃东西"

class Dog(Animal):

    def __init__(self, name, breed):

        super().__init__(name)  # 调用父类构造函数

        self.breed = breed

    def bark(self):

        return f"{self.name}在汪汪叫"

# 创建子类实例

dog = Dog("Tom", "金毛")

print(dog.eat())  # Tom 在吃东西  继承父类方法

print(dog.bark())  # Tom 在汪汪叫  子类自己的方法

class A:

    def method(self):

        return "A.method"

class B:

    def method(self):

        return "B.method"

class C(A, B):

    pass

class D(B, A):

    pass

c = C()

print(c.method())  # A.method  MRO 顺序：C -> A -> B -> object

d = D()

print(d.method())  # B.method  MRO 顺序：D -> B -> A -> object

class Animal:

    def speak(self):

        pass

class Dog(Animal):

    def speak(self):

        return "汪汪汪"

class Cat(Animal):

    def speak(self):

        return "喵喵喵"

class Bird(Animal):

    def speak(self):

        return "叽叽喳喳"

def make_animal_speak(animal):

    return animal.speak()

# 多态性示例

dog = Dog()

cat = Cat()

bird = Bird()

print(make_animal_speak(dog))  # 汪汪汪

print(make_animal_speak(cat))  # 喵喵喵

print(make_animal_speak(bird))  # 叽叽喳喳

# 基本文件操作流程

f = open('file.txt', 'r')  # 打开文件

content = f.read()         # 读取文件内容

f.close()                  # 关闭文件

# 使用 with 语句（推荐）

with open('file.txt', 'r') as f:

    content = f.read()     # 自动关闭文件

with open('file.txt', 'r') as f:

    content = f.read()         # 读取整个文件

    line = f.readline()        # 读取一行

    lines = f.readlines()      # 读取所有行，返回列表

with open('file.txt', 'w') as f:

    f.write('Hello World')     # 写入字符串

    f.writelines(['Line 1\n', 'Line 2\n'])  # 写入多行

with open('file.txt', 'r') as f:

    pos = f.tell()             # 获取当前指针位置

    f.seek(0)                  # 移动指针到文件开头

    f.seek(0, 2)               # 移动指针到文件末尾（仅二进制模式）

    f.flush()                  # 刷新缓冲区

import struct

# 将数据打包为二进制

packed_data = struct.pack('i f s', 1, 3.14, b'hello')

print(packed_data)

# 将二进制数据解包

unpacked_data = struct.unpack('i f s', packed_data)

print(unpacked_data)

# 计算格式字符串的大小

size = struct.calcsize('i f s')

print(size)

import pickle

# 将对象序列化为二进制文件

data = {'name': 'Tom', 'age': 18, 'scores': [90, 85, 95]}

with open('data.pkl', 'wb') as f:

    pickle.dump(data, f)

# 从二进制文件反序列化对象

with open('data.pkl', 'rb') as f:

    loaded_data = pickle.load(f)

    print(loaded_data)

import csv

# 写入 CSV 文件

with open('data.csv', 'w', newline='') as f:

    writer = csv.writer(f)

    writer.writerow(['name', 'age', 'city'])  # 写入表头

    writer.writerows([

        ['Tom', 18, 'Beijing'],

        ['Jerry', 20, 'Shanghai']

    ])  # 写入多行

# 读取 CSV 文件

with open('data.csv', 'r') as f:

    reader = csv.reader(f)

    for row in reader:

        print(row)  # 每行是一个列表

# 使用 DictWriter 和 DictReader

with open('data.csv', 'w', newline='') as f:

    fieldnames = ['name', 'age', 'city']

    writer = csv.DictWriter(f, fieldnames=fieldnames)

    writer.writeheader()  # 写入表头

    writer.writerow({'name': 'Tom', 'age': 18, 'city': 'Beijing'})

    writer.writerow({'name': 'Jerry', 'age': 20, 'city': 'Shanghai'})

with open('data.csv', 'r') as f: