Python: why a comma (,) at the end of the print line?

Simple: with a comma at the end of a ‘print’ line won’t end the line with a newline character going to the new line. In this way if i.e you use ‘raw_input()’, the prompt will be right after the printed line and not below.

Advertisements

Some ‘escape’ sequences in Python

Escape What it does.
\\ Backslash (\)
\' Single-quote (‘)
\" Double-quote (“)
\a ASCII bell (BEL)
\b ASCII backspace (BS)
\f ASCII formfeed (FF)
\n ASCII linefeed (LF)
\N{name} Character named name in the Unicode database (Unicode only)
\r Carriage Return (CR)
\t Horizontal Tab (TAB)
\uxxxx Character with 16-bit hex value xxxx (u” string only)
\Uxxxxxxxx Character with 32-bit hex value xxxxxxxx (u” string only)
\v ASCII vertical tab (VT)
\ooo Character with octal value ooo
\xhh Character with hex value hh

 

Sourcehttps://learnpythonthehardway.org/book/ex10.html

Automate the boring stuff w/Python

Automate the Boring Stuff with Python

Practical programming for total beginners. Written by Al Sweigart.

(Quick plug! You can buy the Automate the Boring Stuff with Python ebook for $1 in the Humble Bundle until Monday!)

Free to read under a Creative Commons license.

Cover image of Automate the Boring Stuff with Python

“The best part of programming is the triumph of seeing the machine do something useful. Automate the Boring Stuff with Python frames all of programming as these small triumphs; it makes the boring fun.”
Hilary Mason, Founder of Fast Forward Labs and Data Scientist in Residence at Accel

“I’m having a lot of fun breaking things and then putting them back together, and just remembering the joy of turning a set of instructions into something useful and fun, like I did when I was a kid.”
Wil Wheaton, WIL WHEATON dot NET

Automate the Boring Stuff with Python is recommended on the Open Source Summer 2015 Reading List!

Learn to Code

If you’ve ever spent hours renaming files or updating hundreds of spreadsheet cells, you know how tedious tasks like these can be. But what if you could have your computer do them for you?

In Automate the Boring Stuff with Python, you’ll learn how to use Python to write programs that do in minutes what would take you hours to do by hand-no prior programming experience required. Once you’ve mastered the basics of programming, you’ll create Python programs that effortlessly perform useful and impressive feats of automation to:

  • Search for text in a file or across multiple files
  • Create, update, move, and rename files and folders
  • Search the Web and download online content
  • Update and format data in Excel spreadsheets of any size
  • Split, merge, watermark, and encrypt PDFs
  • Send reminder emails and text notifications
  • Fill out online forms

Step-by-step instructions walk you through each program, and practice projects at the end of each chapter challenge you to improve those programs and use your newfound skills to automate similar tasks.

Don’t spend your time doing work a well-trained monkey could do. Even if you’ve never written a line of code, you can make your computer do the grunt work. Learn how in Automate the Boring Stuff with Python.

Note: The programs in this book are written to run on Python 3.

Table of Contents

Additional Content

About the Author

Al Sweigart is a software developer and teaches programming to kids and adults. He has written several books for beginners, including Scratch Programming Playground, Hacking Secret Ciphers with Python, Invent Your Own Computer Games with Python, and Making Games with Python & Pygame.

Support the author by purchasing the print & ebook bundle from No Starch Pressor separately on Amazon.

Módulos en Python

La programación modular consiste en subdividir programas de manera organizada para mejorar la legibilidad y aumentar significativamente la reutilización de código. Les mostraré su utilidad con este ejemplo: tenemos un script que se encarga de crear figuras geométricas:

class Triangulo:
	nombre = "Triángulo"

	def __init__(self, lados):
		self.lados = lados

		print("Se creó un triángulo!")

class Circulo:
	nombre = "Círculo"

	def __init__(self, radio):
		self.radio = radio

		print("Se creó un círculo!")

class Cuadrado:
	nombre = "Cuadrado"

	def __init__(self, lado):
		self.lado = lado

		print("Se creó un cuadrado!")

a = Triangulo((3, 2, 2))
b = Circulo(1)
c = Cuadrado(2)

