Pular para o conteúdo principal

30 truques legais de Python para um código melhor com exemplos

Selecionamos 30 truques legais de Python que você pode usar para melhorar seu código e desenvolver suas habilidades em Python.
Actualizado 11 de set. de 2024  · 24 min de leitura

A demanda por habilidades de codificação em Python cresceu nos últimos anos. Para ajudar você a desenvolver suas habilidades de programação em Python, selecionamos 30 truques legais em Python que você pode usar para melhorar seu código. Tente aprender uma por dia nos próximos 30 dias e confira nossa postagem sobre práticas recomendadas de Python para garantir que seu código seja o melhor da categoria.  

Se suas habilidades em Python não estiverem à altura, você também pode aprimorá-las com o nosso Python Skill Track

#1 Fatiamento

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

Slicing é um recurso do Python que se baseia na indexação para permitir que os usuários acessem um subconjunto de uma sequência. Um índice é simplesmente a posição de um elemento em uma sequência. Se o tipo de sequência for mutável, você poderá usar o fatiamento para extrair e modificar dados. 

Observação: Também podemos usar o fatiamento em uma sequência imutável, mas a tentativa de modificar a fatia gerará um TypeError. 

O formato no qual as fatias são implementadas é: sequence[start:stop:step]. Se nenhum valor for especificado nos parâmetros start, stop e step, a sequência implementará os padrões. Os padrões são: 

  • O padrão de "start" é 0 
  • "stop" tem como padrão o comprimento da sequência
  • O valor padrão de "step" é 1 se não for especificado. 

Quando fornecido com sequence[start:stop], os elementos retornados serão do índice inicial até o stop- 1 (o índice de parada não está incluído). 

Também podemos passar índices negativos, que podem ser usados para reverter a sequência. Por exemplo, em uma lista de 4 elementos, o índice 0 também é o índice -4, e o último índice também é -1. No código do exemplo acima, esse conhecimento foi aplicado ao parâmetro de etapa da sequência. Consequentemente, a string foi impressa de trás para frente, começando do final da sequência até o índice 0.   

#2 Troca no local / Atribuição simultânea

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

Se a sua impressão inicial era de que o valor de b seria 7 em vez de 12, você caiu na armadilha da troca de lugar. 

No Python, podemos descompactar iteráveis em variáveis em uma única atribuição usando a descompactação automática. Por exemplo: 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

Também podemos reunir vários valores em uma única variável usando * - esse truque do Python é chamado de empacotamento. Veja abaixo um exemplo de embalagem.  

a, b* = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

A combinação de embalagem e desembalagem automáticas dá origem a uma técnica conhecida como atribuição simultânea. Podemos usar a atribuição simultânea para atribuir uma série de valores a uma série de variáveis.

#3 Lista vs. Tuplas 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 112 bytes
Tuple size: 96 bytes
"""

A maioria dos programadores Python está familiarizada com a estrutura de dados de lista. O mesmo não pode ser dito sobre as tuplas. Ambos são iteráveis, permitem a indexação e o armazenamento de tipos de dados heterogêneos. Mas há situações em que o uso de uma tupla pode ser preferível a uma lista. 

Em primeiro lugar, as listas são mutáveis, o que significa que podemos modificá-las como quisermos: 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

As tuplas, por outro lado, são imutáveis, o que significa que se você tentar modificá-las, ocorrerá um TypeError

Por esse motivo, as tuplas são mais eficientes em termos de memória, pois o Python pode alocar o bloco de memória correto necessário para os dados. Por outro lado, em uma lista, é necessário alocar memória extra apenas para o caso de estendê-la - isso é chamado de alocação dinâmica de memória. 

TLDR; Em cenários em que você não deseja que os dados sejam alterados, uma estrutura de dados de tupla deve ser preferida a uma lista por motivos de memória. As tuplas também são mais rápidas do que as listas. 

Saiba mais sobre as estruturas de dados do Python neste tutorial. 

#4 Geradores

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

As compreensões de lista são a maneira pitônica de criar uma lista a partir de outro iterável - é muito mais rápido do que usar um loop for. Mas o que acontece se você acidentalmente mudar os colchetes de [] para ()? Você obtém um objeto gerador.

Em Python, os colchetes arredondados com lógica de compreensão de lista criam o que é conhecido como objeto gerador. Os geradores são um tipo especial de iterável. Ao contrário das listas, eles não armazenam seus itens. Em vez disso, eles armazenam instruções para gerar cada elemento em ordem e o estado atual das iterações.

Cada elemento é gerado somente quando solicitado, usando uma técnica chamada avaliação preguiçosa. A principal vantagem dessa dica do Python usando um gerador é que ela usa menos memória, pois a sequência inteira não é criada de uma vez. 

#5 Aliasing 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
2278459070720
2278459070720
[1, 2, 3, 4, 7]
"""

