• Curso De Python3 Desde 0 (3ra Parte)

 #398737  por KHC
 22 Dic 2012, 11:10
Bueno con esto del propósito navideño y sarta de tonterías --y para purgar mis pecados--, les dejo la tercera parte de este cursito, que no por ser muy corto
y sintetizado deja de ser bueno. Con las mejores intenciones para que todo puedan aprender de una forma simple y GRATUITA!
También estoy metiendo conceptos poco a poco e inconscientemente para la gente que no tiene experiencia con otros lenguajes orientados a objetos, mas
adelante no tenga ningún problema y aprendan a trata un lenguaje como se debe! DISFRUTEN LA LECTURA!



Operaciones Con Strings
------------------------------


El operador + nos permite concatenar dos strings, es decir unirlos, sin olvidar que el resultado será almacenado en una variable si el usuario lo indica.
>>> cad1 = 'hello'
>>> cad2 = 'world!'
>>> cad1 + cad2
'helloworld!'
>>> cad3 = cad1 + cad2
>>> print(cad3)
helloworld!
>>> cad4 = 'hello ' + 'world'
>>> print(cad4)
hello world
Puse de ejemplo varias formas de hacer el concatenamiento.
Ahora esta forma es muy útil y simple pero a veces necesitamos algo mas formal y elegante, aquí entra en juego el método format().
Tiene una forma de uso que tenemos que respetar al momento de utilizarlo, como por ejemplo usar {}. para indicar las variables locales que utilizaremos dentro de la cadena de texto.
>>> var1 = 'world'
>>> var2 = 'example'
>>> 'hello {0}. this is an {1}.'.format(var1, var2)
'hello world. this is an example.'
>>> 'hello {var1}. this is an {var2}.'.format(var1="WORLD", var2="EXAMPLE")
'hello WORLD. this is an EXAMPLE.'
Bueno el primer ejemplo definimos las variables antes de usar el método format() y al momento de utilizar format() sobre la cadena de texto como argumentos se pasan las variables como argumentos.
No es obligatorio usar {0}. como incidamos en el primer ejemplo.
En el segundo vemos que al momento de usar {}. indicamos directamente el nombre de la variable en lugar de usar un numero y también al
indicar los argumentos (var1, var2), podemos redefinir las variables. Estos son algunos ejemplo ya que hay muchas formas de hacerlo
ya que Python es muy versátil.

Funciones int(), str() e input()
-------------------------------------


Hablando de strings, también podemos concatenar números a strings utilizando el método format() o utilizando el operador “+”:
>>> "hello world " + str(num)
'hello world 7'
Si quisiéramos convertir un str a int – obviamente cumpliendo las condiciones—podemos utilizar la función int():
>>> input("ingrese un numero: ")
ingrese un numero: 1337
'1337'
Compliquemos lo un poco mas para explicar algunas cosas:
>>> print('Tu variable contiende: {0}.'.format(int(nume)))
Tu variable contiende: 1337.

Bueno primeramente utilizamos la función print() indicando un texto que es ‘Tu variable contiene:’
{0}. como sabemos, sirve para indicar a format donde insertar el argumento indicado, seguido del string que utilizamos,
invocamos al método .format() y como argumento único –en este caso--, le decimos que tome la variable nume pero con una condición simple
y es que con int() nos transforme el ‘str’ que tomamos con input() anteriormente y lo agregue con el formato correcto.
Creo que exprese bien los dos métodos que faltaban input() e int(), analizar un poco si les queda alguna duda.
Ahora también podemos utilizar otros operadores como * veamos como:
>>> nombre = input('Ingresa tu nombre: ')
Ingresa tu nombre: julianstafari
>>> print(nombre * 7)
Julianstafarijulianstafarijulianstafarijulianstafarijulianstafarijulianstafarijulianstafari
Esto es bastante intuitivo ;).

