Built on code

A few weeks ago on "Fountain Pen Pals India" whatsapp group (which I am a part of), fellow FPN'er Sulagno (@inkstruck) enquired about the possibility of getting a pen made to a certain flush rounded ends design.

What followed were a bunch of design ideas from (fellow FPNers in the group) Sulagno (@inkstruck), Vaibhav (@mehandiratta),  Pradeep (@pdg84) and Mr. Subramaniam of ASA pens. Vaibhav transferred the design ideas into a CAD illustration and thus the ASA Porus design was born.

Mr. Subramaniam of ASA (NAYY) was very happy with the outcome and immediately set out to build a few initial models of the pen.

In less than a week the pens were built and delivered.

The ASA Porus is a large acrylic pen which comes in 2 flavours.

1. Flush design - where cap and barrel are flush.

2. Step design - there is a step down where the cap and barrel meet.

With this model, ASA pen has exceeded all the high expectations that were set by the group.

The pen is now on sale at on the ASA pen site here: ASA Porus (NAYY)

I chose the flush design and that is what I will be reviewing today.

Flush cap and barrel - no clip:

40 mm Ambitious gold plated nib:

Beautiful white acrylic cap and barrel.

Close up of the "M" grade 40 mm Ambitious nib.

The feed, the nib is not too deeply set, this is to my liking.

Inside of the barrel, thick barrel walls.

The nib and feed properly set:

Porus with Lamy Safari:

And finally, a writing sample. Ink used is Bril Royal Blue. Paper: 100 GSM JK Cedar.

The section is large but is very comfortable to hold. The acrylic material is beautiful, white and feels soft to touch. The 40mm nib does it job of being a nice wet writer.  It is a big pen, but the feel is brilliant. Very well balanced.

This is the most beautiful fountain pen in my small but quickly expanding collection.

Kudos to Mr. Subramaniam of ASA pens of contributing to the design and being kind enough to actually see it to fruition. This I think is a first in the Indian fountain pen industry scene where a group of fountain pen enthusiasts designed a pen and ASA (a FP company) delivered all in a span of 2 weeks  

ASA Pens, India's newest fountain pen company, has been hard at work designing and developing fountain pens for the past several months. The 'I Can' is their latest model.

I got one a few weeks ago and have been using it almost exclusively since then.

Construction:

The pen is made of ebonite. I chose the shiny black model.

The top of the cap and the bottom of the barrel are flat.

The section has been contoured as to make it very comfortable to grip. After using it for long hours of writing it does feel very comfortable.

The barrel has been engraved with the text "ASA I Can India 2015" in cursive. The ASA Crystal LE had the text ASA engraved in upper case which gives it a good sharp look and I feel the same should have been done for the I Can.

Nib:

The stock model comes with a monotone F nib. As with my previous purchase, I chose to get it with the German made Bock 'M' nib.

The nib as I've reviewed before is a smooth and wet writer. It lays down wet medium thick lines without having to exert any pressure on the pen.

Filling system:

The pen is an eye dropper. The barrel can hold up to 3.0 ml of ink. Since the Bock M nib lays down quite a wet line, the ink lasts for up to 3 days of writing.

The pen design is quite similar to another popular Indian fountain pen, the Deccan Advocate, which is manufactured in my home city of Hyderabad.

The I Can's fit and finish is comparable with that of the Deccan Advocate which is to say that it is perfect as a daily writer. I have had the I Can in my shirt pocket during my daily work commute and have never faced any issues like leakages.

The pen writes as soon as it is uncapped and will write even when uncapped for several minutes.

True story.

Late one cold November night, I felt this urge to check ASA pens website. Why? ASA had put up a bunch of photos of upcoming fountain pen models which weren't yet available and I was eager to be the first to get my hands of them before they were sold out.

As luck would have it, they had just updated their site with new fountain pen models manufactured under the ASA brand named. ASA Crystal Limited Edition. was one of the pens. As someone who is a card carrying member of the fountain pen club I had to have the pen and placed an order immediately.

A few days later I received it. Here is my review of ASA Crystal Limited Edition fountain pen.

It is a limited edition fountain pen. Only 50 of this model will ever be made.

The pen came in a beautiful single pen pouch which fits the pen perfectly and will protect it from any scratches.

Construction:

The pen is made of ebonite and has a brushed matte exterior. The top of the cap and the bottom of the barrel are made of clear acrylic.

I have seen a lot of fountain pen designs, but never quite have seen something like this which blends two good fountain pen materials - ebonite and acrylic into one.

The pen is very well constructed, the brushed matte ebonite is without any blemishes. The clear crystal feels soft to touch and has been, what I can only guess, glued on very securely to the ebonite.

The barrel has the text ASA Crystal LE, India 14 carved into it. The carving is very neatly done so as to blend with the all matte brushed finish.

Nib:

The stock ASA Crystal LE comes with a - fine point - monotone iridium nib,  I chose to upgrade to a medium point German made nib by Bock. Bock manufactures nibs for several high end fountain pen makers with their names / logos stamped on them.

The nib hasn't been too deeply set in the section and this is also to my liking, the nib is handsome and should be displayed in all its glory.

Mr. Subramaniam, a fountain of fountain pen knowledge and owner of ASA Pens had tuned it to my liking so the nib is very smooth and wet.

Filling System:

The pen is an eye-dropper. The barrel holds about 4 ml of ink. Some people don't like eye-droppers as they are perceived to be prone to leaks, burps and all the yuck'ities commonly associated with fountain pens. I haven't faced any of these problems so far with any of the eye-dropper fountain pens I own, perhaps it is the tropical weather here in India which does not cause the pen to burp ink.

Writing:

I have been using the pen regularly for a week and I am one happy writer. The pen is very well balanced and despite its jumbo size feels quite light when writing.

The section is comfortable to grip and that makes it easy to use the pen for long writing sessions.

The feed provides a regular flow of ink to the nib and that makes it for smooth writing without any skipping.

I wanted to write about how smooth the nib is but then I can't find words to describe it. This is something that can only be experienced. A smooth nib gliding on paper laying glistening wet blue lines.

A superb, high quality, hand made fountain pen from ASA - brand that is making waves in the Indian and international fountain pen markets by making affordable high quality fountain pens.

I ordered Masters Of Doom on Flipkart two weeks ago. It was delivered last week on Monday. I wanted to read the book in one sitting and yesterday, that is just what I did.

I have an unhealthy obsession with computers and programming. The culture and people that make up its history are a big part of that obsession.

John Carmack is one of the most respected and admired programmers in the industry. So when I came to know of Masters of Doom, a book which documented his coming of age and starting his company, Id software, I had to have it.

Masters of Doom is very well written and documents the life of programmers at Id software, in particular, John Romero and John Carmack, who brought PC gaming into the mainstream and produced Doom and Quake, two of the best selling gaming titles of all time.

Of particular interest to me was Carmack's ability to completely lose himself in a problem and come up with simple and elegant solutions. His solutions to problems of side scrolling on the PC, parallax motion and lighting led to a game engine which gave game designers the ability to build highly immersible gaming experiences.