Python é uma linguagem de programação orientada a objetos - tudo é um objeto. Portanto, atribuir um objeto a um identificador é criar uma referência ao objeto. 

Quando atribuímos um identificador a outro identificador, acabamos com dois identificadores que fazem referência ao mesmo objeto. Esse é um conceito conhecido como aliasing. As alterações em um alias afetarão o outro. Às vezes, esse comportamento é desejado, mas, com frequência, ele nos pega desprevenidos. 

Uma maneira de contornar isso é evitar o aliasing ao usar objetos mutáveis. Outra solução poderia ser criar um clone do objeto original em vez de uma referência. 

A maneira mais direta de criar um clone é aproveitar o fatiamento: 

b = a[:] 

Isso criará uma nova referência a um objeto de lista no identificador b. 

Você poderia criar muitas outras soluções, como chamar list(a) ao atribuir os dados a outro identificador e usar o método copy()

#6 O operador "not" (não)

a = []
print(not a)

"""
True
"""

Nossa próxima dica de Python é a maneira mais fácil de verificar se sua estrutura de dados está vazia usando o operador not. A função embutida do Python não embutido do Python é um operador lógico que retorna True (verdadeiro) se a expressão não for verdadeira, caso contrário, retornará False (falso) - ele inverte o valor de verdade das expressões e objetos booleanos.  

Outra forma de uso que você pode ver é em uma instrução if: 

if not a:
    # do something... 

Quando a é verdadeiro então o not retornará Falsee vice-versa. 

É difícil de entender, mas você deve tentar. 

#7 F-strings

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

Ocasionalmente, talvez seja necessário formatar um objeto string; o Python 3.6 introduziu um recurso interessante chamado f-strings para simplificar esse processo. É útil entender como as cadeias de caracteres eram formatadas antes da nova versão para que você possa entender melhor o novo método. 

Veja como as cadeias de caracteres costumavam ser formatadas: 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

Essencialmente, a nova forma de formatação é mais rápida, mais legível, mais concisa e mais difícil de errar.

Outro uso de f-strings é imprimir o nome de um identificador junto com o valor. Isso foi introduzido no Python 3.8.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Para saber mais, confira este tutorial sobre formatação de string F em Python

#8 O parâmetro "end" das funções de impressão

a = ["english", "french", "spanish", "german", "twi"]
for language in a:
    print(language, end=" ")

"""
english french spanish german twi
"""

É bastante comum você usar um print sem definir nenhum de seus parâmetros opcionais. Consequentemente, muitos pythonistas não sabem que você pode controlar a saída até certo ponto.

Um parâmetro opcional que podemos alterar é o final. O parâmetro end especifica o que deve ser mostrado no final de uma chamada para um parâmetro print para um comando print. 

O padrão de end é "\n", que diz ao Python para iniciar uma nova linha. No código acima, alteramos para espaço. Assim, a saída retornada de todos os elementos da nossa lista é impressa na mesma linha.

