python基础进阶（万字长文不适合零基础）

目录：lambda函数，迭代器，生成器，装饰器，闭包，文件，常用函数，字符编码与解码：理解内码和字节码的概念

1.Lambda函数：

Lambda函数是Python中一种匿名函数（anonymous function）的表示方式，可以用来创建简单的函数操作。

Lambda函数的基本语法如下：

lambda arguments: expression

其中，arguments 是函数的参数，expression 是函数的返回值。Lambda函数可以包含一个或多个表达式，但只能包含一个表达式。

下面是一个简单的例子，展示了如何使用 Lambda 函数：

# 定义一个Lambda函数，用于计算两个数的和  
add = lambda x, y: x + y  
  
# 调用Lambda函数  
result = add(3, 5)  
print(result)  # 输出 8

在上面的例子中，我们定义了一个 Lambda 函数 add，它接受两个参数 x 和 y，并返回它们的和。然后我们调用这个 Lambda 函数，将 3 和 5 作为参数传递给它，并将返回值存储在 result 变量中。最后，我们打印出 result 的值，输出结果为 8。

2.迭代器

迭代器是一种设计模式，它允许你遍历一个集合的所有元素而不需要知道集合的底层表示方法。Python 中的迭代器可以从集合的第一个元素开始访问，直到所有的元素被访问完结束。

迭代器只能往前不会后退。

在 Python 中，你可以通过以下步骤创建和使用迭代器：

1. 定义一个类，并实现 __iter__() 和 __next__() 方法。
2. 在 __iter__() 方法中返回一个实例对象（通常就是迭代器对象本身）。
3. 在 __next__() 方法中返回迭代器的下一个值。当没有更多值可以返回时，应抛出 StopIteration 异常。

以下是一个简单的迭代器示例：

class MyIterator:  
    def __init__(self, start, end):  
        self.current = start  
        self.end = end  
  
    def __iter__(self):  
        return self  
  
    def __next__(self):  
        if self.current >= self.end:  
            raise StopIteration  
        value = self.current  
        self.current += 1  
        return value

使用这个迭代器：

it = MyIterator(0, 5)  
for i in it:  
    print(i)  # 输出 0 1 2 3 4
    print(it)#<__main__.MyIterator object at 0x000001845FF93FD0>

注意，当你使用 for 循环遍历一个对象时，Python 会自动调用该对象的 __iter__() 方法，并将返回的对象存储在 for 循环的变量中。然后，在每次循环迭代时，Python 会自动调用该对象的 __next__() 方法，直到抛出 StopIteration 异常为止。

1. class MyIterator: - 定义一个名为 MyIterator 的新类。
2. def init(self, start, end): - 这是类的初始化方法，当你创建这个类的一个实例时，这个方法会被自动调用。它接受两个参数：start 和 end，分别表示迭代器要遍历的起始和结束值。
3. self.current = start - 在类的实例中创建一个名为 current 的属性，并将其初始值设置为 start。这个属性将用来存储当前迭代的值。
4. self.end = end - 在类的实例中创建一个名为 end 的属性，并将其初始值设置为 end。这个属性表示迭代的结束值。
5. def iter(self): - 这是迭代器协议的一部分，它定义了如何迭代这个对象。当一个对象需要被迭代时（例如在 for 循环中使用它），Python 会自动调用这个方法。
6. return self - 在这个方法中，我们返回当前对象（即 self）本身。这样，我们可以使用 for 循环遍历这个对象。
7. def next(self): - 这是迭代器协议的另一部分，每次调用这个方法时，它都会返回下一个值，直到没有更多的值可以返回为止。
8. if self.current >= self.end: - 检查当前的值是否已经达到或超过结束值。
9. raise StopIteration - 如果当前值已经达到或超过结束值，则抛出一个 StopIteration 异常，表示迭代已经结束。
10. value = self.current - 将当前的值存储在局部变量 value 中。
11. self.current += 1 - 将当前的值增加 1，为下一次迭代做准备。
12. return value - 返回当前的值。

13.<: 表示这是一个对象。

14.main.MyIterator: 这是对象的类型。main 是模块的名称，而 MyIterator 是该模块中的一个类。

15.object at 0x000001845FF93FD0: 这表示对象的内存地址。在Python中，每个对象都有一个与之关联的内存地址，这通常用于调试和异常跟踪。

所以，这个输出表示你有一个名为 MyIterator 的类的一个实例对象，它在内存中的地址是 0x000001845FF93FD0。

3.生成器

生成器是Python中一种特殊的迭代器，它允许你创建可迭代的数据流，而不是一次性生成所有数据。生成器在内存使用方面非常高效，因为它们只存储生成下一个值所需的最小信息。

下面是一些生成器的基本用法：

1. 使用yield关键字定义生成器函数：

def my_generator():  
    yield 1  
    yield 2  
    yield 3

1. 使用next()函数获取生成器的下一个值：

gen = my_generator()  
print(next(gen))  # 输出 1  
print(next(gen))  # 输出 2  
print(next(gen))  # 输出 3  
print(next(gen))  # 抛出 StopIteration 异常

