Main Content

table

Arreglo de tablas con variables con nombre que pueden contener distintos tipos

expandir todo en la página

Descripción

Los arreglos table almacenan datos tabulares u orientados por columna, como columnas de un archivo de texto u hoja de cálculo. Las tablas almacenan cada fragmento de datos orientado por columnas en una variable. Las variables de tabla pueden tener datos de distintos tipos y tamaños, siempre y cuando todas tengan el mismo número de filas. Las variables de tabla tienen nombres, al igual que los campos de una estructura. Utilice la función summary para obtener información sobre una tabla.

Para indexar en una tabla, utilice una de estas sintaxis. Para obtener más información, consulte Acceder a datos en tablas.

  • La notación de puntos, como en T.varname, extrae una variable.

  • Las llaves, como en T{rows,vars}, extraen un arreglo de las filas y las variables especificadas.

  • Los paréntesis, como en T(rows,vars), devuelven una tabla.

Puede realizar operaciones matemáticas, como +, .* y mean, directamente en las tablas. Para obtener más información, consulte Direct Calculations on Tables and Timetables. (desde R2023a)

Si los datos incluyen marcas de tiempo, considere utilizar un timetable en su lugar.

Creación

Puede leer los datos de un archivo en una tabla usando la función Import Tool o la función readtable. De forma alternativa, utilice la función table que se describe más abajo para crear una tabla a partir de arreglos de datos de entrada.

También puede crear una tabla que deje espacio para variables cuyos valores se rellenan más tarde. Para crear una tabla con un espacio asignado previamente para las variables, utilice la función table con 'Size' como el primer argumento de entrada, como se describe más abajo.

Sintaxis

T = table(var1,...,varN)
T = table('Size',sz,'VariableTypes',varTypes)
T = table(___,Name,Value)
T = table

Descripción

ejemplo

T = table(var1,...,varN) crea una tabla a partir de las variables de entrada var1,...,varN. Las variables pueden contener distintos tipos y tamaños de datos, pero todas las variables deben tener el mismo número de filas.

Si las entradas son variables del área de trabajo, table asigna sus nombres como los nombres de las variables en la tabla de salida. De lo contrario, table asigna nombres de variables con el formato 'Var1',...,'VarN', donde N es el número de variables.

ejemplo

T = table('Size',sz,'VariableTypes',varTypes) crea una tabla y asigna previamente espacio para las variables que tienen los tipos de datos que especifica. sz es un arreglo numérico de dos elementos, donde sz(1) especifica el número de filas y sz(2) especifica el número de variables. varTypes especifica los tipos de datos de las variables.

ejemplo

T = table(___,Name,Value) especifica argumentos de entrada adicionales utilizando uno o más argumentos de par nombre-valor. Por ejemplo, puede especificar nombres de variables usando el par nombre-valor 'VariableNames'. Puede utilizar esta sintaxis con cualquiera de los argumentos de entrada de las sintaxis anteriores.

ejemplo

T = table crea una tabla de 0 por 0 vacía.

Argumentos de entrada

expandir todo

Variables de entrada, especificadas como arreglos con el mismo número de filas. Las variables de entrada pueden tener diferentes tamaños y diferentes tipos de datos.

Las variables de entrada comunes son arreglos, arreglos lógicos, arreglos de caracteres, arreglos de estructura o arreglos de celdas. Las variables de entrada también pueden ser objetos que son arreglos. Un arreglo como este debe ser compatible con la indexación del formato var(index1,...,indexN), donde index1 es un vector numérico o lógico que se corresponde con las filas de la variable var. Además, el arreglo debe implementar tanto un método vertcat como un método size con un argumento dim.

