DEV Community: Gabriel Felippe

Resources for Mastering Algorithms & Data Structures

Gabriel Felippe — Sat, 01 Feb 2020 22:39:02 +0000

Deploy de uma Aplicação Flask com PythonAnywhere

Gabriel Felippe — Fri, 29 Nov 2019 15:24:13 +0000

Introdução

O PythonAnywhere é um ambiente de desenvolvimento integrado online (IDE) e um serviço de hospedagem na web (plataforma como serviço) baseado na linguagem de programação Python. Fundada por Giles Thomas e Robert Smithson em 2012, fornece acesso no navegador a interfaces de linha de comando Python e Bash baseadas em servidor, além de um editor de código com destaque de sintaxe. Os arquivos do programa podem ser transferidos de e para o serviço usando o navegador do usuário. Os aplicativos da Web hospedados pelo serviço podem ser gravados usando qualquer estrutura de aplicativos baseada em WSGI.

O WSGI não é um servidor, um módulo python, uma estrutura, uma API ou qualquer tipo de software. É apenas uma especificação de interface pela qual o servidor e o aplicativo se comunicam. Os lados da interface do servidor e do aplicativo são especificados no PEP 3333. Se um aplicativo (ou estrutura ou kit de ferramentas) for escrito na especificação WSGI, ele será executado em qualquer servidor escrito nessa especificação.

Neste guia vamos fazer o Deploy de uma simples Aplicação Web escrita com o microframework Flask, para isso vamos utilizar a plataforma PythonAnywhere. O deployment envolve empacotar seu aplicativo Web e colocá-lo em um ambiente de produção que possa executar o aplicativo para que todos no mundo possam vê-lo.

Tutorial

Nosso primeiro passo neste guia será fazer o registro na plataforma PythonAnywhere, para esta tarefa vamos navegar até este Link e fazer nosso cadastro. Importante, lembre-se de confirmar seu endereço de email.

Uma vez que estamos cadastrados com sucesso, agora podemos nos autenticar na plataforma para obtermos acesso a todas as suas funcionalidades.

Vamos visualizar uma interface similar a essa

Nesse passo, vamos clicar no botão Open Web tab, em seguida vamos clicar no botão Add a new web app.

Nos será apresentada a informação de que nossa aplicação viverá em determinado endereço, no meu caso vai ser akiraflask.pythonanywhere.com, uma vez que eu me cadastrei como o usuário akiraflask.

Tudo certo até então, vamos clicar no botão Next

PythonAnywhere nos pedirá para escolher o framework que vamos trabalhar, em nosso caso será o Flask, mas veja como existem diversas outras opções, por fim ele pedirá para escolhermos uma versão do Python, vamos escolher a última versão 3.8.

Por fim ele nos pedirá para entrarmos com o caminho para o arquivo que irá guardar nossa aplicação, vamos fornecer a seguinte informação:

/home/seu_usuario/mysite/app.py

Importante: Não esqueça de substituir o seu usuário no caminho do arquivo

Nesse ponto, nossa aplicação já está online como um simples Hello World, porém agora precisamos configurar a nossa aplicação que reside no GitHub.

Vamos agora retornar para o painel de controle do PythonAnywhere (representado na primeira imagem) e vamos clicar no botão $Bash para acessarmos o terminal de comandos.

Primeiramente vamos digitar o comando ls para vermos o que há disponível

Veja que temos um arquivo README.txt e um diretório chamado mysite que contém um arquivo app.py que representa o simples Hello World, vamos remover esse diretório com o comando rm -r mysite/ e vamos clonar o repositório de nossa aplicação com o seguinte comando:

git clone https://github.com/the-akira/Flask-Pokedex.git mysite

Uma vez que o clone foi feito, agora já temos nossa aplicação residindo no PythonAnywhere, agora só precisamos navegar até o diretório mysite com o comando cd mysite/ e ativar o Ambiente Virtual, instalar as dependências e tudo deve funcionar corretamente. Vamos executar os seguintes comandos:

Para iniciar e ativar o Ambiente Virtual digite:

mkvirtualenv --python=/usr/bin/python3.8 my-virtualenv

Nesse ponto o ambiente já está ativado, caso eventualmente queira desativá-lo digite: deactivate e caso você queira reativá-lo digite: workon my-virtualenv.

Agora finalmente podemos instalar as dependências necessárias para nossa aplicação funcionar corretamente, vamos executar o seguinte comando:

pip install -r requirements.txt

Nosso último passo agora é muito simples, vamos retornar para o painel de controle e vamos clicar novamente no botão Open Web tab, por fim vamos clicar no botão verde Reload para recarregar nossa aplicação com as novas configurações.

Finalizado, nossa aplicação está online e reside no seguinte endereço https://akiraflask.pythonanywhere.com

Muito simples, não? PythonAnywhere facilita muito nosso workflow e nos permite trabalharmos com git, além de muitos outros frameworks Python.

Deploy de uma Aplicação Flask com Heroku

Gabriel Felippe — Wed, 27 Nov 2019 01:27:37 +0000

Introdução

Heroku é uma plataforma em nuvem como serviço (PaaS) que suporta várias linguagens de programação. Uma das primeiras plataformas em nuvem, o Heroku está em desenvolvimento desde junho de 2007, quando suportava apenas a linguagem de programação Ruby, mas agora suporta Java, Node.js, Scala, Clojure, Python, PHP e Go. Por esse motivo, o Heroku é considerado uma plataforma poliglota, pois possui recursos para um desenvolvedor criar, executar e dimensionar aplicativos de maneira semelhante na maioria dos idiomas.

Neste guia vamos fazer o Deploy de uma simples Aplicação Web escrita com o microframework Flask, para isso vamos utilizar a plataforma Heroku. O deployment envolve empacotar seu aplicativo Web e colocá-lo em um ambiente de produção que possa executar o aplicativo para que todos no mundo possam vê-lo.

