CASTING Y CONVERSIÓN ENTRE TIPOS DE DATOS EN

PYTHON
Python siempre determina el tipo de datos automáticamente, es decir no le tienes que
decir que tipo de dato es:

f= 5

g= "hola"

Encuentra que f es de tipo entero y g de tipo cadena (en inglés string).

Las funciones aceptan un determinado tipo de datos. Por ejemplo, print solo acepta el

tipo de datos de cadena.

Casting de tipos de datos

Si quieres imprimir números, a menudo necesitarás un casting.

En este ejemplo a continuación, queremos imprimir dos números, un número entero y

un número de coma flotante.

j=6

k = 4.456734

print("Definimos 2 numeros,")

print("j = " + str(j))

print("k = " + str(k))

Lanzamos la variable j (entero) y la variable k (float) a una cadena usando la

función str().

¿Qué pasa si tenemos texto que queremos almacenar como número? Tendremos que
lanzar de nuevo.

c = "15.21"

v = "16.672354"

b = float(c) + float(v)

print(b)
En el ejemplo anterior, emitimos dos variables con la cadena de datos al tipo de datos
flotante.

Funciones de conversión entre tipos de datos

Para convertir entre tipos de datos puede utilizar:

int (x) Convierte x en un entero

long (x) Convierte x en un entero largo
float (x) Convierte x en un número de punto flotante
str (x) Convierte x a una cadena. x puede ser del tipo float. entero o
largo
hex (x) Convierte x entero en una cadena hexadecimal
chr (x) Convierte x entero a un caracter
ord (x) Convierte el carácter x en un entero

LISTAS EN PHYTON

Una lista es una estructura de datos y un tipo de dato en python con características
especiales. Lo especial de las listas en Python es que nos permiten almacenar cualquier
tipo de valor como enteros, cadenas y hasta otras funciones; por ejemplo:
lista = [1, 2.5, 'DevCode', [5,6] ,4]
Una lista es un arreglo de elementos donde podemos ingresar cualquier tipo de dato, para
acceder a estos datos podemos hacer mediante un índice.
print lista[0] # 1
print lista[1] # 2.5
print lista[2] # DevCode
print lista[3] # [5,6]
print lista[3][0] # 5
print lista[3][1] # 6
print lista[1:3] # [2.5, 'DevCode']
print lista[1:6] # [2.5, 'DevCode', [5, 6], 4]
print lista[1:6:2] # [2.5, [5, 6]]
Como pueden darse cuenta podemos hasta insertar una lista dentro de otra lista.

Si no quieres estar imprimir uno por uno los elementos de una lista, puedes recorrerlo
utilizando un for.

for element in lista:

print element

METODOS DE LISTAS:

Las listas en Python tienen muchos métodos que podemos utilizar, entre todos ellos vamos
a nombrar los más importantes. Para esto utilizaremos esta lista de ejemplo.
my_list = [2, 5, 'DevCode', 1.2, 5]
Sobre esta vamos a realizar diferentes métodos que son propios de las listas.

Append()

Este método nos permite agregar nuevos elementos a una lista.

my_list.append(10) # [2, 5, 'DevCode', 1.2, 5, 10]

my_list.append([2,5]) # [2, 5, 'DevCode', 1.2, 5, [2, 5]]

Podemos agregar cualquier tipo de elemento a una lista, pero tengan en cuenta lo que
pasa cuando agregamos una lista dentro de otra, esta lista se agrega como uno y solo un
elemento.

Extend()
Extend también nos permite agregar elementos dentro de una lista, pero a diferencia
de append al momento de agregar una lista, cada elemento de esta lista se agrega como
un elemento más dentro de la otra lista.

my_list.extend([2,5]) # [2, 5, 'DevCode', 1.2, 5, 2, 5]

Remove()
El método remove va a remover un elemento que se le pase como parámentro de la lista a
donde se le esté aplicando.

my_list.remove(2) # [5, 'DevCode', 1.2, 5]

En este ejemplo estamos removiendo el elemento 2, de la lista que tiene por nombre
"my_list".

Index()
Index devuelve el número de indice del elemento que le pasemos por parámetro.
my_list.index('DevCode') # 2