A lot of text in the book is reminiscent of a start-up: A group of passionate, hard core enthusiasts break established rules and lend their own voice to a medium and in the process take it to a whole other level.

It also gives a peek into the human side of the 'two Johns'. The same strong personalities and drive which brought them together to build great games also ultimately caused them to go separate ways.

A while ago, I wrote about why developers should learn HTML and CSS. I wrote that post after formally re-introducing myself to HTML and CSS using Head First HTML with CSS and XHTML.

A short time later, I got caught up with more server side programming. As if often happens, once you learn a programming language, you need to build something in it, else with time you'll forget most of what you have learnt.

More than a year passed without me building anything with HTML or CSS. A while back, Head First released a second edition of the book with XHTML part stripped out and a greater emphasis on HTML 5. I picked up the book with the intention of working through it.

It sat on my shelf for over 5 months. Last week, I worked through the book and this time around, thanks to Anki, I am a lot more optimistic about remembering and recalling everything I have learnt.

Anki is this fantastic piece of software that implements active recall testing and spaced repetition.

The software is written in Python, is open source, and is available for Windows / Linux / Android / Mac. A paid version is available for iOS devices.

There are two simple concepts behind Anki: active recall testing and spaced repetition. I came across this on Derek Sivers' blog and have been using it ever since. I would rank this third in my list of wildly useful tools to learn, right after learning to type and using distributed version control.

My study process is:

1. Work through each chapter, type in each example.

2. At the end of a chapter, recall all the important concepts and type them in question / answer form in Anki.

3. Open up Anki each morning and review all the cards it shows for that day.

Simple, ain't it?

Last week, I bought a HP Envy - desktop tower. This is my first desktop purchase after 8 years of using laptops.

My 2 laptops - HP & Lenovo are functional. I bought them in America years ago. The batteries on both the machines reached their end of life. I could not find spares for either models in India. The ones that I did buy were labelled "duplicate" - which meant generic and manufactured by other companies. Both batteries died after their short 3 month warranty period.

Running the notebooks without batteries seems to heat them up to the point that they would simply turn off.

This was 6 months ago.

I started looking to purchase a new laptop which would hold up for atleast 3 years. I was waiting for Intel to launch their Haswell series of processors. It has been 2 months since Intel launched their 4th gen processors. I haven't seen any of the big PC brands launch decent models with these processors in India.

I have pretty much given up on laptops at this point. The laptop scene in India has not improved much in the past 5 years.

Dell, HP and Lenovo have no customization options available on their laptops. Most of their higher end laptops ship with 5200 rpm drives with no options to upgrade or even add a 7200 rpm or a SSD drive. The only models that were close to acceptable were the Dell Alienware series and Lenovo's super expensive - ThinkPad Carbon.

The Dell Alienware machines are very bulky and there have been concerns with their battery performance.

The ThinkPads are way too expensive.

So after 2 months of research and not finding a single laptop which would satisfy my needs - a quad core processor / 8 GB of RAM (with expansion slots) / SSD drives. I gave in and bought a desktop from HP.

I have been using it for a little more than a week and I am really happy with this purchase. The machine is a i7 quad core / 8 GB RAM (with 2 empty slots) / 1 TB 7200 RPM drive and a 3 GB NVidia card.

The expansion options on this machine were what got my attention. I can bump up the RAM to 32 GB, there are 3 empty HDD slots. The hard drive is not an SSD, but 7200 rpm should suffice, for now. The GPU can support up to 3 displays.

There are more USB 3, USB 2, memory card slots than I would ever need. A Blue Ray DVD player, Beats audio support. The tower itself is very well built and nicely ventilated. The tower came with a wireless keyboard and mouse. I have used Microsoft Keyboard 4000 and MX 518 for a while now but I must say that the HP wireless keyboard and mouse work really well.

I have a early MacBook Pro - 2011 model. I would have bought newer iMac or a MacBook Pro laptop, but I need the machine to program in .NET. Performance wise, Windows 8 / VS 2013 in Boot Camp just does not cut it. Besides, I also wanted the ability to load up virtual machines with Debian / Ubuntu / Fedora and not have to worry about the rapid loss of battery power. Apple has a built in battery. What happens to the battery if you use Windows in Boot Camp & Linux VM on Apple hardware? If this causes the battery life to take a hit by even 20%, do you send the laptop to Apple to replace the batteries? How expensive is this?

It is nice to be able to buy a screamer of a desktop machine (which can be easily upgraded) for half the price of an equivalent laptop. No worries about battery performance, easy access to expansion slots. HP also threw in a 3 year onsite-all parts warranty!!.

Yesterday

This post is part 1 of a series that documents my understanding of software construction as I read through Steve McConnell's excellent Code Complete.

I was reading up on software construction and the importance metaphors to get a deeper understanding the process of software development. What follows is my understanding of the aforementioned topics.

Software development is a set of distinct activities. Software construction, what most developers would think of as ‘coding’ or ‘programing’, is one such activity. It is important to understand how to get better at software construction as it represents a large and important part of the overall software development effort.

When building software, it is possible that other activities of software development have been skipped, but construction is the only part that is guaranteed to be done, because without that there would be no product. Also, developers vary in skill by a large factor when it comes to software construction. Focusing on how to get better at it will have a huge impact on the overall quality of the software product.

Metaphors have been used widely to understand new phenomena by relating it to something which we already know and understand. Using metaphors we can better understand the process of software development.

Metaphors in software development range from the rather simplistic – writing software (writing a letter), growing software (farming) and software accretion to something more complex and inclusive - constructing software (constructing a house).

The ‘house construction’ metaphor is the most inclusive when thinking about software development because there are a lot of similarities in both fields.

When constructing a house, the amount of upfront planning, architecture, design and construction methods will depend on the kind of house that is being built. Larger structures require more upfront planning and formal methods of design at every stage. This is similar to software development where a large software project consisting of hundreds of modules and external interfaces will have to go through a much more formal design and construction process. This is in direct contrast to building something simple; say a bookcase, where you do not need much upfront planning at all.

Though McConnell’s ‘building a house’ metaphor best explains the software development process, it too is lacking in some aspects. Software requirements are much more subtle and prone to changes than say requirements that are given when building a house.  Once a house is built, it tends to remain in its original form for years or even decades, but in isn’t the case when it comes to software.

When it comes to constructing a house, you can plan activities to be done one after another (waterfall model) and some of them can occur concurrently. When each activity is completed and verified, you can move on to the next stage without having to worry about any changes in the activities preceding it. For example, when the land has been dug to lay a foundation that has been verified to be stable and secure, you can move on to building a house on top of it. In software construction, there are changes that come about constantly to the basic foundations that were taken for granted at the beginning of development but which are later questioned and can be changed. These changes can be to the underlying technologies on which the foundation was built or to the requirements that were not correctly stated or were misinterpreted.

