Tipos de dados nativos

Outros tipos de dados nativos

Só numeros e caracteres é insuficiente para representar nossos algoritmos. O Python oferece outros (cinco) tipos de dados pré definidos e extremamente poderosos para suportar programação em geral e que veremos à seguir. Na verdade Python é uma linguagem orientada a objetos e isto permite usuários definirem novos tipos de dados que acharem convenientes, mas para nós os cinco tipos nativos provavelmente são suficientes. Pelo menos no início.

Os tipos de dados nativos do Python que iremos usar bastante são:

1. strings
2. lists
3. tuples
4. sets
5. dictionaires

Cada um destes tipos de dados tem um conjunto de funções associadas para manipulá-lo. No que se segue vamos mostrar cada tipo e algumas de suas funções (methods) específicas.

Strings

Strings são sequências ordenadas de caracteres indexados começando em 0 e imutáveis. Oportunamente veremos algo sobre codificação, ASCII, Unicode e similares, mas isto só nos concerne na medida em que precisemos ler arquivos externos e será comentado quando necessário.
Vejamos exemplos:

In [21]:

s = 'abcd'              # a variável s tem como valor o string abcd
print(s)
l = len(s)              # len() é uma função do Python que retorna o comprimento de um objeto
print(l)
print(s[0])             # s[0] é o caracter de índice 0 do string s
print(s[2])

abcd
4
a
c

O operador + (soma) aplicado entre dois strings permite concatenar os dois strings num terceiro string que é o resultado desta "soma":

In [4]:

r = ' são quatro letras'
print(s + r)

abcd são quatro letras

Trechos de texto de várias linhas são usados para comentar algoritmos em cabeçalhos. Tambem podem ser usados para definir strings de várias linhas:

In [5]:

s1 = '''Quando visitar Roma
não deixe de ver o Vaticano.
Seus mármores assombrosos teriam sido
reciclados dos palácios imperiais
no monte Palatino.'''

Como foi mencionado strings são objetos que possuem diversas funções associadas para sua manipulação. A forma de usar tais funções é apendar um ponto (.) ao string seguido do nome da função desejada. Por exemplo:

In [6]:

# splitlines() é uma função membro de strings que devolve uma lista das linhas contidas no string
s1.splitlines()

Out[6]:

['Quando visitar Roma',
 'não deixe de ver o Vaticano.',
 'Seus mármores assombrosos teriam sido',
 'reciclados dos palácios imperiais',
 'no monte Palatino.']

Observe como o Python retornou uma lista de linhas separadas por virgulas e listadas entre chaves quadradas.
Strings podem ser repetidos diversas vêzes usando operador multiplicador * e um numero, desta forma:

In [8]:

s2 = 3*s + 'xy'
print(s)
print(s2)

abcd
abcdabcdabcdxy

Já vimos que caracteres num string são indexados, começando por 0. Às vêzes queremos algum caracter contando do final para o começo do string. Para isto existe a conveniência de índices negativos: -1 é o último caracter, -2 seu predecessor e assim por diante:

In [9]:

print(s[-1])
print(s[-2])

d
c

Além de indexação dos caracteres strings também tem a utilíssima operação de "fatiagem" (slicing). Usamos slicing para obter um pedaço de um string, como se cortassemos fora as partes sem interesse. Isto é feito especificando os índices do começo e do primeiro caracter que não interessa, separados por dois pontos:

In [15]:

print(s[0:2])
print(s[1:])        # deixando o número final ausente equivale a ir até o fim
print(s[:-1])       # deixando o número inicial ausente equivale a começar no 0. -1 é o último caracter.
print(s[-3:])       # imprima os três últimos caracteres

ab
bcd
abc
bcd

Existem muitas outras funções-membro úteis em strings. Aprenda elas na medida do necessário. Aí vão alguns exemplos:

In [17]:

S = s.upper()        # muda todos caracteres de s em maiúsculas, onde possível
print(S)

ABCD

In [18]:

print(S.lower())     # muda maiusculas em minusculas

abcd

Podemos querer saber quantas vêzes uma palavra (um substring) ocorre num texto. Alguem pensou nisto e temos um método adequado:

In [20]:

