Advice for C# programmer writing Python

Question

I've mainly been doing C# development for the past few years but recently started to do a bit of Python (not Iron Python). But I'm not sure if I've made the mental leap to Python...I kind of feel I'm trying to do things as I would in C#.

Any advice on how I can fully take advantage of Python?

Or any tips\tricks, things to learn more about, things to watch out for?

Answer 1

If you are someone who is better learning a new language by taking small incremental steps then I would recommend using IronPython. Otherwise use regular CPython and don't do any more C# coding until you feel like you have a grasp of Python.

Answer 2

I would suggest getting a good editor so that you don't get bitten by whitespace. For simplicity, I just use ActivePython's packages Link, which include an editor and all of the win32api libraries. They are pretty fun to get into if you have been using C#. The win32api in Python can be a little bit simpler. You don't need to do the whole DDLImport thing. Download ActivePython (which comes with CPython), open it up, and start entering some stuff at the console. You will pick it up fairly easy after using C#. For some more interesting Python tidbits, try ActiveState code, which has all sorts of recipes, which can allow you to very simply see different things that you can do with Python.

Answer 3

If you are not new to programming, I would recommend the book "Dive into python" by Mark Pilgrim. It explains python in a way that makes it easy to understand how python techniques and idioms can be applied to build practical applications.

Answer 4

Start by reading The Zen of Python

You can read it at the link above, or just type import this at the Python prompt. =)

Take advantage of Python features not offered* by C#

Such as duck-typing, metaclasses, list comprehension, etc.*

Write simple programs just to test these features. You'll get used (if not addicted) to them in no time.

Look at the Python Standard Library

So you don't reinvent the wheel. Don't try to read the whole thing, even a quick look at the TOC could save you a lot of time.

---

* I know C# already has some of these features, but from what I can see they're either pretty new or not commonly used by C# developers. Please correct me if I'm wrong.

Answer 5

In case you haven't heard about it yet, Dive Into Python is a great place to start for anyone learning Python. It also has a bunch of Tips & Tricks.

Answer 6

• Refrain from using classes. Use dictionaries, sets, list and tuples.
• Setters and getters are forbidden.
• Don't have exception handlers unless you really need to - let it crash in style.
• Pylint can be your friend for more pythonish coding style.
• When you're ready - check out list comprehensions, generators and lambda functions.

Answer 7

If you have programming experience and don't feel like spending money I'd recommend How to Think Like a Computer Scientist in Python.

Answer 8

First, check tgray's and Lundström's advice.

Then, some things you may want to know:

• Python is dynamically typed, so unlike C#, you will not check type but behavior. You may want to google about duck typing. It implies you do not have to deal with boxing and unboxing.

• Python is fully object oriented, but the syntax does not enforce this paradigm. You can write Python without using the word "class".

• The GUI library featured with Python can't compare with C#'s. Check PyQt, GTK or wxPython libraries.

• Python has a lot of concepts you may not be familiar with: list comprehensions, generators ("yield" does exist in C# but is not used much), decorators, metaclasses, etc. Don't be afraid, you can program in Python without them. They are just smart tools, not mandatory.

• Like in C#, the Python standard library is huge. Always look at it when you encounter any problem. It is most likely that someone solved it already.

• Python use LATE binding and variable labels. It's far too early for somebody starting with the language to worry about it, but remember that one day you will encounter a behavior with variables that SEEMS illogical, and you'll have to check that. For the moment:

Just remember to never do the following:

def myfunc(my_list=[]) :
   # bla

Instead:

def myfunc(my_list=()) :
   my_list = list(my_list)

And you'll be good. There is a good reason for that, but that's not the point :-)

• Python is cross platform, enjoy writing on Mac, and run on Linux, if you wish.

• Python is not provided with a complex IDE (you got IDLE :-)). If you are a Visual Studio addict, check Glade. This is not as advanced as Visual Studio, but it's still a good RAD.

• If you want to develop some web application in Python, remember that Python is not .NET. You must add a web framework to it if you want to compare. I like Django.

• Python does not need a huge IDE to work with. SciTE, Notepad++, IDLE, Kate, gedit... Lightweight editors are really sufficient.

• Python enforces indentation using spaces and line break, you can't change that. You should avoid using tabs for indenting and choose spaces instead. The equivalent of empty bracelets {} is the keyword "pass".

• Python does not enforce private vars. You can define a private var using "__" (2 underscore) at the beginning of the var name, but it's still bypassable in some tricky ways. Python usually assume programmers are grown adults that know what they do and communicate.

• Python uses iteration. A lot. A lot of a lot. And so the itertools module is you best friend.

