Logo

菜单

Re.Vi
Re.Vi
发布于 2024-03-26 / 22 阅读
3
0

python常用模块功能

#python

json

特殊json解码

import json
def as_complex(dct):
    if '__complex__' in dct:
        return complex(dct['real'], dct['imag'])
    return dct

json.loads('{"__complex__": true, "real": 1, "imag": 2}',
    object_hook=as_complex)

import decimal
json.loads('1.1', parse_float=decimal.Decimal)

扩展 JSONEncoder：

import json
class ComplexEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, complex):
            return [obj.real, obj.imag]
        # Let the base class default method raise the TypeError
        return super().default(obj)

json.dumps(2 + 1j, cls=ComplexEncoder)

ComplexEncoder().encode(2 + 1j)

list(ComplexEncoder().iterencode(2 + 1j))

keywords-关键字

  • False: 代表布尔类型的假值。
  • await: 用于在异步函数中等待一个异步操作完成。
  • else: 在条件语句中，如果条件不满足，则执行 else 语句块中的代码。
  • import: 用于导入模块或模块中的特定内容。
  • pass: 一个占位符语句，不执行任何操作，通常用于在语法上需要语句但不需要实际代码的情况下。
  • None: 代表空值或缺失值。
  • break: 在循环语句中，用于跳出当前循环。
  • except: 在异常处理中，用于捕获和处理异常。
  • in: 用于判断一个值是否存在于一个容器（如列表、元组、字典等）中。
  • raise: 用于引发异常。
  • True: 代表布尔类型的真值。
  • class: 用于定义一个类。
  • finally: 在异常处理中，无论是否发生异常，都会执行 finally 语句块中的代码。
  • is: 用于比较两个对象是否是同一个对象。
  • return: 用于从函数中返回一个值。
  • and: 逻辑运算符，用于同时判断多个条件是否为真。
  • continue: 在循环语句中，用于结束当前迭代并开始下一次迭代。
  • for: 用于循环迭代一个可迭代对象（如列表、元组、字典等）中的元素。
  • lambda: 用于创建匿名函数。
  • try: 在异常处理中，用于尝试执行可能引发异常的代码块。
  • as: 用于给导入的模块或模块中的内容指定别名。
  • def: 用于定义一个函数。
  • from: 从模块中导入特定的内容。
  • nonlocal: 用于在嵌套函数中修改外部函数的局部变量。
  • while: 在满足条件的情况下，重复执行一段代码块。
  • assert: 用于在调试过程中检查一个条件是否为真，如果条件为假，则引发 AssertionError 异常。
  • del: 用于删除变量或删除容器中的元素。
  • global: 用于在函数内部声明一个全局变量。
  • not: 逻辑运算符，用于对一个条件取反。
  • with: 用于创建一个上下文管理器，提供对资源的安全管理。
  • async: 用于定义一个异步函数。
  • elif: 在条件语句中，如果前面的条件不满足，则检查下一个条件。
  • if: 用于根据条件执行不同的代码块。
  • or: 逻辑运算符，用于判断多个条件中是否至少有一个为真。
  • yield: 在生成器函数中，用于产生一个值，并暂停函数的执行，直到下一次迭代。

logging

要在控制台输出中设置不同级别的日志消息的颜色，您可以使用第三方库如 colorlog 或 termcolor。这些库提供了在终端中添加颜色和样式的功能。

下面是使用 colorlog 库的示例代码：

首先，确保您已经安装了 colorlog 库。可以使用以下命令进行安装：

pip install colorlog

然后，您可以在 logging_config.py 中进行如下的修改：

# logging_config.py

import logging
import logging.config
import colorlog

# 创建一个 ColorFormatter
color_formatter = colorlog.ColoredFormatter(
    '%(log_color)s%(levelname)s:%(name)s:%(message)s',
    log_colors={
        'DEBUG': 'cyan',
        'INFO': 'green',
        'WARNING': 'yellow',
        'ERROR': 'red',
        'CRITICAL': 'red,bg_white',
    }
)

log_config = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'color_formatter': {
            '()': colorlog.ColoredFormatter,
            'format': '%(log_color)s%(levelname)s:%(name)s:%(message)s',
            'log_colors': {
                'DEBUG': 'cyan',
                'INFO': 'green',
                'WARNING': 'yellow',
                'ERROR': 'red',
                'CRITICAL': 'red,bg_white',
            }
        }
    },
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
            'level': 'DEBUG',
            'formatter': 'color_formatter'
        }
    },
    'root': {
        'level': 'DEBUG',
        'handlers': ['console']
    }
}

logging.config.dictConfig(log_config)

在上述代码中，我们创建了一个 ColorFormatter 对象，并为不同的日志级别设置了不同的颜色。然后，在日志配置中使用这个 ColorFormatter。

接下来，在需要使用日志记录的文件中，按照之前的方式导入 logging_config 模块，并使用日志记录器打印日志消息。日志消息将以相应的颜色显示在控制台中。

# main.py

import logging
import logging_config

# 使用日志记录
logger = logging.getLogger(__name__)
logger.debug('这是调试信息')
logger.info('这是信息提示')
logger.warning('这是警告信息')
logger.error('这是错误信息')
logger.critical('这是严重错误信息')

这样，不同级别的日志消息将以不同的颜色显示在控制台中。

请注意，colorlog 是一个第三方库，它提供了更多的颜色和样式选项，您可以根据需要进行自定义。

tempfile

以下是 tempfile 模块典型用法的一些示例:

# Create a temporary file and write 'Hello world!' to it
import tempfile

fp = tempfile.TemporaryFile()
fp.write(b'Hello world!')

# Move the cursor to the beginning of the file and read its content
fp.seek(0)
fp.read()

# Close the file
fp.close()

# Create a temporary file using 'with' statement, write 'Hello world!', read the content and automatically close the file
with tempfile.TemporaryFile() as fp:
 fp.write(b'Hello world!')
 fp.seek(0)
 fp.read()

# Create a named temporary file, write 'Hello world!' to it, close the file and then open it again using its name
# Note: the file is closed, but not removed
with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
 fp.write(b'Hello world!')
 fp.close()
 with open(fp.name, mode='rb') as f:
     f.read()

# Create a temporary directory and print its name
with tempfile.TemporaryDirectory() as tmpdirname:
 print('created temporary directory', tmpdirname)

traceback-打印或读取栈回溯信息

下面的例子演示了打印和格式化异常与回溯的不同方式:

import sys, traceback

def lumberjack():
    bright_side_of_life()

def bright_side_of_life():
    return tuple()[0]

try:
    lumberjack()
except IndexError:
    exc = sys.exception()
    print("*** print_tb:")
    traceback.print_tb(exc.__traceback__, limit=1, file=sys.stdout)
    print("*** print_exception:")
    traceback.print_exception(exc, limit=2, file=sys.stdout)
    print("*** print_exc:")
    traceback.print_exc(limit=2, file=sys.stdout)
    print("*** format_exc, first and last line:")
    formatted_lines = traceback.format_exc().splitlines()
    print(formatted_lines[0])
    print(formatted_lines[-1])
    print("*** format_exception:")
    print(repr(traceback.format_exception(exc)))
    print("*** extract_tb:")
    print(repr(traceback.extract_tb(exc.__traceback__)))
    print("*** format_tb:")
    print(repr(traceback.format_tb(exc.__traceback__)))
    print("*** tb_lineno:", exc.__traceback__.tb_lineno)

*** print_tb:
  File "<doctest...>", line 10, in <module>
    lumberjack()
*** print_exception:
Traceback (most recent call last):
  File "<doctest...>", line 10, in <module>
    lumberjack()
  File "<doctest...>", line 4, in lumberjack
    bright_side_of_life()
IndexError: tuple index out of range
*** print_exc:
Traceback (most recent call last):
  File "<doctest...>", line 10, in <module>
    lumberjack()
  File "<doctest...>", line 4, in lumberjack
    bright_side_of_life()
IndexError: tuple index out of range
*** format_exc, first and last line:
Traceback (most recent call last):
IndexError: tuple index out of range
*** format_exception:
['Traceback (most recent call last):\n',
 '  File "<doctest default[0]>", line 10, in <module>\n    lumberjack()\n',
 '  File "<doctest default[0]>", line 4, in lumberjack\n    bright_side_of_life()\n',
 '  File "<doctest default[0]>", line 7, in bright_side_of_life\n    return tuple()[0]\n           ~~~~~~~^^^\n',
 'IndexError: tuple index out of range\n']
