Pedro Lobato
4 months ago
committed by
GitHub
GitHub
405 changed files with 4791 additions and 3131 deletions
@ -0,0 +1,61 @@ |
|||
# Tipos avanzados de Python { #advanced-python-types } |
|||
|
|||
Aquí tienes algunas ideas adicionales que podrían ser útiles al trabajar con tipos de Python. |
|||
|
|||
## Usar `Union` u `Optional` { #using-union-or-optional } |
|||
|
|||
Si por alguna razón tu código no puede usar `|`, por ejemplo si no está en una anotación de tipos sino en algo como `response_model=`, en lugar de usar la barra vertical (`|`) puedes usar `Union` de `typing`. |
|||
|
|||
Por ejemplo, podrías declarar que algo podría ser un `str` o `None`: |
|||
|
|||
```python |
|||
from typing import Union |
|||
|
|||
|
|||
def say_hi(name: Union[str, None]): |
|||
print(f"Hi {name}!") |
|||
``` |
|||
|
|||
`typing` también tiene un atajo para declarar que algo podría ser `None`, con `Optional`. |
|||
|
|||
Aquí va un Consejo desde mi punto de vista muy subjetivo: |
|||
|
|||
* 🚨 Evita usar `Optional[SomeType]` |
|||
* En su lugar ✨ **usa `Union[SomeType, None]`** ✨. |
|||
|
|||
Ambas son equivalentes y por debajo son lo mismo, pero recomendaría `Union` en lugar de `Optional` porque la palabra "**optional**" parecería implicar que el valor es opcional, y en realidad significa "puede ser `None`", incluso si no es opcional y sigue siendo requerido. |
|||
|
|||
Creo que `Union[SomeType, None]` es más explícito respecto a lo que significa. |
|||
|
|||
Se trata solo de palabras y nombres. Pero esas palabras pueden afectar cómo tú y tu equipo piensan sobre el código. |
|||
|
|||
Como ejemplo, tomemos esta función: |
|||
|
|||
```python |
|||
from typing import Optional |
|||
|
|||
|
|||
def say_hi(name: Optional[str]): |
|||
print(f"Hey {name}!") |
|||
``` |
|||
|
|||
El parámetro `name` está definido como `Optional[str]`, pero **no es opcional**, no puedes llamar a la función sin el parámetro: |
|||
|
|||
```Python |
|||
say_hi() # ¡Oh, no, esto lanza un error! 😱 |
|||
``` |
|||
|
|||
El parámetro `name` **sigue siendo requerido** (no es *opcional*) porque no tiene un valor por defecto. Aun así, `name` acepta `None` como valor: |
|||
|
|||
```Python |
|||
say_hi(name=None) # Esto funciona, None es válido 🎉 |
|||
``` |
|||
|
|||
La buena noticia es que, en la mayoría de los casos, podrás simplemente usar `|` para definir uniones de tipos: |
|||
|
|||
```python |
|||
def say_hi(name: str | None): |
|||
print(f"Hey {name}!") |
|||
``` |
|||
|
|||
Así que, normalmente no tienes que preocuparte por nombres como `Optional` y `Union`. 😎 |
|||
@ -1,7 +1,7 @@ |
|||
# Probando una Base de Datos { #testing-a-database } |
|||
# Escribiendo pruebas para una base de datos { #testing-a-database } |
|||
|
|||
Puedes estudiar sobre bases de datos, SQL y SQLModel en la <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">documentación de SQLModel</a>. 🤓 |
|||
|
|||
Hay un mini <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/" class="external-link" target="_blank">tutorial sobre el uso de SQLModel con FastAPI</a>. ✨ |
|||
|
|||
Ese tutorial incluye una sección sobre <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/" class="external-link" target="_blank">cómo probar bases de datos SQL</a>. 😎 |
|||
Ese tutorial incluye una sección sobre <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/" class="external-link" target="_blank">escribir pruebas para bases de datos SQL</a>. 😎 |
|||
|
|||
@ -0,0 +1,11 @@ |
|||
/// details | 🌐 Traducción por IA y humanos |
|||
|
|||
Esta traducción fue hecha por IA guiada por humanos. 🤝 |
|||
|
|||
Podría tener errores al interpretar el significado original, o sonar poco natural, etc. 🤖 |
|||
|
|||
Puedes mejorar esta traducción [ayudándonos a guiar mejor al LLM de IA](https://fastapi.tiangolo.com/es/contributing/#translations). |
|||
|
|||
[Versión en inglés](ENGLISH_VERSION_URL) |
|||
|
|||
/// |
|||
@ -0,0 +1,61 @@ |
|||
# Tipos Avançados de Python { #advanced-python-types } |
|||
|
|||
Aqui estão algumas ideias adicionais que podem ser úteis ao trabalhar com tipos em Python. |
|||
|
|||
## Usando `Union` ou `Optional` { #using-union-or-optional } |
|||
|
|||
Se, por algum motivo, seu código não puder usar `|`, por exemplo, se não for em uma anotação de tipo, mas em algo como `response_model=`, em vez de usar a barra vertical (`|`) você pode usar `Union` do `typing`. |
|||
|
|||
Por exemplo, você poderia declarar que algo pode ser `str` ou `None`: |
|||
|
|||
```python |
|||
from typing import Union |
|||
|
|||
|
|||
def say_hi(name: Union[str, None]): |
|||
print(f"Hi {name}!") |
|||
``` |
|||
|
|||
O `typing` também tem um atalho para declarar que algo pode ser `None`, com `Optional`. |
|||
|
|||
Aqui vai uma dica do meu ponto de vista bem subjetivo: |
|||
|
|||
* 🚨 Evite usar `Optional[SomeType]` |
|||
* Em vez disso ✨ use **`Union[SomeType, None]`** ✨. |
|||
|
|||
Ambos são equivalentes e, por baixo, são a mesma coisa, mas eu recomendaria `Union` em vez de `Optional` porque a palavra "opcional" sugere que o valor é opcional; na verdade, significa "pode ser `None`", mesmo quando não é opcional e continua sendo obrigatório. |
|||
|
|||
Acho que `Union[SomeType, None]` é mais explícito quanto ao significado. |
|||
|
|||
É apenas uma questão de palavras e nomes. Mas essas palavras podem influenciar como você e sua equipe pensam sobre o código. |
|||
|
|||
Como exemplo, veja esta função: |
|||
|
|||
```python |
|||
from typing import Optional |
|||
|
|||
|
|||
def say_hi(name: Optional[str]): |
|||
print(f"Hey {name}!") |
|||
``` |
|||
|
|||
O parâmetro `name` é definido como `Optional[str]`, mas não é opcional; não é possível chamar a função sem o parâmetro: |
|||
|
|||
```Python |
|||
say_hi() # Ah, não, isso gera um erro! 😱 |
|||
``` |
|||
|
|||
O parâmetro `name` continua obrigatório (não é opcional) porque não tem valor padrão. Ainda assim, `name` aceita `None` como valor: |
|||
|
|||
```Python |
|||
say_hi(name=None) # Isso funciona, None é válido 🎉 |
|||
``` |
|||
|
|||
A boa notícia é que, na maioria dos casos, você poderá simplesmente usar `|` para definir uniões de tipos: |
|||
|
|||
```python |
|||
def say_hi(name: str | None): |
|||
print(f"Hey {name}!") |
|||
``` |
|||
|
|||
Então, normalmente você não precisa se preocupar com nomes como `Optional` e `Union`. 😎 |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue