Introdução ao Python¶

Note

Este arquivo compreende uma fugaz introdução ao python.

Este documento pretende tornar familiar, à primeira vista, contextualizações importantes e sintaxes frequentes no uso linguagem.

Espero que tão logo este documento seja parco frente a sua fome pythônica e você precise enfrentar o árduo plano das documentações :D

Variáveis

Espaço de nome

Escopo

Dados: Type e Id

Boolean

Inteiro,flutuante,complexo,string

Estrutura de Dados

Lista

Dicionário

Tuplas

String

Set

Compreensão e Expressão Geradora

Compreensão de Listas

Compreensão de dicionários

Compreensão de Conjuntos

Expressão Geradora

Manipulação das Estruturas de dados

Lista

Dicionário

Tuplas

String

Set

Built-in

Zip

Slice

Operadores

Operadores aritméticos

Operadores de atribuição

Operadores lógicos

Operadores de identidade

Operadores de Comparação

Operadores de Membro

Iterações

Condicionais

Loops

Funções

Parâmetros Ordinais e Nomeados

Funções Anônimas/Lambda

POO- Programação Orientado a Objeto

Herança

Polimorfismo

Tópicos Avançados

Expressão Regular

Referências

O que é Python?¶

Python é uma linguagem de programação! Tcharan!!!!!!

Uma linguagem de programação de alto nível arquitetada para ser, simultâneamente, compreensível e poderosa!

Criado por Guido van Rossum e lançado em 1991, a estura de controle (sintaxe) requerida pelo interpretador e a abordagem orientada a objeto auxiliam o programador a desenvolver códigos organizados e claros, sejam eles extensos ou breves.

Você pode ler mais sobre no Python.org

PARADIGMAS DE PROGRAMAÇÃO¶

O Paradigmas de programação são um conglomerado de classificações atribuidas às estruturas de código (sintaxe) que o programador utiliza. Para ser mais claro, existem diversas linguagens de programação e também diversas formas de externalizar suas soluções através delas; estas soluções resultam em uma estrutura que pode ser classificada como um determinado paradigma.

Ahhhhhhh! Mas pra quê isso?

Bem, isso é resultado de um longo período de aprimoramento das linguagens de programação! Inicialmente a programação era difícil, requeria um graaande conhecimento, sobre a linguagem e computadores, e atenção do programador pois a escrita era de baixo nível, ou seja, eram compilados de instruções diretas para o computador ( Brinca um pouquinho aqui: Código Binário ). Tudo muito complexo, específico, engessado.

Note

Exemplo de linguagem baixo nível: Código Binário, Assembly

Com a caminhar da tecnologia as demandas passaram a ser outras! Muito trabalho para pouco programador e muita criatividade para linguagens que não conseguiam acompanhar!!

Daí surgem as linguagens de alto nível! As de terceira geração seguiam o paradigma procedural, e descreviam especificamente quais procedimentos utilizar para resolver o problema em específico. E mais uma vez tudo dependia do conhecimento profundo do desenvolvedor e a programação ainda não era nada intuitiva.

Note

Exemplo de linguagem alto nível (Terceira Geração): COBOL,FORTRAN…

Observando, o nível da linguagem é dado de acordo com o grau de proximidade entre a estrutura de programação e a estrutura da nossa língua! Nesse grupo estão as linguagens C, C++, JAVA, […] e nosso amadinho PYTHON!

Voltemos aos paradigmas…

Como dito, existem diversos paradigmas! Mas neste documento focaremos em três: Programação Procedural, Programação Estruturada e a Programação Orientada a Objeto.

Programação Procedural¶

Bem como o nome diz, se trata de uma programação centrada em procedimentos. Este paradigma de programação apresenta-se comumente em scripts corridos que determinavam, diretamente, as ações a serem tomadas pelo computador.

Exemplo de código seguindo o paradigma procedural na linguagem Assembly:

 lea si, string ; Atribui SI ao endereço de string.
 call printf    ; Coloca o endereço atual na pilha e chama o processo printf

 hlt            ; Encerra o computador.
 string db "Ola mundo!", 0

 printf PROC
     mov AL, [SI] ; Atribui à AL o valor no endereço SI.
     cmp AL, 0    ; Compara AL com nulo.
     je pfend     ; Pula se comparação der igual.

     mov AH, 0Eh
     int 10h      ; Executa uma função da BIOS que imprime o caractere em AL.
     inc SI       ; Incrementa em um o valor de SI.
     jmp printf   ; Pula para o início do processo.

     pfend:
     ret          ; Retorna para o endereço na posição atual da pilha.
printf ENDP

Em python poderíamos conseguir o mesmo resultado:

print("Olá, Mundo!") #Teste aí no seu console! :D

Programação Estruturada¶

Bem como o nome diz, se trata de uma programação centrada na estrutura. Este paradigma de programação apresenta-se comumente em blocos únicos, centrados na sequência, decisão e iteração (loops, condicionais…).

Flui bem em projetos breves. Já em projetos extensos a chance de uma única alteração descarrilhar toodo o programa é relevante!

Exemplo de código seguindo o paradigma estruturado:

def soma(*args):
    resultado = 0
    for numero  in args:
        resultado += numero
        print("Soma= ", resultado)

soma(1,2,3)

Programação Orientada a Objeto (OO)¶

Python: Sintaxe Básica¶

Note