texto = '''mas problemas não se resolvem,
problemas têm família grande,
e aos domingos
saem todos a passear
o problema, sua senhora
e outros pequenos probleminhas'''
n = texto.count('problema')            # quantas ocorrências do substring 'problema'?
print(n)

3

Lists

Listas são um poderoso tipo de dados, tanto por razões teóricas quanto na prática. Usando listas podemos emular muitos outros tipos de dados, mas felizmente na prática e para nós isto não será necessário. Uma lista é uma sequência ordenada de elementos. Elementos podem ser objetos quaisquer, não precisam ser do mesmo tipo e, ao contrário dos caracteres de strings, podem ser modificados.
Lista são representadas com chaves quadradas e seus elementos separados por virgulas:

In [24]:

L = ['Esta','é', 'uma', 'lista', 'de','strings', 1, 2, 3]
print(L)

['Esta', 'é', 'uma', 'lista', 'de', 'strings', 1, 2, 3]

Listas também podem ser criadas pela função list() do Python:

In [68]:

v = list()            # cria uma lista vazia
print(v)
v = list('abcd')      # cria lista com elementos de um string
print(v)

[]
['a', 'b', 'c', 'd']

Existe um meio avançado de criar listas usando "comprehensions", um tipo avançado e muito útil de construtor. Voltaremos a isto mais adiante.

Listas tem indexação, como os strings:

In [27]:

print(L[2])
print(L[-1])
print(L[-5:])

uma
3
['de', 'strings', 1, 2, 3]

Mas, ao contrário de strings, os elementos de listas podem ser modificados:

In [28]:

print(L)
L[-4] = 777
print(L)

['Esta', 'é', 'uma', 'lista', 'de', 'strings', 1, 2, 3]
['Esta', 'é', 'uma', 'lista', 'de', 777, 1, 2, 3]

Uma lista pode ser criada vazia, isto é, sem nenhum elemento inicial. Elementos podem ser adicionados na lista a qualquer momento usando métodos do tipo list:

In [39]:

l1 = []            # criei uma lista vazia, sem nenhum elemento
print(l1)
l1.append(123)
print(l1)
l1.append('mais um')
print(l1)
l1.append(777)
print(l1)

[]
[123]
[123, 'mais um']
[123, 'mais um', 777]

Elementos indesejados podem ser removidos pelo método remove():

In [40]:

l1.remove('mais um')        # o elemento indesejado é dado como argumento
print(l1)

[123, 777]

Outro modo de remoção é o método pop() o qual remove sempre o último elemento da lista:

In [42]:

print(L)
L.pop()
print(L)
L.pop()
print(L)

['Esta', 'é', 'uma', 'lista', 'de', 777, 1, 2, 3]
['Esta', 'é', 'uma', 'lista', 'de', 777, 1, 2]
['Esta', 'é', 'uma', 'lista', 'de', 777, 1]

Listas podem ser extendidas e ter elementos inseridos em índices específicos:

In [44]:

print(l1)
l1.extend(['mais', 'uma', 'lista'])
print(l1)
l1.insert(3, '999')
print(l1)

[123, 777, 'mais', 'uma', 'lista']
[123, 777, 'mais', 'uma', 'lista', 'mais', 'uma', 'lista']
[123, 777, 'mais', '999', 'uma', 'lista', 'mais', 'uma', 'lista']

Listas também tem o operador + (soma) de mesma forma que strings. Duas listas podem ser concatenadas usando este operador:

In [45]:

l = [1,2,3]
l1 = [4,5,6]
print(l)
print(l1)
print(l + l1)

[1, 2, 3]
[4, 5, 6]
[1, 2, 3, 4, 5, 6]

Como os strings, listas também podem ser fatiadas:

In [47]:

l1 = L[2:5]
print(l1)
print(l1[-2])

['uma', 'lista', 'de']
lista

Como disse, listas podem ter qualquer tipo de elemento. Em particular podem ter outras listas como elementos:

In [50]:

lst = [1, 2, 3]
outra = ["a", 'b', 'c']
une = lst + outra
print(une)
une[1] = lst             # a lista lst vira elemento de indice 1 em une
print(une)
print(une[1:4])          # uma fatia da lista une
ele = une[1][2]          # pega elemento 1 de une e nele pega o elemento 2 
print(ele)