I guess this disconnect comes about due to the nature of the two activities, construction of a house and constructing software. Software is a representation of your ideas on how to solve a problem. The raw materials in case of software development are ideas, which are a lot more subtle and prone to change than the materials used to build a house.

Until we find something better that reflects this subtlety, the ‘house construction’ metaphor should suffice when thinking of software construction.

This post is the eighth of many that attempts to document everything I have been learning about Python.

Strings are ordered collections of single characters. They are part of the family of sequences. Python does not have a type that is used to represent single characters.

You create a string by enclosing a piece of data in either single or double quotes.

You can run built-in sequence operations on strings.

>>> cartmans_song = 'The lazy river has never been lazier' >>> # Built-in sequence operations >>> len(cartmans_song) 36

Strings can have escape characters embedded in them. You start a special character using a \ backslash. Internally, these are just replaced with their ASCII values.

>>> # \n is a new line escape character >>> str_with_escape_char = 'the lazy river \nhas never been lazier' >>> print(str_with_escape_char) the lazy river has never been lazier >>>

Raw strings are useful when you don’t want to interpret a backslash as start of a special character. To indicate that a string is a raw string, add a r or R before the opening quote. A raw string cannot end in a single backslash.

>>> raw_string = r'This is a raw string. Escape chars will be \n igonred' >>> print(raw_string) This is a raw string. Escape chars will be \n igonred >>>

Triple quotes are used when you want to represent multiline strings. You can use either single or double quotes. These strings are displayed as-is, which means that if you have any line breaks in the string, it will be displayed with those line breaks.

>>> >>> triple_quoted_string = """Eric Cartman Stan Marsh Kyle Broflovski Kenny McCormik""" >>> >>> triple_quoted_string 'Eric Cartman\nStan Marsh\nKyle Broflovski\nKenny McCormik' >>> >>> print(triple_quoted_string) Eric Cartman Stan Marsh Kyle Broflovski Kenny McCormik >>>

Python will always display a non printable character using the hex notation.

Basic String Operations

len() to find the length of the string.

+ for concatenation, * for repetition, these operators are overloaded for the string type.

in can be used to check for membership, it is like the find() string method, but instead of returning the offset it returns a bool value.

>>> cartmans_song = 'the lazy river has never been lazier' >>> >>> # use the in memebership operator to search for a string within another string >>> 'lazy' in cartmans_song True >>> >>> cartmans_song = 'The lazy river has never been lazier' >>> # gets the length of the string >>> len(cartmans_song) 36 >>> # concatenate >>> 'New England' + ' Patriots' 'New England Patriots' >>> >>> # repeat >>> 'But maa ' * 4 'But maa But maa But maa But maa ' >>>

Indexing

You can retrieve specific characters from a string by specifying the index. The offset starts at 0. You can also specify a negative index to specify the offsets from right. The rightmost offset is -1.

>>> cartmans_song = 'The lazy river has never been lazier' >>> # gets the character at the first offset >>> cartmans_song[0] 'T' >>> # gets the character at the last offset >>> cartmans_song[-1] 'r' >>>

Slicing

You can parse out a set of characters from a string using slicing.

S[i:j] - start at the offset i and get all characters up to but not including j. You can also choose to omit the lower and upper bound, in which case they will switch to using defaults which is 0 for lower bound and the length of the string for the upper bound.

>>> cartmans_song = 'The lazy river has never been lazier' >>> cartmans_song[4:30] 'lazy river has never been ' >>> cartmans_song[:30] 'The lazy river has never been ' >>> cartmans_song[4:] 'lazy river has never been lazier' >>>

If you slice without specifying either bounds, you are effectively creating another object in memory, it will have the same value as the string you are slicing.

>>> # this just creates a new string >>> new_str = cartmans_song[:] >>> new_str 'The lazy river has never been lazier' >>>

Slicing using 3 indexes

S[i:j:k] here k is called the step, so you start from i through j by stepping through k number of characters. If you omit both i and j and use -1 as k, you are effectively reversing a string, also if you do specify i, j and a k with a negative offset the lower(i) and upper(j) bounds get reversed.

>>> cartmans_song = 'The lazy river has never been lazier' >>> # start from the beginning and print every 4th character >>> cartmans_song[0:36:4] 'Tl eae nz' >>> # negative step index, reverses the bounds. >>> cartmans_song[36:0:-1] 'reizal neeb reven sah revir yzal eh' >>> cartmans_song[::-1] 'reizal neeb reven sah revir yzal ehT' >>>

You can use a slice object in the index to get a slice:

>>> cartmans_song[slice(1,4)] 'he ' >>> cartmans_song[slice(None, None)] 'The lazy river has never been lazier' >>>

Conversions

To convert something to a string you can pass it to the str() method.

You can convert a character to its ASCII value by passing it to the ord() method.

You can convert a number to its equivalent character by passing it to the chr() method

You can use string formatting expressions to generate strings.

>>> >>> # Create a new string >>> new_string = str("this is a new string") >>> >>> # get the ASCII value of a character >>> ord('a') 97 >>> >>> # get the character by passing in a ASCII value >>> chr(97) 'a' >>> >>> # string formatting expression. >>> '{0} is a string'.format('this') 'this is a string' >>>

String methods

Built-in operators and expressions can be used on a variety of types, string methods can only be used on the string type.

Some string methods:

find() - returns the offset where it finds the string.

replace() - replaces all occurrences of the pattern with the passed in second argument, if you pass in a third arugment, it will replace it only for those many number of occurences.

join() - takes in any iterable as a parameter and joins the values in that iterable by using the string it is being called on as a delimiter.

split() will split a string into a list based on a delimiter which is passed in.

>>> >>> # Create a new string >>> new_string = str("this is a new string") >>> >>> # get the ASCII value of a character >>> ord('a') 97 >>> >>> # get the character by passing in a ASCII value >>> chr(97) 'a' >>> >>> # string formatting expression. >>> '{0} is a string'.format('this') 'this is a string' >>> >>> # find the offset in the string that matches the argument. >>> new_string.find('is') 2 >>> # replace one value with another. >>> new_string.replace('string', 'simple string') 'this is a new simple string' >>> >>> # join a iterable using the string on which the join operation is being called on. >>> '.'.join('string') 's.t.r.i.n.g' >>> >>> # upper case >>> new_string.upper() 'THIS IS A NEW STRING' >>> >>> # check if all the values are alphabets >>> new_string.isalpha() False >>> cartmans_song = 'the lazy river has never been lazier' >>> >>> # split the string using a empty space as the delimiter >>> cartmans_song.split(' ') ['the', 'lazy', 'river', 'has', 'never', 'been', 'lazier'] >>>

String module in older 2.x had most of these string methods, it has been removed in 3.0. You should always use string methods not the methods in the old string module. The string module itself has been retained because it contains some other advanced string processing tools.

String formatting expressions

You can use string formatting expressions to create strings. You can use formatting characters as place holders and use a single value to the right hand of the % or use a tuple in case of multiple values.