También Python ofrece otros operador como es el caso de ‘ in ‘, y nos permite averiguar si se encuentra un carácter dentro de un string
y recibimos como resultado un ‘True’ o ‘False’, ya sea el caso.
>>> 'julian' in nombre
True
>>> 'z' in nombre
False
Ya que ‘julian’ se encuentra en la variable nombre, pero ‘z’ no se encuentra dentro de la variable nombre, realmente esto es muy simple
y creo que el mismo nombre indica para que sirve ‘in’ ‘en’ en español xD.
Como mencione, en Python los strings son inmutables y eso explica que cada vez que utilizamos un método –o casi siempre-- que ofrece los strings,
nos regrese el resultado en pantalla y no nos modifique el contenido de la/las variables :3, pero aun así podemos acceder a algún elemento que forme parte del string:
>>> print(nombre[4])
a
Para esto utilizamos ‘[]’ , si queremos acceder al contenido apartir de un carácter en concreto indicamos con : y el lugar donde se sitúa el carácter:
>>> print(nombre[:4])
juli
>>> print(nombre[4:])
anstafari
Bueno si utilizamos : antes del número que indica la posición del carácter, nos mostrara todos los caracteres que se encuentren antes del indicado y si
utilizamos : después nos mostrar los caracteres que se encuentren después del carácter indicado
–no olvidar que toma también el carácter que se indica—por eso muetsra ‘anstafari’.
Tambien podemos acceder a algún elemento indicando de derecha a izquierda la posición del elemento, utilizando entero negativo:
>>> print(nombre[-9])
a
Tuplas
--------------


Las tuplas en Python, son una estructura de datos que representa una colección de objetos y pueden ser de distintos tipos .
Internamente Python para representar una tupla, utiliza un array de objetos que almacena referencias hacia estos objetos.
Para definir una tupla se utiliza paréntesis ‘ ( ) ’ y todos los elementos se sepran con comas ‘ , ‘
>>> tup = (3, 13.37, 'j', 'u')
>>> tup
(3, 13.37, 'j', 'u')

Y podemos acceder a sus elementos con el índice como en los arrays:
>>> tup[1]
13.37
Y el mismo principio, se cuenta el primer elemento como 0 y así sucesivamente.
Las tuplas son inmutables y no podemos agregar directamente ni modificar elementos con el índice.
>>> tup[1] = 13.3
Traceback (most recent call last):
  File "<pyshell#47>", line 1, in <module>
    tup[1] = 13.3
TypeError: 'tuple' object does not support item assignment
La ultima línea TypeError, nos dice que el objeto ‘tuple’ no soporta la asignación de elementos.
También podemos anidar tuplas y arrays dentro de la tupla:
>>> tup = (3, ('ju','lian'), 13.37)
>>> tup
(3, ('ju', 'lian'), 13.37)
>>> tup = (3, ['ju','lian'], 13.37)
>>> tup
(3, ['ju', 'lian'], 13.37)
Es interesante las tuplas, puesto que nos permite hacer distintas cosas con ellas, una de ellas es iterarlas es decir recorrerlas.
Ahora adelantare un poco, si no entienden como funciona el bucle for no se preocupen lo veremos mas adelante:
>>> for x in tup:
	print(x)	
3
['ju', 'lian']
13.37
Bueno es simple indicamos el bucleo con la palabra clave ‘for’ seguido de una variable local que yo nombre ‘x’ y puede poner el nombre que quieran,
seguimos con la palabra clave in que acabo de ver y seguido del objeto a iterar que en este caso es la tupla con que le asignamos
la variable tup y ‘:’, damos enter y fijaros que nos cambia de línea y nos da una marginación como si hubiéramos puesto la tecla ‘tab’
y seguido llamamos a la función print() y le pasamos como argumento la variable local x. Como resultado nos regresa cada uno de los elemento
y mas adelante les explicare como funciona al 100% x 100% el bucle ‘for’ ya que eso es control de flujo.

También podemos aplicar operadores sobre las tuplas por ejemplo:
>>> print(tup * 3)
(3, ['ju', 'lian'], 13.37, 3, ['ju', 'lian'], 13.37, 3, ['ju', 'lian'], 13.37)
Vemos que al multiplicar la tupla por si misma tres veces, nos regresa otra tupla –ya que son inmutables—con todos los elementos de la
tupla ‘tup’ tres veces cada uno es decir cada elemento 3 veces.
Algunos de los principales métodos que incluyen las tuplas index() y count() –quizá los mas usados--, el primero nos regresa la posición del elemento solicitado –este se pasa como argumento-- :
>>> tup.index(13.37)
2
Lo mismo se cuenta de 0 en adelante y bueno indicamos el objeto ‘tup’ . y el método que es index(), pasándole como argumento el elemento
que de ante mano sabes que se encuentra y nos regresa un int con la posición donde se encuentra.
Ahora el segundo ejemplo nos regresa el numero de veces que se repite un elemento en una tupla:
>>> tup = (1,2,6,43,2,7,3,1,9,6,1)
>>> tup.count(1)
3
Bueno, redefinimos la tupla para que contenga elementos que se repiten y después lo mismo ¡¡¡Objeto Metodo Argumento!!!
Y nos regresa un int con el numero de veces que se repite el elemento solicitado.

