深入挖掘python----python中的库01（全量）

深入挖掘python----python中的库01（全量）

0. 前言

1. 作为一个已工作近四年的测试工程师，接触的岗位从RD开发、到软件测试、再到嵌入式测试，工作时间越长，越发现精通一门编程语言在测试工作中是多么的重要，虽然平时工作中可以用python开发一些小自动化脚本和自动化工具，做一些简单的数据处理工作，但还真没好好的精通一门语言，python作为我进入测试行业的第一门语言，有很深的感情，就决定从它下手吧！！！加油！！！

1. python数据处理库

1.1 文本处理

1.1.1 chardet

1.1.1.1 chardet库的使用

字符编码检测器，该库可以检测文本、网页、xml等多种文件格式的编码它可以帮助你自动识别文本文件的编码格式，例如 UTF-8、GBK、ISO-8859-1 等

import chardet

# 检测文本文件的编码
def detect_encoding(file_path):
    with open(file_path, 'rb') as file:
        content = file.read()
        result = chardet.detect(content)
        encoding = result['encoding']
        confidence = result['confidence']

        print(f"File: {file_path}")
        print(f"Detected Encoding: {encoding}")
        print(f"Confidence: {confidence}")

# 示例文件路径
file_path = 'example.txt'

# 检测编码
detect_encoding(file_path)

1. 在上面的示例中，我们导入了 chardet 模块，并定义了一个名为 detect_encoding 的函数。这个函数接收一个文件路径作为参数，然后使用 chardet.detect() 方法来检测文件的编码。最后，打印出检测到的编码和置信度。

2. 需要注意的是，chardet.detect() 方法返回一个字典，其中包含两个键值对：‘encoding’ 表示检测到的编码名称，‘confidence’ 表示对该编码的置信度。

3. python-chardet 库不依赖其他库，它只提供了一个模块 chardet 用于检测编码。因此，在使用 python-chardet 库时，只需要安装该库即可，无需额外安装其他依赖包。

4. 你可以使用 pip install chardet 命令来安装 python-chardet 库。安装完成后，即可在代码中导入并使用 chardet 模块进行编码检测。

5. 使用chardet库的detect_all()函数检测多个文本的字符编码

texts = [b'\xe4\xb8\xad\xe6\x96\x87', b'Hello, world!', b'\xc3\xa9t\xc3\xa9']
results = chardet.detect_all(texts)

for result in results:
    encoding = result['encoding']
    confidence = result['confidence']
    print(encoding)
    print(confidence)

1.1.1.2 chardet库的常用函数

1. chardet.detect(data): 这是最常用的函数，用于检测字符串或字节数据的编码。它接收一个字符串或字节数据作为参数，并返回一个字典，包含两个键值对：‘encoding’ 表示检测到的编码名称，‘confidence’ 表示对该编码的置信度。

2. chardet.detect_all(byte_sequence): 这个函数与 detect() 函数类似，但它可以接受多个字节数据片段（字节序列）作为输入，并返回一个列表，每个片段都有自己的编码检测结果。

3. chardet.detect_one(byte_sequence): 这个函数与 detect_all() 函数类似，但它只返回一个具有最高置信度的编码检测结果。

4. chardet.enum_possible_encodings(): 这个函数返回一个包含所有可能的编码名称的列表。

5. chardet.detect_best() 检测多个文本的字符编码，并返回最可能的编码结果。

6. chardet.detect_languages() 检测文本的语言及其可信度。

7. chardet.constants 提供了一些常用的编码和语言相关的常量。

1.1.2 diffilib

1.1.2.1 diffilib库的使用

用于比较和生成文本之间的差异。它可以用于比较文件、字符串等，并输出增量更新或差异结果。

from diffilib import unified_diff

# 比较两个文本字符串的差异
def compare_strings(old_text, new_text):
    diff = unified_diff(old_text.splitlines(), new_text.splitlines())
    result = '\n'.join(diff)
    return result

# 示例文本
old_text = '''
Hello,
This is the old text.
Hope you are doing well.
Goodbye!
'''

new_text = '''
Hello,
This is the new text.
Hope you are doing well and enjoying.
Goodbye!
'''

