Python包和模块

标签：Python re 模块 time print import data

Python包和模块

当使用Python编程时，包（Packages）和模块（Modules）是两个关键的概念，它们有助于组织、管理和复用代码。

1. 模块（Modules）

1.1 什么是模块

一个.py 文件就是一个模块

模块是含有一系列数据，函数，类等的程序

• 作用

  把相关功能的函数等放在一起有利于管理，有利于多人合作开发

• 模块的分类

  1. 内置模块（在python3 程序内部，可以直接使用）
  2. 标准库模块(在python3 安装完后就可以使用的 )
  3. 第三方模块（需要下载安装后才能使用）
  4. 自定义模块(用户自己编写)

  模块名如果要给别的程序导入，则模块名必须是 标识符

• 实例

## file: mymod.py
'''
小张写了一个模块，内部有两个函数，两个字符串
... 此处省略 200字
'''
name1 = 'audi'
name2 = 'tesla'

def mysum(n):
    '''
    此函数用来求和
    by weimingze
    '''
    print("正在计算， 1 + 2 + 3 + .... + n的和 ")

def get_name():
    return "tarena"

调用模块

## file: test_mod.py
## 小李写的程序，小李想调用 小张写的 mymod.py 里的两个函数和两个字符串

## 用import 语句导入模块
import mymod

print(mymod.name1)  # Audi
print(mymod.name2)    # tesla

mymod.mysum(100)  # 调用 mymod 模块里的 mysum 函数
print(mymod.get_name())   # 'tarena'

1.2 导入模块

• 语法

1. import 模块名  [as 模块新名字1]
   

   导入一个模块到当前程序

2. from 模块名 import 模块属性名 [as 属性新名]
   

   导入一个模块内部的部分属性到当前程序

3. from 模块名 import *
   

   导入一个模块内部的全部属性到当前程序

• 示例

  import mymod
  mymod.mysum(10)   # 要加模块名
  
  from mymod import get_name
  print(get_name())   # 调用get_name 时不需要加 "模块名."
  
  from mymod import *   
  print(get_name())
  print(name2)
  

• 模块的内部属性

  __file__  绑定模块的路径
  __name__  绑定模块的名称
         如果是主模块（首先启动的模块）则绑定 '__main__'
         如果不是主模块则 绑定 xxx.py 中的 xxx 这个模块名
  

• 示例

  见： test_mymod.py  和 mymod.py
  

• 模块的 __name__ 属性

  每个.py 模块文件都会有 __name__ 属性

  1. 当一个模块是最先运行的模块，则这个模块是主模块, 主模块的__name__ 属性绑定'__main__' 字符串

  2. 如果一个模块是用 三种 import 语句中的一个导入的模块，则此模块不是主模块。

     不是主模块的模块的 __name__ 绑定的 模块名

• 主模块 (__name__ == '__main__')： 当一个模块是直接运行的，即不是通过 import 语句导入的，那么它的 __name__ 属性会被赋值为 '__main__'。例如：

# main_module.py
if __name__ == "__main__":
    print("This is the main module.")

如果运行 python main_module.py，输出将是：

This is the main module.

• 被导入的模块 (__name__ == 模块名)： 当一个模块被导入到另一个模块中时，它的 __name__ 属性会被赋值为它的模块名。例如：

# imported_module.py
print(f"This module's name is {__name__}") # 被其他模块导入时会自动运行

# main_module.py
import imported_module

if __name__ == "__main__":
    print("This is the main module.")

如果运行 python main_module.py，输出将是：

This module's name is imported_module
This is the main module.

这里 imported_module.py 被导入到 main_module.py 中，所以它的 __name__ 是 'imported_module'，而 main_module.py 是直接运行的，所以它的 __name__ 是 '__main__'。

python 的第三方模块

https://pypi.org/

• 使用导入的模块中的函数、变量等，可以通过模块名或从语句中导入的名称来访问。

1.3 Python 常用的内建模块

1.3.1 random 模块

先引入random库基础库:

import random

函数	描述
random.choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
random.randrange (start, stop,step)	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random.random()	随机生成下一个实数，它在[0,1)范围内。
random.shuffle(list)	将序列的所有元素随机排序,修改原list
uniform(x, y)	随机生成实数，它在[x,y]范围内.

生成随机数

文档位置: https://docs.python.org/zh-cn/3/library/random.html

>>> import random
>>> random.randint(1, 6)  # random.randint(a,b) 生产 a~b的随机整数
3
>>> random.randint(1, 6)
4
>>> random.random()   # random.random  生成包含0 但不包含1 的浮点数
0.5884109388439075
>>> random.choice("ABCD")    # 从一个序列中，随机返回一个元素
'C'
>>> random.choice("ABCD")
'B'
>>> L = [1, 2, 3, 6, 9]
>>> random.choice(L)
6
>>> random.shuffle(L)   # random.shuffer(x)  # 把列表X 打乱
>>> L
[1, 6, 2, 9, 3]

• 课后练习

写一个程序， 生产6位由数字组成的随机密码

参考答案

import random

## 生成 n 位的数字密码
def get_random_password(n):
    r_str = ''
    for _ in range(n):
        r_str += str(random.randint(0, 9))
    return r_str

## 生成 n 位的数字和字母组成的密码
charactors = '0123456789abcdefghijklmnopqrstwuxyz'
def get_random_password2(n):
    r_str = ''
    for _ in range(n):
        r_str += random.choice(charactors)
    return r_str


print(get_random_password(6))
print(get_random_password(6))
import time
time.sleep(10)
print(get_random_password2(10))

1.3.2 time 模块

https://docs.python.org/zh-cn/3/library/time.html

时间戳:从 1970年1月1日 0:0:0 UTC 时间 开始计时到现在的秒数

UTC 时间 : 世界协调时间

struct_time 用 含有9个元素的元组来表示时间

>>> import time
>>> time.time()   # 返回当前时间的时间戳
1617117219.0382686
>>> time.ctime()    #返回当前的UTC 时间的字符串
'Tue Mar 30 23:14:48 2021'
>>> t1 = time.localtime()   # 返回当前的本地时间元组
>>> t1
time.struct_time(tm_year=2021, tm_mon=3, tm_mday=30, tm_hour=23, tm_min=18, tm_sec=22, tm_wday=1, tm_yday=89, tm_isdst=0)
>>> t1.tm_year
2021
>>> t1.tm_yday
89
>>> time.sleep(3)  # time.sleep(n)  # 让程序睡眠 n 秒
>>> time.strftime("%Y-%m-%d", t1)   # 格式化时间
'2021-03-30'
>>> time.strftime("%y-%m-%d", t1)
'21-03-30'
>>> time.strftime('%Y-%m-%d %H:%M:%S', t1)
'2021-07-21 17:37:41'
    # 用时间元组来创建一个自定义的时间
