Python入门三

目录：

1. 内置库os
2. 内置库sys
3. 内置库文件处理
4. 内置库科学计算
5. 内置库日期与时间处理
6. 内置库json
7. 内置库正则表达式re
8. 内置库多线程threding
9. 内置库pythonlogging
10. 内置库pythonlogging高级使用
11. venv环境管理
12. pip环境管理
13. 常用第三方库yaml
14. 常用第三方库pymysql
15. 常用第三方库urllib3
16. 学生信息管理系统

1.内置库os

os 概述

• os: Operating System
• os 模块的常用功能
• 跨平台的差异

os 使用

• 导入 os 模块
  • import os
• 查看 os 模块使用文档
  • help(os)
  • dir(os)

import os

# 查看 os 模块使用文档
help(os)

# 查看os模块的属性和方法
print(dir(os))

os 常用方法

• 系统相关
• 操作目录
• 操作路径

os 操作系统相关

• os.name：获取系统名称
• os.environ：获取系统环境变量信息
• os.getenv(‘PATH’)：获取指定名称的环境变量信息
• os.system()：执行系统指令

import os

#os.name：获取系统名称 nt代表window，posix代表linux
print(os.name)

# # os.environ：获取系统环境变量信息
print(os.environ)

# os.getenv('PATH')：获取指定名称的环境变量信息
print(os.getenv('PATH'))

# os.system()：执行系统指令
# os.system('pwd')  # linux系统
print(os.system('dir'))  # windows系统

os 目录相关

• os.getcwd()：获取当前目录
• os.chdir()：切换目录
• os.listdir()：列出当前目录内容
• os.mkdir()：创建空目录
• os.makedirs()：递归创建多级目录
• os.rmdir()：删除空目录
• os.rename()：重命名目录
• os.remove()：删除文件

import os

"""目录相关"""
# 获取当前所在目录 get current directory
print(os.getcwd())
# 切换目录 change directory
os.chdir('D:\\workespace\\workespace_python\\python\\20230728')
print(os.getcwd())
# 列出当前目录下的所有文件
print(os.listdir())
# 创建空目录
os.mkdir('new')
# 递归创建多级空目录
os.makedirs('a/b/c')
# 删除空目录
os.rmdir('new')
# 重命名目录
os.rename('a', 'a1')
# 删除文件
os.remove('demo.txt')

os 路径相关

path 方法	说明
os.path.abspath(path)	返回绝对路径
os.path.basename(path)	返回文件名
os.path.dirname(path)	返回文件路径
os.path.split(path)	分割路径
os.path.join(path)	拼接路径
os.path.exists(path)	判断路径是否存在
os.path.isdir(path)	判断是否是目录
os.path.isfile(path)	判断是否是文件
os.path.getsize(path)	获取文件大小

2.内置库sys

sys 概述

• 是 Python 自带的内置模块
• 是与 Python 解释器交互的桥梁

sys 使用

• 常用属性
• 常用方法
• 导入 sys 模块

# 导入sys模块
import sys

# 查看sys模块帮助文档
help(sys)

# 查看sys模块的属性和方法
print(dir(sys))

sys 常用属性

• sys.version：返回 Python 解释器版本
• sys.platform：返回操作系统平台名称
• sys.argv：返回外部向程序传递的参数
• sys.modules：返回已导入的模块信息
• sys.path：返回导包的搜索路径列表

import sys

"""sys模块常用属性"""
# 返回Python 解释器版本
print(sys.version)
# 返回操作系统平台名称
print(sys.platform)
# 返回外部向程序传递的参数
print(sys.argv)
# 返回已导入的模块信息
print(sys.modules)
print(sys.modules.keys())
# 返回导包的搜索路径列表
print(sys.path)

sys 常用方法

• sys.getdefaultencoding()：获取编码方式

• sys.exit()：运行时退出

import sys
"""sys模块常用方法"""
# 获取系统当前编码
print(sys.getdefaultencoding())

# 运行时退出
sys.exit()

3.内置库文件处理

IO 操作

文件操作步骤

• 打开文件
• 操作文件：读/写内容
• 关闭文件（读写完成，要及时的关闭）

文件读写模式

 实战1

# 第一步：（以只读模式）打开文件
f = open('./data.txt', 'r', encoding='utf-8')

# 第二步：读取文件内容
print(f.read())

# 第三步：关闭文件
f.close()

 读操作

读操作实战

• 读取指定长度的内容
• 读取文件中的一行
• 遍历打印文件中的每一行

# 打开文件
f = open('./data.txt', 'r', encoding='utf-8')

# 读取指定长度的内容
print(f.read(15))
f.seek(0)

# 读取文件中的一行
print(f.readline())
f.seek(0)

