Tutorial de Python
¡Buenvenid@ la introduccion de programacion en Python de ~sdemingo!
Python es un lenguaje de programacion de alto nivel cuya filosofia hace hincapie en la legibilidad de su codigo fuente. Es sencillo de aprender por lo que es ideal para aprender a programar en un pubnix.
Python fue creado por Guido van Rossum a finales de los anos 80 en un centro de investigacion de Paises Bajos. Su nombre viene del grupo de comico britanico Monty Python.
Introduccion
Un programa no es mas que un conjunto de instrucciones secuenciales, que el ordenador ejecutara, desde la primera a la ultima.
Para escribir programas la herramienta basica es un editor de texto, donde podras escribir las instrucciones que quieres que formen parte de tu programa. Tu programa, ademas de instrucciones manejara tambien datos, que podran ser datos internos del propio programa o bien introducidos por el usuario.
Python es un lenguaje de programacion interpretado. Esto quiere decir que el programa que tu escribiras en un fichero de texto no sera compilado por ningun programa externo sino que sera leido y procesado por un interprete de Python. Para que el sistema ejecute las instrucciones de tu programa no vale con indicarle que quieres ejecutarlo. A quien realmente ejecutas es al interprete de Python, y es a el, a quien le dices que lea tu programa.
1. Primeros Pasos
Utiliza tu editor de textos
favorito para crear el fichero hola.py
.
Encontraras tambien los ficheros de codigo fuente de este tutorial en la Biblioteca de Programas.
Por ejemplo, introduce en tu terminal:
nano hola.py
Incorpora al fichero la siguiente instruccion:
print ("hola mundo cruel!")
Guarda los cambios (Ctrl+o) y sal del editor GNU Nano (Ctrl+x).
Para ejecutar un programa escrito Python, debes lanzar el interprete de Python e indicarle como argumento el nombre de fichero de tu programa. En este ejemplo podras hacerlo de esta forma:
python3 hola.py
El sistema compartido interpretara inmediatamente lo programado y te devolvera el resultado:
hola mundo cruel!
¡Has ejecutado tu primer programa de Python con exito! No pierdas mas tiempo y compartelo en nuestro gab!:
gab -m "Soy ~$USER y programe con Python gracias al tutorial de ~sdemingo!"
2. Variables
Una variable es un dato que se almacena en la memoria de nuestro equipo junto a una etiqueta o identificador que usaremos para recuperarlo.
El dato que guardaremos en memoria y al que asignaremos un identificador puede ser de multiples tipos (enteros, caracteres, etc.) y, tal y como veremos. Segun el tipo que sea puede ocupar mas o menos memoria.
Una vez que asignemos el dato a este identificador, al que llamaremos a partir de ahora nombre, siempre nos referiremos a este dato en nuestro codigo a traves del mismo. Por ejemplo, vamos a guardar dos datos numericos en sendas variables y luego mostraremos el resultado de su suma:
variable1 = 8
variable2 = 9
print (variable1 + variable2)
Introduce dicho codigo en un fichero llamado
variables.py
y ejecutalo.
python3 variables.py
En tu terminal deberias obtener el resultado de esta operacion aritmetica de suma:
17
Como se ve, una vez que asignas los valores numericos a sus respectivos nombres, podras operar con dichos valores utilizando dichos nombres.
Tipos de datos
En Python podemos manejar datos de muchos tipos diferentes pero, por ahora, vamos a centrarnos solo en los llamados tipos basicos o primitivos. Estos son:
* **Enteros**: Representan numeros enteros (sin parte decimal).
* **Reales**: Representan numeros con parte decimal. Requieren indicar ambas partes, la decimal y la entera separada por el caracter ..
* **Booleanos**: Representan los dos tipos de valores logicos propios de la logica booleana (//True// y //False//).
* **Cadenas de caracteres** (o "strings"): Como su nombre indica son cadenas de caracteres alfanumericos. Sus valores literales deben encerrarse entre comillas.
Mas adelante trabajaremos ademas con algun otro tipo de dato mas. Tipos algo mas complejos como son las listas, las tuplas y los diccionarios.
A continuacion veamos un ejemplo de creacion de una variable de cada uno de los tipos descritos arriba.
varEntera=784
varReal=345.23
varBooleana=False
varCadena="esto es una cadena"
Para operar con variables es obligatorio que estas pertenezcan al mismo tipo. Para ello a menudo deberas realizar conversiones de tipo. Para convertir una variable de un tipo en otro utiliza el nombre del tipo y entre parentesis el nombre de la variable que queremos convertir.
Por ejemplo, imagina que hemos declarado una variable de tipo
string con la cadena de caracteres "834
" y la
queremos sumar un valor numerico de 9
.
entero=9
cadena="834"
print (entero + cadena)
Si ejecutas el codigo anterior el interprete te devolvera un error a tu terminal, que termina con el texto:
TypeError: unsupported operand type(s) for +: 'int' and 'str'
El interprete nos esta indicando que no podemos operar usando el
operador aritmetico de suma con valores de diferente tipo. Hemos de
convertir la variable entero a cadena de caracteres o bien convertir la
variable cadena a un numero entero. Usaremos la primera opcion usando la
expresion str(entero)
para convertir el 9
en
una cadena de caracteres.
entero=9
cadena="834"
print (str(entero) + cadena)
Ejecutamos el codigo anterior y obtenemos:
9834
¿Como? ¡Esa no es la suma que esperabamos! Realmente el codigo
anterior es perfectamente correcto. Al convertir la variable con valor
9
a cadena de caracteres y usar la suma, estamos operando
con dos cadenas de caracteres. Python suma las cadenas de caracteres
concatenando una a la otra, por lo que el resultado es el esperado.
"9" + "834" -> "9834"
Si ahora probamos a la inversa y convertimos la variable
cadena a un valor numerico veremos que el resultado es la suma
aritmetica que esperabamos inicialmente, esto es el valor numerico
843
.
entero=9
cadena="834"
print (entero + int(cadena))
Operadores
Los operadores permiten operar con variables. Normalmente usaremos otras variables para guardar el resultado de estas operaciones.
Para realizar operaciones aritmeticas con numeros usaremos los
operadores clasicos: +
, -
, *
y
/
. El operador %
nos servira para calcular
resto de una division. En relacion a la division hemos de tener en
cuenta tambien que la operacion de division o /
siempre nos
retornara un valor de tipo real, jamas un entero.
Para comparar valores primitivos podemos usar los operadores:
==
: Indica si los valores son iguales!=
: Indica si los valores son diferentes
Para realizar comparaciones entre los valores de dos variables,
debemos usar los operadores comunes
>
,>=
,<
,<=
,
se leen respectivamente mayor, mayor o igual,
menor y menor o igual. Estos nos devolveran un valor
boolean.
Revisa el fichero operadores.py
, ejecutalo y analiza su
resultado para entender los operadores en un caso practico.
El tipo string
Las cadenas de caracteres o strings forman parte de un tipo especial en Python. Son un objeto. Python posee tipos objetos predefinidos dentro de el y permite tambien que definamos nuestros propios objetos (lo aprenderemos mas adelante).
En Python, para operar con un objeto podemos usar funciones asociadas con el y que podremos invocar usando el// nombre del objeto// en si mismo seguido de la funcion que queremos invocar sobre el.
Para entender vamos a imaginarnos que tenemos una cadena definida en nuestro codigo y queremos convertirla toda entera a mayusculas. Para conseguir esto usaremos la funcion upper(). La invocaremos sobre la variable de tipo string y guardaremos el resultado en una segunda variable:
cadena1="Esto es una cadena"
cadena2 = cadena.upper()
print (cadena1)
print (cadena2)
Existen muchos metodos para trabajar con string que podemos invocar sobre ellos. Os pongo a continuacion una lista con los principales.
count()
: Devuelve el numero de caracteresendswith(sufijo)
: Devuelvetrue
si la cadena termina por ese sufijoindex(cadena)
: Devuelve la posicion de la primera aparicion de la cadena buscadalower()
: Convierte la cadena a minusculasreplace(cad1, cad2)
: Remplaza las apariciones de la cadenacad1
porcad2
startswith()
: Devuelvetrue
si la cadena comienza por ese prefijostrip(prefijo)
: Devuelve una version recortada de la cadenaupper()
: Convierte la cadena a mayusculas
Pedir datos al usuario
Solicitar al usuario que introduzca datos a traves del teclado es
algo basico para que nuestros programas cobren sentido de utilidad. Esto
podemos hacerlo facilmente usando la instruccion input
.
Junto a la instruccion input
podras adjuntar ademas un
mensaje que indique al usuario que necesita ingresar.
Luego recogeremos el valor introducido en una variable tal y como se muestra en el ejemplo siguiente:
numero = input("Introduce un numero cualquiera: ")
La funcion
input
siempre devuelve una cadena. Si deseas tratar esta variable como otro tipo, evita errores realizando una conversion de tipo como se indico anteriormente.
El siguiente programa solicita un numero al usuario, y le suma otro que el propio programa aportara:
numero = input("Introduce un numero cualquiera: ")
otro = 8
print (int(numero) + otro)
Ejercicios
-
Pide un numero al usuario y calcula el triple mostrandolo por pantalla. Solucion
-
Pide al usuario que te introduzca su nombre y envia un mensaje a la pantalla saludandole. Algo como “Hola Sergio, ¿que tal estas?” Solucion
-
Pide al usuario que te introduzca una frase y cambia todas las apariciones de las letras ‘e’ por ‘E’ y ‘a’ por ‘A’. Solucion
3. Tipos Avanzados
Ademas de los tipos basicos, en Python tenemos tipos mas complejos con los que vamos a poder trabajar. Los tipos “avanzados” que vamos a ver en primer lugar serian:
- Listas
- Tuplas
- Diccionarios
Listas
Una lista de Python es una coleccion de datos que se agrupan todos bajo un mismo identificador o nombre de variable. Estos datos pueden ser del mismo tipo o de tipos diferentes. Por ejemplo, vamos a guardar cinco numeros enteros asociados a una sola variable, en lugar de utilizar una para cada uno de ellos:
numeros = [4,2,23,112,-5]
Una lista puede estar compuesta por datos de diferente tipo. Incluso podria estar compuesta por un dato de tipo lista a su vez:
numerosYmas = [4, -2, "hola", 953, True, "si"]
listaDelistas= [4, -2, [ 9, 8, 2], "ultimo"]
listaVacia = []
En el ejemplo anterior vemos que el tercer elemento de
listaDelistas
es una lista. Para acceder a los
elementos de una lista usaremos el operador []
. Usaremos el
nombre de la lista seguido de dicho operador y entrecorchetamos el
indice de la lista que queremos consultar.
Los indices siempre empiezan en
0
. Si deseas consultar el tercer elemento de una lista hemos de usar el indice2
.
Para imprimir por pantalla el cuarto elemento de
numerosYmas
escribiremos
print(numerosYmas[5])
. En caso de que el indice sea
negativo, el acceso sera contando desde el final de la lista. Esto es
desde la derecha.
Usando un indice de -1
nos llevara al ultimo elemento de
la lista.
El acceso a los miembros de una lista puede ser para su consulta o para su modificacion. Piensa en el siguiente codigo:
print (numerosYmas[5]) // imprime "si"
numerosYmas[5]="no"
print (numerosYmas[5]) // imprime "no"
Para anadir miembros a una lista podemos usar el operador
+
pero hemos de tener en cuenta que los datos de ambos
lados del operador deben ser listas. Vamos a anadir un valor de
2
a la lista numerosYmas
y lo haremos
convirtiendo el 2
en una lista:
numerosYmas = numerosYmas + [2]
Tambien podemos hacer uso del metodo append()
sobre la
variable de tipo lista ejecutando
numerosYmas.append(2)
. El resultado seria similar.
Para eliminar elementos de una lista usaremos la instruccion del seguido del elemento que queremos borrar. Por ejemplo:
numeros = [10, 20, 30, 40]
del numeros[1]
print (numeros) //imprime [10, 30, 40]
De una lista podemos extraer otra usando el operador [:]. Es lo que
se llama rodaja o slice en Ingles. Este operador recibe dos enteros que
indican los indices de inicio y de fin de nuestra rodaja Rodajas de
listas [:]
. El primer indice siempre forma parte de la
rodaja mientras que el ultimo nunca hara. La rodaja termina en el
anterior a este. Si no indicamos el inicio de la rodaja esta toma el
inicio de la lista origen y lo mismo pasa con el final y el segundo
indice.
lista = [10, 20, 30, 40, 50, 60]
print (lista[1:]) // imprime [20, 30, 40, 50, 60]
print (lista[:3]) // imprime [10, 20, 30]
print (lista[1:4]) // imprime [20, 30, 40]
Conocer si un valor esta o no en una lista puede ser muy util. Esto nos lo permite el operador in. Con este operador obtendremos un valor booleano que nos indique si el valor esta o no:
lista = [10, 20, 30, 40, 50, 60]
print (10 in lista) // imprime True
print (80 in lista) // imprime False
Por ultimo, para saber la longitud o numero de miembros de una lista usaremos el metodo len() que invocaremos directamente sobre la variable lista que queramos.
Tuplas
Una tupla en Python es un conjunto de datos que estan agrupados.
A diferencia de una lista, una vez creada una tupla no puede ser modificada. No podras agregarle nuevos elementos ni quitarle uno de los que ya tiene. Tampoco podras modificar el valor de un elemento interno.
Definir una tupla indicando entre parentesis los elementos que esta contiene:
tupla = (8, "hola", -34)
Para acceder a los componentes usaremos el mismo mecanismo que con
las listas, empleando el indice entre corchetes []
:
print (tupla[1]) // imprime "hola"
Diccionarios
Los diccionarios son tambien un tipo de datos que nos permitira agrupar datos sobre una sola variable. Se parecen mucho a las listas pero con una salvedad importante: es posible modificar el indice asociado a cada valor. Mientras que con las listas, cada valor quedaba asociado a un indice de tipo entero, con los diccionarios podemos hacer que este indice sea de otro tipo.
Estos indices se llaman claves.
Es fundamental que una clave no se repita dentro de un mismo diccionario.
Veamos un ejemplo que almacena datos numericos asociados a claves de tipo string:
temperaturas = {"Madrid": 18, "Bilbao": 19, "Sevilla": 22, "Barcelona": 24}
Con la anterior declaracion hemos creado un diccionario denominado
temperaturas
que guarda el valor numerico de una
temperatura media en una ciudad. Como clave del diccionario
hemos usado el nombre de la ciudad en formato de cadena de
caracteres.
Utiliza los corchetes []
tanto para acceder al valor de
una clave como para crear claves nuevas, tal como lo haciamos con las
listas:
print (temperaturas["Sevilla"]) // imprime 22
temperaturas["Leon"] = 14
print (temperaturas["Leon"]) // imprime 14
Para saber si existe un valor asociado a una clave en un diccionario
usaremos el operador in
igual que con las
listas:
print ( "Madrid" in temperaturas) // imprime True
Si deseas crear un diccionario vacio emplea las llaves
{}
sin valores en su interior, siguiendo la sintaxis
dicVacio = {}
.
Ejercicios
- Crea una lista que contenga varios nombres a tu eleccion. Pide al usuario un nombre por teclado y muestra por pantalla si es cierto o no que ese nombre esta en la lista. Solucion
4. Instrucciones de Control
Aprendamos hoy las instrucciones que un@ programador@ puede incluir en su codigo que permitan alterar su flujo secuencial. Las instrucciones de control se agrupan normalmente en dos familias:
-
Instrucciones selectivas: Son aquellas que crean varias ramas o bloques de instrucciones. En cada ejecucion, segun a valores internos del programa, se optara por ejecutar la rama de instrucciones correcta.
-
Instrucciones iterativas: Son aquellas que permiten repetir varias veces un mismo bloque de instrucciones sin necesidad de tener que escribirlo mas que una vez.
Instrucciones Selectivas
If
La principal instruccion selectiva de Python es if
. Esta
instruccion no permite crear una bifurcacion en el recorrido secuencial
de nuestro codigo en base al valor de una expresion booleana (es una
expresion que se debe de evaluar como cierta o falsa).
Veamos un ejemplo sencillo de uso de una instruccion de este tipo:
num = input("Introduce un numero: ")
mul = int(num) * 3
if (mul > 200):
print ("Has introducido un numero muy grande!!")
print (mul)
Lo primero que vemos en el codigo anterior (este codigo esta en el
fichero multi_if.py es que tenemos dos datos numericos: uno que pedimos
por teclado al usuario llamado num
y otro que generamos
nosotros llamado mul
multiplicando el valor de
num
por tres.
Tras esto lo que queremos es evaluar el valor de mul
y
compararlo con 200
. Sea como sea impriremos por pantalla el
valor de mul
pero ademas, si este es mayor que
200
imprimiremos un mensaje de advertencia.
Esto lo hemos conseguido con la instruccion if
. Tras
ella hemos escrito la expresion booleana entre parentesis
()
. Esta expresion usa un operador de comparacion
(>
en este caso) y se evaluara siempre como
True
o False
. Tras la expresion indicamos cual
sera el bloque de instrucciones primario del if
. Este sera
el bloque que se ejecute si la expresion se evalua como cierta o
True
.
Nota sobre la tabulacion: Es importante notar que el bloque de instrucciones que sigue al
if
no esta alineado por la izquierda con este sino que esta desplazado hacia la derecha. En Python muy importante usar esta identacion o tabulacion para separar los bloques de codigo. La ultima instruccion deif
porque no tiene esta tabulacion previa y esta alineada con el resto de instrucciones previas delif
.
else
A la instruccion if
podemos anadirle una rama de codigo
opcional a traves de la instruccion else
. El codigo que se
inicia tras el else
sera ejecutado si la expresion booleana
que acompana al if
se evalua como False
.
Veamos un ejemplo:
num = input("Introduce un numero: ")
mul = int(num) * 3
if (mul > 200):
print ("Has introducido un numero muy grande!!")
else:
print (mul)
Con esta variacion ahora, si el valor de mul
sobrepasa
los 200
solo se mostrara el mensaje de advertencia y no el
valor de la multiplicacion.
Instrucciones iterativas
La otra familia de instrucciones de control de flujo son las iterativas, tambien llamadas comunmente bucles. Estas instrucciones nos permite crear bloques de codigo que se ejecutaran varias veces.
While
La primera de estas instrucciones es while
. Esta
instruccion permite ejecutar el bloque de codigo asociado en base a
verdad o falsedad de una expresion booleana. Veamos un ejemplo:
num = input("Introduce un numero: ")
mul = int(num)
while (mul < 200):
mul = mul * int(num)
print (mul)
print ("Ya hemos acabado")
El codigo anterior toma un numero por teclado y lo va multiplicando
por si mismo. Vemos que la expresion booleana es
(mul < 200)
. Esto significa que cuando el resultado
sobrepase ese numero se saldra de ese bucle y se continuara con el resto
de instrucciones bajo el.
For
Otra instruccion iterativa muy usada en Python es for
.
El bucle for
no se basa en una expresion booleana sino en
pivotar el valor de una variable entre los diferentes valores de una
lista a la que acompana.
Por ejemplo, partimos de una lista llamada animales. Vamos a imprimir por pantalla un mensaje por cada animal de la lista:
animales = ["perros", "gatos", "pajaros", "zorros", "burros"]
for animal in animales:
print ("Me gustan los "+animal)
Tras ejecutar el codigo anterior veremos una salida similar a la que se muestra a continuacion. La variable animal ha ido pivotando su valor entre los valores de la lista siguiendo su orden y valiendo ese valor en cada iteracion o vuelta del bucle. El bucle termina cuando ya no hay mas miembros de la lista sobre los que pivotar.
Me gustan los perros
Me gustan los gatos
Me gustan los pajaros
Me gustan los zorros
Me gustan los burros
¿Que tipos de dato pueden ser recorridos con un bucle
for
? Bien, de los que hemos visto, las colecciones (listas,
tuplas y diccionarios) y las cadenas (entendidas como una coleccion de
caracteres).
Range
Puede sernos util conocer la instruccion range
, que
genera una lista con numeros sobre de un rango. Esta instruccion resulta
una gran companera de for
cuando queremos iterar a traves
de una lista numerica:
for i in range(10,30):
print (i)
Ejercicios
-
Pide al usuario dos numeros e imprime cual de ellos es el mayor. Solucion.
-
Genera una lista de nombres que sigan el siguiente patron: “doc1”,“doc2”,“doc3”, … hasta “doc20”. Solucion
5. Funciones
Las funciones en programacion se utilizan para agrupar bloques de codigo bajo un nombre. Esta tecnica permite a los programadores reutilizar estos bloques siempre que quieran sin necesidad de volver a escribirlos, usando solo el nombre del bloque para referirse a ellos.
def saludo():
nombre = input("Escribe tu nombre: ")
print ("Hola "+nombre+", ¿como estas?")
Por ejemplo, en el recuadro anterior hemos creado una funcion llamada
saludo
que pida al usuario su nombre y le salude. A esto se
le suele llamar declarar una funcion. Tras declararla usando la
palabra def
, la podremos usar en cualquier parte de nuestro
programa usando solo el nombre de la funcion seguido de
()
.
saludo()
A esto se le llama invocar o llamar a una funcion. Podremos crear tantas funciones como queramos y estas pueden contener en su interior las instrucciones que necesitemos. La creacion de funciones que agrupen los pequenos problemas que conforman el problema general que quieres
solucionar, es la piedra angular de la programacion.
Uso de parametros
Cuando invocas a una funcion existe la posibilidad de pasarme
diferentes parametros con informacion. Esto permite a la funcion
realizar tareas con datos que no estan “en su interior” sino que vienen
de fuera, del codigo llamante. Puede sonar complejo pero en realidad no
lo es. Veamos esto con un ejemplo. Hemos creado una funcion llamada
mayus
que recibe una lista de palabras. Como le haremos
llegar esta lista a la funcion en el momento de su invocacion todavia no
nos preocupa. El caso es que mayus
recibe una lista y la
recorre convirtiendo las palabras de esta lista en mayuscula. Veamos el
codigo de su declaracion:
def mayus(lista):
i=0
while i<len(lista):
lista[i] = lista[i].upper()
i=i+1
el codigo de mayus
es sencillo. Declara una variable
numerica i
como 0
y usa una instruccion
while
para ejecutar su bloque de instrucciones tantas veces
como elementos haya en la lista. Por eso la expresion asociada a
while
es i<len(lista)
. En cada ejecucion
del bucle se accede la palabra de la lista que ocupa esa posicion:
primero la palabra 0
, luego la 1
, luego
2
, etc. Y se le asigna un nuevo valor: el de esa misma
palabra pero transformada en mayusculas gracias al metodo
upper()
. Por ultimo incrementamos i
en uno y
ejecutamos el bucle una vez mas. No nos importa lo larga o corta que sea
la lista, la recorreremos siempre igual gracias a la instruccion
while
.
Pero ¿de donde sale la lista?. La lista no esta declarada en el
anterior codigo. La lista nos llegara cuando se invoque a la funcion
mayus
. En ese momento, en el de la invocacion o llamada,
sera cuando se asigne valor al parametro lista.
Veamos un ejemplo de como llamariamos a esta funcion. Crearemos dos listas diferentes y para convertirlas a ambas a mayusculas usaremos la funcion declarada previamente:
animales = ["perro", "gato", "raton", "tortuga"]
personas = ["sergio", "luis", "marta", "jose", "maria"]
mayus(animales)
print (animales)
mayus(personas)
print (personas)
En ambos casos se convierte la lista a mayusculas usando la funcion
mayus
. Esta funcion se ejecutara dos veces y en cada caso,
la variable o parametro lista se convertira en una lista diferente. En
la primera invocacion, lista sera realmente animales. Mientras que en la
segunda, lista sera personas.
Puedes ver todo este ejemplo completo en el fichero mayusculas.py.
Podemos declarar funciones con un numero mayor de parametros y en ese caso, en la invocacion hemos de respetar el orden de esos parametros para que la asignacion sea correcta:
def ejemplo(indice, palabra, bool):
print ("El indice vale "+str(indice))
print ("La palabra vale "+palabra)
print ("El booleano vale "+str(bool))
// Ejemplos de declaracion:
ejemplo (9, "hola", False)
ejemplo (-4, "adios", True)
ejemplo (321, "buenas", True)
Valores de retorno
Una funcion, ademas de realizar una serie de operaciones puede retornar un valor a quien la invoca. Este valor puede ser util para saber como ha ido el trabajo de la funcion o para recuperar un dato que ella ha generado. Este valor retornado puede ser de cualquier tipo: entero, string, tupla, lista, ….
Para que una funcion retorne un valor usaremos la instruccion
return
y hemos de tener en cuenta que cuando esta
instruccion se ejecute, la ejecucion de la funcion finaliza. Nunca
pongas ninguna instruccion que pertenezca a la funcion bajo un
return
pues nunca sera ejecutada.
Veamos un ejemplo. Vamos a crear una instruccion que recibe un numero entero como parametro y construye y retorna una lista de los numeros pares hasta ese numero:
def construyePares(limite):
pares=[]
for i in range(1, limite+1):
if (i % 2 == 0):
pares.append(i)
return pares
Para recuperar el valor retornado por la lista usaremos una variable junto con su invocacion de la siguiente manera:
listaPares = construyePares(10)
Ahora tendremos una lista llamada listaPares
construida
dentro de la funcion y retornada por esta que tiene la forma
[2, 4, 6, 8, 10]
.
Ejercicios
- Crea una funcion que reciba un parametro numerico e informe si es
un numero primo o no. Usala para imprimir por pantalla los numeros
primos hasta el
100
. Solucion
6. Entrada/Salida
Las funciones y operaciones que se agrupan dentro de este capitulo
son las que nos permitiran adjuntar datos a nuestros programas y extraer
datos de ellos. Ya conocemos dos de estas funciones: input
y print
. Vamos ahora a conocer formas para leer y
escribir informacion en ficheros .
Estas funciones puede sernos muy util para conseguir que nuestros programas tengan informacion perdurable sobre el sistema de ficheros.
antes de empezar a usar los ficheros y luego de terminar de utilizarlos debemos utilizar las funciones de apertura y de cierre de los mismos.
open()
: Indica al sistema operativo que quieres abrir un fichero para leerlo, a escribirlo, etc.close()
: Una vez finalizado el trabajo de archivaje, indica al sistema que quieres dejar de utilizar el fichero, y que lo cierre.
La funcion open
nos devuelve una variable de
tipo File
que nos ayudara a manejar el fichero. Esta
variable u objeto registra la ultima posicion leida u escrita. Para
invocar correctamente open
necesitamos al menos dos
argumentos: la ruta del fichero sobre el sistema (relativa al
directorio donde estamos situados o absoluta desde la raiz del sistema)
y el modo de trabajo. Hemos de seleccionar uno de los
siguientes modos de trabajo:
**Modo de Trabajo ** | Resultado |
r |
Abre el fichero para leerlo. |
w |
Abre el fichero para escribirlo. Si este existe, su contenido anterior sera eliminado y sino existe, se creara. |
a |
Abre el fichero para escribirlo pero anadiendo el contenido a lo que ya teniamos en su interior. |
+ |
Abre el fichero para leerlo y para escribirlo simultaneamente. |
Leer de ficheros
Para leer un fichero con Python debemos primero indicar al sistema nuestra intencion para luego proceder a leerlo. Una vez lo hayamos abierto, sobre el fichero podemos realizar diferentes operaciones de lectura. A continuacion listo las mas comunes:
read(n) |
Lee n bytes del fichero y devuelve esos bytes como una cadena. Si omites este valor provocas te devolvera todo el contenido del fichero como una sola cadena. |
readline() |
Lee una sola linea del fichero. |
readlines() |
Lee toda las lineas del fichero y las devuelve como una lista de cadenas, donde cada linea opera como miembro de esta lista de cadenas. |
Veamos dos ejemplos. En este primero leeremos todo el fichero de golpe guardandolo en una sola cadena:
fichero = open("nombre.txt","r")
texto = fichero.read()
fichero.close()
Ahora leeremos todo el fichero pero separado en lineas y nos quedaremos solo con las dos ultimas:
fichero = open("nombre.txt", "r")
lineas = fichero.readlines()[-2:]
fichero.close()
Escribir en ficheros
Para escribir un fichero, las operaciones previas son similares a las
de lectura. Necesitamos ejecutar open
con el modo adecuado.
Una vez hecho esto podremos elegir dos funciones para escribir en
el:
write(text) |
Escribe el string sobre el fichero. |
writelines(list) |
Escribe en el fichero una lista de cadenas. |
Si queremos escribir manualmente un salto del linea para separar dos
lineas entre si hemos de escribir el caracter \n
. Veamos un
ejemplo:
fichero = open("salida.txt","w")
fichero.write("Esta sera la primera linea del fichero")
fichero.write("\n")
fichero.write("Esta sera la segunda linea")
fichero.close()