Collations, repas et quantités de nourriture : Nouveautés de Wolfram Language 11

Collations, repas et quantités de nourriture

La base de connaissances de Wolfram comprend des propriétés détaillées et des informations nutritionnelles pour plus de 37 000 entités "Food" et 1000 "FoodType". En utilisant la saisie d'entrée en forme libre, EntityInstance, EntityGroup et Quantity, il est facile de représenter et de calculer les propriétés nutritionnelles de collections d'aliments, en particulier les teneurs en calories, en fibres et en sucres du déjeuner et du dîner.

In[1]:=

Table[EntityValue[foodtype, 
  "EntityCount"], {foodtype, {"Food", "FoodType"}}]

Out[1]=

Utilisez Ctrl+= (entrée en forme libre) pour obtenir facilement une quantité donnée d'aliments, exprimée sous la forme d'une EntityInstance d'une entité alimentaire implicitement définie et d'une quantité spécifiée.

In[2]:=

\!\(
NamespaceBox["LinguisticAssistant",
DynamicModuleBox[{Typeset`query$$ = "2 tbsp peanut butter", 
    Typeset`boxes$$ = RowBox[{"EntityInstance", "[", 
RowBox[{
InterpretationBox[
DynamicModuleBox[{EntityFramework`Formatting`Private`open = False}, 
TemplateBox[{
TemplateBox[{"\"foods\""}, "GeneralizedEntityBase"], 
TagBox[
GridBox[{{
TemplateBox[{
TemplateBox[{"\"food type\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"FoodType\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \\\"FoodType\\\"]\
\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", 
TemplateBox[{"\"peanut butter\"", 
RowBox[{"Entity", "[", 
RowBox[{"\"FoodType\"", ",", "\"PeanutButter\""}], "]"}], 
                    "\"Entity[\\\"FoodType\\\", \\\"PeanutButter\\\"]\
\"", "\"food type\""}, "Entity"], "}"}], "]"}]}, 
                 "GeneralizedEntityInfoRow"]}, {
TemplateBox[{
TemplateBox[{"\"added food types\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"AddedFoodTypes\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"]\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", "}"}], "]"}]}, "GeneralizedEntityInfoRow"]}}, 
              GridBoxAlignment -> {"Columns" -> {{Left}}}, 
              DefaultBaseStyle -> "GeneralizedEntityInfoGrid", 
              GridBoxItemSize -> {
               "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}], 
             "Column"], 
Dynamic[EntityFramework`Formatting`Private`open], 
            "\"Entity[\\\"Food\\\", {EntityProperty[\\\"Food\\\", \
\\\"FoodType\\\"] -> ContainsExactly[{Entity[\\\"FoodType\\\", \
\\\"PeanutButter\\\"]}], EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"] -> ContainsExactly[{}]}]\""}, 
           "GeneralizedEntityToggle"]], 
Entity["Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "PeanutButter"]}], 
           EntityProperty[
            "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
         SelectWithContents -> True], ",", " ", 
TemplateBox[{"2", "\"tbsp\"", "tablespoons", "\"Tablespoons\""}, 
         "Quantity", SyntaxForm -> Mod]}], "]"}], 
    Typeset`allassumptions$$ = {{
     "type" -> "Unit", "word" -> "tbsp", 
      "template" -> "Assuming ${desc1} for \"${word}\". Use ${desc2} \
instead", "count" -> "4", 
      "Values" -> {{
        "name" -> "Tablespoons", "desc" -> "US tablespoons", 
         "input" -> "UnitClash_*tbsp.*Tablespoons--"}, {
        "name" -> "TablespoonsUK", "desc" -> "UK tablespoons", 
         "input" -> "UnitClash_*tbsp.*TablespoonsUK--"}, {
        "name" -> "MetricTablespoons", "desc" -> "metric tablespoons",
          "input" -> "UnitClash_*tbsp.*MetricTablespoons--"}, {
        "name" -> "TablespoonsAustralian", 
         "desc" -> "Australian tablespoons", 
         "input" -> "UnitClash_*tbsp.*TablespoonsAustralian--"}}}}, 
    Typeset`assumptions$$ = {}, Typeset`open$$ = {1}, 
    Typeset`querystate$$ = {
    "Online" -> True, "Allowed" -> True, 
     "mparse.jsp" -> 0.574756`6.211028507153325, "Messages" -> {}}}, 
DynamicBox[ToBoxes[
AlphaIntegration`LinguisticAssistantBoxes["", 4, Automatic, 
Dynamic[Typeset`query$$], 
Dynamic[Typeset`boxes$$], 
Dynamic[Typeset`allassumptions$$], 
Dynamic[Typeset`assumptions$$], 
Dynamic[Typeset`open$$], 
Dynamic[Typeset`querystate$$]], StandardForm],
ImageSizeCache->{138., {7., 16.}},
TrackedSymbols:>{
      Typeset`query$$, Typeset`boxes$$, Typeset`allassumptions$$, 
       Typeset`assumptions$$, Typeset`open$$, Typeset`querystate$$}],