# 遍历打印文件中的每一行
print(f.readlines())

# 关闭文件
f.close()

 忘记关闭文件的危害

• 打开文件达到一定数量， 将会导致打开失败
• 占用内存空间，非常浪费资源
• 会导致系统自动回收资源，而丢失数据

with 用法 

with open('./data.txt', 'r', encoding='utf-8') as f:
    print(f.read())
## 查看关闭状态
print(f.closed)

 写操作实战

# 写操作实战
# mode=“w+”， 读写权限，会新建文件，清空内容再写入
with open('./data.txt','w+',encoding='utf-8') as f:
    print(f.write('tom comming'))
print(f.closed)
# mode=“r+”， 读写权限，替换原来的内容
with open('./data.txt','r+',encoding='utf-8') as f:
    print(f.write('tom comming'))
print(f.closed)
# mode=“a+”， 读写权限，追加内容
with open('./data.txt','a+',encoding='utf-8') as f:
    print(f.write('tom comming'))
print(f.closed)

4.内置库科学计算

了解 math 函数：

math 函数，python 提供的内置数学类函数库，包含了很多数学公式。比如幂函数运算，三角函数，高等函数运算等。

math 函数操作：

• 数字常数
• 数论与表示函数
• 幂对数函数
• 三角对数函数
• 高等特殊函数

数字常量

常数	数学表示	描述
math.pi	π	圆周率，值为3.1415926535…
math.e	e	自然对数，值为2.7182818…
math.inf	∞	正无穷大，负无穷-math.inf
math.nan	NAN	非数字 NAN(Not a Number)

数论与表示函数

幂函数与对数函数

三角函数

高等特殊函数

5.内置库日期与时间处理

工作中应用

• 作为日志信息的内容输出
• 计算某个功能的执行时间
• 用日期命名一个日志文件的名称
• 生成随机数（时间是不会重复的）

python 中处理时间的模块

• time
• datetime
• calendar

 常见的时间表示形式

• 时间戳
• 格式化的时间字符串

datetime 常用的类

• datetime  （from datetime import datetime） 时间日期相关
• timedelta  (from datetime import timedelta) 计算两个时间的时间差
• timezone  (from datetime import timezone) 时区相关

 练习1 - 获取当前日期和时间

import datetime
now = datetime.datetime.now()
print(now)
print(now.day)
print(now.month)
print(now.year)

练习2 - 字符串与时间互转

import datetime
s="2023-09-27 06:47:06"
# 将字符串 转换为datetime实例
s1=datetime.datetime.strptime(s,'%Y-%m-%d %H:%M:%S')
print(s1)
print(type(s1))
# 时间转成字符串
now = datetime.datetime.now()
result = now.strftime('%Y-%m-%d %H:%M:%S')
print(result)
print(type(result))

练习3 - 时间戳 与时间互转 

import datetime

mtimestamp = 1685628796.3456
# 将时间戳转成时间
s = datetime.datetime.fromtimestamp(mtimestamp)
print(s)
print(type(s))
# 将时间转成时间戳
print(s.timestamp())

6.内置库json

什么是json？

• JSON 是用于存储和交换数据的语法，是一种轻量级的数据交换格式。
• 使用场景
  • 接口数据传输
  • 序列化
  • 配置文件

JSON 结构

• 键值对形式
• 数组形式

{
    "language": [
        {
            "name": "python",
            "url": "https://www.python.org/"
        },
        {
            "name": "java",
            "url": "https://www.java.com/zh-CN/"
        }
    ]
}

Python 与 JSON 数据类型对应

 json 库

• 可以从字符串或文件中解析 JSON
• 该库解析 JSON 后将其转为 Python 字典或者列表

 常用方法

• dumps()：将 Python 对象编码成 JSON 字符串
• loads()：解码 JSON 数据，该函数返回 Python 对象
• dump()： Python 对象编码，并将数据写入 json 文件中
• load()：从 json 文件中读取数据并解码为 Python 对象

import json

# 定义 python 结构
data = [{'a': 1, 'b': '2', 'c': True, 'd': False, 'e': None}]

# 将 python 对象编码为 JSON 字符串
json_data = json.dumps(data)
print(type(json_data))
print(json_data)
# 将 JSON 字符串解码为 python 对象
python_data = json.loads(json_data)
print(type(python_data))
print(python_data)
# 写入 JSON 数据，在代码当前目录生成一个 data.json 的文件
with open('data.json', 'w') as f:
    json.dump(data, f)
# 读取数据，读取 json 文件并解码成 python 对象
with open('data.json', 'r') as f:
    data = json.load(f)
    print(data)

dumps 常用参数

