Aula 1

Nesta aula, vamos ver como utilizar o conceito de Notebooks para aprendermos o básico da linguagem Python.

Vamos ver como realizar operações matemáticas básicas, como importar bibliotecas para realizar comandos mais específicos a cada domínio, e vamos estudar um pouco da sintaxe básica da linguagem e conceitos de programação, como blocos de repetição (for, while) e condicionais (if).

É claro que não será um tratamento exaustivo da linguagem; estudaremos estes conceitos durante todo o curso, e também veremos outras estruturas mais avançadas conforme houver necessidade para a resolução dos nossos problemas.

Variáveis e Operações Matemáticas Básicas

Antes de tudo, o console Python (interpretador) pode ser visto como uma calculadora:


In [1]:
a = 1
b = 7
print(a+b)


8

(Observe que podemos incluir várias linhas em uma mesma célula em um Notebook, usando a tecla ENTER. Para executar uma célula e passar para a próxima, usamos SHIFT+ENTER)

As variáveis não precisam ser "declaradas" em Python, e seu tipo não é fixo.


In [2]:
a = 1

In [3]:
print(a)


1

In [4]:
a = "Teste"

In [5]:
print(a)


Teste

No entanto, o Python só reconhece variáveis às quais algum valor foi atribuido:


In [6]:
print(c)


---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-6-1dd5973cae19> in <module>()
----> 1 print(c)

NameError: name 'c' is not defined

As operações matemáticas estão bem definidas:


In [7]:
a = 5
b = 2
a+b


Out[7]:
7

In [8]:
a-b


Out[8]:
3

In [9]:
b-a


Out[9]:
-3

In [10]:
b*a


Out[10]:
10

A potenciação é realizada usando-se o operador **


In [11]:
b**a


Out[11]:
32

In [12]:
b/a


Out[12]:
0.4

Atenção: o Python converteu automaticamente os números (que eram inteiros) em números reais, para que a divisão pudesse ser realizada. A divisão só se comporta assim no Python 3 (no Python 2, essa conversão não é automática).

Strings

Para tratarmos palavras, frases e outras sequências de caracteres, usamos aspas (simples ou duplas)


In [13]:
palavra = "maria julia"

In [14]:
print(palavra)


maria julia

As strings, como chamamos estas sequências de caracteres, são tratadas pelo Python como objetos. (Na realidade, todos os tipos de dados em Python podem ser vistos como objetos! Discutiremos isso mais à frente)

Para entender o que podemos fazer com estes objetos, usamos


In [15]:
dir(palavra)


Out[15]:
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rmod__',
 '__rmul__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'capitalize',
 'casefold',
 'center',
 'count',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'format_map',
 'index',
 'isalnum',
 'isalpha',
 'isdecimal',
 'isdigit',
 'isidentifier',
 'islower',
 'isnumeric',
 'isprintable',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'maketrans',
 'partition',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill']

Para aplicarmos algum desses métodos à variável palavra, vamos usar a seguinte sintaxe:


In [16]:
palavra.capitalize()


Out[16]:
'Maria julia'

In [17]:
palavra.upper()


Out[17]:
'MARIA JULIA'

Observe que na linha anterior, a aplicação do método upper à string palavra não modificou a string original:


In [18]:
palavra


Out[18]:
'maria julia'

In [19]:
palavra.islower()


Out[19]:
True

Para sobrescrevermos o novo valor à variável palavra, usamos


In [20]:
palavra = palavra.upper()

In [21]:
palavra


Out[21]:
'MARIA JULIA'

In [22]:
palavra.islower()


Out[22]:
False

Podemos chamar métodos de maneira encadeada:


In [23]:
palavra.lower().isupper()


Out[23]:
False

Em Python, diferenciamos entre métodos, que são aplicados a objetos (sempre da forma objeto.metodo()) e funções, que tem a forma funcao(argumento)


In [24]:
print(palavra.upper())


MARIA JULIA

Podemos descobrir quantos caracteres estão na string palavra, usando a função len


In [25]:
len(palavra)


Out[25]:
11