Ejemplo: table([1:4]',ones(4,3,2),eye(4,2)) crea una tabla a partir de variables con cuatro filas pero tamaños diferentes.

Ejemplo: table([1:3]',{'one';'two';'three'},categorical({'A';'B';'C'})) crea una tabla a partir de variables con tres filas pero tipos de datos diferentes.

Tamaño de la tabla asignada previamente, especificado como vector numérico de dos elementos. El primer elemento de sz especifica el número de filas y el segundo elemento especifica el número de variables de tabla.

Para crear solo variables, sin filas, especifique 0 como el primer elemento de sz.

Ejemplo: T = table('Size',[50 3],'VariableTypes',{'string','double','datetime'}) asigna previamente 50 filas para una tabla que contiene un arreglo de cadenas, un arreglo doble y un arreglo de fecha/hora.

Ejemplo: T = table('Size',[0 4],'VariableTypes',varTypes) especifica cero filas y cuatro variables.

Tipos de datos de las variables asignadas previamente, especificados como un arreglo de celdas de vectores de caracteres o un arreglo de cadenas. El número de tipos especificados por varTypes debe ser igual al número de variables especificado por el segundo elemento de sz.

varTypes puede contener los nombres de cualquier tipo de datos, incluidos los nombres mostrados en la tabla.

Nombre del tipo de datos

Valor inicial en cada elemento

'double', 'single'

0 De doble precisión o precisión simple

'doublenan', 'doubleNaN', 'singlenan', 'singleNaN'

NaN De doble precisión o precisión simple

'int8', 'int16', 'int32', 'int64'

0 Valor entero de 8, 16, 32 o 64 bits con signo

'uint8', 'uint16', 'uint32', 'uint64'

0 Valor entero de 8, 16, 32 o 64 bits sin signo

'logical'

0 (false)

'categorical'

Valor categórico <undefined>

'datetime'

Valor NaT datetime

'duration'

0 segundos, como un valor duration

'calendarDuration'

0 días, como un valor calendarDuration

'string'

<missing> (cadena faltante)

'cellstr'

{''} (celda con arreglo de caracteres de 0 por 0)

'cell'

{[]} (celda con arreglo doble de 0 por 0)

'struct'

Estructura escalar sin campos

'table'

Tabla sin variables

'timetable'

Horario sin variables y NaT para los tiempos de la fila

Para cualquier otro tipo de datos, el valor inicial es el valor utilizado por ese tipo o clase para elementos "de relleno" sin asignar de un arreglo.

Si especifica 'char' como tipo de datos, table asigna previamente la variable correspondiente como arreglo de celdas de vectores de caracteres, no como arreglo de caracteres. La práctica recomendada es evitar crear variables de tabla u horario que sean arreglos de caracteres. Cuando trabaje con datos de texto en una tabla u horario, considere utilizar un arreglo de cadenas o un arreglo categórico.

Argumentos de par nombre-valor

Especifique pares opcionales de argumentos como Name1=Value1,...,NameN=ValueN, donde Name es el nombre del argumento y Value es el valor correspondiente. Los argumentos nombre-valor deben aparecer después de otros argumentos, pero el orden de los pares no importa.

En las versiones anteriores a R2021a, utilice comas para separar cada nombre y valor, y encierre Name entre comillas.

Ejemplo: T = table(Age,Height,Weight,'RowNames',LastName) crea una tabla con nombres de fila que están especificados por la variable LastName.

Nombres de variables, especificados como un arreglo de celdas de vectores de caracteres o un arreglo de cadenas cuyos elementos no están vacíos y son distintos.

  • El número de nombres del arreglo debe ser igual al número de variables de tabla.

  • La función table también almacena los nombres de las variables en la propiedad VariableNames de la tabla.

  • Los nombres de las variables pueden tener cualquier carácter Unicode®, incluidos espacios y caracteres no ASCII.

Ejemplo: T = table(lat,lon,'VariableNames',["Latitude","Longitude"]) crea una tabla a partir de arreglos de entrada lat y lon y nombra las variables de tabla correspondientes Latitude y Longitude.

Nombres de fila, especificados como un arreglo de celdas de vectores de caracteres o un arreglo de cadenas cuyos elementos no están vacíos y son distintos.

  • El número de nombres del arreglo debe ser igual al número de filas.

  • La función table también almacena los nombres de fila en la propiedad RowNames de la tabla.

  • Los nombres de fila pueden tener cualquier carácter Unicode, incluidos espacios y caracteres no ASCII.

  • La función table elimina cualquier carácter con espacios en blanco iniciales o finales de los nombres de fila.

Ejemplo: T = table(Age,Height,Weight,'RowNames',LastName) crea una tabla con nombres de fila que están especificados por la variable LastName.

Desde la versión R2021a

Nombres de dimensiones, especificados como un arreglo de celdas de dos elementos de vectores de caracteres o un arreglo de cadenas de dos elementos cuyos elementos no están vacíos y son distintos.

  • La función table también almacena los nombres de las dimensiones en la propiedad DimensionNames de la tabla.

  • Los nombres de las dimensiones pueden tener cualquier carácter Unicode, incluidos espacios y caracteres no ASCII.

Antes de la versión R2021a, solo se podían especificar nombres de dimensiones configurando la propiedad DimensionNames.

Ejemplo: T = table(Age,Height,Weight,'RowNames',LastName,'DimensionNames',["PatientName","PatientData"]) crea una tabla donde el nombre de la primera dimensión es "PatientName" y el nombre de la segunda dimensión es "PatientData".

Propiedades

expandir todo

Acceder a las propiedades de los metadatos de una tabla

Una tabla contiene propiedades de los metadatos que describen la tabla y sus variables. Acceda a estas propiedades utilizando la sintaxis tableName.Properties.PropertyName, donde PropertyName es el nombre de la propiedad. Por ejemplo, puede acceder a los nombres de las variables de la tabla T utilizando la sintaxis T.Properties.VariableNames.

Puede devolver un resumen de las propiedades de todos los metadatos utilizando la sintaxis tableName.Properties.

Las tablas proporcionan acceso a los metadatos a través de la propiedad Properties porque puede acceder a los datos de la tabla usando directamente la sintaxis de puntos. Por ejemplo, si la tabla T tiene una variable denominada Var1, puede acceder a los valores de la variable usando la sintaxis T.Var1.

Metadatos de una tabla

Nombres de dimensiones, especificados como un arreglo de celdas de dos elementos de vectores de caracteres o un arreglo de cadenas de dos elementos.

  • Los nombres de las dimensiones pueden tener cualquier carácter Unicode, incluidos espacios y caracteres no ASCII.

  • Si especifica esta propiedad utilizando un arreglo de cadenas, se convierte y almacena como un arreglo de celdas de vectores de caracteres.

Puede acceder a los datos de la tabla utilizando los nombres de las dos dimensiones.

  • Si la tabla tiene nombres de fila y utiliza la sintaxis de puntos y el nombre de la primera dimensión, puede acceder a los nombres de fila como un vector.

  • Si utiliza la sintaxis de puntos y el nombre de la segunda dimensión, los datos de todas las variables se concatenan juntos en un solo arreglo, como si hubiera indexado la tabla utilizando la sintaxis {:,:}.

Ejemplo

Cree una tabla y muestre los nombres de las dimensiones. Puede acceder a los nombres de fila y a los datos utilizando nombres de dimensiones con sintaxis de puntos.

load patients
T = table(Age,Height,Weight,Systolic,Diastolic, ...
          'RowNames',LastName);
T.Properties.DimensionNames
ans = 1x2 cell
    {'Row'}    {'Variables'}

Acceda a los nombres de fila utilizando el nombre de la primera dimensión. Muestre los cinco primeros nombres.

T.Row(1:5)
ans = 5x1 cell
    {'Smith'   }
    {'Johnson' }
    {'Williams'}
    {'Jones'   }
    {'Brown'   }

Acceda a los datos utilizando el nombre de la segunda dimensión. Esta sintaxis equivale a T{:,:}.

T.Variables
ans = 100×5

    38    71   176   124    93
    43    69   163   109    77
    38    64   131   125    83
    40    67   133   117    75
    49    64   119   122    80
    46    68   142   121    70
    33    64   142   130    88
    40    68   180   115    82
    28    68   183   115    78
    31    66   132   118    86
      ⋮

Modifique los nombres de las dimensiones usando la propiedad Properties.DimensionNames. Tras haber cambiado los nombres de las dimensiones, puede acceder a los nombres de fila y a los datos utilizando la sintaxis T.Patient y T.Data, respectivamente.

T.Properties.DimensionNames = ["Patient","Data"];
T.Properties
ans = 
  TableProperties with properties:

             Description: ''
                UserData: []
          DimensionNames: {'Patient'  'Data'}
           VariableNames: {'Age'  'Height'  'Weight'  'Systolic'  'Diastolic'}
    VariableDescriptions: {}
           VariableUnits: {}
      VariableContinuity: []
                RowNames: {100x1 cell}
        CustomProperties: No custom properties are set.
      Use addprop and rmprop to modify CustomProperties.

Nombres de fila, especificados como un arreglo de celdas de vectores de caracteres o un arreglo de cadenas cuyos elementos no están vacíos y son distintos. Si RowNames no está vacío, el número de nombres de fila debe ser igual al número de filas de la tabla.

  • Los nombres de fila pueden tener cualquier carácter Unicode, incluidos espacios y caracteres no ASCII.

  • Si asigna nombres de fila que tienen espacios en blanco iniciales o finales, MATLAB® los elimina de los nombres de fila.

  • Los nombres de fila son visibles cuando se visualiza la tabla. Además, puede usar los nombres de fila entre paréntesis o llaves para acceder a los datos de la tabla.

  • Otra forma de acceder a los nombres de fila es utilizar la sintaxis de puntos y el nombre de la primera dimensión de la tabla.

  • Si especifica esta propiedad utilizando un arreglo de cadenas, se convierte y almacena como un arreglo de celdas de vectores de caracteres.

Ejemplo

Cree una tabla. Luego, añada nombres de fila y acceda a las filas por el nombre.

load patients
T = table(Age,Height,Weight,Smoker,Systolic,Diastolic,SelfAssessedHealthStatus);
T.SelfAssessedHealthStatus = string(SelfAssessedHealthStatus);

Añada nombres de fila utilizando la propiedad Properties.RowNames. De forma predeterminada, las tablas no tienen nombres de fila, pero puede añadirlos en cualquier momento.

T.Properties.RowNames = string(LastName);
head(T,5)
                Age    Height    Weight    Smoker    Systolic    Diastolic    SelfAssessedHealthStatus
                ___    ______    ______    ______    ________    _________    ________________________

    Smith       38       71       176      true        124          93              "Excellent"       
    Johnson     43       69       163      false       109          77              "Fair"            
    Williams    38       64       131      false       125          83              "Good"            
    Jones       40       67       133      false       117          75              "Fair"            
    Brown       49       64       119      false       122          80              "Good"

Otra forma de acceder a los nombres de filas es utilizar la sintaxis de puntos con el nombre de la primera dimensión de la tabla. Muestre los cinco primeros nombres de fila.

T.Properties.DimensionNames
ans = 1x2 cell
    {'Row'}    {'Variables'}


T.Row(1:5)
ans = 5x1 cell
    {'Smith'   }
    {'Johnson' }
    {'Williams'}
    {'Jones'   }
    {'Brown'   }

Indexe en la tabla por nombres de fila.

T(["Smith","Brown"],:)
ans=2×7 table
             Age    Height    Weight    Smoker    Systolic    Diastolic    SelfAssessedHealthStatus
             ___    ______    ______    ______    ________    _________    ________________________

    Smith    38       71       176      true        124          93              "Excellent"       
    Brown    49       64       119      false       122          80              "Good"

Descripción de la tabla, especificada como vector de caracteres o escalar de cadena. Esta descripción es visible cuando se utiliza la función summary.

Si especifica esta propiedad utilizando un escalar de cadena, se convierte y almacena como un vector de caracteres.

Ejemplo

Cree una tabla. Modifique la descripción de la tabla. Muestre un resumen del resultado.

load patients
T = table(LastName,Age,Height,Weight);
T.LastName = string(T.LastName);
T.Properties.Description = "Simulated patient data";
summary(T)
Description:  Simulated patient data

Variables:

    LastName: 100x1 string

    Age: 100x1 double

        Values:

            Min          25   
            Median       39   
            Max          50   

    Height: 100x1 double

        Values:

            Min          60   
            Median       67   
            Max          72   

    Weight: 100x1 double

        Values:

            Min          111  
            Median     142.5  
            Max          202

Información adicional de la tabla, especificada como un arreglo. Puede adjuntar datos de cualquier clase a una tabla utilizando esta propiedad.

Ejemplo

Cree una tabla. Adjunte una función anónima como un dato de usuario que está asociado a la tabla.

load patients
T = table(LastName,Age,Height,Weight,Smoker,Systolic,Diastolic);
formula = @(x) x.^2;
T.Properties.UserData = formula;
T.Properties
ans = 
  TableProperties with properties:

             Description: ''
                UserData: @(x)x.^2
          DimensionNames: {'Row'  'Variables'}
           VariableNames: {'LastName'  'Age'  'Height'  'Weight'  'Smoker'  'Systolic'  'Diastolic'}
    VariableDescriptions: {}
           VariableUnits: {}
      VariableContinuity: []
                RowNames: {}
        CustomProperties: No custom properties are set.
      Use addprop and rmprop to modify CustomProperties.

Metadatos de variables

Nombres de variables, especificados como un arreglo de celdas de vectores de caracteres o un arreglo de cadenas cuyos elementos no están vacíos y son distintos. El número de nombres debe ser igual al número de variables.

  • Los nombres de las variables pueden tener cualquier carácter Unicode, incluidos espacios y caracteres no ASCII.

  • Los nombres de las variables son visibles cuando se visualiza la tabla y cuando se utiliza la función summary. Además, puede usar los nombres de variables entre paréntesis, entre llaves o con indexación de puntos para acceder a los datos de tabla.

  • Si especifica esta propiedad utilizando un arreglo de cadenas, se convierte y almacena como un arreglo de celdas de vectores de caracteres.

Ejemplo

Cree una tabla con nombres de variables predeterminados. Luego, modifique los nombres con la propiedad Properties.VariableNames.

T = table(["Smith";"Nguyen";"Williams";"Fernandez";"Brown"],[38;43;38;40;49], ...
          [71;69;64;67;64],[176;163;131;133;119])
T=5×4 table
       Var1        Var2    Var3    Var4
    ___________    ____    ____    ____

    "Smith"         38      71     176 
    "Nguyen"        43      69     163 
    "Williams"      38      64     131 
    "Fernandez"     40      67     133 
    "Brown"         49      64     119 


T.Properties.VariableNames = ["LastName","Age","Height","Weight"]
T=5×4 table
     LastName      Age    Height    Weight
    ___________    ___    ______    ______

    "Smith"        38       71       176  
    "Nguyen"       43       69       163  
    "Williams"     38       64       131  
    "Fernandez"    40       67       133  
    "Brown"        49       64       119

Una forma fundamental de mostrar y modificar variables es acceder a ellas por nombre utilizando la sintaxis de puntos.

T.Age
ans = 5×1

    38
    43
    38
    40
    49


T.Age(1) = 53
T=5×4 table
     LastName      Age    Height    Weight
    ___________    ___    ______    ______

    "Smith"        53       71       176  
    "Nguyen"       43       69       163  
    "Williams"     38       64       131  
    "Fernandez"    40       67       133  
    "Brown"        49       64       119

Descripciones de variables, especificadas como arreglo de celdas de vectores de caracteres o arreglo de cadenas. Esta propiedad puede ser un arreglo de celdas vacío, que es el valor predeterminado. Si el arreglo no está vacío, debe contener tantos elementos como variables haya. Puede especificar un vector de caracteres vacío individual o una cadena vacía para una variable que no tenga descripción.

  • Las descripciones de las variables son visibles cuando se utiliza la función summary.

  • Si especifica esta propiedad utilizando un arreglo de cadenas, se convierte y almacena como un arreglo de celdas de vectores de caracteres.

Ejemplo

Cree una tabla. Modifique las descripciones de las variables. Muestre un resumen del resultado.

load patients
T = table(LastName,Age,Height,Weight,Smoker,Systolic,Diastolic);
T.LastName = string(T.LastName);
T.Properties.VariableDescriptions = ["","","","", ...
                                     "Has the patient ever been a smoker", ...
                                     "Systolic Pressure","Diastolic Pressure"];
summary(T)
Variables:

    LastName: 100x1 string

    Age: 100x1 double

        Values:

            Min          25   
            Median       39   
            Max          50   

    Height: 100x1 double

        Values:

            Min          60   
            Median       67   
            Max          72   

    Weight: 100x1 double

        Values:

            Min          111  
            Median     142.5  
            Max          202  

    Smoker: 100x1 logical

        Properties:
            Description:  Has the patient ever been a smoker
        Values:

            True        34   
            False       66   

    Systolic: 100x1 double

        Properties:
            Description:  Systolic Pressure
        Values:

            Min         109   
            Median      122   
            Max         138   

    Diastolic: 100x1 double

        Properties:
            Description:  Diastolic Pressure
        Values:

            Min           68  
            Median      81.5  
            Max           99

Unidades de variables, especificadas como un arreglo de celdas de vectores de caracteres o un arreglo de cadenas. Esta propiedad puede ser un arreglo de celdas vacío, que es el valor predeterminado. Si el arreglo no está vacío, debe contener tantos elementos como variables haya. Puede especificar un vector de caracteres vacío individual o una cadena vacía para una variable que no tenga unidades.

  • Las unidades de las variables son visibles cuando se utiliza la función summary.

  • Si especifica esta propiedad utilizando un arreglo de cadenas, se convierte y almacena como un arreglo de celdas de vectores de caracteres.

Ejemplo

Cree una tabla. Modifique las unidades de las variables. Muestre un resumen del resultado.

load patients
T = table(LastName,Age,Height,Weight,Smoker,Systolic,Diastolic);
T.LastName = string(T.LastName);
T.Properties.VariableUnits = ["","Yrs","In","Lbs","","mm Hg","mm Hg"];
summary(T)
Variables:

    LastName: 100x1 string

    Age: 100x1 double

        Properties:
            Units:  Yrs
        Values:

            Min          25   
            Median       39   
            Max          50   

    Height: 100x1 double

        Properties:
            Units:  In
        Values:

            Min          60   
            Median       67   
            Max          72   

    Weight: 100x1 double

        Properties:
            Units:  Lbs
        Values:

            Min          111  
            Median     142.5  
            Max          202  

    Smoker: 100x1 logical

        Values:

            True        34   
            False       66   

    Systolic: 100x1 double

        Properties:
            Units:  mm Hg
        Values:

            Min         109   
            Median      122   
            Max         138   

    Diastolic: 100x1 double

        Properties:
            Units:  mm Hg
        Values:

            Min           68  
            Median      81.5  
            Max           99

Estado como variables continuas o discretas, especificado como un arreglo de celdas de vectores de caracteres o un arreglo de cadenas.

Aunque tanto las tablas como los horarios tienen esta propiedad, solo la usan los horarios. Para obtener más información, consulte la propiedad VariableContinuity de timetable.

Metadatos personalizados

Metadatos personalizados de una tabla y sus variables, especificados como un objeto CustomProperties.

El objeto CustomProperties es un contenedor para metadatos personalizados que puede añadir a una tabla. De forma predeterminada, CustomProperties tiene cero propiedades. Cada propiedad que añade a CustomProperties puede contener metadatos de la tabla o metadatos de las variables. Si una propiedad contiene metadatos de variables, su valor debe ser un arreglo y el número de elementos del arreglo deba ser igual al número de variables de la tabla.

  • Para añadir propiedades a los metadatos personalizados de una tabla, utilice la función addprop.

  • Para acceder o modificar los metadatos personalizados, utilice la sintaxis tableName.Properties.CustomProperties.PropertyName. En esta sintaxis, PropertyName es el nombre que eligió cuando añadió esa propiedad usando addprop.

  • Para eliminar propiedades, utilice la función rmprop.

Nota: Puede añadir o eliminar solo propiedades de los metadatos personalizados utilizando addprop y rmprop. No puede añadir o eliminar propiedades del objeto tableName.Properties.

Ejemplo

Cree una tabla.

load patients
T = table(LastName,Age,Height,Weight,Smoker,Systolic,Diastolic);

Añada propiedades que puedan contener metadatos personalizados sobre la tabla y sus variables. En este ejemplo, los metadatos son nombres de instrumentos y los valores true y false indican si las variables deben representarse, y el nombre de un archivo de salida. Para añadir propiedades, utilice la función addprop.

T = addprop(T,["Instrument","ToPlot","OutputFile"],["variable","variable","table"]);
T.Properties
ans = 
  TableProperties with properties:

             Description: ''
                UserData: []
          DimensionNames: {'Row'  'Variables'}
           VariableNames: {'LastName'  'Age'  'Height'  'Weight'  'Smoker'  'Systolic'  'Diastolic'}
    VariableDescriptions: {}
           VariableUnits: {}
      VariableContinuity: []
                RowNames: {}

   Custom Properties (access using t.Properties.CustomProperties.<name>):
              OutputFile: []
              Instrument: []
                  ToPlot: []

Asigne valores a los metadatos personalizados usando sintaxis de puntos. Cuando asigna un arreglo de valores de texto a metadatos personalizados, la práctica recomendada es utilizar un arreglo de cadenas, no un arreglo de celdas de vectores de caracteres. Si una propiedad de CustomProperties es un arreglo de celdas de vectores de caracteres, no hay ningún mecanismo para evitar que tenga que asignar posteriormente valores no de texto como elementos del arreglo de celdas.

T.Properties.CustomProperties.Instrument = ["","","height rod","scale","","blood pressure cuff","blood pressure cuff"];
T.Properties.CustomProperties.ToPlot = [false false true true false true true];
T.Properties.CustomProperties.OutputFile = 'patientData.csv';
T.Properties
ans = 
  TableProperties with properties:

             Description: ''
                UserData: []
          DimensionNames: {'Row'  'Variables'}
           VariableNames: {'LastName'  'Age'  'Height'  'Weight'  'Smoker'  'Systolic'  'Diastolic'}
    VariableDescriptions: {}
           VariableUnits: {}
      VariableContinuity: []
                RowNames: {}

   Custom Properties (access using t.Properties.CustomProperties.<name>):
              OutputFile: 'patientData.csv'
              Instrument: [""    ""    "height rod"    "scale"    ""    "blood pressure cuff"    "blood pressure cuff"]
                  ToPlot: [0 0 1 1 0 1 1]

Elimine la propiedad OutputFile de T.

T = rmprop(T,"OutputFile");
T.Properties
ans = 
  TableProperties with properties:

             Description: ''
                UserData: []
          DimensionNames: {'Row'  'Variables'}
           VariableNames: {'LastName'  'Age'  'Height'  'Weight'  'Smoker'  'Systolic'  'Diastolic'}
    VariableDescriptions: {}
           VariableUnits: {}
      VariableContinuity: []
                RowNames: {}

   Custom Properties (access using t.Properties.CustomProperties.<name>):
              Instrument: [""    ""    "height rod"    "scale"    ""    "blood pressure cuff"    "blood pressure cuff"]
                  ToPlot: [0 0 1 1 0 1 1]

Ejemplos

contraer todo

Abrir script en vivo

Almacene datos sobre un grupo de pacientes en una tabla. Puede realizar cálculos y almacenar los resultados en la misma tabla. Además, puede hacer anotaciones en la tabla para describir el trabajo y las variables de la tabla.

En primer lugar, cree variables del área de trabajo que tengan los datos de los pacientes. Las variables pueden contener cualquier tipo de datos, pero deben tener el mismo número de filas.

LastName = {'Sanchez';'Johnson';'Li';'Diaz';'Brown'};
Age = [38;43;38;40;49];
Smoker = logical([1;0;1;0;1]);
Height = [71;69;64;67;64];
Weight = [176;163;131;133;119];
BloodPressure = [124 93; 109 77; 125 83; 117 75; 122 80];

Cree una tabla, T, como un contenedor de las variables del área de trabajo. La función table usa los nombres de las variables del área de trabajo como los nombres de las variables de tabla de T. Una variable de tabla puede tener varias columnas. Por ejemplo, la variable BloodPressure de T es un arreglo de 5 por 2.

T = table(LastName,Age,Smoker,Height,Weight,BloodPressure)
T=5×6 table
     LastName      Age    Smoker    Height    Weight    BloodPressure
    ___________    ___    ______    ______    ______    _____________

    {'Sanchez'}    38     true        71       176       124     93  
    {'Johnson'}    43     false       69       163       109     77  
    {'Li'     }    38     true        64       131       125     83  
    {'Diaz'   }    40     false       67       133       117     75  
    {'Brown'  }    49     true        64       119       122     80

Puede utilizar la indexación de puntos para acceder a las variables de tabla. Por ejemplo, calcule la altura media de los pacientes usando los valores de T.Height.

meanHeight = mean(T.Height)
meanHeight = 67

Calcule el índice de masa corporal (BMI) y añádalo como una variable de tabla nueva. También puede añadir y nombrar variables de tabla en un paso usando la sintaxis de puntos.

T.BMI = (T.Weight*0.453592)./(T.Height*0.0254).^2
T=5×7 table
     LastName      Age    Smoker    Height    Weight    BloodPressure     BMI  
    ___________    ___    ______    ______    ______    _____________    ______

    {'Sanchez'}    38     true        71       176       124     93      24.547
    {'Johnson'}    43     false       69       163       109     77      24.071
    {'Li'     }    38     true        64       131       125     83      22.486
    {'Diaz'   }    40     false       67       133       117     75      20.831
    {'Brown'  }    49     true        64       119       122     80      20.426

Haga una anotación en la tabla con la descripción del cálculo del índice de masa corporal. Puede hacer anotaciones en T y sus variables utilizando metadatos a los que se accede a través de T.Properties.

T.Properties.Description = 'Patient data, including body mass index (BMI) calculated using Height and Weight';
T.Properties
ans = 
  TableProperties with properties:

             Description: 'Patient data, including body mass index (BMI) calculated using Height and Weight'
                UserData: []
          DimensionNames: {'Row'  'Variables'}
           VariableNames: {'LastName'  'Age'  'Smoker'  'Height'  'Weight'  'BloodPressure'  'BMI'}
    VariableDescriptions: {}
           VariableUnits: {}
      VariableContinuity: []
                RowNames: {}
        CustomProperties: No custom properties are set.
      Use addprop and rmprop to modify CustomProperties.
Abrir script en vivo

Acceda a todos los datos de una tabla como una matriz, usando el nombre de la segunda dimensión de la tabla.

Cree una tabla que contenga cinco filas de datos sobre un conjunto de pacientes.

Age = [38;43;38;40;49];
Smoker = logical([1;0;1;0;1]);
Height = [71;69;64;67;64];
Weight = [176;163;131;133;119];
BloodPressure = [124 93; 109 77; 125 83; 117 75; 122 80];

T = table(Age,Smoker,Height,Weight,BloodPressure)
T=5×5 table
    Age    Smoker    Height    Weight    BloodPressure
    ___    ______    ______    ______    _____________

    38     true        71       176       124     93  
    43     false       69       163       109     77  
    38     true        64       131       125     83  
    40     false       67       133       117     75  
    49     true        64       119       122     80

Muestre los nombres de las dimensiones de la tabla con la propiedad DimensionNames. El nombre predeterminado de la segunda dimensión es Variables.

T.Properties.DimensionNames
ans = 1x2 cell
    {'Row'}    {'Variables'}

Acceda a los datos de la tabla como una matriz utilizando la sintaxis T.Variables. Esta sintaxis equivale a acceder a todo el contenido utilizando la sintaxis de llaves T{:,:}. Si los datos de la tabla no se pueden concatenar en una matriz, se emite un mensaje de error.

T.Variables
ans = 5×6

    38     1    71   176   124    93
    43     0    69   163   109    77
    38     1    64   131   125    83
    40     0    67   133   117    75
    49     1    64   119   122    80

Modifique el nombre de la segunda dimensión. Si cambia el nombre, puede usar el nombre nuevo para acceder a los datos.

T.Properties.DimensionNames{2} = 'PatientData';
T.PatientData
ans = 5×6

    38     1    71   176   124    93
    43     0    69   163   109    77
    38     1    64   131   125    83
    40     0    67   133   117    75
    49     1    64   119   122    80
Abrir script en vivo

Asigne previamente una tabla especificando su tamaño y los tipos de datos de las variables. La función table rellena las variables con valores predeterminados apropiados para los tipos de datos que especifica. Además, proporciona nombres predeterminados a las variables, pero también puede asignar sus propios nombres de variables. La asignación previa proporciona espacio para los datos que se añadirán a la tabla más tarde.

sz = [4 3];
varTypes = {'double','datetime','string'};
T = table('Size',sz,'VariableTypes',varTypes)
T=4×3 table
    Var1    Var2      Var3   
    ____    ____    _________

     0      NaT     <missing>
     0      NaT     <missing>
     0      NaT     <missing>
     0      NaT     <missing>

Para especificar los nombres de las variables, utilice el argumento de par nombre-valor 'VariableNames'.

varNames = {'Temperature','Time','Station'};
T2 = table('Size',sz,'VariableTypes',varTypes,'VariableNames',varNames)
T2=4×3 table
    Temperature    Time     Station 
    ___________    ____    _________

         0         NaT     <missing>
         0         NaT     <missing>
         0         NaT     <missing>
         0         NaT     <missing>

Añada filas de datos a las dos primeras filas de T2. La asignación previa puede ser una técnica útil cuando el código añade una fila de datos o unas cuantas filas de datos al mismo tiempo. En lugar de aumentar la tabla cada vez que añade una fila, puede rellenar variables de tabla que ya tengan espacio para los datos.

T2(1,:) = {75,datetime('now'),"S1"};
T2(2,:) = {68,datetime('now')+1,"S2"}
T2=4×3 table
    Temperature            Time             Station 
    ___________    ____________________    _________

        75         07-Mar-2024 15:45:00    "S1"     
        68         08-Mar-2024 15:45:00    "S2"     
         0                          NaT    <missing>
         0                          NaT    <missing>

Puede encapsular una fila de valores de datos en un arreglo de celdas. Cuando asigna una fila de un arreglo de celdas, los elementos del arreglo de celdas se asignan a la fila de la tabla.

Abrir script en vivo

Cree una tabla a partir de arreglos. Para especificar los nombres de las variables de la tabla, utilice el argumento de par nombre-valor 'VariableNames'. Por ejemplo, puede utilizar 'VariableNames' para especificar nombres cuando los otros argumentos de entrada no son variables del área de trabajo.

T = table(categorical({'M';'F';'M'}),[45;32;34],...
          {'NY';'CA';'MA'},logical([1;0;0]),...
          'VariableNames',{'Gender','Age','State','Vote'})
T=3×4 table
    Gender    Age    State     Vote 
    ______    ___    ______    _____

      M       45     {'NY'}    true 
      F       32     {'CA'}    false
      M       34     {'MA'}    false

Cree una tabla con los nombres de estado como nombres de fila. Puede especificar tanto el par nombre-valor 'VariableNames' como cuando 'RowNames' use la función table.

T = table(categorical({'M';'F';'M'}),[45;32;34],logical([1;0;0]),...
          'VariableNames',{'Gender','Age','Vote'},...
          'RowNames',{'NY';'CA';'MA'})
T=3×3 table
          Gender    Age    Vote 
          ______    ___    _____

    NY      M       45     true 
    CA      F       32     false
    MA      M       34     false
Abrir script en vivo

Especifique nombres de fila para una tabla. Las tablas no tienen que tener nombres de fila, pero, si los especifica, puede indexar en una tabla por nombre de fila. También puede acceder al conjunto de nombres de fila usando el nombre de la primera dimensión de una tabla.

Cree arreglos que contengan datos de pacientes.

LastName = {'Sanchez';'Johnson';'Lee';'Diaz';'Brown'};
Age = [38;43;38;40;49];
Height = [71;69;64;67;64];
Weight = [176;163;131;133;119];

Cree una tabla que contenga los arreglos. Especifique LastName como la fuente de los nombres de fila de la tabla. La tabla tiene solo tres variables. Los nombres de fila no son una variable de tabla, sino una propiedad de la tabla.

T = table(Age,Weight,Height,'RowNames',LastName)
T=5×3 table
               Age    Weight    Height
               ___    ______    ______

    Sanchez    38      176        71  
    Johnson    43      163        69  
    Lee        38      131        64  
    Diaz       40      133        67  
    Brown      49      119        64

Dado que las filas tienen nombres de fila, puede indexar en las filas de T por nombre.

T('Lee',:)
ans=1×3 table
           Age    Weight    Height
           ___    ______    ______

    Lee    38      131        64

Para especificar varias filas, utilice un arreglo de celdas.

T({'Lee','Brown'},:)
ans=2×3 table
             Age    Weight    Height
             ___    ______    ______

    Lee      38      131        64  
    Brown    49      119        64

Para acceder a todos los nombres de fila de T como un arreglo de celdas, utilice la sintaxis T.Row. De forma predeterminada, Row es el nombre de la primera dimensión de una tabla.

T.Row
ans = 5x1 cell
    {'Sanchez'}
    {'Johnson'}
    {'Lee'    }
    {'Diaz'   }
    {'Brown'  }

Cambie el nombre de la primera dimensión. Si cambia el nombre, puede acceder a los nombres de fila utilizando el nombre nuevo.

T.Properties.DimensionNames{1} = 'LastNames';
T.LastNames
ans = 5x1 cell
    {'Sanchez'}
    {'Johnson'}
    {'Lee'    }
    {'Diaz'   }
    {'Brown'  }
Abrir script en vivo

A partir de la versión R2017a, puede crear cadenas con comillas dobles y añadir arreglos de cadenas como variables de tabla.

FlightNum = [1261;547;3489];
Customer = ["Jones";"Brown";"Smith"];
Date = datetime(2016,12,20:22)';
Rating = categorical(["Good";"Poor";"Fair"]);
Comment = ["Flight left on time, not crowded";...
           "Late departure, ran out of dinner options";...
           "Late, but only by half an hour. Otherwise fine."];
T = table(FlightNum,Customer,Date,Rating,Comment)
T=3×5 table
    FlightNum    Customer       Date        Rating                         Comment                     
    _________    ________    ___________    ______    _________________________________________________

      1261       "Jones"     20-Dec-2016     Good     "Flight left on time, not crowded"               
       547       "Brown"     21-Dec-2016     Poor     "Late departure, ran out of dinner options"      
      3489       "Smith"     22-Dec-2016     Fair     "Late, but only by half an hour. Otherwise fine."

Para usar el texto en un arreglo de cadenas como nombres de fila, convierta un arreglo de cadenas a un arreglo de celdas de vectores de caracteres. Después, cree una tabla con nombres de fila.

Customer = cellstr(Customer);
T = table(FlightNum,Date,Rating,Comment,'RowNames',Customer)
T=3×4 table
             FlightNum       Date        Rating                         Comment                     
             _________    ___________    ______    _________________________________________________

    Jones      1261       20-Dec-2016     Good     "Flight left on time, not crowded"               
    Brown       547       21-Dec-2016     Poor     "Late departure, ran out of dinner options"      
    Smith      3489       22-Dec-2016     Fair     "Late, but only by half an hour. Otherwise fine."
Abrir script en vivo

Cree variables del área de trabajo que contengan el total de nieve caída en fechas distintas en tres localizaciones. Estas variables son vectores fila.

Date = {'12/25/11','1/2/12','1/23/12','2/7/12','2/15/12'};
location1 = [20 5 13 0 17];
location2 = [18 9 21 5 12];
location3 = [26 10 16 3 15];

Una forma de crear una tabla a partir de estas variables es llamar a la función table con la sintaxis T = table(Date',location1',location2',location3'). Como las variables del área de trabajo son vectores fila, debe trasponerlos para colocarlos en la tabla como datos orientados a columnas. Por lo tanto, los argumentos de entrada son expresiones, no variables sencillas. Como resultado, table crea T con los nombres de variable predeterminados Var1, Var2, Var3 y Var4. Puede asignar nombres más significativos a T.Properties.VariableNames después de crear T. Sin embargo, puede ser más conveniente crear una tabla vacía y, después, añadir variables de una en una con nombres nuevos.

Cree una tabla vacía. Trasponga las variables del área de trabajo y añádalas a la tabla como vectores columna. Como parte de la asignación de cada variable del área de trabajo en T, proporcione un nombre significativo para la variable de tabla.

T = table;
T.Date = Date';
T.Natick = location1';
T.Boston = location2';
T.Worcester = location3'
T=5×4 table
        Date        Natick    Boston    Worcester
    ____________    ______    ______    _________

    {'12/25/11'}      20        18         26    
    {'1/2/12'  }       5         9         10    
    {'1/23/12' }      13        21         16    
    {'2/7/12'  }       0         5          3    
    {'2/15/12' }      17        12         15
Abrir script en vivo

A partir de la versión R2019b, puede especificar nombres de variables de tabla que no sean identificadores de MATLAB® válidos. Esos nombres de variables pueden incluir espacios y caracteres no ASCII, y pueden empezar por cualquier carácter. Cuando acceda a un nombre de variable como este, enciérrelo entre comillas.

Cree una tabla que almacene datos sobre un conjunto de pacientes. Comience con las edades y el estado como fumadores.

Age = [38;43;38;40;49];
Smoker = logical([1;0;1;0;1]);
Height = [71;69;64;67;64];
Weight = [176;163;131;133;119];
BloodPressure = [124 93; 109 77; 125 83; 117 75; 122 80];
T = table(Age,Smoker)
T=5×2 table
    Age    Smoker
    ___    ______

    38     true  
    43     false 
    38     true  
    40     false 
    49     true

Añada las lecturas de la presión arterial con el nombre de variable '29-May-2019 Blood Pressure Reading'. Puede utilizar la sintaxis de puntos para añadir o acceder a la variable. Dado que el nombre no es un identificador de MATLAB válido, utilice paréntesis y comillas con la sintaxis de puntos.

T.('29-May-2019 Blood Pressure Reading') = BloodPressure
T=5×3 table
    Age    Smoker    29-May-2019 Blood Pressure Reading
    ___    ______    __________________________________

    38     true                  124     93            
    43     false                 109     77            
    38     true                  125     83            
    40     false                 117     75            
    49     true                  122     80

Cuando los nombres de variables son identificadores de MATLAB válidos, puede usar la sintaxis de puntos sin paréntesis ni comillas.

T.Height = Height;
T.Weight = Weight
T=5×5 table
    Age    Smoker    29-May-2019 Blood Pressure Reading    Height    Weight
    ___    ______    __________________________________    ______    ______

    38     true                  124     93                  71       176  
    43     false                 109     77                  69       163  
    38     true                  125     83                  64       131  
    40     false                 117     75                  67       133  
    49     true                  122     80                  64       119

Indexe en T utilizando nombres de variables.

T(:,{'Age','Smoker','29-May-2019 Blood Pressure Reading'})
ans=5×3 table
    Age    Smoker    29-May-2019 Blood Pressure Reading
    ___    ______    __________________________________

    38     true                  124     93            
    43     false                 109     77            
    38     true                  125     83            
    40     false                 117     75            
    49     true                  122     80

Limitaciones

  • Use comillas simples para estos nombres de entrada:

    • 'DimensionNames'(desde la versión R2021a)

    • 'RowNames'

    • 'Size'

    • 'VariableTypes'

    • 'VariableNames'

    Para evitar la confusión con las entradas de las variables, no utilice escalares de cadena con comillas dobles (como "RowNames") para estos nombres.

Sugerencias

  • Para ver una lista de las funciones que aceptan o devuelven tablas, consulte Tablas.

Capacidades ampliadas

Entorno basado en subprocesos
Ejecute código en segundo plano con MATLAB® backgroundPool o acelere código con Parallel Computing Toolbox™ ThreadPool.

Historial de versiones

Introducido en R2013b

expandir todo

Consulte también

| | | | | | |

Temas