DynamicModuleValues:>{},
UndoTrackedVariables:>{Typeset`open$$}],
BaseStyle->{"Deploy"},
DeleteWithContents->True,
Editable->False,
SelectWithContents->True]\)

Out[2]=

Visualisez l'expression de la Quantity sous-jacente (par défaut, affichée sous une mise forme dans les sorties).

In[3]:=

\!\(
NamespaceBox["LinguisticAssistant",
DynamicModuleBox[{Typeset`query$$ = "2 tbsp peanut butter", 
    Typeset`boxes$$ = RowBox[{"EntityInstance", "[", 
RowBox[{
InterpretationBox[
DynamicModuleBox[{EntityFramework`Formatting`Private`open = False}, 
TemplateBox[{
TemplateBox[{"\"foods\""}, "GeneralizedEntityBase"], 
TagBox[
GridBox[{{
TemplateBox[{
TemplateBox[{"\"food type\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"FoodType\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \\\"FoodType\\\"]\
\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", 
TemplateBox[{"\"peanut butter\"", 
RowBox[{"Entity", "[", 
RowBox[{"\"FoodType\"", ",", "\"PeanutButter\""}], "]"}], 
                    "\"Entity[\\\"FoodType\\\", \\\"PeanutButter\\\"]\
\"", "\"food type\""}, "Entity"], "}"}], "]"}]}, 
                 "GeneralizedEntityInfoRow"]}, {
TemplateBox[{
TemplateBox[{"\"added food types\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"AddedFoodTypes\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"]\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", "}"}], "]"}]}, "GeneralizedEntityInfoRow"]}}, 
              GridBoxAlignment -> {"Columns" -> {{Left}}}, 
              DefaultBaseStyle -> "GeneralizedEntityInfoGrid", 
              GridBoxItemSize -> {
               "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}], 
             "Column"], 
Dynamic[EntityFramework`Formatting`Private`open], 
            "\"Entity[\\\"Food\\\", {EntityProperty[\\\"Food\\\", \
\\\"FoodType\\\"] -> ContainsExactly[{Entity[\\\"FoodType\\\", \
\\\"PeanutButter\\\"]}], EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"] -> ContainsExactly[{}]}]\""}, 
           "GeneralizedEntityToggle"]], 
Entity["Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "PeanutButter"]}], 
           EntityProperty[
            "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
         SelectWithContents -> True], ",", " ", 
TemplateBox[{"2", "\"tbsp\"", "tablespoons", "\"Tablespoons\""}, 
         "Quantity", SyntaxForm -> Mod]}], "]"}], 
    Typeset`allassumptions$$ = {{
     "type" -> "Unit", "word" -> "tbsp", 
      "template" -> "Assuming ${desc1} for \"${word}\". Use ${desc2} \
instead", "count" -> "4", 
      "Values" -> {{
        "name" -> "Tablespoons", "desc" -> "US tablespoons", 
         "input" -> "UnitClash_*tbsp.*Tablespoons--"}, {
        "name" -> "TablespoonsUK", "desc" -> "UK tablespoons", 
         "input" -> "UnitClash_*tbsp.*TablespoonsUK--"}, {
        "name" -> "MetricTablespoons", "desc" -> "metric tablespoons",
          "input" -> "UnitClash_*tbsp.*MetricTablespoons--"}, {
        "name" -> "TablespoonsAustralian", 
         "desc" -> "Australian tablespoons", 
         "input" -> "UnitClash_*tbsp.*TablespoonsAustralian--"}}}}, 
    Typeset`assumptions$$ = {}, Typeset`open$$ = {1}, 
    Typeset`querystate$$ = {
    "Online" -> True, "Allowed" -> True, 
     "mparse.jsp" -> 0.574756`6.211028507153325, "Messages" -> {}}}, 
