1  Introdução ao Python I

Introdução

Nesta aula, vamos aprender desde o básico, sintaxe, tomada de decisões, repetição de ações, e estruturar melhor nossos programas, para que eles possam lidar com diferentes situações de forma dinâmica.

  1. Sintaxe e Scripts Básicos
  2. Tipos de Dados em Python
  3. Operadores em Python
  4. Controle de Fluxo
  5. Funções
  6. Tratamento de Erros

1.1 Porque Python?

Python é uma linguagem de programação fácil de aprender, com uma sintaxe clara e intuitiva, ideal para iniciantes. É amplamente utilizada em diversas áreas, como ciência de dados, desenvolvimento web e automação, tornando-se uma ferramenta versátil e prática.

1.2 Sintaxe

1.2.1 Scripts

Um script é um arquivo de texto com instruções a serem executadas por um computador que antes traduzirá o arquivo para linguagem de máquina.

Um script é um texto instrucional como qualquer outro, escrito em um tipo de linguagem especial, “de programação”, ou “código”, mas é um texto, quase como uma receita de bolo de cenoura.

Como em qualquer linguagem, temos um vocabulário à disposição, um conjunto de palavras (ou tokens) existentes, organizadas em categorias como substantivos, adjetivos, etc. Nós combinamos as palavras em frases (ou statements) para descrever as instruções. Por fim, organizamos o texto em parágrafos (ou blocks), conjuntos de frases que devem ser lidas juntas, para definir a estrutura e facilitar o entendimento do texto.

1.2.2 Sintaxe Básica

A sintaxe dentro do Python é muito semelhante com a linguagem humana. O programa “lê” de cima para baixo, da esqueda para a direita de forma sequencial!

Note ao longo dos programas: espaços, quebras de linha, tabs, comentários…

#Vamos fazer essa soma!

soma = 2 + 2 # soma bem facil...
soma2=2+2

print(soma, soma2)
4 4

1.3 Variáveis

As variáveis no python são bem parecidas com as variáveis da matemática. Serve como caixinhas que carregam algo dentro e, sempre que o programa ler ela, entenderá o seu conteúdo.

x = "julia"  #toda vez que o programa ler x, lerá a string julia
y = 5        #toda vez que o programa ler y, lerá o número inteiro 5
z = 2.5      #toda vez que o programa ler z, lerá o número float 2,5

Variáveis são um nome, associado à um valor, que mora na memória do computador.

Tenha em mente ao nomear uma variável que: - Não se pode usar os termos reservados;

  • Nomes de variáveis podem conter apenas letras, números e underscores(_). Podem começar com uma letra ou um underscore, mas não com um número;

  • Espaços não são permitidos em nomes de variáveis (usa-se underscores para separa as palavras);

  • Dicas: nomes de variáveis devem ser concisos, porém descritivos.

Na prática, quando escrevemos essas varíaveis, números e strings em células de código, observamos diferentes cores que indicam o que o python está enxergando.

Termos reservados são termos que já possuem um “significado” para o Python, então não podemos usa-los como variáveis.

1.4 Tipos de Dados

Tipos de dados são os “tijolinhos” básicos que formam nossos programas. Eles representam os diferentes tipos de informações que podemos armazenar e manipular, como textos, números e valores lógicos. Cada tipo de dado é salvo de uma forma específica na memória, permitindo que realizemos operações adequadas para cada tipo.

Nesta aula, vamos explorar os principais tipos de dados em Python. Para se aprofundar mais: https://docs.python.org/3/library/datatypes.html

1.4.1 String

Uma string é um “desenho”, onde o programa não enxerga nenhum valor numérico mas consegue diferir os “desenhos” entre si. Seu símbolo é ’ ’ ou ” “, indicando ao programa que é uma string. Um número pode ter valor numérico (int ou float por exemplo) ou não (str).

Obs: o python é uma linguagem extremamente sensível, então a string “julia” e a string “Julia” não são iguais para ele.

"Julia"
"luana"
"123456"

Uma ferramenta que vocês usarão e que “respiram” strings é o len().

“Len” é a breviação para a palavra Length, ou seja, comprimento, e é exatamente o que ele mede: essa função retorna o número de caractéres de uma string.

Obs: os ESPAÇOS contam como caracteres.

len("julia cruz") --> retorna o número 10 (um inteiro)

1.4.2 Inteiro

Os inteiros são números que não são strings e não possuem valor depois da vígula, ou seja, são números inteiros :D. Usados em expressões matemáticas para contas.

5
6
12
1000

1.4.3 Float

São semelhantes aos números inteiros porém considera e demanda valores depois da vírgula, mesmo que seja 0. Se misturam com os inteiros em equações matemáticas.

1.0
2.3
45.002
1000.0

1.4.4 Booleano

