Documentos de Académico
Documentos de Profesional
Documentos de Cultura
EDICION BETA
Porque a mí me faltó para esta materia y, no quiero que les falte a ustedes.
PÁGINA 1
Contenido
Strings .............................................................................................................................................................. 4
Concatenación y multiplicación ............................................................................................................... 4
Formatos de presentación ......................................................................................................................... 4
Indexación ................................................................................................................................................... 6
Acceder a un carácter ............................................................................................................................. 6
Característica primordial de los strings: Inmutabilidad ...................................................................... 6
Slicing........................................................................................................................................................7
Funciones NO booleanas de strings ......................................................................................................... 8
join() y split() .......................................................................................................................................... 9
Funciones booleanas para los strings ...................................................................................................... 12
Listas ............................................................................................................................................................... 13
Concatenación ........................................................................................................................................... 14
Replicar ....................................................................................................................................................... 14
Indexación .................................................................................................................................................. 15
Slicing ......................................................................................................................................................... 16
Funciones (que retornan algún valor) útiles para trabajar con listas .................................................. 18
Funciones “in situ” para trabajar con listas. .......................................................................................... 20
ESTRUCTURAS DE CONTROL ...................................................................................................................22
Estructuras de control condicionales ......................................................................................................22
Anidaciones con if .................................................................................................................................. 23
Estructuras de control iterativas ............................................................................................................. 24
La función range() .................................................................................................................................24
Acerca de for ........................................................................................................................................... 25
Acerca de while ....................................................................................................................................... 27
Funciones ...................................................................................................................................................... 29
¿Las funciones siempre tiene que retornar? .......................................................................................... 29
Función sin argumentos/parámetros ..................................................................................................... 29
Función con parámetros ........................................................................................................................... 31
Función que devuelve varios valores ....................................................................................................... 31
Función con n-parámetros ....................................................................................................................... 32
Función con parámetros por defecto. ..................................................................................................... 32
NUMPY (#VamoADarleSinMiedo) .......................................................................................................... 33
PÁGINA 2
Formas de importar la librería ............................................................................................................ 33
Arreglos ..................................................................................................................................................... 33
Creación de arreglos (usando import numpy as np) ........................................................................... 33
Algunas propiedades de los arreglos .....................................................................................................36
Otras funciones ......................................................................................................................................36
Operaciones matemáticas .....................................................................................................................36
Funciones para operar entre vectores. .................................................................................................. 37
PÁGINA 3
Strings
Vamos a ver lo más relevante de este tipo de datos.
CONCATENACIÓN Y MULTIPLICACIÓN
Podemos juntar strings mediante el operador “+” y podemos reproducir una cadena
las n veces que queramos con “*”
FORMATOS DE PRESENTACIÓN
Debe respetarse el orden en el que son llamados en la siguiente sintaxis, sino, el
programa se caerá.
print(“Texto relevante %s texto relevante %d texto relevante
%.nf” %(varDeString,varDeInt,varDeFloat))
Donde:
E N C I C L O P E D I A
0 1 2 3 4 5 6 7 8 9 10 11
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
Acceder a un carácter
Dada la cadena ENCICLOPEDIA en la variable palabra:
palabra= “Enciclopedia”
palabra[0]=”S”
PÁGINA 6
variable desde el punto de vista del programador a la que se pueda cambiar la
referencia.
Slicing
Dicho es español como “corte o rebanada”. Se trata simplemente de la extracción de
una subcadena, a partir de una cadena.
Variable[inicio:final:salto]
Donde:
PÁGINA 7
FUNCIONES NO BOOLEANAS DE STRINGS
n=len(m) Retorna un int con la cantidad de caracteres
que tiene m
PÁGINA 8
join() y split()
Este par de funciones nos permite unir y separar una cadena de caracteres
respectivamente.
Sintaxis:
PÁGINA 9
PÁGINA 10
PÁGINA 11
FUNCIONES BOOLEANAS PARA LOS STRINGS
Estas funciones solo retornan True de ser cierta la condición o False, cuando la
condición es falsa. Al retornar este tipo de valores, para usarlas en estructuras de
control, no hay que hacer igualaciones a True o False.
PÁGINA 12
Listas
Una lista es un elemento iterable mutable el cual, puede contener tantos elementos
del mismo tipo o de forma surtida. Todo eso y más, delimitado por corchetes y cada
uno de los elementos separados por comas.
Vamos a darnos cuenta, a partir de aquí, que las listas comparten algunas
características con los strings.
PÁGINA 13
CONCATENACIÓN
Las listas pueden concatenarse unas con otras con el operador “+”
Más adelante veremos como agregar elementos a una lista sin usar la
concatenación.
REPLICAR
Con las listas también podemos usar el operador *, quien reproduce un n número
de veces lo que esté dentro de una lista.
PÁGINA 14
INDEXACIÓN
Cada elemento dentro de la lista, se identifica por su posición en la lista. Tenemos
índices positivos (celeste) y negativos (rosado)
Tomemos de referencia la lista: consonantes=[“M”, “C”, “X”, “H”, “T”, “K”, “P”]
M C X H T K P
0 1 2 3 4 5 6
-7 -6 -5 -4 -3 -2 -1
Por mutabilidad, a diferencia de los strings, pueden accederse y cambiar algún elemento de la lista.
Acceder a elementos por medio de los índices puede resultar en error si, el índice está fuera del
rango de la lista.
PÁGINA 15
SLICING
De una lista, se puede obtener una cierta porción por medio de slicing, al igual que
los strings.
Variable[inicio:final:salto]
Donde:
PÁGINA 16
Por la mutabilidad de las listas, ya vimos que es posible cambiar sus elementos con
solo acceder mediante una posición. De igual manera, al hacer slicing, es decir,
coger una cierta sección/sublista, también pueden hacerse cambios.
Algo muy interesante es que, al hacer slicing, Python siempre acepta valores fuera
del rango de la lista. Porque su razonamiento lo interpreta como los valores
extremos que podría tener la lista.
PÁGINA 17
FUNCIONES (QUE RETORNAN ALGÚN VALOR) ÚTILES PARA TRABAJAR CON LISTAS
Como estas funciones retornan valores, si necesitamos dicho valor para después,
debe guardarse en una variable. De no hacerlo, se pierde el valor.
PÁGINA 18
PÁGINA 19
FUNCIONES “IN SITU” PARA TRABAJAR CON LISTAS.
“In situ” leído también como “En el mismo sitio” son funciones que no retornan
ningún valor, sino que modifican directamente al elemento al que se está haciendo
referencia. Dado este comportamiento debemos considerar 2 cosas:
PÁGINA 20
PÁGINA 21
ESTRUCTURAS DE CONTROL
Tenemos dos tipos de estructuras de control:
PÁGINA 22
Anidaciones con if
Puede presentarse la situación donde se requiera evaluar otra condición luego de
haber evaluado otra previamente. Para estos casos, se puede usar una estructura
anidada.
PÁGINA 23
ESTRUCTURAS DE CONTROL ITERATIVAS
Son utilizadas para ejecutar las veces que se requiera un determinado bloque de
instrucciones.
bloqueDeInstrucciones
La función range()
Sintaxis:
range(a,b,c)
Donde:
PÁGINA 24
Acerca de for
1. El bloque de instrucciones que esté dentro de este for, se ejecuta tantas
veces como elementos haya por recorrer.
PÁGINA 25
2. La variable que contiene el for, puede usarse para acceder a los elementos
del iterable puesto que, en cada vuelta, toma el elemento. O podemos usar
range() para generar un rango de números que corresponden a cada índice
que contiene una lista. A veces no es necesario, a veces es indispensable
usarla. El ejemplo anterior no es necesario usar elem. Veamos un ejemplo
en donde se la necesite.
PÁGINA 26
Acerca de while
1. El cuerpo del bucle se ejecuta mientras se cumpla la condición
*La denominada variable de control, debe modificarse dentro del bucle para
evitar los bucles infinitos.
PÁGINA 27
3. Bucles infinitos: Ocurre cuando la condición siempre se cumple y por
ende, el bucle nunca dejará de ejecutarse.
Causas:
PÁGINA 28
Funciones
Las funciones son estructuras que nos permiten reducir y reutilizar de forma rápida
y eficiente un enorme grupo de líneas de código.
Sintaxis:
bloqueDeInstrucciones
return
Cuando las funciones no retornan ningún valor, por otro lado, NO se las debe asignar
a una variable. Solamente se las debe llamar.
PÁGINA 29
Pero esto no tiene mucho sentido. Se debió haber puesto las variables a y b como
parámetros y no llamarlas fuera de la función. Sin embargo, una función sin
argumentos puede ser muy útil cuando solo queremos presentar menús, submenús,
y no abombar de tantas líneas de código un programa principal.
PÁGINA 30
FUNCIÓN CON PARÁMETROS
Una función con parámetros es aquella que, de acuerdo a los parámetros definidos,
procede a ejecutar un bloque de instrucciones que involucra a dichos parámetros.
PÁGINA 31
FUNCIÓN CON N-PARÁMETROS
Una función con n-parámetros es aquella que dentro de los ()’s tiene un *nombre. Python entiende
esto como una aceptación de valores sin límite alguno. Para una mejor comprensión, imagine que
*convierte en una especie de lista a nombre. Entonces, dependiendo de cuando valores mandemos a
la función, cada uno de ellos se guardarán en nombre.
PÁGINA 32
NUMPY (#VamoADarleSinMiedo)
Numpy es una librería de Python que contiene objetos y funciones especializadas
para computación científica.
arreglo=numpy.array([1,2,3])
2. from numpy import *
Por otro lado, este import hace que todas las funciones que tenga la librería
estén presentes en el .py. A diferencia del primero, solo basta con escribir el
nombre de la función.
arreglo=array([1,2,3])
3. import numpy as np
Este import es parecido al primero pero, para acceder a cada función de la
librería debe hacerse referencia al alias de la librería. En este caso, es np.
arreglo=np.array([1,2,3])
ARREGLOS
Un arreglo en numpy, es una colección de elementos del mismo tipo, que pueden tener una o más
dimensiones. Dos característica que comparten con las listas, es que también puede accederse a los
elementos por medio de índices y hacer slicings.
variable=np.array(lista, tipoDeDato)
PÁGINA 33
Importante:
“lista” hace referencia a una variable que almacena una lista o, puede
insertarse una lista directamente
“tipoDeDato” define cómo se van a tratar los elementos al crear el arreglo.
Este parámetro es opcional.
PÁGINA 34
np.random: Numpy incluye en su librería, la librería random, por lo cual podemos
rellenar arreglos de forma aleatoria.
np.random.rand(n): Genera un arreglo aleatorio de tamaño n con
números reales entre 0 y 1 (sin incluir el 1) Es decir, podríamos tener un
arreglo de números positivos y negativos.
Entonces, ¿Cómo hacer un arreglo de números que vaya entre -5 y 5? ¿O que
vaya de 3 hasta 10?
np.random.rand(n)*((Num.Final – Num.Inicial)+Num.Inicial)
Importante x2: random.rand(n) sólo puede generar un arreglo en 1D. Más adelante,
se verá como cambiarlo a 2D
Otras funciones
arreglo.toCopy(): Copia un arreglo.
arreglo.toList(): Convierte un arreglo a lista.
Operaciones matemáticas
En numpy, se pueden hacer operaciones de suma, resta, multiplicación, división, potenciación y
módulo. Cada una de estas operaciones se hace elemento a elemento. Es decir, por ejemplo, el
elemento en la posición 1 en el vector a, se sumara con el elemento en la posición 1 en el vector b.
PÁGINA 36
Funciones para operar entre vectores.
arreglo.sum(): Retorna la suma de todos los elementos del arreglo.
arreglo.prod(): Retorna la multiplicación de todos los elementos del arreglo.
arreglo.mean():Retorna el promedio de todos los elementos del arreglo.
arreglo.var():Retorna la varianza de todos los elementos del arreglo.
arreglo.argmax(): Retorna el índice del mayor valor.
arreglo.argmin(): Retorna el índice del menor valor.
arreglo.max(): Retorna el elemento mayor, sea numérico o caracter.
arreglo.min(): Retorna el elemento menor, sea numérico o caracter.
arreglo.sort(): Ordena de menor a mayor el arreglo.
PÁGINA 37