Resumo: Introdução ao Python

1. O que é Python?
• Criado por Guido van Rossum (nome inspirado no grupo Monty Python, não
em cobras)
• Linguagem mais popular e em crescimento (líder no GitHub desde 2024 e
no índice TIOBE)
• Características: simples de aprender + poderosa
• Linguagem de eleição para IA e Machine Learning
2. Características Principais
• Gratuita e open source
• Código simples (semelhante a pseudo-código)
• Alto nível e portável
• Interpretada (com bytecode)
• Orientada a objetos (tudo é objeto: números, strings, funções)
• Extensível (pode integrar código C/C++)
• Rica biblioteca padrão + Python Package Index
3. Instalação - Anaconda
• Recomenda-se instalar Anaconda (não só Python isolado)
• Inclui bibliotecas essenciais para ML:
o Scikit-learn (algoritmos de ML)
o NumPy, Pandas (manipulação de dados)
o Matplotlib, Seaborn (visualização)
• Download: [Link]
4. Jupyter Notebook
• Aplicação web interativa para criar notebooks
• Como usar:
o Executar "Anaconda Prompt" → digitar jupyter notebook
o Criar pasta de trabalho (ex: "AA")
o Criar novo notebook (extensão .ipynb)
• Células: pode executar comandos separadamente ou em conjunto
o Shift+Enter para executar célula
o Números à esquerda mostram ordem de execução
• Dica: reiniciar Kernel se executar células fora de ordem
5. VS Code
• IDE mais poderoso e versátil que Jupyter Notebook
• Necessita instalar extensões: Python + Jupyter Notebook
6. Noções Básicas de Sintaxe
Comentários
Python:
# Comentário com cardinal #
Variáveis
 • Não precisam ser declaradas ☺
• Criadas ao atribuir valor
• Python é case-sensitive
Python:
idade = 20
nome = 'Maria'
Constantes
• Números: inteiros, float, complexos
• Strings: 'texto' ou "texto"
Identificadores
• Alfanuméricos + underscore
• Python 3 aceita acentos
7. Strings
• Imutáveis e usam UTF-8
• Delimitadas por "..." ou '...'
• Múltiplas linhas: """...""" ou '''...'''
• Concatenação: separar por espaço
Python:
dia = 'É' ' ' 'sexta' '-' 'feira'
• Raw strings: r"sem formatação" (útil para regex)
• Sequências escape: \n \t \\ \' \"
Formatação - format() e f-strings
Python:
# Método format()
print('{0} tinha {1} anos'.format(nome, idade))
# F-strings (Python 3.6+) - mais prático
frase = f'{nome} tinha {idade} anos'
# Formatação detalhada
print('{0:.3f}'.format(1.0/3)) # 0.333
8. Indentação
• CRÍTICO: define blocos de código (substitui {...})
• Todas as instruções do bloco devem ter mesma indentação
• Indentação errada = erro sintático ou lógico
Python:
i=5
if i > 3:
print('Maior') # Correto: indentado
print('Fim') # Mesmo bloco
9. Linhas Físicas vs Lógicas
• 1 instrução por linha (recomendado)
• Múltiplas instruções: separar com ;
Python:
i=5; print(i);
• Instrução em várias linhas: usar \
Python:
s = 'Isto é uma \
única string'
10. Operadores Diferentes do C/C++
Python:
not # NOT lógico
and # AND lógico
or # OR lógico
** # Potência (2**3 = 8)
/ # Divisão real (5/3 = 1.666...)
// # Divisão inteira (5//3 = 1)

Pontos-Chave para o Exame:

Python = simples + poderoso
Anaconda inclui bibliotecas ML essenciais
Jupyter Notebook = ambiente interativo
Variáveis não precisam declaração
INDENTAÇÃO É OBRIGATÓRIA (não cosmética!)
Strings: imutáveis, UTF-8, f-strings práticas
Operadores: ** // not and or
Boa sorte no exame!

Resumo: Python - Módulos e Estruturas de Dados

1. Módulos
O que são?
• Funções → reutilizar código no mesmo programa
• Módulos → reutilizar funções em diferentes programas
• Arquivo .py (ou .pyc quando compilado) com funções, classes e variáveis
Importação
Python:
# Importar módulo completo
import sys
print([Link]) # argumentos da linha de comando
# Importação seletiva (evita usar qualificador)
from sys import argv
from math import sqrt
Bytecode (.pyc)
 • Código intermediário compilado
• Mais rápido que .py
• Python cria automaticamente ao importar pela 1ª vez
• Independente de plataforma, mas dependente da versão Python
Atributo __name__
Python:
if __name__ == "__main__":
print("Executado diretamente")
else:
print("Importado de outro módulo")
• __name__ == "__main__" → execução direta
• Caso contrário → importado
Função dir()
Python:
import sys
dir(sys) # Lista nomes do módulo sys
dir() # Lista nomes do módulo atual
2. Packages e Subpackages**
**Package**:
- **Pasta** que contém módulos
- Requer arquivo `__init__.py` (opcional desde Python 3.3, mas recomendado)
- `__init__.py` executa primeiro quando módulo é invocado

Estrutura:
world/
__init__.py
asia/
__init__.py
india/
__init__.py
[Link]
africa/
__init__.py
madagascar/
__init__.py
[Link]
3. Estruturas de Dados (Coleções Nativas)
LISTA (list):
• Heterogênea, ordenada, mutável
• Sintaxe: lista = [2, 5, -3]
 • Acessível por indexação
• Métodos úteis: append(), sort(), del, etc.
Python:
shoplist = ['apple', 'mango', 'carrot']
[Link]('rice') #adicionar no fim
[Link]() # ordenar
del shoplist[0] #Eliminar o [0]
TUPLO (tuple):
• Heterogênea, ordenada, IMUTÁVEL
• Sintaxe: tuplo = (2, 5, -3) ou tuplo = 2, 5, -3
• Mais eficiente que listas (sem alterações)
• Retorno múltiplo de funções:
Python:
def get_error_details():
return (2, 'details')
errnum, errstr = get_error_details()
• Troca de valores simplificada:
Python:
a, b = 5, 8
a, b = b, a # Troca valores
DICIONÁRIO (dict):
• Pares chave/valor
• Sintaxe: dicionario = {'Ana':18, 'Rui':15}
• Chaves devem ser imutáveis
• Valores podem ser mutáveis ou não
• Preserva ordem de inserção (Python 3.7+)
Python:
ab = {'Swaroop': 'swaroop@[Link]'}
print(ab['Swaroop'])
del ab['Spammer']
for name, address in [Link]():
print(name, address)
SET (set):
• Não ordenada, sem repetições
• Sintaxe: c = {2, 5, 3} ou c = set([2,5,3])
• Operações de conjuntos:
Python:
bri = set(['brazil', 'russia', 'india'])
'india' in bri # True
[Link](bri) # Verifica se é superconjunto
bri & bric # Interseção
4. Sequências
Características:
• Listas, tuplos, ranges e strings são sequências
• Acesso por indexação e slicing
• Operadores: in, not in
Indexação e Slicing:
Python:
shoplist = ['apple', 'mango', 'carrot', 'banana']
shoplist[0] # 'apple'
shoplist[-1] # 'banana' (último)
shoplist[1:3] # ['mango', 'carrot']
shoplist[2:] # ['carrot', 'banana']
shoplist[:] # Cópia completa
Strings como Sequências
Python:
name = 'swaroop'
name[1:3] # 'wa'
name[2:] # 'aroop'
name[:] # 'swaroop' (cópia)
5. Referências vs Cópias :
IMPORTANTE: Atribuição cria referência, não cópia!
Python:
shoplist = ['apple', 'mango', 'carrot']
mylist = shoplist # Referência (mesmo objeto)
del shoplist[0]
print(mylist) # ['mango', 'carrot'] - afetado!
# CÓPIA CORRETA (slicing completo):
mylist = shoplist[:] # Cria cópia
del shoplist[0]
print(mylist) # ['mango', 'carrot', 'banana'] - não afetado
6. Strings - Métodos Úteis
Python:
name = 'Swaroop'
# Verificações
[Link]('Swa') # True
'a' in name # True
[Link]('war') # Retorna índice ou -1
# Imutabilidade
# .replace() retorna NOVA string
new_name = [Link]('a', 'A')
# Join
mylist = ['Brazil', 'Russia', 'India']
'_*_'.join(mylist) # 'Brazil_*_Russia_*_India'
7. Input do Usuário
Python:
something = input("Enter text: ")
# SEMPRE retorna string, mesmo para números!
# Para números:
age = int(input("Enter age: "))
Pontos-Chave para o Exame:
Módulos: import vs from...import
__name__: distinguir execução direta de importação
Bytecode (.pyc): compilado automaticamente
Lista = mutável | Tuplo = imutável
Dicionário = chave:valor | Set = sem repetições
Slicing: [início:fim], [:] cria cópia
Referências: atribuição direta NÃO copia, usar [:]
Strings: imutáveis, métodos retornam nova string
input(): sempre retorna string
Tuplos: úteis para retorno múltiplo e troca de valores

