import re
import sys
import cgi
-import rexec
from xml.parsers import expat
LEFT, CENTER, RIGHT = "LEFT", "CENTER", "RIGHT"
def __init__(self):
self.cells = {} # {(x, y): cell, ...}
- self.rexec = rexec.RExec()
- m = self.rexec.add_module('__main__')
- m.cell = self.cellvalue
- m.cells = self.multicellvalue
- m.sum = sum
+ self.ns = dict(
+ cell = self.cellvalue,
+ cells = self.multicellvalue,
+ sum = sum,
+ )
def cellvalue(self, x, y):
cell = self.getcell(x, y)
if hasattr(cell, 'recalc'):
- return cell.recalc(self.rexec)
+ return cell.recalc(self.ns)
else:
return cell
self.reset()
for cell in self.cells.values():
if hasattr(cell, 'recalc'):
- cell.recalc(self.rexec)
+ cell.recalc(self.ns)
def display(self):
maxx, maxy = self.getsize()
if x <= 0 or y <= 0:
continue
if hasattr(cell, 'recalc'):
- cell.recalc(self.rexec)
+ cell.recalc(self.ns)
if hasattr(cell, 'format'):
text, alignment = cell.format()
assert isinstance(text, str)
Subclasses may but needn't provide the following APIs:
cell.reset() -- prepare for recalculation
- cell.recalc(rexec) -> value -- recalculate formula
+ cell.recalc(ns) -> value -- recalculate formula
cell.format() -> (value, alignment) -- return formatted value
cell.xml() -> string -- return XML
"""
self.fmt = fmt
self.alignment = alignment
- def recalc(self, rexec):
+ def recalc(self, ns):
return self.value
def format(self):
self.fmt = fmt
self.alignment = alignment
- def recalc(self, rexec):
+ def recalc(self, ns):
return self.text
def format(self):
def reset(self):
self.value = None
- def recalc(self, rexec):
+ def recalc(self, ns):
if self.value is None:
try:
# A hack to evaluate expressions using true division
- rexec.r_exec("from __future__ import division\n" +
- "__value__ = eval(%s)" % repr(self.translated))
- self.value = rexec.r_eval("__value__")
+ self.value = eval(self.translated, ns)
except:
exc = sys.exc_info()[0]
if hasattr(exc, "__name__"):
('tutorial/index', 'tutorial.tex',
'Python Tutorial', _stdauthor, 'manual'),
('using/index', 'using.tex',
- 'Python Setup', _stdauthor, 'manual'),
+ 'Python Setup and Usage', _stdauthor, 'manual'),
('whatsnew/' + version, 'whatsnew.tex',
'What\'s New in Python', 'A. M. Kuchling', 'howto'),
]
... return [obj.real, obj.imag]
... return json.JSONEncoder.default(self, obj)
...
- >>> dumps(2 + 1j, cls=ComplexEncoder)
+ >>> json.dumps(2 + 1j, cls=ComplexEncoder)
'[2.0, 1.0]'
>>> ComplexEncoder().encode(2 + 1j)
'[2.0, 1.0]'
>>> list(ComplexEncoder().iterencode(2 + 1j))
- ['[', '2.0', ', ', '1.0', ']']
+ ['[2.0', ', 1.0', ']']
.. highlight:: none
encoders and decoders. Otherwise, it will be a :exc:`ValueError` to encode
such floats.
- If *sort_keys* is ``True`` (the default), then the output of dictionaries
+ If *sort_keys* is ``True`` (default ``False``), then the output of dictionaries
will be sorted by key; this is useful for regression tests to ensure that
JSON serializations can be compared on a day-to-day basis.
pass
else:
return list(iterable)
- return JSONEncoder.default(self, o)
+ return json.JSONEncoder.default(self, o)
.. method:: encode(o)
Return a JSON string representation of a Python data structure, *o*. For
example::
- >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
+ >>> json.JSONEncoder().encode({"foo": ["bar", "baz"]})
'{"foo": ["bar", "baz"]}'
Encode the given object, *o*, and yield each string representation as
available. For example::
- for chunk in JSONEncoder().iterencode(bigobject):
+ for chunk in json.JSONEncoder().iterencode(bigobject):
mysocket.write(chunk)
.. literalinclude:: ../includes/mp_synchronize.py
-An showing how to use queues to feed tasks to a collection of worker process and
-collect the results:
+An example showing how to use queues to feed tasks to a collection of worker
+process and collect the results:
.. literalinclude:: ../includes/mp_workers.py
precision: `integer`
type: "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
-The *fill* character can be any character other than '}' (which signifies the
-end of the field). The presence of a fill character is signaled by the *next*
-character, which must be one of the alignment options. If the second character
-of *format_spec* is not a valid alignment option, then it is assumed that both
-the fill character and the alignment option are absent.
+The *fill* character can be any character other than '{' or '}'. The presence
+of a fill character is signaled by the character following it, which must be
+one of the alignment options. If the second character of *format_spec* is not
+a valid alignment option, then it is assumed that both the fill character and
+the alignment option are absent.
The meaning of the various alignment options is as follows:
Exceptions raised in the child process, before the new program has started to
execute, will be re-raised in the parent. Additionally, the exception object
will have one extra attribute called :attr:`child_traceback`, which is a string
-containing traceback information from the childs point of view.
+containing traceback information from the child's point of view.
The most common exception raised is :exc:`OSError`. This occurs, for example,
when trying to execute a non-existent file. Applications should prepare for
variable allows one or more threads to wait until they are notified by another
thread.
+ See :ref:`condition-objects`.
+
.. function:: current_thread()
with the :meth:`clear` method. The :meth:`wait` method blocks until the flag
is true.
+ See :ref:`event-objects`.
+
.. class:: local
acquired it, subsequent attempts to acquire it block, until it is released; any
thread may release it.
+ See :ref:`lock-objects`.
+
.. function:: RLock()
reentrant lock, the same thread may acquire it again without blocking; the
thread must release it once for each time it has acquired it.
+ See :ref:`rlock-objects`.
+
.. function:: Semaphore(value=1)
:noindex:
if necessary until it can return without making the counter negative. If not
given, *value* defaults to 1.
+ See :ref:`semaphore-objects`.
+
.. function:: BoundedSemaphore(value=1)
.. class:: Thread
+ :noindex:
A class that represents a thread of control. This class can be safely
subclassed in a limited fashion.
+ See :ref:`thread-objects`.
+
.. class:: Timer
+ :noindex:
A thread that executes a function after a specified interval has passed.
+ See :ref:`timer-objects`.
+
.. function:: settrace(func)
The execution of the :keyword:`with` statement with one "item" proceeds as follows:
-#. The context expression is evaluated to obtain a context manager.
+#. The context expression (the expression given in the :token:`with_item`) is
+ evaluated to obtain a context manager.
#. The context manager's :meth:`__enter__` method is invoked.
| ``+``, ``-`` | Addition and subtraction |
+-----------------------------------------------+-------------------------------------+
| ``*``, ``/``, ``//``, ``%`` | Multiplication, division, remainder |
+| | [#]_ |
+-----------------------------------------------+-------------------------------------+
| ``+x``, ``-x``, ``~x`` | Positive, negative, bitwise NOT |
+-----------------------------------------------+-------------------------------------+
the :keyword:`is` operator, like those involving comparisons between instance
methods, or constants. Check their documentation for more info.
+.. [#] The ``%`` is also used for string formatting; the same precedence applies.
+
.. [#] The power operator ``**`` binds less tightly than an arithmetic or
bitwise unary operator on its right, that is, ``2**-1`` is ``0.5``.
<span class="linkdescr">keep this under your pillow</span></p>
<p class="biglink"><a class="biglink" href="{{ pathto("reference/index") }}">Language Reference</a><br/>
<span class="linkdescr">describes syntax and language elements</span></p>
- <p class="biglink"><a class="biglink" href="{{ pathto("using/index") }}">Python Setup</a><br/>
+ <p class="biglink"><a class="biglink" href="{{ pathto("using/index") }}">Python Setup and Usage</a><br/>
<span class="linkdescr">how to use Python on different platforms</span></p>
<p class="biglink"><a class="biglink" href="{{ pathto("howto/index") }}">Python HOWTOs</a><br/>
<span class="linkdescr">in-depth documents on specific topics</span></p>
eliminating duplicate entries. Set objects also support mathematical operations
like union, intersection, difference, and symmetric difference.
-Curly braces or the :func:`set` function can be use to create sets. Note: To
+Curly braces or the :func:`set` function can be used to create sets. Note: To
create an empty set you have to use ``set()``, not ``{}``; the latter creates an
empty dictionary, a data structure that we discuss in the next section.
.. _using-index:
-################
- Python Setup
-################
+##########################
+ Python Setup and Usage
+##########################
This part of the documentation is devoted to general information on the setup
RANLIB= @RANLIB@
SVNVERSION= @SVNVERSION@
-GNULD= @GNULD@
+GNULD= @GNULD@
# Shell used by make (some versions default to the login shell, which is bad)
SHELL= /bin/sh
Permissions History
-------------------
+- Lukasz Langa was given commit access on Sep 08 2010 by GFB,
+ at suggestion of Antoine Pitrou, for general bug fixing.
+
+- Daniel Stutzbach was given commit access on Aug 22 2010 by MvL,
+ for general bug fixing.
+
+- Ask Solem was given commit access on Aug 17 2010 by MvL,
+ on recommendation by Jesse Noller, for work on the multiprocessing
+ library.
+
+- George Boutsioukis was given commit access on Aug 10 2010
+ by MvL, for work on 2to3.
+
+- Éric Araujo was given commit access on Aug 10 2010 by BAC,
+ at suggestion of Tarek Ziadé.
+
+- Terry Reedy was given commit access on Aug 04 2010 by MvL,
+ at suggestion of Nick Coghlan.
+
- Brian Quinlan was given commit access on Jul 26 2010 by GFB,
for work related to PEP 3148.
Perform the requested operation on file descriptor fd. The operation\n\
is defined by op and is operating system dependent. These constants are\n\
available from the fcntl module. The argument arg is optional, and\n\
-defaults to 0; it may be an int or a string. If arg is given as a string,\n\
+defaults to 0; it may be an int or a string. If arg is given as a string,\n\
the return value of fcntl is a string of that length, containing the\n\
-resulting value put in the arg buffer by the operating system.The length\n\
-of the arg string is not allowed to exceed 1024 bytes. If the arg given\n\
+resulting value put in the arg buffer by the operating system. The length\n\
+of the arg string is not allowed to exceed 1024 bytes. If the arg given\n\
is an integer or if none is specified, the result value is an integer\n\
corresponding to the return value of the fcntl call in the C code.");
projects / thirdparty / Python / cpython.git / commitdiff