1. 使用for循环遍历生成器：

gen = my_generator()  
for value in gen:  
    print(value)  # 输出 1 2 3

1. 使用生成器表达式创建生成器：

生成器表达式类似于列表推导式，但使用圆括号而不是方括号。它们可以用于创建简单的生成器。

squares = (x**2 for x in range(10))  
for square in squares:  
    print(square)  # 输出 0 1 4 9 16 25 36 49 64 81

1. 使用iter()函数将可迭代对象转换为生成器：

你可以使用iter()函数将任何可迭代对象（如列表、元组、字符串等）转换为生成器。

my_list = [1, 2, 3]  
gen = iter(my_list)  
print(next(gen))  # 输出 1  
print(next(gen))  # 输出 2  
print(next(gen))  # 输出 3  
print(next(gen))  # 抛出 StopIteration 异常

3.1生成器和迭代器之间的区别

生成器和迭代器在Python中都用于处理可迭代对象，但它们有一些不同之处。

相同点：

1. 生成器和迭代器都是用于遍历集合元素的对象。
2. 生成器和迭代器都支持next()方法，用于获取下一个元素。

不同点：

1. 语法：生成器是通过函数的形式，使用yield关键字创建的。而迭代器可以通过iter()内置函数，使用for循环或next()方法创建。
2. 用法：生成器在调用next()函数或for循环中，所有过程被执行，且返回值。而迭代器在调用next()函数或for循环中，所有值被返回，没有其他过程或动作。
3. 状态：生成器不仅“记住”了它的数据状态，还记住了程序执行的位置。当生成器被第二次调用时，它会从上次挂起的位置继续执行。而迭代器只包含一个数据流，不能记住之前的状态。
4. 内存使用：生成器非常适合处理大数据集，因为它们只生成每个值一次，然后立即丢弃，这有助于节省内存。而迭代器会一次性加载整个数据集到内存中。
5. 可重复性：生成器只能遍历一次，不能重复使用。而迭代器可以多次遍历。

3.2yield关键字

yield 是 Python 中的一个关键字，主要用于定义生成器函数。生成器函数是一种特殊类型的函数，它返回一个生成器对象。生成器函数的特点是它们使用 yield 语句来返回值，而不是使用 return 语句。

当生成器函数被调用时，它返回一个迭代器，该迭代器可以记住函数的位置和状态。每次从生成器获取值时，它都会执行到下一个 yield 语句，并返回该语句的值。然后，它可以被暂停并稍后恢复。

下面是一个简单的示例，展示了如何使用 yield 定义一个生成器函数：

def my_generator():  
    yield 1  
    yield 2  
    yield 3  
  
# 创建生成器对象  
gen = my_generator()  
  
# 获取生成器的值  
print(next(gen))  # 输出 1  
print(next(gen))  # 输出 2  
print(next(gen))  # 输出 3  
print(next(gen))  # 抛出 StopIteration 异常，因为所有值都已生成

除了在生成器函数中使用 yield 外，yield 还经常与异步编程和协程一起使用。在异步编程中，yield 可以用于暂停和恢复协程的执行，直到满足某些条件或发生某种事件。这种用法通常与 async/await 关键字一起使用。

4.装饰器

在Python中，装饰器是一种特殊的函数，它可以用来修改或增强其他函数的行为。装饰器本质上是一个接受函数对象作为参数，并返回一个新的函数对象的可调用对象（通常是函数或类）。

要使用装饰器，需要先定义一个装饰器函数，该函数接受一个函数对象作为参数，并返回一个新的函数对象。这个新的函数对象可以调用原来的函数，并在调用前后添加额外的逻辑。

下面是一个简单的示例，演示了如何使用装饰器来计算函数的执行时间：

import time  
  
def timer_decorator(func):  
    def wrapper(*args, **kwargs):  
        start_time = time.time()  
        result = func(*args, **kwargs)  
        end_time = time.time()  
        print(f"{func.__name__} 执行时间：{end_time - start_time} 秒")  
        return result  
    return wrapper  
  
@timer_decorator  
def my_function():  
    time.sleep(2)  # 模拟耗时操作  
    print("函数执行完毕")  
  
my_function()

在上面的示例中，我们定义了一个名为 timer_decorator 的装饰器函数。该函数接受一个函数对象 func 作为参数，并返回一个新的函数对象 wrapper。在 wrapper 函数中，我们记录了函数的执行时间，并调用原来的函数。最后，我们将 timer_decorator 装饰器应用于 my_function 函数上，使其成为一个装饰后的函数。当我们调用 my_function() 时，实际上是调用了 wrapper() 函数，从而实现了计算函数执行时间的功能。

除了上述示例中的用法，装饰器还可以用于实现许多其他功能，如日志记录、权限控制、缓存等。它们是Python中一种非常强大的功能，可以帮助我们简化代码和提高代码的可维护性。

每行代码的解释：

1. import time：
   • 这行代码导入了Python的time模块，它提供了各种时间相关的函数。这里主要是为了使用time.time()来获取当前时间戳。
