It is possible:

>>> x, y = '', 0 * 1e400
>>> sum(0 * x, y) == y
False

The sorted function returns a list instead of an iterator. It's explicitly written in the documentation and therefore explains the behavior (you can compare lists structurally, but you can't do that obviously with the iterators without iterating them).

Nice list! The containment test chaining example reminded me to file https://bugs.python.org/issue32055, since while the current behaviour does follow from the language definition, it's far from clear that containment tests should really participate in comparison chaining that same way other operators do.

You're trying to compare different types. It is obvious that a list and a tuple are completely different objects.

>>> a = [0, 0]  # a is a list
>>> (x, y) = a  # unpacking a list; (x, y) is a tuple
>>> (x, y) == a  # comparing a tuple to a list 
False

Proof:

>>> a = [0, 0]
>>> type(a)
<class 'list'>
>>> (x, y) = a
>>> type((x, y))
<class 'tuple'>

sorted() always returns a list.

>>> type((1, 2, 3))
<class 'tuple'>
>>> type(sorted((1, 2, 3)))
<class 'list'>

Sorry to bother you, but there is no type mixing here:

>>> int(2 * 3)
6
>>> int(2 * '3')
33
>>> int('2' * 3)
222

3 * '2' is a shorthand for '2' + '2' + '2':

>>> 3 * '2'
'222'
>>> '2' + '2' + '2'
'222'

You can't actually mix types in Python like you do in PHP. This is a magic type mixing:

$foo = "0";  // $foo is a string
$foo += 2;   // $foo is now an integer (2)

This is not:

>>> foo = '0'
>>> foo += 2
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly

There is no implicit str<->int type conversion in Python. When you do int('222') you get integer 222, which is exactly what int(str) intended to do.

It's not so confusing when you write it in more than one line:

>>> times = 4
>>> substring = '5'
>>> full_string = substring * times
>>> integer = int(full_string)
>>> integer
5555

I think this "wat" is not "wat enaugh", so it should be removed.

Thank you.

Right now there's a section titled:

The undocumented converse implication operator

In case it helps clarify things, I feel it makes a lot more sense if you think of False and True implemented as 0 and 1 underneath, and ** is a power operator.

>>> True == 1
True
>>> False == 0
True

>>> 0 ** 0 == True
True
>>> 0 ** 1 == False
True
>>> 1 ** 0 == True
True
>>> 1 ** 1 == True
True

Whether that is in and of itself a wat is up to you. :)

Know thine equalities

>>> d = {1: int, 1.0: float, True: bool}
>>> d[1.0]
<class 'bool'>
>>> 1+0j in d
True

especially when intransitive

>>> from collections import OrderedDict
>>> d = dict([(0, 1), (2, 3)])
>>> od = OrderedDict([(0, 1), (2, 3)])
>>> od2 = OrderedDict([(2, 3), (0, 1)])
>>> d == od
True
>>> d == od2
True
>>> od == od2
False
>>> class MyDict(dict):
...   __hash__ = lambda self: 0
...
>>> class MyOrderedDict(OrderedDict):
...   __hash__ = lambda self: 0
...
>>> d = MyDict([(0, 1), (2, 3)])
>>> od = MyOrderedDict([(0, 1), (2, 3)])
>>> od2 = MyOrderedDict([(2, 3), (0, 1)])
>>> len({d, od, od2})
1
>>> len({od, od2, d})
2

❤️ ❤️ ❤️

So we have that question

>>> x, y = ???
>>> sum(0 * x, y) == y
False

if x equal one of

[], '' or ()

and

y = float('nan')

that snippet is possible.
For ex:

>>> x, y = '', float('nan')
>>> sum(0 * x, y) == y
False

Please correct me if I'm wrong.

Snippet is possible
x = iter(range(10))

You claim that x < x is impossible, but it's not:

>>> class C:
...   def __lt__(self, other):
...     return True
... 
>>> x = C()
>>> x < x
True

The standard library contains copy/pasteable functions in the comments, instead of just including them in the standard library. wat?

https://docs.python.org/3/library/itertools.html#itertools-recipes

Same for unicode support in the csv module, but maybe not fair since thats fixed in Python 3. Here goes anyway:

https://docs.python.org/2/library/csv.html

Not sure if these are out of scope - they're not in the language itself, but the standard library is an important part.

https://github.com/cosmologicon/pywat/blob/master/quiz.md

