sexta-feira, 4 de dezembro de 2020

Como verificar se uma string é uma palavra-chave válida em Python?

Na programação, uma palavra-chave é uma “palavra reservada” pela linguagem que transmite um significado especial para o interpretador. Pode ser um comando ou um parâmetro. Palavras-chave não podem ser usadas como um nome de variável ou função dentro do programa.

Palavras-chave em Python: a linguagem Python também reserva algumas palavras-chave que transmitem um significado especial. O conhecimento deles é parte necessária do aprendizado dessa linguagem. Abaixo está uma lista de palavras-chave registradas por python.
False, elif, lambda, None, else, nonlocal, True, except, not, and, finally, or, as, for, pass, assert, from, raise, break, global, return, class, if, try, continue, import, while, def, in, with, del, is, yield.

Como verificar se uma string é uma palavra reservada da linguagem python?

Python em sua linguagem define um módulo embutido “keyword” que lida com certas operações relacionadas a palavras-chave. Uma função “iskeyword()” verifica se uma string é uma palavra-chave ou não. Retorna verdadeiro se uma string for palavra-chave, senão retorna falso.

# Código Python para demonstrar o funcionamento de iskeyword()

# importando "keyword" para operações de palavra-chave
import keyword

# inicializar strings para teste ao colocá-los em um array
keys = ["for", "while", "tanisha", "break", "pato",
"elif", "assert", "sofa", "lambda", "else", "guardanapo"]

for i in range(len(keys)):
    # verifica quais são palavras-chaves
    if keyword.iskeyword(keys[i]):
        print(keys[i] + " é uma palavra reservada da linguagem python")
    else:
        print(keys[i] + " não é uma palavra reservada da linguagem python")

Resultado:

for é uma palavra reservada da linguagem python
while é uma palavra reservada da linguagem python
tanisha não é uma palavra reservada da linguagem python
break é uma palavra reservada da linguagem python
pato não é uma palavra reservada da linguagem python
elif é uma palavra reservada da linguagem python
assert é uma palavra reservada da linguagem python
sofa não é uma palavra reservada da linguagem python
lambda é uma palavra reservada da linguagem python
else é uma palavra reservada da linguagem python
guardanapo não é uma palavra reservada da linguagem python

Como imprimir todas as palavras reservadas da linguagem python?

Às vezes, lembrar de todas as palavras-chave pode ser uma tarefa difícil ao atribuir nomes de variáveis. Portanto, uma função “kwlist()” é fornecida no módulo “keyword” que imprime todas as 33 palavras reservadas do python.

# Código Python para demonstrar o funcionamento de iskeyword()

# importando "keyword" para operações de palavra-chave
import keyword

# imprimir todas as palavras-chave de uma vez usando "kwlist()"
print("A lista de palavras reservadas do python: ")
print(keyword.kwlist)

Resultado:

A lista de palavras reservadas do python: 
['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']

Artigo escrito por Manjeet Singh(S.Nandini) e melhorado por TanishaTomar
Traduzido por Acervo Lima de How to check if a string is a valid keyword in Python?

Declaração, indentação e comentário em Python

Declarações

As instruções escritas no código-fonte para execução são chamadas de instruções. Existem diferentes tipos de instruções na linguagem de programação Python, como instrução de atribuição, instrução condicional, instruções de loop, etc. Tudo isso ajuda o usuário a obter a saída necessária. Por exemplo, n = 50 é uma instrução de atribuição.

Instruções de várias linhas: as instruções em Python podem ser estendidas a uma ou mais linhas usando parênteses (), chaves {}, colchetes [], ponto e vírgula (;), barra de caractere de continuação (\). Quando o programador precisa fazer cálculos longos e não consegue encaixar suas declarações em uma linha, pode-se fazer uso desses caracteres.

Exemplo:

Usando o caractere de continuação (\):

s = 1 + 2 + 3 + \

    4 + 5 + 6 + \

    7 + 8 + 9

Usando parenteses ():

n = (1 * 2 * 3 + 7 + 8 + 9)

Usando colchetes [] :

footballer = ['MESSI',

          'NEYMAR',

          'SUAREZ']

Usando chaves {} :

x = {1 + 2 + 3 + 4 + 5 + 6 +

     7 + 8 + 9}

