Python 3.0

Since the last time I wrote an article Python many changes happened in my life, one of them is the release of Python 3.0 (Which is known also as Python3K and Python3000).

Python 3.0 is the first intentionally backwards incompatible Python release, which means that there are some changes you must notice before start coding in Python 3.0.

Don’t worry that much, the language has become more useful, and also there is 2to3 source-to-source conversion tool which converts your Python 2.x code to meet the requirements of Python 3.0

To find more about change in Python please refer to Python website.

P.S.

From now on all the code will be written in Python 3.0.

Decimal vs. float

Please try the following code in your python console:
d = 0.1
print(d)
print(str(d))
You’d get this output:

0.1
Strange ain’t it?
The second value is the one you put in the variable.
The first one is the real value represented in memory. This is not Python’s fault, this happens because of the way computer store float values in memory as 0′s and 1′s, computers use floating point IEEE-745 representation.

Using this representation unfortunately we can’t represent any float value using 0′s and 1′s, and 0.1 is one of those poor values (The reason is that it can’t be represented in sum of powers of 0.5).

So what all programming languages do is that they ignore the small fraction so it would be 0.1 instead of 0.10000000000000001, but Python doesn’t.

Try this code in Java if you have:
public class NoDifference{
  public static void main(String[] args){
    double a = 0.1;
    System.out.println(a);
    a = 0.10000000000000001;
    System.out.println(a);
  }
}
You’d get this output:

0.1

So Java doesn’t differ those two values while they’re different. (Such a difference could make a disaster in a nuclear reactor )
If you want to go with the flow and ignore this difference in your calculations you’d have to use another data type than float, you’ll have to use Decimal.
from decimal import Decimal
d = Decimal("0.1")
print(d)

0.1

Decimal data type allows you to represent any decimal value you want

It also supports addition, subtraction, multiplication, division and modulo, but the two sides must be Decimals.

Functions

Let’s write a function that prints Fibonacci series to a given boundary:
def fib(n):
  """Prints Fibonacci series up to n"""
  a, b = 0, 1
  while b < n:
    print(b, end = " ")
    a, b = b, a + b
#Now we can call the function by its name
fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Now let’s describe what we have done:

1. def is a keyword in Python, def defines it defines methods and classes.
2. fib is the method’s name, method’s name must meet the same requirements for variable’s name. (first character a-z, A-Z or _, other characters a-z, A-Z, 0-9, _)
3. (n) is the list of parameters, notice that no type names in this list. parameters are comma separated.
4. : defines the scope of the method. All statements under this scope must be tab-aligned.
5. “”"Prints …”"” is an optional string literal that describes what this method does, it will help you and other developers understand the purpose of the method, and it will also help you auto-generate documentation for your code.
6. a, b = 0, 1. define two variables and give them two values. a handy way
7. a, b = b, a + b. also assign two values to two variables.

The previous code defines a procedure (not a function) because it doesn’t return a value, let’s modify the code so it builds an array of Fibonacci values instead of printing them:
def fib(n):
  """Prints Fibonacci series up to n"""
  a, b = 0, 1
  result = []
  while b < n:
    result.append(b)
    a, b = b, a + b
  return result
f = fib(100)
print(f)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

What we have added is the return statement only, which returns a value to the caller.

One more thing to be told is default arguments:
def askYesNoQuestion(question, retries = 4, complaint = "Please write Yes or No only!"):
  while retries > 0:
    answer = raw_input(question)
    if answer in ['y', 'ye', 'yes', 'yep']: return True
    if answer in ['n', 'no', 'nop']: return False
    retries -= 1
    print(complaint)
  raise IOError, "stupid user"
#Now we can call it
askYesNoQuestion("Are you sure?", 1, "What?!")
askYesNoQuestion("Overwrite?", 1)
#Same as askYesNoQuestion("Overwrite?", 1, "Please write Yes or No only!")
askYesNoQuestion("Do you know me?")
#Same as askYesNoQuestion("Do you know me?", 4, "Please write Yes or No only!")
askYesNoQuestion("Do you have a pen?", complaint = "You can say no if you want!")
#Same as askYesNoQuestion("Do you have a pen?", 4, "You can say no if you want!")
Default arguments are assigned a default value if they aren’t when called.
You can set arguments values when calling by writing Name = Value.
Default parameters can’t be followed by non-default arguments.
Important note:
Default arguments are evaluated only once, so the following code will accumulate the values:
def f(a, L = []):
  L.append(a)
  return L
f(1)
print(f)
[1]
f(2)
print(f)
[1, 2]
f(3)
print(f)
[1, 2, 3]
If you don’t want the function to behave like this you can write:
def f(a, L = None):
  if L is None:
    L = []
  L.append(a)
  return L
Let’s explain what I meant by saying “are evaluated only once”:
When the Python interpreter reaches the line that defines the method, it allocates a list in the memory and assigns its address to L the reference.
Next time you call the function L will reference the same list it referenced the time it was created in memory, so it will always reference the same object.
The second code actually referenced to None, so every time you call the function it will assign None to L.
By understanding what I meant you can consider the following example:
i = 10
def f(a, b = i):
  return a + b
