sexta-feira, 4 de dezembro de 2020

Namespaces e escopo em Python

O que é namespace?

Um namespace é um sistema que tem um nome exclusivo para cada objeto em Python. Um objeto pode ser uma variável ou um método. O próprio Python mantém um namespace na forma de um dicionário Python. Vejamos um exemplo, uma estrutura de sistema de arquivos de diretório em computadores. Nem é preciso dizer que é possível ter vários diretórios com um arquivo com o mesmo nome dentro de cada diretório. Mas pode-se ser direcionado para o arquivo, se desejar, apenas especificando o caminho absoluto para o arquivo. Exemplo em tempo real, a função de um namespace é como um sobrenome. Pode-se não encontrar uma única “Alice” na classe, pode haver várias “Alice”, mas quando você pede particularmente “Alice Lee” ou “Alice Clark” (com um sobrenome), haverá apenas uma (desde que não ache que o nome e o sobrenome são os mesmos para vários alunos).

Em linhas semelhantes, o interpretador Python entende para qual método ou variável exata alguém está tentando apontar no código, dependendo do namespace. Portanto, a divisão da palavra em si fornece um pouco mais de informação. Seu Nome (que significa nome, um identificador único) + Espaço (que fala algo relacionado ao escopo). Aqui, um nome pode ser de qualquer método ou variável Python e o espaço depende do local de onde está tentando acessar uma variável ou um método.

Tipos de namespaces

Quando o interpretador Python é executado exclusivamente sem módulos, métodos, classes, etc. definidos pelo usuário. Algumas funções como print(), id() estão sempre presentes, elas são construídas em namespaces. Quando um usuário cria um módulo, um namespace global é criado, a criação posterior de funções locais cria o namespace local. O namespace integrado abrange o namespace global e o namespace global abrange o namespace local.

Vida útil de um namespace

O tempo de vida de um namespace depende do escopo dos objetos; se o escopo de um objeto terminar, o tempo de vida desse namespace chega ao fim. Portanto, não é possível acessar objetos de namespace interno a partir de um namespace externo.

Exemplo:

# var1 está no namespace global
var1 = 5
def alguma_função():
    # var2 está no namespace local
    var2 = 6
    def alguma_função_interna():
        # var3 está no namespace local aninhado 
        var3 = 7

Conforme mostrado na figura a seguir, o mesmo nome de objeto pode estar presente em vários namespaces, pois o isolamento entre o mesmo nome é mantido por seu namespace.

Mas em alguns casos, pode-se estar interessado em atualizar ou processar apenas a variável global, conforme mostrado no exemplo a seguir, deve-se marcá-la explicitamente como global e a atualização ou processo.

# Programa Python processando variável global
count = 5
def algum_método():
    global count
    count = count + 1
    print(count)

algum_método()

Resultado:

6

Escopo de objetos em Python

O escopo se refere à região de codificação a partir da qual um determinado objeto Python está acessível. Consequentemente, não se pode acessar qualquer objeto particular de qualquer lugar do código, o acesso deve ser permitido pelo escopo do objeto.

Vamos dar um exemplo para ter uma compreensão detalhada do mesmo:

Exemplo 1:

# Programa Python mostrando um escopo de objeto 
def alguma_função():
    print("Dentro de alguma_função")
    def alguma_função_interna():
        var = 10
        print("Função dentro de função, valor de var:", var)
    alguma_função_interna()
    print("Tente imprimir var da função externa: ", var)

alguma_função()

Resultado:

Dentro de alguma_função
Função dentro de função, valor de var: 10
Traceback (most recent call last):
  File "c:/Users/user/Desktop/geeksforgeeks/teste.py", line 22, in <module>
    alguma_função()
  File "c:/Users/user/Desktop/geeksforgeeks/teste.py", line 20, in alguma_função
    print("Tente imprimir var da função externa: ", var)
NameError: name 'var' is not defined

Artigo escrito por Shivam Dhanadhya e melhorado por wwwchetanranecr7
Traduzido por Acervo Lima de Namespaces and Scope in Python



Palavras-chave em Python - Parte 2

Mais palavras-chave:

try: Esta palavra-chave é usada para tratamento de exceção, usada para capturar os erros no código usando a palavra-chave except. O código no bloco “try” é verificado, se houver algum tipo de erro, o bloco except é executado.

except: Como explicado acima, isso funciona junto com try para capturar exceções.

raise: Também usado para tratamento de exceções para levantar exceções explicitamente.

finally: Não importa se ouve erros no bloco “try”, o bloco denominado “finally” é sempre executado.

for: Esta palavra-chave é usada para controlar o fluxo e criar um looping.

while: tem um funcionamento semelhante ao “for”, usado para controlar o fluxo e para fazer loop.

pass: É a instrução nula em python. Nada acontece quando isso é encontrado. Isso é usado para evitar erros de indentação e usado como um espaço reservado. É muito utilizado para criar uma função que ainda não tem uma implementação.

import: Esta instrução é usada para incluir um módulo específico no programa atual.

from: Geralmente usado com importação, from é usado para importar uma funcionalidade específica do módulo importado.

as: Esta palavra-chave é usada para criar um alias para o módulo importado. Ou seja, dar um novo nome ao módulo importado. Por exemplo, import math as mymath.

lambda: Esta palavra-chave é usada para fazer funções de retorno embutidas sem nenhuma instrução permitida internamente.

return: Esta palavra-chave é usada para retornar um valor quando uma função é chamada.

yield: Esta palavra-chave é usada como declaração de retorno, mas é usada para retornar um gerador. Básicamente essa palavra chave cria uma lista e retorna essa lista.