#9 Acrescentar à tupla

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

Já sabemos que as tuplas são imutáveis - veja o truque do Python #3 List vs. Tuplas. A tentativa de alterar o estado de uma tupla geraria um TypeError. Mas, se você pensar em um objeto tupla como uma sequência de nomes com associações a objetos que não podem ser alterados, talvez veja as coisas de forma diferente.

Os dois primeiros elementos da nossa tupla são números inteiros, ou seja, são imutáveis. O último elemento da nossa tupla é uma lista, um objeto mutável em Python.

Se considerarmos que nossa lista é apenas mais um nome em uma sequência com uma ligação a um objeto que não pode ser alterado, perceberemos que a lista ainda pode ser modificada de dentro da tupla.

Recomendamos que você faça isso na prática? Provavelmente não, mas é uma daquelas coisas que é bom você saber!

#10 Mesclando dicionários

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

No Python 3.9 e superior, é possível mesclar dicionários usando | (bitewise OR). Não há muito mais a dizer sobre esse truque específico do Python, a não ser que é uma solução muito mais legível!  

#Operador ternário / expressões de condição 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

No código acima, você pode ver o que é conhecido como operador ternário - ele também é chamado de expressão condicional entre nomes. Usamos operadores ternários para avaliar coisas com base no fato de uma condição ser verdadeira ou falsa.

Outra maneira de escrever o código acima é a seguinte:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Embora ambos os conjuntos de código resultem no mesmo resultado, observe como a condicional ternária nos permite escrever um código muito mais curto e claro. É o que os pitonistas chamariam de maneira mais "pitônica" de escrever código. 

#12 Remover duplicatas de listas

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

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

A maneira mais simples de remover elementos duplicados de uma lista é converter a lista em um conjunto (e depois voltar para uma lista, se você desejar).

Com base na mutabilidade, os conjuntos e as listas são bastante semelhantes em Python. Podemos adicionar e remover elementos de ambas as estruturas de dados à vontade, mas elas ainda são extremamente diferentes.

As listas são ordenadas, indexadas com base zero e mutáveis. Os conjuntos não são ordenados e não são indexados. Os elementos em um conjunto devem ser de um tipo imutável, mesmo que o conjunto em si seja mutável - tentar recuperar um elemento por meio de um índice ou modificar um elemento gerará um erro.

Outra diferença importante entre conjuntos e listas é que os conjuntos não podem conter duplicatas. Foi isso que nos ajudou a remover os elementos duplicados de nossa lista.

#13 Sublinhado autônomo 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

O sublinhado (_) é um identificador legal em Python, portanto, é possível usá-lo para fazer referência a um objeto. Mas o sublinhado também tem outra responsabilidade: armazenar o resultado da última avaliação.

A documentação afirma que "o interpretador interativo torna o resultado da última avaliação disponível na variável _. (Ele é armazenado no módulo integrado, juntamente com funções integradas como impressão)."

Como não atribuímos o sublinhado a um objeto antes de chamá-lo na primeira linha, recebemos um erro. Entretanto, quando calculamos o resultado de 1 + 2, o interpretador interativo armazenou o resultado no identificador _ para nós. 

#14 Sublinhado para ignorar valores

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

Na dica Python nº 13, descobrimos que o interpretador interativo disponibiliza o último resultado de uma avaliação no identificador de sublinhado (_), mas esse não é seu único caso de uso.

Também podemos usá-lo para representar objetos com os quais não nos importamos ou que não usaríamos em um momento posterior do programa. Isso é importante porque o uso de um identificador em vez de um sublinhado (_) gerará um erro F841 quando tentarmos fazer o linting em nosso programa. Um erro F841 simplesmente indica que um nome de variável local foi atribuído, mas não foi usado no programa, o que é uma prática ruim.

#15 Trailing Underscores

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

Continuando com os dois truques anteriores, o uso do sublinhado (_) do Python, outra finalidade dele é evitar conflitos com as palavras-chave do Python. 

