Programación RPi Python 07: Conceptos básicos de Python (Parte 2)

En el tutorial anterior , aprendimos sobre la sintaxis de Python, es decir, sus identificadores, palabras clave, comentarios, declaraciones, literales y tipos de datos. También aprendimos que Python está orientado a objetos y que estos objetos pueden ser mutables o inmutables . Los objetos de Python que apuntan a un grupo de valores son iterables, lo que en este caso se denomina iterador .

Todos los tipos de datos cubiertos en el tutorial anterior (enteros, flotantes, números complejos, cadenas, cadenas sin formato) son tipos de datos para literales (valores reales asignados a variables o atributos). Python también tiene tipos de datos para referencias que apuntan a un grupo de valores (elementos) ordenados o desordenados.

Además, Python tiene los siguientes tipos de datos:

Tuplas: una secuencia de objetos. Una secuencia se refiere a un grupo ordenado de elementos (objetos), donde los índices pueden acceder a los elementos. Los elementos de una tupla pueden ser un objeto arbitrario mutable o inmutable.

Sin embargo, la tupla es inmutable, lo que significa que los elementos de una tupla no se pueden actualizar ni cambiar una vez definidos. Es por eso que rara vez se recomienda utilizar elementos mutables en una tupla a menos que nunca cambien o requieran actualización. Una tupla puede verse como un grupo de valores u objetos constantes y puede usarse para definir una o más constantes.

