Skip to main content

Métodos



len()​

Já foi visto outras vezes, é usado para retornar o tamanho de strings (informando quantos caracteres possui), listas (informando quantos elementos possui), dicionários (informando quantas chaves possui) dentre outras formas que podemos usar o len().

lista = ['joao', 'rodrigo', 'joao', 'picles']
m = "teste"
dict_test = { '1': 'key1', '2': 'key2', '3': 'key3' }

len(lista)
# 4

len(m)
# 5

len(dict_test)
# 3


isdigit()​

Usado para verifica se é um número, porém, não trabalha com números:

lista = ['joao', 'rodrigo', 'joao', 'picles']
m = "teste"
n = 2

lista[0].isdigit()
# False

m.isdigit()
# False

n.isdigit()
# Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
# AttributeError: 'int' object has no attribute 'isdigit'


os.walk()​

Podemos usar o método walk() que está dentro do módulo os para procurar arquivos no Sistema Operacional, para isso você deve saber exatamente onde está o arquivo, vamos ver um exemplo:

import os

# Onde buscar os arquivos:
search_path = '/tmp/'

# Nome do arquivo a ser encontrado:
find_file = 'encontrar.txt'

for root, dir, files in os.walk(search_path):
    if find_file in files:
        print(os.path.join(root, find_file))


# Resultado: /tmp/encontrar.txt


## 'root' vai mostrar todos os diretórios dentro do caminho especificado.

## 'dirs' ou 'dir' vai gerar uma lista com diretórios, essa lista contém diretórios que estão abaixo de um mesmo diretório pai.

## 'files' vai mostrar todos os arquivos encontrados

Para casos onde não sabemos o nome completo, podemos fazer assim:

import os

# Onde buscar os arquivos:
search_path = '/tmp/'

# Nome do arquivo a ser encontrado:
find_file = 'encon'

for root, dir, files in os.walk(search_path):

    for match in files:
        if find_file in match:
            print(os.path.join(root, match))

            
# Resultado: /tmp/encontrar.txt


tuple()​

A função tuple() é usada para converter outro objeto iterável em uma tupla. Isso significa que qualquer estrutura de dados que possa ser percorrida (como listas, strings ou até dicionários) pode ser passada como argumento para tuple(), e ela retornará uma tupla com os elementos desse iterável. Por exemplo:

tuple([1, 2, 3])        # retorna (1, 2, 3)
tuple("abc")            # retorna ('a', 'b', 'c')
tuple((x for x in range(3)))  # retorna (0, 1, 2)

Se for chamada sem argumentos, tuple() retorna uma tupla vazia:

tuple()    # retorna ()

A função é muito útil para garantir a imutabilidade de dados que originalmente vêm em formatos mutáveis, como listas. Ao transformar uma lista em tupla, você impede alterações acidentais no conteúdo.



splitlines()​

O método splitlines() é usado em strings e serve para dividir um texto em várias linhas, separando a string original sempre que encontra um caractere de quebra de linha (\n, \r, ou \r\n).


Quando você chama texto.splitlines(), ele devolve uma lista onde cada item é uma linha do texto original, sem os caracteres de quebra de linha.


Exemplo:

mensagem = """linha 1
linha 2
linha 3"""

linhas = mensagem.splitlines()
print(linhas)

Resultado:

['linha 1', 'linha 2', 'linha 3']

Se quiser manter os caracteres de quebra de linha no final de cada item da lista, você pode passar o argumento True:

linhas = mensagem.splitlines(True)

Esse método é útil quando você quer processar um texto linha por linha, como ao ler o conteúdo de um arquivo inteiro com read().



strip()​

O método strip() em Python é usado para remover espaços em branco (ou outros caracteres) do início e do fim de uma string.


Por padrão, ele remove:

  • espaços ( )
  • quebras de linha (\n)
  • tabulações (\t)
  • e outros caracteres "invisíveis"

Exemplo:

texto = "   Olá mundo   \n"
limpo = texto.strip()
print(limpo)

Se você quiser remover outros caracteres específicos, pode passar eles como argumento:

s = "---exemplo---"
print(s.strip("-"))  # resultado: exemplo

O strip() não altera a string original, ele retorna uma nova string com os cortes aplicados. Se quiser só remover da esquerda, use lstrip(). Da direita, use rstrip().



split()​

O método split() em Python é usado para quebrar uma string em partes, transformando ela em uma lista, com base em algum separador. Por padrão, ele usa espaços em branco como separador, mas você pode passar outro caractere se quiser.


Exemplo sem argumento:

