Pular para conteúdo

Python

Python é uma linguagem de programação de alto nível, interpretada, de propósito geral e com uma filosofia de design que enfatiza a legibilidade do código. Criada por Guido van Rossum e lançada pela primeira vez em 1991, Python se tornou uma das linguagens mais populares do mundo devido à sua simplicidade, versatilidade e ampla gama de aplicações.

Características Principais

1. Sintaxe Clara e Legível

Python utiliza indentação para definir blocos de código, o que força um estilo de codificação consistente e melhora a legibilidade.

def calcular_media(numeros):
    if not numeros:
        return 0
    return sum(numeros) / len(numeros)

# Exemplo de uso de condicionais
idade = 18
if idade >= 18:
    print("Maior de idade")
else:
    print("Menor de idade")

2. Tipagem Dinâmica e Forte

Python é uma linguagem de tipagem dinâmica, o que significa que o tipo de uma variável é determinado em tempo de execução. Ao mesmo tempo, é fortemente tipada, o que significa que os tipos de objetos não mudam implicitamente.

x = 10          # x é um inteiro
x = "Python"    # agora x é uma string
# x + 5         # Isso geraria um erro: não pode concatenar 'str' e 'int'

3. Interpretada

Python é uma linguagem interpretada, o que significa que o código é executado linha por linha por um interpretador, sem necessidade de compilação prévia para código de máquina.

4. Multiparadigma

Python suporta múltiplos paradigmas de programação:

  • Programação Imperativa: Baseada em comandos que alteram o estado do programa
  • Programação Orientada a Objetos: Baseada em classes e objetos
  • Programação Funcional: Tratando funções como cidadãos de primeira classe
  • Programação Procedural: Baseada em procedimentos ou rotinas

5. Biblioteca Padrão Abrangente

Python vem com uma biblioteca padrão extensa que oferece módulos e pacotes para diversas tarefas, desde manipulação de arquivos até desenvolvimento web.

Sintaxe Básica

Variáveis e Tipos de Dados

# Números
inteiro = 10
flutuante = 3.14
complexo = 1 + 2j

# Strings
texto = "Python"
texto_multilinha = """Este é um
texto com múltiplas
linhas"""

# Booleanos
verdadeiro = True
falso = False

# Listas (mutáveis)
lista = [1, 2, 3, 4, 5]
lista_mista = [1, "dois", 3.0, [4, 5]]

# Tuplas (imutáveis)
tupla = (1, 2, 3)

# Dicionários
dicionario = {"chave": "valor", "nome": "Python"}

# Conjuntos
conjunto = {1, 2, 3, 4, 5}

Estruturas de Controle

Condicionais

# If-elif-else
idade = 20
if idade < 18:
    print("Menor de idade")
elif idade == 18:
    print("Acabou de atingir a maioridade")
else:
    print("Maior de idade")

# Operador ternário
status = "Maior de idade" if idade >= 18 else "Menor de idade"

Loops

# For loop
for i in range(5):
    print(i)  # Imprime 0, 1, 2, 3, 4

# Iterando sobre uma lista
frutas = ["maçã", "banana", "laranja"]
for fruta in frutas:
    print(fruta)

# While loop
contador = 0
while contador < 5:
    print(contador)
    contador += 1

# Break e continue
for i in range(10):
    if i == 3:
        continue  # Pula para a próxima iteração
    if i == 7:
        break  # Sai do loop
    print(i)

Funções

# Definição de função
def saudacao(nome):
    return f"Olá, {nome}!"

# Chamada de função
mensagem = saudacao("Python")
print(mensagem)  # Saída: Olá, Python!

# Parâmetros padrão
def saudacao_personalizada(nome, saudacao="Olá"):
    return f"{saudacao}, {nome}!"