You can also pull up values from a dictionary by using:

>>> '%(first)s %(second)d' % {'first' : 'eric', 'second' : 5} 'eric 5' >>>

The built in function vars(), generates a dictionary of all the variables and values that have been loaded in the current thread, you can use this on the right hand side of the % to pull values for formatting strings using a dictionary.

String formatting methods

You can use the format method in Python to create strings. This is new in 2.6 and 3.x. You have to use either positional or named arguments. You can also use object attributes.

>>> >>> # positional string formatting. >>> "{0} and {1}".format("Eric", "Stan") 'Eric and Stan' >>> >>> # named string formatting. >>> >>> "{0[eric]}".format({"eric" : "cartman"}) 'cartman' >>> >>> # string formatting using object attributes >>> import sys >>> "{0.platform}".format(sys) 'win32' >>> >>> # variant of string formatting using object attributes >>> "{names[SouthPark]}, {sys.platform}".format(names = {"SouthPark" : "Eric Cartman"}, sys = sys) 'Eric Cartman, win32' >>>

You can use list indexes or dictionary names as the values in the squared brackets

You cannot use negative index offsets in the string literal that is being used as a template.

You can use the formatting method to specify left / right justification, alignment and precision.

The format built in function calls the types internal format method.

You can in 3.1 and later skip the positional index all together, and Python will use relative indexing.

You can in 3.1 and later, use a comma to print out numbers with comma sperating thousands

This post is the seventh of many that attempts to document everything I have been learning about Python.

Much of Python's conciseness, flexibility and power comes from the fact that it is a dynamically typed language.

Dynamic typing means that you, the developer, do not have to declare variables ahead of time and you do not have to specify the type of the variable.

Variables do not have types, they are just pointers to objects in memory.

Objects have types, variables only point to objects.

For example, when you run this line of code:

>>> >>> desc = "Python Programmer"

The string "Python Programmer" is assigned to the variable desc.

The following steps have to happen for this work:

1. Python creates a object in memory to hold the string "Python programmer" 2. It creates the variable desc. 3. It assigns the pointer (the address of the location where the string is being stored) to the variable desc.

Because all that a variable holds is the address to an object, you can re-assign that variable to point to other objects during program execution.

In the example below, the variable desc first points to a string and is then re-assigned to point to a int and then a list.

>>> desc = "Python Programmer" >>> desc = 1 >>> desc = [1, 2, 3] >>>

This is very different from static, compiled languages like C# and Java, where the variable has a type associated with it and it can only hold values of the same type.

In Python:

Variables have to be assigned before they can be used.

Variables only point to objects and not to each other.

When Python creates an object in memory, the object has 2 properties associated with it, its type name, and a reference count.

1. The type name is actually the reference to the type's class (int for integers, str for strings..) 2. The reference count is a counter that stores the number of references that are pointing to the object.

References to immutable objects.

>>> var1 = "The Adam Carolla Podcast" >>> var2 = var1 >>> var2 = "Loveline" >>>

When you run the first 2 lines of code, a object (string) is created in memory to hold the string. The address of that memory location is then stored in var1.

In the second line, that address is copied over to var2.

Now var1 and var2, both point to the same memory location.

In the 3rd line, you create a new object in memory that holds the new string and store its memory location in var2.

var1 and var2 now point to 2 different locations in memory.

References to mutable objects

>>> comedy_podcasts = ["Adam Carolla", "Dave Dameshek", "Rep. Richard Martin"] >>> podcasts = comedy_podcasts >>> comedy_podcasts, podcasts (['Adam Carolla', 'Dave Dameshek', 'Rep. Richard Martin'], ['Adam Carolla', 'Dave Dameshek', 'Rep. Richard Martin']) >>> comedy_podcasts[1] = "Dave Feeney" >>> comedy_podcasts ['Adam Carolla', 'Dave Feeney', 'Rep. Richard Martin'] >>> podcasts ['Adam Carolla', 'Dave Feeney', 'Rep. Richard Martin'] >>>

In this scenario, you create a mutable type (list) in memory and store its memory location in variable comedy_podcasts.

You then assign that same memory location to variable podcasts.

In the 3rd line, when you modify comedy_podcasts, the list is being changed 'in place'. This is because lists are a mutable type and can be changed in place. So what is really happening is that in line 3, you are actually changing the object itself.

Since podcasts is pointing to the same object in memory, its value has also been affected.

If you want to assign the copy of an object instead of its reference, here is some ways of doing it.

For lists, the simplest way is to slice it, this will create another list in memory and assign its address to the new variable.

>>> >>> list1 = [1,2,3] >>> list2 = list1[:] >>> list1[0] = "change" >>> list1 ['change', 2, 3] >>> list2 [1, 2, 3] >>>

Now only list1 is affected, list2 points to a new list in memory.

You can import the copy module and use its copy and deepcopy methods for objects to have this same effect.

Garbage Collection

When an object is created in memory, it has 2 header fields. One holds the type of the object, the other holds a count of references to the object.

When a object's reference counter hits 0, that is to say, no variable is referring to it, the object is claimed by the garbage collector.

This post is the sixth of many that attempts to document everything I have been learning about Python.

Number types in Python

1. Integers 2. Floating Point 3. Complex Numbers 4. Fixed precision decimal numbers 5. Fractions

Integers in 2.6 come in 2 flavors, int which is 32 bits and long which has as much precision as the system memory allows for. Python automatically switches to using long when int cannot hold values. It prints long values with a l or L at the end of the number.

Integers in 3.0 allow for as much precision as the system memory allows. There is no long type in 3.0.

Floating points precision is the same as the precision allowed for by the float data type of the C compiler that was used to build Python.

You can express integer literals as octal, hexadecimal and binary number expressions. All these are just expressions that evaluate to an integer.

>>> # binary, octal, hexadecimal >>> '0b11', '0o21', '0xA2' ('0b11', '0o21', '0xA2') >>>

The built in methods oct, hex and bin convert the integer to the respective forms.

You specify a oct with a 0o, hex with 0x and bin with 0b.

>>> >>> bin(128), oct(128), hex(128) ('0b10000000', '0o200', '0x80') >>>

Operator precedence the easy way

You do not have to memorize the operator precedence rules in Python if you are careful enough to group operations in parenthesis.

Mixed type expressions

When evaluating expressions that have different types (only numeric), the resulting type of the entire expression is the most complex type, that is, types are converted up to the most complex type being used in the expression. This means that integers are converted up to floats and floats to complex numbers.

>>> # adding a int with a float, resulting type is a float >>> 1 + 3.0 4.0 >>>

In 2.6, mixed type comparisons are allowed. By mixed type comparisons, I mean comparisons between types that are not numbers.

>>> # In 2.6, mixed type comparisons >>> 3 < 'test' True >>>

In 3.0, mixed type comparisons, types in which you use numbers with other types like strings will result in an error.

>>> # In 3.0, mixed type comparisons are not allowed >>> 3 < 'test' Traceback (most recent call last): File "", line 1, in 3 < 'test' TypeError: unorderable types: int() < str()

