Sage对象的抽象基类#

班 sage.structure.sage_object。Sage对象[来源]#

基础：对象

Sage中所有（用户可见）对象的基类

每个最终可能返回给用户的对象都应该从…继承Sage对象.

_ascii_art（_A）_()[来源]#

返回ASCII艺术表示。

在派生类中实现多行ASCII艺术输出必须重写此方法。不同_报告_（），这是有时用于哈希键_ascii_art_（）可能取决于设置，并且允许在运行时更改。

输出：

安ASCII图案对象，请参见sage.typeset.ascii_art系列了解详细信息。

示例：

您可以使用ascii_art（）功能要获得Sage中任何对象的ASCII艺术表示，请执行以下操作：

圣人

圣人： 结果 = ascii_art（_A）(完整的(经验(x个+x个^2)/(x个+1), x个))                     #需要圣人符号
...
圣人： 结果                                                                #需要圣人符号
/
|
|   2
|x+x
|e（电子）
|--------天
|x+1
|
/

蟒蛇

>>> 从 sage.all公司 进口 *
>>> 结果 = ascii_art（_A）(完整的(经验(x个+x个**整数(2))/(x个+整数(1)), x个))                     #需要圣人符号
...
>>> 结果                                                                #需要圣人符号
/
|
|   2
|x+x
|e（电子）
|--------天
|x+1
|
/

或者，您可以使用%显示器 ascii_art/简单魔法到将所有输出切换到ASCII图形并返回：

圣人

圣人： #需要sage.combinat
圣人： 从 sage.repl.解释器 进口 获取测试外壳
圣人： 壳 = 获取测试外壳()
圣人： 壳.运行单元格（_C）('tab=标准表aux（3）[2]；选项卡')
[[1, 2], [3]]
鼠尾草： 壳.运行单元格（_C）('%d日显示ascii_art')
圣人： 壳.运行单元格（_C）('选项卡')
1  2
三
圣人： 壳.运行单元格（_C）('Tableaux.options（ascii_art=“table”，convention=“French”）')
圣人： 壳.运行单元格（_C）('选项卡')
+---+
| 3 |
+---+---+
| 1 | 2 |
+---+---+
圣人： 壳.运行单元格（_C）('%d日显示普通')
圣人： 壳.运行单元格（_C）('表aux.options_重置（）')
圣人： 壳.退出()

蟒蛇