A PEP 8 menciona que um sublinhado à direita (_) deve ser "usado por convenção para evitar conflitos com palavras-chave do Python". Ele também afirma que "geralmente é melhor acrescentar um único sublinhado à direita em vez de usar uma abreviação ou corrupção ortográfica". Assim, list_ é melhor do que lst."

#16 Sublinhados principais

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

Muitas vezes, você verá que os programadores Python experientes tendem a colocar um sublinhado como prefixo em um identificador ou nome de método, e por um bom motivo.

O sublinhado prefixado em um identificador ou método tem um significado oculto: essa variável ou método destina-se apenas ao uso interno. Essencialmente, é uma isenção de responsabilidade para outros programadores que foi definida no PEP 8, mas não é aplicada pelo Python. Portanto, os sublinhados à esquerda são um indicador fraco.

Ao contrário do Java, o Python não faz uma distinção clara entre variáveis privadas e públicas. Em outras palavras, ele só tem significado porque a comunidade Python concordou que ele tivesse significado. Sua inclusão não afeta o comportamento de seus programas.

#17 Underscore Visual

Até agora, abordamos três casos de uso diferentes para o sublinhado, mas você pode conferir nosso tutorial para saber mais sobre a função do sublinhado (_) em Python

number = 1_500_000
print(number)

"""
15000000
"""

Outra maneira de usar o sublinhado é como um separador visual para o agrupamento de dígitos em literais de números integrais, de ponto flutuante e complexos - isso foi introduzido no Python 3.6. 

A ideia era ajudar a facilitar a leitura de literais longos ou literais cujo valor deveria ser claramente separado em partes - você pode ler mais sobre isso na PEP 515.

#18 __name__ == “__main__” 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

Há uma grande chance de você ter visto essa sintaxe em vários programas Python; o Python usa um nome especial chamado "__main__" e o define como um identificador chamado __name__ se o arquivo Python que estiver sendo executado for o programa principal.

Se decidirmos importar o módulo exibido na captura de tela para outro módulo (arquivo Python) e executar esse arquivo, a verdade da expressão em nosso código será falsa. Isso ocorre porque, quando importamos de outro módulo, o identificador __name__ é definido como o nome do módulo (arquivo Python). 

#19 O método 'setdefault 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"

Você pode querer definir um valor para várias chaves em um dicionário. Por exemplo, quando você está monitorando a contagem de palavras em um corpus. A maneira comum de fazer isso é a seguinte: 

  1. Verificar se a chave existe no dicionário
  2. Em caso afirmativo, aumente o valor em 1.
  3. Se não for o caso, adicione-o e defina o valor como 1.

É assim que você vê no código:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Uma maneira mais concisa de fazer isso é usar o método setdefault() em seu objeto de dicionário.

O primeiro argumento passado para o método é a chave que queremos verificar. O segundo argumento passado é o valor para o qual você definirá a chave se ela ainda não existir no dicionário; se a chave existir, o método retornará o valor da chave. Portanto, ele não seria alterado.

#20 Correspondência de Regex

import re

number = re.compile(r"(0?)(\+44)?\d(10)")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

A maioria das pessoas sabe que podemos pesquisar coisas usando CTRL + F (Windows), mas se você não souber exatamente o que está pesquisando, como poderá encontrá-lo? A resposta é procurar por padrões.  

Por exemplo, os números do Reino Unido seguem um padrão semelhante: eles terão um zero no início mais dez números ou +44 em vez de zero e dez números - a segunda instância indica que está em seu formato internacional. 

As expressões regulares são uma grande economia de tempo. Se tivéssemos que codificar regras para capturar as instâncias em nossa imagem em vez de regex, isso poderia levar mais de 10 linhas de código. 

Aprender como funcionam as expressões regulares é fundamental, mesmo que você não escreva códigos. A maioria dos editores de texto e processadores de texto modernos permite que você use expressões regulares para localizar e substituir recursos.