Variable creation in Python

1. Variables are never declared ahead of time. 2. Variables are replaced by their values when used in expressions. 3. Variables are created when they are first assigned values. 4. Variables have to be initialized before they can be used.

You can display numbers using both repr and str display formats. repr is used to display numbers as codes and str is usually used to display numbers in user friendly formats.

>>> # repr and str >>> repr("Throw it in the bag"), str("Throw it in the bag") ("'Throw it in the bag'", 'Throw it in the bag') >>>

Chain comparison operations

Python allows you to chain comparison operations.  

>>> >>> #Chaining comparison operators >>> # 2 < 3 AND 3 < 4 >>> 2 < 3 < 4 True >>> # 1 == 2 AND 2 < 3 >>> 1 == 2 < 3 False >>>

Division in Python

There are 2 operators that perform division and they come in 3 flavors.

In 3.0:

The / operator performs true division, no matter what type of operands, the result is always a float.

The // operator performs a floor division and maintains the type conversion convention. int and int will result in int. int and float will result in float

>>> >>> 3 / 2, 3.0 / 2.0 (1.5, 1.5) >>> 3 // 2, 3.0 // 2.0 (1, 1.0) >>>

In 2.6:

The / operator preforms classic division, it drops the decimal part in case of integers.

The // operator works the same way as in 3.0

>>> >>> 3 / 2, 3.0 / 2.0 (1, 1.5) >>> 3 // 2, 3.0 // 2.0 (1, 1.0) >>>

// (3.0 & 2.6) and / (2.6) have a special case because of floor division.

Floor division is the same as truncation in case of positive numbers, but when negative numbers are involved, floor is different from truncation.

Complex Numbers

These are built-in types in Python. They consist of a real part and a imaginary part. You can use the Cmath module to process them. It is the complex number equivalent to the standard Math module.

Oct, Hex, Bin notation

You can code integer literals using oct, hex and bin notation, they are just one way of generating integers.

In 2.6, you can code an octal by adding a zero to the beginning of an integer and it will be interpreted as base 8.

In 3.0, you have to use 0o that is zero followed by the letter o.

The built-in functions oct(), hex() and bin() generate numbers in their respective bases.

The int() built in takes a string and a optional base.

>>> >>> bin(128), oct(128), hex(128) ('0b10000000', '0o200', '0x80') >>> int('0o200', 8) 128 >>> int('0x80', 16) 128 >>>

You can also use formatting expressions

{0:o} is for octal

{0:x} is for hexadecimal

{0:b} is for binary

>>> # octal >>> '{0:o}'.format(200) '310' >>> # hex >>> '{0:x}'.format(200) 'c8' >>> # bin >>> '{0:b}'.format(200) '11001000' >>>

The eval built in function, takes any string and runs it as Python code. You can pass integer literals to it as strings (in any base) and it will run it as python code and echo the result in IDLE.

>>> eval('0b011') 3 >>>

Bit Operators

Python has support for bitwise operations, << (left shift), >> (right shift), ^ (XoR), & (and), | (or)

Further, you can use the bit_length method (new in 3.1) to see how many bits are needed to represent a integer. You can achieve this in 2.6 by getting the length of the binary representation of the integer and subtracting 2 to get the bits needed to represent the number.

>>> a = 3 >>> a.bit_length() 2 >>> len(bin(3)) - 2 2 >>>

There are many built in tools and modules that allow you to process numbers.

Built-ins like abs (absolute), pow (exponent) and round.

The Math module has many of the same functions as the math library in C

trunc - just drops the decimal part.

floor - drops the decimal part and floors the value (same as trunc for positive numbers, but diff for negative numbers)

There are 3 ways to compute a square root in Python

Import the math library and use math.sqrt

Raise the number to the power .5 using **

Use the pow built in function and specify .5 as the power.

>>> abs(-10), pow(3, 2) (10, 9) >>> >>> import math >>> math.trunc(3.0) 3 >>> math.floor(-3.5) -4 >>> round(3.456, 2) 3.46 >>> >>> # all compute the square root >>> math.sqrt(81) 9.0 >>> pow(81, .5) 9.0 >>> 81 ** .5 9.0 >>>

The default namespace in Python is builtins in 3.0 and __builtin__ in 2.6

Decimals

The decimal type in Python represents fixed precision decimal. They are decimal numbers with a fixed set of decimal places.

You cannot create a decimal using a literal. The decimal module must be imported and you call the Decimal method by passing in a string that has the number.

With the decimal type, you can set the number of decimal places to be used. It tends to be a lot more accurate than using floats, but you incur a small performance penalty.

When you run operations on decimals with different precision of decimal places, Python will scale up all the other decimal values to the value with the largest number of decimal places.

You can set the number of decimals to be used by calling the getcontext() method of the decimal module and setting its prec property.

>>> >>> decimal.getcontext().prec = 2 >>> decimal.Decimal('1.4444') + decimal.Decimal('4.11111') Decimal('5.6')

Using the with statement to set the precision will cause all the code inside the with block to use the precision and the code outside the block will use the global default precision value.

>>> >>> # this will set a scope in which the >>> # precision will be applied to >>> with decimal.localcontext() as xt: xt.prec = 2 var1 + var2 Decimal('8.0') >>>

Fraction

Like the Decimal type, Fraction was introduced to get past the inaccuracies of floating point operations.

Like the Decimal type, you have to import the fraction module to use the Fraction type.

You can create the Fraction type by passing in 2 numbers (numerator and denominator). You can also pass in a float to the fraction type's from_float() method to create it.

Floats have a as_integer_ratio method that convert a float to a fraction.

While you can convert float to fractions, you might lose a lot of precision.

You might have to limit the denominator to be able to retain precision. You limit the denominator using the limit_denominator() method of the fraction.

>>> >>> import fractions >>> v1 = fractions.Fraction(1,3) >>> v2 = fractions.Fraction(2,3) >>> v1 + v2 Fraction(1, 1) >>> >>> v3 = fractions.Fraction.from_float(3.44) >>> v3.limit_denominator(10) Fraction(31, 9)

You can pass a fraction to Float() to convert it into a float

Mixed type conversions

Expressions that have int & fraction will result in a fraction

Expressions that have float & fraction will result in a float

Sets

Sets are a un-ordered collection of unique, immutable objects. The set type is iterable

They support all the regular set based operations.

You can create a set by passing in any iterable type to the Set() method.

Apart from the built-in operators that allow you to perform operations on sets. The set type has methods that allow you to perform those same operations.

While the built in operators operate only on set types, the built in methods will accept any iterable type.

In 2.6 you do not have a literal syntax to create a set, you had to rely on the Set() method. In 3.0 you can use the {} syntax to create a set.

Sets can only contain immutable objects and so you cannot embed lists and dictionaries in them. Sets also cannot contain other sets. To store one set inside another, you have to create a frozen set and embed that in other sets.

Set comprehension syntax is the same as list comprehension, except for Sets you enclose it in {}

