• Estudos em Python
  • Udemy
  • Google Style Guide
• Syntax
  • Comentários
  • Comandos de repetição
  • Tipos de dados
  • Operadores
  • Atribuição de variável
• Funções
  • Criação de funções
  • print()
  • input()
  • range()
  • len()
  • round()
  • min()/max()
  • sum()
  • type()
  • exit()
• Listas, Tuplas, Sets e Dicionários
  • Listas (list)
    • Criação de listas
    • Operações com listas
    • Print de listas
    • Acessar elementos
    • Alterar elementos
    • Verificação de elementos
    • Intervalo de listas (Slice)
    • Tamanho de listas len()
    • Soma de listas
    • Map
  • Tuplas (tuple)
  • Sets
    • Operações matemáticas
  • Dicionários (dict)
• Métodos
  • Class String
    • Operações com strings
    • Verificação de ocorrência
    • Acessar elementos
    • Formatação
  • Class List
    • Adicionar elementos
    • Remover elementos
    • Verificiar ocorrência
    • Contagem de ocorrência
    • Ordenação de listas
    • Cópia de listas
    • Join
  • Class Set
    • Adicionar/Remover elementos
• Inclusão de bibliotecas
• Funções importantes

Estudos em Python

Udemy

Google Style Guide

Syntax

Comentários

# Comentários na linha utilizam "#"

"""
Comentários em várias linhas
utilizam no início e fim 3 aspas seguidas
""" 

Comandos de repetição

if condição:
    # comando (PRECISA DE IDENTAÇÃO)
elif: # Equivalente ao else if
    # comando (PRECISA DE IDENTAÇÃO)
else:
    # comando (PRECISA DE IDENTAÇÃO)
# Na condição, qualquer expressão que tenha um valor != 0 é considerada True

a if condição else b
# Condição TRUE  -> Executa A
# Condição FALSE -> Executa B

try:
    # comando
except:
    # comando, caso o comando acima der erro

while condição:
    # comando

for variavel in sequencia:
    # comando
"""
Sequência é qualquer tipo sequencial do python
Ex: Lista, String, Tupla etc.
"""

Tipos de dados

int -> 11 # Inteiro
float -> 11.10 # Float (Números decimais)
str -> "Enzo" # String (Texto)
bool -> True # Booleana (True ou False)
None # NoneType (Nada, vazio, algo a ser preenchido etc.)

Casting

a = "1"
b = "1"
resultado = int(a) + int(b) # resultado = 2 ao invés de "11"

# Com bool(), qualquer número != 0 e qualquer string != "" resultam em True

Operadores

+  -> Adição
-  -> Subtração
*  -> Multiplicação
/  -> Divisão
// -> Divisão Inteira
%  -> Resto da divisão
** -> Potenciação

>  -> Maior
<  -> Menor
>= -> Maior ou igual
<= -> Menor ou igual
== -> Igual
!= -> Diferente

and -> e
or  -> ou
not -> não

+= -> Incrementa
-= -> Decréscimo
Outros operadores também podem ser combinados com "="

Atribuição de variável

x = 10 # Atribui 10 a "x"
x, y = 10, 20 # Atribui 10 a "x" e 20 a "y"

# Obs: Python é case sensitive, ou seja, Var != aar

Funções

Criação de funções

def nome(args): # Define a função "nome" que requer "input"
    return var # Retorna a variável "var"

def nome(arg:type): # Definição de função com type hint do argumento
def nome(arg:typeIn)->typeOut: # Define a função com type hint de input e output

def nome(arg = defaultValue): # Define a função com valor padrão p/ argumento
def nome(arg:type = defaultValue): # Define a função com type hint e valor padrão
"""
Type Hint não tem muito uso prático, apenas no autocompletar
em algumas IDEs, é tipo um comentário
"""

print()

print(var) # Printa uma variável
print("Hello, World!") # Printa um texto
print(sep = " ", end = "\n")
"""
Por padrão:
sep = " "  -> Separador entre argumentos é o espaço
end = "\n" -> Pula linha ao terminar o print
"""

Exemplos de uso

print("Texto", var) # "Texto var"
print("var =", round(var, x))   # Printa a variável "var" com "x" casas decimais

# Print formatado recebe um f antes das " "
print(f"texto {var}") # "texto var"
print(f"{var:.nf}") # Printa variável float com "n" casas decimais

print("Texto1", var, "\nTexto2")
"""
Texto1 var
Texto2
"""

print("MC102", "UNICAMP", "2022", sep = " - ", end = "!\n")
# "MC102 - UNICAMP - 2022!" e pula linha