# 比较两个文本字符串的差异
diff_result = compare_strings(old_text, new_text)

# 打印差异结果
print(diff_result)

1. 在上面的示例中，我们首先导入了 unified_diff 函数。然后定义了一个名为 compare_strings 的函数，该函数接收两个文本字符串作为参数，并比较它们的差异。我们使用 unified_diff 函数将字符串拆分成行列表，并生成差异结果。最后，将差异结果转换为字符串形式并打印出来。

2. 需要注意的是，unified_diff 函数返回的是一个迭代器，每次迭代产生一行差异结果。可以使用字符串的 join 方法将其连接起来，形成完整的差异结果。

3. diffilib 还提供其他比较函数和选项，例如 context_diff、ndiff 等。你可以根据具体的需求选择适合的函数来比较文本差异，并根据结果进行进一步处理。

1.1.2.2 diffilib常用函数

1. context_diff(a, b, fromfile=‘’, tofile=‘’, fromfiledate=‘’, tofiledate=‘’, n=3, lineterm=‘\n’)：
   生成上下文格式的差异结果。参数 a 和 b 是要比较的两个文本序列，fromfile 和 tofile 是源文件和目标文件的名称，fromfiledate 和 tofiledate 是源文件和目标文件的时间戳，n 是上下文行数，lineterm 是行分隔符。

2. unified_diff(a, b, fromfile=‘’, tofile=‘’, fromfiledate=‘’, tofiledate=‘’, n=3, lineterm=‘\n’)：
   生成统一格式的差异结果。参数和返回值与 context_diff 函数相同，但输出结果的格式稍有不同。相比于上下文格式，统一格式的差异结果更加简洁。

3. ndiff(a, b, linejunk=None, charjunk=IS_CHARACTER_JUNK)：
   生成逐行比较的差异结果，显示每行之间的详细改动。参数 a 和 b 是要比较的两个文本序列，linejunk 和 charjunk 是可选的过滤函数，用于指定忽略某些行或字符。

4. html_diff(a, b)：
   生成 HTML 格式的差异结果，可用于在网页上展示。参数 a 和 b 是要比较的两个文本序列。

5. restore(diff, which=0)：
   根据差异结果恢复原始文本。参数 diff 是差异结果字符串，which 是可选的标志，用于指定将哪个版本的差异结果应用到原始文本中。

6. IS_CHARACTER_JUNK(line)：
   默认的字符过滤函数，用于判断行中的字符是否为垃圾字符。可以自定义该函数以满足特定需求。

1.1.3 ftfy

1.1.3.1 ftfy库的使用

用于纠正和修复文本中常见的问题和错误。它提供了一些函数和工具，可以自动处理诸如拼写错误、标点符号问题、Unicode字符问题等文本问题。

1. 修复编码问题：

import ftfy

text = "This is a text with ​encoding issues."
fixed_text = ftfy.fix_encoding(text)
print(fixed_text)

输出结果：

This is a text with encoding issues.

2. 修复拼写错误：

import ftfy

text = "Ths text had speling errers."
fixed_text = ftfy.fix_text(text)
print(fixed_text)

输出结果：

This text had spelling errors.

3. 修复包含Unicode字符的文本：

import ftfy

text = "This text has some Unicode \ud83d\ude00 characters."
fixed_text = ftfy.fix_text(text)
print(fixed_text)

输出结果：

This text has some Unicode 😄 characters.

1.1.3.2 ftfy常用函数

1. ftfy.fix_text(text): 修复文本中的常见问题，如修复编码问题、拼写错误等。
2. ftfy.fix_encoding(text): 修复文本的编码问题。
3. ftfy.fix_text_segment(text): 对文本进行细分并处理，可以更好地处理复杂的文本错误。

1.1.4 fuzzywuzzy

1.1.4.1 fuzzywuzzy库的使用

可以进行字符串的模糊匹配，用于评估字符串相似度。它使用Levenshtein Distance来计算两个字符串之间的差距

from fuzzywuzzy import fuzz
from fuzzywuzzy import process

str1 = "OpenAI is a great platform"
str2 = "OpenAI is a fantastic platform"
ratio = fuzz.ratio(str1, str2)