with: Esta palavra-chave é usada para envolver a execução do bloco de código dentro dos métodos definidos pelo gerenciador de contexto. Essa palavra-chave não é muito usada na programação do dia a dia.

in: Esta palavra-chave é usada para verificar se um contêiner contém um valor. Essa palavra-chave também é usada para percorrer o contêiner.

is: Esta palavra-chave é usada para testar a identidade do objeto, ou seja, para verificar se ambos os objetos ocupam o mesmo local de memória ou não.

# Código Python para demonstrar o
# funcionamento de "in" e "is" 
  
# usando "in" para verificar
if 'm' in 'Acervo Lima': 
       print ("m esta presente em Acervo Lima") 
else : print ("m não esta presente em Acervo Lima") 
  
# usando in em um loop for
for i in 'Acervo Lima': 
    print (i,end=" ") 
  
print ("\r") 
      
# usando "is" para verificar a identidade de um objeto
# strings são imutaveis
# (não podem ser modificadas depois de criadas)
# verifica se ocupam o mesmo espaço na memória
# (é o mesmo objeto com nomes diferentes)
print (' ' is ' ') 
  
# usado para verificar a identidade do objeto
# dicionário é mutável (pode ser alterado depois de criado)
# portanto, ocupa um local de memória diferente 
print ({} is {}) 

Saída:

m esta presente em Acervo Lima

A c e r v o L i m a

True

False

global: esta palavra-chave é usada para definir uma variável dentro da função como sendo de escopo global.

non-local: esta palavra-chave funciona de forma semelhante a global, mas ao invés de global, esta palavra-chave declara uma variável para apontar para uma variável de função envolvente externa, no caso de funções aninhadas.

# Código python para demonstrar o funcionamento de 
# global e non local 

# inicializando variável globalmente 
a = 10

# usado para ler o valor da variável
def read():
    print(a) 

# alterando o valor da variável definida globalmente 
def mod1():
    global a
    a = 5

# altera o valor apenas da variável local 
def mod2():
    a = 15

# lendo o valor inicial de a 
# imprimi 10 
read()

# chamando a função mod1 para modificar o valor
# modifica o valor de a global para 5 
mod1()

# lendo valor modificado 
# imprime 5 
read()

# chamando a função mod2 para modificar o valor
# modifica o valor de a local para 15, não afeta o valor global 
mod2()

# lendo valor modificado 
# imprime 5 novamente 
read()

# demonstrando não local
# loop interno alterando o valor de a externo
# imprime 10 
print ("O valor de a nonlocal é: ",end="")
def outer():
    a = 5
    def inner():
        nonlocal a
        a = 10
    inner()
    print(a)

outer()

# demonstração sem non local 
# o loop interno não alterar o valor de a fora
# imprime 5 
print("O valor de a sem usar nonlocal é: ", end="")
def outer():
    a = 5
    def inner():
        a = 10
    inner()
    print (a)

outer()

Saída:

10
5
5
O valor de a nonlocal é: 10
O valor de a sem usar nonlocal é: 5

Artigo escrito por Manjeet Singh (S. Nandini)
Traduzido por Acervo Lima de Keywords in Python | Set 2

Palavras-chave em Python - Parte 1

Este artigo tem como objetivo fornecer uma visão detalhada dessas palavras-chave:

True: esta palavra-chave é usada para representar o valor booleano verdadeiro. Se uma afirmação for verdadeira, “True” será impresso.

False: esta palavra-chave é usada para representar o valor booleano falso. Se uma declaração for falsa, “False” será impresso. True e False em python são iguais a 1 e 0. Exemplo:

print (False == 0)
print (True == 1)

print (True + True + True)
print (True + False + False)

None: Esta é uma constante especial usada para denotar um valor nulo ou vazio. É importante lembrar, 0, qualquer contêiner vazio (por exemplo, lista vazia) não é computado como None. É um objeto do tipo de dados - NoneType. Não é possível criar vários objetos None e atribuí-los a variáveis.

and: Este é um operador lógico em python. and Retorna o primeiro valor falso. Se não for encontrado, retorne por último. A tabela verdade para “and” é mostrada abaixo.

3 and 0 retorna 0
3 and 10 retorna 10
10 or 20 or 30 or 10 or 70 retorna 10

As instruções acima podem ser um pouco confusas para um programador vindo de uma linguagem como C, onde os operadores lógicos sempre retornam valores booleanos (0 ou 1). As linhas a seguir são retiradas da documentação do python explicando isso:

A expressão x and y primeiro avalia x; se x for falso, seu valor será retornado; caso contrário, y é avaliado e o valor resultante é retornado. A expressão x or y primeiro avalia x; se x for verdadeiro, seu valor será retornado; caso contrário, y é avaliado e o valor resultante é retornado.

Observe que and e or não restringem o valor e o tipo que eles retornam para False ou True, mas, em vez disso, retornam o último argumento avaliado. Isso às vezes é útil, por exemplo, se s é uma string que deve ser substituída por um valor padrão se estiver vazia, a expressão s or 'foo' produz o valor desejado. Como não precisa criar um novo valor, ele retorna um valor booleano independentemente do tipo de seu argumento (por exemplo, not 'foo' produz False).

or: Este é um operador lógico em python. “or” Retorna o primeiro valor Verdadeiro. Se não for encontrado, retorna o encontrado por último. A tabela verdade para “or” é ilustrada abaixo.

3 or 0 retorna 3
3 or 10 retorna 3
0 or 0 or 3 or 10 or 0 retorna 3

not: Este operador lógico inverte o valor. A tabela verdade para "not" é mostrada abaixo.

