python-and-jupyter-notebooks.ipynb

Kernel: Python 3

Introdução ao Python e Jupyter notebooks

Python é uma linguagem de programação em que você não precisa compilar. Você pode simplesmente executá-lo linha por linha (que é como podemos usá-lo em um notebook). Portanto, se você é novo em programação, o Python é um ótimo lugar para começar. A versão atual é o Python 3, que é o que usaremos aqui.

Uma maneira de programar em Python é usar o Jupyter notebook. Esta é provavelmente a melhor maneira de combinar programação, texto e imagens. Em um notebook, tudo é organizado em células. As células de texto e as células de código são as mais comuns. Se você estiver visualizando esta seção como um notebook, o texto que está lendo agora está em uma célula de texto. Uma célula de código pode ser encontrada logo abaixo.

Para executar o conteúdo de uma célula de código, você pode clicar nela e pressionar Shift + Enter. Ou se houver uma pequena seta à esquerda, você pode clicar nela.

1 + 1

2

Se você estiver visualizando esta seção como um notebook ,
execute cada uma das células de código enquanto lê.

a = 1
b = 0.5
a + b

1.5

Acima, criamos duas variáveis, que chamamos de a e b, e demos valores a elas. Então nós as somamos. Aritmética simples como essa é bem fácil de ser realizada em Python.

Variáveis em Python podem se apresentar em diversas formas. Abaixo estão alguns exemplos.

an_integer = 42 # Apenas um inteiro
a_float = 0.1 # Um número não inteiro, com precisão fixada
a_boolean = True # Um valor que pode ser True ou False
a_string = '''just enclose text between two 's, or two "s, or do what we did for this string''' # Texto
none_of_the_above = None # A ausência de qualquer valor atual ou tipo de variável

Além dos números, outra estrutura de dados que podemos usar é a lista.

a_list = [0,1,2,3]

Listas em Python podem conter qualquer mistura de tipos de variáveis.

a_list = [ 42, 0.5, True, [0,1], None, 'Banana' ]

As listas em Python são indexadas a partir do 0 (ao contrário de linguagens como Fortran). Veja como você acessa o 42 no início da lista acima.

a_list[0]

42

Uma estrutura de dados semelhante é a tupla.

a_tuple = ( 42, 0.5, True, [0,1], None, 'Banana' )
a_tuple[0]

42

Uma grande diferença entre a lista e a tupla é que os elementos da lista podem ser alterados

a_list[5] = 'apple'

print(a_list)

[42, 0.5, True, [0, 1], None, 'apple']

enquanto os elementos de tupla não podem

a_tuple[5] = 'apple'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-9-42d08f1e5606> in <module>
----> 1 a_tuple[5] = 'apple'

TypeError: 'tuple' object does not support item assignment

Além disso, podemos adicionar um elemento ao final de uma lista, o que não podemos fazer com tuplas.

a_list.append( 3.14 )

print(a_list)

[42, 0.5, True, [0, 1], None, 'apple', 3.14]

Outra estrutura de dados útil é o dicionário. Isso armazena um conjunto de valores, cada um rotulado por uma chave exclusiva.

Os valores podem ser qualquer tipo de dados. As chaves podem ser qualquer coisa suficientemente simples (integer, float, boolean, string). Não pode ser uma lista, mas pode ser uma tupla.

a_dict = { 1:'Este é o valor, para a chave 1', 'Esta é a chave para o valor 1':1, False:':)', (0,1):256 }

Os valores são acessados usando as chaves

a_dict['Esta é a chave para o valor 1']

1

Novos pares de chave/valor podem ser adicionados apenas fornecendo o novo valor para a nova chave

a_dict['nova chave'] = 'novo_valor'

Para fazer um loop em um intervalo numérico, a sintaxe é

for j in range(5):
    print(j)

0
1
2
3
4

Observe que começa em 0 (por padrão) e termina em n-1 para range(n).

Você também pode fazer um loop sobre qualquer objeto 'iterável', como listas