print(ratio)   # 输出可能会是85，代表两个字符串85%的相似度

str3 = "OPENAI is a GREAT platform"
ratio2 = fuzz.partial_ratio(str1, str3)

print(ratio2)  # 输出可能会是100，因为不区分大小写和词序

# 另一种使用方式是process，可以找到与目标字符串最相似的一组字符串
choices = ["OpenAI is a great platform!", "OpenAI is a fantastic research institute.", "OpenAI makes awesome AI models."]
query = "OpenAI is great"
result = process.extractOne(query, choices)

print(result)  # 输出可能是 ('OpenAI is a great platform!', 90)，第一个是最相似的字符串，第二个是相似度的分数

请注意FuzzyWuzzy的匹配度评分是0到100，其中100表示完全匹配。

1.1.4.2 fuzzywuzzy常用函数

1. fuzz.ratio() : 纯粹的比较字符串的相似度，它只是计算两个字符串的差距。

2. fuzz.partial_ratio(): 通过使用最优的子字符串匹配来提供结果。如果字符串的一个部分非常相似，那么返回的比率会更高。

3. fuzz.token_sort_ratio() : 这个方法通过忽略字符串中单词的顺序，然后进行比较。

4. fuzz.token_set_ratio() : 这也是在比较过程中忽视词序的一种方法。

1.1.5 Levenshtein

Levenshtein库提供了一种用于衡量两个字符串之间的差异的方法，这种方法被称为Levenshtein距离。基本上，Levenshtein距离表示从一个字符串转换到另一个字符串所需要的最小单字符编辑（插入、删除或替换）次数

安装 Levenshtein

pip install python-Levenshtein

import Levenshtein as lev

str1 = "kitten"
str2 = "sitting"

# 计算Levenshtein距离
dist = lev.distance(str1, str2)
print(dist)  # 输出3，代表需要进行3次操作才能将str1转为str2。

# 计算两个字符串的相似度
ratio = lev.ratio(str1, str2)
print(ratio)  # 输出0.73，代表两个字符串有73%的相似度。

# 计算Jaro距离
jaro = lev.jaro(str1, str2)
print(jaro)  # 输出0.76，Jaro距离是一个介于0到1之间的数字，表示两个字符串的相似度。

# 计算Jaro-Winkler距离
jaro_winkler = lev.jaro_winkler(str1, str2)
print(jaro_winkler)  # 输出0.78，Jaro-Winkler距离考虑了字符串前缀的影响，所以相对于Jaro距离，它会给予两个字符串开头部分相似更高的权重。

1.1.6 pangu.py

能够自动在中文字符和英文/数字/特殊字符之间插入空格，以使文本看起来更符合中文阅读习惯
安装pangu

pip install pangu

它主要有一个函数：spacing_text()。这个函数需要一个字符串作为参数，会返回一个在适当位置添加了空格的字符串。

import pangu

text = "中文abc123"
new_text = pangu.spacing_text(text)

print(new_text)  # 输出结果：中文 abc123

在这个例子中，我们首先导入了pangu模块，然后我们有一个字符串中文和英文字母、数字混杂的**“text”。我们将"text"作为参数传递给pangu.spacing_text()**，这将返回一个新的字符串，在中文字符和其他字符之间插入空格。最后，我们打印出新的文本，你可以看到两种字符之间已经添加了空格。

pangu.py模块还提供了另一种方法，**spacing_file()**函数，用于处理文件。你只需要将文件路径作为参数传入即可，它会返回处理后的文本。

import pangu

text = pangu.spacing_file('/path/to/your/file.txt')

print(text)

在这个例子中，我们打开了一个文件，并使用**spacing_file()**函数处理文本，并返回插入适当空格后的文本。

1.1.7 shortuuid

用于生成简洁的全局唯一标识符 (UUID)。这个库的目标是生成比传统UUID更短、更方便使用的ID
安装

pip install shortuuid

import shortuuid

suuid = shortuuid.ShortUUID().random(length=22)
print(suuid)

在上面的代码中，random函数用于生成一个新的短UUID。length参数可以指定生成的UUID的长度。如果不指定长度，则默认长度为22。

