My Technical Blog
Posts tagged CS
I'm Learning Python part 7
Nov 29th
I’m Learning Python (part 7)
Apology:
First of all I wanna apologize for being late with this part, I’ve had busy days first during Shaam 2008 expo and second during some studies at the college and last busy time past launching Bawabaty project.
Numbers:
Numbers in Python are divided into 5 sections:
Integers:
Such as: 1234, -1234, 0
Long Integers (unlimited size):
Such as: 71632487932648921735413278645238947231659821365213847L
These numbers grow as long as your memory can hold, and it ends with a small or capital L but it is an optional literal, you can define:
/>>> TheLongVariable = 99999999999999999999999999
/>>> TheLongVariable
99999999999999999999999999L
Floating Point Numbers:
Such as: 1.234, 3.14e-10, 4.01e+12
You can define them using points, e or E.
Octal and hex literals:
Such as: 0172, 0x9fab, 0X3FBC
Octal is defined by starting your number with a leading zero, while hexadecimal is defined by starting you number by a leading 0x or 0X.
Complex Numbers:
Such as: 3+4j, 3.0-5.1j, 3J
Complex numbers are defined by a j or J at the end of the number, the number can consist of two parts, real and imaginary, so all the following are complex numbers:
1 + 3j, 3j, 5J, -10.1j
Python has lots of built-in numeric tools:
Of course you can use +, -, *, /, <, >, ==, !=, <> as any other programming language, but Python has more:
**: Power, 2 ** 3 is 8.
//: Is truncated division, 5 // 2 is 2
%: Remainder, 5 % 2 is 1
You can use also bitwise operations:
/>>, << shift right and left, 5 << 2 is 20, 24 >> 3 is 3.
|, & Or and And, 4 | 3 is 7, 7 & 2 is 2.
Just as any other programming language, Python deals with expressions using operator precedence: 3 + 4 * 2 is 11 because * is done before +.
Of course you can use parentheses to define the way you want to deal with the expression, (3+ 4) * 2 is 14.
When mixing multiple types in an expressions, all types are converted up, 40 + 3.14 will be calculated as 40.0 + 3.14. The types are ordered like this:
Integers < Long Integers < Floating Points < Complex Numbers.
The type of the result of a mixed expression is the type of the higher type, so 40 + 3.14 is a floating point, but you can force it into an integer using: int(40 + 3.14).
Variables:
During our trip in Python till now we used variables but we haven’t talked about them:
Variables are created once they are assigned a value.
Variables are replaced with their values in expressions.
You can’t use an unassigned variable, because simply you don’t have the variable yet.
Variables are references to objects.
repr & str:
Try this
/>>> a = 3
/>>> b = 4
/>>> b / (2.0 + a)
0.80000000000000004
/>>> print b / (2.0 + a)
0.8
We’ve seen something like this before, and we discussed it, the difference between the two methods is that each one uses a specified function, the first uses a function called repr which prints the value as it is in your memory, while the other uses a function called str which prints the value in a user friendly way.
More Functions:
Python provides functions for Octal and Hex conversion:
/>>> oct(64)
’0100′
/>>> oct(8 )
’010′
/>>> hex(255)
’0xff’
And vice versa, Python provides functions for retrieving integers out of Hex and Oct:
/>>> int(’0234′)
234
/>>> int(’0234′, 8 )
256
/>>> int(’0234′, 16)
564
And it also provides a way to format numbers in strings, which we will cover in another part, but a small example won’t hurt:
/>>> “%o %x” % (25, 21)
’31 15′
Other built-in functions and methods are in math module, which you can import and use:
/>>> import math
/>>> math.pi, math.e
(3.1415926535897931, 2.7182818284590451)
/>>> math.sin(math.pi / 2)
1.0
The result shown in parentheses is a tuple (which we covered last part), it is shown in a tuple because we put a column between math.pi and math.e
Bottom Line:
Thank you for waiting for this part, and until I meet you on another part try to read more about numbers from the online documentation of Python.
Cheers.
(No Ratings Yet)
Loading ...I'm Learning Python part 6
Nov 8th
I’m Learning Python (part 6)
Dictionaries
Dictionaries in Python are like dictionaries in life, they consist of key-value pairs, each key maps a value, values can be any object type, and keys also. Keys must be unique, I mean that we can’t have two identical keys with different values.
Dictionaries are defined using curly braces { and } as the following:
>>> D = {‘name’ : ‘Abd Allah Diab’, ‘age’ : 19, ‘job’ : ‘Web Developer’}
Now we can access any of the pairs using only the key:
>>> D['age']
19
Dictionaries are mutable objects, which means we can change their values in place:
>>> D['age'] += 1
>>> D['age']
20
We can add new pairs also easily:
>>> D['eyes'] = ‘brown’
>>> D
{‘job’ : ‘Web Developer’, ‘age’ : 20′, ‘eyes’ : ‘brown’, ‘name’ : ‘Abd Allah Diab’}
As you can see, the dictionary is not sorted, we entered the name first then the age and job, and at last we added the eyes, but it prints in a different order.
To sort a dictionary you should sort its keys and then print the values of the keys after sorting like the following:
To sort a dictionary you should sort its keys and then print the values of the keys after sorting like the following:
>>> keys = D.keys()
>>> keys ['job', 'age', 'eyes', 'name']
>>> keys.sort()
>>> keys
['age', 'eyes', 'job', 'name']
>>> for key in keys:
print key, ‘=>’, D[key]
age => 20
eyes => brown
job => Web Developer
name => Abd Allah Diab
Here we used a for loop which I haven’t covered, but it is just like list comprehensions, it will do what follows its declaration for each member of the set (here keys).
Please notice the indentation, after the for declaration you must hit the ‘tab’ for each line inside the for loop, and to exit the loop just don’t hit the ‘tab’ (press ‘enter’ in interactive mode).
You can make use of a new method called ‘sorted’ which takes any iteratable object (like a sequence or a string etc):
>>> for key in sorted(D)
print key, ‘=>’, D[key]
age => 20
eyes => brown
job => Web Developer
name => Abd Allah Diab
Nesting
As I told you @ first, the values can be any object, so we can nest anything inside dictionaries, for example if I want to store the first name and last name inside the ‘name’ in the dictionary, and to save a list of jobs inside the ‘job’ in the dictionary, I’d do that just like I nested matrices last time:
>>> D = {‘name’ : {‘first’ : ‘Abd Allah’, ‘last’ : ‘Diab’}, ‘age’ : 19, ‘job’ : ['Web Developer', 'Teacher', 'Student']}
Now let’s see how we can access what we’ve built:
>>> D['name']
{‘first’ : ‘Abd Allah’, ‘last’ : ‘Diab’}
>>> D['name']['first']
‘Abd Allah’
>>> D['name']['last']
‘Diab’
>>> D['job']
['Web Developer', 'Teacher', 'Student']
>>> D['job'][0]
‘Web Developer’
>>> D['job'][-1]
‘Student’
Pretty easy right? 
Memory issue
Did you ask yourself where did the old D dictionary go?
In C, C++ and many other old languages you had to manage memory by hand, but in advanced languages like Java, .NET and Python there exists a garbage collector which handles this process for you, whenever you an object has no references the garbage collector will deallocate its space.
Missing keys
When accessing a dictionary you should be careful to missing keys, especially when the dictionary is filled dynamically.
Accessing a missing key will be a mistake:
>>> D['FFF'] #Will give you a key error.
To avoid this mistake you can ask the dictionary if it has the key then you can access it:
To avoid this mistake you can ask the dictionary if it has the key then you can access it:
>>> if not D.has_key(‘fff’):
print ‘MISS’
MISS
Here we used the if control, which takes this form:
if <Condition1>:
Block1
elif <Condition2>:
Block2
.
.
.
elif <ConditionN>:
BlockN
else:
Block
Notice the indentation, ‘cuz in Python the scope is defined using indention not curly braces or Begin and End.
For Loops, List Comprehensions and Performance
Every list comprehension can be done using a for loop instead:
>>> squares = [x ** 2 for x in [1, 2, 3, 4, 5]]
>>> squares
[1, 4, 9, 16, 25]
Can be done:
>>> squares = []
>>> for x in [1, 2, 3, 4, 5]
squares.append(x ** 2)
>>> squares
[1, 4, 9, 16, 25]
But the former is faster than the latter (sometimes it is twice faster), that’s because Python is optimized, and every new version is faster and optimized more than old ones.
So the rule in Python is “Code for simplicity and readability firs, and worry about performance later” but in most cases you will stop after writing a readable program, ‘cuz Python is optimized by itself.
Tuples
Tuples (pronounced ‘tooples’) are just like lists but they are immutable, which mean that they can’t be changed once the are created, but like strings support type methods (split, len, …) and nesting and sequence operations.
Tuples are defined in parentheses ( ):
>>> T = (1, 2, 3, 4)
>>> T
(1, 2, 3, 4)
>>> T[2]
3
>>> T[-1]
4
>>> T = T + (5, 6, 7)
>>> T
(1, 2, 3, 4, 5, 7)
You might wonder, why would I use an immutable list when I can use a list? The answer is that sometimes you might want to call a method with a list parameter which you don’t want it to be changed, or when you send lists through your program and you don’t want them to be changed, you’ll use tuples then.
Other File Types
Those types we discussed aren’t the only types, there exist more types, such as sets, which are like mathematical sets (a container for a list of objects):
>>> X = set([1, 2, 3, 4])
>>> X set([1, 2, 3, 4])
>>> X.add(5)
>>> X
set([1, 2, 3, 4, 5])
>>> Y = set([1, 6, 3])
>>> X & Y #Intersection
set([1, 3])
>>> X | Y #Union
set([1, 2, 3, 4, 5, 6])
>>> X – Y #Difference
set([2, 4, 5])
Python also supports lots of types, but we won’t cover them all here (or at least now ).
).User-defined Types
You can build your own classes in Python:
>>> class Man:
def __intit__(self, name, age): #Constructor which takes two parameters and saves them
self.name = name #self is the object that we’re calling the method on.
self.age = age
def lastname(self): #A method to get the last name of the man.
return self.name.split(‘ ‘)[-1]
Now you can use your class:
>>> me = Man(‘Abd Allah Diab’, 19) #Initialize a new instance of Man
>>> me.lastname()
‘Diab’
>>> me.age
19
We won’t discuss classes and objects here, but I wanted to show you that you can have your own type easily.
Bottom Line
Here we come to the end of our tour on built in primitive types of Python, Next time we’ll start our detailed trip to Numbers
Until then keep coding and make mistakes, and don’t forget to learn of your mistakes 
Cheers.
(No Ratings Yet) Loading ...I'm Learning Python (part 5)
Oct 29th
I’m Learning Python (part 5)
String Is Immutable?
Last time I told you to try to change a specified character, you must have failed if you tried:
>>> s[0] = ‘c’
The error you’d get is:
TypeError: ‘str’ object does not support item assignment
This means that strings are immutable, so are core-types, numbers and tuples, they can’t be changed, while lists and dictionaries can be changed freely.
More Methods?
All the previous methods and operations are sequence operations, but strings have more methods:
>>> s = ‘My Text’
>>> s.find(‘Tex’ ) #returns the index of the first occurrence of the parameter
3
>>> s.find(‘abc’ ) #if the parameter wasn’t found it will return -1
-1
>>> s.replace(‘Text’, ‘Code’ ) #replaces every occurrence of the first parameter with the second one ‘My Code’ >>> s #notice that the string hasn’t changed
‘My Text’
>>> s = ‘aa,bb,cc,dd’
>>> s.split(‘,’ ) #splits the string into a list of values separated with the parameter
['aa', 'bb', 'cc', 'dd']
>>> s =’My Text\n’
>>> s.rstrip() #removes white space characters from the right of the string
‘My Text’
>>> s #don’t forget that the string hasn’t changed 
‘My Text\n’
>>> len(s) #returns the length of the string
8
>>> ord(‘\n’ ) #returns the ASCII code for the given character
10
>>> s = ‘MyTextA’ # is the null character though it doesn’t terminate the string ?
>>> len(s)
9
>>> s
‘MyTextA’
Wanna Get More?
Of course I can’t talk about every method for every type, but I’ll give you a simple way to get more, in Python there is a method called “dir” which lists the object’s methods and properties:
>>> dir(s)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', __ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', __hash__', '__init__', '__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', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', isalnum', isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper','join', 'ljust', 'lower', 'lstrip', 'partition', replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
Don’t care about those who has underscores, but the rest are methods.
Now to know more about a specified method you can use the “help” method:
>>> help(s.count)
Help on built-in function count:
count(…)
S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in string S[start:end].
Optional arguments start and end are interpreted as in slice notation.
What About Regular Expressions?
Users with a background about regular expressions will definitely ask about it, and the answer is yes you can use them with strings:
>>> import re
>>> match = re.match(‘Hello[ \t]*(.*)world’, ‘Hello Python world’ )
>>> match.group(1)
‘Python’
>>> match = re.match(‘/(.*)/(.*)/(.*)/’, ‘/usr/lib/bin/’ )
>>> match.groups()
(‘usr’, ‘lib’, ‘bin’ )
Of course you can do more as you know with regular expressions like replacing and splitting, try “dir” and “help” for more
What Is The Difference Between ‘Text’ And “Text”?
There is no difference at all, but there is a third way to write strings:
>>> s = “”"Text”"”
This way preserves the text formatting, which means you can write:
>>> s = “”"
<html>
<head></head>
<body>
<b>’I Love “Python”‘</b>
</body>
</html>
“”"
>>> s
‘\n<html>\n<head></head>\n<body>\n<b>’I Love “Python”‘</b>\n</body>\n</html>\n’
You can use this way to write pre-formatted text just like XML and HTML.
Lists And Sequences:
Lists are sequences like strings and they support every thing we talked about when discussed strings methods but the difference is that the results of methods are lists instead of strings, and that lists are changeable objects which means they support changing in place:
>>> L = [123, 'mpcabd', 1.23] #lists support multi-types
>>> len(L)
3
>>> L[0]
123
>>> L[-1]
1.23
>>> L[:-1]
[123, 'mpcabd']
>>> L + [4, 5, 6]
[123, 'mpcabd', 1.23, 4, 5, 6]
>>> L
[123, 'mpcabd', 1.23]
Lists are so much like arrays but they have no fixed size, so you can append to them and delete from them:
>>> L.append(111)
>>> L
[123, 'mpcabd', 1.23, 111]
>>> L.pop(0)
['mpcabd, 1.23, 111]
You can even sort and reverse them:
>>> L = ['a', 'z', 'c']
>>> L.sort()
>>> L
['a', 'c', 'z']
>>> L.reverse()
['z', 'c', 'a']
To find more try “dir” and “help”
What abound boundaries?
Try the following and you’d see an error:
>>> L = ['a', 'b', 'c']
>>> L[9]
IndexError: list index out of range
This means that Python checks for boundaries not like C and C++.
Can I Nest Lists?
Yes
>>> M = [
[ 1, 2, 3 ], [ 4, 5, 6 ],
[ 7, 8, 9 ] ]
>>> M
[ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]
>>> M[1] [4, 5, 6]
>>> M[1][2]
6
This is a good way to define matrices, but I advise you to use NumPy for mathematical operations, ‘cuz it is optimized for fast use.
What Are List Comprehensions?
Python includes along with what we’ve discussed a powerful methods called “List Comprehension Expressions”, suppose we wanna extract the second column of our previous matrix (M), what would you do? Python provides a good way:
>>> col2 = [row[1] for row in M]
>>> col2
[2, 5, 8]
Not good enough? Take this:
>>> [row[1] + 1 for row in M]
[3, 6, 9]
>>> [row[1] for row in M if row[1] % 2 == 0]
[2, 8]
Not enough yet? Take this one and take a nap
>>> [M[i][i] for i in [0, 1, 2]]
[1, 5, 9]
Not enough? I’ll kill you then 
For more wait for me to study
Bottom Line:
I’m sorry I was late this time but I’m really having a busy phase @ work, please wait for more and don’t get bored.
Cheers.
(No Ratings Yet) Loading ...I'm Learning Python part 4
Oct 15th
I’m Learning Python (part 4)
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.
(No Ratings Yet) Loading ...I'm Learning Python part 3
Oct 11th
I'm Learning Python (part 3)
What Is Interactive Mode?
When you install Python on your platform you'll find an executable called 'python', when you run it you'll find a terminal and you'll see something like the following:
Python 2.6 (r26:66721, Oct 2 2008, 11:35:03) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
This is called interactive coding (or interactive mode), here you can write Python statements and the interpreter will execute them directly, let's try:
>>> print "I Love Python"
I Love Python
>>> print 2 ** 10
1024
>>>
You can write any statement here (even those who are more than on line as we'll see later).
If you remember we said that the Python compiler and interpreter are always in present at runtime, so that's why you can execute the statements directly here. Another benefit you get from the presence of the compiler and interpreter at runtime that you can let your program execute Python code written by the user, and that's what some programs do, they let the user manipulate the program's behavior by writing his/her code inside the program.
To do so you can run the "exec" statement like this:
>>> exec "print \"I Love Python\""
I Love Python
>>>
Here we invoked a method called "exec" and it takes a string parameter, this string contains Python code, and the interpreter will run it, so you can simply read code from the user and run it for him/her. This method is available anywhere (not just in the interactive mode).
You must have noticed using the escape character \" in the text, and that is to tell the interpreter that this is not the end of the string and it is a double quotation inside the string, there are more escape characters that we'll find more in the upcoming parts.
Another feature to talk about in the interactive mode that you don't have to write print every time, so the next statement will run without errors:
>>> "I Love Python"
'I Love Python'
>>>
But beware, you must use print in any other mode, interactive mode is the only mode which doesn’t need the print statement, that's 'cuz it is made to print the results.
You might ask, what about statements that don't return values, what would the interactive mode print for them? The answer is: simply nothing
>>> text = "I Love Python"
>>>
The previous statement is an assignment statement, which declares a string called "text" and has the value of "I Love Python".
To exit the interactive code you use the break character (Ctrl+Z in Windows, Ctrl+D in Linux) and hit return.
What Are Modules?
Let's here explain the Python program hierarchy:
Each program consists of modules -> Each module consists of statements -> Each statement consists of expressions -> Each expression creates and processes objects -> Objects are the raw materials you'll use
When you write a Python program you write it in files, these files usually called modules, the module is a namespace, so each module has its own variables and methods. You can have two variables with the same name, but you must put each one in a module.
We'll use modules (for now) to run our code multiple times without the need of re-typing it again.
You can access another module using "import" statement, so let's try something:
- Open your editor and write the following in it:
text = "I Love Python"
print text - Save the file somewhere with the name "module1.py"
- Now start a new file and write the following in it:
import module1
module1.text = "You Know I Love Python"
print module1.text - Save the file in the same folder which has "module1.py" with the name "module2.py"
- Now let the Python interpreter run your module2 file:
python [SOME FOLDER]/module2.py - You must see the following:
I Love Python
You Know I Love Python
What happened here? In module2 I only printed the variable after editing it, why was it printed before it was edited?
When you import a module, you're simply running it, so the Python interpreter ran module1, and executed the print statement so you see "I Love Python", then it executed module2, it edited the value of the variable in module1, then executed the print statement in module2, and you see "You Know I Love Python".
So importing means running, but what if I needed to run the code again? Knowing that you can't import a module more than one, what should we do?
There is another statement "reload" which is a method and takes a string with the name of the module to re-run it again, but it should be imported before.
Try adding this line to your code in module2.py:
reload(module1)
Re-run your module2 and you must see:
I Love Python
You Know I Love Python
I Love Python
The third line is actually the print statement in module1 file.
What Is The Difference Between "import [MODULE]" And "from [MODULE] import"?
The first – import [MODULE] – imports and runs the module, but when you want to access its variables you should write: [MODULE].[VARIABLE], so each time you want to use the variable you should write the module's name followed by a period before the variable's name.
The second – from [MODULE] import – imports the specified variables from the module, so to import the "text" variable from "module1" in the previous example you write:
from module1 import text
To import more than one variable separate them with columns:
from [MODULE] impor [VAR1], [VAR2], …, [VARN]
Notice that importing a variable lets you use the variable without the need to write the module's name before it, you can simply use the "text" variable in module2 after importing it without writing module1.text.
Beware that importing a variable that has the same name of a local variable will replace the local one, for instance:
in module1.py write:
text = "I Love Python"
in module2.py write:
text = "You Know I Love Python"
from module1 import text
print text
Executing module2 will give you: I Love Python.
How can I write hints and comments in Python?
Using the sharp – # – character will hint the following text until the end of the line:
text = "I Love Python" #a declaration of a variable named text
Bottom Line:
Next time we'll learn about built-in types in Python, till then try to create and import and print modules and variables, try that in both files and interactive mode, try to make syntax errors, try to divide by zero.
Cheers.
(No Ratings Yet) Loading ...