i = 11
print(f(2)) #Will it print 12 or 13?
12
That’s because b was given the value of i before the interpreter reached the line in which i was give the value of 11.

Bottom Line

Not that much I presented in this part, but you should consider upgrading your Python knowledge to Python 3.0 for the next time.
And by the way, I’m sorry, I’ve betrayed you and learned a lot during the last month, I have also started creating GUI Applications using Python and Qt, so please forgive me
Cheers.

Dictionaries

Nesting

Pretty easy right?

Memory issue

Missing keys

For Loops, List Comprehensions and Performance

Tuples

Other File Types

Python also supports lots of types, but we won’t cover them all here (or at least now ).

User-defined Types

Bottom Line

Why Use Built-In Types?

Most of the time in programming you’ll use lists, stacks, arrays, queues and dictionaries, so instead of constructing them, Python gives you a bunch of built-in types to use. The built-in types implement the semantic of the type ADT (Abstract Data Type), and they are fast, ‘cuz some of them are written in C and C++.

What Core Data Types Does Python Provide?

As in any language, Python provides the usual list of types besides other data types:

• Numbers: 1234, 3.1415, 999L, 3+4j, Decimal
• String: ‘Some text’, “a Text”
• Lists: [1, [2, 'Three'], 4]
• Dictionaries: {‘food’ : ‘Lemon’, ‘taste’ : ‘Yummy!’ }
• Tuples: (1, ‘Name’, 5, ‘u’ )
• Files: myFile = open(‘someFile’, ‘r’ )
• Other Types: Sets, Types, Boolean, Object, None

And don’t forget that everything is an object at the end
Although Python has no variable declaration – you just assign the value to a variable name and it will be declared automatically -, it keeps track of your variables dynamically, so when you assign a string value to a variable you can use string operations only on it, and so on.
Now let’s discuss the types in a glance ‘cuz we’ll talk about them in depth later.

Numbers:

Python provides: integers (1234), floating point (3.1415), unlimited precision long (43251278364218357642386321984621734982137469321856412L), complex numbers (4568 + 789j), fixed precision decimals and sets.
Python also provides the simple operations:
+ is used for addition, – for subtraction, * for multiplication, ** for exponents, / for division.
You can calculate whatever you want (2 ** 1000000, but you don’t wanna print 300000 digit ).
When printing numbers there are two methods of printing, the first one is called ‘repr’ (object as code) and it prints the number with full precision, the second one is called ‘str’ which prints the number in a user-friendly way:
>>> 3.1415000000000002 * 2 #repr
6.2830000000000004
>>> print 3.1415000000000002 * 2 #str
6.283
We’ll discuss this method later when we introduce classes
Besides basic operations Python provides a module called ‘math’ which has useful methods and variables:
>>> import math
>>> math.pi
3.1415926535897931
>>> math.sqrt(123)
11.090536506409418
And it also provides a module called ‘random’ which generates random numbers:
>>> import random
>>> random.random()
0.8591504308650737 #You might get another value
>>> random.choice([1, 2, 3, 4])
4 #You might also get another value
We’ll discuss more numbers types soon, but now let’s move to another type.

Strings:

Strings as you might all now are arrays of characters (in Python we call the array a sequence).
Some of the sequence operations:
>>> s = ‘My Text’
>>> len(s)
7
>>> s[0]
‘M’
>>> s[3]
‘T’
A good indexing way is the negative indexing, which starts from left to right:
>>> s[-1] #Equivalent to s[len(s) – 1]
‘t’
>>> s[-2] #Equivalent to s[len(s) – 2]
‘x’
Slicing is another way of indexing in sequences, and it is used to extract a portion of the sequence:
>>> s[3:6] #A slice starts from 3 and ends at 5 not 6
‘Tex’
In slicing the left parameter’s default value is 0, and the right’s is the length of the sequence, which leads to some other slicing operations:
>>> s[:]
‘My Text’
>>> s[1:]
‘y Text’
>>> s[1:len(s)] #Same as s[1:]
‘y Text’
>>> s #Notice that s hasn’t changed, we were given new objects.
‘My Text’
>>>s[:-1] #Everything but the last character
‘My Tex’
As you have noticed we were given new objects, which leads to the fact that slicing using [:] will copy the sequence into another new sequence, which is a great way to copy lists and other sequences.
As sequences, strings support concatenation and repetition:
>>> s + ‘ Is Beautiful’
‘My Text Is Beautiful’
>>> s #s hasn’t changed
‘My Text’
>>> s * 5
‘ My TextMy TextMy TextMy TextMy Text’
You see, + is used here for concatenation while in numbers it is used for addition, this is called operator overloading in other languages.

Bottom Line:

We’ll continue talking about types next time, until then create numbers and strings. Try to set a value to specified index of a string, what would you get?
Cheers.