1.Argparse

Em Python, o módulo `argparse` fornece uma maneira conveniente de analisar argumentos de linha de comando e fornecer melhor legibilidade para seus scripts Python. A função `parser.add_argument()` é uma das funções mais importantes neste módulo e é usada para adicionar opções e argumentos de linha de comando. Sua sintaxe comum é a seguinte:

```python
parser.add_argument("nome", ajuda="descrição")
```

Entre eles, `name` é o nome do parâmetro e `help` é a descrição do parâmetro. Por exemplo:

```python
import argparse

parser = argparse.ArgumentParser()
parser.add_argument("nome", help="digite seu nome")
args = parser.parse_args()

print("Olá, " + args.name)
```

Neste exemplo, usamos a função `parser.add_argument()` para adicionar um argumento chamado `name`. Quando o usuário executa o script, ele precisa especificar um valor de parâmetro depois dele. O programa lê os argumentos da linha de comando e imprime a saudação correspondente.

2.Tente-exceto

A instrução try-except do Python é usada para capturar e manipular exceções. Ele permite que você tente algo quando o programa der errado e execute algum código alternativo quando algo der errado.

A sintaxe da instrução try-except é a seguinte:

```
try:
# bloco de código
exceto ExceptionType:
# bloco de manipulação de exceção
```

Entre eles, a instrução try contém um bloco de código que precisa ser tentado para executar.Se uma exceção for lançada durante a execução, o bloco será ignorado e o bloco de tratamento de exceção na instrução except será executado. ExceptionType indica o tipo de exceção que você deseja manipular.

Além de ExceptionType, vários blocos exceto podem ser usados para lidar com diferentes tipos de exceções. Você pode usar uma instrução except vazia para capturar todos os tipos de exceções, mas isso não é uma boa prática.

Aqui está um exemplo de uma instrução try-except que tenta abrir um arquivo e ler seu conteúdo, capturando uma exceção FileNotFoundError e imprimindo uma mensagem de erro se o arquivo não existir:

```
try:
f = open("test.txt", "r")
print(f.read())
except FileNotFoundError:
print("Arquivo não encontrado.")
```

Observe que a instrução try-except só pode capturar exceções geradas durante a execução do programa, ela não pode lidar com erros estáticos, como erros de sintaxe. Portanto, ao escrever programas Python, você deve aprender a evitar esses erros e usar try-except para lidar com erros de tempo de execução que ocorrem no programa.

3. *args e **kwargs

*args e **kwargs são dois argumentos especiais comumente usados nas definições de funções do Python. Eles podem tornar as funções mais flexíveis, permitindo que aceitem qualquer número de argumentos posicionais e palavras-chave.

*args (asterisco args) é usado para passar qualquer número de argumentos posicionais. Use *args quando não tiver certeza de quantos argumentos posicionais a função terá.

Aqui está um exemplo mostrando como usar *args em uma função:

```python
def my_sum(*args):
resultado = 0
for arg in args:
resultado += arg
return resultado

print(my_sum(1, 2, 3)) # output 6
print(my_sum(1, 2, 3, 4, 5)) # output 15
```

**kwargs (duplo asterisco kwargs) é usado para passar qualquer número de argumentos de palavra-chave. Use **kwargs quando não tiver certeza de quantos argumentos de palavra-chave a função terá.

Aqui está um exemplo que demonstra como usar **kwargs em uma função:

```python
def print_kwargs(**kwargs):
for key, value in kwargs.items():
print(f"{key} = {value}")

print_kwargs(name="Alice", idade=30, cidade="Nova York") # 输出 nome = Alice, idade = 30, cidade = Nova York ``
`

Deve-se notar que *args e **kwargs são apenas nomes de parâmetros especiais na definição da função, você pode optar por usar outros nomes. Mas, em geral, *args e **kwargs são convenções amplamente usadas.

4.Lambda

