Notas do processo de aprendizagem Python: Módulo principal (principal) Tratamento de exceções Análise de parâmetros de linha de comando Registro em log do método privado String de bytes da classe do módulo de soquete

Diretório de artigos

1. Programa principal em Python

if __name__ == '__main__'

Em Python, if __name__ == '__main__'é um bloco de código comum. Sua função é determinar se o módulo atual é executado diretamente como programa principal ou se é importado e utilizado como módulo por outros programas.

Quando um script Python é executado diretamente, __name__o valor do seu atributo é definido como '__main__'. E quando o script for importado como módulo, __name__o valor será o nome do módulo.

Portanto, usando if __name__ == '__main__'julgamento condicional, podemos colocar alguns trechos de código dentro deste bloco condicional, que só será executado quando o script for executado como programa principal, mas não será executado quando for importado como módulo.

Esse uso geralmente é usado para colocar algum código de teste ou código que executa tarefas específicas no programa principal sem executá-lo automaticamente quando o módulo é importado. Isso torna o módulo mais flexível e reutilizável.

2. Tratamento de exceções em Python

Em Python, tryos blocos são usados para capturar código que pode lançar exceções. Sua estrutura gramatical é a seguinte:

try:
    # 可能引发异常的代码
except ExceptionType1:
    # 处理 ExceptionType1 类型的异常
except ExceptionType2:
    # 处理 ExceptionType2 类型的异常
else:
    # 当没有异常发生时执行的代码
finally:
    # 无论是否发生异常都会执行的代码

módulo try : tryO código contido no bloco é a parte que pode lançar uma exceção. Se tryo código dentro de um bloco lançar uma exceção, o Python ignorará o trycódigo do bloco restante e encontrará exceptum bloco que corresponda ao tipo de exceção lançada para tratar a exceção.
exceto seção : exceptpode haver zero ou mais blocos, que são usados para lidar com tipos específicos de exceções. Você pode especificar o tipo de exceção, como
ExceptionType1 , ExceptionType2, etc., ou pode usar o geral Exceptionpara capturar todas as exceções. Quando o tipo de exceção lançado exceptcorresponder ao tipo de exceção especificado por um bloco, excepto código do bloco será executado.
else part : elseO bloco é opcional e contém código que será tryexecutado quando o código do bloco não lançar nenhuma exceção. Normalmente, elsedentro de um bloco, você pode colocar uma lógica que trata quando nenhuma exceção ocorre.
finalmente bloco : finallyO bloco também é opcional e contém código que será executado independentemente de ocorrer uma exceção. É comum finallycolocar algum código em um bloco que limpa recursos, como fechar um arquivo aberto ou liberar outros recursos.

Nota : exceptPelo menos um bloco é necessário, enquanto elsetanto o bloco quanto finallyo bloco são opcionais. tryBlocos e pelo menos um exceptbloco são as construções de sintaxe mais básicas usadas para capturar e tratar exceções.

3. Análise de parâmetros de linha de comando em Python

argparseÉ um módulo da biblioteca padrão Python usado para analisar argumentos de linha de comando e gerar interfaces de linha de comando amigáveis. Entre elas, ArgumentParserestá argparseuma aula importante do módulo.

ArgumentParserA classe é usada para definir regras de análise para parâmetros de linha de comando. Ela fornece uma maneira simples e flexível de processar parâmetros de linha de comando. Ao criar um ArgumentParserobjeto, você pode definir os parâmetros exigidos pelo seu programa e escrever código para lidar com esses parâmetros.

Aqui estão ArgumentParseralguns métodos comumente usados da classe:

 ArgumentParser(prog=None, description=None, epilog=None)

Crie um ArgumentParserobjeto. progOs parâmetros são usados para especificar o nome do programa (o padrão é sys.argv[0]), os descriptionparâmetros são usados para adicionar informações de descrição do programa e epilogos parâmetros são usados para adicionar informações finais do programa. Geralmente, pode ser criado sem parâmetros.

.add_argument(name or flags, action, nargs, const, default, type, choices, required, help, metavar)

Defina um parâmetro de linha de comando. Este método tem muitos parâmetros, alguns dos mais comumente usados incluem:

name or flags: o nome do parâmetro ou sinalizador de opção.
action: A ação do parâmetro, o padrão é armazenar o valor do parâmetro. Normalmente não há necessidade de definir este parâmetro.
nargs: O número de parâmetros, que pode ser um valor fixo ou um número variável. onde nargs='?'significa que o parâmetro pode ter zero ou um valor.
const: Valor constante utilizado em determinadas ações (como store_const).
default:Valor padrão do parâmetro.
type: O tipo de parâmetro.
choices: O intervalo limitado de valores de parâmetros.
required: se o parâmetro é obrigatório.
help:Informações de ajuda para parâmetros.
metavar: o nome do parâmetro exibido nas informações de ajuda.

.parse_args(args=None, namespace=None)

Analisa argumentos de linha de comando e retorna um objeto de namespace contendo o valor do argumento. argsOs argumentos são uma lista de strings que especificam os argumentos da linha de comando a serem analisados. Se nenhum argsargumento for fornecido, sys.argv[1:] será usado por padrão. namespaceO parâmetro é usado para especificar o objeto namespace. Se não for fornecido, um novo objeto namespace será criado.

4. Login em Python

O módulo do Python loggingé uma ferramenta poderosa para registro. Ele fornece funções de registro flexíveis que podem ajudá-lo a capturar, registrar e gerenciar vários tipos de informações de registro em seus aplicativos.

Aqui estão loggingalguns componentes e conceitos principais de módulos:

Logger : LoggerÉ loggingum dos componentes mais importantes do módulo. Ele fornece métodos para gravar mensagens de log, como debug(), info(), e . Você pode criar diversas instâncias para diferentes necessidades de registro.warning()error()critical()Logger
Manipulador : Handlerusado para determinar o destino do log, como console, arquivo ou rede. Os módulos loggingfornecem vários tipos Handler, como StreamHandler,,,, etc.FileHandlerRotatingFileHandlerTimedRotatingFileHandler
Formatador : FormatterDetermina o formato de saída das mensagens de log. Você pode definir formatos personalizados, incluindo data, hora, nível de registro, informações de registro, etc.
Filtro : FilterUsado para filtrar e selecionar mensagens de log a serem gravadas. Ao aplicar filtros, você pode decidir quais mensagens de log devem ser registradas e quais devem ser ignoradas.
Logger.setLevel() : Ao chamar setLevel()o método, você pode definir o nível mínimo de registro. Somente mensagens de log deste nível ou superior serão registradas.
Logger.addHandler() : Usando addHandler()o método, você pode adicionar um ou mais manipuladores (Handler) ao logger (Logger). Dessa forma, as mensagens de log serão passadas a esses manipuladores para processamento.

loggingAs etapas básicas para registrar usando o módulo são as seguintes:

Módulo de importação logging.
Crie uma Loggerinstância.
Crie uma ou mais Handlerinstâncias e defina seu nível e formato.
Adicione Handlera Logger.
LoggerRegistrar mensagens usando o método de registro do .

Aqui está um exemplo simples que demonstra como usar loggingo módulo para registro:

import logging

# 创建 Logger 实例
logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)

# 创建文件处理程序
file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.INFO)

# 创建控制台处理程序
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)

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

# 将 Formatter 应用于处理程序
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 将处理程序添加到 Logger
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# 记录日志消息
logger.debug('Debug message')
logger.info('Info message')
logger.warning('Warning message')
logger.error('Error message')
logger.critical('Critical message')

No exemplo acima, criamos uma instância chamada my_loggere Loggerdefinimos seu nível como DEBUG. Em seguida, criamos um manipulador de arquivo e um manipulador de console e definimos o nível e o formato para eles. Por fim, adicionamos esses dois manipuladores Loggere Loggerregistramos diferentes níveis de mensagens de log usando o método de registro do .

No loggingmódulo, os níveis de registro são representados por valores inteiros, com os seguintes níveis predefinidos (em ordem do menor para o maior):

