table

Array de tabla con variables con nombre que pueden contener diferentes tipos

Descripción

table las matrices almacenan datos orientados a columnas o tabulares, como columnas de un archivo de texto o una hoja de cálculo. Las tablas almacenan cada pieza de datos orientados a columnas en una variable . Las variables de tabla pueden tener diferentes tipos de datos y tamaños siempre que todas las variables tengan el mismo número de filas. Utilice la función summary para obtener información sobre una tabla.

Para indexar en una tabla, utilice paréntesis lisos () para devolver una subtabla o llaves rizadas {} para extraer el contenido. Puede hacer referencia a variables y filas usando nombres. Para obtener más información sobre la indización mediante números y nombres, vea Access Data in Tables.

Creación

Puede leer datos de un archivo en una tabla utilizando la función Import Tool o readtable . Como alternativa, utilice la función table descrita a continuación para crear una tabla a partir de las variables de espacio de trabajo existentes.

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

Sintaxis

T = table(var1,...,varN)

T = table('Size',sz,'VariableTypes',varTypes)

T = table(___,'VariableNames',varNames)

T = table(___,'RowNames',rowNames)

T = table

Descripción

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

T = table('Size',sz,'VariableTypes',varTypes) crea una tabla y preasigna espacio para las variables que tienen tipos de datos que especifique. sz es una matriz numérica de dos elementos, donde sz[1] especifica el número de filas y sz[2] especifica el número de variables. varTypes es una matriz de vectores de caracteres que especifica tipos de datos.

T = table(___,'VariableNames',varNames) especifica los nombres de las variables en la tabla de resultados. Puede utilizar esta sintaxis con los argumentos de entrada de cualquiera de las otras sintaxis para esta función.

T = table(___,'RowNames',rowNames) especifica los nombres de las filas de la tabla de resultados. Puede utilizar esta sintaxis con los argumentos de entrada de cualquiera de las sintaxis anteriores.

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

Argumentos de entrada

var1,...,varN — Variables de entrada

(arrays):

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

Las variables de entrada comunes son matrices numéricas, matrices lógicas, matrices de caracteres, matrices de estructura o matrices de celdas. Las variables de entrada también pueden ser objetos que son matrices. Dicha matriz debe admitir la indización del formulario var(index1,...,indexN), donde index1 es un vector numérico o lógico que corresponde a filas de la variable var. Además, la matriz 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 de diferentes tamaños.

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

sz — Tamaño de la tabla preasignada

Vector numérico de dos elementos

Tamaño de la tabla preasignada, especificada como un 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 variables sólo, sin ninguna fila, especifique 0 como el primer elemento de sz.

Ejemplo: T = table('Size',[50 3],'VariableTypes',{'string','double','datetime'}) preasigna 50 filas para una tabla que contiene una matriz de cadenas, una matriz doble y una matriz DateTime.

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

varTypes — Tipos de datos de variables

matriz de celdas de vectores de caracteres

Tipos de datos de las variables en una tabla preasignada, especificada como una matriz de vectores de caracteres. El número de tipos especificados por varTypes debe ser igual al número de variables especificados por el segundo elemento de sz.

Si especifica 'char' como tipo de datos, table preasigna la variable correspondiente como una matriz de vectores de carácter, no como una matriz de caracteres. La mejor práctica es evitar la creación de variables de tabla que sean matrices de caracteres. Cuando trabaje con datos de texto en una tabla o un calendario, considere la posibilidad de utilizar una matriz de cadenas o una matriz categórica.

varTypes puede contener los nombres de cualquier tipo de datos, incluidos los nombres que se muestran en la tabla.

'single'	Número de la solo-precisión
'double'	Número de la doble-precisión
'int8'	Entero de 8 bits firmado
'int16'	Entero de 16 bits firmado
'int32'	Entero 32-bit firmado
'int64'	Entero 64-bit firmado
'uint8'	Entero de 8 bits no firmada
'uint16'	Entero de 16 bits no firmada
'uint32'	Entero de 32 bits no firmados
'uint64'	Entero de 64 bits no firmados
'logical'	Logical 1 (true) o 0 (false)
'char'	Carácter
'string'	Array de cadenas
'struct'	Array estructura
'cell'	Array de celdas
'table'	Tabla
'function_handle'	Manija de la función

varNames — Nombres de variables

matriz de celdas de vectores de caracteres

Nombres de las variables en la tabla de resultados, especificadas como una matriz de vectores de caracteres. El número de nombres de varNames debe ser igual al número de variables.

rowNames — Nombres de filas

matriz de celdas de vectores de caracteres

Nombres de las filas de la tabla de resultados, especificadas como una matriz de vectores de caracteres. El número de nombres de rowNames debe ser igual al número de filas.

Ejemplo: T = table([10;20;30],{'M';'F';'F'},'VariableNames',{'Age','Gender'},'RowNames',{'P1','P2','P3'}) crea una tabla con nombres de variables y nombres de fila.

Propiedades

Propiedades de metadatos de tabla de acceso

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

Puede devolver un resumen de todas las propiedades de metadatos mediante la sintaxis tableName.Properties.

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

Metadatos de tabla

DimensionNames — Nombres de cotas

{'Row','Variables'} (predeterminado) | matriz de celdas de dos elementos de vectores de caracteres

Nombres de cotas, especificados como una matriz de celdas de dos elementos de vectores de caracteres.

Puede acceder a los datos de la tabla mediante los dos nombres de cota. Si la tabla tiene nombres de fila y utiliza la sintaxis de puntos y el nombre de la primera dimensión, puede tener acceso a los nombres de fila como vector. Si utiliza la sintaxis de puntos y el nombre de la segunda dimensión, los datos de todas las variables se concatenan en una matriz, como si se hubiera indexado en el calendario mediante la sintaxis de {:,:} .

Ejemplo

Cree una tabla y muestre sus nombres de cota. Puede tener acceso a nombres de fila y datos mediante nombres de cota con sintaxis de puntos.

load patients
T = table(Age,Height,Weight,Systolic,Diastolic, ...
          'RowNames',LastName);
T.Properties.DimensionNames

ans = 1×2 cell array
    {'Row'}    {'Variables'}

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

T.Row(1:5)

ans = 5×1 cell array
    {'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 sus cotas mediante la propiedad Properties.DimensionNames . Después de haber cambiado los nombres de cota, puede tener acceso a los tiempos de la fila y a los datos mediante las sintaxis T.Patient y T.Data respectivamente.

T.Properties.DimensionNames = {'Patient','Data'};
T.Properties

ans = struct with fields:
             Description: ''
                UserData: []
          DimensionNames: {'Patient'  'Data'}
           VariableNames: {'Age'  'Height'  'Weight'  'Systolic'  'Diastolic'}
    VariableDescriptions: {}
           VariableUnits: {}
      VariableContinuity: []
                RowNames: {100×1 cell}

RowNames — Nombres de fila

{} (predeterminado) | matriz de celdas de vectores de caracteres

Nombres de fila, especificados como una matriz de celdas de vectores de caracteres que no están vacíos y son distintos. Si RowNames no está vacío, el número de vectores de carácter debe ser igual al número de filas de la tabla. MATLAB ^® elimina cualquier espacio en blanco interlineado o final de los vectores de caracteres.

Los nombres de fila son visibles cuando se ve la tabla. Además, puede utilizar los nombres de fila entre paréntesis o llaves rizadas 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.

Ejemplo

Crear una tabla. A continuación, agregue nombres de fila y filas de acceso por sus nombres.

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

Agregue nombres de fila mediante la propiedad Properties.RowNames . De forma predeterminada, las tablas no tienen nombres de fila, pero se pueden agregar en cualquier momento.

T.Properties.RowNames = LastName;
head(T,4)

ans=4×7 table
                 Gender     Age    Height    Weight    Smoker    Systolic    Diastolic
                ________    ___    ______    ______    ______    ________    _________

    Smith       'Male'      38       71       176      true        124          93    
    Johnson     'Male'      43       69       163      false       109          77    
    Williams    'Female'    38       64       131      false       125          83    
    Jones       'Female'    40       67       133      false       117          75    

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

T.Properties.DimensionNames

ans = 1×2 cell array
    {'Row'}    {'Variables'}

T.Row(1:5)

ans = 5×1 cell array
    {'Smith'   }
    {'Johnson' }
    {'Williams'}
    {'Jones'   }
    {'Brown'   }

Índice en la tabla por nombres de fila.

T({'Smith','Williams'},:)

ans=2×7 table
                 Gender     Age    Height    Weight    Smoker    Systolic    Diastolic
                ________    ___    ______    ______    ______    ________    _________

    Smith       'Male'      38       71       176      true        124          93    
    Williams    'Female'    38       64       131      false       125          83    

Description — Descripción de la tabla

'' (predeterminado) | Vector de caracteres

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

Ejemplo

Crear una tabla. Modifique la descripción de la tabla. Mostrar un resumen del resultado.

load patients
T = table(Gender,Age,Height,Weight);
T.Properties.Description = 'Simulated patient data';
summary(T)

Description:  Simulated patient data

Variables:

    Gender: 100×1 cell array of character vectors

    Age: 100×1 double

        Values:

            Min        25  
            Median     39  
            Max        50  

    Height: 100×1 double

        Values:

            Min          60   
            Median       67   
            Max          72   

    Weight: 100×1 double

        Values:

            Min          111  
            Median     142.5  
            Max          202  

UserData — Información adicional de la tabla

[] (predeterminado) | Matriz

Información de tabla adicional, especificada como una matriz. Puede adjuntar datos de cualquier tipo a una tabla utilizando esta propiedad.

Ejemplo

Crear una tabla. Adjunte una función anónima como una pieza de datos de usuario asociada a la tabla.

load patients
T = table(Gender,Age,Height,Weight,Smoker,Systolic,Diastolic);
formula = @(x) x.^2;
T.Properties.UserData = formula;
T.Properties

ans = struct with fields:
             Description: ''
                UserData: @(x)x.^2
          DimensionNames: {'Row'  'Variables'}
           VariableNames: {'Gender'  'Age'  'Height'  'Weight'  'Smoker'  'Systolic'  'Diastolic'}
    VariableDescriptions: {}
           VariableUnits: {}
      VariableContinuity: []
                RowNames: {}

Metadatos variables

VariableNames — Nombres de variables

matriz de celdas de vectores de caracteres

Nombres de variables, especificados como una matriz de celdas de vectores de caracteres que no están vacíos y son distintos. Los nombres de variables deben ser identificadores MATLAB válidos. Puede determinar nombres de variables válidos mediante la función isvarname. MATLAB elimina cualquier espacio en blanco principal o final de los vectores de caracteres. El número de vectores de caracteres debe ser igual al número de variables.

Si no especifica nombres de variables, o especifica identificadores no válidos, MATLAB utiliza una matriz de celdas de vectores de caracteres N de la forma {'Var1' ... 'VarN'} donde N es el número de variables.

Los nombres de las variables son visibles al ver la tabla y al utilizar la función summary . Además, puede utilizar los nombres de variables entre paréntesis, dentro de llaves rizadas, o con indexación de puntos para acceder a los datos de la tabla.

Ejemplo

Cree una tabla con nombres de variables predeterminados. A continuación, modifique los nombres mediante la propiedad Properties.VariableNames .

T = table({'M';'M';'F';'F';'F'},[38;43;38;40;49], ...
          [71;69;64;67;64],[176;163;131;133;119])

T=5×4 table
    Var1    Var2    Var3    Var4
    ____    ____    ____    ____

    'M'      38      71     176 
    'M'      43      69     163 
    'F'      38      64     131 
    'F'      40      67     133 
    'F'      49      64     119 

T.Properties.VariableNames = {'Gender','Age','Height','Weight'}

T=5×4 table
    Gender    Age    Height    Weight
    ______    ___    ______    ______

     'M'      38       71       176  
     'M'      43       69       163  
     'F'      38       64       131  
     'F'      40       67       133  
     'F'      49       64       119  

Una manera fundamental de mostrar y modificar variables es accediendo a ellos por su nombre usando la sintaxis de puntos.

T.Age

ans = 5×1

    38
    43
    38
    40
    49

T.Age(1) = 53

T=5×4 table
    Gender    Age    Height    Weight
    ______    ___    ______    ______

     'M'      53       71       176  
     'M'      43       69       163  
     'F'      38       64       131  
     'F'      40       67       133  
     'F'      49       64       119  

VariableDescriptions — Descripciones variables

{} (predeterminado) | matriz de celdas de vectores de caracteres

Descripciones variables, especificadas como una matriz de vectores de caracteres. Esta propiedad puede ser una matriz de celdas vacía, que es la predeterminada. Si la matriz de celdas no está vacía, debe contener tantos vectores de caracteres como variables. Puede especificar un vector de caracteres vacío individual dentro de la matriz de celdas para una variable que no tenga una descripción.

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

Ejemplo

Crear una tabla. Modifique las descripciones de variables. Mostrar un resumen del resultado.

load patients
T = table(Gender,Age,Height,Weight,Smoker,Systolic,Diastolic);
T.Properties.VariableDescriptions = {'','','','', ...
                                     'Has the patient ever been a smoker', ...
                                     'Systolic Pressure','Diastolic Pressure'};
summary(T)

Variables:

    Gender: 100×1 cell array of character vectors

    Age: 100×1 double

        Values:

            Min        25  
            Median     39  
            Max        50  

    Height: 100×1 double

        Values:

            Min          60   
            Median       67   
            Max          72   

    Weight: 100×1 double

        Values:

            Min          111  
            Median     142.5  
            Max          202  

    Smoker: 100×1 logical

        Description:  Has the patient ever been a smoker
        Values:

            True        34   
            False       66   

    Systolic: 100×1 double

        Description:  Systolic Pressure
        Values:

            Min          109    
            Median       122    
            Max          138    

    Diastolic: 100×1 double

        Description:  Diastolic Pressure
        Values:

            Min            68    
            Median       81.5    
            Max            99    

VariableUnits — Unidades variables

{} (predeterminado) | matriz de celdas de vectores de caracteres

Unidades variables, especificadas como una matriz de vectores de caracteres. Esta propiedad puede ser una matriz de celdas vacía, que es la predeterminada. Si la matriz de celdas no está vacía, debe contener tantos vectores de caracteres como variables. Puede especificar un vector de caracteres vacío individual dentro de la matriz de celdas para una variable que no tenga unidades.

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

Ejemplo

Crear una tabla. Modifique las unidades variables. Mostrar un resumen del resultado.

load patients
T = table(Gender,Age,Height,Weight,Smoker,Systolic,Diastolic);
T.Properties.VariableUnits = {'','Yrs','In','Lbs','','mm Hg','mm Hg'};
summary(T)

Variables:

    Gender: 100×1 cell array of character vectors

    Age: 100×1 double

        Units:  Yrs
        Values:

            Min        25  
            Median     39  
            Max        50  

    Height: 100×1 double

        Units:  In
        Values:

            Min          60   
            Median       67   
            Max          72   

    Weight: 100×1 double

        Units:  Lbs
        Values:

            Min          111  
            Median     142.5  
            Max          202  

    Smoker: 100×1 logical

        Values:

            True        34   
            False       66   

    Systolic: 100×1 double

        Units:  mm Hg
        Values:

            Min          109    
            Median       122    
            Max          138    

    Diastolic: 100×1 double

        Units:  mm Hg
        Values:

            Min            68    
            Median       81.5    
            Max            99    

Ejemplos

Almacenar variables de datos relacionadas en la tabla

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 anotar la tabla para describir su trabajo y las variables de la tabla.

En primer lugar, cree variables de espacio de trabajo que tengan los datos del paciente. Las variables pueden tener 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 contenedor para las variables de espacio de trabajo. La función table utiliza los nombres de las variables de espacio de trabajo como nombres de las variables de tabla en T. Una variable de tabla puede tener varias columnas. Por ejemplo, la variable BloodPressure en T es una matriz 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 indexación de puntos para acceder a las variables de tabla. Por ejemplo, calcule la altura media de los pacientes que utilizan los valores de T.Height.

meanHeight = mean(T.Height)

meanHeight = 67

Calcule el índice de masa corporal (IMC) y añádalo como una nueva variable de tabla. También puede Agregar y nombrar variables de tabla en un solo paso, utilizando 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

Anote la tabla con una descripción del cálculo del IMC. Puede anotar T y sus variables mediante los metadatos a los que se tiene acceso mediante T.Properties.

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

ans = struct with fields:
             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: {}

Acceso a todos los datos de tabla como matriz

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

Cree una tabla que tenga 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 cotas de la tabla mediante la propiedad DimensionNames . El nombre predeterminado de la segunda dimensión es Variables.

T.Properties.DimensionNames

ans = 1×2 cell array
    {'Row'}    {'Variables'}

Acceda a los datos de la tabla como una matriz mediante la sintaxis T.Variables. Esta sintaxis equivale a tener acceso a todo el contenido mediante la sintaxis de Curly Brace, T{:,:}. Si los datos de la tabla no se pueden concatenar en una matriz, se generará 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

Cambie el nombre de la segunda dimensión. Si cambia el nombre, puede utilizar el nuevo nombre 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

Especifique los tipos de tamaño y variable

Preasigne 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 se especifiquen. También proporciona los nombres por defecto de las variables, pero también puede asignar nombres de variables propios. La preasignación proporciona espacio para los datos que se agregan a la tabla más adelante.

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 nombres para las variables, utilice el argumento 'VariableNames' name-value Pair.

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>

Agregue filas de datos a las dos primeras filas de T2. La preasignación puede ser una técnica útil cuando el código agrega una fila de datos, o algunas filas de datos, a la vez. En lugar de cultivar la tabla cada vez que añada una fila, puede rellenar las variables de tabla que ya tienen espacio para sus datos.

T2(1,:) = {75,datetime('now'),"S1"};
T2(2,:) = {68,datetime('now')+1,"S2"}

T2=4×3 table
    Temperature       Time         Station 
    ___________    ___________    _________

        75         18-Jan-2018    "S1"     
        68         19-Jan-2018    "S2"     
         0                 NaT    <missing>
         0                 NaT    <missing>

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

Especificar nombres de variables

Crear una tabla a partir de matrices. Para especificar nombres de variables de tabla, utilice el argumento 'VariableNames' name-value Pair. Por ejemplo, puede utilizar 'VariableNames' para especificar nombres cuando los otros argumentos de entrada no son variables de espacio 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 los Estados como nombres de fila. Puede especificar tanto los pares 'VariableNames' como 'RowNames' cuando se utiliza 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

Especificar nombres de fila

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

Crear matrices que contengan datos del paciente.

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 arrays. Especifique LastName como el origen de los nombres de fila de la tabla. La tabla sólo tiene 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 indizar en las filas de T por su nombre.

T('Lee',:)

ans=1×3 table
           Age    Weight    Height
           ___    ______    ______

    Lee    38      131        64  

Para especificar varias filas, utilice una matriz de celdas.

T({'Lee','Brown'},:)

ans=2×3 table
             Age    Weight    Height
             ___    ______    ______

    Lee      38      131        64  
    Brown    49      119        64  

Para tener acceso a todos los nombres de fila de T como una matriz 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 = 5×1 cell array
    {'Sanchez'}
    {'Johnson'}
    {'Lee'    }
    {'Diaz'   }
    {'Brown'  }

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

T.Properties.DimensionNames{1} = 'LastNames';
T.LastNames

ans = 5×1 cell array
    {'Sanchez'}
    {'Johnson'}
    {'Lee'    }
    {'Diaz'   }
    {'Brown'  }

Especificar variables de tabla y nombres de fila mediante matrices de cadenas

A partir de R2017a, puede crear cadenas con comillas dobles y agregar matrices 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 utilizar el texto de una matriz de cadenas como nombres de fila, convierta la matriz de cadenas en una matriz de vectores de caracteres. A continuación, 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."

Tabla de compilación asignando variables individualmente

Crear variables de espacio de trabajo que contengan nevadas totales en fechas diferentes en tres ubicaciones. Estas variables son vectores de 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'). Debido a que las variables de espacio de trabajo son vectores de fila, debe transponerlos para colocarlos en la tabla como datos orientados a columnas. Por lo tanto, los argumentos de entrada son expresiones, no simples variables. table como resultado, crea T con los nombres de las variables predeterminadas Var1, Var2, Var3 y Var4. Puede asignar nombres más significativos a T.Properties.VariableNames después de crear T. Sin embargo, podría ser más conveniente crear una tabla vacía y, a continuación, añadir variables una a la vez con nuevos nombres.

Crear una tabla vacía. Transponer las variables de espacio de trabajo y agregarlas a la tabla como vectores de columna. Como parte de asignar cada variable de espacio de trabajo a T, proporcione un nombre significativo para la variable Table.

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    

Sugerencias

• Para obtener una lista de funciones que aceptan o devuelven tablas, vea Tablas.

Capacidades ampliadas

Arreglos altos

Realice cálculos con arreglos que tienen más filas de las que caben en la memoria.

Esta función soporta arreglos altos con la limitación:

• La sintaxis TT = table(T1,T2,...) construye una tabla alta de varias matrices altas (T1,T2,...). Puede utilizar el argumento 'VariableNames' name-value pair para especificar nombres de variables.

Para obtener más información, vea Arreglos altos para datos con memoria insuficiente.

Consulte también

| array2table | cell2table cell2table | isvarname | readtable uitablesummary | struct2table | tall

Temas

• Create and Work with Tables
• Modify Units, Descriptions, and Table Variable Names
• Access Data in Tables
• Calculations on Tables

Introducido en R2013b

×

Abrir ejemplo

Tiene una versión modificada de este ejemplo. ¿Desea abrir este ejemplo con sus modificaciones?

No, sobrescribir la versión modificada Sí