内置函数及文件 ¶

# 一个简单的lambda函数，计算两个数的和
add = lambda x, y: x + y
print(add(3, 4))
# 7

# 使用lambda函数作为映射函数的参数
numbers = [1, 2, 5, 10]
squared = list(map(lambda x: x**2, numbers))
print(squared)
# [1, 4, 25, 100]

# 使用lambda函数作为排序函数的参数
numbers = [1, 2, 5, 10]
sorted_numbers = sorted(numbers, key=lambda x: x % 2)
print(sorted_numbers)
# [2, 10, 1, 5]

# 使用lambda函数进行乘法运算
multiply = lambda x, y: x * y
print(multiply(2, 3))
# 6

# 使用lambda函数列表
functions = [lambda a: a * 2, lambda b: b * 3]
print(functions[0](5))
# 10
print(functions[1](5))
# 15

def short_func1(x):
    return x * 2

short_func2 = lambda x: x * 2

print(short_func1(5))  
# 10
print(short_func2(5))  
# 10

# 定义一个函数 apply_to_list，接受一个列表和一个函数作为参数
def apply_to_list(some_list, f):
    # 返回一个新的列表，其中每个元素都是通过对原列表中的每个元素应用函数 f 得到的
    return [f(x) for x in some_list]

ints = [4, 0, 1, 5, 6]

# 调用 apply_to_list 函数，将每个整数乘以 2
result5 = apply_to_list(ints, lambda x: x * 2)

print(result5)  
# [8, 0, 2, 10, 12]

def apply(func, arg):
    return func(arg)

result = apply(lambda x: x * 2, 5)
print(result)  # 输出: 10

print(lambda: None)
# <function <lambda> at 0x7fa5c4097670>

print(lambda **kwargs: 1)  # 输出: <function <lambda> at 0x729037beb9a0>

result = lambda **kwargs: 1
print(result)  # 输出: <function <lambda> at 0x729037f0fd90>

# 调用不带参数的 lambda 函数
result = (lambda **kwargs: 1)()
print(result)  # 输出: 1

# 调用带有一些关键字参数的 lambda 函数
result = (lambda **kwargs: 1)(a=10, b=20)
print(result)  # 输出: 1

result = (lambda **kwargs: kwargs)(a=10, b=20)
print(result)  # 输出: {'a': 10, 'b': 20}

# 将 lambda 函数赋值给变量并调用它
my_lambda = lambda **kwargs: kwargs
result = my_lambda(x=5, y=15)
print(result)  # 输出: {'x': 5, 'y': 15}
print(result.values())  # 输出: dict_values([5, 15])
print(result.keys())  # 输出: dict_keys(['x', 'y'])

# 使用 **kwargs 计算总和
sum_lambda = lambda **kwargs: sum(kwargs.values())
result = sum_lambda(a=1, b=2, c=3)
print(result)  # 输出: 6

# 使用 **kwargs 进行字符串格式化
format_lambda = lambda **kwargs: "Name: {name}, Age: {age}".format(**kwargs)
result = format_lambda(name="Alice", age=30)
print(result)  # 输出: Name: Alice, Age: 30

filter(function, iterable)

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

dict_with_lambda = {'double': lambda x: x * 2}
print(dict_with_lambda['double'](5))
# 10

from functools import reduce
reduce(function, sequence[, initial])

from functools import reduce

# 计算列表中所有元素的累加
numbers = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, numbers)
print(result)
# 15

# 计算列表中所有元素的乘积
numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)
print(product)
# 120

# 连接列表中的字符串
strings = ["Hello", " ", "World", "!"]
concatenated_string = reduce(lambda x, y: x + y, strings)
print(concatenated_string)
# "Hello World!"

# 找到列表中的最大值
numbers = [1, 5, 2, 8, 3]
max_value = reduce(lambda x, y: x if x > y else y, numbers)
print(max_value)
# 8

# 找到列表中的最小值
numbers = [1, 5, 2, 8, 3]
min_value = reduce(lambda x, y: x if x < y else y, numbers)
print(min_value)
# 1

multiply = lambda x, y, z: x * y * z
print(multiply(2, 3, 4))
# 24

class Calculator:
    def __init__(self):
        self.operations = {}  # 初始化操作字典

    def add_operation(self, name, operation):
        self.operations[name] = lambda x, y: operation(x, y)  # 添加操作

    def calculate(self, name, x, y):
        return self.operations[name](x, y)  # 执行操作并返回结果


calc = Calculator()
calc.add_operation("add", lambda x, y: x + y)  # 添加加法操作
print(calc.calculate("add", 3, 4))  # 计算 3 + 4 并打印结果
# 7

s = [3, 1, 4, 1, 5, 9]
print(len(s))        # 输出: 6
print(min(s))        # 输出: 1
print(max(s))        # 输出: 9
print(sum(s))        # 输出: 23
print(all(s))        # 输出: True
print(any(s))        # 输出: True
print(sorted(s))     # 输出: [1, 1, 3, 4, 5, 9]
print(list(reversed(s)))  # 输出: [9, 5, 1, 4, 1, 3]

t = (1, 2, 3)
print(list(t))       # 输出: [1, 2, 3]
print(set(t))        # 输出: {1, 2, 3}

