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

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.

Strings substitution methods

6.4.1. Dar formato a una cadena, sustituyendo texto dinámicamente

Método: format(*args, **kwargs)

Retorna: la cadena formateada.

>>> cadena = "bienvenido a mi aplicación {0}" 
>>> print cadena.format("en Python") 
bienvenido a mi aplicación en Python 
 
>>> cadena = "Importe bruto: ${0} + IVA: ${1} = Importe neto: {2}" 
>>> print cadena.format(100, 21, 121) 
Importe bruto: $100 + IVA: $21 = Importe neto: 121 
 
>>> cadena = "Importe bruto: ${bruto} + IVA: ${iva} = Importe neto: {neto}" 
>>> print cadena.format(bruto=100, iva=21, neto=121) 
Importe bruto: $100 + IVA: $21 = Importe neto: 121 
 
>>> print cadena.format(bruto=100, iva=100 * 21 / 100, neto=100 * 21 / 100 + 100)
Importe bruto: $100 + IVA: $21 = Importe neto: 121

6.4.2. Reemplazar texto en una cadena

Método: replace("subcadena a buscar", "subcadena por la cual reemplazar")

Retorna: la cadena reemplazada.

>>> buscar = "nombre apellido" 
>>> reemplazar_por = "Juan Pérez" 
>>> print "Estimado Sr. nombre apellido:".replace(buscar, reemplazar_por) 
Estimado Sr. Juan Pérez:

6.4.3. Eliminar caracteres a la izquierda y derecha de una cadena

Método: strip(["caracter"])

Retorna: la cadena sustituida.

>>> cadena = "   www.eugeniabahit.com   " 
>>> print cadena.strip()
www.eugeniabahit.com
 
>>> print cadena.strip(' ')
www.eugeniabahit.com

6.4.4. Eliminar caracteres a la izquierda de una cadena

Método: lstrip(["caracter"])

Retorna: la cadena sustituida.

>>> cadena = "www.eugeniabahit.com" 
>>> print cadena.lstrip("w." )
eugeniabahit.com
 
>>> cadena = "       www.eugeniabahit.com" 
>>> print cadena.lstrip()
www.eugeniabahit.com

6.4.5. Eliminar caracteres a la derecha de una cadena

Método: rstrip(["caracter"])

Retorna: la cadena sustituida.

>>> cadena = "www.eugeniabahit.com       " 
>>> print cadena.rstrip( )
www.eugeniabahit.com


SOURCE: http://librosweb.es/libro/python/capitulo_6/metodos_de_sustitucion.html

String format methods

6.1.1. Convertir a mayúscula la primera letra

Método: capitalize()

Retorna: una copia de la cadena con la primera letra en mayúsculas.

>>> cadena = "bienvenido a mi aplicación" 
>>> print cadena.capitalize()
Bienvenido a mi aplicación

6.1.2. Convertir una cadena a minúsculas

Método: lower()

Retorna: una copia de la cadena en minúsculas.

>>> cadena = "Hola Mundo" 
>>> print cadena.lower()
hola mundo

6.1.3. Convertir una cadena a mayúsculas

Método: upper()

Retorna: una copia de la cadena en mayúsculas.

>>> cadena = "Hola Mundo" 
>>> print cadena.upper()
HOLA MUNDO

6.1.4. Convertir mayúsculas a minúsculas y viceversa

Método: swapcase()

Retorna: una copia de la cadena convertidas las mayúsculas en minúsculas y viceversa.

>>> cadena = "Hola Mundo" 
>>> print cadena.swapcase()
hOLA mUNDO

6.1.5. Convertir una cadena en Formato Título

Método: title()

Retorna: una copia de la cadena convertida.

>>> cadena = "hola mundo" 
>>> print cadena.title()
Hola Mundo

6.1.6. Centrar un texto

Método: center(longitud[, "caracter de relleno"])

Retorna: una copia de la cadena centrada.

>>> cadena = "bienvenido a mi aplicación".capitalize() 
>>> print cadena.center(50, "=") 
===========Bienvenido a mi aplicación============ 
 
>>> print cadena.center(50, " ") 
           Bienvenido a mi aplicación

6.1.7. Alinear texto a la izquierda

Método: ljust(longitud[, "caracter de relleno"])

Retorna: una copia de la cadena alineada a la izquierda.

>>> cadena = "bienvenido a mi aplicación".capitalize() 
>>> print cadena.ljust(50, "=")
Bienvenido a mi aplicación=======================

6.1.8. Alinear texto a la derecha

Método: rjust(longitud[, "caracter de relleno"])

Retorna: una copia de la cadena alineada a la derecha.

>>> cadena = "bienvenido a mi aplicación".capitalize() 
>>> print cadena.rjust(50, "=") 
=======================Bienvenido a mi aplicación
 
>>> print cadena.rjust(50, " ") 
                       Bienvenido a mi aplicación

6.1.9. Rellenar un texto anteponiendo ceros

Método: zfill(longitud)

Retorna: una copia de la cadena rellena con ceros a la izquierda hasta alcanzar la longitud final indicada.

>>> numero_factura = 1575 
>>> print str(numero_factura).zfill(12) 
000000001575


SOURCE: http://librosweb.es/libro/python/capitulo_6/metodos_de_formato.html

Python: JSON

JSON

The json library can parse JSON from strings or files. The library parses JSON into a Python dictionary or list. It can also convert Python dictionaries or lists into JSON strings.

Parsing JSON

Take the following string containing JSON data:

json_string = '{"first_name": "Guido", "last_name":"Rossum"}'

It can be parsed like this:

import json
parsed_json = json.loads(json_string)

and can now be used as a normal dictionary:

print(parsed_json['first_name'])
"Guido"

You can also convert the following to JSON:

d = {
    'first_name': 'Guido',
    'second_name': 'Rossum',
    'titles': ['BDFL', 'Developer'],
}

print(json.dumps(d))
'{"first_name": "Guido", "last_name": "Rossum", "titles": ["BDFL", "Developer"]}'

SOURCE: http://docs.python-guide.org/en/latest/scenarios/json/