Pedro Lobato
5 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>. 🤓 |
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>. ✨ |
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