Guia Rápido Python 3.

# Comentário de uma linha

"""
Inserir Comentários Comentário de
várias linhas
"""

a…zA…Z_ seguido de a…zA…Z_0…9

Identificadores  Caracteres acentuados permitidos mas devem ser evitados
 Palavras reservadas da linguagem são proibidas
(nomes para variáveis, funções
 Caixa baixa/ALTA são discriminados
etc.)  x nome x7 y_max NomeGrande
 8y and for “Nome Grande”

1) Avaliação da expressão do lado direito do ‘=’

2) Atribuição na ordem com os identificadores do lado esquerdo
do ‘=’

int
i = 0
idade = 40
temperatura = -142
# mesmo valor p/ diversas variáveis
soma1 = soma2 = 0

float
x = 2.5
soma = 0.0 2,5 106
f1 = -2.5e-6
# múltiplas atribuições
Criando / atribuindo variáveis x, y, z = 2.5, -0.7, 1.8e+6

str
nome = 'Maria'
nome_2 = "João"
sLargura = '2"'
s1 = 'Linha 1\nLinha 2'
Quebra de linha

# string de múltiplas linhas

s = """linha 1
Linha 2
Linha 3"""

bool
inicio = True
fim = False
maior = idade > 18
Escrevendo na tela

Comando Resultado na Tela

print('Carlos da Silva') Carlos da Silva

print('casou-se com Maria.') casou-se com Maria.

print('Carlos da Silva', 'casou-se.') Carlos da Silva casou-se.

print('Carlos da Silva', 'casou-se.', sep=':') Carlos da Silva:casou-se.

Carlos da Silva
print('Carlos da Silva\ncasou-se')
casou-se

print('Carlos', end=' ')

Carlos casou-se com Maria
print('casou-se com Maria')

print('2 / 3 =', 2/3 ) 2 / 3 = 0.6666666666666666

x, y, z = 2, 9, 7
2 9 7
print( x, y, z )

nome = 'Sebastião'
print('Meu nome é', nome ) Meu nome é Sebastião

Formatadores de Saída mais Comuns

Usar: Para imprimir:

Texto (string). Para alinhar o texto à direita ocupando n espaços, use %ns. Para alinhar o texto à
%s
esquerda ocupando n espaços, use %-ns. Ex.: '%40s' e '%-40s'

Número inteiro (decimal). O alinhamento pode ser feito da mesma forma como no formato %s.
%d Para completar a largura n com zeros em vez de espaços em branco, coloque um ‘0’ (zero) antes
do n. Ex.: '%04d'

Número real ou de ponto flutuante (float). O alinhamento é feito com largura total l e precisão d
%l.df (número de dígitos depois do ponto decimal). Ex.: '%8.2f'. Você pode especificar também
apenas a precisão, deixando a largura variávei. Ex.: '%.2f'

%e Número real, usando a notação exponencial. Veja exemplos adiante.

%g O mesmo que %e se o expoente for maior -4 ou menor que a precisão, e %f caso contrário.

%% Escreve o símbolo % na tela.

Exemplos de Saída Formatada

print('Meu nome é %s.' % nome ) Meu nome é Sebastião.

print('Eu sou o número %d.' % 4) Eu sou o número 4.

print('Isso %s %02d vezes' % ('ocorreu', 5)) Isso ocorreu 05 vezes

print('Isso %s%3d vezes' % ('não ocorreu', 7)) Isso ocorreu 7 vezes

x = 1.456
y = 4.56e-4
z = x + y 1.456000 + 0.000456 = 1.456456
1.456000e+00 + 4.560000e-04 = 1.456456e+00
print('%f + %f = %f' % (x, y, z)) 1.456 + 0.000456 = 1.45646
print('%e + %e = %e' % (x, y, z)) 1.456 + 4.56e-04 = 1.46
print('%g + %g = %g' % (x, y, z))
print('%.3f + %.2e = %7.2f' % (x, y, z))

x = 12.3456
print('%.1f' % x ) 12.3
print('%.2f' % x ) 12.35
print('%.3f' % x ) 12.346
print('%.4f' % x ) 12.3456
print('%.5f' % x ) 12.34560
print('%7.4f' % x ) 12.3456
print('%8.4f' % x ) 12.3456
print('%9.4f' % x ) 12.3456
print('%10.4f' % x ) 12.3456

pi = math.pi
print('%-8s %7.4f' % ('pi =', pi) ) pi = 3.1416
print('%-8s %7.4f' % ('2*pi =', 2*pi) ) 2*pi = 6.2832
print('%-8s %7.4f' % ('10*pi =', 10*pi) ) 10*pi = 31.4159

print('%.2f = %.0f%%' % (0.25, 25)) 0.25 = 25%

Lendo valores do teclado

String nome = input('Digite seu nome: ')

Valor inteiro idade = int( input('Digite sua idade: '))

Valor real altura = float( input('Digite sua altura (m): '))

