4 - Tipos de dados

O tipo int é um número inteiro, positivo ou negativo, sem decimais, de comprimento ilimitado.

x = 1
y = 35656222554887711
z = -3255522
print(type(x))
print(type(y))
print(type(z))

<class 'int'>
<class 'int'>
<class 'int'>

O tipo float é um número de ponto flutuante, positivo ou negativo, contendo uma ou mais casas decimais.

x = 1.10
y = 1.0
z = -35.59
print(type(x))
print(type(y))
print(type(z))

<class 'float'>
<class 'float'>
<class 'float'>

O tipo float também podem usar notação científica com e para indicar a potência de 10.

x = 35e3
y = 12E4
z = -87.7e100
print(type(x))
print(type(y))
print(type(z))

<class 'float'>
<class 'float'>
<class 'float'>

Os números complexos são escritos com "j" na parte imaginária.

x = 3+5j
y = 5j
z = -5j
print(type(x))
print(type(y))
print(type(z))

<class 'complex'>
<class 'complex'>
<class 'complex'>

Valores numéricos podem ter o tipo convertido para outro com os métodos int(), float() e complex()

x = 1    # int
y = 2.8  # float
z = 1j   # complex
a = complex(x) # converter de int para complex
b = float(x) # converter de int para float
c = int(y) # converter de float para int
print(x, y, z)
print( a, b, c)
print(type(x), type(y), type(z))
print(type(a), type(b), type(c))

1 2.8 1j
(1+0j) 1.0 2
<class 'int'> <class 'float'> <class 'complex'>
<class 'complex'> <class 'float'> <class 'int'>

Nota: Números complexos não podem ser convertidos para outro tipo de número.

Python não tem uma função para gerar números aleatórios, mas tem o módulo embutido random.

import random
# número aleatório entre 1 e 9
print(random.randrange(1, 10))

9

A atribuição de um texto a uma variável é feita com a declaração do nome da variável seguido pelo sinal de igual e o texto entre aspas simples ou duplas.

a = "Alô!"
print(a)

Alô!

Um texto com várias linhas pode ser atribuido a uma variável com a utilização de três aspas simples ou duplas seguidas.

a = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""
#
b = '''Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.'''
#
print("--- a")
print(a)
#
print("--- b")
print(b)

--- a
Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.
--- b
Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.

Você pode retornar um intervalo de caracteres usando a sintaxe de fatiamento.

Especifique o índice inicial e o índice final, separados por dois pontos, para retornar uma parte de um texto.

No exemplo abaixo obtermos o texto compreendido entre a posição 2 (incluida) até a posição 8 (não incluída).

b = "Alô, mundo!"
print(b[2:8])

ô, mun

Nota: O primeiro caractere tem índice 0.

4.2.3.1 - Fatiamento do início

A omissão da posição inicial determinará o fatiamento a partir da primeira posição.

txt = "Alô, mundo!"
print(txt[:8])

Alô, mun

4.2.3.2 - Fatiamento até o final

A omissão da posição final determinará o fatiamento até a última posição.

txt = "Alô, mundo!"
print(txt[2:])

ô, mundo!

4.2.3.3 - Indexação negativa

Use índices negativos para iniciar o fatiamento a partir do final do texto.

No exemplo abaixo é retornado o texto da posição -2 (incluída) até a posição -5 (não incluída).

txt = "Alô, mundo!"
print(txt[-5:-2])

und

Python tem um conjunto de métodos integrados com textos.

4.2.4.1 - Letras maiúsculas

O método upper() retorna o texto com letras em maiúsculo, inclusíve as acentuadas.

a = "alô, mundo!"
print(a.upper())

ALÔ, MUNDO!

4.2.4.2 - Letras minúsculas

O método lower() retorna o texto com letras em minúsculo, inclusíve as acentuadas.

a = "ALÔ, MUNDO!"
print(a.lower())

alô, mundo!

4.2.4.3 - Remoção de espaços

Espaços no início ou final de textos são removidos com o método strip().

a = " Alô, mundo! "
print("|{}|".format(a))
print("|{}|".format(a.strip()))

| Alô, mundo! |
|Alô, mundo!|

4.2.4.4 - Substituição de texto

O método replace() de um texto substitui uma determinada sequência de caracteres por outro texto, sem alterar o texto original.

a = "Alô, mundo!"
b = a.replace("mundo", "Brasil")
print(a)
print(b)

Alô, mundo!
Alô, Brasil!

4.2.4.5 - Divisão de texto em lista

O método split() retorna uma lista de texto usando um separador especificado com as partes entre o separador como os itens da lista.

a = "Alô, mundo!"
print(a.split(",")) # retorna ['Alô', ' mundo!']

['Alô', ' mundo!']

4.2.4.6 - Concatenação

Para concatenar dois textos é utilizado o operador "+".

a = "Alô"
b = "mundo"
c = a + ", " + b
print(c)

Alô, mundo

Textos podem ser formatadas para exibição conforme necessário com o método format().

São adicionados marcadores de posição com {n} (colchetes), onde n é a posição argumento na formatação do texto.

Se n for omitido os argumentos da formatação serão apresentados na ondem em que os colchetes aparecem no texto.

