Curso de Programación Paramétrica en Rhinoceros 3D

con Rhino-Python y Python-GH

Conociendo el entorno Python

Una guı́a rápida para introducirnos a Python

Author: Javier Calderon-Sanchez

Universidad Politécnica de Madrid (UPM)

Índice

1. Introducción 1
1.1. ¿Qué es Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2. Elementos Básicos 2
2.1. Objetos, Expresiones, Tipos Numéricos y Variables . . . . . . . . . . . . . . . . . . . . 2

3. Bloques y Estructuras de Control 3

3.1. Condicionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3.2. Estructuras iterativas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2.1. Bucles while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2.2. Bucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

4. Tipos Estructurados: Listas, Tuplas y Diccionarios 5

4.1. Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4.2. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4.3. Diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4.4. Operaciones comunes con los tipos estructurados . . . . . . . . . . . . . . . . . . . . . 6

5. Operaciones comunes en Python 7

6. Funciones 7

1. Introducción
Bienvenidos a la guı́a rápida de introducción a Python que servirá para ayudarnos a introducir o
recordar los aspectos principales del lenguaje de programación Python de manera que facilite el módulo
correspondiente del curso.
En pocas lı́neas, aprenderemos los tipos y estructuras de control disponibles en Python y – ya de paso
– casi en cualquier lenguaje de programación.

1
 El objetivo de esta guı́a es tener una referencia rápida en caso de duda a la hora de preparar nuestros
propios scripts, y que sirva como una primera referencia. Ası́ mismo, pretendemos que sirva como tram-
polı́n a otras referencias contrastadas en las que podáis consultar aspectos especı́ficos del lenguaje y de
las funciones disponibles en el mismo.
¡Comenzamos!

1.1. ¿Qué es Python?

Python es un lenguaje de programación de propósito general, orientado a objetos, libre e indepen-
diente de la plataforma y sistema operativo. Lo que ha hecho a Python tan popular en los últimos años es
su simplicidad, versatilidad y rapidez de desarrollo. Dentro de sus caracterı́sticas principales, destacare-
mos:

Lenguaje de propósito general: no está orientado a ningún tipo de desarrollo en particular, y por
tanto, es aplicable a cualquier tipo de programa o aplicación que se nos ocurra.

Lenguaje de alto nivel: es consecuencia de lo anterior. En un lenguaje de alto nivel los algoritmos
se expresan en el nivel de la capacidad cognitiva humana, en contraposición a los lenguajes de bajo
nivel, donde se expresan en lenguaje máquina.

Lenguaje interpretado: es decir, no hay que compilar código antes de su ejecución.

Libre y gratuito: es decir, que es distribuido sin coste alguno para el usuario final, que puede
modificar las fuentes como quiera.

Una vez que sabemos las caracterı́sticas principales del lenguaje que vamos a utilizar, pasemos a ver
cómo hacerlo.

2. Elementos Básicos
Un programa de Python, también llamado un script es una secuencia de definiciones que se evalúan
y comandos que se ejecutan por un intérprete de Python. Existen varias opciones para elegir como Id-
le (por defecto al instalar Python), Canopy, PyCharm o Spyder. Rhinoceros tiene su propio intérprete,
implementado además en IronPython. La implentación limita el número de funciones y paquetes dispo-
nibles en función de si están desarrolladas o no para esa implementación en particular. Puedes buscar
más información sobre IronPython en http://ironpython.net/
Un ejemplo de comando es print. Por ejemplo:

In: print("Hola Mundo")

Out: Hola Mundo

print le ordena al intérprete que imprima el texto Hola Mundo a través de la ventana asociada con el
intérprete.

2.1. Objetos, Expresiones, Tipos Numéricos y Variables

Los objetos son los elementos principales manipulados por un programa de Python. Cada objeto es
de un tipo que define el tipo de acciones que pueden ser llevadas a cabo con dicho objeto.
Los tipos se dividen en escalares y no escalares. Los objetos escalares son indivisibles, es decir, en
principio no pueden ser modificados. Los objetos no escalares tienen estructura interna, y son variables.
Dentro de los objetos escalares, distinguimos cuatro tipos:

1. int: se usa para representar números enteros, es decir, −3 o 5.