DynamicBox[ToBoxes[
AlphaIntegration`LinguisticAssistantBoxes["", 4, Automatic, 
Dynamic[Typeset`query$$], 
Dynamic[Typeset`boxes$$], 
Dynamic[Typeset`allassumptions$$], 
Dynamic[Typeset`assumptions$$], 
Dynamic[Typeset`open$$], 
Dynamic[Typeset`querystate$$]], StandardForm],
ImageSizeCache->{138., {7., 16.}},
TrackedSymbols:>{
      Typeset`query$$, Typeset`boxes$$, Typeset`allassumptions$$, 
       Typeset`assumptions$$, Typeset`open$$, Typeset`querystate$$}],
DynamicModuleValues:>{},
UndoTrackedVariables:>{Typeset`open$$}],
BaseStyle->{"Deploy"},
DeleteWithContents->True,
Editable->False,
SelectWithContents->True]\);
Cases[%, _Quantity] // InputForm

Out[3]//InputForm=

Agrandissez l'entité définie implicitement précédente en cliquant sur le [+].

In[4]:=

EntityInstance[Entity[
 "Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "PeanutButter"]}], 
   EntityProperty["Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
 Quantity[2, "Tablespoons"]]

Les données sous forme libre peuvent également être utilisées directement dans les déclarations programmatiques.

In[5]:=

peanutButter = \!\(\*
NamespaceBox["LinguisticAssistant",
DynamicModuleBox[{Typeset`query$$ = "2 tbsp peanut butter", 
     Typeset`boxes$$ = RowBox[{"EntityInstance", "[", 
RowBox[{
InterpretationBox[
DynamicModuleBox[{EntityFramework`Formatting`Private`open = False}, 
TemplateBox[{
TemplateBox[{"\"foods\""}, "GeneralizedEntityBase"], 
TagBox[
GridBox[{{
TemplateBox[{
TemplateBox[{"\"food type\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"FoodType\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \\\"FoodType\\\"]\
\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", 
TemplateBox[{"\"peanut butter\"", 
RowBox[{"Entity", "[", 
RowBox[{"\"FoodType\"", ",", "\"PeanutButter\""}], "]"}], 
                    "\"Entity[\\\"FoodType\\\", \\\"PeanutButter\\\"]\
\"", "\"food type\""}, "Entity"], "}"}], "]"}]}, 
                  "GeneralizedEntityInfoRow"]}, {
TemplateBox[{
TemplateBox[{"\"added food types\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"AddedFoodTypes\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"]\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", "}"}], "]"}]}, "GeneralizedEntityInfoRow"]}}, 
               GridBoxAlignment -> {"Columns" -> {{Left}}}, 
               DefaultBaseStyle -> "GeneralizedEntityInfoGrid", 
               GridBoxItemSize -> {
                "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}],
               "Column"], 
Dynamic[EntityFramework`Formatting`Private`open], 
             "\"Entity[\\\"Food\\\", {EntityProperty[\\\"Food\\\", \\\
\"FoodType\\\"] -> ContainsExactly[{Entity[\\\"FoodType\\\", \
\\\"PeanutButter\\\"]}], EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"] -> ContainsExactly[{}]}]\""}, 
            "GeneralizedEntityToggle"]], 
Entity["Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "PeanutButter"]}], 
            EntityProperty[
             "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
          SelectWithContents -> True], ",", " ", 
TemplateBox[{"2", "\"tbsp\"", "tablespoons", "\"Tablespoons\""}, 
          "Quantity", SyntaxForm -> Mod]}], "]"}], 
     Typeset`allassumptions$$ = {{
      "type" -> "Unit", "word" -> "tbsp", 
       "template" -> "Assuming ${desc1} for \"${word}\". Use ${desc2} \
instead", "count" -> "4", 
       "Values" -> {{
         "name" -> "Tablespoons", "desc" -> "US tablespoons", 
          "input" -> "UnitClash_*tbsp.*Tablespoons--"}, {
         "name" -> "TablespoonsUK", "desc" -> "UK tablespoons", 
          "input" -> "UnitClash_*tbsp.*TablespoonsUK--"}, {
         "name" -> "MetricTablespoons", 
          "desc" -> "metric tablespoons", 
          "input" -> "UnitClash_*tbsp.*MetricTablespoons--"}, {
         "name" -> "TablespoonsAustralian", 
          "desc" -> "Australian tablespoons", 
          "input" -> "UnitClash_*tbsp.*TablespoonsAustralian--"}}}}, 
     Typeset`assumptions$$ = {}, Typeset`open$$ = {1}, 
     Typeset`querystate$$ = {
     "Online" -> True, "Allowed" -> True, 
      "mparse.jsp" -> 0.574756`6.211028507153325, "Messages" -> {}}}, 
     
DynamicBox[ToBoxes[
AlphaIntegration`LinguisticAssistantBoxes["", 4, Automatic, 
Dynamic[Typeset`query$$], 
Dynamic[Typeset`boxes$$], 
Dynamic[Typeset`allassumptions$$], 
Dynamic[Typeset`assumptions$$], 
Dynamic[Typeset`open$$], 
Dynamic[Typeset`querystate$$]], StandardForm],
ImageSizeCache->{138., {7., 16.}},
TrackedSymbols:>{
       Typeset`query$$, Typeset`boxes$$, Typeset`allassumptions$$, 
        Typeset`assumptions$$, Typeset`open$$, Typeset`querystate$$}],
     
DynamicModuleValues:>{},
UndoTrackedVariables:>{Typeset`open$$}],
BaseStyle->{"Deploy"},
DeleteWithContents->True,
Editable->False,
SelectWithContents->True]\)

Out[5]=

In[6]:=

twoSlicesOfBread = \!\(\*
NamespaceBox["LinguisticAssistant",
DynamicModuleBox[{Typeset`query$$ = "2 slices of bread", 
     Typeset`boxes$$ = RowBox[{"EntityInstance", "[", 
RowBox[{
InterpretationBox[
DynamicModuleBox[{EntityFramework`Formatting`Private`open = False}, 
TemplateBox[{
TemplateBox[{"\"foods\""}, "GeneralizedEntityBase"], 
TagBox[
GridBox[{{
TemplateBox[{
TemplateBox[{"\"food type\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"FoodType\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \\\"FoodType\\\"]\
\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", 
TemplateBox[{"\"bread\"", 
RowBox[{"Entity", "[", 
RowBox[{"\"FoodType\"", ",", "\"Bread\""}], "]"}], 
                    "\"Entity[\\\"FoodType\\\", \\\"Bread\\\"]\"", 
                    "\"food type\""}, "Entity"], "}"}], "]"}]}, 
                  "GeneralizedEntityInfoRow"]}, {
TemplateBox[{
TemplateBox[{"\"added food types\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"AddedFoodTypes\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"]\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", "}"}], "]"}]}, "GeneralizedEntityInfoRow"]}}, 
               GridBoxAlignment -> {"Columns" -> {{Left}}}, 
               DefaultBaseStyle -> "GeneralizedEntityInfoGrid", 
               GridBoxItemSize -> {
                "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}],
               "Column"], 
Dynamic[EntityFramework`Formatting`Private`open], 
             "\"Entity[\\\"Food\\\", {EntityProperty[\\\"Food\\\", \\\
\"FoodType\\\"] -> ContainsExactly[{Entity[\\\"FoodType\\\", \
\\\"Bread\\\"]}], EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"] -> ContainsExactly[{}]}]\""}, 
            "GeneralizedEntityToggle"]], 
Entity["Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "Bread"]}], 
            EntityProperty[
             "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
          SelectWithContents -> True], ",", " ", 
TemplateBox[{"2", "\"slices\"", "slices", "\"Slices\""}, "Quantity", 
          SyntaxForm -> Mod]}], "]"}], 
     Typeset`allassumptions$$ = {{
      "type" -> "Clash", "word" -> "bread", 
       "template" -> "Assuming \"${word}\" is ${desc1}. Use as \
${desc2} instead", "count" -> "2", 
       "Values" -> {{
         "name" -> "FoodType", "desc" -> "a food type", 
          "input" -> "*C.bread-_*FoodType-"}, {
         "name" -> "FoodTypeGroup", 
          "desc" -> " referring to food type group", 
          "input" -> "*C.bread-_*FoodTypeGroup-"}}}}, 
     Typeset`assumptions$$ = {"*C.bread-_*FoodType-"}, 
     Typeset`open$$ = {1}, Typeset`querystate$$ = {
     "Online" -> True, "Allowed" -> True, 
      "mparse.jsp" -> 0.662875`6.2729766336225925, "Messages" -> {}}}, 
DynamicBox[ToBoxes[
AlphaIntegration`LinguisticAssistantBoxes["", 4, Automatic, 
Dynamic[Typeset`query$$], 
Dynamic[Typeset`boxes$$], 
Dynamic[Typeset`allassumptions$$], 
Dynamic[Typeset`assumptions$$], 
Dynamic[Typeset`open$$], 
Dynamic[Typeset`querystate$$]], StandardForm],
ImageSizeCache->{117., {7., 16.}},
TrackedSymbols:>{
       Typeset`query$$, Typeset`boxes$$, Typeset`allassumptions$$, 
        Typeset`assumptions$$, Typeset`open$$, Typeset`querystate$$}],
     
DynamicModuleValues:>{},
UndoTrackedVariables:>{Typeset`open$$}],
BaseStyle->{"Deploy"},
DeleteWithContents->True,
Editable->False,
SelectWithContents->True]\)