2. def timer_decorator(func):：
   • 这行代码定义了一个名为timer_decorator的装饰器函数，它接受一个函数对象func作为参数。装饰器函数是一个返回新函数的函数，这个新函数会调用原来的函数并可能对其行为进行修改。
3. def wrapper(*args, **kwargs):：
   • 这行代码定义了wrapper函数，它是timer_decorator返回的新函数。*args和**kwargs是用来接收任意数量的位置参数和关键字参数的。
4. start_time = time.time()：
   • 这行代码获取当前的时间戳，并赋值给变量start_time。这表示函数开始执行的时间。
5. result = func(*args, **kwargs)：
   • 这行代码调用传入的函数func，并将所有位置参数和关键字参数传递给它。然后，它将返回的结果赋值给变量result。
6. end_time = time.time()：
   • 这行代码再次获取当前的时间戳，并赋值给变量end_time。这表示函数执行结束的时间。
7. print(f"{func.__name__} 执行时间：{end_time - start_time} 秒")：
   • 这行代码计算函数的执行时间（即结束时间减去开始时间），然后使用字符串格式化打印出来。它会显示原始函数的名称和执行时间。
8. return result：
   • 这行代码返回原始函数的结果。注意，尽管我们在这里打印了执行时间，但原始函数的返回值仍然会被返回。
9. @timer_decorator：
   • 这是一个装饰器语法，它表示将timer_decorator装饰器应用于下面的函数。这样，当你调用被装饰的函数时，实际上是调用了装饰后的版本，它会在原始函数前后添加额外的逻辑（在这里是时间记录）。
10. def my_function():：
    • 这行代码定义了一个名为my_function的函数，这个函数在被调用时会执行其中的代码。
11. time.sleep(2)：

5.闭包

闭包（Closure）是计算机科学中一个重要的概念，在 Python 中也广泛应用。闭包可以使得函数内部的函数可以保留其所在函数的局部变量，即使其所在函数已经执行完毕。

下面是一个简单的 Python 闭包示例：

def outer_function(x):  
    def inner_function(y):  
        return x + y  
    return inner_function  
  
closure = outer_function(10)  #外包
print(closure(5))  # 输出 15

在上面的例子中，outer_function 是一个外部函数，它接受一个参数 x，并返回一个内部函数 inner_function。inner_function 接受一个参数 y，并返回 x + y。然后我们通过调用 outer_function(10) 来创建一个闭包，并将返回的内部函数赋值给 closure。最后我们通过调用 closure(5) 来调用这个闭包，并输出结果 15。

闭包的一个重要特性是它可以保留其所在函数的局部变量。在这个例子中，即使 outer_function 已经执行完毕，inner_function 仍然可以访问到 x 的值。这就是闭包的作用。

闭包在 Python 中有很多应用场景，比如高阶函数、装饰器、回调函数等。通过闭包，我们可以实现很多强大的功能，比如实现自己的数据结构、算法等。

模拟闭包进行测试：

def one(x):
    def two(y):
        return x+y
    return two#这里返回内包
test=one(15)
print(test(5))

6.文件

6.1打开文件

在Python中，可以使用内置的open()函数来打开文件。该函数需要指定要打开的文件名和模式（即打开文件的类型，如读取、写入等）。

以下是一个简单的示例，演示如何打开一个文本文件并读取其中的内容：

# 打开文件  
file = open('example.txt', 'r')  # 'r'表示读取模式  
  
# 读取文件内容  
content = file.read()  
  
# 关闭文件  
file.close()  
  
# 输出文件内容  
print(content)

在上面的示例中，open()函数使用'r'模式打开名为example.txt的文件。然后，使用read()方法读取文件的内容，并将其存储在content变量中。最后，使用close()方法关闭文件。

请注意，使用with语句可以更好地处理文件操作，因为它可以自动关闭文件，即使在处理文件时发生异常也是如此。以下是使用with语句的示例：

# 使用with语句打开文件  
with open('example.txt', 'r') as file:  
    # 读取文件内容  
    content = file.read()  
  
# 输出文件内容  
print(content)

在上面的示例中，使用with语句打开文件后，不需要显式调用close()方法关闭文件。当with块结束时，文件将自动关闭。

6.2文件基本方法

在Python中，文件的基本方法主要包括打开文件、读取文件内容、写入文件内容、关闭文件、移动文件指针、读取/写入行等。以下是一些基本方法的详细解释和使用示例：

1. 打开文件：使用open()函数打开文件，并指定模式（如读取模式'r'、写入模式'w'等）。

# 打开文件  
file = open('example.txt', 'r')  # 读取模式  
  
# 写入文件  
file = open('example.txt', 'w')  # 写入模式

1. 读取文件内容：使用read()方法读取整个文件的内容，或使用readline()按行读取文件内容。

# 读取整个文件内容  
file = open('example.txt', 'r')  
content = file.read()  
print(content)  
  
# 按行读取文件内容  
file = open('example.txt', 'r')  
lines = file.readlines()  
for line in lines:  
    print(line)