Listas
----------


Las listas, son una colección ordenada de objetos parecido a los arrays dinámicos en otros lenguajes.
Python ofrece distintos métodos y funciones para trabajar estas y pueden contener distintos tipos de objetos y a deferencia de las tuplas
estas son mutable; se definen con ‘[]’ y sus elementos se separan por comas ‘ , ‘:
li = [1, 'tres',3 , 7]
>>> print(li)
[1, 'tres', 3, 7]
También son iterables y con un bucle ‘for’ podemos deslizarnos entre sus elementos:
>>> for x in li:
	print(x)
1
tres
3
7
Como dije, las listas son mutables y esto quiere decir que podemos modificar por índice algún elemento de esta, indicando la posición del elemento:
>>> len(li)
4
>>> li[-1] = 'siete'
>>> ‘1’ in li
False
>>> 1 in li
True
>>> print(li[-1])
Siete
>>> print(li)
[1, 'tres', 3, 'siete']

Con len() obtenemos el numero total de elemento –aquí si se cuenta desde el 1—y bueno si notaron accedí al ultimo elemento
– es decir el 0,1,2,3 el tercero—pero usando -1 pues se puede acceder también de esta forma a los elemento y si se usa índice negativo,
se cuenta desde el -1 y así drecrementando la cuenta y tan solo se le asigna la el nuevo elemento con el operador ‘ = ‘.
Si notaron, pregunte de dos formas si existía el elemento 1 en la lista. Cuando utilizo ‘1’ con comillas, me regresa false,
puesto que lo esta tratando como ‘str’, cuando pregunto lo mismo pero sin comillas regresa True ya que reconoce que el tipo es int.
También podemos aplicar los operadores a las listas como ‘+’ ‘*’.

Inserción y Borrado En Listas
----------------------------------


Para agregar elementos a la lista, Python nos brinda el método append() y solo se pasa como argumento el elemento que deseamos agregar y será agregado automáticamente al final de la lista:
>>> li.append('greydotsec')
>>> print(li)
[1, 'tres', 3, 'siete', 'greydotsec']
Y si lo desean insertar por índice salta un error así que utilicemos append() para evitar errores : )
Ahora si lo que queremos es agregarlo en una posición específica, contamos con el método insert() y este tomas dos argumentos:
el primero es la posición donde será insertado el elemento y el segundo es el elemento en cuestión, si se indica un índice mayor que el número
de elementos que la lista contiene, se agrega hasta el final sin más:
>>> li.insert(1, 'free software')
>>> print(li)
[1, 'free software', 'tres', 3, 'siete', 'greydotsec']
Si lo notaron aquí también se empieza por el elemento 0 y como indique la posición 1 – que realmente es la segunda posición—
me agrega el elemento en de forma correcta.
Si tenemos métodos para agregar elementos, por obvias razones también tenemos métodos para eliminarlos, uno de estos es del()
–solo que esta es una función, pero igual sirve-- y toma como argumento el elemento en cuestión:
>>> del(li[0])
>>> print(li)
['free software', 'tres', 3, 'siete', 'greydotsec']
En lo personal usar del() en listas es una forma muy burda de hacer las cosas y tenemos métodos propios para las listas como es pop() y
toma como argumento la posición del elemento en cuestión y este método no es del tipo void y nos regresa un valor que es el mismo elemento
que acabamos de eliminar:
>>> li.pop(2)
3
También contamos con remove() que nos permite eliminar un elemento en base al valor, es decir que busca en la lista si se encuentra el valor indicado,
si lo encuentra lo elimina:
>>> li.remove('tres')
>>> print(li)
['free software', 'siete', 'greydotsec']
Ordenación En Listas
-----------
Bueno nuestras listas también puede ser ordenadas –por obvias razones—y para esto contamos con la función sorted() y toma como primer argumento
toma la lista --en cuestión un objeto iterable-- , como segundo se puede aplicar reverse con valor en True o en False
para cambiar invertir el orden de la lista, por defecto se pone a false se indique o no y se ordenan de mayor a menor.
El tercer elemento –que realmente debería ser el objeto iterable, la clave y reverse-- seria la clave pero esto es para los diccionarios ya que es una
función y no un método propio de las listas, también se ocupa pero la omitiré porque es mucho trabajo:
>>> print(li)
['free software', 'siete', 'greydotsec']
>>> sorted(li, reverse=False)
['free software', 'greydotsec', 'siete']
>>> sorted(li, reverse=True)
['siete', 'greydotsec', 'free software']
Si pusieron atención y recuerda lo que les he dicho, notaron que nos regresa un nuevo objeto con al lista ordenada o como la pedimos
–puesto que es una función—y no es propia de las listas, si por el contrario utilizamos sort() que es un método propio de las listas,
la lista se vera alterada –el objeto en memoria—:
>>> li.sort()
>>> print(li)
['free software', 'greydotsec', 'siete']
El mismo principio --lo estoy haciendo apropósito para ir inculcando en el lector la POO Programación Orientada a Objetos—
Objeto, método y argumento(s), pero a diferencia este si se modifica y no nos regresa nada y pasamos a imprimir con print() el contenido de 'li'
y vemos que el objeto en concreto fue modificado, pero respetando nuestro puntero –realmente lo es--, instancia o como la conocemos ‘variable’ li,
pero bueno eso es un cuento aparte :P