Aquí estamos preguntando por el indice de la cadena 'DevCode' dentro de la lista

"my_list", esto devuelve 2.

Count()
Para saber cuántas veces un elemento de una lista se repite podemos utilizar el metodo
count().

my_list.count(5) # 2

Contamos cuantas veces se repite el número 5 dentro de la lista, y esto devuelve 2.

Reverse()
También podemos invertir los elementos  de una lista.

my_list.reverse() # [5, 1.2, 'DevCode', 5, 2]

DICCIONARIOS EN PHYTON
Un Diccionario es una estructura de datos y un tipo de dato en Python con características
especiales que nos permite almacenar cualquier tipo de valor como enteros, cadenas,
listas e incluso otras funciones. Estos diccionarios nos permiten además identificar cada
elemento por una clave (Key).

1. Para definir un diccionario, se encierra el listado de valores entre llaves. Las

parejas de clave y valor se separan con comas, y la clave y el valor se
separan con dos puntos.
2. diccionario = {'nombre' : 'Carlos', 'edad' : 22, 'cursos':
['Python','Django','JavaScript'] }

3. Podemos acceder al elemento de un Diccionario mediante la clave de este

elemento, como veremos a continuación:
4. print diccionario['nombre'] #Carlos
5. print diccionario['edad']#22
6. print diccionario['cursos'] #['Python','Django','JavaScript']

7. También es posible insertar una lista dentro de un diccionario. Para acceder

a cada uno de los cursos usamos los índices:
8. print diccionario['cursos'][0]#Python
9. print diccionario['cursos'][1]#Django
10. print diccionario['cursos'][2]#JavaScript

11. Para recorrer todo el Diccionario, podemos hacer uso de la estructura for:
12. for key in diccionario:
 13. print key, ":", diccionario[key]

Métodos de los Diccionarios

 dict ()

Recibe como parámetro una representación de un diccionario y si es factible,

devuelve un diccionario de datos.

dic = dict(nombre='nestor', apellido='Plasencia', edad=22)

dic → {‘nombre’ : 'nestor', ‘apellido’ : 'Plasencia', ‘edad’ : 22}

 zip()

Recibe como parámetro dos elementos iterables, ya sea una cadena, una lista o
una tupla. Ambos parámetros deben tener el mismo número de elementos. Se
devolverá un diccionario relacionando el elemento i-esimo de cada uno de los
iterables.

dic = dict(zip('abcd',[1,2,3,4]))