1. 写入文件内容：使用write()方法将内容写入文件。如果文件不存在，则会创建一个新文件；如果文件已经存在，则会覆盖原有内容。

# 写入文件内容  
file = open('example.txt', 'w')  
file.write('Hello, world!')

1. 关闭文件：使用close()方法关闭文件。关闭文件是一个好习惯，可以确保文件在使用完毕后被正确关闭，释放系统资源。也可以使用with语句自动关闭文件。

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

1. 移动文件指针：使用seek()方法可以改变文件的读取/写入位置。例如，将指针移动到文件的开头或末尾。

# 将指针移动到文件的开头或末尾  
file = open('example.txt', 'r+')  # 打开文件并可读写  
file.seek(0, 0)  # 将指针移动到文件的开头  
file.seek(0, 2)  # 将指针移动到文件的末尾

1. 读取/写入行：可以使用readline()或readlines()方法按行读取或写入文件内容。也可以使用writelines()方法将多行文本写入文件。

# 按行读取和写入文件内容  
with open('example.txt', 'r') as file:  
    lines = file.readlines()  # 按行读取文件内容  
    for line in lines:  
        print(line)  # 打印每一行的内容  
        # 将修改后的内容写回文件（这里只是一个示例，实际上直接使用write()方法更简单）  
        with open('example.txt', 'a') as file:  # 在原有内容的末尾追加新内容，而不是覆盖原有内容（'a'表示追加模式）  
            file.write('\n' + line)  # 在每一行的末尾添加换行符并追加到文件中

6.3文件内容迭代

在Python中，你可以通过几种方式迭代文件的每一行。最常用的是使用内置的 open() 函数以只读模式（如 ‘r’）打开文件，然后使用 for 循环来迭代文件的每一行。

以下是一个简单的示例：

# 打开文件  
with open('example.txt', 'r') as file:  
    # 文件内容迭代  
    for line in file:  
        print(line)  # 打印每一行的内容

在这个例子中，with open('example.txt', 'r') as file: 这行代码会打开名为 ‘example.txt’ 的文件，并以只读模式读取。for line in file: 这行代码会迭代文件的每一行，并将每一行赋值给变量 line。然后，你可以对每一行进行操作，比如打印出来。

注意，print(line) 实际上会打印出每一行的内容，以及一个换行符。如果你想去掉这个换行符，你可以使用 print(line.strip())。

with 语句是一种很好的做法，因为它会自动关闭文件，即使在处理文件时发生异常也是如此。如果你不使用 with 语句，你需要记得在处理完文件后调用 file.close() 来关闭文件。

7常用标准库：

7.1 datetime

在Python中，datetime 是一个内置的模块，用于处理日期和时间。以下是datetime模块的一些基本使用方法：

1. 导入模块:

from datetime import datetime

1. 获取当前日期和时间:

now = datetime.now()  
print(now)

1. 格式化日期和时间:

from datetime import datetime
now = datetime.now()  
nowtime = now.strftime("%Y-%m-%d %H:%M:%S")  
print(nowtime)#2024-01-23 13:21:34

1. 解析日期和时间字符串:

dt_object = datetime.strptime("2023-07-05 12:34:56", "%Y-%m-%d %H:%M:%S")  
print(dt_object)

1. 日期和时间的算术运算:

from datetime import timedelta  
tomorrow = now + timedelta(days=1)  
print(tomorrow)  # 输出明天的日期和时间

1. 日期比较:

if now > datetime(2023, 7, 4):  
    print("Today is after July 4th, 2023")

1. 时间差:
   获取两个日期之间的时间差：

start_date = datetime(2023, 7, 1)  
end_date = datetime(2023, 7, 30)  
delta = end_date - start_date  
print(delta.days)  # 输出：29天

1. 使用dateutil.relativedelta进行相对日期和时间的计算:
   首先，你需要安装 dateutil 包。可以使用 pip install python-dateutil 进行安装。然后：

from dateutil.relativedelta import relativedelta  
print(relativedelta(2023, 7, 15, 12, 0, 0, tzinfo=None) - relativedelta(2023, 7, 1, 12, 0, 0, tzinfo=None))  # 输出：14天3小时0分钟0秒

1. 其他常用的方法:

• datetime.min: 表示最小的日期时间值。
• datetime.max: 表示最大的日期时间值。
• datetime.resolution: 表示模块所能表示的最小时间间隔。

1. 时区处理: datetime模块也支持时区处理，你可以使用pytz库来处理时区。例如：
   首先，安装pytz库：pip install pytz。然后：

from datetime import datetime, timezone, timedelta  
from pytz import FixedOffset, timezone as pytz_timezone  
tz = FixedOffset(5*60)

7.2 json

在Python中，json 是一个内置的模块，用于处理JSON数据。以下是json模块的一些基本用法：

1. 导入模块:

import json

1. 将Python对象转换为JSON字符串:

data = {  
    "name": "John",  
    "age": 30,  
    "city": "New York"  
}  
json_str = json.dumps(data)  
print(json_str)  # 输出: {"name": "John", "age": 30, "city": "New York"}