Os Tópicos abaixo, e outros mais aprofundados, podem ser encontradas na Documentação Python

Variáveis¶

#Teste esse código no seu console

nome_da_variavel = "valor da variavel"
nome_da_outra_variavel = 5362543
nome_da_outra_outra_variavel = [a,b,c,d,e,f,g,h]

#decalração de múltiplas variáveis
nome_da_variavel, nome_da_variavel_dois = "variavel_um", "variavel_dois"

"""Imprime na tela o valor da variavel"""
print(nome_da_variavel)

Warning

É indicado não começar sua variável com:

número

Warning

O python tem alguns nomes reservados:

‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’

Espaço de nome¶

“Os namespaces são uma ótima ideia - vamos fazer mais disso!” - The zen of python

Se imagine em uma sala de aula com mais 10 pessoas. 50% delas tem nome com grafia e sobrenomes idênticos e a outra metade são apenas idênticos na aparência. Seu trabalho é diferenciá-los. Qual seria sua estratégia?

O mesmO pode acontecer quando programamos. Dentro do nosso módulo é fácil criarmos um script sem nomes repetidos, porém, bem mais trabalhoso quando estamos usando módulos externos.

Tudo no python (strings, listas, funções…) é um objeto, e todo objeto recebe um id equivalente tanto para o atributo quanto para a atribuição:

#teste o código abaixo no seu console
Maria_Maia = 4
print('id(Maria_Maia) =', id(Maria_Maia)) # id 140071085578048

Maria_Maia= Maria_Maia + 1
print('id(Maria_Maia_plus_um) =', id(Maria_Maia)) # id 140071085578080
print('id(5) =', id(5)) # id 140071085578080

Josefa = 4
print('id(Josefa) =', id(Josefa)) # id 140071085578048
print('id(4) =', id(4)) # id 140071085578048

Para evitar conflitos o Python tem um sistema, nomeado namespace, para garantir que todos os nomes atribuidos aos objetos (variáveis, funções, classes…) do programa sejam exclusivos, evitando qualquer conflito. Quando você nomeia algum objeto, este passa a ser mapeado com o nome determinado, podendo, também, nomes diferentes mapearem o mesmo objeto ou nomes iguais mapearem objetos diferentes:

#teste o código abaixo no seu console
x = "Qual foi?" # namespace global
def mostra_o_X_ai():
  x = "E aiiiiiiii!" #namespace local
  print(x)

print(x) # Qual foi?
mostra_o_X_ai() # E aiiiiiiii!

Olha que situação interessante! Para o Python o que determina qual ‘X’ deve ser apresentado é o Escopo;

Escopo¶

O escopo do nome é o local onde determinada variável é acessível; sendo determinado pelo bloco de instrução a qual ele pertence.

#teste o código abaixo no seu console
zero = 0 # Bloco de instrução 0; variável global
  um = 1 # Bloco de instrução 1; variável local
   dois = 2 # Bloco de instrução 2; variável local
    .
    .
    .
                    número_indefinido = inf # Bloco de instrução n; variável local

O escopo de nome tem a função de classificar quais nomes de variáveis, funções e classes estão acessíveis em cada bloco de instrução. Quanto mais próximo de n está o escopo da variável requerida, mais restrito é o acesso a este objeto. É importante ressaltar que cada variável é global internamente ao bloco que pertence, e local externamente ao bloco que pertence. Esta definição é O escopo é importante para expressão de hierarquias.

#teste o código abaixo no seu console
VAR_GLOBAL="Bóson Treinamentos em Tecnologia"
def escreve_texto():
    VAR_LOCAL="Fábio dos Reis"
    print("Variável global: ", VAR_GLOBAL)
    print("Variável local: ", VAR_LOCAL)
print("Executando a função escreve_texto:")

escreve_texto()

print("Tentando acessar as variáveis diretamente:")
print("Variável global: ", VAR_GLOBAL)
print("Variável local: ", VAR_LOCAL) # Tentativa de chamar uma variável local como se fosse global

Fonte exemplo: Bosontreinamentos

Dados: Type e Id¶

Boolean

#teste o código abaixo no seu console
"""Booleano é um estado em python, composto de dois valores: Verdadeiro ou falso."""
print(10 > 9) # True
print(10 == 9) # False
print(10 < 9) # False

Inteiro

#teste o código abaixo no seu console

""" Numeros sem parte decimal recebem o tipo 'inteiro'(int) """
inteiro_um = 12
inteiro_dois = -45
type(inteiro_um)

Flutuante

""" Numeros com parte decimal recebem o tipo 'flutuante'(float) """
flutuante_um = 12.4
flutuante_dois = -45.6
type(flutuante_um)

Complexo

""" Numeros com parte real e imaginnária recebem o tipo 'complex'"""
complexo_um = 12+3j
complexo_dois = 15-7j
type(complexo_um)

String

""" Tudo, TUDO MESMO, que está entres aspas é string no python"""
string_um = "12+3j"
string_dois = "Oi! Espero que esteja tudo bem aí!"
type(string_um)


"""Tudo no python carrega uma identidade, um Id"""
id(insira_uma_variavel_aqui) # substitua por alguma variável qualquer

Tip

Quando estiver brincando com strings busque explorar os Metodos:

Estrutura de Dados¶

Lista

#teste o código abaixo no seu console