# Código python para demonstrar
# True, False, None, and, or , not

# mostra que None não é igual a 0
# imprime False
print(None == 0)

# mostrando objetivo None
# aqui x e y são nulos
# portanto, verdadeiro
x = None
y = None
print(x == y)

# operação lógica
# or (retorna True)
print (True or False)

# operação lógica
# and (retorna False)
print(False and True)

# operação lógica
# not (retorna False)
print(not True)

Saída:

False
True
True
False
False

assert: Esta função é usada para fins de depuração. Normalmente usado para verificar a exatidão do código. Se uma declaração for avaliada como verdadeira, nada acontece, mas quando é falsa, “AssertionError” é gerado. Também se pode imprimir uma mensagem com o erro, separados por vírgula.

break:break” é usado para controlar o fluxo do loop. A instrução é usada para sair do loop e passa o controle para a instrução imediatamente após o loop.

continue:continue” também é usado para controlar o fluxo do código. A palavra-chave pula a iteração atual do loop, mas não termina o loop.

class: Esta palavra-chave é usada para declarar classes definidas pelo usuário. Para mais informações.

def: Esta palavra-chave é usada para declarar funções definidas pelo usuário.

if É uma declaração de controle para a tomada de decisão. A expressão da verdade força o controle a entrar no bloco de instruções “if”.

else: É uma declaração de controle para a tomada de decisão. A expressão falsa força o controle a ir para o bloco de instruções “else”.

elif: É uma declaração de controle para a tomada de decisão. É a abreviação de "else if"

del: del é usado para excluir uma referência a um objeto. Qualquer variável ou valor de lista pode ser excluído usando del.

# Código Python para demonstrar del e assert 

# cria uma lista
a = [1, 2, 3]

# imprime na tela antes de excluir algum valor
print("A lista antes de excluir algum valor")
print(a)

# using del to delete 2nd element of list 
del a[1]
  
# printing list after deleting 2nd element 
print ("The list after deleting 2nd element") 
print (a) 
  
# demonstrating use of assert 
# prints AssertionError 
assert 5 < 3, "5 is not smaller than 3"

Resultado:

A lista antes de excluir algum valor
[1, 2, 3]
A lista depois de excluir o segundo elemento
[1, 3]
Traceback (most recent call last):
  File "/home/thor/Documentos/python/teste.py", line 19, in <module>
    assert 5 < 3, "5 não é menor que 3"
AssertionError: 5 não é menor que 3

Próximo artigo - Palavras-chave em Python - parte 2

Artigo escrito por Manjeet Singh (S. Nandini) e melhorado por VamsiKrishnaMeda, raviteja jammulapati, pradeepyrl e alifyakhan
Traduzido por Acervo Lima de Keywords in Python – Set 1

quinta-feira, 3 de dezembro de 2020

Diferenças importantes entre Python 2 e Python 3 com exemplos

  • Operador de divisão
  • função print
  • Unicode
  • xrange
  • Manipulação de erros
  • módulo _future_

Operador de divisão

Se estivermos portando nosso código ou executando o código python 3.x em python 2.x, pode ser perigoso se as alterações na divisão inteira passarem despercebidas (já que não gera nenhum erro). É preferível usar o um valor de ponto flutuante (como 7.0/5 ou 7/5.0) para obter o resultado esperado ao portar nosso código.

print 7 / 5 
  
print -7 / 5     

Saída:

Saída em Python 2.x  
  
1  
  
-2  
  
Saída em Python 3.x :  
  
1.4  
  
-1.4  

# Consulte o link abaixo para obter detalhes  
# https://www.geeksforgeeks.org/division-operator-in-python/  

função print

Esta é a mudança mais conhecida. Nesse caso, a palavra-chave print no Python 2.x é substituída pela função print() no Python 3.x. No entanto, os parênteses funcionam no Python 2 se um espaço for adicionado após a palavra-chave print porque o interpretador o avalia como uma expressão.

print 'Olá, Geeks'      # Python 3.x não suporta
  
print('Espero que você goste desses fatos')

Saída:

Saída em Python 2.x :  
  
Olá, Geeks  
  
Espero que você goste desses fatos  
  
Saída em Python 3.x :  
  
File "a.py", line 1  
  
    print 'Olá, Geeks'  
  
                       ^  
  
SyntaxError: invalid syntax  

Consulte o link abaixo para obter detalhes
https://www.geeksforgeeks.org/g-fact-25-print-single-multiple-variable-python/  

Como podemos ver, se usarmos parênteses em python 2.x, não haverá problema, mas se não usarmos parênteses em python 3.x, obteremos SyntaxError.

Unicode

No Python 2, o tipo de string implícito é ASCII. Mas no Python 3.x o tipo de string implícito é Unicode.

print(type('default string '))  
  
print(type(b'string with b '))  

Saída:

Saída em Python 2.x (Bytes é o mesmo que str)  
  
<type 'str'>
  
<type 'str'>

Output in Python 3.x (Bytes e str são diferentes)  
  
<class 'str'>
  
<class 'bytes'>

Python 2.x também oferece suporte a Unicode

print(type('string padrão'))  
  
print(type(u'string com b '))

Saída:

  
Saída em Python 2.x (Unicode e str são diferentes)  
  
<type 'str'>  
  
<type 'unicode'>  

Saída em Python 3.x (Unicode e str são o mesmo)  
  
<class 'str'>
  
<class 'str'>>

xrange

xrange() do Python 2.x não existe no Python 3.x. No Python 2.x, range retorna uma lista, ou seja, range(3) retorna [0, 1, 2] enquanto xrange retorna um objeto xrange i. e., xrange(3) retorna um objeto iterador que funciona de forma semelhante ao iterador Java e gera um número quando necessário.