Um valor booleano é um tipo de dado que pode representar apenas dois estados distintos: verdadeiro ou falso. É fundamental em muitos aspectos da programação e da lógica, pois permite tomar decisões com base em condições.

verdadeiro = True
falso = False

1.5 Operadores

São símbolos que nos permitem realizar operações sobre variáveis e valores. Eles são fundamentais para a construção de expressões em Python, ajudando a manipular dados, fazer cálculos e tomar decisões.

Material base e aprofundamento: https://docs.python.org/3/library/operator.html

1.5.1 Operadores Aritiméticos

Os operadores aritméticos são usados para realizar operações matemáticas entre operandos.

image.png
print(2+2)
4
print(2*5 - 7)
3
print(4%2)
0
print(3%2)
1
divisao_inteira = 10 // 6
print(divisao_inteira, 10/6)
1 1.6666666666666667

1.5.1.1 Ordem de Precedência

# Parenteses
expressao_1 = ((2 + 5) * 3)
print(expressao_1)

expressao_2 = (2 + 5 * 3)
print(expressao_2)

expressao_3 = (1 + 5 ** 2)
print(expressao_3)
21
17
26
print(((2*3)**3)/7)
30.857142857142858

1.5.2 Operadores lógicos

Os operadores lógicos são usados alguma relação entre operandos. Quando utilizados, eles retornam valores booleanos (True ou False).

1.5.3 Operadores de Atribuição

Os operadores de atribuição são usados para atibuir valores a variáveis

numero = 5
numero += 1
print(numero)
6
numero = 3
numero -= 1
print(numero)
2
numero = 7
numero *= 5
print(numero)
35
numero = 9
numero /= 5
print(numero)
1.8
numero = 5
numero %= 2
print(numero)
1

😎

1.6 Control Flow

Basicamente, control flow é sobre como o programa decide qual parte do código executar e quando. Essas ferramentas permitem que o código se adapte a diferentes situações, tome decisões e realize ações repetitivas, dependendo dos valores e condições presentes no programa.

Para se aprofundar: https://docs.python.org/3/tutorial/controlflow.html

1.6.1 Condicionais

Condicionais são estruturas usadas para tomar decisões dentro de um programa. Elas permitem que o código execute diferentes blocos de instruções dependendo de condições específicas. Assim, com condicionais, é possível direcionar o fluxo do programa com base em critérios, como valores de variáveis, facilitando a criação de comportamentos dinâmicos e adaptativos.

1.6.1.1 if

A estrutura if é usada para verificar se uma condição é verdadeira e, caso seja, executar um bloco de código específico. Ela é a base das decisões em um programa, permitindo que diferentes ações aconteçamm dependendo do valor de uma condição. Se a condição for verdadeira, o código dentro do if será executado; caso contrário, será ignorado.

1.6.1.2 if else

A estrutura if else é usada quando há a necessidade de definir duas ações diferentes: uma a ser executada se a condição for verdadeira (if) e outra se essa condição for falsa (else). Dessa forma, ela garante que um dos dois blocos de código será executado, cobrindo todas as possibilidades de resultado da condição.

1.6.1.3 if elif else

A estrutura if elif else é usada quando há mais de duas possibilidades para a condição. Primeiro, o if verifica a condição inicial. Caso ela seja falsa, o elif (abreviação de “else if”) verifica uma nova condição, e isso pode se repetir quantas vezes for necessário. Por fim, o else cobre o caso em que nenhuma das condições anteriores é satisfeita. Essa estrutura permite criar múltiplos caminhos de decisão dentro do código.

1.6.2 Loops

Loops são estruturas usadas para repetir um bloco de código várias vezes, facilitando a automação de tarefas repetitivas. Eles são úteis quando se deseja realizar uma mesma operação várias vezes, seja sobre uma coleção de itens ou até que uma determinada condição seja atendida. Com loops, é possível escrever um código de forma mais concisa e eficiente, evitando a repetição manual de instruções.

1.6.2.1 while

A estrutura while repete um bloco de código enquanto uma condição for verdadeira. Ela é útil quando não se sabe exatamente quantas vezes o bloco do código precisará ser executado, mas sim até que uma determinada condição seja atendida. Assim que a condição se tornar falsa, o loop é interrompido.

1.6.2.2 for

A estrutura for é usada para repetir um bloco de código um número específico de vezes. Geralmente, é usada quando já se sabe quantas vezes o bloco de código deve ser executado. No contexto inicial, sem listas, o for pode ser usado para repetir ações com base em um intervalo definido, permitindo automatizar processos repetitivos de maneira simples.

1.6.3 Keywords

1.6.3.1 break