2
 2. float: se usa para representar números reales, como por ejemplo 3,6 o −1,4 Este tipo de objeto
siempre incluye un punto decimal, es decir, que 1,0 o −3,0 también pertenecen a este grupo de
objetos.

3. bool: se usa para representar valores booleanos, es decir, True o False. Aparecen sobre todo al
evaluar igualdades.

4. None: es un objeto con un valor único. Este valor aparece cuando el objeto no pertenece a ninguno
de los tipos. Normalmente indica un error en nuestro código.

Estos tipos pueden ser combinados con operadores para formar expresiones. Ası́, por ejemplo 3 + 2
se combinan para formar el objeto 5 de tipo int, mientras que 3,0 + 2,0 forman el objeto de valor 5,0 y
tipo float. Estas diferencias sutiles son muy importantes a la hora de programar nuestras aplicaciones.
Para saber el tipo de un objeto, podemos usar la función propia de Python type. Ası́, por ejemplo,
type(3) devolverá < type0 int0 >.
Otro tipo de objeto de gran utilidad es el tipo string, que se usa para representar caracteres. La
sintaxis para escribir un objeto de tipo str es con comillas, simples o dobles. ’abc’ y .abc” son dos formas
de representar la misma secuencia de caracteres. Los objetos de tipo string también pueden combinarse
con operadores, aunque lógicamente con distinto significado que en el caso de los tipos numéricos. Ası́,
’abc’ + ’def’ da como resultado ’abcdef’.
Separamos los objetos de tipo string de los anteriores ya que además de con operadores, este tipo de
objetos soportan otro tipo de operaciones como el indexado o el slicing, que comentaremos más adelante,
ya que son propios de los tipos estructurados.
Una variable es simplemente una forma de asociar un nombre a un objeto. Por ejemplo:

pi = 3.14
r = 5
area = pi * (r**2)
print(area)
r = 1
area = pi * (r**2)
print(area)

En este ejemplo asignamos el objeto 3,14 a la variable pi y el valor 5 a la variable r. Calculamos

el área como pi ∗ r2 o 3,14 ∗ 52 e imprimimos el valor de la variable area por pantalla. Si cambiamos
el valor asignado a la variable r y volvemos a calcular el área, el valor de la variable area cambiará de
acuerdo al nuevo valor de r.
Es importante darse cuenta de que el simple hecho de cambiar el valor de la variable r no cambia el
valor de area, a no ser que volvamos a calcular dicho valor con el nuevo valor de r, como hacemos en el
ejemplo.

3. Bloques y Estructuras de Control

Hasta ahora, todo lo que se ha introducido se conoce como programas en lı́nea, es decir, secuen-
cias que ejecutan un comando tras otro en el orden en el que se introducen. Existen no obstante otras
estructuras más interesantes, que se conocen como bloques o estructuras de control.

3.1. Condicionales
Dentro de las estructuras de control, el ejemplo más sencillo es el del condicional. Un condicional
tiene tres partes:

un test: es decir, una expresión que evaluada devuelve Verdadero o Falso.

3
 un bloque de código que se ejecuta si la evaluación resulta Verdadera y
un bloque de código opcional que se ejecuta si la evaluación es Falsa.
En Python, un condicional se traduce como:
if x%2 == 0: # Test
print(’Numero Par’) # Bloque ejecutado si se cumple el test
else:
print(’Impar’) # Bloque optional si no se cumple
print(’Hecho!’)
El ejemplo de código anterior da las claves básicas de cómo introducir un condicional en Python.
Vemos una serie de particularidades en la sintaxis del código. Una de ellas es que los test acaban allı́
donde se colocan los dos puntos (:). La otra es que los bloques de código que se ejecutan dentro del
condicional van indentados. Esta es la mayor particularidad de Python respecto a otros lenguajes de
programación, donde la indentación es recomendable en aras de la limpieza y la facilidad de lectura del
código, pero no es obligatoria, como en el caso de Python.
Los condicionales se pueden concatenar, si un condicional está dentro de otro. Por ejemplo:
if x%2 == 0:
if x%3 == 0:
print(’Divisible por 2 y 3’):
else:
print(’Divisible por 2 pero no por 3’)
elif x%3 == 0:
print(’Divisible por 3 pero no por 2’)
que también nos sirve para introducir un tercer test, elif (que corresponde a else if ), y que se utliza
cuando se quiere introducir una segunda evaluación, diferente a la primera, que se ejecuta después de
evaluar el primer if.