Se precisarmos iterar na mesma sequência várias vezes, preferimos range(), pois range fornece uma lista estática. xrange() reconstrói a sequência todas as vezes. xrange() não oferece suporte a fatias e outros métodos de lista. A vantagem de xrange() é que ele economiza memória quando a tarefa é iterar em um grande intervalo.

No Python 3.x, a função range agora faz o que xrange faz no Python 2.x, então, para manter nosso código portátil, podemos preferir usar range. Portanto, a função de intervalo do Python 3.x é xrange do Python 2.x.

for x in xrange(1, 5):  
  
    print(x),  

for x in range(1, 5):  
  
    print(x),

Saída:

Saída em Python 2.x  
  
1 2 3 4 1 2 3 4  

Saída em Python 3.x  
  
NameError: name 'xrange' is not defined

Manipulação de erros

Há uma pequena mudança no tratamento de erros em ambas as versões. No python 3.x, a palavra-chave "as" é necessária.

try:  
  
    trying_to_check_error  
  
except NameError, err:  
  
    print err, 'Error Caused'   # Não funcionaria em Python 3.x

Saída:

Saída em Python 2.x:  
  
name 'trying_to_check_error' is not defined Error Caused  

Saída em Python 3.x :  
  
File "a.py", line 3  
  
    except NameError, err:  
  
                    ^  
  
SyntaxError: invalid syntax  
try:  
  
     trying_to_check_error  
  
except NameError as err: # 'as' é necessário em python 3.x  
  
     print (err, 'Error Caused')

Saída:

Saída em Python 2.x:
  
(NameError("name 'trying_to_check_error' is not defined",), 'Error Caused')  

Saída em Python 3.x :

name 'trying_to_check_error' is not defined Error Caused

Módulo __future__

Basicamente, isso não é uma diferença entre as duas versões, mas é útil mencionar aqui. A ideia do módulo __future__ é ajudar a migrar para o Python 3.x.

Se estamos planejando ter suporte para Python 3.x em nosso código 2.x, podemos usar importe _future_ em nosso código.

Por exemplo, no código Python 2.x abaixo, usamos o comportamento de divisão de inteiro do Python 3.x usando o módulo __future__.

# No código python 2.x abaixo, a divisão funciona
# assim como em Python 3.x porque usamos __future__  
  
from __future__ import division  

print 7 / 5 
  
print -7 / 5 

Saída:

1.4
-1.4

Outro exemplo em que usamos colchetes no Python 2.x usando o módulo __future__:

from __future__ import print_function      

print('Acervo Lima')  

Saída:

Acervo Lima

Consulte isso para obter mais detalhes do módulo __future__.

Traduzido por Acervo Lima de Important differences between Python 2.x and Python 3.x with examples
Artigo escrito por priteshkanani, lalitshankarch

O básico de Python 3

Python foi desenvolvido por Guido van Rossum no início dos anos 1990 e sua versão mais recente é 3.7.1, podemos simplesmente chamá-lo de Python3. Python 3.0 foi lançado em 2008. e é uma linguagem interpretada, ou seja, não é compilado e o intérprete verifica o código linha por linha. Este artigo pode ser usado para aprender os fundamentos da linguagem de programação Python.

Portanto, antes de prosseguirmos ... vamos fazer a tradição "HelloWorld" mais popular e, portanto, comparar a sintaxe do Python com C, C ++, Java (eu peguei essas 3 porque são as linguagens mais famosas e mais usadas).

# Código python para imprimir na tela "Hello World" 
# nada mais para escrever.. viu como python é simples.
  
print("Hello World")

Nota: Por favor, note que Python para seu escopo não depende das chaves ({}), em vez disso, ele usa recuo para seu escopo.

Agora avançando vamos começar nossos fundamentos do Python. Estarei cobrindo o básico em algumas pequenas seções. Basta passar por eles e, acredite, você aprenderá o básico do Python com muita facilidade.

Introdução e configuração

Se você estiver no sistema operacional Windows, baixe o Python clicando aqui e agora instale a partir da configuração e no menu iniciar digite IDLE.IDLE, você pode considerá-lo um IDE do Python para executar os scripts do Python.

Será algo assim: 


 

Se você estiver em um sistema Linux/Unix, basta abrir o terminal e, em 99% dos sistemas operacionais linux, o Python vem pré-instalado com o sistema operacional. Basta digitar ‘python3’ no terminal e pronto.

Deve aparecer algo como isso: 


 

O ">>>" representa o shell python e está pronto para receber comandos e código Python.

Variáveis e Estruturas de Dados

Em outras linguagens de programação como C, C++ e Java, você precisará declarar o tipo de variáveis, mas em Python você não precisa fazer isso. Basta digitar a variável e quando os valores forem dados a ela, ele saberá automaticamente se o valor dado seria um int, float ou char ou mesmo uma String.

Código:

# Declarando variáveis em python
myNumber = 3
print(myNumber) 
  
myNumber2 = 4.5
print(myNumber2) 
  
myNumber ="helloworld"
print(myNumber) 

Saída:

3
4.5
helloworld

Veja como é simples, basta criar uma variável e atribuir a ela qualquer valor que você quiser e então usar a função de impressão para imprimi-la. Python tem 4 tipos de estruturas de dados integradas, a saber, lista, dicionário, tupla e set.

Lista é a estrutura de dados mais básica em python. Lista é uma estrutura de dados mutável, ou seja, os itens podem ser adicionados à lista posteriormente após a criação da lista. É como se você fosse fazer compras no mercado local e fizesse uma lista de alguns itens e, mais tarde, você pudesse adicionar mais e mais itens à lista. A função append() é usada para adicionar dados à lista.