A instrução break é usada para interromper um loop antes de ele ser concluído. Quando o break é executado, o loop é finalizado imediatamente, e o programa segue para a próxima instrução. Essa instrução é útil quando se deseja parar a repetição ao atender a uma condição específica, mesmo que o loop ainda não tenha terminado seu ciclo completo.

1.6.3.2 continue

A instrução continue é usada para pular a iteração atual de um loop e avançar para a próxima iteração. Quando continue é executado, o loop não finaliza, mas simplesmente ignora o restante do bloco de código daquela iteração e volta para o início, verificando a condição novamente ou avançando para o próximo item. Isso é útil para evitar executar parte do código do loop em condições específicas.

1.6.4 Indo pra prática…

1.6.4.1 If elif else

hora = 7 

if hora >= 6:
    print("Hora de acordar!")
if hora < 6:
    print("Pode dormir mais um pouco.")
Hora de acordar!
dinheiro = 30
preço = 25

if dinheiro >= preço:
    print("Você pode comprar o produto!")
if dinheiro < preço:
    print("Você não tem dinheiro suficiente para comprar o produto.")
Você pode comprar o produto!
temperatura = 80

if temperatura >= 100:
    print("A água está fervendo!")
if temperatura < 100:
    print("A água não está fervendo ainda.")
A água não está fervendo ainda.

Exemplos que vou mostrar (vou tirar essa seção depois, está nos comentários)

1.6.5 Sintaxe e Definição

1.6.6 Argumentos

Argumentos são valores fornecidos a funções para que elas possam trabalhar com dados específicos. Existem três tipos principais:

  • Argumentos Posicionais: São passados para a função na ordem em que são definidos, e essa ordem determina qual parâmetro será preenchido.

  • Argumentos Padrão: São valores definidos como padrão (default) na função. Se um valor não for passado ao chamar a função, o valor padrão será usado.

def mostrar_dados(idade, nome):
    print(f"Nome: {nome}, Idade: {idade}")

# Posicional
mostrar_dados(20, "Aldo")
Nome: Aldo, Idade: 20
def funcao_exemplo(função):
    função()

def dizer_ola():
    print("Olá!")

# Posicional
funcao_exemplo(dizer_ola)
Olá!
def saudar(nome, saudacao):
    print(f"{saudacao}, {nome}!")

# Usando argumentos nomeados
saudar(nome="Vitor", saudacao="Bom dia")
saudar(saudacao="Boa tarde", nome="Ana")  # Aqui a ordem foi invertida, mas podemos identificar os argumentos pelo nome
Bom dia, Vitor!
Boa tarde, Ana!
def mostrar_dados_2(nome, idade=30):
    print(f"Nome: {nome}, Idade: {idade}")

# Chamando a função sem passar o valor para o argumento 'idade', o valor padrão será utilizado
mostrar_dados_2("Mariana")  # Nome: Mariana, Idade: 30

# Chamando a função passando todos os argumentos
mostrar_dados_2("João", 40)  # Nome: João, Idade: 40

# O default deve ser o último parâmetro a ser definido.
Nome: Mariana, Idade: 30
Nome: João, Idade: 40
def calcular_quadrados(numeros):
    for numero in numeros:
        quadrado = numero ** 2
        print(f"O quadrado de {numero} é {quadrado}")

valores = [1, 2, 3, 4, 5]
calcular_quadrados(valores)
O quadrado de 1 é 1
O quadrado de 2 é 4
O quadrado de 3 é 9
O quadrado de 4 é 16
O quadrado de 5 é 25

1.6.7 Funções Anônimas

Funções anônimas são apenas uma forma mais curta de escrever funções normais. Elas também são conhecidas como funções lambda. Ao invés de usar def para definir uma função, as funções anônimas são escritas em uma linha, ideal para tarefas simples. Elas são muito úteis quando você precisa de uma pequena função que será usada apenas uma vez e não quer se preocupar em dar um nome para ela.

https://www.w3schools.com/python/python_lambda.asp

#Estrutura básica:
#lambda argumentos: expressão
#onde:
#lambda: A palavra-chave que indica o início de uma função lambda.
#argumentos: Lista de argumentos separados por vírgulas, semelhante aos argumentos das funções normais. Pode ser um único argumento, múltiplos argumentos, ou nenhum.
#expressão: Uma expressão que é executada e cujo valor é retornado pela função lambda. Diferentemente das funções definidas com def, uma função lambda pode ter apenas uma expressão.
# Função normal:

preco = int(input('\nDigite o preço para o calculo do imposto: '))

def calcular_imposto(preco):
    return preco * 0.3

print(calcular_imposto(preco))
# Função Lambda:

preco = int(input('\nDigite o preço para o calculo do imposto: '))

calcular_imposto = lambda preco: preco * 0.3

print(calcular_imposto(preco))

1.6.8 Técnicas com Funções

1.6.8.1 Recursão