s = [3, 1, 4, 1, 5, 9]
t = (1, 2, 3)

print(list(enumerate(s)))
# [(0, 3), (1, 1), (2, 4), (3, 1), (4, 5), (5, 9)]
print(list(filter(lambda x: x > 2, s)))
# [3, 4, 5, 9]
print(list(map(lambda x: x * 2, s)))
# [6, 2, 8, 2, 10, 18]
print(list(zip(s, t)))
# [(3, 1), (1, 2), (4, 3)]

seasons = ['Spring', 'Summer', 'Fall', 'Winter']

print(list(enumerate(seasons)))  
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

a_list = ['foo', 'bar', 'baz']
mapping = {}

for i, v in enumerate(a_list):  # enumerate生成索引值i和序列值v
    mapping[v] = i

print(mapping)  
# {'foo': 0, 'bar': 1, 'baz': 2}

i = 0
mapping = {}
for v in a_list:
    print(i, a_list[i])
    mapping[v] = i
    i += 1

print(mapping)  
# {'foo': 0, 'bar': 1, 'baz': 2}

a_list = ["01", "02", "03"]
unit_element = "1"  # 必须是字符串

for i, element in enumerate(a_list):
    a_list[i] = unit_element + element

print(a_list)
# ['101', '102', '103']

y = sorted([7, 1, 2, 6, 0, 3, 2])
print(y)  # [0, 1, 2, 2, 3, 6, 7] 结果已排序

z = sorted('Hello World')
print(z)  
# [' ', 'H', 'W', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r']

numbers = [3, 1, 4, 1, 5, 9, 2]
sorted_numbers = sorted(numbers)

print(sorted_numbers)
# 输出: [1, 1, 2, 3, 4, 5, 9]
print(numbers)
# 输出: [3, 1, 4, 1, 5, 9, 2]（原始列表未修改）

numbers = [3, 1, 4, 1, 5, 9, 2]
numbers.sort()
print(numbers)
# 输出: [1, 1, 2, 3, 4, 5, 9]（原始列表被修改）

seq1 = ['foo', 'bar', 'baz']
seq2 = ['one', 'two', 'three']
seq3 = [False, True]

zipped = zip(seq1, seq2)
print(list(zipped))  
# [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

zipped = zip(seq1, seq2, seq3)
print(list(zipped))  
# [('foo', 'one', False), ('bar', 'two', True)]

for i, (a, b) in enumerate(zip(seq1, seq2)):
    print('{0}: {1}, {2}'.format(i, a, b))  # 方法1 {0}列表元素的索引, {1}元组中第一个值, {2}元组中第二个值
    print(f'{i}: {a}, {b}') # 方法2
    # 0: foo, one
    # 1: bar, two
    # 2: baz, three

pitchers = [('Jack', 'Ma'), ('Tom', 'Li'), ('Jimmy', 'Zhang')]
first_names, last_names = zip(*pitchers)

print(first_names)  
# ('Jack', 'Tom', 'Jimmy')
print(last_names)  
# ('Ma', 'Li', 'Zhang')

text = "hello,world"
print(text.split(','))  # 输出: ['hello', 'world']
print('-'.join(['a', 'b', 'c']))  # 输出: a-b-c
print(text.find('world'))  # 输出: 6

r = range(1, 10, 2)
print(list(r))  # 输出: [1, 3, 5, 7, 9]
sl = slice(1, 5, 2)
print(s[sl])    # 输出: [1, 4]

# 生成 1 到 10 的平方列表
squares = [x**2 for x in range(1, 11)]
print(squares)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 过滤偶数
evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)
# [2, 4, 6, 8, 10]

# 嵌套循环
pairs = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
print(pairs)
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

result = []
for val in collection:
    if condition:
        result.append(expr)

data = []

for i in range(-5, 5):
    if i >= -1:
        data.append(i**2)

print(data)
# [1, 0, 1, 4, 9, 16]

data = [i**2 for i in range(-5, 5) if i >= -1]
print(data)
# [1, 0, 1, 4, 9, 16]

data = []
fruit = [
    "apricot",
    "Watermelon",
    "Papaya",
    "pear",
]

data = [x.upper() if x.startswith("p") else x.title() for x in fruit]

print(data)
# ['Apricot', 'Watermelon', 'Papaya', 'PEAR']

# 用for循环实现2层嵌套
data = []
list_i = []
list_j = []

for i in range(-3, 3):
    list_i.append(i)
    if i > 0:
        for j in range(1, 3):
            list_j.append(j)
            data.append((i, j))

print(list_i)
# [-3, -2, -1, 0, 1, 2]
print(list_j)
# [1, 2, 1, 2]
print(data)
# [(1, 1), (1, 2), (2, 1), (2, 2)]


# 用嵌套列表推导式实现
data = [(i, j) for i in range(-3, 3) if i > 0 for j in range(1, 3)]
print(data)
# [(1, 1), (1, 2), (2, 1), (2, 2)]

all_data = [
    ['John', 'Emily', 'Michael', 'Lee', 'Steven'],
    ['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar'],
]
names_of_interest = []

for names in all_data:
    enough_es = [name for name in names if name.count('e') >=2]
    names_of_interest.extend(enough_es)