Código:

# programa python para ilustrar uma lista 
  
# cria uma lista vazia
nums = []  
  
# adiciona dados a lista
nums.append(21) 
nums.append(40.5) 
nums.append("String") 
  
print(nums) 

Saída:

[21, 40.5, String]

Entrada e saída

Nesta seção, aprenderemos como obter informações do usuário e, portanto, manipulá-las ou simplesmente exibi-las. A função input() é usada para obter a entrada do usuário.

# Programa pytho para ilustrar
# como solicitar dados ao usuário
name = input("Entre com seu nome: ")  

print("Olá,", name) 

Saída:

Entre com seu nome: Ana
Olá, Ana

Código:

# Programa para obter a entrada do usuário
  
# aceitando um inteiro do usuário
# o tipo de retorno da função input() é string,
# então precisamos converter a entrada em inteiro

num1 = int(input("Entre com o primeiro número: ")) 
num2 = int(input("Entre com o segundo número: ")) 
  
num3 = num1 * num2 
print("O produto dos números informados é: ", num3) 

Saída:

Entre com o primeiro número: 6
Entre com o segundo número: 9
O produto dos números informados é:  54

Seleção

A seleção em Python é feita usando as duas palavras-chave ‘if’ e ‘elif’ e else (elseif)

# Programa python para ilustrar
# declarações de seleção
  
num1 = 34
if(num1>12): 
    print("Num1 é bom") 
elif(num1>35): 
    print("Num2 não é booommm....") 
else: 
    print("Num2 é ótimo!") 

Saída:

Num1 é bom

Funções

Você pode pensar em funções como um monte de código que se destina a realizar uma tarefa específica em todo o script Python. Python usou a palavra-chave ‘def’ para definir uma função.

Sintaxe:

def função_nome(argumentos):
    # conpo da função

Código:

# Programa para ilustrar
# funções
def hello(): 
    print("Olá") 
    print("Olá de novo")

# chama a função hello
hello() 
  
# chama a função de novo 
hello()

Saída:

Olá
Olá de novo
Olá
Olá de novo

Agora, como sabemos, qualquer programa começa com uma função ‘principal’ ... vamos criar uma função principal como em muitas outras linguagens de programação.

Código:

# programa python para ilustrar
# uma função principal
def obter_inteiro(): 
    resultado = int(input("Entre com um número inteiro: "))
    
    return resultado
  
def função_principal(): 
    print("A função principal começou") 
  
    # chama a função obter_inteiro
    # e guarda o resultado da função obter_inteiro
    # na variável saída
    saída_de_obter_inteiro = obter_inteiro()      
    print(saída_de_obter_inteiro) 
  
# Verifica se esse é o arquivo principal
# e se for chama a função função_principal()
if __name__=="__main__": 
    função_principal() 

Saída:

A função principal começou
Entre com um número inteiro: 8
8

Iteração (Looping)

Como o nome sugere, um looping fica executando a mesma coisa continuamente. Usaremos o loop ‘for’ por ser o mais popular.

Código:

# programa python para ilustrar
# o uso do loop for

for step in range(5):     
    print(step) 

Saída:

0
1
2
3
4

Modulos

Python possui uma biblioteca de módulos muito rica que possui várias funções para realizar muitas tarefas.

A palavra-chave ‘import’ é usada para importar um módulo específico para o seu código Python. Por exemplo, considere o seguinte programa.

Código:

 
# importa o modulo math
import math 
  
def Main(): 
    num = -85
  
    # fabs é usado para obter o valor absoluto
    # de um decimal
    num = math.fabs(num)  
    print(num) 
      
      
if __name__=="__main__": 
    Main() 

Saída:

85.0

Esses são alguns dos princípios básicos da linguagem de programação Python e estarei cobrindo os tópicos de Python de nível intermediário e avançado em meus próximos artigos.

Traduzido por Acervo Lima de Python 3 basics.
Artigo escrito por prabaltiwari09, tejshreelavatre, Kiran Kotari e kainanjali80.

Introdução à linguagem Python

Python é uma linguagem de programação de alto nível de uso geral amplamente usada. Foi criado por Guido van Rossum em 1991 e posteriormente desenvolvido pela Python Software Foundation. Ele foi projetado com ênfase na legibilidade do código e sua sintaxe permite que os programadores expressem seus conceitos em menos linhas de código.

Python é uma linguagem de programação que permite trabalhar rapidamente e integrar sistemas com mais eficiência.

Existem duas versões principais do Python: Python 2 e Python 3. Ambas são bastante diferentes.

Começando com a programação em Python:

Encontrar um interpretador

Antes de iniciarmos a programação Python, precisamos ter um interpretador para interpretar e executar nossos programas. Existem alguns interpretadores online como IDE GeeksForGeeks, ideone ou codepad que podem ser usados para executar programas Python sem instalar um interpretador no seu computador. Mas o mais comum é instalar um interpretador na sua máquina. E isso pode ser feito tanto no Windows, Linux e Mac.

Windows: Existem muitos intérpretes disponíveis gratuitamente para executar scripts Python como IDLE (Integrated Development Environment) que vem junto com o software Python baixado de http://python.org/.

Linux: Python vem pré-instalado com distros populares de Linux, como Ubuntu e Fedora. Para verificar qual versão do Python você está executando, digite “python” no emulador de terminal. O interpretador deve iniciar e imprimir o número da versão.

macOS: geralmente, o Python 2.7 vem com o macOS. Você terá que instalar manualmente o Python 3 em http://python.org/.