1. 将JSON字符串转换为Python对象:

json_str = '{"name": "John", "age": 30, "city": "New York"}'  
data = json.loads(json_str)  
print(data)  # 输出: {'name': 'John', 'age': 30, 'city': 'New York'}

1. 写入JSON文件:

with open('data.json', 'w') as file:  
    json.dump(data, file)

1. 读取JSON文件:

with open('data.json', 'r') as file:  
    data = json.load(file)  
print(data)  # 输出: {'name': 'John', 'age': 30, 'city': 'New York'}

1. JSON编码/解码时的特殊数据类型处理:

• 对于编码（dumps）操作，json模块提供了几个可选的参数来控制序列化的行为，如sort_keys、indent等。例如：

json_str = json.dumps(data, indent=4, sort_keys=True)  # 格式化输出，缩进4个空格，按键排序  
print(json_str)  # 输出: {   "age": 30,   "city": "New York",   "name": "John"}

• 对于解码（loads）操作，如果JSON字符串中的数据类型与Python对象不匹配，会抛出json.JSONDecodeError异常。例如：

invalid_json_str = '{"age": "thirty", "name": "John"}'  # age的值是字符串而不是数字  
try:  
    data = json.loads(invalid_json_str)  
except json.JSONDecodeError as e:  
    print(e)  # 输出: Expecting value: line 1 column 1 (char 0)

7.3 math

在Python中，math模块提供了很多数学函数和常数，可以进行各种数学运算。下面是一些常见的用法和实例：

1. 导入模块：

python复制代码

import math

1. 常用函数和常数：

• math.pi：圆周率π的值。
• math.e：自然对数的底数e的值。
• math.sin(x)：返回x的正弦值。
• math.cos(x)：返回x的余弦值。
• math.tan(x)：返回x的正切值。
• math.log(x[, base])：返回x的自然对数（底数为e）。如果提供了第二个参数，则返回x的以该参数为底的对数。
• math.sqrt(x)：返回x的平方根。
• math.pow(x, y)：返回x的y次方的值。
• math.ceil(x)：返回大于或等于x的最小整数。
• math.floor(x)：返回小于或等于x的最大整数。

1. 三角函数计算：
   实例：计算sin、cos和tan的函数值。

import math  
  
x = math.radians(45)  # 将角度转换为弧度  
print(f"sin({x}) = {math.sin(x)}")  
print(f"cos({x}) = {math.cos(x)}")  
print(f"tan({x}) = {math.tan(x)}")

输出结果为：

sin(0.7853981633974483) = 0.7071067811865476  
cos(0.7853981633974483) = 0.7071067811865476  
tan(0.7853981633974483) = 1.0

1. 对数函数计算：
   实例：计算以10为底的对数。

import math  
  
x = 1000  
print(f"log_{10}({x}) = {math.log10(x)}")

输出结果为：

log_{10}(1000) = 3.0

1. 幂函数计算：
   实例：计算2的3次方。

import math  
  
print(f"2^{3} = {math.pow(2, 3)}")

输出结果为：

makefile复制代码

2^{3} = 8.0

7.4 os

在Python中，os模块是一个非常重要的模块，它提供了许多与操作系统交互的功能。下面是一些常见的os模块的用法和实例：

1. 获取当前工作目录：
   使用os.getcwd()函数可以获取当前工作目录的路径。

实例：

import os  
  
current_directory = os.getcwd()  
print(current_directory)

输出结果为当前工作目录的路径。

2. 改变当前工作目录：

使用os.chdir()函数可以改变当前工作目录。

实例：

import os  
  
os.chdir("/home/user/documents")  
print(os.getcwd())  # 输出 "/home/user/documents"

1. 创建目录：
   使用os.makedirs()函数可以递归地创建目录。

实例：

import os  
  
os.makedirs("path/to/new/directory")

1. 删除目录：
   使用os.removedirs()函数可以递归地删除目录。如果目录为空，则删除该目录并向上移动到上一级目录，直到非空目录为止。

实例：

import os  
  
os.removedirs("path/to/directory")

1. 列出目录内容：
   使用os.listdir()函数可以列出指定目录下的所有文件和子目录。

实例：

import os  
  
files = os.listdir("/home/user/documents")  
print(files)  # 输出所有文件和子目录的名称列表。

1. 判断路径是否存在：
   使用os.path.exists()函数可以判断指定的路径是否存在。如果存在返回True，否则返回False。

实例：

import os  
  
if os.path.exists("path/to/file"):  
    print("文件存在")  
else:  
    print("文件不存在")

7.5 random

在Python中，random模块提供了各种随机数生成器和随机化函数。下面是一些常见的random模块的用法和实例：

1. 导入模块：

import random

1. 随机数生成器：
   使用random.random()函数可以生成一个0到1之间的随机浮点数。

实例：

import random  
  
random_number = random.random()  
print(random_number)  # 输出一个0到1之间的随机浮点数。

1. 随机整数生成器：
   使用random.randint(a, b)函数可以生成一个指定范围内的随机整数，包括a和b。

实例：

import random  
  