print(names_of_interest)  
# ['Lee', 'Steven']

result = [name for names in all_data for name in names if name.count('e') >= 2]
print(result)  
# ['Lee', 'Steven']

matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]

flattened = []

# 传统for循环嵌套
for m in matrix:
    for x in m:
        flattened.append(x)

print(flattened)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

# 嵌套列表推导式
flattened = [x for m in matrix for x in m]
print(flattened)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

# 列表推导式中的列表推导式（上述嵌套列表推导式的改写）
z = [[x for x in m] for m in matrix]
print(z)
# [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

# 生成 1 到 10 的平方集合
squares_set = {x**2 for x in range(1, 11)}
print(squares_set)
# {64, 1, 4, 36, 100, 9, 16, 49, 81, 25}
print(type(squares_set))
# <class 'set'>

# 过滤偶数并去重
evens_set = {x for x in [1, 2, 2, 3, 4, 4, 5] if x % 2 == 0}
print(evens_set)
# {2, 4}

# 生成数字到其平方的字典
squares_dict = {x: x**2 for x in range(1, 6)}
print(squares_dict)
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 过滤偶数并生成字典
evens_dict = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(evens_dict)
# {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

# 交换键值对
original_dict = {'a': 1, 'b': 2, 'c': 3}
swapped_dict = {v: k for k, v in original_dict.items()}
print(swapped_dict)
# {1: 'a', 2: 'b', 3: 'c'}

# 将字串列表改成字典
strings = ['a', 'as', 'bat', 'car', 'dove', 'python']
loc_mapping = {index: val for index, val in enumerate(strings)}
print(loc_mapping)  
# {0: 'a', 1: 'as', 2: 'bat', 3: 'car', 4: 'dove', 5: 'python'}

data = (x for x in range(5))

print(data)
# <generator object <genexpr> at 0x7f87217a8e40>

print(type(data))
# <class 'generator'>

# 方法1: 使用 `for` 循环
data = (x for x in range(5))
for value in data:
    print(value)
# 0
# 1
# 2
# 3
# 4


# 方法2: 使用list()函数将生成器表达式转换为列表，然后输出整个列表
data = (x for x in range(5))
data_list = list(data)
print(data_list)
# [0, 1, 2, 3, 4]


# 方法3: 使用next()函数逐个获取生成器的下一个值，直到没有更多值可生成时抛出 `StopIteration` 异常
data = (x for x in range(5))
try:
    while True:
        print(next(data))
except StopIteration:
    pass
# 0
# 1
# 2
# 3
# 4


# 方法4: 使用tuple()函数将生成器表达式转换为元组，然后输出整个元组
data = (x for x in range(5))
data_tuple = tuple(data)
print(data_tuple)
# (0, 1, 2, 3, 4)


# 方法5: 使用 set()函数将生成器表达式转换为集合，然后输出整个集合（注意：这会去除重复元素）
data = (x for x in range(5))
data_set = set(data)
print(data_set)
# {0, 1, 2, 3, 4}

def function_name(parameters):
    """函数文档字符串（可选）"""
    # 函数体
    return value  # 返回值（可选）

def greet():
    """打印问候语"""
    print("Hello, World!")

# 调用函数
greet()
# Hello, World!

def greet(name):
    """向指定名字的人打招呼"""
    print(f"Hello, {name}!")

# 调用函数
greet("Alice")
# Hello, Alice!
greet("Bob")
# Hello, Bob!

def add(a, b):
    """返回两个数的和"""
    return a + b

# 调用函数
result = add(3, 5)
print(result)
# 8

def greet(name="World"):
    """向指定名字的人打招呼，默认是 World"""
    print(f"Hello, {name}!")

# 调用函数
greet()
# Hello, World!
greet("Alice")
# Hello, Alice!

def add(a, b):
    return a + b

# 调用函数时，参数按照定义的顺序传递
result = add(3, 5)  # 正确的调用方式
print(result)
# 8
result = add(3)
# TypeError: add() missing 1 required positional argument: 'b'

def greet(greeting, name="John"):
    print(f"{greeting}, {name}!")

# 调用函数
greet(name="Alice", greeting="Hi")
# Hi, Alice!
greet(greeting="John")
# Hi, John!
greet()
# TypeError: greet() missing 1 required positional argument: 'greeting'

def add(*numbers):
    """返回所有数字的和"""
    total = 0
    for num in numbers:
        total += num
    return total

# 调用函数
print(add(1, 2, 3))
# 6
print(add(1, 2, 3, 4, 5))
# 15

def print_info(**info):
    """打印所有关键字参数"""
    for key, value in info.items():
        print(f"{key}: {value}")

# 调用函数
print_info(name="Alice", age=25, city="New York")
# name: Alice
# age: 25
# city: New York

def add(a, b, c, d=5):
    return a + b +c + d


args = (3, 5, 7)
kwargs = {"a": 3, "b": 5, "c": 7, "d": 9}

print(add(*args))
# 20
print(add(**kwargs))
# 24

# 定义一个 Lambda 函数
add = lambda a, b: a + b

# 调用 Lambda 函数
print(add(3, 5))
# 8

def greet(name: str) -> str:
    """返回问候语"""
    return f"Hello, {name}!"