dic → {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

 items()

Devuelve una lista de tuplas, cada tupla se compone de dos elementos: el primero
será la clave y el segundo, su valor.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

items = dic.items()

items → [(‘a’,1),(‘b’,2),(‘c’,3),(‘d’,4)]

 keys()

Retorna una lista de elementos, los cuales serán las claves de nuestro diccionario.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

keys= dic.keys()

keys→ [‘a’,’b’,’c’,’d’]
 values()

Retorna una lista de elementos, que serán los valores de nuestro diccionario.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

values= dic.values()

values→ [1,2,3,4]

 clear()

Elimina todos los ítems del diccionario dejándolo vacío.

dic 1 = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

dic1.clean()

dic1 → { }

 copy()

Retorna una copia del diccionario original.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

dic1 = dic.copy()

dic1 → {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

 fromkeys()

Recibe como parámetros un iterable y un valor, devolviendo un diccionario que

contiene como claves los elementos del iterable con el mismo valor ingresado. Si el
valor no es ingresado, devolverá none para todas las claves.

dic = dict.fromkeys(['a','b','c','d'],1)

dic → {‘a’ : 1, ’b’ : 1, ‘c’ : 1 , ‘d’ : 1}

 get()

Recibe como parámetro una clave, devuelve el valor de la clave. Si no lo

encuentra, devuelve un objeto none.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

valor = dic.get(‘b’)

valor → 2
  pop()

Recibe como parámetro una clave, elimina esta y devuelve su valor. Si no lo

encuentra, devuelve error.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

valor = dic.pop(‘b’)

valor → 2
dic → {‘a’ : 1, ‘c’ : 3 , ‘d’ : 4}

 setdefault()

Funciona de dos formas. En la primera como get

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

valor = dic.setdefault(‘a’)

valor → 1

Y en la segunda forma, nos sirve para agregar un nuevo elemento a nuestro

diccionario.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

valor = dic.setdefault(‘e’,5)

dic → {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4 , ‘e’ : 5}

 update()

Recibe como parámetro otro diccionario. Si se tienen claves iguales, actualiza el

valor de la clave repetida; si no hay claves iguales, este par clave-valor es
agregado al diccionario.

dic 1 = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

dic 2 = {‘c’ : 6, ’b’ : 5, ‘e’ : 9 , ‘f’ : 10}
dic1.update(dic 2)

dic 1 → {‘a’ : 1, ’b’ : 5, ‘c’ : 6 , ‘d’ : 4 , ‘e’ : 9 , ‘f’ : 10}

FUNCIONES EN PHYTON
"Una función es una porción o bloque de código reutilizable que se encarga de
realizar una determinada tarea."
Sintaxis

Para empezar primero veremos como podemos definir o declarar una función.

def sumar():
pass

Para declarar una función solo se debe poner la palabra "def" seguido del nombre de la
función, para el ejemplo le hemos puesto "sumar", en los paréntesis deben ir los
parámetros, ya hablaremos de eso más adelante, por último la palabra "pass" es el
contenido de la función. Siempre tengan en cuenta la identación dentro de la función.

Para terminar con la función antes declara vamos a agregar el contenido.

def sumar():
print 5 + 10

sumar()

Con esto tenemos una función que suma 5 + 10, para llamar o activar a esta función,
ponemos el nombre la función seguido de paréntesis.

Parámetros

Si bien en el ejemplo anterior creamos una función que suma 5 + 10 eso no es suficiente,
ahora vamos a enviarle parámetros a esa función y sumar los datos que le enviemos.
Ahora el código.

def sumar(number1, number2):

print number1 + number2

sumar(10, 15) # 25

Con esto nuestra función sumar ahora recibe 2 parámetros, si ejecutan esto verán que el
resultado es 25. Sigamos viendo más variaciones en los parametros.

def sumar(number1, number2=20):

print number1 + number2

sumar(10, 15) # 25
sumar(10) # 30

En este caso el parámetro number2 tiene un valor por defecto, esto quiere decir que
cuando NO se le envie ese parámetro a la función, por defecto number2 tomará el valor de
20.

Orden de los parámetros

Cuando enviamos parámetros a una función, damos por hecho que el primer valor siempre
va al primer parámetro, el segundo valor con el segundo parámetro, y así con todo los que
haya, pero esto es algo que podemos cambiar gracias a Python. Veamos.

def sumar(number1, number2=20):

print number1 # 15
print number2 # 10
print number1 + number2

sumar(number2=10, number1=15) # 25

Al momento de llamar a la función, explícitamente le estamos diciendo que parámetro va a

tomar que valor, para verificar esto, impriman number1 y number2 y verán el valor que
tienen. Ya saben que no es necesario seguir el orden de los parámetros en la función,
pueden enviar los parámetros en el orden que deseen pero siempre poniendo
explícitamente el nombre del parámetro.

Por último veamos que también podemos enviar listas como parámetro.

Enviando listas como parámetro

def sumar(numbers):
result = 0
for number in numbers:
result += number
print result

sumar([4,5]) # 9

Con esto le podemos pasar la cantidad de elementos que queramos a la lista y la función
sumara todos los elementos.
Recibir diccionarios como parámetro

def sumar(**numbers):
print numbers # {'number1': 10, 'number2': 20}
print numbers['number1'] + numbers['number2']

sumar(number1=10, number2=20) # 30

De esta forma podemos enviar varios parámetros, y tomarlos en una sola variable.

3.12. Tipo conjuntos ¶

Un conjunto, es una colección no ordenada y sin elementos repetidos. Los usos
básicos de éstos incluyen verificación de pertenencia y eliminación de entradas
duplicadas.

Clase Tipo Notas Ejemplo

Mutable, sin
Conjunto orden, no
set set([4.0, 'Carro', True])
s contiene
duplicados.

Inmutable, sin
Conjunto orden, no
frozenset frozenset([4.0, 'Carro', True])
s contiene
duplicados.

3.12.1. Métodos

Los objetos de tipo conjunto mutable y conjunto inmutable integra una serie

de métodos integrados a continuación:

3.12.1.1. add()

Este método agrega un elemento a un conjunto mutable. Esto no tiene efecto si

el elemento ya esta presente.

>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])