>>> x = [setattr(__import__('StringIO').StringIO, '__lt__', lambda self, other: True), __import__('StringIO').StringIO()][1]
>>> x<x
    True

Sure, it's a corner case, but it's a valid answer. It's legal by the letter of the rules, it's still just one expression, and it demonstrates that Python has operator overloading and so operators may not always do what you think they do.

Hey I love those wats 😄 I'd love to turn it into an interactive quiz on realpython.com, like the one here for example: https://realpython.com/quizzes/python-lists-tuples/

Please let me know if you're ok with that, obviously I'd link back to your repo here and give you credit on the quiz for creating this wonderful collection 😃

First: thanks for this list, and the amazingly difficult AND fun quiz !

Now, a few suggestions to add to your collection of gotchas:

[] = () # OK
() = [] # KO

bool(datetime.time()) is False # cf. "a false midnight" http://lwn.net/Articles/590299/

x = 256
y = 256
assert (x is y) is True
x = 257
y = 257
assert (x is y) is False
x = 257; y = 257
assert (x is y) is True
# cf. http://stackoverflow.com/q/306313/636849

i=0;a=[0,0]
i, a[i] = 1, 10
print i, a  # 1, [0,10] - cf. https://news.ycombinator.com/item?id=8091943 - Original blog post from http://jw2013.github.io

def create_multipliers(n):
    return [lambda x : i * x for i in range(1,n+1)]
for multiplier in create_multipliers(2):
    print multiplier(3) # Late Binding Closure : prints 6 twice

issubclass(list, object) # True
issubclass(object, collections.Hashable) # True
issubclass(list, collections.Hashable) # False - There are 1449 such triplets (4.3% of all eligible triplets) in Python 2.7.3 std lib

And I found out about those last 3 myself:

d = {'a':42}
print type(d.keys()[0]) # str
class A(str): pass
a = A('a')
d[a] = 42
print d # {'a':42}
print type(d.keys()[0]) # str

f = 100 * -0.016462635 / -0.5487545  # observed on the field, in a real-world situation
print 'float     f:', f              # 3.0
print 'int       f:', int(f)         # 2

class O(object): pass
O() == O()             # False
O() is O()             # False
hash(O()) == hash(O()) # True !
id(O()) == id(O())     # True !!!
# ANSWER: http://stackoverflow.com/a/3877275/636849

>>> a = [0, 0]
>>> (x, y) = a
>>> (x, y) == a
False
>>> type(a)
list
>>> type((x, y))
tuple

>>> [1,2,3] == sorted([1,2,3])
True
>>> (1,2,3) == sorted((1,2,3))
False
>>> type(sorted((1, 2, 3))
list

You are comparing different data types, that makes it unequal.

>>> a = (0, 0)
>>> (x, y) = a
>>> (x, y) == a
True

>>> [1,2,3] == sorted([1,2,3])
True
>>> [1,2,3] == sorted((1,2,3))
True
>>> (1,2,3) == tuple(sorted((1,2,3)))
True

I get how this one can seem weird to newcomers, but it's because dictionaries don't use indices.

>>> {1:4}[0]

Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    {1:4}[0]
KeyError: 0

May be nit-picky, but I don't think indices and keys not being the same thing is a "wat."

This "wat" could be better shown as how two equivalent values are not equivalent in use:

>>> 0 == 0.0
True
>>> [4][0]
4
>>> [4][0.0]

Traceback (most recent call last):
  File "<pyshell#34>", line 1, in <module>
    [4][0.0]
TypeError: list indices must be integers, not float

String is considered false when it is empty, so as other sequences (lists, tuples, sets, etc.). It's described in right here. str(False) is 'False'. 'False' is non-empty string, so bool('False') is True, same as bool('any other non-empty string'). Seems reasonable to me.

First of all, your repository is amazing! So much information and knowledge about the Python wats.

So can I fork and translate it to Portuguese? This will help people that doesn't know English so much.

This is as expected. all takes in one iterable argument. By each case:

1. True because the iterable is empty and therefore all (0) statements within the iterable are True (trivially).
2. False because the only item in the iterable, an empty list, is falsy.
3. True because the only item in the iterable, a list with one item in it, is thruthy.

** is a power operator. The power operator works with numbers, so all booleans seems to be converted to integers (True to 1, False to 0) and then the power operation on them is calculated. Check this out:

>>> False ** False == True
True

But:

>>> False ** False is True
False

Whoopsie :) Seems like the result of the expression does not return the boolean True. Let's look closely:

>>> False ** False
1

Hmm. Let's check the actual type:

>>> type(False ** False)
<class 'int'>

Nope, no booleans here.

This issue needs some math to be recalled. It's commonly known that any number raised to the power of 0 is equal to 1. Also any number raised to the power of 1 is equal to itself. Let's apply this rule to the examples from README.md.

>>> False ** False
1
>>> 0 ** 0
1

Seems legit. 0 raised to power of 0 is equal to 1, which is also equal to True in Python.

>>> False ** True
0
>>> 0 ** 1
0

0 raised to power of 1 is equal to itself, which is also equal to False in Python.

Two more to go:

>>> True ** False
1
>>> 1 ** 0
1

1 raised to power of 0 is equal to 1, which is also equal to True in Python.

>>> True ** True
1
>>> 1 ** 1
1

1 raised to power of 1 is equal to 1, which is also equal to True in Python.

No magic here. The power operator is yielding results, which seems to be similar to the results of the converse implication on certain subset of input values. Point me if I am wrong.

A simple

>>> float('nan').imag
0.0

Is enough of a wat IMO.

Suggestion for a wat:

nan = float("nan")
print (nan == nan)                      # False
print ({1 : nan} == {1 : nan})          # True
print ({1 : nan} == {1 : float("nan")}) # False

In your "inverse implication" operator rationale, you say 0^0 is equal to 1.
That's not what I've learned. It's actually an undefined symbol:
https://www.wolframalpha.com/input/?i=0%5E0
(like 0 * Inf) and so on. So for floats this would be NaN.

However, 1 is the limit of n^n as n->0:
https://www.wolframalpha.com/input/?i=lim+n%5En+as+n-%3E0

Given that ints can't represent NaN it was probably proper to return something, in this case the limit value. But saying that the value of 0^0 is actually 1 is like saying 0 / 0 == 1 - it's also the lim(n->0), but for that Python actually returns:

Python 3.7.3 (default, Mar 27 2019, 22:11:17) 
[GCC 7.3.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 0 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 0 // 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

See https://twitter.com/jakevdp/status/1121873857973870592

Here's one that blew my mind (and my co-workers):

def incrementer():
    i = 0
    def increment():
        i = i + 1
        return i
    return increment

Looks OK. Let's try it.

>>> i = incrementer()
>>> i()
---------------------------------------------------------------------------
UnboundLocalError                         Traceback (most recent call last)
<ipython-input-3-fa1b63ea38ec> in <module>()
----> 1 i()

<ipython-input-1-482b5332e967> in increment()
      2         i = 0
      3         def increment():
----> 4                 i = i + 1
      5                 return i
      6         return increment

UnboundLocalError: local variable 'i' referenced before assignment

Fuck, even JavaScript got this one right!

Maybe this could also be a wat?

Before Python 3.5, a datetime.time object was considered to be False if it represented midnight in UTC. This behavior was considered obscure and error-prone and has been removed in Python 3.5.

Source: https://docs.python.org/3.5/whatsnew/3.5.html#changes-in-the-python-api

Other languages that have floats and ints do not have this behavior

This might not be completely true, ruby:

irb(main):001:0> x = (1 << 53) + 1
=> 9007199254740993
irb(main):002:0> x + 1.0 < x
=> true

By simply trying to evaluate 9007199254740993 + 1.0 < 9007199254740993 in other languages, indeed I haven't been able to find another example... I tried for now:

• Haskell (well, duh... you cannot compare int and fractionals in it)
• Clojure (actually I tested the JVM floats, I suppose)
• Perl5
• NodeJS (Ok, ecmascript doesn't have integers, but I wanted to try nonetheless)

https://docs.python.org/3/library/functions.html#all

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

This is also kinda wat. Else is always executed, unless you break it
https://pastebin.com/HHMRpcQw

This is not, in fact, an arbitrary coincidence; it follows naturally. If A and B are (finite) sets/types then the cardinality of the set/type of functions from A to B is |B|^|A|. If you use the Curry-Howard isomorphism and identify True and False as the unit and empty type respectively, then the function type A -> B is identified with logical implication, and we obtain the result from the original post.

This is not much of a wat. In the first case the example shows attempting to index a list at index 0.0, which does not make sense. In the second case, the example shows attempting to find the key 0.0 in a dictionary, which does make sense. The only wat here might be that Python coerces float to int if possible when using it in a dictionary key search.

Similarly:

{3:'foo'}[3.0]  # 'foo'