# 调用函数
print(greet("Alice"))
# Hello, Alice!

def outer():
    """外部函数"""
    message = "Hello"

    def inner():
        """内部函数"""
        print(message)

    # 调用内部函数
    inner()

# 调用外部函数
outer()
# Hello

def outer():
    """外部函数"""
    message = "Hello"

    def inner():
        """内部函数"""
        print(message)

    return inner  # 返回内部函数

# 调用外部函数，返回内部函数
closure = outer()
closure()
# Hello

class Avg:
    def __init__(self):
        self.mylist = []  # 用于存储历史值

    def __call__(self, newValue):
        self.mylist.append(newValue)  # 添加新值
        total = sum(self.mylist)  # 计算总和
        avg = total / len(self.mylist)  # 计算平均值
        print(f"List: {self.mylist}, Rolling Average: {avg}")
        return avg


# 使用示例
avg = Avg()

avg(10)  # List: [10], Rolling Average: 10.0
avg(20)  # List: [10, 20], Rolling Average: 15.0
avg(30)  # List: [10, 20, 30], Rolling Average: 20.0

def make_avg():
    my_list = []  # 自由变量，用于存储历史值

    def avg(newValue):
        my_list.append(newValue)  # 添加新值
        total = sum(my_list)  # 计算总和
        avg = total / len(my_list)  # 计算平均值
        print(f"List: {my_list}, Rolling Average: {avg}")
        return avg

    return avg  # 返回内部函数


# 使用示例
my_avg = make_avg()

my_avg(10)  # List: [10], Rolling Average: 10.0
my_avg(20)  # List: [10, 20], Rolling Average: 15.0
my_avg(30)  # List: [10, 20, 30], Rolling Average: 20.0

# 查看函数的局部变量和自由变量
print(my_avg.__code__.co_varnames)  # ('newValue', 'total')
print(my_avg.__code__.co_freevars)  # ('my_list',)

# 查看闭包中的值
print(my_avg.__closure__[0].cell_contents)  # [10, 20, 30]

def make_avg():
    count = 0  # 自由变量，用于存储值的数量
    total = 0  # 自由变量，用于存储值的总和

    def avg(newValue):
        nonlocal count, total  # 声明自由变量
        count += 1  # 更新数量
        total += newValue  # 更新总和
        return total / count  # 计算平均值

    return avg  # 返回内部函数


# 使用示例
my_avg = make_avg()

print(my_avg(10))  # 10.0
print(my_avg(20))  # 15.0
print(my_avg(30))  # 20.0

# 查看函数的局部变量和自由变量
print(my_avg.__code__.co_varnames)  # ('newValue',)
print(my_avg.__code__.co_freevars)  # ('count', 'total')

# 查看闭包中的值
print(my_avg.__closure__[0].cell_contents)  # 3 (count 的最终值)
print(my_avg.__closure__[1].cell_contents)  # 60 (total 的最终值)

def get_money():
    money = 0

    def work():
        nonlocal money
        money += 100
        print(money)

    return work


closure = get_money()

closure()
# 100
closure()
# 200
closure()
# 300

def factorial(n):
    """计算阶乘"""
    if n == 1:
        return 1
    else:
        return n * factorial(n - 1)

# 调用函数
print(factorial(5))
# 120

def generator_function():
    # 生成器函数体
    yield value
    # 可以有多个yield语句

def fibonacci(n):
    """生成斐波那契数列的生成器函数"""
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# 使用生成器函数
fib = fibonacci(10)
for num in fib:
    print(num)
# 0
# 1
# 1
# 2
# 3
# 5
# 8
# 13
# 21
# 34

def count_up_to(n):
    """生成从 1 到 n 的数字"""
    i = 1
    while i <= n:
        yield i
        i += 1

# 调用生成器函数
for num in count_up_to(5):
    print(num)
# 1
# 2
# 3
# 4
# 5

gen1 = (x ** 2 for x in range(100))

print(gen1)  
# <generator object <genexpr> at 0x7fd3f30c9580>

def _make_gen():
    for x in range(100):
        yield x ** 2

gen2 = _make_gen()
print(gen2)  
# <generator object _make_gen at 0x7fceb69ed580>

result1 = sum(x**2 for x in range(100))
print(result1)
# 328350

gen1 = (x**2 for x in range(100))
result1 = sum(gen1)
print(result1)
# 328350

result2 = dict((i, i**2) for i in range(5))
print(result2)
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

gen2 = ((i, i**2) for i in range(5))
result2 = dict(gen2)
print(result2)
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

import itertools

first_letter = lambda x: x[0]
names = ['Alan', 'Adam', 'Wes', 'Will', 'Albert', 'Steven']

for letter, names in itertools.groupby(names, first_letter):
    print(letter)
    print(first_letter)
    print(letter, list(names))  # names is generator

# A
# <function <lambda> at 0x7fa598a7a0d0>
# A ['Alan', 'Adam']
# W
# <function <lambda> at 0x7fa598a7a0d0>
# W ['Wes', 'Will']
# A
# <function <lambda> at 0x7fa598a7a0d0>
# A ['Albert']
# S
# <function <lambda> at 0x7fa598a7a0d0>
# S ['Steven']