>>> t2 = time.struct_time ( (2021,1, 1, 10, 11, 20, 0, 0, 0) )

1.3.3 datetime 模块

https://docs.python.org/zh-cn/3/library/datetime.html

>>> import datetime
>>> d1 = datetime.datetime.now()  # 返回当前的时间
>>> d1
datetime.datetime(2021, 3, 30, 23, 32, 7, 342559)
>>> d1.year
2021
>>> d1.year, d1.month, d1.day, d1.hour, d1.minute, d1.second, d1.microsecond  # 用 datetime 的各个属性可以得到 具体的信息
(2021, 3, 30, 23, 32, 44, 757673)
>>> d1.strftime("%Y-%m-%d")
'2021-03-30'

## 计算时间差
>>> delta_time = datetime.timedelta(days=2, hours=1)  # 生成 2天1小时后的时间差
>>> delta_time
datetime.timedelta(2, 3600)
>>> t1 = datetime.datetime.now()  # 得到当前时间
>>> t1
datetime.datetime(2021, 3, 30, 23, 39, 26, 863109)
>>> t1 + delta_time  # 计算 未来时间
datetime.datetime(2021, 4, 2, 0, 39, 26, 863109)

1. 课后练习：

猜数字游戏: guess_number.py
随机生成一个0~100之间的一个整数，用变量x绑定
让用户输入一个数y,输出猜数字的结果，
    如果y等于生成的数x，则提示"恭喜你猜对了",并退出程序
    如果y大于x,则提示"您猜的数字大了"
    如果y小于x,则提示"您猜的数字小了"
直到猜对为止,显示用户猜数字的次数后退出程序.

import random

def guess_number():
    x = random.randint(0, 100)
    guess_count = 0
    
    while True:
        y = input("请输入一个0到100之间的数字: ")
        
        # 检查输入是否为数字
        if not y.isdigit():
            print("请输入一个有效的数字")
            continue
        
        y = int(y)
        guess_count += 1
        
        if y == x:
            print(f"恭喜你猜对了！你一共猜了 {guess_count} 次.")
            break
        elif y > x:
            print("您猜的数字大了")
        else:
            print("您猜的数字小了")

if __name__ == "__main__":
    guess_number()

2. 课后练习 2

随机生成一个6位数字组成的验证码!

1.3.4 os 模块

os 模块

os模块是Python标准库中的一部分，提供了一种与操作系统进行交互的方法。主要功能包括文件和目录的操作、路径处理、进程管理等。在使用os模块之前，我们需要先导入它：

import os

举例

#1. os.getcwd(): 获取当前工作目录
import os
current_directory = os.getcwd()
print("当前工作目录:", current_directory)

#2. os.chdir(path): 改变当前工作目录
import os
new_directory = "/path/to/new/directory"
os.chdir(new_directory)
print("工作目录已更改为:", os.getcwd())

#3. os.listdir(path='.'): 返回指定目录下的所有文件和目录列表
import os
directory_path = "."
files_and_dirs = os.listdir(directory_path)
print("指定目录下的文件和目录列表:", files_and_dirs)

#4. os.mkdir(path): 创建目录
import os
new_directory = "new_folder"
os.mkdir(new_directory)
print(f"目录 '{new_directory}' 已创建")

#5. os.rmdir(path): 删除目录
import os
directory_to_remove = "new_folder"
os.rmdir(directory_to_remove)
print(f"目录 '{directory_to_remove}' 已删除")

#6. os.remove(path): 删除文件
import os
file_to_remove = "example.txt"
os.remove(file_to_remove)
print(f"文件 '{file_to_remove}' 已删除")

os.path 模块

os.path 模块是 Python 标准库的一部分，专门用于处理文件和目录路径的操作。它提供了一系列函数，用于操作和处理文件路径，使得路径操作更加方便和跨平台。

#1.os.path.basename(path): 返回路径中最后的文件名或目录名
import os
path = "/path/to/some/file.txt"
print(os.path.basename(path))  # 输出: file.txt

#2.os.path.dirname(path): 返回路径中的目录部分
import os
path = "/path/to/some/file.txt"
print(os.path.dirname(path))  # 输出: /path/to/some

#3.os.path.join(*paths): 将多个路径合并成一个路径
import os
path1 = "/path/to"
path2 = "some/file.txt"
full_path = os.path.join(path1, path2)
print(full_path)  # 输出: /path/to/some/file.txt

#4.os.path.split(path): 将路径分割成目录和文件名
import os
path = "/path/to/some/file.txt"
print(os.path.split(path))  # 输出: ('/path/to/some', 'file.txt')

#5.os.path.splitext(path): 将路径分割成文件名和扩展名
import os
path = "/path/to/some/file.txt"
print(os.path.splitext(path))  # 输出: ('/path/to/some/file', '.txt')

#6.os.path.exists(path): 检查路径是否存在
import os
path = "/path/to/some/file.txt"
print(os.path.exists(path))  # 输出: True 或 False

#7.os.path.isfile(path): 检查路径是否是文件
import os
path = "/path/to/some/file.txt"
print(os.path.isfile(path))  # 输出: True 或 False

#8.os.path.isdir(path): 检查路径是否是目录
import os
path = "/path/to/some/directory"
print(os.path.isdir(path))  # 输出: True 或 False

2. 包（Packages）

2.1 包的定义和作用

定义

• 包是将模块以文件夹的组织形式进行分组管理的方法，以便更好地组织和管理相关模块。
• 包是一个包含一个特殊的__init__.py文件的目录，这个文件可以为空，但必须存在，以标识目录为Python包。
• 包可以包含子包（子目录）和模块，可以使用点表示法来导入。

作用

• 将一系列模块进行分类管理,有利于防止命名冲突
• 可以在需要时加载一个或部分模块而不是全部模块

包示例:

    mypack/
        __init__.py
        menu.py            # 菜单管理模块
        games/
            __init__.py
            contra.py      # 魂斗罗
            supermario.py  # 超级玛丽 mario
            tanks.py       # 坦克大作战
        office/
            __init__.py
            excel.py
            word.py
            powerpoint.py