>>> print set_mutable1

set([1, 2, 3, 4, 5, 7, 11])

>>> set_mutable1.add(22)

>>> print set_mutable1

set([1, 2, 3, 4, 5, 7, 11, 22])

3.12.1.2. clear()

Este método remueve todos los elementos desde este conjunto mutable.

>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])

>>> print set_mutable1

set([1, 2, 3, 4, 5, 7, 11])

>>> set_mutable1.clear()

>>> print set_mutable1

set([])

3.12.1.3. copy()

Este método devuelve una copia superficial del tipo conjunto

mutable o conjunto inmutable:

>>> set_mutable = set([4.0, 'Carro', True])

>>> otro_set_mutable = set_mutable.copy()

>>> set_mutable == otro_set_mutable

True

3.12.1.4. difference()

Este método devuelve la diferencia entre dos conjunto mutable o conjunto

inmutable: todos los elementos que están en el primero, pero no en el
argumento.

>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])

>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])

>>> print set_mutable1

set([1, 2, 3, 4, 5, 7, 11])

>>> print set_mutable2

set([2, 4, 5, 8, 9, 11])

>>> print set_mutable1.difference(set_mutable2)

set([1, 3, 7])

>>> print set_mutable2.difference(set_mutable1)

set([8, 9])

3.12.1.5. difference_update()

Este método actualiza un tipo conjunto mutable llamando al

método difference_update() con la diferencia de los conjuntos.

>>> proyecto1 = {'python', 'Zope2', 'ZODB3', 'pytz'}

>>> proyecto1

set(['python', 'pytz', 'Zope2', 'ZODB3'])

>>> proyecto2 = {'python', 'Plone', 'diazo'}

>>> proyecto2

set(['python', 'diazo', 'Plone'])

>>> proyecto1.difference_update(proyecto2)

>>> proyecto1

set(['pytz', 'Zope2', 'ZODB3'])

Si proyecto1 y proyecto2 son dos conjuntos. La diferencia del

conjunto proyecto1 y conjunto proyecto2 es un conjunto de elementos que
existen solamente en el conjunto proyecto1 pero no en el conjunto proyecto2.

3.12.1.6. discard()

Este método remueve un elemento desde un conjunto mutable si esta presente.

>>> paquetes = {'python', 'zope', 'plone', 'django'}

>>> paquetes

set(['python', 'zope', 'plone', 'django'])

>>> paquetes.discard('django')

>>> paquetes

set(['python', 'zope', 'plone'])

El conjunto mutable permanece sin cambio si el elemento pasado como

argumento al método discard() no existe.

>>> paquetes = {'python', 'zope', 'plone', 'django'}

>>> paquetes.discard('php')

>>> paquetes

set(['python', 'zope', 'plone'])

3.12.1.7. intersection()

Este método devuelve la intersección entre los conjuntos mutables o conjuntos

inmutables: todos los elementos que están en ambos.

>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])

>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])

>>> print set_mutable1

set([1, 2, 3, 4, 5, 7, 11])

>>> print set_mutable2

set([2, 4, 5, 8, 9, 11])

>>> print set_mutable1.intersection(set_mutable2)

set([2, 11, 4, 5])

>>> print set_mutable2.intersection(set_mutable1)

set([2, 11, 4, 5])

3.12.1.8. intersection_update()
Este método actualiza un conjunto mutable con la intersección de ese mismo y
otro conjunto mutable.

El método intersection_update() le permite arbitrariamente varios numero de

argumentos (conjuntos).

>>> proyecto1 = {'python', 'Zope2', 'pytz'}

>>> proyecto1

set(['python', 'pytz', 'Zope2'])

>>> proyecto2 = {'python', 'Plone', 'diazo', 'z3c.form'}

>>> proyecto2

set(['python', 'z3c.form', 'diazo', 'Plone'])

>>> proyecto3 = {'python', 'django', 'django-filter'}

>>> proyecto3

set(['python', 'django-filter', 'django'])