#21 Regex Pipe

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

As expressões regulares têm um caractere especial chamado pipe(|) que permite que você combine uma de muitas expressões, e elas podem ser usadas em qualquer lugar. Isso é muito útil quando você tem vários padrões semelhantes.

Por exemplo, "Superman", "Superwoman" e "Superhuman" têm o mesmo prefixo. Assim, você pode aproveitar o pipe para manter a parte do padrão que é recorrente e alterar as partes que você precisa que sejam diferentes. Mais uma vez, você economiza um tempo precioso.

Observe a pegadinha: se todas as expressões que você deseja corresponder ocorrerem no mesmo texto, a primeira ocorrência do texto a corresponder será retornada - ou seja, "Um exemplo de texto contendo Superwoman, Superman, Superhuman" retornaria Superwoman.

#22 O parâmetro "sep" da função de impressão

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")




"""
04 10 2022
04/10/2022
04.10.2022
"""

O número de programadores Python que não conhecem todos os recursos da função print() é assustador. Se "Hello World" foi o seu primeiro programa, a função print() provavelmente foi uma das primeiras funções incorporadas que você viu ao aprender Python. Usamos print() para exibir mensagens formatadas na tela, mas há muito mais na função print()

No código acima, mostramos diferentes maneiras de exibir nossa mensagem formatada. O parâmetro sep é um argumento opcional na função print() que nos permite especificar como os objetos devem ser separados se incluirmos mais de um. 

O padrão é separá-los com um espaço, mas alteramos essa funcionalidade com nossos comandos de impressão - um em que sep é definido como "" e outro em que sep é definido como ".".

#23 Funções Lambda 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

As funções Lambda levam você a coisas de nível mais intermediário e avançado que você pode fazer com Python - aprenda Python Intermediário com este curso. Eles parecem complicados à primeira vista, mas são bastante simples.

Em nosso código de exemplo, usamos apenas um argumento, mas poderíamos ter usado vários, se quiséssemos:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

Em essência, a palavra-chave lambda nos permite criar funções pequenas, restritas e anônimas em uma linha. Elas se comportam como uma função normal declarada com a palavra-chave def, exceto que essas funções não têm um nome.

#24 O método "swapcase

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

O método swapcase() é aplicado a um objeto string para permitir que você altere as letras maiúsculas para minúsculas e vice-versa em uma única linha de código. Não há muitos casos de uso para o método swapcase(), mas é bom que você saiba.

#25 O método 'isalnum'

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Digamos que estamos criando um programa que exige que os usuários insiram uma senha, mas ela deve ter uma combinação de números e letras. Podemos fazer isso em uma linha de código chamando isalnum() na instância da string.

O método verifica se todos os caracteres fazem parte do alfabeto (A-Za-z) e numérico (0-9). Um espaço ou símbolo (!#%$&? etc.) retornará Falso.

#26 Tratamento de exceções

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except: ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ratio(x=400, y=0))

"""
400.0
"""

Os programas Python são encerrados quando encontram um erro.

Às vezes, não queremos esse comportamento, como quando temos um usuário final interagindo com nosso código. Seria muito ruim se o nosso código fosse encerrado prematuramente em tal instância?

Há algumas maneiras de pensar sobre como lidar com o caso excepcional. A maioria dos programadores Python normalmente adota a ideia de que é mais fácil pedir perdão do que obter permissão. Isso significa que eles preferem capturar um erro levantado fornecendo um contexto circundante que seja capaz de lidar com uma exceção. A ideia por trás desse pensamento é que não faz sentido perder tempo tentando se proteger contra todos os vários casos excepcionais.

Mas isso só é válido quando há um mecanismo para lidar com um problema depois que ele ocorre.

#27 Identificando as diferenças nas listas

list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

Aqui estão três métodos diferentes para comparar a diferença entre duas listas em Python. 