random_integer = random.randint(1, 100)  
print(random_integer)  # 输出一个1到100之间的随机整数。

1. 随机选择列表中的一个元素：
   使用random.choice()函数可以从列表中随机选择一个元素。

实例：

import random  
  
my_list = [1, 2, 3, 4, 5]  
random_element = random.choice(my_list)  
print(random_element)  # 输出列表中的一个随机元素。

1. 打乱列表的顺序：
   使用random.shuffle()函数可以打乱列表的顺序。

实例：

import random  
  
my_list = [1, 2, 3, 4, 5]  
random.shuffle(my_list)  
print(my_list)  # 输出一个打乱顺序的列表。

这里给大家放松一下，写了个双色球中奖小游戏：

规律如下：

一等奖：投注号码与当期开奖号码全部相同（顺序不限，下同），即中奖；

二等奖：投注号码与当期开奖号码中的6个红色球号码相同，即中奖；

三等奖：投注号码与当期开奖号码中的任意5个红色球号码和1个蓝色球号码相同，即中奖；

四等奖：投注号码与当期开奖号码中的任意5个红色球号码相同，或与任意4个红色球号码和1个蓝色球号码相同，即中奖；

五等奖：投注号码与当期开奖号码中的任意4个红色球号码相同，或与任意3个红色球号码和1个蓝色球号码相同，即中奖；

六等奖：投注号码与当期开奖号码中的1个蓝色球号码相同，即中奖。

我的最后一位为蓝区：

import random  
from datetime import datetime
  
class Lottery:  
    def __init__(self):  
        pass  
      
    
      
    def get_user_guesses(self):  
        guessed_numbers = []  
        for i in range(1,7):    
            while True:  # 无限循环，直到满足退出条件    
                a = int(input(f"请输入第{i}个值,范围是1-33 "))    
                if 1 <= a <= 33:  # 如果输入值在范围内，退出循环    
                    guessed_numbers.append(a)    
                    break    
                else:  # 如果输入值不在范围内，提示用户并继续循环    
                    print("输入值过小或过大")    
        while True:  # 无限循环，直到满足退出条件    
            b = int(input("请输入第7个值,范围是1-16 "))    
            if 1 <= b <= 16:  # 如果输入值在范围内，退出循环    
                guessed_numbers.append(b)    
                break    
            else:  # 如果输入值不在范围内，提示用户并继续循环    
                print("输入值过小或过大")  
        print(f"您的号码是{guessed_numbers}")    
        return guessed_numbers  
      
    def produce_winning_numbers(self):  
        now = datetime.now()
        nowtime = now.strftime("%Y-%m-%d %H:%M:%S")
        self.winning_numbers = []  
        for i in range(6):    
            self.winning_numbers.append(random.randint(1, 34))    
        self.winning_numbers.append(random.randint(1, 17))
        print(f"{nowtime}的中奖号码是{self.winning_numbers}")
        return self.winning_numbers  
    
    def judge(self, user_guesses, winning_numbers):  
        count=0
        for i in range(0,5):
            for j in range(0,5):
                if user_guesses[i]==winning_numbers[j]:
                     count=count+1
        count1=0
        if user_guesses[-1]==winning_numbers[-1]:
            count1=count1+1
        if count==6 and count1 ==1:
            print("恭喜中了一等奖")
        elif count==6:
            print("恭喜中了二等奖")
        elif count==5 and count1==1:
            print("恭喜中了三等奖")
        elif count==4 and count1 ==1:
            print("恭喜中了四等奖")
        elif count==3 and count1==1:
            print("恭喜中了五等奖")
        elif count1==1:
            print("恭喜中了六等奖")
        else :
            print("抱歉,没有中奖")
      
    def play(self):  
        
        user_guesses = self.get_user_guesses()  
        self.produce_winning_numbers()  
        self.judge(user_guesses, self.winning_numbers)  
          
test = Lottery()  
test.play()

7.6 re

Python中的re模块是用于正则表达式操作的模块，提供了多种用于模式匹配和替换的功能。以下是re模块的一些常用方法和功能：

1. re.match(pattern, string)：从字符串的起始位置匹配正则表达式模式。
2. re.search(pattern, string)：在字符串中搜索匹配正则表达式模式的第一个位置。
3. re.findall(pattern, string)：在字符串中查找所有匹配正则表达式模式的子串，并返回一个包含所有匹配的列表。
4. re.split(pattern, string)：根据匹配正则表达式模式的子串分割字符串，并返回分割后的列表。
5. re.sub(pattern, repl, string)：在字符串中替换匹配正则表达式模式的子串。
6. re.escape(string)：将字符串中的特殊字符转义，使其能够作为正则表达式模式的一部分。
7. re.purge()：清除正则表达式缓存，用于在正则表达式模式发生改变时强制重新编译。

此外，正则表达式模式中可以使用元字符、量词和分组等语法来定义匹配规则。例如，可以使用\d+匹配一个或多个数字，[a-z]+匹配一个或多个小写字母，(ab)+匹配一个或多个"ab"，等等。

