Ten quirky things about Python

i am sure people will come and dont like you for showing quirks, but then again nothing can beat critique in the same spirit like C++ FQAs to C** FAQs ;)

def f1(b): 
    if b:
        return 1
    else:
        return 0

def f2(b):
    return 1 if b else 0

def f3(b):
    return b and 1 or 0

def f3bug(b):
    return b and 0 or 1
    # must use f1 or f2 idiom because bool(0) == False

whitespace? quirk? nah

• Bool values are actually strange integers.

>>> a==b
True
>>> a+b
2

So you think a and b are ones? Ha, ha!

>>> str(a)==str(b)
False      < ---- quirk!!! :-)
>>> a
1
>>> b
True

... surprise!

• It gets even quirkier when you mix bools and ints as dictionary keys:

>>> a,b = {},{}
>>> a[True], b[1] = 1, 1
>>> a[1] , b[True] = 42, 42
>>> a, b
({True:42}, {1:42})

Quirky!

Actually for creating tuples it is the comma that decides it not the parentheses plus comma e.g.

>>> x = 1,
>>> x
(1,)
>>> len(x)
1

Whitespace supports spaces, tabs or… a mix of both.

Yay – nice to see that there are some of the coolest features of perl in python :)

Provides access to real threads but… the GIL only allows one thread (in most cases) to execute at a time.

A variable is defined outside a function and used in several places within that function. Now, if you do one assignment of that variable within the function to something of a different type, the type of the variable changes for all uses within the function, even the ones before the assignment! I call that “spooky action at a distance”.

Perl can also do For::Else ;p

http://search.cpan.org/dist/For-Else/lib/For/Else.pm

@rt: dicts can only use hashable types as keys.

id(1) != id(True)
hash(1) == hash(True)

In fact, you don’t even need parenthesis to make a tuple — the comma defines a tuple.

So, this produces a tuple of length 1 as well:

1,

Tuples are defined by the comma, not by the braces :-)

If you want to print WITHOUT a newline you can just add an extra comma after the arguments to ‘print’. Examples.

print 'Hello'
print ', World'
# Will end up on TWO lines.

print 'Hello', # <-- notice the comma
print ', World'
# Will end up on ONE line.

(1) The depth limit, normally 500, on recursions.

(2) The need to pass ‘self’ as a parameter when calling an object’s member functions.

(3) The leading and trailing double underscores look funny.

(4) One-line lambdas but no anonymous blocks as in Ruby.

How about this one?

import decimal
x = decimal.Decimal(1)
x < 2.0   # returns False!

Hey what does python say is 4 divided by 5? 0

How many underscores does it take to create a basic class? 4 for each item

How many orders of magnitude slower is python than Java or C++? 1-2

How many drag & drop gui designers and IDEs are there for python similar in class to Visual Studio, Netbeans, or Eclipse? 0

How can “for x in list: s += x” be O(n^2)? Seems rather unlikely…

Some of the quirks, I too would say are quirks. Some in fact are under review/changed in Python3.0; but some are just the consistent way that Python does things that may not be the same as other languages, such as dividing two integers to produce an integer – why not? How many orders of magnitude slower is Java or C++ development compared to python? 1-2 ;-) How many drag & drop 500Mb GUI designers IDE’s and repetitive code generators are required for Python development? – None!

blog.micropledge.com | CommentURL.com…

blog.micropledge.com … … Useful list of quirks for Python. … … A variable is defined outside a func……

Joe, some of your comments are misleading. Care to provide examples / explanations?

Closed over variables are (unintentionally, it seems) read-only. Say you want to write a function that creates a counter function, something like this:

def makeCounter():
    current = 0
    def counter():
        current += 1
        return current
    return counter

Because assigning to a variable will create that variable in the current scope (unless declared global), current += 1 will create a new variable (and then complain that it is unbound), instead of using the existing variable in the parent scope.

You can store function state in function attributes .

def makeCounter():
    def counter():
        counter.current += 1
        return counter.current
    counter.current = 0
    return counter

Although most people would use a class in Python.

— Paddy.

About string concatenation:

python strings are immutable. So when you do “for x in list: s+=x” a new string is created len(list) times. ”.join(list) only creates a string once. I don’t quite see how the first case is O(n^2) though. They’re both O(n) in terms of number of concatenations but the first case involves many more mallocs.