Como se definen todas las clases en el mismo script, se vuelve un poco largo el código y si alguien quiere leerlo probablemente le parezca enredado, así que la mejor forma de solucionar este problema es separarlo en varios archivos:

figuras.py:

class Triangulo:
	nombre = "Triángulo"

	def __init__(self, lados):
		self.lados = lados

		print("Se creó un triángulo!")

class Circulo:
	nombre = "Círculo"

	def __init__(self, radio):
		self.radio = radio

		print("Se creó un círculo!")

class Cuadrado:
	nombre = "Cuadrado"

	def __init__(self, lado):
		self.lado = lado

		print("Se creó un cuadrado!")

script.py:

a = Triangulo((3, 2, 2))
b = Circulo(1)
c = Cuadrado(2)

Claro, así todavía no funciona pues solo lo separamos, si queremos utilizar las clases tenemos que importar el archivo que las contiene (figuras.py) y para esto existen dos formas:

  • Crear un objeto que contenga todos los elementos (variables, funciones, clases, etc…) del archivo:
import figuras

a = figuras.Triangulo((3, 2, 2))
b = figuras.Circulo(1)
c = figuras.Cuadrado(2)

Se puede utilizar la palabra reservada as para renombrar el objeto import figuras as fig en caso de que ya exista algún elemento del script con el mismo identificador o simplemente para reducir su tamaño.

  • Agregar los elementos del archivo importado al actual:
from figuras import *

a = Triangulo((3, 2, 2))
b = Circulo(1)
c = Cuadrado(2)

El * simboliza todos los elementos, si se quisiera importar alguno en específico solo haría falta cambiar el * por su nombre from figuras import Triangulo. Al igual que el método anterior puede usarse la palabra reservada as pero solo cuando se importa un elemento from figuras import Triangulo as Tri o varios separados por comas from figuras import Triangulo as Tri, Circulo as Cir.

 

En ambos casos, el archivo figuras.py debe estar en la misma carpeta que script.py. Los archivos que se importan son llamados Módulos y su función principal es contener las herramientas necesarias para ejecutar ciertos procesos. Python también usa Paquetesque son simplemente carpetas que contienen módulos, en el mundo de la programación se les conoce como bibliotecas o repositorios de código; para configurar paquetes solo hace falta crear en el interior de una carpeta un archivo vacío llamado __init__.py, bastante sencillo no? para usar los módulos dentro de un paquete tenemos que anteponer el nombre del paquete cuando lo importamos, adaptemos el ejemplo para entenderlo mejor aún:

.
├─ geometria/
│  ├── __init__.py
│  ├── circulo.py
│  ├── cuadrado.py
│  └── triangulo.py
└─ script.py

circulo.py:

class Circulo:
	nombre = "Círculo"

	def __init__(self, radio):
		self.radio = radio

		print("Se creó un círculo!")

cuadrado.py:

class Cuadrado:
	nombre = "Cuadrado"

	def __init__(self, lado):
		self.lado = lado

		print("Se creó un cuadrado!")

triangulo.py:

class Triangulo:
	nombre = "Triángulo"

	def __init__(self, lados):
		self.lados = lados

		print("Se creó un triángulo!")

script.py:

import geometria.circulo, geometria.cuadrado, geometria.triangulo

a = geometria.triangulo.Triangulo((3, 2, 2))
b = geometria.circula.Circulo(1)
c = geometria.cuadrado.Cuadrado(2)

 

Si se crean más subpaquetes, el proceso sería el mismo:

.
└─ paquete/
   ├── __init__.py
   └─ subpaquete/
      ├── __init__.py
      └── modulo.py

Y para importar los módulos:

import paquete.subpaquete.modulo
import paquete.subpaquete.modulo as modulo  # Se puede usar "as"

 

Hasta ahora, los módulos y paquetes que creemos deben estar en la misma carpeta del script que los importará, si queremos alterar este comportamiento tenemos que decirle a Python donde queremos que los busque y para esto existen dos formas:

  • Temporal (mientras dure la ejecución del script):