2.2 导入包和子包

• 使用import关键字可以导入包和子包，以访问其中的模块和内容。

    # 同模块的导入规则
    import 包名 [as 包别名]
    import  包名.模块名 [as 模块新名]
    import  包名.子包名.模块名 [as 模块新名]
    
    from 包名 import 模块名 [as 模块新名]
    from 包名.子包名 import 模块名 [as 模块新名]
    from 包名.子包名.模块名 import 属性名 [as 属性新名]
    
    # 导入包内的所有子包和模块
    from 包名 import *
    from 包名.模块名 import *

参考案例：

# 导入包中的模块
import matplotlib.pyplot as plt

# 导入子包中的模块
from sklearn.linear_model import LinearRegression

2.3 使用包和子包

• 使用导入的包和模块的内容，可以通过包名和点表示法来访问。

参考案例：

# 使用包中的模块
import pandas as pd
data_frame = pd.DataFrame()

# 使用子包中的模块
from tensorflow.keras.layers import Dense

2.4 __init__.py文件

__init__.py 文件的主要作用是用于初始化Python包（package）或模块（module），它可以实现以下功能：

1. 标识包目录： 告诉Python解释器所在的目录应被视为一个包或包含模块的包。没有这个文件，目录可能不会被正确识别为包，导致无法导入包内的模块。
2. 执行初始化代码： 可以包含任何Python代码，通常用于执行包的初始化操作，如变量初始化、导入模块、设定包的属性等。这些代码在包被导入时会被执行。
3. 控制包的导入行为： 通过定义 __all__ 变量，可以明确指定哪些模块可以被从包中导入，从而限制包的公开接口，防止不需要的模块被导入。
4. 提供包级别的命名空间： __init__.py 中定义的变量和函数可以在包的其他模块中共享，提供了一个包级别的命名空间，允许模块之间共享数据和功能。
5. 批量导入模块： 可以在 __init__.py 文件中批量导入系统模块或其他模块，以便在包被导入时，这些模块可以更方便地使用。

以下是一个简单的 __init__.py 文件的代码示例，演示了上述功能的使用：

# __init__.py 文件示例

# 1. 批量导入系统模块
import os
import sys
import datetime

# 2. 定义包级别的变量
package_variable = "This is a package variable"

# 3. 控制包的导入行为
__all__ = ['module1', 'module2']

# 4. 执行初始化代码
print("Initializing mypackage")

# 注意：这个代码会在包被导入时执行

# 5. 导入包内的模块
from . import module1
from . import module2

在这个示例中，__init__.py 文件用于批量导入系统模块、定义包级别的变量、控制包的导入行为、执行初始化代码，以及导入包内的模块。这有助于包的组织、初始化和导入管理。

3. 第三方包

​ Python第三方包是由Python社区开发的，可用于扩展Python功能和解决各种问题的软件包。这些包提供了各种各样的功能，包括数据分析、机器学习、网络编程、Web开发、图形处理、自然语言处理等。

3.1 安装和使用

1. 使用pip：pip是Python的包管理工具，用于安装、升级和管理第三方包。确保你的Python安装中包含了pip。

2. 安装第三方包：

   • 使用pip安装包：在命令行中运行以下命令来安装包，将"package-name"替换为要安装的包的名称。

     pip install package-name
     
     

   • 安装特定版本的包：如果你需要安装特定版本的包，可以使用以下命令：

     pip install package-name==version
     
     

   • 通过镜像安装，可以使用以下命令：

     pip install -i https://pypi.tuna.tsinghua.edu.cn/simple package1 package2 package3 ...
     
     

   • 从requirements文件安装：你可以将要安装的包及其版本记录在一个文本文件中，通常命名为requirements.txt，然后运行以下命令安装其中列出的所有包：

     pip install -r requirements.txt
      
     

3. 导入包：在Python脚本或交互式环境中，使用import语句导入已安装的包，以便在代码中使用它们。

   import package_name
   

4. 使用包：每个第三方包都有不同的用法和功能，通常伴随着官方文档和示例代码。你可以查阅官方文档，或者使用help()函数来了解包的功能和方法。示例：

   import package_name
   help(package_name)
   

5. 更新和卸载包：

   • 更新包：使用以下命令来更新已安装的包：

     pip install --upgrade package-name
     
     

   • 卸载包：如果你想卸载包，可以使用以下命令：

     pip uninstall package-name
     

3.2 依赖清单

可以使用pipreqs来维护requirements.txt文件，以便轻松地重建环境。

pipreqs是一个用于管理Python项目依赖清单的工具，它会自动分析项目代码，并生成requirements.txt文件，列出项目所需的所有依赖包及其版本。以下是使用pipreqs管理依赖清单的步骤：

安装pipreqs：

如果你还没有安装pipreqs，可以使用pip安装它(比较慢,可能会丢包)：

pip install pipreqs   

在项目目录中运行pipreqs：

进入你的项目目录，然后运行以下命令：

pipreqs .

这会分析项目代码，并在当前目录下生成一个名为requirements.txt的文件，其中包含了项目所需的所有依赖包及其版本。

如果遇到编码错误UnicodeDecodeError，则将指定编码为utf8：

pipreqs ./ --encoding=utf8
pipreqs ./ --encoding=gbk
pipreqs ./ --encoding='iso-8859-1' 

查看生成的requirements.txt文件：

打开requirements.txt文件，你将看到列出的依赖包及其版本，类似于以下内容：

package1==1.0.0
package2==2.1.3
...

选择是否要修改requirements.txt文件：

pipreqs生成的requirements.txt文件可能包含一些不必要的依赖，或者可能需要手动指定特定版本。

你可以编辑requirements.txt文件，根据项目的需要添加、删除或修改依赖项。

1. 安装依赖：

   一旦你准备好了requirements.txt文件，你可以使用pip来安装项目的依赖：

   pip install -r requirements.txt
   
   

2. 定期更新依赖：

   定期使用pipreqs重新生成requirements.txt文件，以确保依赖清单保持最新。你可以使用以下命令：

   pipreqs .
   
   

​ pipreqs是一个方便的工具，它可以帮助你自动创建和维护项目的依赖清单。不过，需要记住，生成的依赖清单可能包含一些不必要的依赖，因此你应该仔细检查和编辑requirements.txt文件以确保它反映了项目的真实需求。

