DEV Community: Gustavo Soares

Python: Manipulação de Listas e Matrizes

Gustavo Soares — Fri, 12 May 2023 21:19:11 +0000

Listas

Python possui uma estrutura de dados correspondente ao array em linguagens C-like: a lista.

As listas e matrizes são estruturas de dados que permitem armazenar um conjunto de valores em uma única variável. Essas estruturas são essenciais em Python e em outras linguagens de programação, pois permitem o armazenamento e manipulação de dados de forma eficiente e organizada.

As listas são usadas para armazenar uma sequência de elementos, permitindo que sejam acessados, adicionados ou removidos conforme necessário. Já as matrizes são uma extensão das listas, permitindo que sejam armazenados valores em uma tabela de duas ou mais dimensões. Uma matriz numa linguagem de programação se assemelha consideravelmente ao conceito de matriz na matemática, mas não com sob a mesma ótica.

Uma lista em Python é definida entre colchetes [ ], e pode conter qualquer tipo de dado, incluindo strings, números, outros objetos e até outras listas. Por exemplo:

minha_lista = [1, 2, 3, "quatro", "cinco"]

No entanto, utilizar listas de mais de um tipo não é considerado uma boa prática, principalmente quando se fala de linearidade de memória. Sabendo que uma lista é uma sequência contínua em memória, temos uma lista de 5 inteiros onde cada inteiro ocupa 4 bytes, logo, $5 * 4 = 20$ . Se uma mesma lista possuir elementos de diferentes tipos, isso dificulta o armazenamento e diminui a eficiência da mesma. Se isso não for o suficiente para que você aceite essa boa prática, ao usar listas de diferentes tipos, você pode enfrentar diferentes erros de tipagem, visto que não há como mapear todos os erros de tipo presentes em listas heterogêneas.

Para acessar elementos específicos da lista, utilizamos a indexação, que começa em 0. Por exemplo, para acessar o primeiro elemento da lista acima, usamos:

print(minha_lista[0])

## Output:
1

Métodos de listas

Métodos são funções ligadas a tipos, objetos ou pacotes. No caso das listas, são funções que fazem uso das informações internas das mesmas para executar suas sub-rotinas. Os métodos das listas são majoritariamente usados para a sua manipulação, ou seja, alteração de elementos, mapeamento e afins. Dentre os métodos, temos:

`list.append(value)`

O método append adiciona o valor do parâmetro value no final da lista que invocou o método.

intro = ["mansão", "thug"]
intro.append("stronda")

print(intro)

Output:

$> python3 <nome_do_arquivo>.py
['mansão', 'thug', 'stronda']

`list.remove(value)`

O método remove remove (não me diga) a primeira ocorrência do elemento value na lista que o invocou. Por “primeira ocorrência”, digo a primeira vez em que o elemento aparece, já que os valores dos elementos podem aparecer repetidamente numa mesma lista.

dezenas = [10, 20, 30, 50, 40, 10]
dezenas.remove(10)

print(dezenas)

Output:

$> python3 <nome_do_arquivo>.py
[20, 30, 50, 40, 10]

`list.count(elem)`

O métoro count conta (não me diga???) quantas vezes o elemento elem apareceu na lista que o invocou. Veja o exemplo:

repetidos = [1, 2, 3, 1, 2, 1, 2, 3, 2, 1]
print(repetidos.count(1))

Output:

$> python3 <nome_do_arquivo>.py
4

`list.sort(reverse=False, key=None)`

Onde:

reverse: bool diz se a ordenação da lista deve ser crescente ou decrescente. Esse parâmetro recebe por padrão o valor False, portanto, é opcional;
key: callable é a função que especifica o critério de ordenação. Esse parâmetro recebe por padrão o valor None, portanto, é opcional;

O método sort ordena a lista que o invocou de acordo com os parâmetros especificados acima. Se nenhum valor for passado aos parâmetros, então a lista sofre uma ordenação crescente sem nenhum critério extra, apenas se baseando no tipo dos elementos da lista.

Observação: os parâmetros da função DEVEM ser passados de forma nomeada.

Veja o exemplo abaixo.

sequencia_numerica = [2, 6, 1, 3, 8, 7, 4]
sequencia_numerica.sort()

print(sequencia_numerica)

sequencia_numerica.sort(reverse=True)
print(sequencia_numerica)

nomes = ["gustavo", "joão", "gabriela", "maria", "ana"]
nomes.sort(key=len)

print(nomes)

Output:

$> python3 <nome_do_arquivo>.py
[1, 2, 3, 4, 6, 7, 8]
[8, 7, 6, 4, 3, 2, 1]
['ana', 'joão', 'maria', 'gustavo', 'gabriela']

No trecho de código acima, temos duas listas: sequencia_numerica, de inteiros, e nomes, de strings. De imediato, percebemos 3 chamadas diferentes ao método sort, onde a primeira é uma ordenação simples e crescente, a segunda é uma ordenação decrescente e a terceira, uma crescente com critérios. O parâmetro key pode receber qualquer função que seja válida para o contexto da sua lista. Por exemplo, não podemos passar a função len, que mede o tamanho de uma sequẽncia, como valor de key para uma lista de inteiros, pois não há elementos nessa lista que se adequem ao requisito de len. Logo, o que essa função faz nesse contexto é ordenar as strings de forma crescente pelo seu tamanho.

Slices

Slices em Python são uma forma de selecionar partes específicas de uma lista, matriz ou sequência. Essa funcionalidade é extremamente útil para a manipulação de dados, permitindo que sejam selecionados elementos específicos da estrutura de dados de forma rápida e eficiente. No entanto, apesar de sua utilidade, o uso de slices pode ser um pouco confuso para programadores de primeira viagem.

Slices são denotados pelo uso de colchetes [] e dois pontos : para especificar a faixa de elementos que você deseja selecionar. Como se fossemos selecionar um elemento da lista pelo seu índice, mas são usados dois pontos.

A sintaxe geral é a seguinte: objeto[inicio:fim:passo], onde inicio é o índice inicial da seleção, fim é o índice final (exclusivo) da seleção e passo é a quantidade de elementos a serem pulados. Veja o exemplo abaixo:

sequencia_numerica = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

primeiros_cinco = sequencia_numerica[:5]

pares = sequencia_numerica[::2]

print(sequencia_numerica)
print(sequencia_numerica[::])
print(primeiros_cinco)
print(pares)

No código acima, vemos a variável sequencia_numerica, que recebe uma lista de inteiros de 0 a 10, e abaixo mais duas variáveis, também listas, derivadas da primeira que utilizam o slicing para gerar novas listas a partir de uma original. Seguindo a sintaxe descrita, temos a lista primeiros_cinco, que recebe uma slice de sequencia_numerica que vai da posição inicial 0 (omitida) até a posição final 5 (explícita) com o passo de 1 (também omitido e não pula nenhum índice). Já variável pares recebe uma slice na qual tanto o inicio quanto o fim estão omitidos, ou seja, do começo da lista até o fim dela, e possui um passo de 2 (seleciona os índices de 2 em 2). Quanto algum dos valores é omitido, um valor padrão é considerado no lugar; para cada posição temos 0 para o início, o tamanho da lista para o final e 1 para o passo. O resultado do código acima é:

$> python3 <nome_do_arquivo>.py
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 1, 2, 3, 4]
[0, 2, 4, 6, 8, 10]

List Comprehension

Em Python existem várias maneiras de criar listas. A maneira q será vista nesse tópico é a compreensão de lista (ou list comprehension para os amantes de inglês). List comprehensions permitem criar listas de uma forma mais concisa e legível, tornando o código mais fácil de ser entendido e mantido. Nomezinho chique, hein?

Essa funcionalidade permite criar uma nova lista a partir de uma lista existente, um loop ou outra estrutura de dados, aplicando uma expressão a cada elemento.

A sintaxe de uma List Comprehension pode ser entendida como:

[<expressao> for item in list] # ou
[<expressao> for i in range(inicio, fim)]

Traduzindo para o português bom e claro: "Aplique expressão para todo item da lista list" e "Aplique expressão para cada índice i do intervalo estabelecido".

Onde:

expressao é qualquer sentença da linguagem que retorne um valor. Por exemplo, elevar ao quadrado retorna o resultado da potência;
item representa cada elemento da lista a ser formada/manipulada. A expressão precisa ser compatível com o elemento.
list é a lista a ser criada/manipulada. Por mais que a lista já exista, essa manipulação criará uma nova lista, pois estamos copiando a lista original e modificando cada elemento de acordo com a expressão;
i é o índice do for loop. O índice aumenta o valor em 1 a cada vez que a iteração acontece até chegar no valor final;

Por exemplo, dado o seguinte código:

