Apuntes Pyhton

RAMA: Informática CICLO: DAM
MÓDULO SGE CURSO: 2

PROTOCOLO: Apuntes clases AVAL: 1 DATA: 22/09/2016
UNIDAD COMPETENCIA Pyhton
Contenido
1. Introducción ..................................................................................................................................... 3
2. Elementos base de programación....................................................................................................... 3
2.1. Variables ................................................................................................................................... 3
2.2. Tipos de datos ........................................................................................................................... 4
2.3. Operadores ............................................................................................................................... 4
2.3.1. Operaciones aritméticas ..................................................................................................... 4
2.3.2. Operaciones con cadenas de datos ...................................................................................... 5
2.3.3. Operadores lógicos ............................................................................................................. 5
2.3.4. Conversiones...................................................................................................................... 5
2.4. Salida de datos .......................................................................................................................... 5
2.5. Entrada de datos........................................................................................................................ 5
2.6. Funciones.................................................................................................................................. 6
2.6.1. Docstring ........................................................................................................................... 6
2.7. Strings....................................................................................................................................... 6
2.7.1. Algunos métodos del objeto string ...................................................................................... 7
2.8. Tipos de secuencias o colecciones............................................................................................... 7
2.8.1. Listas ................................................................................................................................. 7
2.8.2. Algunos métodos para trabajar con listas............................................................................. 8
2.8.3. Tuplas ................................................................................................................................ 8
2.8.4. Diccionarios ....................................................................................................................... 8
2.8.5. Métodos de interés para trabajar con diccionarios ............................................................... 8
2.9. Control de flujo.......................................................................................................................... 9
2.9.1. if simple ............................................................................................................................. 9
2.9.2. if-else................................................................................................................................. 9
2.9.3. if-elif-else ........................................................................................................................... 9
2.9.4. While ............................................................................................................................... 10
2.9.5. for-in ............................................................................................................................... 10
2.10. Iteraciones ........................................................................................................................... 10
2.10.1. Range .............................................................................................................................. 10
2.10.2. Map................................................................................................................................. 10
2.11. Ficheros ............................................................................................................................... 10
2.11.1. Apertura .......................................................................................................................... 10
2.11.2. Lectura............................................................................................................................. 11
2.11.3. Escritura........................................................................................................................... 11
2.11.4. Lectura............................................................................................................................. 11
Tema 2: Python v2.1 1

2.11.5. Acceso aleatorio ............................................................................................................... 11

2.12. Módulos .............................................................................................................................. 11
2.12.1. Módulos .......................................................................................................................... 11
2.12.2. Paquetes.......................................................................................................................... 12
2.13. Excepciones ......................................................................................................................... 12
2.14. Orientación a objetos ........................................................................................................... 13

1. Introducción
Python es un lenguaje de script semiinterpretado ya que es traducido a bytecodes y ejecutado por una
máquina virtual de forma similar a como funciona Java.
No es necesario declarar variables, en el momento que se le da un valor a una variable se está declarando.
Es un lenguaje altamente tipado. Una variable cadena no puede ser tratada como entero sin una
conversión previa.
Python es orientado a objetos y multiplataforma.
Python viene instalado en sistemas Linux y Mac OS X por defecto, en sistemas operativos Windows es
necesario la instalación del intérprete, en este caso utilizaremos la versión Python 3
2. Instalación de Python
Para descargar el intérprete lo haremos desde la dirección www.python.org
Una vez obtenido el paquete para el sistema operativo y versión adecuados, ejecutaremos el instalador, y
en una línea de comandos ejecutaremos el intérprete de Python, y probaremos que todo funciona
correctamente mediante el tradicional “Hola Mundo”.
En este ejemplo, hemos llamado al intérprete de Python desde el símbolo del sistema. Al iniciarse, después
de imprimir la información de versiones, Python nos muestra el símbolo >>> para indicarnos que el
intérprete está esperando comandos.
Si todo ha salido correctamente podemos considerar que tenemos la instalación básica de Python lista
para su uso.
2.1. Entornos de desarrollo IDE

Existe la posibilidad de instalar entornos de desarrollo IDE específicos para Python, por ejemplo PyCharm, en
este curso se dejará a la elección del alumno la elección del entorno adecuado. En general un editor de
textos tipo Geany, o el propio que proporciona python debería ser suficiente.
3. Elementos base de programación

3.1. Variables
No se declaran si no que en el momento que se asignan toman el tipo del dato asignado.
Los nombres de las variables empiezan por letra o guion bajo, y solo pueden contener letras números o
guiones bajos.
Las variables en Python son case sensitive, es decir si declaramos una variable ancho,
ancho ≠ Ancho ≠ ANCHO.
Por norma general las variables se escriben en minúsculas, si el nombre de una variable abarca varias
palabras estas se separarán por un guion bajo.

Ejemplo: numero_lados
3.2. Tipos de datos

Para saber el tipo de una variable escribe
type(variable)
Aunque existen tipos de datos como complex para números complejos o unicode para cadenas de textos
Los tipos de datos básicos con los que trabajaremos son:
Números Enteros. De tipo int. Por ejemplo 45
Números Reales. De tipo float. Por ejemplo 12.5
Cadenas de texto. De tipo str. Entre comillas simples o dobles (“hola” y 'hola' son correctos).
Booleanos: True o False. El tipo es bool. Es una subclase de int, de forma que True es 1 y False es 0.
Dado que las variables no se declaran, es posible que llegados a un punto no sepamos de qué tipo es una
variable, para averiguarlo podemos utilizar el comando type()
Ejemplo:
>>> a=20
>>>type(a) #devuelve <class 'int'>
Los números enteros se pueden representar en notación decimal, octal (anteponiendo un “0o” al valor) o
hexadecimal (anteponiendo “0x” al valor). Al igual que en lenguaje C (en el que está escrito Python), los
números se pueden representar mediante enteros (por defecto) o long (entero largo), que permite un
rango mayor de valores posibles.
3.3. Operadores
3.3.1. Operaciones aritméticas
Para las operaciones aritméticas tenemos:
+ Suma a=1+2 # a=3
- Resta a=2-5 # a=-3
* Multiplicación a=2*3 # a=6
** Potencia a=2**3 # a=8
/ División a=5/2 # a=2.5
// División entera a=5//2 # a=2
% Módulo a=5%2 # a=1
Cabe destacar que mantienen el orden de prioridad entre operaciones aritméticas, es decir, sumas y restas
separan operaciones, si queremos indicar otra prioridad es necesario utilizar paréntesis ()
>>> 4+6*2 #resultado 16
>>>(4+6)*2 #resultado 20

3.3.2. Operaciones con cadenas de datos

Es posible utilizar operadores aritméticos con cadenas de caracteres, por ejemplo
>>> ‘verano ‘+’caluroso’ #’verano caluroso’
>>>’verano ‘+’caluroso ’*2 #’verano caluroso caluroso’
>>>(’verano ‘ +’caluroso ’)*2 #’verano caluroso verano caluroso’
3.3.3. Operadores lógicos
and, or, not, ==, !=, <, >, <=, >=
3.3.4. Conversiones
>>> a=12
>>> b=3.4
>>> c=23
>>> str(a)
>>> int(b)
>>> float(c)
3.4. Salida de datos

# Los comentarios empiezan por #
A partir de Python 3.0, print es tratada como una función por lo que es necesario llamarla utilizando ()
>>>print (“Hola”) # Escribe Hola
>>>print(7+6) #Escribe 13
Si queremos separar un print en varias líneas podemos hacerlo utilizando comillas triples o la instrucción
\n
>>>print(‘’’Hola
planeta
azul’’’)
>>>print(‘Hola/nplaneta/n azul’)
3.5. Entrada de datos

La instrucción input muestra en pantalla el mensaje escogido y se queda a la espera de una respuesta.
Siempre devuelve un string, por lo que si trabajamos entrada de números siempre es necesaria la
conversión antes de poder operar con ellos.
>>>nombre =input('¿Cómo te llamas?')
>>>ciudad=input('¿Dónde vives?')
>>>print(nombre, 'vive en ', ciudad)
Realiza un programa que reciba dos números por pantalla y los sume

3.6. Funciones
Se definen de la siguiente forma:
def nombreFuncion(parametro1, parametro2, …):
sentencias
return dato
Ejemplo
def suma(a,b):
return a+b
print suma(12,34)
print suma(b=12,a=34) # Para cambiar el orden de los parámetros
En Python existen una serie de funciones preconstruidas que podemos encontrar ejecutando en la consola
dir(__builtins__)
Si necesitamos ayuda sobre alguna de estas funciones podemos escribir help(nombrefuncion) y se
mostrará la ayuda relativa a la función.
Ejemplo help(max)
3.6.1. Docstring
Al definir una función propia utilizaremos el docstring para indicar el uso de la función, este texto será el
que aparezca si algún usuario hace un help sobre el nombre de nuestra función.
El docstring se escribe después de la definición del nombre de la función entre comillas triples. Ejemplo:
3.7. Strings
Supongamos un string s=’COLEGIOVIVAS’
Cada string tiene un index que es la posición del caracter en el string, esta posición se empieza a contar
desde cero en la dirección de izquierda a derecha(index positivo), y desde -1 en sentido contrario (index
negativo).
Así s[0]=s[-12]
0 1 2 3 4 5 6 7 8 9 10 11
C O L E G I O V I V A S
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
Se puede seleccionar un trozo del string con la siguiente sintaxis:

>>>s[0:5] #COLEG
>>>s[7:len(s)] #VIVAS
>>>s[7:] #VIVAS
>>>s[:3] #COL
>>>s[-12:-10] #CO
>>>s[:] #COLEGIOVIVAS
Los strings no permiten asignación directa de valor, es decir s[8]=’m’ dará un error, es necesario utilizar
uin método de sustitución para realizar el cambio.
3.7.1. Algunos métodos del objeto string
s.lower(). Convierte el string en letras minúsculas
s.upper(). Convierte el string en letras mayúsculas
s.capitalize(). Pone la primera palabra del string en mayúsculas
s.isnumeric(). Devuelve true si solo hay caracteres numéricos en s
s.count(sub[, start[, end]]) Devuelve el número de veces que se encuentra sub en la cadena. Los
parámetros opcionales start y end definen una subcadena en la que buscar.
s.find(sub[, start[, end]]) Devuelve la posición en la que se encontró por primera vez sub en la cadena o -1
si no se encontró.
s.partition(sep) Busca el separador sep en la cadena y devuelve una tupla con la subcadena hasta dicho
separador, el separador en si, y la subcadena del separador hasta el final de la cadena. Si no se encuentra
el separador, la tupla contendrá la cadena en si y dos cadenas vacı ́as.
s.replace(old, new[, count]) Devuelve una cadena en la que se han reemplazado todas las ocurrencias de
la cadena old por la cadena new. Si se especifica el parámetro count, este indica el número máximo de
ocurrencias a reemplazar.
s.split([sep [,maxsplit]]) Devuelve una lista conteniendo las subcadenas en las que se divide nuestra cadena
al dividirlas por el delimitador sep. En el caso de que no se especifique sep, se usan espacios. Si se especifica
maxsplit, este indica el número máximo de particiones a realizar.
Podemos encontrar todos los métodos aplicables al objeto string utilizando dir(s)
3.8. Tipos de secuencias o colecciones

3.8.1. Listas
Las listas son similares a vectores o arrays pueden contener cualquier tipo en cada una de sus “casillas”.
Como en los string se accede por indexación tanto para leer datos como para cambiarlos.
Si se usan índices negativos, el -1 es la última posición y así sucesivamente.
>>> lista=[23, 4, "perro", [1,0, 2, 4]]
>>> lista[0] #23
>>> lista[3] #[1,0,2,4]
>>>lista[3][3] #4

