Programando Python

Um Curso Relâmpago

Prof: Darlan Cavalcante Moreira

Porque aprender Python?

  • Fácil de entender e aprender
  • Muito Flexível
  • Linguagem muito poderosa Extensa biblioteca disponível Excelente para iniciantes e experts
  • Ouvi dizer que vai ser útil mais na frente
  • Vamos utilizar aqui Python 3

Recursos

Instalando Python

  • Python possui duas versões: Python2 e Python3
  • Aqui usaremos a versão 3
  • Podem baixar a partir do site oficial em https://www.python.org/downloads/
  • Ou podemos usar umas das distribuições disponíveis

Diferenças Gerais do C++

  • Não é preciso declarar variáveis Gostei!
  • Não é preciso colocar ";" no final Show!
  • Não é preciso utilizar chaves O escopo é controlado por espaço Depois digo se gostei

O que esse programa faz?

for i in range(1, 101):  # Não há chaves {}
    if i % 15 == 0:  # Não é necessário parêntesis para a condição
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:     # elif combina 'else' com 'if'
        print("Buzz")
    else:
        print(i)
  • A função range cria uma "lista" de elementos
    • range(5) vai criar de 0 a 4
  • O "for" em python itera em cada elemento de um contêiner
  • Não precisamos de parêntesis para as condições

Tipos Primitivos em Python

Tipos já embutidos no núcleo da linguagem

  • Aqui vamos fazer um overview dos tipos primitivos em Python
  • Falamos em maiores detalhes de cada um deles

Tipos Simples

idade = 4            # Inteiro (int)
nome = "Kadu"        # String (str)
peso = 10.4          # Float (float)
vacinado = True      # Booleano (bool)
dono_anterior = None # Representa um tipo vazio (None)
peso_int = int(peso) # Inteiro convertido a partir de um float
c = 1-3j             # Número complexo
  • Utilize "type" para determinar o tipo de uma variável >>> type(peso) float >>> type(peso_int) int >>> type(nome) str

Tipos Compostos (contêineres)

uma_lista = [2, 3, 5.5, 7, 11, "lala"] # Lista (list, [])
uma_tupla = (2, "lala", 4)             # Tupla (tuple, ())
um_dict = {'nome': "Silvio Santos",    # Dicionário (dict)
          'idade': 86,
          "profissões": ["apresentador", "empresário"]}
um_conjunto = {1, 4, 8, 10, "lala"}    # Conjunto (set)
  • Python possui vários estruturas de dados flexíveis como listas, tuplas, dicionários e conjuntos
  • Podemos armazenar valores de diferentes tipos nesses contêineres

Entrada e Saída

  • Em python imprimimos usando a função print >>> print("Tá muito fácil") Tá muito fácil >>> x=10; >>> print("Ele tinha", x, "anos") # Separador padrão: espaço Ele tinha 10 anos
  • Em python recebemos uma entrada com a função input
    • input sempre retorna uma string
    >>> print("Digite o nome") >>> nome = input() >>> print("Digite a idade") >>> x = int(input()) # Input retorna um texto >>> print(nome, "tem", x, "anos") # Digitou 'John Doe' e '20' John Doe tem 20 anos

Operadores em Python

Operadores Aritméticos

  • Os operadores aritméticos em Python são os mesmos do C/C++
    +, -, *, /, //, %, **, +=, -=, *=, /=, %=, **=, \\=
  • Com adição de um operador para divisão de inteiros e um para potenciação
  • Mas não temos os operadores unários ++ e --
>>> a = 1 >>> b = 2 >>> print(a + b) 3 >>> a = 5 >>> print(a / b) # 'a' e 'b' são inteiros, mas a divisão é em float 2.5 >>> print(a // b) 2 >>> print(a**2) 25

Operadores Relacionais

  • Temos os mesmos operadores relacionais do C/C++
    > , < , ==, !=, >=, <=
  • Além deles, temos também os operadores "is" e "in"