你也可以通过shortuuid.uuid()方法生成基于RFC 4122 UUID的短UUID：

suuid = shortuuid.uuid()
print(suuid)

shortuuid库还能自定义编码字符集，通过set_alphabet()函数进行设置：

shortuuid.set_alphabet("0123456789abcdef")  # set the alphabet to hexadecimal characters
suuid = shortuuid.ShortUUID().random(length=10)  # generate a 10-char ID
print(suuid)

上述代码中，我们将字符集合设置为16进制字符，并生成了一个10位的ID。

1.1.8 simplejson

它提供了一种简单的方法来编码和解码 JSON 数据。该库的接口与 Python 标准库中的 json 模块非常相似。

pip install simplejson

1. 编码 JSON

import simplejson as json

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

在上述示例中, dumps() 函数用于将 Python 对象转化为 JSON 字符串。

2. 解码 JSON

import simplejson as json

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

在这个示例中, loads() 函数用于将 JSON 字符串转化为 Python 对象。

3. 自定义编码器和解码器

import simplejson as json
import datetime

class CustomJSONEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime.datetime):
            return int(obj.timestamp())
        return super().default(obj)

json_data = json.dumps(datetime.datetime.now(), cls=CustomJSONEncoder)
print(json_data)  # 输出当前时间的时间戳

在上述示例中，我们创建了一个自定义的 JSON 编码器，它将 datetime.datetime 对象转化为 Unix 时间戳。使用 cls 参数，我们可以将其传递给 dumps() 函数来使用自定义编码器。

1.1.9 unidecode

目标是将所有可能的Unicode 字符串转换为最接近的 ASCII 字符串。这就意味着它可以删除所有特殊字符，只留下字母、数字和基本的标点符号。

pip install unidecode

from unidecode import unidecode

text = "Mëtàl Hëàd"
print(unidecode(text))  # 输出 'Metal Head'

上述的代码里，unidecode() 函数将输入字符串中的非ASCII字符 —— 例如 “ë”，转换为最接近的ASCII字符，这里是 “e”。

此库还可以处理 Unicode 带发音符号的字符，甚至更复杂的如某些特殊符号，例如：

from unidecode import unidecode

text = "Mëtàl Hëàd ♯"
print(unidecode(text))  # 输出 'Metal Head #'

上述的代码中，我们看到 “♯” 被转换成了 “#”。unidecode 功能强大，可以处理全球绝大多数的语言字符，转换为ASCII字符。

**注意：**使用Unidecode库应注意，那些非西方语言在转换过程中可能会失去更多的原始含义。因此，虽然Unidecode库非常强大，但在必要的情况下再使用，特别是在处理用户的数据时，使用者需谨慎处理。

1.1.10 uniout

它能够让你在交互式解释器中易读的输出unicode字符，不再需要调用print去看清楚变量的内容。这对于处理涉及非ASCII字符的问题非常有帮助。

pip install uniout

1. 输出字符串

import uniout
data = '测试'
data  # 输出: 测试

2. 输出列表和字典

import uniout
data_dict = {'name': '测试', 'language': '汉语'}
data_dict  # 输出: {'name': '测试', 'language': '汉语'}

注意，这个库并不提供Python脚本的功能。它的主要目的是为了在交互式解释器里提供漂亮的unicode输出。

另外，uniout库在Python 3上可能会遇到问题，因为在Python3 中字符串已经默认为 Unicode 类型，这使得uniout的用途在Python3中有所减少。如果你使用的是Python 2，那么uniout将极大地方便你的Unicode处理工作。

1.1.11 flashtext

高效地在文本中找到并替换词汇。相比起使用正则表达式，Flashtext在处理大型文本和大型关键词列表时，更为高效且内存占用较小。

pip install flashtext

1. 添加查找关键词

from flashtext import KeywordProcessor
keyword_processor = KeywordProcessor()
keyword_processor.add_keyword('Python')  # 添加关键词
text = 'I love Python.'
found_keywords = keyword_processor.extract_keywords(text)
print(found_keywords)  # 输出：['Python']

上述代码中，我们首先创建了一个 KeywordProcessor，然后用 add_keyword 方法添加了关键词 ‘Python’，最后用 extract_keywords方法在文本中查找这个关键词。