>>> >>> set1 = set('this is a set') >>> set1 {'a', ' ', 'e', 'i', 'h', 's', 't'} >>> set2 = {'n','e','w','s'} >>> set1 & {'1', '2', '3'} set() >>> set1 | {'1', '2'} {'a', ' ', 's', '1', 'e', 't', 'i', 'h', '2'} >>> set1.union >>> set1.union({'1', '2'}) {'a', ' ', 's', '1', 'e', 't', 'i', 'h', '2'}

Booleans

Python has a data type named bool which has 2 values, True and False. These are actually representations of the values 1 and 0. bool is a subclass of int and True / False are basically values that are being printed instead of 1 and 0, this has been done by overriding the repr and str methods of the bool class.

This post is the fifth of many that attempts to document everything I have been learning about Python.

Lists

Lists are mutable (objects that can be changed in place) sequences in Python. They are a collection of arbitrary objects ordered by position.

Lists can contain objects of any type and do not have a fixed size.

You can add and remove items to a list by using the append and pop methods of the list object.

>>> >>> list_of_names = ['John von Neumann', 'Niels Bohr', 'Nikola Tesla'] >>> >>> # add an item to the list >>> list_of_names.append('John Nash') >>> list_of_names ['John von Neumann', 'Niels Bohr', 'Nikola Tesla', 'John Nash'] >>> >>> # remove an item from the list >>> list_of_names.pop() 'John Nash' >>> >>> list_of_names ['John von Neumann', 'Niels Bohr', 'Nikola Tesla'] >>>

You cannot use an index that does not exist as a positional offset nor can you assign to it.

>>> # this list has 3 values. >>> # assigning a value to a 4th offset will >>> # result in an error >>> list_of_names[3] = "John Nash" Traceback (most recent call last): File "", line 1, in list_of_names[3] = "John Nash" IndexError: list assignment index out of range >>>

You can nest lists arbitrarily.

>>> list_of_names ['John von Neumann', 'Niels Bohr', 'Nikola Tesla'] >>> a_sub_list = ['Albert Einstein', 'Alan Turing'] >>> >>> list_of_names.append(a_sub_list) >>> list_of_names ['John von Neumann', 'Niels Bohr', 'Nikola Tesla', ['Albert Einstein', 'Alan Turing']] >>>

Comprehensions.

List Comprehensions are expressions that iterate over any sequence and run a expression over each value in the sequence and return the result in a list

A list comprehension consists of any sequence, a variable that takes on the values of the sequence one at a time and an expression that acts on that variable

>>> a_list_comprehension = [x ** 2 for x in [1,2,3]] >>> a_list_comprehension [1, 4, 9] >>>

By enclosing the comprehension in () you can create generators:

>>> >>> a_generator = (x ** 2 for x in [1,2,3]) >>> next(a_generator) 1 >>> next(a_generator) 4 >>>

You can use this comprehension syntax to generate lists, dictionaries and sets.

Dictionaries

Dictionaries are a mutable type. They are used to map keys to values.

You create a dictionary by wrapping key value pairs in { }

You index a Dictionary type with its key to get to its value.

>>> >>> testdict = {"languages" : ["Python", "C#", "R"], "math" : "Algebra"} >>> testdict["languages"] ['Python', 'C#', 'R'] >>>

When you assign a value to a key that does not exist, that key and value are added to the dictionary, this is unlike the list where adding a value to a index that does not exist results in an error.

>>> >>> testdict["field_of_study"] = "HFT" >>> testdict {'languages': ['Python', 'C#', 'R'], 'field_of_study': 'HFT', 'math': 'Algebra'} >>>

Dictionaries are not sequences, so they do not maintain any left to right order.

You can sort dictionaries by getting their keys in a list, sorting the list, using a for loop to move through the list OR you can use the built-in sorted function call that can sort a variety of objects.

>>> >>> unsorted_dict = {"a" : 1, "b" : 2, "c" : 3} >>> # no left to right order >>> unsorted_dict {'a': 1, 'c': 3, 'b': 2} >>> sorted(unsorted_dict) ['a', 'b', 'c'] >>> >>> keys_in_dict = list(unsorted_dict.keys()) >>> keys_in_dict ['a', 'c', 'b'] >>> # sort the list >>> keys_in_dict.sort() >>> keys_in_dict ['a', 'b', 'c'] >>>

The in membership expression allows us to check if a key we are trying to retrieve in a dictionary exists. It is an error to index and fetch a non-existent key from a dictionary type.

>>> # Using the 'in' membership operator >>> unsorted_dict {'a': 1, 'c': 3, 'b': 2} >>> 'a' in unsorted_dict True >>> >>> # Accessing a key that does not exist >>> unsorted_dict["test"] Traceback (most recent call last): File "", line 1, in unsorted_dict["test"] KeyError: 'test' >>>

You can also call the get method of the dictionary type, this accepts the key name and a default value that will be returned if the key does not exist.

>>> unsorted_dict {'a': 1, 'c': 3, 'b': 2} >>> >>> unsorted_dict.get('a') 1 >>> unsorted_dict.get('m', 9) 9 >>>

Tuple

A tuple is like a list, in that it is a sequence, but unlike a list, it cannot be changed, it is immutable.

You create a tuple by enclosing a set of values in () separated by commas.

>>> wooo_a_tuple = ('what', 'me', 'pragmatic', 'huh') >>>

Files

This type represents external files. Unlike other types, you cannot use a literal to create it, rather, you need to call the built-in open function by passing in the external file name and a access type as parameters.

>>> >>> file_name = open('testfile.txt','w') >>> file_name.write("this is a test string") 21 >>> file_name.close() >>> file_name_to_read = open('testfile.txt', 'r').read() >>> file_name_to_read 'this is a test string' >>>

Sets

Sets are collections of unordered, unique immutable objects. You can think of them as valueless dictionaries. They are created using {}

>>> title_town = {"Celtics", "Patriots", "Red Sox", "Bruins"} >>>

Decimals and Fractions

Decimals and Fractions are the 2 new types added, they are not part of the core built-in types and have to be imported.

>>> >>> from fractions import Fraction >>> var = Fraction(3, 4) >>> var Fraction(3, 4) >>> var1 = Fraction(1, 4) >>> var1 Fraction(1, 4) >>> var + var1 Fraction(1, 1) >>> >>> from decimal import Decimal >>> dec1 = Decimal("1.0") >>> dec2 = Decimal("33.3") >>> dec1 + dec2 Decimal('34.3') >>>

Bool

The Boolean type is essentially a numeric type, it represents values 1 and 0, prints them out as True and False.

>>> bool_var = True >>> # it really is an integer >>> bool_var + 1 2 >>>

Type

The type built in function returns the type of the object being passed to it.

>>> type(bool_var) >>> type(unsorted_dict) >>>

Class

The class keyword allows you to declare your own types that model real world entities.

This post is the fourth of many that attempts to document everything I have been learning about Python.