>>> a = 1; b = 2 # Usamos ";" para colocar dois comandos na mesma linha >>> a == b False >>> a > b False >>> a = [1, 2, 3]; b = [1, 2, 3] # Duas listas contendo os mesmos elementos >>> a == b # 'a' e 'b' são iguais (possuem o mesmo valor) ... True >>> a is b # ... mas 'a' e 'b' são variáveis diferentes False >>> a = b # Agora a e b são a mesma variável (modifique um e o outro muda) >>> a is b True >>> l = [2, 5, 10] >>> 5 in l # O número 5 está na lista 'l'? True >>> 4 in l # O número 4 está na lista 'l'? False

Operadores Lógicos

  • Ao invés de && e || temos as palavras chave and e or
  • Ao invés de ! temos a palavra chave not
  • Também temos os operadores lógicos bit-a-bit &, |, ^, assim como um operador inverter os bits de um inteiro ~
>>> 3 < 5 and 4 <= 2 False >>> 3 <= 5 or 4 < 2 True >>> not (3 <= 5 or 4 < 2) False >>> 5 | 2 # Aquele item na 5 questão da prova 7 >>> 5 & 2 # Aquele outro item na 5 questão da prova 0 >>> 16 ^ 6 ^ 10 ^ 15 ^ 16 ^ 6 ^ 10 # Aquela questão que pouca gente acertou 15 >>> ~7 # Invertemos cada bit de 7 (incluindo o bit de sinal) -8

Controle de Fluxo em Python

Estruturas Condicionais

  • O escopo em Python é controlado por indentação
  • Python possui as estruturas condicionais if, else e elif
    • elif corresponde a um else seguido de um if e existe para evitar indentação excessiva
if x == 42:
    # Código executado de x for igual a 42
    print("x vale 42")
elif x > 0:
    print("x não vale 42, mas pelo menos é maior que 0")
else:
    print("Nenhuma das condições anteriores foi verdadeira")

Nota: Não existe "switch case" em Python, mas temos uma alternativa

Estruturas de Repetição

  • O for em Python difere do for em C/C++
  • Em Python ele itera através dos itens de uma sequência (uma lista, uma string, etc) na ordem em que eles aparecem
    palavras = ['gato', 'janela', 'paralelepípedo']
    for palavra in palavras:
        print (palavra.upper())
  • Para iterar em uma sequência de números use range
    range(5, 10)          # 5, 6, 7, 8, 9
    range(0, 10, 3)       # 0, 3, 6, 9
    range(-10, -100, -30) # -10, -40, -70
    range(-10, -101, -30) # -10, -40, -70 -100
    >>> for i in range(5, 8): ... print(i**2) 25 36 49

Estruturas de Repetição

  • Também temos while em Python, que funciona de forma semelhante ao C/C++
    N = 6
    f = 1
    while N > 1:
        f = f * N
        N -= 1  # Não existe ++ ou -- em Python
  • Em um bloco de código (corpo de um if, for, while, etc) podemos usar pass para não "fazer nada"
    while True:
        pass

Mais sobre os tipos de dados em Python

Vamos agora mostrar em maiores detalhes os tipos de dados em Python

Strings em Python

  • Strings são escritas com aspas simples ou duplas
  • O operador "+" pode ser usado para concatenar strings
    • Ex: "a" + "b" é o mesmo que "ab"
  • O operador "*" pode ser usado para repetir strings
    • Ex: "a" * 10 é o mesmo que "aaaaaaaaaa"
  • Caracteres não imprimíveis podem ser expressos usando notação "barra-invertida"
    • \n é o mesmo que new line
    • \t é o mesmo que tab
    • \\ é o mesmo que \
    • \" e \' é o mesmo que " e ', respectivamente

Strings em Python

  • Também é possível escrever string em várias linhas incluindo as quebras de linha usando três aspas >>> print(""" Um tigre dois tigres três tigres""")
  • Strings possuem muitos métodos úteis, como format, split, join, strip >>> disciplina = "Fundamentos de Programação" >>> professor = "Darlan" >>> print("{0} é o professor de \"{1}\"".format(professor, disciplina)) Darlan é o professor de "Fundamentos de Programação"
  • Veja a documentação de strings para métodos úteis

Índices e Slices

  • É possível pegar um caractere de uma string com a notação string[índice]
  • Um índice negativo endereça em sentido inverso
  • Podemos endereçar fatias (slices) com notação [início:fim:passo]
