Para abrir o Python em Windows, tenha previamente o interpretador Python instalado (Linux e Mac costumam ter ele instalado nativamente). Se tiver com a variável de ambiente instalada, basta apenas digitar python.
O primeiro comando usado é o print, para escrever algo na tela, dessa forma:
print("Olá, Mundo")
PS: No Python não se usa ponto e vírgula, diferente do que acontece em outras linguagens como Java, C++, PHP, C, Javascript e etc., o final de comando é dado com o enter do teclado. Também pode se usar variáveis acentuadas.
Para exibir números para executar operações aritméticas, você pode fazer da mesma forma (sem as aspas, por não serem strings):
print(7 + 4)
O + também é usado como concatenação no Python, mas tem casos que concatenação com vírgula (,) funcionará melhor (como no caso de concatenar números e strings), tipo essa:
print("Ano", 1998)
PS: No caso de números, você pode fazer as operações aritméticas diretamente, simplesmente digitando eles sem nada, como 8 + 5 e confirmar (lembrando que isso só funciona trabalhando diretamente no terminal, em arquivos py use o print). Com strings, apesar de funcionar, exibirá as aspas, nesse caso, é preferível usar o comando print normalmente (evite espaços no final e início das aspas). Podemos ver o "Zen do Python" com os princípios da filosofia da linguagem, digitando apenas import this.
Para usar variáveis em Python, é simples, como em qualquer linguagem de programação. Só lembre de concatenar variáveis com vírgulas. Veja um exemplo:
nome = "Jorge"
idade = 40
peso = 82.6
print(nome, idade, peso)
Para fazer o mesmo script acima, mas podendo escolher os dados digitados, usamos o comando input, dessa forma:
nome = input("Qual o seu nome?")
idade = input("Qual é sua idade?")
peso = input("Quanto você pesa?")
print(nome, idade, peso)
Para salvar um script Python, ele deverá ter a extensão py. Pra executar ele, abra o CMD, use e execute python nomedoarquivo.py (Só não esqueça de escolher a opção UTF-8 do editor para ler acentos, até mesmo se for no bloco de notas).
Agora vamos criar um script que leia o nome de uma pessoa e mostre uma mensagem, de acordo com o valor digitado. Dessa forma:
nome = input("Qual o seu nome?")
print("Olá,", nome, "! Prazer em te conhecer!")
Vamos criar também um que leia o dia, o mês e ano digitado, e mostre uma mensagem com a data formatada, dessa forma:
dia = input("Digite o dia desejado: ")
mes = input("Digite o mês desejado: ")
ano = input("Digite o ano desejado: ")
print("A data digitada foi", dia , "de", mes, "de", ano)
PS: Se quiser limpar o terminal Python, use Ctrl L.
Criaremos um script que somará dois números também, dessa forma:
num1 = int(input("Digite o primeiro número: "))
num2 = int(input("Digite o segundo número: "))
res = num1 + num2
print("A soma é", res)
Para escrever comentários em Python, basta colocar um # na frente do código para cada linha, e três aspas para tudo que vir depois delas virar comentário.
# Exemplo de comentário em Python.
print("Isso será executado normalmente")
"""Tudo que vier daqui pra cá será comentário.
Isso também virou comentário.
Isso também."""
PS: Em Linux é comum em scripts de várias linguagem ter o shell indicado no começo, por uma hashtag, e scripts Python também costumam ter o interpretador indicado, e o padrão é a versão 2 (no caso, #!/usr/bin/env python), para rodar scripts em Python 3, coloque #!/usr/bin/env python3. Isso será considerado comentário também caso rode o mesmo script num interpretador Python de outro sistema, como o Windows.
Como sabemos, se não colocarmos os tipos primitivos nas variáveis, costumam acontecer alguns erros, como no exemplo abaixo:
num1 = input("Digite o primeiro número: ")
num2 = input("Digite o segundo número: ")
res = num1 + num2
print(res)
No código acima, as variáveis estão sendo identificadas como strings, se somássemsos um número qualquer ele os concatenaria (tipo 3 + 2 daria 32). Para resolver isso, basta declarar os tipos primitivos no input, assim:
num1 = int(input("Digite o primeiro número: "))
num2 = int(input("Digite o segundo número: "))
res = num1 + num2
print(res)
No Python, os dados primitivos são identificados dessa forma:
| Dado Primitido | Exemplos |
|---|---|
| int | 90 |
| float | 10.9 |
| bool | True |
| str | "Exemplo" |
Veja um exemplo de uso de tipos primitivos (strings podem estar em aspas duplas ou simples):
num = 50
real = 9.85
frase = "Isso é uma String"
logico = True
Se quiser ver o tipo de variável no Python, basta usar o type, assim:
num = "90"
real = int(num)
print(type(num))
print(type(real))
Podemos também fazer uma atribuição dupla, assim:
n1 = n2 = 0 # Ambas as variáveis receberão 0
print(n1)
print(n2)
E podemos fazer assim também:
n1, n2 = 0, 1 # A primeira variável receberá o primeiro número e a segunda variável, o segundo número
print(n1)
print(n2)
Normalmente, faríamos isso numa concatenação:
n1 = int(input("Digite um valor: "))
n2 = int(input("Digite outro: "))
s = n1 + n2
print("A soma entre", n1, "e", n2, "vale", s)
Mas para evitar muitas aspas e vírgulas, podemos usar o parâmetro .format e colocar chaves dentro da string (máscaras no Python, que podem estar vazias ou com identificadores dentro). Veja um exemplo:
n1 = int(input("Digite um valor: "))
n2 = int(input("Digite outro: "))
s = n1 + n2
print("A soma entre {} e {} vale {}".format(n1, n2, s))
Ao usar float com números, ele aparecerá sempre com ponto, mesmo não havendo frações, e se usar boolean, qualquer valor será identificado como true (o false aparece ao dar enter sem citar valores).
Em versões mais antigas do Python podemos ver essa forma de formatação, bastante semelhante com o C (inclusive com as mesmas máscaras básicas):
numero = 50
real = 9.85
frase = "Exemplo de string"
print("Inteiro.: %d" % numero) # Atenção que é porcentagem, não vírgula, nesse caso.
print("Real....: %.2f" % real)
print("String..: %s" % frase)
PS: No caso de usar mais de um valor num mesmo print, faça assim:
print("Inteiro.: %d\nReal....: %.2f\nString..: %s" % (numero, real, frase))
Podemos também mostrar com valores booleanos, se um valor recebido por variável é de um determinado tipo, veja um exemplo no qual usamos o .isnumeric() para mostrar se é número:
n = input("Digite algo: ")
print(n.isnumeric())
Esse método acima é muito utilizado pra saber se é possível converter o valor de uma string para um numérico.
Da mesma forma, também podemos identificar se um valor é alfabético (não confundir com string), com o .isalpha(). No caso de identificar a variável que tem letras e números, usamos .isalnum() (mas ele não considerará, por exemplo, espaços). Temos outros parâmetros, como o .isupper() (para identificar se todas as letras são em maiúsculas, e várias outras.
Veja também um programa que lê algo pelo teclado e mostra na tela o seu tipo primitivo e todas as informações possíveis sobre ele:
algo = input("Digite Algo! ")
print("O conteúdo digitado ({}) é um número? {}".format(algo, algo.isnumeric()))
print("O conteúdo digitado ({}) é alfabético? {}".format(algo, algo.isalpha()))
print("O conteúdo digitado ({}) é alfanumérico? {}".format(algo, algo.isalnum()))
Veja alguns desses métodos:
| Método | Verifica se é |
|---|---|
| .isnumeric() | Numérico |
| .isalpha() | Alfabético |
| .isalnum() | Alfanumérico |
| .isspace() | Com Espaços |
| .isupper() | Só com Maiúsculas |
| .islower() | Só com Minúsculas |
| .istitle() | Só a 1ª Maiúscula |
Além dos operadores aritméticos tradicionais, temos também no Python os operadores // (divisão inteira), e ** (potência). Por exemplo:
num = 5 ** 2
print(num) # Retornará 25.
A divisão inteira geralmente é usada com o resto, dessa forma:
num = 5 // 2
res = 5 % 2
print(num)
print(res)
Então a ordem completa dos operadores seria essa:
| Ordem | Operador |
|---|---|
| 1 | () |
| 2 | ** |
| 3 | * / // % |
| 4 | + - |
Se colocar algo sem parênteses, ele seguirá a ordem de precedência.
print(5 + 3 * 2) # Multiplicação é feita primeiro, retorna 11.
print(3 * 5 + 4 ** 2) # Potência é feita primeiro, retorna 31.
print(3 * (5 + 4) ** 2) # Soma nos parênteses é feita primeiro, retorna 243.
PS: Podemos também colocar atribuição com algum valor, como por exemplo num += 2 ou num -= 3, que faça a atribuição e a operação juntos no mesmo comando. Concatenação com atribuição também pode ser colocada com o +=.
Lembrando que o Python não tem limite de tamanho pra números, diferente de outras linguagens (tente por exemplo, fazer 365 ** 522 nessa ou em qualquer outra linguagem para ver as diferenças).
Lembrando também que o símbolo = é de atribuição, para igual usa-se dois iguais (==) e pra diferente é != (mas se forem valores booleanos ou nulos, como True, False e None, use is e is not, assim como pra E e OU utilize literalmente and e or e não && e ||). Os operadores relacionais permanecem os mesmos de outras linguagens, como podem ver:
| Operador Aritmético | Significado |
|---|---|
| == | Igualdade. |
| != | Diferente. |
| > | Maior. |
| < | Menor. |
| >= | Maior ou Igual. |
| <= | Menor ou Igual. |
Como em outras linguagens, temos também as funções de operadores, como o pow(), mas nesse caso, se perde a ordem de precedência.
PS: Podemos usar a potência também para tirar raizes, por exemplo:
print(25 ** (1 / 2)) # Retorna raiz quadrada.
print(127 ** (1 / 3)) # Retorna raiz cúbica.
Alguns operadores podem ser usados em strings também, dessa forma:
print("Teste" * 5)
print("=" * 20)
Podemos também colocar valores nas máscaras de formatação, dessa forma:
nome = input("Qual é o seu Nome?\n")
print("Prazer em te Conhecer {:20}!".format(nome))
Esse código acima é para colocar uma string em espaços pré-definidos, os que sobrarem ficarão como espaços.
Podemos inclusive, escolher o local do espaço, se colocarmos > antes do número, os espaços ficarão do lado esquerdo (da mesma forma que o < deixaria do lado direito, mas esse é padrão), veja um exemplo:
print("Prazer em te Conhecer {:>20}!".format(nome))
E também podemos centralizar, com o ^, dessa forma:
print("Prazer em te Conhecer {:^20}!".format(nome))
Se colocarmos um símbolo qualquer antes dos números ou operadores, ele substituirá os espaços restantes, por exemplo:
print("Prazer em te Conhecer {:=^20}!".format(nome))
O format também pode ser usado com operadores, assim:
n1 = int(input("Um valor:\n"))
n2 = int(input("Outro valor:\n"))
print("A soma é {}".format(n1 + n2))
Veja outro exemplo de formatação:
n1 = int(input("Um valor:\n"))
n2 = int(input("Outro valor:\n"))
s = n1 + n2
m = n1 * n2
d = n1 / n2
di = n1 // n2
e = n1 ** n2
print("A soma é {}, o produto é {} e a divisão é {:.3f}. ".format(s, m, d), end = "")
print("Divisão inteira {} e potência {}.".format(di, e))
Veja que no código acima, o .3f dentro da máscara é para formatar as casas de um número real, e o end no final com string vazia, é para não quebrar a linha ao entrar um novo print. Se quiser quebrar dentro de um mesmo print, use a sequência de escape \n.