""" Tudo que está entre colchetes [] é lista no python"""
lista_vazia = []
lista_um = [1,2,3,[1,2,3[1,2,3]]] #quantas listas tem aqui dentro?
lista_dois = ["oi",1,4.3,4+9j]
type(lista_um)

Tip

Quando estiver brincando com listas busque explorar os Metodos:

len()

index()

append()

extend()

insert()

remove()

count()

pop()

reverse()

sort()

copy()

clear()

Dicionário

""" Tudo que tem uma chave e um valor é um dicionário no python"""
dicionario_um = {"um":"1","dois":2,"cachorro":"buldog"}
dict_vazia = {}
type(dicionario_um["um"])
type(dicionario_um["dois"])

dicionario_um.keys()
decionario_um.values()

Tupla

""" Valores entre parêntesis () são uma tupla no python. Elas são imutáveis!"""
tupla_um = (1,2,3,4,5)
tupla_vazia = (,)
type(tupla_um)

Set

""" Valores entre chaves {} são um conjunto (set) em python"""
set_um = {1,2,3,4,"5","e ae"}
type(set_um)

Manipulação das Estruturas de dados¶

Lista
Tuplas
String
Set

Compreensão e Expressão Geradora¶

Como dito anteriormente, o Python é uma linguagem poderosíssima! E alguns conceitos do python funcionam como atalhos na resolução de problemas computacionais.

Abaixo compilamos três funcionalidade muito poderosas da linguagem:

A compreensão é análoga a notação de conjuntos da matemática. Lembra?

{x ^ 2: x é um número natural menor que 10}

{x: x é um número inteiro menor que 20, x é ímpar}

{x: x é uma letra na palavra ‘MATEMÁTICA’, x é uma vogal}

Exemplo: Vooo-Insights

O tipo de compreensão dependerá do tipo de dado (Type) que você quererá como output.

Compreensão de Listas

A compreensão de listas é utilizada onde, comumente, na busca por uma lista como output, usaríamos o loop.

Logo, onde antes nós faríamos:

lista = []
for i in range(13):
    lista.append(i**2)

print(lista)

Com a compreensão de lista conseguimos atribuir a construção da mesma lista da seguinte forma:

nueva_lista = [numero**2 for numero in range(13)]
print(nueva_lista)

A Sintaxe da compreensão de lista é:

[expressão(variável) for variável in conjunto_input [predicate][, …]]

Compreensão de dicionários

Compreensão de Conjuntos

Built-in¶

Os built-ins são funções integradas ao python prontinhas para uso!

Veja mais em: BUILT-IN PYTHON.ORG

Zip

A função zip() toma como argumento iteráveis (list, dict, string…) e as agrega a uma tupla.

Sintaxe da função:

zip(*iteravel)

Aplicação da função:

#gerando as variáveis
lista_quantidade = [1, 2, 3]
lista_alimentos = ['banana', 'laranja', 'maca']
lista_qualidade =  ['estragado','maduro','verde']

#nenhum iterável foi passado
empty_zip = zip()
print(empty_zip)
# Converting iterator to list
resultado_empty_list = list(empty_zip)
print(resultado_empty_list)

# Iteraveis passados
lista_um = zip(lista_alimentos, lista_quantidade)
lista_dois = zip(lista_alimentos, lista_quantidade,lista_qualidade)


# Convertendo em conjunto de tuplas
primeiro_zip= set(lista_um)
segundo_zip = set(lista_dois)
print(primeiro_zip)
print(segundo_zip)

Tip

Os iteráveis passados podem não corresponder em quantidade! Teste no seu console:

LISTA_GRANDE=[‘UM’,’DOIS’,’TRES’,’QUATRO’]

LISTA_PEQUENA = [1,2,3]

Slice

A função slice() pode ser usado para fatiar obejtos sequenciais (strings, bytes, listas, tuplas, conjunto)…

Sintaxe da função:

slice(inicio, parar, pulo)

Aplicação da função:

result1 = slice(1)
print(result1) # default

result2 = slice(1, 5, 2)
print(slice(1, 5, 2))

LISTA_GRANDE=['UM','DOIS','TRES','QUATRO','CINCO','SEIS']

fatia_lista = slice(1) # corte no index 1
#fatia_lista = slice(0,4) # corte do index 0 ao 4
#fatia_lista = slice(0,-1,2) # corte do index 0 ao ultimo index pulando 2
print(LISTA_GRANDE[fatia_lista])

Operadores¶

Os operadores python servem para designar relações entre as variáveis desejadas.

Veja alguns exemplos abaixo:

Operadores aritméticos

OPERADORES ARITIMÉTICOS
OPERADOR	TIPO	VALOR \| EXEMPLO
+	Adição	Realiza a soma entre dois valores.	10+7+4
-	Subtração	Realiza a subtração entre dois valores.	-10-7-4
*	Multiplicação	Realiza a multiplicação entre dois valores.	3*4
/	Divisão	Realiza a divisão entre dois valores.	10/5
//	Divisão	Retorna a parte inteira da divisão	10//5
%	resto	Retorna o resto da divisão entre dois valores.	4%2
**	Exponenciação	Multiplicação de um número por ele mesmo n vezes	4**2

# Teste esse código no seu console!
n = 2
z = 4

a = n+z
b = n-z
c = n*z
d = n/z
e = n%z
f = n**z

print(a)

Operadores de atribuição