>>> proyecto3.intersection_update(proyecto1, proyecto2)

>>> proyecto3

set(['python'])

La intersección de dos o mas conjuntos es el conjunto de elemento el cual es

común a todos los conjuntos.

3.12.1.9. isdisjoint()

Este método devuelve el valor True si no hay elementos comunes entre

los conjuntos mutables o conjuntos inmutables.

>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])

>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])

>>> print set_mutable1

set([1, 2, 3, 4, 5, 7, 11])

>>> print set_mutable2

set([2, 4, 5, 8, 9, 11])

>>> print set_mutable1.isdisjoint(set_mutable2)

3.12.1.10. issubset()

Este método devuelve el valor True si el conjunto mutable es

un subconjunto del conjunto mutable o del conjunto inmutable argumento.

>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])

>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])

>>> set_mutable3 = set([11, 5, 2, 4])

>>> print set_mutable1

set([1, 2, 3, 4, 5, 7, 11])

>>> print set_mutable2

set([2, 4, 5, 8, 9, 11])

>>> print set_mutable3

set([2, 11, 4, 5])

>>> print set_mutable2.issubset(set_mutable1)

False

>>> print set_mutable3.issubset(set_mutable1)

True

3.12.1.11. issuperset()

Este método devuelve el valor True si el conjunto mutable o el conjunto

inmutable es un superset del conjunto mutable argumento.

>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])

>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])

>>> set_mutable3 = set([11, 5, 2, 4])

>>> print set_mutable1

set([1, 2, 3, 4, 5, 7, 11])

>>> print set_mutable2

set([2, 4, 5, 8, 9, 11])

>>> print set_mutable3

set([2, 11, 4, 5])

>>> print set_mutable1.issuperset(set_mutable2)

False

>>> print set_mutable1.issuperset(set_mutable3)

True

3.12.1.12. pop()

Este método remueve arbitrariamente y devuelve un elemento de conjunto

mutable. El método pop() no toma ningún argumento. Si el conjunto
mutable esta vacío se lanza una excepción KeyError.

>>> paquetes = {'python', 'zope', 'plone', 'django'}

>>> paquetes

set(['python', 'zope', 'plone', 'django'])

>>> print "Valor aleatorio devuelto es:", paquetes.pop()

Valor aleatorio devuelto es: python

>>> paquetes

set(['zope', 'plone', 'django'])

>>> print "Valor aleatorio devuelto es:", paquetes.pop()

Valor aleatorio devuelto es: zope

>>> paquetes

set(['plone', 'django'])

>>> print "Valor aleatorio devuelto es:", paquetes.pop()

Valor aleatorio devuelto es: plone

>>> paquetes

set(['django'])

>>> print "Valor aleatorio devuelto es:", paquetes.pop()

Valor aleatorio devuelto es: django

>>> print "Valor aleatorio devuelto es:", paquetes.pop()

Valor aleatorio devuelto es:

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

KeyError: 'pop from an empty set'

Tenga en cuenta que usted podría obtener diferente salida devueltas usando el
método pop() por que remueve aleatoriamente un elemento.

3.12.1.13. remove()

Este método busca y remueve un elemento de un conjunto mutable, si debe ser

un miembro.

>>> paquetes = {'python', 'zope', 'plone', 'django'}

>>> paquetes

set(['python', 'zope', 'plone', 'django'])

>>> paquetes.remove('django')

>>> paquetes

set(['python', 'zope', 'plone'])

Si el elemento no es existe en el conjunto mutable, lanza una

excepción KeyError. Usted puede usar el método discard() si usted no quiere
este error. El conjunto mutable permanece sin cambio si el elemento pasado al
método discard() no existe.

Un conjunto es una colección desordenada de elementos. Si usted quiere remover

arbitrariamente elemento un conjunto, usted puede usar el método pop().
3.12.1.14. symmetric_difference()
Este método devuelve todos los elementos que están en un conjunto
mutable e conjunto inmutable u otro, pero no en ambos.

>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])

>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])

>>> print set_mutable1

set([1, 2, 3, 4, 5, 7, 11])

>>> print set_mutable2

set([2, 4, 5, 8, 9, 11])