Una tupla se define como un grupo de valores u objetos separados por espacios o comas. Opcionalmente, el grupo se puede encerrar entre paréntesis (“(“). Las comas también son opcionales, pero se recomienda usar comas para separar elementos en la tupla, especialmente si la tupla es necesaria para una función.

Opcionalmente, el último elemento de la tupla también puede tener una coma al final. Una tupla vacía se define mediante un par de paréntesis vacíos. La función incorporada, tupla , también se puede utilizar para definir una tupla. Cualquier grupo de elementos separados por espacios o comas será una tupla de forma predeterminada. Si una sola cadena (o cualquier iterable) se define como una tupla, sus caracteres (o elementos) se pueden usar como elementos de tupla.

A continuación se muestran algunos ejemplos válidos de tuplas:

tup1 = 'Id' 'Nombre' 'Dirección'
tup1 = 'Identificación', 'Nombre', 'Dirección'
tup1 = ('Identificación', 'Nombre', 'Dirección')
tup1 = ('Identificación', 'Nombre', 'Dirección',)
tup1 = #Tupla vacía
tup1 = ('Id', 123, 0b1111_1110, 2.5j5.4, Verdadero)
tup1 = ('Id', 123, 0b1111_1110, 2.5j5.4, Verdadero,)
tup1 = tupla('Id', 'Nombre', 'Dirección')
tup1 = tupla('Id' 'Nombre' 'Dirección')
tup1 = tupla('ABC') # es equivalente a tup = ('A', 'B', 'C')

Listas: secuencias ordenadas como un grupo de elementos mutables. Esto significa que los elementos de una lista se pueden cambiar o modificar. Básicamente, las listas son un grupo modificable de valores u objetos donde los elementos del grupo se pueden reemplazar, eliminar o agregar. Los elementos de una lista pueden incluir cualquier objeto mutable o inmutable arbitrario.

Una lista se define como un grupo de valores y/u objetos separados por comas y encerrados entre corchetes ("("). Opcionalmente, el último elemento de la lista puede tener una coma al final. La función incorporada, lista , puede También se puede utilizar para definir una lista.

Una lista vacía se define mediante un par de corchetes vacíos o mediante la función de lista sin argumentos. Si se utiliza un iterable como único elemento de una lista, sus elementos se pueden utilizar como elementos de lista.

Aquí hay algunos ejemplos de listas válidas:

lista1 = ('Identificación', 'Nombre', 'Dirección')
lista1 = ('Identificación', 'Nombre', 'Dirección',)
lista1 = #Listavacia
lista1 = lista #Listavacia
lista1 = ('Id', 123, 0b1111_1110, 2.5j5.4, Verdadero)
lista1 = ('Id', 123, 0b1111_1110, 2.5j5.4, Verdadero,)
lista1 = lista('Identificación', 'Nombre', 'Dirección')
lista1 = lista('Id' 'Nombre' 'Dirección')
lista1 = lista('ABC') # es equivalente a lista1 = ('A', 'B', 'C')

Conjuntos: una colección cambiante y desordenada de elementos únicos. Los elementos de un conjunto deben ser inmutables y “hashables”, lo que significa que su valor (el valor hash) nunca debe cambiar. Inmutable significa que su tipo de datos tampoco debería cambiar nunca. Esto se debe a que un conjunto solo puede contener elementos inmutables y con hash, sin ningún otro conjunto dentro de él.

Un conjunto se define por un grupo de valores y/u objetos (inmutables y hash) separados por comas entre corchetes (“{“). Opcionalmente, el último elemento del conjunto puede tener una coma al final. La función incorporada, define , también se puede utilizar para definir el conjunto. Un conjunto vacío se define mediante un par de corchetes vacíos o define una función sin argumentos.

A continuación se muestran ejemplos válidos de conjuntos:

set1 = {'Id', 'Nombre', 'Dirección'}
set1 = {'Id', 'Nombre', 'Dirección',}
conjunto1 = {} #conjunto vacío
set1 = establecer #Conjunto vacío
set1 = {'Id', 123, 0b1111_1110, 2.5j5.4, Verdadero}
set1 = {'Id', 123, 0b1111_1110, 2.5j5.4, Verdadero,}
set1 = set('Identificación', 'Nombre', 'Dirección')
set1 = set('Id' 'Nombre' 'Dirección')

Conjuntos congelados: versión inmutable de conjuntos. Están definidos por la función de conjunto congelado . Un frozenset vacío está definido por la función frozenset sin argumentos.

Aquí hay ejemplos válidos:

fset1 = frozenset('Identificación', 'Nombre', 'Dirección')
fset1 = frozenset('Id' 'Nombre' 'Dirección')
freset1 = frozenset #Conjunto congelado vacío

Diccionario: una colección de valores mutables y desordenados emparejados con claves arbitrarias. Estas claves son arbitrarias, pero deben ser hash. Los valores pueden incluir cualquier objeto mutable o inmutable arbitrario.

El diccionario es similar a un mapa desordenado o una tabla hash en otros lenguajes de programación. Se define como un grupo de comas, pares de claves separados y valores entre corchetes o utilizados como argumentos en la función dict .

El par clave-valor, la clave y el valor están separados por dos puntos (“:”). En la función dicha , la clave y el valor de un par se pueden separar mediante un signo igual (“="”) o se pueden colocar en una tupla. Opcionalmente, el último elemento (par clave-valor) de un diccionario puede tener una coma al final.

Un diccionario vacío se define mediante un par de corchetes vacíos o mediante la función dictada sin argumentos. Cualquier elemento de un diccionario debe ser un par clave-valor, incluso si el valor es iterable.

A continuación se muestran ejemplos válidos de diccionarios:

dict1 = {x:25, y:57, z:64}
dict1 = {x:25, y:57, z:64,}
dict1 = {'x':25, 'y':57, 'z':64,}
dict1 = {'x':25, 57:'y', z:8.9j6.5}
dictado1 = dictado (x = 25, y = 57, z = 64)
dict1 = dict((x, 25), (y, 57), (z, 64))
dict1 = dict # Diccionario vacío
dict1 = {} # Diccionario vacío

Ninguno: un objeto nulo en Python, que equivale a "ningún objeto" y no tiene atributos ni métodos. Una función devuelve Ninguno si no tiene una declaración de retorno.

Byte: secuencias inmutables (colección ordenada), donde solo los elementos pueden ser bytes (enteros en el rango de 0 a 255). Los elementos de un Byte pueden ser caracteres de una cadena, números enteros, Ninguno o iterables.

Los bytes se pueden definir anteponiendo "b" antes de una cadena o un número entero o utilizando una función de bytes . La función Byte también le permite especificar una codificación.

A continuación se muestran algunos ejemplos válidos:

Val = b'Python'
Val = b'123'
Val = bytes('Python')
Val = bytes('Python', utd-8)
Valor = bytes ((1, 2, 3, 4, 5))

Matrices de bytes: secuencias mutables (colección ordenada), que contienen solo elementos (enteros en el rango de 0 a 255). Los elementos de una matriz de bytes pueden ser caracteres de una cadena, números enteros, Ninguno o iterables.

La única diferencia entre los tipos de matriz de bytes y bytes es que un byte es inmutable, mientras que la matriz de bytes es mutable. Se puede definir una matriz de bytes utilizando la función bytearray incorporada.

A continuación se muestran algunos ejemplos válidos:

Val = bytearray(“Python”, 'utf-8')
Val = bytearray((1, 2, 3, 4, 5,))
Val = bytearray # bytearray vacío

Rango: una secuencia (colección ordenada) de números enteros entre dos valores enteros, de modo que cada valor entero (elemento) difiere en un elemento adyacente a través de un valor de paso. De forma predeterminada, los valores adyacentes están separados por una diferencia de “1”.

Una cocina se refina utilizando la función de cocina integrada. La función de rango tiene la siguiente sintaxis:

intervalo (inicio, parada, paso)

• Si solo se proporciona un valor como argumento en el rango, dará una secuencia de números enteros desde 0 hasta el argumento dado.
• Si se dan dos valores como argumentos, se da una secuencia de números enteros entre los dos valores, que los incluye.
• Si se proporcionan tres valores como argumentos, el tercer valor sirve como la diferencia entre cada elemento adyacente.

A continuación se muestran ejemplos válidos de un rango:

rango(9) # 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
rango(5, 10) # 5, 6, 7, 8, 9, 10
rango(2, 10, 2) #2, 4, 6, 8, 10

Booleano: este tipo sólo puede tener dos valores: Verdadero o Falso. Cualquier valor distinto de cero o contenedor que no esté vacío se considera Verdadero. Cualquier valor de cero, Ninguno o Contenedor vacío se considera falso. Los valores Verdadero y Falso también se pueden indicar con “1” y “0”, respectivamente.

Hay varios otros tipos de datos en Python que pueden tener clases integradas (como fecha y hora) o clases definidas por el usuario. Por ejemplo, cualquier clase que defina un tipo de datos por propósito o denote una estructura de datos puede considerarse una clase de tipo de datos.

Hay seis tipos de secuencias (colecciones ordenadas) en Python:

1. Instrumentos de cuerda
2. bytes
3. matrices de bytes
4. Rango
5. tuplas
6. Liza

Los índices de secuencia deben comenzar en "0" (es decir, el primer elemento de cualquier secuencia tiene un índice/clave de "0"). Los conjuntos, conjuntos congelados y diccionarios son colecciones desordenadas en Python.

Para mayor claridad, consulte esta tabla:

Nombre de la colección	Naturaleza de la colección	Naturaleza de los artículos
Cadena	Secuencia inmutable (colección ordenada) de caracteres ASCII o UTF (u otra codificación)	Caracteres ASCII o UTF o caracteres correspondientes al esquema de codificación aplicado
Byte	Secuencia inmutable de bytes (0 a 255)	Valores de bytes en el rango de 0 a 255 que pueden ser números enteros, caracteres o iterables
Matriz de bytes	Secuencia mutable de bytes	Valores de bytes en el rango de 0 a 255 que pueden ser números enteros, caracteres o iterables
Rango	Secuencia inmutable de números enteros	Enteros entre el rango definido
tupla	Secuencia inmutable de objetos.	Objetos arbitrarios mutables o inmutables.
Lista	Secuencia mutable de objetos.	Objetos arbitrarios mutables o inmutables.
Definir	Colección de objetos mutables y desordenados.	Objetos inmutables arbitrarios, no se permiten objetos duplicados
Conjunto congelado	Colección de objetos inmutable y desordenada.	Objetos inmutables arbitrarios, no se permiten objetos duplicados
Diccionario	Colección mutable y desordenada de pares clave-valor	Claves arbitrarias inmutables y valores mutables o inmutables arbitrarios

Variables, atributos y elementos.
En Python, donde todo es un objeto, los valores de los datos también son objetos. Los valores de los datos se almacenan en la memoria. Esto significa que cada vez que aparece un nuevo valor de datos en el código Python (ya sea definido en el código o en tiempo de ejecución), también se almacena en algún lugar de la memoria.

El código accede a estos valores de datos a través de referencias. Estas referencias pueden ser variables, atributos, métodos o elementos de un objeto. Las variables son referencias a valores de datos que se pueden usar en cualquier parte del código.

Los atributos son referencias a valores de datos no invocables asociados con un objeto. Los métodos son referencias a valores de datos "invocables" asociados con un objeto. Ser invocable significa que estos valores de datos ejecutan un grupo de instrucciones cuando ocurren. En Python, las instancias de una clase se denominan elementos. Por lo tanto, los elementos son referencias a instancias de una clase u objetos.

Siempre que se asigna un valor de datos a una variable, atributo, método u objeto, el proceso se denomina vinculación. El valor de los datos sigue siendo independiente de su conexión. Si se asigna un valor de datos diferente a una referencia, ese valor de datos se almacena en una ubicación de memoria diferente. Como resultado, el valor de los datos anteriores (si no está vinculado a ninguna otra referencia) se desvincula. La limpieza de valores u objetos de datos independientes se denomina recolección de basura.

No hay declaraciones en Python. Las referencias aparecen instantáneamente y no tienen ningún tipo de datos declarado. La forma en que se maneja una referencia (a un objeto de valor/datos) depende de la expresión en la que aparece y de cómo/si se usa para volver a vincular otra referencia.

Los valores de datos se pueden vincular a una referencia mediante una asignación o declaraciones de asignación aumentadas. En una declaración de asignación, una expresión RHS está vinculada a un objetivo LHS y están separados por el signo de asignación (“="). El objetivo puede ser cualquier referencia, como una variable, un atributo o un elemento.

Una declaración de asignación simple se ve así:

var = expresión

Este es un ejemplo de una tarea sencilla:

uno = 1

Puede asignar un valor de datos (o el resultado de una expresión) a varios objetivos al mismo tiempo:

var1 = var2 = var3 = Expresión

Este es un ejemplo de tal tarea:

a = b = c = 1

Si la expresión RHS es iterable o da como resultado un iterable, se debe asignar a otro iterable (del mismo tamaño) o a múltiples variables (iguales en número al tamaño del iterable) de la siguiente manera:

var1, var2, var3 = Iterable/Expresión que resulta en Iterable

Aquí hay un ejemplo de tal declaración:

a, b, c, = (1.1, 1.9, abc)

Si una referencia de destino tiene un asterisco (“*”) delante, acepta una lista de todos los valores/objetos de datos que no han sido asignados, de la siguiente manera:

var1, *var2, var3 = Iterable/Expresión que da como resultado Iterable

Aquí hay un ejemplo de tal tarea:

a, *b, c, = 1.1, 1.9, abc, 43, 2.5j4 # b = 1.9, abc, 43

En una asignación aumentada, se utiliza un operador aumentado como +=, -=, *=, **= para una asignación. La referencia de destino debe crearse antes de usarse en dicha declaración. Solo puede haber una referencia de destino en una tarea aumentada.

En la asignación aumentada, el valor de datos previamente asignado a una referencia se modifica y se reenvía a ella. El valor de datos previamente asignado se desacopla (de esa referencia específica).

A continuación se muestra un ejemplo de una tarea aumentada:

a += b # a = a + b

Los valores de datos se pueden desacoplar de las referencias mediante una declaración del . A esto se le llama desacoplamiento. Puede desvincular varias referencias en una sola declaración del separando las referencias de destino con una coma. Sin embargo, una declaración del solo separa un objeto de valor/datos de una referencia y no elimina el valor o el objeto de datos. Si el valor de los datos no está vinculado a ninguna otra referencia, se deja para la recolección de basura.

Aquí hay ejemplos válidos de declaraciones del :

de ahí a
de a, b, c

Operadores de Python
Los operadores se utilizan para manipular valores de datos y referencias formando expresiones lógicas. Puede haber una o más expresiones dentro de una declaración lógica. Python admite muchos operadores.

Estos son los mas comunes:

Operadores aritméticos: incluyen suma (+), resta (-), multiplicación

, división (/), módulo (%), exponenciación (**) y división piso (//). El operador de suma también sirve como operador de concatenación con cadenas y otros iterables. De manera similar, el operador de multiplicación

se puede usar para copiar una cadena o iterar durante tiempos específicos usando un multiplicador. Operadores de Asignación -

incluyen asignar (=), sumar y asignar (“+=”), restar y asignar (-=), multiplicar y asignar (*=), dividir y asignar (/=), módulo y asignar (%=), exponenciación y asignar (**=) y división de piso y asignar (//==).

Operadores de comparación -

incluya igual (==), distinto de (!= o ), mayor que (>), menor que (<), mayor o igual que (>=) y menor o igual que (<=). También puede encadenar comparaciones de la siguiente manera:

a < b >= c # a < beb >=c Operadores lógicos –

incluya el AND lógico (y), el OR lógico (o) y el NOT lógico (no). Operadores bit a bit –

incluye AND binario (&), OR binario ( ), XOR binario (^), complemento binario (~), desplazamiento binario a la izquierda (<<) y desplazamiento binario a la derecha (>>). Operadores de membresía: incluir en (en) y no en (no en). Estos operadores se utilizan para evaluar si un elemento pertenece a una secuencia o colección. El operador in devuelve verdadero si el elemento LHS es miembro de la secuencia/colección RHS. El operador not in devuelve verdadero si el elemento LHS no es miembro de la secuencia/colección RHS. Operadores de identidad: incluir es (es) y no es (no es). Estos operadores se utilizan para evaluar si dos referencias son idénticas. Las dos referencias pueden tener la misma identidad si apuntan al mismo valor de datos, que se puede almacenar en la misma ubicación de memoria (según el sistema operativo y la plataforma). Qué es

El operador (is) devuelve verdadero si ambas referencias tienen la misma identidad. Lo que no es

El operador (no es) devuelve verdadero si ambas referencias no tienen la misma identidad. Operador de indexación –

El operador de indexación ( ) se utiliza con secuencias para acceder a un elemento específico desde ellas. Los índices de todas las secuencias comienzan con "0", por lo que el primer elemento de cualquier secuencia tiene un índice (o clave) de 0. Los índices de los elementos siguientes aumentan en "1". Por lo tanto, x(2) le permite acceder al tercer elemento de una secuencia “x”. Si se utiliza un número negativo como índice, se accederá a este elemento contando desde el último elemento de la secuencia y no desde el primero.
Operador de corte –

La siguiente tabla resume la precedencia de los operadores en Python, desde la precedencia más baja hasta la precedencia más alta:
Precedencia de operadores en Python

Tabla que muestra la precedencia de los operadores en Python en orden ascendente Declaraciones de flujo de control

Python admite las siguientes declaraciones de flujo de control:
Si-elif-si no –
una declaración condicional que le permite ejecutar declaraciones si las expresiones condicionales devuelven verdadero. Tiene esta sintaxis:
si expresión_condicional1:
declaraciones)
elif expresión_condicional2:
declaraciones)
elif expresión_condicional3:

declaraciones) else expresión_condicional: declaraciones) En la declaración if, Elif y otros

son opcionales. Debido a que una expresión condicional se evalúa como Verdadera, las declaraciones que la preceden se ejecutan y la ejecución de la

si
La declaración termina ahí. Sin embargo, una expresión condicional no necesita devolver explícitamente Verdadero o Falso. En Python, cualquier expresión u objeto se evalúa implícitamente como Verdadero o Falso como expresión condicional.
Por lo que se recomienda utilizar la siguiente expresión:
Vie:
Si no x:
En lugar de las siguientes expresiones:
Si x == Verdadero:
Si x == 1:
Si x es verdadera:
Si booleano(x):

Si x == Falso: Si x == 0: Si x es falso:

Es importante tener en cuenta que Python no

admite una declaración de cambio.

Como declaración -
repite una declaración o bloque de declaraciones si una expresión condicional se evalúa como Verdadera. Sigue repitiéndose hasta que la expresión condicional se evalúa como Falsa. Esto significa que una declaración debe contener código que eventualmente haga que la expresión condicional sea Falsa.

La declaración while tiene esta sintaxis: Mientras expresión_condicional: Declaraciones) Las declaraciones que se ejecutan repetidamente en una declaración while se denominan cuerpo del bucle. Si se usa while dentro de una función y el cuerpo del bucle contiene una declaración de retorno, el bucle termina allí, ya que la declaración de retorno finaliza la ejecución de la función. Asimismo, el descanso y la continuación.

Las declaraciones también pueden afectar la declaración while. Declaración de entrada: le permite ejecutar una declaración o un bloque de declaraciones mientras recorre elementos en un iterable. Una referencia de destino accede a los elementos del iterable. Los elementos iterables pueden ser utilizados por las declaraciones o no. Pero el iterable nunca debe modificarse a un in

declaración como la

mientras
Al iterar a través de una lista, conjunto o diccionario, no se deben agregar ni eliminar elementos.

La declaración for-in tiene esta sintaxis: para target_reference en iterable: Declaraciones)

Puede haber más de una referencia de destino separada por comas si el iterable es un diccionario u otra estructura de datos en la que cada elemento contiene más de un valor de datos. Por ejemplo, el siguiente
para

La declaración se repite a través de un diccionario: para clave, valor en d.items: imprimir (clave + ':' + valor + '/n')

Si se debe ejecutar una sola declaración en cada elemento de un iterable para obtener un nuevo iterable, el

para

La declaración se puede combinar con una declaración de asignación de la siguiente manera:

y = x+3 para x en el intervalo(5)

En esta declaración, la ejecución de la expresión también puede ser condicional, así: y = x+3 for x in range(5) if x%2==0 Son posibles declaraciones similares con listas, conjuntos y diccionarios. Declaración de ruptura –

utilizado en el cuerpo de un bucle para terminar el bucle. A menudo se utiliza con un

si
declaración. Cuando se encuentra la declaración break, el ciclo finaliza.
A continuación se muestran algunos ejemplos válidos de una declaración de interrupción:
Mientras x: #ejecutar bucle si x no es cero o ninguno
Si x<10:
imprimir (x)
x + = 1
otro:
romper
Mientras x: #ejecutar bucle si x no es cero o ninguno
Si x>10:
romper

otro: imprimir (x) x + = 1 Continuar declaración –

se utiliza en el cuerpo de un bucle para dejar la ejecución de declaraciones posteriores solo para la iteración actual del bucle. A menudo se utiliza con el

si
declaración.
Aquí hay un ejemplo válido:

while x<=10: if x%2 == 0: continuar print (x) Otra declaración – usada con declaraciones if , for y while . Cuando se usa con for o while , ejecuta una declaración o un bloque de declaraciones después de la terminación natural del bucle (es decir, después de todos los elementos de un iterable en for

declaración o cuando una expresión condicional de una declaración while se evalúa como False). Declaración de aprobación –

utilizada en
si
declaración si no se debe hacer nada con una expresión condicional. Tiene esta sintaxis:
si expresión_condicional:
Declaraciones)
elif expresión_condicional:
Declaraciones)
elif expresión_condicional:

Pase #Nada que hacer si se cumple esta condición (otro: Declaraciones) Manejo de excepciones: soporte para Python try , excepto , finalmente , otro y con

instrucciones para el manejo de excepciones. Se puede generar una excepción en el código explícitamente mediante un
elevación

• declaración. Cuando se genera una excepción implícita o explícitamente, la ejecución normal del código se desvía hasta que se resuelve la excepción.
• Funciones
• Las funciones son bloques de instrucciones que se pueden llamar. En Python, las funciones también son objetos. Ellos pueden ser:

Asignado a referencias (variables, atributos y otros objetos) Incluido como elemento en un iterable Usado como argumento en otras funciones

Una función también puede devolver otra función. Se define usando una
definición

instrucción y tiene esta sintaxis:

def nombre_función(parámetros):

declaraciones)

El nombre de la función es un identificador que se puede utilizar para realizar llamadas a funciones. Los parámetros son referencias que se deben proporcionar a una función cuando se llama. Los parámetros (o argumentos) son opcionales y si una función no requiere el suministro de referencias, no hay razón para incluirlos en la definición de la función.

Si hay varios parámetros, deben estar separados por comas entre paréntesis en la definición de la función. Es posible que se ejecuten una o más instrucciones al llamar a la función. Estas instrucciones se denominan cuerpo funcional.
Es posible tener parámetros opcionales en una función que pueden o no proporcionarse cuando se llama a la función. Estos parámetros opcionales se especifican mediante una expresión de asignación, donde al parámetro opcional se le asigna un valor predeterminado.

Una función con parámetros opcionales tiene esta sintaxis:

def nombre_función(parámetro, parámetro_opcional = expresión):
declaraciones)
Además, este es un ejemplo válido de una función con parámetros opcionales:

def makeList(x, y=): y.append(x) retorno

Una función puede devolver cualquier dato o valor de objeto usando un

volver

instrucción, que sólo se puede utilizar en el cuerpo de una función. Si la función no tiene una declaración, expresión, valor de datos u objeto de retorno después de una palabra clave de retorno, la función no devuelve ningún objeto.

Los parámetros que no son opcionales se denominan parámetros posicionales. Es posible proporcionar cualquier número arbitrario de parámetros posicionales a una función con un asterisco precedido.
o doble asterisco (**) antes de un parámetro.
Anteponiendo un asterisco

a un parámetro, acepta cualquier número arbitrario de parámetros posicionales y los recopila en una tupla. Anteponiendo un doble asterisco

a un parámetro, acepta cualquier número arbitrario de parámetros posicionales y los recopila en el diccionario.

A continuación se muestra un ejemplo válido de aceptación de un número arbitrario de parámetros posicionales en una función:

def agregar(*núm)
suma devuelta (núm)
s = sumar(15, 20, 15) # s = 50

Las referencias dadas a una función cuando se llama se conocen como argumentos. Los argumentos se pueden proporcionar como argumentos posicionales o con nombre. Si los valores/objetos de datos se utilizan como argumentos sin asignarlos a referencias de parámetros, serán aceptados en la llamada de función por la posición de su aparición en la firma de la función. (Nota: la firma de la función es la colección de parámetros vinculados a una función).

Estos se llaman argumentos posicionales. Si los valores/objetos de datos se utilizan como objetos asignándolos explícitamente a referencias de parámetros, la posición de su aparición en una llamada de función no importa. Se denominan argumentos con nombre o palabras clave.
Aquí hay un ejemplo válido de los argumentos posicionales:
definición f(a, b, c):

devolver a = b = c

f(12, 17, 21) # devuelve 50

Este es un ejemplo válido de argumentos con nombre (palabra clave):

definición f(a, b, c):

devolver a = b = c
f(b = 12, a = 17, c = 21) # devuelve 50
En Python es posible definir una función dentro de otra función y esta se llama. La función definida dentro de otra función se llama función anidada y la función en la que se define otra función se llama función externa. Una función anidada puede utilizar los parámetros y referencias de una función externa. Esta función anidada se llama cierre.
Una función también puede devolver los valores/objetos en diferentes momentos. Por ejemplo, puede tener ingresos o ingresos por declaraciones. Estas funciones se denominan generadores. Cuando se llama a un generador, devuelve el valor/objeto o resultado de una expresión en la primera declaración de rendimiento y guarda todas las referencias locales en su memoria.
Cuando se vuelve a llamar a la función, comienza a ejecutarse a partir de las declaraciones después de la primera declaración de rendimiento y devuelve el resultado del valor/objeto o expresión después de otra declaración de rendimiento. El rendimiento de una declaración se puede utilizar si la expresión que la contiene es un iterador.

Aquí hay un ejemplo válido de una función generadora:

definición f(a, b, c):
producir un
producir a + b
producir a + b + c
para x en f(2, 5, 7): print(x) # devuelve 2, 7, 14

El generador utiliza el rendimiento de instrucciones:

definición f(a, b, c):

rendimiento del intervalo (a)
rendimiento del intervalo (b)
rendimiento del intervalo (c)

para x en f(1, 2, 3): print(x) # devuelve 0, 1, 0, 1, 2, 0, 1, 2, 3
Python también soporta funciones recursivas, que son aquellas que se llaman a sí mismas dentro del propio cuerpo.

Aquí hay un ejemplo válido de una función recursiva en Python: def factorial(n): si n == 1: devuelve 1

de lo contrario devolver n * factorial (n-1)

Alcance de las referencias
En Python, las referencias pueden tener alcance local o global. Esto se llama espacio de nombres. Las referencias que se vinculan a una función u otros objetos son locales para esa función u objeto. Estas referencias sólo se pueden utilizar dentro de la función u objeto al que están vinculadas.
Las referencias que aparecen fuera de funciones u otros objetos tienen alcance global. Estas referencias se pueden utilizar en cualquier parte del código. Una referencia puede hacerse global anteponiendo un
global

palabra clave. Este es un ejemplo válido: a = 1

def(b):