<jupyter_start><jupyter_text>Uso interactivo===  Contenido > * [Uso interactivo](Uso-interactivo)    * [Cálculos numéricos](Cálculos-numéricos)    * [Funciones de usuario](Funciones-de-usuario)    * [Funciones matemáticas](Funciones-matemáticas)    * [Cadenas de caracteres (strings)](Cadenas-de-caracteres)    * [Listas](Listas)  Cálculos numéricos [Contenido](Contenido) IPython puede ser usado de forma interactiva como una calculadora. Esto permite que el análisis de datos pueda ser realizado de forma interactiva, de forma similar a como pueden usarse otras herramientas como el lenguaje R o Matlab. A continuación se ejemplifican los cálculos aritméticos básicos.<jupyter_code>2 + 2 + 1
50 - 5 * 6 + 8
(50 - 5 * 6) / 4
0
8 / 5  # resultado real
8 // 5 # parte entera de la division
8 % 5  # residuo de la división
5 ** 2 # potencia<jupyter_output><empty_output><jupyter_text>También se pueden declarar y usar variables en la ejecución interactiva.<jupyter_code>x = 20
y = 5 * 9
x * y
a = 12.5 / 100
b = 100.50
a * b<jupyter_output><empty_output><jupyter_text>Un caracter de subrayado `_` se usa para indicar el resultado del calculo anterior. Dos caracteres `__` indican el penúltimo resultado; tres caracteres `_` indican el antepenúltimo resultado. Igualmente, se puede usan `In[1]` para obtener el contenido de la primera celda, `In[2]` para la segunda y así sucesivamente. De igual forma, los resultados pueden obtenerse como `Out[1]`, `Out[2]`, etc.<jupyter_code>1.1
1.1 + _
1.1 + _
round(_, 2)
Out[8]
In[13]<jupyter_output><empty_output><jupyter_text>Funciones de usuario [Contenido](Contenido) Las funciones son definidas mediante la palabra reservada `def`. La siguiente función devuelve el cuadrado de su argumento.<jupyter_code>def square(x):   # el caracter `:` es obligatorio
    return x**2  # el cuerpo de la función esta definido por la identación (espacios en blanco)
                 # es obligatorio usar `return` para devolver valores
square(2)
square(1+2)
square(square(2))
square(1) + square(2)
def sum_of_squares(x, y):          
    return square(x) + square(y) # las funciones puden ser llamadas dentro de otras
