文本输入和输出
文本输入和输出
| 输入和输出形式 | Wolfram 语言的语法 |
| 输入和输出的工作过程 | 无内部定义的运算符 |
| 文本形式的表示 | 定义输出格式 |
| 文本形式的翻译 | 底层的输入输出规则 |
| 缩短输出 | 生成无结构的输出 |
| 面向字符串的输出格式 | 格式化输出 |
| 数字的输出格式 | Wolfram 语言中的网格、行和列 |
| 表与矩阵 | 要求输入 |
| 输出的样式和字体 | 消息 |
| 文本格式的框符表示 | 国际消息 |
| 框符的字符串表示 | 文件结构 |
| 字符串、框符和表达式之间的转换 |
x ^ 2 + Sqrt[y]Plus[Power[x, 2], Sqrt[y]]x^2 + Sqrt[y]在 Wolfram 系统的笔记本中，默认情况下，以 StandardForm 形式输出表达式：
x ^ 2 + Sqrt[y]OutputForm 仅用通常的键盘字符，是 Wolfram 语言默认的文本界面：
OutputForm[x ^ 2 + Sqrt[y]]InputForm 产生一个能直接由键盘输入的形式：
InputForm[x ^ 2 + Sqrt[y]]FullForm 显示表达式的以函数记号表示的内部形式：
FullForm[x ^ 2 + Sqrt[y]]| FullForm[expr] | 表达式的内部形式 |
| InputForm[expr] | 适于直接从键盘输入的形式 |
| OutputForm[expr] | 仅用键盘字符的二维形式 |
| StandardForm[expr] | Wolfram 系统笔记本中的默认格式 |
输出形式提供了 Wolfram 语言表达式的文本表示形式. 在有些情况下，这些文本表示方式也适用于 Wolfram 语言的输入. 但是在其他情况下，这仅用来进行查看，或者输出到其他程序，而不是用来作为 Wolfram 语言的输入.
TraditionalForm 用大量的规则集合去产生近似于传统数学记号的形式：
TraditionalForm[x ^ 2 + Sqrt[y] + Gamma[z] EllipticK[z]]TeXForm 产生一个适合导出到 TeX 中的输出：
TeXForm[x ^ 2 + Sqrt[y]]MathMLForm 产生一个 MathML 形式的输出：
MathMLForm[x ^ 2 + Sqrt[y]]CForm[x ^ 2 + Sqrt[y]]FortranForm 产生一个适合导出到 Fortran 中的输出：
FortranForm[x ^ 2 + Sqrt[y]]| TraditionalForm[expr] | 传统的数学记号 |
| TeXForm[expr] | 适合导出到 TeX 中的输出 |
| MathMLForm[expr] | 适用于网上的 MathML 的输出 |
| CForm[expr] | 适合导出到 C 中的输出 |
| FortranForm[expr] | 适合导出到 Fortran 中的输出 |
"底层的输入输出规则" 节中讨论怎样产生自己的输出形式. 但应该看到在与外部程序的交互时，最好用 Wolfram Symbolic Transfer Protocol (WSTP) 去直接传送表达式，而不是产生这些表达式的文本表示形式.
接着，当可能的运算完成后，Wolfram 语言就把表达式 Power[x,2] 转化为输出中的文本表示方式.
x ^ 2FortranForm[%]%如果用户通过使用使用 TraditionalForm[expr] 等明确要求一种特定的输出形式，则用户得到的结果将被标以 Out[n]//TraditionalForm. 这表明即使 Out[n] 的值自身仅是一个表达式 expr，所看到的仍是 expr//TraditionalForm.
t = FortranForm[x ^ 2 + y ^ 2]%t{t ^ 2, 1 / t}与 Wolfram 系统中的其他内容相似，表达式的文本形式本身也可以表示为一个表达式. 由一维字符序列组成的文本形式可以用普通的 Wolfram 系统字符串直接表示. 而涉及到上、下标和其他二维结构的文本形式可用二维框符的嵌套集合来表示.
one‐dimensional strings | InputForm ， FullForm，等. |
two‐dimensional boxes | StandardForm ， TraditionalForm，等. |
生成与 InputForm 中的表达式的文本形式相对应的字符串：
ToString[x ^ 2 + y ^ 3, InputForm]FullForm 显式显示该字符串：
FullForm[%]Characters[%]与 StandardForm 的表达式相对应的框符结构：
ToBoxes[x ^ 2 + y ^ 3, StandardForm]框符结构的 InputForm. 在这种形式下，结构通过一个普通字符串有效地表示出来：
ToBoxes[x ^ 2 + y ^ 3, StandardForm]//InputForm当使用 Wolfram 系统的笔记本前端时，通过使用显示表达式 的菜单项可以看到与每个单元的文本形式对应的表达式.
含有 StandardForm 的表达式的一个单元.
通过使用 显示表达式 的菜单项，此处以框符形式显示该表达式的底层表示：
| ToExpression[input] | 通过翻译字符串或字符盒创建一个表达式 |
ToExpression["2 + 3 + x/y"]与以 StandardForm 的形式给出的表达式的文本形式相对应的字符盒结构：
ToBoxes[2 + x ^ 2, StandardForm]ToExpression 翻译该字符盒结构，重新得到原来的表达式：
ToExpression[%]在 Wolfram 系统的任何进程中，Wolfram 系统总是有效利用 ToExpression 将输入的文本形式翻译为要计算的实际表达式.
使用 Wolfram 系统的笔记本前端时，仅当一个单元的内容送到内核进行计算时才进行翻译. 这意味着在笔记本中，不需要将设置的文本形式与有意义的 Wolfram 系统表达式相对应，仅当要把这些文本形式送往内核时这样做才有必要.
| FullForm | 显式函数记号 |
| InputForm | 一维记号 |
| StandardForm | 二维记号 |
用 FullForm 形式输入一个表达式：
Plus[1, Power[x, 2]]用 InputForm 形式输入的同一个表达式：
1 + x ^ 2用 StandardForm 形式输入的这一个表达式：
1 + x^2Wolfram 系统内部建立了一系列标准规则供 ToExpression 使用，将文本形式转化为表达式.
这些规则定义了 Wolfram 系统的语法. 规则指出，x+y 应该被解释为 Plus[x,y]，而 xy 应该被解释为 Power[x,y]. 若所给的输入是 FullForm 的形式，翻译的规则很简单：每个表达式仅由头部和随后括号内的一列元素组成. 对于 InputForm 的规则稍微复杂一些：其允许使用 +、= 和 -> 等运算符，并理解运算符出现在运算对象之间时的表达式. StandardForm 涉及到的规则更加复杂，不仅允许运算符和运算对象以一维序列形式排列，还允许这些运算符和运算对象以二维结构排列.
Wolfram 系统的设置使得 FullForm、InputForm 和 StandardForm 形成一个严格的分层结构：能用 FullForm 输入的肯定能用 InputForm 输入，而能用 InputForm 输入的也肯定能用 StandardForm 输入.
如果复制一个不许计算就能翻译的 StandardForm 表达式，该表达式将以 InputForm 形式贴入外部应用. 否则该文本将以线性格式被复制，该格式使用 ∖!∖(…∖) 能够精确表示二维结构. 这个线性格式被重新粘贴到 Wolfram 系统笔记本中时将自动转为二维形式.
| ToExpression[input,form] | 假设 input 按指定的文本形式给出，试图创建一个表达式 |
StandardForm 和其子集 FullForm 和 InputForm 提供了以文本形式代表任意 Wolfram 系统表达式的确切方式. 当给定一种文本形式时，总能被无歧义地转化为所代表的表达式.
TraditionalForm 是作为输出的文本形式的一个例子. 可以将任何 Wolfram 系统表达式显示为TraditionalForm 的形式. 但 TraditionalForm 不具有 StandardForm 的精确性，通常不能无歧义的由一种 TraditionalForm 的表示返回得到其所代表的表达式.
读取一个字符串，并以 TraditionalForm 输入的形式将其翻译：
ToExpression["f(6)", TraditionalForm]在 StandardForm 形式时，同一字符串指的却是各项的乘积：
ToExpression["f(6)", StandardForm]当 TraditionalForm 的输出是以计算结果的形式生成时，代表输出的实际字符盒集合通常包含特殊的Interpretation 对象或其他加以特殊标签的形式来指定一个表达式如何由 TraditionalForm 格式的输出被重新构建.
由 StandardForm 通过显式转换得到的 TraditionalForm 也同样如此. 但若要对 TraditionalForm 进行大量编辑，或从头输入时，Wolfram 系统就不得不在没有额外信息的情况下尝试将其进行转化.
| Short[expr] | 用一行显示 expr 的缩略形式 |
| Short[expr,n] | 用 n 行显示 expr 的缩略形式 |
| Shallow[expr] | 显示 expr 的 “顶层” |
| Shallow[expr,{depth,length}] | 显示 expr 中指定深度和长度的部分 |
t = Expand[(1 + x + y) ^ 12];Short[t]Wolfram 语言在生成如 OutputForm 的文本格式的输出时，首先将输出写为一个长行，然后根据要求的文本宽度，将该长行切分成一些 “行”. 这些切分后的每一 “行” 当然可能会含有上标或嵌入分式，所以在输出设备上实际显示的可能多于一行. 当在 Short 中指定某一数目的行时，Wolfram 语言认为要选择的是 “逻辑行” 的数目，而不是在输出设备上实际显示的自然行的数目.
Short[t, 4]Short 在其他形式中也有效，比如在 StandardForm 和 TraditionalForm 等形式中. 当使用这些形式时，自动换行由输出被显示时的笔记本界面决定，而不是由输出被创建时的内核决定. 因此，对由 Short 生成的行数的设定，只能近似于屏幕上实际显示的行数.
Short[InputForm[t]]Short 指令通过删除表达式中的一些项使得结果中的输出形式能放在所指定的行数内. 但有时最好不指定输出结果中有多少行，而是指定要丢掉表达式中的哪些项. Shallow[expr,{depth,length}] 仅包含任意函数的 length 个变量，丢掉指定深度之下的所有子表达式.
Shallow[t]Shallow[t, {Infinity, 10}]fib[n_] := fib[n - 1] + fib[n - 2];fib[0] = fib[1] = 1tr = Trace[fib[8]];可以用 Shallow 来看这个结构的缩略形式：
Shallow[tr]Short 给出一个较难理解的不统一的缩略形式：
Short[tr, 4]当在笔记本界面中生成的输出过于庞大时，Wolfram 语言自动在输出时应用 Short. 这种用户界面的改善可以避免 Wolfram 语言使用过多的时间对用户可能并不想要的打印输出进行生成和格式化.
lst = Range[10^6]"This is a string."InputForm[%]可以将任意类型的文本放在 Wolfram 语言字符串中，这包括非英文字符、换行符和其他控制信息. "字符串和字符" 一节将更深入的讨论字符串的操作.
| StringForm["cccc``cccc",x1,x2,…] | 输出一个字符串，其中相继的 `` 用相继的 xi 替换 |
| StringForm["cccc`i`cccc",x1,x2,…] | 输出一个字符串，其中每个 `i` 由对应的 xi 替换 |
StringForm["x = ``, y = ``", 3, (1 + u) ^ 2]StringForm["{`1`, `2`, `1`}", a, b]在 StringForm 中的字符串有点像的格式输出语句中的格式指令（format directive）. 可以通过将表达式封装在标准输出格式函数内的途径决定在 StringForm 中表达式的输出格式.
可以通过标准输出格式函数指定 StringForm 中表达式的输出格式：
StringForm["The `` of `` is ``.", TeXForm, a / b, TeXForm[a / b]]StringForm 生成 Wolfram 系统标准输出形式的格式化输出：
StringForm["Q: `` -> ``", a, b]在输入形式中，可以看到实际的 StringForm 对象：
InputForm[%]从 StringForm 对象创建了一个普通字符串：
InputForm[ToString[%]]| Row[{expr1,expr2,…}] | 给出连接在一起的 expri 表达式的输出形式 |
| Row[list, s] | 在连续元素之间插入 s |
| Spacer[w] | 可用于 Row 的 w 个点的空格 |
| Invisible[expr] | 由 expr 的物理尺寸决定的空格 |
Row 以一系列连接在一起的表达式的形式打印：
Row[{"[x = ", 56, "]"}]Row 也适用于排版表达式（typeset expression）：
Row[{"[y = ", Subscript[a, b], "]"}]Row 可以在被展示的元素之间自动插入任何表达式：
Row[{a, b, c, d}, "⟷"]Spacer 可用于精确控制元素间的间隔：
Row[{"x", Spacer[10], "y"}]| Column[{expr1,expr2,…}] | 左对齐的列 |
| Column[list,alignment] | |
| Column[list,alignment,s] | 各元素间隔为 s 个x 高度（x-heights）的列 |
Column[{a + b, x ^ 2}]| Defer[expr] | 给出 expr 的输出形式且保持不对 expr 进行计算 |
| Interpretation[e,expr] | 以 e 的形式在输出中显示，但作为 expr 进行计算 |
利用 Row 等文本字符串和函数，可以生成一段不必对应于 Wolfram 语言有效表达式的输出. 然而有时希望只要不进行表达式的计算，则生成的输出应对应于 Wolfram 语言有效表达式. 函数 Defer 可以使其自变量不被计算但允许其被格式化成 Wolfram 系统的标准输出形式.
Defer[1 + 1]Defer 阻止了实际指令的执行：
Defer[x = 3]当 Defer 的输出被再次计算时（这种情况可以通过对输出进行修改或者使用拷贝和粘贴而发生），计算将正常进行.
x = 3通过使用 Interpretation，可以生成外观与其计算方式没有直接关联的输出. 当 Wolfram 系统在对某些形式的输出进行格式化，而可读性最好的形式并不与对象的内部表示良好对应时，这种方法被有效使用. 例如，Series 在其默认输出时，总是生成一个 Interpretation 对象.
Interpretation[y, x]2 x| ScientificForm[expr] | 按照科学记数法显示所有数 |
| EngineeringForm[expr] | 按照工程记数法显示所有数（10 的方幂是3的倍数） |
| AccountingForm[expr] | 按照标准会计记数法显示所有数 |
{6.7 ^ -4, 6.7 ^ 6, 6.7 ^ 8}ScientificForm[%]EngineeringForm[%]AccountingForm[{5.6, -6.7, 10. ^ 7}]| NumberForm[expr,tot] | 最多显示 tot 位近似于 expr 的实数 |
| ScientificForm[expr,tot] | 使用最多有 tot 位的科学记数法 |
| EngineeringForm[expr,tot] | 使用最多有 tot 位的工程记数法 |
N[Pi ^ 9, 30]
NumberForm[%, 10]EngineeringForm[%, 12]
选项名称
|
默认值
| |
| DigitBlock | Infinity | 两分隔符之间一组数字的最大长度 |
| NumberSeparator | {","," "} | 在小数点左边和右边的数字之间的空格位置要插入的字符串 |
| NumberPoint | "." | 用作小数点的字符串 |
| NumberMultiplier | "∖[Times]" | 在科学记数法中用作乘法记号的字符串 |
| NumberSigns | {"-",""} | 用作正负数标记的字符串 |
| NumberPadding | {"",""} | 用作左右填充符（padding）的字符串 |
| SignPadding | False | 是否在符号后插入填充符 |
| NumberFormat | Automatic | 产生数字最终格式的函数 |
| ExponentFunction | Automatic | 决定是否使用指数的函数 |
所有的选项均可用于函数 NumberForm、ScientificForm、EngineeringForm 和 AccountingForm. 事实上，这些函数中某个函数行为的再现，可以通过对其他三个函数之一进行适当的选项设置实现. 表中所列的默认选项设置是对 NumberForm 设置的.
NumberForm[30!, DigitBlock -> 3]NumberForm[30!, DigitBlock -> 5, NumberSeparator -> " "]NumberForm[{4.5, -6.8}, NumberSigns -> {"-", "+"}, NumberPoint -> "|"]Wolfram 语言显示近似实数时，必须对是否使用科学记数法作出选择，如果是，还要知道小数点左边有多少位. 如果使用科学记数法，Wolfram 语言首先找到10的幂指数是多少，并给出小数点左边一位数字. 然后取这个指数值，应用于以选项 ExponentFunction 给出的任意函数. 这个函数的返回值是实际使用的指数，如果不使用科学记数法则返回 Null.
{8. ^ 5, 11. ^ 7, 13. ^ 9}NumberForm[%, ExponentFunction -> (If[-10 < # < 10, Null, #]&)]NumberForm[%, ExponentFunction -> (3 Quotient[#, 3]&)]在确定了尾数和指数之后，最后一步是将这些组合在一起将对象输出. 选项 NumberFormat 允许给出任意函数设定数字的显示形式. 该函数取三个字符串作为变量：尾数，基底和指数. 如果无指数，则给出 "".
NumberForm[{5.6 ^ 10, 7.8 ^ 20}, NumberFormat -> (SequenceForm[#1, "e", #3]&)]可使用 FortranForm 以 Fortran 格式显示每个数：
FortranForm[7.8 ^ 20]| PaddedForm[expr,tot] | 所有数字用 tot 位显示，不足时前面加空格 |
| PaddedForm[expr,{tot,frac}] | 所有数字用 tot 位显示，小数点右边有 frac 位 |
| NumberForm[expr,{tot,frac}] | 所有数字最多有 tot 位，其中小数点右边有 frac 位 |
| Column[{expr1,expr2,…}] | expri 左对齐排在一列 |
PaddedForm[{456, 12345, 12}, 7]PaddedForm[Column[{456, 12345, 12}], 7]PaddedForm[{-6.7, 6.888, 6.99999}, {7, 4}]在 NumberForm 中，7设定的是最大精度，但 Wolfram 语言并不用空格填充：
NumberForm[{-6.7, 6.888, 6.99999}, {7, 4}]如果设置选项 SignPadding->True，Wolfram 语言将在符号之后空格填充：
PaddedForm[{-6.7, 6.888, 6.99999}, {7, 4}, SignPadding -> True]PaddedForm[Column[{6.7 10 ^ 8, 48.7, -2.3 10 ^ -16}], {4, 2}]选项 NumberPadding 使用默认设置时，NumberForm 和 PaddedForm 从右边填充一个数时插入尾随零（trailing zeros）. 通过设置 NumberPadding->{" "," "} 可以用空格进行左右填充.
PaddedForm[{-6.7, 6.888, 6.99999}, {7, 4}, NumberPadding -> {" ", " "}]| BaseForm[expr,b] | 在 b 进制下显示所有数 |
BaseForm[2342424, 2]BaseForm[242345341, 16]BaseForm 对近似实数仍然有效：
BaseForm[2.3, 2]BaseForm 也可用在以科学记数法显示的数中：
BaseForm[2.3 10 ^ 8, 2]"不同形式的数之间的转换" 讨论在任意进位制下数的输入，以及如何得到数字各个位的列表.
Table[(i + 45) ^ j, {i, 3}, {j, 3}]Grid 按表格形式给出列表排版：
Grid[%]TableForm 按表格形式显示列表：
TableForm[%%]Column[Range[5]]FullForm[%]Grid[{{"disk", Graphics[Disk[], ImageSize -> 25]}, {"square", Graphics[Rectangle[], ImageSize -> 25]}}]| PaddedForm[Column[list],tot] | 显示一列，所有数字可以填充至 tot 位 |
| PaddedForm[Grid[list],tot] | 显示一个表格，所有数字可以填充至 tot 位 |
| PaddedForm[Grid[list],{tot,frac}] | 对于所有的近似实数中，在小数点后面显示 frac 位 |
fac = {10!, 15!, 20!}Column 将该列表显示为一列：
Column[fac]PaddedForm[Column[fac], 20]在这个特殊例子里，可以用 Alignment 选项对齐数字：
Column[fac, Alignment -> {Right}]PaddedForm[Column[{6.7, 6.888, 6.99999}], {8, 5}]| SpanFromLeft | 左边的元素横跨 |
| SpanFromAbove | 上边的元素向下跨越 |
| SpanFromBoth | 左边和上边的元素跨越 |
在 Grid 中代表跨越的符号.
这显示了跨越行，其中跨越部分使用 SpanFromLeft 填充：
Grid[{{"t", SpanFromLeft, SpanFromLeft, SpanFromLeft}, {"a", "b", "c", "d"}}]类似的，列可以用 SpanFromAbove 跨越：
Grid[{{"t", "a"}, {SpanFromAbove, "b"}}]当指定矩形跨越区域， SpanFromBoth 用于每个在跨越元素下面和右边的元素：
Grid[{{"t", SpanFromLeft, "a"}, {SpanFromAbove, SpanFromBoth, "b"}, {"c", "d", "e"}}]
选项
|
缺省值
| |
| Background | None | 使用何种背景颜色 |
| BaselinePosition | Automatic | 如何与周围的文本基线对齐 |
| BaseStyle | {} | 网格基本样式规格 |
| Frame | None | 在哪里画网格框架 |
| FrameStyle | Automatic | 框架样式 |
影响 Grid 作为一个整体的行为的一些选项.
Grid[{{"a", "b"}, {"c", "d"}}, Frame -> True]使用 FrameStyle 改变框架的外观：
Grid[{{"a", "b"}, {"c", "d"}}, Frame -> True, FrameStyle -> {Brown, AbsoluteThickness[5]}]Grid[{{"a", "b"}, {"c", "d"}}, Background -> Pink, Frame -> True]Row[{"A matrix:", Grid[{{1, 2}, {3, 4}}, BaselinePosition -> Top]}]Row[{"A matrix:", Grid[{{1, 2}, {3, 4}}, BaselinePosition -> Bottom]}]设置整个 Grid 基本样式为 Subsection 样式：
Grid[{{"a", "bit"}, {"of", "text"}}, BaseStyle -> {"Subsection"}]Column[{1, 2, 3, 4}, Background -> Pink, Frame -> True]
选项
|
缺省值
| |
| Alignment | {Center,Baseline} | 水平和垂直对齐元素 |
| Dividers | None | 在网格中何处画分割线 |
| ItemSize | Automatic | 每个元素的宽度和高度 |
| ItemStyle | None | 行列的样式 |
| Spacings | {0.8,0.1} | 水平和垂直的间隔 |
影响 Grid 行和列的一些选项.
没有设置 Alignment，元素水平方向按中心对齐，垂直方向按基线对齐：
Grid[{{"ten", 10!}, {"twenty", 20!}}]Grid[{{"ten", 10!}, {"twenty", 20!}}, Alignment -> {Right, Baseline}]Grid[{{"ten", 10!}, {"twenty", 20!}}, Alignment -> {{Left, Right}, Baseline}]Grid[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, Background -> {{Orange, None, Cyan}, {None, Green, None}}]说明 ItemStyle 如何把指定样式的行和列相组合：
Grid[{{1, 2}, {3, 4}}, ItemStyle -> {{Red, Automatic}, {Bold, Italic}}]Grid[{{1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12}}, Dividers -> {{None, {Red}, None}, None}]Grid[{{1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12}}, Dividers -> {{None, {Red, Blue}, None}, None}]ItemSize 和 Spacings 选项的ems的水平测量和行高的垂直测量是基于目前的字体设置. 这两个选项也可以采取Scaled 按比例坐标，坐标指定总的单元宽度或窗口高度的比例. 通过使用关键字 Full，ItemSize 选项也可让您要求尽可能多的空间，使得所有元素都适合给定的行或列.
Grid[{{1, 2}, {3, 4}}, Dividers -> All, ItemSize -> {3, 1}]Style[Grid[{{1, 2}, {3, 4}}, Dividers -> All, ItemSize -> {3, 1}], FontSize -> 18]Grid[{{Button["Left button"], Button["Right button"]}}, ItemSize -> {{{Scaled[0.25]}}, Full}]Spacings 的第一个和最后一个的设置指定顶部和底部空间的一半：
Grid[{{1, 2}, {3, 4}}, Frame -> True, Spacings -> {{1, 0, 1}, {1, 1, 1}}]
选项
|
缺省值
| |
| Alignment | {Center,Baseline} | 水平和垂直对齐项 |
| Background | None | 使用何种背景颜色 |
| BaseStyle | {} | 项的基本样式规格 |
| Frame | None | 何处画边框线 |
| FrameStyle | Automatic | 边框线的样式 |
| ItemSize | Automatic | 每项的宽度和高度 |
Item 的一些选项.
通过使用 Item，适用于整个行和列的许多设置也适用于 Grid 或 Column 中个别的的项. Item 允许您更改一个单项的这些设置. 在 Item 级别上定义的设置总是作为一个整体覆盖 Grid 或 Column 的设置.
Grid[{{1, 2}, {Item[3, Background -> StandardGreen, Frame -> True], 4}}]Column[{1, 2, Item[3, Background -> Pink]}, Background -> StandardBlue]Item 的大多数选项采取与 Grid 同样的设置. 但是，Alignment 和 ItemSize 选项例外，在 Grid 中允许复杂的行和列设置，在 Item 中只采取 {horizontal,vertical} 设置.
Column[{Item["Some aligned text", Frame -> True, ItemSize -> {15, 3}, Alignment -> {Center, Bottom}], "caption"}]ItemSize 选项的宽度值用于确定断行：
Column[{Item[N[Pi, 20], ItemSize -> {10, 2}], "digits of pi"}]ItemSize 指明最小高度为2行，但这里的项更高：
Column[{Item[N[Pi, 50], ItemSize -> {10, 2}], "digits of pi"}]多维数据格式化
TableForm[Array[a, {2, 2}]]TableForm[{Array[a, {2, 2}], Array[b, {2, 2}]}]TableForm[{{Array[a, {2, 2}], Array[b, {2, 2}]}, {Array[c, {2, 2}], Array[d, {2, 2}]}}]一般来说，当您打印一个 
维表，相连的维是以列和行交替给出的. 通过设置选项TableDirections->{dir1,dir2,…}，其中 diri 是 Column 或 Row，您可以明确指定每个维度的方向. 默认情况下，该选项设为 {Column,Row,Column,Row,…}.
维表，相连的维是以列和行交替给出的. 通过设置选项TableDirections->{dir1,dir2,…}，其中 diri 是 Column 或 Row，您可以明确指定每个维度的方向. 默认情况下，该选项设为 {Column,Row,Column,Row,…}. 选项 TableDirections 允许明确指定多维表中每一维的方向：
TableForm[{Array[a, {2, 2}], Array[b, {2, 2}]}, TableDirections -> {Row, Row, Column}]TableForm[{{a, a, a}, {b, b}}]TableForm[{{a, {{p, q}, {r, s}}, a, a}, {{x, y}, b, b}}]TableForm[{{a, {x, y}}, {c, d}}, TableDepth -> 2]
选项名
|
缺省值
| |
| TableDepth | Infinity | 表格中所包含的最大层数 |
| TableDirections | {Column,Row,Column,…} | 每一维是否按行或列排列 |
| TableAlignments | {Left,Bottom,Left,…} | 每一维中如何对齐元素 |
| TableSpacing | {1,3,0,1,0,…} | 在每一维中加多少空格 |
| TableHeadings | {None,None,…} | 怎样标记每一维的元素 |
TableForm 的选项.
使用 TableAlignments 选项，可以指定表中的每个项应该是行对齐或列对齐. 对于列，可以指定 Left、Center 或 Right. 对于行，可以指定 Bottom、Center 或 Top. 如果设置 TableAlignments->Center，所有项水平和垂直方向均会中心对齐. TableAlignments->Automatic 使用对齐的缺省选项.
TableForm[{a, bbbb, cccccccc}]TableForm[{a, bbbb, cccccccc}, TableAlignments -> Center]TableForm[{{a, b}, {ccc, d}}, TableSpacing -> {0, 6}]TableHeadings 选项的设置.
TableForm[Array[a, {2, 2, 2}], TableHeadings -> Automatic]TableForm[{{a, b, c}, {ap, bp, cp}}, TableHeadings -> {Automatic, {"first", "middle", "last"}}]TableForm[{{2, 3, 4}, {5, 6, 1}}, TableHeadings -> {{"row a", "row b", "row c"}, None}]
{x ^ 2, Style[x ^ 2, FontWeight -> "Bold"]}Table[Style["text", FontSize -> s], {s, 10, 20}]Style["some text", FontFamily -> "Helvetica"]Style["text", 20, Italic]
选项
|
典型设置
| |
| FontSize | 12 | 以打印机点数计的字符尺寸 |
| FontWeight | "Plain" or "Bold" | 字符的粗细 |
| FontSlant | "Plain" or "Italic" | 字符是否为斜体 |
| FontFamily | "Courier"
,
"Times"
,
"Helvetica" | 字体类 |
| FontColor | GrayLevel[0] | 字符颜色 |
| Background | GrayLevel[1] | 字符的背景色 |
可用于 Style 的一些选项.
如果使用的是 Wolfram 语言的笔记本前端，则生成的每一段输出将默认采用该输出所在单元的样式. 而使用Style[expr,"style"] 可以令 Wolfram 语言用不同的样式输出一个特定的表达式.
Style[x ^ 2 + y ^ 2, "Section"]ToBoxes[a + b]DisplayForm 表明这些框符是如何显示的：
DisplayForm[%]| DisplayForm[boxes] | 表明 boxes 被显示的格式 |
RowBox[{"a", "+", "b"}]//DisplayFormSubscriptBox["a", "i"]//DisplayFormRowBox[{SubscriptBox["a", "1"], SubscriptBox["b", "2"]}]//DisplayForm| "text" | 原样的文本 | |||||||||
| RowBox[{a,b,…}] | 一行框符或字符串 a,b,… | |||||||||
| GridBox[{{a1,b1,…},{a2,b2,…},…}] | ||||||||||
一个框符网
| ||||||||||
| SubscriptBox[a,b] | 下标 ab | |||||||||
| SuperscriptBox[a,b] | 上标 ab | |||||||||
| SubsuperscriptBox[a,b,c] | 上下标  | |||||||||
| UnderscriptBox[a,b] | 底标  | |||||||||
| OverscriptBox[a,b] | 顶标  | |||||||||
| UnderoverscriptBox[a,b,c] | 顶底标  | |||||||||
| FractionBox[a,b] | 分式  | |||||||||
| SqrtBox[a] | 平方根  | |||||||||
| RadicalBox[a,b] | b 次方根  | |||||||||
RadicalBox[FractionBox[x, y], n]//DisplayFormSuperscriptBox[SubscriptBox[a, b], c]//DisplayFormSubsuperscriptBox[a, b, c]//DisplayForm| FrameBox[box] | 在 box 的周围加边框 |
| GridBox[list,RowLines->True] | 在 GridBox 内的行间加线条 |
| GridBox[list,ColumnLines->True] | 在列间加线条 |
| GridBox[list,RowLines->{True,False}] | |
仅在第一行下面加线条 | |
FrameBox[FractionBox["x", "y"]]//DisplayFormGridBox[Table[i + j, {i, 3}, {j, 3}], RowLines -> True, ColumnLines -> True]//DisplayFormFrameBox[%]//DisplayFormStyleBox["name", FontSlant -> "Italic"]//DisplayFormStyleBox["name", "Section"]//DisplayFormStyleBox["name", "Section", FontColor -> GrayLevel[0.5]]//DisplayForm如果使用的是 Wolfram 语言的笔记本前端，则可以用菜单项直接改变屏幕上显示的样式和外观，但这些改变在内部仍将通过插入适当的 StyleBox 对象而记录下来.
| FormBox[boxes,form] | 用与指定格式有关的规则解释 boxes |
| InterpretationBox[boxes,expr] | 将 boxes 当作表达式 expr 的表示形式 |
| TagBox[boxes,tag] | 用 tag 引导 boxes 的解释 |
| ErrorBox[boxes] | 指出错误并不再对 boxes 进行解释 |
SuperscriptBox["x", "2"]//DisplayFormToExpression[%]//InputFormInterpretationBox[SuperscriptBox["x", "2"], vec[x, 2]]//DisplayFormToExpression[%]//InputForm在编辑 InterpretationBox 中给出的框符时，无法保证解释框符给出的解释仍是正确的. 于是，Wolfram 语言就提供了许多选项使用户对 InterpretationBox 对象的选择和编辑进行控制.
选项
|
默认值
| |
| Editable | Automatic | 是否允许对内容进行编辑 |
| Selectable | True | 是否允许对内容进行选择 |
| Deletable | True | 是否允许对框符进行删除 |
| DeletionWarning | False | 是否在框符被删除时发出警告 |
| BoxAutoDelete | False | 当内容修改后是否除去这个框符 |
| StripWrapperBoxes | False |
InterpretationBox 和相关框符的选项.
TagBox 对象用于存储不显示的信息，这些信息被解释框符的规则使用. 一般情况下，TagBox[boxes,tag] 中的 tag 是一个符号，给出对应于 boxes 的表达式的头部. 如果仅编辑这个表达式中的变量，由 TagBox 指定的解释很可能是适当的. 因此，Editable->True 是 TagBox 的默认设置.
Wolfram 语言用于解释框符的规则一般不考察 StyleBox 等对象定义的格式细节. 这样在不使用 StripWrapperBoxes->False 时，红色的 x 与普通的黑色 x 没有区别.
ToExpression[StyleBox[x, FontColor -> RGBColor[1, 0, 0]]] == x创建一个 SuperscriptBox:
\(x\^2\)ToExpression[%]//FullForm对应于一个原始 SuperscriptBox：
\(x\^2\)对应于 SuperscriptBox 代表的幂指数：
\!\(x\^2\)FullForm[\!\(x\^2\)]如果将一个 StandardForm 单元的内容复制到另一个如文本编辑器的程序中，Wolfram 系统将在必要时生成一个 ∖!∖(…∖) 形式. 这样做是为了当讲这个格式的内容重新复制回 Wolfram 系统中时，该 StandardForm 单元的原始内容会自动再次生成. 如果没有 ∖!，则仅得到对应于这些内容的原始框符.
Wolfram 语言通常将出现在字符串内的 ∖(…∖) 格式与其他的一系列字符一样对待. 通过插入 ∖! 可以令 Wolfram 语言将这个格式视作所代表的框符. 通过这种方式可以在普通字符串内嵌入框符结构.
"\( x \^ 2 \)"2
x2 3
box 1: x ; box 2: y| ∖(box1,box2,…∖) | RowBox[box1,box2,…] |
| box1∖^box2 | SuperscriptBox[box1,box2] |
| box1∖_box2 | SubscriptBox[box1,box2] |
| box1∖_box2∖%box3 | SubsuperscriptBox[box1,box2,box3] |
| box1∖&box2 | OverscriptBox[box1,box2] |
| box1∖+box2 | UnderscriptBox[box1,box2] |
| box1∖+box2∖%box3 | UnderoverscriptBox[box1,box2,box3] |
| box1∖/box2 | FractionBox[box1,box2] |
| ∖@box | SqrtBox[box] |
| \@box1\%box2 | RadicalBox[box1,box2] |
| form∖` box | FormBox[box,form] |
| \*input | 构建来自 input 的框符 |
\(x\/(y + z)\)//DisplayForm\(x\/y + z\)//DisplayForm\(x\/\(y + z\)\)//DisplayForm\(x\/\(y + z\)\)当用户在 Wolfram 语言中敲入 aa+bb 作为输入时，首先发生的是，aa、+ 和 bb 被当作一个个单独的项. 当由包括在 ∖(…∖) 内的输入构建框件时，也同样如此. 而在框件内部，每一项是以一个字符串的形式给出，而非其原始格式.
\(aa + bb\)//FullForm\(aa + bb\)//FullForm形成两个嵌套的 RowBox 对象：
\(aa + bb / cc\)//FullForm\(aa + bb / \)//FullForm构建一个 GridBox:
\(\*GridBox[{{"a", "b"}, {"c", "d"}}]\)//DisplayForm构建一个 StyleBox:
\(\*StyleBox["text", FontWeight -> "Bold"]\)//DisplayForm\(x + \*GridBox[{{"a", "b"}, {\(c\^2\), \(d\/\*GridBox[{{"x", "y"}, {"x", "y"}}]\)}}]\)//DisplayForm\!\(c(1 + x)\)反斜杠反引号序列令 Wolfram 语言将其在 TraditionalForm 中被解释：
\!\(TraditionalForm\`c(1 + x)\)当用户将一个笔记本中的单元内容复制到文本编辑器等程序中时，通常不包括显式的反斜杠反引号序列. 但如果用户希望将所得到的重新复制到一个不同类型的单元中时，则需包括反斜杠反引号序列以确保所有的解释均正确.
| ToString[expr,form] | 创建一个字符串，表示 expr 的指定文本形式 |
| ToBoxes[expr,form] | 创建一个框符，表示 expr 的指定文本形式 |
| ToExpression[input,form] | 通过将一个字符串或框件解释为指定文本形式的输入创建一个表达式 |
| ToString[expr] | 使用 OutputForm 创建一个字符串 |
| ToBoxes[expr] | 使用 StandardForm 创建一个框符 |
| ToExpression[input] | 使用 StandardForm 创建一个表达式 |
x ^ 2 + y ^ 2以字符串形式给出表达式的 InputForm：
ToString[x ^ 2 + y ^ 2, InputForm]在 FullForm 中，字符串两边显示引号：
FullForm[%]给出对应于表达式的 StandardForm 框符的字符串表示：
ToString[x ^ 2 + y ^ 2, StandardForm]//FullFormToBoxes 生成自身的框符：
ToBoxes[x ^ 2 + y ^ 2, StandardForm]为文件和外部程序生成数据时，有时需要仅用普通键盘字符产生二维形式. 这可以通过使用 OutputForm 实现.
ToString[x ^ 2 + y ^ 2, OutputForm]FullForm[%]Style[%, FontFamily -> "Times"]如果仅对一维结构进行操作，可以通过 ToString 利用格式函数进行字符串操作.
ToString[StringForm["``^10 = ``", 4, 4 ^ 10]]//InputForm| InputForm | 对应于键盘输入的字符串 |
| StandardForm | 对应于标准二维输入的字符串或框符（默认） |
| TraditionalForm | 与传统数学记号相似的字符串或框符 |
由 ToExpression 处理的一些形式.
从 InputForm 字符串创建一个表达式：
ToExpression["x^2 + y^2"]从 StandardForm 框符创建同一表达式：
ToExpression[RowBox[{SuperscriptBox["x", "2"], "+", SuperscriptBox["y", "2"]}]]按 TraditionalForm，这些被解释为函数：
ToExpression["c(1 + x) + log(x)", TraditionalForm]| ToExpression[input,form,h] | 创建一个表达式，然后由头部 h 封装 |
ToExpression["1 + 1"]ToExpression["1 + 1", StandardForm, Hold]ReleaseHold[%]| SyntaxQ["string"] | 确定一个字符串是否是语法正确的 Wolfram 语言输入 |
| SyntaxLength["string"] | 测试从字符串开始多长的字符序列在语法上是正确的 |
这不是一个语法正确的输入，因此 ToExpression 不将其转换成一个表达式：
ToExpression["1 +/+ 2"]
ToExpression 要求字符串对应于一个完整的 Wolfram 语言表达式：
ToExpression["1 + 2 + "]
可使用函数 SyntaxQ 测试一个特定的字符串是否对应于语法正确的 Wolfram 语言输入. 如果 SyntaxQ 返回 False，可使用 SyntaxLength 找到错误发生的位置. SyntaxLength 的返回值是语法错误发生之前成功运行的字符数.
SyntaxQ 表明字符串不对应于语法正确的 Wolfram 语言输入：
SyntaxQ["1 +/+ 2"]SyntaxLength 表明错误发生在字符串的第三个字符后：
SyntaxLength["1 +/+ 2"]SyntaxLength 返回一个大于字符串长度的值，表明到目前为止输入正确，但需要继续：
SyntaxLength["1 + 2 + "]Wolfram 语言用各种语法规则去解释输入，将字符串或框符转化为表达式. 由 StandardForm 和 InputForm 使用的规则定义了基本的 Wolfram 语言. 由 TraditionalForm 等其他形式使用的规则遵循了同样的原则，但细节上有许多区别.
prefix | !x | Not[x] |
postfix | x! | Factorial[x] |
infix | x+y+z | Plus[x,y,z] |
matchfix | {x,y,z} | List[x,y,z] |
compound | x/:y=z | TagSet[x,y,z] |
overfix |  | OverHat[x] |
{FullForm[a * b + c], FullForm[a + b * c]}a * b + c//ff@a * b + cFullForm[a * (b + c)]符号名的扩展 | x_
,
#2
,
e::s
, 等等.
|
函数应用变量 | e[e]
,
e@@e
, 等等.
|
与幂相关的运算 | √e
,
e^e
, 等等.
|
与乘法相关的运算
| ∇e
,
e/e
,
e⊗e
,
ee
, 等等.
|
与加法相关的运算 | e⊕e
,
e+e
,
e⋃e
, 等等.
|
关系型运算符 | e==e
,
e∼e
,
e⪡e
,
e⧏e
,
e∈e
, 等等.
|
箭头及向量运算 | e⟶e
,
e↗e
,
e⇌e
,
e⥓e
, 等等.
|
逻辑运算符 | ∀ee
,
e&&e
,
e∨e
,
e⊢e
, 等等.
|
模式和规则运算符 | e..
,
ee
,
e->e
,
e/.e
, 等等.
|
纯函数运算符 | e& |
赋值运算符 | e=e
,
e:=e
, 等等.
|
复合表达式 | e;e |
在 "运算符的输入形式" 一节的表按优先级别次序，给出了 Wolfram 语言中全部的运算符的列表. 如 * 和 + 的情形相同，大部分次序是由标准数学用法决定的. 一般，设定的次序使在典型的输入块中能尽量少用括号.
Subscript[∀, x]Subscript[∃, y]x⊗y≻y∧m ≠ 0n⧐̸mFullForm 显示了所构造表达式的结构：
FullForm[%]{x -> # ^ 2&, (x -> # ^ 2)&, x -> (# ^ 2&)}FullForm[a + b + c + d]FullForm[a ^ b ^ c ^ d]
a ⊕ b ⊕ c//FullForm
a × a × a × b × b × c∫ k[x] ⅆx//FullForm∫ a[x] b[x] ⅆx + c[x]∫ (a[x] + b[x]) ⅆx + c[x]x^a + bSubscript[∂, x]x^n
Underoverscript[∑, n = 1, ∞](1/n^s)
Underoverscript[∑, n = 1, ∞](1/n^s) + n
2⊕3//FullForm
2⊕3
x_ ⊕ y_ := Mod[x + y, 2]
2 ⊕ 3| x⊕y | CirclePlus[x,y] |
| x≈y | TildeTilde[x,y] |
| x∴y | Therefore[x,y] |
| x↔y | LeftRightArrow[x,y] |
| ∇x | Del[x] |
| x | Square[x] |
| 〈x,y,…〉 | AngleBracket[x,y,…] |
x ≡ y对应于函数 Congruent:
FullForm[%]应该认识到，即使函数 CirclePlus 和 CircleTimes 没有给定的内部运算规则，运算符 
和 
仍具有内部设定的优先级别. "运算符的输入形式" 一节中按照优先次序列出了能被 Wolfram 语言识别的全部运算符.
和 仍具有内部设定的优先级别. "运算符的输入形式" 一节中按照优先次序列出了能被 Wolfram 语言识别的全部运算符. 
Clear[CirclePlus, CircleTimes];
x ⊗ y ⊕ z//FullForm| xy | Subscript[x,y] |
| x+ | SubPlus[x] |
| x- | SubMinus[x] |
| x* | SubStar[x] |
| x+ | SuperPlus[x] |
| x- | SuperMinus[x] |
| x* | SuperStar[x] |
| x† | SuperDagger[x] |
 | Overscript[x,y] |
 | Underscript[x,y] |
 | OverBar[x] |
 | OverVector[x] |
 | OverTilde[x] |
 | OverHat[x] |
 | OverDot[x] |
 | UnderBar[x] |
Subscript[x, 2] + Subscript[y, 2]//InputFormx^2 + y^2//InputFormx^† + y^ + //InputFormOverscript[x, _] + Overscript[y, ^ ]//InputForm正如 Wolfram 语言允许用户对表达式如何计算进行定义一样，用户也可以定义表达式按何种格式输出. 其基本思想是在无论何时对给定表达式进行格式输出，Wolfram 语言首先调用函数 Format[expr] 找出是否已经定义了该表达式输出格式的特殊规则. 通过给 Format[expr] 赋值，可以令 Wolfram 语言按一定的方式输出某种类型的表达式.
Format[bin[x_, y_]] := MatrixForm[{{x}, {y}}]bin[i + j, k]FullForm[%]通过 Format 的定义可以令 Wolfram 语言将一个特定表达式的格式与另一个表达式相同t. 也可以令 Wolfram 语言运行一个程序去确定怎样格式化一个表达式.
Format[xrep[n_]] := StringJoin[Table["x", {n}]]xrep[1] + xrep[4] + xrep[9]% /. xrep[n_] -> x ^ n| Prefix[f[x],h] | 前缀形式 h x |
| Postfix[f[x],h] | 后缀形式 x h |
| Infix[f[x,y,…],h] | 中缀形式 x h y h… |
| Prefix[f[x]] | 标准前缀形式 f@x |
| Postfix[f[x]] | 标准后缀形式 x//f |
| Infix[f[x,y,…]] | 标准中缀形式 x~f~y~f~… |
| PrecedenceForm[expr,n] | 加括号具有 n 级优先权的对象 |
Prefix[f[x], "<>"]s = Infix[{a, b, c}, "≺≻"]s + 2当输出涉及到运算符时，就需要考虑到是否要对一些变量加括号，正如"表达式输入的特殊方式" 一节中所讨论的，这取决于运算符的 “优先级”. 在对涉及到运算符的输出形式进行设置时，可使用 PrecedenceForm 来定义运算符的优先级. Wolfram 语言用1到1000的整数来表示运算符的 “优先级别”，优先级别越高，越不需要加括号.
PrecedenceForm[s, 100] ^ 2Format[x, TeXForm] := "{\\bf x}"TeXForm[1 + x ^ 2]| MakeBoxes[expr,form] | 按指定格式构造代表 expr 的框符 |
| MakeExpression[boxes,form] | 构造与 boxes 对应的表达式 |
MakeBoxes 在不计算输入的情况下生成框符：
MakeBoxes[2 + 2, StandardForm]MakeExpression[%, StandardForm]Wolfram 语言中有许多规则产生输出和解释输入. 尤其是在 StandardForm 中，这些规则被精心设计成一致的，允许输入和输出交换使用.
CirclePlus[u, v, w]
u ⊕ v ⊕ w//FullForm通过定义 Format[expr] 可以改变某一特定表达式的输出格式. 但要认识到一旦这样做，无法保证所定义的表达式的输出形式在作为 Wolfram 语言的输入时被正确解释.
需要时可以在 Wolfram 语言中重新定义用于表达式的输入和输出的基本规则，这可以通过定义 MakeBoxes 和 MakeExpression 来实现. 但一定要非常仔细地给出这类定义，否则可能出现不一致的结果.
gplus/:MakeBoxes[gplus[x_, y_, n_], StandardForm] := RowBox[{MakeBoxes[x, StandardForm], SubscriptBox["⊕", MakeBoxes[n, StandardForm]], MakeBoxes[y, StandardForm]}]
gplus[a, b, m + n]aSubscript[⊕, m + n]b
MakeExpression[RowBox[{x_, SubscriptBox["⊕", n_], y_}], StandardForm] := MakeExpression[RowBox[{"gplus", "[", x, ",", y, ",", n, "]"}], StandardForm]
aSubscript[⊕, m + n]b//FullForm另外，对于 Format 产生的任何结果进行格式化时， Format 被自动再次调用，而 MakeBoxes 不是这样. 这意味着定义了 MakeBoxes 后，对子表达式格式化必须重新明确调用 MakeBoxes.
■ 将输入分解为记号. |
■ 去掉空格字符. |
■ 使用内部的优先级构造框符. |
■ 去掉 StyleBox 和其他不需要被解释的框符. |
■ 执行为 MakeExpression 定义的规则. |
在 "文本输入和输出" 一节中所介绍的函数决定了表达式被显示时的格式，但这些函数并不能实际上生成任何要显示的内容.
在 Wolfram 语言最常见的使用方式中不需要用指令生成输出. Wolfram 语言通常会自动显示对给定输入处理后的最终结果. 但有时需要显示运算的中间过程，这可以使用函数 Print 实现.
| Print[expr1,expr2,…] | 显示表达式 expri，中间无空格，但结尾换行 |
Print 显示其变量，中间无空格，但结尾换行：
Print[a, b];Print[c]
Do[Print[i, " ", i ^ 2], {i, 5}]
Print[Grid[{{1, 2}, {3, 4}}]]
使用 StringForm 指定输出格式：
Print[StringForm["x = ``, y = ``", a ^ 2, b ^ 2]]
Print 也允许文本和图形混合：
Print["A sine wave:", Plot[Sin[x], {x, 0, 2π}]]
由 Print 生成的输出通常是标准 Wolfram 语言输出格式，但通过显示指定也可以使用其他输出格式.
Print[InputForm[a ^ 2 + b ^ 2]]
应该认识到 Print 仅是 Wolfram 语言中生成输出的几种途径之一. 另一种途径是在 "消息" 一节中介绍的 Message 函数，其用于生成命名信息. 在 "流和底层的输入输出" 一节中还介绍了一些底层函数，可以用来生成各种格式的输出，这些输出既作为交互进程的一部分，又用于文件和外部程序.
自从版本3以来，Wolfram 语言提供了对任意数学排版和布局的有力支持. 这一切基于所谓的框符语言（box language），其允许笔记本自身作为 Wolfram 语言的表达式. 这种方法被证明是非常强大的，并已形成 Wolfram 语言中许多独特功能的基础. 但尽管这种框符语言非常强大，在实际操作时却很难被用户直接使用.
自从版本6开始，出现了这种框符语言的高层界面，这免去了直接使用框符的苦恼，却仍保持了同样的排版和布局的强大功能. 这个新层的函数被称为框符生成器，但用户不必意识到框符语言就能够有效使用这些函数. 在本节教程中，我们首先了解一下与显示大量表达式相关的框符生成器，然后再介绍几种超出了简单数学排版的方式，这些方式能用于生成漂亮的格式化输出.
样式化输出(Styling Output)
Wolfram 系统前端支持文字处理器中出现的所有惯用样式机制，例如包括变换字体特征的菜单. 然而，在生成的结果中自动访问这些样式机制曾经非常困难. 输出继续采用纯12号 Courier 字体（或使用 TraditionalForm 时为 Times 字体）. 为了解决这个问题，创建了函数 Style. 无论何时对一个 Style 表达式进行计算，其输出结果将以给定的样式特征显示 .
Table[If[PrimeQ[i], Style[i, Bold], Style[i, Gray]], {i, 1, 100}]
菜单
| Style[] 选项 | Style[] 指令 |
| 格式 ▶ 尺寸 ▶ 14 | FontSize->14 | 14 |
| 格式 ▶ 字体颜色 ▶ 灰色 | FontColor->Gray | Gray |
| 格式 ▶ 字体效果 ▶ 粗体 | FontWeight->Bold | Bold |
| 格式 ▶ 字体效果 ▶ 斜体 | FontSlant->Italic | Italic |
| 格式 ▶ 背景颜色 ▶ 黄色 | Background->Yellow | |
| 格式 ▶ 字体 | FontFamily->"Times" | |
| 格式 ▶ 样式 ▶ Subsection | "Subsection" |
Style[%, FontFamily -> "Helvetica"]要求一段输出的样式与文本一样也是很常见的. 将代码所用的字体用于文本可能会看上去非常奇怪. 为此，有一个函数 Text 能够使其参数将永远在文本字体中呈现.（熟悉 Wolfram 语言数学图形的用户将把 Text 函数识别为一个图形基元，但那种用法并不会与这种用法冲突.）
Text[%%]网格布局（Grid Layout）
二维布局结构的使用可以如对这些结构应用样式指令一样有用. 在 Wolfram 语言中，这种布局的基本函数是 Grid. Grid 的布局功能很灵活，能够任意调整对齐方式，框架元素（frame elements），以及跨度元素（spanning element）等. （其他教程更深入地介绍了 Grid 的功能，这里仅介绍讨论其重点部分.）
再次观察将质数和合数进行不同显示的 Style 例子.
ptable = Table[If[PrimeQ[i], Style[i, Bold], Style[i, Gray]], {i, 1, 100}];要将此放入一个 Grid 中，首先使用 Partition 将这个含有100个元素的列表转换成一个10×10数组. 尽管可以给 Grid 一个参差不齐的的阵列（列表中的元素为长度不一的列表），在这个例子中我们给 Grid 一个常规数组，且所得到的显示结果经过了漂亮的格式化布局.
Grid[Partition[ptable, 10]]注意到各列按中心对齐，且无框架线，使用 Grid 的选项可以很容易的改变这两项的设置.
Grid[Partition[ptable, 10], Alignment -> Right, Frame -> True, Background -> StandardBlue]Column[Options[Column]]Grid[{Range[15]!}]但注意到在这个例子中，整个网格收缩，以便其与现有窗口的宽度适合. 因此网格中有的元素自身能够进行多行换行. 这是由于 Grid 的默认 ItemSize 选项. 如果想要允许一个网格的元素具有自然宽度，要将 ItemSize 设置为 Full.
Grid[{Range[15]!}, ItemSize -> Full]当然，这时整个网格过宽而不能在一行中被容纳（除非将这个窗口设置的很宽），因此网格中有的元素无法被看到. 这把我们带到另一种横向布局函数：Row.
Row[Range[15]!]默认时 Row 不在元素间留空格. 但若给出第二个参数，则表达式将被插入元素之间. 可以使用任何形式的表达式，此处用的是一个逗号.
Row[Range[15]!, ","]将输出用作输入
这是一个很好的机会来指出 Style、Grid 及其他框符生成器在输出中是持久的. 如果所取的一段输出中的某些格式是由 Style 或者 Grid 创建并作为输入被再次使用，则 Style 或 Grid 表达式将在输入表达式中出现. 对 StyleBox 的旧用法甚至是对 MatrixForm 函数熟悉的用户将会发现这一改变.
将这个具有许多嵌入样式的 Grid 命令的输出用作某个输入表达式.
Grid[Partition[Take[ptable, 16], 4], Alignment -> Right, Frame -> True, Background -> StandardBlue](| | | | |
| -----: | ----: | -----: | -: |
| 1 | **2** | **3** | 4 |
| **5** | 6 | **7** | 8 |
| 9 | 10 | **11** | 12 |
| **13** | 14 | 15 | 16 | + 5)^3//Expand请注意这仍然是一个网格，仍是蓝色的，其元素仍然像以前一样为粗体或灰色. 还要注意，表达式中有 Grid 和 Style 起到了干预效果，否则会给一个矩阵添加一个标量，并将结果进行乘幂. 这种区分是非常重要的，因为往往希望不要将这些复合结构以某种方式自动解释. 但是若想摆脱这些封装并获得你的数据，这也是很容易做到的.
% //. {Grid[a_, ___] :> a, Style[a_, ___] :> a}特殊网格条目（Special Grid Entries）
为了让二维布局更灵活，Grid 接受 SpanFromLeft 等一些特殊符号作为条目. 条目 SpanFromLeft 表明，紧靠左边的网格条目既占用自己的空间也占用跨越字符的空间. 类似的还有 SpanFromAbove 和 SpanFromBoth. 详细信息请参见 "Mathematica 中的网格、行和列" 一节.
Grid[{
{1, 2, 3, 4, 5},
{6, 7, SpanFromLeft, SpanFromLeft, 10},
{11, SpanFromAbove, SpanFromBoth, SpanFromBoth, 15},
{16, 17, 18, 19, 20}}, Frame -> All]这种方法可以用来创建复杂的跨度设置. 用键盘进行下列输入需要很长的时间. 幸运的是，您可以在 插入 ▶ 表格/矩阵 子菜单中使用 合并 和 分开 交互地创建此表. 如果想看看进行下述输入时会牵连到什么，则需要计算该单元，其将展示您应如何进行键盘输入.
| | | | | | | | | | |
| -- | -- | -- | -- | -- | -- | -- | - | - | -- |
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| 11 | 12 | 13 | | 15 | 16 | | | | |
| 21 | 22 | | | 25 | | | | | |
| 31 | 32 | 33 | 34 | 35 | | | | | |
| 41 | | | | | | | | | |
| 51 | 52 | 53 | 54 | 55 | | | | | |
| 61 | 62 | 63 | | | | | | | |
| 71 | 72 | | | | 76 | 77 | | | |
| 81 | 82 | | | | 86 | | | | |
| 91 | 92 | | | | 96 | | | | |//InputForm我们已经看到了如何作为一个整体或针对个别列或行，在网格中进行对齐方式和背景的设置. 我们还没有看到的是如何针对单个元素对设置进行覆盖. 假设您希望您的整个网格中除一些特殊元素外都有相同的背景，一个方便的方法将每一个这种元素封装在 Item 中，然后指定 Item 的选项，覆盖 Grid 中相应的选项.
Grid[Partition[Table[If[PrimeQ[i], Item[i, Background -> StandardGray], i], {i, 1, 100}], 10], Background -> StandardBlue]也可以通过 Style 来覆盖该选项，但 Item 的目的是使覆盖的方式知道Grid 的二维布局. 注意到在前面的输出中，一旦两个黄色单元彼此相邻，则两者之间没有蓝色空格，这只能通过 Item 实现.
不仅仅是 Background，对于 Item 的所有选项均是如此. 现在来看 Frame 选项，如果只想在某些特定元素周围加框架，而其他部位不加，您很可能认为必须在这些元素自己的 Grid 中进行 Frame->True 的设置来完成.（在 "框架和标签" 中我们将学习一种更简单的方法来给任意一个表达式加框架.）
Grid[Partition[Table[If[PrimeQ[i], Grid[{{i}}, Frame -> True], i], {i, 1, 100}], 10]]但请注意相邻框架元素不分享其边界. 相比之下，使用 Item，有足够的信息画出不必要的框架元素. 注意现在2和11的框架交于一点，以及2和3的框架如何共享一个像素的线，而这又完全与13和23的左边框对齐. 这就是 Item 的强大功能.
Grid[Partition[Table[If[PrimeQ[i], Item[i, Frame -> True], i], {i, 1, 100}], 10]]框架和标签
一个表达式添加框架或标签可以通过 Grid 完成，但这些操作在概念上比一般的二维布局简单得多，所以有相应更简单的方法来达到这个目的. 例如 Framed 是一个简单的函数，用于在任意表达式周围绘制一个框架，这样做可以将注意力吸引到表达式的各个部分.
Table[If[PrimeQ[i], Framed[i, Background -> StandardGray], i], {i, 1, 100}]Labeled[
Grid[Partition[ptable, 10], Alignment -> Right, Frame -> True],
Text[Row[{Style["• Prime", Bold], Style["• Composite", Gray]}, Spacer[15]]]]Panel[%]注意 Panel 对于字体类和字体尺寸也有自己的定义，因此 Grid 的内容改变字体类和尺寸，Text 也改变字体尺寸. （尽管如此 Text 关于字体类有自己的定义，且保持 Wolfram 系统中的文本字体.） 在关于 BaseStyle 选项的小节中，我们将对此进行较深入地探讨.
Panel[ptable, "Primes and Composites"]Panel[ptable, {"Primes and Composites"}, {{Bottom, Right}}]其他注释
到目前为止所提到的注释都有一个非常明确的可视组件. 还有一些注释在用户需要之前实际上是不可见的. 例如 Tooltip 不改变其第一个参数的显示，只有将鼠标指针在显示部分移动时，第二个参数才作为一个提示条（tooltips）出现.
Table[Tooltip[i, Divisors[i]], {i, 1, 100}]Mouseover 也属于这类函数，但不是在提示中显示结果，其使用的屏幕区域与后来鼠标指针在上移动的区域相同. 如果这两个显示的大小不同，那么效果会不和谐，因此使用大小相近的显示，或者使用 Mouseover 中的 ImageSize 选项给两个中较大的显示留出空间，无论正在显示哪一个.
Table[Mouseover[i, Framed[Divisors[i], Background -> LightYellow]], {i, 1, 100}]与 Tooltip 类似的是 StatusArea 和 PopupWindow. StatusArea 在笔记本的状态区域（status area）显示额外信息，该区域通常在左下角，而 PopupWindow 将在点击时将额外信息显示在一个新窗口中.
Table[StatusArea[i, Divisors[i]], {i, 1, 100}]Table[PopupWindow[i, Divisors[i]], {i, 1, 100}]Table[Annotation[i, Divisors[i], "Mouse"], {i, 1, 100}]
Dynamic[MouseAnnotation[]]请注意所有这些注释在图形中也同样适用. 因此可以提供提示条（tooltips）或鼠标悬停（mouseovers）协助用户了解所创建的复杂图形. ListPlot 或者 DensityPlot 这样的可视化函数也支持 Tooltip. 详细情况请参见参考资料.
Graphics[{LightBlue, EdgeForm[Gray], Tooltip[CountryData[#, "SchematicPolygon"], #]& /@ CountryData[]}, ImageSize -> Full]默认样式
正如在 "框架和标签" 中所看到的，对 Panel 等的创建实际上类似于 Style，因为其设置了一个能使一组默认样式应用于其内容的环境. 这可以通过明确的 Style 命令进行覆盖，也可以被 Panel 自身通过 BaseStyle 选项覆盖. BaseStyle 可以被设置为一种样式，或者是一列样式指令，正如在 Style 中的用法一样，并且这些指令成为该 Panel 范围内的默认环境.
Panel[Range[10]]Panel[Range[10], BaseStyle -> {"StandardForm"}]事实上，几乎所用的框符生成器都有一个 BaseStyle 选项. 例如这里是一个默认字体颜色为蓝色的网格，注意灰色的元素保持灰色，因为内部的 Style 封装胜过外围 Grid 的 BaseStyle. （这是选项可继承性的主要特征之一，其超出了本文的讨论范围.）
Grid[Partition[ptable, 10], BaseStyle -> {FontColor -> Blue}]默认选项
假设您有一个表达式，多次出现同一框符生成器，如一个 Framed 或 Panel，您想将其全部改变，使之含有相同的选项集合. 在函数每一次出现时都添加相同的选项集可能会非常繁琐， 幸好这里有一个更简单的方法.
DefaultOptions 是 Style 的一个选项，当被设置成形如 head->{opt->val,…} 的一列元素时，该选项会用所给选项设置一个环境，作为给定框符生成头部的默认环境. 在整个 Style 的封装内这些选项都是激活状态，但只针对于相关联的框符发生器.
假设有一个表达式含有某些 Framed 项，你希望所有这些项都用相同背景和框架样式画出.
Table[If[PrimeQ[i], Framed[i], i], {i, 1, 100}]biglist = {1, Framed[2], Framed[3], 4, Framed[5], 6, Framed[7], 8, 9, 10, Framed[11], 12, Framed[13], 14, 15, 16, Framed[17], 18, Framed[19], 20, 21, 22, Framed[23], 24, 25, 26, 27, 28, Framed[29], 30, Framed[31], 32, 33, 34, 35, 36, Framed[37], 38, 39, 40, Framed[41], 42, Framed[43], 44, 45, 46, Framed[47], 48, 49, 50, 51, 52, Framed[53], 54, 55, 56, 57, 58, Framed[59], 60, Framed[61], 62, 63, 64, 65, 66, Framed[67], 68, 69, 70, Framed[71], 72, Framed[73], 74, 75, 76, 77, 78, Framed[79], 80, 81, 82, Framed[83], 84, 85, 86, 87, 88, Framed[89], 90, 91, 92, 93, 94, 95, 96, Framed[97], 98, 99, 100}现在在每一个 Framed 的封装内插入 Background 和 FrameStyle 选项会非常耗时，尽管一定能做到（或者通过写一段程序来为您完成）. 而使用 DefaultOptions，可以有效的设置一个环境，使得所有的 Framed 封装都使用对 Background 和 FrameStyle 的设置.
Style[biglist, DefaultOptions -> {Framed -> {Background -> StandardGray, FrameStyle -> Blue}}]数学排版
{Subscript[a, b], Superscript[a, b], Underscript[a, b], Overscript[a, b], Subsuperscript[a, b, c], Underoverscript[a, b, c]}我们将不对此进行详细，但会指出这些结构在内核中没有任何内置的数学意义. 例如，Superscript[a,b] 不会被解释为 Power[a,b]，尽管两者的显示相同. 因此可以在格式化输出时将这些作为结构元素使用，而不必担心其意义会影响显示.
Table[Row[{i, Row[Superscript @@@ FactorInteger[i], "×"]}, "=="], {i, 100}]使用框符语言（Box Language）
最后一点说明是，对于已经很熟悉框符语言的用户可能偶尔会发现，这些框符生成器在构建的底层框符时会产生阻碍，将其显示插入到一段输出中. 这可以适用于任何一个分层技术，在抽象层将试图隐藏其所在层. 然而，通过一个简单的漏洞，可以将您恰好知道是有效的框符直接显示在输出中：RawBoxes.
{a, b, RawBoxes[SubscriptBox["c", "d"]], e}正如和其他所有漏洞一样，RawBoxes 给了更高的灵活性，但也可以让您搬起石头砸自己的脚，请小心使用. 如果还不熟悉框符语言，也许不应该使用.
基本结构
这些结构可以分为三类：显示在笔记本中的排版结构，产生内容排列在网格上的图形函数，在网格内可以调整格式细节的结构.
Grid、Column 和 Row 形成第一系列，在本教程中是指网格系列. 其界定特点是 Wolfram 语言排版系统紧密集成的一部分. 这意味着任何可以作为内容出现的表达式和结构其本身可以响应诸如窗口宽度，甚至元素大小的变化. 与其他排版结构相同，网格系列的成员是惰性结构，不会计算成其他形式.
Labeled[Grid[{Text@Style[#, "TableHeader"]& /@ {"网格", "列", "行"}, {Grid[Partition[CharacterRange["a", "z"], 6]], Column[{"a", "b", "c", "d"}], Row[CharacterRange["a", "z"]]}}, Alignment -> {Center, {Bottom, Top}}, Frame -> All, ItemSize -> {{10, 10, 10}}, Spacings -> {0, 1}], Text@Style["具有格式化结构的网格系列的例子.", "Text"], {{Bottom, Left}}]当处理图形时，结构的并行设置——图形网格系列支持特别有用的功能. 这些结构是 GraphicsGrid、GraphicsColumn 和 GraphicsRow. 虽然图形可以在网格系列中使用，但是图形网格系列支持的大小和编辑行为更适合图形. 图形网格的系列有带参数的函数且可以计算出新的图形表达，这意味着难以使生成的网格与其环境的变化作出反应，但很容易交互地添加任意注释和额外的图形.
最后一个系列——嵌入式结构系列——由嵌入自身网格的结构组成，并从内部改变网格的外观. 为了定义周边的样式，Item 可以封装网格的元素. SpanFromLeft、SpanFromAbove 和 SpanFromBoth 用于创建横跨多个行或列的区域.
网格系列
| Grid[{{expr11,expr12,…},{expr21,expr22,…},…}] | |
将 exprij 放置于二维网格的对象 | |
| Column[{expr1,expr2,…}] | 将 expri 排列成一列的对象，其中 expr1 在 expr2 之上，依此类推 |
| Row[{expr1,expr2,…}] | 将 expri 排成一行、可能延续数行的对象 |
Grid[{{"a", "b", "c"}, {"d", "e", "f"}, {"g", "h", "i"}}]Column[{"a", "b", "c", "d"}]Row[CharacterRange["a", "z"]]图形网格系列
| GraphicsGrid[{{g11,g12,…},…}] | 生成一个图形，其中 gij 布局在一个二维网格中 |
| GraphicsColumn[{g1,g2,…}] | 生成一个图形，gi 布局在一列中，其中 g1 位于 g2 上方，依此类推 |
| GraphicsRow[{g1,g2,…}] | 生成一个图形，gi 布局在一行中 |
GraphicsGrid[{{[image], [image]}, {[image], [image]}}]GraphicsColumn[{[image], [image], [image]}]GraphicsRow[{[image], [image], [image]}]嵌入结构系列
| Item[expr,options] | 显示 expr 内容，指定适用于包含 expr 区域的选项 |
| SpanFromLeft | 指定该位置被其左方的内容占用 |
| SpanFromAbove | 指定该位置被其上方的内容占用 |
| SpanFromBoth | 指定该位置被其上方和左方的内容占用 |
Grid[{{Item["a", Background -> Red, Frame -> True], "b", "c"}, {"d", "e", "f"}, {"g", "h", "i"}}]Grid[{{"a", SpanFromLeft, "c"}, {"d", "e", "f"}, {"g", "h", "i"}}, Frame -> All]Grid[{{"a", "b", "c"}, {SpanFromAbove, "e", "f"}, {"g", "h", "i"}}, Frame -> All]Grid[{{"a", SpanFromLeft, "c"}, {SpanFromAbove, SpanFromBoth, "f"}, {"g", "h", "i"}}, Frame -> All]功能类别
Grid 和相关的结构允许大量的外观自定义，只需很少的语法. 下表显示所支持的功能，在后面的章节会有详细的说明.
选项的语法
调整网格的外观存在着各种各样的选项. 本节介绍了这些选项共同的常用语法. 此语法提供了一种不仅对整个网格分配选项值，而且对单个的行、列、甚至项分配选项值.
对于许多选项的整体语法，诸如 Background 是基于像 Background->{specx,specy} 这种形式，其中 specx 是模块语法包含不同列的值，specy 包含不同行的值.
| spec | 在所有项应用 spec |
| {specx} | 在连续水平位置应用 specx |
| {specx,specy} | 在连续水平和垂直位置应用 speck |
| {specx,specy,rules} | 基于 i,j 在数组的位置给出项的规则 |
Grid[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, Background -> {{1 -> Red, 2 -> Green, 3 -> Blue}, Automatic}]Grid[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, Background -> {{Red, Green, Blue}, Automatic}]这两种方法有不同的长处，详见 "使用规则" 和 "使用列表".
使用规则
规则提供了一个直接和可读的方法来提供一个具体的行或列的特定值.
Grid[Table[x, {4}, {4}], Background -> {{1 -> Red, 3 -> Red}, Automatic}]Grid[Table[x, {4}, {4}], Background -> {Automatic, {1 -> Red, 3 -> Red}}]Grid[Table[x, {4}, {10}], Background -> {{1 -> Red, 3 -> Red, -2 -> Red}, Automatic}]规则还可以用于对特定的网格构件或分区域赋值. 但是请注意，尽管在概念上是类似的，这下面的语法和先前所讨论的 specx 和 specy 是不同的.
Grid[Table[x, {4}, {10}], Background -> {Automatic, Automatic, {3, 3} -> Red}]Grid[Table[x, {4}, {10}], Background -> {Automatic, Automatic, {{1, 3}, {1, 3}} -> Red}]规则可以有效地指定值的例外. 然而，当用手动指定网格的每块的值时，效率较低.
Grid[Table[x, {4}, {10}], Background -> {{1 -> Red, 2 -> Blue, 3 -> Red, 4 -> Blue, 5 -> Red, 6 -> Blue, 7 -> Red, 8 -> Blue, 9 -> Red, 10 -> Blue}, Automatic}]为了获得重复模式，建议您使用 下一节 讲述的列表语法.
使用列表
给出列表的序列值是一种紧密方便的方式，可以指定相邻的行或列的大量选项值.
Grid[Table[x, {4}, {10}], Background -> {{Red, Green, Blue, Orange, Magenta}, Automatic}]Grid[Table[x, {4}, {10}], Background -> {{{Red, Green}}, Automatic}]Grid[Table[x, {4}, {10}], Background -> {{Blue, Orange, {Red, Green}}, Automatic}]Grid[Table[x, {4}, {10}], Background -> {{{Red, Green}, Blue, Orange}, Automatic}]Grid[Table[x, {4}, {10}], Background -> {{Green, {Automatic}, Blue, Orange}, Automatic}]因为列表中的位置与网格位置相对应，指定中间位置的单个值需要给出其前面的所有值. 若要更直接地获得这些，使用本节 “使用规则” 所描述的规则.
Grid[Table[x, {4}, {10}], Background -> {{Automatic, Automatic, Automatic, Automatic, Red}, Automatic}]Grid[Table[x, {4}, {10}], Background -> {{5 -> Red}, Automatic}]同时使用
最好是两全其美，使用列表语法指定网格的重复部分，同时使用规则语法指定例外.
Grid[Table[x, {4}, {10}], Background -> {{{{Blue, Green}}, {1 -> Red, -1 -> Red}}, Automatic}]Grid[Table[x, {4}, {10}], Background -> {{Blue, {1 -> Red, 5 -> Red}}, Automatic}]| {s1,s2,…,sn} | 使用 s1 到 sn；然后是缺省值 |
| {{c}} | 所有情况下使用 c |
| {{c1,c2}} | 在 c1 和 c2 间变换 |
| {{c1,c2,…}} | 循环使用所有的 ci |
| {s,{c}} | 使用 s，然后重复使用 c |
| {s1,{c},sn} | 使用 s1，然后重复使用 c，最后使用 sn |
| {s1,s2,…,{c1,c2,…},sm,…,sn
}
| 开头使用 si 第一个序列，然后循环使用 ci，结尾使用 si 的剩余序列 |
| {s1,s2,…,{},sm,…,sn} | 开头使用 si 第一个序列，结尾使用 si 的剩余序列 |
| {i1->v1,i2->v2,…} | 指定在位置 ik 使用什么 |
| {spec,rules} | 使用 rules 覆盖 spec 中的规则 |
列、行、 缝隙和项
正如在前面部分所介绍的，Wolfram 语言提供灵活的语法，可以在网格的不同区域改变选项的值. 本节提供该语言的前后关系和阐述更精细的区分.
Grid 和 GraphicsGrid 遵循描述网格不同部分的相同的约定. Column、GraphicsColumn 和 GraphicsRow 遵循相同的约定，但只处理两维中的一维. Row 不参与这种约定.
选项集合
下表列出了可以处理的选项，没有选项适用于所有的结构. 从下表中可以看出在给定的结构中可以使用哪些选项.
注意 Row 没有采纳任何选项.
先列后行
要记住选项的语法，最重要的一步是要知道，首先指定列的具体值，然后是指定行的值.
在 Wolfram 语言中，带有横向设置 h 和垂直设置 v 的选项指定为 opt->{h,v}. ImageSize 和 PlotRange 是两个常用的建立该约定的选项.
在网格中，这些横向和纵向设置分别对应列和行的值. 这是因为列水平堆叠，因此其属性：如宽度和位置，是与水平方向相对应的. 行是垂直叠放，其属性是与纵向相对应的.
Graphics[{}, ImageSize -> {100, 50}, Background -> StandardGray]Grid[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, ItemSize -> {2, 1}, Frame -> All]Grid[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, ItemSize -> {{1, 2, 3}, 1}, Frame -> All]Grid[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, ItemSize -> {1, {1, 2, 3}}, Frame -> All]Grid[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, Background -> {{Red, Green, Blue}, Automatic}]缝隙
与属性相关的许多 Grid 选项最终与网格中的一列，行或项相关.
Grid[Table[x, {3}, {13}], Dividers -> {None, {2 -> True}}]Grid[Table[x, {3}, {13}], Frame -> {None, {2 -> True}}]Dividers 和 Spacings 的语法与其他选项一样. 对于一个在特定方向上有 n 个项的网格，Dividers 和 Spacings 可以指定元素之间的 n+1 个间隔，在第一个元素之前开始和在最后一个元素之后结束.
项
描述最细致的是项，在网格中的每个项都可以自己的值，如 Background、 Alignment 和 Frame.
Item 可以用来清楚列明所需的设置：
Grid[{{Item[a, Background -> Red], b}, {c, d}}]Grid[{{a, b}, {c, d}}, Background -> {Automatic, Automatic, {{1, 1} -> Red}}]Grid[Table[x, {5}, {5}], Background -> {Automatic, Automatic, Table[{i, i} -> Red, {i, 1, 5}]}]Grid[Table[x, {5}, {5}], Background -> {Automatic, Automatic, {{{2, 4}, {2, 4}} -> Red}}]Grid[Table[x, {5}, {5}], Frame -> {None, None, {{{2, 4}, {2, 4}} -> True}}]分割线和框架
| Dividers | 在行或列间画分割线 |
| Frame | 围绕着网格区域画框架 |
| FrameStyle | 用于线的整体样式 |
使用 Frame 在区域的四边或一系列区域画线：
Grid[Table[x, {4}, {7}], Frame -> True]Grid[Table[x, {4}, {7}], Frame -> {2 -> True, 3 -> True}]Frame 总是在封闭区域的四面画线，Dividers 允许更低层次的控制.
Grid[Table[x, {4}, {7}], Dividers -> {2 -> True}]Grid[Table[x, {4}, {7}], Dividers -> {All, None}]Grid[Table[x, {4}, {7}], Frame -> {All, None}]Grid[Table[x, {4}, {7}], Dividers -> Center]分割线和框架的样式
Grid[Table[x, {4}, {7}], Dividers -> {All, None}, FrameStyle -> Red]Grid[Table[x, {4}, {7}], Frame -> {All, None}, FrameStyle -> Red]Grid[Table[x, {4}, {7}], Dividers -> {{Brown, {1 -> Red, -1 -> Green}}, None}]Grid[Table[x, {4}, {7}], Frame -> {{{{Brown}}, {1 -> Red, -1 -> Green}}, None}]优先级
当样式给定有冲突时，Dividers 优先于 Frame，而他们优先于 FrameStyle. Item 定义的样式优先级最高.
Grid[Table[x, {4}, {7}], Dividers -> {2 -> True, 3 -> True}, Frame -> {None, 4 -> True}]Grid[{{x, x, x, x, x, x, x}, {x, Item[x, Frame -> Green], x, x, x, x, x}, {x, x, x, x, x, x, x}, {x, x, x, x, x, x, x}}, Dividers -> {2 -> Red, 2 -> Red}, Frame -> {{1 -> True}, 4 -> Orange}, FrameStyle -> Directive[Dashing[2], Thickness[2], Blue]]对齐和位置
Alignment 选项可以被传递到整个网格.
Grid[{{1, 10}, {100, 1000}, {10000, 100000}}, Alignment -> Right]Grid[{{1, 10}, {100, 1000}, {10000, 100000}}, Alignment -> {{Right, Left}}]Grid[{{1, 10}, {100, 1000}, {10000, 100000}}, Alignment -> {{Right, Left}, Automatic, {{1, 1} -> Left, {1, 2} -> Right}}]Grid[{{Item[1, Alignment -> Left], Item[10, Alignment -> Right]}, {100, 1000}, {10000, 100000}}, Alignment -> {{Right, Left}}]Column[{1234., 123.4, 12.34, 1.234}, Alignment -> "."]在其包围环境中定位网格可以用 BaselinePosition.
{a, Grid[{{1, 2}, {3, 4}}], b}{a, Grid[{{1, 2}, {3, 4}}, BaselinePosition -> Bottom, Frame -> True], b}{a, Grid[{{1, 2}, {3, 4}}, BaselinePosition -> {2, 1}, Frame -> True], b}背景和样式
普通常识
当与元素集合一起工作时，Grid 提供了设置单独背景的方法.
虽然单个元素可以有自己的背景，但当您把所有元素放在一起时，结果会很糟糕.
Grid[{{Style[a, Background -> Brown], Style[b, Background -> Brown]}}]Grid 和相关的函数把背景放在包含这些元素的全部项的组合上.
Grid[{{a, b}}, Background -> Brown]Grid[Table[x, {5}, {7}], Background -> {{{Brown, None}}}]Grid[Table[x, {5}, {7}], Background -> {None, {{Brown, None}}}]Grid[Table[x, {5}, {7}], Background -> {5 -> Brown, 4 -> Brown}]Grid[{{"The ", "quick ", Item["brown", Background -> Brown], " fox ", "jumps ", "over ", "the ", "lazy ", "dog."}}]重叠背景设置的优先级
Grid[Table[x, {3}, {7}], Background -> {{{Brown, None}}, {{StandardGreen, None}}}]Grid[Table[x, {3}, {7}], Background -> {{{Brown, None}}, {1 -> StandardGreen, 3 -> StandardGreen}}]Grid[Table[x, {3}, {7}], Background -> {{1 -> Brown, 3 -> Brown, 5 -> Brown, 7 -> Brown}, {{StandardGreen, None}}}]以 Item 指明的背景具有最高优先级：
Grid[{{Item[x, Background -> Red], x, x, x, x, x, x}, {x, x, x, x, x, x, x}, {x, x, x, x, x, x, x}}, Background -> {{1 -> Brown, 3 -> Brown, 5 -> Brown, 7 -> Brown}, {{StandardGreen, None}}}]跨越和嵌套
Grid[{{"a", SpanFromLeft, "c"}, {"d", "e", "f"}, {"g", "h", "i"}}, Frame -> All]Grid[{{"a", "b", "c"}, {SpanFromAbove, "e", "f"}, {"g", "h", "i"}}, Frame -> All]Grid[{{"a", SpanFromLeft, "c"}, {SpanFromAbove, SpanFromBoth, "f"}, {"g", "h", "i"}}, Frame -> All]Grid[{{"a", SpanFromLeft, "c"}, {SpanFromAbove, SpanFromBoth, SpanFromLeft}, {"g", "h", "i"}}, Frame -> All]Row[{Column[{a, b, c}], Column[{d, e}], f}]Grid[{{Grid[{{a, b}, {c, d}}], e}, {f, g}}]尺寸和间隙
网格中的尺寸
Grid 通常不修改其内容的大小. 此外，默认情况下，行和列设计成只需容纳内容即可.
Grid[{{a, b}, {[image], [image]}}, Frame -> All]在上面的例子中，第二行比第一行长，第二列比第一列窄，但元素的尺寸没有改变.
如果在网格中的元素交互或动态变化，整个网格的大小将自动适当调整.
一个有用的例外是， Button 将自动填充可用空间.
Grid[{{a, b}, {Button[c], [image]}}, Frame -> All]ItemSize 可以用来覆盖缺省的设置.
Grid[{{a, b}, {Button[c], [image]}}, Frame -> All, ItemSize -> All]Grid[Table[x, {3}, {7}], Frame -> All, ItemSize -> {{1, 2, 3, 4, 5, 6, 7}, 1}]ItemSize 的单位是排版单位：“exs” 和 “ems”.
也可以使用 Scaled 来指定封闭区的一小部分的宽度.
Grid[Table[x, {3}, {7}], Frame -> All, ItemSize -> {{Scaled[.3], Scaled[.3], 3, 4, 5, 6, 7}, 1}]网格中的换行
Grid[Table[xxxx, {3}, {7}], Frame -> All, ItemSize -> {{1, 2, 3, 4, 5, 6, 7}, 1}]Grid[{{100!}, {200!}}, Frame -> All, ItemSize -> Automatic]Grid[{{100!}, {110!}}, Frame -> All, ItemSize -> Full]GraphicsGrid 中的尺寸
默认情况下，GraphicsGrid 将返回一个有相同大小项的网格.
randomgrid = Table[Graphics[Circle[], ImageSize -> Automatic,
AspectRatio -> RandomReal[]], {3}, {5}];GraphicsGrid[randomgrid, Frame -> All]和相同的 Grid 例子比较，并没有改变任何一个整体大小或纵横比.
Grid[randomgrid, Frame -> All]GraphicsGrid 不支持 ItemSize 选项，但是支持 ImageSize.
GraphicsGrid[randomgrid, ImageSize -> 200, Frame -> All]| Input[] | 读入一个表达式输入 |
| InputString[] | 读入一个字符串输入 |
| Input["prompt"] | 产生提示，然后读入表达式 |
| InputString["prompt"] | 产生提示，然后读入字符串 |
Input 和 InputString 的工作依赖于所用的计算机系统和 Wolfram 语言界面. 在文本界面中，他们等待标准的输入，用回车结束. 在笔记本界面中，在前端中出现一个 “对话框” 让用户输入.
| Quiet[expr] | 计算 expr 不显示任何消息 |
| Quiet[expr,{s1::tag,s2::tag,…}] | 计算 expr 不显示指定的消息 |
| Off[s::tag] | 关闭消息使其不显示 |
| On[s::tag] | 打开消息 |
Log[a, b, c]
Quiet[Log[a, b, c]]Log[a, b, c]
Off[Log::argt]Log[a, b, c]| s::tag | 给出消息内容 |
| s::tag=string | 设置消息内容 |
| Messages[s] | 显示与 s 相关的消息 |
当给 LinearSolve 输入一个奇异矩阵时，就显示一个警告消息：
LinearSolve[{{1, 1}, {2, 2}}, {3, 5}]
LinearSolve::nosolLinearSolve::nosol = "Matrix encountered is not invertible."LinearSolve[{{1, 1}, {2, 2}}, {3, 5}]
消息总是以适用于 StringForm 的字符串存放. 当需要显示时，一些相应的表达式就拼接成该消息. 这些表达式用HoldForm 封装，以防止被计算. 此外，任何被指定为全局变量 $MessagePrePrint 的函数在被交给 StringForm 之前作用于这些表达式. $MessagePrePrint 默认使用 Short 作为文本格式，并且组合 Short 和Shallow 来排版.
当给函数 F 的变量数目不正确时，Wolfram 语言将显示警告消息诸如， F::argx. 如果 Wolfram 语言找不到命名为 F::argx 的消息时，就用 “一般”消息 General::argx 代替. 可以用 Off[F::argx] 关闭对函数 F 的变量计数的消息，也可以用 Off[General::argx] 关闭所有使用一般消息文本的消息.
Sqrt[a, b]
General::argxQuiet[{Sin[a, b], Sqrt[a, b]}, Sqrt::argx]
Quiet[{Sin[a, b], Sqrt[a, b]}, General::argx]如果 F::tag 消息没有使用 General::tag，压缩 General::tag 不会压缩 F::tag. 比如，关掉 General::targ 消息不会关掉 Entropy::targ 消息，因为两个消息是不一样的.
Entropy[x]
IdentityMatrix[4, x]
Quiet[{Entropy[x], IdentityMatrix[4, x]}, General::targ]
当计算中出现严重错误时，就会发现同样的警告消息反复产生. 这会导致混乱. 于是 Wolfram 语言就跟踪一个计算过程中的所有消息， 当一条消息重复出现多于3次时就不再显示. 当这一情况发生时，Wolfram 语言就显示消息 General::stop 去提醒用户. 如果需要查看所有 Wolfram 语言显示的消息，就要关闭 General::stop.
| $MessageList | 在一个计算过程中产生的消息列表 |
| MessageList[n] | 在一个 Wolfram 语言进程中处理第 n 个输入行时产生的消息列表 |
在每一个计算中，Wolfram 语言将所产生的全部消息放在列表 $MessageList 中. 在标准的 Wolfram 语言进程中，每一行的输出产生后就清除这个消息列表，但在计算过程中可以访问这个列表. 另外，在一个进程中第 n 行的输出产生时，$MessageList 的值就赋给 MessageList[n].
返回 $MessageList，给出所产生消息的列表：
Sqrt[a, b, c];Exp[a, b];$MessageList
消息名由 HoldForm 封装，以阻止他们不被计算：
InputForm[%]| Check[expr,failexpr] | 当计算 expr 时没有产生消息，则返回值 expr； 否则返回 failexpr |
| Check[expr,failexpr,s1::t1,s2::t2,…] | 仅检查消息 si::ti |
Check[1 ^ 0, err]Check[0 ^ 0, err]
有时仅需要测试某一些特定消息，如与数值溢出有关的消息，这就需要告诉 Check 所需要测试的消息名.
Check[Sin[1, 2], err, General::ind]
f::overflow = "Factorial argument `1` too large."f[x_] := If[x > 10, (Message[f::overflow, x];Infinity), x!]f[20]
Off[f::overflow]f[20]调用 Message 时，先找指定名称的消息，找不到时就找一个与 General 符号相关的比较合适的消息名. 再找不到时 ，Wolfram 语言就将所定义的任意函数作全局变量 $NewMessage 的值，且将该函数作用到所要求消息的符号和标记上.
通过对 $NewMessage 的适当设置，当第一次需要一个消息时，就可以让 Wolfram 语言从一个文件读入消息内容.
| $Language="lang" | 设定使用的语言 |
$Language = "French"Sqrt[a, b, c]
| symbol::tag | 消息的默认形式 |
| symbol::tag::Language | 特定语言的消息 |
If[a > b, (*then*) p, (*else*) q]f[x_] := x ^ 2f::usage = "f[x] gives the square of x."? f??f??f? Plot *