>>> 从 sage.all公司 进口 *
>>> #需要sage.combinat
>>> 从 sage.repl.解释器 进口 获取测试外壳
>>> 壳 = 获取测试外壳()
>>> 壳.运行单元格（_C）('tab=标准表aux（3）[2]；选项卡')
[[1, 2], [3]]
>>> 壳.运行单元格（_C）('%d日显示ascii_art)
>>> 壳.运行单元格（_C）('选项卡')
1  2
三
>>> 壳.运行单元格('Tableaux.options（ascii_art=“table”，convention=“French”）')
>>> 壳.运行单元格('选项卡')
+---+
| 3 |
+---+---+
| 1 | 2 |
+---+---+
>>> 壳.运行单元格（_C）('%d日显示普通')
>>> 壳.运行单元格（_C）('表aux.options_重置（）')
>>> 壳.退出()

_缓存密钥（_K）()[来源]#

返回一个哈希键，用于标识要缓存的对象。这个输出必须是哈希本身，或者是一个对象元组hashable或定义_缓存密钥（_K）.

只有当对象本身不可哈希时，才会调用此方法。

一些不可变对象（例如\（p\）-adic数字）无法实现合理的散列函数，因为它们==操作员已经修改为返回真的对于行为可能不同的对象在某些计算中：

圣人

圣人： #需要sage.rings.padics
圣人： K（K）.<一> = 问题q(9)
圣人： b = 一 + O（运行）(三)
圣人： c（c） = 一 + 三
圣人： b
a+O（3）
圣人： c（c）
a+3+O（3^20）
圣人： b == c（c）
真的
圣人： b == 一
真的
鼠尾草： c（c） == 一
False（错误）

蟒蛇

>>> 从 sage.all公司 进口 *
>>> #需要sage.rings.padics
>>> K（K） = 问题q(整数(9), 姓名=(“a”,)); (一,) = K（K）._first_ngens（第一个_基因）(1)
>>> b = 一 + O（运行）(整数(三))
>>> c（c） = 一 + 整数(三)
>>> b
a+O（3）
>>> c（c）
a+3+O（3^20）
>>> b == c（c）
真的
>>> b == 一
真的
>>> c（c） == 一
False（错误）

如果这些对象定义了一个非平凡的哈希函数，那么这将破坏在许多地方缓存。然而，这些对象在缓存。这可以通过定义适当的_缓存密钥（_K）:

圣人

圣人： #需要sage.rings.padics
圣人： 搞砸(b)
回溯（最近一次调用）：
...
TypeError:无法修复的类型：“sage.rings.padics.qadic_flint_CR.qAdicCappedRelativeElement”
圣人： @缓存方法
....: 定义 （f）(x个): 返回 x个==一
圣人： （f）(b)
真的
圣人： （f）(c（c）)  #如果b和c是可散列的，则返回True
False（错误）
圣人： b._缓存密钥（_K）()
(..., ((0, 1),), 0, 1)
圣人： c（c）._缓存密钥（_K）()
(..., ((0, 1), (1,)), 0, 20)

蟒蛇

>>> 从 sage.all公司 进口 *
>>> #需要sage.rings.padics
>>> 搞砸(b)
回溯（最近一次调用）：
...
TypeError:无法修复的类型：“sage.rings.padics.qadic_flint_CR.qAdicCappedRelativeElement”
>>> @缓存方法
... 定义 （f）(x个): 返回 x个==一
>>> （f）(b)
真的
>>> （f）(c（c）)  #如果b和c是可散列的，则返回True
False（错误）
>>> b._缓存密钥（_K）()
(..., ((0, 1),), 0, 1)
>>> c（c）._缓存密钥（_K）()
(..., ((0, 1), (1,)), 0, 20)

实现必须确保元素一和b,如果一 != b，然后也a.检查键（） != b.缓存键（_cache_key）.在实践中，这意味着_缓存密钥（_K）应始终包括父对象作为其第一个参数：

圣人

圣人： S公司.<一> = 问题q(4)                                                         #需要sage.rings.padics
圣人： d日 = 一 + O（运行）(2)                                                          #需要sage.rings.padics
圣人： b._缓存密钥（_K）() == d日._缓存密钥（_K）()  #如果不包括父母#needs sage.rings.padics，这将是真的
False（错误）

蟒蛇

>>> 从 sage.all公司 进口 *
>>> S公司 = 问题q(整数(4), 姓名=(“a”,)); (一,) = S公司._first_ngens（第一个_基因）(1)#需要sage.rings.padics
>>> d日 = 一 + O（运行）(整数(2))                                                          #需要sage.rings.padics
>>> b._缓存密钥（_K）() == d日._缓存密钥（_K）()  #如果不包括父母#needs sage.rings.padics，这将是真的
False（错误）

类别()[来源]#

倾倒(文件名,压缩=真的)[来源]#: 与self.save相同（文件名，压缩）

转储(压缩=真的)[来源]#

转储自己到字符串秒，以后可以重建作为自己使用负载.

有一个可选的布尔参数压缩默认为真的.

示例：

圣人

圣人： 从 sage.misc.个人信息 进口 comp公司
圣人： O（运行） = Sage对象()
圣人： p_comp公司 = O（运行）.转储()
圣人： p_unmp（未压缩） = O（运行）.转储(压缩=False（错误）)
圣人： comp公司.减压(p_comp公司) == p_unmp（未压缩）
真的
鼠尾草： 进口 酸洗工具
圣人： 酸洗工具.数字化信息系统(_解压缩)
0:\x80保护2
2:c GLOBAL“sage.structure.sage_object SageObject”
41:q输入。。。
43:）空元组
44:\x81新沃博
45:q二进制输入。。。
47: .    停止
操作码中最高的协议=2

蟒蛇

>>> 从 sage.all公司 进口 *
>>> 从 sage.misc.个人信息 进口 comp公司
>>> O（运行） = Sage对象()
>>> p_comp公司 = O（运行）.转储()
>>> p_unmp（未压缩） = O（运行）.转储(压缩=False（错误）)
>>> comp公司.减压(p_comp公司) == p_unmp（未压缩）
真的
>>> 进口 酸洗工具
>>> 酸洗工具.数字化信息系统(p_unmp（未压缩）)
0:\x80保护2
2:c GLOBAL“sage.structure.sage_object SageObject”
41:q二进制文件。。。
43：）空_折叠
44:\x81新沃博
45:q二进制输入。。。
47: .    停止
操作码中最高的协议=2

获取自定义名称()[来源]#

返回此对象的自定义名称，或无如果不是的话重命名。

示例：

圣人

圣人： P（P）.<x个> = QQ（QQ）[]
圣人： P（P）.获取自定义名称() 是 无
真的
圣人： P（P）.重命名('多项式环')
鼠尾草： P（P）.获取自定义名称()
'多项式环'
鼠尾草： P（P）.重置名称()
鼠尾草： P（P）.获取自定义名称() 是 无
真的

蟒蛇

>>> 从 sage.all公司 进口 *
>>> P（P） = QQ（QQ）[“x”]; (x个,) = P（P）._first_ngens（第一个_基因）(1)
>>> P（P）.获取自定义名称() 是 无
真的
>>> P（P）.重命名('多项式环')
>>> P（P）.获取自定义名称()
'多项式环'
>>> P（P）.重置名称()
>>> P（P）.获取自定义名称() 是 无
真的

起源()[来源]#

返回的类型自己以支持强制框架。

示例：

圣人

圣人： 吨 = 日志(平方英尺(2) - 1) + 日志(平方英尺(2) + 1); 吨                            #需要圣人符号
log（sqrt（2）+1）+log（sqlt（2）-1）
圣人： u个 = 吨.最大方法（_M）()                                                #需要圣人符号
圣人： u个.起源()                                                            #需要圣人符号
<class‘sage.symbolic.maxima_wrapper。最大包装器'>

蟒蛇

>>> 从 sage.all公司 进口 *
>>> 吨 = 日志(平方英尺(整数(2)) - 整数(1)) + 日志(平方英尺(整数(2)) + 整数(1)); 吨                            #需要圣人符号
log（sqrt（2）+1）+log（sqlt（2）-1）
>>> u个 = 吨.最大方法（_M）()                                                #需要圣人符号
>>> u个.起源()                                                            #需要圣人符号
<class‘sage.symbolic.maxima_wrapper。最大包装器'>

重命名(x个=无)[来源]#

更改self，使其打印为x，其中x是字符串。

如果x是无，则删除现有自定义名称。

注释

这是只有支持派生的Python类来自SageObject。

示例：

圣人

圣人： x个 = 多项式环(QQ（QQ）, “x”, 稀疏的=真的).消息()
圣人： 克 = x个^三 + x个 - 5
鼠尾草： 克
x^3+x-5
鼠尾草： 克.重命名(“多项式”)
圣人： 克
多项式
圣人： 克 + x个
x^3+2*x-5
圣人： 小时 = 克^100
圣人： 字符串(小时)[:20]
'x^300+100*x^298-'
圣人： 小时.重命名('x^300+…')
圣人： 小时
x^300+。。。
圣人： 克.重命名(无)
圣人： 克
x^3+x-5

蟒蛇

>>> 从 sage.all公司 进口 *
>>> x个 = 多项式环(QQ（QQ）, “x”, 稀疏的=真的).消息()
>>> 克 = x个**整数(三) + x个 - 整数(5)
>>> 克
x^3+x-5
>>> 克.重命名(“多项式”)
>>> 克
多项式
>>> 克 + x个
x^3+2*x-5
>>> 小时 = 克**整数(100)
>>> 字符串(小时)[:整数(20)]
'x^300+100*x^298-'
>>> 小时.重命名('x^300+…')
>>> 小时
x^300+。。。
>>> 克.重命名(无)
>>> 克
x^3+x-5

实数不是Python类，因此不支持重命名：

圣人

圣人： 一 = 3.14
圣人： 类型(一)                                                               #需要sage.rings.real_mpfr
<... 'sage.rings.实际值。RealLiteral“>
圣人： 一.重命名(“圆周率”)                                                        #需要sage.rings.real_mpfr
回溯（最近一次调用）：
...
NotImplementedError:对象不支持重命名：3.1400000000000

蟒蛇

>>> 从 sage.all公司 进口 *
>>> 一 = RealNumber（实数）('3.14')
>>> 类型(一)                                                               #需要sage.rings.real_mpfr
<... 'sage.rings.实际值。RealLiteral“>
>>> 一.重命名(“圆周率”)                                                        #需要sage.rings.real_mpfr
回溯（最近一次调用）：
...
NotImplementedError:对象不支持重命名：3.1400000000000

注释

默认情况下不支持C扩展类型的原因如果是那样的话，每个人都必须围绕一个额外的属性，这将是较慢和浪费很多记忆。

要为特定类支持它们，请添加cdef公司公众的 _Sage对象_自定义名称属性。

重置名称()[来源]#

删除对象的自定义名称。

示例：

圣人

圣人： P（P）.<x个> = QQ（QQ）[]
圣人： P（P）
有理域上x中的一元多项式环
圣人： P（P）.重命名('多项式环')
圣人： P（P）
多项式环
圣人： P（P）.重置名称()
圣人： P（P）
有理域上x中的一元多项式环

蟒蛇

>>> 从 sage.all公司 进口 *
>>> P（P） = QQ（QQ）[“x”]; (x个,) = P（P）._first_ngens（第一个_基因）(1)
>>> P（P）
有理域上x中的一元多项式环
>>> P（P）.重命名('多项式环')
>>> P（P）
多项式环
>>> P（P）.重置名称()
>>> P（P）
有理域上x中的一元多项式环

节约(文件名=无,压缩=真的)[来源]#

将自身保存到给定的文件名。

示例：

圣人

圣人： #需要圣人符号
圣人： x个 = SR公司.变量(“x”)
圣人： （f） = x个^三 + 5
鼠尾草： 从 临时文件 进口 命名临时文件
圣人： 具有 命名临时文件(后缀=“.sobj”) 作为 吨:
....:     （f）.节约(吨.名称)
....:     负载(吨.名称)
x^3+5

蟒蛇

>>> 从 sage.all公司 进口 *
>>> #需要圣人符号
>>> x个 = SR公司.变量(“x”)
>>> （f） = x个**整数(三) + 整数(5)
>>> 从 临时文件 进口 命名临时文件
>>> 具有 命名临时文件(后缀=“.sobj”) 作为 吨:
...     （f）.节约(吨.名称)
...     负载(吨.名称)
x^3+5