Sintaxis básica de Python (con ejemplos)

Python es similar a los lenguajes de la "familia C", pero hay algunas diferencias significativas y propiedades únicas.

La diferencia sintáctica más obvia entre Python y un lenguaje como C y ST es que el analizador de Python reconoce estructuras de bloque por su sangría. No hay BEGIN/END o aparatos ortopédicos {} identificar los bloques de IF/ELSE condiciones, FOR y WHILE bucles o funciones.

Los comentarios comienzan con # y extender hasta el final de la línea. En la primera y segunda línea del código fuente, puede establecer un marcador especial para declarar la codificación del archivo. Le recomendamos que utilice UTF-8 como codificación si no se requieren caracteres ASCII.

Para fines de depuración, utiliza print para una fácil salida. Con el % operador, logra una funcionalidad similar a la función C printf(). El resultado se muestra en la vista de mensajes de CODESYS.

ejemplo 4. Ejemplo: print

# encoding:utf-8

# defining a function with the parameter i
def do_something(i):
    # if branch
    if i>0:
        print("The value is: %i" % i)
                                                                sum += i
        print("The new sum is: %i" % sum)

    # else if (optional, there can be none or several elif branches)
    elif i=0:
        print("The sum did not change: %i" % sum)

    # and the final else branch (also optional).
    else:
        handle_error()

# an endless while loop
while True:
    print("I got stuck forever!")

Todo lo que pertenece al mismo bloque tiene que estar sangrado a la misma distancia. El tamaño de la sangría es irrelevante. Elementos como corchetes y llaves tienen mayor prioridad que las sangrías. Por lo tanto, el siguiente segmento de código es completamente correcto, incluso si está escrito en un "estilo de programación deficiente":

ejemplo 5. Ejemplo: sangría

# warning: bad style below. Kids, don't try this at home!
if foo >= bar:
               print("foobar")
else:
    print(
          "barfoo"
)

Para evitar la ambigüedad, no debe mezclar tabulaciones y espacios en un archivo.

Sugerencia

En este momento, mezclar tabulaciones y espacios dorados en Python 3 se considera un error de sintaxis.

La Guía de estilo oficial de Python recomienda la sangría de cuatro espacios e incluye algunos ejemplos de estilo bueno y malo. El tutorial de Python proporciona un resumen del estilo de codificación.

Python es "sensible a mayúsculas y minúsculas", similar a C y en contraste con ST. Palabras clave, como def, if, else, y while, tienen que estar en minúsculas (a diferencia de la regla ST: las palabras clave están en mayúsculas). Dos identificadores, como "i" e "I", también identifican dos variables diferentes.

Python 3 definió otras cuatro palabras clave: False | None | True | nonlocal. Si bien los primeros tres son realmente nuevos, los tres primeros ya eran constantes predefinidas en Python 2 y no deben usarse para ningún otro propósito.

Para más información, ver: Guía de estilo de Python y Tutorial de Python

Variables y tipos de datos

Python es un lenguaje potente y de tipado dinámico: toda la información de tipo se evalúa en tiempo de ejecución. Las variables contienen referencias a objetos, y el objeto conoce su tipo, no la variable. Cuando un programador intenta ejecutar una operación que no es posible (por ejemplo, agregar un número entero y una cadena), Python lanza una excepción en tiempo de ejecución.

En consecuencia, no hay declaraciones de variables y sus tipos. En Python, las variables se crean solo para asignarles valores. Esto es completamente diferente en C y ST donde los tipos son fuertes y estáticos. Cada variable se declara con un tipo y, en tiempo de compilación, el compilador verifica que el tipo y los operadores estén permitidos.

Consulte los siguientes ejemplos para el manejo de variables:

ejemplo 6. Ejemplo: Variables

# assign the integer 1 to the variable i (also "creates" the variable")
i = 1

# assign the string "foobar" to the variable s
s = "foobar"

# Add 5 to the integer i - this is equivalent to i = i + 5
i += 5
# i now holds the integer 6.

