TREINAMENTO Python

Júlia Rizza

contato@juliarizza.com

python
1991

guido van rossum

• Monty Python Flying Circus

• Produtividade e legibilidade

• Interpretada

  • Tradução dinâmica

• Alto nível

• LINDA DE BONITA!

alguém usa python?

Download & Instalação

https://www.python.org/downloads/

Windows

Execute o .exe e então: next, next, next :D

Mac (MacPorts)

sudo port install python34

Linux

sudo apt-get install python3
sudo apt-get install idle3

Python IDLE

arquivos .py

>>> print("Hello world!")
Hello World!

Na IDLE

No Arquivo .Py

# -*- coding: utf-8 -*-

print("Oi, galerão!")

fazendo contas

>>> 10+5 #adição
15

>>> 20-11 #subtração
9

>>> 2*10 #multiplicação
20

>>> 30/2 #divisão
15

>>> 2**4 #exponenciação
16

>>> 10 % 8 #resto da divisão inteira
2

>>> 120-30+2**3 #múltiplas operações
98

python  vs  c++

#include <iostream>
using namespace std;

void main() {
    cout << "Hello World!" << endl;
    system("pause");
}

# -*- coding: utf-8 -*-

print("Hello World!")

# -*- coding: utf-8 -*-
from random import randint

num = randint(1, 1001)
tentativas = 0
usuario = None

while usuario != num:
    usuario = int(input("Chute um número: "))
    tentativas += 1
    if usuario > num:
        print("O número é menor!\n")
    elif usuario < num:
        print("O número é maior!\n")

print("Parabéns! Você acertou o número!")
print("Foram feitas %d tentativas." % tentativas)

Faça um programa que gera um número aleatório de 1 a 1000. O usuário deve tentar acertar qual o número que foi gerado, a cada tentativa o programa deverá informar se o chute é menor ou maior que o número gerado. O programa acaba quando o usuário acerta o número gerado. O programa deve informar em quantas tentativas o número foi descoberto.

Principais tipos básicos

já ouviu falar de string?

num = 10

50

0.5

"Vlw flws"

True

[1, "a", num]

(1, 2, 3)

{123, 456}

{'k': 'v'}

variáveis

strings

tuplas

inteiros

booleanos

sets

floats

listas

dicts

variável

num = 10
num = 20
num += 12
print(num)

Não pode: conter espaços, começar com números ou ser uma palavra reservada.

inteiros e floats

10
2.5 #ponto!!
type(20) #int
type(4.7) #float

Operações básicas:

10+20

50-2.5

4*10

10.5/10

0 ** 0 #1

10 % 5

resto

exponenciação

divisão

multiplicação

subtração

soma

String

"Isso é uma string."
"10" #isso também
print("Vlw flws")
type("50") #string

Casos Especiais

• Aspas simples e duplas

'I\'m an apple.'

• Escapando caracteres

"I'm an apple."

• Aspas triplas

"""
    Mais de uma
    linha.
    Vlw flws.
"""

booleano

True
False
(10 > 5)
type(True) #bool

Valores verdadeiros ou falsos ou interpretados como tal.

Aplicação binária

Comparações lógicas

Linguagem de máquina

listas, tuplas & sets

[5, 10, "20"]
('a', 5, 'c')
{1, 11, 23}
type([1,2,3]) #list
type((4,5,6)) #tuple
type({7,8,9}) #set

Diferenças: imutabilidade da tupla e não-repetição do set

• "Slicing" = fatiamento

lista = [1, 20, 'c']
lista[0] #1
lista[1] #20

• Métodos built-in

Obs: slicing e métodos não aplicáveis no Set

dicionário

{'key': 'value'}
{'nome': 'João', 'idade': 20}
dict(nome='João', idade=20)
type({'chave': 'valor'}) #dict

Definição: associação de valores à palavras-chave

operadores relacionais

>>> 10 > 5
True
>>> 20 < 7
False
>>> (20**2) > 100
True
>>> (2*5) == 10
True
>>> 40 != (4*10)
False
>>> 3*5 <= 15
True
>>> 27 >= 120
False
>>> (2**5) != 32
False
>>> 10 % 2 == 1
False
>>> 120 % 6 == 0
True