A concatenação de textos e números com o operador "+" não é permitida e causa erro.

idade = 58
txt = "Tenho " + idade + " anos"

TypeError: can only concatenate str (not "int") to str <traceback object at 0x0000022CC060BEC0>

Combinamos textos e números utilizados como argumentos do método format() de um texto.

nome ="Roberto"
idade = 58
txt = "Meu nome é {} e tenho {} anos."
print(txt.format(nome,idade))

Meu nome é Roberto e tenho 58 anos.

O método format() recebe um número ilimitado de argumentos, colocados nos respectivos espaços reservados por colchetes.

quantidade = 3
num_item = 567
preco = 49.95
minha_ordem = "Eu quero {} unidades do item {} por {} reais."
print(minha_ordem.format(quantidade, num_item, preco))

Eu quero 3 unidades do item 567 por 49.95 reais.

A formatação pode ter um argumento apenas.

preco = 49
txt = "O preço é {} reais"
print(txt.format(preco))

O preço é 49 reais

A formatação pode ter vários argumentos.

num_item = 10
nome_item = "parafuso"
preco_item = 49.28
qtd_item = 72
txt = "o item {} é o {} e tem {} itens com o preço de {}"
print(txt.format(num_item, nome_item, qtd_item, preco_item))

o item 10 é o parafuso e tem 72 itens com o preço de 49.28

Você pode adicionar parâmetros dentro das chaves para especificar como converter o valor.

Formate o preço a ser exibido como um número com duas casas decimais.

txt = "O preço é {:.2f} reais"

E adicione mais espaços reservados:

quantidade = 3
num_item = 567
preço = 49
minha_ordem = "Quero {} partes do item número {} por {:.2f} reais."
print(minha_ordem.format(quantidade, num_item, preço))

Quero 3 partes do item número 567 por 49.00 reais.

4.2.5.1 - Números de índice

Você pode usar números de índice {n} para garantir que os argumentos sejam colocados nos espaços reservados corretos.

quantidade = 3
num_item = 567
preco = 49.95
minha_ordem = "desejo pagar {2} reais por {0} itens {1}."
print(minha_ordem.format(quantidade, num_item, preco))

desejo pagar 49.95 reais por 3 itens 567.

Números de índice são números dentro das chaves {} usados para posicionar os valores nos espaços determinados.

quantidade = 3
num_item = 567
preço = 49
minha_ordem = "Eu quero {0} peças do item número {1} por {2:.2f} reais."
print(minha_ordem.format(quantidade, num_item, preço))

Eu quero 3 peças do item número 567 por 49.00 reais.

Além disso, se você quiser fazer referência ao mesmo valor mais de uma vez, use o número de índice:

idade = 36
nome = "João"
txt = "Seu nome é {1}. {1} tem {0} anos."
print(txt.format(idade, nome))

Seu nome é João. João tem 36 anos.

4.2.5.2 - Índices nomeados

Você também pode usar índices nomeados inserindo um nome dentro das chaves {carname}, mas você deve usar nomes ao passar os valores de parâmetro txt.format(carname = "Ford"):

minha_ordem = "Tenho um {carname}, é um {model}."
print(minha_ordem.format(carname = "Ford", model = "Mustang"))

Tenho um Ford, é um Mustang.

Para inserir caracteres ilegais em um texto, utilize os caracteres de escape.

Um caractere de escape é uma barra invertida \ seguida pelo caracter que você deseja inserir.

Um exemplo de uso de caracteres especiais são as aspas duplas dentro de um texto cercado por aspas duplas, provocando erro.

txt = "Somos os chamados "Vikings" do norte."

SyntaxError: invalid syntax (<string>, line 1) <traceback object at 0x0000022CBE68BA80>

Para corrigir esse problema, usamos o caractere de escape "\"

txt = "Somos os chamados \"Vikings\" do norte."
print(txt)

Somos os chamados "Vikings" do norte.

São caracteres de escape usados ​​em Python:

Python tem um conjunto de métodos integrados que você pode usar com textos.

Nota: Todos os métodos de texto ring retornam novos valores, não alterando o texto original.

A função bool() permite avaliar e converter valores constantes ou de variáveis de outros tipos.

print(bool(""))
print(bool(0))
print(bool("Alô!"))
print(bool(15))
a = ""
b = 0
x = "Alô!"
y = 15
print(bool(a))
print(bool(b))
print(bool(x))
print(bool(y))

False
False
True
True
False
False
True
True

A data impressa contém ano, mês, dia, hora, minuto, segundo e microssegundo.

O módulo datetime tem muitos métodos para retornar informações sobre o objeto de data.

Aqui estão alguns exemplos, você aprenderá mais sobre eles mais adiante neste capítulo.

Exemplo: Importe o módulo datetime com o alias dt e retorne o ano e o nome do dia da semana.

import datetime as dt
x = dt.datetime.now()
print(x.year)
print(x.strftime("%A"))

2023
Monday

Para criar uma data, podemos usar o método-construtor da classe datetime() do módulo datetime.

A classe datetime() requer três parâmetros para criar uma data: dia, mês, ano.

Exemplo: Crie um objeto de data.

import datetime as dt
x = dt.datetime(2020, 5, 17)
print(x)

2020-05-17 00:00:00

A classe datetime() também recebe parâmetros para hora e fuso horário (hora, minuto, segundo, microssegundo, tzone), mas eles são opcionais e têm um valor padrão de 0, ( Nonepara fuso horário).

O objeto datetime tem um método para formatar objetos de data em strings legíveis.

O método é chamado strftime() e usa um parâmetro, format, para especificar o formato da string retornada.

import datetime as dt
x = dt.datetime(2018, 6, 1)
print(x.strftime("%B"))

June

A lista tem um conjunto de métodos integrados que você pode usar em listas.

Os itens da lista são objetos de valores de diferentes tipos, ordenados de acordo como são declarados na lista e que podem ser duplicados, contendo métodos que permitem a sua manipulação.

No Python as listas são objetos com o tipo de dados 'list'.

lista = ["maçã", "banana", "cereja"]
print(type(lista))

<class 'list'>

4.6.3.1 - Tipos de dados dos itens

Os itens da lista podem ser de qualquer tipo de dados.

lista1 = ["maçã", "banana", "cereja"] # itens do tipo de dados 'str'
lista2 = [1, 5, 7, 9, 3]              # itens do tipo de dados 'int'
lista3 = [True, False, False]         # itens do tipo de dados 'bool'

Uma lista pode conter diferentes tipos de dados.

lista = ["abc", 34, 40.25, 3+2j, True] # itens dos tipos de dados 'str', 'int', 'float', 'complex', 'bool'

Também é possível usar o construtor list() ao criar uma nova lista.

lista = list(("maçã", "banana", "cereja"))
# note os parenteses duplos na utilização do construtor
print(lista)

['maçã', 'banana', 'cereja']

O método len() retorna o tamanho da lista.

lista = ["maçã", "banana", "cereja"]
tamanho = len("lista")
print(tamanho)

5

Os itens da lista são ordenados, ou seja, estão na ordem definida na declaração da lista, ou da inserção de novos items após a atribuição inicial de valores.

Itens são adicionado a uma lista posicionados no seu final.

Nota: alguns métodos de lista alteram a ordenação, mas em geral a ordem dos itens não é alterada.

Os itens da lista são indexados, do índice inicial igual a zero e índice final igual ao tamanho da lista menos um.

lista = ["maçã", "banana", "cereja"]
tamanho = len(lista)
print("Tamanho =",tamanho)
for indice in range(tamanho):
    print("índice =", indice, "item =", lista[indice])

Tamanho = 3
índice = 0 item = maçã
índice = 1 item = banana
índice = 2 item = cereja

4.6.7.1 - Indexação negativa

Indexação negativa significa começar do fim: -1 refere-se ao último item, -2 refere-se ao penúltimo item etc.

lista = ["maçã", "banana", "cereja"]
print(lista[-1])

cereja

4.6.7.2 - Faixa de índices

Você pode especificar um intervalo de índices especificando onde começar e onde terminar o intervalo.

Ao especificar um intervalo, o valor de retorno será uma nova lista com os itens especificados.

Retorne o terceiro, quarto e quinto item.

lista = ["maçã", "banana", "cereja", "laranja", "kiwi", "melão", "manga"]
print(lista[2:5])

['cereja', 'laranja', 'kiwi']

Nota: A pesquisa começará no índice 2 (incluído) e terminará no índice 5 (não incluído).

Lembre-se que o primeiro item tem índice 0.

Ao deixar de fora o valor inicial, o intervalo começará no primeiro item:

lista = ["maçã", "banana", "cereja", "laranja", "kiwi", "melão", "manga"]
print(lista[:4])

['maçã', 'banana', 'cereja', 'laranja']

Ao deixar de fora o valor final, a faixa será do valor inicial até o final da lista.

lista = ["maçã", "banana", "cereja", "laranja", "kiwi", "melão", "manga"]
print(lista[2:])

['cereja', 'laranja', 'kiwi', 'melão', 'manga']

Para alterar o valor de um item específico, consulte o número do índice:

lista = ["maçã", "banana", "cereja"]
lista[1] = "pera"
print(lista)

['maçã', 'pera', 'cereja']

A lista é mutável, o que significa que podemos alterar, adicionar e remover itens em uma lista após ela ter sido criada.

Como as listas são indexadas, as listas podem ter itens com o mesmo valor.

lista = ["maçã", "banana", "cereja", "maçã", "cereja"]
print(lista)

['maçã', 'banana', 'cereja', 'maçã', 'cereja']

4.6.10.1 - Alterar um intervalo de valores de itens

Para alterar o valor dos itens dentro de um intervalo específico, defina uma lista com os novos valores e consulte o intervalo de números de índice onde deseja inserir os novos valores.

Altere os valores "banana" e "cereja" pelos valores "pera" e "mamão".

lista = ["maçã", "banana", "cereja", "laranja", "kiwi", "manga"]
lista[1:3] = ["pera", "mamão"]
print(lista)

['maçã', 'pera', 'mamão', 'laranja', 'kiwi', 'manga']

Se você inserir mais itens do que substituir, os novos itens serão inseridos onde você especificou e os itens restantes serão movidos de acordo:

Exemplo: alteção do segundo valor sendo substituindo por dois novos valores.

lista = ["maçã", "banana", "cereja"]
lista[1:2] = ["pera", "mamão"]
print(lista)

['maçã', 'pera', 'mamão', 'cereja']

Nota: O comprimento da lista mudará quando o número de itens inseridos não corresponder ao número de itens substituídos.

Se você inserir menos itens do que substituir, os novos itens serão inseridos onde você especificou e os itens restantes serão movidos de acordo:

Altere o segundo e o terceiro valor substituindo-o por um valor:

lista = ["maçã", "banana", "cereja"]
lista[1:3] = ["mamão"]
print(lista)

['maçã', 'mamão']

4.6.10.2 - Adicão de itens na lista

Para adicionar um item ao final da lista, use o método append().

lista = ["maçã", "banana", "frutas"]
lista.append("laranja")
print(lista)

['maçã', 'banana', 'frutas', 'laranja']

4.6.10.3 - Inserir itens

Para inserir um item de lista em um índice especificado, use o insert()método.

O método insert() insere um item no índice especificado.

Exemplo: inserção de um item na segunda posição.

lista = ["maçã", "banana", "frutas"]
lista.insert(1, "laranja")
print(lista)

['maçã', 'laranja', 'banana', 'frutas']

4.6.10.4 - Remover itens da lista

Remover item especificado

O método remove() exclui o item especificado.

lista = ["maçã", "banana", "frutas"]
lista.remove("banana")
print(lista)

['maçã', 'frutas']

4.6.10.5 - Remover índice especificado

O método pop() remove o índice especificado.

Exemplo: remoção do segundo item.

lista = ["maçã", "banana", "frutas"]
lista.pop(1)
print(lista)

['maçã', 'frutas']

Se você não especificar o índice, o pop()método removerá o último item.

Exemplo: remoção do último item.

lista = ["maçã", "banana", "frutas"]
lista.pop()
print(lista)

['maçã', 'banana']

A palavra-chave del também remove o índice especificado.

Exemplo: remoção do primeiro item.

lista = ["maçã", "banana", "frutas"]
del lista[0]
print(lista)

['banana', 'frutas']

A palavra-chave del também pode excluir a lista completamente.

lista = ["maçã", "banana", "frutas"]
del lista

4.6.10.6 - Limpar a lista

O método clear() esvazia a lista.

A lista ainda permanece sem conteúdo.

lista = ["maçã", "banana", "frutas"]
lista.clear()
print(lista)

[]

Os laços de uma lista podem ser realizados através de iterações ou indexação.

4.6.11.1 - Laços de iteração

As iterações de lista são realizadas com a instrução for/in:

lista = ["maçã", "banana", "frutas"]
for x in lista: print(x)

maçã
banana
frutas

4.6.11.2 - Laços indexados

Os laços indexados de lista são realizados com o acesso aos itens pelo seu índice, com a utilizaação dos métodos len(), da lista, e range().

lista = ["maçã", "banana", "frutas"]
for i in range(len(lista)): print(lista[i])

maçã
banana
frutas

A compreensão de lista oferece uma sintaxe curta para criação uma nova lista com os itens filtrados de acordo com algum critério sobre seu valor.

Consideremos criar uma nova lista a partir de lista de frutas, com os itens com a letra "a" no nome da fruta.

Sem compreensão de lista:

frutas = ["maçã", "banana", "frutas", "kiwi", "manga"]
nova_lista = []
for x in frutas:
    if "a" in x:
        nova_lista.append(x)
print(nova_lista)

['maçã', 'banana', 'frutas', 'manga']

Com compreensão de lista:

frutas = ["maçã", "banana", "frutas", "kiwi", "manga"]
nova_lista = [x for x in frutas if "a" in x]
print(nova_lista)

['maçã', 'banana', 'frutas', 'manga']

O método sort() dos objetos de listas reordena a lista em ordem crescente ou decrescente, de acordo com os critérios de avaliação dos valores de diferentes tipos.

Para classificar de forma decrescente, use o argumento "reverse = True":

print('--> listas originais')
lista_alfa = ["laranja", "manga", "kiwi", "abacaxi", "banana"]
lista_num = [100, 50, 65, 82, 23]
print(lista_alfa)
print(lista_num)
print('--> listas ordenadas')
lista_alfa.sort()
lista_num.sort()
print(lista_alfa)
print(lista_num)
print('--> listas com ordenação reversa')
lista_alfa.sort(reverse = True)
lista_num.sort(reverse = True)
print(lista_alfa)
print(lista_num)

--> listas originais
['laranja', 'manga', 'kiwi', 'abacaxi', 'banana']
[100, 50, 65, 82, 23]
--> listas ordenadas
['abacaxi', 'banana', 'kiwi', 'laranja', 'manga']
[23, 50, 65, 82, 100]
--> listas com ordenação reversa
['manga', 'laranja', 'kiwi', 'banana', 'abacaxi']
[100, 82, 65, 50, 23]

Uma lista não é copiada com a declaração lista2 = lista1, pois lista2 apenas apontará para o objeto na memória de lista1, e as alterações feitas em lista1 serão refletidas em lista2.

Existem diferentes maneiras para copiar de uma listas:

• Com o método copy().
• Com o construtor list().
• Com a compreensão de lista.

frutas = ["maçã", "banana", "frutas"]
mesma_lista = frutas
nova_lista_1 = frutas.copy()
nova_lista_2 = list(frutas)
nova_lista_3 = [x for x in frutas]
print(mesma_lista, mesma_lista == frutas)
print(nova_lista_1, nova_lista_1 == frutas)
print(nova_lista_2, nova_lista_2 == frutas)
print(nova_lista_3, nova_lista_3 == frutas)

['maçã', 'banana', 'frutas'] True
['maçã', 'banana', 'frutas'] True
['maçã', 'banana', 'frutas'] True
['maçã', 'banana', 'frutas'] True

Existem diferentes maneiras de concatenar uma lista ou mais listas em outra, ou em uma nova lista.

• Concatenando duas listas com o operador de concatenação "+" em uma nova lista.
• Concatenando os itens de uma listas em outra com o método extend.
• Anexando individualmente os itens de uma lista em outra.

lista_1 = ["a", "b", "c"]
lista_2 = [1, 2, 3]
copia_1_lista_1 = lista_1.copy()
copia_2_lista_1 = lista_1.copy()
#
lista_3 = lista_1 + lista_2
copia_1_lista_1.extend(lista_2)
for x in lista_2:
    copia_2_lista_1.append(x)
#
print("lista_1 =", lista_1)
print("lista_2 =", lista_2)
print("lista_3 =", lista_3)
print("copia_l_1ista_1 =", copia_1_lista_1)
print("copia_2_lista_1 =", copia_2_lista_1)

lista_1 = ['a', 'b', 'c']
lista_2 = [1, 2, 3]
lista_3 = ['a', 'b', 'c', 1, 2, 3]
copia_l_1ista_1 = ['a', 'b', 'c', 1, 2, 3]
copia_2_lista_1 = ['a', 'b', 'c', 1, 2, 3]

Python tem dois métodos integrados integrados nos objetos das tuplas.

Os itens de tupla são ordenados, imutáveis, indexados (o primeiro item possui índice [0], o segundo item possui índice [1] etc) ​​e permitem valores duplicados.

Quando dizemos que as tuplas estão ordenadas, significa que os itens têm uma ordem definida, e essa ordem não será alterada, será exatamente a mesma como os itens foram declarados na(s) intrução(ões).

As tuplas são imutáveis, o que significa que não podemos alterar, adicionar ou remover itens após a criação da tupla.

As tuplas são indexadas e podem ter itens duplicados, com o mesmo valor.

tupla = ("maçã", "banana", "cereja", "maçã", "cereja")
print(tupla)

('maçã', 'banana', 'cereja', 'maçã', 'cereja')

Você pode acessar os itens da tupla consultando o número do índice, entre colchetes.

tupla = ("maçã", "banana", "cereja")
print(tupla[1])
# impressão do segundo item na tupla

banana

Nota: O primeiro item tem índice 0.

4.7.6.1 - Indexação negativa

Indexação negativa é feita do sentido do último item em direção ao primeiro, com o índice -1 referindo-se ao último item, -2 referindoe-se ao penúltimo, e assim por diante.

Exemplo: impressão do último item da tupla.

tupla = ("maçã", "banana", "cereja")
print(tupla[-1])

cereja

4.7.6.2 - Faixa de itens de tuplas

Você pode especificar um intervalo de índices especificando onde começar e onde terminar o intervalo.

Ao especificar um intervalo, o valor de retorno será uma nova tupla com os itens especificados.

Exemplo: retornar o terceiro, quarto e quinto item.

tupla = ("maçã", "banana", "cereja", "laranja", "kiwi", "melão", "manga")
print(tupla[2:5])

('cereja', 'laranja', 'kiwi')

Nota: A pesquisa começará no índice 2 (incluído) e terminará no índice 5 (não incluído).

O primeiro item tem índice 0.

Ao deixar de fora o valor inicial, o intervalo começará no primeiro item.

Exemplo: itens do primeiro item ao item do índice 3 (4-1).

tupla = ("maçã", "banana", "cereja", "laranja", "kiwi", "melão", "manga")
print(tupla[:4])

('maçã', 'banana', 'cereja', 'laranja')

Se o valor final for omitido o intervalo será até o final da lista.

Exemplo: itens do terceiro índice ao último item.

tupla = ("maçã", "banana", "cereja", "laranja", "kiwi", "melão", "manga")
print(tupla[2:])

('cereja', 'laranja', 'kiwi', 'melão', 'manga')

A tupla é imutável, o que significa que pode ser alterada, e itens não podem ser adicionados ou removidos após sua criação.

Mas existem algumas soluções alternativas.

4.7.7.1 - Alteração da tupla

Depois que uma tupla é declarada, não pode ser alterada, pois são imutáveis.