Digamos que temos uma série temporal de vendas diárias, e queremos calcular o total acumulado até um determinado dia. Uma forma que podemos fazer isso é montar uma função recurssiva. De forma simples, nós definimos uma função que vai se usar novamente dentro de si mesma.

def acumulado(vendas, n):
    # Caso base: se o índice for 0, só existe um valor a ser somado
    if n == 0:
        return vendas[0]
    # Caso recursivo: soma o valor atual com o acumulado até o ponto anterior
    else:
        return vendas[n] + acumulado(vendas, n - 1)

# Exemplo de uso
vendas = [100, 150, 200, 250, 300]
total_acumulado = acumulado(vendas, 4)
print(f"Total acumulado até o quinto dia: {total_acumulado}")
Total acumulado até o quinto dia: 1000

1.6.9 Função como argumento

Já vimos que podemos usar muitas coisas como argumentos para funções, isso incluindo até mesmo outras funções. A utilidade disso depende de sua criatividade, mas é uma ferramenta muito útil!

def aplicar_operação(lista, operação):
    return [operação(item) for item in lista]

# Funções específicas que podemos aplicar
def dobrar(x):
    return x * 2

def triplicar(x):
    return x * 3

# Exemplo de uso
numeros = [1, 2, 3, 4, 5]

resultado_dobrar = aplicar_operação(numeros, dobrar)
print(f"Dobrando: {resultado_dobrar}")

resultado_triplicar = aplicar_operação(numeros, triplicar)
print(f"Triplicando: {resultado_triplicar}")
Dobrando: [2, 4, 6, 8, 10]
Triplicando: [3, 6, 9, 12, 15]

Recapitulando

Nesta aula, começamos aprendendo a sintaxe básica do Python, que define como organizar o código de forma que o Python possa compreendê-lo. Exploramos conceitos como variáveis e tipos de dados, os quais são os “tijolinhos” essenciais para armazenar informações e construir um programa.

Em seguida, discutimos como podemos brincar com esses tijolinhos usando os operadores aritméticos e lógicos. Eles nos permitem manipular esses dados, realizando cálculos e criando expressões lógicas. Entendemos também a ordem de precedência entre esses operadores, que determina a sequência em que as operações são executadas.

Depois, avançamos para o control flow. Aprendemos a tomar decisões no código usando estruturas condicionais (if, elif, else) e a repetir ações automaticamente com os loops (for e while). Também vimos como controlar a execução dos loops com break e continue.

Por fim, abordamos o conceito de funções. Vimos como criar funções utilizando def e como utilizar funções anônimas (lambda). Entendendo como são, essencialmente, o mesmo, mas igualmente importantes.

Esses conceitos, desde a sintaxe básica até a criação de funções e controle de fluxo, formam a base do Python e são fundamentais para que possamos prosseguir e escrever programas organizados.

1.7 Extras

1.7.1 Erros/Exceções

1.7.1.0.1 Tipos de exceções

Referência: https://docs.python.org/3/library/warnings.html, https://www.tutorialsteacher.com/python/error-types-in-python

Existem vários motivos diferentes para um script não rodar, é importante saber os mais comuns para ajudar na hora de investigar o que está de errado com um código.

  • Erro de sintaxe: SyntaxError, IndentationError, TabError
  • Erro de falta de memória: MemoryError, OverflowError
  • Erro de referência: IndexError, KeyError, NameError
  • Erro de operação: ZeroDivisionError, TypeError
  • Erro de lógica: o python realiza o código, mas não faz o que você queria que ele fizesse
  • Exceções: “o python sabe o que fazer com o código mas não consegue realizar a ação quista”
  • Avisos: não interrompem o código, mas indicam que algo pode estar errado
1.7.1.0.2 Como lidar com exceções?

Referência: https://www.w3schools.com/python/python_try_except.asp

Avisar ao utilizador do código que houve algum erro específico:

try:
    juros = int(input("Qual a taxa de juros desejada? "))
    print("A taxa escolhida foi {0}%.".format(juros))
except:
    print("A taxa de juros deve ser um número")
A taxa de juros deve ser um número

Em um loop, indicar que um dos itens não funcionou, mas realizar a operação para o resto dos itens:

import requests

paginas = []
urlList = ['https://finance.yahoo.com/quote/PETR4.SA', 'urlquebrado.com', 'https://finance.yahoo.com/quote/VALE3.SA']

for url in urlList:
    try:
        request = requests.get(url)
        result = f"result - {url}" #algo com os dados da página
        paginas.append(result)
    except:
        paginas.append("NA")
        print(f"A página {url} não pode ser lida")

paginas
A página urlquebrado.com não pode ser lida
['result - https://finance.yahoo.com/quote/PETR4.SA',
 'NA',
 'result - https://finance.yahoo.com/quote/VALE3.SA']