Python para todos

EDICION BETA

MISHELL YAGUAL MENDOZA

 “Sé el profesor que siempre quisiste tener”

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:

%s Para presentar strings

%d Para presentar int
%.nf Para presentar decimales, n denota
hasta cuantos decimales se van a
presentar
PÁGINA 4
PÁGINA 5
INDEXACIÓN
Toda cadena de caracteres puede indexarse, es decir, podemos acceder a cada
carácter por medio de un índice que representa la posición en la que se encuentre.
Tomemos por ejemplo la siguiente cadena: ENCICLOPEDIA

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

Toda cadena de caracteres tiene índices positivos (celeste) y negativos (verdes).

Queda a razonamiento del usuario aprovecharlos.

Acceder a un carácter
Dada la cadena ENCICLOPEDIA en la variable palabra:

palabra= “Enciclopedia”

Característica primordial de los strings: Inmutabilidad

Al decir que un string es inmutable, quiere decir que no puede ser modificado
directamente. Por ejemplo:

palabra[0]=”S”

En este caso, se está intentando cambiar el valor de palabra[0] que originalmente,

es “E”, por “S”. Lo cual, python no permite por el asunto de inmutabilidad.

El concepto de inmutabilidad es sencillo de entender, si al mismo tiempo leemos

sobre la referencia. Hay veces que, creemos que estamos violando el asunto de
inmutabilidad, sin embargo, lo que generalmente estamos haciendo es cambiar la
referencia. Para el ejemplo presentado anteriormente, la inmutabilidad se presenta
puesto que palabra[0] tiene ya asignado (sin opción a cambios) debido a palabra
quien almacena “ENCICLOPEDIA” y en sí, palabra[0] en un string, no es una

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.

Básicamente, hacer slicing tiene la siguiente estructura:

Variable[inicio:final:salto]

Donde:

 Inicio: número en donde comienza el corte. Si no se lo escribe, python

asume que es 0
 Final: número en donde termina el corte pero, no se lo incluye. Es decir, si
Final es 9, el corte llega hasta la posición 8. Pero, si no se escribe un número
en Final, Python llegará hasta el fin del string.
 Salto: número que controla cada cuanto se hace el corte. Este es opcional.
Usando palabra=”ENCICLOPEDIA” nuevamente

PÁGINA 7
FUNCIONES NO BOOLEANAS DE STRINGS
n=len(m) Retorna un int con la cantidad de caracteres
que tiene m

s=max(m) Retorna el carácter mayor de m. Sea que m

sea un string de números o letras.

s=min(m) Retorna el carácter menor de m. Sea que m

sea un string de números o letras.

s=m.capitalize() Retorna m con la primera letra en mayúscula

s=m.upper() Retorna m en mayúsculas

s=m.lower() Retorna m en minúsculas

n=m.count(“subs”, “start”, “end”) Retorna las veces que está el carácter o

subcadena “subs”. El “start” y “end” son para
hacer slicing y contar desde una región en
específico.

n=m.find(“subs”, “start”, “end”) Retorna el ìndice de “subs” si lo encuentra en

m. De lo contrario, retorna –1. El “start” y
“end” son para hacer slicing y buscar desde
una región en específico.

n=m.index(“subs”) Retorna el índice de la primera aparición de

“subs” en m

s=m.replace(“lo que se va a Retorna m con el reemplazo que se especificó

reemplazar”, “con lo que voy a
reemplazar”)

PÁGINA 8
join() y split()
Este par de funciones nos permite unir y separar una cadena de caracteres
respectivamente.

Sintaxis:

 pegatina.Join(iterable): Entiéndase como pegatina, un carácter por el cual

van a unirse los elementos de iterable (objeto que se puede recorrer uno a
uno). Hasta ahora, solo conocemos como iterables a los strings y a las listas.
 cadena.split(pegatina): Para este caso, pegatina será el carácter por el cual
se van a separar cada uno de los elementos de Cadena. Esta función retorna
una lista.

Veamos a continuación un ejemplo en pycharm con todo lo hablado hasta

ahora:

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.

m.startswith(“caracter”) Pregunta si m comienza con “caracter”