# Args e kwargs
def exemplo_args_kwargs(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

exemplo_args_kwargs(1, 2, 3, nome="Python", versao=3.9)

Funções Lambda

# Função lambda (anônima)
dobro = lambda x: x * 2
print(dobro(5))  # Saída: 10

# Uso com funções de ordem superior
numeros = [1, 2, 3, 4, 5]
pares = list(filter(lambda x: x % 2 == 0, numeros))
dobrados = list(map(lambda x: x * 2, numeros))

Programação Orientada a Objetos

Classes e Objetos

class Pessoa:
    # Atributo de classe
    especie = "Homo sapiens"

    # Método construtor
    def __init__(self, nome, idade):
        # Atributos de instância
        self.nome = nome
        self.idade = idade

    # Método de instância
    def apresentar(self):
        return f"Olá, meu nome é {self.nome} e tenho {self.idade} anos."

    # Método de classe
    @classmethod
    def criar_de_ano_nascimento(cls, nome, ano_nascimento):
        from datetime import date
        idade = date.today().year - ano_nascimento
        return cls(nome, idade)

    # Método estático
    @staticmethod
    def e_adulto(idade):
        return idade >= 18

# Criando instâncias
pessoa1 = Pessoa("Ana", 30)
pessoa2 = Pessoa.criar_de_ano_nascimento("Carlos", 1995)

print(pessoa1.apresentar())  # Saída: Olá, meu nome é Ana e tenho 30 anos.
print(Pessoa.e_adulto(17))   # Saída: False

Herança

class Animal:
    def __init__(self, nome):
        self.nome = nome

    def emitir_som(self):
        pass

class Cachorro(Animal):
    def emitir_som(self):
        return "Au au!"

class Gato(Animal):
    def emitir_som(self):
        return "Miau!"

# Criando instâncias
rex = Cachorro("Rex")
felix = Gato("Felix")

print(rex.nome)         # Saída: Rex
print(rex.emitir_som()) # Saída: Au au!
print(felix.emitir_som()) # Saída: Miau!

Encapsulamento

class ContaBancaria:
    def __init__(self, titular, saldo_inicial=0):
        self.titular = titular
        self.__saldo = saldo_inicial  # Atributo privado

    def depositar(self, valor):
        if valor > 0:
            self.__saldo += valor
            return True
        return False

    def sacar(self, valor):
        if 0 < valor <= self.__saldo:
            self.__saldo -= valor
            return True
        return False

    def consultar_saldo(self):
        return self.__saldo

# Criando uma conta
conta = ContaBancaria("João", 1000)

# Acessando métodos públicos
conta.depositar(500)
conta.sacar(200)
print(conta.consultar_saldo())  # Saída: 1300

# Tentando acessar atributo privado
# print(conta.__saldo)  # Isso geraria um AttributeError

Recursos Avançados

Geradores

# Função geradora
def contador(maximo):
    contador = 0
    while contador < maximo:
        yield contador
        contador += 1

# Usando o gerador
for numero in contador(5):
    print(numero)  # Saída: 0, 1, 2, 3, 4

# Expressão geradora
quadrados = (x**2 for x in range(5))
print(list(quadrados))  # Saída: [0, 1, 4, 9, 16]

Decoradores

# Definindo um decorador
def meu_decorador(funcao):
    def wrapper(*args, **kwargs):
        print("Antes da função")
        resultado = funcao(*args, **kwargs)
        print("Depois da função")
        return resultado
    return wrapper

# Aplicando o decorador
@meu_decorador
def saudacao(nome):
    print(f"Olá, {nome}!")

saudacao("Python")
# Saída:
# Antes da função
# Olá, Python!
# Depois da função

Gerenciadores de Contexto

# Usando with para arquivos
with open("arquivo.txt", "w") as arquivo:
    arquivo.write("Olá, Python!")

# Criando um gerenciador de contexto personalizado
class MinhaConexao:
    def __init__(self, host, porta):
        self.host = host
        self.porta = porta

    def __enter__(self):
        print(f"Conectando a {self.host}:{self.porta}")
        # Código para estabelecer conexão
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"Desconectando de {self.host}:{self.porta}")
        # Código para fechar conexão
        return False  # Propaga exceções

# Usando o gerenciador de contexto
with MinhaConexao("localhost", 8080) as conn:
    print("Conexão estabelecida")

Type Hints (Python 3.5+)

from typing import List, Dict, Optional, Union

def somar_lista(numeros: List[int]) -> int:
    return sum(numeros)

def processar_usuario(usuario: Dict[str, Union[str, int]]) -> str:
    return f"Usuário: {usuario['nome']}, Idade: {usuario['idade']}"

def buscar_usuario(id: int) -> Optional[Dict[str, Union[str, int]]]:
    # Simulação de busca
    if id == 1:
        return {"nome": "Alice", "idade": 30}
    return None

Bibliotecas e Frameworks Populares

Ciência de Dados e Machine Learning

  • NumPy: Computação numérica
  • Pandas: Análise e manipulação de dados
  • Matplotlib e Seaborn: Visualização de dados
  • Scikit-learn: Machine learning
  • TensorFlow e PyTorch: Deep learning

Desenvolvimento Web

  • Django: Framework web full-stack
  • Flask: Microframework web
  • FastAPI: Framework moderno para APIs

Automação e Scripting

  • Requests: HTTP para humanos
  • Beautiful Soup: Web scraping
  • Selenium: Automação de navegadores
  • Paramiko: Cliente SSH

Python no Projeto

No contexto do nosso projeto de sistema de feedback, Python é utilizado para implementar o microserviço de visualização de feedback com FastAPI e Peewee ORM.

Conclusão

Python é uma linguagem versátil e poderosa que se destaca pela sua simplicidade e legibilidade. Sua ampla gama de bibliotecas e frameworks a torna adequada para diversas aplicações, desde desenvolvimento web até ciência de dados e machine learning.

No contexto do nosso projeto, Python com FastAPI e Peewee oferece uma solução eficiente e moderna para implementar o microserviço de visualização de feedback, demonstrando a versatilidade da linguagem em um ambiente de microserviços.

A combinação de uma sintaxe clara, tipagem dinâmica e forte, e um ecossistema rico de bibliotecas faz de Python uma escolha excelente para desenvolvedores que buscam produtividade e expressividade em seus projetos.