i = 1
nota = int( input('Nota do %d° aluno: ' % i))
Usando saída formatada
Resultado: Nota do 1° aluno:

Ordem de prioridade dos operadores e comandos Python mais comuns:

Prioridade Operadores Exemplo

1 ** (exponenciação) x ** 3
2 - (unário) -x
3 * / // % x / y
4 + - x - y
5 < <= > >= == != x < y
6 not not x < y
7 and x > 10 and y < 0
8 or x > 10 or y < 0
9 = (comando de atribuição) x = 2
Comando condicional (if)

Sintaxe Exemplo

if condição: comando_único if x > 0: print('ok')

if x > 0:
if condição:
x = x + 1
<comando(s)>
print('ok')

if x > 0:
if condição: x = x + 1
<comando(s)> print( x )
else: else:
<comando(s)> y = x - 1
print( y )

if condição 1:
if x > 0:
<comando(s)>
x = x + 1
elif condição 2:
print( x )
<comando(s)>
elif x < 0:
...
y = x - 1
elif condição n:
print( y )
<comando(s)>
else:
else:
print('x = zero')
<comando(s)>
Comando de repetição (while)

Sintaxe Exemplo

x = 1
while condição: while x <= 10:
<comando(s)> print( x, end=' ')
x = x + 1
Resultado:
1 2 3 4 5 6 7 8 9 10

Comando de repetição (for)

Sintaxe Exemplo

for variável in range(valor_inicial, limite_superior): for i in range(0, 10):

<comando(s)> print( i, end=' ')
Resultado:
0 1 2 3 4 5 6 7 8 9

Sintaxe Exemplo

for var in range(vlr_ini, limite, passo): for i in range(0, 20, 3):

<comando(s)> print( i, end=' ')
Resultado:
0 3 6 9 12 15 18

Sintaxe Exemplo

for var in range(vlr_ini, limite, passo): for i in range(5, -1, -1):

<comando(s)> print( i, end=' ')
Resultado:
5 4 3 2 1 0

Sintaxe Exemplo

for var in range(vlr_ini, limite, passo): for i in range(12, 0, -2):

<comando(s)> print( i, end=' ')
Resultado:
12 10 8 6 4 2
Strings e Substrings

Comandos Resultado na Tela

s = 'ABCDEFGH'
print( s ) ABCDEFGH
print( s[0], s[5], s[7] ) A F H
print( s[:4] ) ABCD
print( s[4:] ) EFGH
print( s[3:6] ) DEF

Comandos Resultado na Tela

s = ''
for i in range(0, 10):
s = s + '*'
print( s ) **********

s = ''
for i in range(0, 10):
s = s + str( i )
print( s ) 0123456789

s = ''
for i in range(65, 75):
s = s + chr( i )
print( s ) ABCDEFGHIJ

s = '*' * 10
print( s ) **********

s = 'ABC' + 'd' * 4
print( s ) ABCdddd
Obs.: a função chr( x ) retorna o caractere correspondente ao código numérico (inteiro) x. O
complemento disso é a função ord( c ), que retorna o código numérico correspondente ao
caractere c.
Arranjos 1D (vetores, arrays)

# Importação da biblioteca
import numpy as np

# Criar um arranjo A com 10 elementos float zerados

A = np.zeros( 10 )

# Criar um arranjo B com elementos float e mesmo tamanho de A,

# mas sem valor inicial definido
B = np.empty(len( A ))

# Leitura do arranjo A pelo teclado

for i in range(0, len( A )):
A[i] = float( input('Informe o %dº elemento: ' % (i+1)))

# Multiplicar A por 2
for i in range(0, len( A )):
A[i] = 2 * A[i]

# Fazer B[i] = raiz quadrada de A[i] para todo i

for i in range(0, len( A )):
B[i] = A[i] ** 0.5

# Escrever B na tela com largura 8 e 1 casa decimal

for x in B:
print('%8.1f' % x, end='')
print()

# Criar um arranjo C com 10 elementos inteiros

# sem valor inicial definido
C = np.empty( 10, dtype=int )

# Fazer C[i] = 2i para todo i

for i in range(0, len( C )):
C[i] = 2*i

# Escrever C na tela
for x in C:
print( x, end=' ')
print()

# Criar um arranjo D já inicializado

D = np.asarray([70.5, 80.0, 54.3, 77.8])

# Calcular e escrever a soma dos elementos de D

soma = 0
for x in D:
soma = soma + x
print('Soma =', soma )
# Criar um arranjo E de elementos inteiros, inicialmente vazio
E = np.empty( 0, dtype=int )

# Leitura do arranjo E pelo teclado até o usuário digitar

# um valor negativo
while True:
x = int( input('Digite um valor inteiro (< 0 termina): '))
if x < 0:
break
E = np.append( E, x )

# Escrever E na tela sem qualquer formatação (só para testes)

print( E )
Arranjos 2D (matrizes)

