Tipos de datos
Variables
En estos ejercicios se busca trabajar con variables y tipos de datos con el fin de entender estos conceptos ya que existen en todos los lenguajes y son muy importantes.
Aunque su uso es común, cada lenguaje tiene diferentes formas de declarar variables y maneja diferentes tipos de datos.
En general una variable en programación representa un dato almacenado en memoria que puede variar o no (cambiar el dato almacenado) durante el transcurso del programa.
Cuando se habla del tipo de dato se hace referencia al dato que puede almacenar dicha variable dependiendo de como se halla declarado. De acuerdo a esté tipo de dato la memoria apartada para su uso puede ser diferente según el lenguaje. Como el lenguaje natural de los computadores es binario, es decir que todo se basa en bits (0 y 1), la memoria apartada se mide en grupos de 8 bits, lo que conocemos como bytes.
Ejercicio:
Declarar 3 variables con tipos de datos diferentes, asignarles valor para luego mostrarlos en pantalla.
En este ejercicio no será necesario recibir nada del teclado, solamente mostrar datos en pantalla lo cual ya vimos en nuestro primer ejercicio “Hola Mundo”. Por su sencilles será un código de tipo secuencial, osea que el compilador o interprete leerá y ejecutará el código de arriba hacia abajo sin saltos de linea ni repeticiones de ninguna clase.
Variables en Java
Con java se manejan varios tipos de datos en general son:
- Numéricos: byte, short, int, long, float, double;
- Letras: char;
- Booleanos: que representan falso y verdadero solamente.
Pero siendo un poco más específicos podemos clasificarlos en la siguiente tabla:
| Tipo | Bytes | Rango |
|---|---|---|
|
double |
8 |
4.9e–324 to 1.8e+308 |
|
float |
4 |
1.4e–045 to 3.4e+038 |
|
long |
8 |
–9,223,372,036,854,775,808 a 9,223,372,036,854,775,807 |
|
int |
4 |
–2,147,483,648 a 2,147,483,647 |
|
short |
2 |
–32,768 to 32,767 |
|
byte |
1 |
–128 to 127 |
|
char |
1 |
caracteres del código ascii |
El código quedará:
package variables;
public class Variables {
public static void main(String[] args) {
// TODO code application logic here
int a = 123;
float b = 12.78f;
double c = 234.67;
char d = ‘w’;
System.out.println(“Entero a = “+a);
System.out.println(“Flotante b = “+b);
System.out.println(“Doble c = “+c);
System.out.println(“Caracter d = “+d);
}
}
Variables en Python
En python existen tres tipos generales de datos: Enteros (int), reales (float) y string (str) (cadenas de caracteres)
Se dice que python es dinámicamente tipado por que no es necesario colocar el tipo de dato al decalrar una variable, es decir que no usan declaraciones explícitas de tipos de dato; pero tambíen se dice que es fuertemente tipado, porque despues de que la variable toma un tipo de dato no se puede usar como si fuera de otro tipo distinto sin realizar alguna forma de conversión.
Cuando se declara una variable y no se escribe el tipo, python detecta el tipo de variable automaticamente.
El código quedará:
a = 348
b = 4573.456
c = ‘Hola mundo’
print(a,” es un número entero”)
print(b,” es un número real”)
print(c,” – es una cadena de caracteres”)
Recordemos que esté código lo escribimos en cualquier editor de texto y lo guardamos con extensión .py
ejemplo: nombre_archivo.py
Para ejecutarlo desde la consola de nuestro sistema operativo y ubicados en la misma carpeta del archivo .py escribimos:
pyton nombre_archivo.py
Variables en C++
En C++ se trabaja con diferentes tipos de datos, los más básicos seran:
Enteros (int) sin decimales, flotantes (float) con decimales, Caracteres (char) para letras, simbolos y números que están en el teclado (en caso de números no se tiene en cuenta el valor numérico sino el simbolo).
Para declarar una variable es necesario indicar el tipo de dato, un nombre y asignarle un valor
tipo_dato nombre_variable = valor_variable;
También se puede declarar en una instrucción y en otra asignar el valor .
tipo_dato nombre_variable;
nombre_variable = valor_variable;
Para mostrar el dato por pantalla podemos usar la función printf() con las librerias stdio.h que ya se usó en “Hola mundo”. Pero en el momento de mostrar el contenido de una variable es necesario usar una combinación de caracteres que indiquen el tipo de dato: %d para números enteros, %f para flotantes, %c para caracteres. Esto se coloca dentro de las comillas en el lugar que se quiere mostrar dicho valor, luego fuera de las comillas y dentro del parentesis colocamos el nombre de la variable.
Código:
include <stdio.h>
//#include <stdlib.h>
int main(){
int entero = 123;
float flotante =567.45;
char caracter = ‘R’;
printf(“El numero %d es entero \n”,entero);
printf(“El numero %f es flotante \n”,flotante);
printf(“La letra %c es un caracter “,caracter);
return 0;
}
Otra forma sería con #include <iostream> y cout,
#include
using namespace std;
int main(){
int entero = 123;
float flotante =567.45;
char caracter = ‘R’;
cout << “El numero ” << entero << ” es entero” << “\n”;
cout << “El numero ” << flotante << ” es flotante” << “\n”;
cout << “La letra ” << caracter << ” es un caracter” << “\n”;
return 0;
}
Variables en Ruby
En ruby se manejan tambien varios tipos de datos, para generalizar vamos a decir que existen dos tipos de datos básicos: Números (donde se agrupan enteros de diferentes tamaños, números flotantes y números racionales) y Cadenas donde se almacenan letras, palabras o incluso frases.
Al igual que en python no es necesario especificar el tipo de dato al declarar una variable, esto se conoce como interpretación dinámica.
Entonces para decalarar una variable solo será necesario el nombre de la variable y asignar un valor mediante el “=”
nombre_variable = valor_variable
Ejemplo:
entero = 10
cadena = ‘Hola mundo’
Para mostrar en pantalla el dato contenido en una variable continuaremos usando puts (que usamos en el video de “hola mundo”).
Si queremos mostrar solo una variable:
puts nombre_variable
Si queremos mostrar un mensaje:
puts “Mensaje a mostrar”
Si queremos mostrar mensaje y variable:
puts “Quiero mostrar esta variable: #{nombre_variable}”
Código:
entero = 123
flotante = 345.67
cadena = ‘Hola mundo’
puts entero
puts cadena
puts “el numero guardado es #{entero}”
puts “el numero decimal guardado es #{flotante}”
puts “La frase guardada es #{cadena}”
Variables en C#
En C# se habla de tipos de datos integrados o tipos primitivos que pueden representar números enteros, punto flotante, booleanos, caracteres, valores decimales y otros tipos de datos.
| Nombre | Tipo | Ancho | Intervalo |
|---|---|---|---|
|
byte |
Entero sin signo |
8 |
0 a 255 |
|
sbyte |
Entero con signo |
8 |
-128 a 127 |
|
int |
Entero con signo |
32 |
-2.147.483.648 a 2.147.483.647 |
|
uint |
Entero sin signo |
32 |
0 a 4294967295 |
|
short |
Entero con signo |
16 |
-32.768 a 32.767 |
|
ushort |
Entero sin signo |
16 |
0 a 65535 |
|
long |
Entero con signo |
64 |
-922337203685477508 a 922337203685477507 |
|
float |
Tipo de punto flotante |
32 |
-3,402823e38 a 3,402823e38 |
|
Double |
Tipo de punto flotante |
64 |
1,79769313486232e308 a 1,79769313486232e308 |
|
char |
Un carácter Unicode |
16 |
Símbolos Unicode utilizados en el texto |
|
string |
Una secuencia de caracteres |
Para el ejercicio que estamos realizando solo trabajaremos con 3 de los mas usados.
Igual que en java y c++ para declarar una variable será necesario:
tipo_dato nombre_variable; //es decir sin asignar valor
int numero;
También se puede asignar un valor inmediatamente en el momento de declarar con el signo “=”
tipo_dato nombre_variable = valor_variable;
int entero = 342;
Mostraremos el dato con la función “Console.WriteLine();” de la siguiente forma:
Si queremos mostrar solo una variable:
Console.WriteLine(nombre_variable);
Si queremos mostrar un mensaje:
Console.WriteLine(“Mensaje a mostrar …”);”
Si queremos mostrar mensaje y variable tenemos dos opciones:
Console.WriteLine(“Mensaje a mostrar”+nombre_variable);”
Console.WriteLine($”Mensaje a mostrar {nombre_variable}”);”
using System;
namespace variables_cs
{
class Program
{
static void Main(string[] args)
{
int numero = 246;
float fnum = 167.54f;
string frase = “Hola mundo”;
Console.WriteLine(frase);
Console.WriteLine(“El numero entero es: “+numero);
Console.WriteLine($”El flotante es: {fnum}”);
}
}
}