Otro método relacionado con la ordenación y que es propio de las listas es reverse() y no toma ningún argumento y sirve para invertir el orden de los elementos que contiene la lista y recordar que este si afecta directamente a la lista:
>>> li.reverse()
>>> print(li)
['siete', 'greydotsec', 'free software']
Recuerden el mismo principio: Objeto, método y argumento(s).

Comprensión En Listas
-----------------


La compresión de listas en Python nace de una teoría matemática llamada Comprensión De Conjuntos y consiste básicamente
en la declaración de una lista atreves de la creación de otra.
Este teorema afirma que un conjunto se define por comprensión cundo sus elementos son nombrados a través de sus características.
Para entender mejor un ejemplo:
>>> li2 = [x for x in (1,2,3,4,5,6)]
>>> print(li2)
[1, 2, 3, 4, 5, 6]
Y obtenemos como resultado una lista con todos los elementos.
Explico, se define la variable que contendrá la lista ‘lis2’, seguido del operador de asignación y [], dentro de [] tenemos que x será la variable local
–la que almacenara la lista—, la palabra clave ‘for’ que indica el bucle for y otra variable local que será x –pueden usar lo que deseen para estas—
seguida de la palabra clave in que ya vimos para que sirve – en— y como esto es un método en concreto –lo veremos más adelante—
utilizamos () para indicar los elementos separados por comas.
Como resultado obtenemos la lista declarada a partir de definir otra y lo que pasa es que cada elemento que recorre el bucle ‘for’ es almacenado en x
– la primera que es una lista—, a decir verdad las dos son variables locales, solo que la primera esta en otro nivel más alto que la segunda,
ya que la segunda corresponde al bucle ‘for’ y la primera a la lista que estamos declarando, si analizamos nos damos cuenta que el bucle
está dentro de la lista y es como una mini función –algo así como lambda que veremos más adelante, pero es muy distinta—
y asi se construye nuestra lista interesante no? :P
>>> li3 = []
>>> for x in (1,2,3,4,5,6):
	li3.append(x)

	
>>> print(li3)
[1, 2, 3, 4, 5, 6]
Este seria otra forma de obtener el mismo resultado, si no aplicáramos el teorema de la compresión de conjuntos.
Definimos la lista vacía referenciada en li3, después iniciamos el bucle ‘for’, la variable local ‘x’ donde será almacenado cada elemento
en cada ciclo que realice el bucle, seguida de la palabra reservada ‘in’ –en— y le damos un conjunto de valores que será usados para
que el bucle ‘for’ funcione y los :. No da la marginación y el mismo principio –Objeto, método y argumento(s)— que ya vimos para que sirve append(),
le pasamos la variable local x y así va agregando nuestros elementos en cada ciclo y listo ;).
A decir verdad esta explicación se parece más a el funcionamiento del bucle ‘for’ que a cómo funciona xD, pero está bien así vamos adelantando temas,
una pequeña introducción y cuando toquemos el tema no estarán tan perdidos.