Os Operadores de Atribuição Compostos realizam uma operação e em seguida, atribuem o resultado da operação para a variável que está a esquerda do operador de atribuição.

OPERADORES DE ATRIBUIÇÃO
OPERADOR	TIPO	VALOR
=	igualdade	Atribui à variável da esquerda o valor à direita
+=	Adição	Realiza a soma entre dois valores.
-=	Subtração	Realiza a subtração entre dois valores.
*=	Multiplicação	Realiza a multiplicação entre dois valores.
/=	Divisão	Realiza a divisão entre dois valores.
%=	Módulo	Retorna o resto da divisão entre dois valores.
**	Exponenciação	Multiplicação de um número por ele mesmo n vezes
&=		Equivale a a = a & 8

# Teste esse código no seu console!
n = 2
z = 4

n += z # resultado igual a 6
n -= z # resultado igual a -2
n *= z # resultado igual a 8
n /= z
n %= z
n **= z

print(a)

Operadores lógicos

Os operadores lógicos unem expressões lógicas retornando um valor lógico binário compreendido entre não atendimento da lógica (Falso) ou atendimento da lógica (Verdadeiro). Este tipo de dado (sim e não, zero e um, verdadeiro e falso) é chamado Booleano e, no python, as constantes True e False são reconhecidas como pertencentes ao tipo de dado bool:

#Teste no seu console
type(True) # <class 'bool'>
type(False) # <class 'bool'>
type(1 == 1) # <class 'bool'>

OPERADORES LÓGICOS
OPERADOR	VALOR	RESULTADO
and	True se as duas expressões forem verdadeiras	Se a primeira expressão é verdadeira, o resultado será a segunda expressão.
or	False se, e somente se, duas expressões forem falsas	Se a primeira expressão é falsa, o resultado seré a segunda expressão.
not	Muda o valor do argumento: not True é False, not False é True	Booleano
in	True se receber um o item a ser verificado	Booleano

Combinações And:

AND	False	True
False	False	False
True	False	True

Combinações Or:

OR	False	True
False	False	True
True	True	True

#Teste no seu console
print("0 and 1:", bool(0 and 1))
print(0 and 1)
print("\n")

print("1 and 0:", bool(1 and 0))
print(1 and 0)
print("\n")

print("0 and 2:",bool(0 and 2))
print(0 and 2)
print("\n")

print("2 and 0:",bool(2 and 0))
print(2 and 0)
print("\n")

print("1 and 2:",bool(1 and 2))
print(1 and 2)
print("\n")

print("3 and 2:",bool(3 and 2))
print(2 and 3)
print("\n")

print("0 or 1:", bool(0 or 1))
print(0 or 1)
print("\n")

print("0 or 0:", bool(0 or 0))
print(0 or 0)
print("\n")

print("\n")
print("not 0:", bool(not 0))
print(not 0)

print("\n")
print("not 1:", bool(not 1))
print(not 1)
print("\n")

print(2 in (2, 3)) # Saída True
print(2 is 3) # Saída False

Note

#SyntaxWarning: “is” with a literal add ao python 3.8 O compilador agora produz um SyntaxWarning quando as verificações de identidade (is e is not) são usadas com certos tipos de literais (por exemplo, strings, números). Muitas vezes, eles podem funcionar por acidente no CPython, mas não são garantidos pela especificação da linguagem. O aviso aconselha os usuários a usarem testes de igualdade (== e! =). (Contribuição de Serhiy Storchaka em bpo-34850.)

#Teste no seu console
print('1. Idoso')
print('2. Gestante')
print('3. Cadeirante')
print('4. Nenhum destes')
resposta=int( input('Você é: ') )

if (resposta==1) or (resposta==2) or (resposta==3) :
    print('Você tem direito a fila prioritária')
else:
    print('Você não tem direito a nada. Vá pra fila e fique quieto')

Exemplo resgatado em Python Progressivo

#Teste no seu console
mes= input('Qual o mês?')
dia_um= int(input('Que dia é hoje?'))
dia_dois= int(input('Que dia é amanhã?'))

if dia_um and dia_dois < 30 :
  print("Ainda estamos em", mes)
else:
  print("Estamos próximos do próximo mês!")

int_x = int(input("Manda um inteiro aí!"))

int_y = int(input("Manda outro aí!"))

if (int_x == 10) or (int_y < 20):

    print("Uma das duas expressões é verdadeira!")

else:

    print("Ambas são falsas!")

Operadores de identidade

OPERADORES DE IDENTIDADE
OPERADOR	VALOR
is	Retorna verdadeiro quando as variáveis são idênticas (referem-se ao mesmo objeto)
is not	Retorna verdadeiro quando as variáveis nãp são idênticas (variáveis que não se referem ao mesmo objeto)

#Teste esse código no seu console
a = 3
b = 3
print(a is b) #True
print(a is not b) #False

Operadores de comparação

OPERADORES COMPARATIVOS
OPERADOR	VALOR	RESULTADO
>	True se o valor à esquerda é maior que o valor a direita	Se a primeira expressão é verdadeira, o resultado será a segunda expressão.
<	True se o valor à esquerda é menor que o valor a direita	Se a primeira expressão é falsa, o resultado seré a segunda expressão.
==	True se o valores à esquerda e a direita são equivalentes	Booleano
!=	True se o valor à esquerda é diferente ao da direita	Booleano
>=	True se o valor à esquerda é maior ou igual ao da direita	Booleano
<=	True se o valor à esquerda é menor ou igual ao da direita	Booleano

#Teste esse código no seu console
a = 3
b = 3
print(a>b) #True
print(a==b) #False

Operadores de Membro

OPERADORES DE MEMBROS
OPERADOR	VALOR
in	True se o valor está contido do conjunto investigado
not in	True se o valor não está contido no conjunto investigado

a = 10
b = 2
list = [1, 2, 3, 4, 5 ];

if ( a in list ):
  print ("a - esta na lista")
else:
  print ("a - não está na lista")

if ( b not in list ):
  print ("b - não está na lista")
else:
  print ("b - está na lista")

Iterações¶

Iterar é repetir algo.

CONDICIONAIS

São estruturas que executam a verificação de estados com base nos argumentos passados.

As verificações são feitas pelos operadores condicionais que comparam os valores passados e retornam Verdadeiro ou Falso.

SE condição

ENTÃO comando

Veja alguns abaixo:

OPERADORES CONDICIONAIS
OPERADOR	TIPO	VALOR
==	Igualdade	Verifica a igualdade entre dois valores.
!=	Igualdade	Verifica a diferença entre dois valores.
>	Comparação	Verificar se o valor A é maior que o valor B.
<	Comparação	Verifica se o valor A é menor que o valor B.
>=	Comparação	Verifica se o valor A é maior ou igual ao valor B.
<=	Comparação	Verifica se o valor A é menor ou igual ao valor B.
In	Seqüência	Verifica se o valor A está contido em um conjunto.

A sintaxe de uma condicional simples é:

if operacao > valor_comparativo:
  print("operacao é maior que valor_comparativo") # Observe a identação!!

A sintaxe de uma condicional composta é:

if operacao > valor_comparativo:
  print("operacao é maior que valor_comparativo")
else:
  print("operacao não é maior que valor_comparativo")

A sintaxe de uma condicional aninhada é:

if operacao > valor_comparativo:
  print("operacao é maior que valor_comparativo")
elif operacao = valor_comparativo:
  print("operacao é igual que valor_comparativo")
else:
  print("operacao não é maior que valor_comparativo")

LOOP FOR

Os Loops são laços de repetição (iterações) através de sequências (listas, tuplas, dicionários, conjuntos, strings…).

Com os loops é possível executar um conjuntos de instruções para cada item de um iterável.

Exemplos simples abaixo:

animais = ["leão", "macaco", "águia"]
for x in animais:
    print(x)

for x in "paralelepipedo":
   print(x)

Declaração de quebra:

# Pause o print de x quando x for macaco
caco = ["leão", "macaco", "águia"]
for x in caco:
    if x == "macaco":
       break
    print(x) #leão

Declaração de continuação:

caco = ["leão", "macaco", "águia"]
for x in caco:
  if x == "macaco":
    continue
  print(x)

Listas aninhadas:

 lista = [[1,2,3,4,5],[6,7,8,9],[10,11,12],[13,14,15]]

#print da lista
for x in lista:
    print(x)

 #print das listas aninhadas
 for x in lista:
    for y in x:
      print(y)

Uso de funções:

for x in range(9):
  print(x)

LOOP WHILE

  i = 1
while i < 6:
  print(i)
  if i == 3:
    break
  i += 1

Funções¶

Na programação a função é um bloco de código que realiza determinada tarefa que precisam ser executadas diversas vezes ou em momentos específicos.

A estrutura da função requer nome da função, parâmetro e um corpo que representa o comportamento da função.

Nome da função: É um nome arbitrário e será usado para chamar a função.
parâmetro: São os valores necessários para que o comportamento seja possível. O parâmetro pode ser uma lista, string, número… dependerá do comportamento esperado para a função.
corpo: Corpo é a instrução da função. É as ações que ela deverá tomar sobre os parâmetros parâmetros passados.

#estrutura da função
def nome_da_função(parâmetro): # def é um termo reservado do python para dizer que é uma função
    corpo
    corpo
    corpo

Warning

Observe o Escopo do corpo da função. A identação é interna ao def.

Observe o exemplo de função abaixo:

# A função 'diga_o_nome' imprime sempre o nome que for digitado
def diga_o_nome(nome): # 'diga_o_nome é o Nome da função; 'nome' é o parâmetro da função
    print(nome)        # função python print() é o corpo da função

diga_o_nome("Gabriela") #observe como a função é chamada.
                        # "Gabriela" é o ARGUMENTO da função 'diga_o_nome'

Note

Os parâmetros chamam-se parâmetro no cabeçalho da função. Quando chamamos a função, como em diga_o_nome_("Gabriela"), o valor que fica dentro do parêntesis é chamado argumento.

Você pode criar funções que não requerem parâmetros. Estas funções sempre retornarão o mesmo resultado.

# A função 'diga_o_nome' imprime sempre o nome que for digitado
def diga_o_nome(): # 'diga_o_nome é o Nome da função
    nome = Gabriela    # observe que na ausência de parâmetros alguns valores precisam ser declarados
    print(nome)        # função python print() é o corpo da função

diga_o_nome() #observe como a função é chamada

Como dito acima, as funções também são usadas quando determinados comportamento só deve ser chamado em horas oportunas. Observe o código abaixo:

Tip

Teste o código abaixo no seu console!

# Operação fora da função