def simple_generator():
    yield 1
    yield 2
    yield 3

# 使用 for 循环调用生成器函数
for value in simple_generator():
    print(value)
# 输出:
# 1
# 2
# 3

def simple_generator():
    yield 1
    yield 2
    yield 3

# 创建生成器对象
gen = simple_generator()

# 使用 next() 函数获取值
print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3

def simple_generator():
    yield 1
    yield 2
    yield 3

# 将生成器转换为列表
gen_list = list(simple_generator())
print(gen_list)
# [1, 2, 3]

def simple_generator():
    yield 1
    yield 2
    yield 3

# 创建生成器对象
gen = simple_generator()

# 使用 iter() 函数获取迭代器
gen_iter = iter(gen)

# 使用 next() 函数获取值
print(next(gen_iter))  # 1
print(next(gen_iter))  # 2
print(next(gen_iter))  # 3

# 全局命名空间
x = 10  # 全局变量

def foo():
    # 局部命名空间
    y = 20  # 局部变量
    print(x, y)  # 访问全局变量和局部变量

foo()
# 10 20

x = 10  # 全局作用域

def outer():
    y = 20  # 外层函数作用域

    def inner():
        z = 30  # 局部作用域
        print(x, y, z)  # 访问全局、外层和局部变量

    inner()

outer()
# 10 20 30

def outer():
    x = 10  # 外层函数变量

    def inner():
        print(x)  # 访问外层函数变量

    inner()  # 调用本地函数

outer()
# 10

def outer():
    x = 10  # 外层函数变量

    def inner():
        print(x)  # 访问外层函数变量

    return inner  # 返回本地函数


closure = outer()
closure()
# 10

x = 10  # 全局变量

def outer():
    y = 20  # 外层函数变量

    def inner():
        nonlocal y  # 修改外层函数变量
        global x    # 修改全局变量
        y += 1
        x += 1
        print(x, y)

    inner()

outer()  # 输出: 11 21

x = 10  # 全局命名空间

def foo():
    y = 20  # 局部命名空间
    print(x, y)  # 访问全局和局部命名空间

foo()
# 10 20

states = [
    "   Alabama",
    "Georgia!",
    "georgia",
    "Georgia",
    "FlOrIda",
    "south    carolina##",
    "West virginia? ",
]

# 方法1
import re


# 定义一个函数，用于清理字符串列表
def clean_string1(strings):
    result2 = []
    for value in strings:
        value = value.strip()  # 去除字符串两端的空格
        value = re.sub("[! #? ]", "", value)  # 去除字符串中的特定字符
        value = value.title()  # 将字符串转换为标题格式
        result2.append(value)  # 将清理后的字符串添加到结果列表中
    return result2


# 打印清理后的字符串列表
print(clean_string1((states)))
# ['Alabama', 'Georgia', 'Georgia', 'Georgia', 'Florida', 'Southcarolina', 'Westvirginia']


# 方法2
# 定义一个函数，用于去除字符串中的特定字符
def remove_punctuaion(value):
    return re.sub("[! #? ]", "", value)


# 定义一个包含多个清理操作的列表
clean_ops = [str.strip, remove_punctuaion, str.title]


# 定义一个函数，用于按顺序应用多个清理操作
def clean_string2(strings, ops):
    result3 = []
    for value in strings:
        for function in ops:
            value = function(value)  # 依次应用每个清理操作
        result3.append(value)  # 将清理后的字符串添加到结果列表中
    return result3


# 获取并打印清理后的字符串列表
result4 = clean_string2(states, clean_ops)

print(result4)
# ['Alabama', 'Georgia', 'Georgia', 'Georgia', 'Florida', 'Southcarolina', 'Westvirginia']


# 可以将函数作为一个参数传给其他的函数。
# 使用 map 函数将 remove_punctuaion 应用于 states 列表中的每个元素
for x in map(remove_punctuaion, states):
    print(x)

# Alabama
# Georgia
# georgia
# Georgia
# FlOrIda
# southcarolina
# Westvirginia

# 普通写法
def add(x, y, z):
    return x + y + z

print(add(1, 2, 3))  
# 6

# 柯里化写法
def curry_add(a):
    def add_b(b):
        def add_c(c):
            return a + b + c
        return add_c
    return add_b

# 使用柯里化函数
curried_add = curry_add(1)(2)(3)
print(curried_add)
# 6

# 通过固定其中的第二个参数不变来实现柯里化
def curry_add(a, b):
    def add_c(a, b, c):
        return a + b + c

    return add_c(a, 100, b)


result = curry_add(12, 13)
print(result)
# 125

result = curry_add(12, 555, 13)
# TypeError: curry_add() takes 2 positional arguments but 3 were given

from functools import partial


def add(x, y, z):
    return x + y + z


# 固定第一个参数，add_1现在是一个接受两个参数y和z的函数，当调用时，它会将1作为第一个参数传递给add函数。
add_1 = partial(add, 1)
# 固定第二个参数，add_1_2现在是一个接受一个参数z的函数，当调用时，它会将1和10作为前两个参数传递给add函数。
add_1_2 = partial(add_1, 10)
# 调用新函数，这个调用实际上是调用add(1, 10, 100)
result = add_1_2(100)
print(result)
# 111