Matrices
----------------


Se pueden crear matrices anidando listas – a decir verdad las listas son los arrays— y esta estructura de datos son muy usado,
útiles en las matemáticas y no solo en ese campo.
Ahora una matriz bidimensional o un array bidimensional --NO CONFUNDIR ARRAYS CON ARREGLOS, UN ARRAY ES UN VECTOR!!!!-- se puede definir de la siguiente forma:
>>> ma1 = [[1,3],[3,7]]
>>> print(ma1)
[[1, 3], [3, 7]]
Para acceder a la primera lista dentro de la matriz lo podemos hacer mediante índices:
>>> print(ma1[0][:])
[1, 3]
En este caso se llama invoca a la función print(), y como parámetro le pasamos la matriz ‘ma1’ y el primer índice hace referencia al primer
elemento de la matriz que es nuestra primera lista [1,3] y el segundo índice hace referencia a los elementos que contiene la que indicamos
antes con el primer índice, en este caso yo deje ‘[:]’ para que me muestre todos los elementos, pero podemos acceder al que queramos como ya sabemos.
Si quisiéramos revisar el segundo elemento de la segunda lista podría ser así:
>>> print(ma1[1][1])
7
Y como son listas y bien sabemos que son mutables podemos cambiar directamente un valor, agregar, eliminar, popear, etc...
>>> ma1[1][1]= 'siete'
>>> print(ma1)
[[1, 3], [3, 'siete']]
También podemos crear matrices unidimensionales que es un maldito array simple xD, bidimensionales y unidimensionales, de todos tamaños.

Diccionarios
----------------


Un diccionario es una estructura de datos de distintos tipos y que permite utilizar a otros para referenciar, accesar y su almacenamiento.
Son mutables, se puede iterar sobre ellos pero Python, decide el orden que tendrá cada uno.
Cada elemento dentro de un diccionario es un par clave-valor, donde el primero es el que vamos a usar para referencia al valor
–como una ‘variable local’— y no puede ser repetida, es decir que tiene que ser única y el valor puede ser cualquier tipo de datos aceptado por pytho,
es decir strings, ints, floats, tuplas, diccionarios, listas, etcétera.
Son muy utilizadas en Python y esto es por que son rápidas y sencillas, mientras que Python internamente las trata como una tabla hash
y una buen razón es que permite aumentar dinámicamente el número de ellos.

En fin, para declarar un diccionario en Python –no confundir con los conjuntos— se utilizan ‘{}’ donde se encuentran nuestros pares
–clave-valor— separados por comas ‘ , ’ y nuestros pares se separan por ‘ : ‘ example:
>>> dic1 = {'nombre' : 'julianstafari', 'nucleo': 'hurd', 'edad': 1337}
>>> print(dic1)
{'edad': 1337, 'nombre': 'julianstafari', 'nucleo': 'hurd'}
Donde mi nombre es julianstafari, mi núcleo es hurd y tengo 1337 años xD.
Bueno cuando escriba textos, se ponen los datos que quieran : ).
Python, también nos brinda una función para construir nuestros dic’s, dict() como podrán haber deducido, nos permite crear diccionarios,
tomando como argumentos los pares que formaran parte de nuestro diccionario:
>>> dic2 = dict(nombre='juanito', nucleo='bsd', edad=47)
>>> print(dic2)
{'edad': 47, 'nombre': 'juanito', 'nucleo': 'bsd'}
Bueno el pinche Juanito tiene 47 años y usa bsd de núcleo xD.
A diferencia de indicarlo directamente al instaciarlo con nuestra variable dic1 –en nuestro primer caso—, la función dict(),
nos ordena el diccionario por orden, dejando edad como primer ítem, nombre como segundo y núcleo como tercer,
a pesar de que al usar la función los ordenamos de otra forma y deben tener esto en cuenta –if you know what i mean—.

Acceso, Inserción y Borrado En Diccionarios
---------------------------------


