other = ToComplex(other)
return cmp(other, self)
- def __nonzero__(self):
+ def __bool__(self):
return not (self.re == self.im == 0)
abs = radius = __abs__
return cmp(Rat(a), b)
# a != 0
- def __nonzero__(a):
+ def __bool__(a):
return a.__num != 0
# coercion
Return the outcome of \keyword{not} \var{o}. (Note that there is no
\method{__not__()} method for object instances; only the interpreter
core defines this operation. The result is affected by the
-\method{__nonzero__()} and \method{__len__()} methods.)
+\method{__bool__()} and \method{__len__()} methods.)
\end{funcdesc}
\begin{funcdesc}{truth}{o}
\item any empty mapping, for example, \code{\{\}}.
\item instances of user-defined classes, if the class defines a
- \method{__nonzero__()} or \method{__len__()} method, when that
+ \method{__bool__()} or \method{__len__()} method, when that
method returns the integer zero or \class{bool} value
\code{False}.\footnote{Additional
information on these special methods may be found in the
missing and present object attributes.
\begin{verbatim}
-% timeit.py 'try:' ' str.__nonzero__' 'except AttributeError:' ' pass'
+% timeit.py 'try:' ' str.__bool__' 'except AttributeError:' ' pass'
100000 loops, best of 3: 15.7 usec per loop
-% timeit.py 'if hasattr(str, "__nonzero__"): pass'
+% timeit.py 'if hasattr(str, "__bool__"): pass'
100000 loops, best of 3: 4.26 usec per loop
-% timeit.py 'try:' ' int.__nonzero__' 'except AttributeError:' ' pass'
+% timeit.py 'try:' ' int.__bool__' 'except AttributeError:' ' pass'
1000000 loops, best of 3: 1.43 usec per loop
-% timeit.py 'if hasattr(int, "__nonzero__"): pass'
+% timeit.py 'if hasattr(int, "__bool__"): pass'
100000 loops, best of 3: 2.23 usec per loop
\end{verbatim}
>>> import timeit
>>> s = """\
... try:
-... str.__nonzero__
+... str.__bool__
... except AttributeError:
... pass
... """
>>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)
17.09 usec/pass
>>> s = """\
-... if hasattr(str, '__nonzero__'): pass
+... if hasattr(str, '__bool__'): pass
... """
>>> t = timeit.Timer(stmt=s)
>>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)
4.85 usec/pass
>>> s = """\
... try:
-... int.__nonzero__
+... int.__bool__
... except AttributeError:
... pass
... """
>>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)
1.97 usec/pass
>>> s = """\
-... if hasattr(int, '__nonzero__'): pass
+... if hasattr(int, '__bool__'): pass
... """
>>> t = timeit.Timer(stmt=s)
>>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)
also accept an integer, however, use of the handle object is
encouraged.
- Handle objects provide semantics for \method{__nonzero__()} - thus
+ Handle objects provide semantics for \method{__bool__()} - thus
\begin{verbatim}
if handle:
print "Yes"
This class may be initialized from any Python value; the instance
returned depends only on its truth value. It supports various Python
operators through \method{__cmp__()}, \method{__repr__()},
-\method{__int__()}, and \method{__nonzero__()} methods, all
+\method{__int__()}, and \method{__bool__()} methods, all
implemented in the obvious ways.
It also has the following method, supported mainly for internal use by
\withsubitem{(object method)}{\ttindex{__cmp__()}}
\end{methoddesc}
-\begin{methoddesc}[object]{__nonzero__}{self}
+\begin{methoddesc}[object]{__bool__}{self}
Called to implement truth value testing, and the built-in operation
-\code{bool()}; should return \code{False} or \code{True}, or their
-integer equivalents \code{0} or \code{1}.
+\code{bool()}; should return \code{False} or \code{True}.
When this method is not defined, \method{__len__()} is
-called, if it is defined (see below). If a class defines neither
-\method{__len__()} nor \method{__nonzero__()}, all its instances are
+called, if it is defined (see below) and \code{True} is returned when
+the length is not zero. If a class defines neither
+\method{__len__()} nor \method{__bool__()}, all its instances are
considered true.
\withsubitem{(mapping object method)}{\ttindex{__len__()}}
\end{methoddesc}
Called to implement the built-in function
\function{len()}\bifuncindex{len}. Should return the length of the
object, an integer \code{>=} 0. Also, an object that doesn't define a
-\method{__nonzero__()} method and whose \method{__len__()} method
+\method{__bool__()} method and whose \method{__len__()} method
returns zero is considered to be false in a Boolean context.
-\withsubitem{(object method)}{\ttindex{__nonzero__()}}
+\withsubitem{(object method)}{\ttindex{__bool__()}}
\end{methoddesc}
\begin{methoddesc}[container object]{__getitem__}{self, key}
unaryfunc nb_negative;
unaryfunc nb_positive;
unaryfunc nb_absolute;
- inquiry nb_nonzero;
+ inquiry nb_bool;
unaryfunc nb_invert;
binaryfunc nb_lshift;
binaryfunc nb_rshift;
return other
return 0
- def __nonzero__(self):
+ def __bool__(self):
"""Is the number non-zero?
0 if self == 0
1 if self != 0
"""
if self._is_special:
- return 1
+ return True
return sum(self._int) != 0
def __cmp__(self, other, context=None):
i = int(self)
if self == Decimal(i):
return hash(i)
- assert self.__nonzero__() # '-0' handled by integer case
+ assert self.__bool__() # '-0' handled by integer case
return hash(str(self.normalize()))
def as_tuple(self):
def test_convert_to_bool(self):
# Verify that TypeError occurs when bad things are returned
- # from __nonzero__(). This isn't really a bool test, but
+ # from __bool__(). This isn't really a bool test, but
# it's related.
check = lambda o: self.assertRaises(TypeError, bool, o)
class Foo(object):
- def __nonzero__(self):
+ def __bool__(self):
return self
check(Foo())
class Bar(object):
- def __nonzero__(self):
+ def __bool__(self):
return "Yes"
check(Bar())
class Baz(int):
- def __nonzero__(self):
+ def __bool__(self):
return self
check(Baz())
+ # __bool__() must return a bool not an int
+ class Spam(int):
+ def __bool__(self):
+ return 1
+ check(Spam())
+
+ class Eggs:
+ def __len__(self):
+ return -1
+ self.assertRaises(ValueError, bool, Eggs())
+
+ def test_sane_len(self):
+ # this test just tests our assumptions about __len__
+ # this will start failing if __len__ changes assertions
+ for badval in ['illegal', -1, 1 << 32]:
+ class A:
+ def __len__(self):
+ return badval
+ try:
+ bool(A())
+ except (Exception), e_bool:
+ pass
+ try:
+ len(A())
+ except (Exception), e_len:
+ pass
+ self.assertEqual(str(e_bool), str(e_len))
def test_main():
test_support.run_unittest(BoolTest)
]
class TestFailingBool:
- def __nonzero__(self):
+ def __bool__(self):
raise RuntimeError
class TestFailingIter:
checkSameDec("__mod__", True)
checkSameDec("__mul__", True)
checkSameDec("__neg__")
- checkSameDec("__nonzero__")
+ checkSameDec("__bool__")
checkSameDec("__pos__")
checkSameDec("__pow__", True)
checkSameDec("__radd__", True)
if verbose: print "Testing int operations..."
numops(100, 3)
# The following crashes in Python 2.2
- vereq((1).__nonzero__(), 1)
- vereq((0).__nonzero__(), 0)
+ vereq((1).__bool__(), True)
+ vereq((0).__bool__(), False)
# This returns 'NotImplemented' in Python 2.2
class C(int):
def __add__(self, other):
class Proxy(object):
def __init__(self, x):
self.x = x
- def __nonzero__(self):
+ def __bool__(self):
return not not self.x
def __hash__(self):
return hash(self.x)
class DProxy(object):
def __init__(self, x):
self.x = x
- def __nonzero__(self):
+ def __bool__(self):
return not not self.x
def __hash__(self):
return hash(self.x)
class Boolean:
def __init__(self, truth):
self.truth = truth
- def __nonzero__(self):
+ def __bool__(self):
return self.truth
- bTrue = Boolean(1)
- bFalse = Boolean(0)
+ bTrue = Boolean(True)
+ bFalse = Boolean(False)
class Seq:
def __init__(self, *args):
def test_truth(self):
class C(object):
- def __nonzero__(self):
+ def __bool__(self):
raise SyntaxError
self.failUnlessRaises(TypeError, operator.truth)
self.failUnlessRaises(SyntaxError, operator.truth, C())
def __hash__(self):
raise TypeError, "Vectors cannot be hashed"
- def __nonzero__(self):
+ def __bool__(self):
raise TypeError, "Vectors cannot be used in Boolean contexts"
def __cmp__(self, other):
for ops in opmap.itervalues():
for op in ops:
- # calls __nonzero__, which should fail
+ # calls __bool__, which should fail
self.assertRaises(TypeError, bool, op(a, b))
class NumberTest(unittest.TestCase):
self.assertRaises(RuntimeError, cmp, a, b)
def test_not(self):
- # Check that exceptions in __nonzero__ are properly
+ # Check that exceptions in __bool__ are properly
# propagated by the not operator
import operator
class Exc(Exception):
pass
class Bad:
- def __nonzero__(self):
+ def __bool__(self):
raise Exc
def do(bad):
prefix = EMPTY_PREFIX # non-null only for NS elements and attributes
- def __nonzero__(self):
+ def __bool__(self):
return True
def toxml(self, encoding = None):
Core and Builtins
-----------------
+- Renamed nb_nonzero to nb_bool and __nonzero__ to __bool__
+
- Classic classes are a thing of the past. All classes are new style.
- Exceptions *must* derive from BaseException.
{ NULL, NULL },
};
-static int Simple_nonzero(CDataObject *self)
+static int Simple_bool(CDataObject *self)
{
return memcmp(self->b_ptr, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", self->b_size);
}
0, /* nb_negative */
0, /* nb_positive */
0, /* nb_absolute */
- (inquiry)Simple_nonzero, /* nb_nonzero */
+ (inquiry)Simple_bool, /* nb_bool */
};
#if (PY_VERSION_HEX < 0x02040000)
};
static int
-Pointer_nonzero(CDataObject *self)
+Pointer_bool(CDataObject *self)
{
return *(void **)self->b_ptr != NULL;
}
0, /* nb_negative */
0, /* nb_positive */
0, /* nb_absolute */
- (inquiry)Pointer_nonzero, /* nb_nonzero */
+ (inquiry)Pointer_bool, /* nb_bool */
};
PyTypeObject Pointer_Type = {
}
static int
-delta_nonzero(PyDateTime_Delta *self)
+delta_bool(PyDateTime_Delta *self)
{
return (GET_TD_DAYS(self) != 0
|| GET_TD_SECONDS(self) != 0
(unaryfunc)delta_negative, /* nb_negative */
(unaryfunc)delta_positive, /* nb_positive */
(unaryfunc)delta_abs, /* nb_absolute */
- (inquiry)delta_nonzero, /* nb_nonzero */
+ (inquiry)delta_bool, /* nb_bool */
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /* nb_negative */
0, /* nb_positive */
0, /* nb_absolute */
- 0, /* nb_nonzero */
+ 0, /* nb_bool */
};
static PyTypeObject PyDateTime_DateType = {
}
static int
-time_nonzero(PyDateTime_Time *self)
+time_bool(PyDateTime_Time *self)
{
int offset;
int none;
0, /* nb_negative */
0, /* nb_positive */
0, /* nb_absolute */
- (inquiry)time_nonzero, /* nb_nonzero */
+ (inquiry)time_bool, /* nb_bool */
};
static PyTypeObject PyDateTime_TimeType = {
0, /* nb_negative */
0, /* nb_positive */
0, /* nb_absolute */
- 0, /* nb_nonzero */
+ 0, /* nb_bool */
};
static PyTypeObject PyDateTime_DateTimeType = {
0, /* nb_negative */
0, /* nb_positive */
0, /* nb_absolute */
- 0, /* nb_nonzero */
+ 0, /* nb_bool */
0, /* nb_invert */
0, /* nb_lshift */
0, /* nb_rshift */
}
static int
-complex_nonzero(PyComplexObject *v)
+complex_bool(PyComplexObject *v)
{
return v->cval.real != 0.0 || v->cval.imag != 0.0;
}
(unaryfunc)complex_neg, /* nb_negative */
(unaryfunc)complex_pos, /* nb_positive */
(unaryfunc)complex_abs, /* nb_absolute */
- (inquiry)complex_nonzero, /* nb_nonzero */
+ (inquiry)complex_bool, /* nb_bool */
0, /* nb_invert */
0, /* nb_lshift */
0, /* nb_rshift */
}
static int
-float_nonzero(PyFloatObject *v)
+float_bool(PyFloatObject *v)
{
return v->ob_fval != 0.0;
}
(unaryfunc)float_neg, /*nb_negative*/
(unaryfunc)float_pos, /*nb_positive*/
(unaryfunc)float_abs, /*nb_absolute*/
- (inquiry)float_nonzero, /*nb_nonzero*/
+ (inquiry)float_bool, /*nb_bool*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
}
static int
-int_nonzero(PyIntObject *v)
+int_bool(PyIntObject *v)
{
return v->ob_ival != 0;
}
(unaryfunc)int_neg, /*nb_negative*/
(unaryfunc)int_pos, /*nb_positive*/
(unaryfunc)int_abs, /*nb_absolute*/
- (inquiry)int_nonzero, /*nb_nonzero*/
+ (inquiry)int_bool, /*nb_bool*/
(unaryfunc)int_invert, /*nb_invert*/
(binaryfunc)int_lshift, /*nb_lshift*/
(binaryfunc)int_rshift, /*nb_rshift*/
(binaryfunc)int_and, /*nb_and*/
(binaryfunc)int_xor, /*nb_xor*/
(binaryfunc)int_or, /*nb_or*/
- 0, /*nb_coerce*/
+ 0, /*nb_coerce*/
(unaryfunc)int_int, /*nb_int*/
(unaryfunc)int_long, /*nb_long*/
(unaryfunc)int_float, /*nb_float*/
}
static int
-long_nonzero(PyLongObject *v)
+long_bool(PyLongObject *v)
{
return ABS(v->ob_size) != 0;
}
(unaryfunc) long_neg, /*nb_negative*/
(unaryfunc) long_pos, /*tp_positive*/
(unaryfunc) long_abs, /*tp_absolute*/
- (inquiry) long_nonzero, /*tp_nonzero*/
+ (inquiry) long_bool, /*tp_bool*/
(unaryfunc) long_invert, /*nb_invert*/
long_lshift, /*nb_lshift*/
(binaryfunc) long_rshift, /*nb_rshift*/
if (v == Py_None)
return 0;
else if (v->ob_type->tp_as_number != NULL &&
- v->ob_type->tp_as_number->nb_nonzero != NULL)
- res = (*v->ob_type->tp_as_number->nb_nonzero)(v);
+ v->ob_type->tp_as_number->nb_bool != NULL)
+ res = (*v->ob_type->tp_as_number->nb_bool)(v);
else if (v->ob_type->tp_as_mapping != NULL &&
v->ob_type->tp_as_mapping->mp_length != NULL)
res = (*v->ob_type->tp_as_mapping->mp_length)(v);
0, /*nb_negative*/
0, /*nb_positive*/
0, /*nb_absolute*/
- 0, /*nb_nonzero*/
+ 0, /*nb_bool*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_negative*/
0, /*nb_positive*/
0, /*nb_absolute*/
- 0, /*nb_nonzero*/
+ 0, /*nb_bool*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
COPYNUM(nb_negative);
COPYNUM(nb_positive);
COPYNUM(nb_absolute);
- COPYNUM(nb_nonzero);
+ COPYNUM(nb_bool);
COPYNUM(nb_invert);
COPYNUM(nb_lshift);
COPYNUM(nb_rshift);
SLOT0(slot_nb_absolute, "__abs__")
static int
-slot_nb_nonzero(PyObject *self)
+slot_nb_bool(PyObject *self)
{
PyObject *func, *args;
- static PyObject *nonzero_str, *len_str;
+ static PyObject *bool_str, *len_str;
int result = -1;
+ int from_len = 0;
- func = lookup_maybe(self, "__nonzero__", &nonzero_str);
+ func = lookup_maybe(self, "__bool__", &bool_str);
if (func == NULL) {
if (PyErr_Occurred())
return -1;
func = lookup_maybe(self, "__len__", &len_str);
if (func == NULL)
return PyErr_Occurred() ? -1 : 1;
+ from_len = 1;
}
args = PyTuple_New(0);
if (args != NULL) {
PyObject *temp = PyObject_Call(func, args, NULL);
Py_DECREF(args);
if (temp != NULL) {
- if (PyInt_CheckExact(temp) || PyBool_Check(temp))
+ if (from_len) {
+ /* enforced by slot_nb_len */
result = PyObject_IsTrue(temp);
+ }
+ else if (PyBool_Check(temp)) {
+ result = PyObject_IsTrue(temp);
+ }
else {
PyErr_Format(PyExc_TypeError,
- "__nonzero__ should return "
- "bool or int, returned %s",
- temp->ob_type->tp_name);
+ "__bool__ should return "
+ "bool, returned %s",
+ temp->ob_type->tp_name);
result = -1;
}
Py_DECREF(temp);
UNSLOT("__pos__", nb_positive, slot_nb_positive, wrap_unaryfunc, "+x"),
UNSLOT("__abs__", nb_absolute, slot_nb_absolute, wrap_unaryfunc,
"abs(x)"),
- UNSLOT("__nonzero__", nb_nonzero, slot_nb_nonzero, wrap_inquirypred,
+ UNSLOT("__bool__", nb_bool, slot_nb_bool, wrap_inquirypred,
"x != 0"),
UNSLOT("__invert__", nb_invert, slot_nb_invert, wrap_unaryfunc, "~x"),
BINSLOT("__lshift__", nb_lshift, slot_nb_lshift, "<<"),
WRAP_BINARY(proxy_ior, PyNumber_InPlaceOr)
static int
-proxy_nonzero(PyWeakReference *proxy)
+proxy_bool(PyWeakReference *proxy)
{
PyObject *o = PyWeakref_GET_OBJECT(proxy);
if (!proxy_checkref(proxy))
proxy_neg, /*nb_negative*/
proxy_pos, /*nb_positive*/
proxy_abs, /*nb_absolute*/
- (inquiry)proxy_nonzero, /*nb_nonzero*/
+ (inquiry)proxy_bool, /*nb_bool*/
proxy_invert, /*nb_invert*/
proxy_lshift, /*nb_lshift*/
proxy_rshift, /*nb_rshift*/
"handle - The integer Win32 handle.\n"
"\n"
"Operations:\n"
-"__nonzero__ - Handles with an open object return true, otherwise false.\n"
+"__bool__ - Handles with an open object return true, otherwise false.\n"
"__int__ - Converting a handle to an integer returns the Win32 handle.\n"
"__cmp__ - Handle objects are compared using the handle value.");
}
static int
-PyHKEY_nonzeroFunc(PyObject *ob)
+PyHKEY_boolFunc(PyObject *ob)
{
return ((PyHKEYObject *)ob)->hkey != 0;
}
PyHKEY_unaryFailureFunc, /* nb_negative */
PyHKEY_unaryFailureFunc, /* nb_positive */
PyHKEY_unaryFailureFunc, /* nb_absolute */
- PyHKEY_nonzeroFunc, /* nb_nonzero */
+ PyHKEY_boolFunc, /* nb_bool */
PyHKEY_unaryFailureFunc, /* nb_invert */
PyHKEY_binaryFailureFunc, /* nb_lshift */
PyHKEY_binaryFailureFunc, /* nb_rshift */
projects / python / commitdiff