>>> a = "abcde" >>> a[0] # Pega o primeiro elemento a >>> a[-1] # Pega o último elemento e >>> a[-2] # Pega o penúltimo elemento d >>> a[2:4] # Pega os elementos do índice 2 aoíndice 3 cd >>> a[-2:] # Dois últimos elementos de >>> a[::-2] # Pega os elementos do primeiro ao último pulando de 2 em 2 ace

Listas

  • Python possui vários tipos compostos, usados para agrupar outros valores.
  • O mais versátil de todos é a lista >>> l1 = [15, 34.5, 44] # itens são separados por vírgulas >>> l2 = ["Brasil", "Estados Unidos", "Japão", "França"] >>> l3 = [1, 2, "três", "quatro"] # Itens podem ter tipos diferentes
  • A lista é um tipo mutável é possível modificar seus elementos >>> a = [1, 5, 10, 15, 20] >>> a[2] = 100 >>> print(a) [1, 5, 100, 15, 20]
  • Podemos indexar strings, mas strings são imutáveis
    • Não podemos modificar uma letra de uma string
    • Precisamos criar uma nova string nesse caso

Listas

  • Assim como em strings, podemos indexar uma lista para pegar um elemento em particular ou uma fatia (slice)
  • Também é possível concatenar duas listas com o operador + assim como fazemos com strings
  • Uma operação comum em um lista consiste em adicionar um ou mais elementos: use os métodos append e extend
>>> a = [1, 5, 10] >>> a.append(15) # Adiciona o número 15 na lista >>> print(a) [1, 5, 10, 15] >>> b = [100, 200] >>> a.extend(b) # Adiciona os elementos da lista 'b' na lista 'a' >>> print(a) [1, 5, 10, 15, 100, 200]

Listas

  • Podemos usar slices também para fazer atribuições
  • Para remover um elemento podemos usar remove
  • pop remove e retorna o último elemento da lista
  • Para remover um elemento pelo índice use del
>>> a = [1, 5, 10, 15, 100, 200] >>> a[1::2] = [1000, 2000, 3000] # a[1::2] -> posições 1, 3 e 5 >>> print(a) [1, 1000, 10, 2000, 100, 3000] >>> a.remove(10) # Encontra o primeiro 10 na lista e remove >>> print(a) [1, 1000, 2000, 100, 3000] >>> b = a.pop() # Remove o último elemento da lista (3000) e retorna >>> print(b) 3000 >>> del a[0:2] # Remove os 2 primeiros elementos

Listas

  • É comum querermos construir uma lista efetuando uma operação em cada elemento de outra lista
  • Para isso Python forcece o conceito de list comprehensions
  • Suponha que queremos criar um conjunto com valores definidos por \(\{x^2 : x \in \{0, ..., 9\}\}\)
  • E se quisermos o quadrado apenas dos números pares?
>>> a = [x**2 for x in range(10)] >>> print(a) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> a = [x**2 for x in range(10) if x % 2 == 0] >>> print(a) [0, 4, 16, 36, 64]

Veja mais na documentação oficial

Tuplas

  • Tuplas consistem de um conjunto de valores em parêntesis separados por vírgula
  • Tuplas são semelhante as listas, mas tuplas são imutáveis
    • Seus valores não podem ser modificados e não é possível adicionar ou remover valores
  • Também podemos acessar os elementos de uma tupla (ou qualquer sequência) é via unpacking
>>> minha_tupla = (1, 2, 3, "e", "já") >>> minha_tupla[0] = 10 # ERRO -> tuplas são imutáveis! >>> a, b, c, d, e = minha_tupla # Coloca os elementos nas variáveis >>> print(b) 2 >>> print(e) já

Dicionários

  • Um dicionário mapeia uma chave e um valor
  • As chaves precisam ser imutáveis (e únicas)
  • Podemos testar se uma chave está no dicionário com in
  • O método keys() retorna as chaves no dicionário
  • Use del para remover um par chave/valor do dicionário
>>> telefones = {"Polícia": 190, "Ambulância": 192} >>> telefones["Polícia"] 190 >>> "Bombeiros" in telefones False >>> telefones["Bombeiros"] = 193 >>> "Bombeiros" in telefones True >>> print(list(telefones.keys())) # Imprime uma lista com as chaves ['Bombeiros', 'Ambulância', 'Polícia'] >>> del telefones['Ambulância'] >>> print(list(telefones.keys())) # Imprime uma lista com as chaves ['Bombeiros', 'Polícia']

Dicionários

  • Podemos iterar sobre um dicionário com um for
  • use d.items() para retornar uma "lista de pares" de chave e valor que pode ser usada em um for, por exemplo
d = {"pi": 3.141592,
     "e": 2.718282,
     "número de ouro": 1.6180}

for chave, valor in d.items():
    pass  # Faça alguma coisa com a chave e o valor

Exemplo >>> for chave, valor in d.items(): ... print("{0}: {1}".format(chave, valor)) e: 2.718282 pi: 3.141592 número de ouro: 1.618

Conjuntos

  • Um conjunto em python é uma coleção de items sem ordem definida e sem elementos duplicados
  • Criamos um conjunto usando chaves ou usando set
  • Ações básicas: testar pertinência, união, interseção, diferença e diferença simétrica
>>> cesta = {'maçã', 'laranja', 'maçã', 'pera', 'laranja', 'banana'} >>> print(cesta) # Perceba que duplicatas foram eliminadas {'pera', 'banana', 'laranja', 'maçã'} >>> 'laranja' in cesta True >>> 'limão' in frutas False >>> A = set('abracadabra'); B = set('alacazam') # Vamos testar operaçoes >>> A | B # União: Letras em a ou b {'a', 'b', 'c', 'd', 'l', 'm', 'r', 'z'} >>> A & B # Interseção: Letras em a e em b {'a', 'c'} >>> A - B # Diferença: Letras em a que não estão em b {'b', 'd', 'r'} >>> A ^ B # Diferença simétrica: Letras em a ou em b, mas não em ambos {'b', 'd', 'l', 'm', 'r', 'z'}

Funções

Definindo novas Funções

  • Funções são definidas com a palavra chave def >>> def fib(n): ... """Imprime a série de Fibonacci até n. Essa função não retorna nada.""" ... a, b = 0, 1 ... while a < n: ... print(a, end=" ") ... a, b = b, a+b ... print() >>> fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fib <function __main__.fib> >>> f = fib >>> f <function __main__.fib> >>> f(1000) # Chama a função passando 1000 para o parâmetro n 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
  • A primeira declaração na função pode ser uma string, que será usada como documentação (docstring)
    • Pode ser vista com fib? no IPython ou help(fib)
  • Definir uma função introduz a mesma na tabela de símbolos atual

Funções com valor de retorno

  • Uma função pode ou não ter um return
  • Funções sem return retornam None
>>> def fib2(n): ... """Retorna (lista) a série de Fibonacci até n.""" ... result = [] # Cria uma lista vazia ... a, b = 0, 1 ... while a < n: ... result.append(a) # Adiciona um elemento na lista ... a, b = b, a+b ... return result ... >>> f100 = fib2(100) # chama a função >>> f100 # Notem que f100 é uma lista [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Parâmetros com valor padrão

  • Os parâmetros de uma função podem ter um valor padrão
  • Isso permite chamar a função com menos parâmetros do que foram definidos
  • Exemplo: \(s = s_0+v_0 t + \frac{1}{2}a t^2\)
    def calc_s(t, s0=0, v0=1, a=0.5):
        """Calcula posição final dados s0, v0, a e t."""
        return s0 + v0*t + 0.5 * a * t**2
  • Também é possível especificar um parâmetro pelo nome
>>> calc_s(5) # Chama a função apenas com o parâmetro obrigatório 11.25 >>> calc_s(5, 10) # Passa os 2 primeiros parâmetros 21.25 >>> calc_s(5, 10, a=1.0) # Passa 't' e 's0' pela posição e 'a' pelo nome 27.5

Nota: Não use tipos mutáveis para valores padrão

Funções com quantidade variável de argumentos

  • Funções podem aceitar uma quantidade variável de argumentos tanto via posição quanto via palavra chave
  • Para isso use o prefixo * e/ou ** antes do argumento final
  • Se houverem multiplos parâmetros via posição e nome use os dois prefixos
    
    def my_func(a, b, *args, **kwargs):  # 'a' é um 'b' são parâmetros obrigatórios
        print(a)
        print(b)
        # tupla de todos os parâmetros via posição
        print(args)
    
        # Dicionário com todos os parâmetros fornecidos via palavra chave
        print(kwargs)
                                    