2. 同时添加多个关键词

keyword_processor.add_keywords_from_list(['Python', 'language'])

3. 从文件中添加关键词

keyword_processor.add_keywords_from_file('keyword_file.txt')

4. 替换关键词

keyword_processor.add_keyword('Python', 'snake') # 第一个参数是要被替换的关键词，第二个参数是新的词
text = 'I love Python.'
new_text = keyword_processor.replace_keywords(text)
print(new_text)  # 输出: 'I love snake.'

在这个示例中，我们使用 add_keyword 方法，将 ‘Python’ 替换为 ‘snake’。然后，使用replace_keywords 方法，在文本中找到并替换关键词。

Flashtext库是在处理大数据集时查找、删除和替换关键词的有效工具。

1.1.12 esmre

用于 Python 的简单正则表达式引擎，它可以在处理大量正则表达式和大量文本数据时提供高效性能。

pip install esmre

基础的创建索引和搜索

import esmre

index = esmre.Index()

index.enter("Python", "Python")
index.enter("esmre", "esmre")

# 使用索引进行搜索
result = index.query("I love Python and esmre.")
print(result)  # 输出：[('Python', 7, 13), ('esmre', 18, 23)]

在这个例子中，我们先创建了一个 Index 实例。然后使用 enter() 方法添加了两个正则表达式（字符串 “Python” 和 “esmre”，每个都对应一个标签）。然后我们调用 query() 来查找给定字符串中所有匹配的所有正则表达式并返回它们的标签。

于是 ‘Python’ 和 ‘esmre’ 被找到，并显示它们在字符串中的开始和结束位置。在返回的结果列表中，每个元组的形式为 (标签, 开始位置, 结束位置)。

esmre是一个非常使用于处理大量正则表达式或者文本数据的库，能够大幅度的提升字符串查找和匹配的效率。

1.1.13 awesome-slugify

主要用于将字符串转变为易于处理和理解的 “slug” 形式，这在网页 URL、文件命名、标识符等情况下非常有用。Slugs 通常由小写字母、数字和连字符或者下划线组成，为了创建易于理解和优化 SEO 的 URL，这个库经常被使用。

pip install awesome-slugify

from slugify import UniqueSlugify

text = "Hello, World!"
custom_slugify = UniqueSlugify()
slug = custom_slugify(text)
print(slug)  # 输出 'hello-world'

在上述代码中，UniqueSlugify() 从 slugify 模块创建了一个对象，然后我们将一个输入字符串 “Hello, World!” 传递给它，该字符串会被转换为小写，并且所有非字母数字字符（比如空格和标点符号）会被替换成短划线，形成一个 slug。

可以通过 unique_check 函数为 UniqueSlugify 设置唯一性约束：

from slugify import UniqueSlugify

def unique_check(text, increment):
    return f"{text}{increment}"

custom_slugify = UniqueSlugify(unique_check=unique_check)
slug = custom_slugify("Hello, World!")
print(slug)  # 输出 'hello-world'

slug2nd = custom_slugify("Hello, World!")
print(slug2nd)  # 输出 'hello-world2'

在这个例子中，当我们尝试创建的第二个 slug 与之前的 slug 相同时，UniqueSlugify 会调用我们的 unique_check 函数，用于生成一个唯一的 slug。

总的来说，awesome-slugify 是一个便捷的库，用于将字符串转换成易于处理的“slug”格式，这在创建 URL、文件名或其他需要整洁、易读文本的地方非常有用。

1.1.14 python-slugify

用于将字符串转换为URL友好的格式。它可以帮助我们生成SEO友好的URL、文件名或任何需要清除特殊字符和空格的文本。

pip install python-slugify

1. 基本用法

from slugify import slugify

text = "Hello World!"
slug = slugify(text)
print(slug)  # 输出: hello-world

2. 转换为小写字母

from slugify import slugify

text = "Hello World!"
slug = slugify(text, lowercase=True)
print(slug)  # 输出: hello-world

3. 连字符替代空格

from slugify import slugify

text = "Hello World!"
slug = slugify(text, separator="-")
print(slug)  # 输出: hello-world

