Sumário

Downloads..................................................................................................................................... 3
Comentários .................................................................................................................................. 3
Tipos de dados .............................................................................................................................. 3
Identificadores .............................................................................................................................. 4
Variáveis ........................................................................................................................................ 4
Conversão de tipos (type casting) ................................................................................................. 4
Comentários .................................................................................................................................. 5
Lista ............................................................................................................................................... 5
Relação de métodos disponíveis para uma lista: ...................................................................... 6
Funções aplicadas a uma lista, tupla, dicionario ....................................................................... 6
Tuplas ............................................................................................................................................ 6
Dicionários..................................................................................................................................... 7
Conjuntos ...................................................................................................................................... 8
Downloads

1. Anaconda Studio
 https://www.anaconda.com/distribution/#download-section

Comentários

Tipos de dados

1. Int – Números inteiros, sem casas decimais

2. Float – Números reais, com casas decimais
3. Str – String/Texto
4. Bool – Lógico/Boleano
Identificadores

Como o próprio nome sugere é um nome dado a uma função, variável ou constantes. Porém em
Python, existe algumas regras que devem ser seguidas:

 Pode ser utilizado apenas, letras, números e underscore (underline);

 Obrigatoriamente deve começar com letras ou underscore;
 Reforçando, não deve conter caracteres especiais, espaços ou letras acentuadas;

Atenção:

A linguagem Python é case sensitive, ou seja, a palavra “texto” é diferente de “TEXTO”.

Boas práticas de programação:

No PEP8, Guido van Rossum sugere que nomes de variáveis e funções devem ter apenas
letrasminúsculas e utilizar o underscore no caso de identificadores contendo mais de uma
palavra (ex: nome_func, perc_aumento).

Variáveis

Variável é um espaço na memória do computador, utilizado para que um programa possa

armazenar dados e posteriormente ser usada pelo programa.

 Endereço na memória (Criado e gerenciando automaticamente pela linguagem);

 Tipo, apesar de existir outros tipos, os principais são: int, float, str e bool;
 Identificador (Nome da variável).

Para criar uma variável inserir o identificador precedido da expressão, a linguagem Phyton
automaticamente identificará o tipo da variável.

Exemplo:
resultado = 2+2

No exemplo acima, “resultado” será do tipo inteiro, pois o resultado da expressão retorna um
valor inteiro (4).
va r i a ve l _ i n t = 5 + 5 # c r i a u m a va r i á ve l d o t i p o i n t e i r o

va r i a ve l _ f l o a t = 1 2 . 5 + 1 0 # c r i a u m a va r i á ve l d o t i p o r e a l

va r i a ve l _ b o o l = t r u e # c r i a u m a va r i á ve l d o t i p o b o l e a n o / l ó g i c o

va r i a ve l _ s t r = “ V a r i á ve l d o t i p o s t r i n g ” # c r i a u m a va r i á ve l d o t i p o s t r i n g

Conversão de tipos (type casting)

Python permite a conversão entre tipos de dados. Para fazer uma conversão, basta utilizar o
nome do tipo e entre parêntese, passar o valor ou variável que se deseja converter.
Exemplo:
va r i a ve l _ s t r i n g = s t r ( 5 ) # s e r á c o n ve r t i d o o va l o r 5 q u e é d o t i p o i n t e i r o p a r a s t r i n g

va r i a ve l _ i n t = i n t ( “ 5 ” ) # s e r á c o n ve r t i d o o t e xt o “ 5 ” q u e é d o t i p o s t r i n g p a r a u m i n t e i r o

va r i a ve l _ i n t = i n t ( 3 . 5 ) # s e r á c o n ve r t i d o d e f l o a t p a r a i n t e i r o , p o r é a p e n a s o n ú m e r o 3

va r i a ve l _ b o o l = b o o l ( 1 7 ) # q u a l q u e r c o i s a c o n ve r t i d o p a r a b o o l é i g u a l a t r u e , a p e n a s
o n ú m e r o “ 0 ” ( ze r o ) é i g u a l a f a l s e .

Comentários

No Phyton existe duas formas de adicionar comentários em um código:

1. Comentário em apenas uma linha utilizando o caractere #

2. Comentário em multilinhas utilizando 3 aspas duplas para abrir e fechar o “””

Lista

É uma coleção de elementos, similar a um array, porém a quantidade de elementos é dinâmica,

pode aumentar ou diminuir.

Cada elemento tem uma posição na lista, essa posição é chamada de indice, o primeiro elemento
da lista recebe a posição 0 (zero).
Figura 1 - Índices para acessar uma estrutura de dados

Os elementos da lista também podem ser “chamados” por um segundo índice, onde o primeiro
elemento da lista é igual ao total de elementos negativo, conforme o exemplo da imagem acima.

l i s t a = [ ] # c r i a r u m a l i s t a , va zi a , s e m e l e m e n t o s .

l i s t a = l i s t ( ) # c r i a r u m a l i s t a , va zi a , s e m e l e m e n t o s

t yp e ( l i s t a ) # ve r i f i c a r o t i p o d e u m a v a r i á ve l

l e n ( l i s t a ) # ve r i f i c a o t a m a n h o d e u m a l i s t a , r e t o r n a u m n ú m e r o i n t e i r o

lista = [1,2,3] #criando lista com números inteiros

lista = [1.5,1.6,1.7] #criando uma lista com números rea is

l i s t a = [ “ va l o r 1 ” , “ va l o r 2 ” ] # c r i a n d o u m a l i s t a d e s t r i n g

l i s t a = [ t r u e , f a l s o ] # c r i a n d o u m a l i s t a d e va l o r e s b o l e a n o s
l i s t a = [ 1 , 1 . 5 , ” t e xt o ” , f a l s e ] # l i s t a d e va l o r e s c o m d i f e r e n t e s t i p o s

l i s t a = [ “ t e xt o ” , 1 , [ 7 , 8 , 9 ] ] # l i s t a m i s t a c o n t é n d o u m a l i s t a

lista=[[1,2,3],[3,2,1]] #lista de listas (somente listas)

l i s t a # p a r a vi s u a l i za r t o d o s e l e m e n t o s d a l i s t a , b a s t a i n f o r m a r o n o m e d a vá r i a ve l

l i s t a [ 4 ] # p a r a a c e s s a r u m e l e m e n t o e s p e c i f i c o a t r a vé s d o i n d i c e

l i s t a [ 4 ] = 1 0 0 # a l t e r a o v a l o r e l e m e n t o d a p o s i ç ã o “ 4 ” c o m o va l o r “ 1 0 0 ”

l i s t a [ 5 ] [ 1 ] # a c e s s a o e l e m e n t o 1 d e u m a s u b l i s t a l o c a l i za d a n a p o s i ç ã o 5 d a l i s t a
principal.

Relação de métodos disponíveis para uma lista:

lista.append(5) #adiciona o elemento na lista, pode ser números ou outras lista

lista.clear() #apaga todos os elementos da lista

l i s t a . c o p y( ) # p a s s a p a r a o u t r a l i s t a t o d o s o s va l o r e s d e t o d o s o s e l e m e t n o s

lista.count(5) #conta a quantidade de elementos na lista é necessário passar

parametros

l i s t a . e xt e n d ( l i s t a 2 ) # a d i c i o n a t o d o s o s e l e m e n t o s d a l i s t a 2 n a l i s t a

l i s t a . i n d e x( 2 0 ) # r e t o r n a o i n d i c e d o v a l o r p a s s a d o n o p a r a m e t r o ( 1 ° r e g i s t r o
l o c a l i za d o )

l i s t a . i n s e r t ( 3 , “ v a l o r ” ) # i n s e r e o va l o r n o i n d i c e e s p e c i f i c a d o , o u n a u l t i m a p o s i ç ã o s e
n t i ve r

l i s t a . p o p ( 3 ) # r e m o ve o v a l o r d o i n d i c e p a s s a d o n o p a r a m e t r o , d a e r r o n ã o e xi s t i r

l i s t a . r e m o ve ( 3 ) # r e m o ve o va l o r d o i n d i c e p a s s a d o n o p a r a m e t r o , d a e r r o n ã o e xi s t i r

l i s t a . r e ve r s e ( ) # i n ve r t e a s e q u ê n c i a d a l i s t a .

l i s t a . s o r t ( r e ve r s e = t r u e ) # r e a l i za o r d e n a ç ã o , r e v e r s e = t r u e s e r á d o m a i o r p a r a o
menor

