Programe em Python

Python 101 - Parte 10 - Estruturas de Dados - Dicionários

2022-08-30T00:06:00+02:00

Olá!

Hoje vamos falar de uma estrutura de dados que não está presente em todas as linguagens. Esta estrutura é chamada de dicionário.

Os dicionários em Python são estruturas de dados que contém pares de chave-valor.

São parecidos com as listas, considerando que ambos são sequencias de elementos, mas o acesso a cada posição da lista é feito de forma diferente.

Caso você ainda não tenha visto os outros artigos da série Python 101, aqui estão:

Vejamos então como trabalhar com Dicionários em Python!

Para começar, vamos ver as maneiras de definir um dicionário.

Primeiro definimos um dicionário vazio:

dicionario = {}

Este dicionário pode receber valores futuramente durante a execução do programa.

Agora, imaginemos como seria montar um dicionário que relacionasse strings para os dias da semana, como ‘seg’ e ‘ter’ com números. Indispensável se você for fazer um calendário, não acha?

dias_semana = {'dom' : 0, 'seg' : 1, 'ter' : 2, 'qua' : 3,
    'qui' : 4, 'sex' : 5, 'sab' : 6}

Ao criarmos um dicionário, ele terá esta estrutura. Antes do ‘:’ temos a chave do par chave-valor, e logo após, o valor correspondente.

Mas, e se fôssemos criar um dicionário que relacionasse as letras N, L, S, O dos pontos cardeais com números?

Aposto que você já sabe a resposta! Mas, existe uma outra forma, também muito útil de gerar dicionários, e que pode ser muito importante para geração destes dicionários em tempo de execução.

Usando dict() podemos transformar listas de tuplas em dicionários. Tecnicamente seriam sequencias de sequencias, mas para o exemplo vamos usar listas de tuplas.

Se você não lembra o que é uma tupla, confira nosso post de introdução às estruturas de dados

Veja como funciona o dict():

pontos_cardeais = dict([('N', 0), ('L', 1), ('S', 2), ('O', 3)])

Você se lembra da List Comprehension que vimos no último post?

Pois bem, que tal usá-la para montar um dicionário que relaciona os inteiros de zero a dez e seus respectivos quadrados?

quadrados = dict([x, x**2 for x in range(11)])

É muito simples criar dicionário, não?

Mas… simplesmente criar os dicionários não tem utilidade nenhuma, certo?

Vejamos como acessar um valor a partir de sua chave. vamos usar o dicionário dos dias da semana. Experimente os comandos no Shell do Python!

>>> dias_semana['ter']
2
>>> dias_semana['sab']
6

Fácil, não é?

Vamos inserir alguns valores neste dicionário?

>>> dias_semana
{'qua': 3, 'dom': 0, 'sab': 6, 'sex': 5, 'seg': 1, 'qui': 4, 'ter': 2}
>>> dias_semana['Dom'] = 0
>>> dias_semana['Seg'] = 1
>>> dias_semana['Ter'] = 2
>>> dias_semana['Qua'] = 3
>>> dias_semana['Qui'] = 4
>>> dias_semana['Sex'] = 5
>>> dias_semana['Sab'] = 6
>>> dias_semana
{'qua': 3, 'dom': 0, 'sab': 6, 'Dom': 0, 'Seg': 1, 'sex': 5, 'seg': 1, 
'Qui': 4, 'Qua': 3, 'Sab': 6, 'qui': 4, 'ter': 2, 'Sex': 5, 'Ter': 2}

Num dicionário, a ordem em que os elementos aparecem não é tão importante, pois os valores são acessados principalmente através de suas respectivas chaves, e não de suas posições. Além disso, dicionários não guardam a ordem dos elementos, logo, o elemento que aparece em primeiro lugar numa execução pode não ser o primeiro em outra mesmo que a inserção tenha sido feita da mesma forma.

Caso seja necessário verificar se uma chave já se encontra no dicionário, basta fazer o seguinte

>>> 'seg' in dias_semana
True
>>> 'bla' in dias_semana
False

Bem, digamos agora que não quero mais que o dicionário tenha a versão maiúscula para o domingo.

