CURSO PYTHON

Júlia Rizza

juliards@algartech.com

Relembrando o básico...

print("Hello, world!")

Download & Instalação

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

Windows

Mac (Homebrew)

Linux

Baixe e execute o .exe e então next, next, next...

$ brew install python3

$ sudo apt-get install python3

Características da linguagem

Interpretada
Blocos por indentação
Tipagem dinâmica

hello = True

if hello:
    print("Hello, world!")
else:
    print("Ops!")

using System;
namespace HelloWorld
{
    class Hello 
    {
        static void Main() 
        {
            bool hello = true;
        
            if (hello) {
                Console.WriteLine("Hello, world!");
            } else {
                Console.WriteLine("Ops!");
            }
        }
    }
}

Python

C#

Versões da linguagem

print agora é uma função, não mais uma palavra-chave
A operação de divisão diferencia-se da divisão inteira
A codificação das strings passou a ser unicode

2.7 x 3.x

Tipos básicos

Variáveis
Inteiros
Pontos flutuantes (floats)
Strings
Booleanos
Listas, tuplas e sets (arrays)
Dicionários (struct ou par chave-valor)

>>> inteiro = 10
>>> type(inteiro)
<class 'int'>

>>> decimal = 0.5
>>> type(decimal)
<class 'float'>

>>> texto = "Algar Tech"
>>> type(texto)
<class 'str'>

>>> booleano = True
>>> type(booleano)
<class 'bool'>

>>> lista = [1, 2, "a"]
>>> type(lista)
<class 'list'>

>>> tupla = (1, 2, "a")
>>> type(tupla)
<class 'tuple'>

>>> conjunto = {1, 2, "a"}
>>> type(conjunto)
<class 'set'>

>>> dicionario = {"chave": "valor"}
>>> type(dicionario)
<class 'dict'>

Operadores relacionais

>>> 1 == 2
False

>>> 1 != 2
True

>>> 1 < 2
True

>>> 1 > 2
False

>>> 1 <= 2
True

>>> 1 >= 2
False

Operador	Valor
==	Igual
!=	Diferente
<	Menor
>	Maior
<=	Menor ou igual
>=	Maior ou igual

Operadores lógicos

>>> True and True
True

>>> True and False
False

>>> False and True
False

>>> False and False
False

>>> True or True
True

>>> True or False
True

>>> False or True
True

>>> False or False
False

>>> not True
False

>>> not False
True

Condições

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

if 2 * 10 == 20:
    print("Agora sim!")

if None:
    print("Nunca acontecerá!")
elif 2 * 10 == 20:
    print("Agora sim!")
else:
    print("Nem precisa...")

if None:
    print("Nunca acontecerá!")
else:
    print("Agora sim!")

if

if - else

if - elif - else

Repetições

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

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

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

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

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

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

for item in [3,6,9]:
    if item == 4:
        print("4!")
        break
else:
    print("Sem 4 :(")

while

for ... in ...

Funções

def funcao(arg1, arg2):
    pass

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

soma(1, 5) # 6

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

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

Reutilização de código
Grande conjunto de funções builtins
Definem variáveis locais e globais

Orientação a Objetos

ABSTRAÇÃO

HERANÇA

Características

patas: 4
cor: azul
pulgas: 0

Ações

Andar
Latir

Classes

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

    def liga(self):
        print("Carro ligado!")

    def acelera(self, aumento):
        self.velocidade += aumento
        print(self.velocidade + "km/h")

    def para(self):
        self.velocidade = 0
        print("0km/h")

    def desliga(self):
        print("Carro desligado!")


meu_carro = Carro()
meu_carro.liga()      # Carro ligado!
meu_carro.acelera(50) # 50km/h
meu_carro.acelera(20) # 70km/h
meu_carro.para()      # 0km/h

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

    def liga_som(self):
        self.som_ligado = True
        print("Som ligado!")

    def desliga_som(self):
        self.som_ligado = False
        print("Som desligado!")

    def desliga(self):
        self.desliga_som()
        print("Carro desligado!")


meu_gol = Gol()
gol.liga()      # Carro ligado!
gol.acelera(40) # 40km/h
gol.liga_som()  # Som ligado!
gol.para()      # 0km/h
gol.desliga()   # Som desligado!
                # Carro desligado!

Seguindo para o mais avançado...

Funções lambda

É uma função anônima, ou seja, não possui nome.

>>> cubo = lambda x: x**3
>>> cubo(2)
8

>>> funcao_qualquer(arg1, arg2=cubo)

Limitadas a uma só expressão lógica
Ideal para passar como parâmetro

Argumentos variáveis

