Contents

1 INTRODUÇÃO AO PYTHON 2
1.1 Compilação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Variável . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Palavras reservadas (33) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.5 Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.6 Comandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.7 Formatação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.8 Boleanos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.9 Operadores de comparação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Estrutura condicionais 5
2.1 If e Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Elif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4 Break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.5 For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3 Sequencias 6
3.1 Métodos de lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 Dicionários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4 Funções 8
4.1 Parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.2 Abrir arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

5 ORIENTAÇÃO A OBJETOS 11

1
1 INTRODUÇÃO AO PYTHON
1.1 Compilação
• Para acessar o Python no “Prompt de Comando - cmd”:
>Python
• Para executar script Python:
python programa.py
• Para copilar um arquivo Python:
>>> import py compile
>>> py compile.compile(‘programa.py’)

1.2 Type

1 A funç~
ao type() verifica o tipo de dados:
2 String - 'str'
3 Integer - 'int'
4 Float - 'float'
5 Boolean - 'bool'
6 Complex - 'complex'

1.3 Variável
Variável é um nome que guarda um valor. Um valor é atribuı́do a uma variável usando o sinal de
igualdade “=”.

1 variável = valor

Uma variável em Python começa com letra minúscula e quando necessário, separado por “ ”.

1 variavel_de_exemplo = "texto"

Esse padrão é chamado de “snake case”.

É proibido começar uma variável com ”número” ou ”caracter especial”.

1 3nome = ''valor'' ou @nome = ''valor''

1.4 Palavras reservadas (33)

1 and del from None True as

2 elif global nonlocal try assert else
3 if not while break except import
4 or with class False in pass
5 yield continue finaly is raise def
6 for lambda return

Um comando (instrução) é uma unidade de código que o Python pode executar.

1.5 Operadores

1 Operaç~
ao Nome Descriciç~
ao
2 a + b adiç~
ao Soma entre 'a' e 'b'
3 a - b subtraç~
ao Diferença entre 'a' e 'b'
4 a * b multiplicaç~
ao Produto entre 'a' e 'b'

2
 5 a / b Divis~ao Divis~
ao entre 'a' e 'b'
6 a // b Divis~ao inteira Divis~
ao inteira entre 'a' e 'b'
7 a % b Módulo Resto de divis~
ao entre 'a' e 'b'
8 a ** b exponenciaç~
ao 'a' elevado a pot^
encia de 'b'

O operador “+” concatena duas strings.

1 >>> "Py"+"Py"
2 'PyPy'

O operador “*” multiplica uma string por um determinado número de vezes.

1 >>> "Python"*3
2 'PythonPythonPython'

1.6 Comandos
A função int(), converte uma string para um inteiro.
O método upper() retorna o texto em letras maiúculas, lower() o inverso.

1 >>> texto.upper()
2 'PYTHON'
3 >>> texto.lower()
4 'python'

O método capitalize(), retorna com a primeira letra em maiúculas:

1 >>> texto.capitalize()
2 'Python'

A função input() captura a entrada de valores, print() devolve um valor na tela:

1 >>> a = input()
2 'pyhton'
3 >>> print(a)
4 'pyhton'

ou

1 >>> idade = input("Qual sua idade:\n")

2 Qual sua idade:
3 38
4 >>> print(idade)
5 38

O “∖n” quebra a linha após a string.

1.7 Formatação
Formatação usando a função format(). O “{}” é substituido pelo valor da váriável.

1 print('Seu nome é {} e sua idade é {}'.format(nome,idade))

1 >>> x = 95.2346
2 >>> print('{:.2f}'.format(x))
3 95.23

3
1.8 Boleanos
O Python possui poucas constantes embutidas, True, False e None. True e False são boleanos. A
função boo(), retorna True quando o argumento é verdadeiro ou retorna False, caso contrário.
O operador “==” é usado para verificar se algo é igual a outro.

1 >>> 1 == '1'
2 False
3 >>> print(1 == '1')
4 False

A função bool() não recebe apenas expressões. Retorna False quando o valor é zero, vazio ou
None.

1 >>> bool(0)
2 False
3 >>> bool('')
4 False
5 >>> bool(None)
6 False
7 >>> bool(1)
8 True

O None é um valor tipo NoneType, e é usado para representar a abstenção de um valor - como
quando um argumento padrão não é passado para uma função.

1.9 Operadores de comparação

1 a == b 'a' igual a 'b'