operadores lógicos

>>> not False
True
>>> not True
False
>>> True and True
True
>>> True or False
True
>>> True and False
False
>>> 10 > 5 and 10 < 20
True
>>> 5 < 10 < 20 and 10 > 30
False
>>> 20 >= 21 or 11 < 9
False
>>> not 10 > 9
False
>>> not 120 % 60 != 0
True

condições

if (se)

if None:
    print('Nunca acontecerá!')

if 2*10 == 20:
    print('Agora acontece!')

elif (~ou se)

if None:
    print('Nunca acontecerá!')
elif 2*10 == 20:
    print('Agora acontece!')

else (se não)

if None:
    print('Nunca acontecerá!')
elif 2*10 != 20:
    print('Ainda não!')
else:
    print('Agora acontece!')

Utilize sempre indentação, brô!

loops (ou laços ou repetições)

repetição

print(1)
print(2)
print(3)
.
.
.
print(10)

while

i = 1
while (i <= 10):
    print(i)
    i += 1


##############################

i = 1
while (i <= 10):
    print(i)
    if i % 3 == 0:
        break
    i+= 1

for ... in ...

for i in [1,2,3,4,5,6,7,8,9,10]:
    print(i)

for i in range(1, 11):
    print(i)

################################

for i in [1,2,3]:
    if i == 4:
        print("4!")
        break
else:
    print("Sem 4 :(")

Utilize sempre indentação, brô!

ORIENTAÇÃO A OBJETOS

Abstração

Herança

Funções

def soma(a, b):
    return a+b

soma(1, 5) # 6
soma(3,19) # 22


def repetir(qtd, char='*'):
    return qtd*char

repetir(8)      # ********
repetir(5, '$') # $$$$$

• Menos repetição
• Realizar ações
• Reutilização de código

variáveis locais e globais

a = 15

def trocas():
    a = 20
    return a

print(a) #15
trocas() #20

A posição da variável (dentro ou fora da função) faz diferença!

Classes

class Carro():
    def __init__(self):
        self.cor = 'Preto'
        self.lugares = 5
        self.velocidade = 0

    def acelera(self, aumento):
        self.velocidade += aumento

    def para(self):
        self.velocidade = 0

gol = Carro()
gol.acelera(50) # 50km/h
gol.acelera(20) # 70km/h
gol.para()      # 0km/h

self.característica define um atributo

self.função define um método da classe!

Herança (na prática)

class Gol(Carro):
    def __init__(self):
        Carro.__init__(self)
        self.cor = 'Prata'
        self.airbag = True
        self.som_ligado = False

    def liga_som():
        self.som_ligado = True

gol = Gol()
gol.acelera(40) # 40km/h
gol.para()      # 0km/h
gol.liga_som()  # som_ligado = True

As características e funcionalidades da classe Carro são mantidas na classe Gol.

Manipulação de arquivos

arquivo = open('texto.txt', 'w')
arquivo.write("""Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc semper, 
arcu a lacinia varius, nulla sem ultricies massa, nec convallis nulla augue efficitur 
ex. Sed in mollis nisi, sit amet hendrerit orci. Praesent eget lorem ac magna euismod 
vestibulum. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec sagittis ut 
lacus quis bibendum. Fusce in dictum mauris. In varius ex sit amet congue ornare. """)
arquivo.close()


arquivo = open('texto.txt', 'r')
texto = arquivo.readlines()
for linha in texto:
    print(linha)
arquivo.close()

Cria, lê e altera arquivos existentes no diretório informado.

Módulos e bibliotecas

Um módulo é um arquivo Python contendo definições e declarações.

def fib(n):    # escreve a sequência Fibonacci até o número n
    a, b = 0, 1
    while b < n:
        print b,
        a, b = b, a+b

def fib2(n): # retorna a sequência Fibonacci até o número n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

# modo 1
import fibo
fibo.fib(1000) # ou fib = fibo.fib
print(fibo.fib2(1000))