def add1(a, b, c):
    return a + b + c

add2 = lambda x, y: add1(x, 100, y)

result = add2(12, 13)

print(result)  
# 1251

def add1(a, b, c):
    return a + b + c

def currying_add(func):
    def wrapper(a, c, b=100):
        return func(a, b, c)
    return wrapper

result = currying_add(add1)(12, 13)

print(result)  
# 125

def currying_add(func):
    def wrapper(a, c, b=100):
        return func(a, b, c)
    return wrapper

@currying_add
def add(a, b, c):
    return a + b + c

result = add(12, 13)

print(result)
# 125

try:
    # 尝试执行的代码
    pass
except ExceptionType as e:
    # 处理异常的代码
    pass

try:
    # 尝试除以零
    result = 10 / 0
except ZeroDivisionError as e:
    # 处理除以零的异常
    print(f"Error: {e}")
else:
    # 如果没有异常发生，执行这里的代码
    print("Division successful.")
finally:
    # 无论是否发生异常，都执行这里的代码
    print("Cleanup code.")

data = {"a": 1, "b": 2}

# EAFP: 先尝试访问键，如果出错则捕获异常
try:
    value = data["c"]
except KeyError:
    value = "default_value"

print(value)  # 输出: default_value

# LBYL: 先检查键是否存在，如果存在则访问
if "c" in data:
    value = data["c"]
else:
    value = "default_value"
print(value)  # 输出: default_value

# 打开文件（读取模式）
file = open("example.txt", "r")
content = file.read()  # 读取文件内容
file.close()  # 关闭文件

# 使用 with 语句自动关闭文件
with open("example.txt", "r") as file:
    content = file.read()

import os

# 查看当前路径
os.getcwd()
# '/opt/myMemo'

# 更改文件读取默认路径
os.chdir('~/datasets/examples')

# 指定文件名
path = 'file01.txt'

# 打开文件
f = open(path)

# 读取文件每一行，文件每一行作为列表一个元素
lines = [x.rstrip() for x in open(path)]

# 输出列表
print(lines)

# 关闭文件会将资源释放回操作系统
f.close()  

import os

# 查看当前路径
current_path = os.getcwd()

# 更改文件读取默认路径
os.chdir(current_path + "/docs/python/datasets/examples")

# 指定文件名
path = "file01.txt"

# 打开文件
f = open(path)

# 读取文件每一行，文件每一行作为列表一个元素
lines = [x.rstrip() for x in open(path)]

# 输出列表
print(lines)

# 关闭文件会将资源释放回操作系统
f.close()

import os

# 查看当前路径
current_path = os.getcwd()

# 更改文件读取默认路径
os.chdir(current_path + "/docs/python/datasets/examples")

# 指定文件名
path = 'file01.txt'

# 打开文件
f = open(path)

# 读取文件。
print(f.read(5))  # 输出前5个字符。 read方法通过读取的字节数来推进文件句柄的位置。
# I Thi 
print(f.tell())  # tell方法可以给出句柄当前的位置
# 5  
print(f.seek(6))  # seek方法可以将句柄位置改变到文件中特定的字节
# 6  
print(f.read(1))  # 从第7个字节开始，输出1个字节
# k 

# 关闭文件会将资源释放回操作系统
f.close()

import os

# 查看当前路径
current_path = os.getcwd()

# 更改文件读取默认路径
os.chdir(current_path + "/docs/python/datasets/examples")

# 指定文件名
path = 'file01.txt'

# 打开文件
f2 = open(path, 'rb')  # 二进制模式

# 读取文件
print(f2.read(5))  # 第一个b代表二进制格式
# b'I Thi'  
print(f2.tell())  
# 5
print(f2.seek(6))  
# 6
print(f2.read(2))  # 从第7个字节开始，输出2个字节
# b'k '  

# 关闭文件会将资源释放回操作系统
f2.close()

with open("file01.txt", "r") as file:
    print(file.read())  # 读取整个文件
    print(file.readline())  # 读取一行
    print(file.readlines())  # 读取所有行

with open("file01.txt", "w") as file:
    file.write("Hello, World!\n")  # 写入一行
    file.writelines(["Line 1\n", "Line 2\n"])  # 写入多行

import os

# 查看当前路径
current_path = os.getcwd()

# 更改文件读取默认路径
os.chdir(current_path + "/docs/python/datasets/examples")

# 指定文件名
path1 = 'file01.txt'
path2 = 'file02.txt'  # file02.txt是一个空文件

with open(path2, 'r+', encoding='utf-8') as f:
    f.writelines(x for x in open(path1, 'r', encoding='utf-8') if len(x) > 1)  # 把file01.txt的内容写入file02.txt
    lines = f.readlines()
    print(lines)

with open("file01.txt", "a") as file:
    file.write("This is a new line.\n")

import os

# 创建单层目录
os.mkdir("new_dir")

# 创建多层目录
os.makedirs("parent_dir/child_dir")

import os
import shutil

# 删除空目录
os.rmdir("new_dir")

# 删除非空目录
shutil.rmtree("parent_dir")

import os

# 列出目录内容
print(os.listdir("."))  # 当前目录

# 递归遍历目录
for root, dirs, files in os.walk("."):
    print(root, dirs, files)