lista = []

for el in range(1, 10):
    lista.append(el * 10)

É possível reescrevê-lo utilizando list comprehensions na forma:

lista = [el*10 for el in range(1, 10)]

Ambos os trechos de código têm o mesmo resultado, que é criar num intervalo de 1 a 9 (10 é exclusivo), onde cada elemento deve ser multiplicado por 10.

Você pode, ainda, inserir condicionais na forma de instruções if em list comprehensions para limitar seu set de resultados. Por exemplo:

pares = [el for el in range(10) if el % 2 == 0]

print(pares)

Output:

$> python3 <nome_do_arquivo>.py
[0, 2, 4, 6, 8]

A list comprehension do código acima gera uma lista de todos os números pares no intervalo de 0 a 9 (10 exclusivo) graças à instrução if el % 2 == 0.

No começo, pode parecer que você faz uma troca de legibilidade por eficiência e praticidade, mas com o passar do tempo, a sintaxe de list comprehensions começará a se impregnar na sua leitura e a memória muscular ajudará bastante nisso. Apenas pratique e aumente a dificuldade das comprehensions gradativamente.

Matrizes

Uma matriz pode ser entendida como uma lista que contém listas. Na interpretação matemática, uma lista é um vetor e uma matriz é um conjunto de $n$ vetores representando uma matriz n-dimensional. A representação de uma matriz em python é dada da seguinte forma:

matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Em vez de usar inteiros ou strings, você usa listas separadas por vírgula dentro de outra lista para representar uma matriz. Toda matriz possui as mesmas propriedades das listas, incluindo métodos, slices e list comprehensions.

Ao criar matrizes, você insere listas dentro de listas. As list comprehensions seguem o mesmo princípio: é só você inserir comprehensions dentro de comprehensions. Por exemplo, olhe o código abaixo:

matriz = [[i+j for j in range(3)] for i in range(1, 10, 3)]

print(matriz)

Isso criará uma matriz quadrada de ordem 3 idêntica à matriz do primeiro exemplo. Vamos dividí-la em partes para entendermos melhor. Olhando de fora para dentro:

for i in range(1, 10, 3) é responsável por iterar sobre as linhas da matriz. Ele começa em 1, termina em 9 (10 exclusivo) e avança de 3 em 3. Ou seja, ele itera sobre os valores 1, 4 e 7, que correspondem às posições das três linhas na matriz;
A variável i representa a linha da matriz no loop;
for j in range(3) é responsável por iterar sobre as colunas da matriz. Ele itera sobre os valores 0, 1 e 2, que correspondem às posições das três colunas na matriz.
A expressão i+j dentro da list comprehension mais aninhada calcula o valor a ser adicionado na matriz. Essa expressão faz a soma de i, que representa a linha da matriz, com j, a coluna.

Iteração e Manipulação de Matrizes

Para percorrer matrizes, seguimos a mesma lógica de quando precisamos percorrer uma lista: fazer um loop. Mas se eu quero acessar cada linha e coluna da matriz, vou precisar de mais do que só um loop. No caso das matrizes, no algoritmo mais básico de iteração, serão necessários $n$ loops para uma matriz n-dimensional para acessar todos os seus elementos.

Bom, loops são simples, mas e se precisarmos manipular a matriz em operações como produto escalar, multiplicação entre matrizes e inversão? Vamos implementar na mão?

Para tal, usaremos a biblioteca numpy instalada no último material. Esta seção será fortemente baseada na documentação de NumPy, então é extremamente recomendado usar ambos como base.

A biblioteca numpy usa como base o elemento array, popularmente chamado ndarray (n-dimensional array), uma implementação própria da biblioteca similar às listas de Python, com a diferença de que são obrigatoriamente homogêneos. Arrays e listas compartilham diversos comportamentos, como slicing e indexação.

Veja o exemplo abaixo:

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Aqui, criamos um array de Numpy através da função np.array. O parâmetro dessa função pode ser uma lista de Python ou uma matriz. No caso acima, criamos uma matriz quadrada de ordem 3, onde, na linguagem Numpy, suas linhas e colunas são chamadas axes ou, no português claro, eixos. Logo, o primeiro axis dessa matriz possui tamanho 3 e o segundo, 3. Podemos, ainda, criar um array de tamanho n preenchido por zeros, uns ou qualquer outro valor através das funções np.zeros(n), np.ones(n) e np.full(n, v), respectivamente. Para criar um array que replique a função range, podemos utilizar a função np.arange(), que tem a mesma funcionalidade de range(). Para gerar arrays com valores igualmente distanciados entre si, podemos utilizar o método array.linspace(start, stop, num=50, que gera num números de um intervalo de start até stop exclusivo.

Quanto as propriedades do array, temos três principais: número de dimensões, tamanho e formato. O número de dimensões é expresso pela propriedade array.ndim e retorna a quantidade de dimensões/eixos que o seu array possui (lembrando que um array pode ser um vetor ou uma matriz, é só uma nomenclatura utilizada pela biblioteca), o tamanho, pela propriedade array.size, que retorna o produto do número de linhas pelo número de colunas e o formado, pela array.shape, que retorna uma tupla de $n$ inteiros indicando o número de elementos armazenados nas $n$ dimensões do array.

Por exemplo:

import numpy as np

odeio_matriz = np.array([[5, 2, 9], [8, 10, 13], [15, 16, 1]])

print(odeio_matriz.size)
print(odeio_matriz.ndim)
print(odeio_matriz.shape)

Output:

$> python3 <nome_do_arquivo>.py
9
2
(3, 3)

No que tange a manipulação de arrays, temos métodos como array.transpose(), que faz a transposta do array que o invocou. Dentre estes métodos, temos:

`np.inner(a, b)`

Dados dois vetores a e b de mesmo tamanho, inner executa o produto interno entre a e b.

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

print("O produto interno é:", np.inner(a, b))

Output:

$> python3 <nome_do_arquivo>.py
O produto interno é: 32

`np.dot(a, b)`

Dadas duas matrizes a e b, dot executa a multiplicação entre a e b. Para que essa operação ocorra com sucesso, temos que garantir que o número de colunas de a deve ser igual ao número de linhas de b.

import numpy as np

a = np.array([[2, 4, 6], [1, 5, 2], [9, 7, 1]])
b = np.array([[10, 11, 3], [8, 16, 1], [5, 9, 7]])

print("A multiplicação resulta em:\n", np.dot(a, b))

Output:

$> python3 <nome_do_arquivo>.py
A multiplicação resulta em:
 [[ 82 140  52]
 [ 60 109  22]
 [151 220  41]]

`array.trace()`

O trace ou, no português, traço retorna a soma da diagonal principal da matriz que o invocou.

import numpy as np

a = np.array([
    [2, 4, 6],
    [1, 5, 2],
    [9, 7, 1]
])

print("O traço da matriz 'a' é:", a.trace())

Output:

$> python3 <nome_do_arquivo>.py
O traço da matriz 'a' é: 8

`np.linalg.det(a)`

Dada uma matriz quadrada a, seu determinante pode ser calculado através da função det, localizada dentro do pacote linalg de NumPy. Se o determinante resultar em 0, significa que a matriz não admite inversa. Comumente, det retornará um número de ponto flutuante que atinge o limite de precisão de Python. Nesses casos, é válido utilizar a função np.round() para arredondar o resultado ao seu inteiro mais próximo.

import numpy as np

a = np.array([
    [2, 2, 1],
    [1, 3, 1],
    [1, 2, 2]
])

determinante = np.linalg.det(a)

print("O determinante de 'a' é:", np.round(determinante))

Output:

$> python3 <nome_do_arquivo>.py
O determinante de 'a' é: 5.0

Se não tivessemos arredondado o determinante, seu resultado seria $4.999999999999999$ .

`np.linalg.inv(a)`

Dada uma matriz quadrada a, o inverso de a pode ser calculado através da função inv, também dentro de linalg. Como a inversão de uma matriz depende do determinante da mesma ser diferente de 0, usaremos a matriz do exemplo anterior.

import numpy as np

a = np.array([
    [2, 2, 1],
    [1, 3, 1],
    [1, 2, 2]
])

inversa = np.linalg.inv(a)

print("A inversa de 'a' é:\n", inversa)

Output:

$> python3 <nome_do_arquivo>.py
A inversa de 'a' é:
 [[ 0.8 -0.4 -0.2]
 [-0.2  0.6 -0.2]
 [-0.2 -0.4  0.8]]

A biblioteca NumPy dispõe de inúmeros métodos e funções para manipular matrizes. Dito isso, leia a documentação e, se possível, não se restrinja a somente uma fonte de conteúdo. Existem diversas bibliotecas, cada uma com sua aplicação e vantagem.

Aqui e agora, espero que você tenha compreendido os conceitos de listas e matrizes em Python, bem como suas principais funcionalidades e operações. As listas são estruturas de dados extremamente versáteis, permitindo armazenar elementos de diversos tipos e tamanhos, e possuem diversas operações que facilitam sua manipulação e análise. Já as matrizes, apesar de serem estruturas mais específicas, são muito úteis para representar dados de duas ou mais dimensões, como imagens, tabelas, entre outros. Os horizontes se expandirão à medida em que novos desafios surgem.

Python: Imports e Bibliotecas

Gustavo Soares — Fri, 12 May 2023 21:11:18 +0000

Se você já conhece um pouco sobre o mundo da programação, deve saber que, na maioria dos casos, um só arquivo não será o suficiente para escrever seu programa, exceto se você escrever 700 linhas em um único arquivo (não faça isso, por favor). A modularidade e reutilização de código são fundamentais em qualquer linguagem de programação. Em Python, podemos atingir esse objetivo importando pacotes, módulos e bibliotecas. A importação de módulos permite que os desenvolvedores acessem funções, variáveis e classes criadas em outros arquivos e os utilizem em seus próprios programas. Já a importação de bibliotecas oferece uma ampla variedade de recursos prontos para uso, como algoritmos de aprendizado de máquina, visualização de dados, manipulação de arquivos, entre outros.

Imports e mais imports

Importando conteúdos

Para fazer uso de bibliotecas e fatores externos ao arquivo atual de código, devemos importar esses conteúdos através da sintaxe



import <nome_do_conteudo>

no começo do arquivo, onde nome_do_conteudo refere-se a qualquer unidade de código que pode ser exportada de um lugar para outro no programa. Dentre essas unidades, temos principalmente os módulos, os pacotes e as bibliotecas.

Na teoria, qualquer arquivo python já é um módulo, portanto, se você criar outro arquivo e precisar chamar uma função ou variável localizada nele, basta importá-lo utilizando a chamada import <nome_do_arquivo> sem a extensão “.py”. Tome o exemplo:

Estamos criando um módulo que realiza cálculos para o nosso programa. Para tal, crie o arquivo calculo.py e insira o seguinte conteúdo nele:



# calculo.py

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

def subtrair(a, b):
    return a - b

São apenas duas funções, uma soma e a outra subtrai. Agora, no arquivo que você irá executar, chame o módulo através do nome do arquivo e use suas funções. As funções se ligam ao nome do módulo importado por uma notação de ponto . onde se escreve <nome_do_modulo>.funcao(). Veja o código abaixo:



import calculo

print(calculo.somar(1, 2))

Agora execute o programa e veja se o output equivale a esse:



$> python3 <nome_do_arquivo>.py
3

Assim, você criou um módulo, importou em outro arquivo e chamou uma de suas funções. Com esse conceito, aprendemos uma nova formula de encapsulamento e modularização de código.

Você pode, ainda, importar uma função específica do módulo/pacote desejado utilizando uma sintaxe similar a anterior:



from <modulo> import <nome>

Diferente de Javascript e outras linguagens, Python segue uma ordem de busca para achar módulos importados:

Procura nó diretório em que o script que importa está localizado;
Em caminhos localizados na variável de ambiente PYTHONPATH. Ela pode ser acessada através do módulo sys chamando sys.path;
Em um diretório de instalações da linguagem;

Caso sua biblioteca tenha um nome muito grande ou desconfortável de escrever o tempo todo, é possível dar um “apelido” para a importação através da sintaxe as. Do exemplo do módulo calculo.py, podemos apelidar o módulo a fim de escrever menos:



import calculo as c

print(c.somar(1, 2))

Tome muito cuidado com os nomes escolhidos para apelidos, eles podem se tornar pouco intuitivos e difíceis de ler. Um exemplo disso seria você apelidar a biblioteca string de macarrao. Faz sentido? Óbvio que não.

A função `dir(obj=None)`

Cada módulo criado tem sua própria assinatura, denotada por uma tabela privada de símbolos que dita cada objeto daquele módulo. Quando importamos um módulo x através de import x, estamos inserindo a tabela de símbolos de um módulo em outro.

Para saber o que está na tabela de símbolos do módulo atual, podemos fazer uso da função dir, que retorna uma lista de todos os símbolos especificados em obj. Se não for passado nenhum valor como parâmetro, a função retornará uma lista contendo a tabela de símbolos de um módulo.

Toda instrução que possa ser passada como parâmetro tem uma tabela privada de símbolos, incluindo variáveis, funções, classes e afins. Logo, qualquer valor dentro dessa categoria pode ser passado como parâmetro para dir.

Por exemplo:



x = 10
print(dir(x))

O código acima declara uma variável x, que recebe 10 e escreve no terminal sua tabela de símbolos. Como seria a tabela de símbolos de um inteiro?



$> python3 <nome_do_arquivo>.py
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', 
'__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', 
'__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__',
 '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__',
 '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', 
'__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', 
'__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', 
'__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', 
'__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', 
'__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 
'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 
'numerator', 'real', 'to_bytes']

Maluquice? Um pouco. Na verdade, a tabela de símbolos de uma variável inteira é o conjunto de todas as funções e propriedades que fazem parte do módulo do tipo int específicado em tempo de projeto da linguagem, ou seja, essa é a lista que todo inteiro possui como base. Todos esses símbolos podem ser acessados através da notação de ponto ..

Módulos como scripts

Bom, como sabemos, Python não requer uma função main para executar um programa. Isso porque main está impllícita no código e é gerada em tempo de execução dentro do arquivo invocado por python3. Logo, todo e qualquer arquivo python pode ser considerado um script executável.

Por exemplo, eu tenho dois arquivos: main.py, o arquivo que criei para ser o executável, e biblioteca.py, um módulo a ser importado. Suponhamos que o conteúdo de biblioteca.py seja o seguinte:



frase = "cheio de papinho gostoso"

def printa_lista(lista):
    for el in lista:
        print(el)

Podemos simplesmente fazer python3 biblioteca.py e executar o arquivo como se nada houvesse, mas isso não produziria nenhum retorno. O código cria objetos, mas não os executa. No caso, se quisermos um retormo, basta usar print e invocar a função printa(lista).



frase = "cheio de papinho gostoso"

def printa_lista(lista):
    for el in lista:
        print(el)

print(frase)
printa_lista([1, 2, 3, 4])

E assim teremos o output:



$> python3 biblioteca.py
cheio de papinho gostoso
1
2
3
4

Porém, entretanto, todavia, isso também gera output quando esse arquivo é importado por main, já que todo e qualquer símbolo é passado de um arquivo para outro. Talvez esse não seja o comportamento ideal, a menos que você queira outputs rolando soltos em toda a sua estrutura de arquivos. A partir dessa necessidade, podemos definir uma condição especial para o arquivo caso ele seja o executável. Se é uma condição, obviamente devemos usar if.

Quando um arquivo .py é importado como módulo, o interpretador Python gera uma variável especial __name__ que recebe o nome do módulo. No entanto, se o tal arquivo .py é executado como um script por si só (ou seja, ele é o escolhido da vez pela CLI), essa variável especial __name__ recebe a string "__main__". Dito isso, agora podemos diferenciar um módulo qualquer do arquivo que receberá a função main. Adaptando biblioteca.py às nossas necessidades:



frase = "cheio de papinho gostoso"

def printa_lista(lista):
    for el in lista:
        print(el)

if (__name__ == "__main__"):
    print(frase)
    printa_lista([1, 2, 3, 4])

Logo, se esse arquivo for o script executavel a receber main, ele escreverá frase e executará a função. Se não, será tratado como módulo.

Ter o comportamento de módulos como script é extremamente útil especialmente para testes, pois cada módulo pode ser visto como uma unidade funcional por si só, o que facilita a implementação de testes unitários.

Pacotes em Python

Além dos módulos e das bibliotecas nativas como opções de modularizar funcionalidades, também temos os pacotes. Um pacote é uma coleção de módulos que compartilham um mesmo diretório e, geralmente, um mesmo objetivo. Isso permite a organização e modularização de código de forma mais clara e estruturada.

Suponha que você esteja desenvolvendo uma aplicação grande que possui inúmeros módulos. A medida que o número de módulos cresce, a dificuldade de manutenção também cresce junto. Imagina ter os módulos de autenticação, pagamento e interação com banco de dados juntos em uma só estrutura linear? Complicado, hein!

Para tal, temos os pacotes. Para criar um pacote em Python, é necessário criar uma pasta que conterá todos os módulos relacionados dentro dessa pasta. Os arquivos dentro de uma pasta são comumente associados entre si por contexto ou funcionalidade. Por exemplo, uma pasta com o nome “usuário” terá funcionalidades que remetem aos casos de uso do usuario no sistema.