​ Python的包和模块是组织、管理和重用代码的重要工具。它们有助于将代码划分为可管理的单元，提高了代码的可读性和可维护性。通过模块和包，你可以更有效地组织项目，减少命名冲突，以及在不同项目之间重用代码，从而更轻松地进行Python编程。通过上述参考案例，你可以更好地理解如何在实际项目中应用这些概念。

Python异常

• 作用

  用作信号通知，通知上层调用者有错误产生需要处理

1. try 语句

• 语法

try:
    可能发生异常的语句块
except 错误类型1 [as 变量名1]:
    异常处理语句块1
except 错误类型2 [as 变量名2]:
    异常处理语句块2
...
except 错误类型n [as 变量名n]:
    异常处理语句块n
except:
    异常处理语句块other
else:
    未发生异常的语句
finally:
    最终的处理语句

• 作用

  尝试捕获异常，得到异常通知，将程序由异常状态变为正常状态

• 说明

  except 子句可以有 1个或多个

  except: 不给错误类型，可以匹配全部的错误类型

  else 子句里的语句会在 没有错误发生时执行，当处于异常时不执行

  finally 子句里的语句，无论何时都执行

• 示例

try:
    x = int(input("请输入一个整数："))
    print('x=', x)
except ValueError:
    print('您的输入不能转成整数')

print("程序结束")

2. raise 语句

• 问题

  # 写一个函数, get_score 函数，读取用户输入的整数成绩, 
  # 成绩的正常值是0~100 之间， 要求, 如果不在0~100 之间
  # 报 ValueError类型的错误
  def get_score():
      x = int(input('请输入成绩:'))
      if 0 <= x <= 100:
          return x
      raise ValueError
      
  

• 语法

  raise 异常类型
  或
  raise 异常对象
  

• 作用

  • 抛出一个错误，让程序进入异常状态
  • 发送错误通知给调用者

• 示例:

## 写一个函数, get_score 函数，读取用户输入的整数成绩,
## 成绩的正常值是0~100 之间， 要求, 如果不在0~100 之间
## 报 ValueError类型的错误
def get_score():
    x = int(input('请输入成绩:'))
    if 0 <= x <= 100:
        return x
    # raise ValueError
    raise ValueError('用户输入的成绩不在 0～100 之间')

try:
    score = get_score()
    print(score)
except ValueError as err:
    print("成绩输入有误 err=", err)

err的作用就是接收raise ValueError(‘用户输入的成绩不在 0～100 之间’)给出的提示信息

• 异常类型的可选种类

  详见：

  >>> help(__builtins__)
  

• 课后练习1

  写一个猜拳游戏: 石头，剪刀，布， 
  让电脑随机生成一个，
  你的输入如下:
      0)  石头
      1)  剪刀
      2)  布
      q)  退出
      请选择: 0
     电脑出的是 布 ，你输了
  循环输入，知道输入q 为止
  

  参考答案1

  import random
  import time
  
  signal = ['石头', '剪刀', '布']
  
  def show_menu():
      print(" 0)  石头 ")
      print(" 1)  剪刀 ")
      print(" 2)  布  ")
      print(" q)  退出 ")
  
  def begin_compare(computer, your):
      comp_s = signal[computer]  # 电脑的字符串
      your_s = signal[your]
      print('电脑出的是', comp_s, '你出的是', your_s)
      if comp_s == your_s:
          print('平局！')
      elif comp_s == '石头':
          if your_s == '剪刀':
              print('你输了！')
          elif your_s == '布':
              print('你赢了！')
      elif comp_s == '剪刀':
          if your_s == '布':
              print('你输了！')
          elif your_s == '石头':
              print('你赢了！')
      elif comp_s == '布':
          if your_s == '石头':
              print('你输了！')
          elif your_s == '剪刀':
              print('你赢了！')
      # time.sleep(5)
      input('请输入回车键，继续下一次猜拳:')
  
  def run():
      '''开始猜拳游戏'''
      while True:
          show_menu()
          s = input('请选择:')
          if s == 'q':
              break
          your = int(s)  # 你的选项
          computer = random.randint(0, 2)
          begin_compare(computer, your)
  
  
  if __name__ == '__main__':
      run()
  

  参考答案2

  import random
  import time
  
  signal = ['石头', '剪刀', '布']
  result = ['平局！', '你赢了！', '你输了！']
          #   0         1          -1
  
  # 定义一个二维列表， 行代表 电脑的选择， 列代表我的选择
  map = [
    # 用户: 0  1  2
      [ 0, -1,  1],  # 电脑出的是0---> 石头
      [ 1,  0, -1],  # 电脑出的是1---> 剪刀
      [-1,  1,  0],  # 电脑出的是2---> 布
  ]
  
  def show_menu():
      print(" 0)  石头 ")
      print(" 1)  剪刀 ")
      print(" 2)  布  ")
      print(" q)  退出 ")
  
  def begin_compare(computer, your):
      comp_s = signal[computer]  # 电脑的字符串
      your_s = signal[your]
      print('电脑出的是', comp_s, '你出的是', your_s)
      result_index = map[computer][your]
      r = result[result_index]
      print(r)
      # time.sleep(5)
      input('请输入回车键，继续下一次猜拳:')
  
  def run():
      '''开始猜拳游戏'''
      while True:
          show_menu()
          s = input('请选择:')
          if s == 'q':
              break
          your = int(s)  # 你的选项
          computer = random.randint(0, 2)
          begin_compare(computer, your)
  
  
  if __name__ == '__main__':
      run()
  

• 课后练习2

  写一个猜数字游戏 让电脑随机生成一个 0 ~ 100 的整数让用来猜
  如果 您输入的数大于电脑生产的数，提示：“您猜大了”， 继续猜
  如果 您输入的数小于电脑生产的数，提示：“您猜小了”， 继续猜
  当 您输入的数等于电脑生产的数，提示："恭喜您猜对了" 打印猜的次数后退出程序
  

  参考答案

  import random
  
  def run():
      # 1. 让电脑生成一个整数，用 x 变量绑定
      x = random.randint(0, 100)
      count = 0  # 记次数
      while True:
          y = int(input('请输入: '))
          count += 1
          if y > x:
              print('您猜大了！')
          elif y < x:
              print('您猜小了！')
          else:
              print('恭喜您猜对了！')
              break
      print('您共猜了', count, '次')
  
  if __name__ == '__main__':
      run()
  