• indent：根据数据格式缩进显示，默认为 None，没有缩进
• ensure_ascii：对中文使用 ASCII 编码，默认为 True

import json

data = {
    'a': 1, 
    'b': '时机已到，今日起兵！', 
    'c': True, 
    'd': False, 
    'e': None }

python_data = json.dumps(data, indent=4, ensure_ascii=False)
print(python_data)

7.内置库正则表达式re

什么是正则表达式?

正则表达式是一种文本匹配工具，它允许您在字符串中查找模式。这些模式可以是简单的单词或更复杂的结构，如重复模式、分隔符和转义字符。

正则表达式在许多编程语言中都有内置支持，例如Python、JavaScript、Java等。它们通常用于以下目的：

1. 模式匹配：正则表达式可以用于在文本中查找特定的模式。例如，您可以使用正则表达式来查找电子邮件地址、电话号码或特定的日期格式。
2. 替换：正则表达式可以用于替换文本中的特定模式。例如，您可以使用正则表达式来查找并替换字符串中的所有数字或字母。
3. 验证：正则表达式可以用于验证输入是否符合特定的格式。例如，您可以使用正则表达式来验证密码是否符合特定的长度和字符要求。

总之，正则表达式是一种强大的文本处理工具，可用于在字符串中查找和替换模式，以及验证输入的格式。

使用场景

• 处理字符串
• 处理日志

正则表达式对象转换

• compile()：将字符串转换为正则表达式对象
• 需要多次使用这个正则表达式的场景

匹配字符串

• match()：从字符串的开始处进行匹配
• search()：在整个字符串中搜索第一个匹配的值
• findall()：在整个字符串中搜索所有符合正则表达式的字符串，返回列表

# 匹配以hello开头的字符串
pattern = r"hel\w+"
s1 = "hello world! i am jack!"
match1 = re.match(pattern, s1, re.I)
print(match1)
print(f"匹配值的起始位置为:{match1.start()}")
print(f"匹配值的结束位置为:{match1.end()}")
print(f"匹配位置的元组为:{match1.span()}")
print(f"要匹配的字符串为:{match1.string}")
print(f"要匹配的数据为:{match1.group()}")

s2 = "jenny i am tom hello hello!"
match2 = re.match(pattern, s2, re.I)
match3 = re.search(pattern,s2,re.I)
match4 = re.findall(pattern,s2,re.I)
print(match2)
print(match3)
print(match4)

替换字符串

• sub()：实现字符串替换

# 匹配手机号码
pattern = r"1[34578]\d{9}"

s1 = "中奖号码 123456,联系电话 15611111111"
result = re.sub(pattern,'1xxxxxxxxxx',s1)
print(result)

 分割字符串

• split()：根据正则表达式分割字符串，返回列表

pattern = r"[?|&]"
url = "https://mbd.baidu.com/newspage/data/landingsuper?context=%7B%22nid%22%3A%22news_8736992893130596186%22%7D&n_type=-1&p_from=-1"
r = re.split(pattern,url)
print(r)

8.内置库多线程threding

import threading
import time

def task():
    a = 0
    while a < 9999*9999:
        a += 1


def main():
    start_time = time.time()
    thread = threading.Thread(target=task)
    thread2 = threading.Thread(target=task)
    thread2.start()
    thread.start()
    thread.join()
    thread2.join()
    task()
    print("all time: ", time.time() - start_time)

9.内置库python logging

日志作用

• 调试
• 辅助定位问题
• 数据分析

日志的级别

日志的用法

日志常用指引 — Python 3.11.4 文档

设置日志的级别

import logging

logging.basicConfig(level=logging.INFO)
logging.debug("这是debug日志")
logging.warning("这是warning日志")
logging.info("这是info日志")
logging.error("这是error日志")

保存日志到文件

import logging

logging.basicConfig(filename='./example.log', encoding='utf-8', level=logging.DEBUG)
logging.debug("这是debug日志")
logging.warning("这是warning日志")
logging.info("这是info日志")
logging.error("这是error日志")

设置时间格式

import logging

logging.basicConfig(
    filename='./example.log',
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s (%(filename)s:%(lineno)s)',
    datefmt='%m/%d/%Y %I:%M:%S %p',
    encoding='utf-8')

logging.debug("这是debug日志")
logging.warning("这是warning日志")
logging.info("这是info日志")
logging.error("这是error日志")

10.内置库python logging高级使用

python 日志进阶

python 日志记录流程

import logging

# create logger
logger = logging.getLogger('simple_test')
logger.setLevel(logging.DEBUG)

# create handler # 文件处理器
ch_file = logging.FileHandler('./example.log', encoding='utf-8')
ch_file.setLevel(logging.DEBUG)