Pacotes podem ser vistos como uma versão de estrutura hierárquica dos módulos, já que também usam notação de ponto, mas se organizam por pastas. Da mesma forma que módulos evitam colisões entre variáveis com a modularização, pacotes evitam as colisões entre nomes de módulos, pois estão um nível acima na hierarquia de organização. Tome como exemplo a estrutura abaixo:

Temos um diretório pacote com dois módulos arquivo1.py e arquivo2.py com os seguintes conteudos, respectivamente:



# arquivo1.py

def fala_oi():
    print("oi do primeiro módulo")

frase_do_dia = "água mole em pedra dura, tanto bate até que fura"



# arquivo2.py

def fala_tchau():
    print("tchau do segundo módulo")

Dadas essas informações, se o diretório pacote estiver em uma localização (caminho no sistema de arquivos) que não entre em conflito com outros ou com a variável de ambiente PYTHONPATH, então você pode referenciar os dois módulos através da notação de ponto. Observe a importação abaixo em main.py:



import pacote.arquivo1 as a1
import pacote.arquivo2 as a2

a1.fala_oi()
a2.fala_tchau()

Bibliotecas

A importação de bibliotecas é uma das características mais poderosas do Python. Ao importar bibliotecas, podemos expandir a funcionalidade do Python para além das bibliotecas nativas e pacotes do projeto e assim tornar o código mais modular e reutilizável.

Bibliotecas nativas

As bibliotecas nativas são aquelas que já vêm pré-instaladas com a instalação padrão da linguagem e do interpretador. Essas bibliotecas incluem módulos e pacotes que fornecem funcionalidades básicas para a linguagem, como operações matemáticas, manipulação de strings, entrada e saída de arquivos, entre outras.

Além disso, as bibliotecas nativas do Python são de código aberto e são mantidas pela comunidade de desenvolvedores, o que permite que qualquer pessoa possa contribuir com melhorias e correções de bugs. Tá aí a dica caso queira entender como as coisas funcionam.

Algumas das bibliotecas nativas mais comuns do Python incluem:

math: oferece funções matemáticas básicas, como cálculo de raiz quadrada, exponenciação e trigonometria.
string: fornece funcionalidades para manipulação de strings, como a formatação de strings e busca de caracteres específicos.
os: permite a interação com o sistema operacional, como a criação de arquivos e diretórios e a manipulação de variáveis de ambiente.
datetime: oferece funcionalidades para trabalhar com datas e horários.
random: gera valores aleatórios, como números inteiros e floats.

Essas bibliotecas são essenciais para o desenvolvimento de programas em Python e, por isso, é importante ter um conhecimento básico sobre elas.

Veja o exemplo abaixo utilizando a biblioteca os:



import os

print(os.getcwd())

No código, importamos a biblioteca os e utilizamos a função getcwd(), uma abreviação para “get current working directory”, que retorna o diretório onde o script está rodando. No meu caso, o output é:



$> python3 <nome_do_arquivo>.py
/home/iugstav/dev/py/

A importação de bibliotecas é idêntica à importação de módulos, com os mesmos comportamentos de apelidos e afins.

Bibliotecas externas

A instalação de bibliotecas externas é uma etapa importante para qualquer projeto em Python que necessite de recursos adicionais para executar tarefas específicas. Embora a linguagem tenha um conjunto abrangente de bibliotecas nativas, muitas vezes é necessário utilizar recursos de terceiros para atender às necessidades de um projeto.

Existem diversas bibliotecas em Python, tanto as que são nativas da linguagem quanto as que foram criadas por desenvolvedores da comunidade. Algumas das bibliotecas mais populares em Python incluem:

NumPy: usada para manipulação de matrizes e operações matemáticas;
Pandas: utilizada para análise e manipulação de dados;
Matplotlib: usada para criação de gráficos e visualizações;

Como já foi dito algumas vezes nessa série de materiais, Python tem bastante foco em machine learning, computação científica e ciência de dados. De fato, seu ecossistema tem forte influência nisso, pois existem inúmeras bibliotecas focadas nessas áreas, inclusive as três citadas acima. Isso se dá pela portabilidade que outras linguagens têm no ecossistema da linguagem. Existem inúmeras APIs que portam código em C, FORTRAN, Rust e outras para um código compreensível para bibliotecas em Python.

Para utilizar bibliotecas externas em Python, é necessário instalá-las em seu sistema. Existem diversas maneiras de realizar a instalação de bibliotecas, sendo as mais comuns:

Utilizando o gerenciador de pacotes pip: o pip é um gerenciador de pacotes do Python que permite buscar, instalar, atualizar e desinstalar bibliotecas de forma simples e rápida. Para instalar uma biblioteca usando o pip, basta executar o seguinte comando no terminal: pip install <nome_da_biblioteca>.
Utilizando o Anaconda: o Anaconda é uma plataforma que inclui o Python e um conjunto de bibliotecas científicas populares. Ele também possui um gerenciador de pacotes próprio chamado conda, que permite instalar bibliotecas de forma semelhante ao pip.
Instalando manualmente: em alguns casos, a biblioteca pode não estar disponível no repositório do pip ou conda, ou pode ser necessário instalá-la de forma manual. Nesses casos, é necessário baixar os arquivos da biblioteca diretamente do site do desenvolvedor e seguir as instruções de instalação disponibilizadas.

Independentemente do método escolhido, é importante lembrar que algumas bibliotecas podem ter dependências em outras bibliotecas. Portanto, é recomendável verificar as dependências antes da instalação, para garantir que todas as bibliotecas necessárias estejam instaladas corretamente.

Aqui, usaremos pip e a bibliotema NumPy para manipular matrizes. Para instalar a NumPy, digite o comando no seu terminal:



pip install numpy

De acordo com a própria documentação da biblioteca, NumPy (Numerical Python) é uma biblioteca open source usada em quase todas as partes da ciência e engenharia que conta com matrizes multidimensionais e listas próprias. Usaremos ela no próximo tópico sobre matrizes.

Vimos que a modularização de código é fundamental para tornar nossos programas mais organizados e reutilizáveis, e que a utilização de pacotes pode facilitar muito esse processo. Além disso, exploramos como é possível integrar outras linguagens à Python, o que pode ser útil em áreas onde a performance é crítica.

Ao compreender e dominar o uso de bibliotecas em Python, podemos aproveitar ao máximo todo o poder e flexibilidade que a linguagem oferece, além de economizar tempo e esforço em nossos projetos.

Python: Funções

Gustavo Soares — Fri, 12 May 2023 20:59:59 +0000

Não é de hoje que códigos são escritos e reescritos constantemente. Quando programamos, nos vemos numa situação onde o mesmo trecho de código se aplica a diversas situações e, de fato, gostaríamos que assim fosse, sem ter que escrever tudo de novo o tempo todo. Aí entram as funções.

Funções são blocos nomeados de instruções que podem ser chamados e utilizados quantas vezes forem necessários, permitindo à pessoa programadora repetir o mesmo código sem a necessidade de escrevê-lo do zero.

Uma outra explicação para funções em linguagens de programação seria compará-las ao conceito matemático. Para uma função $f (x)$ , existe um conjunto $L$ finito de valores tal que

f:L\xrightarrow{}Im_f, x\in L

Sendo $Im_f$ o conjunto de possíveis valores que $f$ retornará.

As funções em Python se comportam da mesma forma e você pode criá-las através da palavra reservada def, seguida do nome da função e seus parênteses (). Além disso, funções podem retornar valores através da palavra reservada return. Nenhuma instrução da função abaixo do após o retorno será lida, então tome cuidado com seu uso.

# def <nome_da_funcao>(<parametro_1>, <parametro_2>, ...)
def faz_algo():
        #conteúdo

No trecho acima, declaramos a função faz_algo, seguida de dois pontos (:). Como Python usa indentação como marcador para distinguir escopos, utilizar dois pontos diz ao interpretador que aqui estamos criando um novo escopo para a função. Portanto, além de indentar corretamente, não se esqueça dos dois pontos.

Funções são popularmente conhecidas como abstrações de código. De fato, elas nos poupam de muita computação desnecessária, como por exemplo a função print(), que escreve uma mensagem no console. E se ela não existisse na linguagem? Eu não gosto nem de pensar nessas coisas.

Dito isso, vamos criar uma função que retorna a soma de 2 mais 2:

# def <nome_da_funcao>()
def soma_dois():
    return 2 + 2

print(soma_dois())

Ao rodar o script, receberemos o inteiro 4 como resposta e assim encapsulamos uma operação de soma do número 2 com ele mesmo. Mas e se quiséssemos criar uma função que somasse qualquer número com outro qualquer?

Passagem de Parâmetros

Comumente nos deparamos com a necessidade de usar valores externos ao escopo da função dentro dele, mas não seria prático criar uma abstração de código que depende de valores externos. Para tal, temos a passagem de parâmetros a funções.

Parâmetros são variáveis locais especificadas entre os parênteses (), no cabeçalho da função, que recebem cópias de valores externos ao escopo da função. Funções podem receber inúmeros parâmetros de diferentes tipos, contanto que sejam separados por vírgula. Como Python é uma linguagem dinamicamente tipada, não há a necessidade de explicitar os tipos na declaração de parâmetros, ou seja, eles serão descobertos em tempo de execução.

Considerando o exemplo de soma acima, façamos com que ele aceite todo tipo de inteiros para somar e não só o número 2;

# parâmetros a e b declarados dentro dos parênteses e
# separados por vírgula
def soma_dois(a, b):
    return a + b

# invocação da função, passando seus dois parâmetros
print(soma_dois(1, 6))
print(soma_dois(10, 2))
print(soma_dois(5, 20))

E o output:

$> python3 <nome_do_arquivo>.py
7
12
25

Como foi dito anteriormente, quando declaramos uma função, também declaramos um escopo. O escopo pode ser definido como um espaço léxico delimitante aos quais instruções estão associadas. Um exemplo disso são os parâmetros há pouco expliccados. Se os parâmetros são variáveis locais de uma função, então estão vinculados ao escopo e deixarão de existir na memória no fim da mesma. O mesmo serve para variáveis definidas dentro da função.

Valores Padronizados para argumentos

Podemos passar um valor base para um parâmetro contando que ele substitua o valor passado na invocação da função, assim, omitindo ele. Veja o exemplo a seguir:

def falar(mensagem, t=1):
    print(mensagem * t)

falar("Olá, Mundo!")
falar("Olá, Mundo!", 5)

A função falar recebe dois parâmetros na sua declaração: uma mensagem a ser escrita e a quantidade de vezes que a mensagem será escrita. No segundo parâmetro há uma atribuição de valores, o que nos indica que, logo na declaração, um valor já é atribuído a esse parâmetro, excluindo a necessidade de passar um valor na invocação da função. Graças a esse fato, as duas invocações da função são válidas e rodam. Veja o output:

$> python3 <nome_do_arquivo>.py
Olá, Mundo!
Olá, Mundo!Olá, Mundo!Olá, Mundo!Olá, Mundo!Olá, Mundo!

Passagem por Nomenclatura

Se você tiver uma função com diversos parâmetros e quiser especificar um ou mais deles, então você invocar a função e especificar esses parâmetros pelo nome deles em vez da ordem de passagem.

Normalmente, quando invocamos uma função, usamos a passagem posicional de parâmetros, que leva em consideração a ordem em que foram declarados no cabeçalho da função. Na passagem por nomenclatura, o que é considerado é o nome do parâmetro. Observe o exemplo abaixo:

def mostra_valor(a, b=5, c=10):
    print('a é', a, 'e b é', b, 'e c é', c)

mostra_valor(3, 7)
mostra_valor(25, c=24)
mostra_valor(c=50, a=100)

E o seu output:

$> python3 <nome_do_arquivo>.py
a é 3 e b é 7 e c é 10
a é 25 e b é 5 e c é 24
a é 100 e b é 5 e c é 50

A função mostra_valor tem somente um parâmetro sem valor padrão, seguido de outros dois com valores padrão. Na primeira invocação mostra_valor(3, 7), o parâmetro a recebe 3, b recebe 7 e c mantém seu valor padrão, pois não foi passado nenhum outro parâmetro. Na segunda invocação mostra_valor(25, c=24), o parâmetro a recebe o valor 25 devido ao fator posicional da passagem de valores, b mantém seu valor padrão e c recebe 24 graças à passagem por nomenclatura. Na terceira invocação mostra_valor(c=50, a=100), o parâmetro c recebe 50 por nomenclatura, a recebe 100 também por nomenclatura e b mantém seu valor padrão.

Recursão

De forma rasa e informal, a recursão na programação pode ser considerada como a repetição de um processo e, portanto, pode ser definida como um processo que chama a si mesmo direta ou indiretamente até que alcance uma condição de término. Mas como que esse processo se repete? É um laço de iteração?

A recursão se aplica diretamente a funções, pois é o único bloco de processamento que pode chamar a si mesmo durante sua execução. Uma função recursiva em sua integridade aplica um algoritmo de Divisão e Conquista (O que é Divisão e Conquista?), que consiste em dividir de forma recursiva um problema grande em problemas menores até que o problema seja resolvido. Ou seja, a função sempre vai retornar ela mesma com uma versão mais simples do problema até chegar na solução.

Consideremos que você, pessoa programadora, tem que determinar a soma dos $n$ primeiros números naturais ( $N\N$ ). Existem diversas maneiras de fazer isso, mas a mais simples seria sair somando os números de 1 até $n$ , parecendo com isso:

f (n) = 1 + 2 + 3 + 4 + ... + n

Imagina se $n$ for um número na casa dos milhares. Bastante trabalhoso, né? Nesse caso temos a opção recursiva para resolver esse problema. Veja a seguir:

\begin{cases} f(n) = 1 & \text{se } n=1 \\ n + f(n-1) & \text{se } n \gt 1 \end{cases}

A única diferença entre os dois métodos é que a função $f$ está sendo chamada dentro de sua própria função, estabelecendo uma condição de recursão.

Ainda ficou confuso? Observe os dois exemplos abaixo, onde um implementa um for..in loop e o outro, a recursão:

def sequencia_decolar(contagem):
    for numero in range(contagem, -1, -1):
        if numero == 0:
            print("Decolar!!!")
        else:
            print(numero)

sequencia_decolar(5)

No trecho acima, criamos uma contagem regressiva para a decolagem de um foguete com o for e um laço condicional para caso a contagem chegue a 0. Agora veja esse mesmo caso com outros olhos.

def sequencia_decolar(contagem):
    if contagem == 0:
        print("Decolar!!!")
        return
    else:
        print(contagem)
        return sequencia_decolar(contagem - 1)

sequencia_decolar(5)

Onde a variável local contagem representa de onde a contagem deve começar.

No exemplo recursivo vimos que o retorno sequencia_decolar(contagem - 1)
é o mesmo problema, porém simplificado, o que caminha para uma pilha de
funções onde a anterior, mais complexa, não será resolvida até que a
próxima, mais simples, seja. Por exemplo, se a variável contagem for 5, teremos esse comportamento:

## Invocação da função sequencia_decolar(5);

5 é igual a 0? Não.
Então imprima "5" no terminal e retorne sequencia_decolar(5 - 1);

4 é igual a 0? Não.
Então imprima "4" no terminal e retorne sequencia_decolar(4 - 1);

3 é igual a 0? Não.
Então imprima "3" no terminal e retorne sequencia_decolar(3 - 1);

2 é igual a 0? Não.
Então imprima "2" no terminal e retorne sequencia_decolar(2 - 1);

1 é igual a 0? Não.
Então imprima "1" no terminal e retorne sequencia_decolar(1 - 1);

0 é igual a 0? Sim.
Então imprima "Decolar!!!" e retorne vazio;

Tipos de Recursão

Entendemos como a recursão funciona, agora entenderemos onde cada tipo de recursão se encaixa.

Como mencionado anteriormente, a recursividade pode aparecer direta ou indiretamente:

Forma direta: É formada pela mesma estrutura de comandos e uma chamada a si mesma durante seu bloco de execução.
Forma indireta: Nesse caso podem existir n funções e todas dependem de todas, gerando uma cadeia de dependências
até que a condição de término seja atingida. Veja o exemplo abaixo:
```
def impar(n):
    if n == 0:
        return False
    else:
        return par(n - 1)

def par(n):
    if n == 0:
        return True
    else:
        return impar(n - 1)

print(odd(5))  # Output: True
```
No exemplo acima, odd() chama even() e even() chama odd(). Isso cria uma recursão indireta, pois a função odd() não chama a si mesma diretamente, mas chama a função even(), que por sua vez chama odd() novamente. A recursão continua até que a condição de parada seja alcançada. Neste caso, a recursão termina quando o valor de n é zero. Tudo que o exemplo faz é dizer se um número é par ou ímpar através de recursão.

Memória na Recursividade

Sabemos que a recursividade aumenta bastante a legibilidade do nosso código, mas nem tudo é um mar de rosas, principalmente quando se trata de memória na recursão. Como será que funciona a recursividade por debaixo dos panos?