import os

# 查看当前路径
current_path = os.getcwd()

# 拼接路径
path = os.path.join(current_path, "docs/python/datasets/examples/file01.txt")

# 获取绝对路径
abs_path = os.path.abspath("file01.txt")

# 检查路径是否存在
print(os.path.exists(path))
# True

# 获取文件名和目录名
print(os.path.basename(path))
# file01.txt
print(os.path.dirname(path))
# /opt/mySite/docs/python/datasets/examples

import os
from pathlib import Path

# 查看当前路径
current_path = os.getcwd()

# 创建 Path 对象
path = Path(current_path + "/docs/python/datasets/examples/file01.txt")

# 获取绝对路径
abs_path = path.absolute()

# 检查路径是否存在
print(path.exists())
# True

# 读取文件内容
print(path.read_text())

import os
import subprocess

# 使用 os.system
cmd = "ls -l"
os.system(cmd)

# 使用 subprocess.run
result = subprocess.run(["ls", "-l"], capture_output=True, text=True)
print(result.stdout)

import os

# 获取环境变量
var_home = os.environ.get("HOME")
print(var_home)

# 设置环境变量
os.environ["MY_VAR"] = "value"
var_myvar = os.environ.get("MY_VAR")
print(var_myvar)

example_project/
├── source.txt
├── module1.py
├── module2.py
└── resources/
    ├── image1.png
    └── image2.png

import shutil

# 复制单个文件
source_file = "example_project/source.txt"
destination_file = "backup/source.txt"

# 确保目标目录存在
os.makedirs(os.path.dirname(destination_file), exist_ok=True)

# 复制文件
shutil.copy(source_file, destination_file)
print(f"File '{source_file}' copied to '{destination_file}'")

import shutil
import os

# 复制整个目录
source_dir = "example_project/resources"
destination_dir = "backup/resources"

# 确保目标目录不存在，因为 copytree() 不会覆盖已存在的目录
if os.path.exists(destination_dir):
    shutil.rmtree(destination_dir)

# 复制目录
shutil.copytree(source_dir, destination_dir)
print(f"Directory '{source_dir}' copied to '{destination_dir}'")

project/
├── source.txt
├── log.txt
└── temp/
    ├── temp_file1.txt
    └── temp_file2.txt

import shutil
import os

# 移动单个文件
source_file = "project/source.txt"
destination_file = "backup/source.txt"

# 确保目标目录存在
os.makedirs(os.path.dirname(destination_file), exist_ok=True)

# 移动文件
shutil.move(source_file, destination_file)
print(f"File '{source_file}' moved to '{destination_file}'")

import shutil
import os

# 移动整个目录
source_dir = "project/temp"
destination_dir = "backup/temp"

# 确保目标目录不存在，因为 move() 会覆盖已存在的目录
if os.path.exists(destination_dir):
    shutil.rmtree(destination_dir)

# 移动目录
shutil.move(source_dir, destination_dir)
print(f"Directory '{source_dir}' moved to '{destination_dir}'")

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

def get_pet(pet_type):
    """工厂函数，根据pet_type返回相应的宠物实例"""
    if pet_type == "dog":
        return Dog()
    elif pet_type == "cat":
        return Cat()
    else:
        raise ValueError("Unknown pet type")

# 使用工厂函数创建宠物实例
dog = get_pet("dog")
print(dog.speak())
# Woof!

cat = get_pet("cat")
print(cat.speak())
# Meow!

def maker(n):
    k = 8

    def action(x):
       return x + n + k

    return action


f = maker(2) 

print(f(3))
# 13
print(f(4))
# 14
print(f(5))
# 15

def my_decorator(nestedFunc):
    def myFunc():
        """This is a docstring in myFunc()."""
        print("Before executing nestedFunc()")
        nestedFunc()
        print("After executing nestedFunc()")

    return myFunc


def nestedFunc():
    """This is a docstring in nestedFunc()."""
    print("Decoration - executing nestedFunc()")


nestedFunc()  # 直接调用 nestedFunc()
# Decoration - executing nestedFunc()

nestedFunc = my_decorator(nestedFunc)  # 使用 my_decorator 装饰 nestedFunc
nestedFunc()
# Before executing nestedFunc()
# Decoration - executing nestedFunc()
# After executing nestedFunc()

def my_decorator(nestedFunc):
    def myFunc():
        """This is a docstring in myFunc()."""
        print("Before executing nestedFunc()")
        nestedFunc()
        print("After executing nestedFunc()")

    return myFunc


@my_decorator
def nestedFunc():
    """This is a docstring in nestedFunc()."""
    print("New added to decoration - executing nestedFunc()")

nestedFunc()
# Before executing nestedFunc()
# New added to decoration - executing nestedFunc()
# After executing nestedFunc()

print(nestedFunc.__name__)  
# myFunc
print(nestedFunc.__doc__)  
# This is a docstring in myFunc().

from functools import wraps

def my_decorator(nestedFunc):
    @wraps(nestedFunc)
    def myFunc():
        """This is a docstring in myFunc()."""
        print("Before executing nestedFunc()")
        nestedFunc()
        print("After executing nestedFunc()")

    return myFunc