Resumo: Python - Programação Orientada a Objetos

(POO)
1. Tudo é Objeto em Python:
Tipos de Objetos
• Objetos classe: permitem acesso a membros e instanciar objetos
Python:
MinhaClasse.__doc__
obj = MinhaClasse()
• Objetos instância: instâncias típicas das classes
Python:
[Link]
[Link]()
• Objetos função: métodos podem ser atribuídos a variáveis
Python:
y = [Link]
y() # Mesmo que [Link]()
2. Encapsulamento :
Python NÃO tem private/protected/public como C++/Java/C#
Convenções (não são imposições)
 • _atributo: "privado/protegido" (1 underscore)
o Convenção: não acessar fora da classe
• __atributo: name mangling (2 underscores)
o Usado internamente para evitar colisões em subclasses
• __metodo__: métodos especiais do Python
o Ex: __init__, __str__, __eq__
o NÃO usar esse formato em seus identificadores
Filosofia: "Somos todos adultos" - responsabilidade do programador
3. O Parâmetro self:
Conceito
• Similar ao this de C++/Java/C#, mas mais explícito
• Obrigatório como primeiro parâmetro de métodos de instância
• Diferencia membros de objeto dos membros de classe
Como funciona
Python:
class Exemplo:
def metodo(self, arg1, arg2):
pass

obj = Exemplo()
[Link](10, 20) # Python converte para:
# [Link](obj, 10, 20)
• [Link](a1, a2) → [Link](obj, a1, a2)
4. Definição de Classes:
Classe Vazia
Python:
class Person:
pass # Bloco vazio

p = Person()
print(p) # <__main__.Person instance at 0x...>

Classe com Métodos

Python:
class Person:
def say_hi(self):
print('Hello, how are you?')

p = Person()
p.say_hi() # Invocado SEM argumentos (self é automático)
# Também pode: Person().say_hi()
 5. Construtores (__init__) :
Sintaxe
Python:
class Person:
def __init__(self, name): # Construtor
[Link] = name # Cria atributo de objeto

def say_hi(self):
print(f'Hello, my name is {[Link]}')

p = Person('Swaroop')
p.say_hi() # Hello, my name is Swaroop
Características
• Nome fixo: __init__ (≠ Java/C++ onde nome = classe)
• Apenas 1 construtor por classe
o Diferentes inicializações → usar parâmetros opcionais
• 2 tipos:
o Construtor padrão: sem parâmetros (gerado automaticamente)
o Construtor parametrizado: com parâmetros
[Link] vs variável local
• [Link] = name → atributo de objeto
• x = 10 (sem self) → variável local ao método
•
6. Métodos Especiais
Principais
Método Quando é invocado Equivalente
__init__(self, ...) Criação do objeto Construtor
__del__(self) Destruição do objeto Destrutor
__str__(self) print(obj) ou str(obj) toString()
__eq__(self, other) obj1 == obj2 equals()
__lt__(self, other) obj1 < obj2 Comparação
__getitem__(self, key) obj[key] Indexação
__len__(self) len(obj) Tamanho
Uso
• Sobrecarga de operadores em Python
• Invocados automaticamente (sintaxe especial)
•
7. Identidade vs Igualdade:
Python:
x1 = [1, 2, 3]
x2 = [1, 2, 3]
x3 = x1
Operador == (igualdade):
Python:
x1 == x2 # True (mesmo conteúdo)
x1 == x3 # True
• Invoca __eq__(self, other)
• Equivalente ao equals() do Java
Operador is (identidade)
Python:
x1 is x2 # False (objetos diferentes)
x1 is x3 # True (mesmo objeto)
• Equivalente ao == do Java (para objetos)
• Verifica se é o mesmo objeto na memória
Para classes customizadas: definir __eq__() para == funcionar corretamente
8. Iteradores:
Conceito
• Objeto que percorre coleção sem conhecer estrutura interna
Método __next__():
Python:
lista = [2, 5, 1, 3]
it = iter(lista) # Obtém iterador

while True:
try:
x = next(it) # ou it.__next__()
print(x, end=' ')
except StopIteration:
break
# Output: 2 5 1 3
Características
• __next__(): retorna próximo elemento
• StopIteration: exceção quando acabam elementos
9. Iteráveis :
Método __iter__():
• Objeto iterável tem __iter__() que retorna iterador
Python:
lista = [2, 5, 1, 3]
it = iter(lista) # Chama lista.__iter__()
Uso com for
Python:
# Forma compacta (recomendada)
for x in lista:
print(x, end=' ')
# Output: 2 5 1 3
• Python traduz automaticamente para iteração explícita
• range() retorna iterável
10. Funções Geradoras (yield):
Problema: tornar classe iterável dá trabalho
Solução: funções geradoras
Conceito
• Função com yield retorna objeto gerador (tipo de iterador)
• yield devolve valor sem terminar função
• Cada next() continua de onde parou
Exemplo
Python:
class Alunos:
def __init__(self, *nomes):
[Link] = nomes

