2. Tipos de dados fundamentais

2. Tipos de dados fundamentais#

Tipos numéricos#

Int (inteiro)#

São valores que representam números inteiros, positivos ou negativos, sem casas decimais. Normalmente os utilizamos como contadores, índice ou quantidades discretas.

Exemplos: -5, 0, 25, 1000

numero_de_alunos = 30
ANO_NASCIMENTO = 2005
saldo_gols = -3

Float (ponto flutuante)#

Representa números reais, ou seja, números com casas decimais. Podem, até mesmo, ser expressos em notação ciêntífica (ex: 2.5e2 para representar 250.0).

São usados em Medidas, cálculos financeiros, qualquer valor que possa ter frações. Entretanto, números de pontos flutuantes têm uma precisão limitada devido à forma como são armazenados no computador. Para cálculos financeiros que exigem precisão exata, é mais indicado utilizar o módulo decimal.

Exemplos: 2.14158, -0.002, 2.0, 7.89e3

preco_produto = 19.99
PI = 3.14159
temperatura = -3.2

Complex (complexo)#

Representa números complexos, que têm uma parte real e uma parte imaginária (geralmente indicada por j em Python). É usada principalmente em domínios científicos e de engenharia elétrica. Para o dia a dia da maioria dos desenvolvedores, não é tão comum.

Exemplos: 3+5j, 2-8j, 2j

numero_complexo = 2 + 3j
print(numero_complexo.real)    # Saída: 2.0
print(numero_complexo.imag)    # Saída: 3.0

2.0
3.0

Atenção: Como esse é um curso introdutório, não iremos focar muito nos números complexos.

Tipo de Texto#

Str (string)#

Representa sequências de caracteres, ou seja, texto. Strings podem ser delimitadas por aspas simples (' ') ou aspas duplas (" "). Existe também as aspas triplas (''' ''' ou """ """) que servem para que o texto ocupe múltiplas linhas. Strings são usadas para armazenar nomes, mensagens, caminhos de arquivos, qualquer tipo de dado textual.

Exemplos:

saudacao = "Olá, mundo!"
nome = 'Maria'
paragrafo = """Este é um texto
que ocupa múltiplas
linhas."""

Curiosidade: Um fato interessante é que, em Python, strings são imutáveis. Isso significa que, uma vez criada, uma string não pode ser alterada. Qualquer operação que pareça modificar uma string, na verdade, cria uma nova string.

Operações básicas#

É possível realizar algumas operações com strings, são elas:

  • Concatenação (+): Juntar strings;

primeiro_nome = "João" 
sobrenome = "Silva" 
nome_completo = primeiro_nome + " " + sobrenome

print(nome_completo)
print("Pedro " + "Miguel") # Você também pode fazer a concatenação dentro da função print

João Silva
Pedro Miguel

  • Repetição (*): Repete strings num determinado número de vezes;

spam = "Span"

print("-" * 10) # Aqui o símbolo de multiplicação (*) deve sempre está acompanhado de um número e uma string
print(spam * 5) # Ou pode ser uma variável que armazena uma string e um número

----------
SpanSpanSpanSpanSpan

  • Indexação: Permite acessar um caractere específico pela sua posição (índice, começando em 0). Observação: O índice sempre deve está entre couchetes [];

letra_p = "Programador"
print(letra_p[0]) # O índice 0 representa a primeira letra da palvra (p)

P

  • Fatiamento (slicing): Permite obter uma parte específica da string. É realizado entre colchetes [], juntamente com índices que especificam o início e o fim do intervalo que queremos fatiar.

ola_mundo = "Olá Mundo"
ola = ola_mundo[:3]
mundo = ola_mundo[4:]

print(ola)
print(mundo)

Olá
Mundo

Observe que nesses fatiamentos, ignoramos o índice de ínicio na primeira variável (ola) e o último índice da variável (mundo), fizemos isso por que já sabíamos que o primeiro fatiamente começaria pelo índice 0, então não precisaríamos declará-lo, já no segundo fatiamente como ele iria até o último índice, não precisamos definí-lo.

Tipo Booleano#

Representa um dos dois valores de verdade: True (verdadeiro) ou False (falso). É comumente usado em expressões lógicas, estruturas de controle (como if ou while) para tomar decisões no programa.

Exemplos:

tem_permissao = True
login_falhou = False

Contexto Booleano#

Muitos valores em Python podem ser avaliados como True ou False em um contexto booleano:

  • Falsos (false): None, False, 0 (zero de qualquer tipo numérico), sequências vazias('', [], (), {}), mapeamento vazios({}).

  • Verdadeiros (true): Quase todo o resto.

Tipo None#

É um tipo especial que tem um único valor: None.

Ele representa a ausência de um valor ou um valor nulo. É frequentemente usado para indicar que uma variável não tem um valor atribuido ainda, ou que uma função não retorna nada explicitamente.

É usado como valor padrão para argumentos de função, para indicar um resultado “não encontrado”, para inicializar variáveis antes que recebam um valor real.

variavel_sem_valor = None
print(variavel_sem_valor)

None

Observações: Ainda há outros tipos de dados, como tipos sequenciais e mapeamento, entretanto, iremos vê-los apenas mais tarde.

Extra: Verificando e Convertendo Tipos#

Às vezes será necessário saber o tipo de uma variável ou conventer uma variável para outro tipo. Neste tópico abordaremos esses pontos afim de um melhor entendimento sobre os tipos de dados.

Verificando o Tipo#

Como já vimos anteriormente, a função embutida type() é usada para verificar o tipo de um objeto/variável.

numero = 10
texto = "Python"

print(type(numero))            # Saída: <class 'int'>
print(type(texto))             # Saída: <class 'str'>

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

Vimos que dentro dos parênteses deve ficar a variável/objeto que desejamos verificar o tipo e que o class contido nos resultados é usado no sentido de categoria (um tipo é uma categoria de valores).

Agora vamos um pouco além, vamos aprender a utilizar a função embutidade isintance(objeto, tipo) para verificar se um objeto é de um tipo específico ou de uma classe que herda esse tipo (mais relevante quando formos aprender sobre orientação a objetos).

print(isinstance(numero, int))    # Saída: True
print(isinstance(texto, float))   # Saída: False

True
False

Dentro da função isistance(objeto, tipo) recebe dois argumentos (ou parâmetros):

  • Objeto: Variável/objeto a ser verificado;

  • Tipo: A classe, tipo ou uma tupla de classes/tipos a que você quer comparar a variável.

Quanto ao retorno, só existem dois resultados possíveis para essa função, são eles:

  • True: Se a variável for uma instância da classe/tipo fornecida;

  • False: Caso a variável não seja uma instância da classe/tipo fornecida.

Ao decorrer do curso veremos como essa função pode ser útil para sabermos de um objeto pertence a uma determinada classe, ou verificar se a variável pertence a vários tipos usando uma tupla.

Convertendo Tipos#

Python oferece funções embutidas para converter valores de um tipo para outro. Isso é chamado de “type casting” ou “type conversion”.

Para converter valores em Python é bem simples, basta você declarar o tipo que você deseja que a variável passe a ter como uma função (tipo_desejado()) e dentro do parênteses () indicar a variável/objeto que deve ter o valor convertido.

Convertendo em tipos numéricos#

Para converter valores para int ou float, basta usá-los como funções, fazendo-os ficarem assim: int() e float(). Dentro dos parênteses basta colocar a variável/obejto ou valor que se deseja converter.

dado_float = 1.85
dado_int = 20

converter_para_int = int(dado_float) # converte o float para inteiro
converter_para_float = float(dado_int) # converte inteiro para float

print(converter_para_int, type(converter_para_int)) # Saída: 1 <class 'int'>
print(converter_para_float, type(converter_para_float)) # Saída: 20.0 <class 'float'>

1 <class 'int'>
20.0 <class 'float'>

Observe que ao converter um int para float, ele apenas adiciona um ponto flutuante ao valor original, já quando converte-se float para int, a parte decimal do número é cortado, sobrando apenas o 1.

Atenção: Em Python, quando converte-se valores de ponto flutuante para inteiro, o valor não será arredondado, mas sim terá sua parte decimal cortada.

Curiosidades: Também é possível converter tipos booleanos e algumas strings em valores númericos. Veremos mais sobre isso adiante.

Convertendo String em números#

É possível converter strings para valores números desde que a string contenha apenas números, veja:

dado_string = "123"
outra_string = "3.14"

converter_para_int = int(dado_string) # converte o string para inteiro
converter_para_float = float(outra_string) # converte o string para float

print(converter_para_int, type(converter_para_int)) # Saída: 123 <class 'int'>
print(converter_para_float, type(converter_para_float)) # Saída: 3.14 <class 'float'>

123 <class 'int'>
3.14 <class 'float'>

Observe que as strings foram convertidas para valores numéricos, que pode ser atestado pelo uso da função type(). Entretanto, se tentarmos converter uma string que possua texto para valores numéricos, um erro ocorre:

dado_string = "abc123"

converter_para_int = int(dado_string)
converter_para_float = float(dado_string)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[15], line 3
      1 dado_string = "abc123"
----> 3 converter_para_int = int(dado_string)
      4 converter_para_float = float(dado_string)

ValueError: invalid literal for int() with base 10: 'abc123'

Atenção: Value error indica que a função de conversão recebeu um valor inválido para a operação específica, no caso converter letras para valores numéricos.

Convertendo booleanos em números#

Também podemos converter valores booleanos em valores númericos, isso ocorre por que em Python, por padrão, True equivale a 1 e False equivale a 0. Veja:

dado_true = True
dado_false = False

converter_true = int(dado_true) # converte True em número
converter_false = float(dado_false) # converte False em número

print(converter_true, type(converter_true)) # Saída: 1
print(converter_false, type(converter_false)) # Saída: 0.0

1 <class 'int'>
0.0 <class 'float'>

Convertendo em tipos textuais#

Para converter valores em string é bem simples, basta usar a função str() e dentro do parênteses indicar qual variável/objeto ou valor deve-se ser convertido.

Basicamente dá para converter qualquer tipo de dado em strings, veja:

dado_int = 22
dado_float = 10.45
dado_bool = True

converter_int_para_string = str(dado_int)
converter_float_para_string = str(dado_float)
converter_bool_para_string = str(dado_bool)

print(converter_int_para_string, type(converter_int_para_string)) # Saída: 22 <class 'str'>
print(converter_float_para_string, type(converter_float_para_string)) # Saída: 10.45 <class 'str'>
print(converter_bool_para_string, type(converter_bool_para_string)) # Saída: True <class 'str'>

22 <class 'str'>
10.45 <class 'str'>
True <class 'str'>

Observe que os valores convertidos não possuem uma mudança visual que os diferencie de como eram antes de serem convertidos, eles apenas deixaram de possuir as propriedades que tinham anteriormente a passaram a ter características de strings.

Convertendo em tipos booleanos#

Para converter valores em booleano é bem simples, basta usar a função bool() e dentro do parênteses indicar qual variável/objeto ou valor deve-se ser convertido.

Em resumo, se a variável possuir algum valor que seja vazio, nulo ou zero, ela será convertida para False, do contrário será True.

dado_string = "123"
nova_string = "" 

converter_str_em_bool =bool(dado_string)
novs_conversao = bool(nova_string)

print(converter_str_em_bool)
print(novs_conversao)

True
False

Quando foi falado anteriormente no contexto booleano, qualquer tipo de dado que possua algum valor dentro de si é considerado True e dados sem valores ou com valores nulos são False. Veja o exemplo acima, uma string como valores dentro (“123”) possui um valor verdadeiro (true), enquanto uma string vazia, sem nenhum valor dentro das aspas "", possuí o valor falso (false).

veja agora outros exemplos:

dado_string = 123
nova_string = 0

converter_str_em_bool =bool(dado_string)
novs_conversao = bool(nova_string)

print(converter_str_em_bool)
print(novs_conversao)

True
False

Como zero é considerado “sem valor”, ele acaba sendo convertido como False, enquanto outros números são convertidos como True, como é o caso de 123.

Parabéns: Você terminou o módulo 02 do curso de introdução à python. Agora você sabe sobre os tipos de dados básicos e está pronto para começar novos projetos, então mãos à obra.

Contents