gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix(guide): simplify directory structure

Browse Source
This commit is contained in:
Mrugesh Mohapatra
2018-10-16 21:26:13 +05:30
parent f989c28c52
commit da0df12ab7
35752 changed files with 0 additions and 317652 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
guide/spanish/python/abs-function/index.md Normal file
View File

@@ -0,0 +1,29 @@
---
title: Python Abs Function
localeTitle: Función Abs Python
---
`abs()` es una función incorporada en Python 3, para calcular el valor absoluto de cualquier número. El valor absoluto de un número "significa solo a qué distancia está un número de 0" 1 Toma un argumento `x` . El argumento puede ser incluso un [número complejo](https://docs.python.org/3.0/library/cmath.html) , y en ese caso se devuelve su [módulo](http://www.mathcentre.ac.uk/resources/sigma%20complex%20number%20leaflets/sigma-complex9-2009-1.pdf) .
## Argumento
Toma un argumento `x` : un entero, un decimal o un número complejo.
## Valor de retorno
El valor de retorno sería un número positivo. Incluso si se pasa un número complejo, devolvería su magnitud, calculada según el álgebra de números complejos.
## Ejemplo de código
```python
print(abs(3.4)) # prints 3.4
print(abs(-6)) # prints 6
print(abs(3 + 4j)) # prints 5, because |3 + 4j| = 5
```
[🚀 Ejecutar Código](https://repl.it/CL8k/0)
[Documentos oficiales](https://docs.python.org/3/library/functions.html#abs)
### Fuentes
1. [La matematica es divertida. Accedido: 25 de octubre de 2017](https://www.mathsisfun.com/numbers/absolute-value.html)

43
guide/spanish/python/all-iterable/index.md Normal file
View File

@@ -0,0 +1,43 @@
---
title: Python All Iterable
localeTitle: Python Todo Iterable
---
`all()` es una función incorporada en Python 3 (y Python 2 desde la versión 2.5), para verificar si todos los elementos de un [_iterable_](https://docs.python.org/3/glossary.html#term-iterable) son `True` . Se necesita un argumento, `iterable` .
## Argumento
### iterable
El argumento `iterable` es la colección cuyas entradas se deben verificar. Puede ser una `list` , `str` , `dict` , `tuple` , etc.
## Valor de retorno
El valor de retorno es un booleano. Si y solo si **todas las** entradas de `iterable` son [veraces](https://guide.freecodecamp.org/python/truth-value-testing) , devuelve `True` . Esta función esencialmente realiza una operación Boolean `AND` sobre todos los elementos.
Si incluso uno de ellos no es sincero, devuelve `False` .
La operación `all()` es equivalente a (no implementada internamente exactamente como esta)
```
def all(iterable):
for element in iterable:
if not element:
return False
return True
```
## Ejemplo de código
```
print(all([])) #=> True # Because an empty iterable has no non-truthy elements
print(all([6, 7])) #=> True
print(all([6, 7, None])) #=> False # Because it has None
print(all([0, 6, 7])) #=> False # Because it has zero
print(all([9, 8, [1, 2]])) #=> True
print(all([9, 8, []])) #=> False # Because it has []
print(all([9, 8, [1, 2, []]])) #=> True
print(all([9, 8, {}])) #=> False # Because it has {}
print(all([9, 8, {'engine': 'Gcloud'}])) #=> True
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CL9U/0)
[Documentos oficiales](https://docs.python.org/3/library/functions.html#all)

27
guide/spanish/python/anaconda/index.md Normal file
View File

@@ -0,0 +1,27 @@
---
title: Anaconda
localeTitle: Anaconda
---
**Anaconda** es un gestor de paquetes, un gestor de entorno y una distribución Python con una colección de numerosos paquetes. Anaconda es independiente de la plataforma, por lo que puede usarla en Windows, macOS o Linux. Anaconda crea, guarda, carga y cambia fácilmente entre entornos en su computadora local. Fue creado para los programas de Python, pero puede empaquetar y distribuir software para cualquier idioma. Anaconda como gestor de paquetes le ayuda a encontrar e instalar paquetes. Si necesita un paquete que requiera una versión diferente de Python, no necesita cambiar a un administrador de entorno diferente, ya que Anaconda también es un administrador de ambiente. Con solo unos pocos comandos, puede configurar un entorno totalmente independiente para ejecutar esa versión diferente de Python, mientras continúa ejecutando su versión habitual de Python en su entorno normal.
## Visión de conjunto
La forma más rápida de comenzar a usar Conda es atravesar el [Inicio de](https://conda.io/docs/user-guide/getting-started.html) 20 minutos [con](https://conda.io/docs/user-guide/getting-started.html) guía de [conda](https://conda.io/docs/user-guide/getting-started.html) .
El comando `conda` es la interfaz principal para la gestión. Instalaciones de diversos paquetes. Puede:
* Consulta y busca el índice de paquetes de Anaconda y el actual. Instalación de anaconda.
* Crea nuevos entornos conda.
* Instalar y actualizar paquetes en entornos conda existentes.
CONSEJO: Puede abreviar muchas opciones de comando de uso frecuente que están precedidos por 2 guiones ( `--` ) a solo 1 guión y la primera Carta de la opción. Entonces `--name` y `-n` son lo mismo, y `--envs` y `-e` son lo mismo.
Para el uso completo de cada comando, incluidas las abreviaturas, consulte [Referencia de comandos](https://conda.io/docs/commands.html) .
### Fuentes
1. [Documentación Anaconda](https://docs.anaconda.com/)
2. [Documentación Conda](https://conda.io/docs/)

42
guide/spanish/python/any-iterable/index.md Normal file
View File

@@ -0,0 +1,42 @@
---
title: Python Any Iterable
localeTitle: Python cualquier iterable
---
`any()` es una función incorporada en Python 3 (y Python 2 desde la versión 2.5), para verificar si alguno de los elementos de un [_iterable_](https://docs.python.org/3/glossary.html#term-iterable) es `True` . Se necesita un argumento, `iterable` .
## Argumento
### iterable
El argumento `iterable` es la colección cuyas entradas se deben verificar. Por lo general, puede ser una `list` , `str` , `dict` , `tuple` , etc., incluso un `file object` .
## Valor de retorno
El valor de retorno es un booleano. Si y solo si **todas las** entradas de iterable son `False` , o `iterable` está vacío; devuelve `False` . Esta función esencialmente realiza una operación Boolean `OR` sobre todos los elementos.
Si incluso uno de ellos es `True` , devuelve `True` .
La operación `any()` es equivalente a (internamente, no se puede implementar exactamente de esta manera)
```
def any(iterable):
for element in iterable:
if element:
return True
return False
```
## Ejemplo de código
```
print(any([])) #=> False
print(any({})) #=> False
print(any([None])) #=> False
print(any(['', {}, 0])) #=> False
print(any([6, 7])) #=> True
print(any([6, 7, None])) #=> True
print(any([0, 6, 7])) #=> True
print(any([9, 8, [1, 2]])) #=> True
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CL9c/0)
[Documentos oficiales](https://docs.python.org/3/library/functions.html#any)

47
guide/spanish/python/args-variable/index.md Normal file
View File

@@ -0,0 +1,47 @@
---
title: Relationships between * and args
localeTitle: Relaciones entre * y args
---
## Presencia de \* en la definición de la función
```Python
# How does *args work in a function definition
def hardFunc(arg1, arg2):
# create a tuple and pollute it with arguments passed to hardFunc
args=(arg1, arg2)
# print out results
print(args[0])
print(args[1])
hardFunc('hard_one', 'hard_two')
# output — Try it yourself now and in sequential snippets!
def softFunc(*args):
# at this point after calling softFunc a tuple with a name of a word
# followed by * is created automatically (in this case the name is args)
# print out results
print(args[0])
print(args[1])
softFunc('soft_one', 'soft_two')
# Now try to do something illegal
hardFunc('one', 'two', 'three')
# Now do things legally
softFunc('one', 'two', 'three')
# or even
softFunc('one', 'two', 'three', 'infinity')
# softFunc handles arbitrary amount of arguments easily by virtue of * syntax
# So using a single variable name in conjuction with * we gained the ability
# to invoke a function with arbitrary amount of arguments.
# Once again when softFunc is called the newly args
# tuple filled with provided arguments is created
# Conclusion softFunc is a more flexible/dynamic verson of a hardFunc
```

328
guide/spanish/python/basic-operators/index.md Normal file
View File

@@ -0,0 +1,328 @@
---
title: Basic Operators
localeTitle: Operadores básicos
---
## Operadores básicos
Los operadores son símbolos que le indican al intérprete que realice una operación específica (por ejemplo, aritmética, comparación, lógica, etc.)
Los diferentes tipos de operadores en Python se enumeran a continuación:
1. Operadores aritméticos
2. Operadores relacionales
3. Operadores de Bitwise
4. Operadores de Asignación
5. Operadores logicos
6. Operadores de membresía
7. Operadores de Identidad
#### Operadores aritméticos
Un operador aritmético toma dos operandos como entrada, realiza un cálculo y devuelve el resultado.
Considera la expresión, **“a = 2 + 3”** . Aquí, `2` y `3` son los _operandos_ y `+` es el _operador aritmético_ . El resultado de la operación se almacena en la variable a.
Operador
Descripción
Uso
+
Realiza la adición de los operandos.
12 + 3 = 15
\-
Realiza la resta en los operandos. Resta el operando derecho del operando izquierdo
12 - 3 = 9
\*
Realiza la multiplicación de los operandos.
12 \* 3 = 36
/
Realiza división sobre los operandos. Divide el operando izquierdo por el operando derecho
12/3 = 4
Nota: Cuando se usan dos enteros, el resultado difiere entre Python 2 y Python 3.
5/2 = 2 en Python 2
5/2 = 2.5 en Python 3
%
Realiza un módulo sobre los operandos. Devuelve el resto obtenido dividiendo el operando izquierdo por el operando derecho
16% 3 = 1
\*\*
Realiza una operación de Exposiciónción. El operando izquierdo se eleva a la potencia del operando derecho
12 \*\* 3 = 1728
//
Realiza una operación de división de piso. Devuelve la parte integral del cociente obtenido después de bucear el operando izquierdo por el operando derecho
18 // 5 = 3
Nota: para obtener el resultado en tipo flotante, uno de los operandos también debe ser de tipo flotante.
#### Operadores relacionales
Un operador relacional se utiliza para comparar dos operandos para decidir una relación entre ellos. Devuelve un valor booleano basado en la condición.
Operador
Descripción
Uso
\>
Devuelve True si el operando izquierdo es mayor que el operando derecho Devuelve False de lo contrario
12> 3 devuelve Verdadero
<
Devuelve True si el operando derecho es mayor que el operando izquierdo Devuelve False de lo contrario
12 <3 devuelve Falso
\==
Devuelve True si ambos operandos son iguales Devuelve False de lo contrario
12 == 3 devuelve Falso
\> =
Devuelve True si el operando izquierdo es mayor o igual que el operando derecho Devuelve False de lo contrario
12> = 3 devuelve True
<=
Devuelve True si el operando derecho es mayor o igual que el operando izquierdo Devuelve False de lo contrario
12 <= 3 devuelve False
! =
Devuelve True si ambos operandos no son iguales Devuelve False de lo contrario
12! = 3 devuelve True
#### Operadores de Bitwise
Un operador bit a bit realiza operaciones en los operandos bit a bit
Considere a = 2 (en notación binaria, 10) y b = 3 (en notación binaria, 11) para los siguientes usos
Operador
Descripción
Uso
Y
Realiza operaciones bitwise Y en los operandos.
a & b = 2 Binario: 10 y 11 = 10
|
Realiza la operación OR en modo bit en los operandos.
un | b = 3 Binario: 10 | 11 = 11
^
Realiza la operación XOR en modo bit a los operandos.
a ^ b = 1 Binario: 10 ^ 11 = 01
~
Realiza una operación NO bit a bit en el operando Se voltea cada bit en el operando.
~ a = -3 Binario: ~ (00000010) = (11111101)
\>>
Realiza un desplazamiento a la derecha en modo bit. Desplaza los bits del operando izquierdo, derecho por el número de bits especificados como el operando derecho
a >> b = 0 Binario: 00000010 >> 00000011 = 0
<<
Realiza un desplazamiento a la izquierda en modo bit. Desplaza los bits del operando izquierdo, a la izquierda por el número de bits especificados como el operando derecho
a << b = 16 Binario: 00000010 << 00000011 = 00001000
#### Operadores de Asignación
Un operador de asignación se utiliza para asignar valores a una variable. Esto generalmente se combina con otros operadores (como aritmética, bitwise) donde la operación se realiza en los operandos y el resultado se asigna al operando de la izquierda.
Considere los siguientes ejemplos, **a = 18** . Aquí `=` es un operador de asignación, y el resultado se almacena en la variable a. **a + = 10** . Aquí `+=` es un operador de asignación, y el resultado se almacena en la variable a. Esto es lo mismo que a = a + 10.
Operador
Uso
\=
a = 5. El valor 5 se asigna a la variable a
\+ =
a + = 5 es equivalente a a = a + 5
\- =
a - = 5 es equivalente a a = a - 5
\* =
a \* = 3 es equivalente a a = a \* 3
/ =
a / = 3 es equivalente a a = a / 3
% =
a% = 3 es equivalente a a = a% 3
\*\* =
a \*\* = 3 es equivalente a a = a \*\* 3
// =
a // = 3 es equivalente a a = a // 3
& =
a & = 3 es equivalente a a = a & 3
| =
a | = 3 es equivalente a a = a | 3
^ =
a ^ = 3 es equivalente a a = a ^ 3
\>> =
a >> = 3 es equivalente a a = a >> 3
<< =
a << = 3 es equivalente a a = a << 3
#### Operadores logicos
Un operador lógico se utiliza para tomar una decisión basada en múltiples condiciones. Los operadores lógicos utilizados en Python son `and` , `or` `not`
Operador
Descripción
Uso
y
Devuelve True si ambos operandos son True Devuelve False de lo contrario
a y B
o
Devuelve True si alguno de los operandos es True Devuelve False de lo contrario
a o B
no
Devuelve True si el operando es False Devuelve False de lo contrario
No un
#### Operadores de membresía
Un operador de membresía se utiliza para identificar la membresía en cualquier secuencia (listas, cadenas, tuplas). `in` y `not in` son operadores de membresía
`in` devuelve True si el valor especificado se encuentra en la secuencia. Devuelve False de lo contrario. `not in` devuelve Verdadero si el valor especificado no se encuentra en la secuencia. Devuelve False de lo contrario.
###### Ejemplo de uso
```py
a = [1,2,3,4,5]
#Is 3 in the list a?
print 3 in a # prints True
#Is 12 not in list a?
print 12 not in a # prints True
str = "Hello World"
#Does the string str contain World?
print "World" in str # prints True
#Does the string str contain world? (note: case sensitive)
print "world" in str # prints False
print "code" not in str # prints True
```
#### Operadores de Identidad
Un operador de identidad se usa para verificar si dos variables comparten la misma ubicación de memoria. `is` y `is not` es operadores de identidad.
`is` Devuelve true si los operandos se refieren al mismo objeto. Devuelve False de lo contrario. `is not` devuelve Verdadero si los operandos no hacen referencia al mismo objeto. Devuelve False de lo contrario.
Tenga en cuenta que dos valores cuando son iguales, no deben implicar que sean idénticos.
###### Ejemplo de uso
```py
a = 3
b = 3
c = 4
print a is b # prints True
print a is not b # prints False
print a is not c # prints True
x = 1
y = x
z = y
print z is 1 # prints True
print z is x # prints True
str1 = "FreeCodeCamp"
str2 = "FreeCodeCamp"
print str1 is str2 # prints True
print "Code" is str2 # prints False
a = [10,20,30]
b = [10,20,30]
print a is b # prints False (since lists are mutable in Python)
```

32
guide/spanish/python/bool-function/index.md Normal file
View File

@@ -0,0 +1,32 @@
---
title: Python Bool Function
localeTitle: Función Python Bool
---
`bool()` es una función incorporada en Python 3. Esta función devuelve un valor booleano, es decir, Verdadero o Falso. Se necesita un argumento, `x` .
## Argumentos
Se necesita un argumento, `x` . `x` se convierte utilizando el [procedimiento de prueba de verdad](https://docs.python.org/3/library/stdtypes.html#truth) estándar.
## Valor de retorno
Si `x` es falso u omitido, esto devuelve `False` ; De lo contrario, devuelve `True` .
## Ejemplo de código
```
print(bool(4 > 2)) # Returns True as 4 is greater than 2
print(bool(4 < 2)) # Returns False as 4 is not less than 2
print(bool(4 == 4)) # Returns True as 4 is equal to 4
print(bool(4 != 4)) # Returns False as 4 is equal to 4 so inequality doesn't holds
print(bool(4)) # Returns True as 4 is a non-zero value
print(bool(-4)) # Returns True as -4 is a non-zero value
print(bool(0)) # Returns False as it is a zero value
print(bool('dskl')) # Returns True as the string is a non-zero value
print(bool([1, 2, 3])) # Returns True as the list is a non-zero value
print(bool((2,3,4))) # Returns True as tuple is a non-zero value
print(bool([])) # Returns False as list is empty and equal to 0 according to truth value testing
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CVCS/2)
[Documentos oficiales](https://docs.python.org/3/library/functions.html#bool)

52
guide/spanish/python/boolean-operations/index.md Normal file
View File

@@ -0,0 +1,52 @@
---
title: Python Boolean Operations
localeTitle: Operaciones Booleanas Python
---
[`and`](https://docs.python.org/3/reference/expressions.html#and) , [`or`](https://docs.python.org/3/reference/expressions.html#or) , [`not`](https://docs.python.org/3/reference/expressions.html#not)
[Python Docs - Operaciones Booleanas](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not)
Estas son las operaciones booleanas, ordenadas por prioridad ascendente:
Operacion | Resultado | Notas
\--------- | ------------------------------------ | -----
x o y | si x es falso, entonces y, si no x | (1)
x y y | si x es falso, entonces x, si no y | (2)
no x si x es falso, entonces verdadero, sino falso | (3)
**Notas:**
1. Este es un operador de cortocircuito, por lo que solo evalúa el segundo argumento si el primero es Falso.
2. Este es un operador de cortocircuito, por lo que solo evalúa el segundo argumento si el primero es Verdadero.
3. no tiene una prioridad más baja que los operadores no booleanos, por lo que no a == b se interpreta como no (a == b), y a == not b es un error de sintaxis.
## Ejemplos:
### `not`
```
>>> not True
False
>>> not False
True
```
### `and` :
```
>>> True and False # Short-circuited at first argument.
False
>>> False and True # Second argument is evaluated.
False
>>> True and True # Second argument is evaluated.
True
```
### `or` :
```
>>> True or False # Short-circuited at first argument.
True
>>> False or True # Second argument is evaluated.
True
>>> False or False # Second argument is evaluated.
False
```

30
guide/spanish/python/built-in-constants/index.md Normal file
View File

@@ -0,0 +1,30 @@
---
title: Python Built in Constants
localeTitle: Python construido en constantes
---
[Constantes](https://docs.python.org/3/library/constants.html)
Tres constantes incorporadas de uso común:
* `True` : El valor verdadero del tipo _bool_ . Las asignaciones a `True` _generan_ un _SyntaxError_ .
* `False` : El valor falso del tipo _bool_ . Las asignaciones a `False` _generan_ un _error de sintaxis_ .
* `None` : El único valor del tipo _NingunoTipo_ . Ninguno se usa con frecuencia para representar la ausencia de un valor, como cuando los argumentos predeterminados no se pasan a una función. Las asignaciones a `None` _generan_ un _error de sintaxis_ .
Otras constantes incorporadas:
* `NotImplemented` : valor especial que debe ser devuelto por los métodos especiales binarios, como `__eg__()` , `__add__()` , `__rsub__()` , etc.) para indicar que la operación no está implementada con respecto al otro tipo.
* `Ellipsis` : valor especial que se utiliza principalmente en combinación con la sintaxis de división ampliada para tipos de datos de contenedor definidos por el usuario.
* `__debug__` : Es cierto si Python no se inició con una opción -o.
Constantes agregadas por el módulo del sitio El módulo del sitio (que se importa automáticamente durante el inicio, excepto si se da la opción de línea de comandos -S) agrega varias constantes al espacio de nombres integrado. Son útiles para el intérprete de intérprete interactivo y no deben utilizarse en programas.
Los objetos que cuando se imprimen, imprimen un mensaje como "Use quit () o Ctrl-D (es decir, EOF) para salir", y cuando se le llama, levante SystemExit con el código de salida especificado:
* salir (código = Ninguno)
* salir (código = Ninguno)
Los objetos que cuando se imprimen, imprimen un mensaje como "Escriba la licencia () para ver el texto completo de la licencia" y, cuando se le llame, muestre el texto correspondiente de manera similar a un buscapersonas (una pantalla a la vez):
* derechos de autor
* licencia
* creditos

53
guide/spanish/python/calling-functions/index.md Normal file
View File

@@ -0,0 +1,53 @@
---
title: Python Calling Functions
localeTitle: Funciones de llamada de Python
---
Una declaración de definición de función no ejecuta la función. La ejecución (llamada) de una función se realiza utilizando el nombre de la función seguido de paréntesis que incluye los argumentos requeridos (si los hay).
```
>>> def say_hello():
... print('Hello')
...
>>> say_hello()
Hello
```
La ejecución de una función introduce una nueva tabla de símbolos utilizada para las variables locales de la función. Más precisamente, todas las asignaciones de variables en una función almacenan el valor en la tabla de símbolos local; mientras que las referencias de variables primero miran en la tabla de símbolos local, luego en las tablas de símbolos locales de las funciones de encierro, luego en la tabla de símbolos global y finalmente en la tabla de nombres incorporados. Por lo tanto, a las variables globales no se les puede asignar directamente un valor dentro de una función (a menos que estén nombradas en una declaración global), aunque pueden ser referenciadas.
```
>>> a = 1
>>> b = 10
>>> def fn():
... print(a) # local a is not assigned, no enclosing function, global a referenced.
... b = 20 # local b is assigned in the local symbol table for the function.
... print(b) # local b is referenced.
...
>>> fn()
1
20
>>> b # global b is not changed by the function call.
10
```
Los parámetros reales (argumentos) para una llamada de función se introducen en la tabla de símbolos locales de la función llamada cuando se llama; por lo tanto, los argumentos se pasan usando llamada por valor (donde el valor es siempre una referencia de objeto, no el valor del objeto). Cuando una función llama a otra función, se crea una nueva tabla de símbolos locales para esa llamada.
```
>>> def greet(s):
... s = "Hello " + s # s in local symbol table is reassigned.
... print(s)
...
>>> person = "Bob"
>>> greet(person)
Hello Bob
>>> person # person used to call remains bound to original object, 'Bob'.
'Bob'
```
Los argumentos utilizados para llamar a una función no pueden ser reasignados por la función, pero los argumentos que hacen referencia a objetos mutables pueden cambiar sus valores:
```
>>> def fn(arg):
... arg.append(1)
...
>>> a = [1, 2, 3]
>>> fn(a)
>>> a
[1, 2, 3, 1]
```

71
guide/spanish/python/class/index.md Normal file
View File

@@ -0,0 +1,71 @@
---
title: Class
localeTitle: Clase
---
## Clase
Las clases proporcionan un medio de agrupar datos y funcionalidad. La creación de una nueva clase crea un nuevo tipo de objeto, lo que permite crear nuevas instancias de ese tipo. Cada instancia de clase puede tener atributos adjuntos para mantener su estado. Las instancias de clase también pueden tener métodos (definidos por su clase) para modificar su estado.
En comparación con otros lenguajes de programación, el mecanismo de clase de Python agrega clases con un mínimo de Nueva sintaxis y semántica. Es una mezcla de los mecanismos de clase encontrados en C ++. Las clases de Python proporcionan todas las características estándar de la programación orientada a objetos: el mecanismo de herencia de clases permite múltiples clases base, una clase derivada puede anular cualquier método de su clase o clases base, y un método puede llamar al método de una clase base con el mismo nombre. Los objetos pueden contener cantidades arbitrarias y tipos de datos. Como es cierto para los módulos, las clases participan de la naturaleza dinámica de Python: Se crean en tiempo de ejecución y pueden modificarse aún más después de la creación.
#### Sintaxis de definición de clase:
La forma más simple de definición de clase se ve así:
```python
class ClassName:
<statement-1>
...
...
...
<statement-N>
```
#### Class Objects:
Class objects support two kinds of operations: attribute references and instantiation.
Attribute references use the standard syntax used for all attribute references in Python: `obj.name`.
Valid attribute names are all the names that were in the class's namespace when the class object was created.
So, if the class definition looked like this:
```
pitón clase MyClass: "" "Una clase de ejemplo simple" "" i = 12345
```
def f(self):
return 'hello world'
```
```
Then `MyClass.i` and `MyClass.f` are valid attribute references, returning an integer and a function object, respectively.
Class attributes can also be assigned to, so you can change the value of `MyClass.i` by assignment. `__doc__` is also a valid attribute, returning the docstring belonging to the class: `"A simple example class"`.
Class instantiation uses function notation. Just pretend that the class object is a parameterless function that returns a new instance of the class. For example (assuming the above class):
```
pitón x = MyClass ()
```
Creates a new instance of the class and assigns this object to the local variable x.
The instantiation operation (“calling” a class object) creates an empty object.
Many classes like to create objects with instances customized to a specific initial state.
Therefore a class may define a special method named __init__(), like this:
```
pitón def **init** (self): self.data = \[\]
```
When a class defines an `__init__()` method, class instantiation automatically invokes `__init__()` for the newly-created class instance.
So in this example, a new, initialized instance can be obtained by:
```
pitón x = MyClass ()
```
Of course, the `__init__()` method may have arguments for greater flexibility.
In that case, arguments given to the class instantiation operator are passed on to `__init__()`. For example,
```
pitón Complejo de clase: def **init** (self, realpart, imagpart): self.r = realpart self.i = imagpart ...
x = Complejo (3.0, -4.5)
> > > xr, xi (3.0, -4.5) \`\` \`

48
guide/spanish/python/code-blocks-and-indentation/index.md Normal file
View File

@@ -0,0 +1,48 @@
---
title: Python Code Blocks and Indentation
localeTitle: Bloques de código de Python y sangría
---
En general, es una buena práctica no mezclar tabulaciones y espacios al codificar en Python. Hacer esto puede causar un `TabError` , y su programa se bloqueará. Sea coherente al codificar: elija sangrar utilizando tabulaciones o espacios y siga la convención elegida en todo su programa.
#### Bloques de código y sangría
Una de las características más distintivas de Python es su uso de la sangría para marcar bloques de código. Considere la sentencia if de nuestro sencillo programa de comprobación de contraseñas:
\`\` \`pitón si pwd == 'apple': imprimir ('Iniciar sesión en ...') más: imprimir ('Contraseña incorrecta')
Imprimir ('¡Todo listo!')
```
The lines print('Logging on ...') and print('Incorrect password.') are two separate code blocks. These ones happen to be only a single line long, but Python lets you write code blocks consisting of any number of statements.
To indicate a block of code in Python, you must indent each line of the block by the same amount. The two blocks of code in our example if-statement are both indented four spaces, which is a typical amount of indentation for Python.
In most other programming languages, indentation is used only to help make the code look pretty. But in Python, it is required for indicating what block of code a statement belongs to. For instance, the final print('All done!') is not indented, and so is not part of the else-block.
Programmers familiar with other languages often bristle at the thought that indentation matters: Many programmers like the freedom to format their code how they please. However, Python indentation rules are quite simple, and most programmers already use indentation to make their code readable. Python simply takes this idea one step further and gives meaning to the indentation.
#### If/elif-statements
An if/elif-statement is a generalized if-statement with more than one condition. It is used for making complex decisions. For example, suppose an airline has the following “child” ticket rates: Kids 2 years old or younger fly for free, kids older than 2 but younger than 13 pay a discounted child fare, and anyone 13 years or older pays a regular adult fare. The following program determines how much a passenger should pay:
```
pitón
# tarifa aérea.py
age = int (input ('¿Cuántos años tienes?')) Si la edad <= 2: imprimir ('gratis') elif 2 <edad <13: imprimir ('tarifa de niño) más: imprimir ('tarifa de adulto')
```
After Python gets age from the user, it enters the if/elif-statement and checks each condition one after the other in the order they are given. So first it checks if age is less than 2, and if so, it indicates that the flying is free and jumps out of the elif-condition. If age is not less than 2, then it checks the next elif-condition to see if age is between 2 and 13. If so, it prints the appropriate message and jumps out of the if/elif-statement. If neither the if-condition nor the elif-condition is True, then it executes the code in the else-block.
#### Conditional expressions
Python has one more logical operator that some programmers like (and some don't!). It's essentially a shorthand notation for if-statements that can be used directly within expressions. Consider this code:
```
pitón comida = entrada ("¿Cuál es tu comida favorita?") respuesta = 'yuck' si comida == 'cordero' else 'yum'
```
The expression on the right-hand side of = in the second line is called a conditional expression, and it evaluates to either 'yuck' or 'yum'. It's equivalent to the following:
```
pitón comida = entrada ("¿Cuál es tu comida favorita?") si la comida == 'cordero': respuesta = 'yuck' más: respuesta = 'yum' \`\` \`
Las expresiones condicionales suelen ser más cortas que las sentencias if / else correspondientes, aunque no son tan flexibles o fáciles de leer. En general, debe usarlos cuando simplifican su código.
[Documentación Python - Indentación](https://docs.python.org/3/reference/lexical_analysis.html#indentation)

38
guide/spanish/python/commenting-code/index.md Normal file
View File

@@ -0,0 +1,38 @@
---
title: Python Commenting Code
localeTitle: Código de comentarios de Python
---
Los comentarios se utilizan para anotar, describir o explicar códigos que son complejos o difíciles de entender. Python ignorará intencionalmente los comentarios cuando compile el bytecode por el intérprete. [`PEP 8`](https://www.python.org/dev/peps/pep-0008/#comments) tiene una sección que trata con los comentarios. También aumentan la legibilidad del código al agregar un lenguaje fácil y descriptivo para una mejor comprensión.
**Los** comentarios **en** **bloque** y en **línea** comienzan con un `#` , seguido de un espacio antes del comentario:
```python
# This is a block comment.
print('Hello world!') # This is an inline commment.
```
Python no incluye una forma formal de escribir comentarios de varias líneas. Cada línea de un comentario que abarca varias líneas debe comenzar con `#` y un espacio:
```python
# This is the first line of a multiline comment.
# This is the second line.
```
Otro tipo de comentario es el **docstring** , documentado en [`PEP 257`](https://www.python.org/dev/peps/pep-0257/) . Las cadenas de texto son un tipo específico de comentario que se convierte en el atributo `__doc__` .
Para que una cadena literal sea una cadena de documentación, debe comenzar y terminar con `\"\"\"` y ser la primera declaración del módulo, función, clase o definición de método que está documentando:
```python
class SomeClass():
"""Summary line for SomeClass.
More elaborate descriptions may require using a
a multiline docstring.
"""
def method_a(self):
"""Single line summary of method_a."""
pass
```
Los literales de cadena que comienzan y terminan con `"""` que no son cadenas de documentación (no la primera instrucción), se pueden usar para cadenas de `__doc__` . No se convertirán en atributos `__doc__` . Si no están asignados a una variable, no generarán un `__doc__` . Hay una discusión sobre su uso como comentarios de varias líneas que se encuentran [aquí](http://stackoverflow.com/questions/7696924/multiline-comments-in-python) .

84
guide/spanish/python/comparisons/index.md Normal file
View File

@@ -0,0 +1,84 @@
---
title: Python Comparisons
localeTitle: Comparaciones de Python
---
[Python Docs - Comparaciones](https://docs.python.org/3/library/stdtypes.html#comparisons)
Hay ocho operaciones de comparación en Python. Todos tienen la misma prioridad (que es más alta que la de las operaciones booleanas). Las comparaciones pueden ser encadenadas arbitrariamente; por ejemplo, `x < y <= z` es equivalente a `x < y and y <= z` , excepto que `y` se evalúa solo una vez (pero en ambos casos `z` no se evalúa en absoluto cuando se encuentra que `x < y` es falso).
Esta tabla resume las operaciones de comparación:
Operacion | Sentido
\--------- | -----------------------
`<` | estrictamente menos que
`<=` | Menos que o igual a `>` | estrictamente mayor que `>=` | Mayor qué o igual a `==` | igual a `!=` | no igual a `is` | identidad de objeto
`is not` | identidad de objeto negado
Los objetos de diferentes tipos, excepto los diferentes tipos numéricos, nunca se comparan igual. Además, algunos tipos (por ejemplo, objetos de función) admiten solo una noción degenerada de comparación donde dos objetos de ese tipo son desiguales. Los operadores `<` , `<=` , `>` y `>=` generarán una excepción `TypeError` al comparar un número complejo con otro tipo numérico incorporado, cuando los objetos son de diferentes tipos que no pueden compararse, o en otros casos donde no hay definidos ordenando
Las instancias no idénticas de una clase normalmente se comparan como no iguales a menos que la clase defina el `__eq__()` .
Las instancias de una clase no pueden ordenarse con respecto a otras instancias de la misma clase u otros tipos de objetos, a menos que la clase defina suficientes métodos `__lt__()` , `__le__()` , `__gt__()` y `__ge__()` (en general , `__lt__()` y `__eq__()` son suficientes, si desea los significados convencionales de los operadores de comparación).
El comportamiento de los operadores `is` y `is not` puede ser personalizado; también se pueden aplicar a cualquiera de los dos objetos y nunca generar una excepción.
También podemos encadenar `<` y `>` operadores juntos. Por ejemplo, `3 < 4 < 5` devolverá `True` , pero `3 < 4 > 5` no. También podemos encadenar el operador de igualdad. Por ejemplo, `3 == 3 < 5` devolverá `True` pero `3 == 5 < 5` no lo hará.
### Comparaciones de igualdad - "es" vs "=="
En Python, hay dos operadores de comparación que nos permiten verificar si dos objetos son iguales. El operador `is` y el operador `==` . Sin embargo, hay una diferencia clave entre ellos!
La diferencia clave entre 'es' y '==' se puede resumir como:
* `is` usado para comparar **identidad**
* `==` se usa para comparar la **igualdad**
## Ejemplo
Primero, crea una lista en Python.
```python
myListA = [1,2,3]
```
A continuación, crea una copia de esa lista.
```python
myListB = myListA
```
Si usamos el operador '==' o el operador 'is', ambos darán como resultado una salida **True** .
```python
>>> myListA == myListB # both lists contains similar elements
True
>>> myListB is myListA # myListB contains the same elements
True
```
Esto se debe a que myListA y myListB están apuntando a la misma variable de lista, que definí al principio de mi programa Python. Ambas listas son exactamente iguales, tanto en identidad como en contenido.
Sin embargo, ¿qué pasa si ahora creo una nueva lista?
```python
myListC = [1,2,3]
```
La ejecución del operador `==` aún muestra que ambas listas son iguales, en términos de contenido.
```python
>>> myListA == myListC
True
```
Sin embargo, la realización de la `is` operador ahora producir una `False` salida. Esto se debe a que myListA y myListC son dos variables diferentes, a pesar de que contienen los mismos datos. A pesar de que se ven iguales, son **diferentes** .
```python
>>> myListA is myListC
False # both lists have different reference
```
Para resumir:
* Una `is` salidas de expresión `True` si ambas variables están apuntando a la misma referencia
* Una expresión `==` produce `True` si ambas variables contienen los mismos datos

62
guide/spanish/python/complex-numbers/index.md Normal file
View File

@@ -0,0 +1,62 @@
---
title: Python Complex Numbers
localeTitle: Números complejos de Python
---
Los números complejos tienen una parte real y otra imaginaria, cada una representada por un número de punto flotante.
La parte imaginaria de un número complejo se puede crear usando un literal imaginario, esto resulta en un número complejo con una parte real de `0.0` :
```python
>>> a = 3.5j
>>> type(a)
<class 'complex'>
>>> print(a)
3.5j
>>> a.real
0.0
>>> a.imag
3.5
```
No existe un literal para crear un número complejo con partes reales e imaginarias distintas de cero. Para crear un número complejo de parte real que no sea cero, agregue un literal imaginario a un número de punto flotante:
```python
>>> a = 1.1 + 3.5j
>>> type(a)
<class 'complex'>
>>> print(a)
(1.1+3.5j)
>>> a.real
1.1
>>> a.imag
3.5
```
O utilizar el [constructor complejo](https://docs.python.org/3/library/functions.html#complex) .
```python
class complex([real[, imag]])
```
Los argumentos utilizados para llamar al constructor complejo pueden ser de tipo numérico (incluido el `complex` ) para cualquier parámetro:
```python
>>> complex(1, 1)
(1+1j)
>>> complex(1j, 1j)
(-1+1j)
>>> complex(1.1, 3.5)
(1.1+3.5j)
>>> complex(1.1)
(1.1+0j)
>>> complex(0, 3.5)
3.5j
```
También se puede utilizar una `string` como argumento. No se permite un segundo argumento si se usa una cadena como argumento
```python
>>> complex("1.1+3.5j")
(1.1+3.5j)
```

7
guide/spanish/python/containers/index.md Normal file
View File

@@ -0,0 +1,7 @@
---
title: Python Containers
localeTitle: Contenedores de Python
---
Algunos objetos contienen referencias a otros objetos; estos son llamados contenedores. Ejemplos de contenedores son tuplas, listas y diccionarios. Las referencias son parte del valor de un contenedor. En la mayoría de los casos, cuando hablamos del valor de un contenedor, implicamos los valores, no las identidades de los objetos contenidos; sin embargo, cuando hablamos de la mutabilidad de un contenedor, solo están implícitas las identidades de los objetos contenidos inmediatamente. Por lo tanto, si un contenedor inmutable (como una tupla) contiene una referencia a un objeto mutable, su valor cambia si se cambia ese objeto mutable.
[Documentos de Python - Valores y tipos de objetos](https://docs.python.org/3/reference/datamodel.html#objects-values-and-types)

75
guide/spanish/python/converting-integer-to-string-in-python/index.md Normal file
View File

@@ -0,0 +1,75 @@
---
title: Converting Integer to String in Python
localeTitle: Convertir un entero a una cadena en Python
---
## Convertir un entero a una cadena en Python
A diferencia de muchos otros idiomas, Python no encadena implícitamente números enteros (o flotantes) a cadenas cuando concatena con cadenas. Afortunadamente, Python tiene una función incorporada práctica `str()` que convertirá el argumento pasado a un formato de cadena.
#### La forma incorrecta
Los programadores que vienen de otros lenguajes pueden intentar hacer la siguiente concatenación de cadenas que produce un error:
```py
age = 18
string = "Hello, I am " + age + " years old"
```
[Ejecutar código en repl.it](https://repl.it/JyYH/0)
El error que aparece es
```
Traceback (most recent call last):
File "python", line 3, in <module>
TypeError: must be str, not int
```
`TypeError: must be str, not int` indica que el entero se debe convertir primero en una cadena para concatenar.
#### El camino correcto
Ejemplo de concatenación simple:
```py
age = 18
print("Hello, I am " + str(age) + " years old")
# Output
# Hello, I am 18 years old
```
[Ejecutar código en repl.it](https://repl.it/Jz8Q/0)
Imprima `1 2 3 4 5 6 7 8 9 10` usando una sola cadena
```py
result = ""
for i in range(1, 11):
result += str(i) + " "
print(result)
# Output
# 1 2 3 4 5 6 7 8 9 10
```
[Ejecutar código en repl.it](https://repl.it/KBLB/0)
#### Línea por línea explicación del código anterior
1. En primer lugar, se asigna una variable 'resultado' a una cadena vacía.
2. For loop se está utilizando para iterar sobre una lista de números.
3. Esta lista de números se genera utilizando la función de rango.
4. así que el rango (1,11) generará una lista de números del 1 al 10.
5. En cada iteración de bucle for, esta variable 'i' tomará valores del 1 al 10.
6. En la primera iteración cuando la variable i = 1, luego la variable \[resultado = resultado + str (i) + "(carácter de espacio)"\], str (i) convierte la 'i' que es un valor entero a un valor de cadena.
7. Como i = 1, en la primera iteración finalmente resulta = 1.
8. Y el mismo proceso continúa hasta que i = 10 y finalmente después de la última iteración resultado = 1 2 3 4 5 6 7 8 9 10.
9. Por lo tanto, cuando finalmente imprimimos el resultado después del bucle for, la salida en la consola es '1 2 3 4 5 6 7 8 9 10'.
#### Más información:
[Documentación oficial de Python para `str()`](https://docs.python.org/3/library/stdtypes.html#str)

9
guide/spanish/python/creating-guis-in-python3/index.md Normal file
View File

@@ -0,0 +1,9 @@
---
title: Creating GUI's in Python3
localeTitle: Creando GUI's en Python3
---
# Creando GUI's en Python 3
Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/java/collections/index.md) .
[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

130
guide/spanish/python/data-structures/dictionaries/index.md Normal file
View File

@@ -0,0 +1,130 @@
---
title: The Python Dict
localeTitle: El Dict Python
---
Un Diccionario (también conocido como "dict") en python es un tipo de datos incorporado que se puede usar para almacenar pares **`key-value`** . Esto le permite tratar un **`dict`** como si fuera una _base_ de _datos_ para almacenar y organizar datos.
Lo especial de los diccionarios es la forma en que se implementan. La estructura tipo tabla de hash facilita la comprobación de existencia, lo que significa que podemos determinar fácilmente si una clave específica está presente en el diccionario sin necesidad de examinar cada elemento El intérprete de Python puede simplemente ir a la clave de ubicación y verificar si la clave está allí.
Los diccionarios pueden usar casi cualquier tipo de datos arbitrarios, como cadenas, enteros, etc., para las claves. Sin embargo, los valores que no son hashable, es decir, los valores que contienen listas, diccionarios u otros tipos mutables (que se comparan por valor en lugar de por identidad de objeto) no se pueden usar como claves. Los tipos numéricos utilizados para las teclas obedecen las reglas normales para la comparación numérica: si dos números se comparan de la misma manera (como `1` y `1.0` ), se pueden usar indistintamente para indexar la misma entrada del diccionario. (Sin embargo, tenga en cuenta que dado que las computadoras almacenan números de punto flotante como aproximaciones, generalmente no es aconsejable usarlos como claves de diccionario).
Un requisito más importante de un diccionario es que las claves **deben** ser únicas.
Para crear un diccionario vacío solo usa un par de llaves:
```python
>>> teams = {}
>>> type(teams)
>>> <class 'dict'>
```
Para crear un diccionario no vacío con algunos valores iniciales, coloque una lista separada por comas de pares clave-valor:
```python
>>> teams = {'barcelona': 1875, 'chelsea': 1910}
>>> teams
{'barcelona': 1875, 'chelsea': 1910}
```
Es fácil agregar pares clave-valor a un diccionario existente:
```python
>>> teams['santos'] = 1787
>>> teams
{'chelsea': 1910, 'barcelona': 1875, 'santos': 1787} # Notice the order - Dictionaries are unordered !
>>> # extracting value - Just provide the key
...
>>> teams['barcelona']
1875
```
**`del`** operador se utiliza para eliminar un par clave-valor del dict. En los escenarios donde una clave que ya está en uso se usa de nuevo para almacenar valores, el valor antiguo asociado con esa clave se pierde por completo. Además, tenga en cuenta que es un error extraer el valor utilizando una clave que no existe.
```python
>>> del teams['santos']
>>> teams
{'chelsea': 1910, 'barcelona': 1875}
>>> teams['chelsea'] = 2017 # overwriting
>>> teams
{'chelsea': 2017, 'barcelona': 1875}
```
**`in`** palabra clave se puede utilizar para verificar si existe una clave en el dict o no:
```python
>>> 'sanots' in teams
False
>>> 'barcelona' in teams
True
>>> 'chelsea' not in teams
False
```
**`keys`** es un _método_ incorporado que se puede usar para obtener las claves de un diccionario determinado. Para extraer las claves presentes en un dict como listas:
```python
>>> club_names = list(teams.keys())
>>> club_names
['chelsea', 'barcelona']
```
Otra forma de crear un diccionario es mediante el método **`dict()`** :
```python
>>> players = dict( [('messi','argentina'), ('ronaldo','portugal'), ('kaka','brazil')] ) # sequence of key-value pair is passed
>>> players
{'ronaldo': 'portugal', 'kaka': 'brazil', 'messi': 'argentina'}
>>>
>>> # If keys are simple strings, it's quite easier to specify pairs using keyword arguments
...
>>> dict( totti = 38, zidane = 43 )
{'zidane': 43, 'totti': 38}
```
Las comprensiones de Dict también se pueden utilizar para crear diccionarios a partir de expresiones de valor y clave arbitrarias:
```python
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
```
**Bucle en Diccionario**
Para simplemente pasar las claves en el diccionario, en lugar de las claves y valores:
```python
>>> d = {'x': 1, 'y': 2, 'z': 3}
>>> for key in d:
... print(key) # do something
...
x
y
z
```
Para recorrer tanto la clave como el valor, puede utilizar lo siguiente:
Para Python 2.x:
```python
>>> for key, item in d.iteritems():
... print items
...
1
2
3
```
Use **`items()`** para Python 3.x:
```python
>>> for key, item in d.items():
... print(key, items)
...
x 1
y 2
z 3
```

118
guide/spanish/python/data-structures/floating-point-numbers/index.md Normal file
View File

@@ -0,0 +1,118 @@
---
title: Python Floating Point Numbers
localeTitle: Números de punto flotante de Python
---
[Aquí](https://docs.python.org/3/tutorial/floatingpoint.html) se puede encontrar información general sobre los números de punto flotante y cómo funcionan en Python.
Casi todas las implementaciones de Python siguen la especificación IEEE 754: Estándar para aritmética de punto flotante binario. Más información se encuentra en el [sitio IEEE](http://grouper.ieee.org/groups/754/) .
Los objetos flotantes se pueden crear utilizando [literales de punto flotante](https://docs.python.org/3/reference/lexical_analysis.html#floating-point-literals) :
```
>>> 3.14
3.14
>>> 314\. # Trailing zero(s) not required.
314.0
>>> .314 # Leading zero(s) not required.
0.314
>>> 3e0
3.0
>>> 3E0 # 'e' or 'E' can be used.
3.0
>>> 3e1 # Positive value after e moves the decimal to the right.
30.0
>>> 3e-1 # Negative value after e moves the decimal to the left.
0.3
>>> 3.14e+2 # '+' not required but can be used for exponent part.
314.0
```
Los literales numéricos no contienen un signo, sin embargo, es posible crear objetos flotantes negativos prefijando con un operador unario `-` (menos) sin espacio antes del literal
```
>>> -3.141592653589793
-3.141592653589793
>>> type(-3.141592653589793)
<class 'float'>
```
Del mismo modo, los objetos flotantes positivos se pueden prefijar con un operador unario `+ (` más) sin espacio antes del literal. Normalmente se omite `+`
```
>>> +3.141592653589793
3.141592653589793
```
Tenga en cuenta que los cero iniciales y finales son válidos para literales de punto flotante
```
>>> 0.0
0.0
>>> 00.00
0.0
>>> 00100.00100
100.001
>>> 001e0010 # Same as 1e10
10000000000.0
```
El [constructor `float`](https://docs.python.org/3/library/functions.html#float) es otra forma de crear objetos `float` .
La creación de `float` objetos con los literales de punto flotante se prefiere cuando sea posible:
```
>>> a = 3.14 # Prefer floating point literal when possible.
>>> type(a)
<class 'float'>
>>> b = int(3.14) # Works but unnecessary.
>>> type(b)
<class 'float'>
```
Sin embargo, el constructor flotante permite crear objetos flotantes de otros tipos de números:
```
>>> a = 4
>>> type(a)
<class 'int'>
>>> print(a)
4
>>> b = float(4)
>>> type(b)
<class 'float'>
>>> print(b)
4.0
>>> float(400000000000000000000000000000000)
4e+32
>>> float(.00000000000000000000000000000004)
4e-32
>>> float(True)
1.0
>>> float(False)
0.0
```
El constructor `float` también creará objetos `float` partir de cadenas que representan números literales:
```
>>> float('1')
1.0
>>> float('.1')
0.1
>>> float('3.')
3.0
>>> float('1e-3')
0.001
>>> float('3.14')
3.14
>>> float('-.15e-2')
-0.0015
```
El constructor `float` también se puede usar para hacer una representación numérica de `NaN` (No es un número), `infinity` negativo e `infinity` (las cadenas de notas para estas son insensibles a mayúsculas y minúsculas):
```
>>> float('nan')
nan
>>> float('inf')
inf
>>> float('-inf')
-inf
>>> float('infinity')
inf
>>> float('-infinity')
-inf
```

18
guide/spanish/python/data-structures/index.md Normal file
View File

@@ -0,0 +1,18 @@
---
title: The Python Data Structures
localeTitle: Las estructuras de datos de Python
---
Una estructura de datos es una forma particular de organizar los datos en una computadora para que pueda usarse de manera eficiente. Python viene con un conjunto robusto de estructuras de datos incorporadas. Algunos de los más utilizados son:
* Liza
* Tuplas
* Los diccionarios
Principalmente, las estructuras de datos se pueden dividir en dos categorías:
* Mutable: una estructura de datos mutable es una estructura cuyo estado se puede modificar después de su creación. Las listas de Python y los diccionarios son mutables.
* Inmutable: - Una estructura de datos inmutable no puede ser modificada. Ejemplo: - Una vez que se crea una tupla, no podemos actualizar los valores dentro de ella.
## Referencia:
[Estructuras de datos de Python](https://docs.python.org/3.7/tutorial/datastructures.html)

165
guide/spanish/python/data-structures/integers/index.md Normal file
View File

@@ -0,0 +1,165 @@
---
title: Python Integers
localeTitle: Enteros de Python
---
El dominio teórico para enteros en python es infinito negativo a infinito. En la práctica, los valores enteros están limitados por la cantidad de memoria disponible.
En Python 2, había una distinción entre **`int`** , números que caben en números de 32 o 64 bit _C_ , y **`long`** , limitados por la memoria disponible. Python 3 unificó los dos tipos en solo **`int`** , más información en [PEP 237](https://www.python.org/dev/peps/pep-0237/) .
**creación `int` utilizando literales enteros**
[Literales enteros](https://docs.python.org/3/reference/lexical_analysis.html#integer-literals)
_Los objetos enteros_ se pueden crear utilizando literales enteros. Los números sin adornos sin decimales son literales enteros:
```
>>> 1234567890 # Unadorned numbers are integer literals
1234567890
>>> type(1234567890)
<class 'int'>
```
Los literales numéricos no contienen un signo, sin embargo, es posible crear _objetos enteros_ negativos prefijando con un operador unario `-` (menos) sin espacio antes del literal:
```
>>> -1234567890
-1234567890
>>> type(-1234567890)
<class 'int'>
```
Del mismo modo, los objetos enteros positivos se pueden crear prefijando un operador unario `+` (más) sin espacio antes de los dígitos. Por lo general, `+` es omitido:
```
>>> +1234
1234
```
Los enteros binarios (base 2, prefijo: `0b` o `0B` ), octal (base 8, prefijo: `0o` o `0O` ) y hexadecimal (base 16, prefijo: `0x` o `0X` ) también pueden crearse utilizando literales enteros:
```
>>> 0b1, 0b10, 0b11
(1, 2, 3)
>>> 0o1, 0o10, 0o11
(1, 8, 9)
>>> 0x1, 0x10, 0x11
(1, 16, 17)
```
Tenga en cuenta que los 0 iniciales para los literales enteros distintos de cero **no** están **permitidos** :
```
>>> 0 # Zero by itself is okay.
0
>>> 01 # Leading zero(s) cause SyntaxError.
File "<stdin>", line 1
01
^
SyntaxError: invalid token
```
El [constructor](https://docs.python.org/3/library/functions.html#int) `int` es otra forma de crear _objetos enteros_ .
```
class int(x=0)
class int(x, base=10)
```
La creación de _objetos enteros_ con literales enteros se prefiere cuando es posible:
```
>>> a = 1 # Prefer integer literal when possible.
>>> type(a)
<class 'int'>
>>> b = int(1) # Works but unnecessary.
>>> type(b)
<class 'int'>
```
Sin embargo, el constructor permite crear _objetos enteros_ de otros tipos de números:
```
>>> a = 1.123
>>> type(a)
<class 'float'>
>>> print(a)
1.123
>>> b = int(1.123)
>>> type(b)
<class 'int'>
>>> print(b)
1
```
El uso del constructor `int` para los números de punto flotante truncará el número hacia cero:
```
>>> int(-1.23)
-1
>>> int(1.23)
1
```
Las constantes `boolean` integradas son instancias de la clase `bool` , y son subclases de la clase `int` , lo que las convierte en un tipo de tipo numérico:
```
>>> type(True)
<class 'bool'>
>>> issubclass(bool, int)
True
```
Si eso no tiene sentido para ti, no te preocupes. Por ahora solo recuerda que llamar al constructor int con objetos `boolean` devolverá _objetos enteros_ :
```
>>> int(True)
1
>>> int(False)
0
```
El constructor `int` también creará _objetos enteros a_ partir de cadenas:
```
>>> a = "10"
>>> type(a)
<class 'str'>
>>> b = int("10")
>>> type(b)
<class 'int'>
```
_Las cadenas_ para el constructor `int` deben representar un literal entero:
El segundo parámetro del constructor `int` es especificar una base (por defecto: 10). Las bases válidas son 0 y 2-36.
Si se proporciona una base explícita, el primer argumento debe ser una cadena.
```
>>> int("111", 2)
7
>>> int(111, 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: int() can't convert non-string with explicit base
```
La cadena utilizada para el constructor `int` con una base explícita debe ser un literal entero válido para esa base:
```
>>> int('11', 2)
3
>>> int('12', 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 2: '12'
```
Se pueden usar tanto cadenas prefijadas como no prefijadas de literales enteros, sin embargo, si se usan, el prefijo debe coincidir con la base proporcionada.
```
>>> int('1101', 2)
13
>>> int('0b1101', 2)
13
>>> int('0x1101', 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 2: '0x1101'
```
Si se usa una cadena prefijada y una base 0, el objeto entero creado usará la base especificada por el prefijo. Si no se usa ningún prefijo, entonces se supone que la base 10
```
>>> int('100', 0)
100
>>> int('0b100', 0)
4
>>> int('0o100', 0)
64
```

116
guide/spanish/python/data-structures/objects/index.md Normal file
View File

@@ -0,0 +1,116 @@
---
title: The Python Objects
localeTitle: Los objetos de Python
---
> En Python, todo es un _objeto_ .
_Los objetos_ representan una agrupación lógica de atributos. Los atributos son datos y / o funciones. Cuando se crea un objeto en Python, se crea con una _identidad_ , _tipo_ y _valor_ .
En otros idiomas, las _primitivas_ son _valores_ que no tienen _propiedades_ (atributos). Por ejemplo, en javascript `undefined` , `null` , `boolean` , `string` , `number` y `symbol` (nuevo en ECMAScript 2015) son primitivos.
En Python, no hay primitivos. `None` , _booleanos_ , _cadenas_ , _números_ e incluso _funciones_ son _objetos,_ independientemente de cómo se creen.
Podemos demostrar esto usando algunas funciones incorporadas:
* [`id`](https://docs.python.org/3/library/functions.html#id)
* [`type`](https://docs.python.org/3/library/functions.html#type)
* [`dir`](https://docs.python.org/3/library/functions.html#dir)
* [`issubclass`](https://docs.python.org/3/library/functions.html#issubclass)
Las constantes incorporadas `None` , `True` y `False` son _objetos_ :
Aquí probamos el objeto `None` .
```python
>>> id(None)
4550218168
>>> type(None)
<class 'NoneType'>
>>> dir(None)
[__bool__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
>>> issubclass(type(None), object)
True
```
A continuación, vamos a inspeccionar el `True` .
```python
>>> id(True)
4550117616
>>> type(True)
<class 'bool'>
>>> dir(True)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
>>> issubclass(type(True), object)
True
```
No hay razón para dejar de lado lo `False` !
```python
>>> id(False)
4550117584
>>> type(False)
<class 'bool'>
>>> dir(False)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
>>> issubclass(type(False), object)
True
```
_Las cadenas_ , incluso cuando son creadas por literales de una cadena, también son _objetos_ .
```python
>>> id("Hello campers!")
4570186864
>>> type('Hello campers!')
<class 'str'>
>>> dir("Hello campers!")
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> issubclass(type('Hello campers!'), object)
True
```
Igual con _numeros_
```python
>>> id(42)
4550495728
>>> type(42)
<class 'int'>
>>> dir(42)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
>>> issubclass(type(42), object)
True
```
## Las funciones son objetos también
> En Python, las funciones son objetos de primera clase.
_Las funciones_ en Python también son _objetos_ , creados con una _identidad_ , _tipo_ y _valor_ . Ellos también pueden ser pasados ​​a otras _funciones_ :
```python
>>> id(dir)
4568035688
>>> type(dir)
<class 'builtin_function_or_method'>
>>> dir(dir)
['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']
>>> issubclass(type(dir), object)
True
```
También es posible vincular funciones a un nombre y llamar a la función enlazada usando ese nombre:
```python
>>> a = dir
>>> print(a)
<built-in function dir>
>>> a(a)
['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']
```
Recursos:
* [Haga clic aquí](https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/) para obtener más información.

87
guide/spanish/python/data-structures/ranges/index.md Normal file
View File

@@ -0,0 +1,87 @@
---
title: The Python Range
localeTitle: El rango de Python
---
## Rangos de Python
En lugar de ser una función, un rango es en realidad un [tipo de secuencia inmutable](https://docs.python.org/3/library/stdtypes.html#immutable-sequence-types) y se usa comúnmente para hacer un bucle un número específico de veces en los bucles.
**Creación:**
`ranges` se crean utilizando el constructor de `range` . Los parámetros para el constructor son:
* `start` : primer valor inclusivo del rango (entero opcional, predeterminado en 0).
* `stop` : valor de parada exclusivo, el rango se detiene cuando se proporcionará este valor o mayor (entero necesario).
* `step` : la cantidad agregada al valor actual para obtener el siguiente valor (entero opcional, predeterminado en 1).
```python
>>> range(10) # Only the stop parameter is required.
range(0, 10)
>>> range(0, 10) # Default for start parameter is 0.
range(0, 10)
>>> range(0, 10, 1) # Default for step is 1\. Start parameter is required if
step is needed.
range(0, 10)
```
**Ejemplos:**
Como los `ranges` son iterables, se pueden pasar a la `list` y a los constructores de `tuple` para crear esos tipos de secuencias. Usando este hecho, podemos visualizar algunos ejemplos:
```python
>>> list(range(10)) # range as argument for list constructor.
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> tuple(range(10)) # range as argument for tuple constructor.
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
```
`ranges` longitud cero:
```python
>>> list(range(10, 0)) # start greater than stop with postive step.
[]
>>> list(range(10, 10)) # start equal to stop with postive step.
[]
>>> list(range(10, 10, -1)) # start equal to stop with negative step.
[]
>>> list(range(0, 10, -1)) # start less than stop with negative step.
[]
```
`ranges` con argumentos de paso:
```python
>>> list(range(0, 10, 2)) # next value would be 10, stops at 8.
[0, 2, 4, 6, 8]
>>> list(range(0, 10, 3)) # next value would be 12, stops at 9.
[0, 3, 6, 9]
>>> list(range(0, 10, 4)) # next value would be 12, stops at 8.
[0, 4, 8]
>>> list(range(10, 0, -1)) # negative step makes decreasing ranges.
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> list(range(-5, -30, -3)) # negative integers are valid arguments.
[-5, -8, -11, -14, -17, -20, -23, -26, -29]
```
**Beneficios:**
La ventaja de utilizar el `range` es que, independientemente del tamaño del rango especificado, solo se necesita una pequeña cantidad de memoria para almacenar el `range` , los valores de inicio, parada y paso. Los valores individuales de los `ranges` se calculan por iteración.
```python
>>> import sys
>>> a_range = range(1000000)
>>> a_list = list(a_range)
>>> a_tuple = tuple(a_range)
>>> sys.getsizeof(a_range)
48
>>> sys.getsizeof(a_list)
9000112
>>> sys.getsizeof(a_tuple)
8000048
```
### Más información:
[Python Doc - Rangos](https://docs.python.org/3/library/stdtypes.html#ranges)
**TODO: Métodos que los `ranges` implementan y no implementan.**

13
guide/spanish/python/data-structures/scopes/index.md Normal file
View File

@@ -0,0 +1,13 @@
---
title: The Python Scopes
localeTitle: Los alcances de Python
---
**TODO: NOTA**
* Esto pertenece cerca del bloque de código y la información de sangría.
* Esto también está relacionado con las variables, ya que la búsqueda de nombres y la vinculación están relacionadas con los ámbitos.
**TODO: CONTENIDO**
* `global`
* `nonlocal`

36
guide/spanish/python/data-structures/strings/index.md Normal file
View File

@@ -0,0 +1,36 @@
---
title: The Python Strings
localeTitle: Las cuerdas de Python
---
Python permite que los objetos `str` , o _cadenas_ , se expresen de diferentes maneras:
* Comillas simples: `'Single quote strings can have "double" quotes inside.'`
* Comillas dobles: `"Double quote strings can have 'single' quotes inside."`
* Triple citado:
```
"""Triple quoted strings can span multiple lines.
Unescaped "double" and 'single' quotes in triple quoted strings are retained."""
'''Triple quoted strings can be 'single'or "double" quotes.
Unescaped newlines are also retained.'''
```
* Inmutable: no puede editar / cambiar directamente una cadena Python después de haberla creado. Por ejemplo, si intenta reasignar / cambiar directamente la primera letra de una cadena, se produce un error.
```
>>> foo = "my string"
>>> foo[0] = "a"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
```
## Referencia:
[Tipo de secuencia de texto _str_](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)

196
guide/spanish/python/data-structures/tuples/index.md Normal file
View File

@@ -0,0 +1,196 @@
---
title: The Tuples
localeTitle: Las Tuplas
---
## Las Tuplas
Una tupla es una secuencia de objetos de Python. Las tuplas son inmutables, lo que significa que no se pueden modificar después de la creación, a diferencia de las listas.
**Creación:**
Se crea una `tuple` vacía utilizando un par de paréntesis, `()` :
```shell
>>> empty_tuple = ()
>>> print(empty_tuple)
()
>>> type(empty_tuple)
<class 'tuple'>
>>> len(empty_tuple)
0
```
Se crea una `tuple` con elementos al separar los elementos con comas (los corchetes circundantes, `()` , son opcionales con excepciones):
```shell
>>> tuple_1 = 1, 2, 3 # Create tuple without round brackets.
>>> print(tuple_1)
(1, 2, 3)
>>> type(tuple_1)
<class 'tuple'>
>>> len(tuple_1)
3
>>> tuple_2 = (1, 2, 3) # Create tuple with round brackets.
>>> print(tuple_2)
(1, 2, 3)
>>> tuple_3 = 1, 2, 3, # Trailing comma is optional.
>>> print(tuple_3)
(1, 2, 3)
>>> tuple_4 = (1, 2, 3,) # Trailing comma in round brackets is also optional.
>>> print(tuple_4)
(1, 2, 3)
```
Una `tuple` con un solo elemento debe tener una coma al final (con o sin paréntesis):
```shell
>>> not_tuple = (2) # No trailing comma makes this not a tuple.
>>> print(not_tuple)
2
>>> type(not_tuple)
<class 'int'>
>>> a_tuple = (2,) # Single element tuple. Requires trailing comma.
>>> print(a_tuple)
(2,)
>>> type(a_tuple)
<class 'tuple'>
>>> len(a_tuple)
1
>>> also_tuple = 2, # Round brackets omitted. Requires trailing comma.
>>> print(also_tuple)
(2,)
>>> type(also_tuple)
<class 'tuple'>
```
Los paréntesis se requieren en casos de ambigüedad (si la tupla es parte de una expresión más grande):
> Tenga en cuenta que en realidad es la coma la que forma una tupla, no los paréntesis. Los paréntesis son opcionales, excepto en el caso de la tupla vacía, o cuando son necesarios para evitar la ambigüedad sintáctica. Por ejemplo, `f(a, b, c)` es una llamada de función con tres argumentos, mientras que `f((a, b, c))` es una llamada de función con una tupla de 3 como único argumento.
```shell
>>> print(1,2,3,4,) # Calls print with 4 arguments: 1, 2, 3, and 4
1 2 3 4
>>> print((1,2,3,4,)) # Calls print with 1 argument: (1, 2, 3, 4,)
(1, 2, 3, 4)
>>> 1, 2, 3 == (1, 2, 3) # Equivalent to 1, 2, (3 == (1, 2, 3))
(1, 2, False)
>>> (1, 2, 3) == (1, 2, 3) # Use surrounding round brackets when ambiguous.
True
```
Una `tuple` también se puede crear con la `tuple` constructor:
```shell
>>> empty_tuple = tuple()
>>> print(empty_tuple)
()
>>> tuple_from_list = tuple([1,2,3,4])
>>> print(tuple_from_list)
(1, 2, 3, 4)
>>> tuple_from_string = tuple("Hello campers!")
>>> print(tuple_from_string)
('H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!')
>>> a_tuple = 1, 2, 3
>>> b_tuple = tuple(a_tuple) # If the constructor is called with a tuple for
the iterable,
>>> a_tuple is b_tuple # the tuple argument is returned.
True
```
**Accediendo a los elementos de una `tuple` :**
Se accede a los elementos de las `tuples` y se indexan de la misma manera que las `lists` .
```shell
>>> my_tuple = 1, 2, 9, 16, 25
>>> print(my_tuple)
(1, 2, 9, 16, 25)
```
_Cero indexado_
```shell
>>> my_tuple[0]
1
>>> my_tuple[1]
2
>>> my_tuple[2]
9
```
_Envolver alrededor de la indexación_
```shell
>>> my_tuple[-1]
25
>>> my_tuple[-2]
16
```
**Embalaje y desembalaje:**
La declaración `t = 12345, 54321, 'hello!'` es un ejemplo de empaquetamiento de tuplas: los valores `12345` , `54321` y `'hello!'` se empaquetan juntos en una tupla. La operación inversa también es posible:
```shell
>>> x, y, z = t
```
Esto se denomina, apropiadamente, desempaquetado de secuencias y funciona para cualquier secuencia en el lado derecho. El desempaquetado de secuencias requiere que haya tantas variables en el lado izquierdo del signo igual como elementos en la secuencia. Tenga en cuenta que la asignación múltiple es solo una combinación de empaquetamiento de tuplas y desempaquetado de secuencias.
```shell
>>> t = 1, 2, 3 # Tuple packing.
>>> print(t)
(1, 2, 3)
>>> a, b, c = t # Sequence unpacking.
>>> print(a)
1
>>> print(b)
2
>>> print(c)
3
>>> d, e, f = 4, 5, 6 # Multiple assignment combines packing and unpacking.
>>> print(d)
4
>>> print(e)
5
>>> print(f)
6
>>> a, b = 1, 2, 3 # Multiple assignment requires each variable (right)
have a matching element (left).
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)
```
**Inmutable:**
`tuples` son contenedores inmutables, garantizando **que los** objetos que contienen no cambien. Esto **no** garantiza que los objetos que contiene no cambiarán:
```shell
>>> a_list = []
>>> a_tuple = (a_list,) # A tuple (immutable) with a list (mutable) element.
>>> print(a_tuple)
([],)
>>> a_list.append("Hello campers!")
>>> print(a_tuple) # Element of the immutable is mutated.
(['Hello campers!'],)
```
**Usos:**
Las funciones solo pueden devolver un solo valor, sin embargo, se puede usar una `tuple` heterogénea para devolver múltiples valores desde una función. Un ejemplo es la función de `enumerate` integrada que devuelve una iterable de `tuples` heterogéneas:
```shell
>>> greeting = ["Hello", "campers!"]
>>> enumerator = enumerate(greeting)
>>> enumerator.next()
>>> enumerator.__next__()
(0, 'Hello')
>>> enumerator.__next__()
(1, 'campers!')
```
### Más información:
[Python Docs - Tuples](https://docs.python.org/3/library/stdtypes.html#tuples)

263
guide/spanish/python/decorators/index.md Normal file
View File

@@ -0,0 +1,263 @@
---
title: Python Decorators
localeTitle: Decoradores de pitón
---
Los decoradores trabajan esencialmente como envoltorios. Modifican el comportamiento del código antes y después de la ejecución de una función de destino, sin la necesidad de modificar la función en sí, lo que aumenta la funcionalidad original y, por lo tanto, la decora.
Antes de entrar en detalle sobre los decoradores, hay algunos conceptos que deben ser claros. En Python, las funciones son objetos y podemos hacer muchas cosas útiles con ellos.
> ### Asignando funciones a una variable:
```
def greet(name):
return "Hello "+name
greet_someone = greet
print greet_someone("John")
```
> Salida: Hola John
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXGk)
> ### Definiendo funciones dentro de otras funciones:
```
def greet(name):
def get_message():
return "Hello "
result = get_message()+name
return result
print(greet("John"))
```
> Salida: Hola John
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXGu)
> ### Las funciones también se pueden pasar como parámetros a otras funciones:
```
def greet(name):
return "Hello " + name
def call_func(func):
other_name = "John"
return func(other_name)
print call_func(greet)
```
> Salida: Hola John
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXHC)
> ### Las funciones pueden devolver otras funciones:
>
> En otras palabras, funciones que generan otras funciones.
```
def compose_greet_func():
def get_message():
return "Hello there!"
return get_message
greet = compose_greet_func()
print(greet())
```
Salida: ¡Hola!
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXHG)
> ### Las funciones internas tienen acceso al ámbito adjunto.
>
> Más comúnmente conocido como un [cierre](http://www.shutupandship.com/2012/01/python-closures-explained.html) . Un patrón muy poderoso que encontraremos mientras construimos decoradores. Otra cosa a tener en cuenta, Python solo permite el [acceso de lectura al ámbito externo](http://www.tech-thoughts-blog.com/2013/07/writing-closure-in-python.html) y no la asignación. Observe cómo modificamos el ejemplo anterior para leer un argumento de "nombre" en el ámbito de la función interna y devolver la nueva función.
```
def compose_greet_func(name):
def get_message():
return "Hello there "+name+"!"
return get_message
greet = compose_greet_func("John")
print(greet())
```
> Salida: ¡Hola Juan!
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXHI)
## Composición de los decoradores
Los decoradores de funciones son simplemente envoltorios de funciones existentes. Juntando las ideas mencionadas arriba, podemos construir un decorador. En este ejemplo, consideremos una función que envuelve la salida de cadena de otra función mediante p etiquetas.
```
def get_text(name):
return "lorem ipsum, {0} dolor sit amet".format(name)
def p_decorate(func):
def func_wrapper(name):
return "`<p>`{0}`</p>`".format(func(name))
return func_wrapper
my_get_text = p_decorate(get_text)
print (my_get_text("John"))
```
> Salida: `<p>` lorem ipsum, John dolor sit amet `</p>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXHL)
Ese fue nuestro primer decorador. Una función que toma otra función como argumento, genera una nueva función, aumenta el trabajo de la función original y devuelve la función generada para que podamos usarla en cualquier lugar. Para que `get_text` sea ​​decorado por `p_decorate` , solo tenemos que asignar get _text al resultado de p_ decorate.
```
get_text = p_decorate(get_text)
print (get_text("John"))
```
> Salida: lorem ipsum, John dolor sit amet
Otra cosa a tener en cuenta es que nuestra función decorada toma un argumento de nombre. Todo lo que tuvimos que hacer en el decorador es dejar que la envoltura de get\_text pase ese argumento.
> ### Sintaxis del decorador de Python
Python hace que la creación y el uso de decoradores sean un poco más limpios y agradables para el programador a través de un poco de [azúcar sintáctica.](http://en.wikipedia.org/wiki/Syntactic_sugar) Para decorar obtener _texto no tenemos que obtener_ text = p _decorator (obtener_ texto). Hay un atajo limpio para eso, que es mencionar Nombre de la función de decoración antes de la función a decorar. El nombre del decorador debe aparecer con un símbolo @.
```
def p_decorate(func):
def func_wrapper(name):
return "`<p>`{0}`</p>`".format(func(name))
return func_wrapper
@p_decorate
def get_text(name):
return "lorem ipsum, {0} dolor sit amet".format(name)
print get_text("John")
```
> Salida: `<p>` lorem ipsum, John dolor sit amet `</p>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXHN)
Ahora consideremos que queríamos decorar nuestra función get\_text con otras 2 funciones para envolver una etiqueta div y strong alrededor de la salida de la cadena.
```
def p_decorate(func):
def func_wrapper(name):
return "`<p>`{0}`</p>`".format(func(name))
return func_wrapper
def strong_decorate(func):
def func_wrapper(name):
return "`<strong>`{0}`</strong>`".format(func(name))
return func_wrapper
def div_decorate(func):
def func_wrapper(name):
return "`<div>`{0}`</div>`".format(func(name))
return func_wrapper
```
Con el enfoque básico, decorar get\_text estaría en la línea de
```
get_text = div_decorate(p_decorate(strong_decorate(get_text)))
```
Con la sintaxis decorativa de Python, se puede lograr lo mismo con un poder mucho más expresivo.
```
@div_decorate
@p_decorate
@strong_decorate
def get_text(name):
return "lorem ipsum, {0} dolor sit amet".format(name)
print (get_text("John"))
```
> Salida: `<div><p><strong>` lorem ipsum, John dolor sit amet `</strong></p></div>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXHQ)
Una cosa importante a tener en cuenta aquí es que el orden de configuración de nuestros decoradores es importante. Si el orden fuera diferente en el ejemplo anterior, la salida hubiera sido diferente. ## Métodos de decoración En Python, los métodos son funciones que esperan que su primer parámetro sea una referencia al objeto actual. Podemos construir decoradores para métodos de la misma manera, mientras nos tomamos en cuenta la función de envoltura.
```
def p_decorate(func):
def func_wrapper(self):
return "`<p>`{0}`</p>`".format(func(self))
return func_wrapper
class Person(object):
def __init__(self):
self.name = "John"
self.family = "Doe"
@p_decorate
def get_fullname(self):
return self.name+" "+self.family
my_person = Person()
print (my_person.get_fullname())
```
> Salida: `<p>` John Doe `</p>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXH2)
Un enfoque mucho mejor sería hacer que nuestro decorador sea útil para funciones y métodos por igual. Esto se puede hacer poniendo [\* args y \*\* kwargs](http://docs.python.org/2/tutorial/controlflow.html#arbitrary-argument-lists) como parámetros para el contenedor, entonces puede aceptar cualquier número arbitrario de argumentos y argumentos de palabras clave.
```
def p_decorate(func):
def func_wrapper(*args, **kwargs):
return "`<p>`{0}`</p>`".format(func(*args, **kwargs))
return func_wrapper
class Person(object):
def __init__(self):
self.name = "John"
self.family = "Doe"
@p_decorate
def get_fullname(self):
return self.name+" "+self.family
my_person = Person()
print (my_person.get_fullname())
```
> Salida: `<p>` John Doe `</p>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXH5)
### Pasando argumentos a los decoradores Mirando hacia atrás en el ejemplo anterior al anterior, puedes notar cuán redundantes son los decoradores en el ejemplo. 3 decoradores (div _decorate, p_ decorate, strong\_decorate) cada uno con la misma funcionalidad pero envolviendo la cadena con diferentes etiquetas. Definitivamente podemos hacerlo mucho mejor que eso. ¿Por qué no tener una implementación más general para una que lleve la etiqueta a una cadena? ¡Sí por favor!
```
def tags(tag_name):
def tags_decorator(func):
def func_wrapper(name):
return "<{0}>{1}</{0}>".format(tag_name, func(name))
return func_wrapper
return tags_decorator
@tags("p")
def get_text(name):
return "Hello "+name
print (get_text("John"))
```
> Salida: `<p>` Hola Juan `</p>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXH6)
Tomó un poco más de trabajo en este caso. Los decoradores esperan recibir una función como argumento, es por eso que tendremos que construir una función que tome esos argumentos adicionales y genere nuestro decorador sobre la marcha. En el ejemplo anterior, las etiquetas, es nuestro generador decorador. Depuración de funciones decoradas Al final del día, los decoradores están envolviendo nuestras funciones, en caso de que la depuración sea problemática, ya que la función de envoltura no lleva el nombre, el módulo y la cadena de documentos de la función original. Basado en el ejemplo anterior si hacemos:
```
print (get_text.__name__)
```
> Salida: _envoltorio_ funcional _Se esperaba que el resultado fuera obtener_ texto, los atributos **nombre** , **documento** y **módulo** de obtener _texto fueron reemplazados por los del envoltorio (_ envoltorio _func_ . Obviamente, podemos restablecerlos dentro de func\_wrapper pero Python proporciona una gran cantidad de recursos). Manera más agradable. ### Functools al rescate.
```
from functools import wraps
def tags(tag_name):
def tags_decorator(func):
@wraps(func)
def func_wrapper(name):
return "`<{0}>`{1}`</{0}>`".format(tag_name, func(name))
return func_wrapper
return tags_decorator
@tags("p")
def get_text(name):
"""returns some text"""
return "Hello "+name
print (get_text.__name__) # get_text
print (get_text.__doc__) # returns some text
print (get_text.__module__) # __main__
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CXHb)
Puede observar en la salida que los atributos de get\_text son los correctos ahora.

137
guide/spanish/python/defaultdict/index.md Normal file
View File

@@ -0,0 +1,137 @@
---
title: Python defaultdict
localeTitle: Python defaultdict
---
## Python defaultdict
El diccionario es una de las estructuras de datos más utilizadas en Python. Un diccionario es una colección desordenada de elementos y generalmente tenemos claves y valores almacenados en un diccionario. Veamos algunos ejemplos de cómo se usa generalmente el diccionario.
```python
# dictionary declaration 1
dict1 = dict()
# dictionary declaration 2
dict2 = {}
# Add items to the dictionary
# The syntax to add and retrieve items is same for either of the two objects we defined above.
key = "X"
value = "Y"
dict1[key] = value
# The dictionary doesn't have any specific data-type.
# So, the values can be pretty diverse.
dict1[key] = dict2
```
Veamos ahora algunas formas de recuperación.
```python
# Since "X" exists in our dictionary, this will retrieve the value
value = dict1[key]
# This key doesn't exist in the dictionary.
# So, we will get a `KeyError`
value = dict1["random"]
```
### Evitar KeyError: utilizar la función .get
En caso de que la clave dada no exista en el diccionario, Python lanzará un `KeyError` . Hay una solución simple para esto. Veamos cómo podemos evitar `KeyError` usando el Función `.get` incorporada para diccionarios.
```python
dict_ = {}
# Some random key
random_key = "random"
# The most basic way of doing this is to check if the key
# exists in the dictionary or not and only retrieve if the
# key exists. Otherwise not.
if random_key in dict_:
print(dict_[random_key])
else:
print("Key = {} doesn't exist in the dictionary".format(dict_))
```
Muchas veces estamos bien obteniendo un valor predeterminado cuando la clave no existe. Por ejemplo, cuando construyendo un mostrador. Hay una mejor manera de obtener valores predeterminados del diccionario en caso de faltan claves en lugar de confiar en el estándar `if-else` .
```python
# Let's say we want to build a frequency counter for items in the following array
arr = [1,2,3,1,2,3,4,1,2,1,4,1,2,3,1]
freq = {}
for item in arr:
# Fetch a value of 0 in case the key doesn't exist. Otherwise, fetch the stored value
freq[item] = freq.get(item, 0) + 1
```
Por lo tanto, el `get(<key>, <defaultval>)` es una operación útil para recuperar el valor predeterminado para cualquier clave dada del diccionario. El problema con este método viene cuando queremos tratar con estructuras de datos mutables como valores, por ejemplo, `list` o `set` .
```python
dict_ = {}
# Some random key
random_key = "random"
dict_[random_key] = dict_.get(random_key, []).append("Hello World!")
print(dict_) # {'random': None}
dict_ = {}
dict_[random_key] = dict_.get(random_key, set()).add("Hello World!")
print(dict_) # {'random': None}
```
¿Viste el problema?
El nuevo `set` o la `list` no se asignan a la clave del diccionario. Debemos asignar una nueva `list` o un `set` a la clave en caso de que falte valor y luego `append` o `add` respectivamente. La mirada de Ley a un ejemplo para esto.
```python
dict_ = {}
dict_[random_key] = dict_.get(random_key, set())
dict_[random_key].add("Hello World!")
print(dict_) # {'random': set(['Hello World!'])}. Yay!
```
### Evitando KeyError: Use defaultdict
Esto funciona la mayoría de las veces. Sin embargo, hay una mejor manera de hacer esto. Una forma más `pythonic` . El valor `defaultdict` es una subclase de la clase dict incorporada. El `defaultdict` simplemente asigna el valor predeterminado que se especifica en el caso de una llave perdida. Entonces, los dos pasos:
```python
dict_[random_key] = dict_.get(random_key, set())
dict_[random_key].add("Hello World!")
```
Ahora se puede combinar en un solo paso. Por ejemplo
```python
from collections import defaultdict
# Yet another random key
random_key = "random_key"
# list defaultdict
list_dict_ = defaultdict(list)
# set defaultdict
set_dict_ = defaultdict(set)
# integer defaultdict
int_dict_ = defaultdict(int)
list_dict_[random_key].append("Hello World!")
set_dict_[random_key].add("Hello World!")
int_dict_[random_key] += 1
"""
defaultdict(<class 'list'>, {'random_key': ['Hello World!']})
defaultdict(<class 'set'>, {'random_key': {'Hello World!'}})
defaultdict(<class 'int'>, {'random_key': 1})
"""
print(list_dict_, set_dict_, int_dict_)
```
* * *
[Documentos oficiales](https://docs.python.org/2/library/collections.html)

24
guide/spanish/python/defining-functions/index.md Normal file
View File

@@ -0,0 +1,24 @@
---
title: Python Defining Functions
localeTitle: Funciones de definición de Python
---
[Python Docs](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)
Podemos crear una función que escriba la serie de Fibonacci en un límite arbitrario:
```
>>> def fib(n): # write Fibonacci series up to n
... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
```
La palabra clave [`def`](https://docs.python.org/3/reference/compound_stmts.html#def) introduce una definición de función. Debe ir seguido del nombre de la función y la lista de parámetros formales entre paréntesis. Las declaraciones que forman el cuerpo de la función comienzan en la siguiente línea y deben estar sangradas.
La primera declaración del cuerpo de la función puede ser opcionalmente una cadena literal; esta cadena literal es la cadena de la función de la documentación, o [cadena de documentación](https://www.python.org/dev/peps/pep-0257/) (Más información sobre las cadenas de documentación se pueden encontrar en las cadenas sección de documentación). Algunas herramientas usan cadenas de documentación para producir automáticamente documentación en línea o impresa o para permitir que el usuario navegue interactivamente a través del código. Es una buena práctica incluir las cadenas de documentación en el código que escribes, así que trata de convertirlo en un hábito.

27
guide/spanish/python/difference-between-is-and-equal-equal-operators/index.md Normal file
View File

@@ -0,0 +1,27 @@
---
title: Difference between Python 'is' and '==' operators
localeTitle: Diferencia entre los operadores Python 'is' y '=='
---
`is` una verificación de la identidad del objeto, es decir, verificar si dos o más variables se refieren al mismo objeto. No se puede sobrecargar `is` .
`==` evalúa como verdadero si el objeto al que hacen referencia las variables es igual. Puede sobrecargar `==` través del operador `__eq__` .
## Valor de retorno
El valor de retorno para ambos sería `True` o `False` .
## Ejemplo de código
```
a = 2.3
a is 2.3 # => False
a == 2.3 # => True
a = [234,123,321]
b = [234,123,321]
a == b # => True
a is b # => False
a = b
a == b # => True
a is b # => True, because if we change a, b changes too
```

67
guide/spanish/python/docstring/index.md Normal file
View File

@@ -0,0 +1,67 @@
---
title: Docstring
localeTitle: Docstring
---
## Docstring
Docstring es una forma en que los desarrolladores pueden comunicar el propósito, los parámetros, los requisitos y el uso de una función en Python a otros desarrolladores. Permite la facilidad de mantenimiento y comprensión del código.
A diferencia de los comentarios de código fuente convencionales, la cadena de documentación debe describir lo que La función hace, no cómo.
Un ejemplo similar a Docstring es @Javadoc en Java.
Docstring se escribe como un comentario de varias líneas justo después del encabezado de la declaración en Python. Hay 4 partes diferentes en una cadena de documentación:
1. Tipo de entrada, y tipo de salida
* La entrada / salida puede ser `obj, list, bool, int, str, float`
2. Descripción de la función
* Breve, pero completa descripción de lo que hace su función
3. Requerimientos
* Esto es leído por un humano, por lo que no tiene que ser un código
4. Casos de prueba (normalmente 2-3)
El formato general se detalla a continuación.
## Formato de Docstring
```python
def my_examplefunc(input_type1, input_type2):
'''(input_type1, input_type2) -> output_type # Your first line will be the input/output. Remember the space around the arrow!
Here is a description of my example function # Your second line will be the description
REQ: type(input_type1) == list # Your next line (or lines) will be the requirements for the input of your function
REQ: type(input_type2) == str
>>> my_example_func([2, 3], "Hello World!") # After the requirements come test cases
[2, 3] "Hello World"
>>> my_example_func([7, 2], "Another test case") # Your first line of the test case is an example of the usage, prefaced by >>>
[7, 2] "Another test case" # Your second line of the test case is the output
>>> my_example_func([5, 6], "Last test case")
[5, 6] "Last test case"
'''
# Your code goes here, underneath the Docstring
```
La cadena documental se entiende mejor con ejemplos, así que eche un vistazo al programa de ejemplo a continuación, en el que el programa muestra Verdadero si un número es menor que 5, y Falso si un número es mayor que 5.
## Ejemplo 1
```python
def is_less_than_five(some_number):
'''(int) -> bool
Returns True if the given number is less than 5, and False is the given number is greater than 5.
REQ: some_number != 5
>>> is_less_than_five(4)
True
>>> is_less_than_five(6)
False
>>> is_less_than_five(100000)
False
'''
# Your code goes here
```
### Algunos enlaces útiles:
Numpy y Google Docstrings son dos enfoques de uso común:
* Google: http://sphinxcontrib-napoleon.readthedocs.io/en/latest/example\_google.html
* Numpy: http://sphinxcontrib-napoleon.readthedocs.io/en/latest/example\_numpy.html También, consulte algunos buenos comentarios antiguos de PEP: https://www.python.org/dev/peps/pep-0257/

36
guide/spanish/python/escape-sequences/index.md Normal file
View File

@@ -0,0 +1,36 @@
---
title: Python Escape Sequences
localeTitle: Secuencias de escape de Python
---
Una lista de secuencias de escape se puede encontrar [aquí](https://docs.python.org/3/reference/lexical_analysis.html#strings)
Las secuencias de escape permiten incluir caracteres especiales en las cadenas.
```
>>> print('Single quote strings can have \'single\' quotes if they are escaped')
"Single quote strings can have 'single' quotes if they are escaped"
>>> print("Double quote strings can have \"double\" quotes if they are escaped")
'Double quote strings can have "double" quotes if they are escaped'
>>> print("Multiline strings\ncan be created\nusing escape sequences.")
Multiline strings
can be created
using escape sequences.
>>> print("Backslashes \\ need to be escaped.")
Backslashes \ need to be escaped.
```
Se puede usar una cadena en _bruto_ prefijando la cadena con `r` o `R` que permite que se incluyan barras invertidas sin la necesidad de escapar de ellas.
```
>>> print(r"Backslashes \ don't need to be escaped in raw strings.")
Backslashes \ don't need to be escaped in raw strings.
>>> print(r"An odd number of backslashes at the end of a raw string will cause an error\")
File "<stdin>", line 1
print(r"An odd number of backslashes at the end of a raw string will cause an error\")
^
SyntaxError: EOL while scanning string literal.
```
\# Algunos ejemplos más de secuencias de escape. Secuencia de escape
\\ Imprime la barra invertida
\`Imprime una sola cita
\\ "Imprime comillas dobles
\\ una campana ASCII hace sonar los sonidos de alerta de campana (por ejemplo, xterm) \\ b ASCII retroceso (BS) elimina el carácter anterior \\ n agrega nueva linea

32
guide/spanish/python/exception-and-error-handling/index.md Normal file
View File

@@ -0,0 +1,32 @@
---
title: Exceptions and Errors Handling
localeTitle: Excepciones y manejo de errores.
---
## Excepciones y manejo de errores.
Al crear un programa, podemos cometer errores que terminan con errores y los peores programas que hacemos dejan de ejecutarse, sería aún más molesto si no pudiéramos encontrar errores en el código que cometimos o en lo que estaba mal. En palabras simples, los errores son algo que los programadores evitan al hacer un programa. Para resolver este problema en Python podemos usar `try` y `except`
Ejemplo:
```shell
>>> try:
>>> . . . print "this is not a string "+1
>>> except:
>>> . . . print "error"
error
```
y si desea obtener mensajes de error más detallados de su código, puede agregar argumentos `except Exception as err`
```shell
>>> try:
>>> . . . print "this is not a string "+1
>>> except Exception as err:
>>> . . . print "error:\n"+str(err)
error:
cannot concatenate 'str' and 'int' objects
```
Más información:
[Documentación de](https://docs.python.org/2/tutorial/errors.html) errores y excepciones.

115
guide/spanish/python/files-and-io/index.md Normal file
View File

@@ -0,0 +1,115 @@
---
title: Files and IO
localeTitle: Archivos y IO
---
## Archivos y IO
Archivo es una ubicación con nombre en el disco para almacenar información relacionada. Se utiliza para almacenar datos de forma permanente en la memoria no volátil (por ejemplo, disco duro). Dado que la memoria de acceso aleatorio (RAM) es volátil y pierde sus datos cuando la computadora está apagada, usamos archivos para el uso futuro de los datos.
Cuando queremos leer o escribir en un archivo, primero debemos abrirlo. Cuando hayamos terminado, debe cerrarse para que los recursos que están vinculados con el archivo se liberen.
Por lo tanto, en Python, una operación de archivo tiene lugar en el siguiente orden: 1) Abrir un archivo 2) Leer o escribir (realizar operación) 3) cerrar el archivo
Python tiene muchas formas de operaciones de entrada y salida. Algunas de las operaciones de salida pueden ser la impresión de un texto, los registros de la consola e incluso la salida de un archivo de texto o de hoja de cálculo.
### Salida a pantalla
Python proporciona la forma más sencilla de producir resultados en la pantalla.
```python
print "Python is a powerful language.","It is easy to learn."
```
Salida:
```
Python is a powerful language.It is easy to learn.
```
### Entrada del usuario
Hay dos formas de recibir información de un usuario.
raw\_input (\[prompt\])
Se utiliza para leer una línea de la entrada estándar y la devuelve como una cadena
```python
str = raw_input("Enter your name: ")
print "Welcome ", str
```
Salida:
```
Enter your name: John Doe
Welcome John Doe
```
entrada (aviso)
Funcionalidad similar a raw\_input (), pero asume que la entrada es una expresión de Python válida
```python
str = input("Enter input: ")
print "Input: ", str
```
Salida:
```
Enter input: [x*5 for x in range(2,10,2)]
Input: [10,20,30,40]
```
### Interactuando con archivos en Python
Con Python, los archivos se pueden abrir, leer, escribir y cerrar fácilmente. Con las funciones disponibles:
1. `open()`
2. `read()`
3. `write()`
4. `close()`
Ejemplo:
```python
file1 = open("foo.txt", "r+") # Opens the file with read permission.
file1.write("Python is a powerful language.It is easy to learn.") # Writes data into the file.
data = file1.read(15) # Reads first 15 characters in the file.
print "First 15 characters are:\n", data # Prints output
file1.close() # Closes the opened file.
```
Salida:
```
First 15 characters are:
Python is a pow
```
#### Abriendo archivos
El método de python open () se puede usar para devolver un objeto de archivo. Es más comúnmente usado con dos argumentos que son el nombre del archivo y el modo de acceso. El modo de acceso se utiliza para describir la forma en que se accede o se utiliza el archivo.
Los modos más utilizados son 'w' que es para escribir en el archivo y 'r' que se usa para leer el archivo, mientras que 'r +' se usa para leer y escribir el archivo. 'a' es el modo que se utiliza para agregar texto al archivo. El argumento de modo también es opcional y se asumirá que es 'r' si se omite.
Un archivo debe cerrarse después de que se haya completado la operación de entrada y salida para liberar recursos.
Código de muestra para abrir un archivo de texto:
\`\` \`pitón archivo = abrir ('hello\_world.txt', 'w') file.write ('Hello World!') archivo.close ()
```
##### Using with
An alternative to using the `open()` function in standalone is to make use of the `with` statement to open a file. This is considered best practice as it allows the Python framework to manage the context of opening the file, and will autmoatically perform any required resource cleanup.
This is adventageous in the fact that it takes the onus off the programmer to close every file that is opened, and that the file will still be closed even if an exception was encountered during an IO operation.
When using the `with` statement is important to note that access to the file will only available within the scope of the `with` block.
To open a file using the `with` statement the `with` keyword is entered, followed by the call to `open(file)`. Following this the variable used as a handle to the open file is declared after the `as` keyword. Once the programs execution returns from this block, the file will be closed automatically.
Sample code to open a text file using the `with` statement:
```
con abierto ('hello\_world.txt', 'w') como f: f.write ('¡Hola mundo!') \`\` \`
#### Más información:
[Documentación Python - IO](https://docs.python.org/2/tutorial/inputoutput.html) [Automatizar las cosas aburridas](https://automatetheboringstuff.com/chapter8/) [Punto de tutoriales - Python IO](https://www.tutorialspoint.com/python/python_files_io.htm) [8 PEP 343: La declaración 'con'](https://docs.python.org/2.5/whatsnew/pep-343.html)

184
guide/spanish/python/for-loop-statements/index.md Normal file
View File

@@ -0,0 +1,184 @@
---
title: For Loop Statements
localeTitle: Para declaraciones de bucle
---
## Para declaraciones de bucle
Python utiliza un bucle for para iterar sobre una lista de elementos. A diferencia de C o Java, que usan el bucle for para cambiar un valor en pasos y acceder a algo como una matriz que usa ese valor.
Para los bucles, repita sobre las estructuras de datos basadas en recopilación, como listas, tuplas y diccionarios.
La sintaxis básica es:
```python
for value in list_of_values:
# use value inside this block
```
En general, puede usar cualquier cosa como el valor del iterador, donde se pueden asignar las entradas del iterable. Por ejemplo, puede desempaquetar tuplas de una lista de tuplas:
```python
list_of_tuples = [(1,2), (3,4)]
for a, b in list_of_tuples:
print("a:", a, "b:", b)
```
Por otro lado, puedes hacer un bucle sobre cualquier cosa que sea iterable. Puedes llamar a una función o usar una lista literal.
```python
for person in load_persons():
print("The name is:", person.name)
```
```python
for character in ["P", "y", "t", "h", "o", "n"]:
print("Give me a '{}'!".format(character))
```
Algunas formas en que se utilizan los bucles For:
**Iterar sobre la función de rango ()**
```python
for i in range(10):
print(i)
```
En lugar de ser una función, el rango es en realidad un tipo de secuencia inmutable. La salida contendrá los resultados del límite inferior, es decir, 0 al límite superior, es decir, 10, pero excluyendo 10. Por defecto, el límite inferior o el índice de inicio se establece en cero. Salida:
```
>
0
1
2
3
4
5
6
7
8
9
>
```
Además, se puede especificar el límite inferior de la secuencia e incluso el paso de la secuencia agregando un segundo y un tercer parámetro.
```python
for i in range(4,10,2): #From 4 to 9 using a step of two
print(i)
```
Salida:
```
>
4
6
8
>
```
**función xrange ()**
En su mayor parte, xrange y rango son exactamente iguales en términos de funcionalidad. Ambos proporcionan una forma de generar una lista de enteros para que los uses, como desees. La única diferencia es que el rango devuelve un objeto de lista Python y xrange devuelve un objeto xrange. Significa que xrange en realidad no genera una lista estática en tiempo de ejecución como lo hace el rango. Crea los valores a medida que los necesita con una técnica especial llamada rendimiento. Esta técnica se utiliza con un tipo de objeto conocido como generadores.
Una cosa mas que agregar. En Python 3.x, la función xrange ya no existe. La función de rango ahora hace lo que xrange hace en Python 2.x
**Iterar sobre los valores en una lista o tupla**
```python
A = ["hello", 1, 65, "thank you", [2, 3]]
for value in A:
print(value)
```
Salida:
```
>
hello
1
65
thank you
[2, 3]
>
```
**Iterar sobre las claves en un diccionario (también conocido como hashmap)**
```python
fruits_to_colors = {"apple": "#ff0000",
"lemon": "#ffff00",
"orange": "#ffa500"}
for key in fruits_to_colors:
print(key, fruits_to_colors[key])
```
Salida:
```
>
apple #ff0000
lemon #ffff00
orange #ffa500
>
```
**Iterar sobre dos listas del mismo tamaño en un solo bucle con la función zip ()**
\`\` \`pitón A = \["a", "b", "c"\] B = \["a", "d", "e"\]
para a, b en zip (A, B): imprimir a, b, a == b
```
Output:
```
\> aa cierto bd falso ce falso >
```
**Iterate over a list and get the corresponding index with the enumerate() function**
```
pitón A = \["este", "es", "algo", "diversión"\]
para índice, palabra en enumerar (A): imprimir (índice, palabra)
```
Output:
```
\> 0 esto 1 es 2 algo 3 diversión >
```
A common use case is iterating over a dictionary:
```
pitón Para el nombre, número de teléfono en contacts.items (): imprimir (nombre, "es accesible", número de teléfono)
```
If you absolutely need to access the current index of your iteration, do **NOT** use `range(len(iterable))`! This is an extremely bad practice and will get you plenty of chuckles from senior Python developers. Use the built in function `enumerate()` instead:
```
pitón para el índice, artículo en enumerar (shopping\_basket): imprimir ("Artículo", índice, "es un", artículo)
```
**for/else statements**
Pyhton permits you to use else with for loops, the else case is executed when none of the conditions with in the loop body was satisfied. To use the else we have to make use of `break` statement so that we can break out of the loop on a satsfied condition.If we do not break out then the else part will be executed.
```
pitón _días de la_ semana _\= \['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes'\] hoy = 'sábado' por día en_ días de _semana_ : si día == hoy: imprimir ('hoy es un día de la semana') descanso más: imprimir ('hoy no es un día de la semana')
```
In the above case the output will be `today is not a week day` since the break within the loop will never be executed.
**Iterate over a list using inline loop function**
We could also iterate inline using python, for example if we need to uppercase all the words in a list from a list we could simply do the following:
```
pitón A = \["this", "is", "awesome", "shinning", "star"\]
MAYÚSCULAS = \[word.upper () para word en A\] imprimir (MAYÚSCULAS)
```
Output:
```
\> \['ESTE', 'ES', 'IMPRESIONANTE', 'SHINNING', 'ESTRELLA'\] > \`\` \`
#### Más información:
* [Python2 para documentación de bucles.](https://docs.python.org/2.7/tutorial/controlflow.html#for-statements)
* [Python3 para documentación de bucles.](https://docs.python.org/3/tutorial/controlflow.html#for-statements)

35
guide/spanish/python/from-x-import-y/index.md Normal file
View File

@@ -0,0 +1,35 @@
---
title: Python from X Import Y
localeTitle: Python de X Import Y
---
Si ha leído el wiki de `import statements` entonces me habría visto usar esta declaración en uno de los ejemplos. Hoy, trataremos de entender lo que hace.
Así que recogiendo el mismo ejemplo:
```
>>> from math import ceil, sqrt
>>> # here it would be
>>> sqrt(36)
<<< 6
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CS5t/1)
O podríamos usar esto:
```
>>> import math
>>> # here it would be
>>> math.sqrt(36)
<<< 6
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CS5u)
Entonces nuestro código se vería como `math.sqrt(x)` lugar de `sqrt(x)` . Esto sucede porque cuando usamos `import x` , se crea un espacio de nombres `x` para evitar conflictos de nombre. Tienes que acceder a cada objeto del módulo como `x.<name>` . Pero cuando usamos `from x import y` aceptamos agregar `y` al espacio de nombres global principal. Entonces, al usar esto, debemos asegurarnos de que no tenemos un objeto con el mismo nombre en nuestro programa.
> **Nunca use `from x import y` si ya existe un objeto llamado `y`**
Por ejemplo, en el módulo `os` hay un método `open` . Pero incluso tenemos una función incorporada llamada `open` . Por lo tanto, aquí deberíamos evitar el uso `from os import open` .
Incluso podemos usar `form x import *` , esto importaría todos los métodos, clases de ese módulo al espacio de nombres global del programa. Esta es una mala práctica de programación. Por favor, evítalo.
En general, debe evitar la `from x import y` simplemente por los problemas que puede causar en programas a gran escala. Por ejemplo, nunca se sabe si un compañero programador podría querer hacer una nueva función que sea el nombre de una de las funciones existentes. Tampoco sabe si Python cambiará la biblioteca desde la que está importando funciones. Si bien estos problemas no existirán tan a menudo para los proyectos en solitario, como se dijo anteriormente, es una mala práctica de programación y debe evitarse.

37
guide/spanish/python/frozenset/index.md Normal file
View File

@@ -0,0 +1,37 @@
---
title: Python Frozenset
localeTitle: Python Frozenset
---
**información básica de `frozenset`** El tipo `frozenset` es un conjunto de tipos integrado que es inmutable y hashable; su contenido no puede modificarse después de su creación; sin embargo, se puede utilizar como clave de diccionario o como elemento de otro conjunto. Los frozensets son conjuntos a excepción de que no se pueden cambiar, es decir, son inmutables.
```
>>> cities = frozenset(["Frankfurt", "Basel", "Freiburg"])
>>> cities.add("Strasbourg")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
>>>
```
constructor `frozenset` : `frozenset([iterable])` El iterable contiene elementos para inicializar el frozenset con. El iterable se puede configurar, diccionario, tupla, etc. Si no se pasa ningún parámetro, el método `frozenset()` devuelve un frozenset vacío.
**Ejemplos**
```
>>> vowels = ('a', 'e', 'i', 'o', 'u')
>>> fSet = frozenset(vowels)
>>> print("The frozen set is: ", fSet)
The frozen set is: frozenset({'i', 'e', 'a', 'u', 'o'})
>>> print("The empty frozen set is: ", frozenset())
The empty frozen set is: frozenset()
>>>
```
**Otro ejemplo**
```
>>> person = {"name": "John", "age": 23, "sex": "male"}
>>> fSet = frozenset(person)
>>> print("The frozen set is: ", fSet)
The frozen set is: frozenset({'sex', 'name', 'age'})
>>>
```
**Información Adicional** [Python Frozenset ()](https://www.programiz.com/python-programming/methods/built-in/frozenset) [Tipos de set - set, frozenset](https://docs.python.org/2.4/lib/types-set.html) [Tutorial de Python: Sets y Frozen Sets.](https://www.python-course.eu/sets_frozensets.php)

139
guide/spanish/python/functions/index.md Normal file
View File

@@ -0,0 +1,139 @@
---
title: Functions
localeTitle: Funciones
---
## Funciones
Una función le permite definir un bloque de código reutilizable que puede ejecutarse muchas veces dentro de su programa.
Las funciones le permiten crear soluciones más modulares y [SECAS](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) para problemas complejos.
Si bien Python ya proporciona muchas funciones integradas, como `print()` y `len()` , también puede definir sus propias funciones para usar dentro de sus proyectos.
Una de las grandes ventajas de usar funciones en su código es que reduce el número total de líneas de código en su proyecto.
### Sintaxis
En Python, una definición de función tiene las siguientes características:
1. La palabra clave `def`
2. un nombre de función
3. paranthesis '()', y dentro de paranthesis parámetros de entrada, aunque los parámetros de entrada son opcionales.
4. dos puntos ':'
5. algun bloque de codigo para ejecutar
6. una declaración de retorno (opcional)
```python
# a function with no parameters or returned values
def sayHello():
print("Hello!")
sayHello() # calls the function, 'Hello!' is printed to the console
# a function with a parameter
def helloWithName(name):
print("Hello " + name + "!")
helloWithName("Ada") # calls the function, 'Hello Ada!' is printed to the console
# a function with multiple parameters with a return statement
def multiply(val1, val2):
return val1 * val2
multiply(3, 5) # prints 15 to the console
```
Las funciones son bloques de código que se pueden reutilizar simplemente llamando a la función. Esto permite una reutilización de código simple y elegante sin tener que volver a escribir explícitamente secciones de código. Esto hace que el código sea más legible, facilita la depuración y limita los errores de escritura.
Las funciones en Python se crean utilizando la palabra clave `def` , seguida de un nombre de función y parámetros de función entre paréntesis.
Una función siempre devuelve un valor. La palabra clave de `return` es utilizada por la función para devolver un valor. Si no desea devolver ningún valor, el valor predeterminado `None` se devolverá.
El nombre de la función se utiliza para llamar a la función, pasando los parámetros necesarios entre paréntesis.
```python
# this is a basic sum function
def sum(a, b):
return a + b
result = sum(1, 2)
# result = 3
```
Puede definir valores predeterminados para los parámetros, de esa manera Python interpretará que el valor de ese parámetro es el predeterminado si no se proporciona ninguno.
```python
def sum(a, b=3):
return a + b
result = sum(1)
# result = 4
```
Puede pasar los parámetros en el orden que desee, utilizando el nombre del parámetro.
```python
result = sum(b=2, a=2)
# result = 4
```
Sin embargo, no es posible pasar un argumento de palabra clave antes que uno que no sea de palabra clave.
```Python
result = sum(3, b=2)
#result = 5
result2 = sum(b=2, 3)
#Will raise SyntaxError
```
Las funciones también son objetos, por lo que puede asignarlas a una variable y usar esa variable como una función.
```python
s = sum
result = s(1, 2)
# result = 3
```
### Notas
* Si la definición de una función incluye parámetros, debe proporcionar el mismo número de parámetros cuando llama a la función.
```python
print(multiply(3)) # TypeError: multiply() takes exactly 2 arguments (0 given)
print(multiply('a', 5)) # 'aaaaa' printed to the console
print(multiply('a', 'b')) # TypeError: Python can't multiply two strings
```
* El bloque de código que ejecutará la función incluye todas las declaraciones sangradas dentro de la función.
```python
def myFunc():
print('this will print')
print('so will this')
x = 7
# the assignment of x is not a part of the function since it is not indented
```
* Las variables definidas dentro de una función solo existen dentro del alcance de esa función.
```python
def double(num):
x = num * 2
return x
print(x) # error - x is not defined
print(double(4)) # prints 8
```
\-Python interpreta el bloque de función solo cuando se llama a la función y no cuando se define la función. Por lo tanto, incluso si el bloque de definición de función contiene algún tipo de error, la interpretación de python lo señalará solo cuando se llame a la función.
### Más información:
* [Python 3 Docs: Definiendo Funciones](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)

60
guide/spanish/python/generators/index.md Normal file
View File

@@ -0,0 +1,60 @@
---
title: Generators
localeTitle: Generadores
---
## Generadores
Los generadores son un tipo especial de función que le permite devolver valores sin finalizar una función. Lo hace utilizando la palabra clave de `yield` . Similar a la `return` , la expresión de `yield` devolverá un valor a la persona que llama. La diferencia clave entre los dos es que el `yield` suspenderá la función, permitiendo que se devuelvan más valores en el futuro.
Los generadores son iterables por lo que se pueden usar limpiamente con bucles o cualquier otra cosa que se repita.
```python
def my_generator():
yield 'hello'
yield 'world'
yield '!'
for item in my_generator():
print(item)
# output:
# hello
# world
# !
```
Al igual que otros iteradores, los generadores pueden pasar a la `next` función para recuperar el siguiente elemento. Cuando un generador no tiene más valores para producir, se `StopIteration` un error de `StopIteration` .
```python
g = my_generator()
print(next(g))
# 'hello'
print(next(g))
# 'world'
print(next(g))
# '!'
print(next(g))
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# StopIteration
```
Los generadores son particularmente útiles cuando necesita crear un gran conjunto de valores pero no necesita mantenerlos todos en la memoria al mismo tiempo. Por ejemplo, si necesita imprimir el primer millón de números de fibonacci, normalmente devolverá una lista de un millón de valores e iterar sobre la lista para imprimir cada valor. Sin embargo, con un generador, puede devolver cada valor uno a la vez:
```python
def fib(n):
a = 1
b = 1
for i in range(n):
yield a
a, b = b, a + b
for x in fib(1000000):
print(x)
```
### Más información
* [PEP 255](https://www.python.org/dev/peps/pep-0255/)
* [Python Wiki](https://wiki.python.org/moin/Generators)
* [Documentación de declaración de rendimiento](https://docs.python.org/2/reference/simple_stmts.html#yield)

24
guide/spanish/python/hex-functions/index.md Normal file
View File

@@ -0,0 +1,24 @@
---
title: Python Hex Function
localeTitle: Función Hex Python
---
`hex(x)` es una función incorporada en Python 3 para convertir un número entero en una cadena [hexadecimal en](https://www.mathsisfun.com/hexadecimals.html) minúsculas con el prefijo "0x".
## Argumento
Esta función toma un argumento, `x` , que debe ser de tipo entero.
## Regreso
Esta función devuelve una cadena hexadecimal en minúsculas con el prefijo "0x".
## Ejemplo
```
print(hex(16)) # prints 0x10
print(hex(-298)) # prints -0x12a
print(hex(543)) # prints 0x21f
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CV0S)
[Documentacion oficial](https://docs.python.org/3/library/functions.html#hex)

79
guide/spanish/python/how-to-convert-strings-into-integers-in-python/index.md Normal file
View File

@@ -0,0 +1,79 @@
---
title: How to Convert Strings into Integers in Python
localeTitle: Cómo convertir cadenas en enteros en Python
---
## Cómo convertir cadenas en enteros en Python
Al igual que el `str()` incorporado, Python también ofrece un práctico accesorio que toma un objeto de cadena como un argumento y devuelve el objeto entero correspondiente.
#### Ejemplo de uso:
```py
# Here age is a string object
age = "18"
print(age)
# Converting string to integer
int_age = int(age)
print(int_age)
```
Salida
```py
18
18
```
Aquí, aunque la salida es visualmente similar, pero debe tener en cuenta que la primera línea imprime un objeto de cadena, mientras que la línea que se encuentra a su lado imprime un objeto entero, que se ilustra con más detalle en el siguiente ejemplo:
```py
age = "18"
print(age+2)
```
Salida:
```py
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
```
`The error should make it clear to you that you need to convert the` dejarle `The error should make it clear to you that you need to convert the` objeto age\` en un entero antes de agregarle algo.
```py
age = "18"
age_int = int(age)
print(age_int+2)
```
Salida:
```py
20
```
Pero debes tener en cuenta algunos casos especiales:
1. Un punto flotante (un entero con parte fraccionaria) como argumento devolverá el flotante redondeado hacia abajo al entero entero más cercano. Por ejemplo: `print(int(7.9))` imprimirá `7` . También `print(int("7.9"))` generará un error, ya que la cadena no es un argumento válido para convertir en un entero.
```py
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '7.9'
```
2. Además, cualquier entero en palabras, si se presenta como un argumento, devolverá el mismo error anterior: `print(int("one"))` dará un error de la siguiente manera:
```py
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'one'
```
#### Más información:
La documentación oficial de `int()` incorporada se puede encontrar [aquí](https://docs.python.org/3.6/library/functions.html#int)

43
guide/spanish/python/idobject/index.md Normal file
View File

@@ -0,0 +1,43 @@
---
title: Python Idobject
localeTitle: Objeto Python
---
`id()` es una función incorporada en Python 3, que devuelve la _identidad_ de un objeto. La _identidad_ es un entero único para ese objeto durante su vida útil. Esta es también la dirección del objeto en la memoria.
## Argumento
#### objeto
El argumento `object` normalmente puede ser un `int` , `float` , `str` , `list` , `dict` , `tuple` , etc.
## Ejemplo de código
```
a = 2
print(id(a)) #=> 140454723286976 (Values returned by id() might be different for different users)
b = 3
print(id(b)) #=> 140454723287008
c = 2
print(id(c)) #=> 140454723286976 (This is same as id(a) since they both contain the same value and hence have same memory address)
print(id(a) == id(b)) #=> False (since a and b have different values stored in them)
print(id(a) == id(c)) #=> True (since a and c have same values stored in them)
d = 1.1
e = 1.1
print(id(d) == id(e)) #=> True (since d and e have same values stored in them)
str1 = 'hello'
str2 = 'hello'
print(id(str1) == id(str2)) #=> True (since str1 and str2 have same values stored in them)
# For complex objects like lists, tuples, dictionaries etc. id() would give a unique integer even if the content of those containers is same.
tup1 = (1,1)
tup2 = (1,1)
print(id(tup1) == id(tup2)) #=> False
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CQw7/1)
[Documentos oficiales](https://docs.python.org/3/library/functions.html#id)

96
guide/spanish/python/if-elif-else-statements/index.md Normal file
View File

@@ -0,0 +1,96 @@
---
title: If Elif Else Statements
localeTitle: Si Elif Else Declaraciones
---
## Si Elif Else Declaraciones
La estructura `if` / `elif` / `else` es una forma común de controlar el flujo de un programa, lo que le permite ejecutar bloques específicos de código dependiendo del valor de algunos datos. Si la condición que sigue a la palabra clave `if` evalúa como `true` , el bloque de código se ejecutará: Tenga en cuenta que el paréntesis no se usa antes y después de la verificación de condición como en otros idiomas.
```python
if True:
print('If block will execute!')
```
```python
x = 5
if x > 4:
print("The condition was true!") #this statement executes
```
Opcionalmente, puede agregar una respuesta `else` que se ejecutará si la condición es `false` :
```python
if not True:
print('If statement will execute!')
else:
print('Else statement will execute!')
```
O también puedes ver este ejemplo.
```python
y = 3
if y > 4:
print("I won't print!") #this statement does not execute
else:
print("The condition wasn't true!") #this statement executes
```
_Tenga en cuenta que no hay ninguna condición que siga a la palabra clave `else` : detecta todas las situaciones en las que la condición era `false`_
Se pueden verificar varias condiciones incluyendo una o más verificaciones `elif` después de su declaración inicial `if` , pero solo se ejecutará una condición:
```python
z = 7
if z > 8:
print("I won't print!") #this statement does not execute
elif z > 5:
print("I will!") #this statement will execute
elif z > 6:
print("I also won't print!") #this statement does not execute
else:
print("Neither will I!") #this statement does not execute
```
_Tenga en cuenta que solo se ejecutará la primera condición que se evalúe como `true` . Aunque `z > 6` es `true` , el bloque `if/elif/else` termina después de la primera condición verdadera. Esto significa que otra `else` solo se ejecutará si ninguna de las condiciones es `true` ._
También podemos crear anidados si para la toma de decisiones. Antes de la anterior, consulte la guía de sangrado href = 'https: //guide.freecodecamp.org/python/code-blocks-and-indentation' target = '\_ blank' rel = 'nofollow'> una vez antes de la anterior.
Tomemos un ejemplo de encontrar un número que sea par y también mayor que '10 \`
```
python
x = 34
if x % 2 == 0: # this is how you create a comment and now, checking for even.
if x > 10:
print("This number is even and is greater than 10")
else:
print("This number is even, but not greater 10")
else:
print ("The number is not even. So point checking further.")
```
Esto fue solo un ejemplo simple para anidar if's. Por favor, siéntase libre de explorar más en línea.
Si bien los ejemplos anteriores son simples, puede crear condiciones complejas utilizando [comparaciones](https://guide.freecodecamp.org/python/comparisons) [booleanas](https://guide.freecodecamp.org/python/boolean-operations) y [operadores booleanos](https://guide.freecodecamp.org/python/boolean-operations) .
**_Python en línea if-else instrucción_**
También podemos usar sentencias if-else en funciones de python en línea El siguiente ejemplo debe verificar si el número es mayor o igual a 50, si es así, devuelva Verdadero:
```
python
x = 89
is_greater = True if x >= 50 else False
print(is_greater)
```
Salida
```
>
True
>
```

97
guide/spanish/python/import-statements/index.md Normal file
View File

@@ -0,0 +1,97 @@
---
title: Python Import Statements
localeTitle: Declaraciones de importación de Python
---
Mientras aprendía a programar y leer algunos recursos, habrías encontrado esta palabra 'abstracción' que simplemente significa reducir y reutilizar el código tanto como sea posible.
Funciones y módulos facilitan la abstracción. Usted crea funciones cuando quiere hacer algo repetidamente dentro de un archivo.
Los módulos entran en escena cuando desea reutilizar un grupo de funciones en diferentes archivos de origen. Los módulos también son útiles para estructurar bien el programa.
* Usando bibliotecas estándar y otros módulos de terceros:
* Estructurando el programa
## Uso de bibliotecas estándar
Ejemplo: puede leer en detalle los métodos / funciones de todas las bibliotecas estándar en los documentos oficiales de Python.
```
import time
for i in range(100):
time.sleep(1) # Waits for 1 second and then executes the next command
print(str(i) + ' seconds have passed') # prints the number of seconds passed after the program was started
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CS6C)
```
# To calculate the execution time of a part of program
import time
start = time.time()
# code here
end = time.time()
print('Execution time:' , end-start)
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CS6C/1)
```
# Using math Module
import math
print(math.sqrt(100)) # prints 10
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CS6C/2)
## Uso de módulos de terceros
Los módulos de terceros no vienen incluidos con Python, pero tenemos que instalarlos externamente utilizando administradores de paquetes como [`pip`](https://bootstrap.pypa.io/get-pip.py) y [`easy install`](https://bootstrap.pypa.io/ez_setup.py)
```
# To make http requests
import requests
rq = requests.get(target_url)
print(rq.status_code)
```
Obtenga más información sobre el módulo de solicitudes de python [aquí](http://docs.python-requests.org/en/master/)
## Estructurar programas
Queremos hacer un programa que tenga varias funciones con respecto a los números primos. Así que vamos a empezar. Definiremos todas las funciones en `prime_functions.py`
```
# prime_functions.py
from math import ceil, sqrt
def isPrime(a):
if a == 2:
return True
elif a % 2 == 0:
return False
else:
for i in range(3,ceil(sqrt(a)) + 1,2):
if a % i == 0:
return False
return True
def print_n_primes(a):
i = 0
m = 2
while True:
if isPrime(m) ==True:
print(m)
i += 1
m += 1
if i == a:
break
```
Ahora queremos usar las funciones que acabamos de crear en `prime_functions.py` así que creamos un nuevo archivo `playground.py` para usar esas funciones.
> _Tenga en cuenta que este programa es demasiado simple para hacer dos archivos separados, solo para demostrarlo. Pero cuando hay grandes programas complejos, hacer archivos diferentes es realmente útil._
```
# playground.py
import prime_functions
print(prime_functions.isPrime(29)) # returns True
```
## Clasificación de importaciones
Una buena práctica es ordenar `import` módulos de `import` en tres grupos: importaciones de bibliotecas estándar, importaciones de terceros relacionadas e importaciones locales. Dentro de cada grupo es sensato ordenar alfabéticamente por nombre de módulo. Puedes encontrar [más información en PEP8](https://www.python.org/dev/peps/pep-0008/?#imports) .
Una de las cosas más importantes para el lenguaje Python es la legibilidad, y los módulos de clasificación alfabética son más rápidos de leer y buscar. También es más fácil verificar que algo se importe y evitar las importaciones duplicadas.

175
guide/spanish/python/index.md Normal file
View File

@@ -0,0 +1,175 @@
---
title: Python
localeTitle: Pitón
---
## ¿Qué es Python?
[Python](https://www.python.org) es un lenguaje de programación de propósito general que se escribe, interpreta y conoce dinámicamente por su fácil legibilidad con excelentes principios de diseño.
Para obtener más información sobre Python, consulte estas páginas en python.org:
[¿Qué es Python?](https://www.python.org/doc/essays/blurb/)
[Preguntas frecuentes sobre Python](https://docs.python.org/3/faq/general.html) .
## Python 2 o Python 3
* Las dos versiones son similares, con el conocimiento de un cambio a escribir código para el otro es fácil.
* [Python 2 o Python 3](https://wiki.python.org/moin/Python2orPython3)
* [Python 2.x no se mantendrá a partir de 2020.](https://www.python.org/dev/peps/pep-0373/)
* 3.x esta en desarrollo activo. Esto significa que todas las mejoras recientes de la biblioteca estándar, por ejemplo, solo están disponibles de forma predeterminada en Python 3.x.
* El ecosistema de Python ha acumulado una cantidad significativa de software de calidad a lo largo de los años. La desventaja de romper la compatibilidad con versiones anteriores en 3.x es que parte de ese software (especialmente el software interno de las empresas) todavía no funciona en 3.x todavía.
## Instalación
La mayoría de los sistemas operativos basados ​​en \* nix vienen con Python instalado (generalmente Python 2, Python 3 en los más recientes). Reemplazar el sistema Python no se recomienda y puede causar problemas. Sin embargo, diferentes versiones de Python pueden instalarse de manera segura junto con el sistema Python. Consulte [Configuración y uso de Python](https://docs.python.org/3/using/index.html) .
Windows no viene con Python, el instalador y las instrucciones se pueden encontrar [aquí](https://docs.python.org/3/using/windows.html)
## Intérprete de Python
El intérprete de Python es lo que se utiliza para ejecutar los scripts de Python.
Si está disponible y en la ruta de búsqueda del shell de Unix, es posible iniciarlo escribiendo el comando `python` seguido del nombre del script, invocará al intérprete y ejecutará el script.
`hello_campers.py`
```python
print('Hello campers!')
```
Desde la terminal:
```
$ python hello_campers.py
Hello campers!
```
"Cuando se instalan varias versiones de Python, se puede llamar por versión dependiendo de la configuración de instalación. En el entorno personalizado de Cloud9 ide, se pueden invocar como:
```
$ python --version
Python 2.7.6
$ python3 --version
Python 3.4.3
$ python3.5 --version
Python 3.5.1
$ python3.6 --version
Python 3.6.2
$ python3.7 --version
Python 3.7.1
```
## Modo interactivo de intérprete de Python
El modo interactivo puede iniciarse invocando al intérprete de Python con el indicador `-i` o sin ningún argumento.
El modo interactivo tiene un aviso donde se pueden ingresar y ejecutar los comandos de Python:
```
$ python3.5
Python 3.5.1 (default, Dec 18 2015, 00:00:00)
GCC 4.8.4 on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello campers!")
Hello campers!
>>> 1 + 2
3
>>> exit()
$
```
## El zen de pitón
Algunos de los principios que influyeron en el diseño de Python se incluyen como un huevo de Pascua y se pueden leer usando el comando en el modo interactivo de intérprete de Python:
```
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
```
## Pros y contras de Python
### Pros
1. Lenguaje interactivo con soporte de módulo para casi todas las funcionalidades.
2. Código abierto: Entonces, puede contribuir a la comunidad, las funciones que ha desarrollado para su uso futuro y para ayudar a otros
3. Un montón de buenos intérpretes y cuadernos disponibles para una mejor experiencia como el cuaderno jupyter.
#### Contras
1. Siendo de código abierto, se han desarrollado muchas formas diferentes a lo largo del año para la misma función. Esto a veces, crea un caos para que otros lean el código de otra persona.
2. Es un lenguaje lento. Entonces, un lenguaje muy malo para usar en el desarrollo de algoritmos generales.
## Documentación
[Python está bien documentado](https://docs.python.org/3/) . Estos documentos incluyen tutoriales, guías, referencias y metainformación para el idioma.
Otra referencia importante son las Propuestas de mejora de Python ( [PEP](https://www.python.org/dev/peps/) ). En los PEP se incluye una guía de estilo para escribir el código Python, [`PEP 8`](https://www.python.org/dev/peps/pep-0008/) .
## Depuración
Las declaraciones de `print` línea se pueden utilizar para la depuración simple:
> **... a menudo, la forma más rápida de depurar un programa es agregar algunas declaraciones de impresión a la fuente: el rápido ciclo de edición-prueba-depuración hace que este enfoque simple sea muy efectivo.**
>
> \- [Resumen ejecutivo](https://www.python.org/doc/essays/blurb/)
Python también incluye herramientas más potentes para la depuración, como:
* módulo de [_registro_](https://docs.python.org/3/library/logging.html) , [_registro_](https://docs.python.org/3/library/logging.html)
* módulo de depuración, [_pdb_](https://docs.python.org/3/library/pdb.html)
Sólo tenga en cuenta que estos existen por ahora.
## Hola Mundo!
Volviendo a los documentos, podemos leer acerca de la función de [`print`](https://docs.python.org/3/library/functions.html#print) , una [_función incorporada_](https://docs.python.org/3/library/functions.html) de la [biblioteca estándar de Python](https://docs.python.org/3/library/index.html) .
```
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
```
Las funciones incorporadas se enumeran en orden alfabético. El nombre va seguido de una lista entre paréntesis de parámetros formales con valores predeterminados opcionales. Debajo hay una breve descripción de la función y sus parámetros, y ocasionalmente un ejemplo.
La función de [`print`](https://docs.python.org/3/library/functions.html#print) en Python 3 reemplaza la declaración de [`print`](https://docs.python.org/2/reference/simple_stmts.html#print) en Python 2.
```
>>> print("Hello world!")
Hello world!
```
Se llama a una función cuando el nombre de la función va seguido de `()` . Para el mundo Hola! Por ejemplo, la función de impresión se llama con una cadena como argumento para el primer parámetro. Para el resto de los parámetros se utilizan los valores por defecto.
El argumento con el que llamamos a la función de `print` es un objeto `str` o _cadena_ , uno de los [_tipos incorporados_](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str) de Python. Además, lo más importante de python es que no tiene que especificar el tipo de datos al declarar una variable, el compilador de python Lo hará por sí mismo en función del tipo de valor asignado.
El parámetro de los `objects` tiene un prefijo `*` que indica que la función tomará un número arbitrario de argumentos para ese parámetro.
## ¿Querer aprender más?
Free Code Camp tiene algunos grandes recursos. La web es un lugar grande, hay mucho más que explorar:
* Libro de práctica de Python: http://anandology.com/python-practice-book/index.html
* Piense Python: http://greenteapress.com/thinkpython/html/index.html
* Practical Business Python: http://pbpython.com/
* Otro curso: https://realpython.com/?utm _source = fsp & utm_ medium = promo & utm\_campaign = bestresources
* General: https://www.fullstackpython.com/
* Aprenda lo básico: https://www.codecademy.com/learn/learn-python
* Informática utilizando Python: https://www.edx.org/course/introduction-computer-science-mitx-6-00-1x-11?ref=hackernoon#!
* Lista de más recursos para aprender python: https://github.com/vinta/awesome-python
* Python interactivo: http://interactivepython.org/runestone/static/thinkcspy/index.html
* Guía para desarrolladores de Python: https://devguide.python.org/

51
guide/spanish/python/input-functions/index.md Normal file
View File

@@ -0,0 +1,51 @@
---
title: Python Input Function
localeTitle: Función de entrada de Python
---
Muchas veces, en un programa necesitamos algo de entrada del usuario. Tomar entradas del usuario hace que el programa se sienta interactivo. En Python 3, para obtener información del usuario, tenemos una función `input()` . Si se llama a la función de entrada, el flujo del programa se detendrá hasta que el usuario haya dado una entrada y haya terminado la entrada con la tecla de retorno. Veamos algunos ejemplos:
1. Cuando solo queremos tomar la entrada:
# Esto solo dará un mensaje sin ningún mensaje
inp = entrada ()
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CUqX/0)
1. Para dar un mensaje con un mensaje:
mensaje _con_ mensaje = entrada (' ')
# \_
# La '\_' en la salida es el indicador
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CUqX/1)
3\. Cuando queremos tomar una entrada entera:
```
number = int(input('Please enter a number: '))
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CUqX/2)
Si ingresa un valor no entero, Python generará un error `ValueError` . **Así que siempre que uses esto, asegúrate de que también lo atrapes.** De lo contrario, su programa se detendrá inesperadamente después del aviso.
```
number = int(input('Please enter a number: '))
# Please enter a number: as
# Enter a string and it will throw this error
# ValueError: invalid literal for int() with base 10 'as'
```
4\. Cuando queremos una entrada de cadena:
```
string = str(input('Please enter a string: '))
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CUqX/3)
Sin embargo, las entradas se almacenan por defecto como una cadena. El uso de la función `str()` deja claro al lector de códigos que la entrada será una "cadena". Es una buena práctica mencionar qué tipo de información se tomará de antemano.
[Documentos oficiales](https://docs.python.org/3/library/functions.html#input)

77
guide/spanish/python/installing-and-using-python-3/index.md Normal file
View File

@@ -0,0 +1,77 @@
---
title: Installing and Using Python 3
localeTitle: Instalación y uso de Python 3
---
## Instalación de Python 3
Puedes descargar Python desde este [enlace](https://www.python.org/downloads/) oficial. Según su sistema operativo (Windows o Linux o OSX), es posible que desee instalar Python 3 siguiendo [estas instrucciones](http://docs.python-guide.org/en/latest/starting/installation/) .
## Uso de entornos virtuales
Siempre es una buena idea [aislar](https://en.wikipedia.org/wiki/Sandbox_(computer_security)) la instalación de Python; y manteniéndolo separado de su _sistema Python_ . El _sistema Python_ es la ruta al intérprete de Python, que es utilizado por otros módulos instalados junto con su sistema operativo.
No es **seguro** instalar marcos o bibliotecas web de Python directamente con _System Python_ . En su lugar, puedes usar [Virtualenv](https://virtualenv.readthedocs.org/en/latest/) para crear y generar un proceso Python separado cuando estés desarrollando aplicaciones Python.
### Virtualenvwrapper
El [módulo Virtualenvwrapper](https://virtualenvwrapper.readthedocs.org/en/latest/) le facilita la administración y el aislamiento de varios entornos de entornos aislados de Python en una sola máquina; sin dañar ningún módulo o servicio escrito en Python y utilizado por su máquina.
Por supuesto, la mayoría de los entornos de desarrollo alojados en la nube, como [Nitrous](https://www.nitrous.io/) o [Cloud9,](https://c9.io/) también vienen con estos preinstalados y listos para que usted pueda codificar. Puede seleccionar rápidamente un cuadro de su panel y comenzar a codificar después de activar un entorno Python 3.
En [Cloud9](https://c9.io/) , debe seleccionar el cuadro Django al crear un nuevo entorno de desarrollo.
Unos pocos ejemplos de comandos de shell seguirían. Si desea copiar y pegar, tenga en cuenta que el signo `$` es una abreviatura para el indicador de terminal, no es parte del comando. Mi aviso de terminal se ve algo como esto:
```
alayek:~/workspace (master) $
```
Y, una `ls` se vería como
```
alayek:~/workspace (master) $ ls
```
Pero, mientras escribo lo mismo en esta documentación, lo estaría escribiendo como
```
$ ls
```
Volviendo a nuestra discusión, puede crear un recinto de seguridad incluido en el intérprete de Python 3 en Cloud9 ejecutando en su terminal en la nube:
```
$ mkvirtualenv py3 --python=/usr/bin/python3
```
Debe ejecutarlo solo una vez después de crear una nueva caja para su proyecto. Una vez ejecutado, este comando creará un nuevo virtualenv listo para su uso, denominado `py3` .
Para ver los entornos virtuales disponibles, puede utilizar
```
$ workon
```
Para activar `py3` , puede usar el comando `workon` con el nombre del entorno:
```
$ workon py3
```
Los tres comandos de terminal anteriores también funcionarían en máquinas Linux locales o máquinas OSX. Estos son comandos de [virtualenvwrapper](https://virtualenvwrapper.readthedocs.org/en/latest/#introduction) ; así que si planea usarlos, asegúrese de tener este módulo instalado y agregado a la variable `PATH` .
Si estás dentro de un entorno virtual; Puede descubrirlo fácilmente consultando el indicador de su terminal. El nombre del entorno se mostrará claramente en el indicador de su terminal.
Por ejemplo, cuando estoy dentro del entorno `py3` ; Estaría viendo esto como mi indicador de terminal:
```
(py3)alayek:~/workspace (master) $
```
¡Note el `(py3)` entre llaves! Si por alguna razón, no está viendo esto, incluso si está dentro de un entorno virtual; Puedes intentar hacer una de las cosas [mencionadas aquí](http://stackoverflow.com/questions/1871549/python-determine-if-running-inside-virtualenv) .
Salir de un entorno virtual; o para desactivar uno - usa el comando
```
$ deactivate
```
De nuevo, esto funciona solo con el módulo virtualenvwrapper.
### Pipenv
Una alternativa al uso de virtualenvwrapper es [Pipenv](https://docs.pipenv.org/) . Crea automáticamente entornos virtuales para sus proyectos y mantiene un `Pipfile` que contiene las dependencias. Usando Pipenv significa que ya no es necesario utilizar PIP y virtualenv separado, o es propietario de su propio `requirements.txt` archivo. Para aquellos familiarizados con JavaScript, Pipenv es similar a usar una herramienta de empaquetado como `npm` .
Para comenzar con Pipenv, puede seguir esta [guía](https://docs.pipenv.org/install.html#installing-pipenv) muy detallada. Pipenv hace que sea fácil de [especificar qué versión de Python](https://docs.pipenv.org/basics.html#specifying-versions-of-python) que desea utilizar para cada proyecto, [la importación](https://docs.pipenv.org/basics.html#importing-from-requirements-txt) de una existente `requirements.txt` archivo y [graficar](https://docs.pipenv.org/#pipenv-graph) sus dependencias.

125
guide/spanish/python/is-there-a-way-to-substring-a-string-in-python/index.md Normal file
View File

@@ -0,0 +1,125 @@
---
title: Is There a Way to Substring a String in Python
localeTitle: ¿Hay una manera de subordinar una cadena en Python
---
## ¿Hay una manera de subordinar una cadena en Python
Python ofrece muchas formas de subscribir una cadena. A menudo se le llama 'rebanar'.
Sigue esta plantilla:
```python
string[start: end: step]
```
Dónde,
`start` : El índice de inicio de la subcadena. El carácter en este índice se incluye en la subcadena. Si el _inicio_ no está incluido, se supone que es igual a 0.
`end` : el índice de terminación de la subcadena. El carácter en este índice _NO se_ incluye en la subcadena. Si no se incluye el _final_ , o si el valor especificado excede la longitud de la cadena, se asume que es igual a la longitud de la cadena por defecto.
`step` : cada carácter de 'paso' después del carácter actual que se incluirá. El valor predeterminado es 1. Si se omite el valor del _paso_ , se supone que es igual a 1.
#### Modelo
`string[start:end]` : Obtener todos los caracteres de índice de _principio_ a _fin-1_
`string[:end]` : obtiene todos los caracteres desde el principio de la cadena hasta el _final-1_
`string[start:]` : obtiene todos los caracteres desde el _inicio_ hasta el final de la cadena
`string[start:end:step]` : obtenga todos los caracteres desde el _principio_ hasta el _final 1_ descontando cada carácter de _paso_
#### Ejemplos
* **Consigue los primeros 5 caracteres de una cadena.**
```python
string = "freeCodeCamp"
print(string[0:5])
```
Salida:
```shell
> freeC
```
Nota: `print(string[:5])` devuelve el mismo resultado que `print(string[0:5])`
* **Obtén una subcadena de longitud 4 del 3er carácter de la cadena**
```python
string = "freeCodeCamp"
print(string[2:6])
```
Salida:
```shell
> eeCo
```
Tenga en cuenta que el índice inicial o final puede ser un número negativo. Un índice negativo significa que comienza a contar desde el final de la cadena en lugar del principio (es decir, de derecha a izquierda). El índice -1 representa el último carácter de la cadena, -2 representa el segundo al último carácter y así sucesivamente ...
* **Consigue el último carácter de la cadena.**
```python
string = "freeCodeCamp"
print(string[-1])
```
Salida:
```shell
> p
```
* **Consigue los últimos 5 caracteres de una cadena.**
```python
string = "freeCodeCamp"
print(string[-5:])
```
Salida:
```shell
> eCamp
```
* **Obtenga una subcadena que contiene todos los caracteres excepto los últimos 4 caracteres y el primer carácter**
```python
string = "freeCodeCamp"
print(string[1:-4])
```
Salida:
```shell
> reeCode
```
#### Más ejemplos
```py
str = “freeCodeCamp”
print str[-5:-2] # prints 'eCa'
print str[-1:-2] # prints '' (empty string)
```
* **Consigue todos los demás caracteres de una cadena**
```python
string = "freeCodeCamp"
print(string[::2])
```
Salida:
```shell
> feCdCm
```

40
guide/spanish/python/iterators/index.md Normal file
View File

@@ -0,0 +1,40 @@
---
title: Python Iterators
localeTitle: Iteradores de pitón
---
Python soporta un concepto de iteración sobre contenedores. Esto se implementa utilizando dos métodos distintos; estos se utilizan para permitir que las clases definidas por el usuario admitan la iteración.
[Python Docs - Tipos de iterador](https://docs.python.org/3/library/stdtypes.html#iterator-types)
La iteración es el proceso de repetir programáticamente un paso un número determinado de veces. Un programador puede hacer uso de la iteración para realizar la misma operación en cada ítem en una colección de datos, por ejemplo, imprimiendo cada ítem en una lista.
* Los objetos pueden implementar un `__iter__()` que devuelve un objeto iterador para admitir la iteración.
* Los objetos iteradores deben implementar:
* `__iter__()` : devuelve el objeto iterador.
* `__next__()` : devuelve el siguiente objeto del contenedor.
_objeto_ iterador _\= 'abc'. **iter** () imprimir (_ objeto _iterador_ ) imprimir (id ( _objeto_ iterador _)) print (id (_ objeto _iterador_ . **iter** ())) # Devuelve el iterador. imprimir ( _objeto_ iterador _. **next** ()) # Devuelve el primer objeto y avanza el iterador. imprimir (_ objeto _iterador_ . **next** ()) # Devuelve el segundo objeto y avanza el iterador. imprimir ( _objeto_ iterador _. **next** ()) # Devuelve el tercer objeto y avanza el iterador. print (_ objeto _iterador_ . **next** ()) # Aumenta la excepción StopIteration.
Salida:
```
<str_iterator object at 0x102e196a0>
4343305888
4343305888
a
b
c
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-1-d466eea8c1b0> in <module>()
6 print(iterator_object.__next__()) # Returns 2nd object and advances iterator.
7 print(iterator_object.__next__()) # Returns 3rd object and advances iterator.
----> 8 print(iterator_object.__next__()) # Raises StopIteration Exception.
StopIteration:
```

51
guide/spanish/python/itertools/index.md Normal file
View File

@@ -0,0 +1,51 @@
---
title: Itertools
localeTitle: Itertools
---
Itertools es un módulo de Python con funciones que devuelven generadores, objetos que solo funcionan cuando se iteran. Algunos ejemplos de funciones de itertool incluyen pero no se limitan a: chain (), imap (), product (), y compress ().
### cadena()
La función chain () toma varios iteradores como argumentos y devuelve un único iterador que produce el contenido de todos ellos como si procedieran de una secuencia.
```py
import itertools
list(itertools.chain([1, 2], [3, 4]))
# Output
# [1, 2, 3, 4]
```
### islice ()
La función islice () devuelve un iterador que devuelve los elementos seleccionados del iterador de entrada, por índice. Toma los mismos argumentos que el operador de división para listas: iniciar, detener y paso. El inicio y la parada son opcionales.
```py
import itertools
list(itertools.islice(count(), 5))
# Output
# [0,1, 2, 3, 4]
```
### izip ()
izip () devuelve un iterador que combina los elementos de varios iteradores en tuplas. Funciona como la función incorporada zip (), excepto que devuelve un iterador en lugar de una lista.
```py
import itertools
list(izip([1, 2, 3], ['a', 'b', 'c']))
# Output
# [(1, 'a'),(2, 'b'),(3, 'c')]
```
Los iteradores combinatorios:
Resultados de los argumentos de iterador producto () p, q, ... \[repetir = 1\] producto cartesiano, equivalente a un ciclo anidado para permutaciones () p \[, r\] tuplas de longitud r, todos los ordenamientos posibles, sin elementos repetidos combinaciones () p, r tuplas de longitud r, ordenadas, sin elementos repetidos combinaciones _con_ reemplazo () p, r tuplas de longitud r, en orden ordenado, con elementos repetidos producto ('ABCD', repetición = 2) AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD permutaciones ('ABCD', 2) AB AC AD BA BC BD CA CB CD DA DB DC
combinaciones ('ABCD', 2) AB AC AD BC BD CD
combinaciones _con_ reemplazo ('ABCD', 2) AA AB AC AD BB BC BD CC CD DD
Fuente: https: //docs.python.org/3/library/itertools.html

22
guide/spanish/python/keywords/index.md Normal file
View File

@@ -0,0 +1,22 @@
---
title: Python Keywords
localeTitle: Palabras clave de Python
---
## Palabras clave de Python
Python tiene una lista de [palabras clave](https://docs.python.org/3/reference/lexical_analysis.html#keywords) que no se pueden usar como identificadores (nombres de variables). Intentar usar cualquiera de estas palabras clave como variables creará un **error de sintaxis** y su secuencia de comandos de Python no se ejecutará:
```
>>> False = "Hello campers!"
File "<stdin>"
SyntaxError: can't assign to keyword
>>> break = "Hello campers!"
File "<stdin>", line 1
break = "Hello campers!"
^
SyntaxError: invalid syntax
```
#### Lista de palabras clave
Palabra clave | - | - | - | - --- | --- | --- | --- | --- `False` | `class` | `finally` | `is` | `return` `None` | `continue` | `for` | `lambda` `try` `True` | `def` | `from` | `nonlocal` | `while` `and` | `del` | `global` | `not` | `with` `as` | `elif` | `if` | `or` | `yield` `assert` `else` | `import` `pass` `break` `except` | `in` | `raise`

94
guide/spanish/python/lambda-expressions/index.md Normal file
View File

@@ -0,0 +1,94 @@
---
title: Lambda Expressions
localeTitle: Expresiones lambda
---
## Expresiones lambda
Las expresiones Lambda se utilizan idealmente cuando tenemos algo simple que hacer y estamos más interesados ​​en realizar el trabajo rápidamente en lugar de nombrar formalmente la función. Expresiones lambda también conocidas como funciones anónimas. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/python/lambda-expressions/index.md) .
Las expresiones Lambda en Python son una forma breve de declarar funciones pequeñas y anónimas (no es necesario proporcionar un nombre para las funciones lambda). Las funciones Lambda se comportan como funciones regulares declaradas con la palabra clave `def` . Son útiles cuando se desea definir una función pequeña de manera concisa. Solo pueden contener una expresión, por lo que no son los más adecuados para las funciones con declaraciones de flujo de control. dominar
#### Sintaxis de la función Lambda
`lambda arguments: expression`
Las funciones Lambda pueden tener cualquier número de argumentos pero solo una expresión
#### Código de ejemplo
```py
# Lambda function to calculate square of a number
square = lambda x: x ** 2
print(square(3)) # Output: 9
# Traditional function to calculate square of a number
def square1(num):
return num ** 2
print(square(5)) # Output: 25
```
En el ejemplo `lambda x: x ** 2` anterior, lambda `lambda x: x ** 2` produce un objeto de función anónimo que puede asociarse con cualquier nombre. Entonces, asociamos el objeto de función con el `square` y, por lo tanto, a partir de ahora podemos llamar al objeto `square` como cualquier función tradicional. por ejemplo, `square(10)`
## Ejemplos
### Principiante
```py
lambda_func = lambda x: x**2 # Function that takes an integer and returns its square
lambda_func(3) # Returns 9
```
### Intermedio
```py
lambda_func = lambda x: True if x**2 >= 10 else False
lambda_func(3) # Returns False
lambda_func(4) # Returns True
```
### Complejo
```py
my_dict = {"A": 1, "B": 2, "C": 3}
sorted(my_dict, key=lambda x: my_dict[x]%3) # Returns ['C', 'A', 'B']
```
### Caso de uso
Digamos que quiere filtrar los números impares de una `list` . Podrías usar un bucle `for` :
```python
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered = []
for num in my_list:
if num % 2 != 0:
filtered.append(num)
print(filtered) # Python 2: print filtered
# [1, 3, 5, 7, 9]
```
You could write this as a one liner with list-comprehensions
```
pitón filtrado = \[x para x en \[1, 2, 3, 4, 5, 6, 7, 8, 9, 10\] si x% 2! = 0\] \`\` \`
Pero es posible que tenga la tentación de utilizar la función de `filter` integrada. ¿Por qué? El primer ejemplo es un poco detallado, el de una sola línea puede ser más difícil de entender, donde el `filter` ofrece lo mejor de ambas palabras. Además, las funciones integradas suelen ser más rápidas.
\`\` \`pitón my\_list = \[1, 2, 3, 4, 5, 6, 7, 8, 9, 10\]
filtrada = filtro (lambda x: x% 2! = 0, my\_list)
lista (filtrada)
# \[1, 3, 5, 7, 9\]
` `` NOTE: in Python 3 built in function return generator objects, so you have to call` lista `, while in Python 2 they return a` lista `,` tupla `or` cadena\`.
¿Que pasó? Le dijiste a `filter` que tomara cada elemento en `my_list` y aplicara las expresiones lambda. Los valores que devuelven `False` se filtran.
#### Más información:
* [Doc oficial](https://docs.python.org/3/reference/expressions.html#lambda)
* [Leer más](https://dbader.org/blog/python-lambda-functions)

35
guide/spanish/python/learn-about-python-sets/index.md Normal file
View File

@@ -0,0 +1,35 @@
---
title: Learn About Python Sets
localeTitle: Aprenda acerca de los conjuntos de Python
---
`Set` s en Python son un tipo de estructura de datos mutable pero desordenada, que solo puede contener elementos _únicos_ .
**Creación:**
`set` literal:
Los corchetes, `{}` , _no se_ pueden usar para crear un conjunto vacío:
```python
>>> not_set = {} # set constructor must be used to make empty sets.
>>> type(not_set) # Empty curly brackets create empty dictionaries.
<class 'dict'>
```
Solo puede crear un conjunto vacío utilizando el método `set()` .
```python
>>> example_set = set()
>>> type(example_set)
<class 'set'>
```
Sin embargo, si los elementos se incluyen dentro de los corchetes, sería sintaxis aceptable crear un conjunto.
```python
>>> example_set_2 = {1, 2, 3}
>>> type(example_set_2)
<class 'set'>
```
\`

32
guide/spanish/python/len-function/index.md Normal file
View File

@@ -0,0 +1,32 @@
---
title: Python Len Function
localeTitle: Función de Python Len
---
`len()` es una función incorporada en Python 3. Este método devuelve la longitud (el número de elementos) de un objeto. Se necesita un argumento `x` .
## Argumentos
Se necesita un argumento, `x` . Este argumento puede ser una secuencia (como una cadena, bytes, tupla, lista o rango) o una colección (como un diccionario, conjunto o conjunto congelado).
## Valor de retorno
Esta función devuelve el número de elementos en el argumento que se pasa a la función `len()` .
## Ejemplo de código
```
list1 = [123, 'xyz', 'zara'] # list
print(len(list1)) # prints 3 as there are 3 elements in the list1
str1 = 'basketball' # string
print(len(str1)) # prints 10 as the str1 is made of 10 characters
tuple1 = (2, 3, 4, 5) # tuple
print(len(tuple1)) # prints 4 as there are 4 elements in the tuple1
dict1 = {'name': 'John', 'age': 4, 'score': 45} # dictionary
print(len(dict1)) # prints 3 as there are 3 key and value pairs in the dict1
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CUmt/15)
[Documentos oficiales](https://docs.python.org/3/library/functions.html#len)

32
guide/spanish/python/list-deque/index.md Normal file
View File

@@ -0,0 +1,32 @@
---
title: Deque
localeTitle: y
---
## Usando la lista como colas
También es posible utilizar una lista como una cola, donde se necesita una operación FIFO ("primero en entrar, primero en salir"). Las listas no son eficientes como cola mientras se usan los apéndices y las ventanas emergentes, ya que puede ir más lento, ya que todos los elementos tendrán que desplazarse en uno para cada una de las partes adicionales.
Para implementar una cola, use collections.deque, que fue diseñado para tener apéndices y pops rápidos desde ambos extremos.
#### Ejemplo de uso
```py
from collections import deque
queue = deque(["January", "February", "March", "April"] )
queue.append("May")
queue.popleft()
queue.popleft()
print "Spring months in the list: ", queue
```
#### Salida
```
Spring months in the list: deque(['March', 'April', 'May'])
```
#### Más información:
La documentación oficial de `collections.deque` se puede encontrar [aquí.](https://docs.python.org/3/library/collections.html#collections.deque)

124
guide/spanish/python/lists/index.md Normal file
View File

@@ -0,0 +1,124 @@
---
title: Lists
localeTitle: Liza
---
**TODO: `list` información básica**
[Python Docs - Listas](https://docs.python.org/3/library/stdtypes.html#lists)
**Creación:**
Una `list` vacía se crea utilizando un par de corchetes:
```shell
>>> empty_list = []
>>> type(empty_list)
<class 'list'>
>>> len(empty_list)
0
```
Se puede crear una `list` con elementos encerrando una lista de elementos separados por comas entre corchetes. Las listas permiten que los elementos sean de diferentes tipos (heterogéneos), pero generalmente son de un solo tipo (homogéneos):
```shell
>>> homogeneous_list = [1, 1, 2, 3, 5, 8]
>>> type(homogeneous_list)
<class 'list'>
>>> print(homogeneous_list)
[1, 1, 2, 3, 5, 8]
>>> len(homogeneous_list)
6
>>> heterogeneous_list = [1, "Hello Campers!"]
>>> print(heterogeneous_list)
[1, "Hello Campers!"]
>>> len(heterogeneous_list)
2
```
El constructor de `list` también se puede utilizar para crear una `list` :
```shell
>>> empty_list = list() # Creates an empty list
>>> print(empty_list)
[]
>>> list_from_iterable = list("Hello campers!") # Creates a list from an iterable.
>>> print(list_from_iterable)
['H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!']
```
**Accediendo a los elementos de una `list` :**
```shell
>>> my_list = [1, 2, 9, 16, 25]
>>> print(my_list)
[1, 2, 9, 16, 25]
```
_Cero indexado_
```shell
>>> my_list[0]
1
>>> my_list[1]
2
>>> my_list[2]
9
```
_Envolver alrededor de la indexación_
```shell
>>> my_list[-1]
25
>>> my_list[-2]
16
```
_Desembalaje de listas para python-3_
```shell
>>> print(*my_list)
1 2 9 16 25
```
**Mudable:**
`lists` son contenedores mutables. Los contenedores mutables son contenedores que permiten cambios en los objetos que contiene el contenedor. **TODO: AÑADIR MÁS?**
_Reorganizar elementos en una lista._
Los elementos de una `list` pueden extraerse y reorganizarse utilizando otra `list` como índice.
```shell
>>> my_list = [1, 2, 9, 16, 25, 34, 53, 21]
>>> my_index = [5, 2, 0]
>>> my_new_list = [my_list[i] for i in my_index]
>>> print(my_new_list)
[34, 9, 1]
```
**TODO: ¿Cuál de estos debería ser discutido aquí?**
[Python Docs - Más en las listas](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)
* `list.append(x)` Agrega un elemento al final de la lista. Equivalente a un \[len (a):\] = \[x\].
* `list.extend(L)` Extienda la lista agregando todos los elementos en la lista dada. Equivalente a un \[len (a):\] = L.
* `list.insert(i, x)` Insertar un elemento en una posición dada. El primer argumento es el índice del elemento antes del cual se inserta, por lo que a.insert (0, x) se inserta al principio de la lista, y a.insert (len (a), x) es equivalente a a.append ( X).
* `list.remove(x)` Elimina el primer elemento de la lista cuyo valor es x. Es un error si no hay tal artículo.
* `list.pop([i])` Elimine el elemento en la posición dada en la lista y devuélvalo. Si no se especifica ningún índice, a.pop () elimina y devuelve el último elemento de la lista. (Los corchetes alrededor de la i en la firma del método indican que el parámetro es opcional, no que se deben escribir corchetes en esa posición. Verá esta notación con frecuencia en la Referencia de la biblioteca de Python).
* `list.clear()` Eliminar todos los elementos de la lista. Equivalente a del a \[:\].
* `list.index(x)` Devuelve el índice en la lista del primer elemento cuyo valor es x. Es un error si no hay tal artículo.
* `list.count(x)` Devuelve el número de veces que x aparece en la lista.
* `list.sort(key=None, reverse=False)` Ordena los elementos de la lista en su lugar (los argumentos se pueden usar para la personalización de la clasificación, consulta ordenados () para su explicación).
* `list.reverse()` Invierta los elementos de la lista en su lugar.
* `list.copy()` Devuelve una copia superficial de la lista. Equivalente a un \[:\].

26
guide/spanish/python/lists/list-append-method/index.md Normal file
View File

@@ -0,0 +1,26 @@
---
title: List Append Method
localeTitle: Lista de añadir método
---
## Lista de añadir método
Existen muchos métodos para listas, puede explorarlas todas escribiendo `help(list)` en su consola de Python. Una de ellas es la función de agregar que, como su nombre lo dice, adjunta el argumento de la lista.
#### Ejemplo de uso
```py
words = ["I", "love", "Python"]
words.append("very much")
print(words)
```
#### Salida
```
["I", "love", "Python", "very much"]
```
Como habrán notado, el elemento `"very much"` se adjunta a la lista.
#### Más información:
La documentación oficial del `append()` se puede encontrar [aquí.](https://docs.python.org/3.6/tutorial/datastructures.html)

116
guide/spanish/python/lists/list-comprehension/index.md Normal file
View File

@@ -0,0 +1,116 @@
---
title: List Comprehension
localeTitle: Comprensión de lista
---
## Comprensión de lista
La comprensión de lista es una forma de recorrer una lista para generar una nueva lista basada en algunas condiciones. Puede ser confuso al principio, pero una vez que se haya aclimatado a la sintaxis es muy potente y rápido.
El primer paso para aprender a usar la comprensión de listas es observar la forma tradicional de recorrer una lista. El siguiente es un ejemplo simple que devuelve una nueva lista de números pares.
```python
# Example list for demonstration
some_list = [1, 2, 5, 7, 8, 10]
# Empty list that will be populate with a loop
even_list = []
for number in some_list:
if number % 2 == 0:
even_list.append(number)
# even_list now equals [2, 8, 10]
```
Primero se crea una lista con algunos números. A continuación, crea una lista vacía que contendrá sus resultados del bucle. En el bucle, verifica si cada número es divisible por 2 y, si es así, lo agregas a la lista\_incluso. Esto tomó 5 líneas de código sin incluir comentarios y espacios en blanco, lo cual no es mucho en este ejemplo.
Ahora para el ejemplo de la lista de comprensión.
```python
# Example list for demonstration
some_list = [1, 2, 5, 7, 8, 10]
# List Comprehension
even_list = [number for number in some_list if number % 2 == 0]
# even_list now equals [2, 8, 10]
```
Otro ejemplo, con los mismos dos pasos: Lo siguiente creará una lista de números que corresponden a los números en `my_starting_list` multiplicados por 7.
```py
my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_new_list = []
for item in my_starting_list:
my_new_list.append(item * 7)
```
Cuando se ejecuta este código, el valor final de `my_new_list` es: `[7, 14, 21, 28, 35, 42, 49, 56]`
Un desarrollador que usa la comprensión de la lista podría lograr el mismo resultado utilizando la siguiente comprensión de la lista, lo que da como resultado la misma `my_new_list` .
```py
my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_new_list = [item * 7 for item in my_starting_list]
```
Una fórmula simple para escribir en una lista de comprensión es:
`my_list = [{operation with input n} for n in {python iterable}]`
Reemplace `{operation with input n}` con sin embargo, desea cambiar el elemento devuelto desde el iterable. El ejemplo anterior utiliza `n * 7` pero la operación puede ser tan simple o tan compleja como sea necesario.
Reemplace `{python iterable}` con cualquier iterable. [Los tipos de secuencia](https://guide.freecodecamp.org/python/sequence-types) serán los más comunes. Se utilizó una lista en el ejemplo anterior, pero también son comunes las tuplas y los rangos.
La comprensión de la lista agrega un elemento de una lista existente a una nueva lista si se cumple alguna condición. Es más ordenado, pero también es mucho más rápido en la mayoría de los casos. En algunos casos, la comprensión de la lista puede dificultar la legibilidad, por lo que el desarrollador debe sopesar sus opciones al elegir utilizar la comprensión de la lista.
## Ejemplos de comprensión de lista con condicionales
El flujo de control en las listas de comprensión se puede controlar usando condicionales. Por ejemplo:
```py
only_even_list = [i for i in range(13) if i%2==0]
```
Esto es equivalente al siguiente bucle:
```py
only_even_list = list()
for i in range(13):
if i%2 == 0:
only_even_list.append(i)
```
Lista de comprensión también puede contener anidada si las condiciones. Considere el siguiente bucle:
```py
divisible = list()
for i in range(50):
if i%2 == 0:
if i%3 == 0:
divisible.append(i)
```
Usando la lista de comprensión esto se puede escribir como:
```py
divisible = [i for i in range(50) if i%2==0 if i%3==0]
```
La instrucción If-Else también se puede utilizar junto con la comprensión de la lista.
```py
list_1 = [i if i%2==0 else i*-1 for i in range(10)]
```
#### Más información:
[Estructuras de datos Python - Listas](https://docs.python.org/2.7/tutorial/datastructures.html)
[Python For Loops](https://guide.freecodecamp.org/python/for-loop-statements)
[Listas de Python](https://guide.freecodecamp.org/python/learn-about-python-lists)
[Python para principiantes - List Comprehensions](http://www.pythonforbeginners.com/basics/list-comprehensions-in-python)

25
guide/spanish/python/lists/list-extend-method/index.md Normal file
View File

@@ -0,0 +1,25 @@
---
title: List Extend Method
localeTitle: Método de ampliación de lista
---
## Método de ampliación de lista
Existen muchos métodos para listas, puede explorarlas todas escribiendo `help(list)` en su consola de Python. Una de ellas es la función de extensión que, como su nombre lo dice, extiende la lista al agregar todos los elementos de una lista (que se pasa como argumento) al final.
#### Ejemplo de uso
```py
cities = ["San Francisco", "Los Angeles", "New York"]
cities_in_texas = ["San Antonio", "Austin", "Dallas"]
cities.extend(cities_in_texas)
print(cities)
```
#### Salida
```
["San Francisco", "Los Angeles", "New York", "San Antonio", "Austin", "Dallas"]
```
#### Más información:
La documentación oficial de `extend()` se puede encontrar [aquí.](https://docs.python.org/3.6/tutorial/datastructures.html)

59
guide/spanish/python/lists/list-index-method/index.md Normal file
View File

@@ -0,0 +1,59 @@
---
title: List Index Method
localeTitle: Método de índice de lista
---
## Método de índice de lista
Entre las muchas funciones que vienen junto con la estructura de datos de la lista, el `index()` devuelve la primera aparición / índice del elemento en la lista dada como un argumento a la función.
Las listas son la estructura de datos de Python más básica y almacenan una lista de valores en orden (en comparación con los diccionarios, el orden no importa). Recuperamos los artículos por índice numérico.
Teniendo en cuenta el hecho de que la indexación comienza desde 0, o se considera que el primer elemento se encuentra en el índice 0, veamos algunos ejemplos.
#### Ejemplo de uso:
```py
numbers = [1, 2, 2, 3, 9, 5, 6, 10]
words = ["I", "love", "Python", "I", "love"]
print(numbers.index(9))
print(numbers.index(2))
print(words.index("I"))
print(words.index("am"))
```
##### Salida:
```py
4
1
0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'am' is not in list
```
Aquí la primera salida es muy obvia, pero la segunda y la tercera pueden parecer confusas al principio. Pero recuerda que `index()` devuelve la primera aparición del elemento y, por lo tanto, en este caso `1` y `0` son los índices donde `2` y `"I"` aparecen primero en las listas respectivamente.
Además, si un elemento no se encuentra en la lista, se devuelve un `ValueError` como en el caso de la indexación `"am"` en la lista de `words` .
#### Argumentos opcionales:
También puede usar argumentos opcionales para limitar su búsqueda a una subsecuencia particular de la lista como se ilustra en este ejemplo:
```py
words = ["I","am", "a", "I", "am", "Pythonista"]
print(words.index("am",2,5))
```
##### Salida:
```
4
```
Aquí, aunque el elemento se busca entre los índices 2 (inclusive) y 5 (no incluido), el índice devuelto se calcula en relación con el principio de la lista completa en lugar del argumento de inicio.
#### Más información:
La documentación oficial de `index()` se puede encontrar [aquí.](https://docs.python.org/3.6/tutorial/datastructures.html)

88
guide/spanish/python/lists/list-map-filter-reduce/index.md Normal file
View File

@@ -0,0 +1,88 @@
---
title: Map, Reduce, Filter
localeTitle: Mapa, Reducir, Filtrar
---
# Mapa, Reducir y Filtrar
La mayoría de los ingenieros trabajan con listas para procesar la lista de pedidos / usuarios, etc. El análisis de las listas puede complicarse y desordenarse rápidamente si se usan varios bucles for y loops anidados. Por lo tanto, estos métodos anteriores pueden simplificar el uso de las operaciones de lista.
## Mapa
Si su tarea es aplicar un método específico a cada elemento de una lista, el mapa será útil. Supongamos que tiene una lista de valores de grado y desea convertir todos estos valores en una lista de valores en unidades Fahrenheit.
#### Ejemplo de uso
```py
inputs = [10,32,5,40,25]
def degreesToFahren(deg):
fahrenheit = (9.0/5)*deg +32
return fahrenheit
# The most common way of doing this
result=[]
for i in inputs:
iTofahren = degreesToFahren(i)
result.append(iTofahren)
print(result) # [50.0, 89.6, 41.0, 104.0, 77.0]
```
```py
# Using Map
result = list(map(degreesToFahren,inputs))
print(result) # [50.0, 89.6, 41.0, 104.0, 77.0]
```
Como habrás notado, el uso de mapas es simplemente una operación de una sola línea. Generalmente, si tiene datos = `[a1,a2,...,an]` y una función `f()` , entonces `map(f,data):` devuelve un iterador sobre `f(a1),f(a2)...f(an).` use `list()` para convertir el objeto iterador en una lista de python.
## Filtrar
La función de filtro elimina los datos de una lista que necesita / no necesita, de ahí el nombre. Supongamos que desea filtrar una lista según los valores que no necesita, por ejemplo, valores superiores a 2.
#### Ejemplo de uso
```py
data = [1.2,2.5,5.8,0.4,4.7,9.9]
result = list(filter(lambda x:x > 2,data))
print(result)
```
#### Salida
```
[2.5, 5.8, 4.7, 9.9]
```
Este también es un simple 1 liner similar a la función map () anterior. Consulte el tutorial sobre las funciones de lambda si encuentra este término desconocido.
## Reducir
Del creador de Python, Guido van Rossum. `"Use functools.reduce if you really need it; however, 99% of the time an explicit for loop is more readable"`
Lo que generalmente hace es aplicar una función `f()` a elementos de datos en una lista y usar ese resultado para el siguiente valor en la lista. Visualmente,
Datos = \[a 1 , a 2 ,…, a n \] función = f (x, y)
reducir (f, datos): Paso 1: val 1 = f (a 1 , a 2 ) Paso 2: val 2 = f (val 1 , a 3 ) Paso 3: val 3 = f (val 2 , a 4 ) . . . Paso n-1: val n-1 = f (val n-2 , a n )
Por ejemplo, usted quiere multiplicar todos los números en una lista.
#### Ejemplo de uso
```py
from functools import reduce
input = [1,2,3,4,5,6]
multiplier = lambda x,y:x*y
answer = reduce(multiplier,input)
print(answer)
```
#### Salida
```
720
```
Sin embargo, lo anterior podría calcularse utilizando un bucle simple y el uso de estos métodos está sujeto a preferencias.
#### Más información:

31
guide/spanish/python/lists/list-pop/index.md Normal file
View File

@@ -0,0 +1,31 @@
---
title: List Pop Method
localeTitle: Método de lista pop
---
# Función pop
El método pop () elimina y devuelve el último elemento de la lista. Hay un parámetro opcional, índice del elemento que se eliminará de la lista. Si no se especifica ningún índice, a.pop () elimina y devuelve el último elemento de la lista. Si el índice pasado al método pop () no está en el rango, arroja IndexError: el índice de pop fuera de la excepción de rango.
#### Ejemplo de uso
\`\` \`py ciudades = \['Nueva York', 'Dallas', 'San Antonio', 'Houston', 'San Francisco'\];
Imprimir "Ciudad emergida es:", cities.pop () Imprimir "Ciudad en el índice 2 es:", cities.pop (2) \`\` \`
\#### Salida `City popped is : San Francisco City at index 2 is : San Antonio`
#### Funcionalidad de pila básica
El método `pop()` se usa a menudo junto con `append()` para implementar la funcionalidad de pila básica en una aplicación Python.
```py
stack = []
for i in range(5):
stack.append(i)
while len(stack):
print(stack.pop())
```
\#### Más información: La documentación oficial de `pop()` se puede encontrar [aquí.](https://docs.python.org/3.6/tutorial/datastructures.html)

40
guide/spanish/python/lists/list-remove-method/index.md Normal file
View File

@@ -0,0 +1,40 @@
---
title: List Remove Method
localeTitle: Método de eliminación de lista
---
## Método de eliminación de lista
El método `remove()` elimina el argumento dado a él de la lista.
#### Ejemplo de uso
```py
words = ["I", "love", "Python"]
words.remove("I")
print(words)
```
#### Salida
```py
["love","Python"]
```
Tenga en cuenta que devuelve un error si el elemento que se va a eliminar no se encuentra en la lista, como se ilustra en el siguiente ejemplo.
```py
kiss = ["keep", "it", "simple", "stupid"]
kiss.remove("complex")
print(kiss)
```
#### Salida
```
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
```
#### Más información:
Más información sobre `remove()` se puede encontrar [aquí](https://docs.python.org/3.6/tutorial/datastructures.html)

109
guide/spanish/python/lists/list-sort-method/index.md Normal file
View File

@@ -0,0 +1,109 @@
---
title: List Sort Method
localeTitle: Método de clasificación de lista
---
## Método de clasificación de lista
Las listas de Python tienen un método `sort()` incorporado que modifica la lista en el lugar y una función incorporada `sorted()` que construye una nueva lista ordenada a partir de una iterable.
list.sort (key =…, reverse = \[True / False\])
### Parámetros
Hay dos parámetros opcionales para este método. _clave_ : el valor de entrada para el parámetro clave debe ser una función que tome un solo argumento y devuelva un valor utilizado para las comparaciones para ordenar los elementos de la lista _revertir = \[valor\]_ _valor = Verdadero_ : ordena los elementos de la lista en orden descendente _valor = falso_ : ordena los elementos de la lista en orden ascendente. Esto se considera el valor predeterminado. Tenga en cuenta que el método `sort()` no devuelve ningún valor. Modifica la lista original.
### Ejemplo de uso
```py
a = [4, 2, 5, 3, 1]
a.sort()
print a # prints [1, 2, 3, 4, 5]
b = ['free', 'code', 'camp']
b.sort()
print b # prints ['camp', 'code', 'free']
```
Considere un ejemplo con el parámetro **inverso**
```py
a = [4, 2, 5, 3, 1]
#Sorts the list in descending order
a.sort(reverse=True)
print a # prints [5, 4, 3, 2, 1]
```
Si desea ordenar la lista en función de su propia función, utilice el parámetro **clave** . Aquí hay un ejemplo para ordenar las cadenas en la lista por longitud, en orden ascendente
```py
a = ["hello", "hi", "hey"]
#The built-in len() function is given as an input to key parameter to sort the strings by length
a.sort(key = len)
print a # prints ['hi', 'hey', 'hello']
```
Aquí hay otro ejemplo, donde la lista contiene tuplas (nombre, edad). El uso a continuación muestra cómo ordenar la lista por edad, en orden ascendente.
```py
#Consider the second element in the tuple for sorting
>>> def compareByAge(element):
... return element[1]
b = [('Adam', 20), ('Rahman', 30), ('Rahul', 25)]
#Sort the list by age
b.sort(key = compareByAge)
#Output
print b # prints [('Adam', 20), ('Rahul', 25), ('Rahman', 30)]
```
### Conceptos básicos de clasificación
Una ordenación ascendente simple es muy fácil, simplemente llame a la función ordenada (). Devuelve una nueva lista ordenada:
```python
>>> sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]
```
También puede utilizar el método list.sort () de una lista. Modifica la lista en el lugar (y devuelve Ninguno para evitar confusiones). Por lo general, es menos conveniente que el ordenado (), pero si no necesita la lista original, es un poco más eficiente.
```python
>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
```
Otra diferencia es que el método list.sort () solo se define para listas. En contraste, la función ordenada () acepta cualquier iterable.
```python
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
```
#### Detalles de implementacion
Si desea conocer detalles sobre la implementación de la función de clasificación, el algoritmo y la complejidad del tiempo, etc., consulte [aquí](http://svn.python.org/projects/python/trunk/Objects/listsort.txt) . En resumen, la función de clasificación utiliza el algoritmo TimSort, que según Python Developers es:
> una combinación adaptativa, estable y natural, llamada modestamente timsort (hey, me lo gané ). Tiene un rendimiento sobrenatural en muchos tipos de arreglos ordenados parcialmente (se necesitan menos de lg (N!) comparaciones, y tan pocos como N-1), pero tan rápido como el sampleort altamente afinado anterior de Python híbrido en matrices aleatorias.
#### ordenar () Parámetros
Por defecto, sort () no requiere ningún parámetro extra. Sin embargo, tiene dos parámetros opcionales:
* Invertir: si es verdadero, la lista ordenada se invierte (o se ordena en orden descendente)
* tecla - función que sirve como una tecla para la comparación de ordenación
#### Más información:
Más información sobre `sort()` se puede encontrar [aquí](https://docs.python.org/3/library/functions.html#sorted)
Puede encontrar más información sobre sort () y sorted () [aquí.](https://docs.python.org/3.6/tutorial/datastructures.html)
Más información sobre sort () y sorted () se puede encontrar [aquí](https://docs.python.org/3.6/tutorial/datastructures.html) .

51
guide/spanish/python/max-function/index.md Normal file
View File

@@ -0,0 +1,51 @@
---
title: Python Max Function
localeTitle: Función Max Python
---
`max()` es una función incorporada en Python 3. Devuelve el elemento más grande en un iterable o el más grande de dos o más argumentos.
## Argumentos
Esta función toma dos o más números o cualquier tipo de iterable como argumento. Al dar un iterable como argumento, debemos asegurarnos de que todos los elementos en el iterable sean del mismo tipo. Esto significa que no podemos pasar una lista que tenga valores de cadena y enteros almacenados en ella. Sintaxis: max (iterable, \* iterables \[, clave, predeterminado\]) max (arg1, arg2, \* args \[, tecla\])
Argumentos válidos:
```
max(2, 3)
max([1, 2, 3])
max('a', 'b', 'c')
```
Argumentos inválidos:
```
max(2, 'a')
max([1, 2, 3, 'a'])
max([])
```
## Valor de retorno
Se devuelve el artículo más grande en el iterable. Si se proporcionan dos o más argumentos posicionales, se devuelve el mayor de los argumentos posicionales. Si el iterable está vacío y no se proporciona el valor predeterminado, se `ValueError` un `ValueError` .
## Ejemplo de código
```
print(max(2, 3)) # Returns 3 as 3 is the largest of the two values
print(max(2, 3, 23)) # Returns 23 as 23 is the largest of all the values
list1 = [1, 2, 4, 5, 54]
print(max(list1)) # Returns 54 as 54 is the largest value in the list
list2 = ['a', 'b', 'c' ]
print(max(list2)) # Returns 'c' as 'c' is the largest in the list because c has ascii value larger then 'a' ,'b'.
list3 = [1, 2, 'abc', 'xyz']
print(max(list3)) # Gives TypeError as values in the list are of different type
#Fix the TypeError mentioned above first before moving on to next step
list4 = []
print(max(list4)) # Gives ValueError as the argument is empty
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CVok)
[Documentos oficiales](https://docs.python.org/3/library/functions.html#max)

52
guide/spanish/python/min-function/index.md Normal file
View File

@@ -0,0 +1,52 @@
---
title: Python Min Function
localeTitle: Función Min de Python
---
`min()` es una función incorporada en Python 3. Devuelve el elemento más pequeño en un iterable o el más pequeño de dos o más argumentos.
## Argumentos
Esta función toma dos o más números o cualquier tipo de iterable como argumento. Al dar un iterable como argumento, debemos asegurarnos de que todos los elementos en el iterable sean del mismo tipo. Esto significa que no podemos pasar una lista que tenga valores de cadena y enteros almacenados en ella.
Argumentos válidos:
```
min(2, 3)
min([1, 2, 3])
min('a', 'b', 'c')
```
Argumentos inválidos:
```
min(2, 'a')
min([1, 2, 3, 'a'])
min([])
```
## Valor de retorno
Se devuelve el artículo más pequeño en el iterable. Si se proporcionan dos o más argumentos posicionales, el más pequeño de los argumentos posicionales
es regresado. Si el iterable está vacío y no se proporciona el valor predeterminado, se genera un ValueError.
## Ejemplo de código
```
print(min(2, 3)) # Returns 2 as 2 is the smallest of the two values
print(min(2, 3, -1)) # Returns -1 as -1 is the smallest of the two values
list1 = [1, 2, 4, 5, -54]
print(min(list1)) # Returns -54 as -54 is the smallest value in the list
list2 = ['a', 'b', 'c' ]
print(min(list2)) # Returns 'a' as 'a' is the smallest in the list in alphabetical order
list3 = [1, 2, 'abc', 'xyz']
print(min(list3)) # Gives TypeError as values in the list are of different type
#Fix the TypeError mentioned above first before moving on to next step
list4 = []
print(min(list4)) # Gives ValueError as the argument is empty
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CVir/4)
[Documentos oficiales](https://docs.python.org/3/library/functions.html#min)

9
guide/spanish/python/more-built-in-types/index.md Normal file
View File

@@ -0,0 +1,9 @@
---
title: Python More Built in Types
localeTitle: Python más construido en tipos
---
Las siguientes secciones describen los tipos estándar que están integrados en el intérprete.
Los principales tipos incorporados son numéricos, secuencias, asignaciones, clases, instancias y excepciones.
Algunas clases de colección son mutables. Los métodos que agregan, restan o reorganizan sus miembros en su lugar, y no devuelven un elemento específico, nunca devuelven la instancia de colección en sí, sino Ninguno.

68
guide/spanish/python/mutability-and-variable-assignments/index.md Normal file
View File

@@ -0,0 +1,68 @@
---
title: Python Mutability and Variable Assignments
localeTitle: Mutabilidad Python y asignaciones de variables
---
> Cada objeto tiene una identidad, un tipo y un valor. La identidad de un objeto nunca cambia una vez que ha sido creado; usted puede pensar en ello como la dirección del objeto en la memoria. [fuente](https://docs.python.org/3/reference/datamodel.html#data-model)
Una vez `object` se crea un `object` , el tipo y la identidad no se pueden cambiar. Si los valores del objeto pueden cambiar o no después de la creación, se determina si el objeto es mutable (puede cambiar) o inmutable (no puede cambiar).
Hasta ahora hemos aprendido sobre algunos tipos de objetos y sus subclases: `string` y objetos numéricos (enteros, de punto flotante, complejos y booleanos). Todos estos son objetos **inmutables** .
Este concepto puede ser confuso al principio porque lo bueno es un objeto si no puede modificarlo. Lo que hace que estos objetos sean utilizables es la capacidad de asignar y reasignar variables. Las funciones y los operadores pueden devolver nuevos objetos que pueden asignarse a variables.
Usando la [función de identificación integrada](https://docs.python.org/3/library/functions.html#id) , que devuelve la identidad de un objeto, podemos ver cómo funciona esto.
Aquí hay algunas cosas a tener en cuenta:
* Asignar una variable no significa que la _variable_ sea ​​el _objeto_ . Utilizamos un lenguaje muy específico que indica que las _instrucciones de asignación_ **unen** un **nombre** (identificador) a un _objeto_ . Las variables pueden ser reasignadas:
\`pitón
> > > a = 1 # Unir a un objeto.
> > > id (a)
> > > 140355241530152
> > > a = 2 # Rebindir a otro objeto.
> > > id (a)
> > > 140355241530128
> > > \`
* Asignar dos variables diferentes a _objetos inmutables_ con el mismo valor puede resultar (no garantizado) en que estén vinculados al mismo _objeto_
\`pitón
> > > a = 1
> > > b = 1
> > > id (a)
> > > 140355241530152
> > > id (b) # En este caso a y b están vinculados al mismo objeto.
> > > 140355241530152
> > > \`
* Asignar dos variables diferentes a _objetos imutables_ con valores diferentes siempre dará como resultado que estén vinculados a _objetos_ diferentes:
\`pitón
> > > a = 1
> > > b = 2
> > > id (a)
> > > 140355241530152
> > > id (b) # a y b están vinculados a diferentes objetos.
> > > 140355241530128
> > > \`
* La reasignación de variables no cambia el objeto original, las vincula a un objeto diferente.
\`pitón
> > > a = 1
> > > b = 1
> > > id (a)
> > > 140355241530152
> > > id (b)
> > > 140355241530152
> > > a = 2
> > > id (a) # a es rebote a un objeto diferente.
> > > 140355241530128
> > > id (b) # b todavía está vinculado al objeto original.
> > > 140355241530152
> > > \`

28
guide/spanish/python/name-binding-and-aliasing-functions/index.md Normal file
View File

@@ -0,0 +1,28 @@
---
title: Python Name Binding and Aliasing Functions
localeTitle: Funciones de vinculación y alias de nombres de Python
---
Una definición de función introduce el nombre de la función en la tabla de símbolos actual. El valor del nombre de la función tiene un tipo que el intérprete reconoce como una función definida por el usuario.
```
>>> something = 1
>>> type(something)
<type 'int'>
>>> def something():
... pass
...
>>> type(something)
<type 'function'>
>>> something = []
>>> type(something)
<type 'list'>
```
Este valor puede asignarse a otro nombre que también puede usarse como una función. Esto sirve como un mecanismo general de cambio de nombre:
```
>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
```

105
guide/spanish/python/nested-functions/index.md Normal file
View File

@@ -0,0 +1,105 @@
---
title: Nested Functions in Python
localeTitle: Funciones anidadas en Python
---
### Espacios de nombres
Los parámetros de una función, más cualquier variable que esté vinculada (por asignación o por otras declaraciones vinculantes, como def) en el cuerpo de la función, conforman el espacio de nombres local de la función, también conocido como ámbito local. Cada una de estas variables se conoce como una variable local de la función.
Las variables que no son locales se conocen como variables globales (en ausencia de definiciones de funciones anidadas, que analizaremos en breve). Las variables globales son atributos del objeto de módulo, como se describe en "Atributos de los objetos de módulo" en la página 140. Cuando una variable local de una función tiene el mismo nombre que una variable global, ese nombre, dentro del cuerpo de la función, se refiere a la variable local, No la global. Expresamos esto diciendo que la variable local oculta la variable global del mismo nombre en todo el cuerpo de la función.
### La declaración global
De forma predeterminada, cualquier variable que esté vinculada dentro del cuerpo de una función es una variable local de la función. Si una función necesita volver a vincular algunas variables globales, la primera La declaración de la función debe ser:
identificadores globales
donde identificadores es uno o más identificadores separados por comas (,). Los identificadores enumerados en una declaración global se refieren a las variables globales (es decir, los atributos del objeto de módulo) que la función necesita volver a vincular. Por ejemplo, el contador de funciones que vimos en "Otros atributos de objetos de función" en la página 73 podría implementarse utilizando una variable global y global, en lugar de un atributo del objeto de función:
\_count = 0 def contador (): cuenta global \_count + = 1 devolver \_cuenta
Sin la declaración global, la función de contador generaría una excepción UnboundLocal-Error porque \_count sería una variable local no iniciada (no vinculada). Si bien la declaración global permite este tipo de programación, este estilo suele ser poco elegante y desaconsejable. Como mencioné anteriormente, cuando desea agrupar un estado y un comportamiento, los mecanismos orientados a objetos que se describen en el Capítulo 5 suelen ser los mejores.
No use global si el cuerpo de la función solo usa una variable global (incluida la mutación del objeto vinculado a esa variable si el objeto es mutable). Use una declaración global solo si el cuerpo de la función vuelve a vincular una variable global (generalmente asignando el nombre de la variable). Como cuestión de estilo, no use global a menos que sea estrictamente necesario, ya que su presencia hará que los lectores de su programa asuman que la afirmación está ahí por algún propósito útil. En particular, nunca use global excepto como la primera declaración en un cuerpo de función.
{mospagebreak title = Funciones anidadas y ámbitos anidados}
Una declaración de definición dentro de un cuerpo de función define una función anidada, y la función cuyo cuerpo incluye la definición se conoce como una función externa a la función anidada. El código en el cuerpo de una función anidada puede acceder (pero no volver a vincular) las variables locales de una función externa, también conocidas como variables libres de la función anidada.
La forma más sencilla de permitir que una función anidada acceda a un valor es a menudo no confiar en los ámbitos anidados, sino más bien pasar ese valor como uno de los argumentos de la función. Si es necesario, el valor del argumento puede vincularse cuando la función anidada se define utilizando el valor como predeterminado para un argumento opcional. Por ejemplo:
def percent1 (a, b, c): def pc (x, total = a + b + c): retorno (x \* 100.0) / total imprima "Los porcentajes son:", pc (a), pc (b), pc (c)
Aquí está la misma funcionalidad que usa los ámbitos anidados:
def percent2 (a, b, c): def pc (x): return (x \* 100.0) / (a ​​+ b + c) imprima "Los porcentajes son:", pc (a), pc (b), pc (c)
En este caso específico, percent1 tiene una pequeña ventaja: el cálculo de a + b + c ocurre solo una vez, mientras que pc de la función interna de percent2 repite el cálculo tres veces. Sin embargo, si la función externa vuelve a vincular sus variables locales entre las llamadas a la función anidada, puede ser necesario repetir el cálculo. Por lo tanto, es aconsejable conocer los dos enfoques y elegir el caso por caso más apropiado.
Una función anidada que accede a valores desde variables locales externas también se conoce como cierre. El siguiente ejemplo muestra cómo construir un cierre:
def make\_adder (agosto): def add (addend): retorno addend + augend volver agregar
Los cierres son una excepción a la regla general de que los mecanismos orientados a objetos cubiertos en el Capítulo 5 son la mejor manera de agrupar datos y códigos. Cuando necesita construir específicamente objetos que se pueden llamar, con algunos parámetros fijos en el momento de la construcción del objeto, los cierres pueden ser más simples y más efectivos que las clases. Por ejemplo, el resultado de make\_adder (7) es una función que acepta un solo argumento y agrega 7 a ese argumento. Una función externa que devuelve un cierre es una "fábrica" ​​para los miembros de una familia de funciones que se distingue por algunos parámetros, como el valor del argumento augend en el ejemplo anterior, y a menudo puede ayudarlo a evitar la duplicación de código.
### Expresiones lambda
Si el cuerpo de una función es una sola declaración de expresión de retorno, puede elegir reemplazar la función con la forma de expresión lambda especial:
parámetros lambda: expresión
Una expresión lambda es el equivalente anónimo de una función normal cuyo cuerpo es una sola declaración de retorno. Tenga en cuenta que la sintaxis lambda no utiliza la palabra clave return. Puede usar una expresión lambda donde quiera que pueda usar una referencia a una función. Lambda a veces puede ser útil cuando se quiere usar una función simple como argumento o valor de retorno. Aquí hay un ejemplo que usa una expresión lambda como un argumento para la función de filtro incorporada (cubierto en el filtro en la página 161):
aList = \[1, 2, 3, 4, 5, 6, 7, 8, 9\] bajo = 3 alto = 7 filtro (lambda x, l = bajo, h = alto: h> x> l, aList) # devuelve: \[4, 5, 6\]
Como alternativa, siempre puede usar una declaración de definición local que le dé un nombre al objeto de función. A continuación, puede utilizar este nombre como argumento o valor de retorno. Aquí está el mismo ejemplo de filtro usando una declaración de definición local:
aList = \[1, 2, 3, 4, 5, 6, 7, 8, 9\] bajo = 3 alto = 7 def dentro de los _límites (valor, l = bajo, h = alto): devuelve h> valor> l filter (dentro de los_ límites, aList) # devuelve: \[4, 5, 6\]
Si bien lambda ocasionalmente puede ser útil, muchos usuarios de Python prefieren def, que es más general, y pueden hacer que su código sea más legible si elige un nombre razonable para la función.
{mospagebreak title = Generadores}
Cuando el cuerpo de una función contiene una o más apariciones del rendimiento de la palabra clave, la función se conoce como generador. Cuando llama a un generador, el cuerpo de la función no se ejecuta. En su lugar, llamar al generador devuelve un objeto iterador especial que envuelve el cuerpo de la función, sus variables locales (incluidos sus parámetros) y el punto actual de ejecución, que inicialmente es el inicio de la función.
Cuando se llama al siguiente método de este objeto iterador, el cuerpo de la función se ejecuta hasta la siguiente declaración de rendimiento, que toma la forma:
expresión de rendimiento
Cuando se ejecuta una declaración de rendimiento, la ejecución de la función se "congela", con el punto de ejecución actual y las variables locales intactas, y la siguiente expresión de rendimiento se devuelve como resultado del siguiente método. Cuando se vuelve a llamar a next, la ejecución del cuerpo de la función se reanuda donde se detuvo, nuevamente hasta la siguiente declaración de rendimiento. Si el cuerpo de la función finaliza, o ejecuta una instrucción de retorno, el iterador genera una excepción StopIteration para indicar que la iteración ha finalizado. Las declaraciones de retorno en un generador no pueden contener expresiones.
Un generador es una forma muy útil de construir un iterador. Dado que la forma más común de usar un iterador es hacer un bucle con una instrucción for, normalmente se llama a un generador como este:
para avariable en somegenerator (argumentos):
Por ejemplo, supongamos que desea una secuencia de números que cuenten de 1 a N y luego nuevamente a 1. Un generador puede ayudar:
def updown (N): para x en xrange (1, N): rendimiento x para x en xrange (N, 0, -1): rendimiento x para i en updown (3): imprimir i # impresiones: 1 2 3 2 1
Aquí hay un generador que funciona de forma similar a la función xrange incorporada, pero devuelve una secuencia de valores de coma flotante en lugar de una secuencia de enteros:
def frange (inicio, parada, paso = 1.0): mientras se inicia <detener: comienzo de rendimiento inicio + = paso
Este ejemplo de frange es solo un poco como xrange porque, por simplicidad, hace que los argumentos comiencen y paren de manera obligatoria, y supone silenciosamente que el paso es positivo.
Los generadores son más flexibles que las funciones que devuelven listas. Un generador puede construir un iterador ilimitado, es decir, uno que devuelve un flujo infinito de resultados (para usar solo en bucles que terminan por otros medios, por ejemplo, a través de una instrucción break). Además, un iterador creado por generador realiza una evaluación perezosa: el iterador calcula cada elemento sucesivo solo cuando es necesario, justo a tiempo, mientras que la función equivalente realiza todos los cálculos por adelantado y puede requerir grandes cantidades de memoria para contener la lista de resultados. Por lo tanto, si todo lo que necesita es la capacidad de iterar en una secuencia calculada, a menudo es mejor calcular la secuencia en un generador en lugar de en una función que devuelve una lista. Si la persona que llama necesita una lista de todos los elementos producidos por algunos generadores limitados G (argumentos), la persona que llama simplemente puede usar el siguiente código:
Lista\_resultada = lista (G (argumentos))
### Expresiones generadoras
Python 2.4 introduce una forma aún más sencilla de codificar generadores particularmente simples: expresiones generadoras, comúnmente conocidas como genexps. La sintaxis de un genexp es igual a la de una lista de comprensión (como se describe en "Lista de comprensión" en la página 67), excepto que un genexp se incluye entre paréntesis (()) en lugar de corchetes (\[\]); la semántica de un genexp es la misma que la de la comprensión de la lista correspondiente, excepto que un genexp produce un iterador que produce un elemento a la vez, mientras que la comprensión de la lista produce una lista de todos los resultados en la memoria (por lo tanto, utilizando un genexp, cuando apropiado, guarda la memoria). Por ejemplo, para sumar los cuadrados de todos los enteros de un solo dígito, en cualquier Python moderno, puede codificar suma (\[x _x para x en xrange (10)\]); en Python 2.4, puede expresar esta funcionalidad aún mejor, codificándola como suma (x_ x para x en xrange (10)) (igual, pero omitiendo los corchetes), y obtenga exactamente el mismo resultado mientras consume menos memoria. Tenga en cuenta que los paréntesis que indican la llamada a la función también "cumplen una doble función" y encierran el genexp (no se necesitan paréntesis adicionales).
{mospagebreak title = Generadores en Python 2.5}
En Python 2.5, los generadores se mejoran aún más, con la posibilidad de recibir un valor (o una excepción) de la persona que llama a medida que se ejecuta cada rendimiento. Estas características avanzadas permiten a los generadores en 2.5 implementar co-rutinas de pleno derecho, como se explica en http://www.python.org/peps/pep-0342.html. El cambio principal es que, en 2.5, el rendimiento no es una declaración, sino una expresión, por lo que tiene un valor. Cuando se reanuda un generador llamando a su método a continuación, el valor del rendimiento correspondiente es Ninguno. Para pasar un valor x a un generador g (de modo que g reciba x como el valor del rendimiento en el que está suspendido), en lugar de llamar a g.next (), el llamador llama a g.send (x) (llamando a g.send (Ninguno) es como llamar a g.next ()). Además, un rendimiento simple sin argumentos, en Python 2.5, se convierte en legal y equivalente a ninguno.
Otras mejoras de Python 2.5 a los generadores tienen que ver con las excepciones, y están cubiertas en "Mejoras del generador" en la página 126.
### Recursion
Python admite la recursión (es decir, una función de Python puede llamarse a sí misma), pero hay un límite a la profundidad de la recursión. De forma predeterminada, Python interrumpe la recursión y genera una excepción RecursionLimitExceeded (tratada en "Clases de excepción estándar" en la página 130) cuando detecta que la pila de llamadas recursivas ha superado la profundidad de 1.000. Puede cambiar el límite de recursión con la función setrecursionlimit del módulo sys, cubierto en setrecursionlimit en la página 171.
Sin embargo, cambiar el límite de recursión no le otorga una recursión ilimitada; el límite máximo absoluto depende de la plataforma en la que se ejecuta su programa, en particular del sistema operativo subyacente y la biblioteca de tiempo de ejecución de C, pero generalmente son unos pocos miles de niveles. Si las llamadas recursivas son demasiado profundas, su programa falla. Dicha recursión fuera de control, después de una llamada a setrecursionlimit que excede las capacidades de la plataforma, es una de las pocas formas en que un programa Python puede fallar: realmente falla, sin la red de seguridad habitual de los mecanismos de excepción de Python. Por lo tanto, desconfíe de intentar arreglar un programa que está obteniendo excepciones RecursionLimitExceeded elevando el límite de recursión demasiado alto con setrecursionlimit. La mayoría de las veces, le recomendamos que busque formas de eliminar la recursión o, más específicamente, limite la profundidad de recursión que su programa necesita.
Los lectores que están familiarizados con los lenguajes Lisp, Scheme o de programación funcional deben saber, en particular, que Python no implementa la optimización de la "eliminación de la llamada de cola", que es tan importante en estos idiomas. En Python, cualquier llamada, recursiva o no, tiene el mismo costo en términos de tiempo y espacio de memoria, dependiendo solo del número de argumentos: el costo no cambia, si la llamada es una "llamada de cola" (lo que significa que la llamada es la última operación que ejecuta la persona que llama) o cualquier otra llamada que no sea de cola.

45
guide/spanish/python/numeric-operations/index.md Normal file
View File

@@ -0,0 +1,45 @@
---
title: Python Numeric Operations
localeTitle: Operaciones Numéricas de Python
---
[Python Docs - Operaciones Numéricas](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)
Python es totalmente compatible con aritmética mixta: cuando un operador aritmético binario tiene operandos de diferentes tipos numéricos, el operando con el tipo "más estrecho" se amplía al del otro, donde el entero es más estrecho que el punto flotante, que es más estrecho que complejo. Las comparaciones entre números de tipo mixto usan la misma regla. [2\] Los constructores int (), float () y complex () se pueden usar para producir números de un tipo específico.](https://docs.python.org/3/library/functions.html#abs)
Todos los tipos numéricos (excepto los complejos) admiten las siguientes operaciones, ordenadas por prioridad ascendente (todas las operaciones numéricas tienen una prioridad más alta que las operaciones de comparación):
Operacion | Resultados | Notas | Documentación completa
\----------------- | -------------------------------------------------- ------------------------- | ------ | -------------------------------------------------- ---------------------
`x + y` | suma de x y y | |
`x - y` | diferencia de x y y | |
`x * y` | producto de x y y | |
`x / y` | cociente de x y y | |
`x // y` | cociente piso de xey | (1) |
`x % y` | resto de x / y | (2)
`-x` | x negado | |
`+x` | x sin cambios | |
`abs(x)` | valor absoluto o magnitud de x | | \[ `abs()`
`int(x)` | x convertido a entero | (3) (6) | [`int()`](https://docs.python.org/3/library/functions.html#int)
`float(x)` | x convertido a punto flotante | (4) (6) | [`float()`](https://docs.python.org/3/library/functions.html#float)
`complex(re, im)` | un número complejo con parte real re, parte imaginaria im. Im por defecto a cero. | (6) | [`complex()`](https://docs.python.org/3/library/functions.html#complex)
`c.conjugate()` | conjugado del número complejo c | |
`divmod(x, y)` | el par (x // y, x% y) | (2) | [`divmod()`](https://docs.python.org/3/library/functions.html#divmod)
`pow(x, y)` | x al poder y | (5) | [`pow()`](https://docs.python.org/3/library/functions.html#pow)
`x ** y` | x al poder y | (5)
**Notas:**
1. También se conoce como división entera. El valor resultante es un entero entero, aunque el tipo del resultado no es necesariamente int. El resultado siempre se redondea hacia menos infinito: `1//2` es `0` , `(-1)//2` es `-1` , `1//(-2)` es `-1` , y `(-1)//(-2)` es `0` .
2. No para números complejos. En su lugar, convierta a flotadores usando `abs()` si es apropiado.
3. La conversión de punto flotante a entero puede redondear o truncar como en C; vea las funciones [`math.floor()`](https://docs.python.org/3/library/math.html#math.floor) y [`math.ceil()`](https://docs.python.org/3/library/math.html#math.ceil) para conversiones bien definidas.
4. `float` también acepta las cadenas `“nan”` e `“inf”` con un prefijo opcional `“+”` o `“-”` para Not a Number (NaN) e infinito positivo o negativo.
5. Python define `pow(0, 0)` y `0 ** 0` como `1` , como es común en los lenguajes de programación.
6. Los literales numéricos aceptados incluyen los dígitos del 0 al 9 o cualquier equivalente de Unicode (puntos de código con la propiedad `Nd` ).
> Consulte [Tipo numérico derivado de Unicode](http://www.unicode.org/Public/8.0.0/ucd/extracted/DerivedNumericType.txt) para obtener una lista completa de puntos de código con la propiedad `Nd` .

36
guide/spanish/python/numeric-types/index.md Normal file
View File

@@ -0,0 +1,36 @@
---
title: Python Numeric Types
localeTitle: Tipos Numéricos de Python
---
Los [tipos numéricos](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex) para Python son:
* enteros ( `int` )
#### Ejemplos:
```py
print(1)
print(100)
print(8435367)
```
* números de punto flotante ( `float` )
* [constructor](https://docs.python.org/3/library/functions.html#float)
#### Ejemplos:
```py
print(1.5)
print(46.84)
print(84357.435)
```
* números complejos
* [constructor](https://docs.python.org/3/library/functions.html#complex)
La biblioteca estándar agrega tipos numéricos para
* [fracciones](https://docs.python.org/3/library/fractions.html#module-fractions)
* [decimales](https://docs.python.org/3/library/decimal.html#module-decimal)
Los objetos numéricos se crean a partir de literales o como resultado de funciones y operadores. La sintaxis de los literales numéricos está bien [documentada](https://docs.python.org/3/reference/lexical_analysis.html#numeric-literals) .

17
guide/spanish/python/object-oriented-programming/classes/index.md Normal file
View File

@@ -0,0 +1,17 @@
---
title: Classes
localeTitle: Las clases
---
## Las clases
Una clase es un "plano" para crear objetos: escribir un permiso de clase para describir atributos y comportamientos comunes a cada instancia de esta clase.
## Crear una clase
Para definir una clase **,** se usa la **clase de** palabra clave, seguida del nombre que define la clase y dos puntos. Todas las líneas siguientes (código que describe atributos y comportamientos / métodos) están sangradas como en una función de Python. Por ejemplo, para crear una clase llamada Persona, podemos escribir:
`class Person: <code describing attributes and behaviors/methods>`
Las definiciones de clase deben ejecutarse antes de que tengan algún efecto.
#### Más información:

11
guide/spanish/python/object-oriented-programming/constructors/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Constructors
localeTitle: Constructores
---
## Constructores
Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Más información:

16
guide/spanish/python/object-oriented-programming/index.md Normal file
View File

@@ -0,0 +1,16 @@
---
title: Python Object Oriented Programming
localeTitle: Programación Orientada a Objetos Python
---
## Programación Orientada a Objetos Python
Python es un lenguaje de programación multi-paradigma que soporta diferentes enfoques de programación. Un paradigma de programación excelente es la programación orientada a objetos, o POO para abreviar, mediante la creación de objetos.
En OOP, las propiedades y comportamientos se agrupan en objetos individuales, caracterizados por:
* atributos
* comportamientos
Por ejemplo, un objeto podría representar a una persona con atributos como nombre, edad, dirección, con comportamientos como caminar, hablar, respirar y correr.
OOP modela entidades del mundo real como objetos de software, que tienen algunos datos asociados y pueden realizar ciertas funciones. Los objetos se modelan como **clases** , que son una especie de _modelo_ .

11
guide/spanish/python/object-oriented-programming/inheritance/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Inheritance
localeTitle: Herencia
---
## Herencia
Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Más información:

11
guide/spanish/python/object-oriented-programming/methods/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Methods
localeTitle: Métodos
---
## Métodos
Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Más información:

11
guide/spanish/python/object-oriented-programming/operator-overloading/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Operator Overloading
localeTitle: Sobrecarga del operador
---
## Sobrecarga del operador
Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Más información:

11
guide/spanish/python/object-oriented-programming/special-comparison-methods/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Special Comparison Methods
localeTitle: Métodos de comparación especiales
---
## Métodos de comparación especiales
Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Más información:

11
guide/spanish/python/object-oriented-programming/special-formatting-methods/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Special Formatting Methods
localeTitle: Métodos especiales de formateo
---
## Métodos especiales de formateo
Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Más información:

11
guide/spanish/python/object-oriented-programming/special-iteration-methods/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Special Iteration Methods
localeTitle: Métodos de iteración especiales
---
## Métodos de iteración especiales
Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Más información:

11
guide/spanish/python/object-oriented-programming/static-variables/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Static Variables
localeTitle: Variables estáticas
---
## Variables estáticas
Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Más información:

35
guide/spanish/python/ord-function/index.md Normal file
View File

@@ -0,0 +1,35 @@
---
title: Python Ord Function
localeTitle: Función de Python Ord
---
## Función ord
`ord()` es una función incorporada en Python 3, para convertir la cadena que representa un carácter Unicode en un entero Representando el código Unicode del personaje.
#### Ejemplos:
```
>>> ord('d')
100
>>> ord('1')
49
```
## función chr
`chr()` es una función incorporada en Python 3, para convertir el entero representando el código Unicode en una cadena que representa un carácter correspondiente.
#### Ejemplos:
```
>>> chr(49)
'1'
```
Se debe tener en cuenta que, si el valor entero pasado a `chr()` está fuera de rango, se generará un ValueError.
```
>>> chr(-10)
'Traceback (most recent call last):
File "<pyshell#24>", line 1, in <module>
chr(-1)
ValueError: chr() arg not in range(0x110000)'
```

17
guide/spanish/python/parenthesis-for-boolean-operations/index.md Normal file
View File

@@ -0,0 +1,17 @@
---
title: Python Parenthesis for Boolean Operations
localeTitle: Paréntesis Python para Operaciones Booleanas
---
Al igual que en matemáticas, el paréntesis se puede usar para anular el orden de las operaciones:
```
>>> not True or True
True
>>> not (True or True)
False
>>> True or False and False
True
>>> (True or False) and False
False
```

25
guide/spanish/python/powxy/index.md Normal file
View File

@@ -0,0 +1,25 @@
---
title: Python Powxy
localeTitle: Python Powxy
---
`pow(x, y, z)` es una función incorporada en Python 3 para calcular `x` a la potencia `y` , y si `z` está presente, devuelve `x` a la potencia `y` [módulo](https://processing.org/reference/modulo.html) `z` .
## Argumentos
Los argumentos deben tener tipos numéricos. Esta función toma dos argumentos, `x` e `y` , así como tres, `x` , `y` y `z` . Si `z` está presente, `x` e `y` deben ser de tipos enteros, y y deben ser no negativos.
## Regreso
Si `z` está presente, devuelve `x` a la potencia `y` módulo `z` . Si solo están presentes `x` e `y` , devuelve `x` a la potencia `y` (igual que `x**y` ).
## Ejemplo
```python
print(pow(2,4)) # prints 16
print(pow(10,-2)) # prints 0.01
print(pow(4,3,5)) # prints 4
```
[🚀Código de ejecución](https://repl.it/CTGi)
[Documentacion oficial](https://docs.python.org/3/library/functions.html#pow)

65
guide/spanish/python/python-2-vs-python-3/index.md Normal file
View File

@@ -0,0 +1,65 @@
---
title: Python 2 vs Python 3
localeTitle: Python 2 vs Python 3
---
No estamos tomando partido en el debate. Si está interesado en saber más sobre esto con fines académicos, tal vez [este artículo que compara Python 2 y Python 3](https://wiki.python.org/moin/Python2orPython3) lo intrigaría.
Pero tampoco podemos ignorar el hecho de que hay dos sabores principales de Python. ¿Por qué debería importarte, te preguntarás? Debido a que el código escrito para una versión de Python puede provocar un error de sintaxis en otra versión de Python.
La siguiente es una declaración de `print` válida en Python 2, pero no funciona en Python 3:
```py
print "Hello World"
```
En Python 3, la misma declaración produce un error como este:
```
>>> print "hello"
File "<stdin>", line 1
print "hello"
^
SyntaxError: Missing parentheses in call to 'print'
```
En Python 2, "imprimir" se trata como una declaración en lugar de una función. No es necesario envolver el texto que desea imprimir entre paréntesis, aunque puede hacerlo si lo desea. Python 3 trata explícitamente la "impresión" como una función, lo que significa que tiene que pasar los elementos que necesita para imprimir la función entre paréntesis de forma estándar, o recibirá un error de sintaxis
El uso de la función `print()` es 'seguro' en Python 2 y 3:
```python
print("Hello World")
```
Otra diferencia entre Python 2 y Python 3 es la estructura de datos que devuelven cuando llama a la función `map()` .
En Python 2, `map()` devuelve una lista:
```
>>> result = map(int,['10','20','30','40'])
>>> print result
>>> [10,20,30,40]
```
En Python 3, `map()` devuelve un iterador:
```
>>> result = map(int,['10','20','30','40'])
>>> print (result)
>>> <map object at 0x7f40896b4630>
```
Para obtener una lista en Python 3, necesita convertirla:
```
>>> result = list(map(int,['10','20','30','40']))
>>> print (result)
>>> [10,20,30,40]
```
Por lo tanto, la única pregunta que debe preocuparse ahora mismo; ¿Cuál deberías elegir? Si eres nuevo en Python, debes elegir Python 3. Python 2 tiene su fecha de [fin de vida](https://www.python.org/dev/peps/pep-0373/#update) establecida en 2020. Lo que significa que las correcciones de errores regulares no están garantizadas en el futuro y sí, toma tiempo incluso para familiarizarse con los aspectos más comunes con cualquiera Pitón; y tu tiempo es importante. Entonces, invierte tu tiempo y esfuerzo sabiamente!
Si bien Python 2 es bien compatible y popular, las bibliotecas y los marcos más comunes en Python prefieren Python 3. Django [recomienda](https://docs.djangoproject.com/en/1.9/faq/install/#faq-python-version-support) oficialmente Python 3. Flask y todas sus dependencias también son [compatibles](http://flask.pocoo.org/docs/0.10/python3/#python3-support) con Python 3.
Tanto Python 2 como Python 3 son geniales. La mayoría de las distribuciones de Linux y macOS vienen preinstaladas con Python 2 como la versión predeterminada de Python. Y Python 3 nació de la búsqueda insaciable de construcciones de lenguaje más legibles y más bellas.
Este artículo utiliza Python 3 para configurar los marcos web en su entorno de desarrollo. Pero antes de eso, debes asegurarte de tener Python 3 y saber cómo usarlo.
#### Más información:
* [Python 2 o 3 artículo](https://wiki.python.org/moin/Python2orPython3)

30
guide/spanish/python/python-coding-standards/index.md Normal file
View File

@@ -0,0 +1,30 @@
---
title: Coding standards
localeTitle: Normas de codificación
---
### contorno
* ¿Por qué codificar estándares?
* Introducción a PEP 8
* Comandos
### ¿Por qué codificar estándares?
La comunidad global de python está creciendo rápidamente, y casi todos usan python. Aquí es donde la legibilidad del código y los estándares uniformes son importantes. Cualquiera en el planeta debería poder leer su código y entender lo que hace. Hay muchos aspectos para entender el código de otros, por ejemplo, comentarios sobre lo que hace una función, dividir lógicamente las tareas entre módulos y funciones, buenos nombres de variables, etc.
### Introducción a PEP 8
Nos encanta pegarnos a las convenciones. La comunidad de usuarios de Python ha creado un conjunto de estándares, que ahora se toman como convención. Cualquier código de nivel de industria que escriba se ejecuta a través del verificador PEP 8. Por lo tanto, es una buena práctica comenzar a escribir cadenas de documentación para sus clases y funciones, y nombrar variables en minúsculas con guiones bajos apropiados. Puede que valga la pena echar un vistazo a estos estándares antes de comenzar a codificar.
[Aquí está el enlace exhaustivo.](https://www.python.org/dev/peps/pep-0008/ "Estándares PEP 8")
### Comandos
Así es como verificas si tu código de Python cumple con los estándares.
```console
:~$ pip install pep8
:~$ pep8 --first myCode.py
```
Esto le dará a todas las líneas que violan los estándares, junto con una breve descripción de las correcciones.

53
guide/spanish/python/python-f-strings/index.md Normal file
View File

@@ -0,0 +1,53 @@
---
title: Python f-strings
localeTitle: Cuerdas de pitón
---
# F-cuerdas en Python
En Python versión 3.6, se implementó un nuevo método para formatear cadenas. El nuevo método se denomina interpolación de cadena literal (aunque comúnmente se denomina cadena de caracteres).
El uso de f-string permite al programador insertar dinámicamente una variable en una cadena de una manera limpia y concisa. Además de insertar variables en una cadena, esta característica también brinda la capacidad de un programador para evaluar expresiones, unir el contenido de la colección e incluso invocar funciones dentro de la cadena f.
Para realizar estos comportamientos dinámicos dentro de una f-string, los envolvemos entre corchetes dentro de la cadena, y escribimos una minúscula f al principio de la cadena (antes de la cita inicial).
### Ejemplos
1. Insertar dinámicamente una variable en una cadena en tiempo de ejecución:
```python
name = 'Jon Snow'
greeting = f'Hello! {name}'
print(greeting)
```
2. Evaluar una expresión en una cadena: `python val1 = 2 val2 = 3 expr = f'The sum of {val1} + {val2} is {val1 + val2}' print(expr)`
3. Llamando una función e insertando salida dentro de una cadena:
```python
def sum(*args):
result = 0
for arg in args:
result += arg
return result
func = f'The sum of 3 + 5 is {sum(3, 5)}'
print(func)
```
4. Uniendo los contenidos de una colección dentro de una cadena:
```python
fruits = ['Apple', 'Banana', 'Pear']
list_str = f'List of fruits: {", ".join(fruits)}'
print(list_str)
```
### Fuentes
https://www.python.org/dev/peps/pep-0498/

69
guide/spanish/python/python-resources/index.md Normal file
View File

@@ -0,0 +1,69 @@
---
title: Python Resources
localeTitle: Recursos de Python
---
## Tutoriales
* [Tutoriales Oficiales de Python](https://docs.python.org/3/tutorial/)
* [La guía del autoestopista de Python](https://python-guide.readthedocs.org/en/latest/)
* [Google Python Class](https://developers.google.com/edu/python/)
* [Aprende Python de la manera difícil](http://learnpythonthehardway.org/book/)
* [Piensa en pitón](http://www.greenteapress.com/thinkpython/html/index.html)
* [Aprende Python en X minutos](https://learnxinyminutes.com/docs/python/)
* [Aprende Python 3 en X minutos](https://learnxinyminutes.com/docs/python3/)
* [Sumérgete en Python 3](http://www.diveintopython3.net/)
* [Python de pila completa](http://www.fullstackpython.com/)
* [Automatiza las cosas aburridas con Python](https://automatetheboringstuff.com/)
* [Python REPL en el navegador](https://repl.it/languages/python3)
* [Tutorial del código visual de Python](http://pythontutor.com/)
* [Codecademy Python](https://www.codecademy.com/learn/python)
* [Cómo pensar como un científico informático](http://interactivepython.org/runestone/static/thinkcspy/index.html) : libro de texto interactivo que enseña programación con Python
* [Introducción a la informática y la programación mediante Python](https://www.edx.org/course/introduction-computer-science-mitx-6-00-1x-8) (MIT)
* [CS para todos: Introducción a la informática y la programación en Python](https://www.edx.org/course/cs-all-introduction-computer-science-harveymuddx-cs005x-0)
* [Aprendiendo Python](https://www.packtpub.com/packt/free-ebook/learning-python) - ebook gratuito
* [Nuevo codificador](http://newcoder.io/) : tutoriales / desafíos que lo llevarán de novato a codificador real.
* [Inventa con Python](https://inventwithpython.com/) (además de otros dos libros de Automate the Boring Stuff)
* [Resolución de problemas con algoritmos y estructuras de datos utilizando Python](http://interactivepython.org/runestone/static/pythonds/index.html)
* [Patrones de diseño de Python](https://github.com/faif/python-patterns)
* [Tutorial de iniciación de Django](https://www.djangoproject.com/start/)
* [Desarrollo guiado por pruebas con Python](http://chimera.labs.oreilly.com/books/1234000000754/index.html)
* [Tango con Django](http://www.tangowithdjango.com/)
* [Django Girls 'Tutorial](http://tutorial.djangogirls.org/en/) - Construye un blog
* [TaskBuster Django Tutorial](http://www.marinamele.com/taskbuster-django-tutorial) - Construye un proyecto Django desde cero
* [Derek Banas 'Learn Python In One Video](https://www.youtube.com/watch?v=N4mEzFDjqtA)
* [pythonprogramming.net Python Baics](https://pythonprogramming.net/introduction-to-python-programming/)
* [thenewboston Python 3.4 Tutoriales de programación](https://www.youtube.com/playlist?list=PL6gx4Cwl9DGAcbMi1sH6oAMk4JHw91mC_)
* [Punto de tutoriales - Python](http://www.tutorialspoint.com/python/)
* [Conjunto de proyectos iniciales con videos](https://pythonprogramming.net) : de lo básico en adelante.
* [El mega tutorial del matraz (miguel grinberg)](https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world)
## Desafíos
* [Python Koans](https://github.com/gregmalcolm/python_koans)
* [Ejercicios de Python Challenges.](http://exercism.io/languages/python)
* [CodingBat Python Challenges](http://codingbat.com/python)
* [Aprende Python interactivamente](http://www.learnpython.org/)
* [Proyecto euler](http://projecteuler.net/)
* [Rosalind Python Bio-informatics Problems](http://rosalind.info/problems/locations/)
* [Desafío del elevador de Python](https://github.com/mshang/python-elevator-challenge)
* [CoderByte Challenges](https://coderbyte.com/)
* [CheckiO](https://checkio.org) - el juego para codificadores
* [CodeAbbey](http://www.codeabbey.com/)
* [HackerRank - Desafíos de Python](https://hackerrank.com/domains/python/py-introduction)
* [CodeSignal - Prepárese para entrevistas y mejore sus habilidades de programación](https://codesignal.com/)
* [CodeWars](https://www.codewars.com/)
* [CodeChef](https://www.codechef.com/)
## Comunidad
* [Python impresionante](https://github.com/vinta/awesome-python)
* [/ r / Python](https://www.reddit.com/r/python)
* [/ r / LearnPython](https://www.reddit.com/r/learnpython)
* [Planeta pitón](http://planetpython.org/)
* [PyLadies](http://www.pyladies.com/)
* [DjangoGirls](https://djangogirls.org/)
* [Python-forum.io](https://python-forum.io/)
## Herramientas:
* [PyCharm Edu](https://www.jetbrains.com/pycharm-edu/) : una versión educativa gratuita de PyCharm que viene con tutoriales para enseñarte Python y la capacidad de descargar más.

13
guide/spanish/python/range-function/index.md Normal file
View File

@@ -0,0 +1,13 @@
---
title: Range Method
localeTitle: Método de rango
---
# Función de rango
Si necesita iterar sobre una secuencia de números, el rango de funciones incorporadas () es muy útil. Genera progresiones aritméticas:
#### Ejemplo de uso
`py for i in range(5): print(i)`
\#### Salida `0 1 2 3 4`

91
guide/spanish/python/rest-api-with-falcon/index.md Normal file
View File

@@ -0,0 +1,91 @@
---
title: REST APIs with Falcon
localeTitle: API REST con Falcon
---
## Introducción
Las API REST son un componente importante de cualquier pila bien diseñada, y Python tiene algunos marcos brillantes para componer API rápidamente. Uno de estos marcos se llama [Falcon](https://falconframework.org) , ¡y es genial! Esencialmente un microframado, se envía con una cantidad considerable de ventajas:
1. Es rápido. Realmente rápido. Echa un vistazo a los puntos de referencia [aquí](https://falconframework.org/#sectionBenchmarks) .
2. Los recursos HTTP se definen como clases, y los métodos de clase se utilizan para diferentes operaciones REST en estos recursos. Esto ayuda a mantener un código base limpio.
3. Es bastante extensible: echa un vistazo a [esta sección](https://github.com/falconry/falcon/wiki/Complementary-Packages) en su wiki, para familiarizarse con ella.
4. Se basa en WSGI, el estándar Pythonic para aplicaciones web, por lo que funciona con Python 2.6, 2.7 y 3.3+. Y si necesita más rendimiento, ejecútelo usando PyPy!
## Empezando
Primero, preparemos nuestro medio ambiente. Personalmente, siempre es bueno trabajar en entornos virtuales: puedes usar `virtualenv` , `virtualenvwrapper` o `venv` . A continuación, instale Falcon usando `pip` : `pip install falcon` .
Vamos a desarrollar una pequeña API de muestra que hace manipulaciones de zona horaria muy básicas para nosotros. Mostrará la hora actual en UTC, así como el tiempo de la época correspondiente. Para ese fin, tomaremos una biblioteca ingeniosa llamada `arrow` : `pip install arrow` .
Puede encontrar la muestra terminada en [https://github.com/rudimk/freecodecamp-guides-rest-api-falcon](https://github.com/rudimk/freecodecamp-guides-rest-api-falcon) .
## Recursos
Piense en un recurso como una entidad que su API necesita manipular. En nuestro caso, el mejor recurso sería una `Timestamp` . Nuestra ruta sería típicamente algo como esto:
```
GET /timestamp
```
Aquí, `GET` es el verbo HTTP que se usa para llamar a este punto final, y `/timestamp` es la propia URL. Ahora que hemos eliminado este bit del camino, ¡creemos un módulo!
`$ touch timestamp.py`
Tiempo para importar la biblioteca Falcon:
```python
import json
import falcon
import arrow
```
Tenga en cuenta que también importamos el paquete `json` y la biblioteca de `arrow` . Ahora, definamos una clase para nuestro recurso:
```python
class Timestamp(object):
def on_get(self, req, resp):
payload = {}
payload['utc'] = arrow.utcnow().format('YYYY-MM-DD HH:mm:SS')
payload['unix'] = arrow.utcnow().timestamp
resp.body = json.dumps(payload)
resp.status = falcon.HTTP_200
```
Vamos a pasar por este fragmento. Hemos definido una clase de `Timestamp` y hemos definido un método de clase llamado `on_get` ; esta función le dice a Falcon que cuando se emita una solicitud `GET` a un punto final para este recurso, ejecute la función `on_get` y proporcione los objetos de solicitud y respuesta como parámetros. Después de eso, es fácil navegar: creamos un diccionario vacío, lo llenamos con las marcas de hora UTC y UNIX actuales, lo convertimos a JSON y lo adjuntamos al objeto de respuesta.
Bastante simple, ¿verdad? Pero lamentablemente, eso no es todo. Ahora necesitamos crear un servidor Falcon y conectar la clase de recurso que acabamos de definir a un punto final real.
`$ touch app.py`
Ahora, agregue el siguiente código:
```python
import falcon
from timestamp import Timestamp
api = application = falcon.API()
timestamp = Timestamp()
api.add_route('/timestamp', timestamp)
```
Aquí, hemos definido una API de Falcon e inicializado una instancia de la clase de recurso que creamos anteriormente. Luego, `/timestamp` punto final `/timestamp` con la instancia de clase, ¡y ahora estamos listos! Para probar esta API, instale `gunicorn` ( `pip install gunicorn` ), y ejecute la `gunicorn app` . Use Postman o simple `cURL` para probar esto:
```
$ curl http://localhost:8000/timestamp
{"utc": "2017-10-20 06:03:14", "unix": 1508479437}
```
¡Y eso lo hace!
## Seguir adelante
Una vez que haya aprendido a usar Falcon, es muy fácil componer poderosas API REST que interactúan con bases de datos o colas de mensajería. Revise los [documentos de Falcon](https://falcon.readthedocs.io/en/stable/index.html) , así como el PyPI para ver los interesantes módulos de Falcon que siguen apareciendo.

91
guide/spanish/python/return-statement/index.md Normal file
View File

@@ -0,0 +1,91 @@
---
title: Python Return Statement
localeTitle: Declaración de retorno de Python
---
[Python Docs](https://docs.python.org/3/reference/simple_stmts.html#the-return-statement)
Todas las funciones devuelven un valor cuando se llama.
Si una declaración de devolución va seguida de una lista de expresiones, esa lista de expresiones se evalúa y se devuelve el valor:
```
>>> def greater_than_1(n):
... return n > 1
...
>>> print(greater_than_1(1))
False
>>> print(greater_than_1(2))
True
```
Si no se especifica una lista de expresiones, se devuelve `None` :
```
>>> def no_expression_list():
... return # No return expression list.
...
>>> print(no_expression_list())
None
```
Si se alcanza una declaración de retorno durante la ejecución de una función, la llamada a la función actual se deja en ese punto:
```
>>> def return_middle():
... a = 1
... return a
... a = 2 # This assignment is never reached.
...
>>> print(return_middle())
1
```
Si no hay una declaración de retorno, la función devuelve Ninguno cuando llega al final:
```
>>> def no_return():
... pass # No return statement.
...
>>> print(no_return())
None
```
Una sola función puede tener múltiples declaraciones de `return` . La ejecución de la función finaliza cuando se alcanza una de estas declaraciones de `return` :
```
>>> def multiple_returns(n):
... if(n):
... return "First Return Statement"
... else:
... return "Second Return Statement"
...
>>> print(multiple_returns(True))
First Return Statement
>>> print(multiple_returns(False))
Second Return Statement
```
Una sola función puede devolver varios tipos:
```
>>> def various_return_types(n):
... if(n==1):
... return "Hello World." # Return a string
... elif(n==2):
... return 42 # Return a value
... else:
... return True # Return a boolean
...
>>> print(various_return_types(1))
Hello World.
>>> print(various_return_types(2))
42
>>> print(various_return_types(3))
True
```
Incluso es posible que una sola función devuelva varios valores con solo una única devolución:
```
>>> def return_two_values():
... a = 40
... b = 2
... return a,b
...
>>> print("First value = %d, Second value = %d" %(return_two_values()))
First value = 40, Second value = 2
```

27
guide/spanish/python/sequence-types/index.md Normal file
View File

@@ -0,0 +1,27 @@
---
title: Python Sequence Types
localeTitle: Tipos de secuencias de Python
---
Estos representan conjuntos ordenados finitos indexados por números no negativos. La función incorporada `len()` devuelve el número de elementos de una secuencia. Cuando la longitud de una secuencia es `n` , el conjunto de índices contiene los números `0, 1, ..., n-1` . Artículo `i` de la secuencia A es seleccionado por `a<a href='https://docs.python.org/3/reference/datamodel.html#the-standard-type-hierarchy' target='_blank' rel='nofollow'>i]` .
\[Docs Python - Jerarquía Estándar
## Más
* Incorporado tipos de secuencias son:
* `list`
* `tuple`
* `range`
* Los tipos de secuencia incorporados son tipos iterables (implementar el `__iter__()` requerido `__iter__()` ).
* Operaciones:
* [Operaciones secuencia común](https://docs.python.org/3/library/stdtypes.html#common-sequence-operations)
* [Tipos de secuencias mutables](https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types)
* [Tipos de secuencias inmutables](https://docs.python.org/3/library/stdtypes.html#immutable-sequence-types)

22
guide/spanish/python/set-types/index.md Normal file
View File

@@ -0,0 +1,22 @@
---
title: Python Set Types
localeTitle: Tipos de conjuntos de Python
---
Un objeto establecido es una colección desordenada de objetos hashable distintos. Los usos comunes incluyen la prueba de membresía, la eliminación de duplicados de una secuencia y el cálculo de operaciones matemáticas como intersección, unión, diferencia y diferencia simétrica.
[Python Docs - Set Types Set Frozenset](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset)
**TODO: explicar hash / hashable** Una tabla hash es un vector contiguo de registros, cuyas ranuras vienen en tres sabores
1. Slots con pares clave + valor. Llama a estos ciudadanos.
2. Ranuras aún no utilizadas. Llama a estas vírgenes.
3. Las ranuras que una vez fueron ciudadanos, pero cuya clave se eliminó, y donde otro par clave + valor aún no ha sobrescrito la ranura. Llama a estos turds (ese es el término técnico <0.9 wink>).
Python redimensiona la tabla cuando el número de vírgenes cae por debajo de un tercio de el número total de ranuras. En el caso habitual, Python duplica el tamaño de la tabla. (Hasta un máximo actual de 1,073,741,824 ranuras). Sin embargo, si muchos Las eliminaciones dejan atrás a muchos turds, es posible para el número de vírgenes bajar muy a pesar de que quedan pocos ciudadanos; en ese caso, Python en realidad reduce la tabla (hasta un mínimo actual de 4 ranuras).
Para evitar golpes cuando se realiza una mezcla de adiciones y eliminaciones cuando el la tabla está cerca de un umbral de cambio de tamaño, Python en realidad no comprueba el número de vírgenes después de una eliminación (en efecto, se supone que pronto reemplazará la turds con ciudadanos de nuevo). Así que, curiosamente, borrar una clave _nunca_ encoge la mesa. Una larga secuencia de eliminaciones seguidas de un complemento puede reducirse aunque, Una forma de forzar una posible contracción sin agregar una clave es:
```
dict = dict.copy()
```
dict.copy () siempre devuelve un diccionario libre de turd, del más pequeño Tamaño de potencia de 2 que deja al menos un tercio de las ranuras vírgenes.

43
guide/spanish/python/setting-up-python-web-framework-django-and-flask/index.md Normal file
View File

@@ -0,0 +1,43 @@
---
title: Setting Up Python Web Framework Django and Flask
localeTitle: Configurando Python Web Framework Django y Flask
---
En este artículo, discutiremos cómo instalar [Django](https://www.djangoproject.com/) y [Flask](http://flask.pocoo.org/) , dos marcos web populares escritos en Python.
Quizás ya esté familiarizado con el uso generalizado y el soporte de la comunidad para Python; en desarrollo web. También deberías saber qué es un framework web; y las opciones disponibles para Python.
En caso de que estas suposiciones no sean ciertas, es posible que desee echar un vistazo a este artículo de wiki . Si está al corriente, vamos a comenzar a configurar los marcos web de Python en su máquina de desarrollo local.
Pero sería injusto si ignoramos por completo el debate [Python 2 vs Python 3](http://docs.python-guide.org/en/latest/starting/which-python/#the-state-of-python-2-vs-3) .
## Ambiente virtual
Antes de instalar Django, le pediremos que instale una herramienta extremadamente útil para ayudar a mantener ordenado su entorno de codificación en su computadora. Es posible omitir este paso, pero es muy recomendable. ¡Comenzar con la mejor configuración posible le ahorrará muchos problemas en el futuro!
Entonces, vamos a crear un entorno virtual (también llamado virtualenv). Virtualenv aislará su configuración de Python / Django por proyecto. Esto significa que cualquier cambio que realice en un sitio web no afectará a otros que también esté desarrollando. Limpio, ¿verdad?
Para obtener más información sobre los entornos virtuales, consulte la sección correspondiente [aquí](https://guide.freecodecamp.org/python/virtual-environments/) .
## Terminando
Si ya ha instalado `pip` , simplemente:
```
$ pip install django
```
Una vez finalizada la instalación podemos crear un nuevo proyecto:
```
$ django-admin startproject myproject
$ cd myproject
$ python manage.py runserver
```
Vaya a `http://localhost:8000` ! :cohete:
Hemos instalado con éxito el marco web de nuestra necesidad. Sin embargo, aún no está completo. La mayoría de las aplicaciones web están basadas en contenido y datos, por lo que necesitamos un almacenamiento de datos. O, una base de datos, si lo desea.
En el próximo artículo, discutiremos cómo instalar PostgreSQL y usarlo con nuestra aplicación web Python.
Un punto para reflexionar: hemos estado usando mucho `pip` , pero apenas hemos dicho nada al respecto. Bueno, por ahora, es solo un gestor de paquetes como `npm` . Tiene algunas diferencias con `npm` ; Pero, no tienes que preocuparte por eso ahora. Si estás interesado, revisa la [documentación oficial del `pip`](http://pip-python3.readthedocs.org/en/latest/index.html) .
_Si tiene sugerencias o preguntas, únase a nosotros en [Gitter](https://gitter.im/FreeCodeCamp/FreeCodeCamp)_ .

20
guide/spanish/python/share-file-using-python-simple-http-server/index.md Normal file
View File

@@ -0,0 +1,20 @@
---
title: Share File Using Python SimpleHTTPserver
localeTitle: Compartir archivo usando Python SimpleHTTPserver
---
## Los pasos deben seguir para enviar el archivo.
1. Asegúrese de que ambas computadoras estén conectadas a través de la misma red a través de LAN o WIFI.
2. Abra el terminal en Ubuntu y asegúrese de tener Python instalado en su PC.
3. Si no está instalado, instálelo escribiendo en el terminal "sudo apt-get install python" sin comillas.
4. Vaya al directorio cuyo archivo desea compartir con el comando cd (cambiar directorio).
5. Escriba este comando "python -m simpleHTTPserver" sin las comillas.
6. Abre una nueva terminal, escribe ifconfig y encuentra tu dirección IP.
## Ahora en segunda computadora
1. Abra el navegador y escriba la dirección IP de la primera.
2. No olvide agregar el número de puerto al final de la dirección IP ... que de forma predeterminada es: 8000
Se abrirá una página que muestra la estructura de tipos de directorio y mostrará todos los archivos de la PC de origen.
Ahora puedes acceder a todos los archivos.

22
guide/spanish/python/sleep-how-can-i-make-a-time-delay-in-python/index.md Normal file
View File

@@ -0,0 +1,22 @@
---
title: Sleep How Can I Make a Time Delay in Python
localeTitle: Dormir, ¿cómo puedo hacer un retraso en Python?
---
## Dormir, ¿cómo puedo hacer un retraso en Python?
El módulo de `time` en la biblioteca estándar de Python contiene la función `sleep()` que suspende un programa durante un número determinado de segundos.
Ejemplo:
```
import time
for letter in 'hello, world!':
print(letter)
time.sleep(2) # sleep 2 seconds between each print
```
Se pueden dar números de punto flotante como argumento para `sleep()` para tiempos de sueño más precisos.
#### Más información:
[Documentación del](https://docs.python.org/3/library/time.html#time.sleep) módulo de tiempo sobre la función dormir.

51
guide/spanish/python/slicestartstopstep/index.md Normal file
View File

@@ -0,0 +1,51 @@
---
title: Python Slicestartstopstep
localeTitle: Python Slicestartstopstep
---
`slice(start:stop[:step])` es un objeto que generalmente contiene una parte de una secuencia. Una porción se crea utilizando la notación de subíndices, \[\] con dos puntos entre los números cuando se dan varios, como en variable\_name \[1: 3: 5\].
## Argumentos
Esta función se puede utilizar para cortar tuplas, matrices y listas.
El valor del parámetro de `start` (o Ninguno si no se proporciona)
El valor del parámetro de `stop` (o último índice de secuencia)
El valor del parámetro de `step` (o Ninguno si no se proporciona). No puede ser 0.
Los tres deben ser de tipo entero.
## Regreso
Si solo se proporciona una `stop` , genera una parte de la secuencia desde el índice `0` hasta la `stop` .
Si solo se proporciona el `start` , genera una parte de la secuencia después del `start` índice hasta el último elemento.
Si se proporcionan tanto el `start` como la `stop` , genera una parte de la secuencia después del `start` índice hasta la `stop` .
Si se proporcionan los tres `start` , `stop` y `step` , se genera una parte de la secuencia después del `start` índice hasta la `stop` con el incremento del `step` del índice.
## Ejemplo
```
a = [1, 2, 3, 4, 5, 6, 7, 8]
print(a[:5]) # prints [1, 2, 3, 4, 5]
print(a[2:]) # prints [3, 4, 5, 6, 7, 8]
print(a[2:5]) # prints [3, 4, 5]
print(a[2:7:2]) # prints [3, 5, 7]
```
Puede indexar el último índice de una secuencia usando `-1` :
```
a = [1, 2, 3, 4, 5, 6]
print(a[-1]) # prints 6
print(a[2:-1]) # prints [3, 4, 5]
```
Puede voltear una secuencia usando la notación de división `[::-1]` :
```
a = [1, 2, 3, 4, 5, 6]
print(a[::-1]) # prints [6, 5, 4, 3, 2, 1]
```
[Documentacion oficial](https://docs.python.org/3/library/functions.html#slice) ![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":cohete:") [Ejecutar código](https://repl.it/CT5h)

31
guide/spanish/python/string-methods/index.md Normal file
View File

@@ -0,0 +1,31 @@
---
title: String Methods
localeTitle: Métodos de cuerda
---
**TODO: `string` información básica**
[Python Docs - Cuerdas](https://docs.python.org/3/library/stdtypes.html#strings)
**Creación:**
Una `string` vacía se crea utilizando un par de comillas o apóstrofes:
```shell
>>> new_string = ''
>>> type(new_string)
<class 'string'>
>>> len(new_string)
0
```
[Python Docs - Más sobre cuerdas](https://docs.python.org/3/tutorial/datastructures.html#more-on-strings)
* `string.find('you')` Devuelve la posición más baja en la que se encuentra la subcadena.
* `str.join(iterable)` Une todos los elementos en un `iterable` con una cadena especificada.
* `str.replace(old, new, max)` se usa para reemplazar la subcadena `old` con la cadena `new` por un total de `max` veces. Este método devuelve una nueva copia de la cadena con el reemplazo, y la `str` original no se modifica.
* `string.split(separator, maxsplit)` Devuelve una lista de subcadenas delimitadas por el `separator` , un número de `maxsplit` opcional de veces, y si no se especifica, la cadena se dividirá en todas las instancias del `separator` .
* `string.strip(to_strip)` Devuelve una cadena con `to_strip` eliminada tanto del principio como del final de la cadena. Si no se especifica `to_strip` , esto eliminará todos los caracteres de espacio en blanco.

Some files were not shown because too many files have changed in this diff Show More