Objetos e Classes
Em Python, tudo é um objeto, e os objetos são instâncias de classes. Uma classe é um modelo ou “plano” para criar objetos que compartilham características e comportamentos semelhantes. Classes definem atributos (dados) e métodos (funções) que os objetos podem ter.
Há diversos tipos de objetos e classes que permitem a criação de estruturas de dados e a modelagem de comportamentos específicos.
Números
Temos números inteiros (‘int’) e de ponto flutuante (‘float’), que representa números com casa decimais. Ambos são tipo de dados numéricos fundamentais
numero_inteiro = 31
numero_decimal = 12.54
Você pode realizar várias operações aritméticas com números inteiros e de ponto flutuante em Python. Por exemplo, adição, subtração, multiplicação e divisão funcionam para ambos os tipos:
# Operações com inteiros
a = 10
b = 3
soma = a + b # 13
subtracao = a - b # 7
multiplicacao = a * b # 30
divisao = a / b # 3.3333333333333335
# Operações com números de ponto flutuante
x = 2.5
y = 1.2
soma_float = x + y # 3.7
subtracao_float = x - y # 1.3
multiplicacao_float = x * y # 3.0
divisao_float = x / y # 2.0833333333333335
O Python também oferece funções embutidas para converter entre inteiros e números de ponto flutuante:
# Convertendo um int para float
int_para_float = float(a) # 10.0
# Convertendo um float para int (neste caso, a parte decimal é truncada)
float_para_int = int(x) # 2
String
Strings (‘str’) representa sequência de caracteres.
Ela é utilizada para representar texto e é uma das estruturas de dados mais comuns na linguagem. As strings são representadas por um conjunto de caracteres entre aspas simples (‘) ou aspas duplas (“).
# Strings com aspas simples
string1 = 'Olá, mundo!'
# Strings com aspas duplas
string2 = "Bioscriptistica é incrível!"
# Mesclar aspas simples e aspas duplas
string3 = "It's a beautiful day."
Booleanos
Booleanos (‘bool’) representa valores verdadeiros (‘True’) e falso (‘False’). Eles são usados para realizar operações lógicas e para tomar decisões em programas.
Os valores booleanos são retornados como resultados de comparações, operações lógicas e expressões condicionais. Por exemplo, ao comparar dois valores, a expressão retornará um valor booleano, indicando se a comparação é verdadeira ou falsa.
# Comparação
a = 10
b = 5
resultado = a > b # Resultado será True, pois 10 é maior que 5
# Operações lógicas
x = True
y = False
resultado_and = x and y # Resultado será False, pois ambas as variáveis devem ser True para o resultado ser True
resultado_or = x or y # Resultado será True, pois apenas uma das variáveis precisa ser True para o resultado ser True
resultado_not = not x # Resultado será False, pois not inverte o valor de x (True vira False e vice-versa)
Os valores booleanos são frequentemente utilizados em estruturas de controle de fluxo, como condicionais (if, else, elif) e loops (while, for), para tomar decisões e controlar o comportamento do programa com base em certas condições.
temperatura = 25
if temperatura > 30:
print("Está quente!")
elif temperatura > 20:
print("Está agradável.")
else:
print("Está frio.")
Listas
Lista (list) é uma estrutura de dados que permite armazenar uma coleção ordenada de elementos.
As listas são mutáveis, o que significa que você pode adicionar, remover e modificar elementos após a criação da lista.
As listas são representadas por colchetes [] e os elementos são separados por vírgulas. Os elementos de uma lista podem ser de diferentes tipos, incluindo inteiros, números de ponto flutuante, strings, outras listas, dicionários, entre outros.
# Lista de números inteiros
numeros = [1, 2, 3, 4, 5]
# Lista de nomes
nomes = ['Ana', 'João', 'Maria', 'Pedro']
# Lista mista
lista_mista = [1, 'Python', 3.14, True]
# Lista aninhada (lista contendo outras listas)
lista_aninhada = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
As listas são indexadas, o que significa que cada elemento da lista possui uma posição numérica, começando do índice 0 para o primeiro elemento, 1 para o segundo elemento e assim por diante. Você pode acessar os elementos de uma lista usando a notação de índice.
print(numeros[0]) # Output: 1
print(numeros[2]) # Output: 3
Você também pode modificar elementos existentes da lista e adicionar novos elementos usando os métodos apropriados.
# Modificar elemento existente
nomes = ['Ana', 'João', 'Maria']
nomes[1] = 'Pedro' # Agora a lista será ['Ana', 'Pedro', 'Maria']
# Adicionar elemento ao final da lista
numeros = [1, 2, 3]
numeros.append(4) # Agora a lista será [1, 2, 3, 4]
# Adicionar elemento em uma posição específica
numeros.insert(1, 10) # Agora a lista será [1, 10, 2, 3, 4]
Tuplas
Tupla é uma estrutura de dados semelhante a uma lista, mas com uma importante diferença: ela é imutável. Isso significa que, uma vez criada, não é possível modificar, adicionar ou remover elementos individuais da tupla. No entanto, você pode criar uma nova tupla com elementos diferentes.
Enquanto listas são definidas usando colchetes [], tuplas são definitas usando parênteses () e podem conter zero ou mais elementos separados por vírgulas.
Veja alguns exemplos de tuplas:
# Tupla vazia
tupla_vazia = ()
# Tupla com um único elemento
tupla_unico_elemento = (42,)
# Tupla com vários elementos
tupla_numeros = (1, 2, 3, 4, 5)
# Tupla com nomes de frutas
tupla_frutas = ('maçã', 'banana', 'laranja', 'uva')
# Tupla com diferentes tipos de dados
tupla_mista = ('Python', 3, True)
# Tupla aninhada
tupla_aninhada = (1, (2, 3), 'Tupla dentro de tupla')
Você pode acessar os elementos de uma tupla usando indexação:
tupla_frutas = ('maçã', 'banana', 'laranja', 'uva')
print(tupla_frutas[0]) # Output: maçã
print(tupla_frutas[2]) # Output: laranja
As tuplas podem ser usadas de várias maneiras, mas são mais comumente usadas para retornar múltiplos valores de uma função ou para armazenar coleções de itens relacionados que não precisam ser modificados. Um exemplo comum é usar tuplas para trocar valores de variáveis de forma elegante:
a = 10
b = 20
# Troca os valores de a e b usando uma tupla
a, b = b, a
print(a) # Output: 20
print(b) # Output: 10
Embora as tuplas sejam imutáveis, você pode realizar operações como a concatenação de tuplas para criar novas tuplas:
tupla1 = (1, 2, 3)
tupla2 = (4, 5, 6)
tupla_concatenada = tupla1 + tupla2
print(tupla_concatenada) # Output: (1, 2, 3, 4, 5, 6)
As tuplas são usadas em várias situações, principalmente quando você deseja garantir que os dados não sejam acidentalmente modificados, ou quando precisa retornar múltiplos valores de uma função.
Dado que as tuplas são imutáveis, elas são mais eficientes em termos de memória do que as listas e podem ser usadas como chaves em dicionários, ao contrário das listas.
Dicionários
Dicionários (dict) é uma estrutura de dados que permite armazenar uma coleção de elementos com chave-valor.
Os dicionários são representados por chaves {} e os pares chave-valor são definidos separando a chave do valor por dois-pontos “:”. Cada par chave-valor é separado por vírgula. As chaves em um dicionário devem ser únicas, mas os valores podem ser repetidos.
São extremamente úteis quando se precisa mapear e armazenar informações relacionadas, como informações de uma pessoa, dados de um produto, ou qualquer conjunto de informações que exija uma chave para recuperar os respectivos valores associados.
# Dicionário de informações de uma pessoa
pessoa = {
'nome': 'João',
'idade': 30,
'cidade': 'São Paulo',
'profissao': 'Engenheiro'
}
Nesse exemplo, o dicionário pessoa contém quatro pares chave-valor: ‘nome’: ‘João’, ‘idade’: 30, ‘cidade’: ‘São Paulo’ e ‘profissao’: ‘Engenheiro’.
Você pode acessar os valores de um dicionário usando a chave correspondente e modificar os valores associados às chaves ou adicionar novos pares chave-valor ao dicionário:
print(pessoa['nome']) # Output: 'João'
print(pessoa['idade']) # Output: 30
pessoa['idade'] = 31 # Modificar o valor da chave 'idade'
pessoa['sobrenome'] = 'Silva' # Adicionar novo par chave-valor
Funções
Funções (function): Permite definir blocos de código reutilizáveis.
Uma função é um bloco de código nomeado que realiza uma tarefa específica. Ela permite agrupar um conjunto de instruções em um único bloco lógico, que pode ser chamado e executado várias vezes em um programa.
As funções são úteis para evitar repetição de código, melhorar a legibilidade, modularidade e reutilização de código. Em vez de escrever o mesmo conjunto de instruções várias vezes, você pode definir uma função uma vez e chamá-la sempre que necessário. Aqui está a sintaxe básica de uma função em Python:
def nome_da_funcao(argumentos):
# Corpo da função
# Instruções executadas pela função
return valor_de_retorno
A definição de função começa com a palavra-chave def, seguida pelo nome da função e uma lista de argumentos entre parênteses. Os argumentos são opcionais, então você pode ter uma função sem argumentos. O corpo da função é um bloco de código indentado que contém as instruções a serem executadas.
A palavra-chave return é usada para retornar um valor da função. Se não houver uma declaração de retorno, a função retornará None implicitamente.
Aqui está um exemplo de uma função simples que calcula a soma de dois números:
def soma(a, b):
resultado = a + b
return resultado
Depois de definir a função, você pode chamá-la usando seu nome e fornecendo os argumentos necessários:
resultado = soma(2, 3)
print(resultado) # Saída: 5
Além disso, as funções em Python podem ter argumentos padrão, que possuem um valor pré-definido caso nenhum argumento seja fornecido. Isso permite que você crie funções mais flexíveis.
Neste exemplo, se nenhum argumento for fornecido, o valor padrão “Usuário” será usado.
def saudacao(nome="Usuário"):
print("Olá, " + nome + "!")
saudacao() # Saída: Olá, Usuário!
saudacao("Alice") # Saída: Olá, Alice!
Matriz
Uma matriz é uma estrutura de dados bidimensional que permite armazenar uma coleção de elementos organizados em linhas e colunas. Ela é representada como uma lista de listas, onde cada lista interna representa uma linha da matriz.
Matrizes em Python não são um tipo de dado nativo como em algumas linguagens de programação, mas você pode criar e manipular matrizes usando listas ou bibliotecas como NumPy.
# Exemplo de matriz 2x3
matriz = [
[1, 2, 3],
[4, 5, 6]
]
Neste exemplo, temos uma matriz 2×3, com duas linhas e três colunas. A primeira linha contém os elementos 1, 2 e 3, e a segunda linha contém os elementos 4, 5 e 6.
Você pode acessar os elementos individuais da matriz usando a notação de índice de listas:
print(matriz[0][1]) # Output: 2 (elemento na linha 0 e coluna 1)
print(matriz[1][2]) # Output: 6 (elemento na linha 1 e coluna 2)
Apesar de ser possível criar matrizes usando listas nativas do Python, a biblioteca NumPy oferece recursos mais avançados e otimizados para trabalhar com matrizes e cálculos numéricos. Exemplo de matriz usando NumPy:
import numpy as np
# Criar uma matriz usando NumPy
matriz_np = np.array([
[1, 2, 3],
[4, 5, 6]
])
O NumPy permite realizar operações de matriz, como multiplicação, adição, transposição e muito mais, de forma eficiente e concisa.
# Multiplicação de matrizes com NumPy
outra_matriz_np = np.array([
[7, 8],
[9, 10],
[11, 12]
])
resultado = np.dot(matriz_np, outra_matriz_np)
print(resultado)
# Output [[ 58 64] [139 154]]
Dataframe
DataFrame é uma estrutura de dados bidimensional e tabular que é amplamente usada na análise de dados e ciência de dados. Ele é uma das principais estruturas fornecidas pela biblioteca pandas, que é uma biblioteca popular para manipulação e análise de dados.
Um DataFrame pode ser considerado como uma tabela de dados, onde as informações são organizadas em linhas e colunas. Cada coluna do DataFrame representa uma variável e cada linha representa uma observação ou registro.
Para usar DataFrames, você precisa importar a biblioteca pandas antes:
import pandas as pd
Você pode criar um DataFrame a partir de diferentes fontes de dados, como listas, dicionários, arquivos CSV, bancos de dados, entre outros.
# Dados em formato de dicionário
dados = {
'Nome': ['João', 'Maria', 'Pedro', 'Ana'],
'Idade': [30, 25, 28, 22],
'Cidade': ['São Paulo', 'Rio de Janeiro', 'Belo Horizonte', 'Salvador']
}
# Criar DataFrame a partir do dicionário
df = pd.DataFrame(dados)
print(df)
Exemplo de criação de DataFrame a partir de uma lista de listas:
# Dados em formato de lista de listas
dados_lista = [
['João', 30, 'São Paulo'],
['Maria', 25, 'Rio de Janeiro'],
['Pedro', 28, 'Belo Horizonte'],
['Ana', 22, 'Salvador']
]
# Criar DataFrame a partir da lista de listas
df_lista = pd.DataFrame(dados_lista, columns=['Nome', 'Idade', 'Cidade'])
print(df_lista)
Os DataFrames do pandas oferecem uma ampla gama de funcionalidades para manipulação de dados, como filtragem, seleção, agregação, fusão, ordenação e muito mais. Eles são especialmente úteis para análise exploratória de dados e preparação de dados antes de aplicar modelos de aprendizado de máquina. Devido à sua versatilidade e eficiência, os DataFrames do pandas são uma ferramenta essencial para cientistas de dados e analistas que trabalham com manipulação e análise de dados em Python.
Exercícios
1. Crie uma matriz com números em sequência de 1 a 25 com número igual de colunas e linhas.
2. Crie uma lista com dois componentes: (1) um vetor com as letras A, B, e C, repetidas 2, 5, e 4 vezes respectivamente; (2) a matriz do exemplo anterior.
3. Atribua nomes para estes dois componentes da lista.
4. Inclua mais um componente nesta lista, com o nome de fator, e que seja um vetor da classe fator, idêntico ao objeto caracter criado acima (que possui apenas os nomes Olaf, Sheldon, Hulk).