for j in a_list:
    print(j)

42
0.5
True
[0, 1]
None
apple
3.14

ou dicionários

for key in a_dict:
    value = a_dict[key]
    print('key =',key)
    print('value =',value)
    print()

key = 1
value = Este é o valor, para a chave 1

key = Esta é a chave para o valor 1
value = 1

key = False
value = :)

key = (0, 1)
value = 256

key = nova chave
value = novo_valor

Os comandos condicionais são feitos com if, elif e else utilizando a seguinte sintaxe.

if 'strawberry' in a_list:
    print('We have a strawberry!')
elif a_list[5]=='apple':
    print('We have an apple!')
else:
    print('Not much fruit here!')

We have an apple!

A importação de pacotes é feita da seguinte forma

import numpy

O pacote numpy é importante para fazer cálculos

numpy.sin( numpy.pi/2 )

1.0

Temos que escrever numpy. na frente de cada comando numpy para que ele saiba como encontrar esse comando no pacote numpy. Para encurtar a escrita, é comum usar

import numpy as np

np.sin( np.pi/2 )

1.0

Então você só precisa do nome abreviado. A maioria das pessoas usa np, mas você pode escolher o que quiser.

Você também pode importar tudo diretamente do numpy com

from numpy import *

Então você pode usar os comandos diretamente. Mas isso pode fazer com que os pacotes interfiram uns nos outros, então use com cuidado.

sin( pi/2 )

1.0

Se você quer fazer trigonometria, álgebra linear etc, pode usar o numpy. Para plotagem, use matplotlib. Para teoria dos grafos, use networkx. Para computação quântica, use qiskit. Para o que você quiser, provavelmente haverá um pacote para ajudá-lo

Uma coisa boa de se saber em qualquer linguagem é como fazer uma função.

Aqui está uma função, cujo nome escolhido foi do_some_maths, suas entradas são chamadas Input1 e Input2 e sua saída é chamada the_answer.

def do_some_maths ( Input1, Input2 ):
    the_answer = Input1 + Input2
    return the_answer

A função é usada da seguinte forma

x = do_some_maths(1,72)
print(x)

73

Se você der um objeto a uma função e a função chamar um método desse objeto para alterar seu estado, o efeito persistirá. Então, se isso é tudo que você quer fazer, você não precisa usar o return. Por exemplo, vamos fazer isso com o método append de uma lista.

def add_sausages ( input_list ):
    if 'sausages' not in input_list:
        input_list.append('sausages')

print('List before the function')
print(a_list)

add_sausages(a_list) # function called without an output

print('\nList after the function')
print(a_list)

List before the function
[42, 0.5, True, [0, 1], None, 'apple', 3.14]

List after the function
[42, 0.5, True, [0, 1], None, 'apple', 3.14, 'sausages']

A aleatoriedade pode ser gerada usando o pacote random.

import random

for j in range(5):
    print('* Results from sample',j+1)
    print('\n    Random number from 0 to 1:', random.random() )
    print("\n    Random choice from our list:", random.choice( a_list ) )
    print('\n')

* Results from sample 1

    Random number from 0 to 1: 0.9565207808448243

    Random choice from our list: 3.14


* Results from sample 2

    Random number from 0 to 1: 0.2965136670559021

    Random choice from our list: sausages


* Results from sample 3

    Random number from 0 to 1: 0.5742595097667611

    Random choice from our list: 3.14


* Results from sample 4

    Random number from 0 to 1: 0.8530438802121619

    Random choice from our list: True


* Results from sample 5

    Random number from 0 to 1: 0.1329354419675386

    Random choice from our list: None

Estes são os fundamentos. Agora tudo que você precisa é um mecanismo de busca e a intuição para saber quem vale a pena ouvir no Stack Exchange. Então você pode fazer qualquer coisa com Python. Seu código pode não ser o mais 'Pythonico', mas apenas Pythonistas realmente se importam com isso.