DEBUG : para informações detalhadas de depuração.
INFO : usado para fornecer informações de execução do programa.
AVISO : Utilizado para indicar possíveis problemas, mas não afetará o funcionamento normal do programa.
ERRO : Usado para indicar uma condição de erro, mas o programa ainda pode continuar a ser executado.
CRÍTICO : Usado para indicar um erro grave que pode impedir a execução do programa.

Os valores inteiros para esses níveis são 10, 20, 30, 40 e 50 respectivamente. Quanto menor o valor do nível, menor o nível do log; quanto maior o valor do nível, maior o nível do log.

Ao definir um nível de Loggerou Handler, somente as mensagens de log que atingirem esse nível ou superior serão registradas. Por exemplo, se Loggero nível de for definido como WARNING, as mensagens WARNINGde log nos níveis ERRORe serão registradas, enquanto as mensagens de log nos níveis e serão ignoradas.CRITICALDEBUGINFO

Além disso, loggingo módulo fornece um nível especial NOTSETcom um valor inteiro igual a 0. Se o nível de Loggerou Handlerestiver definido como NOTSET, ele usará o nível de seu pai. Se não houver nível pai, o nível padrão será WARNING.

5. Módulo de soquete de programação de rede

socketMódulos em Python são uma ferramenta importante quando se trata de programação de redes . Ele permite criar objetos de soquete para comunicação em rede.

A seguir está socketuma breve introdução ao módulo:

Soquete : Soquete é o componente básico da comunicação de rede e é usado para transmitir dados entre diferentes hosts. socket()Função usada para criar objetos de soquete. Você precisa especificar a família de endereços (como AF_INET para IPv4) e o tipo de soquete (como SOCK_STREAM para soquete TCP). Depois que o objeto soquete for criado, você poderá usar bind()métodos para vincular o soquete a um endereço e porta específicos.
Ouvindo : Ao usar listen()o método, você pode começar a ouvir solicitações de conexão recebidas.
Receber conexão : o servidor pode usar accept()o método para aceitar a solicitação de conexão do cliente e criar um novo objeto de soquete para lidar com a comunicação com o cliente. Depois que a conexão for estabelecida, você poderá usar os send()métodos do objeto soquete para enviar dados e seus recv()métodos para receber dados.

Aqui está um exemplo simples que mostra como usar socketo módulo para criar um servidor TCP simples:

import socket

# 创建套接字对象
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定地址和端口
server_address = ('localhost', 8888)
server_socket.bind(server_address)

# 监听连接
server_socket.listen(1)
print('服务器正在监听端口 8888...')

# 接受连接并处理请求
while True:
    client_socket, client_address = server_socket.accept()
    print('接受来自', client_address, '的连接')

    # 接收数据
    data = client_socket.recv(1024)
    print('接收到的数据:', data.decode())

    # 发送响应
    response = 'Hello, client!'
    client_socket.send(response.encode())

    # 关闭连接
    client_socket.close()

No exemplo acima, criamos um servidor TCP vinculado à porta 8888 do localhost. O servidor começa a escutar conexões e após aceitar a conexão, recebe os dados enviados pelo cliente e envia uma resposta.

Além disso, quando você precisar obter o nome do host atual para bindvincular um soquete em uma função, poderá usar socket.gethostname()a função. Esta função obtém o nome do host consultando o sistema operacional. Ele retorna uma string que representa o nome do host do host atual.

Os métodos e métodos socketdo módulo serão analisados a seguir :sendsendall

socketNos módulos do Python , send()funções e sendall()funções são usadas para enviar dados para um soquete conectado, mas existem algumas diferenças na maneira como elas lidam com os dados.

método send : send()a função é usada para enviar blocos de dados. Ele enviará o máximo possível dos dados especificados e retornará o número real de bytes enviados. Se send()não puder enviar todos os dados de uma vez (por exemplo, o buffer de envio do soquete estiver cheio), ele poderá enviar apenas parte dos dados. Neste caso, você pode ligar novamente send()para enviar os dados restantes.
Método sendall : sendall()A função também é usada para enviar blocos de dados, mas fará o possível para enviar todos os dados especificados. Ele continuará a enviar dados até que todos os dados tenham sido enviados com êxito ou até que ocorra um erro. Se ocorrer um erro durante o envio, sendall()a função lançará uma exceção. Portanto, garante que não retornará até que todos os dados tenham sido enviados.