3.Python全部的错误类型

错误类型	说明
ZeroDivisionError	除(或取模)零 (所有数据类型)
ValueError	传入无效的参数
AssertionError	断言语句失败
StopIteration	迭代器没有更多的值
IndexError	序列中没有此索引(index)
IndentationError	缩进错误
OSError	输入/输出操作失败
ImportError	导入模块/对象失败
NameError	未声明/初始化对象 (没有属性)
AttributeError	对象没有这个属性
GeneratorExit	生成器(generator)发生异常来通知退出
TypeError	对类型无效的操作
KeyboardInterrupt	用户中断执行(通常是输入^C)
OverflowError	数值运算超出最大限制
FloatingPointError	浮点计算错误
BaseException	所有异常的基类
SystemExit	解释器请求退出
Exception	常规错误的基类
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
EOFError	没有内建输入,到达EOF 标记
EnvironmentError	操作系统错误的基类
WindowsError	系统调用失败
LookupError	无效数据查询的基类
KeyError	映射中没有这个键
MemoryError	内存溢出错误(对于Python 解释器不是致命的)
UnboundLocalError	访问未初始化的本地变量
ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError	一般的运行时错误
NotImplementedError	尚未实现的方法
SyntaxError Python	语法错误
TabError	Tab 和空格混用
SystemError	一般的解释器系统错误
UnicodeError	Unicode 相关的错误
UnicodeDecodeError	Unicode 解码时的错误
UnicodeEncodeError	Unicode 编码时错误
UnicodeTranslateError	Unicode 转换时错误
以下为警告类型
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告

详见：help(builtins)

课后练习

写一个函数 get_age() 用来获取一个人的年龄信息
    此函数规定用户只能输入1~140之间的整数，如果用户输入其它的数则直接触发ValueError类型的错误！

def get_age():
    ...
try:
    age = get_age()
    print("用户输入的年龄是:", age)
except ValueError as err:
    print("用户输入的不是1~140的整数，获取年龄失败!")

参考答案

def get_age():
    age = int(input('请输入: '))
    if age < 0 or age > 140:
        raise ValueError("年龄范围错误")
    return age

Python文件操作

文件操作是Python中常见的任务之一，用于创建、读取、写入和管理文件。以下是一些常见的文件操作任务的思路、总结和示例代码：

1. 打开文件

要执行文件操作，首先需要打开文件。使用open()函数可以打开文件，指定文件名以及打开模式（读取、写入、追加等）。

# 打开一个文本文件以读取内容
file = open("example.txt", "r")

2. 读取文件

一旦文件被打开，可以使用不同的方法来读取文件内容。

# 读取整个文件内容
content = file.read()

# 逐行读取文件内容
for line in file:  #直接遍历文件对象，每次读取一行。这种方式更内存友好，因为不需要将所有行读入内存。
    print(line)

with open('example.txt', 'r') as file:
    lines = file.readlines() # 读取文件的所有行，并将其作为一个列表返回。
    for line in lines:
        print(line, end='') 代码和file = open("example.txt", "r")for line in file:
    print(line) 代码的区别

3. 写入文件

要写入文件，需要打开文件以写入模式（‘w’），然后使用write()方法。

# 打开文件以写入内容
file = open("example.txt", "w")

# 写入内容
file.write("这是一个示例文本。")

4. 关闭文件

完成文件操作后，应该关闭文件，以释放资源和确保文件的完整性。

file.close()

5. 使用with

更安全的方法是使用with语句，它会自动关闭文件。

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

6. 检查是否存在

可以使用os.path.exists()来检查文件是否存在。

import os

if os.path.exists("example.txt"):
    print("文件存在")

7. 处理异常

在文件操作中，可能会出现各种异常情况，例如文件不存在或没有权限。在文件操作中捕获这些异常是个好习惯。

try:
    with open("example.txt", "r") as file:
        content = file.read()
except FileNotFoundError:
    print("文件不存在")
except Exception as e:
    print(f"发生错误：{e}")

这些是文件操作的一些常见思路和示例代码。请根据你的具体需求和场景来调整代码。在进行文件操作时，要确保小心处理文件，以避免意外数据损坏或文件损坏。

除了打开、读取和写入文件之外，还有一些其他常见的文件操作，如复制、删除和改变文件名。以下是这些操作的思路和示例代码：

8. 复制文件

要复制文件，你可以使用shutil模块的copy方法。

import shutil

source_file = "source.txt"
destination_file = "destination.txt"

shutil.copy(source_file, destination_file)

9. 删除文件

要删除文件，可以使用os模块的remove方法。

import os

file_to_delete = "file_to_delete.txt"

if os.path.exists(file_to_delete):
    os.remove(file_to_delete)
    print(f"{file_to_delete} 已删除")
else:
    print(f"{file_to_delete} 不存在")

10. 修改名称

要改变文件名，可以使用os模块的rename方法。

import os

old_name = "old_name.txt"
new_name = "new_name.txt"

if os.path.exists(old_name):
    os.rename(old_name, new_name)
    print(f"文件名已更改为 {new_name}")
else:
    print(f"{old_name} 不存在")

Python JSON 数据解析

JSON（JavaScript Object Notation）是一种轻量级数据交换格式，它易于阅读和编写，同时也易于机器解析和生成。Python提供了内置的JSON模块，用于处理JSON数据。

1. 导入模块

import json

2. 序列化

import json
data = {
    "name": "John",
    "age": 30,
    "city": "New York"
}

json_str = json.dumps(data)  # json.dumps() 是 Python 的 json 模块中的一个函数，它的作用是将 Python 对象转换为 JSON 格式的字符串。
print(json_str)

3. 反序列化

json_str = '{"name": "John", "age": 30, "city": "New York"}'

data = json.loads(json_str) # json.loads() 是 Python json 模块中的一个函数，它的作用是将 JSON 格式的字符串转换为 Python 对象。
print(data)

4. 对象存文件

data = {
    "name": "John",
    "age": 30,
    "city": "New York"
}

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

5. 从文件加载

with open('data.json', 'r') as json_file:
    data = json.load(json_file)
    print(data)

6. 嵌套JSON数据

如果JSON数据包含嵌套结构，您可以使用递归来访

问和修改其中的值。

json_data = {
    "name": "Alice",
    "info": {
        "age": 25,
        "location": "Paris"
    }
}

