table
Arreglo de tablas con variables con nombre que pueden contener distintos tipos
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.
, extrae una variable.varname
Las llaves, como en
T{
, extraen un arreglo de las filas y las variables especificadas.rows
,vars
}Los paréntesis, como en
T(
, devuelven una tabla.rows
,vars
)
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
Descripción
T = table(
crea una tabla a partir de las variables de entrada var1,...,varN
)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',...,'Var
, donde N
'
es el número de variables.N
T = table('Size',
crea una tabla y asigna previamente espacio para las variables que tienen los tipos de datos que especifica. sz
,'VariableTypes',varTypes
)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.
T = table(___,
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 Name,Value
)'VariableNames'
. Puede utilizar esta sintaxis con cualquiera de los argumentos de entrada de las sintaxis anteriores.
T = table
crea una tabla de 0 por 0 vacía.
Argumentos de entrada
var1,...,varN
— Variables de entrada
arreglos
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.
sz
— Tamaño de la tabla asignada previamente
vector numérico de dos elementos
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.
varTypes
— Tipos de datos de las variables asignadas previamente
arreglo de celdas de vectores de caracteres | arreglo de cadenas
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 |
---|---|
|
|
|
|
|
|
|
|
|
|
| Valor categórico |
| Valor |
|
|
|
|
|
|
|
|
|
|
| Estructura escalar sin campos |
| Tabla sin variables |
| Horario sin variables y |
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.
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
.
VariableNames
— Nombres de variables
arreglo de celdas de vectores de caracteres | arreglo de cadenas
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 propiedadVariableNames
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
.
RowNames
— Nombres de fila
arreglo de celdas de vectores de caracteres | arreglo de cadenas
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 propiedadRowNames
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
.
DimensionNames
— Nombres de dimensiones
arreglo de celdas de dos elementos de vectores de caracteres | arreglo de cadenas de dos elementos
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 propiedadDimensionNames
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
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
, donde tableName
.Properties.PropertyName
es el nombre de la propiedad. Por ejemplo, puede acceder a los nombres de las variables de la tabla PropertyName
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
DimensionNames
— Nombres de dimensiones
{'Row','Variables'}
(predeterminado) | arreglo de celdas de dos elementos de vectores de caracteres | arreglo de cadenas de dos elementos
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.
RowNames
— Nombres de fila
{}
(predeterminado) | arreglo de celdas de vectores de caracteres | arreglo de cadenas
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"
Description
— Descripción de la tabla
''
(predeterminado) | vector de caracteres | escalar de cadena
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
UserData
— Información adicional de la tabla
[]
(predeterminado) | arreglo
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
VariableNames
— Nombres de variables
arreglo de celdas de vectores de caracteres | arreglo de cadenas
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
VariableDescriptions
— Descripciones de variables
{}
(predeterminado) | arreglo de celdas de vectores de caracteres | arreglo de cadenas
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
VariableUnits
— Unidades de variables
{}
(predeterminado) | arreglo de celdas de vectores de caracteres | arreglo de cadenas
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
VariableContinuity
— Estado como variables continuas o discretas
[]
(predeterminado) | arreglo de celdas de vectores de caracteres | arreglo de cadenas
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
CustomProperties
— Metadatos personalizados de una tabla y sus variables
objeto CustomProperties
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
. En esta sintaxis,tableName
.Properties.CustomProperties.PropertyName
es el nombre que eligió cuando añadió esa propiedad usandoPropertyName
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
Almacenar variables de datos relacionados en una 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 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.
Acceder a todos los datos de tabla como una matriz
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
Especificar el tamaño y los tipos de variable
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.
Especificar nombres de variables
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
Especificar nombres de fila
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' }
Especificar variables de tabla y nombres de fila utilizando arreglos de cadenas
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."
Crear una tabla asignando variables individualmente
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
Especificar nombres de variables utilizando cualquier carácter
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
Arreglos altos
Realice cálculos con arreglos que tienen más filas de las que caben en la memoria.
Esta función es compatible con arreglos altos, con la siguiente limitación:
La sintaxis
TT = table(T1,T2,...)
crea una tabla alta a partir de varios arreglos altos(T1,T2,...)
. Puede utilizar el argumento de par nombre-valor'VariableNames'
para especificar los nombres de variables.
Para obtener más información, consulte Arreglos altos para datos con memoria insuficiente.
Generación de código C/C++
Genere código C y C++ mediante MATLAB® Coder™.
Notas y limitaciones de uso:
A partir de la versión R2019b, puede utilizar tablas en código de MATLAB previsto para la generación de código. Para obtener más información, consulte Code Generation for Tables (MATLAB Coder) y Table Limitations for Code Generation (MATLAB Coder).
Entorno basado en subprocesos
Ejecute código en segundo plano con MATLAB® backgroundPool
o acelere código con Parallel Computing Toolbox™ ThreadPool
.
Arreglos distribuidos
Realice particiones de arreglos grandes por toda la memoria combinada de su cluster mediante Parallel Computing Toolbox™.
Notas y limitaciones de uso:
Los arreglos de entrada deben estar distribuidos y tener el mismo número de filas.
El resultado se distribuye utilizando un esquema de distribución 1D en la primera dimensión.
Para obtener más información, consulte Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).
Historial de versiones
Introducido en R2013bR2023a: Realizar cálculos directamente en tablas y horarios sin extraer los datos
Ahora puede realizar cálculos directamente en tablas y horarios sin extraer los datos. Todas las variables de las tablas y los horarios deben tener tipos de datos que admitan los cálculos. También puede realizar operaciones en las que un operando es una tabla u horario y el otro es un arreglo lógico o numérico. Anteriormente, todos los cálculos requerían extraer datos de las tablas y horarios indexándolos.
Para obtener más información, consulte Direct Calculations on Tables and Timetables y Rules for Table and Timetable Mathematics.
R2022a: Rendimiento mejorado cuando se crean subíndices con notación de puntos o múltiples niveles de indexación
La creación de subíndices con notación de puntos es significativamente más rápida en la versión R2022a que en la versión R2021b. Además, la creación de subíndices con múltiples niveles de indexación es más rápida.
Por ejemplo, cuando usa la notación de puntos para hacer referencia a una variable de tabla con 106 elementos, el rendimiento de la versión R2022a es más de 4 veces más rápido que el de la versión R2021b.
function timingTest() t = table(zeros(1e6,1), ones(1e6,1), nan(1e6,1)); indices = 1:10000; tic; % Refer to variable using dot notation for i = indices x = t.Var1; end toc end
Los tiempos de ejecución aproximados son:
Versión R2021b: 0,15 s
Versión R2022a: 0,035 s
De forma similar, cuando usa la notación de puntos para asignar un arreglo a una variable de tabla con 106 elementos, el rendimiento de la versión R2022a es unas 3,6 veces más rápido que el de la versión R2021b.
function timingTest() t = table(zeros(1e6,1), ones(1e6,1), nan(1e6,1)); indices = 1:10000; x = randi(1e6,1e6,1); tic; % Assign to variable using dot notation for i = indices t.Var1 = x; end toc end
Los tiempos de ejecución aproximados son:
Versión R2021b: 0,23 s
Versión R2022a: 0,063 s
Además, cuando usa la notación de puntos y los paréntesis para asignar valores individuales a los elementos de una variable de tabla, el rendimiento de la versión R2022a es más de 4 veces más rápido que el de la versión R2021b.
function timingTest() t = table(zeros(1e6,1), ones(1e6,1), nan(1e6,1)); indices = randi(1e6,1,10000); tic; % Assign to elements using dot notation and parentheses for i = indices t.Var1(i) = rand; end toc end
Los tiempos de ejecución aproximados son:
Versión R2021b: 0,53 s
Versión R2022a: 0,12 s
El código se cronometró en un sistema de prueba Windows® 10, Intel® Xeon CPU W-2133 @ 3.60 GHz llamando a cada versión de la función timingTest
.
R2021b: Rendimiento mejorado cuando se asignan elementos creando subíndices con llaves
La asignación con subíndices utilizando llaves es significativamente más rápida en la versión R2021b que en la versión R2021a.
Por ejemplo, cuando asigna en tres variables de tabla con 106 elementos, el rendimiento de la versión R2021b es aproximadamente 4,4 veces más rápido, como se muestra a continuación.
function timingTest() t = table(zeros(1e6,1), ones(1e6,1), nan(1e6,1)); indices = randi(1e6,1,10000); tic; % Assign row vector of random values to randomly chosen row for i = indices t{i,:} = rand(1,3); end toc end
Los tiempos de ejecución aproximados son:
Versión R2021a: 7,4 s
Versión R2021b: 1,7 s
El código se cronometró en un sistema Windows 10 con Intel Xeon W-2133 CPU a 3.6 GHz llamando a la función timingTest
en las versiones R2021a y R2021b.
R2021a: Los nombres de dimensiones no pueden coincidir con nombres reservados
MATLAB emite un error si asigna un nombre de dimensiones que coincida con uno de estos nombres reservados: 'Properties'
, 'RowNames'
, 'VariableNames'
o ':'
. En versiones anteriores, MATLAB emitía una advertencia y modificaba los nombres de dimensiones para que fueran diferentes de los nombres reservados.
R2020a: Rendimiento mejorado cuando se asignan elementos creando subíndices en variables de tabla
La asignación de subíndices en variables de tabla es significativamente más rápida. El rendimiento es fundamentalmente constante con el número de elementos de cada variable de tabla.
Por ejemplo, cuando usa la indexación de puntos para asignar elementos a una variable con 106 elementos, el rendimiento de la versión R2020a es aproximadamente 2 veces más rápido que el de la versión R2019b, como se muestra a continuación.
function timingTest() t = table(zeros(1e6,1)); indices = randi(1e6,1,10000); tic; for i = indices t.Var1(i) = rand; end toc end
Los tiempos de ejecución aproximados son:
Versión R2019b: 1,20 s
Versión R2020a: 0,59 s
De forma similar, la asignación con llaves es más rápida. Cuando asigna en tres variables de tabla con 106 elementos, el rendimiento de la versión R2020a es aproximadamente 1,2 veces más rápido que el de la versión R2019b, como se muestra a continuación.
function timingTest() t = table(zeros(1e6,1), ones(1e6,1), nan(1e6,1)); indices = randi(1e6,1,10000); tic; for i = indices t{i,:} = rand; end toc end
Los tiempos de ejecución aproximados son:
Versión R2019b: 8,04 s
Versión R2020a: 6,68 s
El código se cronometró en un sistema de prueba Windows 10, Intel Xeon® W-2133 @ 3.60 GHz llamando a la función timingTest
.
La mejora del rendimiento se produce solo cuando hace asignaciones con subíndices de tablas dentro de una función. No hay mejora cuando se crean subíndices en tablas en la línea de comandos o dentro de bloques try-catch
.
R2019b: Los nombres de las variables pueden contener espacios en blanco iniciales y finales
Los nombres de las variables de tablas y horarios con espacios en blanco iniciales o finales no se modifican.
En versiones anteriores, los espacios en blanco iniciales y finales se eliminaban de los nombres de las variables cuando se especificaban con el argumento de par nombre-valor 'VariableNames'
o se asignaban a la propiedad VariableNames
.
Para eliminar manualmente estos caracteres, utilice primero la función strtrim
en los nombres y, a continuación, asígnelos como nombres de variables a la tabla u horario.
R2019b: Los nombres de las variables y los nombres de las dimensiones deben ser únicos
MATLAB crea un error si asigna un nombre de variable de tabla que coincida con un nombre de dimensión o un nombre de dimensión que coincida con un nombre de variable. En versiones anteriores, MATLAB creaba una advertencia y modificaba los nombres para que fueran únicos.
R2019b: Rendimiento mejorado cuando se asignan elementos creando subíndices en variables de tabla grandes
La asignación de subíndices en variables de tabla grandes es significativamente más rápida. Ahora el rendimiento es fundamentalmente constante con el número de elementos de cada variable de tabla.
Por ejemplo, cuando usa la indexación de puntos para asignar elementos a una variable con 106 elementos, el rendimiento de la versión R2019b es aproximadamente 40 veces más rápido, como se muestra a continuación.
function timingTest() t = table(zeros(1e6,1)); indices = randi(1e6,1,10000); tic; for i = indices t.Var1(i) = rand; end toc end
Los tiempos de ejecución aproximados son:
Versión R2019a: 47,83 s
Versión R2019b: 1,20 s
De forma similar, la asignación con llaves es más rápida. Por ejemplo, cuando asigna en tres variables de tabla con 106 elementos, el rendimiento de la versión R2019b es aproximadamente 18 veces más rápido.
function timingTest() t = table(zeros(1e6,1), ones(1e6,1), nan(1e6,1)); indices = randi(1e6,1,10000); tic; for i = indices t{i,:} = rand; end toc end
Los tiempos de ejecución aproximados son:
Versión R2019a: 156,39 s
Versión R2019b: 8,51 s
El código se cronometró en un sistema Windows 10 con Intel Xeon W-2133 CPU a 3.6 GHz llamando a cada versión de la función timingTest
.
Cuanto mayores sean las variables de la tabla, mayor será la mejora del rendimiento. Sin embargo, la mejora del rendimiento se produce solo cuando hace asignaciones con subíndices de tablas dentro de una función. No hay mejora cuando se crean subíndices en tablas en la línea de comandos o dentro de bloques try-catch.
Comando de MATLAB
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.
Select a Web Site
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: .
You can also select a web site from the following list:
How to Get Best Site Performance
Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.
Americas
- América Latina (Español)
- Canada (English)
- United States (English)
Europe
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)