*** extract_tb:
[<FrameSummary file <doctest...>, line 10 in <module>>,
 <FrameSummary file <doctest...>, line 4 in lumberjack>,
 <FrameSummary file <doctest...>, line 7 in bright_side_of_life>]
*** format_tb:
['  File "<doctest default[0]>", line 10, in <module>\n    lumberjack()\n',
 '  File "<doctest default[0]>", line 4, in lumberjack\n    bright_side_of_life()\n',
 '  File "<doctest default[0]>", line 7, in bright_side_of_life\n    return tuple()[0]\n           ~~~~~~~^^^\n']
*** tb_lineno: 10

tracemalloc-跟踪和分析内存分配

基本使用

tracemalloc 是 Python 标准库中的一个模块，用于跟踪和分析内存分配的情况。它可以帮助您找出代码中的内存泄漏和高内存使用的问题。下面是一个简单的示例，展示了如何使用 tracemalloc 模块：

import tracemalloc

# 开始跟踪内存分配
tracemalloc.start()

# 运行您的代码
# ...

# 获取当前内存分配的快照
snapshot = tracemalloc.take_snapshot()

# 打印出前 10 个内存分配的统计信息
top_stats = snapshot.statistics('lineno')
print("[ Top 10 Memory Allocation ]")
for stat in top_stats[:10]:
    print(stat)

# 停止跟踪内存分配
tracemalloc.stop()

在上面的示例中，我们首先使用 tracemalloc.start() 开始跟踪内存分配。然后，在您的代码运行期间，tracemalloc 会记录内存分配的信息。

在代码的适当位置，使用 tracemalloc.take_snapshot() 获取当前的内存分配快照。您可以在需要的地方获取多个快照，以便进行比较和分析。

接下来，使用 snapshot.statistics('lineno') 获取内存分配的统计信息。'lineno' 参数表示按照行号进行统计，您也可以选择其他参数，如 'traceback'。

最后，使用 print 语句或其他方式输出统计信息，以便查看内存分配的情况。

在完成内存分析后，使用 tracemalloc.stop() 停止跟踪内存分配。

请注意，tracemalloc 模块在 Python 3.4 及更高版本中可用。

获取统计信息

在 tracemalloc 模块中，您可以使用以下方法来获取内存分配的统计信息：

  1. take_snapshot(): 获取当前的内存分配快照。您可以在需要的地方获取多个快照，以便进行比较和分析。

  2. snapshot.statistics(key_type='lineno'): 获取内存分配的统计信息。可以使用不同的 key_type 参数来指定统计的方式，常用的参数包括：

    • 'lineno'：按照行号进行统计，返回每行的内存分配量。
    • 'filename'：按照文件名进行统计，返回每个文件的内存分配量。
    • 'traceback'：按照调用栈进行统计，返回每个调用栈的内存分配量。

    该方法返回一个列表，其中每个元素都是一个 Traceback 对象，包含了相应的统计信息。

  3. snapshot.filter_traces(inclusive=True, filename=None, lineno=None): 根据条件过滤内存分配的统计信息。可以使用以下参数进行过滤：

    • inclusive：如果为 True，则返回与指定条件匹配的内存分配统计信息；如果为 False，则返回与指定条件不匹配的统计信息。
    • filename：指定要过滤的文件名。
    • lineno：指定要过滤的行号。

    该方法返回一个新的 Snapshot 对象，其中包含了符合条件的统计信息。

  4. Traceback: Traceback 对象表示一条调用栈信息，包含了相关的统计信息。它具有以下属性：

    • traceback: 调用栈的字符串表示。
    • size: 内存分配的总大小。
    • count: 内存分配的次数。
    • lineno: 调用栈的起始行号。
    • filename: 调用栈所在的文件名。

这些方法和属性可以帮助您获取和分析内存分配的统计信息，以便找出内存泄漏和高内存使用的问题。

centos7安装深度学习环境
ArcMap入门

评论