Existem três tipos diferentes de números: inteiros, números de ponto flutuante e números complexos. Números são obtidos a partir de declarações ou operações aritméticas.
Números inteiros possuem precisão "ilimitada", ou seja, podem, em teoria, ter infinitas casas decimais. Números de ponto flutuante são implementados usando o tipo double em C e sua precisão pode variar de acordo com a máquina que roda o programa. Números complexos possuem uma parte real e imaginária e ambas são números de ponto flutuante
O interpretador do Python e - por consequência cada célula de código do Jupyter Notebook - funciona como uma calculadora, assim podemos mostrar o funcionamento desses números na prática:
In [1]:
20 + 13
Out[1]:
In [2]:
5 * 8 - 10
Out[2]:
In [3]:
(5 * 8 - 10) / 3
Out[3]:
In [4]:
8 / 5 # o resultado da divsião sempre é um float
Out[4]:
Os números inteiros (como 20, 13, 33 e 30) possuem tipo int, enquanto os que possuem a parte fracional (como 10.0 e 1.6) são float.
Para verificar o tipo deve ser usada a função type() que é utilizada assim:
In [5]:
type(100)
Out[5]:
In [6]:
type(5.0)
Out[6]:
O python também suporta os seguinte operadores:
// divisão inteira% resto da divisão inteira** potenciaçãoSeu uso é demonstrado a seguir.
In [7]:
16 / 3
Out[7]:
In [8]:
16 // 3
Out[8]:
In [9]:
16 % 3
Out[9]:
In [10]:
5 * 3 + 1 # resultado * divisor + resto
Out[10]:
In [11]:
2 ** 3
Out[11]:
In [12]:
2 ** 10
Out[12]:
In [13]:
(10 ** 800 + 9 ** 1000) * 233 # Olha, mãe! Números gigantes sem as bibliotecas!1!!1!111!
Out[13]:
Os números também podem ser representados em razão a sua potência na base 10 dessa forma:
In [1]:
1e2 # equivale a 10 ^ 2
Out[1]:
In [3]:
1e-2 # equivale a 10 ^ -2
Out[3]:
Geralmente essa notação é ativada automaticamente para números muito pequenos:
In [16]:
1 / 10000000 # 0.0000001
Out[16]:
In [9]:
127 / 310000000
Out[9]:
Tome cuidado ao realizar divisões, pois divisão por 0 levanta uma exceção:
In [14]:
10 / 0
O Python não possui os operadores ++ e --, para incrementar ou decrementar números faça:
In [15]:
i = 0
i
Out[15]:
In [16]:
i += 1
i
Out[16]:
In [17]:
i += 1
i
Out[17]:
In [18]:
i -= 1
i
Out[18]:
Isso também funciona para outros operadores:
In [19]:
numero = 100
numero
Out[19]:
In [20]:
numero /= 5
numero
Out[20]:
In [21]:
numero *= 20
numero
Out[21]:
In [22]:
numero -= 25
numero
Out[22]:
In [23]:
numero //= 7
numero
Out[23]:
In [24]:
numero **= 2
numero
Out[24]:
Os números complexo são criados da seguinte forma:
In [25]:
1 + 3j
Out[25]:
In [26]:
type(1 + 3j)
Out[26]:
E também permitem operações aritméticas:
In [27]:
(1 + 3j) + (5 - 1j) - (3 - 2j)
Out[27]:
Para realizar operações mais avançadas existe dentro do Python a biblioteca math que possuim funções para calcular:
Para utilizar essas funções precisamos importar essa biblioteca:
In [28]:
import math
In [29]:
math.pi, math.e
Out[29]:
In [30]:
math.floor(math.pi) # chão
Out[30]:
In [31]:
math.ceil(math.pi) # teto
Out[31]:
In [32]:
math.log(math.e ** 10)
Out[32]:
In [33]:
math.log10(10 ** 15)
Out[33]:
In [34]:
math.exp(5)
Out[34]:
In [35]:
math.pow(1.99999, 10) # math.pow é recomendado para se trabalhar com números de ponto flutuante
Out[35]:
In [36]:
math.sqrt(3.999999999999999)
Out[36]:
In [ ]:
def area_circulo(raio):
area = ...
return area
In [ ]:
# Não mude as próximas linhas!
# Elas servem para testar se seu código funciona :-)
assert area_circulo(7.93115399705473) == 197.61624270971336
assert area_circulo(38.68203836108609) == 4700.765375865766
assert area_circulo(64.88921270604881) == 13228.021209431301
assert area_circulo(94.11113713755829) == 27824.79124198601
assert area_circulo(99.77934573034769) == 31277.438328220036
In [ ]:
def calcula_encargos(salario):
imposto_renda = ...
valor_INSS = ...
valor_sindicato = ...
salario_liquido = ...
# não precisa mexer daqui para baixo!
# A impressão dos dados calculados já está pronta! :-)
FORMATO = (
"+ Salário Bruto: R$ {salario:.2f}\n"
"- IR(11%) : R$ {imposto_renda:.2f}\n"
"- INSS(8%) : R$ {valor_INSS:.2f}\n"
"- Sindicato(5%): R$ {valor_sindicato:.2f}\n"
"= Salário Líquido: R$ {salario_liquido:.2f}\n"
)
print(FORMATO.format(salario=salario, imposto_renda=imposto_renda,
valor_INSS=valor_INSS, valor_sindicato=valor_sindicato,
salario_liquido=salario_liquido))
# imprime os encargos dos salário de 1000, 1500, 2000, ..., 5000
salarios = range(1000, 5001, 500)
for salario in salarios:
calcula_encargos(salario)
No Python 3 todas as strings são representadas por caracteres Unicode e o encoding padrão é UTF-8. Tá, mas o que isso quer dizer? Na prática a adoção desses padrões resolvem a maior parte dos problemas de codificação de caracteres. Acentos, caracteres das línguas chinesas, coreanas são representados sem dor de cabeça. Para entender melhor como isso funciona olhe esta página.
Strings em python podem ser representadas de diferentes maneiras:
In [39]:
'Sou uma string!11!11!!!' # aspas simples
Out[39]:
In [40]:
"Ela é uma string!?" # aspas duplas
Out[40]:
In [41]:
'这是一个字符串' # UTF-8 é maravilhindo
Out[41]:
In [42]:
'😸😹😺' # tem até gatinhos sorrindo, como não gostar?
Out[42]:
Para exibir aspas simples dentro de uma string definida por aspas simples use \:
In [43]:
'É preciso ter cuidado com \'aspas\''
Out[43]:
Ou você pode simplesmente definí-las com aspas duplas:
In [44]:
"É preciso ter cuidado com 'aspas'"
Out[44]:
O inverso também é valido:
In [45]:
"Ele disse: \"É preciso ter cuidado com aspas\""
Out[45]:
In [46]:
'Ele dise: "É preciso ter cuidado com aspas"'
Out[46]:
In [47]:
s = 'Primeira linha.\nSegunda linha.' # \n representa uma quebra de linha
In [48]:
s # sem usar a função print() o \n aparece na saída
Out[48]:
In [49]:
print(s) # com print() o \n produz uma quebra de linha
Se você não quiser que caracteres começados com \ sejam tratados como caracteres especiais você pode usar strings brutas (raw strings). Isso é feito adiciona um r antes da primeira aspa:
In [50]:
print('C:\algum\nome')
In [51]:
print(r'C:\algum\nome')
Raw strings facilitam o uso de expressões regulares.
Para especificar strings com mais de linha é recomendado usar aspas trilas: """...""" ou '''...'''. Quebras de linha são adicionadas automaticamente, porém podem ser ignoradas com \, conforme o seguinte exemplo:
In [52]:
print("""\
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex
...\
""")
Strings podem ser concatenadas de duas maneiras.
Com o operador + :
In [53]:
'Py' + 'thon'
Out[53]:
Com duas strings (somente as envoltas por aspas) do lado da outra:
In [54]:
'Py' 'thon'
Out[54]:
Esta concatenação não funciona com variáveis ou expressões:
In [55]:
prefixo = 'Py'
prefixo 'thon'
In [56]:
('Py' + 'thon') '!!!'
Isso também pode ser usado para quebrar strings longas:
In [57]:
texto = ('É possível colocar várias strings em parenteses '
'para elas se juntarem')
texto
Out[57]:
Strings podem ser repetidas com o uso do operador *:
In [58]:
'Créu ' * 10
Out[58]:
In [59]:
textão = (texto + '\n') * 5 # no Python 3 é possível criar variáveis com acentos!
print(textão)
Strings podem ser acessadas pelo seu índice, com o primeiro caracter possuindo índice 0. No Python não existe um tipo específico para caracter, um caracter é simplesmente uma string de tamanho 1:
In [60]:
palavra = 'Python'
palavra
Out[60]:
In [61]:
palavra[0]
Out[61]:
In [62]:
palavra[5]
Out[62]:
Os índices podem ser negativos e acessam a sequência da direita para a esquerda:
In [63]:
palavra[-1] # acessando o último índice
Out[63]:
In [64]:
palavra[-2] # penúltimo
Out[64]:
In [65]:
palavra[-6]
Out[65]:
Além de índices o Python também suporta fatiamento (slicing). O fatiamento oferece uma maneira simples de acessar substrings:
In [66]:
palavra[:2] # pega os caracteres da posição 0 (incluído) até 2 (excluído)
Out[66]:
In [67]:
palavra[4:] # pega os caracteres da posição 4 (incluído) até o final
Out[67]:
In [68]:
palavra[-2:] # pega os caracteres da "segunda última" até o final
Out[68]:
Para lembrar como funciona slicing funciona é pensar que os índices apontam para o índices entre os caracteres, como por exemplo:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
Tentar acessar um índice maior que o tamanho da string resulta em um erro:
In [69]:
palavra[1500]
Mas um fatiamento não:
In [70]:
palavra[4:1500]
Out[70]:
In [71]:
palavra[1500:]
Out[71]:
Strings são imutáveis, para obter uma nova string é necessário criar uma nova:
In [72]:
palavra[0] = 'J'
In [73]:
'J' + palavra[1:]
Out[73]:
In [74]:
palavra[:2] + 'py'
Out[74]:
Lembrando que para saber o tamanho da string use a função len():
In [75]:
len(palavra)
Out[75]:
In [76]:
s = 'Pneumoultramicroscopicossilicovulcanoconioticos'
len(s)
Out[76]:
Como string são sequências é possível iterar seus caracteres assim como fazemos com a lista:
In [77]:
for caracter in palavra:
print(caracter)
Também é possível iterar usando while para iterar por índices, apesar de o while não ser a melhor forma de fazer isso:
In [78]:
s = 'Saudades'
i = 0
while i < len(s):
print(s[i])
i += 1
# não faça isso
Se você realmente precisar acessar os índices - o que acontece em algumas raras vezes - é possível iterar por índices usando for e a função range() como demonstrado a seguir
Na grande maioria dos casos não é necessário acessar os índices diretamente
In [79]:
s = 'Necessito!'
for i in range(len(s)):
print(s[i])
# use somente quando necessário
In [80]:
string = 'Fafofa' # Farofa
string[:2] + 'r' + string[3:]
Out[80]:
In [81]:
string = 'Phython' # Python
... # digite o código aqui
In [82]:
string = 'Gambiara' # Gambiarra
... # digite o código aqui
In [83]:
string = 'Mundo Olá,' # Olá, Mundo
... # digite o código aqui
In [84]:
nome = 'josé'
nome.capitalize()
Out[84]:
Verificar se uma substring faz parte da string:
In [85]:
nome = 'José Pereira da Silva'
'Pereira' in nome
Out[85]:
In [86]:
'Silveira' in nome
Out[86]:
string.lower() - transformar todos os caracteres para caixa baixa
In [87]:
grito = 'AAAAAAAAAAAAAAAAAAAAAAAAAH!'
grito.lower()
Out[87]:
string.upper() - transformar todos os caracteres para caixa alta
In [88]:
sigla = 'abc'
sigla.upper()
Out[88]:
string.split(separador) - retorna uma lista das palavras divididas pelo separador:
In [89]:
frase = 'Pegando cada palavra desta frase e colocando-as em uma lista'
lista = frase.split(' ')
lista
Out[89]:
In [90]:
numeros = '1-2-3-4-5-6-7-8'
lista2 = numeros.split('-')
lista2
Out[90]:
separador.join(lista) - concatenas os elementos da lista separador pelo separador:
In [91]:
lista = ['Fazendo', 'o', 'caminho', 'inverso', 'do', 'split']
' '.join(lista)
Out[91]:
In [92]:
lista = ['1', '2', '3', '4', '5', '6', '7', '8']
' * '.join(lista)
Out[92]:
string.count(substring) - conta quantas ocorrências de substring existem na string
In [93]:
'créu créu créu créu créu créu créu créu créu'.count('créu')
Out[93]:
In [94]:
frase = 'Essa frase não significa nada, não perca seu tempo lendo. Só vou contar quantos não eu escrevi aqui'
frase.count('não')
Out[94]:
In [95]:
creu = 'Créu créu créu Créu créu créu créu Créu créu'
creu.count('créu') # count é sensível a caixa (case-sensitive)
Out[95]:
In [96]:
creu = 'Créu créu créu Créu créu créu créu Créu créu'
creu.lower().count('créu') # normaliza a string para caixa baixa antes da contagem
Out[96]:
string.replace(antigo, novo[, maxreplace]) - realiza a troca de ocorrência da substring antiga pela nova, maxreplace vezes.
In [97]:
creu = 'créu créu créu créu créu créu créu créu créu'
tchan = creu.replace('créu', 'Segura o tchan', 1)
tchan
Out[97]:
In [98]:
tchan.replace('créu', 'amarra o tchan, segura o', 1)
Out[98]:
In [99]:
tchan.replace('créu', 'tchan')
Out[99]:
Depois desses exemplos eu declaro essa aula terminada, mas não antes de exercícios:
In [ ]:
def conta_vogais(string):
vogais = 'aeiou'
total = 0
... # normaliza a string
for vogal in vogais:
... # conta ocorrências
return total
In [ ]:
# o código abaixo serve para testar a corretude do programa
assert conta_vogais('Camila Melo') == 5
assert conta_vogais('Loteamento Dias, 73 - Cardoso - 14713-611 Fernandes de Ribeiro / RO') == 19
assert conta_vogais('Pedro Miguel Araújo') == 8
assert conta_vogais('Residencial Lorena Costela, 797 - Sion - 03517039 Silva Grande / SP') == 17
assert conta_vogais('Clara Correia') == 6
assert conta_vogais('Conjunto Rodrigues, 41 - Vila Pinho - 81177-479 Silva / SC') == 13
assert conta_vogais('Emanuel Costela') == 7
assert conta_vogais('Colônia Carolina Cardoso, 30 - Vila Canto Do Sabiá - 48402517 Castro / MT') == 19
Se for do padrão antigo (8 caracteres) adicionar um 9 no começo.
Se o celular enviado já possuir 9 deverá verificar se o primeiro caracter é 9. Se não for troque-o para 9.
Se conter menos que 8 ou mais que 9 levante uma exceção.
In [ ]:
def corrige_celular(celular):
if len(celular) == 8:
... # corrige e retorna o celular
elif len(celular) == 9:
... # verifica se o celular está correto e retorna número corrigido se necessario
else:
raise ValueError('Celular "{0}" é inválido'.format(celular))
In [ ]:
assert corrige_celular("733080280") == "933080280"
assert corrige_celular("820229289") == "920229289"
assert corrige_celular("634950619") == "934950619"
assert corrige_celular("620143587") == "920143587"
assert corrige_celular("27439428") == "927439428"
assert corrige_celular("11856634") == "911856634"
Já foi mostrado em alguns exemplos anteriores o uso do if...elif...else, mas deixarei aqui alguns exemplos e explicações para não haver duvidas:
A função input em um script para o mesmo e espera a entrada de um usuário. Já no Jupyter Notebook essa função cria um campo de entrada
In [8]:
nota = float(input())
In [7]:
if nota < 0 or nota > 10:
raise ValueError('Nota {} inválida'.format(nota)) # levanta uma exceção do tipo ValueError
elif nota < 5:
print('{}... reprovado'.format(nota))
elif 5 <= nota <= 10: # o python permite comparação encadeada
print('Passou com {}!'.format(nota))
elif nota == 10:
print('Parabens pelo 10.')
Vamos colocar esse trecho de código em uma função para poder testá-la:
In [104]:
def resultado(nota):
if nota < 0 or nota > 10:
raise ValueError('Nota {} inválida'.format(nota)) # levanta uma exceção do tipo ValueError
elif nota < 5:
print('{}... reprovado'.format(nota))
elif 10 > nota >= 5: # o python permite comparação encadeada
print('Passou com {}!'.format(nota))
elif nota == 10:
print('Parabens pelo 10.')
In [105]:
for nota in (3.25, 6, 10, 150):
resultado(nota)
In [122]:
from time import sleep
n = 10
while n > 0:
print('{}...'.format(n))
sleep(1)
n -= 1
print('0!!!')
Nem sempre a condição precisa ser satisfeita (loop infinito):
Se você rodar um loop infinito no Jupyter Notebook vai travar o servidor e não poderá executar outras células de código
In [ ]:
while True:
...
Calcular uma subsequência de Fibonacci até certo valor:
In [175]:
a, b = 0, 1 # atribuição múltipla
while b < 100:
print(b)
a, b = b, a + b
O print() acabou imprimindo a sequência em linhas separadas, pois ao final de cada print é anexado um caracter de quebra de linha \n. Para modificar esse comportamento podemos fazer:
In [176]:
a, b = 0, 1
while b < 100:
print(b, end=' ')
a, b = b, a + b
Podemos usar while para fazer um simples jogo de advinhar o número sorteado.
In [9]:
import random
sorteado = random.randint(1, 101) # sorteia um inteiro entre 1 e 100
tentativa = 0
while tentativa != sorteado:
tentativa = int(input('Qual foi o número sorteado: '))
if tentativa > sorteado:
print('tentativa > sorteado\n')
elif tentativa < sorteado:
print('tentativa < sorteado\n')
print('Você acertou!')
Extra
Usando o algoritmo de busca binária é possível sempre encontrar o resultado com até ceil(log2(100)) == 7 tentativas. Para saber mais sobre esse algoritmo consulte nossa amiga wikipédia (em inglês, pois a versão em portugês não explica o algoritmo direito).