OPERADORES

+, -, /, *, **
<, >, >=,<=, ==, !=
and, or, not
% = divisível (retorna o resto) ---- bom para definir se o numero é par ou impar
// = retorna o quociente

VARIÁVEIS
É uma posição na memória que armazena algum valor que pode variar ao longo do programa.
X=a x= a+2
Frase = “hoje choveu”

COMANDOS
print ( )
print (“O valor é %d somado com %d é igual a %d”, x,y,z) – forma elaborada de incluir
dados no print. Substitui o %d pelos números apontados no final na sequencia.

input ( )
variável “x” = input (“Apresenta um texto ao usuário e guarda o valor na variável apontada
“x””)
– O VALOR QUE O INPUT E O PRINT RETORNA É SEMPRE UMA STRING (mesmo
que seja um número), POR ISTO TEM QUE CONVERTER EM OUTRO TIPO PARA O
PROGRAMA PROSSEGUIR. Ex. converter em int (inteiro), float (real) etc.
Se for usado o que o print ou input retornam, haverá apenas uma concatenação e não uma
operação. Ex. input (“1”) + input (“2”) = 12 e não a soma = 3
FORMA DE CONVERTER STRING EM INTEIRO --> x = int (input(“Digite um número”))

while ( )
O laço while executa durante o tempo em que, ou enquanto, uma determinada condição for
verdadeira.
O while é melhor para trabalhar com listas/dicionários do que o for, especialmente para
altera-as.

Condição = 0 ---- primeiro valor da variável

while condição < 5 :
comandos
...
Comandos
Condição = condição + 1 ou condição +=1

Quando o comando while é executado, a <condição> é testada e, caso verdadeira, o seu corpo
é executado um comando de cada vez, ou seja <comando_1> primeiro, depois o
<comando_2>, até o <comando_n>. Quando o último comando (<comando_n>) termina, a
<condição> volta a ser testada e, caso verdadeira, o processo se repete. O while termina
quando, ao testar a <condição>, o resultado do teste for falso.

Break - faz com que sai do laço imediatamente, ainda que a condição while seja verdadeira.
Variável flag - para simplificar a saída do laço ---- flag = True ....while flag: .....print (input
(‘digite algo’) .... if flag ==quit: flag = False ----ao se tornar falsa digitando “quit”, sai do laço.
Continue  faz com que o laço pare e retorne imediatamente do inicio e ignora os demais
comandos.

If ( )
If condição :
 Comandos
...
Comandos
Elif condição :
Comando
else condição :
comando

A expressão booleana depois do if é chamada de condição. Se é verdadeira, então os

comandos tabulados (COMANDOS_1) são executados. Se não, então os comandos
tabulados depois do else são executados.
Se for necessário que mais de uma condição seja verdadeira, deve ser usado vários IF. Se
apenas uma for necessária, melhor usar IF e ELIF.

Listas
Guarda uma coleção de dados em uma única variável.
Nome da lista = [ ] ------ bicycles = ['trek', 'cannondale', 'redline', 'specialized']

Comandos:
len ( ) – numero de elementos da lista
type ( ) – tipo
append ( ) – acrescenta um item ao final da lista  motorcycles.append('honda')
insert ( )  insere um novo dado em lista em posição determinada
motorcycles.insert(0, 'ducati')
Alterando item da lista  bicycles [1] = “caloi” --- altera o item na posição 1
fatia de listas  lista [inicio:fim] --- lista [1:2] lista [:2] lista [2:]
relaclonar listas  lista1 = lista2[ : ] (as duas listas terão uma mesma referência)
alterar lista  lista1[2] = “rosa” (inclui rosa na posição 2)
concatenação  [1,2] + [3,4], lista1 + lista2 (junta uma lista ao final de outra)
repetir listas  lista [ ] * 3 --- repete a lista 3 vezes
copiar lista  se usar lista1 = lista2, os mesmos itens estarão nas duas listas, pois
ambas se referem a uma mesma posição da memória. Se usar lista1 = lista2[:], será
feita uma cópia da lista2, mas as duas ficaram em lugar da memória distintos.
Assim, neste caso se mudar algo na lista2, não haverá alteração na lista1.
remoção em listas  del lista [ 2] – item 2 será removido da lista ou del lista [1:5] –
apaga os itens de 1 a 5.
Remove ( )  quanto não se sabe qual a posição a ser removida, mas sabe-se o
conteúdo dela --- motorcycles.remove('ducati') --- outra forma --- cria uma variável
too_expensive = 'ducati' e depois aponta ela como item a ser retirado da lista
motorcycles.remove(too_expensive)
Pop ( )  retira o último item da lista e permite que seja usado em outro lugar ---
popped_motorcycle = motorcycles.pop() --- o item retirado fica na variável
popped_motorcycle --- pode ser retirado um item especifico informando a posição na
variável -- popped_motorcycle = motorcycles.pop(2)
A is B = vê na memoria se é a mesma coisa
A == B – vê se o conteúdo é igual das duas variáveis
Lista de listas  [lista]*3 = cria 3 listas dentro de uma lista
Sort ( )  ordena uma lista em ordem alfabética ---- cars.sort(reverse=True) com o
reverse a ordem é decrescente. TODAS AS LETRAS TEM QUE ESTAR
MINUSCULAS
Sorted ( )  a lista é apenas apresentada em ordem, mas na realidade ela continua
na ordem original.
Reverse ( )  inverte a ordem da lista de trás para frente
Para acessar um item da lista, basta indicar o nome dela e a posição  lista [0]
 Também podem ser usados os métodos das strings para as listas, como upper,
lower, strip etc. ---- print(bicycles[0].title())

Estatísticas com listas:

List comprehensions  forma de descrever uma lista com for com poucos códigos.
Squares = [value**2 for value in range(1,11)]

Min ( )  menor valor dentro uma lista

Max ( )  maior valor dentro uma lista
Sum ( )  soma o valor dos números de uma lista
For
for variável in conjunto de valores :
Comandos

<variável> receberá os valores existentes no <conjunto de valores>, um em cada

interação. <conjunto de valores> poderá ser uma lista ou um intervalo de valores.
<comandos> são os comandos que serão executados enquanto houver valores para
a <variável> assumir.

Comandos:
Range (A função range( ) de Python facilita gerar uma série de números)

for i in range (inicio, fim, passo) :

comando
i  começa em 0
inicio, fim  local de inicio e de fim
passo  qual é a faixa de números ex. de 10 em 10, 1 em 1

Função list  numbers = list(range(1,6)) print(numbers) E oresultado será este: [1, 2, 3, 4,

5] --- Se quiser criar uma lista de números, você pode converter os resultados de range()
diretamente em uma lista usando a função list(). Quando colocamos list() em torno de uma
chamada à função range(), a saída será uma lista de números.

listar só os pares  num = list(range(2,11,2)) --- o numero 2 ao final indica que pula de 2
em 2.

Matriz
A = [ [1,2,3], [4,5,6], [6,7,8] ] – cria a matriz
A = [ [‘gato’, ‘macaco’, ‘arara’], [‘jacaré’, ‘rato’, ‘leão’]] – cria a matriz

Strings (strings são imutáveis, assim as variáveis apontam para o mesmo lugar)

Upper ( )  todas letras em maiúsculo

Lower ( )  letras em minúsculo
Title ( )  só primeira letra em maiúsculo
+  para concatenar strings
\t  insere tabulação
\n  acrescenta linha em branco -----print("Languages:\n\tPython\n\tC\n\tJavaScript")
Rstrip ( )  tira os espaços em branco que tiverem no final de uma frase ----a remoção é
apenas temporária. Por isso, é preciso incluir a nova alteração em nova variável para se tornar
definitiva ----------favorite_language = favorite_language.rstrip()
Lstrip ( )  retira os espaços no inicio da frase.
Sstrip ( )  retira os espaços dos dois lados.
 Comparar o conteúdo das strings  x==y ou x!=y ---- ele compara código por código
UNICODE/ANSI para ver se é igual

Números
Inteiros - 1,2,3
Ponto flutuante  que tem casa decimal 0.1, 0.32
Números não trabalham com strings e vice-versa. Por isso deve ser convertido int ( ) ou str
( ).

Tuplas

As listas funcionam bem para armazenar conjuntos de itens que podem mudar durante a
vida de um programa. Python refere-se a valores que não podem mudar como imutáveis, e uma
lista imutável é chamada de tupla.
Uma tupla se parece exatamente com uma lista, exceto por usar parênteses no lugar de colchetes.
dimensions = (200, 50)

Dicionários
Sintaxe  alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color']) --- para acessar um item do dicionários informar o
valor-chave entre colchetes.

Um dicionário em Python é uma coleção de pares chave-valor. Cada chave é conectada a

um valor, e você pode usar uma chave para acessar o valor associado a ela. O valor de uma
chave pode ser um número, uma string, uma lista ou até mesmo outro dicionário.

Adicionar chave-valor novo  nomedicionario [‘novachave-valor’] = valor-chave

Criar dicionário vazio  nomedicionario = { }
Modificar valor-chave  nomedicionario [‘chave-valor’] = valor-chave novo
Remover chave-valor  del nomedicionario [‘chave-valor a ser removida’]
Percorrer dicionários  método items( ) ----- for chave, valor in nomedodicionario.items( ):
Método Keys( ) ---- for chave in nomedodicionario.keys( ): --- é a
mesma coisa que: for chave in nomedodicionario:
Função Sorted  coloca as chave-valor em ordem ---- for chave in sorted(dicionario.keys()):
Método Values ()  percorre apenas o valor-chave ---- for chave in dicionario.values( )):
Função set ( )  apresenta o valor-chave sem repetição caso haja vários iguais ----
for chave in set(dicionario.values( )):
Dicionários com listas  para coloca lista, basta incluir o campo com colchetes na chave-
valor ----- pizza = {‘massa’: ‘crocante’, ‘recheio’: [‘queijo’,’presunto’,’molho’], }
Dicionários com dicionários 

Funções
Sintaxe: def nome ( variável, variável ... ) : --- quando for passado o parâmetro, tem que
observar a ordem das variáveis
Comandos
Comandos....

Quando chamamos uma função que devolve um valor, precisamos fornecer uma
variável em que o valor de retorno possa ser armazenado.

Valores default  se colocar um valor para a variável, este valor se tornará default e será
o observado pelo programa se o usuário não informar um valor para aquela variável, ex. Def
cachorro (nome, raça=’bichon’) : --- se não for informada a raça, automaticamente será
bichon. ---- a primeira variável é sempre obrigatória, por isto não pode ser default.
 Valores de retorno  criar uma função é no final incluir return devolverá o valor processado
ao programa que chamou a função e lá poderá trabalhar com este valor de retorno.
Valores opcionais  se uma das variáveis for opcional, basta declarar a função assim, na
última posição --- def carros (marca, modelo, potencia=’ ‘) --- assim a potência não precisar
ser informada.

Classes
Sintaxe: class Dog ( ):
def _init_(self, name, age): ------ método __init__( ) ----self é obrigatório incluir
self.name = name
self.age=age
def senta (self):
Print (self.name.title( ) + ‘está agora sentado’)
def rola (self):
Print (self.name.title( ) + ‘rola no chao’)

meucao = Dog('kitty', 13)

print('O nome dela é ' + meucao.name.title( ))
meucao.rola( ) -------------para chamar um método da classe Dog
meucao.senta( )

__init__  é o construtor da classe e é ele que declara os atributos.

As classes não precisam do método return, porque a devolução do resultado é automática.

CONVERSOR DE TIPOS
Int ( ) Float ( ) str ( )

ATRIBUIÇÕES DE VALORES
A, B = 10, 20 --- atribui 10 para A e 20 para B
A, B = B, A --- inverte os valores de A e B, para 20 e 10, respectivamente.
X*=2 --- multiplica o valor da variável x por 2
X+=2 --- soma o valor da variável X com 2.
Parâmetros opcionais -- def pgto (salario, hora = 40): --- o parâmetro hora é opcional,
pois se não for informado outro valor, será atribuído o valor 40 automaticamente) -- os
opcionais sempre tem que ficar no final)
Assert - impoe uma regra para ser verificada, que se não for verdadeira dá um erro.

IMPORTAÇÃO DE MÓDULOS
Import nomedomódulo ---- importa todas as funções, sendo preciso chama-las
individualmente com o comando . ---- pizza.fazPizza( )
Import nomedomodulo as alias ---- dá um apelido para ser usado
From nomedomódulo import nomedafunção as alias --- chama apenas uma das
funções do módulo, sendo desnecessário usar o comando ‘ . ‘ e dá um apelido para ela ----
fazPizza ( ).

CORES NO TERMINAL
Usando o método ANSI: \033[código para estilo; código para texto; código para fundo m
Print(f,’/033[style; text; Background m ............’)
Style= 0, 1, 4, 7
Texto= 30 a 37
Fundo= 40 a 47
Branco, Vermelho, Verde, Amarelo, Azul, Lilás, Ciano, Cinza.