以下是几个个简单的示例，演示如何使用re模块来查找字符串中的所有数字：

import re  
  
text = "This is a sample text with numbers 123 and 456."  
numbers = re.findall(r'\d+', text)  
print(numbers)  # 输出: ['123', '456']

在上面的示例中，我们使用re.findall()方法查找字符串中所有匹配正则表达式模式\d+的子串，即所有数字。然后将匹配结果存储在列表中并打印出来。

匹配字符串中的所有字母和数字：

import re  
  
text = "This is a sample text with letters and numbers 123abc456."  
letters_digits = re.findall(r'[a-zA-Z0-9]+', text)  
print(letters_digits)  # 输出: ['This', 'is', 'a', 'sample', 'text', 'with', 'letters', 'and', 'numbers', '123abc456']

匹配字符串中的所有单词：

import re  
  
text = "This is a sample text with words."  
words = re.findall(r'\b\w+\b', text)  
print(words)  # 输出: ['This', 'is', 'a', 'sample', 'text', 'with', 'words']

匹配字符串中的所有电子邮件地址：

import re  
  
text = "Contact us at [email protected] or [email protected]."  
emails = re.findall(r'[\w\.-]+@[\w\.-]+\.\w+', text)  
print(emails)  # 输出: ['[email protected]', '[email protected]']

替换字符串中的所有数字为特定的文本：

import re  
  
text = "The price is $10 and the discount is $5 off."  
replaced_text = re.sub(r'\$\d+', 'xxxxx', text)  
print(replaced_text)  # 输出: 'The price is xxxxx and the discount is xxxxx off.'

分割字符串中的逗号分隔的列表：

import re  
  
text = "apple,banana,orange,grape"  
items = re.split(r',\s*', text)  
print(items)  # 输出: ['apple', 'banana', 'orange', 'grape']

7.7 sys

在Python中，sys 是一个内置模块，主要用于与Python解释器交互。它提供了一些变量和函数，用于访问解释器的参数和功能。下面是一些sys模块的常用功能和示例：

1. sys.argv：这是一个列表，包含了从命令行传递给Python脚本的参数。sys.argv[0]通常是脚本的名称，而后续的元素是按顺序排列的命令行参数。

示例：

import sys  
  
print(sys.argv)

运行上述脚本并传入参数：python script.py arg1 arg2 arg3，输出结果将是：['script.py', 'arg1', 'arg2', 'arg3']。

2. sys.exit()：这个函数用于退出Python程序。它接受一个可选的参数，表示退出状态。0通常表示正常退出，非零值表示异常退出。

示例：

import sys  
  
if some_error_condition:  
    sys.exit(1)  # 退出程序并返回状态码1

1. sys.path：这是一个列表，包含了Python解释器查找模块的路径。你可以向这个列表添加新的路径，使Python可以导入该路径下的模块。

示例：

import sys  
sys.path.append('/path/to/directory')  # 添加新的模块搜索路径

1. sys.stdin, sys.stdout, sys.stderr：这些是文件对象，分别代表标准输入、标准输出和标准错误流。你可以使用它们来读取从标准输入流（通常是键盘）读取数据，向标准输出流（通常是屏幕）写入数据，以及向标准错误流（通常是屏幕）写入错误信息。

示例：从标准输入读取一行数据：

import sys  
  
data = sys.stdin.readline()  # 从标准输入读取一行数据

1. sys.getsizeof()：这个函数返回对象（如字符串、列表、字典等）在内存中所占的字节数。

示例：

import sys  
  
x = [1, 2, 3]  # 创建一个列表对象x  
print(sys.getsizeof(x))  # 输出该对象在内存中所占的字节数

1. sys.version：这个变量包含了当前Python解释器的版本信息。它是一个字符串，格式为"版本号+编译日期"。例如，“3.8.5+”, “3.9.0a4+”, “3.9.0a5+”, “3.9.0a6+”, "3.9.0a6 (2021-04-08, 12:54:59) [GCC 9.3.0]"等。

7.8 time

在Python中，time模块提供了各种时间相关的函数。以下是一些常用的time模块的用法和示例：

1. time()：返回当前时间的时间戳，即从1970年1月1日00:00:00开始到现在的秒数。

示例：

import time  
  
current_time = time.time()  
print(current_time)

1. sleep(seconds)：使程序暂停指定的秒数。

示例：

import time  
  
time.sleep(2)  # 程序暂停2秒钟

1. localtime([seconds])：将时间戳转换为本地时间。如果没有给定参数，则返回当前时间的本地时间。

示例：

import time  
  
current_local_time = time.localtime()  # 获取当前本地时间  
print(current_local_time)

1. strftime(format[, t])：将本地时间格式化为字符串。format指定了输出的格式，可以使用各种格式化符号来表示日期和时间的各个部分。t参数是可选的，用于指定一个时间元组，而不是当前时间。

示例：

import time  
  
current_local_time = time.localtime()  # 获取当前本地时间  
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", current_local_time)  # 将时间格式化为"年-月-日 时:分:秒"的格式  
print(formatted_time)  # 输出类似于"2023-03-15 12:34:56"的字符串