Usando ponto e vírgula (;) :

flag = 2; ropes = 3; pole = 4

Indentação

Um bloco é uma combinação de todas essas instruções. Bloco pode ser considerado o agrupamento de afirmações para um propósito específico. A maioria das linguagens de programação como C, C ++, Java usam chaves {} para definir um bloco de código. Uma das características distintivas do Python é o uso de indentação para destacar os blocos de código. O espaço em branco é usado para indentação em Python. Todas as instruções com a mesma distância para a direita pertencem ao mesmo bloco de código. Se um bloco precisar ser aninhado mais profundamente, ele será simplesmente recuado mais para a direita. Você pode entendê-lo melhor observando as seguintes linhas de código:

# Programa python mostrando a indentação

site = 'Acervo Lima'

if site == 'Acervo Lima':
    print('https://www.acervolima.com.br')
else:
    print('Site não encontrado, tente ou site!')

print('Tudo pronto !') 

Resultado:

https://www.acervolima.com.br
Tudo pronto !

As linhas print('https://www.acervolima.com.br') e print('Site não encontrado, tente ou site!') São dois blocos de código separados. Os dois blocos de código em nosso exemplo de instrução if são indentados com quatro espaços. A impressão final print('Tudo pronto !') Não é indentada e, portanto, não pertence ao bloco else.

j = 1
while(j <= 5):
    print(j)
    j = j + 1

Resultado:

1
2
3
4
5

Para indicar um bloco de código em Python, você deve recuar cada linha do bloco com o mesmo número de espaços em branco. As duas linhas de código no loop while são indentadas com quatro espaços. É necessário para indicar a qual bloco de código uma instrução pertence. Por exemplo, j = 1 e while (j <= 5): não é indentado e, portanto, não está dentro do bloco while. Portanto, a estrutura de um código python é definida pela indentação.

Comentários

Os desenvolvedores de Python costumam fazer uso do sistema de comentários, pois, sem ele, as coisas podem ficar realmente confusas, muito rápido. Os comentários são as informações úteis que os desenvolvedores fornecem para fazer o leitor entender o código-fonte. Explica a lógica ou parte dela usada no código. Os comentários geralmente são úteis para alguém que mantém ou aprimora seu código quando você não está mais por perto para responder a perguntas sobre ele. Eles são frequentemente citados como uma convenção de programação útil que não faz parte da saída do programa, mas melhora a legibilidade de todo o programa. Existem dois tipos de comentário em Python:

Comentários de linha única: o comentário de linha única do Python começa com o símbolo de hashtag sem espaços em branco (#) e dura até o final da linha. Se o comentário exceder uma linha, coloque uma hashtag na próxima linha e continue o comentário. Os comentários de linha única do Python são úteis para fornecer explicações curtas para variáveis, declarações de funções e expressões. Veja o seguinte snippet de código que mostra um comentário de uma única linha:

Código 1:

# Isso é um comentário de uma linha
# imprime "Acervo Lima" no terminal
print("Acervo Lima")

Código 2:

a, b = 1, 3 # Declara dois inteiros
sum = a + b # Soma dois inteiros
print(sum) # Mostra o resultado

String de várias linhas como comentário: o comentário de várias linhas do Python é um pedaço de texto colocado em um delimitador (""") em cada extremidade do comentário. Novamente, não deve haver nenhum espaço em branco entre o delimitador (" ""). Eles são úteis quando o texto do comentário não cabe em uma linha; portanto, precisa abranger todas as linhas. Comentários ou parágrafos com várias linhas servem como documentação para outras pessoas que leiam seu código. Veja o seguinte snippet de código que demonstra o comentário de várias linhas:

Código 1:

""" 
Este seria um comentário multilinha em Python que
abrange várias linhas e descreve Acervo Lima.
Um portal de Ciência da Computação. Ele contém
artigos de programação e ciência da computação
bem escritos, bem pensados e bem explicados,
questionários e muito mais.  
… 
"""
print("Acervo Lima") 

Código 2:

'''
Este artigo sobre Acervo Lima oferece
um exemplo perfeito de comentários de várias linhas
'''

print("Acervo Lima") 

Artigo escrito por NamanKed e melhorado por ManiRamu
Traduzido por Acervo Lima de Statement, Indentation and Comment in Python

Estruturação de programas Python

Neste artigo, você conhecerá a estruturação e a formatação adequadas de seus programas Python.

Instruções Python Em geral, o interpretador lê e executa as instruções linha por linha, ou seja, sequencialmente. Porém, existem algumas instruções que podem alterar esse comportamento, como as instruções condicionais. Geralmente, as instruções python são escritas em um formato que uma instrução é escrita apenas em uma única linha. O intérprete considera o 'caractere de nova linha' como o terminador de uma instrução. Mas, escrever várias instruções por linha também é possível, você pode encontrar abaixo um exemplo disso.

Exemplos:

# Exemplo 1

print('Bem-vindo ao Acervo Lima')
# Exemplo 2

x = [1, 2, 3, 4]

# x[1:3] significa que começa do index 1 e vai até o 3
print(x[1:3])

""" No formato mencionado acima,
o primeiro índice é incluído,
mas o último índice não é incluído. """

Várias instruções por linha Também podemos escrever várias instruções por linha, mas não é uma boa prática, pois reduz a legibilidade do código. Tente evitar escrever várias instruções em uma única linha. Mas, ainda assim, você pode escrever várias linhas encerrando uma instrução com a ajuda de ‘;’. ‘;’ É usado como o terminador de uma instrução neste caso. Por exemplo, considere o código a seguir.

# Exemplo 

a = 10; b = 20; c = b + a

print(a); print(b); print(c)

Saída:

10
20
30

Continuação de linha para evitar rolagem para a esquerda e para a direita
Algumas declarações podem se tornar muito longas e forçar você a rolar a tela para a esquerda e para a direita com frequência. Você pode ajustar seu código de forma que não precise rolar aqui e ali. Python permite que você escreva uma única instrução em várias linhas, também conhecido como continuação de linha. A continuação da linha também melhora a legibilidade.

# Má prática, pois a largura deste código é muito grande.
# código

x = 10
y = 20
z = 30

não_de_professores = x
não_de_estudantes_masculinos = y
não_de_estudantes_femininos = z

if (não_de_professores == 10 and não_de_estudantes_femininos == 30 and não_de_estudantes_masculinos == 20 and (x + y) == 30):
    print('Esse jeito é válido')

# Isso poderia ser feito em vez disso:
if (não_de_professores == 10 and não_de_estudantes_femininos == 30
    and não_de_estudantes_masculinos == 20 and x + y == 30):

    print('Esse jeito é válido')

Tipos de continuação de linha
Em geral, existem dois tipos de continuação de linha:

Continuação de linha implícita
Esta é a técnica mais direta para escrever uma declaração que se estenda por várias linhas. Qualquer instrução contendo parênteses de abertura '(', colchetes '[' ou chaves '{' é considerada incompleta até que todos os parênteses, colchetes e chaves correspondentes tenham sido encontrados. Até então, o instrução pode ser continuada implicitamente nas linhas sem gerar um erro.

Exemplo 1:

# Exemplo 1 
  
# Esse código é válido
a = [
    [1, 2, 3],
    [3, 4, 5],
    [5, 6, 7]
    ]

print(a)

Saída:

[[1, 2, 3], [3, 4, 5], [5, 6, 7]]

Exemplo 2:

# Exemplo 2
# O código abaixo tambem é válido

pessoa_1 = 18
pessoa_2 = 20
pessoa_3 = 12

if (
    pessoa_1 >= 18 and
    pessoa_2 >= 18 and
    pessoa_3 < 18
    ):
    print('2 pessoas devem ter carteiras de identidade')

Saída:

2 pessoas devem ter carteiras de identidade

Continuação de linha explícita
A união de linha explícita é usada principalmente quando a união de linha implícita não é aplicável. Nesse método, você deve usar um caractere que ajude o intérprete a entender que a instrução específica abrange mais de uma linha.
Barra invertida (\) é usada para indicar que uma instrução se estende por mais de uma linha. O ponto deve ser observado que a barra invertida deve ser o último caractere nessa linha, mesmo espaços em branco não é permitido.
Veja o exemplo a seguir para esclarecimentos.

# Exemplo

x = \
    1 + 2 \
    + 5 + 6 \
    + 10

print(x)

Saída:

24

Comentários em Python
Escrever comentários no código é muito importante e eles ajudam na legibilidade do código e também informam mais sobre o código. Isso ajuda você a escrever detalhes em uma instrução ou um pedaço de código. O intérprete ignora os comentários e não os conta nos comandos. Nesta seção, aprenderemos como escrever comentários em Python.
Os símbolos usados para escrever comentários incluem Hash (#) ou aspas duplas triplas ("""). O hash é usado para escrever comentários de uma única linha que não abrangem várias linhas. As aspas triplas são usadas para escrever comentários de várias linhas. Três aspas triplas para iniciar o comentário e novamente três aspas para encerrar o comentário.
Considere os seguintes exemplos:

# Exemplo 1

####### Esse exemplo não vai imprimir Hello World ####### print('Hello World')  # Porque isso é um comentário
# Exemplo 2
  
""" Esse exemplo vai
    demonstrar vários
    comentários """
  
""" A variável seguinte
    vai guardar o valor
    'How old are you?' 
"""
a = 'How old are you?'

""" A declaração seguinte
    imprime na tela
    o conteúdo da variável a """
print(a)

Nota: Observe que o hash (#) dentro de uma string não significa um comentário. Considere o seguinte exemplo para demonstração.

# Exemplo

""" A seguinte instrução imprime
    a string armazenada na variável """

a = 'Isso não # é um comentário #'
print(a) # imprime o conteúdo da variável a

Espaços em branco
Os caracteres de espaço em branco mais comuns são os seguintes:

Caractere Código ASCII Expressão Literal
Espaço em branco 32 (0x20) ''
Tab 9 (0x9) '\t'
Nova linha 10 (0xA) '\n'

* Você sempre pode consultar a Tabela ASCII clicando aqui.

O espaço em branco é quase sempre ignorado e não exigido pelo interpretador Python. Quando estiver claro onde um token termina e o próximo começa, os espaços em branco podem ser omitidos. Geralmente, esse é o caso quando caracteres especiais não alfanuméricos estão envolvidos.
Veja exemplos:

# Exemplo 1

# Correto, mas o espaço em branco pode melhorar a legibilidade

a = 1-2  # Melhor desse jeito a = 1 - 2

print(a)
# Exemplo 2

# Isso esta correto
# Espaços em branco podem melhorar a legibilidade
x = 10
flag =(x == 10)and(x<12)
print(flag)

""" Uma forma mais legivel pode ser assim:
x = 10
flag = (x == 10) and (x < 12)
print(flag)
"""

# Experimente o código mais legível

Espaços em branco são necessários para separar as palavras-chave das variáveis ou outras palavras-chave. Considere o seguinte exemplo.

# Exemplo

x = [1, 2, 3]
y = 2

""" Esse código esta errado e vai gerar um erro de sintaxe
a = yin x
"""

# Essa é a versão correta
a = y in x
print(a)

Espaços em branco como indentação
A sintaxe do Python é muito fácil, mas ainda assim você deve tomar alguns cuidados ao escrever o código. A indentação é usada na escrita de códigos Python.
Os espaços em branco antes de uma instrução têm um papel significativo e são usados na indentação. O espaço em branco antes de uma declaração pode ter um significado diferente. Vamos tentar um exemplo.

# Exemplo
  
print('foo') # Correto

   print('foo') # Isso vai gerar um erro

# O erro deve ser algo como 'unexpected indent'

Espaços em branco à esquerda são usados para determinar o agrupamento das instruções como em loops ou estruturas de controle, etc.
Exemplo:

# Exemplo

x = 10

while(x != 0):
    if(x > 5):   # Linha 1
        print('x > 5')  # Linha 2
    else:        # Linha 3
        print('x < 5') # Linha 4 
x -= 2       # Linha 5

"""
As linhas 1, 3 e 5 estão no mesmo nivel
A linha 2 vai ser executada apenas se x for maior que 5
A linha 4 vai ser executada apenas se x não for maior que 5
"""
x > 5
x > 5
x > 5
x < 5
x < 5

Artigo escrito por AnasShamoon e melhorado por harlinseritt
Traduzido por Acervo Lima de Structuring Python Programs

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