3.2. Estructuras iterativas

Las estructuras iterativas sirven para realizar una tarea de una forma repetitiva un número determina-
do de veces. Su estructura es similar a la de los condicionales. Comienzan con un test, que si se cumple,
permite ejecutar una parte de código y repetirla tantas veces como el test se cumpla.
Es necesario por tanto que el código que se ejecuta modifique de alguna manera las variables que
están envueltas en la evaluación, de manera que el bucle no se ejecute infinitas veces.
Existen dos formas de introducir un bucle en Python, que veremos a continuación: los bucles while
y los bucles for.

3.2.1. Bucles while

Un bucle while permite la ejecución de un grupo de instrucciones mientras se cumpla una condición.
La estructura básica de un bucle while es la siguiente:
i = n # Inicializacion del iterador
while "condicion":
cuerpo del bucle
actualizacion del iterador
La condición no está establecida a priori, y por tanto, el número de iteraciones que se llevan a cabo
no es conocida, y depende de cómo el bucle modifique el iterador para que la condición siga o no
cumpliéndose.
Los bucles while son la estructura tradicional de control en muchos lenguajes de programación.
Python sin embargo, proporciona otra opción con una sintaxis diferente: los bucles for.

4
3.2.2. Bucles for
Los bucles while son una estructura altamente estilosa, pero sólo opera sobre secuencias de números
enteros. Para poder generalizar los bucles sobre todos los tipos de variables, Python dispone de los bucles
for, cuya estructura en general es de la siguiente forma:

for variable in sequence:

code block

La variable que sigue al statement for está ligada al primer valor de la secuencia. A medida que
ejecutamos el bloque de código del bucle, esta variable va evolucionando a lo largo de los valores de
dicha secuencia. El proceso continúa hasta que acabe o hasta que se fuerce mediante el comando break.
Para producir la secuencia, lo más común es usar una función propia de Python conocida como
range, que devuelve una secuencia de valores en progresión aritmética. Veremos la estructura de la
función range más adelante. Veamos un ejemplo:

x = 4
for i in range(0,4)
print i

Nos devolverá sucesivamente los valores 0, 1, 2 y 3.

4. Tipos Estructurados: Listas, Tuplas y Diccionarios

Los tipos de variable que hemos visto hasta ahora no tienen ningún tipo de estructura interna (salvo
los str, que son una excepción), pero que tampoco podemos considerar aquı́. No obstante, existen otros
tipos de variables con estructura interna, compuestos normalmente de otros tipos de variables: las listas,
las tuplas y los diccionarios. Vamos a hablar un poco de ellas.

4.1. Tuplas
Las tuplas son secuencias ordenadas de elementos, Al igual que los strings. La diferencia radica en
que las tuplas no tienen por qué estar compuestas de caracteres, es decir, son una generalización de los
strings.
Los elementos de una tupla se escriben como una lista separada por comas, y englobada dentro de
paréntesis. Por ejemplo,

t1 = ()
t2 = (1, ’dos’, 3.0)

Las tuplas pueden ser concatenadas, indexadas y deslizadas, ası́, redefiniendo la primera tupla del
ejemplo anterior:

t1 = (t2, ’123’)
print t1
print (t1 + t2)
print(t1[0])
print(t2[1:3])

Nos devolverá:

((1, ’dos’,3.0), ’123’)

((1, ’dos’,3.0), ’123’, 1, ’dos’, 3.0)
(1, ’dos’, 3.0)
(’dos’,3.0)

5
 Si sabemos la longitud de una tupla, puede ser conveniente asignar múltiples variables a cada uno de
los elementos:

x,y = (3,4)

De esta forma, tendremos localizados cada uno de los elementos de la secuencia y nos ahorraremos
el indexado.

4.2. Listas
Al igual que las tuplas, las listas son secuencias ordenadas de elementos. Sin embargo, y como
elemento diferenciador, se escriben entre corchetes:

L1 = []
L2 = [1, ’dos’, 3.0]