Python is dynamically typed, there are no type declarations. It keeps track of types for you and is a strongly typed language. Types are created when expressions are evaluated. Only operations valid on a type can be performed on it.

Python provides built-in object types that you can start using in your programs right away. Objects like lists, dictionaries, tuples and strings are part of the core language.

In most cases, these built-in objects are all that you need to model your application domain. Moreover, these objects are implemented using C which means you get a good deal of performance by using them.

In cases where you have to define your own, Python allows you to define your own types which can in turn leverage the functionality provided by Python's core built-in objects.

Python types are either immutable (cannot be changed in place) or mutable (can be changed in place).

Strings, numbers, tuples, sets are immutable.

Lists & Dictionaries are mutable.

Numbers

Numbers in python  are integers, floating point numbers, fixed precision decimals, complex and rational numbers.

In 3.0 integers can hold values no matter how large, in 2.6 a separate long integer type holds values that are beyond the range of integers.

Strings

Strings in Python are positional ordered collection of single characters. They are part of the family of sequences. You can operations like index and slice on them.

Indexing a string:

>>> >>> # string in Python >>> day_job = 'human genome project' >>> >>> # indexing a string to retrieve the >>> # character at the index (offset) >>> >>> day_job[0] 'h' >>> >>> # Negative offsets can be used >>> # start from the end of the string >>> >>> day_job[-1] 't' >>>

Slicing a string:

You can extract parts of a string by slicing it. The syntax is val[i:j] where i is the starting offset and the string is sliced all the way up to but not including offset j

>>> >>> day_job = "human genome project" >>> >>> # slicing a string >>> day_job[6:12] 'genome' >>>

You can slice using negative offsets. If you skip the indexes all together, they default - 0 for the lower bound and the length of the string for the upper bound.

>>> day_job = "human genome project" >>> >>> # slicing a string >>> # using negative offsets >>> day_job[0:-3] 'human genome proj' >>> >>> # slicing a string >>> # using offset defaults >>> day_job[:-7] 'human genome ' >>> day_job[5:] ' genome project' >>>

The indexing and slice operations are built in Python operations and are applicable to any type that is a sequence.

You can apply operations on strings. + is used to concatenate strings, whereas a * will repeat the string a certain number of times.

>>> >>> # concatenation >>> "day" + " job" 'day job' >>> >>> # repetition >>> "day job" * 3 'day jobday jobday job' >>>

Operations that are type specific are available as callable methods on that type.

>>> >>> day_job = "human genome project" >>> >>> # returns the index of the string >>> # location of the string. >>> day_job.find('genome') 6 >>> >>> # replaces the old value with the new one >>> day_job.replace('project', 'assignment') 'human genome assignment' >>>

To get a list of all string methods, you can use the dir method by passing in the type as parameter. You can then invoke the help method by passing the type and its attribute to learn more about its usage.

>>> >>> day_job = "human genome project" >>> dir(day_job) ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] >>> >>> help(day_job.upper) Help on built-in function upper: upper(...) S.upper() -> str Return a copy of S converted to uppercase. >>>

You can create strings using string literals, string format expressions, string format functions (new in version 3.x), strings with special characters, multiline strings that are printed as-is created using 3 quotes (either single or double).

This post is the third of many that attempts to document everything I have been learning about Python.

Some ways to execute a Python program:

From the command line you can invoke the interpreter using

              python source.py

Double clicking the file icon in windows. This assumes that the .py file extension is associated with the Python runtime in the windows registry.

Inserting this string in the first line of your .py source file will turn the file into a executable python script (on *nix), the second line turns the script into an executable.

              #! /usr/bin/python

              chmod +x sourcefile.py

By launching an interactive session using either the system shell or via IDLE and using import to load the module.

>>> import math >>> math.sqrt(144) 12.0 >>>

When you load a module using a import statement, the python interpreter executes all the code in that module.

If you change the source and import the same file again in the same session, you will not see your changes reflected. This is because import is a expensive operation to run multiple times. Every time you import a module, the module code has to be compiled and then executed.

# sourcefile module # Function accepts 2 parameters and displays them. def printname(first, last): print(first, last)

Import the sourcefile module, importing it will execute the code in the module.

>>> >>> import sourcefile >>> sourcefile.printname('Rakshit', 'Pai') Rakshit Pai >>>

If you have made changes to the code of a module after you have imported it, you can reload it using using the reload function of the imp module.

# sourcefile module # Modify function to accept 3 parameters and display them. def printname(first, last, middle): print(first, last, middle)

>>> >>> import imp >>> imp.reload(sourcefile) >>> sourcefile.printname('Rakshit', 'Pai', 'K') Rakshit Pai K >>>

The reload function of the imp module will only reload a module that was previously loaded via a import call in the session. When you load modules using import, the module name acts as a namespace through which the attributes in the imported modules can be accessed, it acts as a buffer that helps you avoid naming clashes if variables with the same name are already declared in the importing environment.

reload only loads the module that you have passed in as a parameter. Any modules being imported in the module being loaded have to be re-loaded separately.

For example, when you import the module sourcefile, you can access the attributes of sourcefile by qualifying their names with the namespace of their enclosing module (sourcefile)

# sourcefile is the module name. # it has a function attribute named printname >>> sourcefile.printname('Rakshit', 'Pai', 'K')

When you import modules using the from... import... syntax, its attributes are copied over in the environment you imported the module into, this means that any previously declared variables that have the same name in the loading environment will now be overwritten by the variables in the module

>>> # declare a list named lst in the current session. >>> >>> lst = [1, 2, 3] >>> lst [1, 2, 3] >>>

# module named sourcefile has a lst list variable lst = ['hello', 'world']

using from... import... syntax import the lst variable from the sourcefile module.

>>> # Declare a variable lst in the current session >>> lst = [1, 2, 3] >>> lst [1, 2, 3] >>> >>> from sourcefile import lst >>> lst ['hello', 'world'] >>> >>> # The original lst variable declared earlier in the session >>> # has now been replaced with the variable in the imported module

You can also use the built in exec function to load a module. Using exec is similar to pasting the modules code and running it. But as with from.. import… this will override the values of any variables that have the same names as variables in the working environment.

This post is the second of many that attempts to document everything I have been learning about Python. 

Python code files a.k.a Modules

Python files end with the .py extension. This is not required, only files that have to be imported have to end with .py. Most python script files follow this convention.

Program Execution

When you run the a python script, the source code is first compiled to byte code, if Python has write access to the machine, it will generate this byte code and save it in .pyc file, else, it will just store it in memory. Byte code is low level portable code that the python interpreter can execute with greater speed than the source code.

When you run the same program again, unless the source file has been changed, the interpreter just runs the byte code in the .pyc file. This can result in improvement in startup speed, as python does not have to do a compile step.

Python can run programs just using .pyc. It does not need to have the .py source file.

The Python Virtual Machine then runs through the byte code file, executing each instruction from top to bottom.

