Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Merged revisions 67060-67061 via svnmerge from 

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r67060 | benjamin.peterson | 2008-10-30 17:39:25 -0500 (Thu, 30 Oct 2008) | 1 line

  backport bin() documentation
........
  r67061 | benjamin.peterson | 2008-10-30 17:44:18 -0500 (Thu, 30 Oct 2008) | 1 line

  finish backporting binary literals and new octal literals docs
........
This commit is contained in:
Benjamin Peterson 2008-10-30 23:00:52 +00:00
parent 8efccfdfd1
commit f4d016f38a
3 changed files with 23 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Doc/library/functions.rst
View File

@ -112,6 +112,15 @@ available. They are listed here in alphabetical order.
.. versionadded:: 2.3
.. function:: bin(x)
Convert an integer number to a binary string. The result is a valid Python
expression. If *x* is not a Python :class:`int` object, it has to define an
:meth:`__index__` method that returns an integer.
.. versionadded:: 2.6
.. function:: bool([x])
Convert a value to a Boolean, using the standard truth testing procedure. If

17
Doc/library/stdtypes.rst
View File

@ -246,14 +246,15 @@ Complex numbers have a real and imaginary part, which are each implemented using
pair: octal; literals
Numbers are created by numeric literals or as the result of built-in functions
and operators. Unadorned integer literals (including hex and octal numbers)
yield plain integers unless the value they denote is too large to be represented
as a plain integer, in which case they yield a long integer. Integer literals
with an ``'L'`` or ``'l'`` suffix yield long integers (``'L'`` is preferred
because ``1l`` looks too much like eleven!). Numeric literals containing a
decimal point or an exponent sign yield floating point numbers. Appending
``'j'`` or ``'J'`` to a numeric literal yields a complex number with a zero real
part. A complex numeric literal is the sum of a real and an imaginary part.
and operators. Unadorned integer literals (including binary, hex, and octal
numbers) yield plain integers unless the value they denote is too large to be
represented as a plain integer, in which case they yield a long integer.
Integer literals with an ``'L'`` or ``'l'`` suffix yield long integers (``'L'``
is preferred because ``1l`` looks too much like eleven!). Numeric literals
containing a decimal point or an exponent sign yield floating point numbers.
Appending ``'j'`` or ``'J'`` to a numeric literal yields a complex number with a
zero real part. A complex numeric literal is the sum of a real and an imaginary
part.
.. index::
single: arithmetic

7
Doc/reference/lexical_analysis.rst
View File

@ -605,6 +605,7 @@ Numeric literals
single: long integer literal
single: floating point literal
single: hexadecimal literal
single: binary literal
single: octal literal
single: decimal literal
single: imaginary literal
@ -629,12 +630,14 @@ definitions:
.. productionlist::
longinteger: `integer` ("l" | "L")
integer: `decimalinteger` | `octinteger` | `hexinteger`
integer: `decimalinteger` | `octinteger` | `hexinteger` | `bininteger`
decimalinteger: `nonzerodigit` `digit`* | "0"
octinteger: "0" `octdigit`+
octinteger: "0" ("o" | "O") `octdigit`+ | "0" `octdigit`+
hexinteger: "0" ("x" | "X") `hexdigit`+
bininteger: "0" ("b" | "B") `bindigit`+
nonzerodigit: "1"..."9"
octdigit: "0"..."7"
bindigit: "0" | "1"
hexdigit: `digit` | "a"..."f" | "A"..."F"
Although both lower case ``'l'`` and upper case ``'L'`` are allowed as suffix