A diferencia de los string las listas sí permiten asignación directa, por ejemplo
>>> lista[2]='gato'
>>> lista[3][0]=23
3.8.2. Algunos métodos para trabajar con listas
Se puede añadir elementos mediante append o insert.
Se puede concatenar con otra lista mediante extend.
Se obtiene su longitud mediante len.
>>> lista.append(2)
>>> lista.insert(3,'bicho')
>>> lista.extend([33,1,2])
>>> len(lista)
Métodos de interés:
l.append(object) Añade un objeto al final de la lista.
l.extend(object) Añade nuevos objetos al final de la lista, a diferencia de append puede ser más de uno.
l.count(value) Devuelve el número de veces que se encontró value en la lista.
l.index(value[, start[, stop]]) Devuelve la posición en la que se encontró la primera ocurrencia de value. Si
se especifican, start y stop definen las posiciones de inicio y fin de una sublista en la que buscar.
l.insert(index, object) Inserta el objeto object en la posición index.
l.pop([index]) Devuelve el valor en la posición index y lo elimina de la lista. Si no se especifica la posición,
se utiliza el último elemento de la lista.
l.remove(value) Eliminar la primera ocurrencia de value en la lista.
l.reverse() Invierte el orden de elementos de la lista.
Se puede acceder a todos los métodos creados para trabajar con listas mediante dir(list).
3.8.3. Tuplas
Las tuplas son similares a las listas pero de tamaño fijo y son inmutables. La ventaja es que son más ligeras
con lo que se ahorra recursos.
Se define como una lista pero entre paréntesis. Se puede acceder a cada posición por índices como las
listas.
>>> tupla=(2,3,'hola', [0,1])
3.8.4. Diccionarios
Son tablas hash que se definen entre llaves y la clave y el valor de cada posición se separa por dos puntos
(:). El acceso no es indexado si no que es por clave.
>>> dic={"moto":2, "coche":4, "camion":4, "barco":0}
>>> dic["moto"]
>>> dic["camion"]=16
3.8.5. Métodos de interés para trabajar con diccionarios

Podemos acceder s todos los métodos creados para trabajar con diccionarios mediante dir(dict)
dic.items() Devuelve una lista de tuplas con pares clave-valor.
dic.keys() Devuelve una lista de las claves del diccionario.
dic.pop(k[, d]) Borra la clave k del diccionario y devuelve su valor. Si no se encuentra dicha clave se
devuelve d si se especificó el parámetro o bien se lanza una excepción.
dic.values() Devuelve una lista de los valores del diccionario.
3.9. Control de flujo

El control de flujo es muy similar a otros lenguajes. Python tiene la característica de que la forma de indicar
si un elemento está o no dentro de una estructura es mediante la identación. (4 espacios para ser exactos)
3.9.1. if simple
c= input("Introduce edad > ")
c=int(c)
if c>=18:
print ("Puedes acceder")
print ("Adelante!")
print ("Esta linea siempre se ejecuta")
3.9.2. if-else
c=int(c)
if c>=18:
print ("Puedes acceder")
print ("Adelante!")
else:
print ("Eres menor")
3.9.3. if-elif-else
n= input("Introduce un número ")
numero=int(n)
if numero < 0:
print ('Negativo')
elif numero > 0:
print ('Positivo')
else:
print ('Cero')

3.9.4. While
c=0;
while c<18:
c=int(c)
print ("Ahora puedes pasar")
Se permite el uso de break y continue.

3.9.5. for-in
for-in : similar al foreach de otros lenguajes
secuencia = ['uno', 'dos', 'tres']
for elemento in secuencia:
print (elemento)
3.10. Iteraciones
Sirven para evitar hacer bucles dando mucha versatilidad al trabajo con listas, tuplas y otras secuencias:
3.10.1. Range
range([inicio,] fin[, paso]): Genera una lista de enteros entre inicio, fin y con el paso indicado.
>>> range(4) #[0, 1, 2, 3]
>>> range(-2,2) #[-2, -1, 0, 1]
>>> range(-10,10,5) #[-10, -5, 0, 5]
3.10.2. Map
map(funcion, secuencia): La función map aplica una función a cada elemento de una secuencia y devuelve
una lista con el resultado de aplicar la función a cada elemento.
>>> def inc(n):
... return n+1
>>> l=[3, 4,3,2,1,6]
>>> list(map(inc, l))
3.11. Ficheros
3.11.1. Apertura
Son objetos tipo file y para trabajar con ellos lo primero es abrirlos:
f = open(string rutaynombre, string modo)
Donde algunos de los modos pueden ser (trabajando archivos de texto):
‘r’: read, lectura. Abre el archivo en modo lectura. El archivo tiene que existir previamente, en caso
contrario se lanzará una excepción de tipo IOError.
‘w’: write, escritura. Abre el archivo en modo escritura. Si el archivo no existe se crea. Si existe,
sobreescribe el contenido.