# modo 2
from fibo import *
fib(1000)
print(fib2(1000))

# modo 3
from fibo import fib
fib(1000)
print(fib2(1000))

# modo 3 e meio :P
from fibo import fib, fib2
fib(1000)
print(fib2(1000))

random           math           tkinter

Standard (inclusos na linguagem): https://docs.python.org/3/py-modindex.html

PyPI (Package Index):  https://pypi.python.org/pypi

fibo.py

contas.py

Interfaces Gráficas

#!/usr/bin/python

import tkinter

top = tkinter.Tk()

def hello_world():
    l = tkinter.Label(top, text="Hello world!")
    l.pack()

w = tkinter.Button(top, text="Clica em mim!", command=hello_world)
w.pack()

top.mainloop()

Usando o Tkinter, módulo padrão de Python:

Tkinter       PyGTK       PyQt       wxPython       JPython       Kivy

Tutoriais: http://www.tutorialspoint.com/python/python_gui_programming.ht

http://zetcode.com/gui/tkinter/

tratamento de erros

try:
    4/0
except ZeroDivisionError:
    print("Não foi dessa vez, champs!")

SintaxError

IdentationError

KeyError

NameError

TypeError

ValueError

IndexError

INDICAÇÕES & REFERÊNCIAS

• Apostila do minicurso
• CodeAcademy
• LearnPython
• Python Wiki
• Python para Zumbis
• Google's Python Class
• Python Tutor
• The Hitchhiker's Guide to Python
• Dive Into Python 3

Introdução à programação com Python - Nilo Ney

PARTE ii

FUNÇÕES ESPECIAIS

lambda: são funções anônimas que suportam argumentos e que aceitam apenas uma expressão, ou seja, funções de uma linha só.

substitui = lambda palavra: palavra.replace(" ", "_")
substitui("Treinamento de Python")
>>> Treinamento_de_Python

pass: é uma palavra especial utilizada para deixar algo (geralmente funções) em branco, ou seja, um comando para não fazer nada.

def soma(a,b):
    pass

for i in [1,2,3]:
    if i == 2:
        pass
    else:
        print("Não é 2!")

FUNÇÕES ESPECIAIS

Existem funções que podem ter uma quantidade de argumentos variáveis. Para passarmos isso na definição de uma função, usamos duas palavras especiais: *args e **kwargs. A primeira, faz com que os valores sejam recebidos e retornados no formato de tubla; a segunda, no formato de dicionário.

def mostra(*args):
    print(args)

>>> mostra("oi", 20, True)
>>> ("oi", 20, True)

def mostra(**kwargs):
    print(kwargs)

>>> mostra(a="oi", j=20, d=True)
>>> {'a': "oi", 'j': 20, 'd': True}

LIST COMPREhENSION

É uma nova forma de popular listas, onde a sintaxe se assemelha a sintaxe de conjuntos na matemática.

Por exemplo:

L = {-100, ... , -3, -2, -1, 0, 1, 2, 3, ... , 100}

C = {x | x ∈ L;  0 < x <= 10 }

L = range(-100, 100)
C = [x for x in L if 0 < x <= 10]

L = range(-100, 100)
C = [x-11 for x in L if 0 < x <= 10]

matrizes

Da mesma forma como fazemos em outras linguagens, uma matriz pode ser criada a partir de listas dentro de listas.

m = [[1,1,1],
     [2,2,2],
     [3,3,3]]

print(m[0][1]) # 1

## CUIDADO!!
m1 = [0,1,2]
m2 = [3,4,5]

m1 + m2 # NÃO É SOMA DE MATRIZES, É CONCATENAÇÃO (APPEND)
        # m1 + m2 => [0,1,2,3,4,5]

formatação de strings

São operações para modificar o conteúdo de uma string, seja adicionando elementos externos ou trabalhando com o que já existe na string.

Inserindo dados

"Oi, eu sou %s e tenho %d anos." % ("Fulano", 15)
>>> Oi, eu sou Fulano e tenho 15 anos.

"Oi, eu sou %(nome)s e tenho %(idade)d anos." % {'idade': 15, 'nome': "Fulano"}
>>> Oi, eu sou Fulano e tenho 15 anos.

"O preço é R$%.2f" % (10)
>>> O preço é R$10.00

formatação de strings

São operações para modificar o conteúdo de uma string, seja adicionando elementos externos ou trabalhando com o que já existe na string.

Inserindo dados

"Oi, eu sou {0} e tenho {1} anos.".format("Fulano", 15)
>>> Oi, eu sou Fulano e tenho 15 anos.

"Oi, eu sou {nome} e tenho {idade} anos.".format(idade=15, nome="Fulano")
>>> Oi, eu sou Fulano e tenho 15 anos.

"O preço é R${preco:.2}".format(preco=10)
>>> O preço é R$10.00

formatação de strings

São operações para modificar o conteúdo de uma string, seja adicionando elementos externos ou trabalhando com o que já existe na string.

MODIFICANDO dados

"minha mensagem.".capitalize()
>>> Minha mensagem.

"três tigres tristes comeram três pratos de trigo".count("tr")
>>> 4

"Tudo certo".endswith("rto") # o mesmo funciona para .startswith()
>>> True

"sem espaços aqui".replace(" ", "")
>>> "semespaçosaqui"

formatação de strings

São operações para modificar o conteúdo de uma string, seja adicionando elementos externos ou trabalhando com o que já existe na string.

MODIFICANDO dados

"separando em palavras".split(" ")
>>> ["separando", "em", "palavras"]

"           muito espaço        ".strip()
>>> "muito espaço"

"isso é um título charmoso".title()
>>> Isso É Um Título Charmoso

"um grito bem alto".upper() # o mesmo vale para .lower()
>>> 'UM GRITO BEM ALTO'

geradores

Iteradores: são, em geral, objetos que podem ser percorridos elemento por elemento. Por exemplo, listas, tuplas e até mesmo strings. Basicamente, objetos que podem ser percorridos por um for.

Geradores: são um padrão de design que criam objetos iteráveis nos quais os elementos são gerados um por vez, e não são armazenados na memória.

Como criar uma classe que segue o padrão gerador é algo tedioso e pouco legível, o Python oferece duas formas de se criar objetos geradores, as expressões geradoras e as funções geradoras.

funções geradoras

As expressões geradoras são similares às list comprehensions, exceto que elas são encapsuladas por parênteses e não colchetes.

As funções geradoras são funções nas quais ao invés de se retornar apenas uma vez, se "concede" um objeto repetidas vezes, sendo que em cada chamada à next um novo objeto é concedido.

Desta forma, pode-se criar iterações de tamanho indefinido sem ocupar um espaço significativo na memória!

módulos e pacotes

Módulo: É um agrupamento de código e funções de propósitos semelhantes. É um arquivo único.

Pacote: É um diretório que consiste em módulos, subpacotes, sub-subpacotes e assim por diante. Todos os módulos e subpacotes são reunidos a partir de um arquivo __init__.py.

módulos

def hello_world():
    print("Hello World!")

def hello_user(user):
    print("Hello, {0}!".format(user))

hello.py

import hello

hello.hello_world()
hello.hello_user("Fulano")

from hello import *

hello_world()
hello_user("Fulano")

from hello import hello_world, hello_user

hello_world()
hello_user("Fulano")

outro.py

pacotes

def laranja():
    print("Laranja!")

laranja.py

def pera():
    print("Pêra!")

pera.py

def laranja():
    print("Laranja!")

uva.py

from laranja import *
from pera import *
from uva import *

__init__.py

Frutas/
├── __init__.py
├── laranja.py
├── pera.py
└── uva.py

import Frutas
Frutas.laranja()

from Frutas.laranja import laranja
laranja()

bibliotecas externas

$ pip install thefuck

Pip é um sistema de gerenciamento de pacotes usado para instalar e gerenciar pacotes de software escritos em Python. A maior parte dos pacotes está no PyPI (Python Package Index) e pode ser encontrada em: https://pypi.python.org/pypi

teste unitário

São testes configurados para serem realizados e aprovados ou não automaticamente. Funciona assim: você sabe qual deve ser o resultado quando o programa realizar determinado procedimento, então você faz um teste que compara o resultado esperado com o que o programa está realmente devolvendo.

teste unitário

import unittest
from fibo import fibo
 
class testa_fibonacci(unittest.TestCase):
   def teste_um(self):
      self.assertEqual(fibo(0),0)
 
   def teste_dois(self):
      self.assertEqual(fibo(1),1)
 
   def teste_tres(self):
      self.assertEqual(fibo(7),13)
 
   def teste_quatro(self):
      self.assertEqual(fibo(10),55)
 
unittest.main()

def fibo(n):
   if n < 2:
      return n
   else:
      return fibo(n-1) + fibo(n-2)

fibo.py

teste.py

documentação

Para documentar programas, é convencional utilizarmos docstrings. São strings de aspas triplas que funcionam como comentários e geralmente estão localizadas no início de um programa ou na definição de classe ou função.

Dessa forma, podemos utilizar uma ferramenta externa que irá ler essas docstrings e irá gerar sua documentação em um formato mais legível, como HTML ou PDF. Por exemplo, o Sphinx: http://www.sphinx-doc.org/en/stable/#

documentação

def hello_user(user):
    """
    Função que exibe "Hello " + o nome do usuário na tela.
    Exemplo: hello_user("Fulano")
             >>> "Hello Fulano"
    """
    print("Hello {0}".format(user))

pep8

A PEP8 (Python Enhancement Proposal 8) é um guia de boas práticas. Não é obrigatório que você siga tudo o que está escrito lá, mas é uma recomendação para que seu código fique legível, bem escrito e profissional. Além de facilitar a vida de quem for trabalhar com você e contribuir com seu código.

$ pip install autopep8

PEP8: https://www.python.org/dev/peps/pep-0008/

exercícios

Faça um programa que, dado um número inteiro, fornece como resultado a soma dos números representados por esses algarismos. Exemplo: Numero digitado (123) deve fornecer resultado (6).

Faça um programa que calcule o comprimento e a área de uma circunferência, cada um por meio de uma função diferente, quando o usuário informar o raio. As fórmulas são, respectivamente:

Comprimento = 2*pi*R

Área = 4/3(pi*R²)

Escreva um programa que solicite o preço de uma mercadoria e o percentual de desconto e armazene os valores no dicionário. Utilize o dicionário para retornar os valores e fazer o cálculo do preço com o desconto.

Escreva um programa que solicite o preço de uma mercadoria e o percentual de desconto e armazene os valores no dicionário. Utilize o dicionário para retornar os valores e fazer o cálculo do preço com o desconto.

Escreva um programa para calcular a redução do tempo de vida de um fumante. Pergunte a quantidade de cigarros fumados por dia e quantos anos ele já fumou. Considere que um fumante perde 10 minutos de vida a cada cigarro, calcule quantos dias de vida um fumante perderá. Exiba o total em dias.

Escreva um programa que pergunte a distância que um passageiro deseja percorrer em km. Calcule o preço da passagem, cobrando R$ 0,50 por km para viagens de até 200 km e R$ 0,45 para viagens mais longas.

Escreva um programa que leia números inteiros do teclado e armazene-os numa lista. O programa deve ler os números e armazenar até que o usuário digite 0 (zero). No final da execução, exiba a quantidade de números digitados, assim como a soma e a média aritimética.

Escreva uma classe Cliente que tenha como atributos os dados de um usuário (nome, telefone, idade, etc) e métodos alterar_nome, alterar_idade, etc.

exercícios uri

https://www.urionlinejudge.com.br/judge/pt/login

• 1036
• 1014
• 1933
• 1983
• 2006
• 1169

• 1047
• 1131
• 1160
• 1024
• 1168
• 1234

• 1436
• 1520
• 1025
• 1069

TREINAMENTO python

Júlia Rizza

contato@juliarizza.com