# Para printar caracteres especiais, usar o escape (\) antes
print("\\n") # "\n"
print(" \"Frase entre aspas\" ") # " "Frase entre aspas" "

input()

var = input() # Aguarda receber entrada e guarda na variável "var"
"""
A função input() retorna uma string do que foi digitado antes do <ENTER>
"""

var = input("Entrada: ") # Printa o texto e espera por entrada

var = int(input()) # Casting de inteiro no input

range()

# 3 parâmetros
range(inicio, fim, passo)
# 2 parâmetros
range(inicio, fim)  # Por padrão, passo += 1
# 1 parâmetro
range(fim)          # Por padrão, inicio = 0

Exemplos de range() com for

for i in range(n): # De 0 até n - 1
    # comando
    # i += 1

for i in range(1, n) # de 1 até n - 1
    # comando
    # i += 1

for i in range(1, n + 1) # de 1 até n
    # comando
    # i += 1

for i in range(1, n, 2) # de 1 até n - 1 ou menor
    # comando
    # i += 2

len()

len(sequencia)
# Retorna a quantidade de elementos de uma sequência

round()

round(var, casas) # Arredonda a variável "var" para um certo número de casas decimais
round(var) # Transforma a variável "var" float em inteiro

min()/max()

min(x1, x2, ..., xn) # Retorna o MENOR valor entre x1, x2, ..., xn
max(x1, x2, ..., xn) # Retorna o MAIOR valor entre x1, x2, ..., xn

sum()

sum(sequencia)
# Retorna a soma de todos os elementos da sequência

type()

type(var) # Retorna o tipo da variável (int, str, float etc)
# Formato: <class 'type'>

exit()

exit(0) # Fecha o programa de forma "amigável" (Por conta do 0)
# Obs: Não utilizar fora do interpretador

Listas, Tuplas, Sets e Dicionários

Listas (list)

Criação de listas

listas = [x, y, z]
listas = ["a", "b", "c"]
listas = [x, "a", y, "b", z, "c"]

Pela função list()

listas = list() # listas = []
listas = list(range(5)) # listas = [0, 1, 2, 3, 4]
listas = list(["x1", "x2", "x3"]) # listas = [x1, x2, x3]
listas = list("test") # listas = ['t', 'e', 's', 't']
# Strings são listas de caractéres

Forma compacta com input

n = int(input())

listas = [int(input()) for i in range(n)]

Operações com listas

lista = [1] * 3 # lista = [1, 1, 1]

lista = [1, 2, 3]
lista2 = lista + [4, 5] # lista2 = [1, 2, 3, 4, 5]
# OU
lista += [4, 5] # lista = [1, 2, 3, 4, 5]

Print de listas

listas = ['A', 'B', 'C', 'D', 'E']

print(listas)  # ['A', 'B', 'C', 'D', 'E']
print(*listas) # A B C D E

Acessar elementos

listas = ['A', 'B', 'C', 'D', 'E']

listas[0]  # 'A'
listas[-1] # 'E'

Alterar elementos

listas = ['A', 'B', 'C', 'D', 'E']

listas[2] = 'x' # listas = ['A', 'B', 'x', 'D', 'E']

listas = [0, 1, 2, 3, 4, 5]

listas[1:4] = ['A', 'B', 'C'] # listas = [0, 'A', 'B', 'C', 4, 5]
listas[1:4] = ['A', 'B',] # listas = [0, 'A', 'B', 4, 5]
listas[2:4] = [] # listas = [0, 1, 4, 5]

Verificação de elementos

# Verificar existência
letras = ['A', 'B', 'C', 'D', 'E']

'A' in letras # True
'F' in letras # False

Intervalo de listas (Slice)

listas[start:stop:step]
"""
Começa em start (inclui), termina em stop (exclui) e vai de step em step

Equivale a:
"""

[lista[i] for i in range(início, fim, passo)]

"""
Por padrão
start = 0
stop = len(listas)
step = 1
"""

Exemplos de uso

listas = ['A', 'B', 'C', 'D', 'E']

listas[1:3]  # 'B', 'C'
listas[:2]   # 'A', 'B'
listas[-3]   # 'C', 'D', 'E'
listas[::2]  # 'A', 'C', 'E'
listas[1::2] # 'B', 'D'
listas[::-1] # 'E', 'D', 'C', 'B', 'A'

Tamanho de listas len()

listas = ['A', 'B', 'C', 'D', 'E']

len(listas) # 5

Soma de listas

listas = [1, 2, 3, 4, 5]

soma = sum(listas) # soma = 15

Map