4. 删除特殊字符

from slugify import slugify

text = "Hello @$World!"
slug = slugify(text, regex_pattern=r'[^a-zA-Z0-9]')
print(slug)  # 输出: hello-world

1.1.15 unicode-slugify

用于将Unicode字符串转换为Slug格式（URL友好的格式）

pip install unicode-slugify

1. 使用slugify库的slugify()函数将Unicode字符串转换为Slug格式

text = "I am a Unicode string!"
slug = slugify.slugify(text)
print(slug)  # Output: "i-am-a-unicode-string"

2. 使用其他选项来自定义Slug格式的转换。例如，可以指定下划线而不是短划线作为分隔符

text = "I am a Unicode string!"
slug = slugify.slugify(text, separator='_')
print(slug)  # Output: "i_am_a_unicode_string"

3. 通过设置allow_unicode参数为True来保留Unicode字符而不转换为ASCII字符

text = "I am a Unicode string!"
slug = slugify.slugify(text, allow_unicode=True)
print(slug)  # Output: "i-am-a-unicode-string"

1.1.16 phonenumbers

用于解析、验证和格式化电话号码

pip install phonenumbers

1. 使用phonenumbers库的parse()函数解析电话号码：

import phonenumbers

phone_number = "123-456-7890"
parsed_number = phonenumbers.parse(phone_number, "US")
print(parsed_number)  # Output: Country Code: 1 National Number: 1234567890

2. 使用phonenumbers库的is_valid_number()函数验证电话号码是否有效

import phonenumbers

phone_number = "+14155552671"
is_valid = phonenumbers.is_valid_number(phonenumbers.parse(phone_number))
print(is_valid)  # Output: True

3. 使用phonenumbers库的format_number()函数格式化电话号码

import phonenumbers

phone_number = "+14155552671"
formatted_number = phonenumbers.format_number(phonenumbers.parse(phone_number), phonenumbers.PhoneNumberFormat.E164)
print(formatted_number)  # Output: +14155552671

1.1.17 PLY（Python Lex-Yacc）

用于编写词法分析器和语法分析器的Python库

pip install ply

import ply.lex as lex
import ply.yacc as yacc

定义词法分析器的规则（使用lex模块）和语法分析器的规则（使用yacc模块）。词法分析器规则用于将输入字符串分割成记号，语法分析器规则用于定义语法规则和语义动作

1. 创建词法分析器和语法分析器

# 词法分析器实例
lexer = lex.lex()

# 语法分析器实例
parser = yacc.yacc()

2. 对输入字符串进行词法分析和语法分析

input_string = "1 + 2 * 3"
result = parser.parse(input_string)
print(result)  # Output: 7

1.1.18 Pygments

用于语法高亮显示代码

pip install pygments

from pygments import highlight
from pygments.lexers import get_lexer_by_name
from pygments.formatters import HtmlFormatter

1. 使用Pygments库的highlight()函数进行语法高亮显示

code = "def hello_world():\n    print('Hello, World!')"
lexer = get_lexer_by_name("python")
formatted_code = highlight(code, lexer, HtmlFormatter())
print(formatted_code)

2. 可以使用不同的语言选项来指定要高亮显示的代码的语言。例如，上面的例子使用的是Python

code = "const message = 'Hello, World!';"
lexer = get_lexer_by_name("javascript")
formatted_code = highlight(code, lexer, HtmlFormatter())
print(formatted_code)

get_lexer_by_name() 可以接受语言名称字符串作为参数，例如"python"、"javascript"等。

HtmlFormatter() 是用于生成HTML格式的高亮代码的格式化器。你可以根据需要自定义输出的样式。

这些示例展示了Pygments库的基本用法和一些常用功能，包括导入库、选择语言和格式化选项以及使用highlight() 函数生成高亮代码

1.1.19 pyparsing

用于构建解析器和实现文本解析

pip install pyparsing

import pyparsing as pp

1. 使用pyparsing库的一些基本构造块来定义解析规则，例如字面量、标识符

integer = pp.Word(pp.nums)
identifier = pp.Word(pp.alphas)

2. 使用pyparsing库的操作符和组合函数来定义更复杂的解析规则，例如序列、选择、重复