Existem funções que recebem quantidades variáveis de argumentos. Para isso, utilizamos *args e **kwargs para representá-los. Da primeira forma, os valores são retornados em forma de tupla; da segunda, em forma de dicionário.

def multiplica(*args):
    resultado = 1
    for numero in args:
        resultado *= numero
    return resultado

>>> multiplica(2, 3, 5)
30
>>> multiplica(2, 3)
6

def dados(**kwargs):
    for chave, valor in kwargs.items():
        print(chave + ": " + str(valor))

>>> dados(nome="Julia", idade=21)
nome: Julia
idade: 21

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.

Funções builtin

Grande quantidade de funções builtin
Funções de uso comum e prático

Funções de conversão

>>> str(10)
'10'

>>> int('20')
20

Funções matemáticas

>>> min([32, 12, 220])
12

>>> max([32, 12, 220])
220

>>> d = [{'a': 1, 'b': 2}, {'a': 2, 'b': 1}]
>>> min(d, key=lambda item: item['b'])
{'a': 2, 'b': 1}

>>> sum([1, 2, 3])
6

>>> abs(2-3j)
3.605551275463989

Funções de manipulação

>>> len([1, 2, 3, 4, 5])
5

>>> len("Algar Tech")
10

>>> complex(2, 3)
(2+3j)

>>> pow(2, 3)
8

>>> round(2.7)
3

Funções builtin

Funções de iteráveis

>>> all([2>1, 3<59, 2!=3])
True

>>> any([2<1, 3<59, 2==3])
True

>>> enumerate(['Primavera', 'Verão', 'Outono', 'Inverno'])
[(0, 'Primavera'), (1, 'Verão'), (2, 'Outono'), (3, 'Inverno')]

>>> filter(lambda x: x>10, [3, 42, 15, 5, 7, 39])
[42, 15, 39]

>>> map(lambda x: x+1, [15, 20, 25, 30])
[16, 21, 26, 31]

>>> range(3, 10)
[3, 4, 5, 6, 7, 8, 9]

>>> sorted([3, 45, 20, 13, 29])
[3, 13, 20, 29, 45]

>>> zip(['a', 'b', 'c'], [1, 2, 3])
[('a', 1), ('b', 2), ('c', 3)]

https://docs.python.org/3.3/library/functions.html#abs

Manipulação de arquivos

arquivo = open("texto.txt", 'w')
arquivo.write("Um texto bem interessante.")
arquivo.close()

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

with open("texto.txt", 'r') as arquivo:
    linhas = arquivo.readlines()
    for linha in linhas:
        print(linha)

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

valor_bin = "ALGUM_VALOR_BINARIO_DE_ARQUIVO"
with open("arquivo.formato", 'wb') as arquivo:
    arquivo.write(valor_bin)

Modos de abertura:

Leitura 'r'
Escrita 'w'
Adição 'a'

Leitura binária 'rb'
Escrita binária 'wb'

Módulos e bibliotecas

def fib(n):
    a, b = 0, 1
    while b < n:
        print(b)
        a, b = b, a+b

def fib2(n):
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

fibo.py

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

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

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

Bibliotecas são conjuntos de módulos que ficam armazenados na pasta de binários do Python.

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

List Comprehension

É uma técnica para popular listas, onde a sintaxe é semelhante à sintaxe de conjuntos da matemática.

Por exemplo:

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

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

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

>>> xl = ['a', 'b', 'c']
>>> yl = ['x', 'y', 'z']
>>> t = [x+y for x in xl for y in yl]
>>> print(t)
['ax', 'ay', 'az', 'bx', 'by', 'bz', 'cx', 'cy', 'cz']

Formatação de strings

>>> "Oi, eu sou %s e tenho %d anos" % ("Julia", 21)
'Oi, eu sou Julia e tenho 21 anos'

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

>>> "Oi, eu sou {} e tenho {} anos".format("Julia", 21)
'Oi, eu sou Julia e tenho 21 anos'

>>> "Oi, eu sou {nome} e tenho {idade} anos".format(nome="Julia", idade=21)
'Oi, eu sou Julia e tenho 21 anos'

>>> nome = "Julia"
>>> idade = 21
>>> f"Oi, eu sou {nome} e tenho {idade} anos"
'Oi, eu sou Julia e tenho 21 anos'

>>> "O preço é R$%.2f" % 2.449
'O preço é R$2.45'

>>> "O preço é R${preco:.3}".format(preco=2.449)
'O preço é R$2.45'

>>> preco = 2.449
>>> f"O preço é R${preco:.3}"
'O preço é R$2.45'

Formatação de strings

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

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

>>> "      espaços desnecessários   ".strip()
'espaços desnecessários'

>>> "Linguagem hacker".replace('a', '4')
'Lingu4gem h4cker'

>>> "Separando as palavras da frase".split(" ")
['Separando', 'as', 'palavras', 'da', 'frase']

>>> " ".join(["Juntando", "as", "palavras"])
'Juntando as palavras'

>>> "isso é um título formatado".title()
'Isso É Um Título Formatado'

>>> "um grito bem alto".upper()
'UM GRITO BEM ALTO'

>>> "Uma Conversa Normal".lower()
'uma conversa normal'

Manipulação de listas

>>> l1 = [0, 1, 2, 3]
>>> l2 = ['a', 'b', 'c', 'd']

>>> l1[0:2]
[0, 1]

>>> l1[:3]
[0, 1, 2]

>>> l1[0:4:2]
[0, 2]

>>> l1[::2]
[0, 2]

>>> l1[-1]
3

>>> l1[::-1]
[3, 2, 1, 0]

>>> l1 + l2
[0, 1, 2, 3, 'a', 'b', 'c', 'd']

Manipulação de listas

>>> l1 = [0, 1, 2, 3]
>>> l2 = ['a', 'b', 'c', 'd']

>>> l2.append('e')
['a', 'b', 'c', 'd', 'e']

>>> l2.pop(4)
'e'

>>> l2.remove('b')
['a', 'c', 'd']

>>> l2.index('c')
1

>>> l2.count('d')
1

Tratamento de erros

try:
    4/0
except ZeroDivisionError:
    print("Não pode dividir por zero!")

try:
    20/0
except Exception as e:
    print(f"Erro: {e}")

SyntaxError

IndexError

ValueError

TypeError

KeyError

NameError

IdentationError

Requests

Requisições HTTP e comunicação com APIs

import requests

URL = "http://example.com"
params = {"language": "pt-BR"}
headers = {
    "Content-Type": "application/json"
}
data = {
    "nome": "Julia",
    "idade": 21
}
user = "julia"
password = "1234"

response = requests.get(URL, params=params, headers=headers, json=data, auth=(user, password))
print(response.status)
print(response.text)
print(response.json())

http://docs.python-requests.org/en/master/

APIs com Python

Utilizando um web framework para criar APIs

from flask import Flask, jsonify, abort

app = Flask(__name__)
users = [
    {
        "id": 1,
        "nome": "Fulano",
        "idade": 30
    },
    {
        "id": 2,
        "nome": "Ciclano",
        "idade": 40
    }
]

@app.route('/users/api/1.0/users', methods=['GET'])
def get_users():
    return jsonify({'users': users})

@app.route('/users/api/1.0/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    user = [u for u in users if u["id"] == user_id]
    if len(user) == 0:
        return abort(404)
    return jsonify({"user": user[0]})

http://flask.pocoo.org/

APIs com Python

Utilizando um web framework para criar APIs

@app.route('/users/api/1.0/users', methods=['POST'])
def create_user():
    if not request.json or not 'nome' in request.json:
        abort(400)
    user = {
        "id": users[-1]['id'] + 1,
        "nome": request.json['nome'],
        "idade": requests.json.get('idade')
    }
    users.append(user)
    return jsonify({"user": user}), 201


@app.route('/users/api/1.0/users/<int:user_id>', methods=['DELETE'])
def delete_user(user_id):
    user = [u for u in users if u['id'] == user_id]
    if len(user) == 0:
        abort(404)
    users.remove(user[0])
    return jsonify({'result': True})

http://flask.pocoo.org/

Testes unitários

Testes automatizados de funcionalidades

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

import unittest
from fibo import fib
 
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()

fibo.py

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

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

CURSO PYTHON

Júlia Rizza

juliards@algartech.com

Python - Algar Tech

By Júlia Rizza

CURSO PYTHON

Relembrando o básico...

Download & Instalação

Windows

Mac (Homebrew)

Linux

Características da linguagem

Versões da linguagem

2.7 x 3.x

Tipos básicos

Operadores relacionais

Operadores lógicos

Condições

Repetições

Funções

Orientação a Objetos

ABSTRAÇÃO

HERANÇA

Classes

Seguindo para o mais avançado...

Funções lambda

Argumentos variáveis

Geradores

Funções builtin

Funções builtin

Manipulação de arquivos

Módulos e bibliotecas

List Comprehension

Formatação de strings

Formatação de strings

Manipulação de listas

Manipulação de listas

Tratamento de erros

Requests

APIs com Python

APIs com Python

Testes unitários

Documentação

CURSO PYTHON

Python - Algar Tech

More from Júlia Rizza