# Try to add i and s - this will throw an exception when executed
# TypeError: unsupported operand type(s) for +: 'int' and 'str'
result = i + s

# variables can also be "undeclared" by deleting them.
# Further access to the variable i will throw a NameError exception,
# as the variable does not exist any more.
del i

i += 5 # now throws an exception: NameError: name 'i' is not defined

Todas las variables existentes hacen referencia a un solo valor. No hay variables no asignadas o no inicializadas en Python. Para expresar la ausencia de un valor, Python proporciona un objeto especial: None. En C o ST, usaría un puntero nulo. Su único propósito es expresar "aquí no hay valor", aunque None es en realidad una instancia existente de la clase NoneType.

Tipos numéricos y puntos flotantes

En contraste con las docenas de tipos enteros en IEC o C, solo hay un tipo entero en Python. Los tipos enteros en Python no tienen un tamaño fijo. En su lugar, crecen según sea necesario y están limitados únicamente por la memoria disponible.

ejemplo 7. Ejemplo: Integers.py

from __future__ import print_function

i = 1
print(i)

j = 0x1234   # hex number, is 16#1234 in IEC and 4660 in decimal
k = 0o123    # octal number, is 8#123 in IEC and 83 decimal
l = 0b101010 # binary number, is 2#101010 in IEC and 42 in decimal
print(j, k, l)

m = (2 + 3)*10 # k is 50 now
print(m)

n = 10 ** 100 # 10 to the power of 100
print(n)

Salida resultante:

También hay un solo tipo de punto flotante en Python que es similar al tipo de datos IEC LREAL. Proporciona aritmética de punto flotante IEEE de 64 bits.

La sintaxis es como lenguajes basados en C en su mayor parte:

ejemplo 8. Ejemplo: tipos de punto flotante

# A simple float...
a = 123.456

# A float containing the integral value 2
b = 2.

# Leading zeroes can be left off
c = .3 # same as 0.3

# Exponential / scientific representation
d = -123e-5

Dos casos especiales son True y False, dos constantes que definen los valores de verdad booleanos. Se comportan de forma similar a los valores enteros. 0 y 1, excepto cuando se convierten en cadenas y devuelven sus nombres.

ejemplo 9. Ejemplo: Booleans.py

# booleans behave like integers, except when converted to strings.
# The built-in function "type" can be used to query the type of a value.
print("True:  ", True, type(True))
print("False: ", False, type(False))
print("1:     ", 1, type(1))
print("False + 0: ", False + 0, type(False + 0))
print("True * 5: ", True * 5, type(True * 5))

Salida resultante:

Instrumentos de cuerda

En IronPython, las cadenas siempre están en Unicode y de cualquier longitud. No hace ninguna diferencia si están encerrados en ' o ". Las cadenas también pueden tener comillas triples """ o ''', que permite literales de cadena multilínea.

Al igual que en C, los caracteres especiales se pueden excluir mediante caracteres de barra invertida. Como comparación, el signo de dólar ($) se utiliza en IEC para este propósito.

También hay cadenas sin formato que tienen otras reglas para la barra invertida. Esto es práctico cuando la cadena debe tener barras invertidas literales. Ejemplo: rutas de archivos de Windows o expresiones regulares.

ejemplo 10. Ejemplo: Strings.py

# encoding:utf-8
from __future__ import print_function

a = "a simple string"
b = 'another string'
c = "strings may contain 'quotes' of the other type."
d = "multiple string literals" ' are concatenated ' '''by the parser'''
e = "Escaping: quotes: \" \' backslash: \\ newline: \r\n ascii code: \x40"
f = """triple-quoted strings may contain newlines, "single"
'quotes' and '''multiquotes''' of the other type"""
g = "Üňíçǿđȩ is also possible: 北京, Москва, Αθήνα, القاهرة"
h = r"c:\raw\strings\retain\backslashes.txt"

# we iterate over a sequence of all the variables defined above:
for i in (a,b,c,d,e,f,g,h):
    print(i) # prints the contents of the variable

Salida resultante:

Python no tiene tipos de caracteres. Los caracteres se expresan mediante el uso de cadenas con una longitud de 1. De esta manera, la iteración a través de una cadena, o la indexación en una cadena, devuelve una sola cadena.

Listas y tuplas (conjuntos de datos)

Las listas y tuplas básicamente corresponden a arreglos en C e IEC, pero hay algunas diferencias notables:

El acceso al índice siempre está marcado. Acceder a una lista o una tupla con un índice no válido genera una excepción.
Tanto las listas como las tuplas pueden contener elementos de diferente tipo (también otras listas y tuplas). En contraste, en C e IEC, las matrices pueden contener solo elementos de un solo tipo.
Las listas son dinámicas y los elementos se pueden agregar, eliminar o reemplazar en cualquier momento.
Las tuplas no se pueden cambiar: una vez que se crea una tupla, ya no se puede modificar.

Las listas se crean con el list() constructor. Como alternativa, puede utilizar corchetes []. Las tuplas se crean con el tuple() constructor o paréntesis ().

ejemplo 11. Ejemplo: list_tuples.py

from __future__ import print_function
print("Testing tuples and lists")

# We define a tuple with the numbers from 1 to 10:
t = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print("Tuple:", t)

# We can access the 6th element of the tuple.
# As in C, index counting starts with 0.
print("Element 5:", t[5])

# Subscription is more powerful using the range syntax:
print("Range[2:5]:", t[2:5]) # lower bound is inclusive, upper bound is exclusive.
print("Range[2::2]:", t[2::2]) # start with 3rd element, and print every 2nd element.
print("Range[-3:-1]:", t[-3:-1]) # Start with the 3rd last element, end just before the last element (upper bound is exclusive)
print("Range[::-1]:", t[::-1]) # negative step with - print backwards

# lists are similar to tuples...
l = [11, 12, 13, "8", t] # contains mixed types: 3 integers, a string, and the tuple defined above.
print("List:", l)

# ... but elements can be added or removed dynamically.
l.append(9) # Add a 9 to the list.
print("List with 9:", l)
print("List Range[3:6:2]:", l[3:6:2]) # print the 4th and 6th element.

del l[1] # remove the element at index 1, the 12.
print("Removed[1]:", l)
del l[1:3] # Remove the elements at index 1 and 2, the 13 and the '8'.
print("Removed[1:3]:", l)

Salida resultante:

Diccionario

Python también tiene un tipo de tabla hash (también "hashmap"). A diferencia de la lista, se puede indexar con cualquier elemento, por ejemplo, cadenas. Su constructor es dict() y sus literales se declaran con llaves {}.

El guión de muestra dictionaries.py crea la salida que se muestra a continuación. En la última línea, el script finaliza con una excepción "KeyError":

ejemplo 12. Ejemplo: dictionaries.py

from __future__ import print_function
print("Testing dictionaries")

# Declare a dictionary with three entries, the third being a list
d = {1: "a", 2: "b", "my list": [1, 2, 3]}
print(d)

# print the value of the key 1
print(d[1])

# remove the value with the key "my list"
del d["my list"]

# Add a value 4 with the key 3
d[3] = 4
print(d)

# The "get" method returns the second argument if the key cannot be found.
print(d.get(1, 42))
print(d.get(23, 42))

# print all keys in the dictionary
for key in d:
    print(key)

# index access for unknown keys will throw a "KeyError" exception!
print(d[23])

Salida resultante:

Y luego, en la última línea, el script termina:

Haga clic en el Detalles botón para ver el seguimiento de la pila. Aquí se determina el número de línea 27 y la llave desconocida 23.

En esta sección:

Sintaxis básica de Python (con ejemplos)

Sugerencia

Variables y tipos de datos

Tipos numéricos y puntos flotantes

Instrumentos de cuerda

Listas y tuplas (conjuntos de datos)

Diccionario

Resultados de la búsqueda