(Para uma explicação de por que usamos uma função len ao invés de um método, veja http://lucumr.pocoo.org/2011/7/9/python-and-pola/)

Se já sabemos o nome do método que desejamos usar, podemos obter mais informações sobre ele usando a função help:


In [26]:
help(palavra.split)


Help on built-in function split:

split(...) method of builtins.str instance
    S.split(sep=None, maxsplit=-1) -> list of strings
    
    Return a list of the words in S, using sep as the
    delimiter string.  If maxsplit is given, at most maxsplit
    splits are done. If sep is not specified or is None, any
    whitespace string is a separator and empty strings are
    removed from the result.


In [27]:
palavra.split?

O resultado do método split é uma lista de strings:


In [28]:
palavra.split()


Out[28]:
['MARIA', 'JULIA']

Se quisermos separar palavras usando outros caracteres que não sejam o espaço (whitespace), podemos indicar qual separador a ser usado:


In [29]:
palavra = "Melissa: dois pontos"

In [30]:
palavra.split()


Out[30]:
['Melissa:', 'dois', 'pontos']

In [31]:
palavra.split(sep=":")


Out[31]:
['Melissa', ' dois pontos']

In [32]:
palavra.split(sep=" ")


Out[32]:
['Melissa:', 'dois', 'pontos']

Na verdade, uma string pode ser pensada como uma lista de letras; assim, podemos acessar cada letra separadamente, como um dos itens dessa lista. (No Python, o primeiro elemento de uma lista tem índice 0)


In [33]:
palavra[2]


Out[33]:
'l'

No entanto, uma lista é um tipo de objeto distinto em Python. Podemos transformar uma string em uma lista através da função list:


In [34]:
list(palavra)


Out[34]:
['M',
 'e',
 'l',
 'i',
 's',
 's',
 'a',
 ':',
 ' ',
 'd',
 'o',
 'i',
 's',
 ' ',
 'p',
 'o',
 'n',
 't',
 'o',
 's']

Exemplo


In [35]:
frase = "O dia está lindo!"

O método rstrip, associado a uma string, remove o caracter escolhido pelo usuário do final da string.


In [36]:
frase = frase.rstrip("!")

In [37]:
frase


Out[37]:
'O dia está lindo'

In [38]:
pedacos = frase.split()

In [39]:
print(pedacos)


['O', 'dia', 'está', 'lindo']

A função type informa que tipo de objeto temos:


In [40]:
type(pedacos)


Out[40]:
list

In [41]:
type(frase)


Out[41]:
str

(str, na linha acima, indica que frase é um objeto do tipo string.)

Listas


In [42]:
palavra = "melissa"

In [43]:
lista_palavra = ["melissa"]

Observe que palavra é uma string, e por isso os métodos que podem ser aplicados a esta variável são os métodos associados a um objeto do tipo string, enquanto que lista_palavra é uma lista, com métodos associados a um objeto do tipo lista:


In [44]:
dir(lista_palavra)


Out[44]:
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

Também podemos saber quantos itens tem uma lista:


In [45]:
len(lista_palavra)


Out[45]:
1

In [46]:
letras = list(palavra)

In [47]:
print(letras)


['m', 'e', 'l', 'i', 's', 's', 'a']

O acesso a cada elemento de uma lista é feito da mesma maneira como acessamos os caracteres de uma string (lembrando que o índice do primeiro elemento de uma lista, no Python, é 0)


In [48]:
letras[0]


Out[48]:
'm'

Alguns métodos especiais que são bastante interessantes:

O método append acrescenta ao final da lista algum item (neste caso, uma string)


In [49]:
pedacos.append("!")

In [50]:
pedacos


Out[50]:
['O', 'dia', 'está', 'lindo', '!']

In [51]:
pedacos.append("!")

In [52]:
pedacos


Out[52]:
['O', 'dia', 'está', 'lindo', '!', '!']

O método insert acrescenta um item à lista, na posição indicada:


In [53]:
pedacos.insert(3,"mais")

In [54]:
pedacos


Out[54]:
['O', 'dia', 'está', 'mais', 'lindo', '!', '!']

Em Python, o operador del pode ser usado para excluir um item de uma lista, dado seu índice:


In [55]:
del pedacos[3]

In [56]:
pedacos


Out[56]:
['O', 'dia', 'está', 'lindo', '!', '!']

No entanto, é mais usual excluirmos um item da lista usando o método pop (que exclui um item selecionado pelo seu índice, assim como o operador del) ou o método remove (que remove um item da lista selecionado pelo seu valor):


In [57]:
pedacos.remove("está")

In [58]:
pedacos


Out[58]:
['O', 'dia', 'lindo', '!', '!']

O método pop é interessante pois retorna, ao final de sua execução, o valor do item que foi removido:


In [59]:
pedacos.pop(3)


Out[59]:
'!'

Podemos também descobrir o índice de um item da lista, dado seu valor:


In [60]:
pedacos.index("dia")


Out[60]:
1

Para descobrirmos se determinado valor está em uma lista, usamos a seguinte sintaxe:


In [61]:
"!" in pedacos


Out[61]:
True

Observe que na lista pedacos, cada entrada também pode ser vista como uma lista!


In [62]:
pedacos[1]


Out[62]:
'dia'

In [63]:
pedacos[1][0]


Out[63]:
'd'

In [64]:
pedacos[0]


Out[64]:
'O'

(Fim da Aula 1, ministrada em 13/09/2016)


In [ ]: