Guia Completa de Python 2025 (1/3): tipos de dados

11 de fevereiro de 2021

Aviso: Este post foi traduzido para o português usando um modelo de tradução automática. Por favor, me avise se encontrar algum erro.

📚 **Esta entrada faz parte da série _Guia completo de Python_**, dividida em três capítulos que se leem em ordem:

> * 👉 **Parte 1: Tipos de datos**

* Parte 2: Operadores, controle de fluxo e funções

* Parte 3: Classes, objetos e temas avançados

1. Resumo

Vamos a fazer uma breve introdução ao Python, explicando os tipos de dados que temos, os operadores, o uso de funções e de classes. Além disso, veremos como usar os objetos iteráveis, como usar módulos, etc.

2. Tipos de dados de Python

Existem 7 tipos de dados em Python

Do tipo texto: str
Numéricos: int, float, complex
Sequências: list, tuple, range
Mapeamento: dict5. Conjuntos: set, frozenset
Booleanos: bool
Binários: bytes, bytearray, memoryview

Podemos obter o tipo de dado por meio da função type()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		type(5.)
	
	Copied

>_ Output

			
				float

Python é uma linguagem de tipagem dinâmica, ou seja, você pode ter uma variável de um tipo e depois atribuir a ela outro tipo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 5
type(a)
	
	Copied

>_ Output

int

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 'MaximoFN'
type(a)
	
	Copied

>_ Output

str

Python tipa as variáveis por ti, mas se quiseres tipá-las tu, também é possível.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		b = int(5.1)
type(b), b
	
	Copied

>_ Output

			
				(int, 5)

Embora b tenha sido inicializado como 5.1, ou seja, deveria ser do tipo float, ao o tiparmos para o tipo int, vemos que ele é do tipo int e, além disso, seu valor é 5

2.1. Strings

As strings são cadeias de caracteres; estas podem ser definidas com aspas duplas " ou aspas simples '

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = "MaximoFN"
string
	
	Copied

>_ Output

			
				'MaximoFN'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
string
	
	Copied

>_ Output

			
				'MaximoFN'

Para escrever uma string muito longa e não ter uma linha que ocupe muito espaço, ela pode ser introduzida em várias linhas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = """Este es un ejemplo de
como estoy introduciendo un string
en varias lineas"""
string
	
	Copied

>_ Output

			
				'Este es un ejemplo de
como estoy introduciendo un string
en varias lineas'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = '''Este es un ejemplo de
como estoy introduciendo un string
en varias lineas'''
string
	
	Copied

>_ Output

			
				'Este es un ejemplo de
como estoy introduciendo un string
en varias lineas'

No entanto, vemos que no meio ele inseriu o caractere de quebra de linha. Se usarmos a função print() veremos como já não aparece

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string)
	
	Copied

>_ Output

			
				Este es un ejemplo de
como estoy introduciendo un string
en varias lineas

Como dissemos, as strings são cadeias de caracteres, então podemos navegar e iterar através delas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(10):
  # Se indica a la función print que cuando imprima no termine con un salto de 
  # linea para escribir todo en la misma linea
  print(string[i], end='')
	
	Copied

>_ Output

			
				Este es un

Podemos obter o comprimento da nossa string usando a função len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(string)
	
	Copied

>_ Output

Verificar se há alguma string determinada dentro da nossa

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'ejemplo' in string
	
	Copied

>_ Output

			
				True

As strings têm certos atributos úteis, como colocar tudo em maiúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.upper())
	
	Copied

>_ Output

			
				ESTE ES UN EJEMPLO DE
COMO ESTOY INTRODUCIENDO UN STRING
EN VARIAS LINEAS

tudo em minúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.lower())
	
	Copied

>_ Output

			
				este es un ejemplo de
como estoy introduciendo un string
en varias lineas

Substituir caracteres

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.replace('o', '@'))
	
	Copied

>_ Output

			
				Este es un ejempl@ de
c@m@ est@y intr@duciend@ un string
en varias lineas

Obter todas as palavras

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.split())
	
	Copied

>_ Output

			
				['Este', 'es', 'un', 'ejemplo', 'de', 'como', 'estoy', 'introduciendo', 'un', 'string', 'en', 'varias', 'lineas']

Você pode ver todos os métodos das strings neste enlace

Outra coisa útil que se pode fazer com as strings é concatená-las

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string1 = 'Maximo'
string2 = 'FN'
string1 + string2
	
	Copied

>_ Output

			
				'MaximoFN'

Antes explicamos que o caractere \n correspondia a uma quebra de linha, este caractere especial corresponde a uma série de caracteres especiais chamados Escape Characters. Vejamos outros

Se declararmos uma string com aspas duplas e quisermos adicionar uma aspa dupla dentro da string, usamos o caractere de escape \"

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print("Este es el blog de "MaximoFN"")
	
	Copied

>_ Output

			
				Este es el blog de "MaximoFN"

O mesmo com a aspa simples, adicionamos \'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de 'MaximoFN'')
	
	Copied

>_ Output

			
				Este es el blog de 'MaximoFN'

Agora temos o problema de que, se quisermos adicionar o caractere \, como vimos, ele é um escape character, então o solucionamos colocando dupla barra (backslash) \

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \\MaximoFN\\')
	
	Copied

>_ Output

			
				Este es el blog de \MaximoFN\

Já vimos antes o escape character de nova linha \n

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \nMaximoFN')
	
	Copied

>_ Output

			
				Este es el blog de
MaximoFN

Se quisermos escrever desde o início da linha, adicionamos \r

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Esto no se imprimirá \rEste es el blog de MaximoFN')
	
	Copied

>_ Output

			
				Este es el blog de MaximoFN

Se quisermos adicionar um grande espaço (recuo), usamos \t

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \tMaximoFN')
	
	Copied

>_ Output

			
				Este es el blog de 	MaximoFN

Podemos apagar um caractere com \b

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \bMaximoFN')
	
	Copied

>_ Output

			
				Este es el blog deMaximoFN

Podemos adicionar o código ASCII em octal por meio de \ooo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('\115\141\170\151\155\157\106\116')
	
	Copied

>_ Output

			
				MaximoFN

Ou adicionar o código ASCII em hexadecimal por meio de \xhh

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('\x4d\x61\x78\x69\x6d\x6f\x46\x4e')
	
	Copied

>_ Output

			
				MaximoFN

Por último, podemos converter outro tipo de dado em uma string

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5
print(type (n))
string = str(n)
print(type(string))
	
	Copied

>_ Output

			
				&lt;class 'int'&gt;
&lt;class 'str'&gt;

2.2. Números

2.2.1. Inteiros

Números do tipo inteiro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5
n, type(n)
	
	Copied

>_ Output

			
				(5, int)

2.2.2. Float

Números de ponto flutuante

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5.1
n, type(n)
	
	Copied

>_ Output

			
				(5.1, float)

2.2.3. Complexos

Números complexos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 3 + 5j
n, type(n)
	
	Copied

>_ Output

			
				((3+5j), complex)

2.2.4. Conversão

É possível converter entre tipos numéricos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5
n = float(n)
n, type(n)
	
	Copied

>_ Output

			
				(5.0, float)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5.1
n = complex(n)
n, type(n)
	
	Copied

>_ Output

			
				((5.1+0j), complex)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5.1
n = int(n)
n, type(n)
	
	Copied

>_ Output

			
				(5, int)

Não é possível converter um número complex para o tipo int ou para o tipo float

2.3. Sequências

2.3.1. Listas

As listas guardam múltiplos itens em uma variável. Elas são declaradas usando os símbolos [], com os itens separados por vírgulas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ['item0', 'item1', 'item2', 'item3', 'item4', 'item5']
lista
	
	Copied

>_ Output

			
				['item0', 'item1', 'item2', 'item3', 'item4', 'item5']

Podemos obter o comprimento de uma lista mediante a função len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(lista)
	
	Copied

>_ Output

As listas podem ter itens de diferentes tipos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ['item0', 1, True, 5.3, "item4", 5, 6.6]
lista
	
	Copied

>_ Output

			
				['item0', 1, True, 5.3, 'item4', 5, 6.6]

Em Python, começa-se a contar a partir da posição 0, ou seja, se quisermos obter o primeiro elemento da lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[0]
	
	Copied

>_ Output

			
				'item0'

Mas uma das coisas poderosas do Python é que, se quisermos acessar a última posição, podemos usar índices negativos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[-1]
	
	Copied

>_ Output

6.6

Se em vez da última posição da lista quisermos a penúltima

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[-2]
	
	Copied

>_ Output

Se quisermos apenas um intervalo de valores, por exemplo, do segundo ao quinto item, acessamos por meio de [2:5]

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[2:5]
	
	Copied

>_ Output

			
				[True, 5.3, 'item4']

Se o primeiro número do intervalo for omitido, significa que queremos do primeiro item da lista até o item indicado; ou seja, se quisermos do primeiro item até o quinto, usamos [:5]

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[:5]
	
	Copied

>_ Output

			
				['item0', 1, True, 5.3, 'item4']

Se o último número do intervalo for omitido, significa que queremos do item indicado até o último. Ou seja, se queremos do terceiro item até o último, usamos [3:]

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[3:]
	
	Copied

>_ Output

			
				[5.3, 'item4', 5, 6.6]

Podemos escolher o intervalo de itens também com números negativos, ou seja, se quisermos do antepenúltimo até o penúltimo usamos [-3:-1]. Isso é útil quando se têm listas das quais não se sabe o seu comprimento, mas se sabe que se quer um intervalo de valores do final, porque, por exemplo, a lista foi criada com medições que vão sendo feitas e quer-se saber as últimas médias

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[-3:-1]
	
	Copied

>_ Output

			
				['item4', 5]

É possível verificar se um item está na lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'item4' in lista
	
	Copied

>_ Output

			
				True

2.3.1.1. Editar listas

As listas em Python são dinâmicas, ou seja, podem ser modificadas. Por exemplo, é possível modificar o terceiro item

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[2] = False
lista
	
	Copied

>_ Output

			
				['item0', 1, False, 5.3, 'item4', 5, 6.6]

Também se pode modificar um intervalo de valores

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[1:4] = [1.1, True, 3]
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6]

Podem ser adicionados valores ao final da lista por meio do método append()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.append('item7')
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6, 'item7']

Ou podemos inserir um valor em uma posição determinada por meio do método insert()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.insert(2, 'insert')
lista
	
	Copied

>_ Output

			
				['item0', 1.1, 'insert', True, 3, 'item4', 5, 6.6, 'item7']

Podem-se unir listas através do método extend()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista2 = ['item8', 'item9']
lista.extend(lista2)
lista
	
	Copied

>_ Output

			
				['item0', 1.1, 'insert', True, 3, 'item4', 5, 6.6, 'item7', 'item8', 'item9']

Não é necessário estender a lista por meio de outra lista, isso pode ser feito por meio de outro tipo de dado iterável do Python (tuplas, sets, dicionários, etc)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item10', 'item11')
lista.extend(tupla)
lista
	
	Copied

>_ Output

			
				['item0',
1.1,
'insert',
True,
3,
'item4',
5,
6.6,
'item7',
'item8',
'item9',
'item10',
'item11']

Podemos remover uma posição determinada mediante o método pop()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.pop(2)
lista
	
	Copied

>_ Output

			
				['item0',
1.1,
True,
3,
'item4',
5,
6.6,
'item7',
'item8',
'item9',
'item10',
'item11']

Se o índice não for especificado, o último item é removido

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.pop()
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6, 'item7', 'item8', 'item9', 'item10']

Ou é possível eliminar um item sabendo seu valor por meio do método remove()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.remove('item7')
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6, 'item8', 'item9', 'item10']

Com a função del() também se pode eliminar um item da posição indicada

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del lista[3]
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 'item4', 5, 6.6, 'item8', 'item9', 'item10']

Se não for indicado o índice, a lista completa será eliminada

Com o método clear() deixo a lista vazia

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.clear()
lista
	
	Copied

>_ Output

[]

Pode-se obter a quantidade de itens com um valor determinado por meio do método count()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 4, 6, 5, 7, 8, 5, 3, 1, 5]
lista.count(5)
	
	Copied

>_ Output

Também é possível obter o primeiro índice de um item com um valor determinado por meio do método index()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 4, 6, 5, 7, 8, 5, 3, 1, 5]
lista.index(5)
	
	Copied

>_ Output

2.3.1.2. Comprensión de listas

Podemos operar através da lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []
 
# Iteramos por todos los items de la lista
for x in fruits:
  # Si el item contiene el caracter "a" lo añadimos a newlist
  if "a" in x:
    newlist.append(x)
 
newlist
	
	Copied

>_ Output

			
				['apple', 'banana', 'mango']

Outras coisas poderosas do Python são as list comprehensions, que permitem fazer tudo em uma única linha e deixam o código mais compacto

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
 
newlist = [x for x in fruits if "a" in x]
 
newlist
	
	Copied

>_ Output

			
				['apple', 'banana', 'mango']

A sintaxe é a seguinte:

newlist = [expression for item in iterable if condition == True]

Pode ser aproveitado para realizar operações na lista original

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		newlist = [x.upper() for x in fruits if "a" in x]
newlist
	
	Copied

>_ Output

			
				['APPLE', 'BANANA', 'MANGO']

2.3.1.3. Ordenar listas

Para ordenar listas usamos o método sort()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.sort()
lista
	
	Copied

>_ Output

			
				[3, 4, 5, 5, 6, 8, 9]

Também as ordena alfabeticamente

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["orange", "mango", "kiwi", "pineapple", "banana"]
lista.sort()
lista
	
	Copied

>_ Output

			
				['banana', 'kiwi', 'mango', 'orange', 'pineapple']

Ao ordenar alfabeticamente, distingue entre maiúsculas e minúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["orange", "mango", "kiwi", "Pineapple", "banana"]
lista.sort()
lista
	
	Copied

>_ Output

			
				['Pineapple', 'banana', 'kiwi', 'mango', 'orange']

Podem ser ordenados em ordem decrescente por meio do atributo reverse = True

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.sort(reverse = True)
lista
	
	Copied

>_ Output

			
				[9, 8, 6, 5, 5, 4, 3]

Podem ser ordenados da maneira que quisermos por meio do atributo key

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def myfunc(n):
  # devuelve el valor absoluto de n - 50
  return abs(n - 50)
 
lista = [100, 50, 65, 82, 23]
lista.sort(key = myfunc)
lista
	
	Copied

>_ Output

			
				[50, 65, 23, 82, 100]

Pode-se aproveitar isso para que, por exemplo, na hora de ordenar, não distinga entre maiúsculas e minúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["orange", "mango", "kiwi", "Pineapple", "banana"]
lista.sort(key = str.lower)
lista
	
	Copied

>_ Output

			
				['banana', 'kiwi', 'mango', 'orange', 'Pineapple']

É possível inverter a lista usando o método reverse

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.reverse()
lista
	
	Copied

>_ Output

			
				[6, 5, 9, 4, 3, 8, 5]

2.3.1.4. Copiar listas

Não se podem copiar listas por meio de lista1 = lista2, já que, se lista1 for modificada, lista2 também será modificada

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = lista1
lista1[0] = True
lista2
	
	Copied

>_ Output

			
				[True, 8, 3, 4, 9, 5, 6]

Então, deve-se usar o método copy()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = lista1.copy()
lista1[0] = True
lista2
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6]

Ou é preciso usar o construtor de listas list()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = list(lista1)
lista1[0] = True
lista2
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6]

2.3.1.5. Concatenar listas

Podem-se concatenar listas por meio do operador +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = ['a', 'b', 'c']
lista = lista1 + lista2
lista
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6, 'a', 'b', 'c']

Ou por meio do método extend

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = ['a', 'b', 'c']
lista1.extend(lista2)
lista1
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6, 'a', 'b', 'c']

Outra forma de concatenar é repetir a tupla X vezes por meio do operador *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = ['a', 'b', 'c']
lista2 = lista1 * 3
lista2
	
	Copied

>_ Output

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

2.3.2. Tuplas

As tuplas são semelhantes às listas, guardam vários itens em uma variável, podem conter itens de tipos diferentes, mas não podem ser modificadas nem reordenadas. Elas são definidas por meio de (), com os itens separados por vírgulas

Por não poderem ser modificadas, as tuplas são executadas um pouco mais rapidamente do que as listas, por isso, se não precisas modificar os dados, é melhor utilizar tuplas em vez de listas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0', 1, True, 3.3, 'item4', True)
tupla
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'item4', True)

Pode-se obter seu comprimento por meio da função len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len (tupla)
	
	Copied

>_ Output

Para criar tuplas com um único elemento, é necessário adicionar uma vírgula

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0',)
tupla, type(tupla)
	
	Copied

>_ Output

			
				(('item0',), tuple)

Para acessar um elemento da tupla, procede-se da mesma forma que com as listas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0', 1, True, 3.3, 'item4', True)
print(tupla[0])
print(tupla[-1])
print(tupla[2:4])
print(tupla[-4:-2])
	
	Copied

>_ Output

			
				item0
True
(True, 3.3)
(True, 3.3)

Podemos verificar se há um item na tupla

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'item4' in tupla
	
	Copied

>_ Output

			
				True

2.3.2.1. Modificar tuplas

Embora as tuplas não sejam modificáveis, elas podem ser modificadas convertendo-as em listas, modificando a lista e depois convertendo-a novamente em uma tupla

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = list(tupla)
lista[4] = 'ITEM4'
tupla = tuple(lista)
tupla
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'ITEM4', True)

Ao convertê-la em lista, podemos fazer todas as modificações vistas nas listas

O que se pode fazer é eliminar a tupla completa

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del tupla
 
if 'tupla' not in locals():
  print("tupla eliminada")
	
	Copied

>_ Output

			
				tupla eliminada

2.3.2.2. Desempacotar tuplas

Quando criamos tuplas, na verdade estamos empacotando dados

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0', 1, True, 3.3, 'item4', True)
tupla
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'item4', True)

mas podemos descompactá-los

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		item0, item1, item2, item3, item4, item5 = tupla
item0, item1, item2, item3, item4, item5
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'item4', True)

Se quisermos extrair menos dados do que o comprimento da tupla, adicionamos um *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		item0, item1, item2, *item3 = tupla
item0, item1, item2, item3
	
	Copied

>_ Output

			
				('item0', 1, True, [3.3, 'item4', True])

Pode-se colocar o asterisco * em outra parte se, por exemplo, o que queremos é o último item

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		item0, item1, *item2, item5 = tupla
item0, item1, item2, item5
	
	Copied

>_ Output

			
				('item0', 1, [True, 3.3, 'item4'], True)

2.3.2.3. Concatenar tuplas

As tuplas podem ser concatenadas usando o operador +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla1 = ("a", "b" , "c")
tupla2 = (1, 2, 3)
 
tupla3 = tupla1 + tupla2
tupla3
	
	Copied

>_ Output

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

Outra forma de concatenar é repetir a tupla X vezes mediante o operador *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla1 = ("a", "b" , "c")
 
tupla2 = tupla1 * 3
tupla2
	
	Copied

>_ Output

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

2.3.2.4. Métodos das tuplas

As tuplas têm dois métodos, o primeiro é o método count() que devolve o número de vezes que um item aparece dentro da tupla

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (5, 4, 6, 5, 7, 8, 5, 3, 1, 5)
tupla.count(5)
	
	Copied

>_ Output

Outro método é index() que devolve a primeira posição de um item dentro da tupla

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (5, 4, 6, 5, 7, 8, 5, 3, 1, 5)
tupla.index(5)
	
	Copied

>_ Output

2.3.3. Faixa

Com range() podemos criar uma sequência de números, começando a partir de 0 (por padrão), incrementando em 1 (por padrão) e parando antes de um número especificado

range(start, stop, step)

Por exemplo, se quisermos uma sequência de 0 a 5 (sem incluir o 5)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(5):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				0 1 2 3 4

Se, por exemplo, não queremos que comece em 0

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(2, 5):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				2 3 4

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(-2, 5):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				-2 -1 0 1 2 3 4

Por fim, se não quisermos que seja incrementado em 1, por exemplo, se quisermos uma sequência de números pares.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(0, 10, 2):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				0 2 4 6 8

2.4. Dicionários

Os dicionários são usados para guardar dados em pares key:value. São modificáveis, não ordenados e não permitem duplicidades. São definidos por meio dos símbolos {}. Admitem itens de diferentes tipos de dados

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "colors": ["red", "white", "blue"]
}
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford',
'model': 'Mustang',
'year': 1964,
'colors': ['red', 'white', 'blue']}

Como foi dito, eles não permitem duplicidades

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "year": 2000,
  "colors": ["red", "white", "blue"]
}
diccionario["year"]
	
	Copied

>_ Output

Pode-se obter seu comprimento por meio da função len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(diccionario)
	
	Copied

>_ Output

Como se pode ver, o comprimento é 4 e não 5, já que year o conta apenas uma vez

2.4.1. Aceder aos itens

Para acessar um elemento, podemos fazê-lo através de sua key

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario["model"]
	
	Copied

>_ Output

			
				'Mustang'

Também pode ser acessado por meio do método get

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.get("model")
	
	Copied

>_ Output

			
				'Mustang'

Para saber todas as keys dos dicionários, pode-se usar o método keys()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.keys()
	
	Copied

>_ Output

			
				dict_keys(['brand', 'model', 'year', 'colors'])

Pode-se usar uma variável para apontar para as keys do dicionário, com o que, chamando-a uma vez, é necessário

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se declara una vez la variable que apunta a las keys
x = diccionario.keys()
print(x)
 
# Se añade una nueva key
diccionario["color"] = "white"
 
# Se consulta la variable que apunta a las key
print(x)
	
	Copied

>_ Output

			
				dict_keys(['brand', 'model', 'year'])
dict_keys(['brand', 'model', 'year', 'color'])

Para obter os valores do dicionário, pode-se usar o método values()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.values()
	
	Copied

>_ Output

			
				dict_values(['Ford', 'Mustang', 1964, 'white'])

Pode-se usar uma variável para apontar para os valuess do dicionário, com o que chamando-a uma vez é necessário

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se declara una vez la variable que apunta a los values
x = diccionario.values()
print(x)
 
# Se modifica un value
diccionario["year"] = 2020
 
# Se consulta la variable que apunta a los values
print(x)
	
	Copied

>_ Output

			
				dict_values(['Ford', 'Mustang', 1964])
dict_values(['Ford', 'Mustang', 2020])

Se o que se quer são os items inteiros, ou seja keys e values, é preciso usar o método items()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.items()
	
	Copied

>_ Output

			
				dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 2020)])

Pode-se usar uma variável para apontar para os items do dicionário, de modo que, ao chamá-la uma vez, é necessário

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se declara una vez la variable que apunta a los items
x = diccionario.items()
print(x)
 
# Se modifica un value
diccionario["year"] = 2020
 
# Se consulta la variable que apunta a los items
print(x)
	
	Copied

>_ Output

			
				dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)])
dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 2020)])

Pode-se verificar se uma key existe no dicionário

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		"model" in diccionario
	
	Copied

>_ Output

			
				True

2.4.2. Modificar os itens

É possível modificar um item acessando-o diretamente?

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se modifica un item
diccionario["year"] = 2020
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 2020}

Ou pode ser modificado por meio do método update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se modifica un item
diccionario.update({"year": 2020})
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 2020}

2.4.3. Adicionar itens

Pode-se adicionar um item acrescentando-o desta maneira:

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se modifica un item
diccionario["colour"] = "blue"
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'colour': 'blue'}

Ou pode ser adicionado por meio do método update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se modifica un item
diccionario.update({"colour": "blue"})
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'colour': 'blue'}

2.4.4. Remover itens

É possível eliminar um item com uma key específica usando o método pop()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina un item
diccionario.pop("model")
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'year': 1964}

Ou é possível eliminar um item com uma key específica usando del, indicando o nome da key entre os símbolos []

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina un item
del diccionario["model"]
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'year': 1964}

O dicionário inteiro é eliminado se del for usado e a key de um item não for especificada

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina un item
del diccionario
 
if 'diccionario' not in locals():
  print("diccionario eliminado")
	
	Copied

>_ Output

			
				diccionario eliminado

Se o que se deseja é eliminar o último item introduzido, pode-se usar o método popitem()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina el último item introducido
diccionario.popitem()
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang'}

Se se quiser limpar o dicionário, é preciso usar o método clear()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario.clear()
diccionario
	
	Copied

>_ Output

{}

2.4.5. Copiar dicionários

Não se podem copiar dicionários por meio de diccionario1 = diccionario2, já que, se diccionario1 for modificado, diccionario2 também é modificado

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario1 = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario2 = diccionario1
diccionario1["year"] = 2000
diccionario2["year"]
	
	Copied

>_ Output

Portanto, é necessário usar o método copy()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario1 = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario2 = diccionario1.copy()
diccionario1["year"] = 2000
diccionario2["year"]
	
	Copied

>_ Output

Ou é preciso usar o construtor de dicionários dict()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario1 = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario2 = dict(diccionario1)
diccionario1["year"] = 2000
diccionario2["year"]
	
	Copied

>_ Output

2.4.6. Dicionários aninhados

Os dicionários podem ter items de qualquer tipo de dado, inclusive outros dicionários. A esse tipo de dicionários se chama dicionários nested

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario_nested = {
  "child1" : {
    "name" : "Emil",
    "year" : 2004
  },
  "child2" : {
    "name" : "Tobias",
    "year" : 2007
  },
  "child3" : {
    "name" : "Linus",
    "year" : 2011
  }
}
diccionario_nested
	
	Copied

>_ Output

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

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		child1 = {
  "name" : "Emil",
  "year" : 2004
}
child2 = {
  "name" : "Tobias",
  "year" : 2007
}
child3 = {
  "name" : "Linus",
  "year" : 2011
}
 
diccionario_nested = {
  "child1" : child1,
  "child2" : child2,
  "child3" : child3
}
 
diccionario_nested
	
	Copied

>_ Output

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

2.4.7. Métodos dos dicionários

Estes são os métodos que podem ser usados nos dicionários

2.4.8. Compreensão de dicionário

Assim como podíamos fazer list comprehensions por meio da sintaxe

list_comprehension = [expressão for item em iterable if condition == True]

Podemos fazer dictionaries comprehensions mediante a seguinte sintaxe

dictionary_comprehension = {expressão_chave: expressão_valor for item in iterable if condition == True}

Vamos ver um exemplo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		dictionary_comprehension = {x: x**2 for x in (2, 4, 6) if x &gt; 2}
dictionary_comprehension
	
	Copied

>_ Output

			
				{4: 16, 6: 36}

2.5. Conjuntos

2.5.1. Conjunto

Os sets são usados em Python para armazenar um conjunto de itens em uma única variável. Podem ser armazenados itens de diferentes tipos. São não ordenados e não têm índice.

Diferenciam-se das listas por não terem ordem nem índice.

São declarados por meio dos símbolos {}

Como set é uma palavra reservada em Python, criamos um set com o nome set_

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6}
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 'item0', 'item4'}

Não pode haver itens duplicados, se encontrar algum item duplicado, fica apenas com um.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6, 'item0'}
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 'item0', 'item4'}

Pode-se obter o comprimento do set por meio da função len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(set_)
	
	Copied

>_ Output

Como se pode ver, o comprimento do set é 6 e não 7, já que ele fica com apenas um 'item0'

Pode-se verificar se um item está no conjunto

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'item4' in set_
	
	Copied

>_ Output

			
				True

2.5.1.1. Adicionar itens

É possível adicionar um elemento ao conjunto usando o método add()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.add(8.8)
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 8.8, 'item0', 'item4'}

Pode-se adicionar outro conjunto por meio do método update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set2 = {"item5", "item6", 7}
set_.update(set2)
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5', 'item6'}

Também podem ser adicionados itens de tipos de dados iteráveis do Python

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["item9", 10, 11.2]
set_.update(lista)
set_
	
	Copied

>_ Output

			
				{1, 10, 11.2, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5', 'item6', 'item9'}

2.5.1.2. Remover itens

É possível remover um item específico por meio do método remove()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.remove('item9')
set_
	
	Copied

>_ Output

			
				{1, 10, 11.2, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5', 'item6'}

Ou por meio do método discard()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.discard('item6')
set_
	
	Copied

>_ Output

			
				{1, 10, 11.2, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5'}

Através do método pop(), é possível remover o último item, mas como os sets não são ordenados, não há como saber qual é o último item. O método pop() retorna o item removido

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(f"set antes de pop(): {set_}")
eliminado = set_.pop()
print(f"Se ha eliminado {eliminado}")
	
	Copied

>_ Output

			
				set antes de pop(): {1, 5, 5.3, 6.6, 8.8, 7, 10, 11.2, 'item5', 'item0', 'item4'}
Se ha eliminado 1

Por meio do método clear() é possível esvaziar o conjunto

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.clear()
set_
	
	Copied

>_ Output

			
				set()

Por fim, com del é possível eliminar o set

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del set_
 
if 'set_' not in locals():
  print("set eliminado")
	
	Copied

>_ Output

			
				set eliminado

2.5.1.3. Unir itens

Uma forma de unir conjuntos é por meio do método union()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
set3
	
	Copied

>_ Output

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

Outra forma é por meio do método update(), mas dessa maneira um conjunto é adicionado a outro, não se cria um novo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set1.update(set2)
set1
	
	Copied

>_ Output

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

Esses métodos de união eliminam os duplicados, mas se quisermos obter os elementos duplicados em dois conjuntos, usamos o método intersection()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set3 = set1.intersection(set2)
set3
	
	Copied

>_ Output

			
				{'apple'}

Se quisermos obter os elementos duplicados em dois sets, mas sem criar um novo set, usamos o método intersection_update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set1.intersection_update(set2)
set1
	
	Copied

>_ Output

			
				{'apple'}

Agora ao contrário, se quisermos ficar com os não duplicados usamos o método symmetric_difference().

A diferença entre isso e a união entre dois conjuntos é que na união ficam com todos os itens, mas os que estão duplicados são considerados apenas uma vez. Agora ficamos com os que não estão duplicados.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set3 = set1.symmetric_difference(set2)
set3
	
	Copied

>_ Output

			
				{'banana', 'cherry', 'google', 'microsoft'}

Se quisermos ficar com os não duplicados sem criar um novo conjunto, usamos o método symmetric_difference_update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set1.symmetric_difference_update(set2)
set1
	
	Copied

>_ Output

			
				{'banana', 'cherry', 'google', 'microsoft'}

2.5.1.4. Métodos dos conjuntos

Estes são os métodos que podem ser usados nos sets

2.5.2. FrozenSet

Os frozensets são como os sets, mas com a ressalva de que são imutáveis, assim como as tuplas são como as lists, mas imutáveis. Portanto, não poderemos adicionar ou eliminar itens

2.6. Booleanos

Há apenas dois booleanos em Python: True e False

Por meio da função bool() é possível avaliar se qualquer coisa é True ou False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(bool("Hello"))
print(bool(15))
print(bool(0))
	
	Copied

>_ Output

			
				True
True
False

2.6.1. Outros tipos de dados True e False

Os seguintes dados são True:

Qualquer string que não esteja vazia
Qualquer número exceto 0* Qualquer lista, tupla, dicionário ou conjunto que não esteja vazio

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(bool("Hola"))
print(bool(""))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(bool(3))
print(bool(0))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [1, 2, 3]
print(bool(lista))
 
lista = []
print(bool(lista))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (1, 2, 3)
print(bool(tupla))
 
tupla = ()
print(bool(tupla))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "colors": ["red", "white", "blue"]
}
print(bool(diccionario))
 
diccionario.clear()
print(bool(diccionario))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6}
print(bool(set_))
 
set_.clear()
print(bool(set_))
	
	Copied

>_ Output

			
				True
False

2.7. Binários

2.7.1. Bytes

O tipo bytes é uma sequência imutável de bytes. Só admitem caracteres ASCII. Também se podem representar os bytes por meio de números inteiros cujos valores devem cumprir 0 <= x < 256

Para criar um tipo byte devemos introduzir antes o caractere b

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte = b"MaximoFN"
byte
	
	Copied

>_ Output

			
				b'MaximoFN'

Também podem ser criadas por meio do seu construtor bytes()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte = bytes(10)
byte
	
	Copied

>_ Output

b''

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte = bytes(range(10))
byte
	
	Copied

>_ Output

			
				b'	'

Podem-se concatenar bytes mediante o operador +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte1 = b'DeepMax'
byte2 = b'FN'
byte3 = byte1 + byte2
byte3
	
	Copied

>_ Output

			
				b'DeepMaxFN'

Ou por meio da repetição com o operador *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte1 = b'MaximoFN '
byte2 = byte1 * 3
byte2
	
	Copied

>_ Output

			
				b'MaximoFN MaximoFN MaximoFN '

Podemos verificar se um caractere está dentro da cadeia de texto

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		b'D' in byte1
	
	Copied

>_ Output

			
				False

Estes são os métodos que podem ser usados nos bytes

2.7.2. Bytearray

Os bytearrays são iguais aos bytes, só que são mutáveis

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte_array = bytearray(b'MaximoFN')
byte_array
	
	Copied

>_ Output

			
				bytearray(b'MaximoFN')

2.7.3. MemoryView

Os objetos memoryview permitem que o código Python acesse os dados internos de um objeto que suporta o protocolo de buffer sem realizar cópias.

A função memoryview() permite o acesso direto de leitura e escrita aos dados orientados a bytes de um objeto sem a necessidade de copiá-los primeiro. Isso pode gerar grandes ganhos de desempenho ao trabalhar com objetos grandes, já que não cria uma cópia ao fatiar.

Protocolo de buffer, pode criar outro objeto de acesso para modificar os dados grandes sem copiá-los. Isso faz com que o programa use menos memória e aumente a velocidade de execução.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte_array = bytearray('XYZ', 'utf-8')
print(f'Antes de acceder a la memoria: {byte_array}')
 
mem_view = memoryview(byte_array)
 
mem_view[2]= 74
print(f'Después de acceder a la memoria: {byte_array}')
	
	Copied

>_ Output

			
				Antes de acceder a la memoria: bytearray(b'XYZ')
Después de acceder a la memoria: bytearray(b'XYJ')

---

➡️ **Continua na Parte 2: operadores, control de fluxo e funções**, onde você aprenderá a operar com os dados e a estruturar seu código com funções.

Continuar lendo

Deep Research com LangGraph (3/3): agente Writer e relatório final

Terceira e última parte da série Deep Research com LangGraph. Implemente o agente Writer que redige o relatório final a partir da pesquisa, integre todo o grafo do deep researcher e execute o assistente completo de ponta a ponta.

Deep Research com LangGraph (2/3): Research Supervisor multiagente

Segunda parte da série Deep Research com LangGraph. Construa o Research Supervisor que coordena vários agentes Researche...

Deep Research com LangGraph (1/3): agentes Scope e Researcher

Primeira parte da série para criar um assistente de pesquisa com LangGraph. Conheça a arquitetura do sistema e construa ...

Últimos posts -->

Você viu esses projetos?

Gymnasia

Horeca chatbot

Naviground

Ver todos os projetos -->

>_ Disponível para projetos

Tem um projeto com IA?

Vamos conversar.

maximofn@gmail.com

Especialista em Machine Learning e Inteligência Artificial. Desenvolvo soluções com IA generativa, agentes inteligentes e modelos personalizados.

Escreva-me LinkedIn

Quer assistir alguma palestra?

Agentes do Amanhã: Descifrando os Mistérios da Planificação, UX e Memória

Agentes de IA, impulsionados por LLMs, prometem transformar aplicações. Mas eles são meros executores hoje ou futuros colaboradores inteligentes? Para...

Crie sua própria inteligência Apple

Aprenda a criar um sistema de IA para executar eficientemente em um dispositivo

Últimas palestras -->

Quer melhorar com essas dicas?

Boas práticas criando agentes com Claude Code

Palestra técnica: skills, subagentes, slash commands e MCPs no Claude Code

o1 prompt engineering

Criar prompts melhores para o1 seguindo um exemplo

Memory profiler

Ver o uso de memória de um script

Últimos tips -->

Use isso localmente

Os espaços do Hugging Face nos permitem executar modelos com demos muito simples, mas e se a demo quebrar? Ou se o usuário a deletar? Por isso, criei contêineres docker com alguns espaços interessantes, para poder usá-los localmente, aconteça o que acontecer. Na verdade, se você clicar em qualquer botão de visualização de projeto, ele pode levá-lo a um espaço que não funciona.