1.Argparse
En Python, el módulo `argparse` proporciona una manera conveniente de analizar los argumentos de la línea de comandos y brinda una mejor legibilidad para sus scripts de Python. La función `parser.add_argument()` es una de las funciones más importantes de este módulo y se usa para agregar argumentos y opciones de línea de comandos. Su sintaxis común es la siguiente:
```python
parser.add_argument("nombre", ayuda="descripción")
```
Entre ellos, `name` es el nombre del parámetro y `help` es la descripción del parámetro. Por ejemplo:
```Python
import argparse
analizador = argparse.ArgumentParser()
analizador.add_argument("nombre", ayuda="ingrese su nombre")
args = analizador.parse_args()
print("Hola, " + args.nombre)
```
En este ejemplo, usamos la función `parser.add_argument()` para agregar un argumento llamado `name`. Cuando el usuario ejecuta el script, debe especificar un valor de parámetro después. El programa lee los argumentos de la línea de comando e imprime el saludo correspondiente.
2.Prueba-excepto
La declaración try-except de Python se usa para capturar y manejar excepciones. Le permite probar algo cuando el programa sale mal y ejecutar algún código de respaldo cuando algo sale mal.
La sintaxis de la sentencia try-except es la siguiente:
```
try:
# bloque de código
excepto ExceptionType:
# bloque de manejo de excepciones
```
Entre ellos, la declaración de prueba contiene un bloque de código que debe intentarse para ejecutar.Si se lanza una excepción durante la ejecución, el bloque se omitirá y se ejecutará el bloque de manejo de excepciones en la declaración de excepción. ExceptionType indica el tipo de excepción que desea manejar.
Además de ExceptionType, se pueden usar varios bloques de excepción para manejar diferentes tipos de excepciones. Puede usar una declaración de excepción vacía para capturar todos los tipos de excepciones, pero esta no es una buena práctica.
Aquí hay un ejemplo de una declaración de prueba y excepción que intenta abrir un archivo y leer su contenido, detectando una excepción FileNotFoundError e imprimiendo un mensaje de error si el archivo no existe:
```
intente:
f = open("test.txt", "r")
print(f.read())
excepto FileNotFoundError:
print("Archivo no encontrado")
```
Tenga en cuenta que la instrucción try-except solo puede detectar excepciones generadas durante la ejecución del programa, no puede manejar errores estáticos como errores de sintaxis. Por lo tanto, al escribir programas de Python, debe aprender a evitar estos errores y usar try-except para manejar los errores de tiempo de ejecución que ocurren en el programa.
3. *argumentos y **kwargos
*args y **kwargs son dos argumentos especiales comúnmente utilizados en las definiciones de funciones de Python. Pueden hacer que las funciones sean más flexibles al permitirles aceptar cualquier cantidad de argumentos posicionales y de palabras clave.
*args (asterisk args) se usa para pasar cualquier cantidad de argumentos posicionales. Use *args cuando no esté seguro de cuántos argumentos posicionales tomará la función.
Aquí hay un ejemplo que muestra cómo usar *args en una función:
```python
def my_sum(*args):
result = 0
for arg in args:
result += arg
return result
print(my_sum(1, 2, 3)) # salida 6
print(my_sum(1, 2, 3, 4, 5)) # salida 15
```
**kwargs (kwargs de doble asterisco) se utiliza para pasar cualquier número de argumentos de palabras clave. Use **kwargs cuando no esté seguro de cuántos argumentos de palabra clave tomará la función.
Aquí hay un ejemplo que demuestra cómo usar **kwargs en una función:
```python
def print_kwargs(**kwargs):
para clave, valor en kwargs.items():
print(f"{clave} = {valor}")
print_kwargs(nombre="Alicia", edad=30, ciudad="Nueva York") # 输出 nombre = Alicia, edad = 30, ciudad = Nueva York ``
`
Cabe señalar que *args y **kwargs son solo nombres de parámetros especiales en la definición de la función, puede optar por usar otros nombres. Pero, en general, *args y **kwargs son convenciones muy utilizadas.
4.Lambda
Una lambda en Python es una función anónima, también conocida como "función literal". Estas funciones no tienen nombre, se pueden definir con la palabra clave lambda y, por lo general, solo tienen una línea de código.
La sintaxis de una función lambda es la siguiente:
```Python
lambda argumentos: expresión
```
Entre ellos, los argumentos son los parámetros que se pasan a la función y la expresión es el valor de retorno de la función.
Aquí hay un ejemplo que demuestra cómo definir una función usando lambdas para calcular el cuadrado de un número:
```python
cuadrado = lambda x: x**2
print(cuadrado(4)) # salida 16
```
Las funciones de Lambda también se pueden usar junto con otras funciones de Python, como el mapa y el filtro de funciones integrado:
```
números de Python = [1, 2, 3, 4, 5]
cuadrados = lista (mapa (lambda x: x ** 2, números))
impresión (cuadrados) # 输出 [1, 4, 9, 16, 25 ]
numeros_pares = lista(filtro(lambda x: x % 2 == 0, numeros))
print(numeros_pares) # 输出 [2, 4]
```
Cabe señalar que, dado que las funciones lambda son funciones anónimas, generalmente solo son adecuadas para operaciones simples. Si necesita definir funciones más complejas, se recomienda utilizar declaraciones def regulares para definir funciones con nombre.
5.Embalaje y desembalaje
Empaquetar y desempaquetar en Python se refiere a empaquetar múltiples variables con tuplas o listas o desempaquetar tuplas o listas para obtener los valores en ellas.
1. Embalaje
El empaquetado es el proceso de combinar múltiples valores en una secuencia (como una tupla). Esta secuencia puede ser una tupla de longitud conocida o una lista de longitud variable. Por ejemplo:
```python
# empaquetado de tuplas
tupla1 = 1, 'hola', 3.14
print(tupla1) # 输出 (1, 'hola', 3.14)
# lista empaque
lista1 = [1, 'hola', 3.14]
print(lista1) # 输出 [1, 'hola', 3.14]
```
2. Desembalaje
Desempaquetar es el proceso de dividir una secuencia (como una tupla o una lista) en variables separadas. Por ejemplo:
```python
# tupla desempaquetando
a, b, c = tupla1
print(a, b, c) # 输出 1 hola 3.14
# lista desempaquetando
x, y, z = list1
print(x, y, z) # 输出 1 hola 3.14
```
Al desempaquetar una secuencia, se puede usar un * para convertirla en un número variable de listas de argumentos. Por ejemplo:
```
números de Python = [1, 2, 3, 4, 5]
a, *b, c = números
print(a, b, c) # 输出 1 [2, 3, 4] 5
```
En el código anterior, a y c son los elementos primero y último, mientras que b es una lista de números variables explícita. Al usar *, debe ser el último elemento.
Tenga en cuenta que el empaquetado y desempaquetado se puede aplicar a todos los iterables, incluidas cadenas, listas, tuplas, conjuntos y diccionarios.
6. Alcance anidado
En Python, el ámbito de una función está anidado en otras funciones o en el espacio de nombres global.Este ámbito anidado se denomina ámbito anidado.
Cuando una función se define dentro de otra función, la función interna puede acceder a las variables de la función externa y puede modificar estas variables. Sin embargo, cuando el nombre de la variable de la función interna es el mismo que el de la función externa, se produce un conflicto de nombres y es necesario usar la palabra clave no local para acceder y modificar la variable de la función externa. Por ejemplo:
```python
def exterior():
x = 10
def interior():
no local x
x += 1
print(x)
interior()
exterior() # salida 11
```
En el código anterior, la función interna puede acceder y modificar la variable x de la función externa y declara que x proviene de la función externa a través de la palabra clave no local.
Además, en Python hay una función especial capaz de devolver variables desde ámbitos anidados. Esta función se llama cierre. Los cierres permiten que una función devuelva otra función, y esta función devuelta puede acceder a las variables de la función externa. Por ejemplo:
```python
def exterior(y):
def interior(x):
devuelve x + y
devuelve interior
add_10 = exterior(10)
print(add_10(5)) # salida 15
```
En el código anterior, la función externa devuelve una función interna interna y mantiene el valor de la variable y en la función interna. Luego asigne la función interna a la variable add_10, de modo que llamar a add_10(5) devolverá 15 porque el valor de y es 10. Dado que la función interna interior tiene un alcance anidado, puede acceder a sus propios parámetros y variables de la función externa (por ejemplo, y). Este es el poder de los cierres.
7. Variable libre
En Python, si se hace referencia a una variable dentro de una función que no está declarada en la función, entonces la variable se considera una variable libre (free variable).
Por ejemplo:
```python
def exterior():
x = 10
def interior():
imprimir(x)
volver interior
func = exterior()
func() # salida 10
```
En el código anterior, la función interna se refiere a la variable x, pero x no se declara en la función interna, por lo que x es una variable libre. Cuando se llama a la función interna, busca el alcance externo más cercano (es decir, el alcance de la función externa) para encontrar el valor de la variable x.
Si el valor de la variable x se modifica en la función externa, la función interna también imprimirá el nuevo valor cuando se llame a la función interna:
```python
def outside():
x = 10
def inner():
print(x)
x = 20 # Modificar el valor de x
return inner
func = exterior()
func() # salida 20
```
En el código anterior, cuando la función exterior vuelve a la función interior, el valor de x se ha modificado a 20. Entonces, cuando se llama a la función interna, imprime el nuevo valor 20.
Cabe señalar que si asigna un valor a una variable libre en una función interna, Python tratará la variable como una variable local en lugar de una variable libre. Por ejemplo:
```python
def outside():
x = 10
def inner():
x = 20 # Asigna x a 20 (considerada una variable local)
print(x)
return internal
func = exterior()
func() # salida 20
```
En el código anterior, a x en la función interna se le asigna el valor 20, pero se trata como una variable local, no como una variable libre. Entonces, cuando se llama a la función interna, imprime el valor 20 de la variable local x en lugar del valor 10 de la variable x externa.
8. Decorador
Los decoradores son una característica muy común en Python que le permite agregar funcionalidad adicional a funciones y clases. Los decoradores se dividen en decoradores con parámetros y decoradores sin parámetros.
## Decorador con parámetros
Un decorador con parámetros normalmente define una función decorada que acepta los parámetros del decorador y devuelve una nueva función decorada que modifica el comportamiento de la función decorada. Aquí hay un ejemplo de un decorador con parámetros:
```python
def repeat(num):
def my_decorator(func):
def wrapper(*args, **kwargs):
for i in range(num):
print("Antes de llamar a la función")
result = func(* args, **kwargs)
print("Después de llamar a la función.")
devuelve el resultado
devuelve el envoltorio
devuelve mi_decorador
@repeat(num=3)
def say_hello(nombre):
print(f"Hola, {nombre}!")
decir_hola("Juan")
```
En el ejemplo anterior, el decorador `repeat` toma el parámetro `num`, lo que hace que la función `say_hello` se llame 3 veces. La función `my_decorator` en el decorador recibe la función `say_hello` como argumento y modifica su comportamiento.
## Decorador sin parámetros
Un decorador sin parámetros se refiere a definir directamente una función para modificar el comportamiento de la función decorada sin pasar parámetros adicionales. Aquí hay un ejemplo de un decorador que no toma parámetros:
```python
def my_decorator(func):
def wrapper(*args, **kwargs):
print("Antes de llamar a la función.")
result = func(*args, **kwargs)
print("Después de llamar a la función. ") envoltorio de
retorno de resultado de retorno
@my_decorator
def say_hello(nombre):
print(f"Hola, {nombre}!")
decir_hola("Juan")
```
En el ejemplo anterior, la función `my_decorator` en sí misma es un decorador, su función es imprimir el registro antes y después de llamar a la función `say_hello` y devolver el resultado de la función original. No se pasan parámetros adicionales al decorador, simplemente aplique `@my_decorator` a la función `say_hello`.
En general, los decoradores son una característica muy poderosa en Python, a través de la cual podemos agregar fácilmente funcionalidades adicionales a funciones y clases, mejorando así la reutilización y el mantenimiento del código.