• Python has no built in delegates. The delegate module is not what you think. For event-driven programming, use a GUI lib (or code the pattern yourself, it's not that difficult).

• Python has an interpreter: you can test almost anything, live. It should always be running next to your text editor. Python basic interpreter is not much, try IPython for something tasty.

• Python is autodocumented: use docstrings in your own code and consult other's using "help()" in the python interpreter

Module basics :

• sys: manipulate system features
• os: set credential, manipulate file paths, rename, recursive file walk, etc
• shutil: batch file processing (such as recursive delete)
• re: regexp
• urllib and urllib2: HTTP¨scripting like downloading, post / get resquests, etc
• datetime: manipulate date, time AND DURATION
• thread: you guess it
• zlib: compression
• pickle: serialization
• xml: parsing / Writing XML with SAX or DOM

There are hundreds of modules. Enjoy.

Some typical ways to do things in Python:

Loops:

Python coders use massively the equivalent of the foreach C# loop, and prefer it to any others :

Basic iterations:

for item in collection:
    print str(item)

"collection" can be a string, a list, a tuple... Any iterable: any object defining the .next() method. There are a lot of iterables in Python. E.g: a typical Python idiom to read files:

for line in open("/path/to/file") :
    print line

A shortcut to the for loop is called "list comprehension". It's a way to create an new iterable in one line:

Creating a filtered list with list comprehension:

my_list = [item for item in collection if condition]

Creating a new list with a list comprehension:

my_list = [int(item) * 3 for item in collection]

Creating a new generator with a list comprehension:

my_list = (int(item) * 3 for item in collection)

Same as above, but the values will be generated on the fly at the first iteration then lost. More info about it here.

Ordinary for loop

If you want to express a usual for loop, you can use the xrange() function. for (int i = 0; i < 5; i++) becomes:

for i in xrange(0,5) :

do while equivalent

There is no "Do While" in Python. I never missed it, but if you have to use this logic, do the following:

while True : # yes, this is an infinite loop. Crazy, hu ?

  # do your stuff

  if condition :
      break

Unpacking

Swapping variables:

a, b = b, a

Multiple assignations:

The above is just a result of what we call "unpacking" (here applied to a tuple). A simple way to explain it is that you can assign each value of any sequence directly to an equal number a variables, in one row:

animal1, animal2, animal3, animal4 = ["cow", "dog", "bird", "fish"]

This has a lot of implications. While iterating on a multidimensional array, you normally get each sub sequence one by one then use it, e.g :

agenda = [("steve", "jobs"), ("linus", "torvald"), ("bill", "gates"),("jon", "skeet")]
for person in agenda:
    print person[0], person[1]

But with unpacking, you can assign the values directly to variables as well:

agenda = [("steve", "jobs"), ("linus", "torvald"), ("bill", "gates"),("jon", "skeet")]
for name, lastname in agenda:
    print name, lastname

And that's why if you want to get an index while iterating, Python coders use the following idioms (enumerate() is a standard function):

for index, value in enumerate(sequence) :
    print index, value

Unpacking in functions calls

This is advanced use, you can skip if it bothers you.

You can unpack values using the sign "*" to use a sequence directly in a function call. E.g:

>>> foo(var1, var1, var3) :
    print var1, var2
    print var3
>>> seq = (3.14, 42, "yeah")
>>> foo(*seq)
3.14 42
yeah

There is even more than that. You can unpack a dictionary as named variables, and write function prototypes with *, ** to accept an arbitrary number of arguments. But it not used enough to deserve to make this post even longer :-).

String formating:

print "This is a %s on %s about %s" % ("post", "stackoverflow", "python")
print "This is a %(subject)s on %(place)s about %(about)s" % {"subject" : "post", "place" : "stackoverflow", "about" : "python"}

Slicing an iterable:

You can get any part of an iterable using a very concise syntax:

print "blebla"[2:4] # print "eb"
last = string[:-1] # getting last element
even = (0,1,2,3,4,5,6,7,8,9)[::2] # getting evens only (third argument is a step)
reversed = string[::-1] # reversing a string

Logical checks:

You can check the way you do in C#, but there are "Pythonic" ways (shorter, clearer :-)):

if 1 in (1, 2, 3, 4) : # check en element is in a sequence

if var : # check is var is true. Var == false if it's False, 0, (), [], {} or None

if not var : # contrary of above

if thing is var: # check if "thing" and "var" label the same content.

if thing is None : # we use that one because None means nothing in Python (almost null)

Combo (print on one line all the words containing an "o" in uppercase ):

sentence = "It's a good day to write some code"
print " ".join([word.upper() for word in sentence.split() if "o" in word])

Output: "GOOD TO SOME CODE"

Easier to ask for forgiveness than permission

Python coders usually don't check if something is possible. They are a bit like Chuck Norris. They do it. Then catch the exception. Typically, you don't check if a file exists, you try to open it, and roll back if it fails:

try :
    f = open(file)
except IOerror :
    print "no file here !"

Of course Chuck Norris never uses excepts since he never fails.

The else clause

"Else" is a world of many uses in Python. You will find "else" after "if", but after "except" and "for" as well.

for stuff in bunch :
    # do thing
else :
    # this always happens unless you hit "break" in the loop

This works for "while" loop too, even if we do not use this loop as much.

   try :
      # a crazy stuff
   except ToCrazyError :
      # this happens if the crazy stuff raises a ToCrazyError Exception
   else :
      # this will happen if there is no error so you can put only one line after the "try" clause
   finally :
      # the same as in C#

---

If you are curious, here is a bunch of advanced quick and dirty (but nice) Python snippets.

Answer 9

And then something you can benefit from:

IPython shell: Auto completion in the shell. It does batch operations, adds a ton of features, logging and such. >>> Play with the shell - always!

easy_install / pip: So nice and an easy way to install a 3rd party Python application.

Answer 10

I'm pretty much in your shoes too, still using c# for most of my work but using python more and more for other projects.

@e-satis probably knows python inside-out and all his advice is top-notch. From my point of view what made the biggest difference to me was the following:

Get back into functional. not necesarily spaghetti code, but learning that not everything has to be in an object, nor should it be.

The interpreter. It's like the immediate window except 10^10 better. Because of how python works you don't need all the baggage and crap c# makes you put in before you can run things you can just whack in a few lines and see how things work. I've normally got an IDLE instance up where I just throw around snippets as I'm working out how the various bits in the language works while I'm editing my files... e.g. busy working out how to do a map call on a list but I'm not 100% on the lambda I should use... whack in a few lines into IDLE, see how it works and what it does.

and finally, loving into the verbosity of python, and I don't mean that in the long winded meaning of verbosity, but as e-satis pointed out, using verbs like "in", "is", "for", etc.

If you did a lot of reflection work in c# you'll feel like crying when you see how simple the same stuff is in python.

Good luck with it.