I’m Learning Python part 8
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.10000000000000001
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
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:
- def is a keyword in Python, def defines it defines methods and classes.
- 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, _)
- (n) is the list of parameters, notice that no type names in this list. parameters are comma separated.
- : defines the scope of the method. All statements under this scope must be tab-aligned.
- “”"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.
- a, b = 0, 1. define two variables and give them two values. a handy way
- 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.
a given value to the caller. PopAll method works this way: The first time the caller calls it it would return the first value and stop. Each next time it will continue from where it stopped.