Tutorial

Nosso primeiro passo no tutorial é fazer o download e instalar a interface de linha de comandos do Heroku para o seu Sistema Operacional, não vamos abordar essa etapa em detalhe, uma vez que ela é particular para cada sistema.

Visite este Link para fazer o download, lembrando que é necessário ter o git instalado em sua máquina!

Uma vez que o Heroku esteja instalado em sua máquina com sucesso, agora é necessário fazermos o login, para isso vamos abrir nossa Interface de Linha de Comandos e digitar o seguinte comando:

heroku login

Uma página em seu navegador será aberta, faça o login e sua autenticação estará completa.

Agora que estamos autenticados no Heroku, vamos fazer o clone do nosso projeto para podermos fazer o Deployment. Para esta tarefa vamos executar o seguinte comando

git clone https://github.com/the-akira/Flask-Blog.git

Navegamos dentro do diretório principal de nosso projeto e agora vamos reinicializar o repositório com o comando

git init

Vamos criar um Ambiente Virtual

python -m venv myvenv

Ativamos o Ambiente Virtual

source myvenv/bin/activate

Instalamos as dependências necessárias de nosso projeto

pip install -r requirements.txt

Vamos precisar instalar agora o famoso gunicorn. Ele é um servidor Web Python para sistemas operacionais baseados em UNIX. É necessário tê-lo instalado em seu código com o ambiente virtual ativado para iniciar o aplicativo Flask no Heroku.

pip install gunicorn

Uma vez instalado o gunicorn, não podemos esquecer de adicioná-lo ao arquivo requirements.txt, sendo assim, vamos executar

pip freeze > requirements.txt

Agora, na verdade, criamos sua instância de aplicativo nos servidores Heroku. É aqui que você especifica o nome do aplicativo. Irei chamar o aplicativo de akiraflask

heroku create akiraflask

Uma vez que nosso aplicativo foi criado, agora precisamos criar um arquivo especial chamado Procfile. O Procfile será o comando que o Heroku executa para iniciar seu código. Seria como você executando python app.py. Crie um arquivo no diretório root do seu aplicativo com o nome Procfile e insira o seguinte conteúdo

web: gunicorn app:app

Substitua o primeiro "app" no código acima pelo nome do script que você deseja executar. O script Python que inicia meu aplicativo Flask é chamado app.py, portanto, o Procfile contém app:app. Se o script fosse intitulado run.py, o Procfile exibiria:

web: gunicorn run:app

Agora podemos adicionar, fazer o commit e enviar o código para o Heroku

git add .
git commit -m "Procfile Adicionada"
git push heroku master

Observe que o envio não apenas envia as alterações, mas também resulta em uma reconstrução. O arquivo requirements.txt é verificado mais uma vez e assim por diante.

Nossa aplicação já está online, podemos visitá-la em https://akiraflask.herokuapp.com

Podemos concluir então que Heroku é uma plataforma muito interessante e que facilita muito o processo de Deployment de aplicações Python e até mesmo de outras linguagens.

Funções em Python

Gabriel Felippe — Sat, 23 Nov 2019 18:26:51 +0000

Introdução

Uma função é um bloco de código organizado e reutilizável que é capaz de realizar uma determinada ação. Funções nos ajudam a deixar o nosso código mais modular, trazendo a possibilidade de reusabilidade, conforme nosso programa fica cada vez maior, as funções o tornam mais organizado e gerenciável.

Como vimos ao longo do guia, Python já nos traz várias funções pré-construídas, como por exemplo print() e range(), mas também é possível criarmos nossas próprias funções!

Anatomia das Funções

Podemos imaginar as funções (de modo geral) como um mecanismo capaz de receber valores como input e então realizar operações nesses valores e retornar um output.

Características das Funções

Possuem um nome
Possuem parâmetros (0 ou mais)
Possuem docstrings (opcional, porém recomendado)
Possuem um corpo
Retornam algo (opcional)

Definindo uma Função

Em Python devemos seguir a seguinte sintaxe para construirmos uma Função:

def nome_da_função(parametros):
    """docstrings"""
    <comandos>

Para definir uma função é necessário que sigamos algumas regras:

Bloco de funções começam com a palavra-chave def seguido do nome da função e parenteses ().
O nome da função identifica exclusivamente a função. A nomenclatura de funções segue as mesmas regras de escrita de identificadores em Python.
Parâmetros de input ou argumentos (dados fornecidos por nós) devem ser colocados entre parenteses (). Eles são opcionais.
Dois pontos (:) para marcar o final do cabeçalho da função.
Opcionalmente podemos usar strings de documentação (docstrings) para descrever o que nossa função faz.
Uma ou mais instruções Python válidas que constituem o corpo da função. As declarações devem ter o mesmo nível de indentação (geralmente 4 espaços).
O comando opcional return (expressão) sai da função, opcionalmente passando um parâmetro para o chamador. O comando de retorno sem argumentos é o mesmo que return None.

Por exemplo, vamos definir uma função capaz de converter uma temperatura em Fahrenheit para Celsius.

def fahr_to_celsius(temp):
    """
    Função que recebe como argumento uma temperatura
    em Fahrenheit e converte ela para Celsius 
    """
    return ((temp - 32) * (5/9))

Uma vez que temos a função definida, agora podemos usá-la. Se quisermos obter ajuda, podemos contar com o comando help() que nos trará o docstrings dessa função.

help(fahr_to_celsius)

Para invocar a função, devemos passar um valor para ela como argumento:

print(fahr_to_celsius(91.76)) # 33.2
print(fahr_to_celsius(101.3)) # 38.5

Como essa função tem valor de retorno, podemos armazenar o seu resultado em uma variável:

celsius = fahr_to_celsius(70.76)
print(celsius) # 21.53333333333334

Também podemos definir uma função que não irá retornar um valor, por exemplo:

def cumprimentar(nome):
    """
    Essa função cumprimentará a pessoa passada por parâmetro
    """
    print("Olá {0} Seja bem-vindo".format(nome))

A função foi criada e está definida, porém nada aconteceu. Para que ela possa funcionar precisamos invocá-la, para isso chamaremos ela por seu nome e passaremos os parâmetros requisitados por ela:

cumprimentar("Gabriel") # Olá Gabriel Seja bem-vindo

Observe que esta função apenas nos imprime uma string, uma vez que ela não tem valor de retorno.

Parâmetros Padrão

Podemos definir parâmetros padrão para caso a função seja invocada sem nenhum argumento passado, estes preencherão as opções.

def padrao(valor=100):
    """Função que apenas imprime um valor"""
    print("O valor definido foi: " + str(valor))

padrao() # 100
padrao(10) # 10
padrao(33) # 33

Docstring

A primeira string depois do cabeçalho da função é chamada de docstring, é uma string usada para especificar a funcionalidade da nossa função, e embora seja opcional, vos lembro que documentar é uma importante prática de programação, uma vez que possivelmente outras pessoas estarão lendo nosso código, inclusive é importante até mesmo para você lembrar o que você fez!

Caso queiramos ver o docstring de uma função, podemos acessar o atributo __doc__:

print(padrao.__doc__) # Função que apenas imprime um valor

O Comando return

Novamente, o comando return nos permite fazer com que a função retorne um valor e possamos armazená-lo em uma variável, por exemplo:

def func(x):
    return x + 1 

y = func(1)
z = func(2)
print(y) # 2
print(z) # 3

Utilizando somente o return, nossa função retornará None:

def func():
    return 

x = func()
print(x) # None

Names

Antes de falarmos sobre o conceito de Namespace e Escopo em Python, é importante entendermos os names(também conhecidos como identifiers), que são simplesmente um nome dado aos objetos. Lembre que tudo em Python é um objeto. Names são uma maneira de acessar os objetos.

Por exemplo, quando fazemos a atribuição x = 13, nesse caso 13 é um objeto armazenado em memória e x é o name que este objeto está associado. Nós podemos obter o endereço (em RAM) de um objeto através da função construída em Python chamada id(), vejamos exemplos:

x = 13

print(id(13)) # 10914880
print(id(x)) # 10914880

Observe que ambos se referem ao mesmo objeto, vamos agora considerar:

x = 13

print(f'id(x) = {id(x)}') # id(x) = 10914880

x = x + 1

print(f'id(x) = {id(x)}') # id(x) = 10914912
print(f'id(14) = {id(14)}') # id(x) = 10914912

y = 13

print(f'id(13) = {id(13)}') # id(13) = 10914880

Veja que inicialmente um objeto 13 é criado e o name x é associado com ele, quando executamos a expressão x = x + 1, um novo objeto 14 é criado, e agora x é associado com esse objeto, tendo ele um novo endereço de memória, podemos confirmar essa afirmação ao verificarmos que id(x) e id(14) possuem o mesmo endereço.

Finalmente, quando executamos y = 13, o novo name y se associa com o objeto antigo 13, obtendo seu endereço.

Essa dinâmica é capaz de tornar Python uma linguagem muito poderosa, uma vez que um name pode referir-se a qualquer tipo de objeto.

x = 1
x = 'Programação com Python'
x = [0,5,10]

Todas essas expressões são válidas e x irá referir-se à três diferentes tipos de objetos em diferentes instances. Funções também são objetos em Python, sendo assim, um name pode fazer referência a ela.

def zero():
    return 0

z = zero
print(z()) # 0

O name z definido por nós pode fazer referência a uma função e através dele podemos chamar a função.

Namespace

Um namespace em Python é uma coleção de nomes. Portanto, um namespace é essencialmente um mapeamento de nomes para os objetos correspondentes. A qualquer momento, diferentes namespaces podem coexistir completamente isolados - o isolamento garante que não haja colisões de nomes. Simplesmente, dois namespaces em python podem ter o mesmo nome sem que haja nenhum problema. Um namespace é implementado como um dicionário Python.

No namespace há um mapeamento de nome para objeto, com os nomes como chaves e os objetos como valores. Diversos namespace podem usar o mesmo nome e mapeá-lo para um objeto diferente. Vejamos alguns exemplos de namespaces:

Namespace Local: Este namespace inclui nomes locais dentro de uma função. Este namespace é criado quando uma função é chamada e dura apenas até que a função retorne.
Namespace Global: Este namespace inclui nomes de vários módulos importados que você está usando em um projeto. É criado quando o módulo é incluído no projeto e dura até o final do script
Namespace Built-In: Este namespace inclui funções internas e nomes de exceção internos.

Em Python, você pode então imaginar um namespace como um mapeamento de todos os nomes que você definiu para os objetos correspondentes.

Escopo

Embora existam vários namespaces exclusivos definidos, talvez não possamos acessar todos eles de todas as partes do programa. É nesse momento que o conceito de escopo entra em jogo.

Podemos dizer que o Escopo é a parte do programa a partir do qual um namespace pode ser acessado diretamente sem nenhum prefixo.

A qualquer momento, existem pelo menos três escopos aninhados.

Escopo da função atual que possui nomes locais
Escopo do módulo que possui nomes globais
Escopo externo que possui nomes construídos

Quando uma referência é feita dentro de uma função, o name é procurado no namespace local, depois no namespace global e, finalmente, no namespace externo.

Caso haja uma função dentro de outra função, um novo escopo será aninhado dentro do escopo local.

Consideramos agora o seguinte exemplo:

def externa():
    z = 13
    print(z)
    print(f'valor de z = {z}')
    def interna():
        y = 14
        print(f'valor de y = {y}')
    interna()

x = 10
externa()
print(f'valor de x = {x}')

O script nos trará o seguinte output:

valor de z = 13
valor de y = 14
valor de x = 10

Aqui, a variável x está no namespace global. A variável z está no namespace local da função externa() e a variável y está no namespace local aninhado da função interna().

Quando estamos na função interna(), y é uma variável local para nós, z é não-local e x é global. Nós podemos ler e atribuir novos valores à y, porém só podemos ler z e x através da função interna().

Se tentarmos atribuir um novo valor para a variável z, uma nova variável z será criada no namespace local no qual é diferente do não-local z. O mesmo acontece quando atribuimos um novo valor para x.

Entretanto, se declararmos x como global, todas as referências e atribuições irão para a global x. Similarmente, se desejarmos reatribuir a variável z, ela deve ser declarada como não-local, vamos ver mais um exemplo para ilustrar a ideia.

def externa():
    x = 13
    print(x)
    print(f'valor de x = {x}')
    def interna():
        x = 14
        print(f'valor de x = {x}')
    interna()

x = 10
externa()
print(f'valor de x = {x}')

O script nos trará o seguinte output:

valor de x = 13
valor de x = 14
valor de x = 10

Neste último script de exemplo, três diferentes variáveis x são definidas em namespaces separados e acessadas de acordo, enquanto que no seguinte script:

def externa():
    global x
    x = 20
    def interna():
        global x
        x = 30
        print(f'x = {x}')
    interna()
    print(f'x = {x}')

x = 10
externa()
print(f'x = {x}')

O script nos trará o seguinte output:

x = 30
x = 30
x = 30

Neste caso específico, todas as referências e atribuições são para a variável global x por causa do uso da palavra-chave global.

O que ocorre então quando chamamos/invocamos uma função?

Parâmetro formal se conecta com o valor do parâmetro real quando a função é chamada
Um novo escopo/quadro/ambiente é criado quando entra uma função
Escopo é o mapeamento de nomes para objetos

# Definição da Função
def f(x): # parâmetro formal
    x += 1
    print('Em f(x): x = ',x)
    return x 

# Código principal do Programa
# -> Inicializa a variável x
# -> faz uma chamada de função f(x)
# -> atribui o retorno da função para a variável z
x = 10
z = f(x) # parâmetro real
print(z) # 11

Funções como Argumentos

Argumentos podem assumir qualquer tipo, até mesmo funções:

def func_a():
    print('dentro da func_a')

def func_b(y):
    print('dentro da func_b')
    return y

def func_c(z):
    print('dentro da func_c')
    return z()

print(func_a()) # chama a função func_a, não recebe parâmetros
print(5+func_b(2)) # chama a função func_b, recebe um parâmetro
print(func_c(func_a)) # chama a função func_c, recebe outra função como parâmetro

Observe que:

A função func_a retorna None, pois ela apenas imprime uma string
A função func_b retorna 2 (valor que passamos via argumento)
A função func_c recebe a func_a como parâmetro, que por sua vez retorna None

Exemplo do Escopo

Nem todas as variáveis são acessíveis a partir de todas as partes do nosso programa, e nem todas as variáveis existem durante o mesmo período de tempo. Onde uma variável é acessível e por quanto tempo ela existe depende de como é definida. Chamamos a parte de um programa onde uma variável está acessível de seu escopo, e a duração para a qual a variável existe seu tempo de vida.

Uma variável que é definida dentro de uma função é local para essa função. Ela é acessível a partir do ponto em que foi definida até o final da função e existe enquanto a função estiver em execução. Os nomes dos parâmetros na definição da função se comportam como variáveis locais, mas contêm os valores que passamos para a função quando a chamamos. Quando usamos o operador de atribuição (=) dentro de uma função, seu comportamento padrão é criar uma nova variável local - a menos que uma variável com o mesmo nome já esteja definida no escopo local.

Dentro de uma função, podemos acessar uma variável definida fora dela
Dentro de uma função, não podemos modificar uma variável definida fora dela, na verdade podemos utilizando a variável global, mas normalmente não é o ideal

def f(y):
    # x é redefinido no escopo de f
    x = 1
    x += 1
    print(x)

x = 5
f(x) # 2
print(x) # 5

Neste caso temos diferentes objetos x, a função f() irá utilizar o x definido dentro dela e print() irá imprimir o objeto x global.

def g(y):
    print(x)
    print(x+1)

x = 5
g(x)
print(x)
# 5
# 6
# 5

Neste caso a função g() e print() vão usar o mesmo objeto x global.

def h(y):
    x += 1

x = 5 
h(x)
print(x)
# UnboundLocalError: local variable 'x' referenced before assignment

Neste exemplo ocorrerá um erro, uma vez que a função h() está tentando modificar o objeto x antes mesmo dele ser definido.

A Função globals()

Como o próprio nome indica, a função globals() exibirá informações de escopo global.
Por exemplo, se abrirmos um console Python e inserirmos globals(), um dicionário incluindo todos os nomes e valores de variáveis no escopo global será retornado.

Veja que estou usando ... para abreviar o resultado:

>>> globals()
# {'__name__': '__main__', ..., '__builtins__': <module 'builtins' (built-in)>}

Se adicionarmos uma variável, ela agora será incluída no escopo global:

x = 1
globals()
# {'__name__': '__main__', ...,  '__builtins__': <module 'builtins' (built-in)>, 'x': 1}

A Função locals()

Como o próprio nome indica, a função locals() retornará um dicionário incluindo todos os nomes e valores locais.

def anime():
    nome = 'Naruto'
    print(locals())

anime() # {'nome': 'Naruto'}

Se chamarmos a função locals() no escopo global, o resultado será idêntico ao resultado da função globals(), portanto esteja ciente disso quando usá-la:

globals() is locals() # True

*args & **kwargs

As variáveis mágicas *args e **kwargs são normalmente usadas em definições de funções, elas nos permitem passar um número variável de argumentos para uma função. Variável nesse caso significa que não sabemos de antemão quantos argumentos vamos receber, então nesse caso utilizamos *args e **kwargs.

*args

*args é usado para enviar uma variável que não tenha palavras-chave, veja um exemplo:

def soma(*args):
    total = 0
    for num in args:
        total += num 
    return total

print(soma(2,3,4,6)) # 15
print(soma(2,3,4,6,5,5,5,1,2)) # 32
print(soma(2,3)) # 5

**kwargs

**kwargs nos permite passarmos variáveis com palavras-chave como argumento, veja exemplos:

def pessoa(**kwargs):
    print(kwargs)
    for nome, idade in kwargs.items():
        print(f'{nome} tem atualmente {idade} anos de idade')

pessoa(gabriel='33', rafael='47', daniel='22')
# {'gabriel': '33', 'rafael': '47', 'daniel': '22'}
# gabriel tem atualmente 33 anos de idade
# rafael tem atualmente 47 anos de idade
# daniel tem atualmente 22 anos de idade

Recursão

'Recursividade' é um termo usado de maneira mais geral para descrever o processo de repetição de um objeto de um jeito similar ao que já fora mostrado. Um bom exemplo disso são as imagens repetidas que aparecem quando dois espelhos são apontados um para o outro.

Outro grande exemplo seria O Triângulo de Sierpinski - também chamado de Junta de Sierpinski - é uma figura geométrica obtida através de um processo recursivo. Ele é uma das formas elementares da geometria fractal por apresentar algumas propriedades, tais como: ter tantos pontos como o do conjunto dos números reais; ter área igual a zero; ser auto-semelhante (uma parte sua é idêntica ao todo); não perder a sua definição inicial à medida que é ampliado. Foi primeiramente descrito em 1915 por Waclaw Sierpinski (1882 - 1969), matemático polonês.

Imagem do Triângulo de Sierpinski:

Pensando de forma computacional:

Algoritmicamente falando, Recursão é uma maneira de desenvolver soluções para problemas através de divide-and-conquer ou decrease-and-conquer, reduzindo o problema para versões simplificadas do mesmo problema
Semanticamente: Uma técnica de programação onde a função chama a si mesmo
Em Programação, o objetivo é não ter recursão infinita
Deve-se ter 1 ou mais casos bases que são fáceis de resolver
Deve-se resolver o mesmo problema em algum outro input com o objetivo de simplificar o input do problema maior

Recursão em Python

Nós sabemos que em Python é possível uma função chamar outras funções, inclusive é possível que uma função chame ela mesma, esses tipos de constructos são chamados de funções recursivas.

A seguir temos o exemplo de uma função que descobre o fatorial de um inteiro. Fatorial de um número é produto de todos inteiros de 1 até esse número. Por exemplo, o fatorial de 5 (denotado por 5!) é 1x2x3x4x5 = 120.

Exemplo de uma função recursiva:

def fatorial(x):
    """
    Essa é uma função recursiva
    Ela calcula o fatorial de um número inteiro
    """
    if x == 1:
        return 1
    else:
        return (x * fatorial(x - 1))

y = 4
z = 10
print("O fatorial de {0} é {1}".format(y,fatorial(y))) # O fatorial de 4 é 24
print("O fatorial de {0} é {1}".format(z,fatorial(z))) # O fatorial de 7 é 3628800

No exemplo acima fatorial() é considerada uma função recursiva, pois chama a ela mesma. Quando nós chamamos essa função com um inteiro positivo, ela chamará recursivamente ela mesma diminuindo o número. Para entendermos melhor, veja o cálculo que ocorre:

fatorial(4)              # Primeira chamada com 4
4 * fatorial(3)          # Segunda chamada com 3
4 * 3 * fatorial(2)      # Terceira chamada com 2
4 * 3 * 2 * fatorial(1)  # Quarta chamada com 1
4 * 3 * 2 * 1            # Retorno da quarta chamada, uma vez que y = 1
4 * 3 * 2                # Retorno da terceira chamada
4 * 6                    # Retorno da segunda chamada
24                       # Retorno da primeira chamada

Como podem ver, nossa recursão acaba quando o valor de y reduz a 1, essa é considerada a condição base. Toda recursão deve ter uma condição base que para a recursão ou a função ficará chamando-a eternamente.

Recursão com Múltiplos Casos Base

Como já vimos, um caso de base é um cenário de encerramento que não usa recursão para produzir uma resposta, podemos ter um ou mais desses cenários em nossas funções.

Na matemática, a Sucessão de Fibonacci (ou Sequência de Fibonacci), é uma sequência de números inteiros, começando normalmente por 0 e 1, na qual, cada termo subsequente corresponde à soma dos dois anteriores. A sequência recebeu o nome do matemático italiano Leonardo de Pisa.

Fibonacci modelou o seguinte desafio:

Pares de coelhos recém-nascidos (um macho e uma fêmea) são colocados em um curral
Coelhos se acasalam na idade de um mês
Coelhos tem um mês de período de gestação
Assumindo que o coelho nunca morre, a fêmea sempre produz um novo par (um macho e uma fêmea) a cada mês a partir do segundo mês
Quantos coelhos fêmeas estão lá no final do ano?

Fibonacci em Python

Vamos então definir o problema, para que seja mais fácil solucioná-lo:

Depois de um mês (chamamos ele de 0) = 1 fêmea
Depois do segundo mês, ainda 1 fêmea (agora grávida)
Depois do terceiro, 2 fêmeas, 1 grávida, 1 não-grávida
Em geral, temos então fêmeas(n) = fêmeas(n-1) + fêmeas(n-2)
- Cada fêmea viva no mês n-2 irá produzir uma fêmea no mês n
- Estes podem ser adicionados aqueles vivos no mês n-1 para obter total vivos no mês n

Temos então os seguintes casos:

Casos Base:
- Femeas(0) = 1
- Femeas(1) = 1
Caso Recursivo
- Femeas(n) = Femeas(n-1) + Femeas(n-2)

Convertendo para a linguagem Python:

def fib(x):
    """
    Assume x como inteiro >= 0
    Retorna o Fibonacci de x
    """
    if x == 0 or x == 1:
        return 1
    else:
        return fib(x-1) + fib(x-2)

print(fib(8)) # 34
print(fib(10)) # 89

Vantagens e Desvantagens

Vantagens da Recursão:

Funções recursivas tornam o código limpo e elegante
Uma tarefa complexa pode ser quebrada em sub-problemas usando a recursão
Gerar sequências é mais fácil com recursão

Desvantagens da Recursão:

As vezes a lógica por trás dela pode ser complexa de entender
Chamadas recursivas são custosas e ineficientes e podem nos custar muita memória e tempo!
Funções recursivas são mais difíceis de debugar (processo de encontrar e reduzir defeitos de um programa).

Por fim, entendemos que as funções são um tema essencial e fundamental para a programação, elas são capazes de facilitar muito a vida dos programadores através da abstração, tornando os códigos muito mais elegantes, modulares e fáceis de entender. O código ainda pode ser utilizados muitas vezes e precisa ser debuggado/testado apenas uma vez.

Cheque a documentação oficial do Python para conhecer todas as funções construídas no interpretador Python.

Strings em Python: Introdução

Gabriel Felippe — Sun, 17 Nov 2019 22:34:55 +0000

Introdução

Definição: Uma String é tradicionalmente um tipo de dados que representa uma sequência de caracteres.

Um caracter é simplesmente um símbolo. Por exemplo, o idioma inglês possui 26 caracteres.