Hay una variable de Python que contiene una lista de ubicaciones donde buscar módulos, solo haría falta agregarle la ruta a la carpeta que contiene los módulos y ya podríamos usarlos aunque con una diferencia, no será necesario crear el archivo__init__.py ni anteponer el nombre del paquete (solo en la carpeta principal, sus subcarpetas si necesitan que se hagan las dos). Les explico con un ejemplo:

.
├─ geometria/
│  ├── circulo.py
│  ├── cuadrado.py
│  └── triangulo.py
└─ Python/
   └── script.py

script.py:

import sys

sys.path += ["../geometria"]

import triangulo

a = triangulo.Triangulo((3, 2, 2))

Resultado:

Se creó un triángulo!

Como ven, sys.path soporta rutas relativas, pero esto es un poco peligroso pues esta ruta será relativa a la carpeta desde la que se está ejecutando el script y no en la que está almacenado, es decir, si lo ejecutamos desde /home/ntrrg/Descargas/Python/ (que es donde yo lo guardé) entonces ../geometria equivaldrá a /home/ntrrg/Descargas/geometria/y el resultado sería el esperado; si se ejecuta desde /home/ntrrg/Descargas/ entonces equivaldrá a /home/ntrrg/geometria/ y apuntará a una ruta que no existe. Con una ruta absoluta quedaría así:

script.py:

import sys

sys.path += ["/home/ntrrg/Descargas/geometria"]

import triangulo

a = triangulo.Triangulo((3, 2, 2))
  • Permanente:

Se debe agregar la siguiente línea en el archivo /etc/profile y reiniciar la sesión de usuario:

export PYTHONPATH=$PYTHONPATH:/home/ntrrg/Descargas/geometria

# Para agregar varias ubicaciones:
export PYTHONPATH=$PYTHONPATH:<ruta>:<otraRuta>

Me disculpo con los que estén usando Windows, pero realmente no conozco el equivalente a este método.

 

Todas las sentencias escritas en el cuerpo de los módulos serán ejecutadas cuando se importen, aunque es posible crear un bloque que se ejecute solo en caso de que el módulo sea llamado como un script, que utilidad tiene esto? bueno, imaginen que quieren obtener el área de un triángulo usando el módulo triangulo.py, sería muy fastidioso tener que crear un script solo para importarlo, así que les muestro como usarlo directamente:

# El primer parámetro será la altura y el segundo la base
python3 geometria/triangulo.py 3 3

Y los cambios en el módulo:

triangulo.py:

class Triangulo:
	nombre = "Triángulo"

	def __init__(self, lados):
		self.lados = lados

		print("Se creó un triángulo!")

# Bloque que se ejecuta solo al llamarse como script

if __name__ == "__main__":
	import sys  # Esta biblioteca nos deja leer los parámetros

	# sys.argv[0] contiene la ruta con la que fue ejecutado el módulo
	base = int(sys.argv[1])
	altura = int(sys.argv[2])

	print(base * altura / 2)

 

Por último, el estándar de Python tiene ciertas recomendaciones al momento de importar módulos:

  • Escribir las instrucciones de importación en las primeras líneas del script.
  • Ordenar los paquetes/módulos en tres secciones:
      <paquetes/módulos de Python>
      # Una línea vacía
      <paquetes/módulos de herramientas externas>
      # Una línea vacía
      <paquetes/módulos propios>
    
  • Organizar alfabéticamente los paquetes/módulos.

Python: dict methods

Vaciar un diccionario

Método: clear()

>>> diccionario = {"color": "violeta", "talle": "XS", "precio": 174.25} 
>>> print diccionario 
{'color': 'violeta', 'precio': 174.25, 'talle': 'XS'} 
 
>>> diccionario.clear() 
>>> print diccionario 
{}

Copiar un diccionario

Método: copy()

>>> diccionario = {"color": "violeta", "talle": "XS", "precio": 174.25} 
>>> remera = diccionario.copy() 
>>> diccionario
{'color': 'violeta', 'precio': 174.25, 'talle': 'XS'} 
>>> remera
{'color': 'violeta', 'precio': 174.25, 'talle': 'XS'} 
 