# 获取嵌套的值
age = json_data["info"]["age"]

# 修改嵌套的值
json_data["info"]["location"] = "New York"

# 将更改后的数据转换为JSON字符串
new_json_str = json.dumps(json_data)

7. JSON中列表

JSON可以包含列表，可以使用索引来访问列表元素。

json_data = {
    "fruits": ["apple", "banana", "cherry"]
}

# 获取列表中的第一个水果
first_fruit = json_data["fruits"][0]

# 添加一个新水果到列表
json_data["fruits"].append("orange")

8. JSON中空值

JSON允许表示空值（null），在Python中，它通常转换为None。

json_data = {
    "value": None
}

字典和JSON格式不同之处

1. 数据类型限制：
   • JSON：支持的数据类型包括对象（类似于字典）、数组（类似于列表）、字符串、数字、布尔值和 null。JSON 不支持 Python 特有的数据类型如 tuple、set、bytes 等。
   • Python 字典：可以包含多种 Python 特有的数据类型，比如 tuple、set、bytes 等。
2. 格式要求：
   • JSON：数据必须以字符串的形式表示，键必须是双引号括起来的字符串，值可以是字符串、数字、布尔值、数组、对象或 null。
   • Python 字典：键可以是任意不可变的类型（如字符串、数字、元组），值可以是任意类型。键通常用单引号或双引号括起来，但 Python 允许在字典中使用不加引号的键。

Python正则表达式

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。re模块使 Python 语言拥有全部的正则表达式功能。正则表达式在网络爬虫、数据分析中有着广泛使用，掌握正则表达式能够达到事半功倍的效果。

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[…]	用来表示一组字符,单独列出：[amk] 匹配 ‘a’，‘m’或’k’
[^…]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{n}	匹配n个前面表达式。例如，"o{2}“不能匹配"Bob"中的"o”，但是能匹配"food"中的两个o。
re{n,}	精确匹配n个前面表达式。例如，"o{2,}“不能匹配"Bob"中的"o”，但能匹配"foooood"中的所有o。"o{1,}“等价于"o+”。"o{0,}“则等价于"o*”。
re{n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
|	匹配a或b
(re)	匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (…), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#…)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。
(?> re)	匹配的独立模式，省去回溯。
\w	匹配数字字母下划线
\W	匹配非数字字母下划线
\s	匹配任意空白字符，等价于 [\t\n\r\f]。
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9]。
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\B	匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
\n, \t, 等	匹配一个换行符。匹配一个制表符, 等
\1…\9	匹配第n个分组的内容。
\10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

1.字符匹配

方法和功能

方法	功能
match()	判断一个正则表达式是否从开始处匹配一个字符串
search()	遍历字符串，找到正则表达式匹配的第一个位置，返回匹配对象
findall()	遍历字符串，找到正则表达式匹配的所有位置，并以列表的形式返回。如果给出的正则表达式中包含子组，就会把子组的内容单独返回，如果有多个子组就会以元组的形式返回。
finditer()	遍历字符串，找到正则表达式匹配的所有位置，并以迭代器的形式返回

• hqyj匹配文本中的hqyj

import re
text="hqyj牛皮6666,hqyj有个老师也牛皮666"
data=re.findall("hqyj",text)
print(data)#['hqyj', 'hqyj']

• [hqyj]匹配h或者q或者y或者j字符

import re
text="hqyj牛皮6666,hqyj有个老师也牛皮666"
data=re.findall("[hqyj]",text)
print(data)#['h', 'q', 'y', 'j', 'h', 'q', 'y', 'j']

import re
text="hqyj牛皮6666,hqyj有个老师也牛皮666"
data=re.findall("[hqyj]牛",text)
print(data)#['j牛']

• [^hqyj]匹配除了hqyj以外的其他字符

import re
text="hqyj牛皮6666,hqyj有个老师也牛皮666"
data=re.findall("[^hqyj]",text)
print(data)#['牛', '皮', '6', '6', '6', '6', ',', '有', '个', '老', '师', '也', '牛', '皮', '6', '6', '6']

• [a-z]匹配a~z的任意字符([0-9]也可以)

import re
text="hqyj牛皮6666,hqyj有个老师abchqyj也牛皮666"
data=re.findall("[a-z]hqyj",text)
print(data)#['chqyj']

• .匹配除了换行符以外的任意字符

import re
text="hqyj牛皮6666,hqyj有个老师abchqyj也牛皮666"
data=re.findall(".hqyj",text)
print(data)#[',hqyj', 'chqyj']

import re
text="hqyj牛皮6666,hqyj有个老师abchqyj也牛皮666"
data=re.findall(".+hqyj",text) #贪婪匹配(匹配最长的)
print(data)#['hqyj牛皮6666,hqyj有个老师abchqyj']

import re
text="hqyj牛皮6666,hqyj有个老师abchqyj也牛皮666"
data=re.findall(".?hqyj",text)
print(data)#['hqyj', ',hqyj', 'chqyj']

特殊字符

特殊字符	含义
\d	匹配任何十进制数字；相当于类 [0-9]
\D	与 \d 相反，匹配任何非十进制数字的字符；相当于类 [^0-9]
\s	匹配任何空白字符（包含空格、换行符、制表符等）；相当于类 [ \t\n\r\f\v]
\S	与 \s 相反，匹配任何非空白字符；相当于类 [^ \t\n\r\f\v]
\w	匹配任意一个文字字符，包括大小写字母、数字、下划线，等价于表达式[a-zA-Z0-9_]
\W	于 \w 相反 (注：re.ASCII 标志使得 \w 只能匹配 ASCII 字符)
\b	匹配单词的开始或结束
\B	与 \b 相反

• \w 匹配字母数字下划线(汉字)

import re
text="华清_远见abc 华清hqyj远见 华清牛皮远见"
data=re.findall("华清\w+远见",text)
print(data)#['华清_远见', '华清hqyj远见', '华清牛皮远见']

• \d匹配数字

import re
text="hqyj66d6 a1h43d3fd43s43d4 "
data=re.findall("d\d",text) # 只匹配一个数字
print(data)#['d6', 'd3', 'd4', 'd4']

import re
text="hqyj66d6 a1h43d3fd43s43d4 "
data=re.findall("d\d+",text)
print(data)#['d6', 'd3', 'd43', 'd4']

• \s匹配任意空白符 包括空格,制表符等等

import re
text="hqyj666  jack karen 666"
data=re.findall("\sj\w+\s",text)
print(data)#[' jack ']

2.数量控制

*重复0次或者更多次

import re
text="华清远见 华清666远见"
data=re.findall("华清6*远见",text)
print(data)#['华清远见', '华清666远见']

+重复1次或者更多次

import re
text="华清远见 华清666远见 华清6远见"
data=re.findall("华清6+远见",text)
print(data)#['华清666远见', '华清6远见']

?重复1次或者0次

import re
text="华清远见 华清666远见 华清6远见"
data=re.findall("华清6?远见",text)
print(data)#['华清远见', '华清6远见']

{n}重复n次,n是数字

import re
text="华清远见 华清666远见 华清6远见"
data=re.findall("华清6{3}远见",text)
print(data)#['华清666远见']

{n,}重复n次或者更多次

import re
text="华清远见 华清666远见 华清6远见 华清66远见"
data=re.findall("华清6{2,}远见",text)
print(data)#['华清666远见', '华清66远见']

{n,m}重复n到m次

import re
text="华清远见 华清666远见 华清6远见 华清66远见"
data=re.findall("华清6{0,2}远见",text)
print(data)#['华清远见', '华清6远见', '华清66远见']

3.分组

• ()提取兴趣区域

import re
text="谢帝谢帝,我要迪士尼,我的电话号码18282832341,qq号码1817696843"
data=re.findall("号码(\d{10,})",text)
print(data)#['18282832341', '1817696843']

import re
text="谢帝谢帝,我要迪士尼,我的电话号码18282832341,qq号码1817696843"
data=re.findall("(\w{2}号码(\d{10,}))",text)
print(data)#['18282832341', '1817696843']

• (|)提取兴趣区域(| = or)

import re
text="第一名张三 第一名物理149分 第一名数学150分 第一名英语148分 第一名总分740分"
data=re.findall("第一名(\w{2,}|\w{2,}\d{2,}分)",text)
print(data)#['张三', '物理149分', '数学150分', '英语148分', '总分740分']

4.开始和结束

• ^开始

import re
text = "hqyj66abc hqyj123"
data = re.findall("^hqyj\d+", text)
print(data)  #['hqyj66']

• $结尾

import re
text = "hqyj66abc hqyj123"
data = re.findall("hqyj\d+$", text)
print(data)  #['hqyj123']

5.特殊字符

由于正则表达式中* . \ {} () 等等符号具有特殊含义,如果你指定的字符正好就是这些符号,需要用\进行转义

import re
text = "数学中集合的写法是{2}"
data = re.findall("\{2\}", text)
print(data)  #['{2}']

6.re模块的常用方法

re.findall

获取匹配到的所有数据

import re
text="hqyj66d6 a1h43d3fd43s43d4 "
data=re.findall("d\d+",text)
print(data)#['d6', 'd3', 'd43', 'd4']

re.match

从字符串的起始位置匹配，成功返回一个对象否则返回none。

匹配成功返回对象,对象的方法:

方法	功能
group()	返回匹配的字符串
start()	返回匹配的开始位置
end()	返回匹配的结束位置
span()	返回一个元组表示匹配位置（开始，结束）

import re

# 在起始位置匹配，并返回一个包含匹配 (开始,结束) 的位置的元组
print(re.match('www', "www.python.com").span())#(0, 3)
print(re.match('www', "www.python.com").start())#0
print(re.match('www', "www.python.com").end())#3
# 不在起始位置匹配
print(re.match('com', "www.python.com"))# None

re.search

扫描整个字符串并返回第一个成功匹配的字符串。成功返回一个对象否则返回none

import re

# 在起始位置匹配 
print(re.search('www', 'www.hqyj.com').span())#(0, 3)
# 不在起始位置匹配
print(re.search('com', 'www.hqyj.com').span())#(9, 12)

re.sub

替换匹配成功的字符

类似与字符串的replace函数

import re
text = "以前华清远见在四川大学旁边,现在华清远见在西南交大旁边"
data = re.sub("华清远见","北京华清远见科技集团成都中心", text)
print(data)#以前北京华清远见科技集团成都中心在四川大学旁边,现在北京华清远见科技集团成都中心在西南交大旁边

re.split

根据匹配成功的位置对字符串进行分割

import re
text = "python is   very easy"
data = re.split("\s{1,}", text)
print(data)#['python', 'is', 'very', 'easy']

re.finditer

类似findall 但是不会全部返回出来 而是返回迭代器(比如匹配成功了10万个 全部返回就很吃内存了)

import re
text = "python is   very easy"
data = re.findall("\w+", text)
print(data)#['python', 'is', 'very', 'easy']

import re
text = "python is   very easy"
data = re.finditer("\w+", text)
print(data)
for el in data:
    print(el.group())

7.常见的一些正则