1. mktime(t)：将本地时间元组转换为时间戳。与localtime()函数相反，它将时间元组转换为从1970年1月1日00:00:00开始到现在的秒数。

示例：

import time  
  
local_time = (2023, 3, 15, 12, 34, 56, 0, 78, -1)  # 指定一个本地时间元组  
timestamp = time.mktime(local_time)  # 将本地时间元组转换为时间戳  
print(timestamp)  # 输出类似于1679474996.0的浮点数，表示从1970年1月1日00:00:00开始到该时间的秒数（以小数点表示小数部分）

7.9 urlib

在Python中，urllib是一个用于处理URLs的库，提供了用于发送HTTP请求、下载网页内容等功能。下面是urllib库中一些常用函数的用法和示例：

1. urlopen(url, data=None, timeout=None)：打开一个URL，并返回一个响应对象。可以传递可选的data参数来发送POST请求，以及可选的timeout参数来设置超时时间。

示例：

import urllib.request  
  
response = urllib.request.urlopen("http://www.example.com")  
print(response.read())  # 读取响应内容

import urllib.request  
  
response = urllib.request.urlopen("http://www.baidu.com")  
print(response.read())  # 读取响应内容

部分输出：

js/components/guide_tips-d9e617f782.js":["components/guide_tips.ts"],"/js/components/login_guide-4fba3971ce.js":["components/login_guide.ts"],"/js/components/video-","card_side2.css"],"/css/recommand/init-c52228535a.css":["news_new/init.css","news_new/waterfall.css","news_new/custom_sui.css","news_new/hot_search.css","news_new/dialog.css"],"/css/ubase_sync-d600f57804.css?v=md5":["scrollbar_sync.css"],"/css/ubase-89d6b96e41.css?v=md5":["superui/superui.css","superui/dialog.css","superui/tips.css","superui/share.css","superui/scrollbar.css","superui/suggestion.css"],"/css/ubase_sync-d600f57804.css?v=md5":["superui/scrollbar_sync.css"]})\n;window._xman_speed=window._xman_speed||{};F._setContext({base:"lib/sbase"});F.use("lib/mod_evt",function(evt){F._setContextMethod("fire",function(evtName,evtArgs){return evt.fire(this.svnMod+":"+3ea684d5.js">

1. quote(s, safe='/' , encoding='utf-8', errors='strict')：对字符串进行URL编码。

示例：

import urllib.parse  
  
encoded_string = urllib.parse.quote("Hello, World!")  
print(encoded_string)  # 输出："Hello%2C+World%21"

1. unquote(s, encoding='utf-8', errors='replace')：对URL编码的字符串进行解码。

示例：

import urllib.parse  
  
decoded_string = urllib.parse.unquote("Hello%2C+World%21")  
print(decoded_string)  # 输出："Hello, World!"

1. quote_plus(s, safe='' , encoding='utf-8', errors='strict')：对字符串进行URL编码，并将空格转换为加号。

示例：

import urllib.parse  
  
encoded_string = urllib.parse.quote_plus("Hello, World!")  
print(encoded_string)  # 输出："Hello%2CP+World%21"

1. urlencode(query, doseq=False)：将一个查询参数的键值对列表转换为URL编码的字符串。如果doseq参数为True，则将列表视为键值对的序列，而不是单个键值对。

示例：

import urllib.parse  
  
params = [("key1", "value1"), ("key2", "value2")]  
encoded_params = urllib.parse.urlencode(params)  
print(encoded_params)  # 输出："key1=value1&key2=value2"

8.字符编码和解码：

在Python中，字符编码和解码是处理文本数据的重要步骤。Python提供了多种内置的编码和解码方法，以支持不同的字符编码格式。下面是一些常见的编码和解码方法及其示例：

1. 编码：将字符串转换为字节序列

示例：

# 定义一个字符串  
s = "Hello, World!"  
  
# 使用UTF-8编码将字符串转换为字节序列  
encoded_bytes = s.encode('utf-8')  
print(encoded_bytes)  # 输出：b'Hello, World!'

1. 解码：将字节序列转换为字符串

示例：

# 定义一个字节序列  
bytes = b"Hello, World!"  
  
# 使用UTF-8解码将字节序列转换为字符串  
decoded_string = bytes.decode('utf-8')  
print(decoded_string)  # 输出：'Hello, World!'

1. 使用open()函数进行编码和解码

示例：

# 打开一个文件，指定编码格式为UTF-8  
with open('file.txt', 'r', encoding='utf-8') as f:  
    # 读取文件内容并打印解码后的字符串  
    content = f.read()  
    print(content)  # 输出：'Hello, World!'

1. 使用io模块进行编码和解码

示例：

import io  
  
# 创建一个字节流对象，并写入字节序列  
bytes_stream = io.BytesIO(b"Hello, World!")  
  
# 将字节流对象解码为字符串并打印输出  
decoded_string = bytes_stream.read().decode('utf-8')  
print(decoded_string)  # 输出：'Hello, World!'

本文到这里就结束了，感谢大家查看。