m.endswith(“caracter”) Pregunta si m termina con “caracter”
m.isalnum() Pregunta si m contiene letras y
números sin espacios.
m.isalpha() Pregunta si m contiene solo y
únicamente letras.
m.isdigit() Pregunta si m contiene solo y
únicamente números.
m.islower() Pregunta si m está en minúscula.
m.isupper() Pregunta si m está en mayúscula.
m.isspace() Pregunta si m contiene espacios.
m.istitle() Pregunta si el primer carácter de m está
en mayúscula.

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.

Recordemos que, hacer slicing tiene la siguiente estructura:

Variable[inicio:final:salto]

Donde:

 Inicio: número en donde comienza el corte. Si no se lo escribe, python

asume que es 0
 Final: número en donde termina el corte, pero, no se lo incluye. Es decir, si
Final es 9, el corte llega hasta la posición 8. Pero, si no se escribe un número
en Final, Python llegará hasta el fin de la lista.
 Salto: número que controla cada cuanto se hace el corte. Este es opcional.

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.

n=len(L) Retorna la cantidad de elementos que

tiene L
n=sum(L) Retorna la suma de todos los
elementos que tiene L
e=min(L) Retorna el elemento menor en L. Si L
contiene strings o números, busca al
menor de acuerdo al orden numérico o
alfabético.
e=max(L) Retorna el elemento mayor en L. Si L
contiene strings o números, busca al
mayor de acuerdo al orden numérico o
alfabético.
M=sorted(L,reverse=True/False) Retorna L ordenada de menor a mayor
(cuando reverse=False) o de mayor a
menor (cuando reverse=True). Si L
tiene números o letras, los ordena
numéricamente o alfabéticamente.
n=L.count(elemento) Retorna cuantas veces aparece
elemento en L
i=L.index(elemento) Retorna el índice de la primera
aparición de elemento en L
M=L.copy() Saca copia a la lista L

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:

 Antes de aplicar alguna de estas funciones, pensar si no vamos a necesitar la

lista tal y como nos la presentan para trabajar. De necesitarse que se
mantenga “en modo original”, optemos por sacarle una copia o si se puede,
usar las funciones que retornan valores, ya que estas no cambian la lista
original sino, que crean una copia, hacen lo que tienen que hacer y el
resultado se puede asignar a una variable.
 Como estas funciones modifican “en el mismo sitio” no deben ser
asignadas a ninguna variable.

L.append(elemento) Agrega elemento a la lista L

L.insert(n,elemento) Agrega elemento en la
posición n a la lista L
L.remove(elemento) Elimina la primera aparición
de elemento en L
L.sort(reverse=True/False) Ordenada de a L menor a
mayor (cuando reverse=False)
o de mayor a menor (cuando
reverse=True). Si L tiene
números o letras, los ordena
numéricamente o
alfabéticamente.
L.reverse() Invierte el orden en el que
estaba L
L.clear() Borra el contenido de L

PÁGINA 20
PÁGINA 21
ESTRUCTURAS DE CONTROL
Tenemos dos tipos de estructuras de control:

 Condicionales: if- if else- if elif else

 Iterativas: for – while

ESTRUCTURAS DE CONTROL CONDICIONALES

Permiten evaluar condiciones y ejecutar acciones (instrucciones) dependiendo si las
condiciones se cumplen o no.

1. If: instrucciónA se ejecuta si condición es True. Si no, se ejecuta instrucciónB.

2. If-else: instrucciónA se ejecuta si condición es True. Caso contrario, se
ejecuta instrucciónB.
3. If-elif-else: instrucción A se ejecuta si condición es True. Caso contrario, si
condición2 es True, se ejecuta instrucciónB. Caso contrario, se ejecuta
instrucciónC.

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.

 La línea 1 solo se ejecuta si condición1 es True. De no serlo, pasa a la línea 9

 Si condición1 es True, se ejecuta instrucciónA y la estructura de control
condicional ya que pertenece al mismo bloque de instrucciones. Cuando
termine de ejecutarse, pasa a la línea 9.

PÁGINA 23
ESTRUCTURAS DE CONTROL ITERATIVAS
Son utilizadas para ejecutar las veces que se requiera un determinado bloque de
instrucciones.

Tenemos dos estructuras de control iterativas:

 For: Utilizado cuando se conoce el número de veces que debe ejecutarse un

bloque de instrucciones.
Sintaxis:
for variable in elemento_iterable:
bloqueDeInstrucciones
.
.
.

 While: Utilizado cuando queremos repetir un bloque de instrucciones

mientras se cumple una condición.
Sintaxis:
while condición:

bloqueDeInstrucciones

La función range()
Sintaxis:

range(a,b,c)

Donde:

 a: valor con el que inicia el rango de números. Al omitirlo, toma el valor de

cero por defecto.
 b: valor hasta donde se genera el rango de números. Este NO aparecer en el
rango generado.
 c: valor opcional; de cuanto en cuanto va el rango (pasando 1, pasando 2,
etc.)
range() se considera un tipo de dato. Si queremos ver los números que generó como
tal, debe pasarse a lista, y eso se consigue con list()

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.

3. Recuerde que for necesita de un elemento iterable para ejecutarse. Sino,

nunca podrá accederse al bloque de instrucciones que esté dentro.

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.

2. El número de iteraciones no está definido en un while. Siempre debemos

definir/inicializar una variable que se convertirá en la variable de control.

PÁGINA 27
3. Bucles infinitos: Ocurre cuando la condición siempre se cumple y por
ende, el bucle nunca dejará de ejecutarse.
Causas:

 Se olvidó de modificar la variable de control.

 Se programó una condición que se cumple siempre.

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:

def nombreDeLaFuncion (argumentos):

bloqueDeInstrucciones

return

¿LAS FUNCIONES SIEMPRE TIENE QUE RETORNAR?

El uso principal de las funciones es que, luego de ejecutar un conjunto de
instrucciones nos devuelvan un valor. Pero, de acuerdo a lo que el usuario necesite
hacer, no es obligación retornar/devolver un valor.

Entonces, ¿Cuándo una función devuelve un valor? Solamente cuando en ella

aparezca la palabra reservada return. Una función puede devolver más de un valor a
la vez y estos pueden ser del mismo tipo o diferentes.

Es lógico que, si la función devuelve un valor, la función al momento de ser llamada,

debe ser asignada a una variable. Si devuelve más de un valor, debe asignarse a más
variables.

Cuando las funciones no retornan ningún valor, por otro lado, NO se las debe asignar
a una variable. Solamente se las debe llamar.

Vamos a observar diferentes formar de implementar una función e ilustraremos todo

lo descrito anteriormente.

FUNCIÓN SIN ARGUMENTOS/PARÁMETROS

Una función sin argumentos es aquella que no necesita de ellos para realizar una
operación específica. Sin embargo, debemos analizar su funcionamiento y el porqué
no debería llevar argumentos ya que, generalmente, una función por lo menos posee
un argumento.

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.

FUNCIÓN QUE DEVUELVE VARIOS VALORES

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.

FUNCIÓN CON PARÁMETROS POR DEFECTO.

Hay casos en donde nuestra función, no necesariamente, debe recibir los
parámetros definidos porque se le asigna un valor de inicialización. Un parámetro
por defecto, es aquel que se define dentro de los ()’s y su valor no cambia a menos
que se llame a dicha variable que contiene el valor default.

PÁGINA 32
NUMPY (#VamoADarleSinMiedo)
Numpy es una librería de Python que contiene objetos y funciones especializadas
para computación científica.

FORMAS DE IMPORTAR LA LIBRERÍA

1. import numpy
Con esta importación, para acceder a las funciones de la librería debe
escribirse de la siguiente manera:

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.

Creación de arreglos (usando import numpy as np)

 Arreglos de 1D: Conocidos como vectores.

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.

 np.arange(start,stop,step,dtype=TipoDeDato): análoga a la función range(),

crea un arreglo unidimensional de una secuencia de números, por defecto, de tipo
float. Con dtype, puede cambiarse.

 np.ones((x,y)) | np.zeros((x,y)): Crea arreglos rellenos de ones/unos o de

zeros/ceros. Si se mandan x e y será un arreglo en 2D. Si solo se manda x será un
arreglo en 1D

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: Si el Num.Inicial es negativo, debe incluirlo con signo en la fórmula

Importante x2: random.rand(n) sólo puede generar un arreglo en 1D. Más adelante,
se verá como cambiarlo a 2D

 np.random.randint(start,stop,size=(x,y)): Genera un arreglo de tamaño (x,y)

con números enteros positivos entre el start y el stop. (Sin incluir al stop)
PÁGINA 35
Algunas propiedades de los arreglos
 arreglo.shape: Devuelve una tupla con la cantidad de filas y columnas que
tiene el arreglo.
 arreglo.size: Devuelve un int con el total de elemento que contiene el
arreglo.

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