# create handler # 流处理器
ch_stream = logging.StreamHandler()
ch_stream.setLevel(logging.DEBUG)

# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s -%(levelname)s -%(message)s')

# add formatter to ch
ch_file.setFormatter(formatter)
ch_stream.setFormatter(formatter)

# add ch to logger
logger.addHandler(ch_file)
logger.addHandler(ch_stream)

# application code
logger.debug("这是debug日志")
logger.warning("这是warning日志")
logger.info("这是info日志")
logger.error("这是error日志")

python 日志定义

官网：https://docs.python.org/zh-cn/3/howto/logging.html 

import logging
import os

# create logger 创建一个logger 记录器
logger = logging.getLogger(os.path.basename(__file__))
logger.setLevel(logging.DEBUG)
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# add formatter to ch
ch.setFormatter(formatter)
# add ch to logger
logger.addHandler(ch)
# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warning('warn message')
logger.error('error message')
logger.critical('critical message')

提问：ch.setLevel(logging.DEBUG) 这个会不会多此一举？因为之前 logger.setLevel(logging.DEBUG)

做个比喻：logger好比车库，进入车库有俩个门，东门，西门，ch相当于看门大爷，看门大爷得到指令，东门的大爷只让通过error级别的车辆，西门的大爷让所有的车都通过，但是我们发现，车库logger有各种级别的车

注意（logger可以有多个处理器，上边有图，就相当于车库有好几个门）

封装日志公共函数

import logging
import os

def get_logger():
    # create logger
    #打印模块名字
    print(os.path.basename(__file__))
    logger = logging.getLogger(os.path.basename(__file__))
    logger.setLevel(logging.DEBUG)
    # create console handler and set level to debug
    ch = logging.FileHandler(filename='./example.log', encoding="utf-8")
    ch.setLevel(logging.DEBUG)
    # create formatter
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    # add formatter to ch
    ch.setFormatter(formatter)
    # add ch to logger
    logger.addHandler(ch)
    return logger

def log_info(message):
    logger.info(message)

logger = get_logger()
logger.debug('debug message')
# logger.info('info message')
log_info("info message")
logger.warning('warn message')
logger.error('error message')
logger.critical('critical message')

日志配置文件logging.conf

[loggers] # loggers 对象列表
        keys=root,main

[handlers] # handlers 对象列表
        keys=consoleHandlers,fileHandlers

[formatters] # formatters 列表
        keys=fmt

[logger_root]
        level=DEBUG
        handlers=consoleHandlers,fileHandlers

[logger_main] # main logger
        level = DEBUG
        handlers = fileHandlers
        qualname=main
        propagate=0

[handler_consoleHandlers]
        class = StreamHandler
        level = DEBUG
        formatter = fmt
        args = (sys.stdout,)

[handler_fileHandlers]
        class = logging.handlers.RotatingFileHandler
        level = DEBUG
        formatter = fmt
        args = ('./logs/test.log', 'a', 10000, 3, 'UTF-8')

[formatter_fmt]  # fmt 格式
        format=%(asctime)s [%(levelname)s] %(message)s (%(filename)s:%(lineno)s)
        datefmt=

import logging.config

logging.config.fileConfig("logging.conf")
logger = logging.getLogger("main")
logger.debug("debug 日志")

11.venv环境管理

简介：

在Python中，venv是一种虚拟环境管理器，它允许你在不干扰全局Python环境（即系统默认的Python环境）的情况下，在同一台机器上同时运行多个Python版本及其相关库。

具体来说，venv通过以下功能来管理环境：

1. 创建和激活虚拟环境：使用virtualenv命令可以创建一个新的虚拟环境，并且可以使用source命令激活该环境。在虚拟环境中，你可以安装、更新、卸载Python包，而不会影响到全局环境。
2. 共享依赖库：venv允许你在多个虚拟环境中共享相同的依赖库。你可以使用-p选项指定使用特定版本的Python解释器，并且使用--system-site-packages选项允许你访问全局Python环境中的某些包。
3. 隔离环境：venv的另一个重要功能是隔离环境。这意味着在虚拟环境中安装的包只会影响到该环境，而不会影响到全局环境。这对于开发多个项目时非常有用，因为你可以在每个项目中使用不同的Python版本和依赖库。
4. 清除虚拟环境：当你不再需要某个虚拟环境时，可以使用deactivate命令将其清除。

总之，venv提供了一种在不影响全局Python环境的情况下管理多个Python版本和依赖库的方法，这对于开发多个项目、测试和调试非常有用。

venv 虚拟环境的优点

• 独立的 Python 环境，不会产生冲突
• 有助于包的管理
• 删除和卸载方便

venv 使用方法

• 创建虚拟环境
• 激活虚拟环境
• 安装 Python 包

 venv 创建虚拟环境

• 执行指令

python -m venv test

venv 激活虚拟环境

• 切换指定文件夹
  • Windows：/Scripts/
  • macOS：/bin/
• 执行指令：activate

 venv 安装 Python 包

• Python 版本选择
  • 进入 python2.7 环境：python2
  • 进入 python3.x 环境: python3
• pip 安装 Python 包
  • 安装 Python2.x 版本的包
  • 安装 Python3.x 版本的包

# 进入 python2.7 环境
python2

# 进入 python3.x 环境
python3

# 安装 Python2.x 版本的包
pip install xxx

# 安装 Python3.x 版本的包
pip3 install xxx

venv 退出和删除

• 退出虚拟环境：deactivate
• 删除虚拟环境：删除环境目录

12.pip环境管理

pip 概述

• pip 是 Python 包管理工具
  • python2 的 2.7.9 版本开始自带
  • python3 的 3.4 版本开始自带
• https://pypi.org/ 托管了大量流行的 Python 包

 pip 常用命令

功能                                        指令

查看 pip 版本                          pip -V

查看帮助文档                          pip help

查看包列表                             pip list

导出包列表                             pip freeze

安装                                        pip install 包名

升级                                        pip install -U 包名

卸载                                        pip uninstall 包名

pip 安装包

• 普通安装
• 指定版本
• 从文件中安装

# 默认安装最新版本
$ pip install pytest

# 执行版本
$ pip install pytest==6.2.0

#将本地环境写入到文件中
$ pip freeze >> requirments.txt

# 从文件清单中批量安装
$ pip install -r requirments.txt

# 文件格式
pytest==6.2.0
Faker==9.3.1
selenium==3.14.1

pip 升级包

• 升级已安装的 Python 包

$ pip install -U pytest

 pip 卸载包

• 卸载 Python 包

# 卸载包

$ pip uninstall pytest

pip 使用镜像加速

• pip install -i 镜像源

• 国内常用源

  • 阿里源：https://mirrors.aliyun.com/pypi/simple/
  • 清华源：https://pypi.tuna.tsinghua.edu.cn/simple/
  • 豆瓣源：http://pypi.douban.com/simple/

  # 使用镜像
  
  pip install pytest -i https://pypi.douban.com/simple

13.常用第三方库yaml

简介：

• 一种数据序列化格式
• 用于人类的可读性和与脚本语言的交互
• 一种被认为可以超越 XML、JSON 的配置文件

YAML 基本语法规则

• 大小写敏感
• 使用缩进表示层级关系
• 缩进时不允许使用 Tab 键，只允许使用空格
• 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
• # 表示注释，从这个字符一直到行尾，都会被解析器忽略

 YAML 支持的数据结构

• 对象：键值对的集合，用冒号 “:” 表示
• 数组：一组按次序排列的值，前加 “-”
• 纯量：单个的、不可再分的值
  • 字符串
  • 布尔值
  • 整数
  • 浮点数
  • Null
  • 时间
  • 日期

# 编程语言
languages:
  - PHP
  - Java
  - Python 
book:
  Python入门: # 书籍名称
    price: 55.5
    author: Lily
    available: True
    repertory: 20
    date: 2018-02-17
  Java入门:
    price: 60
    author: Lily
    available: False
    repertory: Null
    date: 2018-05-11

示例创建 yaml 文件：

import yaml

data = {
    "client": {"default-character-set": "utf8"},
    "mysql": {"user": 'root', "password": 123},
    "custom": {
        "user1": {"user": "张三", "pwd": 666},
        "user2": {"user": "李四", "pwd": 999},
    }
}

with open('./my.yaml', 'w', encoding='utf8') as f:
    yaml.dump(data, f, allow_unicode=True)

读取 yaml 文件

import yaml

file_path = './my.yaml'

with open(file_path, 'r', encoding='utf-8') as f:
    data = yaml.safe_load(f)
print(data)

PyYAML

• Python 的 YAML 解析器和生成器
• 官网：https://pypi.org/project/PyYAML/
• 安装：pip install pyyaml

14.常用第三方库pymysql

pymysql 概述

• Python 的数据库接口标准是 Python DB-API

• PyMySQL 是从 Python 连接到 MySQL 数据库服务器的接口

• PyMySQL 的目标是成为 MySQLdb 的替代品

• 官方文档：http://pymysql.readthedocs.io/

pymysql 安装

• 使用 pip 安装

• 使用 Pycharm 界面安装

pip install pymysql

pymysql 连接数据库

• host：MySQL 服务器地址
• user：用户名
• password：密码
• database：数据库名称
• charset：编码方式，推荐使用 utf8mb4

# 1.导入库
import pymysql