A escolha de qual função usar depende de seus requisitos. Se quiser saber o número real de bytes enviados ao enviar dados ou se precisar lidar manualmente com o envio dos dados restantes, você pode usar send()funções. Se quiser garantir que todos os dados sejam enviados intactos e não quiser lidar manualmente com erros de envio, você pode usar sendall()funções.

6. Métodos privados em Python

Em Python, não existem métodos estritamente privados. No entanto, a convenção de prefixar nomes de métodos com um sublinhado duplo (__) identifica os métodos como internos à classe, o que significa que são privados.

Quando o nome do método começa com um sublinhado duplo, o interpretador Python executará automaticamente a manipulação do nome do método e o converterá na _ClassName__methodforma de . Isso é feito para evitar a substituição acidental de métodos de classe pai em subclasses.

7. Sequências de bytes em Python

Em Python, existem dois tipos principais de strings: strings (str) e strings de bytes (bytes).

String : Uma string (str) é uma sequência de caracteres Unicode usados para representar dados de texto. Strings são imutáveis em Python e podem ser colocadas entre aspas simples ou duplas, como 'Hello' ou "World".
String de bytes : String de bytes (bytes) é uma sequência de bytes usada para representar dados binários. Strings de bytes também são imutáveis em Python, começam com b e podem ser colocadas entre aspas simples ou duplas, b'\x48\x65\x6c\x6c\x6f'por exemplo.

Ao lidar com dados de texto, geralmente é usado o tipo string (str). Ao lidar com dados binários (como leitura e gravação de arquivos, transmissão de rede, etc.), é mais comum usar o tipo byte string (bytes).

Existem vários motivos pelos quais strings de bytes são frequentemente usadas em vez de strings ao transmitir pela rede:

A unidade básica de transmissão em rede são bytes : redes de computadores transmitem dados em bytes. Seja na Internet ou em uma rede local, os dados são transmitidos pela rede em formato binário. Portanto, a codificação dos dados como uma sequência de bytes mapeia mais diretamente os dados reais transmitidos pela rede.
A expressão e transmissão de dados binários são mais eficientes : Na transmissão em rede, vários tipos de dados geralmente precisam ser processados, incluindo texto, imagens, áudio, vídeo, etc. Esses dados são geralmente representados em formato binário e transmitidos usando um esquema de codificação específico. Esses dados binários podem ser representados e processados de forma mais eficiente usando cadeias de bytes sem introduzir conversão adicional e sobrecarga de processamento.
Consistência de codificações e conjuntos de caracteres : Na transmissão em rede entre diferentes sistemas de computador, sistemas operacionais e países, a consistência das codificações e conjuntos de caracteres é uma consideração importante. As strings podem ter representações diferentes sob diferentes esquemas de codificação, enquanto as strings de bytes são representações diretas de dados binários. Ao usar cadeias de bytes, você pode evitar inconsistências entre codificações e conjuntos de caracteres, reduzindo assim possíveis erros e confusão na transmissão de dados.
Compatibilidade e interoperabilidade : Strings de bytes são uma representação universal de dados que pode ser usada em praticamente qualquer linguagem de programação e plataforma. Eles oferecem compatibilidade e interoperabilidade mais amplas, permitindo integração perfeita com uma variedade de protocolos de rede e bibliotecas de transferência de dados.

Em Python, encode()é um método do objeto String usado para codificar uma string em uma string de bytes. Ele aceita um parâmetro que especifica o esquema de codificação de caracteres a ser usado.

Aqui está encode()a sintaxe básica do método:

encoded_bytes = string.encode(encoding)

em:

stringé a string a ser codificada.
encodingé uma string que especifica o esquema de codificação de caracteres a ser usado. Esquemas comuns de codificação de caracteres incluem UTF-8, ASCII, Latin-1, etc.