1. Iterando Elementos de uma Lista

Para processar cada item em uma coleção de dados, utilizamos laços de repetição. Um laço for em Python permite executar a mesma sequência de operações para cada elemento de uma lista.

É uma prática recomendada escloher nomes de variáveis que sejam descritivos para o elemento temporário que armazena cada valor durante a iteração.

itens_compras = ["banana", "maçã", "laranja", "uva"]
for fruta in itens_compras:
    print(f"Preciso comprar uma {fruta}.")
print("Lista de compras verificada!")

2. Erros Comuns de Indentação em Python

A indentação é crucial em Python e erros nela podem causar problemas de execução. Alguns dos erros mais frequentes encluem:

• Esquecer a indentação de uma linha de código que deveria pertencer a um bloco (como um laço for ou uma função).
• Indentar linhas adicionais dentro de um bloco, além da primeira linha.
• Indentar incorretamente uma instrução que deveria estar fora de um laço para dentro dele, fazendo com que ela seja executada múltiplas vezes.
• Esquecer os dois pontos (:) no final da declaração de um laço ou condição: Este é um erro comum e pode ser difícil de depurar.

3. Criando Sequências Numéricas

Listas são estruturas de dados ideais para armazenar sequências de números.

3.1. Utilizando a Função range()

A função range() é uma maneira eficiente de gerar uma sequência de números. Lembre-se que ela gera números até, mas não incluindo, o segundo argumento.

print("Números de 0 a 4:")
for num in range(5): # Gera de 0 a 4
    print(num)

print("\nNúmeros de 5 a 8:")
for valor in range(5, 9): # Gera de 5 a 8
    print(valor)

3.2. Gerando Listas de Números com range()

Para converter uma sequência gerada por range() em uma lista, basta envolvê-la com list(). A função range() também pode aceitar um terceiro argumento para definir o "passo" entre os números.

# Lista de números pares de 2 a 10
pares = list(range(2, 11, 2))
print(f"Números pares: {pares}")

# Lista de números ímpares de 1 a 9
impares = list(range(1, 10, 2))
print(f"Números ímpares: {impares}")

Para realizar operações matemáticas como potenciação, você pode usar o operador **.

quadrados = []
for i in range(1, 6): # De 1 a 5
    quadrado = i ** 2
    quadrados.append(quadrado)
print(f"Quadrados dos primeiros 5 números: {quadrados}")

Python também oferece funções para cálculos estatísticos básicos em listas numéricas:

dados = [5, 12, 3, 45, 8, 22, 1, 19]
print(f"Maior valor: {max(dados)}")
print(f"Menor valor: {min(dados)}")
print(f"Soma total: {sum(dados)}")

List Comprehension (Compreensão de Lista): Uma forma concisa de criar listas. Se você está criando uma lista em três ou quatro linhas de código, é provável que possa usar uma compreensão de lista.

# Gerando a lista de cubos de 1 a 10
cubos = [num**3 for num in range(1, 11)]
print(f"Cubos de 1 a 10: {cubos}")

4. Manipulando Partes de uma Lista

4.1. Fatiamento (Slicing) de Listas

É possível acessar qualquer subconjunto de elementos de uma lista utilizando a notação de fatiamento [inicio:fim]. O elemento no índice fim não é incluído. Omitir o inicio implica começar do primeiro elemento, e omitir o fim implica ir até o último.

animais = ["leão", "tigre", "urso", "cobra", "elefante"]
print(f"Os três primeiros animais: {animais[0:3]}") # ou animais[:3]
print(f"Animais do segundo ao quarto: {animais[1:4]}")
print(f"Os dois últimos animais: {animais[-2:]}")

4.2. Iterando em um Fatia

Você pode usar fatias diretamente em um laço for para processar apenas uma parte da lista.

cores = ["vermelho", "verde", "azul", "amarelo", "roxo"]
print("As primeiras três cores são:")
for cor in cores[:3]:
    print(cor.capitalize())

4.3. Duplicando uma Lista

Para criar uma cópia independente de uma lista, você pode usar uma fatia que abrange toda a lista ([:]).

lista_original = ["itemA", "itemB", "itemC"]
lista_copia = lista_original[:]

print(f"Original: {lista_original}")
print(f"Cópia: {lista_copia}")

lista_original.append("itemD") # Adiciona apenas à lista original
print(f"Original após adição: {lista_original}")
print(f"Cópia inalterada: {lista_copia}")

5. Tuplas: Sequências Imutáveis

Tuplas são como listas, mas seus elementos não podem ser alterados após a criação. Elas são definidas usando parênteses () em vez de colchetes [].

5.1. Definição e Acesso a Tuplas

Você acessa elementos de uma tupla da mesma forma que em uma lista, usando índices.

coordenadas = (10, 25)
print(f"Coordenada X: {coordenadas[0]}")
print(f"Coordenada Y: {coordenadas[1]}")

# Tentativa de modificar um elemento resultaria em um erro:
# coordenadas[0] = 15 # Isso causaria um TypeError

5.2. Reatriubindo uma Variável de Tupla

Embora os elementos de uma tupla não possam ser alterados, você pode reatribuir a variável da tupla a uma nova tupla completamente diferente.

dimensoes_tela = (800, 600)
print(f"Dimensões iniciais: {dimensoes_tela}")

# A tela foi redimensionada
dimensoes_tela = (1024, 768)
print(f"Novas dimensões: {dimensoes_tela}")

Tuplas são úteis quando você precisa de uma coleção de valores que devem permanecer constantes durante a execução do programa, oferecendo uma garantia de imutabilidade.

6. Operadores Básicos em Python

6.1. Operadores Aritméticos: Divisão, Resto e Divisão Inteira

Python fornece operadores para diferentes tipos de divisão e para obter o resto de uma divisão.

val_a = 27
val_b = 5

# Divisão inteira (descarta a parte decimal)
print(f"Divisão inteira de {val_a} por {val_b}: {val_a // val_b}")

# Resto da divisão
print(f"Resto da divisão de {val_a} por {val_b}: {val_a % val_b}")

# Divisão de ponto flutuante (resulta em um float)
print(f"Divisão de {val_a} por {val_b} (float): {val_a / val_b:.2f}") # Formatado para 2 casas decimais

6.2. Operadores Lógicos

Usados para combinar expressões condicionais.

condicao1 = True
condicao2 = False
condicao3 = 10 # Valores não-zero são True em contexto booleano
condicao4 = 0 # Zero é False em contexto booleano

print(f"True AND False: {condicao1 and condicao2}")
print(f"True OR False: {condicao1 or condicao2}")
print(f"NOT True: {not condicao1}")
print(f"NOT False: {not condicao2}")
print(f"10 AND 0: {condicao3 and condicao4}") # Retorna o segundo operando se o primeiro for True, ou o primeiro se for False
print(f"10 OR 0: {condicao3 or condicao4}") # Retorna o primeiro operando se for True, ou o segundo se o primeiro for False

6.3. Operadores Bit a Bit (Bitwise)

Operam nos bits individuais dos números.

num_x = 6  # Binário: 0110
num_y = 3  # Binário: 0011

# AND bit a bit
#   0110 (6)
# & 0011 (3)
# --------
#   0010 (2)
print(f"{num_x} & {num_y}: {num_x & num_y}")

# OR bit a bit
#   0110 (6)
# | 0011 (3)
# --------
#   0111 (7)
print(f"{num_x} | {num_y}: {num_x | num_y}")