# o código:
n1 = int(input('Chuta um número:'))
n2 = int(input('Chuta mais um número'))
soma = n1 + n2
print("O resultado:", soma)

# Mesma operação dentro da função
def soma_FUN():
    n1 = int(input('Digite o Primeiro Número:'))
    n2 = int(input('Digite o Segundo Número:'))
    print("O resultado da função soma_FUN:", n1 + n2)

soma_FUN()

Funções Anônimas/Lambda¶

Uma forma mais elegante de programar é a construção de funções lambda ou função anônima.

A função lambda tem a seguinte sintaxe:

lambda argumentos da função: expressão/ação da função

Observe o exemplo abaixo:

dobro = lambda x: x*2
print(dobro(5))

Parâmetros Ordinais e Nomeados¶

Retomando, parâmetros são valores que serão utilizados pelo corpo da função para exercer alguns comportamentos. Quando a função não pede parâmetros, geralmente, as variáveis do corpo exercem tal função.

O parâmetros podem ser ordinais ou nomeados, ou seja, dependentes da posição ou do nome. Por exemplo: centagem

# Uma função que calcula a porcentagem de um valor.
def porcento(valor,porc=100):
    print(valor*(porc/100))


porcento(100) # 100
porcento(100,50) # 50

a função porcento pede: parâmetro ordinal valor e o parâmetro nomeado porc que, por ser nomeado, é o valor padrão/default da função, ou seja, sempre que chamarmos a função o argumento porc = 100

Vejamos um outro exemplo:

# Uma função que calcula descontos e porcentagens acumulativas.
def porcento_desconto(valor,descnt,porc=100):
    prctgm = valor*(porc/100)
    print(int(prctgm-(prctgm*(descnt/100)))) # o int() é uma função python que retorna apenas os valores sem a casa decimal (inteiros).


porcento_desconto(100) # TypeError: porcento() missing 1 required positional argument: 'descnt'
porcento_desconto(100,0) # 100
porcento_desconto(0,100) # 0
porcento_desconto(100,50) # 50
porcento_desconto(100,50,50) # 25

Tip

Observe que no caso de parâmetros ordinais a ordem do chamado importa no resultado!!!!

Na função porcento pede: o parâmetro ordinal valor, o parâmetro ordinal descnt, e o parâmetro nomeado porc que torna 100 o valor padrão/default da função.

Warning

Todo parâmetro ordinal precisa ser passado no chamamento da função.

Veja alguns exemplos de funções python: Funções Python

POO- Programação Orientado a Objeto¶

TUDO NO PYTHON É OBJETO!

Grave esta frase. Retomaremos ela mais tarde.

Herança¶

Polimorfismo¶

Tópicos Avançados¶

Bem-vindo a seção de tópicos avançados!!

Não se assuste. Não é um espaço para tópicos difíceis, são apenas tópicos que requerem um conhecimento sólido sobre os tipos de dados e estruturas sintáticas que ele utiliza.

EXPRESSÃO REGULAR (RE)

Expressões regulares (chamadas REs, ou regexes ou padrões de regex) são essencialmente uma pequena linguagem de programação altamente especializada embutida em Python e feita disponível através do re módulo. Através das expressões regulares é possível encontrar facilmente sequências, padrões, dentro de uma string.

Fonte: Python org

Imagine um stencil com padrão ABC:

Agora imagine uma string como esta abaixo:

texto = """ fbusfGFHHFdhbsfhbsjfjjfgjjbFHFHFHFGHsahbdshdFHFGJFGJFGHFGHFHbsfgjgjsfjjsfD
            GhjshdvuvJfghfgjsgfgjfgjjjADABCHJFJFGFHFHHFHHgshfgjJdfhhHFHFHFGHFGsfghggDG
            FDGHJHGjhfhgHGFHJGFhgfhgfhgfHFHGHGChgchgchgcCHGHjhvhvhgCHGCHJGChgcjhgcJHGCH
        """

Como você faria para descobrir se o padrão do stencil ABC está na string texto?

Existem diversas formas: iterações, fatiamento de string e lista, built-in zip, etc. E há a expressão regular!

Ao utilizar o re a pergunta que queremos responder é: “Essa string corresponde a este padrão?” ou “Existe algum lugar nesta string que corresponda a este padrão?”. O re também pode ser utilizados para manipular strings!

Antes de prosseguirmos deixe-me familiar você a alguns detalhes:

METACARACTERES

Em sua grande maioria as letras e os caracteres correspondem a si mesmos. Por exemplo, a letra a corresponderá a qualquer letra a presente na string “Eu fui à feira e não sabia o que comprar, sabia que havia esquecido a lista” independente de ser o a que você procura!

string = "Eu fui à feira e não sabia o que comprAr, sabia que havia esquecido a lista"
stencil = "a"

print(stencil in string, string.count(stencil)) #True, 9
# Observe que a letra maiúscula foi ignorada pelo método count

Mas há desvios nesta esta regra, os metacaracteres não correpondem a si mesmo mas sim a marcadores de exceções.

Os metacaracteres são os marcadores do seu stencil:

METACARACTERES
METACARACTER	VALOR	EXPRESSÃO
[]	Corresponde a uma lista de ocorrências dos caracteres desejados	[ABC]; [A-E]`equivale a [ABCDE]; `[^ABC] complementa excluindo o set
.	Corresponde a uma string de acordo com a quantidade de pontos	. ; ..
^	Corresponde a string que inicia com determinado caracter ou sequência	^A; ^bE
$	Corresponde a string que termina com certo conjunto de caractere	A$; ^bE$`
*	Verifica zero ou mais correspondências do caracterer à esquerda	ma*n
+	Verifica uma ou mais correspondências da ordem à esquerda	ma+n
?	Verifica zero ou uma correspondência de ordem à esquerda	ma?n
{}	Verifica repetições em uma string	a{n,m} onde n e m correspondem, respectivamente, o mínimo e o máximo
()	Verifica subpadrões	(a\|b\|c)xz combina qualquer string que corresponda a abc seguida de xz
\	Esta folga é usada para “escapar” de caracteres e matacaracteres	$ torna o matacaracter $ em um caracter comum
\|	Verifica alternâncias	a\|b

Algumas sequências especiais tornam alguns padrões mais fáceis e escrever:

SEQUENCIAS ESPECIAIS
SEQUÊNCIAS ESPECIAIS	VALOR
\A	Verifica se uma string começa com determinado conjunto de caracteres
\b	Corresponde aos caracteres que estão no início ou final
\B	É o oposto de b
\d	Corresponde a qualquer dígito decimal. Equivale a [0-9]
\D	Corresponde a qualquer dígito não decimal. Equivale a [^0-9]
\s	Corresponde a uma string que contenha caracter de espaço e branco
\S	Corresponde a string que não correspondente ao espaço em branco
\W	Verifica presença de qualquer caracter não alpha-numérico
\Z	Corresponde a caracteres específicos no final de uma string

Sigamos para alguns casos de uso dos metacaract:

import re

string = 'Ola! Eu tenho 26 anos e carrego 2 bolsas'
#pattern = '[aeiou]' # ['a', 'u', 'e', 'o', 'a', 'o', 'e', 'a', 'e', 'o', 'o', 'a']
#pattern = '[^aeiou]'#['O', 'l', '!', ' ', 'E', ' ', 't', 'n', 'h', ' ', '2', '3', ' ', 'n', 's', ' ', ' ', 'c', 'r', 'r', 'g', ' ', '2', ' ', 'b', 'l', 's', 's']
#pattern = '[a-c]' # ['a', 'a', 'c', 'a', 'b', 'a']
#pattern = '.....' # ['Ola! ', 'Eu te', 'nho 2', '3 ano', 's e c', 'arreg', 'o 2 b', 'olsas']

result = re.findall(pattern, string)
print(result)

import re

string = 'Ola! Eu tenho 26 anos e carrego 2 bolsas'
pattern = 'sasxvdv$' # ['sas']
pattern = '[sas$]' # ['a', 'a', 's', 'a', 's', 'a', 's']
pattern = 'sasuie #' # []

result = re.findall(pattern, string)
print(result)

import re

string = "The rain in Spain falls maizly in the plain!"
pattern = 'ain*' #['ain', 'ain', 'ai', 'ain']
pattern = 'ai*n' #['ain', 'ain', 'ain']
pattern = 'a*in' #['ain', 'in', 'ain', 'in', 'ain']
pattern = 'ainhehe' #[]

result = re.findall(pattern, string)
print(result)

import re

string = "The rain in Spain falls maizly in the plain!"
#pattern = 'ain+' #['ain', 'ain', 'ain']
#pattern = 'ai+n' #['ain', 'ain', 'ain']
#pattern = 'a+in' # ['ain', 'ain', 'ain']
#pattern = a+isdsf

result = re.findall(pattern, string)
print(result)

import re

string = "aaaaaah! The rain in Spaain falls maizly in the plaaaaain!"
pattern = 'a{1,5}' #['aaaaa', 'a', 'a', 'aa', 'a', 'a', 'aaaaa']
pattern = 'a{5}' #['aaaaa', 'aaaaa']

result = re.findall(pattern, string)
print(result)

import re

string = "The rain in Spain falls maizly izamly zamily in the plain!"
#pattern = '(maiz)ly' #['maiz'] pois existe apenas uma correspondencia dessa ordem seguida de `ly`
#pattern = '(m|a|i|z)ly' #['z', 'm', 'i']

result = re.findall(pattern, string)
print(result)

import re

string = "The rain in Spain falls maizly izamly zamily in the plain!"
pattern = 'a|i' #['a', 'i', 'i', 'a', 'i', 'a', 'a', 'i', 'i', 'a', 'a', 'i', 'i', 'a', 'i']
#pattern = 'e|a|i' #['e', 'a', 'i', 'i', 'a', 'i', 'a', 'a', 'i', 'i', 'a', 'a', 'i', 'i', 'e', 'a', 'i']


result = re.findall(pattern, string)
print(result)

import re

string = "The rain in Spain falls maizly 9 izamly zamily in the plain!"
pattern = '\AThe'
pattern = '\Arain'
pattern = '\d' # ['9']
pattern =  '\D' #  ['T', 'h', 'e', ' ', 'r', 'a', 'i', 'n', ' ', 'i', 'n', ' ', 'S', 'p', 'a', 'i', 'n', ' ', 'f', 'a', 'l', 'l', 's', ' ', 'm', 'a', 'i', 'z', 'l', 'y', ' ', ' ', 'i', 'z', 'a', 'm', 'l', 'y', ' ', 'z', 'a', 'm', 'i', 'l', 'y', ' ', 'i', 'n', ' ', 't', 'h', 'e', ' ', 'p', 'l', 'a', 'i', 'n', '!']

result = re.findall(pattern, string)
print(result)

import re

string = "Therain"
pattern = \s #[]

result = re.findall(pattern, string)
print(result)

string_2 = "The rain"
pattern_2 = '\S' # ['T', 'h', 'e', 'r', 'a', 'i', 'n']

result_2 = re.findall(pattern_2, string_2)
print(result_2)

import re

string = "The rain * ^%$"
pattern = '\W' # [' ', ' ', '*', ' ', '^', '%', '$']

result = re.findall(pattern, string)
print(result)

import re

string = "The rain"
pattern = 'rain\Z' # ['rain']

result = re.findall(pattern, string)
print(result)

Vamos para os métodos do módulo:

re.findall()

Retorna uma lista de strings contendo todas as correspondências.

import re

    string = 'Ola! Eu tenho 26 anos e carrego 2 bolsas'
    #pattern = '[aeiou]' # ['a', 'u', 'e', 'o', 'a', 'o', 'e', 'a', 'e', 'o', 'o', 'a']
    #pattern = '[^aeiou]'#['O', 'l', '!', ' ', 'E', ' ', 't', 'n', 'h', ' ', '2', '3', ' ', 'n', 's', ' ', ' ', 'c', 'r', 'r', 'g', ' ', '2', ' ', 'b', 'l', 's', 's']
    #pattern = '[a-c]' # ['a', 'a', 'c', 'a', 'b', 'a']
    #pattern = '.....' # ['Ola! ', 'Eu te', 'nho 2', '3 ano', 's e c', 'arreg', 'o 2 b', 'olsas']

    result = re.findall(pattern, string)
    print(result)

re.split()

Divide a string onde há correspondência e retorna uma lista de strings onde as divisões ocorreram.

import re

string = "The rain 15 pain 20 spain"
pattern = '\d' # ['rain']

result = re.split(pattern, string) # ['The rain ', '', ' pain ', '', ' spain']
#result = re.split(pattern, string, 2) # ['The rain ', '', ' pain 20 spain']
print(result)

Tip

No casos onde o padrão não é encontrado, o split retorna um lista contendo a string original

Tip

O método split() suporta o argumento maxsplit que retornará o número máximo de divisões que ocorrerão.

re.sub

#sintaxe do método
re.sub(pattern, replace, string)

Retorna uma string em que todas as ocorrências correspondentes são subtituídas pelo conteúdo da variável substituta.

import re

string = "The rain 15 pain 20 spain"
pattern = '\s+' # ['rain']
replace = ''

result = re.sub(pattern,replace, string) # Therain15pain20spain
#result = re.sub(pattern,replace, string,2) # este quarto argumento permite ao método substituir apenas nas "n" primeiras ocorrências
print(result)

É possível também passar a contagem como um quarto parâmetros. Seu default é 0, retornando todas as ocorrências.

re.subn()

É semelhante ao método anterior,porém retorna uma tupla de 2 itens: (nova string, número de substituições)

import re

string = "The rain 15 pain 20 spain"
pattern = '\s+' # ['rain']
replace = ''

result = re.subn(pattern,replace, string)
print(result) # ('Therain15pain20spain', 5)

re.search()

O método search() procura um padrão em uma string. Ao encontrar o primeiro lugar, faz-se uma correspondência com a string. Se bem sucedido retorna um objeto de correspondências, do contrário retorna None.

import re

string = "The rain 15 pain 20 spain"
pattern = 'rain' # ['rain']


result = re.search(pattern,string)
print(result) # <re.Match object; span=(4, 8), match='rain'>

Expressão Regular no doc python: `Doc_Python Re`_

Introdução ao Python¶

ÍNDICE¶

O que é Python?¶

PARADIGMAS DE PROGRAMAÇÃO¶

Programação Procedural¶

Programação Estruturada¶

Programação Orientada a Objeto (OO)¶

Python: Sintaxe Básica¶

Variáveis¶

Espaço de nome¶

Escopo¶

Dados: Type e Id¶

Estrutura de Dados¶

Manipulação das Estruturas de dados¶

Compreensão e Expressão Geradora¶

Built-in¶

Operadores¶

Iterações¶

Funções¶

Funções Anônimas/Lambda¶

Parâmetros Ordinais e Nomeados¶

POO- Programação Orientado a Objeto¶

Herança¶

Polimorfismo¶

Tópicos Avançados¶

Referências¶

Tutorial Vitollino ¶

Introdução ao Python¶

ÍNDICE¶

O que é Python?¶

PARADIGMAS DE PROGRAMAÇÃO¶

Programação Procedural¶

Programação Estruturada¶

Programação Orientada a Objeto (OO)¶

Python: Sintaxe Básica¶

Variáveis¶

Espaço de nome¶

Escopo¶

Dados: Type e Id¶

Estrutura de Dados¶

Manipulação das Estruturas de dados¶

Compreensão e Expressão Geradora¶

Built-in¶

Operadores¶

Iterações¶

Funções¶

Funções Anônimas/Lambda¶

Parâmetros Ordinais e Nomeados¶

POO- Programação Orientado a Objeto¶

Herança¶

Polimorfismo¶

Tópicos Avançados¶

Referências¶

Tutorial Vitollino¶

Tutorial Vitollino ¶