Numa função recursiva, enquanto a chamada não atinge a condição de término, empilhamos uma invocação na pilha. Quando a condição de término é atingida, as funções empilhadas são executadas uma por uma, da última empilhada até a primeira, até que não haja mais função a ser executada.

Quando comparadas com laços de iteração, funções recursivas consomem mais memória que laços, visto que cada chamada à função consome mais memória na stack e um loop não requer espaço extra. Dito isso, pense bem antes de aplicar recursividade no seu projeto, principalmente se desempenho for um fator crucial.

Alguns pontos a serem ressaltados ao comparar as duas situações são:

Iterações terminam quando uma condição se torna falha. As recursões, quando se chega no caso mais básico;
Iterações não alocam espaços extras na stack;
Recursões fornecem maior legibilidade ao código. Uma vez que se compreende o processo, fica fácil proceder;

Python: Conceitos e Palavras Reservadas

Gustavo Soares — Fri, 12 May 2023 20:50:23 +0000

Post anterior

As linguagens de programação precisam de instruções sintaticamente corretas para serem executadas e assim criar um programa funcional. Em Python não seria diferente, até porque ainda não existe programação com a mente, né, então precisamos escrever o código. Mas que tipos de instruções são essas?

Python é uma linguagem extremamente simples, com poucas palavras reservadas e mesmo assim tem um impacto absurdo em todas as áreas que ela atinge. O alto nível de abstração propõe um modelo de fácil escrita e compreensão até para leigos (cof, cof) e é por isso que é tão bem-quista pelos programadores. Passeando pelas instruções da linguagem, temos:

Fluxos de Controle

Nós vimos um exemplo de fluxo de controle no último material, na parte de tipos de dados predefinidos, mas aqui veremos como essa instrução se comporta.

Quando estamos planejando uma ação, pensamos num caminho linear a ser seguido. No entanto, um só caminho não é o suficiente, pois talvez se torne necessário mudar a forma como as coisas funcionam. Por exemplo, você deve mandar “Bom dia”, “Boa tarde” ou “Boa noite” no grupo da família? Não sei, depende do horário. Aí que entram as estruturas de controle.

A Instrução `if`

Esse pedaço de comando serve para avaliar se uma condição é verdadeira. Se for, ele executará um fluxo alternativo de código. Se não, ele processará outro bloco de controle else ou seguirá com a linearidade do código. A instrução else é opcional.

Por exemplo, observe o código abaixo:

# número a ser adivinhado
numero_secreto = 13

# número digitado pelo usuáriopython
input_usuario = int(input("Digite o seu número: "))

# instrução if
if input_usuario == numero_secreto:
    # começo do fluxo alternativo
    print("Que isso, hein! Acertou!")

else:
    # bloco else de condição não atendida
    print("Eita! Tá errado.")

E o output é:

$> python3 <nome_do_arquivo>.py
Digite o seu número: 20
Eita! Tá errado.

$> python3 <nome_do_arquivo>.py
Digite o seu número: 13
Que isso, hein! Acertou!

O programa acima consiste num código de adivinhação. Nele, criamos a variável numero_secreto para armazenar o nosso número a ser achado 13 e, logo em seguida, perguntamos o usuário qual número ele deseja tentar a sorte. Então, criamos uma estrutura de controle cuja condição verifica se o número digitado pelo usuário corresponde com o número armazenado em numero_secreto. Se sim, então ele escreve uma mensagem e se não, escreve outra. Mas ainda está muito simples… Que tal encadearmos mais condições para verificar se o número é maior ou menor?

Tal requerimento pode ser feito com a instrução elif, que encadeia blocos condicionais de código após um if.

# número a ser adivinhado
numero_secreto = 29

# número digitado pelo usuário
input_usuario = int(input("Digite o seu número: "))

# instrução if
if input_usuario == numero_secreto:
    # começo do fluxo alternativo
    print("Que isso, hein! Acertou!")

elif input_usuario < numero_secreto:
    print("Chutou baixo! Aumenta esse valor aí.")

elif input_usuario > numero_secreto:
    print("Muito alto, colega. De novo!!")

E agora no output temos:

$> python3 <nome_do_arquivo>.py
Digite o seu número: 20
Chutou baixo! Aumenta esse valor aí.

$> python3 <nome_do_arquivo>.py
Digite o seu número: 54
Muito alto, colega. De novo!!

Assim, criamos uma estrutura de controle completamente funcional. Ainda podemos combinar Álgebra Booleana com os blocos if para criar instruções encadeadas com as palavras reservadas or e and.

Estruturas de repetição

A Instrução `while`

Essa instrução nos permite executar repeticamente um bloco de código enquanto a condição inicial dele for verdadeira. Podemos chamar a instrução while loop. A sintaxe deste loop pode ser resumida como:

while <condicao>:
        #bloco de código a ser repetido

Olhando o exemplo da instrução if, eu gostaria que esse programa rodasse até que o usuário adivinhasse o número. Para isso, podemos implementar a estrutura de repetição while e, quando o usuário acertar o número secreto, negar a condição inicial, como no código abaixo:

# número a ser adivinhado
numero_secreto = 13
esta_rodando = True

while esta_rodando == True:
    # número digitado pelo usuário
    input_usuario = int(input("Digite o seu número: "))

    # instrução if
    if input_usuario == numero_secreto:
        # começo do fluxo alternativo
        print("Que isso, hein! Acertou!")
        esta_rodando = False

    elif input_usuario < numero_secreto:
        print("Chutou baixo! Aumenta esse valor aí.")

    elif input_usuario > numero_secreto:
        print("Muito alto, colega. De novo!!")

print("Acabou o jogo")

E o novo output:

Digite o seu número: 10
Chutou baixo! Aumenta esse valor aí.
Digite o seu número: 15
Muito alto, colega. De novo!!
Digite o seu número: 13
Que isso, hein! Acertou!
Acabou o jogo

Até acertarmos o número, o código estava rodando loop, executando o mesmo bloco de processamento. Quando acertamos, o bloco de código referente ao if de acerto executado, o resto do código foi lido e, logo no próximo loop, a condição foi negada.

A Instrução `for..in`

A estrutura de repetição for..in é outra instrução de loop, mas em vez de rodar até uma condição ser negada, ela roda dentro de um intervalo de números inteiros. Com o intervalo estabelecido, o bloco de processamento declarado dentro do for se repete até que o fim do intervalo seja alcançado.

Para criar um intervalo sem valores predefinidos, temos a função range() que recebe dois parâmetros: o começo do intervalo e o seu fim, ambos inteiros. A função pode, ainda, receber somente um parâmetro, que é o fim do intervalo. Nesse caso, a função começaria a contar do primeiro valor possível até o fim passado. O intervalo gerado pela função range é exclusivo, ou seja, ele conta o fim do intervalo - 1.

Chamamos essa ato de percorrer um intervalo finito de iteração. Portanto, loop for..in itera sobre um intervalo. Segue um exemplo dessa repetição abaixo:

resultado = 0

# declaração do loop
for numero in range(1, 10):
    resultado += numero

print(resultado)

E o output:

$> python3 <nome_do_arquivo>.py
45

Além de intervalos gerados, podemos utilizar listas de inteiros ou até strings. Mas como vamos iterar sobre strings se uma string não é um intervalo de números? É aí que tá a brincadeira.

As strings em python são listas de caracteres, logo ela tem uma posição inicial e uma final, isto é, um intervalo. A partir daí o que Python implicitamente faz é acessar a posição da string referente ao número do intervalo. Vejamos um exemplo disso abaixo:

mensagem = "Olá Mundo!"

for letra in mensagem:
    print(letra)

No caso acima, mengasem é interpretada como um range da posição 0 até o tamanho da string e letra se torna o elemento da lista na posição correspondente ao número do range. Por exemplo, se mensagem criasse o intervalo [0, 5] e eu estivesse no momento 3 do intervalo, letra seria mensagem[3].

A Instrução `break`

A instrução break é usada para sair de uma estrutura de repetição no meio de sua execução, mesmo se o intervalo não foi finalizado ou a condição não foi negada.

A Instrução `continue`

A instrução continue é usada para pular o resto das instruções restantes de um loop e pular para a próxima iteração do mesmo.

Aqui, terminamos o básico sobre instruções em Python e começamos a utilizar os conceitos apresentados para formar scripts de grande impacto. Condições e iterações são só o dedo mindinho do que a linguagem oferece. Um passo de cada vez até a elegância.

Próximo post

Python: Tipos

Gustavo Soares — Wed, 03 May 2023 18:41:14 +0000

Post anterior

As linguagens de programação são um meio para expressar instruções para um computador realizar uma determinada tarefa. Um elemento fundamental dessas linguagens são os tipos de dados, que permitem representar informações de diferentes formas, tal como números, textos, o cachorro da vizinha, entre outros. A escolha dos tipos de dados pode ter um grande impacto na clareza e eficiência do código. Por exemplo, uma linguagem que permite a manipulação precisa de números reais ( $R\Reals$ ) pode ser ideal para cálculos científicos.

Python, por sua vez, possui tipagem dinâmica e forte, mas o que isso nos diz? Para entender esses conceitos, primeiro vamos entender o que vem a ser um sistema de tipos.

Tipagem

Bom, um sistema de tipos é feito de tipos. Só por essa frase eu já merecia um Nobel.

Brincadeiras à parte, na verdade, para entender os sistemas de tipos, temos que dar mais um passo para trás e entender o que seria a sintaxe e a semântica de uma linguagem.

A sintaxe dita as regras que instruções devem ser seguir para que um programa de uma determinada linguagem as execute corretamente. Um exemplo disso é a criação de variáveis em Python, onde você declara seu nome, seguido de um sinal de igual = e o valor que será atribuido à variavel.

# <nome_da_variavel> = <valor>
usuario = "Fulaninho"
nota = 8

Podemos ver claramente uma estrutura a ser seguida para que o interpretador entenda que estamos criando uma variável e atribuindo um valor a ela. Qualquer coisa fora dessa regra é tratado como erro sintático quando o programa for executado.

A semântica, por sua vez, atribui um significado e dita o comportamento por trás desses termos da linguagem. A semântica do exemplo citado acima seria:

1. Uma variável de nome `usuario` é criada;
2. a string `Fulaninho` é atribuída a essa variável;
3. Outra variável de nome `nota` é criada;
4. O número 8 é atribuído a ela;

Partindo dos conceitos de sintaxe e semântica, podemos tomar as seguintes afirmações:

Matematicamente falando, o número 8 faz parte do conjunto dos inteiros ( $Z\Z$ );
No trecho de código acima, a variável nota recebe o valor $\in \Z$ ;
Logo, se $n o t a = 8$ e $\in \Z$ , logo $\in \Z$ ;

Decorrente das afirmações, foi visto que a variável é inteira e, com isso, podemos afirmar que sua faixa de valores está restrita ao conjunto dos inteiros. Dito isso, podemos inferir que um tipo trabalha como uma regra, adicionando semântica a algum dado. Se um tipo é uma regra, então um sistema de tipos pode ser compreendido como um conjunto dessas regras.

Quando dizemos que o sistema de tipos de Python é dinâmico e forte, isso implica diretamente na forma como escrevemos e entendemos código.

O dinamismo de um sistema de tipos em uma linguagem de programação nos diz que os tipos atribuídos aos termos da linguagem podem mudar ao longo da execução do programa, ou seja, não há um mecanismo de verificação estática de tipos. O oposto de um sistema de tipos dinâmico é chamado de sistema de tipos estático, onde a vinculação de tipos aos elementos do código ocorre numa etapa antes da execução.

Já a força de um sistema de tipos está atrelada a intensidade da ligação de um tipo com algum elemento da linguagem. Viajei legal? Então pensa comigo: se um tipo adiciona semântica a um termo, esse vínculo pode ter uma força, tal como forte ou fraco, e essa força vai medir o comportamento desse vínculo ao longo da execução do programa.

Podemos categorizar um vínculo de tipo-termo como forte quando durante a execução, o termo sofre poucas ou nenhuma alteração de significado, ou seja, seu tipo se mantém sem conversões implícitas. Já um vínculo fraco seria o oposto, podendo produzir código com diversas conversões implícitas de tipo e resultados imprevisíveis.

Na verdade, esse debate sobre tipagem forte ou fraca se refere à segurança de um sistema de tipos, já que tudo que é falado é se seus tipos serão convertidos sem sua permissão ou não. Uma definição de “segurança” que se encaixa nesse contexto é:

Segurança: Se qualquer tentativa de interpretar mal os dados é pega em tempo de compilação ou gera um erro específico para isso em tempo de execução

Às vezes, linguagens ou ferramentas pouco seguras são necessárias e o contrário também é válido. Uma possibilidade não exclui a outra e se excluísse eu não estaria aqui falando sobre esse conceito.

Tipos Predefinidos em Python

Existem vários tipos de dados que podem ser usados para representar diversos tipos de informações. Dentre eles, temos os tipos de dados predefinidos da linguagem e os definidos pelo usuário. Dentre os predefinidos, temos:

Números

Os números em Python podem ser inteiros, de ponto flutuante ou complexos. Os números inteiros são representados pelo tipo int, enquanto os números de ponto flutuante são representados pelo tipo float. Os números complexos são representados pelo tipo complex, que consiste em uma parte real e uma parte imaginária.

O tipo int é usado para representar números inteiros positivos ou negativos ( $Z\Z$ ). Python é capaz de lidar com inteiros de tamanho arbitrário, o que significa que não há limite para o tamanho do número que pode ser armazenado. Isso é útil para cálculos que envolvem números muito grandes.

O tipo float é usado para representar números reais ( $R\R$ ), com casas decimais. Embora os números de ponto flutuante tenham uma precisão limitada, eles são úteis para cálculos que envolvem frações decimais, como cálculos financeiros ou científicos.

O tipo complex é usado para representar números complexos ( $C\Complex$ ), que consistem em uma parte real e uma parte imaginária. Esses números são úteis para cálculos que envolvem fases ou oscilações, como em processamento de sinais ou imagens.

Abaixo temos exemplos de cada um dos tipos:

# int
idade = 23 + 2

# float
nota_p1 = 4.6

# complexos podem ser definidos dos dois jeitos abaixo
complexo = 2 + 3j
complexo_funcao = complex(1, 2)  # 1 + 2j

Booleanos

Os valores booleanos em Python são True (verdadeiro) e False (falso). Esses valores são usados para avaliar condições em programas Python. Por exemplo, se uma condição for verdadeira, um determinado bloco de código será executado. Se a condição for falsa, o bloco de código será ignorado. Quem nunca fez gambiarra em condicionais, que atire a primeira pedra!

Os valores booleanos também são usados para fazer comparações entre valores. Por exemplo, se o valor de uma variável é maior que outro, a expressão retornará True. Caso contrário, retornará False.

passou_em_calculo = True

if passou_em_calculo == True:
    print("Parabéns! Você passou!!!")
else:
    print("Eita, colega... E vamos de chorar.")

No trecho de código acima, temos uma variável passou_em_calculo que recebe o booleano True. Logo em seguida, temos uma condicional que escreve uma mensagem no terminal se a variável for True e outra mensagem se for False. Se você rodar o código abaixo, terá o resultado:

$> Parabéns! Você passou!!!

Sequências

As sequências em Python são usadas para representar uma coleção ordenada de valores. Existem três tipos principais de sequências em Python: listas, tuplas e strings.

As listas são os arrays de Python. São coleções mutáveis de valores ordenados, que podem ser alteradas adicionando, removendo ou modificando os elementos da lista. As listas são definidas entre colchetes ([]).

As tuplas são semelhantes às listas, mas são imutáveis. Isso significa que uma vez que uma tupla é criada, seus elementos não podem ser alterados. As tuplas são definidas entre parênteses (()).

As strings são sequências de caracteres que representam texto. As strings são imutáveis em Python, o que significa que uma vez criada, uma string não pode ser alterada. Isso significa que quando você altera uma string, na verdade está criando uma nova string com as modificações desejadas. As strings são definidas entre aspas simples ('') ou duplas (""). Strings podem, ainda, ser escritas em diversas linhas utilizando aspas triplas (””” ”””).

Abaixo temos exemplos de sequências:

# lista de strings
compras_mercado = ["banana", "aveia", "pão"]

# tupla de floats
coordenadas = (-23.588254, -46.632477)

# string
mensagem = "viu como é fácil criar sequências?"

Você pode, ainda, escrever cada uma dessas variáveis no terminal com a função print(), basta escrever o nome da variável desejada entre os parênteses.

Sets ou Conjuntos

Os conjuntos em Python são usados para representar uma coleção não ordenada e mutável de valores únicos. Os conjuntos são definidos entre chaves ({}). O set em si é mutável, mas seus elementos devem ser imutáveis

O trecho abaixo ilustra a criação de um Set pela função set() com o valor que será convertido num set entre os parênteses.

# lista de inteiros
lista_repetida = [1, 1, 2, 2, 3, 4, 4]

# set a partir de uma lista
set_unico = set(lista_repetida)

print(set_unico)

Se você rodar o código, terá o resultado:

$> {1, 2, 3, 4}

Dicts ou Dicionários