expr = integer + pp.Suppress("+") + integer

3. 使用pyparsing库的parseString()函数对输入进行解析

input_string = "123 + 456"
result = expr.parseString(input_string)
print(result)  # Output: ['123', '+', '456']

1.1.20 python-user-agents

用于解析用户代理字符串（User Agent String）并提供对应的设备、浏览器和操作系统信息

pip install python-user-agents

from user_agents import parse

1. 使用UserAgent类的parse()函数解析用户代理字符串

user_agent_string = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.75 Safari/537.36"
user_agent = parse(user_agent_string)

2. 访问UserAgent对象的属性获取设备、浏览器和操作系统信息

print(user_agent.device)  # Output: "Other"
print(user_agent.browser)  # Output: "Chrome"
print(user_agent.browser.version)  # Output: (86, 0, 4240)
print(user_agent.os)  # Output: "Windows NT 10.0"

3. 根据需要，可以使用UserAgent对象的其他属性，如is_mobile、is_tablet和is_touch_capable等，来获取更详细的设备信息

# is_mobile：如果设备是移动设备（手机），返回True；否则返回False
print(user_agent.is_mobile)  # Output: False

# is_tablet：如果设备是平板电脑，返回True；否则返回False
print(user_agent.is_tablet)  # Output: False

# is_touch_capable：如果设备支持触摸操作，返回True；否则返回False
print(user_agent.is_touch_capable)  # Output: False

# is_pc：如果设备是个人计算机（PC），返回True；否则返回False
print(user_agent.is_pc)  # Output: True

1.1.21 sqlparse

解析、分析和格式化SQL语句

pip install sqlparse
import sqlparse

1. 使用sqlparse库的parse()函数解析SQL语句

sql = "SELECT * FROM users WHERE age > 18;"
parsed = sqlparse.parse(sql)[0]

2. 访问解析后的SQL语句的各个部分

print(parsed.get_type())  # Output: "SELECT"
print(parsed.tokens)  # Output: ['SELECT', ' ', '*', ' ', 'FROM', ' ', 'users', ' ', 'WHERE', ' ', 'age', ' ', '>', ' ', '18', ';']

3. 使用sqlparse库的format()函数将解析后的SQL语句重新格式化

formatted = sqlparse.format(parsed.to_unicode(), reindent=True, keyword_case='upper')
print(formatted)  # Output: "SELECT *\nFROM users\nWHERE age > 18;"

4. 处理嵌套查询

sql = "SELECT * FROM (SELECT * FROM users WHERE age > 18) AS subquery WHERE gender = 'female';"
parsed = sqlparse.parse(sql)[0]

# 获取嵌套查询的子查询
subquery = parsed.tokens[6]
print(subquery.get_type())  # Output: "SELECT"

# 获取子查询中的WHERE条件
where_clause = subquery.tokens[-1]
print(where_clause)  # Output: "WHERE age > 18"

5. 分析表达式

sql = "SELECT age + 5 AS result FROM users WHERE age > 18;"
parsed = sqlparse.parse(sql)[0]

# 获取SELECT语句中的表达式
expression = parsed.tokens[2]
print(expression)  # Output: "age + 5"

# 检查表达式是否包含特定的操作符
if any(token.value == '+' for token in expression.tokens):
    print("表达式中包含加法操作符")

6. 处理JOIN语句

sql = "SELECT * FROM table1 JOIN table2 ON table1.id = table2.id;"
parsed = sqlparse.parse(sql)[0]

# 获取JOIN语句的表名和连接条件
tables = parsed.get_real_name(0)
conditions = parsed.tokens[-1]
print(tables)  # Output: "table1 JOIN table2"
print(conditions)  # Output: "ON table1.id = table2.id"

7. 解析子查询的结果集

sql = "SELECT * FROM (SELECT * FROM table1 UNION SELECT * FROM table2) AS subquery;"
parsed = sqlparse.parse(sql)[0]

# 获取子查询的结果集
subquery = parsed.tokens[6]
subquery_result = subquery.tokens[-2]
print(subquery_result)  # Output: "SELECT * FROM table1 UNION SELECT * FROM table2"