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
  darlan@darlan-G75VX

  >>> 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

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

  darlan@darlan-G75VX

  >>> 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
  darlan@darlan-G75VX

  >>> print("""
  Um tigre
  dois tigres
  três tigres""")

• Strings possuem muitos métodos úteis, como format, split, join, strip
  darlan@darlan-G75VX

  >>> 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
  darlan@darlan-G75VX

  >>> 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
  

  Listas podem conter itens de diferentes tipos, mas normalmente todos os itens possuem o mesmo tipo
• A lista é um tipo mutável é possível modificar seus elementos
  darlan@darlan-G75VX

  >>> 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
  darlan@darlan-G75VX

  >>> 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
  darlan@darlan-G75VX

  >>> 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
  darlan@darlan-G75VX

  ~$ 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

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 0xEx: x = 0o20 (20 em octal -> 16 em decimal)

Classes