Python. Lenguaje.

Listas y tuplas.
Operadores

Los operadores son, [según sabemos], componentes de todo lenguaje de programación que permiten manipular los datos referenciados en las variables de diferentes maneras, según el tipo de operador y de datos de que se trate. También las colecciones de datos admiten la acción de operadores y listas y tuplas comparten los mismos.

Los operadores disponibles en listas y tuplas son los siguientes:

• :, que permite obtener segmentos del contenido de ambas colecciones.
• + y *, que permiten realizar las operaciones sobre listas y tuplas. Veremos cuáles.
• in / not in, que permiten verificar la presencia / no presencia de determinado dato dentro del conjunto.
• Y los operadores relacionales <, <=, >, >=, == y !=, cuyas funciones describiremos en su momento.

Aunque figure en primer lugar, no trataré el operador : en esta entrada, dada la relación que mantiene con el acceso a los datos. Por este motivo desplazo su análisis a la [entrada correspondiente]. 

Inicio este análisis con los operadores + y * , los cuales cumplen funciones específicas con listas y tuplas, diferentes de las que permiten hacer con variables. 

• El operador + permite la unión o concatenación de los elementos de varias listas , como cabe suponer por lo que sabemos de los operaciones aritméticos, nos permiten realizar operaciones de suma y multiplicación con listas y tuplas.

lista1 = list([1,2,3,4])

lista2 = list([5,6,7,8])

print(lista1 + lista2) -> devuelve [1,2,3,4,5,6,7,8]

• Este mismo operador, aplicado a tuplas funciona exactamente igual, aunque lógicamente devuelve una tupla ((1,2,3,4,5,6,7,8))
• La operación * tiene como efecto la repetición de la lista o la tupla sujeta a tal operación, siendo indiferente que el operador se sitúa antes o después de la lista o tupla. Así que print(3 * lista1) devuelve [1,2,3,4,1,2,3,4,1,2,3,4] y print(tupla1 * 2) devuelve (1,2,3,4,1,2,3,4). En ambos casos el número debe ser entero (ni 3.1 ni 2.4 se admiten como "multiplicadores")
• Ambos operadores tienen el mismo efecto con independencia de la naturaleza de los elementos de la lista o de la tupla.
• En ambos casos no está permitido el trabajo con listas y tuplas simultáneamente. No es posible ni lista + tupla, ni tupla * lista, ni ninguna otra combinación o permutación de elementos.

Los operadores in / not in permiten identificar si un datos forma parte o no de una lista o de una tupla. in y not in devuelven el booleano True o False según el resultado de la operación. Ejemplos para lista1 y tupla1 anteriores:

print(5 in lista1) devuelve False

print(1 in lista1) devuelve False

print(5 not in lista1) devuelve True

print(1 not in lista1) devuelve True

print(5 in tupla1) devuelve False

print(1 in tupla1) devuelve False

print(5 not in tupla1) devuelve True

print(1 not in tupla1) devuelve True

Los operadores relacionales permiten comparar dos listas entre sí, elemento a elemento y según criterios específicos en función del tipo de elemento. También devuelven True o False, según el resultado de la comparación. Veamos algunas comparaciones, tomando como referencia las listas y las tuplas creadas antes. Dada la multiplicidad de opciones me limitaré a unos pocos ejemplos, aunque los resultados se pueden hacer extensibles al resto de los operadores:

#Operadores relacionales con listas

print(lista1 == lista1) devuelve True

print(lista1 != lista2) Devuelve True

#Operadores relacionales con tuplas

print(tupla1 == tupla1) Devuelve True

print(tupla1 != tupla2) Devuelve True

#Operadores relacionales con listas y tuplas

print('Operadores relacionales con listas y tuplas')

print(lista1 == tupla1) Devuelve False por ser una lista y la otra tupla, aunque su contenido es el mismo (valores enteros 1,2,3,4 en ambos casos)

Lenguajes. R.

Operadores

Los operadores indican al lenguaje qué operación debe realizar con los datos. Aunque sea una simplificación, se puede decir que es la combinación de ambos (datos y operadores) la base que nos permite resolver las tareas con este y con el resto de los lenguajes de programación.

Al igual que en resto de los lenguajes, también en R podemos diferenciar distintos tipos de operadores: aritméticos, relacionales, lógicos y de asignación.

Empezaremos por los operadores de asignación, ya que [ya ha sido empleado]. En realidad uno de los dos posibles (saludo <- "Hola Mundo R"), porque también podemos realizar la asignación mediante el operador = (saludo = "Hola Mundo R"), si bien <- es el operador de asignación que más se usa en R por tradición y para evitar confusiones. En cualquier caso, realizar la operación de asignación es, como sabemos, asignar una referencia que permite al lenguaje encontrar el dato en una posición de la memoria RAM.

Los operadores aritméticos (algebraicos, si se prefiere) son los que se emplean para realizar cálculos matemáticos: 

• Las cuatro operaciones básicas: + , - , * y /
• La división entera: %%, que redondea al entero más próximo y omite la parte decimal
• Y la potenciación: ^, que eleva el número a la n.esima que se indique (2^3)

Los operadores relacionales permiten valorar la comparación entre los datos en términos dicotómicos (V/F): < (menor que), <= (menor o igual que), > (mayor que), >= (mayor o igual que), == (igual que) y su opuesto != (no igual que).

Estos operadores se comportan de forma específica con datos string, ya que lo que hacen es comparar por el criterio "orden alfabético", de modo que "casa" > "barco" devuelve TRUE, ya que "casa" es posterior (superior o mayor) a "barco" por ese criterio. Además no tiene sentido realizar comparaciones con datos tipo factor, por lo que obtendremos NA como resultado y un mensaje de error.

Los operadores lógicos son empleados para describir relaciones lógicas (álgebra booleana), expresadas en términos V/F:

• x | z -> O lógico (x o z). Devuelve TRUE si alguno de los miembros es TRUE y sólo devuelve FALSE si todos los miembros son FALSE.
• x & z -> Y lógico ( x y z). Devuelve FALSE si alguno de los miembros es FALSE y TRUE sólo cuando todos los miembros son TRUE.
• !x -> Negación lógica (x no es verdadero)
• isTRUE(x) -> Afirmación lógica (x es verdadero)

Los operadores lógicos pueden ser usados con datos numéricos, lógicos y complejos. Además los operadores lógicos se pueden combinar entre sí y también con los operadores relacionales, ya que ambos devuelven V/F.

Como en matemáticas y en el resto de los lenguajes de programación, existe un orden de prelación en el uso de los operadores que podemos alterar empleando paréntesis.

1. ^
2.  * /
3. + -
4. < > <= >= == !=
5. !
6. &
7. |
8. <-

Lenguajes. Python.

Variables numéricas y operadores algebraicos

También python cuenta con tipos numéricos y los operadores algebraicos básicos necesarios para realizar las principales operaciones. En esta entrada trataremos de ambos.

Respecto a los tipos numéricos, al contrario que PseInt, y OOo Basic, en Python, al no ser necesario declarar previamente las variables (declaración implícita), en la asignación de valores o datos a las variables, no son necesarios nombres específicos para identificar los tipos de variables, aunque procesos de conversión o cambio de tipo revela que se pueden diferenciar tres conjunto numéricos (lo que equivale a decir que se identifican tres tipos numéricos: entero (Int), reales do de coma flotante (float) e complejos (números con parte imaginaria). Siguiendo la lógica de la teoría de conjuntos, los reales incluyen a los enteros y los complejos a los reales.

NOTA: Recuerda el gráfico de los conjuntos numéricos. En él se muestran los conjuntos y las relaciones que inclusión que rigen su relación. Los número complejos (conjunto C) incluyen los reales (conjunto R) y los imaginarios, por lo que constituyen el grupo más amplio de todos los conjuntos numéricos descritos por la ciencia matemática. Si estás interesado en conocer qué son los números imaginarios y las operaciones que se pueden realizar con ellas, te recomiendo que consultes este documento. También te recomiendo esta página.

A parte de simplificar el proceso de creación de variables y asignación de datos, la declaración implícita, cuando se trabaja con tipos numéricos, presenta en Python la ventaja añadida de que no existe incompatibilidad de tipos, desbordamiento o imprecisión por truncamiento cuando asignamos a una tercera variable el resultados de operar con otras. Es el propio intérprete el que se encarga de gestionar estas cuestiones (tipado dinámico), lo que nos evita tener que estar pendientes de cuestiones como las que comentamos respeto a los tipo numéricos y los operadores algebraicos en OOo Basic.

Te muestro una ejemplificación de lo anterior en estas comprobaciones realizadas directamente en el intérprete de Python (PyShell):

var1 = 23 

var2 = 32

var1+var2

55
var1 = 23
var2 = 34.54
var1+var2
57.54 

var1=23
var2 = 33
var3 = var1 + var2
print(var3)
56
var1 = 23
var2 = 3567.980
var3 = var1 + var2
print(var3)
3590.98

Observa que las primeras comprobaciones se realizan directamente y las segundas mediante la asignación del resultado de la operación a una variable. En azul el resultado que devuelve el intérprete.

Por lo que se refiere a los operadores algebraicos, Python cuenta con el mismo repertorio básico que se identifican en PSeInt y en OOo Basic, aunque varían algunos de los símbolos:

• Suma (+)
• Resta (-)
• Multiplicación (*)
• Potenciación (**)
• División real (/)
• División entera (//)
• Resto (%)

Respecto a las dos modalidades de división (real y  entera) observa el resultado de aplicar los operadores /, // y % en Python, primero directamente...

var1 = 389

var2 = 23

var1/var2

16.91304347826087

var1//var2

16

var1%var2

21

... y en segundo lugar, asignando el resultado de la división a una variable:

vDivR = var1/var2

print(vDivR)

16.91304347826087

vDivE = var1//var2

print(vDivE)

16

vResto = var1%var2

print(vResto)

21

Como puedes ver, el resultado es el mismo, sin que se observen las diferencias de resultados en función del tipo de operación y variable. Esto supone una ventaja evidente sobre OOo Basic, y sobre otros lenguajes mucho más rigurosos en el tratamiento de los tipos numéricos. Y todo ello gracias el tipado dinámico.

Además de los operadores anteriores, Python dispone de unos operadores especiales llamados operadores aumentados de asignación. Son los siguientes (uno por cada tipo de operador básico):

• += Suma asignación
• -= Resta asignación
• *= Multiplicación asignación
• **= Potenciación asignación
• /= División real asignación
• //= División entera asignación
• %= Resto asignación

Estos signos son equivalentes a lo que en otros lenguajes se expresa como asignación de operación a variable: a = a + x (siendo a la variable y x un número cualquiera). Por ejemplo:

a += 3 (Python) equivale a a = a + 3  (OOo Basic)

El resultado es una simplificación de la escritura del código, aunque para entender mejor su lógica, es necesario recordar que la asignación se realiza de derecha a izquierda, no de izquierda a derecha, por lo que la lectura de de la instrucción es la siguiente: el valor x (3), sumado al valor previamente asignado a la variable a, se asigna a la misma variable a. El resultado es que ahora a = a+3.

Del mismo modo debemos entender el resto de las operaciones. Reproduzco a continuación la comprobación de estas instrucciones de asignación realizadas en el pyshell:

var = 5

print(var)

5

var+=3

print(var)

8

var-=3

print(var)

5

var*=3

print(var)

15

var**=3

print(var)

3375

var/=4

print(var)

843.75

var//=2

print(var)

421.0

Antes de dar por concluida esta entrada, me gustaría avanzar un poco más en el conocimiento del IDLE de Python y en su uso, ya que así es posible crear materiales de mayor complejidad. En concreto quisiera hablar de la diferencia entre el intérprete (Shell o PyShell) y el editor de código.

NOTA: Pyshell es el intérprete interactivo de comandos o instrucciones del IDLE que proporciona Python en su instalación. El editor de código, como su nombre implica, es una herramienta simple de escritura de texto, pero plenamente funcional para crear script.

Como vimos en una entrada anterior y en esta misma, podemos escribir código directamente en el intérprete del IDLE, pero hacerlo nos crea una importante restricción: únicamente podemos comprobar el funcionamiento de instrucciones sucesivas; aunque permite guardar el código generado durante nuestra sesión de trabajo (extensión .py) el resultado no es operativo, ya que necesitamos eliminar el texto identificativo inicial y los resultados de la propia ejecución de los comandos e instrucciones.

Cuando nos interesa guardar nuestro script plenamente funcional o desarrollarlo previamente para probarlo después como un todo, es necesario utilizar un editor de texto. Podemos utilizar cualquier editor, como el propio bloc de notas de Windows, pero el IDLE de Python cuenta con una aplicación orientada a este fin. Para acceder a ella deberemos...

Seleccionar el menú File del Shell y seleccionar...

• New File, si queremos crear un nuevo script, u...
• Open, si queremos acceder a un script ya creado.

A diferencia del intérprete, el editor permite escribir el script para que sea interpretado posteriormente; también permite guardarlo (con extensión .py) y ejecutarlo a posteriori cuantas veces queramos (desde el menú Run). En principio, la ejecución se realiza en el intérprete (PyShell).

Finalmente, antes de dar por concluida esta entrada, incorporaremos la nueva funcionalidad del IDLE de Python e inauguraremos la creación de script en este lenguaje, aunque sea un script un tanto especial y limitado. Para ello te dejo acceso al "script" Python que contiene el conjunto de las comprobaciones que realizamos a lo largo de esta sesión. 

NOTA: Recuerda que, además de acceder a él, tienes que descargarlo, guardarlo en una carpeta de tu elección y acceder a él desde el IDLE de Python. Ya sabes cómo activarlo.

Lenguajes. Python.

Variables, constantes y operadores.

Una variable es un identificador de una posición o contenedor de la memoria RAM en la que se almacenan datos a los que se puede acceder mediante la referencia a la variable o nombre identificativo. En función del tipo de contenido que se almacene en esa posición de memoria hablaremos de tipos de variables (numéricas, alfanuméricas o booleanas).

A diferencia de otros lenguajes, Python no precisa que las variables sean declaradas previamente, sino que la identificación se realiza en el momento en que se la nombre y se le asigna un dato. Otra característica específica de Python es que diferencia la variable según se escriba (case sensitive): vVar1 es una variable y vvar1 es otra variables distinta.

Otras condiciones que se deben tener en cuenta a la hora de dar nombre (identificador) a una variable es que no se pueden usar las palabras reservadas del lenguaje Python, que son las siguientes:

and  - as  - assert - break - class - continue - def - del - elif - else - except - finally - for - from - global - if - import - in - is - lambda - nonlocal - not - or - pass  - raise - return - try - while - with - yield - False - None - True

Las variables deben empezar por una letra, no por números, aunque los pueden contener. Lo que no pueden es contener caracteres que no sean alfanuméricos (a excepción del guion bajo, que se puede usar para unir dos palabras (var_prim)o una palabra y un número (var_1) ni espacios en blanco (var prim no es un nombre válido de variable, var_prim sí lo es).

Python no cuenta con constantes, pero por convención, las variables se escriben en minúsculas (ej. var1, var_1) y se reservan los nombres en mayúsculas para funcionar como constantes (ej. CONST1, CONST_1).

En consecuencia, la diferencia entre variables y constantes es, en Python, más funcional y de lógica de programación, que consustancial al lenguaje: una variable "contiene" (referencia a un contenedor RAM) datos (valores) que pueden cambiar; una constante, por el contrario, se mantendrá sin cambios a lo largo del algoritmo.

Para trabajar con las variables utilizamos los llamados operadores, en los que se diferencian tipos en función del tipo de variable. Así podemos hablar de operadores algebraicos o aritméticos, operadores alfanuméricos o de cadena, operadores booleanos y operadores de asignación.

Los operadores aritméticos son los siguientes:

• + Suma (a+b = c
• - Resta (a-b = d)
• * Multiplicación (a*b = e)
• / División (b/a = d.ddd)
• // División entera (b//a = d)
• % Resto (de la división entera) (b%a = e)
• ** Potenciación (a**2 = a*a= f) (1)

Los operadores de cadena (string) son:

• + Concatenación (literal) s1+s2 ("suma" ambas cadenas)
• s1*n Multiplicador. s1*3 -> s1s1s1 (repite la cadena n veces)

Los operadores booleanos siempre devuelven True (V) o False (F):

• > y >= Mayor (mayor o igual) que
• < y <= Menor (menor o igual) que
• and (Y lógico). a>b and b>c V si se cumplen ambas condiciones. F el resto.
• or (O lógico). a>b or b>c. V se se cumple al menos una condición. F si no se cumple ninguna de las dos.
• != Diferente a!=b.
• == Igual que

Por último tenemos los operadores de asignación siguientes:

• = Asignación (a = 3) (2)
• += Asignación e incremento (a +=1 -> a = a+1)
• -= Asignación y decremento (a -=1 -> a = a-1)
• *= Asignación y producto (a*=2 -> a = a * 2)
• /= Asignación y división (a/=2 -> a = a/2)
• %= Asignación y resto (de división entera) (a%=2 -> a = a%2)

Ejemplos de uso de variables y operadores:

# Operadores aritméticos

3+4*(8-2)

27

45/7

6.428571428571429

45//7

6

7**2

49

43%7

1

45/7

6.428571428571429

45//7

6

45%7

3

2**2

4

2**3

8

2**4

16

2**5

32

2**1/2

1.0

24**2

576

576**1/2

288.0

576**(1/2)

24.0

#Operadores alfanuméricos (string)

"Hola"

'Hola'

"Hola " + "Julio y Juan"

'Hola Julio y Juan'

3*"Hola-"

'Hola-Hola-Hola-'

"Hola-" * 3

'Hola-Hola-Hola-'

#Operadores booleanos

>>> 7 > 9

False

>>> 7>5

True

>>> 7>=7

True

>>> 7>=6

True

>>> 7<5

False

>>> 7<8

True

>>> 7<=8

True

>>> 7==7

True

>>> 7<9 or 7<6

True

>>> 7<9 and 7<6

False

>>> 7<9 and 7<8

True

>>> 7!=5

True

>>> 7<9 | 7<6

False

>>> 7<9 & 7<8

False

# Operadores de asignación

>>> x = 5

>>> print(x)

5

>>> x +=1

>>> print(x)

6

>>> x -=1

>>> print(x)

5

>>> x *=2

>>> print(x)

10

>>> x /=2

>>> print(x)

5.0

>>> x %=2

>>> print(x)

1.0

NOTAS

(1) No existe símbolo operacional para la raíz, por lo que su cálculo debe realizarse a partir de la equivalencia conocida entre raiz y potenciación fraccional (24**2 permite calcular la raíz cuadrada de 24). En la lógica de los ejemplos de la entrada f**2 = a)

(2) Es importante tener presente que = es operador de asignación, no de equivalencia o igualdad, función que cumple el operador ==. La confusión puede venir dada por ser = operador de asignación y de igualdad en otros lenguajes como OOo Basic.

OOo Basic. Datos

 Operadores de asignación, concatenación y de relación

Los operadores son expresiones breves (uno o dos signos) que permiten el trabajo con las variables. Podemos diferenciar tres tipos: el de asignación, los de concatenación y los relacionales o de relación (1).

Los operadores de concatenación son dos: & y +, que se pueden usar indistintamente cuando trabajamos con variables string o con variables string y de tipo numérico, aunque en ambos casos es preferible utilizar el concatenador & por ser el operador específico para esta operación (2).

Los operadores de relación son los más numerosos y complejos. Permiten comparar el valor de dos expresiones, confirmando conjuntamente (expresión 1 # operador # Expresión 2) una proposición. Como tal proposición puede tener valor V (1 o True) o F (0 o False)

La lista de operadores relacionales en OOo Basic es breve, pero suficiente para realizar las comparaciones necesarias entre expresiones (o entre variables) y generar las proposiciones básicas.

Aunque parecen priorizar las comparaciones entre variables (y expresiones) numéricas, también sirven para realizar comparaciones entre variables no numéricas, aunque en este caso con ciertas restricciones en términos de equivalencia/igualdad. 

El operador de asignación (=) tiene como función asignar contenido (del tipo que sea) a una variable. Su uso es aparente muy sencillo (sVar = "Casa", iNum = 323) pero presenta una dificultad que deriva del hecho de que OOo Basic utiliza el mismo signo para el operador de asignación y para la igualdad o equivalencia (uno de los operadores relacionales), lo que genera cierta confusión. Por ejemplo:

Siendo...

Dim A As Integer, B As Integer, C As Integer

 Decir...

A = 230

B = 540 

 ... es asignar el entero 230 a la variable A, y 540 a la variable B, pero también se puede entender que A vale 230 y B 540, por lo que...

C = A + B

... implica tanto asignar el resultado de la A+B (230+540 -> 770) a C como plantear que C es el resultante de la operación matemática +  aplicada sobre A y B. 

En este caso. ambos significados son equivalentes, pero si A y B son cadenas...

A = "Casa"

B = "Mesa"

... ahora es evidente que las respectivas cadenas no son "valores" de A y de B, sino contenidos asignados a los espacios de memoria RAM identificados como A y B, y si...

C = A + B (aunque es preferible A & B)

 ... C no resulta de sumar A + B, sino de concatenar ambas, siendo que asignamos a C  la cadena resultante "CasaMesa"

Una tercera circunstancia es cuando empleamos cualquier proposición en la que dos expresiones, dos variables o una expresión y una variable son comparadas mediante cualquiera de los operadores relacionales, como, por ejemplo...

A < 100

... pero también

A = 100

... en el marco de una estructura condicional (If...End If). En este caso no se está haciendo una asignación, sino expresando una comparación, concretamente que A es inferior a 100 (A<100) o que A es igual a 100 (A=100), pudiendo ser 100 asignado a B, con lo que A=100 es equivalente a A=B. 

En este caso (A = 100 equivalente A = B, para B =100) lo que pedimos de LibreOffice es que valore si esta proposición es cierta (V) o falsa (F) para proceder como corresponda en función de la bifurcación del algoritmo que contiene el condicional If.

NOTAS

(1) En realidad existe un cuanto tipo de operadores, los aritméticos, pero estos ya han sido expuestos [en esta entrada]

(2) Concatenar significa unir cadenas, lo que remite a datos de tipo string o que funcionan como tales. Aunque podemos usar el concatenador +, no es recomendable por la posible confusión con el operador aritmético de suma. Ver al respecto [esta entrada]

OOo Basic. Datos y operadores

Operadores lógicos.

Para finalizar la descripción de los tipos (datos y variables) y los operadores, corresponde ahora presentar los tipos lógicos y los operadores relacionados. Pero antes es necesario retomar algunas cuestiones relativas a la lógica, especialmente a la lógica matemática y a la teoría de conjunto.

En este recorrido, lo primero que debemos retomar es el concepto de proposición que, como podremos ver, tiene diferentes significados.

Según la RAE, el término proposición puede ser entendido como sinónimo de oración, más concretamente como oración simple que se une a otras para formar oraciones compuestas; pero también se entiende por proposición el contenido de su enunciado, respecto al cual se puede emitir un juicio dicotómico en términos de verdad o falsedad. Desde esta perspectiva más centrada en la semántica que en la forma, una proposición es la relación semántica que se produce entre sus dos términos constituyentes (sujeto y predicado), de modo que posible emitir un juicio que los relaciona: bien se afirma o se niega el predicado respecto al sujeto, bien se incluye o excluye el sujeto del predicado.

La primera relación establece una opción dicotómica: V vs. F (toda proposición puede ser verdadera o falsa), que reduce el concepto proposición a determinadas formas expresivas: un enunciado desiderativo o imperativo no son proposiciones, ya que de ellos no se deriva posibilidad de afirmar o negar su enunciado.

Pero la segunda relación, o mejor dicho, la segunda forma de expresar la relación entre el sujeto y el predicado de una proposición, nos permite relacionar su análisis con la matemática, y más concretamente con la teoría de conjuntos (lógica matemática), tanto en términos de relación de pertenencia del elemento al conjunto, como en términos de relación de inclusión entre un conjunto y sus posibles subconjuntos (especialmente el conjunto varío y los unarios).

Además la teoría de conjuntos también permite expresar las relaciones que se producen entre dos o más conjuntos, sean éstas de igualdad o desigualdad. Los operadores relacionales vistos en la entrada anterior permiten establecer relaciones en esos términos entre dos variables (que asimilamos a expresiones que remiten a proposiciones), tanto en términos de igualdad vs. desigualdad (= vs. <>) como en las formas específicas en las que se expresa la desigualdad (esto es: como inecuación): < vs. > cuando no se incluye el extremo en el subconjunto que se define, y <= / >= cuando sí se incluye.

Es por ello por lo que estos operadores devuelven valores V vs. F como resultados de los juicios resultantes de su aplicación, según pudimos comprobar en la entrada anterior.

Desde esta misma perspectiva, podemos considerar los tipos lógicos como contenedores del resultado de las comparaciones establecidas mediante los operadores relacionales, lo que permite realizar procesos de análisis mucho más complejos.

También los operadores lógicos suponen un avance en esta línea, aunque su comprensión exige que nos adentremos un poco más en la teoría de conjuntos y en la lógica matemática.

Si podemos establecer un juicio dicotómico v vs. F respecto a la pertenencia de un elemento a un conjunto, o respecto a la inclusión de un subconjunto en un conjunto, también podemos realizar análisis en esos mismo términos (V-F) respecto a las relaciones que se establecen entre dos conjuntos diferenciados, esto es: que no cumplen criterios de inclusión o relación jerárquica. Esto es: conjuntos que mantienen entre ellos una relación que permite enjuiciar la existencia de elementos comunes (intersección), la suma o unión de ambos (unión) o una relación de complementariedad.

Obsérvese que la primera de estas relaciones, la inclusión, es expresión del concepto lógico y (AND), compartiendo ambas las mismas restricciones para cumplir criterios de verdad y similares signos:

• Un elemento pertenece a la intersección de dos (o más) conjuntos sí y sólo sí pertenece al primero y (también) al segundo.
• AND es V sí y sólo sí la proposición A es V y (también) la proposición B es V

Por su parte la relación Unión (de conjuntos) se asocia con el O lógico (y mantiene simbología similar) y permite juicios de verdad mucho más laxos:

• Un elemento pertenece a la unión de dos (o más) conjuntos, con tal de que pertenezca al menos a uno de ellos.
• OR es V con tal de que la proposición A sea V o lo sea la proposición B

Finalmente Not (No) permite negar la proposición (o la relación proposicional) afirmada previamente, de modo que si A->V, ¬A->F, y viceversa. ¬A puede considerarse, por tanto, complementario de A y cumple los mismos criterios que satisface el conjunto complementario (¬A) de A.

• Si un elemento pertenece al conjunto A, no pertenece a su complementario. Si pertenece al complementario (¬A), pertenece a A.
• Si la proposición A es V, entonces su contraria (No-A) es F y viceversa.

Además NOT también nos permite valorar (e invertir) el resultado de comparaciones: si (A AND B) es F implica que ¬(A AND B) es V.

Todos estos operadores se rigen (y permiten elaborar) tablas de verdad como las que puedes consultar en este documento.

OOo Basic. Lenguaje.

Operadores relacionales.

Cuando necesitamos comparar el valor asignado a dos variables empleamos los operadores relacionales, los cuales devuelven Verdadero (V o 1) si el resultado de la comparación es positivo o Falso (F o 0) si ese resultado es negativo.

Los principales operadores relacionales son los siguientes:

• De igualdad (= o ==, según el lenguaje), que valora V/F en función de que el contenido de de las dos variables sea el mismo.
• De diferencia ( !=, <>), el opuesto del anterior.
• De superioridad: Mayor (>) o igual o mayor (>=), que compara dos variables y determina V/F en función de que la primera sea más grande o cuanto menos igual de grande (en el caso de >=) que la segunda.
• De inferioridad: Menor (<) o igual o menor (<=), que realiza la misma comparación que los anteriores, pero ahora en relación al juicio de inferioridad.

En PSeInt y también Python, los comparadores relacionales son los mismos, aunque algunos de ellos se representen mediante símbolos diferentes.

• El comparador de igualdad se representa con = en pseudocódigo (PSeInt), coincidiendo con el signo del operador de asignación. En Python se emplea el doble signo de igualdad (==) para evitar esa posible confusión.

• El opuesto al anterior, el comparador de diferencia se expresa de dos formas diferentes en PSeInt (<> o !=), aunque se puede convertir automáticamente al símbolo matemático de diferencia () según configuración.
• El segundo de estos símbolos (!=) es que que empleamos en Python.
• El resto de los operadores (< vs. > y <= vs. >=) son iguales en PSeInt y Python.
  

Por lo que parece, los operadores relacionales no presentan especial dificultad, pero es conveniente analizar su comportamiento cuando los empleamos en la comparación de los dos tipos de variable que conocemos hasta el momento: variables alfanuméricas (o de texto) y los distintos tipo de variables numéricas. 

• Sólo cuando dos variables (var1 y var2) son del mismo tipo (sea éste alfanumérico o numérico) y tienen asignado el mismo dato, existe coincidencia (V) entre los operadores de igualdad (=), superioridad (>=) o inferioridad (<=), dado que los tres devuelven V. Y es que en realidad se trata de la misma situación: var1 = var2.
• En caso de variables alfanuméricas, = es V sí y sólo sí ambas tienen asignado exactamente el mismo contenido. Un cambio, por mínimo que sea (vg. un espacio en blanco en Var1 ausente en Var2), aunque no cambie el significado del contenido (vg, el uso de mayúsculas) o sea admisible desde el punto de vista del significado (vg, en caso de que la presencia/ausencia de tilde no afecte al significado), da como resultado que la comparación = resulte F y la comparación <> resulte V.
• No es posible comparar entre variables de diferente tipo (vg, alfanuméricas con numéricas). En estos casos, Python resuelve la igualdad (==) como F y la diferencia (!=) como V.
• En las variables numéricas, aunque una variable sea de tipo diferente a otra (Entero vs Real) son posibles todas las comparaciones.