def __iter__(self): # Função geradora

for nome in [Link]:
yield nome # Retorna 1 valor por vez
alunos = Alunos('Ana', 'Rita', 'Rui')
for a in alunos:
print(a)
# Output:
# Ana
# Rita
# Rui
Vantagens
• Simplifica criação de iteradores
• Não precisa classe separada para iterador
• Não precisa implementar __next__() manualmente
Pontos-Chave para o Exame:
Tudo é objeto em Python (até inteiros)
Encapsulamento: _privado, __name_mangling, __especial__
self: obrigatório como 1º parâmetro, diferencia membros
Construtor: __init__(self, ...), apenas 1 por classe
Métodos especiais: __str__, __eq__, __getitem__, etc.
 == vs is: igualdade vs identidade
Iterador: tem __next__() e lança StopIteration
Iterável: tem __iter__() que retorna iterador
yield: cria função geradora (simplifica iteradores)
for x in obj: requer obj iterável (com __iter__())
Comparação com Java/C++:

Python Java/C++
self this
__init__ Construtor (nome da classe)
__str__ toString()
__eq__ equals()
== equals()
is == (para objetos)
yield (não existe facilmente)

Resumo: Python - POO Avançada e Conceitos Adicionais

1. Atributos e Métodos de Classe vs Objeto
Atributos de Objeto (com self):
• Particulares a cada instância
• Cada objeto tem sua própria cópia
Python:
class Robot:
def __init__(self, name):
[Link] = name # Atributo de OBJETO
Atributos de Classe (sem self)
• Compartilhados por TODAS as instâncias
• Apenas UMA cópia para toda a classe
Python:
class Robot:
population = 0 # Atributo de CLASSE

def __init__(self, name):

[Link] = name
[Link] += 1 # Acesso: [Link]
Métodos de Classe (@classmethod)
• Primeiro parâmetro: cls (referência à classe)
 • Pode acessar atributos de classe
• Precedido por @classmethod
Python:
@classmethod
def how_many(cls):
print(f"We have {[Link]} robots.")
Métodos Estáticos (@staticmethod)
• NÃO tem self nem cls
• Função utilitária sem acesso à classe/objeto
• Opera apenas com seus parâmetros
• Precedido por @staticmethod
Python:
@staticmethod
def utilidade(x, y):
return x + y
2. Docstrings:
Python:
class Robot:
"""Represents a robot, with a name."""

def say_hi(self):
"""Says hello."""
print('Greetings!')

# Acesso:
print(Robot.__doc__)
print(Robot.say_hi.__doc__)
help(Robot)
3. Herança:
Conceitos
• Todas as classes derivam de object (direta ou indiretamente)
• Herança múltipla é permitida
Sintaxe
Python:
from modulo import ClasseBase

class SubClasse(ClasseBase):
def __init__(self, param1, param2):
# Invocar construtor da superclasse:
super().__init__(param1) # Forma 1 (recomendada)
# OU
 ClasseBase.__init__(self, param1) # Forma 2
self.novo_atributo = param2
Regras
• Construtor da subclasse deve invocar construtor da superclasse
• Se não definir construtor, herda o da classe base
• Importar classe base antes de usá-la
4. Polimorfismo:
Em Python, polimorfismo é IMPLÍCITO
Características
• Todos os métodos são virtuais
• Sempre usamos referências para objetos
• Método chamado depende do tipo do objeto em tempo de execução
Python:
class SchoolMember:
def tell(self):
print(f"Name: {[Link]}")

class Teacher(SchoolMember):
def tell(self):
[Link](self) # ou super().tell()
print(f"Salary: {[Link]}")

class Student(SchoolMember):
def tell(self):
[Link](self)
print(f"Marks: {[Link]}")

members = [Teacher('Mrs. X', 40, 30000), Student('Y', 25, 75)]

for member in members:
[Link]() # Polimorfismo automático!
5. Ficheiros:
Abertura e Modos
Python:
# Modo tradicional
f = open('[Link]', 'w') # 'r'=ler, 'w'=escrever, 'a'=acrescentar
[Link](poem) # 't'=texto (default), 'b'=binário
[Link]()
# Leitura
f = open('[Link]') # Default: modo leitura texto
while True:
line = [Link]()
 if len(line) == 0: # EOF
break
print(line, end='')
[Link]()
Forma Moderna (with):
Python;
with open('[Link]', 'w') as f:
[Link](poem)
# Fecha automaticamente!
with open('[Link]') as f:
for line in f:
print(line, end='')
6. Persistência com pickle
Salvar Objetos
Python:
import pickle
shoplist = ['apple', 'mango', 'carrot']
# Escrever
with open('[Link]', 'wb') as f:
[Link](shoplist, f)
# Ler
with open('[Link]', 'rb') as f:
storedlist = [Link](f)
print(storedlist) # ['apple', 'mango', 'carrot']
Características
• Salva objeto + todos subobjetos (recursivo)
• Modo binário obrigatório ('wb', 'rb')
7. Biblioteca Standard:
Módulo sys
Python:
import sys
# Argumentos de linha de comando
print([Link]) # [nome_programa, arg1, arg2, ...]
# Versão do Python
sys.version_info
sys.version_info.major == 3 # True
# Caminhos de busca de módulos
[Link]
Outros Módulos Úteis
• re: expressões regulares
• argparse: opções de linha de comando
 • datetime: data/hora
• pdb: debugging interativo
8. Listas por Compreensão :
Sintaxe Básica
Python:
lista1 = [2, 3, 4]
lista2 = [2*x for x in lista1]
print(lista2) # [4, 6, 8]
Com Filtro
Python:
lista2 = [2*x for x in lista1 if x > 2]
print(lista2) # [6, 8]
Equivalente Matemático:
{2x : x ∈ {2, 3, 4} ∧ x > 2}
Operações
1. Selecionar valores (iteração)
2. Transformar cada valor
3. Formar nova lista
Nota
• Funciona com qualquer iterável (não só listas)

9. Expressões Geradoras
Conceito
• Lista por compreensão com parêntesis curvos ()
• Retorna objeto gerador (iterador), não lista
Python:
lista1 = [2, 3, 4]
it = (2*x for x in lista1 if x > 2)
print(it) # <generator object ...>
next(it) # 6
next(it) # 8
next(it) # StopIteration
Diferença
• Lista: [...] → cria lista completa na memória
• Gerador: (...) → calcula valores sob demanda (lazy)
10. Função Lambda:
Sintaxe
Python:
lambda <parâmetros>: <expressão>
Características
• Função anónima de uma linha
 • Usa lambda em vez de def
• NÃO precisa de return (implícito)
• Não pode ter instruções de controlo
• Não pode ter variáveis locais
Exemplo
Python:
(lambda x, y: [Link]() == [Link]())('ana', 'Ana') # True
# Equivalente a:
def compara(x, y):
return [Link]() == [Link]()
Uso Típico
• Funções pequenas usadas uma vez
• Quando sintaxe def não é adequada
• Melhora estilo do código
11. map() e filter()
map(função, lista):
• Aplica função a todos elementos
• Retorna iterador (objeto map)
Python:
lista1 = [2, 3, 4]
lista2 = list(map(lambda x: 2*x, lista1))
print(lista2) # [4, 6, 8]
filter(função_booleana, lista):
• Aplica filtro a todos elementos
• Retorna iterador (objeto filter)
Python:
lista1 = [2, 3, 4]
lista2 = list(filter(lambda x: x % 2 == 0, lista1))
print(lista2) # [2, 4]
Pontos-Chave para o Exame:
Atributos de classe: sem self, compartilhados (ex: [Link])
Atributos de objeto: com self, individuais (ex: [Link])
@classmethod: tem cls, acessa classe
@staticmethod: sem cls nem self, função utilitária
Herança: super().__init__() ou ClasseBase.__init__(self, ...)
Polimorfismo: implícito, métodos sempre virtuais
Ficheiros: with open(...) as f: fecha automaticamente
Pickle: dump() grava, load() lê, modo binário obrigatório
Listas por compreensão: [expr for x in lista if cond]
Expressões geradoras: (expr for x in lista) → iterador
 Lambda: lambda x: x*2, funções anónimas pequenas
map(): aplica função, retorna iterador
filter(): aplica filtro booleano, retorna iterador

Comparação Rápida
Conceito Python Java/C++
Método de classe @classmethod + cls static (mas diferente)
Método estático @staticmethod static
Polimorfismo Implícito/automático Explícito (virtual)
Lambda lambda x: x*2 (Java 8+, C++11+)
List comprehension [x*2 for x in list] (não existe facilmente)