Out[6]=

Les groupes d'aliments (par exemple, les repas, les en-cas, etc.) peuvent être représentés par EntityGroup.

In[7]:=

pbjSandwich = EntityGroup[{
    twoSlicesOfBread,
    peanutButter,
    EntityInstance[Entity[
     "Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "Jelly"]}], 
       EntityProperty[
        "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
     Quantity[1, "Servings"]]
    }];

Trouvez le contenu nutritionnel du groupe d'aliments dans son ensemble.

In[8]:=

pbjSandwich[{EntityProperty["Food", "AbsoluteTotalCaloriesContent"], 
  EntityProperty["Food", 
   "AbsoluteTotalProteinContent"]}, "PropertyAssociation"]

Out[8]=

Utilisez EntityGroup et EntityInstance pour analyser un dîner de spaghettis.

In[9]:=

dinner = EntityGroup[{
    EntityInstance[Entity[
     "Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "Spaghetti"]}], 
       EntityProperty[
        "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
     Quantity[1, "Servings"]],
    EntityInstance[Entity[
     "Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "Meatball"]}], 
       EntityProperty[
        "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
     Quantity[3, "Items"]],
    EntityInstance[Entity[
     "Food", {
      EntityProperty["Food", "BrandName"] -> Entity[
        "FoodBrandName", "Bertolli"], 
       EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "Sauce"]}], 
       EntityProperty[
        "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
     Quantity[1.5, "Servings"]],
    EntityInstance[Entity[
     "Food", {
      EntityProperty["Food", "Flavor"] -> Entity[
        "FoodFlavor", "Cola"], 
       EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "CarbonatedBeverage"]}], 
       EntityProperty[
        "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
     Quantity[1, "USSodaCanVolumes"]]
    }];

In[10]:=

dinner[{EntityProperty["Food", "AbsoluteTotalCaloriesContent"], 
  EntityProperty["Food", 
   "AbsoluteTotalSugarContent"]}, "PropertyAssociation"]

Out[10]=

Exemples connexes

Collations, repas et quantités de nourriture

Préparez de l'aspirine

Évaluez un sac de pièces de monnaie

Explorez la filmologie

Auto-analyse en Wolfram Language

Visualisez la nutrition en termes de valeurs quotidiennes recommandées

Le pouvoir des Pokémon

Le yoga pour la santé et la connaissance

Créez un EntityStore pour les météorites à boules de feu

Enumérez les structures de PCB et partagez-les via un EntityStore

Risque de cancer basé sur l'activité physique à l'aide d'un EntityStore

Transformée intégrale d'EntityStore

Musée d'art moderne : peintures et artistes

Les chiffres du marathon de Chicago 2015

Subventions de la Fondation nationale des sciences

Données institutionnelles de la Federal Deposit Insurance Corporation

Prévoyez la météo

Cartographiez le passage du Nord-Ouest à l'aide de la modélisation géomagnétique

Visualisez Wolfram Language

Réseau de dérivées de fonctions spéciales

Analysez les ingrédients d'une recette

Analysez, visualisez et comparez les « super-aliments »

Requêtes entité-propriété en forme libre

Génération de quiz en ligne