Introdução 6

Características iniciais - 6ª Parte

Continuando mais... Tipos de Dados...

Listas:

Listas são coleções heterogêneas de objetos, que podem ser de qualquer tipo, inclusive outras listas.
As listas no Python são mutáveis, podendo ser alteradas a qualquer momento. Listas podem ser fatiadas da mesma forma que as strings, mas como as listas são mutáveis, é possível fazer atribuições a itens da lista.
Sintaxe:
lista = [a, b, ..., z]

Exemplos:
lista_alimentos = ['Cebola', 'Tomate', 'Alho', 'Laranja']
# imprime toda a lista
for alimento in lista_alimentos:
    print (alimento)
    #Cebola
    #Tomate
    #Alho
    #Laranja    

# Troca o último item
lista_alimentos[-1] = 'Abacate'

# Inclui item
lista_alimentos.append('Manga')

# Remove item
lista_alimentos.remove('Alho')

# Ordena a lista
lista_alimentos.sort()

# Inverte a lista
lista_alimentos.reverse()

# Imprime novamente
for i, alimento in enumerate(lista_alimentos):
    print (i + 1, '=>', alimento)
    #1 => Tomate
    #2 => Manga
    #3 => Cebola
    #4 => Abacate    
--------------------------------------------------------------------
A função enumerate() é usada para percorrer uma lista enquanto mantém o controle dos índices dos itens da lista. Nos permite fazer um loop em algo e ter um contador automático. A função retorna um objeto enumerado. Exemplos:
my_list = ['apple', 'banana', 'grapes', 'pear']
for c, value in enumerate(my_list,1): #2º parâmetro: início da enum.

    print(c, value)
    #1 apple
    #2 banana
    #3 grapes

    #4 pear

No próximo exemplo, o objeto counter_list é uma lista de tuplas (listas imutáveis), cada uma contendo um par de índice e valor. Lembrando que a Lista é mutável, mas as Tuplas não. Exemplo:
my_list = ['apple', 'banana', 'grapes', 'pear']
counter_list = list(enumerate(my_list, 1))
print(counter_list)

#[(1, 'apple'), (2, 'banana'), (3, 'grapes'), (4, 'pear')]
--------------------------------------------------------------------
# Imprime do segundo item em diante
print (lista_alimentos[1:])
#['Manga', 'Cebola', 'Abacate']

Obs.: As operações de ordenação (sort) e inversão (reverse) são realizadas na própria lista, sendo assim, não geram novas listas.
Listas possuem o método pop() que facilita a implementação de filas e pilhas:
Exemplo:
lista = ['A', 'B', 'C']
print ('lista:', lista)
#lista: ['A', 'B', 'C']

# A lista vazia é avaliada como falsa
while lista:
    # Em filas, o primeiro item é o primeiro a sair
    # pop(0) remove e retorna o primeiro item
    print ('Saiu', lista.pop(0), ', faltam', len(lista))
    #Saiu A , faltam 2
    #Saiu B , faltam 1
    #Saiu C , faltam 0

# Mais itens na lista
lista += ['D', 'E', 'F']
print ('lista:', lista)
#lista: ['D', 'E', 'F']

while lista:
    # Em pilhas, o primeiro item é o último a sair
    # pop() remove e retorna o último item
    print ('Saiu', lista.pop(), ', faltam', len(lista))
    #Saiu F , faltam 2
    #Saiu E , faltam 1
    #Saiu D , faltam 0
--------------------------------------------------------------------
Tuplas: 

Semelhantes as listas, porém são imutáveis: não se pode acrescentar, apagar ou fazer atribuições aos itens.
Sintaxe:
tupla = (a, b, ..., z) #Os parênteses são opcionais.

Obs.: tupla com apenas um elemento é representada como: t1 = (1,)

Os itens de uma tupla são referenciados como os itens de uma lista: 
primeiro_item = tupla[0]

Listas podem ser convertidas em tuplas: tupla = tuple(lista)
Tuplas podem ser convertidas em listas: lista = list(tupla)

Embora a tupla possa conter elementos mutáveis, esses elementos não podem sofrer atribuição, pois isto modificaria a referência ao objeto.
Exemplo: 
t = ([1, 2], 4)
t[0].append(3)
print(t)
#([1, 2, 3], 4)
t[0] = [1, 2, 3] #'tuple' object does not support item assignment.

As tuplas são mais eficientes do que as listas, consome menos memória, por serem estruturas mais simples, como as strings imutáveis em relação às strings mutáveis.
--------------------------------------------------------------------
Dicionários:

É uma lista de associações formada por uma chave única e valores correspondentes. Dicionários são mutáveis, tais como as listas. A chave de um Dicionário precisa ser de um tipo imutável, geralmente são usadas strings, mas também podem ser tuplas ou tipos numéricos. Já os itens dos dicionários podem ser tanto mutáveis quanto imutáveis. O dicionário do Python não fornece garantia de que as chaves estarão ordenadas.
Sintaxe: 
dicionario = {'a': a, 'b': b, ..., 'z': z}

Exemplos:
cadastro = {'nome': 'Miriam', 'sexo': 'Feminino'}
#Acessar itens:
print (cadastro['nome'])
#Miriam

#Adicionar itens:
cadastro['idade'] = 32
print(cadastro)
#{'nome': 'Miriam', 'sexo': 'Feminino', 'idade': 32}

#Apagar um item:
del cadastro['sexo']
print(cadastro)
#{'nome': 'Miriam', 'idade': 32}

Obter os itens, chaves e valores:
itens = cadastro.items()
#dict_items([('nome', 'Miriam'), ('idade', 32)])
print(itens)

chaves = cadastro.keys()
print(chaves)
#dict_keys(['nome', 'idade'])

valores = cadastro.values()
print(valores)
#dict_values(['Miriam', 32])

Mais Exemplos com dicionários: 

cadastro_profissional = {
'Advogados': ['Miriam', 'Alexandre'],
'Programadores': ['Marco', 'Antonio']
}
# Mais cadastro_profissional
cadastro_profissional['Pedreiros'] = ['Expedito', 'Andre']
print(cadastro_profissional)
#{'Advogados': ['Miriam', 'Alexandre'], 'Programadores': ['Marco', 'Antonio'], 'Pedreiros': ['Expedito', 'Andre']}

#obs.: has_key() foi removido no Python 3, use in.

for chave, valor in cadastro_profissional.items():
    print (chave, '=>', valor)
    #Advogados => ['Miriam', 'Alexandre']
    #Programadores => ['Marco', 'Antonio']
    #Pedreiros => ['Expedito', 'Andre']

# Se tiver 'ELP' na chave, deleta
if 'Pedreiros' in cadastro_profissional:
    del cadastro_profissional['Pedreiros']
print(cadastro_profissional)
#{'Advogados': ['Miriam', 'Alexandre'], 'Programadores': ['Marco', 'Antonio']}
--------------------------------------------------------------------
Outros tipos de sequências:

O Python possui também os tipos de objetos(built-in):

• set: objeto de sequência mutável unívoca (sem repetições) não ordenada.
• frozenset: objeto de sequência imutável unívoca não ordenada.
• Os dois tipos implementam operações de conjuntos, tais como: união, interseção e diferença.

Exemplo:
# Conjuntos de dados
s1 = set(range(3))
s2 = set(range(10, 7, -1))
s3 = set(range(2, 10, 2))
print ('s1:', s1, '\ns2:', s2, '\ns3:', s3)
#s1: {0, 1, 2} 
#s2: {8, 9, 10} 
#s3: {8, 2, 4, 6}

# União
s1s2 = s1.union(s2)
print ('União de s1 e s2:', s1s2)
#União de s1 e s2: {0, 1, 2, 8, 9, 10}

# Diferença
print ('Diferença com s3:', s1s2.difference(s3))
#Diferença com s3: {0, 1, 10, 9}

# Interseção
print ('Interseção com s3:', s1s2.intersection(s3))
#Interseção com s3: {8, 2}

# Testa se um set inclui outro
if s1.issuperset([1, 2]):
    print ('s1 inclui 1 e 2')
#s1 inclui 1 e 2    