2 a != b 'a' diferente de 'b'
3 a < b 'a' menor do que 'b'
4 a > b 'a' maior do que 'b'
5 a <= b 'a' menor ou igual a 'b'
6 a >= b 'a' maior ou igual a 'b'

Operadores que retornam valores booleanos

1 a is b True se 'a' e 'b' s~ ao id^

enticos
2 a is not b True se 'a' e 'b' s~ ao id^
enticos
3 a in b True se 'a' é membro de 'b'
4 a not in b True se 'a' n~ao é membro de 'b'

Os operadores “==” e “is” são diferentes.

1 >>> x = [1, 2, 3]
2 >>> y = [1, 2, 3]
3 >>> x == y
4 True
5 >>> x is y
6 False

“==” verifica se os valores são iguais, “is” verifica se são o mesmo objeto.

4
2 Estrutura condicionais
2.1 If e Else
O Python possui o operador condicional para representar a palavra se que é o “if ” e a palavra senão
que é o “else”.

1 numero = 42
2 chute = int(input('Digite um número: '))
3 if chute == numero:
4 print('Voc^
e acertou')
5 else:
6 print('Voc^
e errou')

2.2 Elif
O “else” pode ser utilizado com uma condição de entrada, o “elif ”.

1 acertou = chute == numero_secreto

2 maior = chute > numero_secreto
3 menor = chute < numero_secreto
4 if(acertou):
5 print('Voc^
e acertou!')
6 elif(maior):
7 print('Voc^
e errou! O seu chute foi maior que o número secreto')
8 elif(menor):
9 print('Voc^
e errou! O seu chute foi menor que o número secreto')

2.3 While
O comando “while” executa enquanto a condição for verdadeira.

1 x = 5
2 while(x > 1):
3 print(x)
4 x = x - 1
5 #5
6 #4
7 #3
8 #2

1 from random import randint

2 x=randint(0,100)
3 a=1
4 c=0
5 while a!=0:
6 b = int(input("Um número de 0-100: \n "))
7 c +=1
8 ok = b == x
9 maior = b > x
10 menor = b < x
11 if(ok):
12 print('Acertou!\n ')
13 a=0
14 elif(maior):
15 a=1
16 print('Chute mais baixo\n ')
17 elif(menor):

5
 18 a=1
19 print('Chute mais alto\n ')
20 print('jogo finalizado, em {} tentativas'.format(c))

2.4 Break
Para finalizar a execução de um loop usa-se o comando “break”.

2.5 For
No comando “for” é definido o valor de inı́cio e final, e loop incrementa automaticamente.

1 for n in range(5):
2 print(n)
3 #1
4 #2
5 #3
6 #4

1 for n in range(1,5):
2 print(n)
3 #1
4 #2
5 #3
6 #4

Na função range() pode ser definido um step:

1 for n in range(1,5,2):
2 print(n)
3 1
4 3

Para o comando “for” pode ser passado os valores diretamente:

1 for n in [1,2,3]:
2 print(n)
3 1
4 2
5 3

3 Sequencias
3.1 Métodos de lista
1 append() Adiciona um elemento no final da lista.
2 clear() Remove todos os elementos da lista.
3 copy() Retorna uma cópia da lista.
4 count() Retorna o número de elementos com o valor especificado.
5 extend() Adiciona os elementos ao final da lista.
6 index() Retorna o ı́ndice do primeiro elemento com o valor especificado.
7 insert() Adiciona um elemento na posiç~
ao especificada.
8 pop() Remove o elemento na posiç~
ao especificada.
9 remove() Remove o primeiro item com o valor especificado.
10 reverse() Inverte a ordem da lista.
11 sort() Classifica a lista.

6
 1 >>> v = [1, 2, 3]
2 >>> min(v)
3 1
4 >>> max(v)
5 3
6 >>> v.append(4)
7 >>> v
8 [1, 2, 3,4]
9 >>> v[0]
10 1
11 >>> v[1]=5
12 >>> v
13 [1, 5, 3, 4]
14 >>> v[-2]
15 3
16 >>>len(v)
17 4
18 >>> 0 in v
19 False
20 >>> 5 in v
21 True
22 >>> v = [1, 5, 3, 4, 6]
23 >>> v[:2] #Retorna os 2 primeiros elementos
24 [1, 5]
25 >>> v[2:] #Retorna exceto os 2 primeiros elementos
26 [3, 4, 6]

Sequencias são containers, são 3 tipos básicos: lista, tupla e range.

Operações

1 x in s True se um item de 's' é igual a 'x'

2 x not in s False se um item de 's' é igual a 'x'
3 s + t Concatenaç~
ao de 's' e 't'
4 s * n Adiciona 's' a si mesmo 'n' vezes
5 s[i] Elemento na posiç~
ao 'i' de 's'
6 s[i:j] Fatia 's' de 'i' para 'j'
7 s[i:j:k] Fatia 's' de 'i' para 'j' com o passo 'k'
8 len(s) Tamanho de 's'
9 min(s) Menor item de 's'
10 max(s) Maior item de 's'
11 s.count(x) Número de ocorr^
encia de 'x' em 's'

Uma “lista” pode ter elementos de qualquer tipo, é delimitada por colchetes e seus elementos
separados por virgula. A função list(), converte um string para lista.

1 >>> lista = list('python')

2 >>> lista
3 ['p', 'y', 't', 'h', 'o', 'n']

Uma “tupla” é uma lista imutável, uma sequência que não pode ser alterada, sendo delimitada por
parênteses.
É possı́vel criar tuplas que contenham objetos mutáveis, como lista

1 >>> lista = [3, 4]

2 >>> tupla = (1, 2, lista)
3 >>> tupla
4 (1, 2, [3, 4])
5 >>> lista = [4, 4]
6 >>> tupla

7
 7 (1, 2, [4, 4])

O “range” é uma sequência imutálvel, usado no looping “for”, gera um intervalo de valores. Pode
ser gerado com o valor final, inı́cio e final, inicio, final e passo.
Um “conjunto” é uma coleção não ordenada e que não admite elementos duplicados. O uso
incluem teste de associação e eliminação de entradas duplicadas. Suportam operações matemáticas
como união, interseção, diferença e diferença simétrica.

1 >>> a = set('abacate')
2 >>> b = set('abacaxi')
3 >>> a
4 {'a', 'e', 'c', 't', 'b'}
5 >>> b
6 {'a', 'x', 'i', 'c', 'b'}
7 >>> a - b # diferença
8 {'e', 't'}
9 >>> a | b # uni~
ao
10 {'c', 'b', 'i', 't', 'x', 'e', 'a'}
11 >>> a & b # interseç~
ao
12 {'a', 'c', 'b'}
13 >>> a ^ b # diferença simétrica
14 {'i', 't', 'x', 'e'}

3.2 Dicionários
Os “dicionários” são estruturas poderosas, seus elementos são acessados através de “keys” e não por
sua posição. Em outras linguagens é conhecida como “matriz associativa”. Qualquer “keys” de um
dicionário é associada a um valor. Os valores pode ser quaquer tipo de dado.

1 >>> p = {'nome': 'Jo~

ao', 'idade': 25, 'cidade': 'S~
ao Paulo'}
2 >>> p
3 'nome': 'Jo~
ao', 'idade': 25, 'cidade': 'S~
ao Paulo'

Os dicionário são delimitados por ’’ e suas chaves (’nome’, ’idade’ e ’cidade’) por apóstrofo.

1 >>> p['nome']
2 'Jo~
ao'
3 >>> p['idade']
4 25
5 >>> p['paı́s'] = 'Brasil'
6 >>> p
7 {'nome': 'Jo~ao', 'idade': 25, 'cidade': 'S~
ao Paulo', 'paı́s': 'Brasil'}

O dicionário, o método keys() que devolve o conjunto de suas chaves.

1 >>> p.keys()
2 dict_keys(['nome', 'idade', 'cidade', 'pais'])

O método values() retorna os seus valores:

1 >>> p.values()
2 dict_values(['Jo~
ao', 25, 'S~
ao Paulo', 'Brasil'])

4 Funções
Função(rotinas, procedimentos, métodos) é uma sequencia de instruções que computa um ou mais
resultados chamados de “parametros”. É um conjunto de instruções que podem ser reutilizadas. Para

8
definir uma função, é utilizado o comando “def ”:

1 def velocidade(dis,tem):
2 pass

Após o “def ” vem o nome da função, seguido dentro dos parenteses, os argumento. O “pass” diz
ao interpretador que os cálculos serão definidos posteriormente.

1 def velocidade(dis,tem):
2 v=dis/tem
3 print('Velocidade: {}m/s'.format(v))

Paramentros de função é uma lista com nenhum ou mais elementos que podem ser obrigatórios
ou opcionais. Parametro opcional: None

1 def dados(nome, idade=None):

2 print('nome: {}'.format(nome))
3 if(idade is not None):
4 print('idade: {}'.format(idade))
5 else:
6 print('idade: n~
ao informada')

O comando “return”: retorna o resultado de uma função.

1 def velocidade(dis,tem):
2 v=dis/tem
3 return v

Outras formas de retorno de função:

1 acel = velocidade(dis, tem) / tem

2 print(velocidade(dis, tem))
3 resultado = velocidade(dis, tem)
4 print(resultado)

Para retornar múltiplos valores:

1 def calculadora(x, y):

2 return x+y, x-y
3
4 print(calculadora(1, 2))
5 #(3, -1)

ou

1 def calculadora(x, y):

2 return {'soma':x+y, 'subtraç~
ao':x-y}
3
4 resultados = calculadora(1, 2)
5 for key in resultados:
6 print('{}: {}'.format(key, resultados[key]))
7 #soma: 3
8 #subtraç~
ao: -1

Número arbitrário de parametros, variáveis mágica “*args” e “**kwargs”, estabelecido por con-
venção, mas poderia ser “*var” ou “**var”, apenas asterisco. A variável “*args” permite passar uma
quantitade variável de informações para uma função.

9
 1 def teste(arg, *args):
2 print('primeiro argumento normal: {}'.format(arg))
3 for arg in args:
4 print('outro argumento: {}'.format(arg))
5 teste('python', 'é', 'muito', 'legal')
6
7 # primeiro argumento normal: python
8 # outro argumento: é
9 # outro argumento: muito
10 # outro argumento: legal

4.1 Parâmetros
O parâmetro “arg” é como qualquer outro parâmetro de função, já o “*args” recebe múltiplos parâmetros.
O “*” executa um empacotamento dos dados para facilitar a passagem de parâmetros, e a função que
recebe este tipo de parâmetro é capaz de fazer o desempacotamento.
O “**kwargs” permite que passemos o tamanho variável da palavra-chave dos argumentos para
umafunção. Deve ser usado o “**kwargs” para manipular argumentos nomeados em uma função.

1 def funcao(**kwargs):
2 for key, value in kwargs.items():
3 print('{0} = {1}'.format(key, value))
4
5 dicionario = {'nome': 'leandro', 'idade': 38}
6 funcao(**dicionario)
7
8 nome = leandro
9 idade = 38

4.2 Abrir arquivos

Para abrir um arquivo, função open(), recebe dois parametros:

1. nome do arquivo

2. modo de trabalho - ‘w’ escrita, ‘r’ leitura, ‘a’ adiciona e ‘b’ binário. O modo é opcional, sendo o
padrão ‘r’

A função write() escreve no arquivo.

1 >>> arquivo.write('banana')
2 6

Retorna o número de caracteres inseridos.

A função close() fecha um arquivo:

1 >>> arquivo.close()

Para ler um arquivo interiro - função ’read()’ Para usar uma segunda vez a funçao ’read()’ é
necessário fechar e reabir o arquivo.
Para ler linha por linha, sendo o arquivo uma sequencia de linhas:

1 arquivo = open('nome.txt', 'r')

2 for linha in arquivo:
3 print(linha)

Para retirar caracteres especiais como “\n′′ :

10
 1 arquivo = open('nome.txt', 'r')
2 palavras = []
3 for linha in arquivo:
4 linha = linha.strip('\n')
5 palavras.append(linha)
6 arquivo.close()

Para gerar um número aleatório, função randrange() da biblioteca random

1 >>> import random

2 >>> random.randrange(0, 4)

1 Para evitar erro na leitura de arquivos, o comando 'with':

2 with open('nome.txt') as arquivo:
3 for linha in arquivo:
4 print(linha)

O comando with fecha o arquivo utilizado automaticamente.

5 ORIENTAÇÃO A OBJETOS
Criar contas bancárias de forma dinâmica:
Numa analogia, a “classe” estaria para a planta, e a casa construı́da para o “objeto”. A definição
da conta, é a classe. O construido (instanciado) a partir da classe é o objeto, a conta.
Criação de uma class:

1 class Conta:
2
3 def __init__(self, numero, titular, saldo, limite):
4 self.numero = numero
5 self.titular = titular
6 self.saldo = saldo
7 self.limite = limite
8
9 def deposita(self, valor):
10 self.saldo += valor
11
12 def saca(self, valor):
13 self.saldo -= valor
14
15 def extrato(self):
16 print("numero: {} \nsaldo: {}".format(self.numero, self.saldo))
17
18 conta = Conta('123-4', 'Jo~
ao', 120.0, 1000.0)
19 conta.deposita(20.0)
20 conta.extrato()
21
22 #numero: 123-4
23 #saldo: 140.0

11