>>> my_func(1, 2, 3, "e", "já", modelo="Fusca", cor="Amarelo") 1 2 (3, 'e', 'já') {'cor': 'Amarelo', 'modelo': 'Fusca'}

Funções Anônimas: lambda functions

  • As vezes precisamos efetuar algum cálculo simples, que possivelmente utilizaremos uma única vez logo em seguida
  • Nesses casos podemos criar uma "função anônima"
  • Notação: lambda variáveis: expressão >>> f = lambda a, b: a+b >>> f(3, 4) 7 >>> f = lambda x: x**2 >>> f(4) 16

Módulos e Scripts

Criando Scripts

  • Python é uma linguagem interpretada
    • Não precisamos compilar nosso programa
    • Podemos executar os comandos diretamente no terminal
      • Mas isso será perdido se fecharmos o terminal
    • Se salvarmos o código em um arquivo (script) poderemos rodar o programa sempre que quisermos
  • Para criar um script basta colocar o código em um arquivo com extensão .py
  • Rode o interpretador python passando o script como parâmetro ~$ python meu_script.py
  • Nota: É necessário ter o Python instalado no computador

Criando Módulos

  • Outra alternativa é criar um módulo e importá-lo
  • Supuponha que o arquivo my_funcs.py contém
    def dobra(x):
        return 2*x
    
    def triplica(x):
        return 3*x
    É possíve importar as definições do módulo my_funcs
>>> from my_funcs import dobra, triplica >>> dobra(5) 10 >>> triplica(5) 15 >>> import my_funcs as mf >>> mf.dobra(5) 10 >>> mf.triplica(5) 15
abs?
lalelel

IPython

  • Terminal interativo para a linguagem python que oferece:
  • Obtendo Ajuda com "?" (se necessário aperte "q" para sair do help) abs? Docstring: Return the absolute value of the argument. Type: builtin_function_or_method
  • Funções mágicas Muito úteis
    • %whos: Veja variáveis e funções atuais
    • %run: Executa um arquivo como um script
    • %paste: Cola e executa um bloco de código
    • %timeit: Executa uma expressão e mostra tempo decorrido
    • %quickref: Cartão de referência do IPython

Exemplos de Programas

  • Calcula quando precisei pagar de frutas no supermercado
precos = {"banana prata": 3.50,
          "coco verde": 2.0,
          "maçã nacional": 4.50,
          "manga tommy": 5.0,
          "uva red glob": 5.0}
minhas_compras = {"banana prata": 1.2,
                  "coco verde": 6,
                  "uva red glob": 0.6}

# Usa um list comprehension para gerar uma lista e soma os seus valores
conta = sum([precos[fruta] * minhas_compras[fruta] for fruta in minhas_compras])
print("Eu precisei pagar o total de R$ {0:.2f} em frutas".format(conta))

Exemplos de Programas

  • Conta o número de palavras em um texto
texto = '''"Aonde fica a saída?", Perguntou Alice ao gato que ria.
"Depende", respondeu o gato.
"De quê?", replicou Alice;
"Depende de para onde você quer ir..."'''
palavras = texto.split()  # Separa o texto em uma lista de palavras
print("O texto tem {0} palavras, sendo {1} delas diferentes.".format(
    len(palavras),      # Número de palavras
    len(set(palavras))  # Número de palavras únicas
))

O que aprender em seguida

  • baterias incluídas: Python possui uma biblioteca extensa
    • Já existe uma biblioteca apropriada para o que você quer fazer
  • Em computação numérica você vai querer usar o numpy e bibliotecas que são construídas em cima do numpy como:
    • matplotlib: plotar diversos tipos de gráficos
    • scipy: coleção de algoritmos numéricos para processamento de sinais, otimização, estatística, etc
    • pandas: estrutura de dados para análise de dados

Conteúdo Extra

Conversão de Base

  • bin: converte para representação em base 2
  • oct: converte para representação em base 8
  • hex: converte para representação em base 16
  • int('0b1010', base=2): converte a partir de uma base para um inteiro (em base 10)
  • Podemos entrar com um número em uma base com prefixos 0b, 0o e 0x
    Ex: x = 0o20 (20 em octal -> 16 em decimal)

Classes