Como vimos en las listas, vectores y tuplas podemos acceder directamente mediante el índice, pero en los diccionarios cambia esto
y en lugar del índice del elemento que queremos consultar o modificar, tendremos que hacerlo por medio de la clave:
>>> dic1['nombre']
'julianstafari'
Hay güeyyyyyyyy, simple no? Bueno, a lo mejor los que no estén familiarizados con otros lenguajes de programación,
no entiende la funcionalidad que eso tiene, pero créanme por algo es una Python grande, mucho muy grande xD.
Y si, si podemos modificar un elemento directamente con su clave:
>>> dic1['edad'] = 31337
>>> print(dic1['edad'])
31337
Bueno ahora tengo 31337 años y a diferencia de cómo lo hacíamos, ahora llamamos a print() pasando como argumento
la clave ‘edad’ del diccionario ‘dic1’. Creo que bastante claro y preciso.
Si lo que deseamos es agregar nuevos elementos a nuestro diccionario tan simple como indicar como se llamara la clave y el valor que contendrá:
>>> dic1['comunidad'] = 'indetectables.net'
>>> print(dic1)
{'edad': 31337, 'nombre': 'julianstafari', 'nucleo': 'hurd', 'comunidad': 'indetectables.net'}
Simple no? Python al no encontrar la clave que se le indica la agrega automáticamente y como le estamos asignando un valor con
el operador ‘=’ nos agrega el valor a la clave creada : ).

Ahora, los 3 principales métodos –o los más comunes— que suelen utilizarse para trabajar con los diccionarios en Python son ítems(), values() y keys().
El primero ‘items()’nos da la clave y el valor de todos los elementos del diccionario, el segundo ‘values()’, nos regresa todos los valores dentro
del diccionario y ‘keys()’ nos regresa las claves que tienen el diccionario:
>>> for x, y in dic1.items():
	print("clave: {0} \t valor: {1}".format(x, y))

clave: edad 	 valor: 31337
clave: nombre 	 valor: julianstafari
clave: nucleo 	 valor: hurd
clave: comunidad 	 valor: indetectables.net
Hay güeyyyyyyyy…

Explico, iniciamos el bucle ‘for’ seguido de dos variables locales –separadas por coma—, palabra reservado ‘in’ –en—,
¡¡Objeto, Método, y Argumento!!.
Objeto = diccionario ‘dic1’, Método = ‘items()’, Argumento = ‘ninguno’. Nuestra marginación –sirve para indicarnos cuando estamos dentro
del bucle y forma parte de la elegancia del lenguaje ; )— y llamamos a print() cada vez que haga un ciclo el bucle ‘for’,
usando nuestro format() para hacer más elegante el asunto –y usar el lenguaje de forma correcta— indicamos que diga ‘clave : , valor: ‘
y donde tenemos {0} y {1}, será nuestra variables locales que indicamos como argumentos en format() y el ‘\t’ es un tab
–como si apretáramos la tecla—. Ahora, lo que hará este bucle, será en las variables locales, guardar los valores del primer elemento
del diccionario ‘edad y 31337 ’ –ósea su clave y su valor— para después pasar a mostrarlos por pantalla y pasar al siguiente elemento
y así hasta recorrer todo el diccionario.

Ahora practiquemos con values() y keys(), en values() para que nos regrese cada valor de los elementos en el diccionario:
>>> for x in dic1.values():
	print('Valor: \t {0}'.format(x))
	
Valor: 	 31337
Valor: 	 julianstafari
Valor: 	 hurd
Valor: 	 indetectables.net
Ahora hagámoslo con keys() de una forma un poco distinta:
>>> for x in dic1:
	print('Clave: \t {0}'.format(x))

Clave: 	 edad
Clave: 	 nombre
Clave: 	 nucleo
Clave: 	 comunidad
Ahora no estamos indicando el método keys(), por defecto Python al momento de iterar sobre un diccionario te regresa las claves de todos los elementos ‘pares’ que contenga el diccionario. También seria valido hacer esto:
>>> for x in dic1:
	print('Clave: \t ' + x)
	
Clave: 	 edad
Clave: 	 nombre
Clave: 	 nucleo
Clave: 	 comunidad
Pero es una forma muy burda de hacer las cosas, además si conocemos format(), hay que utilizarlo de forma correcta;
embellecemos el lenguaje, un código más claro y legible y más estético ; ).
Y creo que para lo anterior deberíamos usar el método keys(), que por algo está integrado para los diccionarios y creo que lo más correcto sería esto:
>>> for x in dic1.keys():
	print('Clave: \t {0}'.format(x))
	
Clave: 	 edad
Clave: 	 nombre
Clave: 	 nucleo
Clave: 	 comunidad
Hay güeyyyyy.

Comprensión En Diccionarios
--------------------