>>> print set_mutable1.symmetric_difference(set_mutable2)

set([1, 3, 7, 8, 9])

3.12.1.15. symmetric_difference_update()

Este método actualiza un conjunto mutable llamando al

método symmetric_difference_update() con los conjuntos de diferencia
simétrica.

La diferencia simétrica de dos conjuntos es el conjunto de elementos que están en

cualquiera de los conjuntos pero no en ambos.

>>> proyecto1 = {'python', 'plone', 'django'}

>>> proyecto1

set(['python', 'plone', 'django'])

>>> proyecto2 = {'django', 'zope', 'pyramid'}

>>> proyecto2

set(['zope', 'pyramid', 'django'])

>>> proyecto1.symmetric_difference_update(proyecto2)

>>> proyecto1

set(['python', 'zope', 'pyramid', 'plone'])

El método symmetric_difference_update() toma un argumento simple de un
tipo conjunto mutable.

3.12.1.16. union()

Este método devuelve un conjunto mutable y conjunto inmutable con todos

los elementos que están en alguno de los conjuntos mutables y conjuntos
inmutables.

>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])

>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])

>>> print set_mutable1

set([1, 2, 3, 4, 5, 7, 11])

>>> print set_mutable2

set([2, 4, 5, 8, 9, 11])

>>> print set_mutable1.union(set_mutable2)

set([1, 2, 3, 4, 5, 7, 8, 9, 11])

3.12.1.17. update()

Este método agrega elementos desde un conjunto mutable (pasando como un

argumento) un tipo tupla, un tipo lista, un tipo diccionario o un tipo conjunto
mutable llamado con el método update().

A continuación un ejemplo de agregar nuevos elementos un tipo conjunto

mutable usando otro tipo conjunto mutable:

>>> version_plone_dev = set([5.1, 6])

>>> version_plone_dev

set([5.1, 6])

>>> versiones_plone = set([2.1, 2.5, 3.6, 4])

>>> versiones_plone

set([2.5, 3.6, 2.1, 4])

>>> versiones_plone.update(version_plone_dev)
>>> versiones_plone

set([2.5, 3.6, 4, 6, 5.1, 2.1])

A continuación un ejemplo de agregar nuevos elementos un tipo conjunto

mutable usando otro tipo cadena de caracteres:

>>> cadena = 'abc'

>>> cadena

'abc'

>>> conjunto = {1, 2}

>>> conjunto.update(cadena)

>>> conjunto

set(['a', 1, 2, 'b', 'c'])

A continuación un ejemplo de agregar nuevos elementos un tipo conjunto

mutable usando otro tipo diccionario:

>>> diccionario = {'key': 1, 2:'lock'}

>>> diccionario.viewitems()

dict_items([(2, 'lock'), ('key', 1)])

>>> conjunto = {'a', 'b'}

>>> conjunto.update(diccionario)

>>> conjunto

set(['a', 2, 'b', 'key'])

3.12.2. Convertir a conjuntos

Para convertir a tipos conjuntos debe usar las funciones set() y frozenset(), las

cuales están integradas en el interprete Python.

Truco
Para más información consulte las funciones integradas para operaciones de
secuencias.
3.12.3. Ejemplos

3.12.3.1. Conjuntos set

A continuación, se presentan un ejemplo de conjuntos set:

# crea un conjunto sin valores repetidos y lo asigna la variable

para_comer = set([

'pastel', 'tequeno', 'papa', 'empanada', 'mandoca'])

print para_comer, type(para_comer)

para_tomar = set(['refresco', 'malta', 'jugo', 'cafe'])

print para_tomar, type(para_tomar)

# usa operaciones condicionales con operador in

hay_tequeno = 'tequeno' in para_comer

hay_fresco = 'refresco' in para_tomar

print "\nTostadas A que Pipo!"

print "===================="

# valida si un elemento esta en el conjunto

print "Tenéis tequeno?:", 'tequeno' in para_comer

# valida si un elemento esta en el conjunto

print "Tenéis pa' tomar fresco?:", 'refresco' in para_tomar

if (hay_tequeno and hay_fresco):

print "Desayuno vergatario!!!"

else:

print "Desayuno ligero"

3.12.3.2. Conjuntos frozenset