Escrevendo nosso primeiro programa

Basta digitar o código a seguir após iniciar o interpretador.

Código:

# começo do Script

print("Acervo Lima") 

# fim do Scripts 

Saída:

Acervo Lima

Vamos analisar o script linha por linha.

Linha 1: [# começo do Script] Em Python, os comentários começam com um #. Esta declaração é ignorada pelo interpretador e serve como documentação para nosso código.

Linha 2: [print("Acervo Lima")] Para imprimir algo no console, a função print() é usada. Esta função também adiciona uma nova linha após a impressão de nossa mensagem (ao contrário de C). Observe que no Python 2, “print” não é uma função, mas uma palavra-chave e, portanto, pode ser usada sem parênteses. No entanto, no Python 3, é uma função e deve ser chamada entre parênteses.

Linha 3: [# Script termina] Este é apenas outro comentário como na linha 1.

Traduzido por Acervo Lima de Python Language Introduction.
Artigo escrito por shivamsaraswat, lalitshankarch.

quinta-feira, 1 de outubro de 2020

Juntando tabelas em uma base de dados relacional com SQL

Photo by Tim Johnson on Unsplash

No primeiro post sobre a linguagem SQL fomos apresentados ao conceito de bancos de dados relacionais e a um aplicativo que nos possibilita armazenar dados em tabelas relacionadas. Nessas tabelas os dados são armazenados em colunas e cada linha dessas colunas guardam os valores de um elemento. Com a linguagem SQL podemos fazer uma junção de linhas de uma tabela com outra tabela.
Com o modelo relacional construirmos tabelas que eliminam dados duplicados, são mais flexíveis na consulta para obter dados especificísticos e fáceis de manter.

Vinculando tabelas usando JOIN

Podemos juntar tabelas durante uma consulta com a declaração JOIN ... ON (Existem outras variações que veremos mais a frente). Usamos essa declaração para vincular uma tabela a outra durante uma consulta. Desse modo usamos valores correspondentes em colunas que especificamos em ambas as tabelas. A sintaxe que vamos usar é essa:

SELECT *
FROM tabela_a JOIN tabela_b
ON tabela_a.coluna_a = tabela_b.coluna_b

Esse exemplo é parecido com a sintaxe básica da declaração SELECT. A diferença é que utilizamos JOIN para fornecer duas tabelas e não somente uma. Depois do ON é onde especificamos as colunas que queremos combinar os valores. O resultado dessa declaração é que realizamos uma consulta nas duas tabelas e retornamos as linhas onde o valor da coluna coluna_a seja igual ao valor da coluna coluna_b.
O uso mais comum da cláusula ON é procurar por colunas com valores iguais, mas também é possível realizar consultas com outras expressões onde o resultado seja verdadeiro ou falso.

Relacionando tabelas com colunas-chave

Vamos imaginar o seguinte cenário: Você é um analista de dados e acabou de ser contratado para analisar os gastos com folha de pagamento por departamento. Você faz o pedido dos dados que vai precisar esperando receber uma tabela parecida com essa:

depart localizacao nome     sobrenome salario
------ ----------- -------- --------- -------
RH     São Paulo   Daniela  Silva     62450
RH     São Paulo   Everton  Oliveira  59300
AD     Fortaleza   Fábio    Feitosa   87654
AD     Fortaleza   Dénis    Reis      87654

Mas não é o que você recebe. Você acaba de receber dois arquivos csv, cada um representando uma tabela. Analisando essas tabelas você percebe que as colunas colaboradores e departamentos se destacam.
Usando o código abaixo vamos criar essas duas tabelas e encontrar o melhor jeito de juntar os dados das tabelas. Se não souber criar uma tabela veja os tutoriais anteriores.

CREATE TABLE departamentos (
	departamento_id BIGINT AUTO_INCREMENT,
	departamento VARCHAR(100),
	cidade VARCHAR(100),
	CONSTRAINT departamento_chave PRIMARY KEY (departamento_id),
	CONSTRAINT depart_cidade_u UNIQUE (departamento, cidade)
);

CREATE TABLE colaboradores (
	colaboradores_id BIGINT AUTO_INCREMENT,
	nome VARCHAR(100),
	sobrenome VARCHAR(100),
	salario INTEGER,
	departamento_id BIGINT REFERENCES departamentos (departamento_id),
	CONSTRAINT colaboradores_chave PRIMARY KEY (colaboradores_id),
	CONSTRAINT colabo_depart_unique UNIQUE (colaboradores_id, departamento_id)
);

INSERT INTO departamentos (departamento, cidade)
VALUES
	('RH', 'São Paulo'),
	('AD', 'Fortaleza');

INSERT INTO colaboradores (nome, sobrenome, salario, departamento_id)
VALUES
	('Erique', 'Silva', 62500, 1),
	('Fabiana', 'Oliveira', 59300, 1),
	('Eveline', 'Reis', 83000, 2),
	('Daniela', 'Ferreira', 95000, 2);

Podemos notar que as duas tabelas que acabamos de criar seguem o modelo proposto por Codd em que cada tabela descreve atributos de uma única entidade, nesse exemplo sobre os colaboradores e os departamentos. Fazendo uma consulta simples vemos que o conteúdo da tabela departamentos é esse:

SELECT * FROM departamentos;
+-----------------+--------------+-----------+
| departamento_id | departamento | cidade    |
+-----------------+--------------+-----------+
|               2 | AD           | Fortaleza |
|               1 | RH           | São Paulo |
+-----------------+--------------+-----------+
2 rows in set (0.003 sec)

A coluna departamento_id é a chave primária da tabela, definimos isso na linha cinco. Isso quer dizer que os valores dessa tabela não podem ser repetidos e não devem ser nulos (deve ser adicionado algum valor). Para não precisarmos adicionar um valor para a coluna departamento_id adicionamos a cláusula AUTO_INCREMENT. Desse modo quando for adicionado uma nova linha a tabela, a coluna departamento_id será acrecida de um valor crescente. Adicionamos a restrição PRIMARY KEY porque cada departamento é único, não existe dois RH numa empresa. Nos próximos tutoriais vamos aprender mais sobre restrições (CONSTRAINT).
Se você realizar uma consulta simples na tabela de colaboradores o conteúdo deve ser esse:

SELECT * FROM colaboradores;
+------------------+----------+-----------+---------+-----------------+
| colaboradores_id | nome     | sobrenome | salario | departamento_id |
+------------------+----------+-----------+---------+-----------------+
|                1 | Erique   | Silva     |   62500 |               1 |
|                2 | Fabiana  | Oliveira  |   59300 |               1 |
|                3 | Eveline  | Reis      |   83000 |               2 |
|                4 | Daniela  | Ferreira  |   95000 |               2 |
+------------------+----------+-----------+---------+-----------------+
8 rows in set (0.003 sec)

A coluna colaboradores_id é utilizada para identificar cada funcionário. Para saber em qual departamento um funcionário trabalha temos a colunas departamento_id. Os valores dessa coluna fazem referência aos valores da coluna departamento_id da tabela departamentos. Essa referência a outra coluna em outra tabela é chamada de chave estrangeira. Uma restrição com chave estrangeira usando referência (REFERENCES) só nos permite adicionar um valor se esse valor já estiver presente na coluna estrangeira, no nosso caso na coluna departamento_id. Isso quer disser que para adicionar o valor 1 na coluna departamento_id da tabela colaboradores esse valor já deve estar presente na coluna departamento_id da tabela departamentos.
Outra restrição é a UNIQUE. Utilizamos UNIQUE para definir que a tabela não pode ter valores repetidos. Agora você deve estar pensando que UNIQUE e PRIMARY KEY são a mesma coisa, mas isso não é verdade. Existem duas diferenças entre as duas. A primeira é que uma tabela só pode ter uma coluna PRIMARY KEY enquanto a mesma tabela pode ter várias colunas UNIQUEs. E a segunda diferença é que uma coluna UNIQUE aceita o valor nulo. Vamos aprender mais sobre essa restrição em outro tutorial.
Nesse momento você deve estar pensando pra que serve essas restrições, além de complicar a sua vida. E a resposta é bem simples: Não permitir a entrada de dados duplicados. Se cada departamento e cidade são únicos porque duplicar esses valores. Se tivéssemos recebidos os dados do jeito que queríamos inicialmente era isso que ia acontecer. Não tem problema ter dados duplicados numa tabela com quatro valores como a nossa, ou quatro mil. Mas agora imagine um banco de dados com milhares de linhas. Agora temos um problema: estamos desperdiçando espaço para armazenar valores duplicados.
Agora que você sabe o básico de como as tabelas podem se relacionar, vamos dar uma olhada em como juntá-los em uma consulta.

Consultando várias tabelas usando JOIN

Quando realizamos uma consulta com JOIN o banco de dados nos retorna uma tabela com as linhas das tabelas lado a lado. Isso para cada linha que a condição passada depois da cláusula ON seja verdadeira. Ainda podemos filtrar os resultados dessa consulta com a cláusula WHERE.
As consultas usando JOIN são parecidas com a sintaxe básica de uma consulta simples com SELECT. A diferença é que usamos JOIN … ON para selecionar as tabelas e as variações de JOIN para definir os critérios da junção.
Vamos começar com um exemplo simples. Para a nossa primeira consulta utilizando JOIN queremos os dados de todas as colunas onde os valores de departamento_id (da tabela colaboradores) e departamento_id (da tabela departamentos) sejam iguais.

SELECT *
FROM colaboradores JOIN departamentos
ON colaboradores.colaboradores_id = departamentos.departamento_id;
+------------------+---------+-----------+---------+-----------------+-----------------+--------------+-----------+
| colaboradores_id | nome    | sobrenome | salario | departamento_id | departamento_id | departamento | cidade    |
+------------------+---------+-----------+---------+-----------------+-----------------+--------------+-----------+
|                2 | Fabiana | Oliveira  |   59300 |               1 |               2 | AD           | Fortaleza |
|                1 | Erique  | Silva     |   62500 |               1 |               1 | RH           | São Paulo |
+------------------+---------+-----------+---------+-----------------+-----------------+--------------+-----------+
2 rows in set (0.002 sec)

Nessa busca foi retornado apenas duas linhas, mesmo fazendo a consulta nas duas tabelas, isso acontece porque definimos uma condição para a busca. E a condição é o valor das colunas colaboradores_id das duas tabelas serem iguais.
É possível fazer uma consulta nas duas colunas sem definir uma condição. Desse modo as tabelas serão apresentadas uma do lado da outra. Para isso use a declaração SELECT * FROM tabela1 JOIN tabela2;.
Utilizando a cláusula ON ou não você vai perceber que a tabela com menos linhas vai se repeti até que as duas tabelas tenham o mesmo número.

JOIN

Utilizamos JOIN ou INNER JOIN quando queremos consultar duas ou mais tabelas que tenham uma tabela em comum. No exemplo anterior, as tabelas colaboradores e departamentos tinham a coluna colaboradores_id em comum. Para os nossos próximos exemplos vamos usar essa tabela:

CREATE TABLE escola_esquerda (id INT, escola_esquerda VARCHAR(50));

CREATE TABLE escola_direita (id INT, escola_direita VARCHAR(50));

INSERT INTO escola_esquerda (id, escola_esquerda)
VALUES
	(1, 'COLEGIO CONTATO MACEIO'),
	(2, 'COLEGIO HARMONIA'),
	(3, 'ESC COLEGIO LATO SENSU'),
	(4, 'COLEGIO OBJETIVO'),
	(5, 'ESC AQUARELA ENSINO E CULTURA');
	
INSERT INTO escola_direita (id, escola_direita)
VALUES
	(1, 'COLEGIO CONTATO MACEIO'),
	(2, 'COLEGIO HARMONIA'),
	(3, 'ESC COLEGIO LATO SENSU'),
	(5, 'ESC AQUARELA ENSINO E CULTURA'),
	(6, 'ESC COLEGIO VITORIA');

Veja um exemplo utilizando JOIN:

SELECT *
FROM escola_esquerda JOIN escola_direita
ON escola_esquerda.id = escola_direita.id;
+------+-------------------------------+------+-------------------------------+
| id   | escola_esquerda               | id   | escola_direita                |
+------+-------------------------------+------+-------------------------------+
|    1 | COLEGIO CONTATO MACEIO        |    1 | COLEGIO CONTATO MACEIO        |
|    2 | COLEGIO HARMONIA              |    2 | COLEGIO HARMONIA              |
|    3 | ESC COLEGIO LATO SENSU        |    3 | ESC COLEGIO LATO SENSU        |
|    5 | ESC AQUARELA ENSINO E CULTURA |    5 | ESC AQUARELA ENSINO E CULTURA |
+------+-------------------------------+------+-------------------------------+
4 rows in set (0.167 sec)

Você deve utilizar o JOIN quando os dados estiverem bem estruturados e uma relação entre as tabelas. Para retornar os valores das duas tabelas use outro tipo de JOIN.

LEFT JOIN e RIGHT JOIN

Utilizamos LEFT JOIN e RIGHT JOIN quando queremos que todos os elementos de uma tabela apareçam na consulta. Por exemplo, você quer que todos os elementos da tabela escola_esquerda apareçam na consulta, assim usamos LEFT JOIN. Os elementos da tabela escola_direita que não tiverem um correspondente na tabela escola_esquerda apareceram em branco (NULL). O mesmo vale para RIGHT JOIN. Veja um exemplo de utilização dos dois JOIN:

SELECT *
FROM escola_esquerda LEFT JOIN escola_direita
ON escola_esquerda.id = escola_direita.id;
+------+-------------------------------+------+-------------------------------+
| id   | escola_esquerda               | id   | escola_direita                |
+------+-------------------------------+------+-------------------------------+
|    1 | COLEGIO CONTATO MACEIO        |    1 | COLEGIO CONTATO MACEIO        |
|    2 | COLEGIO HARMONIA              |    2 | COLEGIO HARMONIA              |
|    3 | ESC COLEGIO LATO SENSU        |    3 | ESC COLEGIO LATO SENSU        |
|    5 | ESC AQUARELA ENSINO E CULTURA |    5 | ESC AQUARELA ENSINO E CULTURA |
|    4 | COLEGIO OBJETIVO              | NULL | NULL                          |
+------+-------------------------------+------+-------------------------------+
5 rows in set (0.004 sec)

SELECT *
FROM escola_esquerda RIGHT JOIN escola_direita
ON escola_esquerda.id = escola_direita.id;
+------+-------------------------------+------+-------------------------------+
| id   | escola_esquerda               | id   | escola_direita                |
+------+-------------------------------+------+-------------------------------+
|    1 | COLEGIO CONTATO MACEIO        |    1 | COLEGIO CONTATO MACEIO        |
|    2 | COLEGIO HARMONIA              |    2 | COLEGIO HARMONIA              |
|    3 | ESC COLEGIO LATO SENSU        |    3 | ESC COLEGIO LATO SENSU        |
|    5 | ESC AQUARELA ENSINO E CULTURA |    5 | ESC AQUARELA ENSINO E CULTURA |
| NULL | NULL                          |    6 | ESC COLEGIO VITORIA           |
+------+-------------------------------+------+-------------------------------+
5 rows in set (0.001 sec)

RIGHT JOIN e LEFT JOIN são usados quando você precisa que todos os elementos de uma tabela apareçam, quando você quer comparar duas tabelas procurando por dados ausentes e quando você precisa saber quais elementos de uma tabela não tem correspondentes na outra tabela.

Usando NULL para encontrar linhas com valores ausentes

Podemos descobrir quais são os valores ausentes numa consulta usando WHERE com NULL. Por exemplo, no exemplo acima a nossa consulta retorna um valor NULL, podemos usar esse valor para descobrir quais são as linhas que não têm correspondentes na outra tabela. Veja como fazer isso:

SELECT *
FROM escola_esquerda LEFT JOIN escola_direita
ON escola_esquerda.id = escola_direita.id
WHERE escola_direita.id IS NULL;
+------+------------------+------+----------------+
| id   | escola_esquerda  | id   | escola_direita |
+------+------------------+------+----------------+
|    4 | COLEGIO OBJETIVO | NULL | NULL           |
+------+------------------+------+----------------+
1 row in set (0.001 sec)

Com esse exemplo descobrimos que o valor 4 da coluna id da tabela escola_esquerda não tem um correspondente na tabela escola_direita.
Obs: Quando for trabalhar com o valor NULL use sempre IS porque NULL = NULL retorna NULL e NULL IS NULL retorna 1.