>>> diccionario.clear() 
>>> diccionario
{} 
>>> remera 
{'color': 'violeta', 'precio': 174.25, 'talle': 'XS'} 
 
>>> musculosa = remera 
>>> remera 
{'color': 'violeta', 'precio': 174.25, 'talle': 'XS'} 
>>> musculosa 
{'color': 'violeta', 'precio': 174.25, 'talle': 'XS'} 
 
>>> remera.clear() 
>>> remera 
{} 
>>> musculosa 
{} 
>>>

Crear un nuevo diccionario desde las claves de una secuencia

Método: dict.fromkeys(secuencia[, valor por defecto])

>>> secuencia = ["color", "talle", "marca"]
>>> diccionario1 = dict.fromkeys(secuencia)
>>> diccionario1
{'color': None, 'marca': None, 'talle': None}
 
>>> diccionario2 = dict.fromkeys(secuencia, 'valor x defecto')
>>> diccionario2
{'color': 'valor x defecto', 'marca': 'valor x defecto', 'talle': 'valor x defecto'}

Concatenar diccionarios

Método: update(diccionario)

>>> diccionario1 = {"color": "verde", "precio": 45}
>>> diccionario2 = {"talle": "M", "marca": "Lacoste"}
>>> diccionario1.update(diccionario2)
>>> diccionario1
{'color': 'verde', 'precio': 45, 'marca': 'Lacoste', 'talle': 'M'}

Establecer una clave y valor por defecto

Método: setdefault("clave" [, None|valor_por_defecto])

Si la clave no existe, la crea con el valor por defecto. Siempre retorna el valor para la clave pasada como parámetro.

>>> remera = {"color": "rosa", "marca": "Zara"} 
>>> clave = remera.setdefault("talle", "U") 
>>> clave 
'U'
>>> remera 
{'color': 'rosa', 'marca': 'Zara', 'talle': 'U'} 
 
>>> remera2 = remera.copy() 
>>> remera2 
{'color': 'rosa', 'marca': 'Zara', 'talle': 'U'} 
>>> clave = remera2.setdefault("estampado") 
>>> clave 
>>> remera2 
{'color': 'rosa', 'estampado': None, 'marca': 'Zara', 'talle': 'U'} 
 
>>> clave = remera2.setdefault("marca", "Lacoste") 
>>> clave 
'Zara' 
>>> remera2 
{'color': 'rosa', 'estampado': None, 'marca': 'Zara', 'talle': 'U'}
 

Obtener el valor de una clave

Método: get(clave[, "valor x defecto si la clave no existe"])

>>> remera.get("color") 
'rosa'
 
>>> remera.get("stock") 
>>> remera.get("stock", "sin stock") 
'sin stock'

Saber si una clave existe en el diccionario

Método: has_key(clave)

>>> existe = remera.has_key("precio") 
>>> existe 
False
 
>>> existe = remera.has_key("color") 
>>> existe 
True

Obtener las claves y valores de un diccionario

Método: iteritems()

Alias: items()

diccionario = {'color': 'rosa', 'marca': 'Zara', 'talle': 'U'} 
for clave, valor in diccionario.iteritems(): 
    print "El valor de la clave %s es %s" % (clave, valor)

Salida:

El valor de la clave color es rosa 
El valor de la clave marca es Zara 
El valor de la clave talle es U

Obtener las claves de un diccionario

Método: keys()

>>> diccionario = {'color': 'rosa', 'marca': 'Zara', 'talle': 'U'}
>>> claves = diccionario.keys()
>>> claves
['color', 'marca', 'talle']

Obtener los valores de un diccionario

Método: values()

>>> diccionario = {'color': 'rosa', 'marca': 'Zara', 'talle': 'U'}
>>> valores = diccionario.values()
>>> valores
['rosa', 'Zara', 'U']

Obtener la cantidad de elementos de un diccionario

Para contar los elementos de un diccionario, al igual que con las listas y tuplas, se utiliza la función integrada len().

>>> diccionario = {'color': 'rosa', 'marca': 'Zara', 'talle': 'U'} 
>>> len(diccionario)
3

 

SOURCEhttp://librosweb.es/libro/python/capitulo_8.html