map(função, lista)
# Aplica uma função em todos os elementos da lista

Casting em listas c/ map()

entrada = ["1", "2", "3", "4", "5"]
entradaInt = list(map(int, entrada)) # [1, 2, 3, 4, 5]
# map aplica int em cada elemento da entrada
# list() aplica list no map

Tuplas (tuple)

# OBS: Tuplas são listas imutáveis, ou seja, uma vez criadas não permitem modificações.
tupla = (x, "y", 11, 10.5)
tupla = x, "y", 11, 10.5

a, b, c, d = tupla # a = x, b = "y", c = 11, d = 10.5
a, *b, c   = tupla # a = x, b = ["y", 11]  , c = 10.5
# OBS: Quando usamos o prefixo *, a variável recebe tudo sobrar das outras

tupla[0] # a
tupla[1] # "b"
print(tupla) # (a, "b")

Sets

# Listas desordenadas e não indexadas, mas são mais rápidos de usar o "in"
sets = {x, "y", 11, 10.5}

Operações matemáticas

Operações matemáticas podem ser feitas entre sets, gerando outro set. Elas são:

| -> União
& -> Intersecção
- -> Diferença (Itens da esquerda - itens da direita)
^ -> Diferença Simétrica (Itens que só estão em um ou outro, não ambos)

Dicionários (dict)

dicionario = {
    key: value,
    a: "b",
    "c": d
}
# OBS: A key tem que ser algo imutável

dicionario[key] # value
dicionario[a]   # "b"
dicionario["c"] # d
print(dicionario) # {key: value, a: "b", "c": d}

Métodos

Class String

Operações com strings

"Texto1" + "Texto2" # "Texto1Texto2"
"A" * 3 # "AAA"
"1" + "1" # "11"

"a" < "b" # True
# Ordem do alfabeto: ABC...XYZabc...xyz

Verificação de ocorrência

string = "Olá mundo"
"Ol" in string # True
"Do" in string # False (Case sensitive)

.startswith("Olá") # True
.startswith("mundo") # False

Acessar elementos

string[x] # Acessa o índice x da string
string[start:stop:step] # String c/ slice
# Vai de start até stoop - 1 de step em step
# Por padrão: start = 0; stop = len(string); step = 1

.index() # Retorna o index que começa o argumento
.find() # Retorna o index que começa o argumento, retorna -1 caso não encontre

Formatação

.capitalize() # Inicial maiúscula
.upper() # Todas maiúsculas
.lower() # Todas minúsculas

.strip() # Retira espaços, \n etc das extremidades
.replace("x", "y") # Retorna a string com os "x" trocados por "y"
.split(separador) # Transforma uma string em uma lista de strings, separando pelo separador
# Por padrão, separador = " " -> Espaço

"{0} {1}".format(var0, var1) # Coloca as variáveis do argumento em ordem nos placeholders {n}
"{const}".format(const = x) # Outra forma de usar
# OBS: Usada semelhantemente no print formadato de uma forma mais direta como: print(f"")

Class List

Adicionar elementos

.insert(index, elemento) # Adiciona o elemento na posição do Index

.append(elemento) # Adiciona o elemento no fim da lista

.extend(lista) # Adiciona elementos da lista "lista" no fim da lista "listas"

Remover elementos

.remove(elemento) # Remove a 1a ocorrência do elemento
# OBS: Se o elemento não estiver na lista, haverá um erro

.pop(indice) # Retorna elemento do índice e o remove da lista

Verificiar ocorrência

.index(elemento) # Retorna o índice do elemento

Contagem de ocorrência

.count(elemento) # Retorna o n° de ocorrências do elemento

Ordenação de listas

.sort() # Ordenada em ordem Crescente

.sort(reverse = True) # Ordena em ordem Decrescente

listas.reverse() # Inverte ordem da lista

Cópia de listas

listas2 = listas.copy()  # Cópia independente da lista
listas2 = sorted(Listas) # Cópia ordenada da lista, sem alterar original

Join

# Transforma uma lista de strings em uma string
string = sep.join(listas)
# sep = separador entre os elementos da lista

Class Set

Adicionar/Remover elementos

.add(elemento) # Adiciona um elemento
.remove(elemento) # Remove um elemento

Inclusão de bibliotecas

import Nome_da_biblioteca # Importa uma biblioteca
import Nome_da_biblioteca as prefix # Importa uma biblioteca com um prefixo diferente
from Nome_da_biblioteca import something # Importa algo específico de uma biblioteca

Exemplos de uso

import math

x = math.pi

from math import pi

x = pi

import math as m

x = m.pi

Funções importantes