[1, 2, 3, 'a', 'b', 'c']
[1, [1, 2, 3], 3, 'a', 'b', 'c']
[[1, 2, 3], 3, 'a']
3

No ultimo exemplo observe algo que é padrão no Python: dado algum objeto você sempre pode invocar seus metodos ou demais propriedades. Ali o elemento une[1] é por acaso outra lista, então tudo que se aplica a uma lista também vale para este elemento, em particular ele é indexavel donde une[1][2] é perfeitamente válido.

Entre os muitos métodos aplicáveis a listas alguns são realmente da hora. Por exemplo frequentemente queremos saber se determinado objeto está numa lista ou não. Neste caso usamos o método in que funciona assim:

In [57]:

print(L)
'uma' in L         # 'uma' in L é uma expressão que necessariamente tem valor True ou False

['Esta', 'é', 'uma', 'lista', 'de', 777, 1]

Out[57]:

True

O operador in é um método da classe list e produz um resultado booleano, True ou False

In [58]:

print(88 in L)            # será que 88 é membro de L?

False

Python tem uma série de funções embutidas entre as quais todos conectivos de lógica booleana: and, or e not. Com isto podemos montar expressões mais complicadas, o que será muito útil para nossos algoritmos:

In [59]:

'uma' in L and 777 in L       # uma conjunção de duas expressões lógicas

Out[59]:

True

In [60]:

1 in L and 88 in L

Out[60]:

False

In [61]:

not 88 in L             # não é o caso que 88 está na lista L?

Out[61]:

True

In [66]:

88 in L or 1 in L       # 88 na lista L OU 1 na lista L?

Out[66]:

True

Em suma, listas são tipos de dados que modelam bem a maioria dos conceitos que vamos encontrar em nossos problemas.

Tuples

Tuples (enuplas) são sequências ordenadas e imutáveis de quaisquer objetos. O que torna tuples diferentes de listas é serem imutáveis, como os strings. Uma vez criada uma tupla seus elementos não podem mais ser modificados. Como listas, as tuplas são indexadas e podem ser fatiadas.
Tuplas são úteis para devolver resultados de funções, armazenar constantes e são mais rápidas que listas.
Tuplas podem ser construidas com elementos em fila separados por virgulas e entre parênteses:

In [70]:

tup = ('a', 'b', 'c')          # constroi uma tupla usando 3 elementos
tup

Out[70]:

('a', 'b', 'c')

In [77]:

t = ()          # constroi uma tupla vazia. existem casos onde isto é útil.
t

Out[77]:

()

In [71]:

tup[1]            # tuplas são indexadas

Out[71]:

'b'

In [73]:

tup[1:]            # tuplas podem ser fatiadas

Out[73]:

('b', 'c')

In [74]:

'b' in tup         # tuplas tem metodo de busca, como em listas

Out[74]:

True

In [75]:

'd' in tup

Out[75]:

False

Também existe uma função criadora de tuplas usando outros tipos de dados como argumento. Igual ao que vimos em listas.

In [78]:

t = tuple('ab7d89')      # cria tupla a partir de um string
t

Out[78]:

('a', 'b', '7', 'd', '8', '9')

In [79]:

t1 = 'a', 'b', 42, 'd'   # tuplas podem ser criadas de fila de objetos separados por virgulas
t1

Out[79]:

('a', 'b', 42, 'd')

Range

Range é um tipo de dados bastante útil que usaremos muito para contagem de repetições. Essencialmente um range "conta", incrementando a contagem por 1 cada vez que o objeto é acionado e termina a contagem qundo chegar a um valor determinado.
Um objeto range é construido por uma expressão que dá o número final da contagem e, opcionalmente, o número inicial (seu default é zero) e um "passo" ou incremento da contagem (seu default é 1).

In [82]:

list(range(10))   # vai criar uma lista com os valores da contagem um a um

Out[82]:

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

In [83]:

list(range(21,27,2))     # começando em 21, conte até 27 de 2 em 2

Out[83]:

[21, 23, 25]

In [84]:

list(range(100, 70, -10)) # contagem decrescente de 100 a 70 contando de 10 em 10

Out[84]:

[100, 90, 80]

E com isto termina esta lição. Na próxima veremos os tipos de dados set e dict e começaremos com comandos.