Olá mais uma vez.
Vamos lá então voltar às variáveis. Lembra-se daquela diferença entre 6/2 = 3.0 ou 3? Sim, estes resultados têm um
tipo diferente: 3.0 é um
número de vírgula flutuante (isto é, permite casas decimais), enquanto 3 é um
número inteiro. Se experimentarmos:
>>> type(3)
<class 'int'>
>>> b=2
>>> type(3.0)
<class 'float'> |
Resultado interessante, não é? A função
type() devolve-nos o
tipo do valor ou variável que lhe fornecemos:
int para inteiro e
float para vírgula flutuante. Outra diferença entre a versão
2.x e a
3.x: na versão
2.x, surge:
<type 'tipo
'>. Mais geralmente, a função
type() devolve-nos o
tipo (ou
classe) de qualquer objeto, e veremos depois o que significa isto.
A principal diferença entre estes tipos de variável prende-se com o modo de armazenamento interno destes valores no computador. Além disso, de um modo geral as operações entre variáveis ou valores do mesmo tipo resulta no mesmo tipo, com a notável exceção da divisão de números inteiros que, como já vimos, em
Python 3.0 resulta num número
float. De momento, não dá para perceber qual a utilidade entre ter números
inteiros ou de
vírgula flutuante, mas veremos isso mais tarde, quando falarmos em
enumeração.
Já agora, uma curiosidade: o
Python permite utilizar também números complexos (ou imaginários). Para representar a parte imaginária, usa-se a letra
j (e não a
i, a que estamos habituados). Experimente:
>>> (3 + 5j) + (2 - 7j)
(5-2j)
>>> 3 + 5j + 2 - 7j
(5-2j)
>>> type(5-2j)
<class 'complex'> |
Alguns pormenores a ter em atenção: na primeira linha usei parêntesis só por claridade, pois como se percebe na segunda entrada não são necessários. E podemos ver que estes valores são do
tipo complex.
Para resumir: operações entre
inteiros podem resultar em
inteiros ou de
vírgula flutuante; entre
inteiros e de
vírgula flutuante resulta sempre em
vírgula flutuante; entre valores em
vírgula flutuante e
complexos resulta sempre
complexos.
Até agora, só vimos números. Mas existem outros
tipos de valores: as cadeias de caracteres, que constituem texto. Estas são definidas colocando caracteres entre plicas (
'') ou entre aspas (
""). Por exemplo:
>>> "Olá mundo!"
'Olá mundo!'
>>> letras = 'Olá mundo!'
>>> letras
'Olá mundo!'
>>> type(letras)
<class 'str'> |
Ora então o que temos aqui? Vemos que, como sempre, quando colocamos um valor em '>>>', obtermos como resultado esse valor. Embora tenhamos definido a cadeia com aspas, o resultado apareceu com plicas. Isto só muda se inserirmos alguma plica dentro do texto entre aspas. O objetivo de termos duas maneiras de criar as cadeias é para podermos inserir plicas ou aspas dentro do texto de modo mais fácil.
Também podemos criar variáveis com texto, e ver o seu conteúdo. e o
tipo destes valores ou variáveis é
str, diminutivo de
string. Aqui estão mais umas coisas que se podem fazer com as cadeias:
>>> "Olá " + "mundo!"
'Olá mundo!'
>>> "Olá! "*5
'Olá! Olá! Olá! Olá! Olá! '
>>> letras = 'abcdef'
>>> letras[2]
'c'
>>> letras[2:5]
'cde'
>>> 'cde'[1]
'd' |
Como seria de esperar, podemos concatenar cadeias. O que possivelmente já não estaria à espera é de poder multiplicá-las! Claro que só se pode multiplicar uma cadeia por um inteiro, e o resultado está à vista.
E finalmente, aquela coisa dos parêntesis retos (
[]) é chamada de
slicing (em português poderia traduzir-se por
seccionamento, mas não me soa tão bem...), e pode usar-se com definição de um ou dois números: se usarmos um, vai buscar o caracter que se encontra na posição definida pelo número; mas atenção que a contagem começa com zero!! No exemplo acima, o caracter
'c' é o terceiro de
letras, mas fica na posição 2 se contarmos a partir de zero. Quando se usam dois números separados por
':', o primeiro número aponta para a posição do primeiro caracter a incluir, e o segundo número indica qual o caracter onde se para,
não incluindo esse. No exemplo acima, 2 é o terceiro caracter e 5 é o sexto (
'f'), que já não foi incluído no resultado. A última linha mostra que podemos seccionar diretamente uma cadeia, não precisa de ser uma variável. Mais uma vez, isto não é tudo, e voltaremos a este assunto mais tarde...
E vamos terminar com o último
tipo elementar de que falta falar: o booleano. Este só pode assumir dois valores: verdadeiro (
True) ou falso (
False). Sim, têm de ser com a primeira letra maiúscula.
>>> True
True
>>> True == False
False
>>> True != False
True
>>> type(True)
<class 'bool'> |
True é um valor com resultado
True. Na segunda inserção, estamos a perguntar se
True é igual a
False, e como não são iguais, o resultado é
False. Acabámos de apresentar outro operador: a
igualdade (
==), que resulta em verdadeiro ou falso. São dois sinais de igual, para não se confundir com a
atribuição de variáveis, só com um sinal de igual. Podemos comparar várias coisas, como (mais uma vez) veremos mais tarde. Depois, temos o operador de
desigualdade (
!=), que verifica se dois objetos são diferentes. Finalmente, mostramos que o
tipo destes valores é booleano (
'bool').
E por agora chega.