Caracteres podem ser letras, dígitos, símbolos ($, !, #, @), etc.

Os computadores originalmente não lidam com caracteres, eles lidam fundamentalmente com números (binários). Mesmo que vejamos caracteres em nossa tela, internamente eles são armazenados e manipulados como uma combinação de 0's e 1's.

A conversão de caracteres em números é chamada de codificação e o processo reverso é a decodificação. ASCII e Unicode são algumas das codificações populares usadas. Em Python, uma string é uma sequência de caracteres Unicode. O Unicode foi introduzido para incluir todos os caracteres em todos os idiomas e trazer uniformidade na codificação.

A figura a seguir nos mostra a Tabela ASCII:

Com a função ord() podemos obter o valor ASCII para um determinado caracter:

ord('A') # 65
ord('X') # 88
ord('<') # 60

Contanto que permaneçamos no domínio dos caracteres comuns, haverá pouca diferença prática entre ASCII e Unicode. Mas a função ord() retornará valores numéricos para caracteres Unicode também:

ord('∑') # 8721
ord('火') # 28779

Já o método chr() faz o inverso de ord(). Fornecido um valor numérico, ele retorna uma string representando este valor.

chr(65) # 'A'
chr(88) # 'X'
chr(60) # '<'
chr(28779) # '火'

Existem diversos problemas no mundo real que envolvem as strings, podemos citar por exemplo:

Criptografia e Descriptografia
Análises de DNA
Tradução de linguagens

Fundamentos

Além dos números, Python é capaz de manipular strings com maestria, as strings podem ser expressas de diversas maneiras, podemos encapsular elas com aspas simples ('...') ou também aspas duplas ("...") ou até mesmo ("""...""") para múltiplas linhas. Por exemplo:

print('String é um elemento importante da programação')
print("Também podemos representá-las com aspas duplas")
print("""Podemos, até mesmo, representá-las com três aspas duplas, para textos grandes""")

Como podemos ver, strings podem ser impressas utilizando a função print()
Caso você queira usar palavras entre aspas na sua string, você deve usar \ (contrabarra) para dar escape nas aspas, caso contrário ocorrerá um erro:

print("Podemos usar aspas dentro das \"strings\"")
print('Podemos usar aspas dentro das \'strings\'')

Ou até mesmo você pode inverter o uso das aspas:

print("Dessa forma não há 'problema'")
print('Dessa forma não há "problema"')

Índices de Strings

Assim como em diversas linguagens de programação, strings em Python são consideradas arrays de bytes que representam caractéres unicode, entretanto Python não tem um tipo de dados caracter. Caracteres únicos são simplesmente strings de tamanho 1. Para acessarmos elementos individuais das strings, utilizamos colchetes [].

s = "Rafael"
print(s[0]) # Imprime a primeira letra do nome
print(s[-6]) # Imprime a primeira letra do nome

print(s[5]) # Imprime a última letra do nome
print(s[-1]) # Imprime a última letra do nome

Observe que foi utilizado a notação s[0], isso porque o primeiro caracter começa na posição 0, lembre que isso é muito comum nas linguagens de programação e estruturas de dados. Cada caracter na string é associado com um índice numérico, que é um inteiro representando a localização do caracter em uma determinada string.

Além disso, podemos formar substrings a partir de uma string.

nome = "John Von Neumann"

Neste exemplo, selecionamos o caracter da posição 5 até 11 (não incluindo 12):

print(nome[5:12]) # Von Neu

Podemos também reverter a string usando a seguinte notação:

print(nome[::-1]) # nnamueN noV nhoJ

Métodos em Strings

Um detalhe importante dentro do universo das strings é que podemos utilizar métodos (funções especiais) para manipulalá-las.

Para compreendermos melhor estes métodos, vamos definir uma string para podermos testá-los:

nome = " Meu nome é Dennis Ritchie "

O método strip() remove todos os espaços extras no começo e no fim da string:

print(nome.strip()) # Meu nome é Dennis Ritchie

O método len() retorna o tamanho (comprimento) da string:

print(len(nome)) # 27

O método lower() retorna a string em lower case (todos os caracteres se tornam minúsculos):

print(nome.lower()) # meu nome é dennis ritchie

O método upper() retorna a string em upper case (todos os caracteres se tornam maiúsculos):

print(nome.upper()) # MEU NOME É DENNIS RITCHIE

O método swapcase() retorna a string com caracteres uppercase convertidos para lowercase e vice-versa:

print(nome.swapcase()) # mEU NOME É dENNIS rITCHIE

O método title() retorna a string ao qual a primeira letra de cada palavra é convertida para uppercase e as demais letras pernanecem lowercase:

print(nome.title()) # Meu Nome É Dennis Ritchie

O método replace() substitui a string que desejarmos por outra string especifica por nós via argumento:

Primeiro informamos a string a ser substituída
Segundo informados a nova string

print(nome.replace("Dennis", "Ken")) # Meu nome é Ken Ritchie

O método split() separa a string em substrings caso haja um separador, nesse caso utilizamos o espaço (" ") e ele nos retorna uma lista de strings:

print(nome.split(" ")) # ['', 'Meu', 'nome', 'é', 'Dennis', 'Ritchie', '']

O método join() retorna a string que resulta da concatenação dos objetos em um iterável separados por delimitador.

No exemplo a seguir, o delimitador é a string ',' e o iterável é uma lista de filósofos:

filosofos = ['Kant', 'Kierkegaard', 'Nietzsche', 'Leibniz']

print(', '.join(filosofos)) # Kant, Kierkegaard, Nietzsche, Leibniz
print(' - '.join(filosofos)) # Kant - Kierkegaard - Nietzsche - Leibniz

O resultado é uma única string que consiste nos objetos da lista separados por um delimitador especificado por nós.

No próximo exemplo, iterável é especificado como um único valor de string. Quando um valor de string é usado como um iterável, ele é interpretado como uma lista dos caracteres individuais da string:

list('aeiou') # ['a', 'e', 'i', 'o', 'u']
'|'.join('aeiou') # 'a|e|i|o|u'

O método count() retorna o número de ocorrências não sobrepostas de substring informada por nós:

print("Ra Ra Ja Ra Ta".count("Ra")) # 3

O método startwith() retorna True se uma determinada string começa com um prefixo especificado, caso contrário, retorna False:

print("existencialismo".startswith("exist")) # True
print("existencialismo".startswith("ismo")) # False

O método endswith() retorna True se uma determinada string termina com um sufixo especificado, caso contrário, retorna False:

print("existencialismo".endswith("ismo")) # True
print("existencialismo".endswith("exist")) # False

O método find() pode ser usado para vermos se uma string contém uma substring informada e retorna o menor índice na string onde esta substring é encontrada:

print('Amar, é encontrar a própria felicidade na felicidade alheia'.find('Amar')) # 0
print('Amar, é encontrar a própria felicidade na felicidade alheia'.find('é')) # 6

Os métodos de classificação de caracteres são capazes de classificar uma string baseado nos caracteres contidos nela. Vejamos alguns exemplos.

O método isalnum() retorna True se a string for não-vazia e todos os seus caracteres forem alfanuméricos (ou uma letra ou um número), e caso contrário, retorna False.

print('xyz678'.isalnum()) # True
print('xyz#678'.isalnum()) # False
print(' '.isalnum()) # False

O método isalpha() retorna True se a string for não-vazia e todos os seus caracteres forem alfabéticos, caso contrário, retorna False.

print('exemplo'.isalpha()) # True
print('exemplo 2'.isalpha()) # False

Para checarmos se uma string contém apenas dígitos, podemos utilizar o método isdigit(), ele vai retornar True se a string for não-vazia e todos os caracteres forem numéricos, e caso contrário, retornará False.

print('33'.isdigit()) # True
print('a33z'.isdigit()) # False
print(''.isdigit()) # False

O método isidentifier() nos retorna True se uma determina string é um identificador válido de acordo com a definição da linguagem Python, caso contrário, retorna False.

print('nome'.isidentifier()) # True
print('nome2'.isidentifier()) # True
print('2nome'.isidentifier()) # False
print('nome#'.isidentifier()) # False

Dessa forma podemos saber como definir uma variável corretamente.

Já o método iskeyword() é capaz de testar se uma determinada string corresponde à uma palavra-chave Python, este método é contido no módulo keyword, sendo então necessário importá-lo.

from keyword import iskeyword

print(iskeyword("or")) # True
print(iskeyword("else")) # True
print(iskeyword("while")) # True
print(iskeyword("switch")) # False

O método isprintable() determina se uma string consiste inteiramente de caracteres imprimíveis. Ele retorna True se a string for vazia ou se todos os caracteres alfabéticos que ela conter forem imprimíveis, retorna False se ela conter pelo menos um caracter não-imprimível. Caracteres não-alfabéticos são ignorados.

print('Gabriel\tFelippe'.isprintable()) # False
print('Gabriel Felippe'.isprintable()) # True
print(''.isprintable()) # True
print('x\ny'.isprintable()) # False

O método isspace() determina se uma string consiste de caracteres de espaço em branco, retornará True se a string for não-vazia e todos os caracteres forem de espaço em branco, caso contrário, retornará False.

print(''.isspace()) # False
print('x'.isspace()) # False
print(' '.isspace()) # True
print('\t\n'.isspace()) # True

O método isupper() é capaz de verificar se todos os caracteres de uma string são uppercase:

print("STRING".isupper()) # True
print("String".isupper()) # False

Já o método islower() é capaz de identificar se todos os caracteres de uma string são lowercase:

print("String".islower()) # False
print("string".islower()) # True

Formatando Strings

Vejamos agora como podemos usar métodos que modificam ou aprimoram o formato de uma string.

O método center() retorna uma string centralizada em um determinado comprimento especificado por nós via argumento, por padrão, o preenchimento consiste no caractere de espaço ASCII, por exemplo:

'python'.center(20) # '       python       '
'python'.center(25,'.') # '..........python.........'

O método expandtabs() substitui cada caracter tab (\t) com espaços.

'x\ty'.expandtabs() # 'x       y'

O método ljust() retorna uma string justificada à esquerda em um campo de comprimento especifica por nós via argumento, por padrão, o preenchimento consiste no caractere de espaço ASCII, por exemplo:

'C++'.ljust(10) # 'C++       '
'C++'.ljust(10,'-') # 'C++-------'

O método rjust() retorna uma string justificada à direita em um campo de comprimento especifica por nós via argumento, por padrão, o preenchimento consiste no caractere de espaço ASCII, por exemplo:

'Javascript'.rjust(20) # '          Javascript'
'Javascript'.rjust(20,'-') # '----------Javascript'

O método zfill() retorna uma cópia da string com preenchimento à esquerda com caracteres '0', o comprimento é especificado por nós, por exemplo:

'66'.zfill(4) # '0066'

Embora seja mais interessante para números, zfill() também funciona com caracteres:

'letra'.zfill(7) # '00letra'

O método format() nos permite construir strings de uma maneira flexível:

nome = "Rafael"
profissao = "Programador"

print("A profissão de {0} é {1}".format(nome,profissao))
# A profissao de Rafael é Programador

Criando um elemento HTML:

tag = 'p'
texto = 'Este é um parágrafo'

sentenca = '<{0}>{1}</{0}>'.format(tag, texto)
print(sentenca) # <p>Este é um parágrafo</p>

Calculando um valor:

valor = '1 GB é igual a {:,} bytes'.format(10**9)
print(valor) # 1 GB é igual a 1,000,000,000 bytes

Existe também a possibilidade de usarmos Códigos de Formatação.

Inteiro:

print("{:d}".format(4)) # 4

Binário:

print("{:b}".format(55)) # 110111

Hexadecimal:

print("{:x}".format(15)) # f

Lista:

print("{:}".format([20, 30])) # [20, 30]

Também podemos representar as strings de maneira similar ao estilo da linguagem C.

String:

nome = "Alan"
amigo = "Jones"

print("%s é amigo de %s" %(nome,amigo))
# Alan é amigo de Jones

Inteiro:

print("%d" % (4545)) # 4545

Float:

print("%3.5f" % (3.123456789)) # 3.12346
print("%2.4f" % (3.123456789)) # 3.1235

F-Strings

F-strings são um novo tipo de string literals introduzido na versão 3.6 do Python. A string formatada é prefixada com a letra f e é similar à formatação de strings aceita por format().

Vejamos exemplos:

first_name = "Alan"
last_name = "Turing"

sentenca = f'Meu nome e {first_name.upper()} {last_name.lower()}'
print(sentenca) # Meu nome e ALAN turing

Observe que podemos também executar métodos com F-strings.

Além disso, podemos também utilizar dicionários:

pessoa = {'nome': 'Muhammad', 'idade': 22}

sentenca = f'Meu nome é {pessoa["nome"]} e eu tenho {pessoa["idade"]} anos de idade'

print(sentenca)
# Meu nome é Muhammad e eu tenho 22 anos de idade

Ou até mesmo realizar operações matemáticas:

calculo = f'4 vezes 11 é igual a {4 * 11}'
print(calculo) # 4 vezes 11 é igual a 44

for n in range(1,11):
    sentenca = f'O Valor é {n:02}'
    print(sentenca)

Para formatarmos datas precisaremos importar a biblioteca datetime:

from datetime import datetime

nascimento = datetime(1991, 6, 6)

sentenca = f'O Nascimento é no dia {nascimento:%B %d, %Y}'

print(sentenca)
# O Nascimento é no dia June 06, 1991

Convertendo para o Formato String

Para fazermos a conversão para uma string podemos utilizar os métodos repr() e str():

x = 10
y = [1, 3.14, 17, 13]

print(type(repr(x))) # <class 'str'>
print(type(str(y))) # <class 'str'>

Escape Caracteres

Strings também são capazes de aceitar Escape caracteres:

Carácter	Descrição
\n	nova linha
\r	carriage return
\s	espaço
\t	tab
\v	tab vertical
\e	escape
\b	backspace

Vejamos um exemplos dos escape caracteres:

print("Meu nome é\nGabriel")
print("\tOlá meu amigo")

Operadores

Operadores Especiais:

Operador	Descrição
+	concatenação, adiciona os valores
*	repetição, concatena múltiplas cópias da mesma string
in	para verificarmos se determinado caracter existe na string
not in	para verificarmos se determinado caracter não existe na string

Veja um exemplo dos operadores especiais:

nome = "Carl"
sobrenome = "Sagan"

print(nome +" "+ sobrenome) # Concatena o nome e sobrenome
print(nome*10)              # Multiplica o nome por 10
print("C" in nome)          # Verifica se C está presente em nome e retorna True
print("C" not in nome)      # Verifica se C não está presente em nome e retorna False

É importante lembrarmos que strings são imutáveis, uma vez criada, não pode ser modificada. Para alterar uma string você deve primeiro construir uma nova string através da concatenação ou chamada de uma função e então re-atribuir à variável string.

O conteúdo de strings é bastante extenso e continuaremos vendo elas ao longo do guia, considere dar bastante importância a elas!