También los diccionarios pueden ser creador por este mismo principio matemático, y vamos a crear un diccionario a partir de iterar sobre una lista:
>>> {x: x+1 for x in (1,2,3,4)}
{1: 2, 2: 3, 3: 4, 4: 5}
A decir verdad, esto es lambda –podrian pensar— y si lo es pero dejémoslos para mas adelante. Y simple como la otra vez.
Explico, variable temporal ‘x’ –clave— : ‘x’+1 –valor—, bucle ‘for’ variable local ‘x’ –del bucle ‘for’, in –en— nuestra lista o conjunto de números’(1,2,3,4)’.
Cuando x vale 1 por que es el primer elemento del conjunto de números, se le suma uno y recorre y almacena nuestro par para el nuevo diccionarios,
cuando x = 2 –clave--, se le suma uno—valor—y recorre, etcétera…

A lo mejor no comprendieron bien por que son puros numero en el ejemplo anterior pero pongamos otro:
>>> {clave: 'null' for clave in ('nombre','nucleo', 'edad', 'comunidad')}
{'edad': 'null', 'nombre': 'null', 'nucleo': 'null', 'comunidad': 'null'}
Mas claro, a decir verdad este principio es muy útil cuando queremos crear un diccionario en base a algo que no tenemos –como en el ejemplo—
que tenemos la idea, en este caso recopilar datos de algún tío, pero no sabes los valores de las claves ; )
–los que estén metidos con base de datos me entenderán—.

Ordenación
--------------


Bueno, recuerdan que les dije que sorted() es una función y no un método propio de la clase ‘lista’ por ejemplo, ahora entenderán por que la
diferencia entre método y función ; ).
Claro que un diccionario se puede ordenar, pero a comparación de las listas que teníamos, el método propio para esos objetos
que es sort() para los diccionario no esta disponible –ya que es solo para las listas— pero podemos utilizar la función sorted():
>>> sorted(dic1)
['comunidad', 'edad', 'nombre', 'nucleo']
Recordar que si quieren mantener los cambios almacenar la lista en otra variable o utilizar la misma:
>>> dic1 = sorted(dic1)
>>> print(dic1)
['comunidad', 'edad', 'nombre', 'nucleo']
Y como podíamos aplicar reverse como parámetro a las listas, también podemos a los diccionarios:
>>> sorted(dic1, reverse=True)
['nucleo', 'nombre', 'edad', 'comunidad']
Recuerden que si no se indica, Python por defecto pone reverse en False, y para hacer este tipo de cosas en las funciones,
existe algo que se llama método constructor o init –esto explica por que al momento de invocar a sorted() no pido obligatoriamente
setear un valor a reverse, pero mas adelante lo veremos con mas calama.)


Y bueno, creo que con esto es suficiente para poder pasar en el siguiente texto a control de flujo y otras cosas mas interesante.
Espero les sea de su agrado mi forma de redacción, mis ejemplos y la forma en que voy expresando las idea y sacandoles brillo.
Tambien estoy metiendo ideas inconsciente o conscientemente en los lectores para poder trabajar la POO con todo su esplendor mas adelante.
Si tienen alguna duda no duden en postear, si tienen alguna sugerencia pueden postear o mandarme MP, alguna idea o lo que sea aqui estamos!

[ Debe registrarse para ver este enlace ]
@GreyDotSec
@julianstafari
 #398793  por linkgl
 22 Dic 2012, 18:59
No estarían mal unos ejercicios sin resolver al final para aplicar lo que se aprendió y retroalimentarse.
 #398799  por Flame
 22 Dic 2012, 19:39
Si eso iba a decir XD pero la información esta de 200% Gracias
¿se puede aprender a programar de esta forma??
 #398815  por KHC
 22 Dic 2012, 21:22
Lo voy a tomar en cuenta y en el proximo texto y si se me da la auoridad para modificar los post's, creo unos ejercicios! Saludos y gracias por las sugerencias!
 #398816  por linkgl
 22 Dic 2012, 21:26
Cualquier modificación que quieras hacerle a un post puedes mandarla en un mp a mi o a cualquier moderador bro ;) dale con los textos.
 #398817  por KHC
 22 Dic 2012, 21:48
Gracias a nuestro amigo linkgl ahora podemos gozar de los textos, respetando el mismo formato, también corrigió algunos errores que se me pasaron por alto! Gracias hermano!