# 2.建立连接
conn = pymysql.connect(host='服务器地址',
                     user='用户名',
                     password='密码',
                     database='数据库名',
                     charset="utf8mb4")
# 3.关闭连接
conn.close()

 封装获取连接的函数

# 1.封装建立连接的对象
def get_conn():
    conn = pymysql.connect(
        host="服务器地址",
        user="root",
        password="123456",
        database="数据库名",
        charset="utf8mb4"
    )

    return conn

pymysql 入门实例

• 获取连接对象
  • 打开
  • 关闭
• 获取游标对象
  • 执行 SQL
  • 查询记录

import pymysql

def get_conn():
    conn = pymysql.connect(host='127.0.0.1',
                           user='root',
                           password='666666',
                           database='book',
                           charset="utf8mb4")
    return conn


def demo():
    # 1.获取连接对象
    conn = get_conn()
    # 2.获取游标对象
    cursor = conn.cursor()
    # 3.执行SQL
    cursor.execute("SELECT VERSION()")
    # 4.查询结果
    version = cursor.fetchone()
    print(f"数据库的版本是：{version}")
    # 5.关闭连接
    conn.close()

pymysql 数据库操作

• CRUD 操作
  • 创建表
  • 插入记录
  • 查询记录
  • 更新记录
  • 删除记录
• 执行事务
  • 提交：commit
  • 回滚：rollback

 pymysql 创建表

• 创建表 testcase

import pymysql

def get_conn():
    conn = pymysql.connect(host='127.0.0.1',
                           user='root',
                           password='666666',
                           database='book',
                           charset="utf8mb4")
    return conn

def create():
    conn = get_conn()  # 获取连接
    cursor = conn.cursor()  # 获取游标

    sql = """
    CREATE TABLE `testcase` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `title` varchar(255) COLLATE utf8_bin NOT NULL,
    `expect` varchar(255) COLLATE utf8_bin NOT NULL,
    `owner` varchar(255) COLLATE utf8_bin NOT NULL,
    PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;
    """
    cursor.execute(sql)  # 执行SQL
    conn.close()  # 关闭连接

create()

pymysql 插入操作

• 插入记录

import pymysql

def get_conn():
    conn = pymysql.connect(host='127.0.0.1',
                           user='root',
                           password='666666',
                           database='book',
                           charset="utf8mb4")
    return conn

def insert():
    conn = get_conn()  # 获取连接
    cursor = conn.cursor()  # 获取游标

    sql = """INSERT INTO testcase
    (id, title, expect, owner)
    values (1, 'S11总决赛', '冠军', 'EDG');
    """

    cursor.execute(sql)  # 执行SQL
    conn.commit()  # 提交

insert()

pymysql 查询操作

• 查询操作
  • fetchone()：获取单条记录
  • fetchmany(n)：获取 n 条记录
  • fetchall()：获取所有结果记录

import pymysql
import sys

def get_conn():
    conn = pymysql.connect(host='127.0.0.1',
                           user='root',
                           password='666666',
                           database='book',
                           charset="utf8mb4")
    return conn

def retrieve():
    conn = get_conn()  # 获取连接
    cursor = conn.cursor()  # 获取游标
    sql = "SELECT * FROM testcase;"
    # 捕获异常
    try:
        cursor.execute(sql)  # 执行SQL
        record = cursor.fetchone()  # 查询记录
        # record = cursor.fetchmany(2)  # 查询记录
        # record = cursor.fetchall()  # 查询记录
        print(record)
    except Exception as e:
        print(sys.exc_info())  # 打印错误信息
    finally:
        conn.close()  # 关闭连接

retrieve()

pymysql 更新操作 

• 更新数据表的数据

import pymysql

def get_conn():
    conn = pymysql.connect(host='127.0.0.1',
                           user='root',
                           password='666666',
                           database='book',
                           charset="utf8mb4")
    return conn

def update():
    conn = get_conn()
    cursor = conn.cursor()
    sql = "UPDATE testcase SET owner='root' WHERE id=1;"
    try:
        cursor.execute(sql)  # 执行SQL
        conn.commit()  # 提交事务
    except:
        conn.rollback()  # 回滚事务
    finally:
        conn.close()  # 关闭连接

update()

 pymysql 删除操作

• 删除数据表的数据

import pymysql

def get_conn():
    conn = pymysql.connect(host='127.0.0.1',
                           user='root',
                           password='666666',
                           database='book',
                           charset="utf8mb4")
    return conn

def delete():
    conn = get_conn()  # 获取连接
    cursor = conn.cursor()  # 获取游标
    sql = "DELETE FROM testcase WHERE id=1;"
    try:
        cursor.execute(sql)  # 执行SQL
        conn.commit()  # 提交事务
    except:
        conn.rollback()  # 回滚事务
    finally:
        conn.close()  # 关闭连接

delete()

 执行事务

• 提交操作：commit()
• 回滚操作：rollback()
• try-catch-finally

import pymysql

def get_conn():
    conn = pymysql.connect(host='127.0.0.1',
                           user='root',
                           password='666666',
                           database='book',
                           charset="utf8mb4")
    return conn

def insert():
    conn = get_conn()  # 获取连接
    cursor = conn.cursor()  # 获取游标

    sql = """INSERT INTO testcase
    (id, title, expect, owner)
    values (2, 'S11全球总决赛', '冠军', 'EDG');
    
    """
    try:
        cursor.execute(sql)  # 执行SQL
        10 / 0
        conn.commit()  # 提交事务
    except:
        conn.rollback()  # 回滚事务
    finally:
        conn.close()  # 关闭连接

insert()

15.常用第三方库urllib3

urllib3 概述

• 内置模块

  • urllib

• 第三方库

  • requests

  • urllib3

urllib3 概述

• 线程安全
• 连接池管理
• 客户端 SSL/TLS 验证
• 支持 HTTP 和 SOCKS 代理
• 官方文档：https://urllib3.readthedocs.io/en/stable/ 

urllib3 安装

• 通过 pip 安装
•  pip install urllib3

urllib3 发送 HTTP 请求

• 导入 urllib3 模块
• 创建 PoolManager 实例
• 调用 request() 方法

import urllib3

def HTTP():
    # 创建连接池对象，默认会校验证书
    pm = urllib3.PoolManager()
    # 发送HTTP请求
    resp = pm.request(method='GET', url="http://httpbin.org/robots.txt")
    print(type(resp))

HTTP()

urllib3 HTTPResponse 对象

• status 属性
• headers 属性
• data 属性

def response():
    # 创建连接池对象
    pm = urllib3.PoolManager()
    # 发送请求
    resp = pm.request(method='GET', url="http://httpbin.org/ip")

    print(resp.status)  # 查看响应状态状态码
    print(resp.headers)  # 查看响应头信息
    print(resp.data)  # 查看响应原始二进制信息

response()

urllib3 解析响应内容

• 二进制响应内容解码

• JSON 字符串

import json
import urllib3


def response():
    pm = urllib3.PoolManager()
    resp = pm.request(method='GET', url="http://httpbin.org/ip")

    # 获取二进制形式的响应内容
    raw = resp.data
    print(type(raw), raw)
    # 使用utf-8解码成字符串
    content = raw.decode('utf-8')
    print(type(content), content)
    # 将JSON字符串解析成字典对象
    dict_obj = json.loads(content)
    print(type(dict_obj), dict_obj)
    print(dict_obj['origin'])

response()

urllib3 request 请求参数

• 语法：request(method, url, fields, headers, **)
• 必填
  • method：请求方式
  • url：请求地址
• 选填
  • headers：请求头信息
  • fields：请求体数据
  • body：指定请求体类型
  • tiemout：设置超时时间 

 urllib3 定制请求数据

• 定制请求头信息

• 使用 headers 参数

import urllib3
import json


def headers():
    pm = urllib3.PoolManager()
    url = "http://httpbin.org/get"

    # 定制请求头
    headers = {'School': 'hdc'}
    resp = pm.request('GET', url, headers=headers)
    content = json.loads(resp.data.decode('utf-8'))
    print(content)
    print(content['headers'])

headers()

 定制查询字符串参数

• fields 参数：适用于GET, HEAD, DELETE 请求
• 拼接url：适用于POST, PUT请求

import urllib3
import json
# 从内置库urllib的parse模块导入编码方法
from urllib.parse import urlencode

# GET/HEAD/DELETE 请求
def fields():
    pm = urllib3.PoolManager()
    url = "http://httpbin.org/get"
    fields = {'school': 'hdc'}
    resp = pm.request(method='GET', url=url, fields=fields)
    content = json.loads(resp.data.decode('utf-8'))
    print(content)

fields()

# POST/PUT 请求
def urlencode():
    pm = urllib3.PoolManager()
    url = "http://httpbin.org/post"
    # POST和PUT请求需要编码后拼接到URL中
    encoded_str = urlencode({'school': 'hdc'})
    resp = pm.request('POST', url=url + "?" + encoded_str)
    content = json.loads(resp.data.decode('utf-8'))
    print(content)

urlencode()

  定制请求体数据（form表单）

• 提交 form 表单数据

• 类型 'Content-Type': 'multipart/form-data

• 请求方式：POST、PUT

import urllib3
import json