Embora não seja adequado o uso de uma tupla havendo a necessidade de ser alterada, pode-se o metodo alternativo de convertê-la em uma lista, alterando-se a lista para convertê-la novamente como tupla.

tupla = ("maçã", "banana", "cereja")
lista = list(tupla)
lista[1] = "kiwi"
tupla = tuple(lista)
print(tupla)

('maçã', 'kiwi', 'cereja')

4.7.7.2 - Adição de itens

Como as tuplas são imutáveis, elas não possuem um método append() embutido, mas existem outras maneiras de adicionar itens a uma tupla.

1. Converter em uma lista : Assim como a solução alternativa para alterar uma tupla, você pode convertê-la em uma lista, adicionar seu(s) item(ns) e convertê-la novamente em uma tupla.

tupla = ("maçã", "banana", "cereja")
lista = list(tupla)     # converta a tupla em uma lista
lista.append("laranja") # adicione "laranja"
tupla = tuple(lista)    # converta novamente em uma tupla
print(tupla)

('maçã', 'banana', 'cereja', 'laranja')

2. Adicionar tupla a uma tupla. Você tem permissão para adicionar tuplas a tuplas, portanto, se você quiser adicionar um item (ou muitos), crie uma nova tupla com o(s) item(ns) e adicione-a à tupla existente.

# criação de tupla
tupla1 = ("maçã", "banana", "cereja")
# criação de nova tupla
tupla2 = ("laranja",)
# adição de tuplas
tupla1 += tupla2     
print(tupla1)

('maçã', 'banana', 'cereja', 'laranja')

Nota: Ao criar uma tupla com apenas um item, lembre-se de incluir uma vírgula após o item, caso contrário o não será identificado como uma tupla.

4.7.7.3 - Remoção de itens

Itens não podem ser removidos de uma tupla.

As tuplas não podem ser alteradas, portanto, seus itens não podem ser removidos.

O método alternativo com listas permite a remoção de itens de uma tupla.

tupla = ("maçã", "banana", "cereja")
lista = list(tupla)  # conversão de tupla em lista
lista.remove("maçã") # remoção do item "maçã"
tupla = tuple(lista) # conversão da lista em tupla
print(tupla)

('banana', 'cereja')

Tupla podem ser completamente removidas com a instrução del.

tupla = ("maçã", "banana", "cereja")
del tupla
print(tupla) # isso gerará um erro porque a tupla não existe mais

NameError: name 'tupla' is not defined <traceback object at 0x0000022CBE9169C0>

É chamado "empacotar" uma tupla a atribuição valores.

frutas = ("maçã", "banana", "cereja") # empacotamento
print(frutas)

('maçã', 'banana', 'cereja')

É chamado "descompactar" extrair da tupla para variáveis.

frutas = ("maçã", "banana", "cereja") # empacotamento
(verde, amarelo, vermelho) = frutas   # desempacotamento
print(verde)
print(amarelo)
print(vermelho)

maçã
banana
cereja

Você pode iterar (percorrer) os itens da tupla usando um laço (loop) for.

tupla = ("maçã", "banana", "cereja")
for x in tupla: print(x)

maçã
banana
cereja

4.7.9.1 - Percorrer os números de índice

Você também pode percorrer os itens da tupla consultando seu número de índice.

Use as funções range() e len() para criar um iterável adequado com índices.

tupla = ("maçã", "banana", "cereja")
for i in range(len(tupla)):
    print(tupla[i])

maçã
banana
cereja

Para juntar duas ou mais tuplas você pode usar operador "+".

tupla1 = ("a", "b" , "c")
tupla2 = (1, 2, 3)
tupla3 = tupla1 + tupla2
print(tupla3)

('a', 'b', 'c', 1, 2, 3)

Se você quiser multiplicar o conteúdo de uma tupla um determinado número de vezes, você pode usar o operador "*":

Exemplo: multiplique da tupla de frutas por 2.

frutas = ("maçã", "banana", "cereja")
tupla = frutas * 2
print(tupla)

('maçã', 'banana', 'cereja', 'maçã', 'banana', 'cereja')

Os itens do conjunto não são ordenados, não podem ser alterados e não permitem valores duplicados.

Não ordenado significa que os itens em um conjunto não têm uma ordem definida.

Os itens do conjunto podem aparecer em uma ordem diferente toda vez que você os usa e não podem ser referenciados por índice ou chave.

Os itens do conjunto são imutáveis, o que significa que não podemos alterar os itens após a criação do conjunto.

Depois que um conjunto é criado, você não pode alterar seus itens, mas pode remover itens e adicionar novos itens.

Os valores dos itens não podem ser repetidos.

conjunto = {"maçã", "banana", "cereja", "maçã"}
print(conjunto)

Os itens de um conjunto não são acessados com índices ou chaves, mas pode ser percorridos com o laço for loop.

conjunto = {"maçã", "banana", "cereja"}
for x in conjunto: print(x)

maçã
banana
cereja

A palavra-chave in permite verificar a presenção de itens com determinado valor.

conjunto = {"maçã", "banana", "cereja"}
print("banana" in conjunto)

True

Após a criação os itens dos conjuntos não podem ser alterados mas novos itens poderão ser adicionados ao conjunto.

Depois que um conjunto é criado, você não pode alterar seus itens, mas pode adicionar novos itens.

Para adicionar um item a um conjunto, use o método add().

conjunto = {"maçã", "banana", "cereja"}
conjunto.add("laranja")
print(conjunto)

{'maçã', 'banana', 'cereja', 'laranja'}

Para adicionar itens de outro conjunto ao conjunto atual, use o método update().

conjunto = {"maçã", "banana", "cereja"}
tropical = {"abacaxi", "manga", "mamão"}
conjunto.update(tropical)
print(conjunto)

{'abacaxi', 'maçã', 'banana', 'cereja', 'mamão', 'manga'}

O objeto no método update() não precisa ser um conjunto, pode ser qualquer objeto iterável (tuplas, listas, dicionários etc.).

conjunto = {"maçã", "banana", "cereja"}
lista = ["kiwi", "laranja"]
conjunto.update(lista)
print(conjunto)

{'maçã', 'cereja', 'banana', 'kiwi', 'laranja'}

Itens em um conjunto podem ser removidos com os método remove() e discard()

conjunto = {"maçã", "banana", "cereja"}

conjunto.remove("banana")

print(conjunto)

Nota: Se o item a ser removido não existir, o método remove() irá gerar um erro.

conjunto = {"maçã", "banana", "cereja"}
conjunto.discard("banana")
print(conjunto)

{'maçã', 'cereja'}

Nota: Se o item a ser removido não existir, o método discard() irá gerar um erro.

Você também pode usar o método pop() para remover o último item do conjunto.

Lembre-se de que os conjuntos não são ordenados, então você não saberá qual item será removido.

O valor de retorno do método pop() é o item removido.

conjunto = {"maçã", "banana", "cereja"}
print(conjunto)
ultimo = conjunto.pop()
print(ultimo)
print(conjunto)

{'maçã', 'banana', 'cereja'}
maçã
{'banana', 'cereja'}

Nota: Os conjuntos não são ordenados, portanto, ao usar o pop()método, você não sabe qual item será removido.

O método clear() esvazia o conjunto.

conjunto = {"maçã", "banana", "cereja"}
conjunto.clear()
print(conjunto)

set()

A palavra-chave del excluirá o conjunto completamente.

conjunto = {"maçã", "banana", "cereja"}
del conjunto
print(conjunto)

NameError: name 'conjunto' is not defined <traceback object at 0x0000022CC060B8C0>

Os itens de um conjunto são percorridos com laços (loops) for.

conjunto = {"maçã", "banana", "cereja"}
for x in conjunto: print(x)

maçã
banana
cereja

Conjuntos podem ser unidos de diferentes maneiras.

O método union() retorna um novo conjunto contendo todos os itens de ambos os conjuntos.

conj1 = {"a", "b" , "c"}
conj2 = {1, 2, 3}
conj3 = conj1.union(conj2)
print(conj3)

{1, 2, 3, 'a', 'b', 'c'}

O método update() insere os itens de um conjunto em outro.

conj1 = {"a", "b" , "c"}
conj2 = {1, 2, 3}
conj1.update(conj2)
print(conj1)

{1, 2, 3, 'a', 'b', 'c'}

Python tem um conjunto de métodos integrados que você pode usar em conjuntos.

Python tem um conjunto de métodos integrados usados com dicionários.

Os itens do dicionário são apresentados em pares chave:valor e podem ser referenciados pelo nome da chave; são ordenados, alteráveis ​​e não permitem duplicação das chaves.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
print(dicionario["marca"])

Ford

4.9.2.1 - Dicionários são ordenados

A partir da versão 3.7 do Python, os dicionários são ordenados. No Python 3.6 e anteriores, os dicionários não são ordenados.

Quando dizemos que os dicionários estão ordenados, significa que os itens têm uma ordem definida, e essa ordem não será alterada, será mantida como foi declarada.

Não ordenado significa que os itens não têm uma ordem definida, você não pode fazer referência a um item usando um índice.

4.9.2.2 - Dicionários são alteráveis

Os dicionários são mutáveis, o que significa que podemos alterar, adicionar ou remover itens após a criação do dicionário.

4.9.2.3 - Dicionários não têm duplicação de chave

Os dicionários não podem ter dois itens com a mesma chave. Uma declaração duplicada não causa erro entretanto a duplicação é ignorada.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964,
  "ano": 2020
}
print(dicionario)

{'marca': 'Ford', 'modelo': 'Mustang', 'ano': 2020}

Você pode acessar os itens de um dicionário consultando o nome da chave, entre colchetes, ou usando o método get().

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
item1 = dicionario["modelo"]
item2 = dicionario.get("modelo")
print(item1)
print(item2)

Mustang
Mustang

4.9.3.1 - Relação de chaves

O método keys() retorna a lista de todas as chaves do dicionário.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
print(dicionario.keys())

dict_keys(['marca', 'modelo', 'ano'])

A lista de chaves é uma visualização do dicionário, o que significa que quaisquer alterações feitas no dicionário serão refletidas na lista de chaves.

carro = {
    "marca": "Ford",
    "modelo": "Mustang",
    "ano": 1964
}
item1 = carro.keys()
print(item1) # antes
carro["cor"] = "branco"
print(item1) # depois

dict_keys(['marca', 'modelo', 'ano'])
dict_keys(['marca', 'modelo', 'ano', 'cor'])

Você pode alterar o valor de um item específico pelo nome da chave. Se o item não existir, o item será adicionado.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
print(dicionario)
dicionario["ano"] = 2018
dicionario["cor"] = "vermelho"
print(dicionario)

{'marca': 'Ford', 'modelo': 'Mustang', 'ano': 1964}
{'marca': 'Ford', 'modelo': 'Mustang', 'ano': 2018, 'cor': 'vermelho'}

4.9.4.1 - Método update()

O método update() atualizará o dicionário com os itens de um determinado argumento. Se o item não existir, o item será adicionado.

O argumento deve ser um dicionário ou um objeto iterável com pares chave:valor.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
dicionario.update({"ano": 1963})
dicionario.update({"cor": "vermelho"})
print(dicionario)

{'marca': 'Ford', 'modelo': 'Mustang', 'ano': 1963, 'cor': 'vermelho'}

Existem vários métodos para remover itens de um dicionário

4.9.5.1 - Remover com a chave

O método pop() remove o item com o nome de chave especificado.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
dicionario.pop("modelo")
print(dicionario)

{'marca': 'Ford', 'ano': 1964}

O método popitem() remove o último item inserido.

Nas versões anteriores à 3.7, um item aleatório é removido.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
dicionario.popitem()
print(dicionario)

{'marca': 'Ford', 'modelo': 'Mustang'}

4.9.5.2 - Instrução del

A palavra-chave del remove o item com o nome de chave especificado.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
del dicionario["modelo"]
print(dicionario)

{'marca': 'Ford', 'ano': 1964}

A instrução del pode excluir completamente o dicionário.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
del dicionario
print(dicionario) # erro: dicionario não existe mais.

NameError: name 'dicionario' is not defined <traceback object at 0x0000022CC05D9280>

4.9.5.3 - Método clear()

O método clear() remove todos os itens de um dicionário sem apagar a referência à variável.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
dicionario.clear()
print(dicionario)

{}

Os dicionários são iteradores e podem ser percorridos com o laço for.

Ao percorrer um dicionário, o valor de retorno são as chaves do dicionário, mas também existem métodos para retornar os valores.

Os nomes das chave no dicionário são retornados como abaixo.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
for x in dicionario: print(x)

marca
modelo
ano

Os valores das chaves no dicionário são retornados como abaixo.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
for x in dicionario: print(dicionario[x])

Ford
Mustang
1964

O método values() retorna valores de um dicionário.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
for x in dicionario.values(): print(x)

Ford
Mustang
1964

O método keys() retorna as chaves de um dicionário:

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
for x in dicionario.keys(): print(x)

marca
modelo
ano

o método items() retorna todos os itens de pares com chaves e valores de um dicionário.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
for x, y in dicionario.items(): print(x, y)

marca Ford
modelo Mustang
ano 1964

Você não pode copiar um dicionário simplesmente com a instrução dict2 = dict1, porque dict2 apenas apontará para o objeto de dict1, e as alterações feitas em dict1 serão refletidas em dict2.

Existem maneiras de fazer uma cópia, uma delas é usar o método copy() do dicionário.

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
copia = dicionario.copy()
print(copia)

{'marca': 'Ford', 'modelo': 'Mustang', 'ano': 1964}

O dicionário também pode ser copiado com o método dict().

dicionario = {
  "marca": "Ford",
  "modelo": "Mustang",
  "ano": 1964
}
mydict = dict(dicionario)
print(mydict)

{'marca': 'Ford', 'modelo': 'Mustang', 'ano': 1964}

Um dicionário pode conter dicionários internamente, isso é chamado de dicionários aninhados ou aninhamento de dicionários.

No exemplo abaixo 3 dicionários são incluidos internamen no dicionário "familia".

familia = {
  "child1" : {
    "name" : "Emil",
    "ano" : 2004
  },
  "child2" : {
    "name" : "Tobias",
    "ano" : 2007
  },
  "child3" : {
    "name" : "Linus",
    "ano" : 2011
  }
}
print(familia)

{'child1': {'name': 'Emil', 'ano': 2004}, 'child2': {'name': 'Tobias', 'ano': 2007}, 'child3': {'name': 'Linus', 'ano': 2011}}

No exemplo abaixo 3 dicionários são atribuidos a 3 variáveis incluidas no dicionário "familia".

filho1 = {
  "name" : "Emil",
  "ano" : 2004
}
filho2 = {
  "name" : "Tobias",
  "ano" : 2007
}
filho3 = {
  "name" : "Linus",
  "ano" : 2011
}
familia = {
  "filho1" : filho1,
  "filho2" : filho2,
  "filho3" : filho3
}
print(familia)

{'filho1': {'name': 'Emil', 'ano': 2004}, 'filho2': {'name': 'Tobias', 'ano': 2007}, 'filho3': {'name': 'Linus', 'ano': 2011}}