>>> del(dias_semana['Dom])

Também é possível saber quais as chaves que já foram inseridas:

>>> dias_semana.keys()
['sab', 'seg', 'sex', 'qua', 'qui', 'ter', 'Qua', 'dom', 'Sab', 'Sex',
'Seg', 'Qui', 'Ter']

E quais os valores que há no dicionário: >>> dias_semana.values() [6, 1, 5, 3, 4, 2, 3, 0, 6, 5, 1, 4, 2]

Algo importante a se notar é que as chaves e elementos de dicionários podem ser de virtualmente qualquer tipo, com exceção das chaves que tem uma restrição. Os objetos tem que ser imutáveis.

Isto quer dizer que a lista [1, 2, 3] não pode ser uma chave de dicionário já que podemos no meio da execução alterar valores da lista. Já a tupla (1, 2, 3) que é imutável pode ser uma chave de dicionários sem problemas.

Agora, você já conhece os Dicionários do Python, esta estrutura de dados que tem tantas aplicações importantes.

Não deixe de enviar dúvidas e opiniões nos comentários abaixo!

Até o próximo post!

Python 101 - Part 10 - Data Structures - Dictionaries

2022-08-30T00:06:00+02:00

Hi!

Today we are going to talk about a data structure that is not present in all languages. This structure is called a dictionary.

Python dictionaries are data structures that contain key-value pairs.

They are similar to lists, considering that both are sequences of elements, but accessing each position in the list is done differently.

In case you haven’t seen the other articles in the Python 101 series, here they are:

So let’s see how to work with Dictionaries in Python!

To get started, let’s look at ways to define a dictionary.

First we define an empty dictionary:

dictionary = {}

This dictionary can receive values in the future during the execution of the program.

Now, let’s imagine what it would be like to build a dictionary that listed strings for the days of the week, such as ‘mon’ and ‘ter’ with numbers. Indispensable if you’re going to make a calendar, don’t you think?

weekdays = {'sun' : 0, 'mon' : 1, 'tue' : 2, 'wed' : 3,
    'thu' : 4, 'sex' : 5, 'sat' : 6}

When we create a dictionary, it will have this structure. Before the : we have the key of the key-value pair, and after that, the corresponding value.

But, what if we were to create a dictionary that related the letters N, E, S, W of the cardinal points with numbers?

I bet you already know the answer! But, there is another way, also very useful to generate dictionaries, and that can be very important for generating these dictionaries at runtime.

Using dict() we can turn tuple lists into dictionaries. Technically it should be a sequence of sequences, but we’ll use a list of tuples to illustrate that.

If you don’t remember what a tuple is, check out our Introduction to Data Structures post

Here’s how dict() works:

cardinal points = dict([('N', 0), ('E', 1), ('S', 2), ('W', 3)])

Do you remember the List Comprehension we saw in the last post?

Well, how about using it to build a dictionary that lists the integers from zero to ten and their respective squares?

squares = dict([x, x**2 for x in range(11)])

It’s very simple to create a dictionary, isn’t it?

But… just creating the dictionaries is useless, right?

Let’s see how to access a value from its key. let’s use the days of the week dictionary. Try the commands in the Python Shell!

>>> weekdays['tue']
two
>>> weekdays['sat']
6

Easy, isn’t it?

Shall we insert some values into this dictionary?

>>> weekdays
{'wed': 3, 'sun': 0, 'sat': 6, 'fri': 5, 'mon': 1, 'thu': 4, 'tue': 2}
>>> weekdays['Sun'] = 0
>>> weekdays['Mon'] = 1
>>> weekdays['Tue'] = 2
>>> weekdays['Wed'] = 3
>>> weekdays['Thu'] = 4
>>> weekdays['Fri'] = 5
>>> weekdays['Sat'] = 6
>>> weekdays
{'wed': 3, 'sun': 0, 'sat': 6, 'Sun': 0, 'mon': 1, 'fri': 5, 'Mon': 1,
'thu': 4, 'Wed': 3, 'Sat': 6, 'Thu': 4, 'tue': 2, 'Fri': 5, 'Tue': 2}

In a dictionary, the order in which the elements appear is not so important, as the values are accessed mainly through their respective keys, not their positions. In addition, dictionaries do not keep the order of elements, so the element that appears first in one execution may not be the first in another, even if the insertion was done in the same way.

If you need to check if a key is already in the dictionary, just do the following

>>> 'mon' in weekdays
true
>>> 'bla' in weekdays
false

Well, let’s say now that I no longer want the dictionary to have the capitalized version for Sunday.

>>> del(weekdays['Sun])

It is also possible to know which keys have already been inserted:

>>> weekdays.keys()
['Sat', 'Mon', 'Fri', 'Wed', 'Thu', 'Tue', 'Wed', 'Sun', 'Sat', 'Fri',
'Mon', 'Thu', 'Tue']

And what values are in the dictionary: >>> weekdays.values() [6, 1, 5, 3, 4, 2, 3, 0, 6, 5, 1, 4, 2]

One important thing to note is that keys and dictionary elements can be of virtually any type, with the exception of keys which have a constraint. Objects have to be immutable.

This means that the list [1, 2, 3] cannot be a dictionary key as we can change values in the list in the middle of the execution. The tuple (1, 2, 3) that is immutable can be a dictionary key without any problems.

By now, you are familiar with Python Dictionaries, this data structure that has so many important applications.

Be sure to post questions and opinions in the comments below!

See you in the next post!

Python 101 - Parte 9 - Estruturas de Dados - List Comprehention

2022-08-22T23:06:00+02:00

Olá!

Como prometido, hoje vamos continuar o post falando sobre listas em Python, pois este é uma assunto bastante extenso.

O assunto de hoje é List Comprehension, ou em português, abrangência de listas. Como o termo em português não retrata bem o que este recurso faz, vamos usar o termo em inglês mesmo.

List Comprehension é um recurso do Python que permite a criação de listas de forma simples, usando simplesmente uma expressão seguida de um for que pode conter outros for e/ou if dentro dele.

Tudo ficará mais claro ao partirmos para os exemplos.

Então, vamos colocar a mão na massa! Abra o shell do Python.

Lembre-se que o que deve ser digitado estará precedido de >>> ou ..., assim como aparecerá no shell do python.

Se por acaso você não entendeu do que estou falando, é aconselhável que você leia antes os posts anteriores que te deixarão em dia com tudo que vimos até agora.

Procure entender exatamente o que acontece em cada exemplo. Vamos lá!

>>> l = [1, 2, 4] 
>>> [3 * x for x in l]
[3, 6, 12]
>>> [2 * x for x in l if x > 3]
[12]
>>> 5 * x for x in l if x < 0] 
[]
>>> [[x, 2*x] for x in l]
[[1, 2], [2, 4], [4, 8]]
>>> [(x, 2*x) for x in l]
[(1, 2), (2, 4), (4, 8)]
>>> l1 = [0, 1, 2]
>>> l2 = [1, 2, 3]
>>> [x * y for x in l1 for y in l2] 
[0, 0, 0, 1, 2, 3, 2, 4, 6]
>>> [l1[i] * l2[i] for i in range(len(l1))]
[0, 2, 6]

As instruções são sempre dadas no mesmo padrão:

[<expressao> for <variável> in <lista> [if <condição>] [for...]]
*** As estruturas entre [] são opcionais. ***

Agora chegamos ao ponto em que devemos responder ao desafio do último post da série Python 101 para prosseguir.

“Quem imagina como fazer uma matriz em Python usando o que vimos hoje?”

A resposta é: Criar listas de listas!

Então, se fizermos:

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

Teremos a matriz m com 2 linhas e 3 colunas, contendo na primeira linha os valores 1, 2, 3 e na segunda os valores 2, 3, 4.

Assim, podemo usar list comprehention também para criarmos matrizes. Chamamos este recurso de Nested List Comprehention (nested = aninhado).

Vejamos o seguinte exemplo:

>>> m = [
...         [1, 2, 3],
...         [4, 5, 6],
...         [7, 8, 9],
...     ]

Aqui, criamos uma matriz 3x3 com os valores de 1 a 9. Agora, veja uma forma de trocar as linhas com as colunas da matriz m:

>>> [[linha[i] for linha in m] for i in [0, 1, 2]]
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

Acho que por hoje, este recurso está bem ilustrado. Não deixe de enviar dúvidas e opiniões nos comentários abaixo!

Até o próximo post!

Python 101 - Part 9 - Data Structures - List Comprehention

2022-08-22T23:06:00+02:00

Hello!

As promised, today we are going to continue the post talking about lists in Python, as this is a very extensive subject.

Today’s topic is List Comprehension.

List Comprehension is a Python feature that allows the creation of lists in a simple way, simply using an expression followed by a for that can contain another for and/or if within it.

Everything will become clearer as we move on to the examples.

So, let’s get our hands dirty! Open the Python shell.

Remember that what must be typed will be preceded by >>> or ..., as it will appear in the python shell.

If by any chance you don’t understand what I’m talking about, it’s advisable that you read the previous posts beforehand, which will keep you up to date with everything we’ve seen so far.

Try to understand exactly what happens in each example. Come on!

>>> l = [1, 2, 4]
>>> [3 * x for x in l]
[3, 6, 12]
>>> [2 * x for x in l if x > 3]
[12]
>>> 5 * x for x in l if x < 0]
[]
>>> [[x, 2*x] for x in l]
[[1, 2], [2, 4], [4, 8]]
>>> [(x, 2*x) for x in l]
[(1, 2), (2, 4), (4, 8)]
>>> l1 = [0, 1, 2]
>>> l2 = [1, 2, 3]
>>> [x * y for x in l1 for y in l2]
[0, 0, 0, 1, 2, 3, 2, 4, 6]
>>> [l1[i] * l2[i] for i in range(len(l1))]
[0, 2, 6]

The instructions are always given in the same pattern:

[<expression> for <variable> in <list> [if <condition>] [for...]]
*** Structures between [] are optional. ***

Now we come to the point where we must answer last Python 101 post’s challenge in order to proceed.

“Who can imagine how to make an array in Python using what we saw today?”

The answer is: Create lists of lists!

So if we do:

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

We will have the matrix m with 2 rows and 3 columns, containing in the first row the values 1, 2, 3 and in the second the values 2, 3, 4.

So we can use list comprehention to create matrices as well. We call this feature Nested List Comprehention.

Let’s look at the following example:

>>> m = [
... [1, 2, 3],
... [4, 5, 6],
... [7, 8, 9],
... ]

Here, we create a 3x3 matrix with values from 1 to 9. Now, here’s a way to exchange the rows with the columns of the matrix m:

>>> [[line[i] for line in m] for i in [0, 1, 2]]
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

I think for today, this feature is well illustrated. Be sure to post questions and opinions in the comments below!

See you in the next post!

Tutorial de Pelican com Github Pages e CircleCI - 3

2022-08-15T09:30:00+02:00

Olá!

Hora de continuar nosso tutorial e colocarmos nosso blog Pelican no github pages!

Caso você ainda não tenha visto os posts anteriores, veja aqui para podermos seguir do mesmo ponto.

Recapitulando rapidamente, no primeiro tutorial nós criamos um site bem simples com Pelican e no terceiro nós criamos uma página bastante simples no github pages.

A estrutura atual do seu diretório do github pages deve ser algo como

usuario.github.io/
    index.html

Bom, não vamos usar este arquivo html.

No terminal, vamos criar uma nova branch, que será nossa branch principal para criarmos todos os textos do blog.

git checkout -b pelican

Este comando criará uma nova branch no seu repositório git local e vai automaticamente mudar a branch atual para pelican.

Vamos apagar o arquivo html.

rm index.html

E agora vamos criar nosso blog. Precisamos ter acesso aqui ao comando pelican-quickstart que usamos no tutorial de pelican, então, num ambiente que contenha o pelican (pode ser o mesmo que usamos no tutorial de pelican), digite o comando:

pelican-quickstart

Desta vez não vamos ficar nos parâmetros padrão. Adapte as escolhas que eu mostrar a seguir ao seu projeto.

> Where do you want to create your new web site? [.]
# Simplesmente aperte `Enter` para usar a opção padrão.
> What will be the title of this web site? 
# Caso tenha um nome para o blog, ele vai aqui, senão, usuario.github.io pode ser uma boa
> Who will be the author of this web site?
# Aqui, será seu nome
> What will be the default language of this web site? [pt]
# `pt` não é uma opção válida, então use `pt_BR`
> Do you want to specify a URL prefix? e.g., https://example.com   (Y/n)
# Aqui responda `y` e depois a url do seu blog (https://usuario.github.io por exemplo
> Do you want to enable article pagination? (Y/n)
# Sempre acho uma boa ideia ter paginação, então, `Y`
> How many articles per page do you want? [10]
# Aqui também recomendo o padro, `Enter`
> What is your time zone? [America/Sao_Paulo] 
# Use aqui o que fizer mais sentido pra você
> Do you want to generate a tasks.py/Makefile to automate generation and publishing? (Y/n)
# Esta é a parte mais importante. A resposta aqui é SIM! `Y`
> Do you want to upload your website using FTP? (y/N) 
# Nós não queremos, então `n`
> Do you want to upload your website using SSH? (y/N) 
# Mesmo aqui, `n`
> Do you want to upload your website using Dropbox? (y/N) 
# Aqui, `n`
> Do you want to upload your website using S3? (y/N)
# Aqui, `n'
> Do you want to upload your website using Rackspace Cloud Files? (y/N)
#E aqui, `n`
> Do you want to upload your website using GitHub Pages? (y/N)
# Nós queremos usar github pages então a resposta aqui é `y`
> Is this your personal page (username.github.io)? (y/N) 
# E sim, é a página pessoal, então, `y`

Vamos precisar da lib de Python que interage com github pages então vamos instalá-la:

pip install ghp-import

Para o caso de precisarmos editar este repositório em outro local, outro ambiente, vamos criar um arquivo requirements.txt que vai conter

ghp-import
pelican[markdown]

Isto nos permite instalar facilmente as dependências no futuro com o comando

pip install -r requirements.txt

Mais uma vez você deve ter uma estrutura de arquivos dentro do seu repositório parecida com isto:

content/
pelicanconf.py
publishconf.py
requirements.txt

Vamos dar uma olhada no arquivo pelicanconf.py

AUTHOR = 'Author Name'
SITENAME = 'My Blog'
SITEURL = ''

PATH = 'content'

TIMEZONE = 'America/Sao_Paulo'

DEFAULT_LANG = 'pt'

# Feed generation is usually not desired when developing
FEED_ALL_ATOM = None
CATEGORY_FEED_ATOM = None
TRANSLATION_FEED_ATOM = None
AUTHOR_FEED_ATOM = None
AUTHOR_FEED_RSS = None

# Blogroll
LINKS = (('Pelican', 'https://getpelican.com/'),
        ('Python.org', 'https://www.python.org/'),
        ('Jinja2', 'https://palletsprojects.com/p/jinja/'),
        ('You can modify those links in your config file', '#'),)

# Social widget
SOCIAL = (('You can add links in your config file', '#'),
        ('Another social link', '#'),)

DEFAULT_PAGINATION = 10

# Uncomment following line if you want document-relative URLs when developing
#RELATIVE_URLS = True

Podemos remover os links e acrescentar links mais relevantes. Também podemos acrescentar links para redes sociais.

Vamos acrescentar uma URL para quando estivermos rodando o blog em modo de desenvolvimento para vermos como está o post, por exemplo.

Em SITEURL insira 'http://localhost:8000'.

Agora vamos criar um post em content e podemos chamar por exemplo de primeiro-post.md

Sua estrutura de arquivos ficará

content/
    primeiro-post.md
pelicanconf.py
publishconf.py
requirements.txt

Em primeiro-post.md escreva:

Title: Primeiro Post
Date: 2022-08-14 12:30
Category: Geral
Tags: Geral
Slug: primeiro-post

# Olá!

Este é meu primeiro post

Isto é um [link](#)

É muito __fácil__ criar posts com _Pelican_!

Aqui temos a estrutura de um post bem simples, com metadados básicos e um exemplo de texto que exemplifica algumas marcações do Markdown.

Vamos testá-lo no servidor de testes.

pelican -l -r
--- AutoReload Mode: Monitoring `content`, `theme` and `settings` for changes. ---
Serving site at: http://127.0.0.1:8000 - Tap CTRL-C to stop
[04:22:41] WARNING  Watched path does not exist: /path/to/username.github.io/content/images


-> Modified: settings, content, theme. re-generating...
Done: Processed 1 article, 0 drafts, 0 hidden articles, 0 pages, 0 hidden pages and 0 draft pages in 0.06 seconds.

Acesse o servidor local e você deve ver algo assim:

Para continuarmos, você precisa ter instalado o make. Como no Windows a instalação do make é mais chatinha, segue um tutorial de make no Windows.

Podemos usar o make para várias tarefas.

Para executar um servidor de desenvolvimento, podemos usar

make devserver

Podemos simplesmente gerar os arquivos para deploy com

make publish

E para enviarmos para o github, vamos usar:

make github

Porém, antes de enviarmos nosso projeto para o github pages vamos conferir a configuração do blog para publicação. Abra o arquivo publishconf.py. Ele deve ter aproximadamente este conteúdo:

# This file is only used if you use `make publish` or
# explicitly specify it as your config file.

import os
import sys
sys.path.append(os.curdir)
from pelicanconf import *

# If your site is available via HTTPS, make sure SITEURL begins with https://
SITEURL = 'https://jcempython.github.io'
RELATIVE_URLS = False

FEED_ALL_ATOM = 'feeds/all.atom.xml'
CATEGORY_FEED_ATOM = 'feeds/{slug}.atom.xml'

DELETE_OUTPUT_DIRECTORY = True

# Following items are often useful when publishing

#DISQUS_SITENAME = ""
#GOOGLE_ANALYTICS = ""

Em alguns instantes você poderá acessar seu site usuario.github.io e ver seu blog no ar!

Quando escrever novos posts, simplesmente execute make publish e make github e em alguns instantes seu post estará no ar!

Por hora é isto! Tenho certeza que você já vai se divertir muito com seu blog e já vai poder começar a postar tudo que quiser!

Não se esqueça, quando terminar de fazer alterações no seu blog, de fazer um commit das alterações para a branch pelican também.

git add .
git commit -m "uma mensagem do que foi feito"
git push origin pelican

Assim você não corre o risco de perder suas alterações e tem sempre controle sobre as versões dos textos que vau publicar!

No próximo post vamos dar um tapa neste blog para termos mais funções, como comentários, por exemplo.

Espero que tenham gostado e não esqueçam de deixar suas opiniões e dúvidas nos comentários!

Até o próximo post!

Pelican Tutorial with Github Pages and CircleCI - 3

2022-08-15T09:30:00+02:00

Hi!

It’s time to continue our tutorial and put our Pelican blog on github pages!

Just in case you haven’t seen the previous posts, check here so we can follow from the same page.

To recap quickly, in the first tutorial we created a very simple site with Pelican and in the third we created a very simple page on github pages.

The current structure of your github pages directory should look something like

username.github.io/
    index.html

Well, let’s not use this html file.

In the terminal, let’s create a new branch, which will be our main branch to create all the blog texts.

git checkout -b pelican

This command will create a new branch in your local git repository and will automatically change the current branch to pelican.

Let’s delete the html file.

rm index.html

And now let’s create our blog. We need access here to the pelican-quickstart command that we used in the pelican tutorial, so, in an environment that contains the pelican (may be the same one we used in the pelican tutorial), type the command:

pelican-quickstart

This time we are not going to stick to the default parameters. Adapt the choices I show below to your project.

> Where do you want to create your new web site? [.]
# Simply press `Enter` to use the default option.
> What will be the title of this web site?
# If you have a name for the blog, it goes here, otherwise, username.github.io might be a good idea
> Who will be the author of this web site?
# Here will be your name
> What will be the default language of this web site? [en]
# `pt` is not a valid option, so use `pt_BR`
> Do you want to specify a URL prefix? e.g., https://example.com (Y/n)
# Here answer `y` and then the url of your blog (https://username.github.io for example)
> Do you want to enable article pagination? (Y/n)
# I always think it's a good idea to have pagination, so `Y`
> How many articles per page do you want? [10]
# Here I also recommend the default, `Enter`
> What is your time zone? [America/New_York]
# Use here what makes the most sense to you
> Do you want to generate a tasks.py/Makefile to automate generation and publishing? (Y/n)
# This is the most important part. The answer here is YES! `Y`
> Do you want to upload your website using FTP? (y/n)
# We don't want to, so `n`
> Do you want to upload your website using SSH? (y/n)
# Even here, `n`
> Do you want to upload your website using Dropbox? (y/n)
# Here, `n`
> Do you want to upload your website using S3? (y/n)
# Here, `n'
> Do you want to upload your website using Rackspace Cloud Files? (y/n)
#And here, `n`
> Do you want to upload your website using GitHub Pages? (y/n)
# We want to use github pages so the answer here is `y`
> Is this your personal page (username.github.io)? (y/n)
# And yes, it's the personal page, so `y`

We’re going to need the Python lib that interacts with github pages so let’s install it:

pip install ghp-import

In case we need to edit this repository in another location, another environment, let’s create a requirements.txt file that will contain

ghp-import
pelican[markdown]

This allows us to easily install dependencies in the future with the command

pip install -r requirements.txt

Once again you should have a file structure within your repository that looks like this:

content/
pelicanconf.py
publishconf.py
requirements.txt

Let’s take a look at the pelicanconf.py file

AUTHOR = 'Author Name'
SITENAME = 'My Blog'
SITEURL = ''

PATH = 'content'

TIMEZONE = 'America/New_York'

DEFAULT_LANG = 'en'

# Feed generation is usually not desired when developing
FEED_ALL_ATOM = None
CATEGORY_FEED_ATOM = None
TRANSLATION_FEED_ATOM = None
AUTHOR_FEED_ATOM = None
AUTHOR_FEED_RSS = None

# blogroll
LINKS = (('Pelican', 'https://getpelican.com/'),
        ('Python.org', 'https://www.python.org/'),
        ('Jinja2', 'https://palletsprojects.com/p/jinja/'),
        ('You can modify those links in your config file', '#'),)

# Social widget
SOCIAL = (('You can add links in your config file', '#'),
        ('Another social link', '#'),)

DEFAULT_PAGINATION = 10

# Uncomment following line if you want document-relative URLs when developing
#RELATIVE_URLS = True

We may remove links and add more relevant links. We can also add links to social networks. Let’s add a URL for when we are running the blog in development mode to see how the post is doing, for example.

In SITEURL enter 'http://localhost:8000'.

Now let’s create a post in content and we can call it for example first-post.md

Your file structure will be

content/
    first-post.md
pelicanconf.py
publishconf.py
requirements.txt

In first-post.md write:

Title: First Post
Date: 2022-08-14 12:30
Category: General
Tags: General
Slug: first-post

# Hello!

this is my first post

This is a [link](#)

It's very __easy__ to create posts with _Pelican_!

Here we have the structure of a very simple post, with basic metadata and an example text that exemplifies some Markdown markup.

Let’s test it on the test server.

pelican -l -r
--- AutoReload Mode: Monitoring `content`, `theme` and `settings` for changes. ---
Serving site at: http://127.0.0.1:8000 - Tap CTRL-C to stop
[04:22:41] WARNING Watched path does not exist: /path/to/username.github.io/content/images


-> Modified: settings, content, theme. re-generating...
Done: Processed 1 article, 0 drafts, 0 hidden articles, 0 pages, 0 hidden pages and 0 draft pages in 0.06 seconds.

Go to the local server and you should see something like this:

To continue, you need to have make installed. As the installation of make is more annoying on Windows, follow a make tutorial on Windows.

We can use make for many tasks.

To run a development server we can use

make devserver

We can simply generate the files for deploy with

make publish

And to upload to github, let’s use:

make github

However, before we upload our project to github pages, let’s check the configuration of the blog for publishing. Open the publishconf.py file. It should have approximately this content:

# This file is only used if you use `make publish` or
# explicitly specify it as your config file.

import them
import sys
sys.path.append(os.curdir)
from pelicanconf import *

# If your site is available via HTTPS, make sure SITEURL begins with https://
SITEURL = 'https://jcempython.github.io'
RELATIVE_URLS = False

FEED_ALL_ATOM = 'feeds/all.atom.xml'
CATEGORY_FEED_ATOM = 'feeds/{slug}.atom.xml'

DELETE_OUTPUT_DIRECTORY = True

# Following items are often useful when publishing

#DISQUS_SITENAME = ""
#GOOGLE_ANALYTICS = ""

In a few moments you will be able to access your site username.github.io and see your blog live!

When writing new posts, simply run make publish and make github and in a few moments your post will be live!

That’s it for an hour! I’m sure you’ll have a lot of fun with your blog and you’ll be able to start posting whatever you want!

Don’t forget, when you’re done making changes to your blog, to commit the changes to the pelican branch as well.

git add .
git commit -m "a message of what was done"
git push origin pelican

So you don’t run the risk of losing your changes and you always have control over the versions of the texts that I’m going to publish!

In the next post we’ll slap this blog to have more functions, like comments, for example.

Hope you liked it and don’t forget to leave your opinions and questions in the comments!

See you in the next post!

Python 101 - Parte 8 - Estruturas de Dados - Listas

2022-08-13T02:06:00+02:00

Olá!

Vou falar hoje sobre Listas em Python.

Caso não tenha visto os tutoriais anteriores, já temos:

Listas são conjuntos ordenados de dados. Em python, estes conjuntos podem conter vários tipos de dados misturados, visto que tudo em Python é objeto.

Assim, além de tipos de dados básicos como inteiros, números reais e texto, as listas podem conter qualquer outro objeto da linguagem.

Vejamos como as listas são criadas em python:

# Criando uma lista vazia
l = []

#Criando uma lista já com valores
l1 = [1, 2, 3, 'a', 'd', l]

#Criando uma lista de letras a partir de uma string
l2 = list("abracadabra")

No primeiro comando, criamos uma lista vazia, que poderá ser preenchida futuramente. Em seguida, criamos uma lista, já atribuindo valores no momento da criação.

Perceba que ao criar a lista são passados valores inteiros, letras e a lista que foi criada vazia anteriormente. Assim, demonstramos que uma lista pode receber qualquer tipo de objeto, e que pode ter objetos de tipos diferentes ao mesmo tempo!

Na lista três, utilizamos list() para criar um objeto list a partir de um string. Isto é possível porque tanto listas quanto strings são sequências.

Mas, as listas em Python não são estáticas. Podemos inserir e retirar valores conforme bem quisermos a qualquer hora durante a execução do programa. Vejamos:

# vamos acrescentar valores à lista l criada anteriormente
# append(o) insere um objeto o no final da lista
l.append(1) # a lista ficará assim [1]
l.append(3) # a lista ficará assim [1, 3]

# insert(i, o), insere o objeto o na posição i (a primeira posição é zero)
l.insert(1, 2) # a lista ficará assim [1, 2, 3]
l.insert(0, 5) # a lista ficará assim [5, 1, 2, 3]

# remove(o) remove a primeira ocorrência do objeto o
l.append(5) # a lista ficará assim [5, 1, 2, 3, 5]
l.remove(5) # a lista ficará assim [1, 2, 3, 5]

# pop(i) remove e retorna o objeto da posição i
# pop() remove e retorna o último elemento da lista
l.insert(3, 6) # a lista ficará assim [1, 2, 3, 6, 5]
l.pop(3) # a lista ficará assim [1, 2, 3, 5] e retornará 6
l.pop() # a lista ficará assim [1, 2, 3] e retornará 5

#index(o) retorna o índice do objeto o
l.index(3) # retorna 2
l.append(3) # a lista ficará assim [1, 2, 3, 3]
l.index(3) # continua retornando 2 pois é a primeira ocorrência do 3

# count(o) conta quantas vezes o objeto o aparece na lista
l.count(1) # retorna 1
l.count(3) # retorna 2
l.pop() # a lista ficará assim [1, 2, 3] e retorna 3

# extend(L) estende a lista com a lista L
l.extend([0, -1, -2]) # a lista ficará assim [1, 2, 3, 0, -1, -2]

# sort() organiza os itens da lista nela mesma
l.sort() # a lista ficará assim [-2, -1, 0, 1, 2, 3]

# reverse() inverte os elementos da lista nela mesma
l.reverse() # a lista ficará assim [3, 2, 1, 0, -1, -2]

Agora é hora de treinar!

Abram o terminal, e comecem a brincar com as listas! Vejam como funcionam os comandos!

Uma dica! O comando help mostra informações sobre um comando! Experimente, após criar uma lista l, o comando:

>>> help(l.sort)

No próximo post vamos falar de uma operação que tem tudo a ver com listas: List Comprehension.

Um desafio!

Quem imagina como fazer uma matriz em Python usando o que vimos hoje?

Deixe sua resposta nos comentários!

Não deixe de enviar dúvidas e opiniões nos comentários abaixo!

Até o próximo post!

Python 101 - Parte 8 - Data Structures - Lists

2022-08-13T02:06:00+02:00

Hi!

Today I’m going to talk about Lists in Python.

In case you haven’t seen the previous tutorials, we already have:

Lists are ordered sets of data. In python, these sets can contain many mixed data types, since everything in Python is an object.

So, in addition to basic data types like integers, real numbers, and text, lists can contain any other language object.

Let’s see how lists are created in python:

# Creating an empty list
l = []

#Creating a list with values
l1 = [1, 2, 3, 'a', 'd', l]

# Creating a list of letters from a string
l2 = list("abracadabra")

In the first command, we create an empty list, which can be filled in the future. Next, we create a list, already assigning values at the time of creation.

Note that when creating the list, integer values, letters and the list that was created empty previously are passed. Thus, we demonstrate that a list can receive any type of object, and that it can have objects of different types at the same time!

In the third list creation, we use list() to create a list object from a string. This is possible because both lists and strings are sequences.

But, Python lists are not static. We can insert and remove values as we please at any time during program execution. Let’s see:

# let's add values ​​to the list l created earlier
# append(o) inserts an object o at the end of the list
l.append(1) # the list will look like this [1]
l.append(3) # the list will look like this [1, 3]

# insert(i, o), insert object o at position i (first position is zero)
l.insert(1, 2) # the list will look like this [1, 2, 3]
l.insert(0, 5) # the list will look like this [5, 1, 2, 3]

# remove(o) removes the first occurrence of the object o
l.append(5) # the list will look like this [5, 1, 2, 3, 5]
l.remove(5) # the list will look like this [1, 2, 3, 5]

# pop(i) remove and return the object from position i
# pop() removes and returns the last element of the list
l.insert(3, 6) # the list will look like this [1, 2, 3, 6, 5]
l.pop(3) # the list will look like this [1, 2, 3, 5] and return 6
l.pop() # the list will look like this [1, 2, 3] and return 5

#index(o) returns the index of the object o
l.index(3) # returns 2
l.append(3) # the list will look like this [1, 2, 3, 3]
l.index(3) # keeps returning 2 as it is the first occurrence of 3

# count(o) counts how many times the object o appears in the list
l.count(1) # returns 1
l.count(3) # returns 2
l.pop() # the list will look like this [1, 2, 3] and returns 3

# extend(L) extend list with list L
l.extend([0, -1, -2]) # the list will look like this [1, 2, 3, 0, -1, -2]

# sort() sorts the list items by itself
l.sort() # the list will look like this [-2, -1, 0, 1, 2, 3]

# reverse() reverses the elements of the list on itself
l.reverse() # the list will look like this [3, 2, 1, 0, -1, -2]

Now it’s time to exercise!

Open the terminal, and start playing with the lists! See how the commands work!

A tip! The help command shows information about a command! try it after creating a list l, the command: >>> help(l.sort)

In the next post we will talk about an operation that has everything to do with lists: List Comprehension.

A challenge!

Who can imagine how to make a matrix in Python using what we saw today?

Leave your answer in the comments!

Be sure to post questions and opinions in the comments below!

See you in the the next post!

Python 101 - Parte 7 - Estruturas de Dados - 1

2022-08-11T00:29:00+02:00

Olá!

Hoje vamos ver uma coisa muito importante no Python: as estruturas de dados nativas.

Caso não tenha visto os tutoriais anteriores, já temos:

São vários os tipos de dados nativos do Python. Entre eles, os mais importantes, pois são essenciais para qualquer programa, são os tipos:

int - números inteiro
float - ponto flutuante, representando os números reais, basicamente
string - cadeia de caracteres, ou basicamente, texto

Porém, em Python, diferente de outras linguagens, estes tipos de dados, assim como todas as outras estruturas da linguagem são objetos, desta forma, o tipo básico de tudo em python é object. Há muito a se discutir sobre tipos de dados, mas para simplificar consideraremos assim.

Voltando às estruturas de dados nativas, veremos que estas são conjuntos estruturados de objetos que podem conter elementos de qualquer outro tipo.

A primeira e talvez mais largamente usada destas estruturas é a list. Uma list implementa uma lista que pode conter virtualmente qualquer objeto, sendo composta por quantos tipos de objeto for necessário (diferente de algumas linguagens).

Desta forma, listas se tornam uma ferramenta muito poderosa dentro do Python. Teremos mais adiante um post focado especialmente nas listas e seus métodos.

Para criar uma lista, basta atribuir valores a ela da seguinte forma:

l = [1, 2, 3, 4, 5]

Assim como fizemos quando vimos como funciona o for.

Outra estrutura de dados muito importante e largamente usada é a tuple (tupla). Tuplas contém conjuntos de valores assim como as listas, porém se diferenciam destas principalmente pelo fato de as tuplas não poderem ser alteradas após sua criação, e as listas sim.

Vamos criar uma tupla:

t = (1, 2, 3, 4, 5)

Vejamos agora uma das estruturas de dados mais poderosas do Python, e que possui muitas possibilidades de utilização. Esta estrutura é o dict (dicionário) que relaciona pares de chave e valor.

Assim criamos um dicionário:

d = {'a': 1, 'b': 2,'c': 3, 'd': 4, 'e': 5}

Finalmente, a última estrutura de dados nativa do Python que veremos hoje é o set (conjunto). Os sets representam conjuntos matemáticos. Assim, são sequências e uma característica interessante é que não possuem elementos repetidos.

Por exemplo, ao criar este set:

s = set([1, 1, 2, 3, 5, 7, 13, 17])

O conjunto será [1, 2, 3, 5, 7, 13, 17], pois 1 aparecia 2 vezes na lista original, e no set ele aparece somente uma vez.

Nos Próximos posts, vamos ver em mais detalhes estas estruturas de dados :D

Não deixe de enviar dúvidas e opiniões nos comentários abaixo!

Até o próximo post!

Python 101 - Part 7 - Data Structures - 1

2022-08-11T00:29:00+02:00

Hi!

Today we are going to look at a very important thing in Python: the native data structures.

In case you haven’t seen the previous tutorials, we already have:

There are several native Python data types. Among them, the most important, as they are essential for any program, are the types:

int - integers
float - floating point, representing the real numbers, basically
string - string, or basically, text

However, in Python, unlike other languages, these data types, like all other structures in the language, are objects, so the basic type of everything in python is object. There’s a lot to discuss about data types, but for simplicity’s sake we’ll consider it that way.

Returning to native data structures, we will see that these are structured sets of objects that can contain elements of any other type.

The first and perhaps most widely used of these structures is the list. A list implements a list that can contain virtually any object, consisting of as many object types as needed (unlike some languages).

In this way, lists become a very powerful tool within Python. We will have a post later focused especially on lists and their methods.

To create a list, simply assign values to it as follows:

l = [1, 2, 3, 4, 5]

Just like we did when we saw how for works.

Another very important and widely used data structure is the tuple. Tuples contain sets of values just like lists, but they differ from them mainly in that tuples cannot be changed after they are created, and lists can.

Let’s create a tuple:

t = (1, 2, 3, 4, 5)

Now let’s look at one of Python’s most powerful data structures, and one that has many possibilities for use. This structure is the dict (dictionary) that relates key and value pairs.

So we create a dictionary:

d = {'a': 1, 'b': 2,'c': 3, 'd': 4, 'e': 5}

Finally, the last native Python data structure we’ll look at today is the set. The sets represent mathematical sets. Thus, they are sequences and an interesting feature is that they do not have repeated elements.

For example, when creating this set:

s = set([1, 1, 2, 3, 5, 7, 13, 17])

The set will be [1, 2, 3, 5, 7, 13, 17], as 1 appeared twice in the original list, and in the set it appears only once.

In the next posts, we will see these data structures in more detail :D

Be sure to post questions and opinions in the comments below!

Until the next post!

Python 101 - Parte 6 - Estruturas de Repetição - For

2022-08-09T12:06:00+02:00

Olá!

Mais um post aqui ensinando Python para vocês e hoje veremos o for.

Caso não tenha visto os tutoriais anteriores, já temos:

Vamos começar com um exemplo simples:

l = [1, 2, 3, 4, 5]
for i in l:
    print(i)

Aqui, inicialmente, começamos com algo que ainda não vimos: listas.

Começamos criando l como uma lista que contém uma sequência de números.

Então, esta lista é usada dentro do for.

Em outras linguagens, determinamos o valor inicial da variável contadora, seu limite e o passo de iteração. Em python isso não acontece. Aqui, o for somente itera sobre sequências. Isto traz várias vantagens, como por exemplo, iterar sobre strings, ou listas de elementos variados.

Será mostrado adiante porque este for não está em desvantagem frente ao for das outras linguagens.

Então, a cada iteração, a variável de iteração, neste caso i, recebe o elemento de uma posição da lista.

Assim, este trecho acima imprime na tela todos os valores contidos na lista l.

Vamos ver agora este trecho de código:

d = ['arroz', 'feijão', 'carne', 'batata']
for i in d:
    print('Estou cozinhando ', i)

Este exemplo demonstra a utilização do for com listas que contém strings, mostrando que pode-se usar listas com qualquer objeto num for.

No for também podemos usar break e continue. Assim, podemos controlar ainda mais o comportamento do laço. Além disso, há uma característica no for do Python que o deixa muito poderoso: podemos usar um else ao final do for como no exemplo a seguir:

for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g']:
    if i == 'h':
        break
    print(i)
else:
    print('"h" não está na lista mas eu printo mesmo assim')

Usando o else no final, podemos controlar o que será executado ao final de um execução completa do for e o que será executado se o laço for quebrado por um break. Quando o laço é completamente percorrido sem uma quebra, a execução segue pra dentro do else!

Neste exemplo, a saída será algo assim:

a
b
c
d
e
f
g
"h" não está na lista mas eu printo mesmo assim

Isto é muito importante, pois evita que tenhamos que fazer testes complicados para detectar quando um for for quebrado por um break que será chamado em condições complexas.

Finalmente, muitos devem estar se perguntando: “Como este for pode ser tão poderoso se temos que definir as listas manualmente?”

O fato é que não temos que fazer manualmente se for uma lista de números (assim como não precisamos em outras linguagens).

Existe uma função em Python, range, que retorna uma generator (objeto que pode ser iterado como uma lista, mas gera os valores durante a execução) de números no intervalo especificado. Veja o exemplo:

for i in range(50):
    if i%2 == 0:
        print(i, 'é par')
    else:
        print(i, 'é impar')

Quando fazemos range(50), teremos uma generator que funcionará como uma lista de inteiros de 0 a 49. (experimente no shell).

Bem, pessoal! Por hoje é isso!

Agora falta pouco para iniciarmos uma programação efetiva em Python!

Nos Próximos Posts, tipos de dados nativos do Python!

Não deixe de enviar dúvidas e opiniões nos comentários abaixo!

Até o próximo post!

Python 101 - Part 6 - Repetition Structures - For

2022-08-09T12:06:00+02:00

Hi!

One more post here teaching you Python and today we will talk about for.

In case you haven’t seen the previous tutorials, we already have:

Let’s start with a simple example:

l = [1, 2, 3, 4, 5]
for i in l:
    print(i)

Here, initially, we start with something we haven’t seen yet: lists.

We start by creating l as a list that contains a sequence of numbers.

So this list is used inside the for.

In other languages, we determine the initial value of the counter variable, its limit and the iteration step. In python this does not happen. Here, for only iterates over sequences. This has several advantages, such as iterating over strings, or lists of different elements.

It will be shown later because this for is not at a disadvantage compared to the for of other languages.

Then, at each iteration, the iteration variable, in this case i, receives the element of a position in the list.

Thus, this snippet above prints on the screen all the values contained in the list l.

Now let’s see this code snippet:

d = ['rice', 'beans', 'meat', 'potato']
for i in d:
    print('I'm cooking ', i)

This example demonstrates the use of for with lists that contain strings, showing that you can use lists with any object in a for.

In for we can also use break and continue. Thus, we can further control the behavior of the loop. Also, there is a feature in Python’s for that makes it very powerful: we can use an else at the end of the for as in the following example:

for i in ['a', 'b', 'c', 'd', 'e', ​​'f', 'g']:
    if i == 'h':
        break
    print(i)
else:
    print('"h" is not in the list but I print anyway')

Using else at the end, we can control what will be executed at the end of a complete for execution and what will be executed if the loop is broken by a break. When the loop is completely traversed without a break, execution proceeds into else!

In this example, the output will look something like this:

a
b
c
d
e
f
g
"h" is not in the list but I print it anyway

This is very important, as it avoids having to do complicated tests to detect when a for is broken by a break that will be called under complex conditions.

Finally, many may be wondering: “How can this for be so powerful if we have to define the lists manually?”

The fact is that we don’t have to do it manually if it’s a list of numbers (just like we don’t need to in other languages).

There is a Python function, range, which returns a generator (object that can be iterated over like a list, but generates the values at runtime) of numbers in the specified range. See the example:

for i in range(50):
    if i%2 == 0:
        print(i, 'is even')
    else:
        print(i, 'is odd')

When we do range(50), we will have a generator that will work as a list of integers from 0 to 49. (try it in the shell).

Well folks! That’s it for today!

Now it’s not long before we start effective programming in Python!

In the next posts, native Python data types!

Be sure to post questions and opinions in the comments below!

See you in the next post!

Tutorial de Pelican com Github Pages e CircleCI - 2

2022-08-08T09:30:00+02:00

Olá!

Chegou a hora de continuarmos o tutorial de como publicar seu blog com Pelican, Github Pages e Circle CI como eu fiz, e caso você esteja chegando por aqui agora, confira nossos tutoriais anteriores

Hoje vamos falar sobre Github Pages.

Github Pages é uma funcionalidade gratuita do Github que te permite criar um site estático para seu perfil ou para seus projetos. Geralmente estes sites terão uma URL do tipo usuario.github.io ou projeto.github.io. Porém, é possível também colocar seu próprio domínio, como fiz aqui.

Para este tutorial, vamos usar o github pages para seu usuário, assim, crie um repositório chamado username.github.io, onde username é seu nome de usuário.

No canto superior direito do site clique no + e selecione New Repository. O nome deve ser na forma username.github.io, como disse acima.

Agora, vamos clonar o repositório. Se você nunca usou git ou github antes, o tutorial listado acima é essencial para continuar.

Copie o link SSH para clonar seu repositório, e execute o comando:

git clone git@github.com:username/username.github.io

Isto vai criar uma pasta chamada username.github.io.

Entre na pasta, e vamos criar um arquivo chamado index.html, e este terá o seguinte conteúdo:

<html>
    <body>
        <h1>Olá! Github Pages é muito legal!</h1>
    </body>
</html>

Em seguida vamos fazer commit e push deste arquivo para nosso repositório.

git add .
git commit -m "primeiro commit"
git push origin main

Agora no github, na página do seu repositório, vamos clicar em Settings.

No menu lateral, na sessão Code and Automation selecione Pages. Então, em Branch selecione main.

Clique no botão Save.

Aguarde um tempo, geralmente menos de 1 minuto, e sua página do Github Pages estará no ar! Muito fácil, não?

No próximo post vamos juntar Pelican e Github Pages e estaremos mais próximos de ter nosso blog pronto para publicar :D

Espero que tenham gostado e não esqueçam de deixar suas opiniões e dúvidas nos comentários!

Até o próximo post!

Pelican Tutorial with Github Pages and CircleCI - 2

2022-08-08T09:30:00+02:00

Hello!

It’s time for us to continue the tutorial on how to publish your blog with Pelican, Github Pages and Circle CI like I did, and in case you’re getting here now, check out our previous tutorials

Today we are going to talk about Github Pages.

Github Pages is a free feature of Github that allows you to create a static website for your profile or projects. Usually these sites will have a URL like user.github.io or project.github.io. However, you can also put your own domain, as I did here.

For this tutorial, we’re going to use github pages for your user, so create a repository called username.github.io, where username is your username.

In the upper right corner of the site click on the + and select New Repository. The name must be in the form username.github.io, as said above.

Now, let’s clone the repository. If you’ve never used git or github before, the tutorial listed above is essential to continue.

Copy the SSH link to clone your repository, and run the command:

git clone git@github.com:username/username.github.io

This will create a folder called username.github.io.

Enter the folder, and we will create a file called index.html, and this will have the following content:

<html>
    <body>
        <h1>Hello! Github Pages is really cool!</h1>
    </body>
</html>

Next we will commit and push this file to our repository.

git add .
git commit -m "first commit"
git push origin main

Now on github, on your repository page, let’s click on Settings.

In the side menu, in the Code and Automation section select Pages. Then in Branch select main.

Click on the Save button.

Wait for a while, usually less than 1 minute, and your Github Pages page will be live! Very easy, no?

In the next post we will join Pelican and Github Pages and we will be closer to having our blog ready to publish :D

I hope you liked it and don’t forget to leave your opinions and questions in the comments!

See you in the next post!

Python 101 - Parte 5 - Estruturas de Repetição - While

2022-08-07T22:11:00+02:00

Olá!

Vamos continuar falando sobre Programação Básica no Python! Caso não tenha visto os tutoriais anteriores, já temos:

Hoje vamos falar de uma das estruturas mais importantes: o while.

O while é um comando que manda um bloco de código ser executado enquanto uma condição for satisfeita. Assim, permite que sejam criados loops de execução, assim como temos em jogos e aplicativos com interfaces gráficas.

O while é um comando muito útil, mas pode ser perigoso, pois se não tratarmos corretamente o critério de parada, o laço pode não ter fim, e o programa não faz o que deveria.

Vamos ver então um exemplo de como funciona o while em Python:

x = 100
while x > 0:
    print("x > 0")
    x = x - 1

Neste código, será mostrada a mensagem x > 0 até que x seja igual a zero. Quando o valor de x passar para 0, a verificação x>0 retornará falso, o programa sai do laço.

Vejamos agora este trecho de código:

i = 0
while True:
    print("Não vou parar nunca!")
    i = i + 1
    if i > 100:
        break

Aqui temos um laço que seria executado eternamente (while True:). Porém, dentro dele, fazemos uma verificação, e quando a variável i estiver guardando um valor maior que 100, será executado o comando break. O comando break literalmente quebra o laço, então, naquele instante, o programa sai do laço.

Se logo abaixo deste código fizéssemos um print(i), o valor mostrado seria 100.

Assim, juntamente ao comando while, vimos agora o comando break que pode ser muito útil para quebrar laços fora da comparação padrão.

Vejamos agora o seguinte trecho:

i= 0
while i < 100:
    i = i + 1
    if i % 2 == 0:
        continue
    print(i)

Inicialmente, i recebe o valor 0, e é comparado com 100. Como 0 é menor que 100, o laço começa. Logo em seguida, após incrementarmos o valor de i, temos uma comparação: if 1%2 == 0:. aqui verificamos se i é múltiplo de 2. Caso i seja múltiplo de dois, há um comando continue. continue faz com que esta iteração do laço termine e o programa passe para a próxima iteração. Desta forma, o programa ignora tudo o que está após o continue.

No caso de i não ser múltiplo de 2, o programa não executa o continue, e imprime o valor de i na tela.

Se um continue estivesse fora do if, sempre o programa executaria este continue, e nunca seria executado o que há após ele. Assim, o continue controla a execução do laço sem quebrá-lo.

Por enquanto é isso.

Nosso próximo post vai falar sobre a instrução for.

Não deixe de enviar dúvidas e opiniões nos comentários abaixo!

Até o próximo post!

Python 101 - Part 5 - Repetition Structures - While

2022-08-07T22:11:00+02:00

Hi!

Let’s keep talking about Basic Programming in Python! In case you haven’t seen the previous tutorials, we already have:

Today we are going to talk about one of the most important structures: the while.

The while is a statement that tells a block of code to be executed while a condition is satisfied. Thus, it allows execution loops to be created, as we have in games and applications with graphical interfaces.

while is a very useful statement, but it can be dangerous, because if we don’t handle the stopping criterion correctly, the loop may never end, and the program doesn’t do what it should.

Let’s see an example of how while works in Python:

x = 100
while x > 0:
    print("x > 0")
    x = x - 1

In this code, the message x > 0 will be displayed until x is equal to zero. When the value of x goes to 0, the check x>0 will return false, the program exits the loop.

Now let’s look at this code snippet:

i = 0
while True:
    print("I will never stop!")
    i = i + 1
    if i > 100:
        break

Here we have a loop that would run forever (while True:). However, inside it, we do a check, and when the i variable is storing a value greater than 100, the break command will be executed. The break command literally breaks the loop, so at that instant, the program exits the loop.

If just below this code we did a print(i), the value displayed would be 100.

So, along with the while command, we have now seen the break command which can be very useful for breaking loops outside the standard comparison.

Now let’s look at the following snippet:

i=0
while i < 100:
    i = i + 1
    if i % 2 == 0:
        continues
    print(i)

Initially, i is assigned the value 0, and is compared to 100. As 0 is less than 100, the loop starts. Soon after, after incrementing the value of i, we have a comparison: if 1%2 == 0:. here we check if i is a multiple of 2. If i is a multiple of two, there is a continue command. continue causes this iteration of the loop to end and the program moves on to the next iteration. This way, the program ignores everything after continue.

In case i is not a multiple of 2, the program does not execute continue, and prints the value of i on the screen.

If a continue were outside the if, the program would always execute this continue, and the one after it would never be executed. Thus, continue controls the execution of the loop without breaking it.

That’s it for now.

Our next post will talk about the for statement.

Be sure to post questions and opinions in the comments below!

See you in the next post!

Tutorial de Git e Github

2022-08-07T10:02:00+02:00

Olá!

Eu estava escrevendo a continuação do tutorial de pelican quando percebi que para falar de github pages, primeiro é importante falar de git e github para ter certeza que estamos todos alinhados mais adiante.

Então, o que é GIT?

Git é um sistema de gerenciamento de versões de código, ou seja, ele é usado para controlarmos alterações no código e é especialmente útil quando trabalhamos em colaboração, seja num time centralizado ou de forma distribuída como acontece com projetos open source, por exemplo.

Vou deixar aqui a página oficial onde você pode ver como instalar o GIT. Se você usa Windows, recomendo que use Git Bash, que faz parte da instalaço oficial, para interagir com repositórios GIT.

Dado que agora você tem git instalado no seu computador, vamos configurar seu github.

Crie sua conta no github, caso ainda não tenha.

No seu computador abra o terminal onde você usa o git. Vamos aqui gerar uma chave SSH para autenticar no github de forma segura. Entre o comando:

ssh-keygen

Você pode simplesmente usar as opções padrão. Elas não são as mais seguras mas acredito que sejam suficientes para início de conversa. Se você prover uma senha para sua chave SSH, terá de usá-la sempre que for usar o acesso ao github no terminal, por exemplo.

Após executar este comando, você terá criado um par de arquivos na pasta .ssh na sua pasta de usuário. Estes sœ id_rsa e id_rsa.pub.

Vamos precisar do conteúdo do arquivo id_rsa.pub.

Agora, na sua página do gihub, clique no ícone do seu usuário (canto superior direito da página) e nas opções, selecione Settings.

Ali, em Access selecione SSH and GPG keys. Clique no botão New SSH Key.

Copie o conteúdo do arquivo id_rsa.pub e cole em Key, Dê algum nome relevante e salve.

Agora seu github está configurado.

Crie então um repositåorio no github atraves do botão + no canto superior direito ao lado do menu de usuário.

Você verá uma página com instruções de como clonar seu repositório. Selecione a opção SSH ecopie o link.

No terminal, gigite:

git clone git@github.com:username/repositorui.git

Onde você vai substituir o git@github.com:username/repositorui.git pela URL que copiou do github. Ela deve ter este formato também, começando com git@github.com.

Entre na pasta criada e crie um arquivo, pode ter qualquer nome, como README.md por exemplo e escreva algo nele.

Agora você precisa informar ao git que ele deve guardar as mudanças deste repositório, então digite.

git add .
git commit -m "primeiro commit"

Agora vamos enviar este arquivo para o github com um comando de push.

git push origin main

Pronto! Você deu seus primeiros passos com Git e Gihub!

Espero que tenham gostado e não esqueçam de deixar seuas opiniões e dúvidas nos comentários!

Até o próximo post!

Tutorial de Git e Github

2022-08-07T10:02:00+02:00

Hi!

I was writing the next post to the pelican tutorial when I realized that in order to talk about github pages, it’s important to first talk about git and github to make sure we’re all on the same page later on.

So what is GIT?

Git is a code version management system, that means, it is used to control code changes and is especially useful when we work in collaboration, either in a centralized team or in a distributed way as with open source projects, for example.

I’ll leave here the official page where you can see how to install GIT. If you use Windows, I recommend using Git Bash, which is part of the official package, to interact with GIT repositories.

Since you now have git installed on your computer, let’s configure your github.

Create your account on github if you still don’t have it.

On your computer open the terminal where you use git. Here we will generate an SSH key to authenticate to github securely. Enter the command:

ssh-keygen

You can just use the default options. They are not the safest but I believe they are good enough to start using it. If you provide a password for your SSH key, you will have to use it whenever you use github access on the terminal, for example.

After running this command, you will have created a couple of files in the .ssh folder in your home folder. These are id_rsa and id_rsa.pub.

We will need the contents of the id_rsa.pub file.

Now, on your gihub page, click on your user icon (top right of the page) and from the options select Settings.

There, under Access select SSH and GPG keys. Click on the New SSH Key button.

Copy the contents of the id_rsa.pub file and paste it in Key, Give it some relevant name and save.

Now your github is set up.

Then create a repository on github via the + button in the upper right corner next to the user menu.

You will see a page with instructions on how to clone your repository. Select the SSH option and copy the link.

In the terminal, type:

git clone git@github.com:username/repositorui.git

Where you will replace git@github.com:username/repositorui.git with the URL you copied from github. It should have this format as well, starting with git@github.com.

Enter the created folder and create a file, it can have any name, like README.md for example and write something in it.

Now you need to tell git that it should save changes in this repository, so type.

git add .
git commit -m "first commit"

Now let’s push this file to github with a push command.

git push origin main

Done! You’ve taken your first steps with Git and Gihub!

I hope you liked it and don’t forget to leave your opinions and questions in the comments!

See you in the next post!

Python 101 - Parte 4 - Estruturas Condicionais em Python, o Retorno

2022-08-02T22:06:00+02:00

Olá!

Continuando o artigo sobre Estruturas Condicionais em Python, veremos agora algumas outras fomas de usar a construção if/else.

Caso não tenha visto os tutoriais anteriores, já temos:

Muitas vezes, não é possível resolver um problema computacional simplesmente com um if/else. Então, usamos vários conjuntos de if/else aninhados (um dentro do outro)

caminho = 3
if caminho == 0:
    print("Volte para a posicao inicial")
else:
    if caminho == 1:
        print("Siga em frente")
    else:
        if caminho == 2:
            print("Abaixe a cabeca")
        else:
            if caminho == 3:
                print("Você caiu no buraco")
            else:
                print("Opcao invalida")

Mas, dá pra perceber que, se você tiver uma estrutura muito grade de condições, seu código vai ficar bem bagunçado… imagina trinta if/else aninhados dessa forma? Não dá!

Então, pra resolver este problema, temos a construção if/elif/else. O elif faz o papel das sequências de else que contém if. Veja como o código fica muito mais legível e organizado!

d = 4

if d > 0:
    print("d é positivo")
elif d < 0:
    print("d é negativo")
else:
    print("d é nulo")

Você pode ter quantos elif forem necessários entre o if e o else. Veja este exemplo:

opcao = 2
if opcao == 0:
    print "O valor escolhido foi 0"
elif opcao == 1:
    print "O valor escolhido foi 1"
elif opcao == 2:
    print "O valor escolhido foi 2"
elif opcao == 3:
    print "O valor escolhido foi 3"
else:
    print "O valor escolhido não é válido"

O código continua organizado e legível, ajudando no entendimento do programa!

Provavelmente, neste ponto, as pessoas que conhecem C, C++, java ou algumas outras linguagens devem estar se perguntando: Mas cadê o switch?

Na realidade, python não tem um switch como temos em outras linguagens, sendo que sua função é muito bem cumprida pelas estruturas ‘if’/’elif’/’else’. Estas estruturas ainda tem vantagens sobre algumas implementações do switch que por exemplo somente fazem comparações de inteiros e caracteres únicos.

É possível simular um switch de forma muito eficiente e elegnte no Python, mas isto ficará para um próximo post com conteúdo mais avançado.

Vamos ficando por aqui.

No próximo tópico, falaremos de Estruturas de Repetição!

ão deixe de enviar dúvidas e opiniões nos comentários abaixo!

Até o próximo post!

Python 101 - Part 4 - Conditionals in Python, the Return

2022-08-02T22:06:00+02:00

Continuing the article series on Conditional Structures in Python, we will now look at some other ways to use the if/else instructions.

I you haven’t seen our previous tutorials, check here:

It is often not possible to solve a computational problem simply with an if/else. So we use multiple nested if/else sets (one inside the other)

path = 3
if path == 0:
    print("Go back to the starting position")
else:
    if path == 1:
        print("Go ahead")
    else:
        if path == 2:
            print("Lower your head")
        else:
            if path == 3:
                print("You fell in the hole")
            else:
                print("Invalid option")

But, you can see that if you have a very nested structure of conditions, your code will be very messy… imagine thirty if/else instructions nested like that? It gets crazy!

So, to solve this problem, we have the if/elif/else construct. The elif plays the role of the else sequences that contain an if. See how the code is much more readable and organized!

d = 4

if d > 0:
    print("d is positive")
elif d < 0:
    print("d is negative")
else:
    print("d is null")

You can have as many elif as needed between if and else. See this example:

option = 2
if option == 0:
    print "The value chosen was 0"
elif option == 1:
    print "The value chosen was 1"
elif option == 2:
    print "The value chosen was 2"
elif option == 3:
    print "The value chosen was 3"
else:
    print "The chosen value is not valid"

The code remains organized and readable, helping you to understand the code!

Probably, at this point, people who know C, C++, java or some other languages must be asking themselves: But where’s the switch?

Actually, python doesn’t have a switch like we have in other languages, and its function is very well fulfilled by the ‘if’/’elif’/’else’ structures. These structures still have advantages over some switch implementations that for example only do integer and single character comparisons.

It is possible to simulate a switch very efficiently and elegantly in Python, but that will be left for a next post with more advanced content.

In the next topic, we’ll talk about Repetition Structures!

Don’t forget to send your questions and opinions in the comments below!

See you in the next post!

Python 101 - Parte 3 - Estruturas Condicionais em Python

2022-08-01T23:06:00+02:00

Olá!

Continuando nossa série introdutória sobre Python, vamos falar um pouco sobre as estruturas condicionais.

Caso não tenha visto os tutoriais anteriores, já temos:

As estruturas condicionais são essenciais na programação. Sem elas, os programas seriam chatos, monótonos, e nunca teriam a capacidade toda que temos atualmente.

Sem estruturas condicionais não haveria jogos eletrônicos!!!!

Então, vejamos como o Python implementa suas estruturas condicionais.

A principal estrutura condicional do Python (e mais usada também) é a construção if/else ou sua variação if/elif/else.

if, traduzindo do inglês quer dizer se, e else senão, logo, estas construções nos permitem orientar a execução de um trecho de código. Se isso, faz aquilo, senão, faz aquilo outro…

Veja abaixo um exemplo de utilização do if/else:

x = 3
if x % 2 == 0:
    print("x é par")
else:
    print("x é impar")

Este código analisa o valor da variável x. Se x % 2 (o resto da divisão de x por 2) for igual a zero, então o número é par, senão, é impar. Veremos mais funções matemáticas em posts futuros.

Ao digitar estes comando no terminal, ficaria assim:

>>> x = 3
>>> if x % 2 == 0:
...     print("x é par")
... else:
...     print("x é impar") 
...
x e impar

Recapitulando o que foi dito no texto sobre blocos de código em Python, quando temos um bloco identado logo abaixo de um comando terminado em :, temos um bloco que está diretamente relacionado a este comando.

No exemplo, temos o comando if x%2==0: e logo abaixo o print "x é par" identado. Isto quer dizer que o código identado (print("x é par")) somente será executado se o resto da divisão de x por 2 for zero.

Caso este resultado seja diferente de zero, x não é par, e o interpretador encontra o comando else:.

Logo abaxo deste comando, temos print("x é impar") que está identado, mostrando ao interpretador que este é o comando que deve ser executado caso a comparação dentro do if seja falsa.

Não vamos esticar o assunto. Por enquanto paramos por aqui, mas espere que logo teremos a continuação pra você!

Não deixe de enviar dúvidas e opiniões nos comentários abaixo!

Até o próximo post!

Python 101 - part 3 - Python Conditional Structures

2022-08-01T23:06:00+02:00

Hi!

Continuing our introductory Python series, let’s talk a little about conditional structures.

I you haven’t seen our previous tutorials, check here:

Conditional structures are essential in programming. Without them, programs would be boring, monotonous, and would never have been able to do what they do today.

Without conditional structures there would be no video games!!!!

So, let’s see how Python implements its conditional structures.

Python’s main conditional structure (and most used as well) is the if/else construct or its if/elif/else variation.

These constructions will guide us through the execution of a code snippet. If this, do that, if not, do that other thing…

Below is an example of using if/else:

x = 3
if x % 2 == 0:
    print("x is even")
if no:
    print("x is odd")

This code parses the value of the variable x. If x % 2 (the remainder of dividing x by 2) is equal to zero, then the number is even, otherwise it is odd. We will see more math functions in future posts.

When typing these commands in the terminal, it would look like this:

>>> x = 3
>>> if x % 2 == 0:
... print("x is even")
... if no:
... print("x is odd")
...
x is odd

To recap what was said in the text about blocks of code in Python, when we have a block identified just below a command ending in :, a block that is directly related to this command.

In the example, we have the command if x%2==0: and just below the print "x is even" identified. This means that the code identified (print("x is even")) will only be executed if the remainder of the division x by 2 is zero.

If this result is non-zero, x is not even, and the interpreter encounters the command else:.

Below this command, print which is identified as the case which is interpreted which should be executed in comparison within thefalse if`).

We will not cherish the matter. For now we stop here, but hope that soon we will have a sequel for you!

Feel free to post questions and comments in the comments below!

Until the next post!

Tutorial de Pelican com Github Pages e CircleCI - 1

2022-07-31T22:03:00+02:00

Olá!

Como prometido, vamos abordar como criei meu blog com Pelican, Github Pages e CircleCI num tutorial. Como é bastante conteúdo vamos dividir em partes e aqui veremos uma introdução ao Pelican.

Recapitulando, Pelican é um gerador de site estático, ou seja, gera um site estático em HTML baseado em conteúdos escritos numa linguagem de Markup, geralmente rich text ou markdown. Pelican gera as postagens usando Jinja2 como biblioteca de template. Assim, se você tem alguma familiaridade com jinja ou Django, que tem uma biblioteca de templates semelhante, você não vai ter dificuldades em por exemplo criar ou customizar temas para o Pelican.

Primeiro, para criar um site com Pelican, vamos instalá-lo.

Pode ser num ambiente virtual ou diretamente na sua instalação padrão do python. No terminal, execute:

pip install pelican[markdown]

Isto vai instalar o Pelican com suporte a Markdown, que é minha linguagem de markup preferida.

Finalizando sua instalação, vamos criar um site Pelican.

Crie uma pasta onde ficará seu site, para executarmos comandos lá de dentro. No Linux, seria algo assim:

mkdir ~/projetos/meu_blog/ -p
cd ~/projetos/meu_blog

Então, agora vamos executar um comando do Pelican que vai iniciar nosso blog.

pelican-quickstart

Este script vai te perguntar diversas coisas.

> Where do you want to create your new web site? [.] 
> What will be the title of this web site? 
> Who will be the author of this web site? 
> What will be the default language of this web site? [pt] 
> Do you want to specify a URL prefix? e.g., https://example.com   (Y/n)
> Do you want to enable article pagination? (Y/n)
> What is your time zone? [America/Sao_Paulo] 
> Do you want to generate a tasks.py/Makefile to automate generation and publishing? (Y/n)

Vamos nos manter no mais simples possível para este tutorial introdutório, então responda

(Somente digite `Enter`)
Teste
Teste
(Somente digite `Enter`)
n
n
(Somente digite `Enter`)
n

Assim, o Pelican vai criar um projeto bastante simplificado que podemos usar para iniciar nosso blog. Num próximo post, vamos executar novamente este comando para criar realmente o blog que vamos publicar, mas aqui como é somente para introduzir o Pelican vamos manter a simplicidade.

Agora vamos criar nosso primeiro post exemplo. Veja que o Pelican criou uma estrutura de arquivos assim na pasta do blog:

content/
pelicanconf.py
publishconf.py

Dentro da pasta content, crie um arquivo, vamos chamá-lo de teste.md (Muito criativo :p). Nele insira o seguinte conteúdo

Title: Teste
Date: 2022-07-31 08:00
Category: Geral

Olá! Este é meu primeiro post com Pelican!

Isto é o suficiente para um post com Pelican. Título, data, categoria e o conteúdo em si.

Agora vamos rodar um servidor de teste e ver o que nosso blog.

pelican -r -l

O resultado deve ser algo assim:

  --- AutoReload Mode: Monitoring `content`, `theme` and `settings` for changes. ---
Serving site at: http://127.0.0.1:8000 - Tap CTRL-C to stop
[22:56:36] WARNING  Docutils has no localization for 'pt'. Using 'en' instead.                                                                                                                                                                                                                                       log.py:91
        WARNING  Watched path does not exist: /home/jcemelanda/projetos/myblog/content/images                                                                                                                                                                                                                     log.py:91

-> Modified: settings, content, theme. re-generating...
Done: Processed 1 article, 0 drafts, 0 hidden articles, 0 pages, 0 hidden pages and 0 draft pages in 0.06 seconds.

Acesse o endereço indicado http://127.0.0.1:8000

Esta deve ser a aparência do seu blog.

Agora abra seu arquivo pelicanconf.py. Seu conteúdo deve ser aproximadamente este:

AUTHOR = 'teste'
SITENAME = 'TESTE'
SITEURL = ''

PATH = 'content'
TIMEZONE = 'America/Sao_Paulo'

DEFAULT_LANG = 'pt'

# Feed generation is usually not desired when developing
FEED_ALL_ATOM = None
CATEGORY_FEED_ATOM = None
TRANSLATION_FEED_ATOM = None
AUTHOR_FEED_ATOM = None
AUTHOR_FEED_RSS = None

# Blogroll
LINKS = (('Pelican', 'https://getpelican.com/'),
        ('Python.org', 'https://www.python.org/'),
        ('Jinja2', 'https://palletsprojects.com/p/jinja/'),
        ('You can modify those links in your config file', '#'),)

# Social widget
SOCIAL = (('You can add links in your config file', '#'),
        ('Another social link', '#'),)

DEFAULT_PAGINATION = False

# Uncomment following line if you want document-relative URLs when developing
#RELATIVE_URLS = True

Este arquivo é bem autoexplicativo. Aqui é nele que mexemos para a maioria das configurações do Pelican.

Finalmente, abra o publishconf.py. Seu conteúdo deve ser aproximadamente este:

# This file is only used if you use `make publish` or
# explicitly specify it as your config file.

import os
import sys
sys.path.append(os.curdir)
from pelicanconf import *

# If your site is available via HTTPS, make sure SITEURL begins with https://
SITEURL = ''
RELATIVE_URLS = False

FEED_ALL_ATOM = 'feeds/all.atom.xml'
CATEGORY_FEED_ATOM = 'feeds/{slug}.atom.xml'

DELETE_OUTPUT_DIRECTORY = True

# Following items are often useful when publishing

#DISQUS_SITENAME = ""
#GOOGLE_ANALYTICS = ""

Veja que este arquivo importa de pelicanconf, logo, aqui você consegue sobrescrever configurações, te permitindo ter uma configuração para seu ambiente onde escreve os posts e outra para a efetiva publicação do site.

No momento, estas informações são suficientes para prosseguirmos, então, não perca a próxima parte deste tutorial onde vamos falar sobre Github pages para depois juntarmos as duas coisas :D

Espero que tenham gostado e não esqueçam de deixar suas opiniões e dúvidas nos comentários!

Até o próximo post!

Pelican tutorial with Github Pages and CircleCI - 1

2022-07-31T22:03:00+02:00

Hi!

As promised, we’ll cover how I created my blog with Pelican, Github Pages and CircleCI in a tutorial. As it is a lot of content, we will divide it into parts and here we will see an introduction to Pelican.

To recap, Pelican is a static site generator, that is, it generates a static HTML site based on content written in a Markup language, usually rich text or markdown. Pelican generates the posts using Jinja2 as the template library. So, if you have some familiarity with jinja or Django, which has a similar template library, you won’t have any difficulties in, for example, creating or customizing themes for Pelican.

First, to create a website with Pelican, let’s install it.

It can be in a virtual environment or directly in your default python installation. In the terminal, run:

pip install pelican[markdown]

This will install Pelican with Markdown support, which is my favorite markup language.

Finishing your installation, let’s create a Pelican website.

Create a folder where your site will be, so we can run commands from there. On Linux it would be something like this:

mkdir ~/projects/my_blog/ -p
cd ~/projects/my_blog

So now let’s run a Pelican command that will start our blog.

pelican-quickstart

This script will ask you several questions.

> Where do you want to create your new web site? [.]
> What will be the title of this web site?
> Who will be the author of this web site?
> What will be the default language of this web site? [en]
> Do you want to specify a URL prefix? e.g., https://example.com (Y/n)
> Do you want to enable article pagination? (Y/n)
> What is your time zone? [America/New_York]
> Do you want to generate a tasks.py/Makefile to automate generation and publishing? (Y/n)

Let’s keep it as simple as possible for this introductory tutorial, so answer

(Just type `Enter`)
Test
Test
(Just type `Enter`)
no
no
(Just type `Enter`)
no

So Pelican will create a very simplified project that we can use to start our blog. In a next post, we’ll run this command again to actually create the blog we’re going to publish, but here, as it’s just to introduce Pelican, let’s keep it simple.

Now let’s create our first example post. See that Pelican created a file structure like this in the blog folder:

content /
pelicanconf.py
publishconf.py

Inside the content folder, create a file, let’s call it teste.md (Very creative :p). In it insert the following content

Title: Test
Date: 2022-07-31 08:00
Category: General

Hi! This is my first post with Pelican!

This is enough for a post with Pelican. Title, date, category and the content itself.

Now let’s run a test server and see what our blog looks like.

pelican -r -l

The result should be something like this:

  --- AutoReload Mode: Monitoring `content`, `theme` and `settings` for changes. ---
Serving site at: http://127.0.0.1:8000 - Tap CTRL-C to stop
[22:56:36] WARNING Docutils has no localization for 'pt'. Using 'en' instead. log.py:91
        WARNING Watched path does not exist: /home/jcemelanda/projects/myblog/content/images log.py:91

-> Modified: settings, content, theme. re-generating...
Done: Processed 1 article, 0 drafts, 0 hidden articles, 0 pages, 0 hidden pages and 0 draft pages in 0.06 seconds.

Access the indicated address http://127.0.0.1:8000

This should be what your blog looks like.

Now open your pelicanconf.py file. Your content should look like this:

AUTHOR = 'test'
SITENAME = 'TEST'
SITEURL = ''

PATH = 'content'
TIMEZONE = 'America/New_York'

DEFAULT_LANG = 'en'

# Feed generation is usually not desired when developing
FEED_ALL_ATOM = None
CATEGORY_FEED_ATOM = None
TRANSLATION_FEED_ATOM = None
AUTHOR_FEED_ATOM = None
AUTHOR_FEED_RSS = None

# blogroll
LINKS = (('Pelican', 'https://getpelican.com/'),
        ('Python.org', 'https://www.python.org/'),
        ('Jinja2', 'https://palletsprojects.com/p/jinja/'),
        ('You can modify those links in your config file', '#'),)

# Social widget
SOCIAL = (('You can add links in your config file', '#'),
        ('Another social link', '#'),)

DEFAULT_PAGINATION = False

# Uncomment following line if you want document-relative URLs when developing
#RELATIVE_URLS = True

This file is very self explanatory. This is where we tweak most of the Pelican settings.

Finally, open publishconf.py. Your content should look like this:

# This file is only used if you use `make publish` or
# explicitly specify it as your config file.

import them
import sys
sys.path.append(os.curdir)
from pelicanconf import *

# If your site is available via HTTPS, make sure SITEURL begins with https://
SITEURL = ''
RELATIVE_URLS = False

FEED_ALL_ATOM = 'feeds/all.atom.xml'
CATEGORY_FEED_ATOM = 'feeds/{slug}.atom.xml'

DELETE_OUTPUT_DIRECTORY = True

# Following items are often useful when publishing

#DISQUS_SITENAME = ""
#GOOGLE_ANALYTICS = ""

See that this file imports from pelicanconf, so here you can overwrite configurations, allowing you to have a configuration for your environment where you write posts and another for the effective publication of the site.

For the moment, this information is enough to go on, so don’t miss the next part of this tutorial where we’ll talk about Github pages and then put the two together :D

I hope you liked it and don’t forget to leave your opinions and questions in the comments!

See you in the next post!

Python 101 - Segunda Parte

2022-07-29T12:06:00+02:00

Olá!

Agora que já temos o Python instalado e já conhecemos a sua interface interativa, vamos aprender um pouco sobre os comandos mais básicos da linguagem!

Caso não tenha visto os tutoriais anteriores, já temos:

Introdução ao Python

Como visto, no shell Python, temos dois cursores:

>>>
...

Ao fazermos um if, estrutura condicional que será explicada em mais detalhes num próximo post, temos o seguinte no console:

>>> x = 0
>>> if x < 1:
...     print("x é menor que 1")
... 
x é menor que 1

Agora, a explicação =]

Na primeira linha, dizemos que a variável x contém o valor 0; Em seguida, comparamos o valor contido em x com 1. Ao terminarmos um comando com : o interpretador entende que este é um comando que não acabou no final daquela linha, e que é composto por mais comandos, então surge o cursor secundário ....

Então, muitos programadores habituados com outras linguagens devem se perguntar onde estão as chaves pra determinar o bloco.

No Python, os blocos são determinados pela identação (ou edentação, ou endentação… já vi várias formas da palavra).

As linhas que estão dentro do if, ou seja o que deve ser executado caso a comparação seja verdadeira deve estar identado.

Em geral é uma convenção, no Python, usarmos 4 espaços para a identação.

O print("x é menor que 1") é o comando que deve ser executado se a comparação x < 1 for verdadeira. Assim, esta linha está identada, e o interpretador sabe que só deve executá-la caso x seja menor que 1.

Quando você dá um ENTER no final desta linha, o interpretador te mostra novamente o cursor secundário, pois um if pode ter vários comandos ali dentro. Como veremos mais adiante a execução de um programa todo pode estar dentro de um if.

Assim, só depois de um segundo ENTER é que o interpretador executa o comando e mostra o resultado.

Então, recapitulando:

Blocos em Python são definidos pela identação
A identação deve seguir um padrão, preferencialmente em todos os programas
É convenção usar 4 espaços para identação
No interpretador, blocos identados são precedidos do cursos secundário …
Um bloco indica um trecho de código que está dentro de outro comando

Por enquanto é só!

No próximo post aproveitamos a deixa, e falamos sobre estruturas condicionais em Python!

Não deixe de deixar dúvidas e opiniões nos comentários abaixo!

Até o próximo post!

Python 101 - Segunda Parte

2022-07-29T12:06:00+02:00

Hi!

Now that we have Python installed and we already know its interactive interface, let’s learn a little about the most basic commands of the language!

I you haven’t seen our previous tutorials, check here:

Introdution to Python

As seen, in the Python shell we have two cursors:

>>>
...

When we make an if, conditional structure that will be explained in more detail in a next post, we have the following in the console:

>>> x = 0
>>> if x < 1:
...     print("x is less than 1")
...
x is less than 1

Now the explanation =]

In the first line, we say that the variable x contains the value 0; Next, we compare the value contained in x with 1. When we end a command with : the interpreter understands that this is a command that did not end at the end of that line, and that it is composed of more commands, so the secondary cursor ... gets in the game.

So, many programmers used to other languages must ask themselves where are the curly braces to determine the block.

In Python, blocks are determined by indentation.

The lines that are inside the if, ie what must be executed if the comparison is true must be indented.

It is generally a convention, in Python, to use 4 spaces for the indentation.

The print("x is less than 1") is the command that should be executed if the comparison x < 1 is true. Thus, this line is indented, and the interpreter knows that it should only execute it if x is less than 1.

When you press ENTER at the end of this line, the interpreter shows you the secondary cursor again, because an if can have several commands inside. As we will see later, the execution of an entire program can be inside an if.

Thus, only after a second ENTER does the interpreter execute the command and display the result.

So, let’s recap:

Blocks in Python are defined by indentation
The indentation must follow a pattern, preferably in all programs
It is convention to use 4 spaces for indentation
In the interpreter, indented blocks are preceded by the secondary cursor ...
A block indicates a snippet of code that is inside another command

That’s all for now!

In the next Python 101 post we take the hint, and talk about conditional structures in Python!

Be sure to leave your questions and opinions in the comments below!

See you in the next post!

Python 101 - Primeira Parte

2022-07-29T01:06:00+02:00

Bom, um blog com o nome Programe em Python não pode ficar sem um tutorial básico de Python, né?

Antes de mais nada, se você usa Linux ou MacOS você provavelmente já tem o Python então você está com sorte.

No windows, vá à página de downloads do Python e baixe dali a versão mais recente.

Quando terminar o download, execute o instalador e siga as instruções de instalação.

Lembre-se de marcar a opção para inserir Python nos caminhos do sistema (Add Python to PATH), pois isto vai facilitar muito a sua vida.

Quando o Python estiver finalmente instalado, numa janela de linha de comando, (CMD ou powershell no Windows) digite Python e você deve ver algo semelhante a isto.

Veja que na primeira linha você consegue ver qual a versão do Python, e na última linha há um prompt esperando pelos seus comandos.

>>>

Este prompt será usado neste blog sempre para denotar que devemos escrever código no console do Python.

Faça um teste. Digite, seguido de ENTER:

>>> print('Olá Mundo!')

O resultado deve ser algo assim:

>>> print('Olá Mundo!')
Olá Mundo!

Isto significa que o console do Python já te retorna as respostas para os comando logo em seguida de você executá-los. Veja por exemplo:

>>> 23*256/98+3
63.08163265306123

Finalmente, quando formos executar códigos com blocos, como if por exemplo, será assim:

>>> if True:
...     print('É verdade!')
...
É verdade!

Assim, note que os 3 pontos ... são indicadores de bloco de código no terminal do Python, ou seja, indicam que um comando iniciado acima ainda não foi terminado. Desta forma, precisamos inserir uma linha em branco para o Python perceber que finalizamos aquele comando e ele pode então executá-lo.

Acho que este é um bom momento para finalizarmos esta primeira parte do tutorial :D

Não deixem de comentar abaixo com sua opinião e dúvidas!

Até o próximo post!

Python 101 - First Part

2022-07-29T01:06:00+02:00

Well, a blog with the name Programe em Python can’e exist without a basic Python Tutorial, right?

First things first, if you are using Linux or OSX you most probably already have Python installed, so you are a lucky person ;)

On windows, go to the Python downloads page and download the most recent version from there.

When the download is complete, run the installer and follow the installation instructions.

Remember to check the option to insert Python in the system paths (Add Python to PATH), as this will make your life a lot easier.

When Python is finally installed, in a command line window (CMD or powershell on Windows) type Python and you should see something similar to this.

See that on the first line you can see the version of Python, and on the last line there is a prompt waiting for your commands.

>>>

This prompt will be used throughout this blog to denote that we must write code in the Python console. Try it. Type, followed by ENTER:

>>> print('Hello World!')

The result should be something like this:

>>> print('Hello World!')
Hello World!

This means that the Python console already returns the answers to the commands right after you execute them. See for example:

>>> 23*256/98+3
63.08163265306123

Finally, when we run code with blocks, like if for example, it will look like this:

>>> if(True):
... print('It's true!')
...
It's true!

So, note that the 3 dots ... are code block indicators in the Python terminal, that means they indicate that a command started above has not yet been finished. This way, we need to insert a blank line for Python to realize that we have finished that command and it can then execute it.

I think this is a good time to finish this first part of the tutorial :D

Don’t forget to comment below with your opinion and questions!

See you in the next post!

Porque Pelican

2022-07-25T22:03:00+02:00

Olá!

Eu andei avaliando se e como eu deveria retomar o blog, e depois de muitas ideias, aqui estamos, e acho que nada como começar falando um pouco sobre o processo de decisão para escolher fazer o blog em Pelican hospedado no Github Pages ao invés de qualquer outra plataforma.

Para isto acho que podemos começar com um pequeno histórico do blog.

Minha primeira versão do Programe em Python foi no Blogger. Era bastante fácil e prático de início, porém, para customizar as páginas era um tanto trabalhoso devido às especificidades dos templates HTML do Blogger.

Depois, migrei para uma solução django rodando no openshift da redhat. Eu adorava. 100% customizável, meus textos saiam bem como eu queria, mas depois de um tempo, o openshift teve mudanças pras quais eu demorei pra me atentar e tive que fazer um backup super corrido dos textos e infelizmente não consegui mais continuar com o blog.

Um tempo depois eu descobri github pages e pelican e fiz uma tentativa inicial, mas não estava num bom momento e o projeto mais uma vez não foi pra frente.

Agora, quando decidi retomar o blog tive que escolher entre continuar usando github pages e pelican ou procurar uma nova plataforma.

Minha escolha teve alguns pontos decisivos.

O blog é um site estático e dificilmente vou precisar de muito mais do que um site estático pode me oferecer, dado que o Pelican simplifica muito a postagem dos textos e acrescentar as páginas.
Git é um sistema que eu uso diariamente e que eu sempre recomendo, além de permitir versionamento dos texto, o que pode ser bastante útil, eu posso escrever de basicamente qualquer lugar e enviar facilmente para o github.
Pelican é um gerador de sites estáticos, que me permite facilmente acrescentar novos posts ao blog, escrevendo com Markdown

Alguns pontos precisei levar em consideração são que o Pelican não tem um suporte nativo no Github Pages como tem o Jekyll por exemplo, e para ter busca e outras features, precisei de alguns plugins do pelican. Isto aumenta um pouco as complexidades, porém não o suficiente para me desanimar.

Algo que eu fiz também foi implementar um workflow no CircleCI para publicar a postagem quando eu fizer um commit na branch do blog, assim, a publicação que dependeria de eu rodar alguns comandos do pelican fica automatizada.

Uma pergunta que pode ficar é, por que usei Pelican no lugar de Jekyll ou Hugo por exemplo?

Minha ideia neste sentido foi bem simples. Eu queria um gerador de site estático feito em Python. Assim, se eu eu sentir que preciso de algo ou que tem um bug eu posso trabalhar na mudança facilmente.

Também, Pelican usa Jinja2 para os templates, e esta biblioteca eu já usei diversas vezes, além de ser parecida com a biblioteca de templates do Django.

Assim, aqui estamos. Um blog usando Pelican para gerar o site, o host sendo o sistema de pages do github, e com CircleCI automatizando as publicações quando eu envio os posts.

Espero que tenham gostado. Quer saber mais sobre como funciona o Pelican, ou como criar seu próprio blog usando esta stack?

Deixe seu comentário!

Te vejo no próximo psot!

Porque Pelican

2022-07-25T22:03:00+02:00

Hi!

I’ve been thinking about how and if I should restart blogging, and after a long brainstorm, here we are, and I think nothing could be better here than to talk a little about the thinking process of my decision to use Pelican hosted on Github Pages instead of any other platform.

So, I think we can start with a little timeline of my blog’s history.

My first version of Programe em Python was hosted on Blogger. It was quite easy and practical at first, but, it wasn’t that easy to customize the pages because it has some very specific things on it’s HTML.

After that I migrated to a django solution running on RedHat’s Openshift. I used to love it. It was 100% customizable, my texts wen’t through exectly as I wanted them to be, but after a while, opeshift changed it’s rules and I took to long to notice as I wasn’t on the best of my moments at that time. In the end I had to make a backup in a hurry, ando unfortunately I couldnt go on with the blog after that.

Some time later I found out about Github Pages and pelican, and I took my changes, but it wasn’t still a good moment for me and the project once again stalled.

Now, when I decided to blog again, I had to choose between going on with Github Pages + Pelican or to look for something else that would fit me as I wanted.

I had some decisive points to consider.vos.

The blog is mostly a static content website and it would hardly ever need much more than a static site given that with Pelican it’s quite easy to add new articles and pages.
Git is something I use daily and I always recommend, besides that it would allow me to blog from basically anywhere. Also, I would have my posts in a version control system, and that can come in handy sometimes.
Pelican is a nice piece of software, allowing me to add new posts easily throuhg git and using Markdown.

Some issues that I had to find workarounds for include the fact that Pelican is not natively supported by Github Pages like Jekyll for example, and to be able to have search and some other things I’d need Pelican plugins, increasing a bit the complexity of using it. But it wasn’t enough to let me down.

One of the workarounds were the creation of a CircleCI workflow that generates the static site and commits to the proper branch of Github when I add a content to the work branch of the repo. This way, publishing the content wouldn’t anymore depend on me running pelican commands locally.

One question you may ask is why I decided to use Pelican instead of Jekyll or Hugo for example?

My thought in that case was simple. I wanted a python software for that. So if I ever need to bugfix or improve something, I’ll be working with the language I know the most.

Besides that, Pelican uses Jinja2 for then templates, and that’s a library I have already used and it kind of resembles the Django template system too.

So, here we are. A blog using Pelican to generate the static site, hosted on Github Pages and CircleCI to automate the publishing of the posts when I push them.

I hope you enjoyed this little post. If you would like to know more about how Pelican works or how to create your own blog using this setup, let me know in the comments below!

See you in the next post!

Um novo começo

2022-07-21T11:52:00+02:00

Estamos aqui mais uma vez recomeçando este lindo blog que tem como intuito ensinar python e também compartilhar um pouco das minhas experiências e desafios com esta tão amada tecnologia.

Você pode esperar que este site tenha sempre conteúdos de qualidade, e você pode tirar todas as dúvidas diretamente comigo nos comentários ou redes sociais :D

Até o próximo post!

A new beggining

2022-07-21T11:52:00+02:00

Here I am once again starting this beautiful blog over aiming to teach python and also share some of my experiences and challenges with this beloved technology.

Here you can expect that this blog will have always quality content, and you can eliminate your doubts directly with me or on social networks :D

See you in the next post!