# POST/PUT 请求
def form():
    pm = urllib3.PoolManager()
    url = "http://httpbin.org/post"
    fields = {'school': 'hdc'}

    # fields数据会自动转成form格式提交
    resp = pm.request('POST', url, fields=fields)
    content = json.loads(resp.data.decode('utf-8'))
    print(content['form'])

form()

  定制请求体数据（json格式数据） 

• 提交 JSON 格式数据

• 类型：'Content-Type': 'application/json'

• 请求方式：POST、PUT

import urllib3
import json


def json():
    pm = urllib3.PoolManager()
    url = "http://httpbin.org/post"

    # 设定请求体数据类型
    headers = {'Content-Type': 'application/json'}

    # JSON文本数据
    json_str = json.dumps({'school': 'hdc'})
    resp = pm.request('POST', url, headers=headers, body=json_str)
    content = json.loads(resp.data.decode('utf-8'))
    print(content)

json()

• timeout ：设置超时时间

• 时间单位：秒

• 值的格式：float 类型

import urllib3

def timeout():
    pm = urllib3.PoolManager()
    # 访问这个地址，服务器会在3秒后响应
    url = "http://httpbin.org/delay/3"

    # 设置超时时长
    resp = pm.request(method='GET', url=url, timeout=2.0)
    print(resp.status)
    assert resp.status == 200

timeout()

 urllib3 发送 HTTPS 请求

• HTTPS 请求默认需要校验证书

• PoolManager 的 cert_reqs 参数

  • "CERT_REQUIRED"：需要校验
  • "CERT_NONE"：取消校验

import urllib3
import json

def HTTPS():
    # 创建不校验证书的连接池对象
    pm_https = urllib3.PoolManager(cert_reqs="CERT_NONE")
    url = "https://httpbin./get"

    # 发送HTTPS请求
    resp = pm_https.request(method='GET', url=url)
    print(json.dumps(resp.data.decode('utf-8')))

HTTPS()

16.学生信息管理系统

class Student:
    def __init__(self, id, name, sex):
        self.id = id
        self.name = name
        self.sex = sex
 
    def __repr__(self):
        return f"学号：{self.id},姓名：{self.name},性别：{self.sex}"
 
 
class StudentManagement:
    student_list = []
 
    # 单个添加学生
    def add_student(self, stu):
        result = self.get_student_by_id(stu.id)
        if result:
            print(f"学员{stu.id}已存在，请核对学生信息")
        else:
            self.student_list.append(stu)
            print(f"添加成功，添加的学员信息为：{stu}")
 
    # 添加多个学员
    def addStudents(self, stu_list):
        add_list = []
        for s in stu_list:
            result = self.get_student_by_id(s.id)
            if result:
                print(f"学员{s.id}已存在，请核对学生信息")
            else:
                self.student_list.append(s)
                add_list.append(s)
 
        if add_list:
            print("添加成功，添加的学员信息为：")
            for i in add_list:
                print(i)
 
    # 根据id查找学生
    def get_student_by_id(self, stu_id):
        for stu in self.student_list:
            if stu.id == stu_id:
                return stu
 
    # 查询所有学生
    def get_all_student(self):
        for stu in self.student_list:
            print(stu)
 
    # 根据id删除学生
    def delete_student_by_id(self, stu_id):
        result = self.get_student_by_id(stu_id)
        if result:
            self.student_list.remove(result)
            print(f"删除成功，删除的学员信息为：{result}")
            print("删除后的学员信息为：")
            self.get_all_student()
        else:
            print("删除失败，请核对学生信息")
 
    def menu(self):
        print("|----------欢迎来到学员信息管理系统------------------------|")
        print("|----------1.根据学号查看学员信息-------------------------|")
        print("|----------2.添加学员-----------------------------------|")
        print("|----------3.根据学号删除学员后:查看所有学员信息------------|")
        print("|----------4.查询当前所有学员的信息-----------------------|")
        print("|----------5.退出系统-----------------------------------|")
 
 
if __name__ == '__main__':
    stumg = StudentManagement()
    while True:
        stumg.menu()
        n = int(input("请输入你的选择:"))
        if n == 1:
            id = int(input("请输入想要查找的学员编号:"))
            print(stumg.get_student_by_id(id))
        elif n == 2:
            id = int(input("请输入学员编号:"))
            name = input("请输入学员姓名:")
            sex = input("请输入学员性别:")
            stumg.add_student(Student(id, name, sex))
        elif n == 3:
            id = int(input("请输入想要删除的学员编号:"))
            stumg.delete_student_by_id(id)
        elif n == 4:
            stumg.get_all_student()
        elif n == 5:
            print("成功退出系统，欢迎下次使用！")
            break
        else:
            print("输入有误！重新输入！")
            continue