QQ号：[1 - 9][0 - 9]{4, }(腾讯QQ号从10000开始)
帐号(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
Email地址：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$
身份证号(15位、18位数字)：^\d{15}|\d{18}$
短身份证号码(数字、字母x结尾)：^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$

Python日期和时间

Python 的 time 模块下有很多函数可以转换

• 常见日期格式。

time 模块时间处理的和转换时间格式的常用API: [官网链接](time — 时间访问和转换 — Python 3.12.2 文档)

time.time() - 获取当前时间的时间戳（以秒为单位，浮点数形式，精确到小数点后若干位）

import time  # 引入time模块

ticks = time.time()
print ("当前时间戳为:", ticks)#时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年

time.sleep(secs) - 让程序暂停执行指定秒数。

import time

# 让程序暂停3秒
time.sleep(3)
print("3秒后执行到这里...")

time.ctime(timestamp=None) - 将时间戳转换为易读的本地时间格式。

import time

# 获取当前时间的ctime格式
current_time = time.ctime()
print("当前时间 (ctime):", current_time)

# 或者使用特定时间戳
timestamp = 1647708000  # 这是一个示例时间戳
converted_time = time.ctime(timestamp)
print("时间戳转ctime格式:", converted_time)

time.localtime([secs]) - 将时间戳转换为本地时区的struct_time元组。

import time

# 获取当前时间的struct_time元组
local_time_tuple = time.localtime()
print("当前时间 (struct_time):", local_time_tuple)

# 或者使用特定时间戳
timestamp = time.time()
converted_tuple = time.localtime(timestamp)
print("时间戳转struct_time:", converted_tuple)

time.strftime(format[, t]) - 格式化本地时间。

import time

# 获取当前时间并格式化为“年-月-日 时:分:秒”
formatted_time = time.strftime('%Y-%m-%d %H:%M:%S')
print("格式化当前时间:", formatted_time)

# 使用特定时间戳
timestamp = time.time()
custom_format = time.strftime("%Y%m%d_%H%M%S", time.localtime(timestamp))
print("格式化后的时间戳:", custom_format)

格式化符号:

• %y 两位数的年份表示（00-99）
• %Y 四位数的年份表示（000-9999）
• %m 月份（01-12）
• %d 月内中的一天（0-31）
• %H 24小时制小时数（0-23）
• %I 12小时制小时数（01-12）
• %M 分钟数（00=59）
• %S 秒（00-59）
• %a 本地简化星期名称
• %A 本地完整星期名称
• %b 本地简化的月份名称
• %B 本地完整的月份名称
• %c 本地相应的日期表示和时间表示
• %j 年内的一天（001-366）
• %p 本地A.M.或P.M.的等价符
• %U 一年中的星期数（00-53）星期天为星期的开始
• %w 星期（0-6），星期天为星期的开始
• %W 一年中的星期数（00-53）星期一为星期的开始
• %x 本地相应的日期表示
• %X 本地相应的时间表示
• %Z 当前时区的名称
• %% %号本身

属性（time模块本身没有属性，但可以通过其提供的函数生成的对象来访问属性）

对于struct_time对象（由time.localtime()或time.gmtime()等返回），它是一个元组，可以按索引访问各个时间元素：

属性	值
tm_year	年
tm_mon	月:1 到 12
tm_mday	日:1 到 31
tm_hour	时:0 到 23
tm_min	分:0 到 59
tm_sec	秒:0 到 61 (60或61 是闰秒)
tm_wday	星期:0 到 6 (0是周一)
tm_yday	一年中的第几天，1 到 366
tm_isdst	是否为夏令时，值有：1(夏令时)、0(不是夏令时)、-1(未知)，默认 -1

import time

local_time = time.localtime()

# 访问struct_time的属性（索引）
year = local_time.tm_year
month = local_time.tm_mon
day = local_time.tm_mday
hour = local_time.tm_hour
minute = local_time.tm_min
second = local_time.tm_sec
print(f"当前日期和时间：{year}-{month}-{day} {hour}:{minute}:{second}")

Python网络

Python requests 是一个常用的 HTTP 请求库，可以方便地向网站发送 HTTP 请求，并获取响应结果。

使用 requests 发送 HTTP 请求需要先下载并导入 requests 模块：

import requests

# 导入 requests 包
import requests
response = requests.get('https://www.baidu.com')# 发送请求
print(response.content)  # 获取响应内容


response2 = requests.get('http://localhost:7001/test')# 发送请求
print(response2.json())  # 获取json数据并解析

每次调用 requests 请求之后，会返回一个 response 对象，该对象包含了具体的响应信息，如状态码、响应头、响应内容等：

response的属性或方法	说明
apparent_encoding	编码方式
close()	关闭与服务器的连接
content	返回响应的内容，以字节为单位
cookies	返回一个 CookieJar 对象，包含了从服务器发回的 cookie
elapsed	返回一个 timedelta 对象，包含了从发送请求到响应到达之间经过的时间量，可以用于测试响应速度。比如 r.elapsed.microseconds 表示响应到达需要多少微秒。
encoding	解码 r.text 的编码方式
headers	返回响应头，字典格式
history	返回包含请求历史的响应对象列表（url）
is_permanent_redirect	如果响应是永久重定向的 url，则返回 True，否则返回 False
is_redirect	如果响应被重定向，则返回 True，否则返回 False
iter_content()	迭代响应
iter_lines()	迭代响应的行
json()	返回结果的 JSON 对象 (结果需要以 JSON 格式编写的，否则会引发错误)
links	返回响应的解析头链接
next	返回重定向链中下一个请求的 PreparedRequest 对象
ok	检查 “status_code” 的值，如果小于400，则返回 True，如果不小于 400，则返回 False
raise_for_status()	如果发生错误，方法返回一个 HTTPError 对象
reason	响应状态的描述，比如 “Not Found” 或 “OK”
request	返回请求此响应的请求对象
status_code	返回 http 的状态码，比如 404 和 200（200 是 OK，404 是 Not Found）
text	返回响应的内容，unicode 类型数据
url	返回响应的 URL

requests的方法

方法	描述
delete(url, args)	发送 DELETE 请求到指定 url
get(url, params, args)	发送 GET 请求到指定 url
head(url, args)	发送 HEAD 请求到指定 url
patch(url, data, args)	发送 PATCH 请求到指定 url
post(url, data, json, args)	发送 POST 请求到指定 url
put(url, data, args)	发送 PUT 请求到指定 url
request(method, url, args)	向指定的 url 发送指定的请求方法

requests.get(url, params ={key: value}, args)

• url 请求 url。
• **params ** 参数为要发送到指定 url 的 JSON 对象。
• args 为其他参数，比如 cookies、headers、verify等。

import requests

# 图片URL地址
image_url = 'http://localhost:7001/public/1.png'

# 发送GET请求获取图片数据
response = requests.get(image_url)

# 检查请求是否成功（HTTP状态码为200）
if response.status_code == 200:
    # 将图片数据写入本地文件
    with open('image.jpg', 'wb') as f:
        f.write(response.content)
    print("图片已成功下载并保存为 image.jpg")
else:
    print(f"无法下载图片，响应状态码：{response.status_code}")

requests.post(url, data={key: value}, json={key: value}, args)

• url 请求 url。
• data 参数为要发送到指定 url 的字典、元组列表、字节或文件对象。
• json 参数为要发送到指定 url 的 JSON 对象。
• args 为其他参数，比如 cookies、headers、verify等。

import requests
headers = {'User-Agent': 'Mozilla/5.0'}  # 设置请求头
params = {'key1': 'value1', 'key2': 'value2'}  # 设置查询参数
data = {'username': 'jack', 'password': '123456'}  # 设置请求体
response = requests.post('http://localhost:7001/test', headers=headers, params=params, data=data)
print(response.text)

标签：Python,re,模块,time,print,import,data
From： https://blog.csdn.net/qq_70019265/article/details/143369143