sum_of_squares(1, 2)<jupyter_output><empty_output><jupyter_text>Funciones matemáticas [Contenido](Contenido) > La lista completa de funciones matemáticas se encuentra disponible [aquí](https://docs.python.org/3/library/math.html).<jupyter_code>import math           # importa la libreria de funciones matemáticas
math.cos(3.141516)    # llama la función cos en la librería math<jupyter_output><empty_output><jupyter_text>**Ejercicio.** Calcule el valor de la siguiente expresión:$$\frac{5-(1 -(3 - \exp(\frac{1}{8}))}{3(4-2)(2-\frac{3}{8})} - 2!(-1)^3 + \sin (0.98\pi) $$  Cadenas de caracteres [Contenido](Contenido) En IPython también pueden usarse cadenas de caracteres (strings). Ellas pueden delimitarse usando comillas simples o dobles.<jupyter_code>'hola mundo'  # comillas simples
"hola mundo"  # comillas dobles
'--"--'  # uso alternado de comillas. IPython entiende que se usa la comilla simples para delimitar el string.
"--'--"
'--\'--'  # En estos dos casos se requiere usar el `\` para indicar que la comilla intermedia no es el delimitador.
"--\"--"<jupyter_output><empty_output><jupyter_text>El caracter de escape `\n` indica retorno-de-carro o nueva-linea.<jupyter_code>s = 'Primera linea.\nsegunda linea.'  
s
print(s)  # se debe usar la función print para imprimir con formato.
print(r'Primera linea.\nsegunda linea.')  # note la r antes de la comilla inicial
print(f'Primera linea.\nsegunda linea.')  # note la f antes de la comilla inicial
"""
  Los strings de varias lineas pueden
  escribirse delimitándolos tres comillas 
  dobles y son usados corrientemente como
  comentarios
"""
print(""" 
  Los strings de varias lineas pueden
  escribirse delimitándolos tres comillas 
  dobles y son usados corrientemente como
  comentarios
""")
3 * 'abc ' + '012'  # los strings usan `*` para indicar repetición y `+` para indicar concatenación.
'abc ' * 3 + '012'
'Py' 'thon'   # note que acá se ignoran los espacios entre las comillas interiores
# los strings pueden escribirse en varias líneas delimitandolos por paréntesis.
text = ('Linea 1 '
        'Linea 2 '
        'Linea 3')

print(text)
# borra los caracteres '-' de la cadena de texto
'h-o-l-a- -m-u-n-d-o'.replace('-', '')
# cambia los '-'  por '='
'h-o-l-a- -m-u-n-d-o'.replace('-', '=')
# convierte a mayúsculas
'hola mundo'.upper()
# convierte a minúsculas
'HOLA MUNDO'.lower()
'hola mundo'.capitalize()
'Hola Mundo Cruel'.swapcase()
'hola mundo cruel'.title()
'hola mundo'.center(20, '-')
'hola mundo'.ljust(20, '-')
'hola mundo'.rjust(20, '-')
'abcdeabcdeabcde'.count('ab')
'abcdeabcdeabcde'.find('cd') # posicion de la primera aparación de la cadena 'cd'
'abc123'.isalnum() # alfanumérico?
'()#@'.isalnum() # alfanumérico?
'abc'.isalpha() # alfabético?
'1234'.isdigit()
'1.234'.isdigit()
'1.234'.isnumeric()
'1,2,3,4,5'.partition(',')
'1,2,3,4,5'.rsplit(',')
'hola\nmundo\ncruel'.splitlines()
# concatenación de strings
x = 'foo'
y = 'bar'
xy = x + y              # Ok
x += 'ooo'              # Mal
x = ''.join([x, 'ooo']) # Alternativa<jupyter_output><empty_output><jupyter_text>En Python, los strings son vectores de caracteres; el primer caracter ocupa la posición 0, el segundo la 1 y así sucesivamente. Los índices negativos (iniciando en `-1`) se usan para indicar la posición contando desde atrás. Poe ejemplo:       +---+---+---+---+---+---+     | P | y | t | h | o | n |     +---+---+---+---+---+---+     0   1   2   3   4   5       -6  -5  -4  -3  -2  -1<jupyter_code>word = 'Python'
word[0]    # caracter en la posición 0
word[5]    # caracter en la posición 5
word[-1]   # último caracter
word[-2]   # antepenúltimo caracter
word[-6]   # primer caracter 
word[0:2]  # el operador `:` se usa para indicar rangos
word[:2]   # ':2' indica desde el principio hasta la posición 2 (sin incluirla)
word[2:5]
word[2:]   # desde la posición 2 hasta el final
word[:2] + word[2:]  
word[:4] + word[4:]
word[-2:]  # desde la posición -2 hasta el final, o sea, los últimos dos caracteres.
word[:]    # desde el primero hasta el último caracter.
s = 'abcde'  # la función len calcula la longitud de una cadena de caracteres.
len(s)<jupyter_output><empty_output><jupyter_text>**Ejercicio.** Convierta las letras en las posiciones 3, 6, ... de la cadena `'abcdefghijklm'` en mayúsculas.  Listas [Contenido](Contenido) Las listas son una de las principales estructuras para almacenar información en Python. En esta primera parte se presentan los elementos más básicos sobre el manejo de listas. Una revisión más detallada es presentada en este mismo documento más adelante.<jupyter_code>squares = [1, 4, 9, 16, 25]  # las listas se crean delimitando sus elementos entre [ y ]
squares
squares[0]  # Sus elementos se indexan desde cero al igual que en los strings
squares[-1] # también funcionan los índices negativos.
squares[-3:]  # desde la posición -3 hasta el final
squares[:]  # desde el primer hasta el último elemento.
squares + [36, 49, 64, 81, 100]  # concatenacion de listas usando el operador +
cubes = [1, 8, 27, 65, 125]  # lista de cubos con un elemento malo
4 ** 3  # el cubo de 4 es 64, no 65!
cubes[3] = 64  # se reemplaza el valor erróneo
cubes
cubes.append(216)     # se agrega el cubo de 6 al final de la lista.
cubes.append(7 ** 3)  # y nuevamente se agrega el cubo de 7 al final
cubes
letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] 
letters
letters[2:5] = ['C', 'D', 'E']  # se puede reemplazar un rango de posiciones 
letters
letters[2:5] = []  # ahora se remueven.
letters
letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] 
letters
letters[0:7:2] # cada 2
letters[0:7:2] = ['A', 'C', 'E', 'G']
letters
letters[:] = []  # borrado del contenido de la lista
letters
letters = ['a', 'b', 'c', 'd'] # la función len retorna la longitud de la lista
len(letters)
a = ['a', 'b', 'c'] # los elementos de las listas pueden ser de cualquier tipo.
n = [1, 2, 3]
x = [a, n]          # x es una lista de listas
x
x[0]  # el primer elemento de x
x[0][1]  # el elemento en la posición 1 de la primera lista
x[1]  # el segundo elemento de x
x[1][2] # el elemento en la posición 2 de la segunda lista<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13125681735547207, 'fraction_numerical': 0.02860259362501515, 'mean_word_length': 4.013365735115431, 'pattern_counts': {'":': 0, '<': 37, '<?xml version=': 0, '>': 39, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '103848', 'license': 'MIT', 'n_tokens_mistral': 3231, 'n_tokens_neox': 3141, 'n_words': 1010, 'path': 'P01-uso-interactivo.ipynb', 'repo_name': 'dazulu4/sura-dojo-ml', 'size': '8251'}