Observação: A menos que você saiba com certeza que a lista_1 é um subconjunto da lista_2, a solução 1 não é a mesma que as outras duas soluções.

#28 Args & Kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

Usamos *args e **kwargs como parâmetros de uma função quando não temos conhecimento do número de variáveis que nossa função deve esperar. 

O parâmetro *args permite que você passe um número variável de parâmetros para uma função quando ela não tiver palavras-chave (ou seja, os parâmetros que passamos não precisam de um nome associado). Por outro lado, o parâmetro **kwargs nos permite passar um número arbitrário de parâmetros com palavras-chave para uma função.

Na verdade, as palavras *args e **kwargs não são tão mágicas: a verdadeira magia está nos asteriscos (*). Isso significa que poderíamos ter usado qualquer palavra após os asteriscos, mas o uso de args e kwargs é uma prática comum e é imposta entre os desenvolvedores do Python. 

#29 A elipse

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

O Ellipsis é um objeto Python que pode ser chamado fornecendo uma sequência de três pontos (...) ou chamando o próprio objeto (Ellipsis).

Seu uso mais notável é para acessar e dividir matrizes multidimensionais no NumPy, por exemplo:

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

Mas outro uso de Ellipsis é como um espaço reservado em uma função não implementada. 

Isso significa que você poderia passar Ellipsis, ..., ou passar, e todos eles ainda seriam válidos.

#30 Compreensão de listas

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Nosso último truque em Python são as compreensões de lista, uma maneira elegante de criar uma lista a partir de outra sequência. Eles permitem que você execute lógica e filtragem sofisticadas, como fizemos no código acima.

Há outras maneiras de atingir o mesmo objetivo; por exemplo, poderíamos ter usado uma função lambda da seguinte forma:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Mas vários pitonistas argumentariam que essa solução é muito menos legível do que a compreensão de lista.

Confira este tutorial para saber mais sobre as compreensões de lista do Python.   

Temas

Principais cursos de Python

Certificação disponível

curso

Python intermediário

4 hr
1.1M
Eleve o nível de suas habilidades em ciência de dados criando visualizações usando Matplotlib e manipulando DataFrames com pandas.
Ver DetalhesRight Arrow
Iniciar curso
Ver maisRight Arrow
Relacionado
Data Skills

blog

6 práticas recomendadas de Python para um código melhor

Descubra as práticas recomendadas de codificação Python para escrever os melhores scripts Python da categoria.
Javier Canales Luna's photo

Javier Canales Luna

13 min

5 Python Challenges

blog

5 desafios Python para desenvolver suas habilidades

Aumente o nível de suas habilidades em Python com estes cinco desafios de codificação em Python. Faça um teste para ver se você consegue completar um em uma semana!
DataCamp Team's photo

DataCamp Team

5 min

blog

Mais de 60 projetos Python para todos os níveis de conhecimento

60 ideias de projetos de ciência de dados que os cientistas de dados podem usar para criar um portfólio sólido, independentemente de sua especialização.
Bekhruz Tuychiev's photo

Bekhruz Tuychiev

16 min

Python snake

blog

Para que o Python é usado? 7 usos reais do Python

Você já se perguntou para que o Python é usado no mundo real? Confira 7 usos práticos para essa poderosa linguagem de programação.
Elena Kosourova's photo

Elena Kosourova

10 min

tutorial

21 ferramentas essenciais do Python

Aprenda sobre as ferramentas Python essenciais para o desenvolvimento de software, raspagem e desenvolvimento da Web, análise e visualização de dados e aprendizado de máquina.
Abid Ali Awan's photo

Abid Ali Awan

6 min

tutorial

Tutorial e exemplos de funções e métodos de lista do Python

Saiba mais sobre as funções e os métodos da Lista do Python. Siga exemplos de código para list() e outras funções e métodos Python agora!
Abid Ali Awan's photo

Abid Ali Awan

7 min

Ver maisVer mais