s = "banana maçã pera"
print(s.split())

Resultado:

['banana', 'maçã', 'pera']

Agora com separador definido:

s = "banana,maçã,pera"
print(s.split(","))

Resultado:

['banana', 'maçã', 'pera']

Você também pode controlar quantas vezes ele vai dividir, usando um segundo argumento:

s = "chave:valor:extra"
print(s.split(":", 1))

Resultado:

['chave', 'valor:extra']


subprocess​

O módulo subprocess permite que você execute comandos do sistema operacional (como se estivesse digitando no terminal) diretamente a partir do seu script Python. Ele serve para rodar programas externos, capturar suas saídas, lidar com erros e até interagir com eles.


O subprocess também funciona no Windows. Ele é parte da biblioteca padrão do Python e foi feito justamente para ser portável, ou seja, funcionar tanto em Linux quanto em Windows e macOS.


O subprocess substitui módulos antigos como os.system, os.popen e commands. Ele é mais seguro, mais flexível e permite um controle muito maior sobre entrada e saída dos processos externos.


Quando você usa subprocess, o Python pode:

  • rodar um comando como ls, docker, curl, echo, cat e etc.
  • capturar a saída do comando
  • capturar erros
  • enviar dados para a entrada padrão do processo
  • verificar se o comando funcionou ou não


run()​

Esse é o método mais usado dentro de subprocess. Ele é usado para executar um comando, espera terminar, e devolve um objeto com informações sobre o que aconteceu.


Exemplo:

import subprocess

resultado = subprocess.run(["ls", "-l"], capture_output=True, text=True)
print(resultado.stdout)

Aqui o stdout traz o resultado do ls -l. Você pode usar:

  • check=True para forçar erro se o comando falhar
  • text=True para receber a saída como string (em vez de bytes)
  • stdout=subprocess.PIPE para capturar a saída
  • stderr=subprocess.PIPE ou subprocess.DEVNULL para lidar com erros


Popen()​

É mais antigo e mais flexível. Permite interagir com o processo em tempo real, ler saída linha por linha, escrever na entrada, etc. Mas exige mais controle manual.


Exemplo:

p = subprocess.Popen(["cat"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
saida, _ = p.communicate("Olá\n")

print(saida)

Aqui o Python envia "Olá" para o comando cat, que apenas devolve o mesmo texto.



call()​

Executa um comando e retorna o código de saída (zero se deu certo). É como run(), mas sem capturar stdout, apenas informa se deu certo a execução do comando ou não.

codigo = subprocess.call(["ls", "/"])
print(codigo)


check_output()​

Executa o comando e retorna somente a saída, ou seja, o stdout. Se o comando falhar, lança uma exceção.

saida = subprocess.check_output(["echo", "oi"], text=True)
print(saida)


argparse​

O argparse é um módulo da biblioteca padrão do Python que serve para criar e tratar argumentos de linha de comando, o argparse substitui o uso direto de sys.argv, e faz isso de forma muito melhor, mais segura e organizada. Ele permite que seu script receba opções como se fosse um programa de terminal, por exemplo:

python meu_script.py --nome Fulano --idade 30

Com argparse, você define quais argumentos o script aceita, se são obrigatórios ou não, que tipo de valor eles recebem, e ainda pode gerar automaticamente uma ajuda (--help) para o usuário.



Uso prático​

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--nome", help="Nome da pessoa")
parser.add_argument("--idade", type=int, help="Idade da pessoa")

args = parser.parse_args()

print(f"Nome: {args.nome}")
print(f"Idade: {args.idade}")

Se você rodar:

python script.py --nome João --idade 25

A saída será:

Nome: João
Idade: 25


add_argument​

Você pode controlar o comportamento de cada argumento com vários parâmetros:

  • type= define o tipo esperado (como int, float, str).
  • default= define um valor padrão se o argumento não for passado.
  • required=True faz o argumento ser obrigatório.
  • choices=[...] limita os valores possíveis.
  • action="store_true" transforma a opção em um flag booleana (ativa se for usada, False se omitida).
  • metavar= permite fornecer uma descrição após o comando, exemplo: '--get', metavar='PROPERTY' é exibido como --get PROPERTY.

Exemplo com flag:

parser.add_argument("--verbose", action="store_true", help="Modo detalhado")

Agora, se você rodar com --verbose, args.verbose será True. Se não rodar, será False.



Entendendo argparse​

O código abaixo cria o parser, ou seja, o objeto que vai cuidar da leitura e interpretação dos argumentos passados na linha de comando.

parser = argparse.ArgumentParser()

O código abaixo está incompleto, mas é usado para adicionar um argumento possível ao código.

parser.add_argument("--nome")

O código abaixo obtém os argumentos que o usuário passou e analisa. Os valores são armazenados dentro do objeto args, que você pode usar depois como args.alguma_coisa.

args = parser.parse_args()

Podemos usar o código abaixo para exibir o help, isso pode ser útil caso você queira que o help seja exibido após um erro, por exemplo, quando não foi informado um argumento obrigatório ou faltou um argumento, é como se o usuário tivesse chamado o script com --help.

parser.print_help()

Já o código abaixo encerra o programa imediatamente com o código de saída 21. Esse número é arbitrário, o 0 significa sucesso, qualquer outro número indica erro. Ele substitui o sys.exit(), porém, ao finalizar, ele exibe uma mensagem no terminal, se você quiser.

parser.exit(21)

Por padrão, ele imprime a mensagem usage: ..., igual ao que você vê ao usar --help. Mas você pode passar sua própria mensagem, assim:

parser.exit(1, "Erro: argumento obrigatório não informado.\n")

Isso vai imprimir a mensagem personalizada e encerrar o programa com o código de saída 1.



requests​

O módulo requests é uma biblioteca externa muito usada no Python para realizar requisições HTTP de forma simples e legível. Ela substitui o uso direto de módulos como urllib ou http.client, que são mais verbosos e complicados. Para usar o requests, é necessário instalá-lo com pip install requests, pois não faz parte da biblioteca padrão.


Quando se usa requests, você consegue interagir com APIs e sites como se estivesse navegando pela web com um navegador, mas de forma automatizada e controlada pelo código. A principal característica da biblioteca é que ela trata tudo como objetos de alto nível, cuidando internamente da conexão, do envio de cabeçalhos, do corpo da requisição e do recebimento da resposta. Você trabalha apenas com funções e objetos simples.


A biblioteca também tem suporte a autenticação básica embutido, usando o parâmetro auth=(usuario, senha). Isso adiciona automaticamente o cabeçalho Authorization para autenticação HTTP básica.


Outro ponto importante é o tratamento de exceções. Embora requests tente ser simples, ele pode lançar exceções como requests.exceptions.RequestException caso algo dê errado, como falha de rede ou resposta inválida. Por isso, é comum usar blocos try/except ao redor das requisições.


Por padrão, o módulo não gera erro quando o código HTTP é diferente de 200. Se quiser forçar isso, você pode usar r.raise_for_status(), que levanta uma exceção se a resposta tiver código de erro.



Métodos HTTP​

Os métodos HTTP, também conhecidos como verbos HTTP, são comandos que indicam a ação que está sendo solicitada para ser realizada em um recurso específico em um servidor. Eles são usados em solicitações HTTP para indicar a natureza da operação que está sendo realizada no recurso identificado pela URL. Os principais verbos HTTP incluem:

  • GET: Solicita a representação de um recurso específico. É usado para recuperar dados do servidor. Por exemplo, ao digitar uma URL no navegador, uma solicitação GET é enviada para recuperar a página web correspondente.

  • POST: Envia dados para o servidor para criar um novo recurso. É comumente usado para enviar dados de formulário para o servidor ou para enviar dados para serem processados e armazenados.

  • PUT: Atualiza um recurso existente no servidor com os dados fornecidos. Geralmente, é usado para atualizar completamente um recurso.

  • PATCH: Atualiza parcialmente um recurso existente no servidor. Ele envia apenas os dados que precisam ser alterados, em vez de enviar todos os dados do recurso.

  • DELETE: Remove um recurso específico do servidor. É usado para excluir recursos existentes.

  • HEAD: Solicita apenas os cabeçalhos de resposta de um recurso, sem a carga útil de dados. É útil para verificar a existência de um recurso e obter informações sobre ele sem baixar todo o conteúdo.

  • OPTIONS: Solicita informações sobre as opções de comunicação disponíveis para um recurso, como os métodos HTTP suportados ou os cabeçalhos aceitos.


Esses são os principais verbos HTTP, cada um com uma função específica na comunicação entre clientes e servidores web. Eles permitem uma variedade de operações para recuperar, criar, atualizar e excluir recursos em servidores web, formando a base da arquitetura RESTful comumente usada na web moderna.



Método GET​

O método mais usado é requests.get(), que envia uma requisição HTTP do tipo GET para o servidor e retorna uma resposta que pode ser analisada. Por exemplo:

import requests
r = requests.get("https://example.com")
print(r.status_code)
print(r.text)

Com isso você pode verificar se o servidor respondeu com sucesso (código 200, por exemplo) e ler o conteúdo retornado como texto. Também é possível acessar os dados como JSON, se a resposta for nesse formato, com r.json().



Método POST​

Outro método muito comum é o requests.post(), usado para enviar dados para o servidor, como formulários ou informações para uma API. Por exemplo:

set_payload = {"nome": "fulano"}

r = requests.post("https://httpbin.org/post", data=set_payload)
print(r.text)

Nesse caso, os dados serão enviados no corpo da requisição, como em um formulário HTML. Se quiser enviar dados em JSON, basta usar o parâmetro json= em vez de data=, e o próprio requests ajusta o cabeçalho Content-Type.

set_payload = {"nome": "fulano"}

r = requests.post("https://httpbin.org/post", json=set_payload)
print(r.text)

Além de GET e POST, o módulo também suporta métodos como PUT, DELETE, PATCH, HEAD e OPTIONS, todos com chamadas semelhantes. Por exemplo, requests.delete(url) ou requests.put(url, data=...).


A biblioteca também permite enviar cabeçalhos personalizados com o parâmetro headers=, o que é útil para se identificar para um servidor ou enviar tokens de autenticação. Por exemplo:

headers = {"Authorization": "Bearer meu_token"}
r = requests.get("https://api.site.com/dados", headers=headers)

Você também pode trabalhar com cookies, tanto para enviar quanto para receber. Se a resposta tiver cookies, você pode acessá-los com r.cookies. Para enviar cookies, basta passar um dicionário com cookies=.


Existe também o conceito de sessões, usando requests.Session(). Isso permite manter cookies entre várias requisições e reutilizar conexões TCP, o que melhora a performance. Com uma sessão, você pode fazer login e depois continuar acessando páginas autenticadas.

s = requests.Session()
s.post("https://site.com/login", data={"user": "fulano", "senha": "123"})
r = s.get("https://site.com/perfil")


SSL​

O módulo ssl é responsável por adicionar uma camada de segurança às conexões de rede, permitindo o uso de criptografia SSL e TLS sobre sockets comuns. Por padrão, quando você usa o módulo socket, a conexão ocorre em texto puro, ou seja, os dados trafegam abertos, podendo ser interceptados. O ssl permite transformar esse socket inseguro em um canal criptografado, garantindo confidencialidade, integridade e autenticação entre as partes envolvidas.


Para realizar isso, o ssl fornece uma interface que pode envolver qualquer socket TCP e aplicar os protocolos TLS. A forma mais simples e moderna de fazer isso é utilizando ssl.create_default_context(), que cria um objeto de contexto com configurações seguras padrão.


Esse contexto pode ser configurado com certificados, verificação de hostname, verificação de validade de certificados e seleção do protocolo TLS a ser usado. Esse objeto de contexto então pode ser aplicado sobre um socket já existente com wrap_socket() ou, mais corretamente, com context.wrap_socket().


Por exemplo, ao se conectar a um servidor HTTPS, você criaria primeiro um socket TCP normal, depois aplicaria o contexto SSL sobre ele, e só então faria a comunicação:

import socket
import ssl

context = ssl.create_default_context()
sock = socket.create_connection(("www.exemplo.com", 443))

secure_sock = context.wrap_socket(sock, server_hostname="www.exemplo.com")
secure_sock.send(b"GET / HTTP/1.1\r\nHost: www.exemplo.com\r\n\r\n")

print(secure_sock.recv(1024).decode())
secure_sock.close()

Nesse exemplo, o wrap_socket transforma a conexão TCP em uma sessão TLS, e o argumento server_hostname é essencial para que o nome do servidor seja verificado contra o certificado digital que ele apresenta. Isso é parte fundamental da segurança de HTTPS. Se o certificado não for válido, ou não corresponder ao nome, a conexão falha com erro.


O módulo também permite que você atue como servidor. Nesse caso, o contexto SSL precisa ser configurado com um certificado digital válido e a respectiva chave privada. Isso é feito com context.load_cert_chain(certfile="cert.pem", keyfile="key.pem"). A partir daí, qualquer conexão TCP recebida pode ser envolvida com wrap_socket() e se tornará uma sessão segura.


Além disso, o ssl permite controlar diretamente qual versão de TLS será usada, quais algoritmos de criptografia serão permitidos, e como os certificados serão verificados. Também é possível usar certificados autoassinados, embora isso desative a verificação automática e exija validação manual no cliente.