To you, the programmer, this process consists of entirely one step, running the code file with the interpreter. The compilation step to generate the byte code and the execution of the byte code by PVM happens behind the scenes.

Because the PVM has to interpret the byte code instructions and run them, Python code usually runs slower than C and C++ code which are always compiled to machine code and executed directly by the CPU.

Implementations of Python

Python language has 3 implementations.

CPython: This is the standard implementation. It is written using ANSI C

Jython: This implementation allows Python programs to inherit and call programs written in Java. Jython converts Python source code to java byte code and runs it on the JVM.

IronPython: Similar to Jython, except this compiles .py to .net IL code and then executes it on the CLR.

Some tools that speed up program execution

Psyco JIT:

As a python program is being executed, Psyco will attempt to convert the data types being used to native binary code. This can lead to some decent improvements in speed. It attempts to read and understand the types being used in the program. It then compiles those types to native machine code. This machine code can then replace parts of the python byte code which leads to faster execution.

Psyco has to be installed separately, it is not part of the standard Python install.

Currently, it only generates machine code for x86 chips.

Shedskin C++ compiler:

Attempts to translate python source code into C++ and execute the resulting C++ code using the C++ compiler. This dictates that Python programs be written using what can be described as a non-pythonic approach.

Frozen binaries

You can package python byte code files, PVM and support files in a single exe that can be shipped off to consumers.

Tools that help you create frozen binaries:

Py2exe for windows

pyinstaller for unix/linux

Freeze -the original program used to generate frozen binaries.

Other execution options

Stackless Python: Does not save state data on the C stack.

Cython: Hybrid language which allows you to use C type declarations in python code and call C functions. Cython code can be compiled to C code that uses the Python / C API. It is not completely compatible with standard Python

Parrot: Attempts to provide a common byte code format and virtual machine environment for different languages

PyPy: Attempt to re-write PVM using Python

A few weeks ago, I spent a few days learning Python using LPTHW.

Starting this week, I began my deep dive into Python exploring each feature of the language in depth.

This post is the first of many that attempts to document everything I have been learning about the language.

Why learn Python?

Python is a simple, coherent language that is easy to learn. It has a small core and focuses on readability. Python programs, even the ones you did not write, are easy to read and understand. This leads to re usability and ease of maintenance.

Python has support for object oriented programming. You do not have to use it, but it is there if you need it.

Programs written using Python are typically smaller than similar programs written in static compiled languages like C++, Java and C#. This means that there is less code that needs to be written and maintained.

It comes with a standard library that has support for a lot of tasks that are part of application development. It has modules for network programming, regular expressions, parsing different forms of markup and many more.

Python programs are portable, in most cases, all you have to do is copy the source files from one OS to another. Programs can be called from and can call programs written using C, C++, Java and .NET. This makes it a good choice for extending programs or as a integration language.

Because Python builds out on a small core, the language is remarkably consistent. This makes it easy to remember. I experienced this first hand when writing a simple program to parse an xml file. I never found myself reaching for a reference book to look up the usage for syntax.

A lot of libraries useful in various application domains that are written using  languages like C, C++, Java and C# have a front end Python API that make it easy to integrate them in Python programs. NumPy and SciPy are some of the popular ones.

Scripting language

Python is often referred to as a scripting language. I have found that this often leads to confusion. To some, a scripting language is something that is used to code operating system level tasks, to others, it signifies the ability of a language which can be used to integrate various application components written using C++ and Java.

Python is in fact used in these roles, but is not limited to them.

You can use Python to build  line of business (industry jargon for boring & un-exciting) applications. You can use Python to build any application that you would build using languages like Java and C#.

Speed of Execution vs Speed of Development

The question - '..but is it fast' always pops up when discussing the viability of any programming language. Let's not forget that speed of development is often preferred over speed of execution for applications in most domains.

As per the standard Python implementation, Python code is first compiled to byte code. You can think of this as low level portable code. The Python interpreter then interprets and executes the byte code. Because the Python source code is first compiled to byte code and not binary machine executable code it results in a decrease in performance when compared to code written in languages like C which are always compiled down to machine level code.

Certain tasks such as file processing in Python are dispatched to compiled C code inside the Python interpreter and run at native speeds.

If you still want the programs to run at native execution speeds, you can code those parts in languages like C or C++ and call those compiled extensions using Python.

Some technical strengths

Dynamic typing

Python is dynamically typed, which means that you, the developer, do not have to write mountains of code that do nothing but declare types. In Python, there is no concept of declaring variable or assigning types ahead of time. Types are created when expressions are evaluated at runtime.

Memory management

Python has a garbage collector that reclaims objects that are no longer being used. You do not have to write code to manage memory.

OOP

Inheritance, Polymorphism, Operator Overloading are all supported in Python. You don’t have to use OOP for programs, but it has support for OOP if you need it.

Built in objects

The language and its standard library has built in objects that are used in everyday programming tasks. Objects like lists, dictionaries, tuples, strings are part of the standard language. Python also has built in tools that are used to manipulate these objects.

Portable

The standard Python implementation is written using ANSI C. This can be compiled and run on virtually every hardware platform. Most of the standard library that comes with Python is also portable.

Polymorphism

I spent all of last week learning Python using Learn Python the Hard Way (LPTHW) written by Zed Shaw.

The book is targeted mainly towards people who have never programmed before, but that should not prevent experienced software developers from using it to learn Python.

I spent all of March learning Python using Mark Lutz’s Learning Python. After finishing about 20 chapters, I was exhausted. I have never programmed in a dynamic language before, well, I have programmed in JavaScript, but let’s face it, is that really a programming language? :)

Working through Learning Python was exhausting because it my first look at Python, but also mostly because the book is an in-depth reference for Python, which meant that every single statement and concept had a lot of text around it explaining why or how it worked.

Now this is good because you definitely need to know how stuff works, but I was looking to learn just enough of the language to write small useful programs and was willing to dive in and learn more as I went along.

I picked up LPTHW last weekend. It was my second pass at learning Python. A few exercises into it and I was hooked.

Zed’s teaching style is brilliant. Each exercise is short. It has a code snippet that you are to type in and run. You then compare the results of your program with his. There is a short explanation of why or how it worked. An extra credit exercise that builds upon or helps reinforce the concepts that were covered in the exercise.

Because the exercises are simple and short, you can get through them fairly quickly. This helps keep up interest because you get the feeling of being able to progress quickly.

This style of teaching is so effective that after finishing a few exercises, I was able to build a neat tool (for work) that parsed XML and wrote its output to a text file.

The program is very primitive; I do not use any xml library, and instead, read the xml data from the file while going each line looking for a tag. When I find it, I pull out a part of that line by using the substring method.

LPTHW teaches you Python by showing some cool ways in which to use the language. For example, exercise 41 shows you how to store function references in dictionaries and then use that to build a simple finite state machine.

I now find myself building simple python programs for fun.

I wish more books were written using the LPTHW style. See with LPTHW, the author teaches the language using simple and fun examples. These keep the reader interested which leads them to experiment with the language by writing their own programs.