“Python/docs/3.9/c-api/complex”的版本间差异

来自菜鸟教程
Python/docs/3.9/c-api/complex
跳转至:导航、​搜索
(autoload)
 
(Page commit)
 
第1行: 第1行:
 +
{{DISPLAYTITLE:复数对象 — Python 文档}}
 
<div id="complex-number-objects" class="section">
 
<div id="complex-number-objects" class="section">
  
 
<span id="complexobjects"></span>
 
<span id="complexobjects"></span>
= Complex Number Objects =
+
= 复数对象 =
  
Python's complex number objects are implemented as two distinct types when
+
C API 来看,Python 的复数对象实现为两种不同的类型:一种是暴露给 Python 程序的 Python 对象,另一种是表示实际复数值的 C 结构。 API 提供了与两者一起使用的函数。
viewed from the C API: one is the Python object exposed to Python programs, and
 
the other is a C structure which represents the actual complex number value.
 
The API provides functions for working with both.
 
  
 
<div id="complex-numbers-as-c-structures" class="section">
 
<div id="complex-numbers-as-c-structures" class="section">
  
== Complex Numbers as C Structures ==
+
== 作为 C 结构的复数 ==
  
Note that the functions which accept these structures as parameters and return
+
请注意,接受这些结构作为参数并将它们作为结果返回的函数是通过值 '''' 而不是通过指针取消引用它们。 这在整个 API 中是一致的。
them as results do so ''by value'' rather than dereferencing them through
 
pointers. This is consistent throughout the API.
 
  
 
<dl>
 
<dl>
<dt>''type'' <code>Py_complex</code></dt>
+
<dt><span class="k"><span class="pre">type</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">Py_complex</span></span></span><br />
<dd><p>The C structure which corresponds to the value portion of a Python complex
+
</dt>
number object. Most of the functions for dealing with complex number objects
+
<dd><p>对应于 Python 复数对象的值部分的 C 结构。 大多数用于处理复数对象的函数都使用这种类型的结构作为输入或输出值,视情况而定。 它被定义为:</p>
use structures of this type as input or output values, as appropriate. It is
 
defined as:</p>
 
 
<div class="highlight-c notranslate">
 
<div class="highlight-c notranslate">
  
 
<div class="highlight">
 
<div class="highlight">
  
<pre>typedef struct {
+
<syntaxhighlight lang="c">typedef struct {
 
   double real;
 
   double real;
 
   double imag;
 
   double imag;
} Py_complex;</pre>
+
} Py_complex;</syntaxhighlight>
  
 
</div>
 
</div>
第36行: 第30行:
 
</div></dd></dl>
 
</div></dd></dl>
  
; [[#c.Py_complex|Py_complex]] <code>_Py_c_sum</code><span class="sig-paren">(</span>[[#c.Py_complex|Py_complex]] ''left'', [[#c.Py_complex|Py_complex]] ''right''<span class="sig-paren">)</span>
+
; [[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">_Py_c_sum</span></span></span><span class="sig-paren">(</span>[[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">left</span></span>, [[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">right</span></span><span class="sig-paren">)</span><br />
: Return the sum of two complex numbers, using the C [[#c.Py_complex|<code>Py_complex</code>]] representation.
 
  
; [[#c.Py_complex|Py_complex]] <code>_Py_c_diff</code><span class="sig-paren">(</span>[[#c.Py_complex|Py_complex]] ''left'', [[#c.Py_complex|Py_complex]] ''right''<span class="sig-paren">)</span>
+
: 使用 C [[#c.Py_complex|Py_complex]] 表示返回两个复数的总和。
: Return the difference between two complex numbers, using the C [[#c.Py_complex|<code>Py_complex</code>]] representation.
 
  
; [[#c.Py_complex|Py_complex]] <code>_Py_c_neg</code><span class="sig-paren">(</span>[[#c.Py_complex|Py_complex]] ''complex''<span class="sig-paren">)</span>
+
; [[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">_Py_c_diff</span></span></span><span class="sig-paren">(</span>[[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">left</span></span>, [[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">right</span></span><span class="sig-paren">)</span><br />
: Return the negation of the complex number ''complex'', using the C [[#c.Py_complex|<code>Py_complex</code>]] representation.
 
  
; [[#c.Py_complex|Py_complex]] <code>_Py_c_prod</code><span class="sig-paren">(</span>[[#c.Py_complex|Py_complex]] ''left'', [[#c.Py_complex|Py_complex]] ''right''<span class="sig-paren">)</span>
+
: 使用 C [[#c.Py_complex|Py_complex]] 表示返回两个复数之间的差值。
: Return the product of two complex numbers, using the C [[#c.Py_complex|<code>Py_complex</code>]] representation.
+
 
 +
; [[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">_Py_c_neg</span></span></span><span class="sig-paren">(</span>[[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">num</span></span><span class="sig-paren">)</span><br />
 +
 
 +
: 使用 C [[#c.Py_complex|Py_complex]] 表示返回复数 ''num'' 的否定。
 +
 
 +
; [[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">_Py_c_prod</span></span></span><span class="sig-paren">(</span>[[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">left</span></span>, [[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">right</span></span><span class="sig-paren">)</span><br />
 +
 
 +
: 使用 C [[#c.Py_complex|Py_complex]] 表示返回两个复数的乘积。
  
 
<dl>
 
<dl>
<dt>[[#c.Py_complex|Py_complex]] <code>_Py_c_quot</code><span class="sig-paren">(</span>[[#c.Py_complex|Py_complex]] ''dividend'', [[#c.Py_complex|Py_complex]] ''divisor''<span class="sig-paren">)</span></dt>
+
<dt>[[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">_Py_c_quot</span></span></span><span class="sig-paren">(</span>[[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">dividend</span></span>, [[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">divisor</span></span><span class="sig-paren">)</span><br />
<dd><p>Return the quotient of two complex numbers, using the C [[#c.Py_complex|<code>Py_complex</code>]]
+
</dt>
representation.</p>
+
<dd><p>使用 C [[#c.Py_complex|Py_complex]] 表示返回两个复数的商。</p>
<p>If ''divisor'' is null, this method returns zero and sets
+
<p>如果 ''divisor'' 为空,则此方法返回零并将 <code>errno</code> 设置为 <code>EDOM</code></p></dd></dl>
<code>errno</code> to <code>EDOM</code>.</p></dd></dl>
 
  
 
<dl>
 
<dl>
<dt>[[#c.Py_complex|Py_complex]] <code>_Py_c_pow</code><span class="sig-paren">(</span>[[#c.Py_complex|Py_complex]] ''num'', [[#c.Py_complex|Py_complex]] ''exp''<span class="sig-paren">)</span></dt>
+
<dt>[[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">_Py_c_pow</span></span></span><span class="sig-paren">(</span>[[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">num</span></span>, [[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">exp</span></span><span class="sig-paren">)</span><br />
<dd><p>Return the exponentiation of ''num'' by ''exp'', using the C [[#c.Py_complex|<code>Py_complex</code>]]
+
</dt>
representation.</p>
+
<dd><p>使用 C [[#c.Py_complex|Py_complex]] 表示返回 ''num'' 乘以 ''exp'' 的幂。</p>
<p>If ''num'' is null and ''exp'' is not a positive real number,
+
<p>如果 ''num'' 为空且 ''exp'' 不是正实数,则此方法返回零并将 <code>errno</code> 设置为 <code>EDOM</code></p></dd></dl>
this method returns zero and sets <code>errno</code> to <code>EDOM</code>.</p></dd></dl>
 
  
  
第66行: 第62行:
 
<div id="complex-numbers-as-python-objects" class="section">
 
<div id="complex-numbers-as-python-objects" class="section">
  
== Complex Numbers as Python Objects ==
+
== 复数作为 Python 对象 ==
 +
 
 +
; <span class="k"><span class="pre">type</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">PyComplexObject</span></span></span><br />
 +
 
 +
: [[../structures#c|PyObject]] 的这个子类型表示一个 Python 复数对象。
 +
 
 +
; [[../type#c|<span class="n"><span class="pre">PyTypeObject</span></span>]]<span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">PyComplex_Type</span></span></span><br />
 +
 
 +
: [[../type#c|PyTypeObject]] 的这个实例表示 Python 复数类型。 它与 Python 层中的 [[../../library/functions#complex|complex]] 是同一个对象。
 +
 
 +
; <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">PyComplex_Check</span></span></span><span class="sig-paren">(</span>[[../structures#c|<span class="n"><span class="pre">PyObject</span></span>]]<span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">p</span></span><span class="sig-paren">)</span><br />
 +
 
 +
: 如果其参数是 [[#c.PyComplexObject|PyComplexObject]] 或 [[#c.PyComplexObject|PyComplexObject]] 的子类型,则返回 true。 此功能总是成功。
  
; ''type'' <code>PyComplexObject</code>
+
; <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">PyComplex_CheckExact</span></span></span><span class="sig-paren">(</span>[[../structures#c|<span class="n"><span class="pre">PyObject</span></span>]]<span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">p</span></span><span class="sig-paren">)</span><br />
: This subtype of [[../structures#c|<code>PyObject</code>]] represents a Python complex number object.
 
  
; [[../type#c|PyTypeObject]] <code>PyComplex_Type</code>
+
: 如果其参数是 [[#c.PyComplexObject|PyComplexObject]],但不是 [[#c.PyComplexObject|PyComplexObject]] 的子类型,则返回 true。 此功能总是成功。
: This instance of [[../type#c|<code>PyTypeObject</code>]] represents the Python complex number type. It is the same object as [[../../library/functions#complex|<code>complex</code>]] in the Python layer.
 
  
; int <code>PyComplex_Check</code><span class="sig-paren">(</span>[[../structures#c|PyObject]] *''p''<span class="sig-paren">)</span>
+
; [[../structures#c|<span class="n"><span class="pre">PyObject</span></span>]]<span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">PyComplex_FromCComplex</span></span></span><span class="sig-paren">(</span>[[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="n"><span class="pre">v</span></span><span class="sig-paren">)</span><br />
: Return true if its argument is a [[#c.PyComplexObject|<code>PyComplexObject</code>]] or a subtype of [[#c.PyComplexObject|<code>PyComplexObject</code>]].
 
  
; int <code>PyComplex_CheckExact</code><span class="sig-paren">(</span>[[../structures#c|PyObject]] *''p''<span class="sig-paren">)</span>
+
: 从 C [[#c.Py_complex|Py_complex]] 值创建一个新的 Python 复数对象。
: Return true if its argument is a [[#c.PyComplexObject|<code>PyComplexObject</code>]], but not a subtype of [[#c.PyComplexObject|<code>PyComplexObject</code>]].
 
  
<dl>
+
; [[../structures#c|<span class="n"><span class="pre">PyObject</span></span>]]<span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">PyComplex_FromDoubles</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">double</span></span><span class="w"> </span><span class="n"><span class="pre">real</span></span>, <span class="kt"><span class="pre">double</span></span><span class="w"> </span><span class="n"><span class="pre">imag</span></span><span class="sig-paren">)</span><br />
<dt>[[../structures#c|PyObject]] *<code>PyComplex_FromCComplex</code><span class="sig-paren">(</span>[[#c.Py_complex|Py_complex]] ''v''<span class="sig-paren">)</span></dt>
+
 
<dd><p>''Return value: New reference.''</p>
+
: 从 ''real'' 和 ''imag'' 返回一个新的 [[#c.PyComplexObject|PyComplexObject]] 对象。
<p>Create a new Python complex number object from a C [[#c.Py_complex|<code>Py_complex</code>]] value.</p></dd></dl>
+
 
 +
; <span class="kt"><span class="pre">double</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">PyComplex_RealAsDouble</span></span></span><span class="sig-paren">(</span>[[../structures#c|<span class="n"><span class="pre">PyObject</span></span>]]<span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">op</span></span><span class="sig-paren">)</span><br />
  
<dl>
+
: 将 ''op'' 的实部作为 C <span class="xref c c-texpr">double</span> 返回。
<dt>[[../structures#c|PyObject]] *<code>PyComplex_FromDoubles</code><span class="sig-paren">(</span>double ''real'', double ''imag''<span class="sig-paren">)</span></dt>
 
<dd><p>''Return value: New reference.''</p>
 
<p>Return a new [[#c.PyComplexObject|<code>PyComplexObject</code>]] object from ''real'' and ''imag''.</p></dd></dl>
 
  
; double <code>PyComplex_RealAsDouble</code><span class="sig-paren">(</span>[[../structures#c|PyObject]] *''op''<span class="sig-paren">)</span>
+
; <span class="kt"><span class="pre">double</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">PyComplex_ImagAsDouble</span></span></span><span class="sig-paren">(</span>[[../structures#c|<span class="n"><span class="pre">PyObject</span></span>]]<span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">op</span></span><span class="sig-paren">)</span><br />
: Return the real part of ''op'' as a C <span class="xref c c-texpr">double</span>.
 
  
; double <code>PyComplex_ImagAsDouble</code><span class="sig-paren">(</span>[[../structures#c|PyObject]] *''op''<span class="sig-paren">)</span>
+
: ''op'' 的虚部作为 C <span class="xref c c-texpr">double</span> 返回。
: Return the imaginary part of ''op'' as a C <span class="xref c c-texpr">double</span>.
 
  
 
<dl>
 
<dl>
<dt>[[#c.Py_complex|Py_complex]] <code>PyComplex_AsCComplex</code><span class="sig-paren">(</span>[[../structures#c|PyObject]] *''op''<span class="sig-paren">)</span></dt>
+
<dt>[[#c.Py_complex|<span class="n"><span class="pre">Py_complex</span></span>]]<span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">PyComplex_AsCComplex</span></span></span><span class="sig-paren">(</span>[[../structures#c|<span class="n"><span class="pre">PyObject</span></span>]]<span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">op</span></span><span class="sig-paren">)</span><br />
<dd><p>Return the [[#c.Py_complex|<code>Py_complex</code>]] value of the complex number ''op''.</p>
+
</dt>
<p>If ''op'' is not a Python complex number object but has a <code>__complex__()</code>
+
<dd><p>返回复数 ''op'' 的 [[#c.Py_complex|Py_complex]] 值。</p>
method, this method will first be called to convert ''op'' to a Python complex
+
<p>如果 ''op'' 不是 Python 复数对象但具有 <code>__complex__()</code> 方法,则将首先调用该方法将 ''op'' 转换为 Python 复数对象。 如果 <code>__complex__()</code> 未定义,则回退到 <code>__float__()</code>。 如果 <code>__float__()</code> 未定义,则回退到 <code>__index__()</code>。 失败时,此方法返回 <code>-1.0</code> 作为实际值。</p>
number object. If <code>__complex__()</code> is not defined then it falls back to
 
<code>__float__()</code>. If <code>__float__()</code> is not defined then it falls back
 
to <code>__index__()</code>. Upon failure, this method returns <code>-1.0</code> as a real
 
value.</p>
 
 
<div class="versionchanged">
 
<div class="versionchanged">
  
<p><span class="versionmodified changed">在 3.8 版更改: </span>Use <code>__index__()</code> if available.</p>
+
<p><span class="versionmodified changed">在 3.8 版更改:</span>如果可用,请使用 <code>__index__()</code></p>
  
 
</div></dd></dl>
 
</div></dd></dl>
第113行: 第109行:
  
 
</div>
 
</div>
 +
 +
</div>
 +
<div class="clearer">
 +
 +
  
 
</div>
 
</div>
  
[[Category:Python 3.9 中文文档]]
+
[[Category:Python 3.9 文档]]

2021年10月31日 (日) 04:50的最新版本

复数对象

从 C API 来看,Python 的复数对象实现为两种不同的类型:一种是暴露给 Python 程序的 Python 对象,另一种是表示实际复数值的 C 结构。 API 提供了与两者一起使用的函数。

作为 C 结构的复数

请注意,接受这些结构作为参数并将它们作为结果返回的函数是通过值 ' 而不是通过指针取消引用它们。 这在整个 API 中是一致的。

type Py_complex

对应于 Python 复数对象的值部分的 C 结构。 大多数用于处理复数对象的函数都使用这种类型的结构作为输入或输出值,视情况而定。 它被定义为:

typedef struct {
   double real;
   double imag;
} Py_complex;
Py_complex _Py_c_sum(Py_complex left, Py_complex right)
使用 C Py_complex 表示返回两个复数的总和。
Py_complex _Py_c_diff(Py_complex left, Py_complex right)
使用 C Py_complex 表示返回两个复数之间的差值。
Py_complex _Py_c_neg(Py_complex num)
使用 C Py_complex 表示返回复数 num 的否定。
Py_complex _Py_c_prod(Py_complex left, Py_complex right)
使用 C Py_complex 表示返回两个复数的乘积。
Py_complex _Py_c_quot(Py_complex dividend, Py_complex divisor)

使用 C Py_complex 表示返回两个复数的商。

如果 divisor 为空,则此方法返回零并将 errno 设置为 EDOM

Py_complex _Py_c_pow(Py_complex num, Py_complex exp)

使用 C Py_complex 表示返回 num 乘以 exp 的幂。

如果 num 为空且 exp 不是正实数,则此方法返回零并将 errno 设置为 EDOM


复数作为 Python 对象

type PyComplexObject
PyObject 的这个子类型表示一个 Python 复数对象。
PyTypeObject PyComplex_Type
PyTypeObject 的这个实例表示 Python 复数类型。 它与 Python 层中的 complex 是同一个对象。
int PyComplex_Check(PyObject *p)
如果其参数是 PyComplexObjectPyComplexObject 的子类型,则返回 true。 此功能总是成功。
int PyComplex_CheckExact(PyObject *p)
如果其参数是 PyComplexObject,但不是 PyComplexObject 的子类型,则返回 true。 此功能总是成功。
PyObject *PyComplex_FromCComplex(Py_complex v)
从 C Py_complex 值创建一个新的 Python 复数对象。
PyObject *PyComplex_FromDoubles(double real, double imag)
realimag 返回一个新的 PyComplexObject 对象。
double PyComplex_RealAsDouble(PyObject *op)
op 的实部作为 C double 返回。
double PyComplex_ImagAsDouble(PyObject *op)
op 的虚部作为 C double 返回。
Py_complex PyComplex_AsCComplex(PyObject *op)

返回复数 opPy_complex 值。

如果 op 不是 Python 复数对象但具有 __complex__() 方法,则将首先调用该方法将 op 转换为 Python 复数对象。 如果 __complex__() 未定义,则回退到 __float__()。 如果 __float__() 未定义,则回退到 __index__()。 失败时,此方法返回 -1.0 作为实际值。

在 3.8 版更改:如果可用,请使用 __index__()