‘a’: append, añadir. Abre el archivo en modo escritura. Se diferencia del modo ‘w’ en que en este caso no
se sobreescribe el contenido del archivo, sino que se comienza a escribir al final del archivo.
‘r+’: permite lectura y escritura simultáneas.
3.11.2. Lectura
read(): Lee como cadena el contenido completo
read(n): Lee n bytes
readline(): Lee una linea
readlines(): Lee todas las líneas del archivo pero las devuelve en una lista en lugar de en un único string
3.11.3. Escritura
write(cadena): Escribe la cadena que se pasa como parámetro.
writelines(lista): Escribe la lista de cadenas que se pasa como parámetro.
f = open("prueba.txt", "w")
f.writelines(["uno\n","dos"," 3\n"])
f.write("adios")
f.close() #para cerrar el archivo
3.11.4. Lectura
f = open("prueba.txt", "r")
print f.read()
3.11.5. Acceso aleatorio
seek(posicion,[inicio]): Sitúa el puntero del archivo donde indique posición. Si establecemos el parámetro
inicio a 0, la posición se refiere desde el principio (funcionamiento por defecto), si colocamos 1 se refiere
a posición desde la actual y 2 desde el final.
tell(): Me dice la posición del puntero. Distancia en bytes desde el principio.
3.12. Módulos
Es posible hacer librerías de funciones y clases metiéndolas en archivos (módulos) y estos archivos en
directorios y subdirectorios (paquetes).
3.12.1. Módulos
Para importar un módulo se hace de la forma:
import nombre
Esto hace que tengamos acceso a las funciones de ese módulo. Por ejemplo:
>>> import math
>>>dir (math) #muestra el listado de funciones del módulo math
>>>help (math.sqrt) #muestra la ayuda de la función sqrt del módulo math
El hecho de poner el nombre del módulo delante de la función es bueno por claridad y para evitar
sobreescribir funciones con el mismo nombre.

También es posible importar únicamente una función de un módulo de la forma

>>> from math import sqrt
En este caso se puede utilizará la función sqrt directamente sin necesidad de poner el nombre del módulo
delante.
Se pueden importar todas las funciones mediante *
3.12.2. Paquetes
Un paquete es un directorio con archivos python.
Además para que dicho directorio pueda ser paquete debe existir en él el archivo vacío __init__.py
Este directorio tiene otras utilidades en las que no entraremos por el momento. Llega con dejarlo vacío.
El uso general será:
>>>import directorio.subdirectorio.modulo
3.13. Excepciones
Llamamos excepciones a los errores acaecidos durante la ejecución de un programa, si a lo largo de la
ejecución del mismo no nos hacemos cargo de ellos, interrumpen la ejecución del programa.
Para el manejo de excepciones Python tiene 3 palabras reservadas try, except, y finally, que nos permiten
realizar acciones para evitar la interrupción del programa.
El uso básico es el siguiente:
Dentro del bloque try se introduce el código que pueda llegar a generar (levantar) una excepción
A continuación situamos el bloque except que se encarga de capturar la excepción y nos da la oportunidad
de procesarla mostrando un mensaje al usuario.
Ejemplo para la división por cero:
dividendo=int(input('Introduce el dividendo: '))

divisor=int(input('Introduce el divisor: '))
try:
cociente=dividendo/divisor
except:
print('No se puede realizar una división por cero')
Si el usuario introduce un cero como divisor se levantará la excepción ZeroDivisionError, para evitar que lo
haga y se detenga el programa, se utiliza el bloque try-except.
Dado que dentro de un mismo bloque try pueden producirse excepciones de distinto tipo, es posible utilizar
varios bloques except, cada uno para capturar un tipo distinto de excepción, aunque solo se ejecutará a lo
sumo, uno de ellos.
try:
n1=int(input("Introduce dividendo: "))
n2=int(input("Introduce divisor: "))
print (n1/n2)
except ValueError:

print ("No has introducido números")

except ZeroDivisionError:
print ("División por cero")
Finalmente, puede ubicarse un bloque finally donde se escriben las sentencias de finalización, que son
típicamente acciones de limpieza. La particularidad del bloque finally es que se ejecuta siempre, haya surgido
una excepción o no. Si hay un bloque except, no es necesario que esté presente el finally, y es posible tener
un bloque try sólo con finally, sin except.
Declaración raise
Para lanzar una excepción se usa la declaración raise que nos permite forzar a que ocurra una excepción
específica:
class NegativosError(Exception):
pass
try:
n1=int(input("Introduce dividendo: "))
n2=int(input("Introduce divisor: "))
if n1<0 or n2<0:
raise NegativosError
print (n1/n2)
except ValueError:
print ("No has introducido números")
except ZeroDivisionError:
print ("División por cero")
except NegativosError:
print ("No son válidos números negativos")
3.14. Orientación a objetos

Una clase se crea con la palabra reservada class.
El constructor es la función __init__(self) que como mínimo tiene el parámetro objeto aunque luego no
sea imprescindible pasárselo.
Cuando una función forme parte de una clase se debe incluir el parámetro self para llamar a funciones de
su misma clase o de su clase padre, aunque no es obligatorio.
Todos los métodos que vayan a usar elementos del propio objeto deberán llevar el parámetro self al
principio.
class Coche:
def __init__(self, gasolina):
self.gasolina = gasolina
print ("Tenemos", gasolina, "litros")
def arrancar(self):
if self.gasolina > 0:
print ("Arranca")
else:
print ("No arranca")
def conducir(self):
if self.gasolina > 0:

self.gasolina -= 1
print ("Quedan", self.gasolina, "litros")
else:
print ("No se mueve")
Instanciación:
coche=Coche(5)
coche.arrancar();
while coche.gasolina:
coche.conducir()
print ("Nos hemos quedado secos")
coche.arrancar()
Herencia: Se realiza indicando la superclase entre paréntesis. El concepto es el que ya se conoce con
algunas particularidades:
Existe herencia múltiple (se separa por comas)
Si se desea heredar una clase y que no se le añada nada a mayores se puede usar la palabra reservada
pass. Significa “nada que hacer aquí”.
class Deportivo(Coche):
def competir(self, posicion):
if self.gasolina>0:
print ("preparate voy a llegar en la posicion",posicion)
else:
print ("no tengo gasolina")
class Turismo(Coche):
pass
coche=Deportivo(5)
coche.competir(1)
No entraremos a fondo en orientación a objetos. Profundizaremos más adelante si nos hiciera falta.

Apuntes Pyhton

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apuntes Pyhton

Cargado por

Copyright:

Formatos disponibles

RAMA: Informática CICLO: DAM

MÓDULO SGE CURSO: 2

Tema 2: Python v2.1 1

2.11.5. Acceso aleatorio ............................................................................................................... 11

Tema 2: Python v2.1 2

2.1. Entornos de desarrollo IDE

3. Elementos base de programación

Tema 2: Python v2.1 3

3.2. Tipos de datos

Tema 2: Python v2.1 4

3.3.2. Operaciones con cadenas de datos

3.4. Salida de datos

3.5. Entrada de datos

Tema 2: Python v2.1 5

Se puede seleccionar un trozo del string con la siguiente sintaxis:

Tema 2: Python v2.1 6

3.8. Tipos de secuencias o colecciones

Tema 2: Python v2.1 7

Tema 2: Python v2.1 8

3.9. Control de flujo

Tema 2: Python v2.1 9

Se permite el uso de break y continue.

Tema 2: Python v2.1 10

Tema 2: Python v2.1 11

También es posible importar únicamente una función de un módulo de la forma

dividendo=int(input('Introduce el dividendo: '))

Tema 2: Python v2.1 12

print ("No has introducido números")

3.14. Orientación a objetos

Tema 2: Python v2.1 13

Tema 2: Python v2.1 14

También podría gustarte