4.3 Comenzar con el lenguaje Python

Plufación preliminar

Por lo tanto, si quieres aprender el lenguaje de programación Python pero no puedes encontrar un tutorial conciso y completo, este tutorial intentará enseñarte Python en 10 minutos. Probablemente no sea tanto un tutorial como un cruce entre un tutorial y una hoja de trucos, por lo que solo te mostrará algunos conceptos básicos para comenzar. Obviamente, si realmente quieres aprender un lenguaje, necesitas programar en él por un tiempo. Asumiré que ya estás familiarizado con la programación y, por lo tanto, omitirás la mayoría de las cosas no específicas del lenguaje. Las palabras clave importantes se resaltarán para que puedas detectarlas fácilmente.

Todos los ejemplos en el libro están en Python 3 y si alguien te aconseja usar 2, no son tus amigos.

Propiedades

Python es fuertemente tipo (es decir, los tipos se aplican), dinámicamente, tipado implícitamente (es decir, no tiene que declarar variables), sensible a mayúsculas y minúsculas (es decir, var y VAR son dos variables diferentes) y orientado a objetos (es decir, todo es un objeto).

Obtener ayuda

La ayuda en Python siempre está disponible directamente en el intérprete. Si quieres saber cómo funciona un objeto, todo lo que tienes que hacer es llamar a help(- ¿ Qué pasa?, que muestra su cadena de documentación:

>>> help(5)
Help on int object:
(etc etc)

>>> dir(5)
['__abs__', '__add__', ...]

>>> abs.__doc__
'abs(number) -> number

Return the absolute value of the argument.

La sintaxis

Python no tiene caracteres de terminación de instrucciones obligatorios y los bloques se especifican por hendidura. Indent para comenzar un bloque, dedent para terminar uno. Las instrucciones que esperan un nivel de hendidura terminan en un punto y punto (:). Los comentarios comienzan con el signo de libra (#) y son de una sola línea, las cadenas de múltiples líneas se utilizan para comentarios de múltiples líneas. Los valores se asignan (de hecho, los objetos están vinculados a nombres) con el signo de igual (=), y la prueba de igualdad se realiza utilizando dos signos de igual (==). Puede incrementar / disminuir los valores utilizando los operadores += y -= respectivamente por la cantidad de la mano derecha. Esto funciona en muchos tipos de datos, incluidas las cadenas. También puede usar varias variables en una línea. Por ejemplo:

>>> myvar = 3
>>> myvar += 2
>>> myvar
5
>>> myvar -= 1
>>> myvar
4
"""This is a multiline comment.
The following lines concatenate the two strings."""
>>> mystring = "Hello"
>>> mystring += " world."
>>> print(mystring)
Hello world.
# This swaps the variables in one line(!).
# It doesn't violate strong typing because values aren't
# actually being assigned, but new objects are bound to
# the old names.
>>> myvar, mystring = mystring, myvar

Tipos de datos

Las estructuras de datos disponibles en Python son listas, tuplas y diccionarios. Los conjuntos están disponibles en la biblioteca de conjuntos (pero están integrados en Python 2.5 y posteriores). Las listas son como matrices unidimensionales (pero también puede tener listas de otras listas), los diccionarios son matrices asociativas (también conocidas como tablas de hash) y los tuplas son matrices unidimensionales inmutables (Python arrays puede ser de cualquier tipo, por lo que puede mezclar, por ejemplo, enteros, cadenas, etc. en listas / diccionarios / tuplas). El índice del primer elemento en todos los tipos de array es 0.

>>> sample = [1, ["another", "list"], ("a", "tuple")]
>>> mylist = ["List item 1", 2, 3.14]
>>> mylist[0] = "List item 1 again" # We're changing the item.
>>> mylist[-1] = 3.21 # Here, we refer to the last item.
>>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}
>>> mydict["pi"] = 3.15 # This is how you change dictionary values.
>>> mytuple = (1, 2, 3)
>>> myfunction = len
>>> print(myfunction(mylist))
3

Puede acceder a los rangos de matriz usando un punto y punto (:). Dejar el índice de inicio vacío asume el primer elemento, dejar el índice final asume el último elemento. La indexación es inclusiva-exclusiva, por lo que especificar [2:10] devolverá los elementos [2] (el tercer elemento, debido a la indexación de 0) a [9] (el décimo elemento), incluidos (8 elementos). Los índices negativos cuentan desde el último elemento hacia atrás (por lo tanto -1 es el último elemento) de la siguiente manera:

>>> mylist = ["List item 1", 2, 3.14]
>>> print(mylist[:])
['List item 1', 2, 3.1400000000000001]
>>> print(mylist[0:2])
['List item 1', 2]
>>> print(mylist[-3:-1])
['List item 1', 2]
>>> print(mylist[1:])
[2, 3.14]
# Adding a third parameter, "step" will have Python step in
# N item increments, rather than 1.
# E.g., this will return the first item, then go to the third and
# return that (so, items 0 and 2 in 0-indexing).
>>> print(mylist[::2])
['List item 1', 3.14]

Las cuerdas

Sus cadenas pueden usar comillas simples o dobles, y puede tener comillas de un tipo dentro de una cadena que utiliza el otro tipo (es decir, He said hello. es válido).las cotizaciones triples dobles (o únicas)(). Las cadenas de Python son siempre Unicode, pero hay otro tipo de cadena que son bytes puros. Se llaman bystrings y se representan con el prefijo b, por ejemplo bHello \xce\xb1. Para llenar una cadena con valores, se usa el operador % (modulo) y un tuple. Cada %s se reemplaza con un elemento del tuple, de izquierda a derecha, y también se pueden usar sustituciones de diccionario, como esto:

>>> print("Name: %s\
Number: %s\
String: %s" % (myclass.name, 3, 3 * "-"))
Name: Stavros
Number: 3
String: ---

strString = """This is
a multiline
string."""

# WARNING: Watch out for the trailing s in "%(key)s".
>>> print("This %(verb)s a %(noun)s." % {"noun": "test", "verb": "is"})
This is a test.

>>> name = "Stavros"
>>> "Hello, {}!".format(name)
Hello, Stavros!
>>> print(f"Hello, {name}!")
Hello, Stavros!

Declaraciones de control de flujo

Las instrucciones de control de flujo son if, for, y while. No hay switch; en su lugar, use if. Use for para enumerar a través de miembros de una lista. Para obtener una secuencia de números que puede iterar, use range() . La sintaxis de estas instrucciones es así:

rangelist = list(range(10))
>>> print(rangelist)
range(0, 10)
>>> print(list(rangelist))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for number in rangelist:
    # Check if number is one of
    # the numbers in the tuple.
    if number in (3, 4, 7, 9):
        # "Break" terminates a for without
        # executing the "else" clause.
        break
    else:
        # "Continue" starts the next iteration
        # of the loop. It's rather useless here,
        # as it's the last statement of the loop.
        continue
else:
    # The "else" clause is optional and is
    # executed only if the loop didn't "break".
    pass # Do nothing

if rangelist[1] == 2:
    print("The second item (lists are 0-based) is 2")
elif rangelist[1] == 3:
    print("The second item (lists are 0-based) is 3")
else:
    print("Dunno")

while rangelist[1] == 1:
    print("We are trapped in an infinite loop!")

Funciones

Las funciones se declaran con la palabra clave def. Los argumentos opcionales se establecen en la declaración de la función después de los argumentos obligatorios asignándole un valor predeterminado. Para los argumentos nombrados, se asigna un valor al nombre del argumento. Las funciones pueden devolver un tuple (y utilizando el desempaquetado de tuple puede devolver efectivamente múltiples valores). Las funciones lambda son funciones ad hoc que se componen de una sola instrucción. Los parámetros se pasan por referencia, pero los tipos inmutables (tuples, int, strings, etc.) no pueden ser cambiados en el llamador por el llamador. Esto se debe a que solo se pasa la ubicación de memoria del elemento, y la vinculación de otro objeto a una variable descarta el antiguo, por lo que se reemplazan los tipos inmutables. Por ejemplo:

# Same as def funcvar(x): return x + 1
funcvar = lambda x: x + 1
>>> print(funcvar(1))
2

# an_int and a_string are optional, they have default values
# if one is not passed (2 and "A default string", respectively).
def passing_example(a_list, an_int=2, a_string="A default string"):
    a_list.append("A new item")
    an_int = 4
    return a_list, an_int, a_string

>>> my_list = [1, 2, 3]
>>> my_int = 10
>>> print(passing_example(my_list, my_int))
([1, 2, 3, 'A new item'], 4, "A default string")
>>> my_list
[1, 2, 3, 'A new item']
>>> my_int
10

Las clases

Python admite una forma limitada de herencia múltiple en clases. Las variables privadas y métodos pueden declararse (por convención, esto no es aplicado por el lenguaje) agregando un subrayado principal (por ejemplo _spam). También podemos vincular nombres arbitrarios a las instancias de clase. Un ejemplo es el siguiente:

class MyClass(object):
    common = 10
    def __init__(self):
        self.myvariable = 3
    def myfunction(self, arg1, arg2):
        return self.myvariable

    # This is the class instantiation

>>> classinstance = MyClass()
>>> classinstance.myfunction(1, 2)
3
# This variable is shared by all instances.
>>> classinstance2 = MyClass()
>>> classinstance.common
10
>>> classinstance2.common
10
# Note how we use the class name
# instead of the instance.
>>> MyClass.common = 30
>>> classinstance.common
30
>>> classinstance2.common
30
# This will not update the variable on the class,
# instead it will bind a new object to the old
# variable name.
>>> classinstance.common = 10
>>> classinstance.common
10
>>> classinstance2.common
30
>>> MyClass.common = 50
# This has not changed, because "common" is
# now an instance variable.
>>> classinstance.common
10
>>> classinstance2.common
50

# This class inherits from MyClass. The example
# class above inherits from "object", which makes
# it what's called a "new-style class".
# Multiple inheritance is declared as:
# class OtherClass(MyClass1, MyClass2, MyClassN)
class OtherClass(MyClass):
    # The "self" argument is passed automatically
    # and refers to the class instance, so you can set
    # instance variables as above, but from inside the class.
    def __init__(self, arg1):
        self.myvariable = 3
        print(arg1)

>>> classinstance = OtherClass("hello")
hello
>>> classinstance.myfunction(1, 2)
3
# This class doesn't have a .test member, but
# we can add one to the instance anyway. Note
# that this will only be a member of classinstance.
>>> classinstance.test = 10
>>> classinstance.test
10

Excepciones

Las excepciones en Python se manejan con los bloques try-except [nombre de excepción]:

def some_function():
    try:
        # Division by zero raises an exception
        10 / 0
    except ZeroDivisionError:
        print("Oops, invalid.")
    else:
        # Exception didn't occur, we're good.
        pass
    finally:
        # This is executed after the code block is run
        # and all exceptions have been handled, even
        # if a new exception is raised while handling.
        print("We're done with that.")

>>> some_function()
Oops, invalid.
We're done with that.

Importación

Las bibliotecas externas se utilizan con la palabra clave import [libname]. También puede usar from [libname] import [funcname] para funciones individuales. Aquí hay un ejemplo:

import random
from time import clock

randomint = random.randint(1, 100)
>>> print(randomint)
64

El archivo I/O

Python tiene una amplia gama de bibliotecas integradas. Como ejemplo, aquí se utiliza la serialización (conversión de estructuras de datos a cadenas utilizando la biblioteca pickle) con E/S de archivo:

import pickle
mylist = ["This", "is", 4, 13327]
# Open the file C:\\binary.dat for writing. The letter r before the
# filename string is used to prevent backslash escaping.
myfile = open(r"C:\\binary.dat", "wb")
pickle.dump(mylist, myfile)
myfile.close()

myfile = open(r"C:\\text.txt", "w")
myfile.write("This is a sample string")
myfile.close()

myfile = open(r"C:\\text.txt")
>>> print(myfile.read())
'This is a sample string'
myfile.close()

# Open the file for reading.
myfile = open(r"C:\\binary.dat", "rb")
loadedlist = pickle.load(myfile)
myfile.close()
>>> print(loadedlist)
['This', 'is', 4, 13327]

Las demás

• Las condiciones pueden ser encadenadas: 1 < a < 3 comprueba que a es menor que 3 y mayor que 1.
• Puedes usar del para borrar variables o elementos en matrices.
• Las comprensiones de listas proporcionan una poderosa manera de crear y manipular listas. Consisten en una expresión seguida de una cláusula for seguida de cero o más cláusulas if o for, como esto:

>>> lst1 = [1, 2, 3]
>>> lst2 = [3, 4, 5]
>>> print([x * y for x in lst1 for y in lst2])
[3, 4, 5, 6, 8, 10, 9, 12, 15]
>>> print([x for x in lst1 if 4 > x > 1])
[2, 3]
# Check if a condition is true for any items.
# "any" returns true if any item in the list is true.
>>> any([i % 3 for i in [3, 3, 4, 4, 3]])
True
# This is because 4 % 3 = 1, and 1 is true, so any()
# returns True.

# Check for how many items a condition is true.
>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)
2
>>> del lst1[0]
>>> print(lst1)
[2, 3]
>>> del lst1

• Las variables globales se declaran fuera de las funciones y se pueden leer sin ninguna declaración especial, pero si quieres escribirlas debes declararlas al principio de la función con la palabra clave global, de lo contrario Python vinculará ese objeto a una nueva variable local (ten cuidado, es un pequeño problema que puede ocurrir si no lo sabes). Por ejemplo:

number = 5

def myfunc():
    # This will print 5.
    print(number)

def anotherfunc():
    # This raises an exception because the variable has not
    # been bound before printing. Python knows that it an
    # object will be bound to it later and creates a new, local
    # object instead of accessing the global one.
    print(number)
    number = 3

def yetanotherfunc():
    global number
    # This will correctly change the global.
    number = 3

El epílogo

Este tutorial no pretende ser una lista exhaustiva de todo (o incluso un subconjunto) de Python. Python tiene una amplia gama de bibliotecas y mucha más funcionalidad que tendrá que descubrir a través de otros medios, como el excelente libro Dive into Python. Espero haber hecho su transición en Python más fácil. Por favor, deje comentarios si cree que hay algo que podría ser mejorado o añadido o si hay algo más que le gustaría ver (clases, manejo de errores, cualquier cosa).