Funções aplicadas a uma lista, tupla, dicionario

Len(lista) #retonar a quantidade de elementos de uma lista

Ma x( l i s t a ) # r e t o r n a o m a i o r va l o r d e u m a l i s t a

Mi n ( l i s t a ) # r e t o r n a o m e n o r va l o r d e u m a l i s t a

S u m ( l i s t a ) # r e a l i za a s o m a n t ó r i a d o s e l e m e n t o s d e u m a l i s t a , n ã o p o d e t e r l i s t a n o
elemento

Tuplas

Tupla (Tuple) é um tipo de estrutura de dados, similar a uma lista, a principal diferença entre
elas é que a Tupla é imutável, ou seja, após definidos os elementos eles não podem ser
alterados. Entretanto, caso existir alguma estrutura de dado que seja elemento de uma tupla
essas estruturas podem ser alteradas.
Similar a uma lista, a tupla também possui um índice de referência para os elementos, o indicie
inicia em 0 zero. Também é possível acessar os elementos de outro modo conforme a Figura 1.

Devido a imutabilidade das tuplas, alguns métodos não estarão disponíveis.

Os elementos de uma tupla não podem ser alterados, mas eles podem ser criados na mesma
variável.
t u p l a = ( ) # c r i a u m a t u p l a va zi a

t u p l a = t u p l e ( ) # c r i a u m a t u p l a va zi a

tupla =(1,”aaa”,3) #cria a tupla com os elementos que estão entre parenteses

t u p l a . c o u n t ( 1 ) # c o n t a a q u a n t i d a d e d e e l e m e n t o s “ 1 ” e xi s t e n a t u p l a

t u p l a . i n d e x( “ a a a ” ) # r e t o r n a a p o s i ç ã o / i n d e x d o e l e m e n t o “ a a a ”

lista = list(tupla) #converte uma tupla para lista.

Dicionários

Dicionários são estruturas de dados similar a uma lista, a principal diferença é que nos
dicionários os índices/chaves são valores fornecidos por nós e que ficam associados a outros
dados. Cada chave está associada a um valor/dados, conforme a figura abaixo.

Veja a relação de métodos disponíveis para os dicionários em Phyton:

d i c = { } # c r i a u m d i c i o n á r i o va zi o

d i c = d i c t ( ) # c r i a u m d i c i o n á r i o va zi o

dic = dic(“mg”:”minas gerais”, “ba”:”bahia”) #cria um dicionário com dois elementos

d i c Mi x = { " m g " : " m i n a s " , 1 : " n u m e r o " , " l i s t a " : [ 1 , 2 , 3 ] , " d i c i o n a r i o " : { 1 : " o n e " } } # d i c o n á r i o
misto

d i c Mi x[ “ l i s t a ” ] [ 1 ] # a c e s s a o i t e m 1 d a l i s t a , d e u m d i c i o n á r i o q u e t e m a c h a ve “ l i s t a ”

dic.clear() # apaga todos elementos de um dicionário

d i c . c o p y( ) # c o p i a o s e l e m e n t o s d e u m d i c i o n á r i o

d i c . f r o m k e ys ( [ 1 , 2 , 3 ] ) # c r i a u m d i c i o n a r i o a p a r t i r d a s c h a ve s i n f o r m a d a s
d i c . f r o m k e ys ( [ 1 , 2 ] , ” a ” ) # c r i a u m d i c i o n a r i o a p a r t i r d a s c h a ve s i n f o r m a d a s , va l o r
default “a”

d i c . g e t ( 2 ) # r e t o r n a o va l o r a s s o c i a d o a c h a ve 2

d i c . i t e m s ( ) # r e t o r n a u m a vi s ã o d o s p a r e s d a d o s / va l o r d e u m d i c i o n á r i o

d i c . k e ys ( ) # r e t o r n a u m a vi s ã o d a s c h a ve s d o s d i c i o n á r i o s

d i c . va l u e s ( ) # e xi b e o s v a l o r e s d o d i c i o n a r i o

d i c . p o p ( ) # r e m o ve e r e t o r n a r o e l e m e n t o s p a s s a d o p o r p a r a m ê t r o

d i c . p o p i t e m ( ) # r e m o ve o u l t i m o e l e m e n t o d o d i c i o n a r i o

d i c . s e t d e f a u l t ( 5 ) # r e t o r n a o v a l o r a s s o c i a d o a u m a c h a ve , s e n ã o e xi s t i r e l e i n s e r e

d i c . s e t d e f a u l t ( 5 , ” c i n c o ” ) # r e t o r n a o va l o r a s s o c i a d o a u m a c h a ve , s e n ã o e xi s t i r e l e
insere

d i c . u p d a t e ( d i c 2 ) # a d i c i o n a a o d i c i o n á r i o o s p a r e s d e c h a ve / va l o r d e o u t r o d i c i o n á r i o
passado

Conjuntos

Conjuntos são coleções de elementos únicos

Principais características:

Os elementos não são armazenados em uma ordem específica

Conjuntos não contém elementos repetidos

Conjuntos não suportam indexação como as listas e tuplas

Não permitem inserir outras estruturas de dados (lista, tuplas ou dicionários)

Não podemos modificar apenas excluir e adicionar um novo

Como um conjunto não possui index eles só podem ser acessar pelo FOR

c o n j = s e t ( ) # c r i a u m c o n j u n t o va zi o , e s s e é o ú n i c o m o d o d e c r i a r u m c o n j u n t o va zi o

c o n j = { 1 , 2 , 3 } # c r i a u m c o n j u n t o c o m va l o r e s

f o r i t e m i n c o n j : p r i n t ( i t e m ) # a c e s s a n d o o s va l o r e s d o c o n j u n t o

c o n j . a d d ( 1 0 ) # a d i c i o n a o va l o r 1 0 n o c o n j u n t o

conj.clear() # apaga todos os registros do conjunto

conj2 = conj.copy() #cria uma copia do conj para o conj2

conj.difference(conj2) #retorna os elementos que tem em conj mas não tem em conj 2

c o n j . i s d i s j o i n t ( c o n j 2 ) # r e t o r n a t r u e s e n ã o e xi s t i r e l e m e n t o s i g u a i s n o s d o i s g r u p o s

c o n j . i s s u b s e t ( c o n j 2 ) # ve r i f i c a s e o c o n j é s u b c o n j u n t o d e c o n j 2 . S e t o d o s e m e n t o s
estão em conj2.

c o n j . i s s u b s e t ( c o n j 2 ) # ve r i f i c a s e o c o n j 2 é s u b c o n j u n t o d e c o n j . S e t o d o s e l e m e n t o s
de conj2 estão em conj.

c o n j . r e m o ve ( 2 5 ) o u c o n j . d i s c a r t ( 2 5 ) # r e m o ve o e l e m e n t o 2 5 d o c o n j u n t o
c o n j . s ym m e t r i c _ d i f f e r e n c e ( c o n j 2 ) # r e t o r n a o s e l e m e n t o s q u e n ã o c o n t é m n o s d o i s
conjuntos

conj.union(conj2) #junta os dois conjuntos e não repete os elementos

conj = set(lista) #adiciona uma lista em um conjunto

Nota: disjunto = não possuem elementos iguais.

Comandos uteis

i s i n s t a n c e ( va r i a ve l , i n t ) # ve r i f i c a s e u m a a i n s t a n c i a d e u m a va r i a v e l é i n t e i r a

t yp e ( ) # ve r i f i c a o t i p o d a va r i a ve l

p r i n t ( “ n o m e : { } , ” , “ i d a d e { } ” . f o r m a t ( n o m e , i d a d e ) ) # i r á a l t e r a r a s c h a ve s { } p e l a s o s
va l o r e s d a s va r i a v e i s n a m e s m a s e q u ê n c i a .

Operadores

Strings
É uma sequência de caracteres, que podem ser acessado através de um índice, começando da
posição Zero. No python uma string é “str”.

As strings são criadas através do apóstrofos (‘ ’) ou aspas duplas (“ ”)

Utilizando aspas em um texto, basta introduzir o texto com apostrofo e adicionar a aspas
duplas no local desejado. Exemplo: ‘Ele disse “bla bla bla...” ’ .

Cara

n o m e = “ j o a o ” # c r i a u m a va r i a ve l e a t r i b u i o va l o r

n o m e [ 0 ] # a c e s s a o va l o r d o i n d i c e 0 d e u m a va r i a ve l , n e s s e c a s o s e r á o J