A continuación, se presentan un ejemplo de conjuntos frozenset:

>>> versiones_plone = frozenset([6, 2.1, 2.5, 3.6, 4, 5, 4, 2.5])

>>> print versiones_plone, type(versiones_plone)

frozenset([2.5, 4, 5, 6, 2.1, 3.6]) <type 'frozenset'>

Los elementos de un set son únicos (sin repeticiones dentro del set), y deben ser
objetos inmutables: números, cadenas de caracteres, tuplas y sets inmutables,
pero no listas ni sets mutables.

3.12.4. Ayuda integrada

Usted puede consultar toda la documentación disponible sobre los conjuntos

set desde la consola interactiva de la siguiente forma:

>>> help(set)

Usted puede consultar toda la documentación disponible sobre los conjuntos

frozenset desde la consola interactiva de la siguiente forma:

>>> help(frozenset)

Para salir de esa ayuda presione la tecla q.

Generar números aleatorios entre dos valores en Python

randint(a, b)

Para generar números aleatorios en Python de valor entero, se suele utilizar la

función  randint() . La función  randint(a, b)  devuelve un
número entero comprendido entre  a  y  b  (ambos inclusive) de forma aleatoria.
Ejemplos útiles de esta función: determinar quién comienza una partida
(jugador/PC); simular el dado del parchís, etc:
import random

# ¿Quién comienza?

comienza = random.randint(0, 1)

if comienza == 0:

print('Comienza el jugador')

else:

print('Comienza el PC')

# Número aleatorio del parchís

numero = random.randint(1, 6)

randrange(a, b, salto)

La función  randrange(a, b, salto)  genera números enteros aleatorios

comprendidos entre  a  y  b  separados entre sí con un  salto . Por
ejemplo,  randrange(5, 27, 4)  obtendría un valor aleatorio de entre los
siguientes posibles:  5, 9, 13, 17, 21, 25 .

>>> import random

>>> for i in range(10):

... print(random.randrange(5, 27, 4))

...

17

13

17

13

25

random()

La función  random()  devuelve un float comprendido entre [0.0 y 1.0)

>>> import random

>>> for i in range(5):

... print(random.random())

...

0.6355590910913725

0.38870490605141683

0.3757381647176976

0.38770694501889935

0.22472067642268556

uniform(a, b)

La función  uniform(a, b)  devuelve un float aleatorio comprendido

entre  a  y  b  (ambos inclusive).

>>> import random

>>> for i in range(5):

... print(random.uniform(100, 200))

...

170.3543065193162

103.47025653056637

126.52588283656675

169.60671144065486

145.21872629322894

Obtener elementos aleatorios de una secuencia

Hasta ahora hemos visto cómo obtener números aleatorios en Python. A

continuación veremos que también es posible obtener elementos aleatorios de
una secuencia.

choice()

La función  choice(sec)  devuelve un elemento aleatorio de una secuencia. Es

muy útil cuando hay que elegir al azar un elemento de entre un conjunto.
>>> import random

>>> frutas = ['peras', 'manzanas', 'plátanos', 'ciruelas']

>>> for i in range(3):

... print(random.choice(frutas))

...

peras

ciruelas

plátanos

shuffle()

La función  shuffle(sec)  modifica el orden de los elementos de una lista. Esta

función se asemeja a la acción de mezclar una baraja.

>>> import random

>>> baraja = [1, 2, 3, 4, 5, 6, 7, 10, 11, 12]

>>> for i in range(3):

... random.shuffle(baraja)

... print(baraja)

...

[11, 3, 2, 6, 12, 10, 5, 4, 1, 7]

[7, 3, 1, 10, 6, 12, 2, 11, 5, 4]

[1, 11, 3, 2, 4, 12, 5, 10, 7, 6]

sample()

La última función que veremos es  sample(sec, num) . Esta función

devuelve  num  elementos aleatorios de la secuencia  sec . Siguiendo con el
ejemplo de la baraja, sería similar a la acción de repartir  num  cartas a un
jugador.

>>> import random

>>> baraja = [1, 2, 3, 4, 5, 6, 7, 10, 11, 12]

>>> random.sample(baraja, 5)

[2, 1, 4, 11, 12]