4 - Variáveis, Literais e 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(f"x = 1; type(x): {type(x)}")
print(f"y = 35656222554887711; type(y): {type(y)}")
print(f"z = -3255522; type(z): {type(z)}")

x = 1; type(x): <class 'int'>
y = 35656222554887711; type(y): <class 'int'>
z = -3255522; type(z): <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(f"x = 1.10; type(x): {type(x)}")
print(f"y = 1.0; type(y): {type(y)}")
print(f"z = -35.59; type(z): {type(z)}")

x = 1.10; type(x): <class 'float'>
y = 1.0; type(y): <class 'float'>
z = -35.59; type(z): <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(f"x = 35e3; type(x): {type(x)}")
print(f"y = 12E4; type(y): {type(y)}")
print(f"z = -87.7e100; type(z): {type(z)}")

x = 35e3; type(x): <class 'float'>
y = 12E4; type(y): <class 'float'>
z = -87.7e100; type(z): <class 'float'>

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

x = 3+5j
y = 5j
z = -5j

print(f"x = 3+5j; type(x): {type(x)}")
print(f"y = 5j; type(y): {type(y)}")
print(f"z = -5j; type(z): {type(z)}")

x = 3+5j; type(x): <class 'complex'>
y = 5j; type(y): <class 'complex'>
z = -5j; type(z): <class 'complex'>

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

Conversão de número inteiro para outro tipo numérico:

print(f"type(float(1)) = {type(float(1))}")
print(f"type(complex(1)) = {type(complex(1))}")

print(f"type(int(2.8)) = {type(int(2.8))}")
print(f"type(complex(2.8)) = {type(complex(2.8))}")

type(float(1)) = <class 'float'>
type(complex(1)) = <class 'complex'>
type(int(2.8)) = <class 'int'>
type(complex(2.8)) = <class 'complex'>

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

try:
    print(f"type(int(1+2j)) = {type(int(1+2j))}")
except:
    print("Erro ao tentar converter int(1+2j)!")

try:
    print(f"type(float(1+2j)) = {type(float(1+2j))}")
except:
    print("Erro ao tentar converter float(1+2j)!")

Erro ao tentar converter int(1+2j)!
Erro ao tentar converter float(1+2j)!

Conversão de um número para tipo texto:

print(f"type(str(1)) = {type(str(1))}")
print(f"type(str(2.8)) = {type(str(2.8))}")
print(f"type(str(1+2j)) = {type(str(1+2j))}")

type(str(1)) = <class 'str'>
type(str(2.8)) = <class 'str'>
type(str(1+2j)) = <class 'str'>

Conversão do tipo texto para tipos numéricos:

print(f"type(int('1')) = {type(int('1'))}")
print(f"type(float('2.8')) = {type(float('2.8'))}")
print(f"type(complex('1+2j')) = {type(complex('1+2j'))}")

type(int('1')) = <class 'int'>
type(float('2.8')) = <class 'float'>
type(complex('1+2j')) = <class 'complex'>

Python não tem uma função para gerar números aleatórios, mas tem o pacote nativo random.

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

8

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 direita para esquerda, da posição -5 (incluída) até a posição -2 (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 formatados 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 ordem 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 = 60
txt = "Tenho " + idade + " anos"

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

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

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

Meu nome é Roberto e tenho 60 anos.

Podemos usar o atalho de formatação de textos iniciados com a letra "f" e colocando as variáveis entre chaves.

nome ="Roberto"
idade = 60
txt = f"Meu nome é {nome} e tenho {idade} anos."
print(txt)

Meu nome é Roberto e tenho 60 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 0x0000018D431F3100>

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.

Exemplos dos métodos de texto da classe str.

capitalize(): Converte o primeiro caractere do texto para maiúscula.

print("alô, mundo!".capitalize())

Alô, mundo!

casefold(): Converte o texto em minúsculas.

print("Alô, Mundo!".casefold())

alô, mundo!

center(): Centraliza o texto.

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

|                   Alô, mundo!                    |

count(): Retorna o número de ocorrencias de um valor especificado.

print("Temos quantas letras 'e' nessa frase?".count("e"))
print("Alô, mundo".count("o"))

5
1

encode(): Retorna o texto em bytes.

print("Alô, mundo!".encode())

b'Al\xc3\xb4, mundo!'

endswith(): Retorna verdadeiro se o texto terminar com o valor especificado.

a = "Alô, mundo!"
print(a.endswith("o"))
print(a.endswith("!"))

False
True

expandtabs(): Substitui o tab por um número especificado de espaços.

print("Alô,\tmundo!".expandtabs(20))

Alô,                mundo!

find(): Procura no texto por um valor especificado e retorna a posição de onde foi encontrado.

a = "Alô, mundo!"
print(a.find("ô"))
print(a.find("o"))

2
9

format(): Formata um texto com valores.

print("Alô, {}, este é o mundo!".format("Roberto"))

Alô, Roberto, este é o mundo!

index(): Procura no texto por um valor especificado e retorna a posição de onde foi encontrado.

print("Alô, mundo!".index("o"))

9

isalnum(): Retorna verdadeiro se o texto contém apenas letras ou números.

print("abc".isalnum())
print("123".isalnum())
print("abc123".isalnum())
print("abc 123".isalnum())

True
True
True
False

isalpha(): Retorna verdadeiro se o texto contém apenas letras.

print("abc".isalpha())
print("ABC".isalpha())
print("123".isalpha())
print("abc123".isalpha())

True
True
False
False

isdecimal(): Retorna verdadeiro se o texto contém apenas números decimais, de 0 a 9, sem pontos, virgulas ou sublinhados.

print("abc".isdecimal())
print("123".isdecimal())
print("123.".isdecimal())
print("123.1".isdecimal())

False
True
False
False

isdigit(): Retorna verdadeiro se o texto contém apenas números.

print("abc".isdigit())
print("123".isdigit())
print("123.".isdigit())
print("123.1".isdigit())

False
True
False
False

isidentifier(): Retorna verdadeiro se o texto contém apenas letras, números e sublinhados.

print("a_A_1".isidentifier())
print("a _A_ 1".isidentifier())

True
False

islower(): Retorna verdadeiro se o texto contém apenas letras minúsculas.

print("ALÔ, MUNDO!".islower())
print("Alô, mundo!".islower())
print("alô, mundo!".islower())

False
False
True

isnumeric(): Retorna verdadeiro se o texto contém apenas números.

print("123".isnumeric())
print("123.".isnumeric())
print("123.3".isnumeric())
print("abc123".isnumeric())

True
False
False
False

isspace(): Retorna verdadeiro se o texto contém apenas espaços.

print("Alô, mundo!".isspace())
print("           ".isspace())

False
True

istitle(): Retorna verdadeiro se o texto contém apenas palavras com primeira letra maiúscula.

print("Alô, mundo!".istitle())
print("Alô, Mundo!".istitle())

False
True

isupper(): Retorna verdadeiro se o texto contém apenas letras maiúsculas.

print("Alô, mundo!".isupper())
print("ALÔ, MUNDO!".isupper())

False
True

join(): Junta os textos de uma coleção com o texto especificado.

print(",".join(["1","2","3"]))

1,2,3

ljust(): Justifica o texto à esquerda dentro do espaço especificado.

print(f"|{'Alô, mundo.'.ljust(50)}|")

|Alô, mundo.                                       |

lower(): Converte o texto em minúsculas.

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

alô, mundo!

lstrip(): Remove os espaços no início do texto.

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

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

partition(): Divide o texto em tupla de trechos a partir da primeira ocorrência do valor especificado, da esquerda para a direita.

print("123.456.789".partition("."))

('123', '.', '456.789')

replace(): Substitui um valor por outro.

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

Alô, Brasil!

rfind(): Procura no texto por um valor especificado e retorna a posição de onde foi encontrado.

print("Alô, mundo!".rfind("o"))

9

rindex(): Procura no texto por um valor especificado e retorna a posição de onde foi encontrado.

print("Alô, mundo!".rindex("o"))

9

rjust(): Justifica o texto à direita dentro do espaço especificado.

print(f"|{'Alô, mundo.'.rjust(50)}|")

|                                       Alô, mundo.|

rpartition(): Divide o texto em tupla de trechos a partir da primeira ocorrência do valor especificado, da direita para a esquerda.

print("123.456.789".rpartition("."))

('123.456', '.', '789')

rstrip(): Remove os espaços no final do texto.

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

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

split(): Divide o texto em uma lista.

print("0,1,2,3,4,5,6,7,8,9".split(","))

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

splitlines(): Divide o texto contendo o caracter de escape de quebra de linha (\n) em uma lista de linhas.

print("Linha 1\nLinha 2\nLinha 3".splitlines())

['Linha 1', 'Linha 2', 'Linha 3']

startswith(): Retorna verdadeiro se o texto comecar com o valor especificado.

print("Alô, mundo!".startswith("A"))
print("Alô, mundo!".startswith("a"))

True
False

strip(): Remove os espaços no início e no final do texto.

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

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

swapcase(): Inverte maiúsculas e minúsculas.

print("Alô, mundo!".swapcase())

aLÔ, MUNDO!

title(): Converte o texto em palavras com primeira letra maiúscula.

print("este é um título".())

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

upper(): Converte o texto em maiúsculas.

print("Alô, mundo!".upper())

ALÔ, MUNDO!

zfill(): Acrescenta zeros a esquerda do texto.

print("101".zfill(8))

00000101

O construtor bool() permite avaliar e converter os valores constantes ou de variáveis de outros tipos, usados no argumento do construtor, em valores lógicos, se houver correspondência possível.

A maioria dos tipos pode ser convertida em valores lógicos, seguindo critérios para considerar o valor como verdadeiro ou falso.

Zero de qualquer tipo numérico (0, 0.0, 0j, respectivamente inteiro, real e complexo), texto vazio ("" ou ''), sequências vazias ('', (), []), e conjuntos vazios ({}) são considerados falsos.

print(f"bool(0): {bool(0)}, bool(15): {bool(15)}")
print(f"bool(0.0): {bool(0.0)}, bool(15.0): {bool(15.0)}")
print(f"bool(0j): {bool(0j)}, bool(15j): {bool(15j)}")
print(f"bool(''): {bool('')}, bool('Alô!'): {bool('Alô!')}")
print(f"bool([]): {bool([])}, bool([1,2,3]): {bool([1,2,3])}")
print(f"bool(()): {bool(())}, bool((1,2,3)): {bool((1,2,3))}")
print(f"bool({{}}): {bool({})}, bool({1,2,3}): {bool({1,2,3})}")
print(f"bool(False): {bool(False)}, bool(True): {bool(True)}")

bool(0): False, bool(15): True
bool(0.0): False, bool(15.0): True
bool(0j): False, bool(15j): True
bool(''): False, bool('Alô!'): True
bool([]): False, bool([1,2,3]): True
bool(()): False, bool((1,2,3)): True
bool({}): False, bool((1, 2, 3)): True
bool(False): False, bool(True): True

Usando variáveis recebendo os resultados da chamada do construtor bool():

a = ""
b = 0
x = "Alô!"
y = 15
print(f"a = ''; bool(a): {bool(a)}")
print(f"b = 0; bool(b): {bool(b)}")
print(f"x = 'Alô!'; bool(x): {bool(x)}")
print(f"y = 15; bool(y): {bool(y)}")

a = ''; bool(a): False
b = 0; bool(b): False
x = 'Alô!'; bool(x): True
y = 15; bool(y): True

Principais métodos da classe date:

Exemplos dos métodos de instância da classe date.

Criamos um objeto da classe date com ano, mês e dia na variável apenas_data.

import datetime as dt
apenas_data = dt.date(2024, 6, 12)

year: Retorna o ano.

print(apenas_data.year)

2024

month: Retorna o mês.

print(apenas_data.month)

6

day: Retorna o dia.

print(apenas_data.day)

12

weekday: Retorna o dia da semana.

print(apenas_data.weekday())

2

isoweekday: Retorna o dia da semana ISO.

print(apenas_data.isoweekday())

3

isoformat(): Retorna o horário ISO.

print(apenas_data.isoformat())

2024-06-12

ctime(): Retorna um texto representando a data.

print(apenas_data.ctime())

Wed Jun 12 00:00:00 2024

strftime(): Retorna um texto representando a data, controlada por um texto explícito de formatação.

print(apenas_data.strftime("%d-%m-%Y"))

12-06-2024

Para criar um horário, podemos usar o método-construtor da classe time() do módulo datetime.

Exemplo: Crie um objeto de horário.

import datetime as dt
apenas_data = dt.time(10,15,30)
print(apenas_data)

10:15:30

A classe time() recebe parâmetros para hora e fuso horário (hora, minuto, segundo, microssegundo, tzone), mas eles são opcionais e estão com o valor padrão de 0, (None para fuso horário).

Os métodos da classe time:

Exemplos dos métodos de horário da classe time.

hour(): Retorna a hora.

import time as tm
import datetime as dt
apenas_hms = dt.time(10, 15, 30, 60, dt.timezone.utc)

hour: Retorna a hora.

print(apenas_hms.hour)

10

minute: Retorna o minuto.

print(apenas_hms.minute)

15

second: Retorna o segundo.

print(apenas_hms.second)

30

microsecond: Retorna o microssegundo.

print(apenas_hms.microsecond)

60

tzinfo: Retorna o fuso horário.

print(apenas_hms.tzinfo)

UTC

tzname(): Retorna o nome do fuso horário.

print(apenas_hms.tzname())

UTC

utcoffset(): Retorna o fuso horário.

print(apenas_hms.utcoffset())

0:00:00

dst(): Retorna o fuso horário.

print(apenas_hms.dst())

None

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
data_hora = dt.datetime(2018, 6, 1)
print(data_hora.strftime("%B"))

June

Exemplos da tabela acima:

import datetime as dt
data_hora = dt.datetime(2024, 5, 30)
def print_data(simbolo,descricao,data_hora=data_hora):
    print(f'{simbolo}: {data_hora.strftime(simbolo):12} ({descricao})')
print_data('%a','Dia da semana, versão curta')
print_data('%A','Dia da semana, versão completa')
print_data('%w','Dia da semana como um número 0-6, 0 é domingo')
print_data('%d','Dia do mês 01-31')
print_data('%b','Nome do mês, versão curta')
print_data('%B','Nome do mês, versão completa')
print_data('%m','Mês como um número 01-12')   
print_data('%y','Ano, versão curta')
print_data('%Y','Ano, versão completa')
print_data('%H','Hora 00-23')
print_data('%I','Hora 00-12')
print_data('%p','AM/PM')
print_data('%M','Minuto 00-59')
print_data('%S','Segundo 00-59')
print_data('%f','Microssegundo 000000-999999')
print_data('%z','deslocamento UTC')
print_data('%Z','fuso horário CST')
print_data('%j','Número do dia do ano 001-366')
print_data('%U','Número da semana do ano, domingo como o primeiro dia da semana, 00-53')
print_data('%W','Número da semana do ano, segunda-feira como o primeiro dia da semana, 00-53')
print_data('%c','Versão local de data e hora')
print_data('%C','Século 20')
print_data('%x','Versão local da data')
print_data('%X','Versão local da hora')
print_data('%%','Um personagem %')
print_data('%G','ISO 8601 ano')
print_data('%u','ISO 8601 dia da semana (1-7)')
print_data('%V','número da semana ISO 8601 (01-53)')

%a: Thu          (Dia da semana, versão curta)
%A: Thursday     (Dia da semana, versão completa)
%w: 4            (Dia da semana como um número 0-6, 0 é domingo)
%d: 30           (Dia do mês 01-31)
%b: May          (Nome do mês, versão curta)
%B: May          (Nome do mês, versão completa)
%m: 05           (Mês como um número 01-12)
%y: 24           (Ano, versão curta)
%Y: 2024         (Ano, versão completa)
%H: 00           (Hora 00-23)
%I: 12           (Hora 00-12)
%p: AM           (AM/PM)
%M: 00           (Minuto 00-59)
%S: 00           (Segundo 00-59)
%f: 000000       (Microssegundo 000000-999999)
%z:              (deslocamento UTC)
%Z:              (fuso horário CST)
%j: 151          (Número do dia do ano 001-366)
%U: 21           (Número da semana do ano, domingo como o primeiro dia da semana, 00-53)
%W: 22           (Número da semana do ano, segunda-feira como o primeiro dia da semana, 00-53)
%c: Thu May 30 00:00:00 2024 (Versão local de data e hora)
%C: 20           (Século 20)
%x: 05/30/24     (Versão local da data)
%X: 00:00:00     (Versão local da hora)
%%: %            (Um personagem %)
%G: 2024         (ISO 8601 ano)
%u: 4            (ISO 8601 dia da semana (1-7))
%V: 22           (número da semana ISO 8601 (01-53))

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".

Exemplo: ordenação e reordenação de listas.

Listas originais:

print('--> listas originais')
lista_alfa = ["laranja", "manga", "kiwi", "abacaxi", "banana"]
lista_num = [100, 50, 65, 82, 23]
print(lista_alfa)
print(lista_num)

--> listas originais
['laranja', 'manga', 'kiwi', 'abacaxi', 'banana']
[100, 50, 65, 82, 23]

Listas ordenadas:

print('--> listas ordenadas')
lista_alfa.sort()
lista_num.sort()
print(lista_alfa)
print(lista_num)

--> listas ordenadas
['abacaxi', 'banana', 'kiwi', 'laranja', 'manga']
[23, 50, 65, 82, 100]

Listas ordenadas de forma reversa:

print('--> listas com ordenação reversa')
lista_alfa.sort(reverse = True)
lista_num.sort(reverse = True)
print(lista_alfa)
print(lista_num)

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

Mutabilidade das listas

A lista é mutável, o que significa que podemos alterar, adicionar e remover itens nela após sua criação.

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

A seguir exemplos dos métodos de lista.

append(): Adiciona um elemento no final da lista.

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

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

copy(): Retorna uma cópia da lista.

print(lista.copy())

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

count(): Retorna o número de elementos com o valor especificado.

print(lista.count("banana"))

1

extend(): Adiciona os elementos de uma lista (ou qualquer iterável), ao final da lista atual.

lista.extend(["cajú", "abacaxi", "laranja"])
print(lista)

['maçã', 'banana', 'cereja', 'morango', 'cajú', 'abacaxi', 'laranja']

index(): Retorna o índice do primeiro elemento com o valor especificado.

print(lista.index("banana"))

1

insert(): Adiciona um elemento na posição especificada.

lista.insert(1, "laranja")
print(lista)

['maçã', 'laranja', 'banana', 'cereja', 'morango', 'cajú', 'abacaxi', 'laranja']

pop(): Remove o elemento na posição especificada.

print(lista.pop(1))

laranja

remove(): Remove o item com o valor especificado.

lista.remove("laranja")
print(lista)

['maçã', 'banana', 'cereja', 'morango', 'cajú', 'abacaxi']

reverse(): Inverte a ordem da lista.

lista.reverse()
print(lista)

['abacaxi', 'cajú', 'morango', 'cereja', 'banana', 'maçã']

sort(): Classifica a lista.

lista.sort()
print(lista)

['abacaxi', 'banana', 'cajú', 'cereja', 'maçã', 'morango']

sort(reverse=True): Classifica a lista inversamente.

lista.sort(reverse=True)
print(lista)

['morango', 'maçã', 'cereja', 'cajú', 'banana', 'abacaxi']

len(): Retorna o tamanho da lista.

print(len(lista))

6

in: Retorna True se o elemento estiver na lista e False se o elemento não estiver na lista.

print("banana" in lista)

True

not in: Retorna True se o elemento não estiver na lista e False se o elemento estiver na lista.

print("banana" not in lista)

False

clear(): Remove todos os elementos da lista.

lista.clear()
print(lista)

[]

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'

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

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

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']

As listas podem ser modificadas, adicionando ou sobrepondo novos itens ou removendo itens existentes.

Alteração de um item da lista

Para alterar o valor de um item específico, consulte o item pela sua posição usando o número do índice:

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

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

Duplicação de itens

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']

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: alteraçã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']

Adicão de itens na lista

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

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

['maçã', 'banana', 'melão', 'laranja']

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", "cajú"]
lista.insert(1, "laranja")
print(lista)

['maçã', 'laranja', 'banana', 'cajú']

Remover itens da lista

Remover item especificado

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

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

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

Remover índice especificado

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

Exemplo: remoção do segundo item.

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

['maçã', 'cajá']

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

Exemplo: remoção do último item.

lista = ["maçã", "banana", "pitanga"]
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", "acerola"]
del lista[0]
print(lista)

['banana', 'acerola']

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

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

Limpar a lista

O método clear() esvazia a lista, que continua existindo, sem itens.

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

[]

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

Laços de iteração

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

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

maçã
banana
maracujá

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", "abacate"]
for i in range(len(lista)): print(lista[i])

maçã
banana
abacate

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.

frutas = ["maçã", "Coco", "mangaba", "kiwi", "maçã"]

Sem compreensão de lista:

nova_lista = []
for x in frutas:
    if "a" in x:
        nova_lista.append(x)
print(nova_lista)

['maçã', 'mangaba', 'maçã']

Com compreensão de lista:

nova_lista = [x for x in frutas if "a" in x]
print(nova_lista)

['maçã', 'mangaba', 'maçã']

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.

frutas = ["maçã", "banana", "framboesa"]

Atribuindo frutas para nova_lista_1:

nova_lista_1 = frutas
print(nova_lista_1 == frutas)
print(nova_lista_1 is frutas)

True
True

Existem diferentes maneiras para copiar de uma listas:

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

Atribuindo frutas.copy() para nova_lista_2:

nova_lista_2 = frutas.copy()
print(nova_lista_2 == frutas)
print(nova_lista_2 is frutas)
print(nova_lista_2 == nova_lista_1)
print(nova_lista_2 is nova_lista_1)

True
False
True
False

Atribuindo list(frutas) para nova_lista_3:

nova_lista_3 = list(frutas)
print(nova_lista_3 == frutas)
print(nova_lista_3 is frutas)
print(nova_lista_3 == nova_lista_2)
print(nova_lista_3 is nova_lista_2)
print(nova_lista_3 == nova_lista_1)
print(nova_lista_3 is nova_lista_1)

True
False
True
False
True
False

Atribuindo [x for x in frutas] para nova_lista_4:

nova_lista_4 = [x for x in frutas]
print(nova_lista_4 == frutas)
print(nova_lista_4 is frutas)
print(nova_lista_4 == nova_lista_3)
print(nova_lista_4 is nova_lista_3)
print(nova_lista_4 == nova_lista_2)
print(nova_lista_4 is nova_lista_2)
print(nova_lista_4 == nova_lista_1)
print(nova_lista_4 is nova_lista_1)

True
False
True
False
True
False
True
False

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.

Exemplo: concatenando listas.

Declaramos as listas lista_1 e lista_2, e a lista_3 contendo os itens das listas lista_1 e lista_2 concatenadas com o operador "+".

lista_1 = ["a", "b", "c"]
lista_2 = [1, 2, 3]
lista_3 = lista_1 + lista_2
print("lista_1 =", lista_1)
print("lista_2 =", lista_2)
print("lista_3 =", lista_3)

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

Exemplo: concatenando listas com o método extend.

# criamos uma cópia da lista_1
copia = lista_1.copy()
# concatenamos os itens da lista_2
copia.extend(lista_2)
# imprimimos a cópia concatenada
print("copia =", copia)

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

Exemplo: concatenando listas com o método append.

# criamos uma cópia da lista_1
copia = lista_1.copy()
# concatenamos os itens da lista_2
for x in lista_2:
    copia.append(x)
# imprimimos a cópia concatenada
print("copia =", copia)

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

Você pode acessar os itens da tupla consultando o número do índice entre colchetes '[' e ']'.

O primeiro item tem índice [0] (índice zero) e o último tem índice [len(tupla)-1] (número de itens da tupla menos um).

frutas = ("manga", "abacate", "laranja", "uva")
print(f"frutas = {frutas}")
# impressão do segundo item na tupla 'frutas'
print(f"frutas[1] = {frutas[1]}")

frutas = ('manga', 'abacate', 'laranja', 'uva')
frutas[1] = abacate

Impressão de todos os itens na lista:

for i in range(len(frutas)):
    print(f"frutas[{i}] = {frutas[i]}")

frutas[0] = manga
frutas[1] = abacate
frutas[2] = laranja
frutas[3] = uva

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, o índice [-2] referindo-se ao penúltimo, e assim por diante, até o índice [0].

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

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

cereja

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')

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

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

O primeiro item tem índice 0.

Exemplo: itens do primeiro item ao item do índice 4 (não incluído).

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')

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

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

Laço while

O laço while é usado para percorrer os itens da tupla, enquanto a condição for verdadeira.

tupla = ("maçã", "banana", "cereja")
i = 0
while i < len(tupla):
    print(tupla[i])
    i = i + 1

maçã
banana
cereja

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

Existem soluções alternativas.

Alteração da tupla

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

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

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

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.

Converter em uma lista:

Assim como a solução alternativa para alterar uma tupla, você pode convertê-la em uma lista, adicionar itens e convertê-la novamente em uma tupla.

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

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

Concatenar tuplas:

Você pode adicionar duas tuplas com os operadores de atribuição + ou += e atribuir em uma variável.

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

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

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

aux = ("maçã")
print(f"{aux}: {type(aux)}")

aux = ("maçã",)
print(f"{aux}: {type(aux)}")

maçã: <class 'str'>
('maçã',): <class 'tuple'>

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 0x0000018D43519B00>

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