O Python é uma linguagem de programação de alto nível, interpretada, imperativa, orientada a objetos, de tipagem dinâmica e forte, que possui ainda as seguintes características:
- Não há pré-declaração de variáveis, e os tipos das variáveis são determinados dinamicamente.
- O controle de bloco é feito apenas por indentação; não há delimitadores do tipo BEGIN e END ou { e }.
- Oferece tipos de dados de alto nível: strings, listas, tuplas, dicionários, arquivos, classes.
- É orientada a objetos.
É uma linguagem moderna e adaptada para o desenvolvimento tanto de aplicações genéricas como científicas. Para aplicações científicas, o Python possui um pacote muito importante e eficiente para o processamento de arrays multidimensionais: Numpy.
Em sua forma nativa, o Python suporta os seguintes tipos de variáveis:
| Tipo Variável | Descrição | Exemplo de sintaxe |
|---|---|---|
| int | Variável inteira | a = 103458 |
| float | Variável de ponto flutuante | pi = 3.14159265 |
| bool | Variável booleana - True ou False | a = False |
| complex | Variável de número complexo | c = 2+3j |
| str | Variável para cadeia de caracteres ASCII | a = "Exemplo" |
| list | Lista heterogênea pode alterar os valores | lista = [4,'eu',1] |
| tuple | Tupla heterogênea imutável | tupla = (1,'eu',2) |
| dict | Conjunto associativo de valores | dic = {1:'eu',2:'você'} |
In [1]:
a = 3
print(type(a))
b = 3.14
print(type(b))
c = 3 + 4j
print(type(c))
d = False
print(type(d))
print(a + b)
print(b * c)
print(c / a)
Observe que em operações envolvendo elementos de tipos diferentes a linguagem realiza a conversão dos elementos ao tipo adequado, conforme a seguinte hierarquia: complexo > ponto flutuante > inteiro
Python possui três tipos sequenciais principais: listas, tuplas e cadeia de caracteres (string).
Pode-se declarar strings tanto usando aspas simples como duplas ou triplas. Strings são vetores imutáveis compostos de caracteres. Pode-se calcular o tamanho do string usando-se len.
In [2]:
nome1 = 'Faraday'
nome2 = "Maxwell"
print('string do tipo:', type(nome1), 'nome1:', nome1, "comprimento:", len(nome1))
String é um vetor imutável de caracteres. É possível indexar um caractere único e é possível aplicar regras consistentes do Python no tratamento de sequências, tais como fatiamento (slicing) e formas de indexação. Em Python, o primeiro elemento é sempre indexado como zero, assim quando tenho um string de 5 caracteres, ele é indexado de 0 a 4. É possível também indexar os elementos da direita para a esquerda utilizando índices negativos. Assim, o último elemento do vetor pode ser indexado pelo índice -1.
In [3]:
print('Primeiro caractere de ', nome1, ' é: ', nome1[0])
print('Último caractere de ', nome1, ' é: ', nome1[-1])
print('Repetindo-se strings 3 vezes', 3 * nome1)
In [4]:
lista1 = [1, 1.1, 'um'] # Listas podem conter elementos de diferentes tipos.
lista2 = [3+4j, lista1] # Inclusive uma lista pode conter outras listas como elementos!
print('tipo da lista1=', type(lista1))
print('lista2=', lista2)
lista2[1] = 'Faraday' #Diferentemente das strings, pode-se atribuir novos valores a elementos da lista.
print('lista2=', lista2)
lista3 = lista1 + lista2 # Concatenando 2 listas
print('lista3=',lista3)
print('concatenando 2 vezes:',2*lista3)
Tupla é similar a lista, porém seus valores são imutáveis. Tupla é uma sequência de objetos separados por vírgulas que podem, opcionalmente, serem iniciados e terminados por parênteses. Tupla contendo um único elemento precisa ser seguido de uma vírgula.
O entendimento da tupla é muito importante e ela
será bastante utilizada neste curso, pois muitos parâmetros do ndarray do NumPy utilizando tuplas.
In [5]:
#Declarando tuplas
tupla1 = () # tupla vazia
tupla2 = ('Gauss',) # tupla com apenas um elemento. Note a vírgula.
tupla3 = (1.1, 'Ohm', 3+4j)
tupla4 = 3, 'aqui', True
print('tupla1=', tupla1)
print('tupla2=', tupla2)
print('tupla3=', tupla3)
print('tupla4=', tupla4)
print('tipo da tupla3=', type(tupla3))
In [6]:
s = 'abcdefg'
print('s=',s)
print('s[0:2] =', s[0:2]) # caracteres a partir da posição 0 (inclusivo) até 2 (exclusivo)
print('s[2:5] =', s[2:5]) # caracteres a partir da posição 2 (inclusivo) até 5 (exclusivo)
Quando o início for zero e o final for o comprimento do string, ele pode ser omitido. Veja os exemplos:
In [7]:
s = 'abcdefg'
print('s=',s)
print('s[:2] =', s[:2]) # caracteres a partir do início até 2 (exclusivo)
print('s[2:] =', s[2:]) # caracteres a partir da posição 2 (inclusivo) até o final do string
print('s[-2:] =', s[-2:]) # últimos 2 caracteres
Note que a posição de início é sempre inclusiva e a posição final é sempre exclusiva.
Isto é feito para que a concatenação entre s[:i] e s[i:] seja igual a s.
O slicing permite ainda um terceiro valor que é opcional: step.
Para quem é familiarizado com a linguagem C, os 3 parâmetros do slicing é similar ao for:
comando for |
slicing |
|---|---|
for (i=inicio; i < fim; i += passo) a[i] |
a[inicio:fim:passo] |
Veja exemplos de indexação usando slicing num string de 7 caracteres, indexados de 0 a 6:
| slice | indices | explicação |
|---|---|---|
| 0:5 | 0,1,2,3,4 | vai de 0 até 4 que é menor que 5 |
| 2:5 | 2,3,4 | vai de 2 até 4 |
| 0:5:2 | 0,2,4 | vai de 0 até 4, pulando de 2 em 2 |
| ::2 | 0,2,4,6 | vai do início até o final de 2 em 2 |
| :5 | 0,1,2,3,4 | vai do início até 4, que é menor que 5 |
| 3: | 3,4,5,6 | vai de 3 até o final |
| ::-1 | 6,5,4,3,2,1,0 | vai do final (6) até o início |
Veja estes exemplos aplicados no string 'abcdefg':
In [8]:
s = 'abcdefg'
print('s=',s)
print('s[2:5]=', s[2:5])
print('s[0:5:2]=',s[0:5:2])
print('s[::2]=', s[::2])
print('s[:5]=', s[:5])
print('s[3:]=', s[3:])
print('s[::-1]=', s[::-1])
Este conceito de *slicing* será essencial neste curso. Ele pode ser aplicado em strings,
tuplas, listas e principalmente no ``ndarray`` do NumPy. Procure entendê-lo integralmente.
Tanto strings, tuplas como listas podem ser desempacotados através de atribuição. O importante é que o mapeamento seja consistente. Lembrar que a única sequência que é mutável, isto é, pode ser modificada por atribuição é a lista. Procure estudar os exemplos abaixo:
In [9]:
s = "abc"
s1,s2,s3 = s
print('s1:',s1)
print('s2:',s2)
print('s3:',s3)
list = [1,2,3]
t = 8,9,True
print('list=',list)
list = t
print('list=',list)
(_,a,_) = t
print('a=',a)
In [10]:
s = 'formatação inteiro:%d, float:%f, string:%s' % (5, 3.2, 'alo')
print(s)
Existem ainda os Dicionários e Conjuntos, entretanto eles não serão utilizados durante este curso.
Dicionários podem ser definidos como sendo listas associativas que ao invés de associar os seus elementos a índices númericos, associa os seus elementos a palavras-chave.
In [22]:
dict1 = {'blue':135,'green':12.34,'red':'ocean'} #definindo um dicionário
print(type(dict1))
print(dict1)
print(dict1['blue'])
print(dict1.keys()) # Mostra as chaves do dicionário
del dict1['blue'] # Deleta o elemento com a chave 'blue'
print(dict1.keys()) # Mostra as chaves do dicionário após o elemento com a chave 'blue' ser apagado
In [23]:
lista1 = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
lista2 = ['red', 'blue', 'green','red','red']
conjunto1 = set(lista1) # Definindo um conjunto
conjunto2 = set(lista2)
print(conjunto1) # Observe que os elementos repetidos são contados apenas uma vez
print((type(conjunto1)))
print((conjunto1 | conjunto2)) # União de 2 conjuntos
In [ ]: