Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.
Array de tabla con variables con nombre que pueden contener diferentes tipos
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.
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.
T = table(
crea una tabla a partir de las variables de entrada var1,...,varN
) 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',
crea una tabla y preasigna espacio para las variables que tienen tipos de datos que especifique. sz
,'VariableTypes',varTypes
) 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',
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.varNames
)
T = table(___,'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.rowNames
)
T = table
crea una tabla vacía de 0 por 0.
var1,...,varN
— Variables de entradaVariables 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 preasignadaTamañ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 variablesTipos 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 variablesNombres 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 filasNombres 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 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
, donde tableName
.Properties.PropertyName
es el nombre de una propiedad. Por ejemplo, puede tener acceso a los nombres de las variables de la tabla PropertyName
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
.
DimensionNames
— Nombres de cotas{'Row','Variables'}
(predeterminado) | matriz de celdas de dos elementos de vectores de caracteresNombres 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 {:,:}
.
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 caracteresNombres 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.
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 caracteresDescripción de la tabla, especificada como vector de caracteres. Esta descripción es visible cuando se utiliza la función summary
.
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) | MatrizInformación de tabla adicional, especificada como una matriz. Puede adjuntar datos de cualquier tipo a una tabla utilizando esta propiedad.
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: {}
VariableNames
— Nombres de variablesNombres 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' ...
'Var
donde N
'}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.
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 caracteresDescripciones 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
.
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 caracteresUnidades 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
.
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
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: {}
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
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.
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
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' }
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."
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
Para obtener una lista de funciones que aceptan o devuelven tablas, vea Tablas.
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.
| array2table
|
cell2table
cell2table
| isvarname
| readtable uitablesummary
| struct2table
| tall
Existe una versión modificada de este ejemplo en su sistema. ¿Prefiere abrir esta versión?
Ha hecho clic en un enlace que corresponde a este comando de MATLAB:
Ejecute el comando introduciéndolo en la ventana de comandos de MATLAB. Los navegadores web no admiten comandos de MATLAB.
Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .
Select web siteYou can also select a web site from the following list:
Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.