O(n^2) because the memory allocations go like this: 1 12 123 1234 12345 123456 1234567 12345678

As you can see, memory foot print grows quadratically: O(n(n-1)/2) = n^2

This page has been added to TechZe.us. Feel free to submit future content to the list.

@Joe: 1. in ipython:

4/5 is 0

divides an integer number by an integer which gives 0 in most programming languages.. one migh argue that / should convert to float but I’m not sure if that would work..

4./5 is 0.80000000000000004 shows the usual float representation bugs

1. syntax nitpicking?

2. psyco can speed up python, c extensions can speed up python, jython should be comparable in speed to similar java code.. but speed is usually not the reason you go for python…

3. wxglade.. glade.. and i bet there are others..

There’s been a lot of debate about making this faster, and it looks like it should be faster in Python 2.5, but my tests show otherwise. Any ideas why?

Because the optimization only applies to string literals ('foo' + 'bar' + 'baz'). If you add to a non-literal, such as a variable containing a string, you don’t get the optimization.

For loops and if blocks don’t create their own scope. i.e.:

ls = []
for x in range(5):
    ls.append(lambda: x)

for l in ls:
    print l(),

Writes: 44444. You would expect: 01234

This is because for loops don’t create their own scope, and when you create the lambda, it keeps a pointer to x, which is the same x as all the others.

Continual string appending is still O(N^2), the optimization just gives a (significant) constant factor speedup.

It still has to do a resize and a reallocation for every string append, what the optimization does is save the destruction of the old string object and the creation of a new one. Try using a global instead of the local (so something else holds a reference to it and the optimization can’t be used) to see the difference.

some of these are pretty cool features. thanks guys!

[…] Ten quirky things about Python, […]

Jonathan Mark: “The need to pass ’self’ as a parameter when calling an object’s member functions.”

You don’t need to pass it, it is passed automatically. you need to receive it. The only other way to do so is to add a new reserved keyword to the language, which is ugly.

Joe: “Hey what does python say is 4 divided by 5? 0”

fixed in 3.0, or you can “from __future__ import division” today. use // to get integer division again. Note that the behaviour you mention is exactly how integer division works in most languages.

“How many drag & drop gui designers and IDEs are there for python similar in class to Visual Studio, Netbeans, or Eclipse? 0”

While I’m not a fan of drag & drop gui designers and haven’t used either, what about Glade? and… Eclipse? I’ve no doubt that there is a reasonable way to use Visual Studio with IronPython, too.

There are a few quirks that usually take a few mistakes for people to learn. These stem from ‘every name is a reference’, mutability, and scoping rules, mostly. For example, a = 3; b = a; a = 7 leaves b == 3. However, a = [3];b = a; a[0] = 7 leaves b == [7].

This is because = rebinds the left hand side to point at the object referred to on the right hand side. In the first case, a is rebound to refer at a new integer object with value 7, and in the latter case a and b still refer to the same list, but the first element of the list has been rebound to the new integer object.

A lot of expressiveness comes from this mechanism. You end up with no desire for an ugly ‘pointer type’, and you don’t have to worry about immutable objects like strings changing under your feet. But it seems like this trips up a lot of new Python programmers.

Also, name binding occurs in the local scope, so a = 3 binds the name a to 3 in the local scope. However, you can refer to and even mutate objects referred to by names in other scopes without any extra effort- eg, if a = [3] in the global scope, and in a function with no local name a, you do a[0] = 7, it will change the object referred to by the global name. Although if you use raw integers as in the above example, it will bind a new local variable a instead. To bind the global name, you will have to tell the function to treat that name global. [This is quite neat in that functions can’t accidentally trip on ‘global’ variables without knowing of their existence.]

[and unfortunately, what I’ve written is a bit thick for a Python beginner, although the concept is not.]

[…] 1 and Part 2 Stack Overflow – Hidden Features of Python When Pythons Attack Python Gotchas 10 Python Quirks Python Idioms and Efficiency bool is […]

[…] 1 and Part 2 Stack Overflow – Hidden Features of Python When Pythons Attack Python Gotchas 10 Python Quirks Python Idioms and Efficiency bool is […]

a = 100 b = 1000 a is 100 and b is 1000

False

a is 100

True b is 1000 False