Um lambda em Python é uma função anônima, também conhecida como "literal de função". Essas funções não têm nome, podem ser definidas usando a palavra-chave lambda e geralmente têm apenas uma linha de código.

A sintaxe de uma função lambda é a seguinte:

```
argumentos lambda do python: expressão
```

Entre eles, argumentos são os parâmetros passados para a função e expressão é o valor de retorno da função.

Aqui está um exemplo que demonstra como definir uma função usando lambdas para calcular o quadrado de um número:

```python
square = lambda x: x**2
print(square(4)) # output 16
```

As funções do Lambda também podem ser usadas em conjunto com outras funções do Python, como as funções integradas map e filter:

```
números python = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))
print(squares) # 输出 [1, 4, 9, 16, 25 ]

pares_números = lista(filtro(lambda x: x % 2 == 0, números))
print(números_pares) # 输出 [2, 4]
```

Deve-se notar que, como as funções lambda são funções anônimas, elas geralmente são adequadas apenas para operações simples. Se você precisar definir funções mais complexas, é recomendável usar instruções def regulares para definir funções nomeadas.

5.Embalar e desembalar

Empacotar e desempacotar em Python referem-se a empacotar múltiplas variáveis com tuplas ou listas ou desempacotar tuplas ou listas para obter os valores nelas.

1. Embalagem

A embalagem é o processo de combinar vários valores em uma sequência (como uma tupla). Essa sequência pode ser uma tupla de comprimento conhecido ou uma lista de comprimento variável. Por exemplo:

```python
# embalagem tupla
tuple1 = 1, 'hello', 3.14
print(tuple1) # 输出 (1, 'hello', 3.14)

# list packing
list1 = [1, 'hello', 3.14]
print(list1) # 输出 [1, 'hello', 3.14]
```

2. Desempacotando

Desempacotar é o processo de quebrar uma sequência (como uma tupla ou lista) em variáveis separadas. Por exemplo:

```python
# tuple unpacking
a, b, c = tuple1
print(a, b, c) # 输出 1 hello 3.14

# list unpacking
x, y, z = list1
print(x, y, z) # 输出 1 hello 3.14
```

Ao descompactar uma sequência, um * pode ser usado para convertê-la em um número variável de listas de argumentos. Por exemplo:

```
números python = [1, 2, 3, 4, 5]
a, *b, c = números
print(a, b, c) # 输出 1 [2, 3, 4] 5
```

No código acima, a e c são o primeiro e o último elemento, enquanto b é uma lista explícita de números de variáveis. Ao usar *, deve ser o último elemento.

Observe que empacotar e desempacotar pode ser aplicado a todos os iteráveis, incluindo strings, listas, tuplas, conjuntos e dicionários.

6. Escopo aninhado

Em Python, o escopo de uma função é aninhado em outras funções ou no namespace global.Esse escopo aninhado é chamado de escopo aninhado.

Quando uma função é definida dentro de outra função, a função interna pode acessar as variáveis da função externa e pode modificar essas variáveis. No entanto, quando o nome da variável da função interna é o mesmo da função externa, ocorre um conflito de nomes e a palavra-chave não local precisa ser usada para acessar e modificar a variável da função externa. Por exemplo:

```python
def exterior():
x = 10

def interior():
não-local x
x += 1
print(x)

interior()

outer() # saída 11
```

No código acima, a função interna pode acessar e modificar a variável x da função externa e declara que x vem da função externa por meio da palavra-chave não local.

Além disso, em Python existe uma função especial capaz de retornar variáveis de escopos aninhados. Essa função é chamada de fechamento. Closures permitem que uma função retorne outra função, e essa função retornada pode acessar variáveis da função externa. Por exemplo:

```python
def externo(y):
def interno(x):
retorna x + y
retorna interno

add_10 = outer(10)
print(add_10(5)) # output 15
```