# Testa se não existe elementos em comum
if s1.isdisjoint(s2):
    print ('s1 e s2 não tem elementos em comum')
    #s1 e s2 não tem elementos em comum

Operações sobre set:
Exemplos:
var1 = set('Tutorial de Python')
print(var1)
print(type(var1))
#{'a', 'h', 'd', 'e', 'i', ' ', 'y', 't', 'u', 'l', 'T', 'P', 'o', 'n', 'r'}
#<class 'set'>

#Executar o codigo acima novamente:
#{'d', 'h', 'i', 'T', 'u', 'P', 'n', 'o', 'l', 'y', 'a', ' ', 't', 'e', 'r'}
#<class 'set'>
#Set não tem ordem definida para seus elementos: resultado aleatório

#Passar uma Lista para um set:
x = set(["Perl", "Python", "Java"])
print(x)
#{'Python', 'Java', 'Perl'}

#Passar um Tupla para um set (Valores repetidos no set não são mostrados):
cities = set(("Paris", "Lyon", "London","Berlin","Paris","Birmingham"))
print(cities)
#{'Paris', 'Birmingham', 'Lyon', 'London', 'Berlin'}

Converter tupla e list em set: 
cities = set((("Python","Perl"), ("Paris", "Berlin", "London")))
cities = set((["Python","Perl"], ["Paris", "Berlin", "London"]))
#list não é possivel pois set nao permite objetos mutaveis: gera o erro abaixo:
#Traceback (most recent call last):
#  File "C:\Users\M\Desktop\Python\exemplo.py", line 26, in <module>
#    cities = set((["Python","Perl"], ["Paris", "Berlin", "London"]))
#TypeError: unhashable type: 'list'

Exemplo de Frozensets (sets imutáveis):    
cities = frozenset(["Frankfurt", "Basel","Freiburg"])
cities.add("Strasbourg")
#Gera erro o método add():
#Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
#AttributeError: 'frozenset' object has no attribute 'add'
--------------------------------------------------------------------
Verdadeiro, falso e nulo:

Em Python, o tipo booleano (bool) é uma especialização do tipo inteiro (int). O verdadeiro é chamado True e é igual a 1, enquanto o falso é chamado False e é igual a zero.
Os seguintes valores são considerados falsos:

• False (falso).
• None (nulo).
• 0 (zero).
• '' (string vazia).
• [] (lista vazia).
• () (tupla vazia).
• {} (dicionário vazio).
• Outras estruturas com o tamanho igual a zero.

São considerados V todos os outros objetos fora dessa lista. 
O objeto None, que é do tipo NoneType, do Python representa o nulo e é avaliado como falso.
--------------------------------------------------------------------
Operadores booleanos:

Utilizados para especificar condições, controlar desvios condicionais e laços. Os operadores booleanos no Python são: 

• and: retorna V se e somente se receber duas expressões que forem V.
• or: retorna F se e somente se receber duas expressões que forem F.
• not: retorna F se receber uma expressão V e vice-versa.
• is: retorna V se receber duas referências ao mesmo objeto e F caso contrário.
• in: retorna V se receber um item e uma lista e o item ocorrer uma ou mais vezes na lista e F em caso contrário.

Cálculos do valor em operações lógicas:

• Com and ocorre da seguinte forma: se a 1ª expressão for V, o resultado será a 2ª expressão, senão será a 1ª. 
• Com or, se a 1ª expressão for F, o resultado será a 2ª expressão, senão será a 1ª. 

Exemplos:
print(0 and 3)
#0
print(2 and 3)
#3
print(0 or 3)
#3
print(2 or 3)
#2
print(not 0)
#True
print(not 2)
#False
print(2 in (2, 3))
#True
print(2 is 3)
#False

Além dos operadores booleanos, existe a função all(), que retorna V quando todos os itens forem V na sequência usada como parâmetro, e any(), que retorna V se algum item for igual.
Exemplos:
print(any(l == 't' for l in 'python'))
#Retorna True. É o mesmo que: 't' in 'python'
print(all(l == 't' for l in 'python'))
#Retorna False. Nem todas as letras são 't'
print(all(l == 'x' for l in 'xxx'))
#Retorna True. Todas as letras são 'x'
--------------------------------------------------------------------