# Importação da biblioteca
import numpy as np

m = n = 10 # Dimensões da matriz

# Criar uma matriz m x n de elementos float zerados

A = np.zeros( (m, n) )

# Criar uma matriz B com elementos float e mesmas dimensões

# de A, mas sem valor inicial definido
B = np.empty( A.shape )

# Leitura da matriz A pelo teclado

for i in range(0, m):
for j in range(0, n):
A[i][j] = float( input('Informe o elemento (%d,%d): ' % (i+1, j+1)))

# Multiplicar A por 2
for i in range(0, m):
for j in range(0, n):
A[i][j] = 2 * A[i][j]

# Fazer B[i][j] = raiz quadrada de A[i][j] para todo i,j

for i in range(0, m):
for j in range(0, n):
B[i][j] = A[i][j] ** 0.5

# Escrever B na tela com largura 8 e 1 casa decimal

for i in range(0, m):
for j in range(0, n):
print('%8.1f' % B[i][j], end='')
print()

# Criar uma matriz quadrada C de n x n elementos inteiros

# sem valor inicial definido
C = np.empty( (n, n), dtype=int )

# Fazer C[i][j] = 2i+j para todo i,j

for i in range(0, n):
for j in range(0, n):
C[i][j] = 2*i + j

# Criar uma matriz D 2 x 2 já inicializada

D = np.asarray([[70.5, 80.0],
[54.3, 77.8]])

# Calcular e escrever a soma dos elementos de D

soma = 0
for i in range(0, 2):
for j in range(0, 2):
soma = soma + D[i][j]
print('Soma =', soma )
Arranjos com Valores Aleatórios (usando a biblioteca ‘random’)

# Importação da biblioteca
import numpy as np
import random

# Inicializar a ‘semente’ aleatória

random.seed()

# Criar um arranjo v de 10 números inteiros aleatórios entre -50 e 50

v = np.empty( 10, dtype=int )
for i in range( 0, 10 ):
v[i] = random.randint( -50, 50 )

# Criar uma matriz A (5 x 5) de números reais aleatórios

# uniformemente distribuídos entre 1 e 100
A = np.empty( (5, 5) )
for i in range( 0, 5 ):
for j in range( 0, 5 ):
A[i][j] = random.uniform( 1, 100 )

# Escrever v na tela com largura 6

for x in v:
print('%6d' % x, end='')
print('\n')

# Escrever A na tela com largura 8 e 1 casa decimal

for i in range(0, 5):
for j in range(0, 5):
print('%8.1f' % A[i][j], end='')
print()

Arranjos com Valores Aleatórios (sem usar a biblioteca ‘random’)

O próprio numpy possui funções para criar arranjos preenchidos com valores aleatórios. Nesse caso não
precisamos na biblioteca ‘random’.

# Importação da biblioteca
import numpy as np

# Criar um arranjo v de 10 números inteiros aleatórios no intervalo fechado

# [-50,50], o que corresponde ao intervalo aberto [-50,51)
# ou: -50 <= v[i] < 51
v = np.random.randint( -50, 51, 10 )

# Criar uma matriz A (5 x 5) de números reais aleatórios

# uniformemente distribuídos no intervalo aberto [1,100)
# ou: 1 <= A[i][j] < 100
A = np.random.uniform( 1, 100, (5, 5) )
Definição de uma função

def nome( lista_de_parâmetros ):

<comandos>
return <valor(es) de retorno>

• nome: nome usado para chamar (usar) a função.

• lista_de_parâmetros: dados (constantes, variáveis) passados para a função.

Exemplos de função com arranjos

# Importação da biblioteca
import numpy as np
import random

# Criar e retornar um arranjo (vetor) de n números inteiros

# aleatórios entre a e b
def randVetInt( n, a, b ):
v = np.empty( n, dtype=int )
for i in range( 0, n ):
v[i] = random.randint( a, b )
return v

# Criar e retornar um arranjo (vetor) de n números reais

# aleatórios uniformemente distribuídos entre a e b
def randVetFloat( n, a, b ):
v = np.empty( n )
for i in range( 0, n ):
v[i] = random.uniform( a, b )
return v

# Escrever na tela um arranjo v.

# Cada elemento é escrito com espaçamento <larg> e <dec> casas decimais
def escreveVet( v, larg, dec ):
for x in v:
print(('%'+str( larg )+'.'+str( dec )+'f') % x, end='')
print()

# Escrever na tela um arranjo v usando a formatação <fmt>.

# Exemplo: escreveVetFmt( v, '%5d')
def escreveVetFmt( v, fmt ):
for x in v:
print( fmt % x, end='')
print()

# Calcular e retornar o produto interno entre dois vetores A e B.

# A função não verifica se A e B possuem o mesmo número de elementos
def produtoInterno( A, B ):
soma = 0
for i in range( 0, len( A )):
soma = soma + A[i] * B[i]
return soma