Os dicionários em Python são usados para representar uma coleção de pares chave-valor. Cada chave deve ser única e é associada a um valor. Os dicionários são definidos entre chaves ({}), com a chave se separando do valor por por dois pontos (:) e cada par chave-valor se separando por vírgula.

O exemplo abaixo ilustra a criação de um Dict:

dados_jogador = {
    "nome": "Pedro",
    "idade": 25,
    "apelido": "queixada",
    "time": "flamengo"
}

print(dados_jogador)

O resultado deste exemplo é:

{'nome': 'Pedro', 'idade': 25, 'apelido': 'queixada', 'time': 'flamengo'}

Próximo post

Python: O Começo de Tudo

Gustavo Soares — Wed, 03 May 2023 18:22:36 +0000

Próximo post

Disclaimer

Este material não retrata a instalação da linguagem, logo, é destinado a quem já instalou Python e deseja explorar suas características e fundamentos. Assumo que a instalação da linguagem e a configuração do ambiente já foram realizadas.

Caso não tenha a feito, pode acompanhar um dos links abaixo:

Todos os tópicos apresentados nesta introdução serão revisitados com maior aprofundamento a medida que os conteúdos forem apresentados. Caso não entenda algum tópico, não se desespere! Você não é obrigado a saber tudo sobre qualquer coisa. Procure saber o termo ou o tópico específico e, após entender, volte a ler esse material, pois um conteúdo se liga a outro e assim por diante.

Dito isso, seguimos com o material.

Introdução

Houve inúmeras mudanças na computação das últimas décadas até hoje. As máquinas ficaram mais poderosas, a complexidade dos softwares aumentou e novos desafios foram surgindo. Com isso, foram se criando ambientes onde a produtividade de quem estivesse desenvolvendo o software era mais valorizada em prol da performance bruta da execução.

Seguindo esse raciocínio, seria inviável pensar em produtividade e ainda assim escrever Assembly ou C. A galera só queria um javascript da vida que suprisse as necessidades do software sem sacrificar o desenvolvedor! Foi nesse contexto que nasceu Python.

Python é uma linguagem de script (O que é uma linguagem de script?) de alto nível, multiparadigma, interpretada e dinamicamente tipada cuja filosofia preza pela simplicidade e legibilidade. Python é aquela linguagem que torna tudo mais fácil – inclusive te humilhar lembrando daquele seu programa em C++ que você gastou 3 noites em claro e usou 510 linhas (talvez eu tenha levado pro pessoal) para fazer. Brincadeiras à parte, Python é extremamente poderosa nas áreas que ela tange, que são principalmente computação científica, Ciência de Dados e desenvolvimento de websites.

Embora Python sacrifique performance pensando na experiência do desenvolvedor, isso não significa que a linguagem seja uma lesma. As comparações são comumente feitas com linguagens de médio nível com propósitos diferentes aos de Python, como C++ e Java, que atuam nas mesma áreas, mas com outras prioridades.

Sintaxe

O propósito da linguagem é ter uma sintaxe mais próxima do ser humano a fim de simplificar o processo de entendimento do código, a tão falada expressividade. Para isso, Python utiliza paravras reservadas simples e próximas do inglês, o que facilita o raciocínio criado por desenvolvedores.

Uma linguagem expressiva garante ao usuário da linguagem formas mais claras e concisas de escrever executáveis corretamente, mas fica ao cargo de quem programa escrever códigos expressivos.

Um dos aspectos mais marcantes de Python é o uso de indentação para marcar blocos de código. Diferente das linguagens que usam chaves {} ou palavras reservadas como do ... end para delimitar um escopo ou bloco de código, Python define os escopos do programa por meio tabs ou espaços no seu código. Isso torna o código mais legível e organizado, mas também cria maiores chances de quebrar o programa ao esquecer a indentação de alguma parte do mesmo. É essencial manter a consistência na hora de indentar seu programa.

Para garantir as boas práticas de desenvolvimento, existe um conjunto de princípios em Python chamado Zen of Python que nos garante que certas regras sejam seguidas para que mantenhamos nosso sistema coeso. afinal, a vida não é um morango para você ignorar as regras.

Algumas verdades do Zen of Python são:

Beautiful is better than ugly. (Bonito é melhor que feio)
Explicit is better than implicit. (Explícito é melhor que implícito)
Simple is better than complex. (Simples é melhor que complexo)

Esses princípios são guias úteis para escrever códigos mais claros e legíveis. Não se preocupe em memorizá-los de imediato; com o tempo, eles se tornarão naturais.

Execução da Linguagem

Python é uma linguagem interpretada, o que significa que não é necessário compilar o código antes de executá-lo. Em vez disso, o interpretador de Python executa o código linha por linha, o que oferece vantagens como:

Facilidade de Depuração: Você pode parar o programa a qualquer momento para examinar o estado atual e identificar erros.
Portabilidade: O código Python é executado em diferentes plataformas sem necessidade de recompilação.

No entanto, a interpretação também pode ter algumas desvantagens em relação à performance do programa. Como o interpretador precisa ler o código em tempo real, linha por linha, e executar as instruções correspondentes, a execução do código pode ser mais lenta se for comparada à execução de linguagens compiladas. Apesar da perda de performance, para muitas aplicações, como scripts de automação e prototipagem rápida, essa diferença é insignificante dado o contexto em que essas aplicações estão inseridas.

Primeiros passos

Dadas as boas-vindas, vamos escrever um programa que mostra hello world! no terminal. Se você instalou Python com sucesso, já deve ter acesso ao interpretador via terminal. Ele pode ser ativado digitando python3, python ou py, dependendo da configuração e do seu sistema operacional.

Ao digitar python3, python ou até py e pressionar a tecla enter você pode acessar o interpretador da linguagem no terminal, que interpretará seus scripts e mostrar seus resultados em seguida. Lá, você pode testar funções, listas de comandos e afins.

Com o prompt aberto, você verá a escrita >>> no início da linha com algo similar a isso:

Agora, digite o comando abaixo e, em seguida, aperte enter:

print("hello world!")

Pronto! Você acabou de escrever um script em Python que exibe uma mensagem no terminal.

Fato curioso: Caso queira muito ver os princípios do Zen of Python, você pode digitar import this nesse mesmo prompt e esse comando escreverá na tela os princípios em inglês.

Exemplo prático adicional: O código abaixo cria uma lista e exibe seus elementos no terminal.

frutas = ["maçã", "banana", "laranja"]
for fruta in frutas:
    print(fruta)

O resultado será:

maçã
banana
laranja

Pronto! Você escreveu um script em Python que mostra a mensagem hello world! no terminal. Existe uma infinidade de possibilidades no universo de Python e esse foi só o pontapé inicial para algo grandioso. Caso sinta dificuldade para assimilar os construtos ou as características da linguagem, não se desanime! O começo não é fácil, mas não se deixe levar pelo medo, afinal, só vive o propósito quem suporta o processo.

Explore bibliotecas populares como NumPy para matemática, Flask para desenvolvimento web ou Pandas para análise de dados. E lembre-se: o mais importante é continuar praticando e explorando.

Próximo post

DEV Community: Gustavo Soares

Python: Manipulação de Listas e Matrizes

Listas

Métodos de listas

list.append(value)

list.remove(value)

list.count(elem)

list.sort(reverse=False, key=None)

Slices

List Comprehension

Matrizes

Iteração e Manipulação de Matrizes

np.inner(a, b)

np.dot(a, b)

array.trace()

np.linalg.det(a)

np.linalg.inv(a)

Python: Imports e Bibliotecas

Imports e mais imports

Importando conteúdos

A função dir(obj=None)

Módulos como scripts

Pacotes em Python

Bibliotecas

Bibliotecas nativas

Bibliotecas externas

Python: Funções

Passagem de Parâmetros

Valores Padronizados para argumentos

Passagem por Nomenclatura

Recursão

Tipos de Recursão

Memória na Recursividade

Python: Conceitos e Palavras Reservadas

Fluxos de Controle

A Instrução if

Estruturas de repetição

A Instrução while

A Instrução for..in

A Instrução break

A Instrução continue

Python: Tipos

Tipagem

Tipos Predefinidos em Python

Números

Booleanos

Sequências

Sets ou Conjuntos

Dicts ou Dicionários

Python: O Começo de Tudo

Disclaimer

Introdução

Sintaxe

Execução da Linguagem

Primeiros passos

`list.append(value)`

`list.remove(value)`

`list.count(elem)`

`list.sort(reverse=False, key=None)`

`np.inner(a, b)`

`np.dot(a, b)`

`array.trace()`

`np.linalg.det(a)`

`np.linalg.inv(a)`

A função `dir(obj=None)`

A Instrução `if`

A Instrução `while`

A Instrução `for..in`

A Instrução `break`

A Instrução `continue`