previous sections. We will break down the main differences between them. ::
typedef struct {
- PyListObject list;
- int state;
+ PyListObject list;
+ int state;
} Shoddy;
The primary difference for derived type objects is that the base type's object
static int
Shoddy_init(Shoddy *self, PyObject *args, PyObject *kwds)
{
- if (PyList_Type.tp_init((PyObject *)self, args, kwds) < 0)
- return -1;
- self->state = 0;
- return 0;
+ if (PyList_Type.tp_init((PyObject *)self, args, kwds) < 0)
+ return -1;
+ self->state = 0;
+ return 0;
}
In the :attr:`__init__` method for our type, we can see how to call through to
PyMODINIT_FUNC
PyInit_shoddy(void)
{
- PyObject *m;
+ PyObject *m;
- ShoddyType.tp_base = &PyList_Type;
- if (PyType_Ready(&ShoddyType) < 0)
- return NULL;
+ ShoddyType.tp_base = &PyList_Type;
+ if (PyType_Ready(&ShoddyType) < 0)
+ return NULL;
- m = PyModule_Create(&shoddymodule);
- if (m == NULL)
- return NULL;
+ m = PyModule_Create(&shoddymodule);
+ if (m == NULL)
+ return NULL;
- Py_INCREF(&ShoddyType);
- PyModule_AddObject(m, "Shoddy", (PyObject *) &ShoddyType);
+ Py_INCREF(&ShoddyType);
+ PyModule_AddObject(m, "Shoddy", (PyObject *) &ShoddyType);
}
Before calling :cfunc:`PyType_Ready`, the type structure must have the
typedef struct PyMethodDef {
char *ml_name; /* method name */
PyCFunction ml_meth; /* implementation function */
- int ml_flags; /* flags */
+ int ml_flags; /* flags */
char *ml_doc; /* docstring */
} PyMethodDef;
could code::
stdscr.addstr(0, 0, "Current mode: Typing mode",
- curses.A_REVERSE)
+ curses.A_REVERSE)
stdscr.refresh()
The curses library also supports color on those terminals that provide it, The
InternalDate = re.compile(r'INTERNALDATE "'
r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-'
- r'(?P<year>[0-9][0-9][0-9][0-9])'
+ r'(?P<year>[0-9][0-9][0-9][0-9])'
r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'
r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'
r'"')
"""
def __init__(self, sock=None):
- if sock is None:
- self.sock = socket.socket(
- socket.AF_INET, socket.SOCK_STREAM)
- else:
- self.sock = sock
+ if sock is None:
+ self.sock = socket.socket(
+ socket.AF_INET, socket.SOCK_STREAM)
+ else:
+ self.sock = sock
def connect(self, host, port):
self.sock.connect((host, port))
def mysend(self, msg):
- totalsent = 0
- while totalsent < MSGLEN:
- sent = self.sock.send(msg[totalsent:])
- if sent == 0:
- raise RuntimeError("socket connection broken")
- totalsent = totalsent + sent
+ totalsent = 0
+ while totalsent < MSGLEN:
+ sent = self.sock.send(msg[totalsent:])
+ if sent == 0:
+ raise RuntimeError("socket connection broken")
+ totalsent = totalsent + sent
def myreceive(self):
msg = ''
while len(msg) < MSGLEN:
- chunk = self.sock.recv(MSGLEN-len(msg))
- if chunk == '':
- raise RuntimeError("socket connection broken")
- msg = msg + chunk
+ chunk = self.sock.recv(MSGLEN-len(msg))
+ if chunk == '':
+ raise RuntimeError("socket connection broken")
+ msg = msg + chunk
return msg
The sending code here is usable for almost any messaging scheme - in Python you
looking at Apple ][ BASIC programs, published in French-language publications in
the mid-1980s, that had lines like these::
- PRINT "FICHIER EST COMPLETE."
- PRINT "CARACTERE NON ACCEPTE."
+ PRINT "FICHIER EST COMPLETE."
+ PRINT "CARACTERE NON ACCEPTE."
Those messages should contain accents, and they just look wrong to someone who
can read French.
character with value 0x12ca (4810 decimal). The Unicode standard contains a lot
of tables listing characters and their corresponding code points::
- 0061 'a'; LATIN SMALL LETTER A
- 0062 'b'; LATIN SMALL LETTER B
- 0063 'c'; LATIN SMALL LETTER C
- ...
- 007B '{'; LEFT CURLY BRACKET
+ 0061 'a'; LATIN SMALL LETTER A
+ 0062 'b'; LATIN SMALL LETTER B
+ 0063 'c'; LATIN SMALL LETTER C
+ ...
+ 007B '{'; LEFT CURLY BRACKET
Strictly, these definitions imply that it's meaningless to say 'this is
character U+12ca'. U+12ca is a code point, which represents some particular
assuming the default filesystem encoding is UTF-8, running the following
program::
- fn = 'filename\u4500abc'
- f = open(fn, 'w')
- f.close()
+ fn = 'filename\u4500abc'
+ f = open(fn, 'w')
+ f.close()
- import os
- print(os.listdir(b'.'))
- print(os.listdir('.'))
+ import os
+ print(os.listdir(b'.'))
+ print(os.listdir('.'))
will produce the following output::
- amk:~$ python t.py
- [b'.svn', b'filename\xe4\x94\x80abc', ...]
- ['.svn', 'filename\u4500abc', ...]
+ amk:~$ python t.py
+ [b'.svn', b'filename\xe4\x94\x80abc', ...]
+ ['.svn', 'filename\u4500abc', ...]
The first list contains UTF-8-encoded filenames, and the second list contains
the Unicode versions.
- [ ] Unicode introduction
- [ ] ASCII
- [ ] Terms
- - [ ] Character
- - [ ] Code point
- - [ ] Encodings
- - [ ] Common encodings: ASCII, Latin-1, UTF-8
+ - [ ] Character
+ - [ ] Code point
+ - [ ] Encodings
+ - [ ] Common encodings: ASCII, Latin-1, UTF-8
- [ ] Unicode Python type
- - [ ] Writing unicode literals
- - [ ] Obscurity: -U switch
- - [ ] Built-ins
- - [ ] unichr()
- - [ ] ord()
- - [ ] unicode() constructor
- - [ ] Unicode type
- - [ ] encode(), decode() methods
+ - [ ] Writing unicode literals
+ - [ ] Obscurity: -U switch
+ - [ ] Built-ins
+ - [ ] unichr()
+ - [ ] ord()
+ - [ ] unicode() constructor
+ - [ ] Unicode type
+ - [ ] encode(), decode() methods
- [ ] Unicodedata module for character properties
- [ ] I/O
- - [ ] Reading/writing Unicode data into files
- - [ ] Byte-order marks
- - [ ] Unicode filenames
+ - [ ] Reading/writing Unicode data into files
+ - [ ] Byte-order marks
+ - [ ] Unicode filenames
- [ ] Writing Unicode programs
- - [ ] Do everything in Unicode
- - [ ] Declaring source code encodings (PEP 263)
+ - [ ] Do everything in Unicode
+ - [ ] Declaring source code encodings (PEP 263)
- [ ] Other issues
- - [ ] Building Python (UCS2, UCS4)
+ - [ ] Building Python (UCS2, UCS4)
Register *subclass* as a "virtual subclass" of this ABC. For
example::
- from abc import ABCMeta
+ from abc import ABCMeta
- class MyABC(metaclass=ABCMeta):
- pass
+ class MyABC(metaclass=ABCMeta):
+ pass
- MyABC.register(tuple)
+ MyABC.register(tuple)
- assert issubclass(tuple, MyABC)
- assert isinstance((), MyABC)
+ assert issubclass(tuple, MyABC)
+ assert isinstance((), MyABC)
You can also override this method in an abstract base class:
:class:`Hashable` ``__hash__``
:class:`Iterable` ``__iter__``
:class:`Iterator` :class:`Iterable` ``__next__`` ``__iter__``
-:class:`Sized` ``__len__``
+:class:`Sized` ``__len__``
:class:`Callable` ``__call__``
:class:`Sequence` :class:`Sized`, ``__getitem__`` ``__contains__``. ``__iter__``, ``__reversed__``.
:class:`MutableMapping` :class:`Mapping` ``__getitem__`` Inherited Mapping methods and
``__setitem__``, ``pop``, ``popitem``, ``clear``, ``update``,
``__delitem__``, and ``setdefault``
- ``__iter__``, and
+ ``__iter__``, and
``__len__``
:class:`MappingView` :class:`Sized` ``__len__``
size = None
if isinstance(myvar, collections.Sized):
- size = len(myvar)
+ size = len(myvar)
Several of the ABCs are also useful as mixins that make it easier to develop
classes supporting container APIs. For example, to write a class supporting
animals = ['mollusk',
'albatross',
- 'rat',
- 'penguin',
- 'python',
- ]
+ 'rat',
+ 'penguin',
+ 'python', ]
# ...
for a in animals:
print(a)
animals = [_('mollusk'),
_('albatross'),
- _('rat'),
- _('penguin'),
- _('python'),
- ]
+ _('rat'),
+ _('penguin'),
+ _('python'), ]
del _
animals = [N_('mollusk'),
N_('albatross'),
- N_('rat'),
- N_('penguin'),
- N_('python'),
- ]
+ N_('rat'),
+ N_('penguin'),
+ N_('python'), ]
# ...
for a in animals:
>>> from multiprocessing import Pool
>>> p = Pool(5)
>>> def f(x):
- ... return x*x
+ ... return x*x
...
>>> p.map(f, [1,2,3])
Process PoolWorker-1:
:class:`OptionGroup` to a parser is easy::
group = OptionGroup(parser, "Dangerous Options",
- "Caution: use these options at your own risk. "
- "It is believed that some of them bite.")
+ "Caution: use these options at your own risk. "
+ "It is believed that some of them bite.")
group.add_option("-g", action="store_true", help="Group option.")
parser.add_option_group(group)
-q, --quiet be vewwy quiet (I'm hunting wabbits)
-fFILE, --file=FILE write output to FILE
-mMODE, --mode=MODE interaction mode: one of 'novice', 'intermediate'
- [default], 'expert'
+ [default], 'expert'
Dangerous Options:
- Caution: use of these options is at your own risk. It is believed that
- some of them bite.
- -g Group option.
+ Caution: use of these options is at your own risk. It is believed that
+ some of them bite.
+ -g Group option.
.. _optparse-printing-version-string:
... print(time.time())
... Timer(5, print_time, ()).start()
... Timer(10, print_time, ()).start()
- ... time.sleep(11) # sleep while time-delay events execute
+ ... time.sleep(11) # sleep while time-delay events execute
... print(time.time())
...
>>> print_some_times()
socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
af, socktype, proto, canonname, sa = res
try:
- s = socket.socket(af, socktype, proto)
+ s = socket.socket(af, socktype, proto)
except socket.error as msg:
- s = None
- continue
+ s = None
+ continue
try:
- s.bind(sa)
- s.listen(1)
+ s.bind(sa)
+ s.listen(1)
except socket.error as msg:
- s.close()
- s = None
- continue
+ s.close()
+ s = None
+ continue
break
if s is None:
print('could not open socket')
for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM):
af, socktype, proto, canonname, sa = res
try:
- s = socket.socket(af, socktype, proto)
+ s = socket.socket(af, socktype, proto)
except socket.error as msg:
- s = None
- continue
+ s = None
+ continue
try:
- s.connect(sa)
+ s.connect(sa)
except socket.error as msg:
- s.close()
- s = None
- continue
+ s.close()
+ s = None
+ continue
break
if s is None:
print('could not open socket')
Tuples can often be created without their parentheses, but not here::
- >>> [x, x**2 for x in vec] # error - parens required for tuples
+ >>> [x, x**2 for x in vec] # error - parens required for tuples
File "<stdin>", line 1, in ?
[x, x**2 for x in vec]
^
>>> locale.format("%d", x, grouping=True)
'1,234,567'
>>> locale.format("%s%.*f", (conv['currency_symbol'],
- ... conv['frac_digits'], x), grouping=True)
+ ... conv['frac_digits'], x), grouping=True)
'$1,234,567.80'
# containing the substring S.
sublist = filter( lambda s, substring=S:
string.find(s, substring) != -1,
- L)
+ L)
Because of Python's scoping rules, a default argument is used so that the
anonymous function created by the :keyword:`lambda` statement knows what
[ expression for expr in sequence1
for expr2 in sequence2 ...
- for exprN in sequenceN
+ for exprN in sequenceN
if condition ]
The :keyword:`for`...\ :keyword:`in` clauses contain the sequences to be
def __init__(self, value):
self.value = value
def __iadd__(self, increment):
- return Number( self.value + increment)
+ return Number( self.value + increment)
n = Number(5)
n += 3
from distutils.core import setup, Extension
expat_extension = Extension('xml.parsers.pyexpat',
- define_macros = [('XML_NS', None)],
- include_dirs = [ 'extensions/expat/xmltok',
- 'extensions/expat/xmlparse' ],
- sources = [ 'extensions/pyexpat.c',
- 'extensions/expat/xmltok/xmltok.c',
- 'extensions/expat/xmltok/xmlrole.c',
- ]
+ define_macros = [('XML_NS', None)],
+ include_dirs = [ 'extensions/expat/xmltok',
+ 'extensions/expat/xmlparse' ],
+ sources = [ 'extensions/pyexpat.c',
+ 'extensions/expat/xmltok/xmltok.c',
+ 'extensions/expat/xmltok/xmlrole.c', ]
)
setup (name = "PyXML", version = "0.5.4",
ext_modules =[ expat_extension ] )
class D (B,C):
def save (self):
- # Call superclass .save()
+ # Call superclass .save()
super(D, self).save()
# Save D's private information here
...
different keyword arguments. ::
class Popen(args, bufsize=0, executable=None,
- stdin=None, stdout=None, stderr=None,
- preexec_fn=None, close_fds=False, shell=False,
- cwd=None, env=None, universal_newlines=False,
- startupinfo=None, creationflags=0):
+ stdin=None, stdout=None, stderr=None,
+ preexec_fn=None, close_fds=False, shell=False,
+ cwd=None, env=None, universal_newlines=False,
+ startupinfo=None, creationflags=0):
*args* is commonly a sequence of strings that will be the arguments to the
program executed as the subprocess. (If the *shell* argument is true, *args*
def factorial(queue, N):
- "Compute a factorial."
- # If N is a multiple of 4, this function will take much longer.
- if (N % 4) == 0:
- time.sleep(.05 * N/4)
+ "Compute a factorial."
+ # If N is a multiple of 4, this function will take much longer.
+ if (N % 4) == 0:
+ time.sleep(.05 * N/4)
- # Calculate the result
- fact = 1L
- for i in range(1, N+1):
- fact = fact * i
+ # Calculate the result
+ fact = 1L
+ for i in range(1, N+1):
+ fact = fact * i
- # Put the result on the queue
- queue.put(fact)
+ # Put the result on the queue
+ queue.put(fact)
if __name__ == '__main__':
- queue = Queue()
+ queue = Queue()
- N = 5
+ N = 5
- p = Process(target=factorial, args=(queue, N))
- p.start()
- p.join()
+ p = Process(target=factorial, args=(queue, N))
+ p.start()
+ p.join()
- result = queue.get()
- print 'Factorial', N, '=', result
+ result = queue.get()
+ print 'Factorial', N, '=', result
A :class:`Queue` is used to communicate the input parameter *N* and
the result. The :class:`Queue` object is stored in a global variable.
from multiprocessing import Pool
def factorial(N, dictionary):
- "Compute a factorial."
- ...
+ "Compute a factorial."
+ ...
p = Pool(5)
result = p.map(factorial, range(1, 1000, 10))
for v in result:
- print v
+ print v
This produces the following output::
('id', 'name', 'type', 'size')
>>> var = var_type(1, 'frequency', 'int', 4)
- >>> print var[0], var.id # Equivalent
+ >>> print var[0], var.id # Equivalent
1 1
- >>> print var[2], var.type # Equivalent
+ >>> print var[2], var.type # Equivalent
int int
>>> var._asdict()
{'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
>>> list(itertools.product([1,2,3], [4,5,6]))
[(1, 4), (1, 5), (1, 6),
- (2, 4), (2, 5), (2, 6),
- (3, 4), (3, 5), (3, 6)]
+ (2, 4), (2, 5), (2, 6),
+ (3, 4), (3, 5), (3, 6)]
The optional *repeat* keyword argument is used for taking the
product of an iterable or a set of iterables with themselves,
projects / python / commitdiff