@my_decorator
def nestedFunc():
    """This is a docstring in nestedFunc()."""
    print("New added to decoration - executing nestedFunc()")

nestedFunc()
# Before executing nestedFunc()
# New added to decoration - executing nestedFunc()
# After executing nestedFunc()

print(nestedFunc.__name__)  
# nestedFunc
print(nestedFunc.__doc__)  
# This is a docstring in nestedFunc().

from functools import wraps

def decorator_name(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        if not can_run:
            return "Function will not run"
        return f(*args, **kwargs)
    return decorated

@decorator_name
def func():
    return "Function is running"

can_run = True
print(func())
# Function is running

can_run = False
print(func())
# Function will not run

# 创建一个空列表 registry，用于存储注册的函数。
registry = []


# 定义一个装饰器函数 register，用于注册函数。
def register(func):
    print(f"running register {func}")  # 当装饰器被应用时，打印一条消息，表明正在注册函数 func。
    registry.append(func)  # 将函数 func 添加到 registry 列表中。
    return func  # 返回原始函数 func，以便它可以被正常调用。


# 将装饰器 register 应用于函数 f1 和 f2。应用装饰器后，f1 和 f2 会被自动注册到 registry 列表中。
@register
def f1():
    print("running f1()")


@register
def f2():
    print("running f2()")


# 定义一个未注册的函数 f3。
def f3():
    print("running f3()")


def main():
    print("runnning main()")
    print(f"registry--> {registry}") # 打印注册表 registry 的内容，显示已注册的函数。
    f1()
    f2()
    f3()


if __name__ == "__main__":
    main()

running register <function f1 at 0x7f70847bec80>
running register <function f2 at 0x7f70705aa9d8>
runnning main()
registry--> [<function f1 at 0x7f70847bec80>, <function f2 at 0x7f70705aa9d8>]
running f1()
running f2()
running f3()

from typing import NamedTuple

class City(NamedTuple):
    name: str
    country: str
    population: float
    coordinates: tuple

beijing = City("Beijing", "CN", 22.596, (39.9042, 116.4074))

from dataclasses import dataclass

@dataclass
class City:
    name: str
    country: str
    population: float
    coordinates: tuple

beijing = City("Beijing", "CN", 22.596, (39.9042, 116.4074))

print(beijing)
# City(name='Beijing', country='CN', population=22.596, coordinates=(39.9042, 116.4074))

print(beijing.population)
# 22.596

print(beijing.coordinates)
# (39.9042, 116.4074)

from dataclasses import dataclass

@dataclass(order=True)
class City:
    name: str
    country: str
    population: float
    coordinates: tuple

beijing = City("Beijing", "CN", 22.596, (39.9042, 116.4074))
shanghai = City("Shanghai", "CN", 26.317, (31.2304, 121.4737))

print(beijing < shanghai)
# True

from dataclasses import dataclass

@dataclass
class City:
    name: str
    country: str = "CN"
    population: float = 0.0
    coordinates: tuple = (0.0, 0.0)

beijing = City("Beijing")
print(beijing)
# City(name='Beijing', country='CN', population=0.0, coordinates=(0.0, 0.0))

from dataclasses import dataclass

@dataclass(frozen=True, order=True)
class City:
    name: str
    country: str
    population: float
    coordinates: tuple

beijing = City("Beijing", "CN", 22.596, (39.9042, 116.4074))

try:
    beijing.population = 23.0
except Exception as e:
    print(e)
# cannot assign to field 'population'

from typing import NamedTuple

class City(NamedTuple):
    name: str
    country: str
    population: float
    coordinates: tuple
    __defaults__ = ("CN", 0.0, (0.0, 0.0))

beijing = City("Beijing", "CN", 22.596, (39.9042, 116.4074))
shanghai = City("Shanghai", "CN", 26.317, (31.2304, 121.4737))

# 打印实例
print(beijing)
# City(name='Beijing', country='CN', population=22.596, coordinates=(39.9042, 116.4074))

# 比较大小
print(beijing < shanghai)
# True

# 尝试修改属性（会报错）
try:
    beijing.population = 23.0
except Exception as e:
    print(e)
# can't set attribute

from dataclasses import dataclass, field

@dataclass
class City:
    name: str
    country: str = field(default="CN", metadata={"description": "Country code"})
    population: float = field(default=0.0, metadata={"description": "Population in millions"})
    coordinates: tuple = field(default=(0.0, 0.0), metadata={"description": "Latitude and Longitude"})

beijing = City("Beijing")
print(beijing)
# City(name='Beijing', country='CN', population=0.0, coordinates=(0.0, 0.0))

# 获取字段的元数据
for field_name, field_def in City.__dataclass_fields__.items():
    print(f"Field: {field_name}")
    print(f"  Default: {field_def.default}")
    print(f"  Metadata: {field_def.metadata}")
    print()
# Field: name
#   Default: <dataclasses._MISSING_TYPE object at 0x7f37b8138560>
#   Metadata: {}

# Field: country
#   Default: CN
#   Metadata: {'description': 'Country code'}

# Field: population
#   Default: 0.0
#   Metadata: {'description': 'Population in millions'}

# Field: coordinates
#   Default: (0.0, 0.0)
#   Metadata: {'description': 'Latitude and Longitude'}