Esta forma de escribir las listas entre corchetes (al igual que el indexado y el deslizamiento que
veremos a continuación) puede llevar a expresiones confusas en algunos casos, como: [1, 2, 3, 4][1 :
3][1], por lo que hay que tener cuidado.
La principal diferencia entre una lista y una tupla es que las listas son mutables, mientras que las
tuplas (y los strings) son inmutables. Los elementos inmutables no pueden ser modificados una vez han
sido creados , mientras que los elementos mutables si que conservan la capacidad de ser modificados.
La diferencia puede parecer sutil, pero tiene una gran importancia, especialmente a la hora de asignar
variables a estas listas.
El efecto de la mutabilidad podemos apreciarlo con el método append. Este método añade un nuevo
elemento a una lista, pero en lugar de crear una nueva lista que incluya este valor, muta la lista existente,
a la que incluye este nuevo elemento.
De esta forma, si creamos dos listas, las concatenamos, asignándo una nueva variable a esta última,
y luego modificamos una de las listas creadas previamente, ocurre que la lista concatenada, también ha
sido modificada!

4.3. Diccionarios
Los objetos de tipo diccionario, o dict, son como las listas, solo que los ı́ndices que se necesitan no
tienen por qué ser números enteros, si no que pueden ser cualquier cosa, y que llamaremos llaves.
De esta forma, no hay un orden, y un diccionario se convierte en un conjunto de elementos (o valores),
cada uno de ellos asociados a una llave.
Los diccionarios se escriben entre llaves, y cada elemento se escribe como una llave seguida de dos
puntos y del valor asignado. Para que quede más claro:

meses = {’Enero’:1, ’Febrero’:2, ’Marzo’:3}

print(’El segundo mes es’ + meses[2])

El segundo mes es Febrero

El método keys devuelve una lista con todas las llaves del diccionario, sin un orden preestablecido.

4.4. Operaciones comunes con los tipos estructurados

Después de haber visto de forma general los tipos de operaciones estructuradas que existen en Python
(incluimos aquı́ a los string, describimos a continuación una serie de operaciones que pueden ser llevadas
a cabo por este tipo de objetos:

seq[i]: devuelve el elemento i de una secuencia. Esto se conoce como indexado

6
 seq1 + seq2: devuelve la concatenación de dos secuencias.

seq[start:stop]: devuelve la porción de la secuencia comprendida entre start y stop − 1. Esto se

conoce como slicing.

e in seq: devuelve T rue si e está en la secuencia y False si no.

5. Operaciones comunes en Python

length: Se escribe len(d), y devuelve el número de elementos en d.

range: se escribe range([start],[stop],[step]) y es una función muy útil para establecer una lista
de números en progresión aritmética. Se utiliza normalmente combinado con los bucles for.

frange: tiene la misma estructura y función que range, con la diferencia de que esta función nos
permite realizar progresiones aritméticas con saltos menores a la unidad.

formato: en algunas ocasiones, puede resultarnos útil devolver el valor de una variable con un
formato determinado (uno o varios decimales, sin decimales, etc.). La estructura para realizarlo es
la siguiente:

print("El resultado es: %f") % Resultado

En este caso, %f corresponde a dar el valor de resultado como un float. Para dar un string se usa %s
y para dar un integer, %d.

6. Funciones
La última estructura básica que nos queda por introducir son las funciones. Una función es un bloque
de código organizado y reutilizable que cumple una determinada tarea. Las funciones son muy útiles
para no repetir código y que de esta forma sea más compacto, modular y eficiente.
La estructura de una función comienza definiendo la palabra clave def seguido del nombre de la
función y las variables de entrada entre paréntesis. Tras los clásicos dos puntos (:), indentamos el código
para introducir el bloque dentro de la función. Una función necesita, al igual que unas variables de
entrada, unas variables de retorno al código, que se especificarán tras introducir la palabra clave return.
Para verlo de forma más gráfica:

def mi_funcion(input1,input2,...):
bloque de codigo
...
return output1,output2,output3,...

Referencias
[1] Guttag, John V. Introduction to Computation and Programming Using Python 2013.

[2] Python Documentation. URL: https://www.python.org/

[3] Tutorial de Python. URL: https://docs.python.org/3/tutorial/index.html

[4] Beginner’s guide to Python. URL: https://wiki.python.org/moin/BeginnersGuide