No código acima, a função externa retorna uma função interna interna e mantém o valor da variável y na função interna. Em seguida, atribua a função interna à variável add_10, portanto, chamar add_10(5) retornará 15 porque o valor de y é 10. Como a função interna inner tem escopo aninhado, ela é capaz de acessar seus próprios parâmetros e variáveis da função externa (por exemplo, y ). Este é o poder dos encerramentos.

7. Variável livre

Em Python, se uma variável é referenciada dentro de uma função que não está declarada na função, então a variável é considerada uma variável livre (variável livre).

Por exemplo:

```python
def exterior():
x = 10

def interior():
print(x)

return interior

func = outer()
func() # saída 10
```

No código acima, a função interna refere-se à variável x, mas x não é declarado na função interna, então x é uma variável livre. Quando a função interna é chamada, ela procura o escopo externo mais próximo (ou seja, o escopo da função externa) para encontrar o valor da variável x.

Se o valor da variável x for modificado na função externa, a função interna também imprimirá o novo valor quando a função interna for chamada:

```python
def outer():
x = 10

def inner():
print(x)

x = 20 # Modifica o valor de x
return inner

func = outer()
func() # saída 20
```

No código acima, quando a função externa retorna para a função interna, o valor de x foi modificado para 20. Assim, quando a função interna é chamada, ela imprime o novo valor 20.

Deve-se observar que, se você atribuir um valor a uma variável livre em uma função interna, o Python tratará a variável como uma variável local em vez de uma variável livre. Por exemplo:

```python
def outer():
x = 10

def inner():
x = 20 # Atribui x a 20 (considerada uma variável local)
print(x)

return inner

func = outer()
func() # saída 20
```

No código acima, x na função interna recebe o valor 20, mas isso é tratado como uma variável local, não uma variável livre. Assim, quando a função interna é chamada, ela imprime o valor 20 da variável local x em vez do valor 10 da variável externa x.

8. Decorador

Decoradores são um recurso muito comum em Python que permite adicionar funcionalidade extra a funções e classes. Os decoradores são divididos em decoradores com parâmetros e decoradores sem parâmetros.

## Decorador com parâmetros

Um decorador com parâmetros geralmente define uma função decorada que aceita os parâmetros do decorador e retorna uma nova função decorada que modifica o comportamento da função decorada. Aqui está um exemplo de um decorador com parâmetros:

```python
def repeat(num):
def my_decorator(func):
def wrapper(*args, **kwargs):
for i in range(num):
print("Antes da função ser chamada.")
result = func(* args, **kwargs)
print("Depois que a função é chamada.")
return result
return wrapper
return my_decorator

@repeat(num=3)
def say_hello(name):
print(f"Olá, {name}!")

diga_olá("João")
```

No exemplo acima, o decorador `repeat` recebe o parâmetro `num`, que faz com que a função `say_hello` seja chamada 3 vezes. A função `my_decorator` no decorator recebe a função `say_hello` como um argumento e modifica seu comportamento.

## Decorador sem parâmetros

Um decorador sem parâmetros refere-se à definição direta de uma função para modificar o comportamento da função decorada sem passar parâmetros adicionais. Aqui está um exemplo de um decorador que não recebe parâmetros:

```python
def my_decorator(func):
def wrapper(*args, **kwargs):
print("Antes da chamada da função.")
result = func(*args, **kwargs)
print("Depois da chamada da função. ")
retorna resultado
retorna wrapper

@my_decorator
def say_hello(name):
print(f"Olá, {name}!")

diga_olá("João")
```

No exemplo acima, a própria função `my_decorator` é um decorador, sua função é imprimir o log antes e depois da função `say_hello` ser chamada e retornar o resultado da função original. Não há parâmetros extras passados para o decorador, basta aplicar `@my_decorator` à função `say_hello`.

Em geral, decoradores são um recurso muito poderoso em Python, por meio do qual podemos facilmente adicionar funcionalidades adicionais a funções e classes, melhorando assim a capacidade de reutilização e manutenção do código.

[Python]Notas de acabamento de detalhes em Python