DareNET Wiki - User contributions [en]

Python en:Basics

2009-03-31T18:48:24Z

Swaroop: /* Logical And Physical Lines */ Improving sentence, thanks to Vincent Zee

<div class="python book">

Just printing 'Hello World' is not enough, is it? You want to do more than that - you want to take some input, manipulate it and get something out of it. We can achieve this in Python using constants and variables.

== Literal Constants ==

An example of a literal constant is a number like <tt>5</tt>, <tt>1.23</tt>, <tt>9.25e-3</tt> or a string like <tt>'This is a string'</tt> or <tt>"It's a string!"</tt>. It is called a literal because it is ''literal'' - you use its value literally. The number <tt>2</tt> always represents itself and nothing else - it is a ''constant'' because its value cannot be changed. Hence, all these are referred to as literal constants.

== Numbers ==

Numbers in Python are of three types - integers, floating point and complex numbers.

* An examples of an integer is <tt>2</tt> which is just a whole number.
* Examples of floating point numbers (or ''floats'' for short) are <tt>3.23</tt> and <tt>52.3E-4</tt>. The <tt>E</tt> notation indicates powers of 10. In this case, <tt>52.3E-4</tt> means <tt>52.3 * 10<sup>-4</sup></tt>.
* Examples of complex numbers are <tt>(-5+4j)</tt> and <tt>(2.3 - 4.6j)</tt>

; Note for Experienced Programmers
: There is no separate 'long int' type. The default integer type can be any large value.

== Strings ==

A string is a ''sequence'' of ''characters''. Strings are basically just a bunch of words. The words can be in English or any other language that is supported in the Unicode standard, which means [http://www.unicode.org/faq/basic_q.html#16 almost any language in the world].

; Note for Experienced Programmers
: There are no "ASCII-only" strings because Unicode is a superset of ASCII. If a strictly ASCII-encoded byte-stream is needed, then use <tt>str.encode("ascii")</tt>. For more details, please see the [http://stackoverflow.com/questions/175240/how-do-i-convert-a-files-format-from-unicode-to-ascii-using-python#175270 related discussion at StackOverflow].
: By default, all strings are in Unicode.

I can almost guarantee that you will be using strings in almost every Python program that you write, so pay attention to the following part on how to use strings in Python.

=== Single Quotes ===

You can specify strings using single quotes such as <tt>'Quote me on this'</tt>. All white space i.e. spaces and tabs are preserved as-is.

=== Double Quotes ===

Strings in double quotes work exactly the same way as strings in single quotes. An example is <tt>"What's your name?"</tt>

=== Triple Quotes ===

You can specify multi-line strings using triple quotes - (""" or <nowiki>'''</nowiki>). You can use single quotes and double quotes freely within the triple quotes. An example is:

<nowiki>'''This is a multi-line string. This is the first line.
This is the second line.
"What's your name?," I asked.
He said "Bond, James Bond."
'''</nowiki>

=== Escape Sequences ===

Suppose, you want to have a string which contains a single quote (<tt>'</tt>), how will you specify this string? For example, the string is <tt>What's your name?</tt>. You cannot specify <tt>'What's your name?'</tt> because Python will be confused as to where the string starts and ends. So, you will have to specify that this single quote does not indicate the end of the string. This can be done with the help of what is called an ''escape sequence''. You specify the single quote as <tt>\'</tt> - notice the backslash. Now, you can specify the string as <tt>'What\'s your name?'</tt>.

Another way of specifying this specific string would be <tt>"What's your name?"</tt> i.e. using double quotes. Similarly, you have to use an escape sequence for using a double quote itself in a double quoted string. Also, you have to indicate the backslash itself using the escape sequence <tt>\\</tt>.

What if you wanted to specify a two-line string? One way is to use a triple-quoted string as shown [[#Triple Quotes|previously]] or you can use an escape sequence for the newline character - <tt>\n</tt> to indicate the start of a new line. An example is <tt>This is the first line\nThis is the second line</tt>. Another useful escape sequence to know is the tab - <tt>\t</tt>. There are many more escape sequences but I have mentioned only the most useful ones here.

One thing to note is that in a string, a single backslash at the end of the line indicates that the string is continued in the next line, but no newline is added. For example:

"This is the first sentence.\
This is the second sentence."

is equivalent to <tt>"This is the first sentence. This is the second sentence."</tt>.

=== Raw Strings ===

If you need to specify some strings where no special processing such as escape sequences are handled, then what you need is to specify a ''raw'' string by prefixing <tt>r</tt> or <tt>R</tt> to the string. An example is <tt>r"Newlines are indicated by \n"</tt>.

=== Strings Are Immutable ===

This means that once you have created a string, you cannot change it. Although this might seem like a bad thing, it really isn't. We will see why this is not a limitation in the various programs that we see later on.

=== String Literal Concatenation ===

If you place two string literals side by side, they are automatically concatenated by Python. For example, <tt>'What\'s ' 'your name?'</tt> is automatically converted in to <tt>"What's your name?"</tt>.

; Note for C/C++ Programmers
: There is no separate <tt>char</tt> data type in Python. There is no real need for it and I am sure you won't miss it.

; Note for Perl/PHP Programmers
: Remember that single-quoted strings and double-quoted strings are the same - they do not differ in any way.

; Note for Regular Expression Users
: Always use raw strings when dealing with regular expressions. Otherwise, a lot of backwhacking may be required. For example, backreferences can be referred to as <tt>'\\1'</tt> or <tt>r'\1'</tt>.

=== The format Method ===

Sometimes we may want to construct strings from other information. This is where the <tt>format()</tt> method is useful.

<source lang="python">
#!/usr/bin/python
# Filename: str_format.py

age = 25
name = 'Swaroop'

print('{0} is {1} years old'.format(name, age))
print('Why is {0} playing with that python?'.format(name))
</source>

Output:

$ python str_format.py
Swaroop is 25 years old
Why is Swaroop playing with that python?

How It Works:

A string can use certain specifications and subsequently, the ''format'' method can be called to substitute those specifications with corresponding arguments to the <tt>format</tt> method.

Observe the first usage where we use <tt>{0}</tt> and this corresponds to the variable <tt>name</tt> which is the first argument to the format method. Similarly, the second specification is <tt>{1}</tt> corresponding to <tt>age</tt> which is the second argument to the format method.

Notice that we could achieved the same using string concatenation: <tt>name + ' is ' + str(age) + ' years old'</tt> but notice how much uglier and error-prone this is. Second, the conversion to string would be done automatically by the <tt>format</tt> method instead of the explicit conversion here. Third, when using the <tt>format</tt> method, we can change the message without having to deal with the variables used and vice-versa.

What Python does in the <tt>format</tt> method is that it substitutes each argument value into the place of the specification. There can be more detailed specifications such as:

<source lang="python">
>>> '{0:.3}'.format(1/3) # decimal (.) precision of 3 for float
'0.333'
>>> '{0:_^11}'.format('hello') # fill with underscores (_) with the text centered (^) to 11 width
'___hello___'
>>> '{name} wrote {book}'.format(name='Swaroop', book='A Byte of Python') # keyword-based
'Swaroop wrote A Byte of Python'
</source>

Details of this formatting specification is explained in the [http://www.python.org/dev/peps/pep-3101/ Python Enhancement Proposal No. 3101].

== Variables ==

Using just literal constants can soon become boring - we need some way of storing any information and manipulate them as well. This is where ''variables'' come into the picture. Variables are exactly what the name implies - their value can vary, i.e., you can store anything using a variable. Variables are just parts of your computer's memory where you store some information. Unlike literal constants, you need some method of accessing these variables and hence you give them names.

== Identifier Naming ==

Variables are examples of identifiers. ''Identifiers'' are names given to identify ''something''. There are some rules you have to follow for naming identifiers:

* The first character of the identifier must be a letter of the alphabet (uppercase ASCII or lowercase ASCII or Unicode character) or an underscore ('_').
* The rest of the identifier name can consist of letters (uppercase ASCII or lowercase ASCII or Unicode character), underscores ('_') or digits (0-9).
* Identifier names are case-sensitive. For example, <tt>myname</tt> and <tt>myName</tt> are '''not''' the same. Note the lowercase <tt>n</tt> in the former and the uppercase <tt>N</tt> in the latter.
* Examples of ''valid'' identifier names are <tt>i</tt>, <tt>__my_name</tt>, <tt>name_23</tt>, <tt>a1b2_c3</tt> and <tt>resumÃƒÆ’Ã†â€™Ãƒâ€ Ã¢â‚¬â„¢ÃƒÆ’Ã¢â‚¬Å¡Ãƒâ€šÃ‚Â©_count</tt>.
* Examples of ''invalid'' identifier names are <tt>2things</tt>, <tt>this is spaced out</tt>, <tt>my-name</tt>, and <tt>"this_is_in_quotes"</tt>.

== Data Types ==

Variables can hold values of different types called '''data types'''. The basic types are numbers and strings, which we have already discussed. In later chapters, we will see how to create our own types using [[Python_en:Object Oriented Programming|classes]].

== Objects ==

Remember, Python refers to anything used in a program as an ''object''. This is meant in the generic sense. Instead of saying 'the ''something''<nowiki>'</nowiki>, we say 'the ''object''<nowiki>'</nowiki>.

; Note for Object Oriented Programming users
: Python is strongly object-oriented in the sense that everything is an object including numbers, strings and functions.

We will now see how to use variables along with literal constants. Save the following example and run the program.

; How to write Python programs
: Henceforth, the standard procedure to save and run a Python program is as follows:
:# Open your favorite editor.
:# Enter the program code given in the example.
:# Save it as a file with the filename mentioned in the comment. I follow the convention of having all Python programs saved with the extension <tt>.py</tt>.
:# Run the interpreter with the command <tt>python program.py</tt> or use IDLE to run the programs. You can also use the [[Python_en:First Steps#Executable Python Programs|executable method]] as explained earlier.

=== Example: Using Variables And Literal Constants ===

<source lang="python">
# Filename : var.py

i = 5
print(i)
i = i + 1
print(i)

s = '''This is a multi-line string.
This is the second line.'''
print(s)
</source>

Output:

$ python var.py
5
6
This is a multi-line string.
This is the second line.

How It Works:

Here's how this program works. First, we assign the literal constant value <tt>5</tt> to the variable <tt>i</tt> using the assignment operator (<tt>=</tt>). This line is called a statement because it states that something should be done and in this case, we connect the variable name <tt>i</tt> to the value <tt>5</tt>. Next, we print the value of <tt>i</tt> using the <tt>print</tt> statement which, unsurprisingly, just prints the value of the variable to the screen.

Then we add <tt>1</tt> to the value stored in <tt>i</tt> and store it back. We then print it and expectedly, we get the value <tt>6</tt>.

Similarly, we assign the literal string to the variable <tt>s</tt> and then print it.

; Note for static language programmers
: Variables are used by just assigning them a value. No declaration or data type definition is needed/used.

== Logical And Physical Lines ==

A physical line is what you ''see'' when you write the program. A logical line is what ''Python sees'' as a single statement. Python implicitly assumes that each ''physical line'' corresponds to a ''logical line''.

An example of a logical line is a statement like <tt>print('Hello World')</tt> - if this was on a line by itself (as you see it in an editor), then this also corresponds to a physical line.

Implicitly, Python encourages the use of a single statement per line which makes code more readable.

If you want to specify more than one logical line on a single physical line, then you have to explicitly specify this using a semicolon (<tt>;</tt>) which indicates the end of a logical line/statement. For example,

i = 5
print(i)

is effectively same as

i = 5;
print(i);

and the same can be written as

i = 5; print(i);

or even

i = 5; print(i)

However, I '''strongly recommend''' that you stick to '''writing a single logical line in a single physical line only'''. Use more than one physical line for a single logical line only if the logical line is really long. The idea is to avoid the semicolon as much as possible since it leads to more readable code. In fact, I have ''never'' used or even seen a semicolon in a Python program.

An example of writing a logical line spanning many physical lines follows. This is referred to as '''explicit line joining'''.

s = 'This is a string. \
This continues the string.'
print(s)

This gives the output:

This is a string. This continues the string.

Similarly,

print\
(i)

is the same as

print(i)

Sometimes, there is an implicit assumption where you don't need to use a backslash. This is the case where the logical line uses parentheses, square brackets or curly braces. This is is called '''implicit line joining'''. You can see this in action when we write programs using [[Python_en:Data Structures#Lists|lists]] in later chapters.

== Indentation ==

Whitespace is important in Python. Actually, '''whitespace at the beginning of the line is important'''. This is called '''indentation'''. Leading whitespace (spaces and tabs) at the beginning of the logical line is used to determine the indentation level of the logical line, which in turn is used to determine the grouping of statements.

This means that statements which go together '''must''' have the same indentation. Each such set of statements is called a '''block'''. We will see examples of how blocks are important in later chapters.

One thing you should remember is that wrong indentation can give rise to errors. For example:

<source lang="python">
i = 5
print('Value is ', i) # Error! Notice a single space at the start of the line
print('I repeat, the value is ', i)
</source>

When you run this, you get the following error:

File "whitespace.py", line 4
print('Value is ', i) # Error! Notice a single space at the start of the line
^
IndentationError: unexpected indent

Notice that there is a single space at the beginning of the second line. The error indicated by Python tells us that the syntax of the program is invalid i.e. the program was not properly written. What this means to you is that ''you cannot arbitrarily start new blocks of statements'' (except for the default main block which you have been using all along, of course). Cases where you can use new blocks will be detailed in later chapters such as the [[Python_en:Control Flow|control flow chapter]].

; How to indent
: Do '''not''' use a mixture of tabs and spaces for the indentation as it does not work across different platforms properly. I ''strongly recommend'' that you use a ''single tab'' or ''four spaces'' for each indentation level.
: Choose either of these two indentation styles. More importantly, choose one and use it '''consistently''' i.e. use that indentation style ''only''.

; Note to static language programmers
: Python will always use indentation for blocks and will never use braces. Run <tt>from __future__ import braces</tt> to learn more.

== Summary ==

Now that we have gone through many nitty-gritty details, we can move on to more interesting stuff such as control flow statements. Be sure to become comfortable with what you have read in this chapter.

----

<div class="paging">
<span class="prev">[[Python_en:First Steps|Previous]]</span>
<span class="next">[[Python_en:Operators and Expressions|Next]]</span>
</div>

</div>

[[Category:A Byte of Python|Basics]]

Python en:Modules

2009-03-30T12:56:19Z

Swaroop: /* Introduction */

<div class="python book">

== Introduction ==

You have seen how you can reuse code in your program by defining functions once. What if you wanted to reuse a number of functions in other programs that you write? As you might have guessed, the answer is modules.

There are various methods of writing modules, but the simplest way is to create a file with a <tt>.py</tt> extension that contains functions and variables.

Another method is to write the modules in the native language in which the Python interpreter itself was written. For example, you can write modules in the [http://docs.python.org/extending/ C programming language] and when compiled, they can be used from your Python code when using the standard Python interpreter.

A module can be ''imported'' by another program to make use of its functionality. This is how we can use the Python standard library as well. First, we will see how to use the standard library modules.

Example:

<source lang="python">
#!/usr/bin/python
# Filename: using_sys.py

import sys

print('The command line arguments are:')
for i in sys.argv:
print(i)

print('\n\nThe PYTHONPATH is', sys.path, '\n')
</source>

Output:

$ python using_sys.py we are arguments
The command line arguments are:
using_sys.py
we
are
arguments

The PYTHONPATH is [<nowiki>''</nowiki>, 'C:\\Windows\\system32\\python30.zip',
'C:\\Python30\\DLLs', 'C:\\Python30\\lib',
'C:\\Python30\\lib\\plat-win', 'C:\\Python30',
'C:\\Python30\\lib\\site-packages']

How It Works:

First, we ''import'' the <tt>sys</tt> module using the <tt>import</tt> statement. Basically, this translates to us telling Python that we want to use this module. The <tt>sys</tt> module contains functionality related to the Python interpreter and its environment i.e. the ''sys''tem.

When Python executes the <tt>import sys</tt> statement, it looks for the <tt>sys</tt> module. In this case, it is one of the built-in modules, and hence Python knows where to find it.

If it was not a compiled module i.e. a module written in Python, then the Python interpreter will search for it in the directories listed in its <tt>sys.path</tt> variable. If the module is found, then the statements in the body of that module is run and then the module is made ''available'' for you to use. Note that the initialization is done only the ''first'' time that we import a module.

The <tt>argv</tt> variable in the <tt>sys</tt> module is accessed using the dotted notation i.e. <tt>sys.argv</tt>. It clearly indicates that this name is part of the <tt>sys</tt> module. Another advantage of this approach is that the name does not clash with any <tt>argv</tt> variable used in your program.

The <tt>sys.argv</tt> variable is a ''list'' of strings (lists are explained in detail in a later [[Python_en:Data Structures#Lists|chapter]]. Specifically, the <tt>sys.argv</tt> contains the list of ''command line arguments'' i.e. the arguments passed to your program using the command line.

If you are using an IDE to write and run these programs, look for a way to specify command line arguments to the program in the menus.

Here, when we execute <tt>python using_sys.py we are arguments</tt>, we run the module <tt>using_sys.py</tt> with the <tt>python</tt> command and the other things that follow are arguments passed to the program. Python stores the command line arguments in the <tt>sys.argv</tt> variable for us to use.

Remember, the name of the script running is always the first argument in the <tt>sys.argv</tt> list. So, in this case we will have <tt>'using_sys.py'</tt> as <tt>sys.argv[0]</tt>, <tt>'we'</tt> as <tt>sys.argv[1]</tt>, <tt>'are'</tt> as <tt>sys.argv[2]</tt> and <tt>'arguments'</tt> as <tt>sys.argv[3]</tt>. Notice that Python starts counting from 0 and not 1.

The <tt>sys.path</tt> contains the list of directory names where modules are imported from. Observe that the first string in <tt>sys.path</tt> is empty - this empty string indicates that the current directory is also part of the <tt>sys.path</tt> which is same as the <tt>PYTHONPATH</tt> environment variable. This means that you can directly import modules located in the current directory. Otherwise, you will have to place your module in one of the directories listed in <tt>sys.path</tt>.

Note that the current directory is the directory from which the program is launched. Run <tt>import os; print(os.getcwd())</tt> to find out the current directory of your program.

== Byte-compiled .pyc files ==

Importing a module is a relatively costly affair, so Python does some tricks to make it faster. One way is to create ''byte-compiled'' files with the extension <tt>.pyc</tt> which is an intermediate form that Python transforms the program into (remember the [[Python_en:Introduction|introduction section]] on how Python works?). This <tt>.pyc</tt> file is useful when you import the module the next time from a different program - it will be much faster since a portion of the processing required in importing a module is already done. Also, these byte-compiled files are platform-independent.

; Note
: These <tt>.pyc</tt> files are usually created in the same directory as the corresponding <tt>.py</tt> files. If Python does not have permission to write to files in that directory, then the <tt>.pyc</tt> files will not be created.

== The from ... import ... statement ==

If you want to directly import the <tt>argv</tt> variable into your program (to avoid typing the <tt>sys.</tt> everytime for it), then you can use the <tt>from sys import argv</tt> statement. If you want to import all the names used in the <tt>sys</tt> module, then you can use the <tt>from sys import *</tt> statement. This works for any module.

In general, you ''should avoid'' using this statement and use the <tt>import</tt> statement instead since your program will avoid name clashes and will be more readable.

== A module's __name__ ==

Every module has a name and statements in a module can find out the name of its module. This is handy in the particular situation of figuring out if the module is being run standalone or being imported. As mentioned previously, when a module is imported for the first time, the code in that module is executed. We can use this concept to alter the behavior of the module if the program was used by itself and not when it was imported from another module. This can be achieved using the <tt>__name__</tt> attribute of the module.

Example:

<source lang="python">
#!/usr/bin/python
# Filename: using_name.py

if __name__ == '__main__':
print('This program is being run by itself')
else:
print('I am being imported from another module')
</source>

Output:

$ python using_name.py
This program is being run by itself

$ python
>>> import using_name
I am being imported from another module
>>>

How It Works:

Every Python module has it's <tt>__name__</tt> defined and if this is <tt>'__main__'</tt>, it implies that the module is being run standalone by the user and we can take appropriate actions.

== Making Your Own Modules ==

Creating your own modules is easy, you've been doing it all along! This is because every Python program is also a module. You just have to make sure it has a <tt>.py</tt> extension. The following example should make it clear.

Example:

<source lang="python">
#!/usr/bin/python
# Filename: mymodule.py

def sayhi():
print('Hi, this is mymodule speaking.')

__version__ = '0.1'

# End of mymodule.py
</source>

The above was a sample ''module''. As you can see, there is nothing particularly special about compared to our usual Python program. We will next see how to use this module in our other Python programs.

Remember that the module should be placed in the same directory as the program that we import it in, or the module should be in one of the directories listed in <tt>sys.path</tt>.

<source lang="python">
#!/usr/bin/python
# Filename: mymodule_demo.py

import mymodule

mymodule.sayhi()
print ('Version', mymodule.__version__)
</source>

Output:

$ python mymodule_demo.py
Hi, this is mymodule speaking.
Version 0.1

How It Works:

Notice that we use the same dotted notation to access members of the module. Python makes good reuse of the same notation to give the distinctive 'Pythonic' feel to it so that we don't have to keep learning new ways to do things.

Here is a version utilising the <tt>from..import</tt> syntax:

<source lang="python">
#!/usr/bin/python
# Filename: mymodule_demo2.py

from mymodule import sayhi, __version__

sayhi()
print('Version', __version__)
</source>

The output of <tt>mymodule_demo2.py</tt> is same as the output of <tt>mymodule_demo.py</tt>.

Notice that if there was already a <tt>__version__</tt> name declared in the module that imports mymodule, there would be a clash. This is also likely because it is common practice for each module to declare it's version number using this name. Hence, it is always recommended to prefer the <tt>import</tt> statement even though it might make your program a little longer.

You could also use:

<source lang="python">
from mymodule import *
</source>

This will import all public names such as <tt>sayhi</tt> but would not import <tt>__version__</tt> because it starts with double underscores.

; Zen of Python
: One of Python's guiding principles is that "Explicit is better than Implicit". Run <tt>import this</tt> to learn more and see [http://stackoverflow.com/questions/228181/zen-of-python this discussion] which lists examples for each of the principles.

== The dir function ==

You can use the built-in <tt>dir</tt> function to list the identifiers that an object defines. For example, for a module, the identifiers include the functions, classes and variables defined in that module.

When you supply a module name to the <tt>dir()</tt> function, it returns the list of the names defined in that module. When no argument is applied to it, it returns the list of names defined in the current module.

Example:

<source lang="python">
$ python

>>> import sys # get list of attributes, in this case, for the sys module

>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__s
tderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_compact_freelists',
'_current_frames', '_getframe', 'api_version', 'argv', 'builtin_module_names', '
byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle'
, 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable',
'exit', 'flags', 'float_info', 'getcheckinterval', 'getdefaultencoding', 'getfil
esystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof',
'gettrace', 'getwindowsversion', 'hexversion', 'intern', 'maxsize', 'maxunicode
', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platfor
m', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit
', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_in
fo', 'warnoptions', 'winver']

>>> dir() # get list of attributes for current module
['__builtins__', '__doc__', '__name__', '__package__', 'sys']

>>> a = 5 # create a new variable 'a'

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'a', 'sys']

>>> del a # delete/remove a name

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'sys']

>>>
</source>

How It Works:

First, we see the usage of <tt>dir</tt> on the imported <tt>sys</tt> module. We can see the huge list of attributes that it contains.

Next, we use the <tt>dir</tt> function without passing parameters to it. By default, it returns the list of attributes for the current module. Notice that the list of imported modules is also part of this list.

In order to observe the <tt>dir</tt> in action, we define a new variable <tt>a</tt> and assign it a value and then check <tt>dir</tt> and we observe that there is an additional value in the list of the same name. We remove the variable/attribute of the current module using the <tt>del</tt> statement and the change is reflected again in the output of the <tt>dir</tt> function.

A note on <tt>del</tt> - this statement is used to ''delete'' a variable/name and after the statement has run, in this case <tt>del a</tt>, you can no longer access the variable <tt>a</tt> - it is as if it never existed before at all.

Note that the <tt>dir()</tt> function works on ''any'' object. For example, run <tt>dir(print)</tt> to learn about the attributes of the print function, or <tt>dir(str)</tt> for the attributes of the str class.

== Packages ==

By now, you must have started observing the hierarchy of organizing your programs. Variables usually go inside functions. Functions and global variables usually go inside modules. What if you wanted to organize modules? That's where packages come into the picture.

Packages are just folders of modules with a special <tt>__init__.py</tt> file that indicates to Python that this folder is special because it contains Python modules.

Let's say you want to create a package called 'world' with subpackages 'asia', 'africa', etc. and these subpackages in turn contain modules like 'india', 'madagascar', etc.

This is how you would structure the folders:

- <some folder present in the sys.path>/
- world/
- __init__.py
- asia/
- __init__.py
- india/
- __init__.py
- foo.py
- africa/
- __init__.py
- madagascar/
- __init__.py
- bar.py

Packages are just a convenience to hierarchically organize modules. You will see many instances of this in the [[Python_en:Standard Library|standard library]].

== Summary ==

Just like functions are reusable parts of programs, modules are reusable programs. Packages are another hierarchy to organize modules. The standard library that comes with Python is an example of such a set of packages and modules.

We have seen how to use these modules and create our own modules.

Next, we will learn about some interesting concepts called data structures.

----

<div class="paging">
<span class="prev">[[Python_en:Functions|Previous]]</span>
<span class="next">[[Python_en:Data Structures|Next]]</span>
</div>

</div>

[[Category:A Byte of Python|Modules]]

Python en:Installation

2009-02-05T05:23:39Z

Swaroop: /* For Linux and BSD users */ Note on python3 binary

<div class="python book">

If you have Python 2.x installed already, you do '''not''' have to remove it to install Python 3.0. You can have both installed at the same time.

== For Linux and BSD users ==

If you are using a Linux distribution such as Ubuntu, Fedora, OpenSUSE or {put your choice here}, or a BSD system such as FreeBSD, then it is most likely you already have Python installed on your system.

To test if you have Python already installed on your Linux box, open a shell program (like <tt>konsole</tt> or <tt>gnome-terminal</tt>) and enter the command <tt>python -V</tt> as shown below.

$ python -V
Python 3.0b1

; Note
: <tt>$</tt> is the prompt of the shell. It will be different for you depending on the settings of your OS, hence I will indicate the prompt by just the <tt>$</tt> symbol.

If you see some version information like the one shown above, then you have Python installed already.

However, if you get a message like this one:

$ python -V
bash: Python: command not found

Then you don't have Python installed. This is highly unlikely but possible.

; Note
: If you have Python 2.x already installed, then try <tt>python3 -V</tt>.

In this case, you have two ways of installing Python on your system.

* You can compile Python from the [http://www.python.org/download/releases/3.0/ source code] and install it. The compilation instructions are provided at the website.
* [This option will be available after the final release of Python 3.0] Install the binary packages using the package management software that comes with your OS, such as <tt>apt-get</tt> in Ubuntu/Debian and other Debian-based Linux, <tt>yum</tt> in Fedora Linux, <tt>pkg_add</tt> in FreeBSD, etc. Note that you will need an internet connection to use this method. Alternatively, you can download the binaries from somewhere else and then copy to your PC and install it.

== For Windows Users ==

Visit http://www.python.org/download/releases/3.0/ and download the latest version from this website, which was [http://www.python.org/ftp/python/3.0/python-3.0b1.msi 3.0 beta 1] as of this writing. This is just 12.8 MB which is very compact compared to most other languages or software. The installation is just like any other Windows-based software.

; Caution
: When you are given the option of unchecking any "optional" components, don't uncheck any! Some of these components can be useful for you, especially IDLE.

An interesting fact is that majority of Python downloads are by Windows users. Of course, this doesn't give the complete picture since almost all Linux users will have Python installed already on their systems by default.

=== DOS Prompt ===

If you want to be able to use Python from the Windows command line i.e. the DOS prompt, then you need to set the PATH variable appropriately.

For Windows 2000, XP, 2003 , click on <tt>Control Panel</tt> -> <tt>System</tt> -> <tt>Advanced</tt> -> <tt>Environment Variables</tt>. Click on the variable named '''PATH''' in the 'System Variables' section, then select <tt>Edit</tt> and add <tt>;C:\Python30</tt> to the end of what is already there. Of course, use the appropriate directory name.

For older versions of Windows, add the following line to the file <tt>C:\AUTOEXEC.BAT</tt> : '<tt>PATH=%PATH%;C:\Python30</tt>' (without the quotes) and restart the system. For Windows NT, use the <tt>AUTOEXEC.NT</tt> file.

== For Mac OS X Users ==

Mac OS X Users will find Python already installed on their system. Open the <tt>Terminal.app</tt> and run <tt>python -V</tt> and follow the advice in the above Linux section.

== Summary ==

For a Linux system, you most probably already have Python installed on your system. Otherwise, you can install it using the package management software that comes with your distribution. For a Windows system, installing Python is as easy as downloading the installer and double-clicking on it. From now on, we will assume that you have Python installed on your system.

Next, we will write our first Python program.

----

<div class="paging">
<span class="prev">[[Python_en:Introduction|Previous]]</span>
<span class="next">[[Python_en:First Steps|Next]]</span>
</div>

</div>

[[Category:A Byte of Python|Installation]]

Python en:Input Output

2009-01-25T21:29:54Z

Swaroop: /* Input from user */

<div class="python book">

== Introduction ==

There will be situations where your program has to interact with the user. For example, you would want to take input from the user and then print some results back. We can achieve this using the <tt>input()</tt> and <tt>print()</tt> functions respectively.

For output, we can also use the various methods of the <tt>str</tt> (string) class. For example, you can use the <tt>rjust</tt> method to get a string which is right justified to a specified width. See <tt>help(str)</tt> for more details.

Another common type of input/output is dealing with files. The ability to create, read and write files is essential to many programs and we will explore this aspect in this chapter.

== Input from user ==

<source lang="python">
#!/usr/bin/python
# user_input.py

def reverse(text):
return text[::-1]

def is_palindrome(text):
return text == reverse(text)

something = input('Enter text: ')
if (is_palindrome(something)):
print("Yes, it is a palindrome")
else:
print("No, it is not a palindrome")
</source>

Output:

$ python user_input.py
Enter text: sir
No, it is not a palindrome

$ python user_input.py
Enter text: madam
Yes, it is a palindrome

$ python user_input.py
Enter text: racecar
Yes, it is a palindrome

How It Works:

We use the slicing feature to reverse the text. We've already seen how we can make [[Python_en:Data Structures#Sequences|slices from sequences]] using the <tt>seq[a:b]</tt> code starting from position <tt>a</tt> to position <tt>b</tt>. We can also provide a third argument that determines the ''step'' by which the slicing is done. The default step is <tt>1</tt> because of which it returns a continuous part of the text. Giving a negative step, i.e., <tt>-1</tt> will return the text in reverse.

The <tt>input()</tt> function takes a string as argument and displays it to the user. Then it waits for the user to type something and press the return key. Once the user has entered, the <tt>input()</tt> function will then return that text.

We take that text and reverse it. If the original text and reversed text are equal, then the text is a [http://en.wiktionary.org/wiki/palindrome palindrome].

Homework exercise:

Checking whether a text is a palindrome should also ignore punctuation, spaces and case. For example, "Rise to vote, sir." is also a palindrome but our current program doesn't say it is. Can you improve the above program to recognize this palindrome?

== Files ==

You can open and use files for reading or writing by creating an object of the <tt>file</tt> class and using its <tt>read</tt>, <tt>readline</tt> or <tt>write</tt> methods appropriately to read from or write to the file. The ability to read or write to the file depends on the mode you have specified for the file opening. Then finally, when you are finished with the file, you call the <tt>close</tt> method to tell Python that we are done using the file.

Example:

<source lang="python">
#!/usr/bin/python
# Filename: using_file.py

poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
use Python!
'''

f = open('poem.txt', 'w') # open for 'w'riting
f.write(poem) # write text to file
f.close() # close the file

f = open('poem.txt') # if no mode is specified, 'r'ead mode is assumed by default
while True:
line = f.readline()
if len(line) == 0: # Zero length indicates EOF
break
print(line, end='')
f.close() # close the file
</source>

Output:

$ python using_file.py
Programming is fun
When the work is done
if you wanna make your work also fun:
use Python!

How It Works:

First, open a file by using the built-in <tt>open</tt> function and specifying the name of the file and the mode in which we want to open the file. The mode can be a read mode (<tt>'r'</tt>), write mode (<tt>'w'</tt>) or append mode (<tt>'a'</tt>). We can also by dealing with a text file (<tt>'t'</tt>) or a binary file (<tt>'b'</tt>). There are actually many more modes available and <tt>help(open)</tt> will give you more details about them. By default, <tt>open()</tt> considers the file to be a 't'ext file and opens it in 'r'ead mode.

In our example, we first open the file in write text mode and use the <tt>write</tt> method of the file object to write to the file and then we finally <tt>close</tt> the file.

Next, we open the same file again for reading. We don't need to specify a mode because 'read text file' is the default mode. We read in each line of the file using the <tt>readline</tt> method in a loop. This method returns a complete line including the newline character at the end of the line. When an ''empty'' string is returned, it means that we have reached the end of the file and we 'break' out of the loop.

By deafult, the <tt>print()</tt> function prints the text as well as an automatic newline to the screen. We are suppressing the newline by specifying <tt>end=<nowiki>''</nowiki></tt> because the line that is read from the file already ends with a newline character. Then, we finally <tt>close</tt> the file.

Now, check the contents of the <tt>poem.txt</tt> file to confirm that the program has indeed written and read from that file.

== Pickle ==

Python provides a standard module called <tt>pickle</tt> using which you can store '''any''' Python object in a file and then get it back later. This is called storing the object ''persistently''.

Example:

<source lang="python">
#!/usr/bin/python
# Filename: pickling.py

import pickle

# the name of the file where we will store the object
shoplistfile = 'shoplist.data'
# the list of things to buy
shoplist = ['apple', 'mango', 'carrot']

# Write to the file
f = open(shoplistfile, 'wb')
pickle.dump(shoplist, f) # dump the object to a file
f.close()

del shoplist # destroy the shoplist variable

# Read back from the storage
f = open(shoplistfile, 'rb')
storedlist = pickle.load(f) # load the object from the file
print(storedlist)
</source>

Output:

$ python pickling.py
['apple', 'mango', 'carrot']

How It Works:

To store an object in a file, we have to first <tt>open</tt> the file in 'w'rite 'b'inary mode and then call the <tt>dump</tt> function of the <tt>pickle</tt> module. This process is called ''pickling''.

Next, we retrieve the object using the <tt>load</tt> function of the <tt>pickle</tt> module which returns the object. This process is called ''unpickling''.

== Summary ==

We have discussed various types of input/output and also file handling and using the pickle module.

Next, we will explore the concept of exceptions.

----

<div class="paging">
<span class="prev">[[Python_en:Object Oriented Programming|Previous]]</span>
<span class="next">[[Python_en:Exceptions|Next]]</span>
</div>

</div>

[[Category:A Byte of Python|Input Output]]

Python en:Data Structures

2009-01-25T21:28:58Z

Swaroop: /* References */

<div class="python book">

== Introduction ==

Data structures are basically just that - they are ''structures'' which can hold some ''data'' together. In other words, they are used to store a collection of related data.

There are four built-in data structures in Python - list, tuple, dictionary and set. We will see how to use each of them and how they make life easier for us.

== List ==

A <tt>list</tt> is a data structure that holds an ordered collection of items i.e. you can store a ''sequence'' of items in a list. This is easy to imagine if you can think of a shopping list where you have a list of items to buy, except that you probably have each item on a separate line in your shopping list whereas in Python you put commas in between them.

The list of items should be enclosed in square brackets so that Python understands that you are specifying a list. Once you have created a list, you can add, remove or search for items in the list. Since we can add and remove items, we say that a list is a ''mutable'' data type i.e. this type can be altered.

=== Quick Introduction To Objects And Classes ===

Although I've been generally delaying the discussion of objects and classes till now, a little explanation is needed right now so that you can understand lists better. We will explore this topic in detail later in its [[Python_en:Object Oriented Programming|own chapter]].

A list is an example of usage of objects and classes. When we use a variable <tt>i</tt> and assign a value to it, say integer <tt>5</tt> to it, you can think of it as creating an '''object''' (i.e. instance) <tt>i</tt> of '''class''' (i.e. type) <tt>int</tt>. In fact, you can read <tt>help(int)</tt> to understand this better.

A class can also have '''methods''' i.e. functions defined for use with respect to that class only. You can use these pieces of functionality only when you have an object of that class. For example, Python provides an <tt>append</tt> method for the <tt>list</tt> class which allows you to add an item to the end of the list. For example, <tt>mylist.append('an item')</tt> will add that string to the list <tt>mylist</tt>. Note the use of dotted notation for accessing methods of the objects.

A class can also have '''fields''' which are nothing but variables defined for use with respect to that class only. You can use these variables/names only when you have an object of that class. Fields are also accessed by the dotted notation, for example, <tt>mylist.field</tt>.

Example:

<source lang="python">
#!/usr/bin/python
# Filename: using_list.py

# This is my shopping list
shoplist = ['apple', 'mango', 'carrot', 'banana']

print('I have', len(shoplist), 'items to purchase.')

print('These items are:', end=' ')
for item in shoplist:
print(item, end=' ')

print('\nI also have to buy rice.')
shoplist.append('rice')
print('My shopping list is now', shoplist)

print('I will sort my list now')
shoplist.sort()
print('Sorted shopping list is', shoplist)

print('The first item I will buy is', shoplist[0])
olditem = shoplist[0]
del shoplist[0]
print('I bought the', olditem)
print('My shopping list is now', shoplist)
</source>

Output:

$ python using_list.py
I have 4 items to purchase.
These items are: apple mango carrot banana
I also have to buy rice.
My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice']
I will sort my list now
Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice']
The first item I will buy is apple
I bought the apple
My shopping list is now ['banana', 'carrot', 'mango', 'rice']

How It Works:

The variable <tt>shoplist</tt> is a shopping list for someone who is going to the market. In <tt>shoplist</tt>, we only store strings of the names of the items to buy but you can add ''any kind of object'' to a list including numbers and even other lists.

We have also used the <tt>for..in</tt> loop to iterate through the items of the list. By now, you must have realised that a list is also a sequence. The speciality of sequences will be discussed in a later [[#Sequences|section]].

Notice the use of the <tt>end</tt> keyword argument to the <tt>print</tt> function to indicate that we want to end the output with a space instead of the usual line break.

Next, we add an item to the list using the <tt>append</tt> method of the list object, as already discussed before. Then, we check that the item has been indeed added to the list by printing the contents of the list by simply passing the list to the <tt>print</tt> statement which prints it neatly.

Then, we sort the list by using the <tt>sort</tt> method of the list. It is important to understand that this method affects the list itself and does not return a modified list - this is different from the way strings work. This is what we mean by saying that lists are ''mutable'' and that strings are ''immutable''.

Next, when we finish buying an item in the market, we want to remove it from the list. We achieve this by using the <tt>del</tt> statement. Here, we mention which item of the list we want to remove and the <tt>del</tt> statement removes it from the list for us. We specify that we want to remove the first item from the list and hence we use <tt>del shoplist[0]</tt> (remember that Python starts counting from 0).

If you want to know all the methods defined by the list object, see <tt>help(list)</tt> for details.

== Tuple ==

Tuples are used to hold together multiple objects. Think of them as similar to lists, but without the extensive functionality that the list class gives you. One major feature of tuples is that they are '''immutable''' like strings i.e. you cannot modify tuples.

Tuples are defined by specifying items separated by commas within an optional pair of parentheses.

Tuples are usually used in cases where a statement or a user-defined function can safely assume that the collection of values i.e. the tuple of values used will not change.

Example:

<source lang="python">
#!/usr/bin/python
# Filename: using_tuple.py

zoo = ('python', 'elephant', 'penguin') # remember the parentheses are optional
print('Number of animals in the zoo is', len(zoo))

new_zoo = ('monkey', 'camel', zoo)
print('Number of cages in the new zoo is', len(new_zoo))
print('All animals in new zoo are', new_zoo)
print('Animals brought from old zoo are', new_zoo[2])
print('Last animal brought from old zoo is', new_zoo[2][2])
print('Number of animals in the new zoo is', len(new_zoo)-1+len(new_zoo[2]))
</source>

Output:

$ python using_tuple.py
Number of animals in the zoo is 3
Number of cages in the new zoo is 3
All animals in new zoo are ('monkey', 'camel', ('python', 'elephant', 'penguin'))
Animals brought from old zoo are ('python', 'elephant', 'penguin')
Last animal brought from old zoo is penguin
Number of animals in the new zoo is 5

How It Works:

The variable <tt>zoo</tt> refers to a tuple of items. We see that the <tt>len</tt> function can be used to get the length of the tuple. This also indicates that a tuple is a [[#Sequences|sequence]] as well.

We are now shifting these animals to a new zoo since the old zoo is being closed. Therefore, the <tt>new_zoo</tt> tuple contains some animals which are already there along with the animals brought over from the old zoo. Back to reality, note that a tuple within a tuple does not lose its identity.

We can access the items in the tuple by specifying the item's position within a pair of square brackets just like we did for lists. This is called the ''indexing'' operator. We access the third item in <tt>new_zoo</tt> by specifying <tt>new_zoo[2]</tt> and we access the third item within the third item in the <tt>new_zoo</tt> tuple by specifying <tt>new_zoo[2][2]</tt>. This is pretty simple once you've understood the idiom.

; Parentheses
: Although the parentheses is optional, I prefer always having them to make it obvious that it is a tuple, especially because it avoids ambiguity. For example, <tt>print(1,2,3)</tt> and <tt>print( (1,2,3) )</tt> mean two different things - the former prints three numbers whereas the latter prints a tuple (which contains three numbers).

; Tuple with 0 or 1 items
: An empty tuple is constructed by an empty pair of parentheses such as <tt>myempty = ()</tt>. However, a tuple with a single item is not so simple. You have to specify it using a comma following the first (and only) item so that Python can differentiate between a tuple and a pair of parentheses surrounding the object in an expression i.e. you have to specify <tt>singleton = (2 , )</tt> if you mean you want a tuple containing the item <tt>2</tt>.

; Note for Perl programmers
: A list within a list does not lose its identity i.e. lists are not flattened as in Perl. The same applies to a tuple within a tuple, or a tuple within a list, or a list within a tuple, etc. As far as Python is concerned, they are just objects stored using another object, that's all.

== Dictionary ==

A dictionary is like an address-book where you can find the address or contact details of a person by knowing only his/her name i.e. we associate '''keys''' (name) with '''values''' (details). Note that the key must be unique just like you cannot find out the correct information if you have two persons with the exact same name.

Note that you can use only immutable objects (like strings) for the keys of a dictionary but you can use either immutable or mutable objects for the values of the dictionary. This basically translates to say that you should use only simple objects for keys.

Pairs of keys and values are specified in a dictionary by using the notation <tt>d = {key1 : value1, key2 : value2 }</tt>. Notice that the key-value pairs are separated by a colon and the pairs are separated themselves by commas and all this is enclosed in a pair of curly braces.

Remember that key-value pairs in a dictionary are not ordered in any manner. If you want a particular order, then you will have to sort them yourself before using it.

The dictionaries that you will be using are instances/objects of the <tt>dict</tt> class.

Example:

<source lang="python">
#!/usr/bin/python
# Filename: using_dict.py

# 'ab' is short for 'a'ddress'b'ook

ab = { 'Swaroop' : 'swaroop@swaroopch.com',
'Larry' : 'larry@wall.org',
'Matsumoto' : 'matz@ruby-lang.org',
'Spammer' : 'spammer@hotmail.com'
}

print("Swaroop's address is", ab['Swaroop'])

# Deleting a key-value pair
del ab['Spammer']

print('\nThere are {0} contacts in the address-book\n'.format(len(ab)))

for name, address in ab.items():
print('Contact {0} at {1}'.format(name, address))

# Adding a key-value pair
ab['Guido'] = 'guido@python.org'

if 'Guido' in ab: # OR ab.has_key('Guido')
print("\nGuido's address is", ab['Guido'])
</source>

Output:

$ python using_dict.py
Swaroop's address is swaroop@swaroopch.com

There are 3 contacts in the address-book

Contact Swaroop at swaroop@swaroopch.com
Contact Matsumoto at matz@ruby-lang.org
Contact Larry at larry@wall.org

Guido's address is guido@python.org

How It Works:

We create the dictionary <tt>ab</tt> using the notation already discussed. We then access key-value pairs by specifying the key using the indexing operator as discussed in the context of lists and tuples. Observe the simple syntax.

We can delete key-value pairs using our old friend - the <tt>del</tt> statement. We simply specify the dictionary and the indexing operator for the key to be removed and pass it to the <tt>del</tt> statement. There is no need to know the value corresponding to the key for this operation.

Next, we access each key-value pair of the dictionary using the <tt>items</tt> method of the dictionary which returns a list of tuples where each tuple contains a pair of items - the key followed by the value. We retrieve this pair and assign it to the variables <tt>name</tt> and <tt>address</tt> correspondingly for each pair using the <tt>for..in</tt> loop and then print these values in the for-block.

We can add new key-value pairs by simply using the indexing operator to access a key and assign that value, as we have done for Guido in the above case.

We can check if a key-value pair exists using the <tt>in</tt> operator or even the <tt>has_key</tt> method of the <tt>dict</tt> class. You can see the documentation for the complete list of methods of the <tt>dict</tt> class using <tt>help(dict)</tt>.

; Keyword Arguments and Dictionaries
: On a different note, if you have used keyword arguments in your functions, you have already used dictionaries! Just think about it - the key-value pair is specified by you in the parameter list of the function definition and when you access variables within your function, it is just a key access of a dictionary (which is called the ''symbol table'' in compiler design terminology).

== Sequences ==

Lists, tuples and strings are examples of sequences, but what are sequences and what is so special about them?

The major features is that they have membership tests (i.e. the <tt>in</tt> and <tt>not in</tt> expressions) and indexing operations. The '''indexing''' operation which allows us to fetch a particular item in the sequence directly.

The three types of sequences mentioned above - lists, tuples and strings, also have a '''slicing''' operation which allows us to retrieve a slice of the sequence i.e. a part of the sequence.

Example:

<source lang="python">
#!/usr/bin/python
# Filename: seq.py

shoplist = ['apple', 'mango', 'carrot', 'banana']
name = 'swaroop'

# Indexing or 'Subscription' operation
print('Item 0 is', shoplist[0])
print('Item 1 is', shoplist[1])
print('Item 2 is', shoplist[2])
print('Item 3 is', shoplist[3])
print('Item -1 is', shoplist[-1])
print('Item -2 is', shoplist[-2])
print('Character 0 is', name[0])

# Slicing on a list
print('Item 1 to 3 is', shoplist[1:3])
print('Item 2 to end is', shoplist[2:])
print('Item 1 to -1 is', shoplist[1:-1])
print('Item start to end is', shoplist[:])

# Slicing on a string
print('characters 1 to 3 is', name[1:3])
print('characters 2 to end is', name[2:])
print('characters 1 to -1 is', name[1:-1])
print('characters start to end is', name[:])
</source>

Output:

$ python seq.py
Item 0 is apple
Item 1 is mango
Item 2 is carrot
Item 3 is banana
Item -1 is banana
Item -2 is carrot
Character 0 is s
Item 1 to 3 is ['mango', 'carrot']
Item 2 to end is ['carrot', 'banana']
Item 1 to -1 is ['mango', 'carrot']
Item start to end is ['apple', 'mango', 'carrot', 'banana']
characters 1 to 3 is wa
characters 2 to end is aroop
characters 1 to -1 is waroo
characters start to end is swaroop

How It Works:

First, we see how to use indexes to get individual items of a sequence. This is also referred to as the ''subscription operation''. Whenever you specify a number to a sequence within square brackets as shown above, Python will fetch you the item corresponding to that position in the sequence. Remember that Python starts counting numbers from 0. Hence, <tt>shoplist[0]</tt> fetches the first item and <tt>shoplist[3]</tt> fetches the fourth item in the <tt>shoplist</tt> sequence.

The index can also be a negative number, in which case, the position is calculated from the end of the sequence. Therefore, <tt>shoplist[-1]</tt> refers to the last item in the sequence and <tt>shoplist[-2]</tt> fetches the second last item in the sequence.

The slicing operation is used by specifying the name of the sequence followed by an optional pair of numbers separated by a colon within square brackets. Note that this is very similar to the indexing operation you have been using till now. Remember the numbers are optional but the colon isn't.

The first number (before the colon) in the slicing operation refers to the position from where the slice starts and the second number (after the colon) indicates where the slice will stop at. If the first number is not specified, Python will start at the beginning of the sequence. If the second number is left out, Python will stop at the end of the sequence. Note that the slice returned ''starts'' at the start position and will end just before the ''end'' position i.e. the start position is included but the end position is excluded from the sequence slice.

Thus, <tt>shoplist[1:3]</tt> returns a slice of the sequence starting at position 1, includes position 2 but stops at position 3 and therefore a ''slice'' of two items is returned. Similarly, <tt>shoplist[:]</tt> returns a copy of the whole sequence.

You can also do slicing with negative positions. Negative numbers are used for positions from the end of the sequence. For example, <tt>shoplist[:-1]</tt> will return a slice of the sequence which excludes the last item of the sequence but contains everything else.

You can also provide a third argument for the slice, which is the ''step'' for the slicing (by default, the step size is 1):

<source lang="python">
>>> shoplist = ['apple', 'mango', 'carrot', 'banana']
>>> shoplist[::1]
['apple', 'mango', 'carrot', 'banana']
>>> shoplist[::2]
['apple', 'carrot']
>>> shoplist[::3]
['apple', 'banana']
>>> shoplist[::-1]
['banana', 'carrot', 'mango', 'apple']
</source>

Notice that when the step is 2, we get the items with position 0, 2, ... When the step size is 3, we get the items with position 0, 3, etc.

Try various combinations of such slice specifications using the Python interpreter interactively i.e. the prompt so that you can see the results immediately. The great thing about sequences is that you can access tuples, lists and strings all in the same way!

== Set ==

Sets are ''unordered'' collections of simple objects. These are used when the existence of an object in a collection is more important than the order or how many times it occurs.

Using sets, you can test for membership, whether it is a subset of another set, find the intersection between two sets, and so on.

<source lang="python">
>>> bri = set(['brazil', 'russia', 'india'])
>>> 'india' in bri
True
>>> 'usa' in bri
False
>>> bric = bri.copy()
>>> bric.add('china')
>>> bric.issuperset(bri)
True
>>> bri.remove('russia')
>>> bri & bric # OR bri.intersection(bric)
{'brazil', 'india'}
</source>

How It Works:

The example is pretty much self-explanatory because it involves basic set theory mathematics taught in school.

== References ==

When you create an object and assign it to a variable, the variable only ''refers'' to the object and does not represent the object itself! That is, the variable name points to that part of your computer's memory where the object is stored. This is called as '''binding''' of the name to the object.

Generally, you don't need to be worried about this, but there is a subtle effect due to references which you need to be aware of:

Example:

<source lang="python">
#!/usr/bin/python
# Filename: reference.py

print('Simple Assignment')
shoplist = ['apple', 'mango', 'carrot', 'banana']
mylist = shoplist # mylist is just another name pointing to the same object!

del shoplist[0] # I purchased the first item, so I remove it from the list

print('shoplist is', shoplist)
print('mylist is', mylist)
# notice that both shoplist and mylist both print the same list without
# the 'apple' confirming that they point to the same object

print('Copy by making a full slice')
mylist = shoplist[:] # make a copy by doing a full slice
del mylist[0] # remove first item

print('shoplist is', shoplist)
print('mylist is', mylist)
# notice that now the two lists are different
</source>

Output:

$ python reference.py
Simple Assignment
shoplist is ['mango', 'carrot', 'banana']
mylist is ['mango', 'carrot', 'banana']
Copy by making a full slice
shoplist is ['mango', 'carrot', 'banana']
mylist is ['carrot', 'banana']

How It Works:

Most of the explanation is available in the comments.

Remember that if you want to make a copy of a list or such kinds of sequences or complex objects (not simple ''objects'' such as integers), then you have to use the slicing operation to make a copy. If you just assign the variable name to another name, both of them will ''refer'' to the same object and this could be trouble if you are not careful.

; Note for Perl programmers
: Remember that an assignment statement for lists does '''not''' create a copy. You have to use slicing operation to make a copy of the sequence.

== More About Strings ==

We have already discussed strings in detail earlier. What more can there be to know? Well, did you know that strings are also objects and have methods which do everything from checking part of a string to stripping spaces!

The strings that you use in program are all objects of the class <tt>str</tt>. Some useful methods of this class are demonstrated in the next example. For a complete list of such methods, see <tt>help(str)</tt>.

Example:

<source lang="python">
#!/usr/bin/python
# Filename: str_methods.py

name = 'Swaroop' # This is a string object

if name.startswith('Swa'):
print('Yes, the string starts with "Swa"')

if 'a' in name:
print('Yes, it contains the string "a"')

if name.find('war') != -1:
print('Yes, it contains the string "war"')

delimiter = '_*_'
mylist = ['Brazil', 'Russia', 'India', 'China']
print(delimiter.join(mylist))
</source>

Output:

$ python str_methods.py
Yes, the string starts with "Swa"
Yes, it contains the string "a"
Yes, it contains the string "war"
Brazil_*_Russia_*_India_*_China

How It Works:

Here, we see a lot of the string methods in action. The <tt>startswith</tt> method is used to find out whether the string starts with the given string. The <tt>in</tt> operator is used to check if a given string is a part of the string.

The <tt>find</tt> method is used to do find the position of the given string in the string or returns -1 if it is not successful to find the substring. The <tt>str</tt> class also has a neat method to <tt>join</tt> the items of a sequence with the string acting as a delimiter between each item of the sequence and returns a bigger string generated from this.

== Summary ==

We have explored the various built-in data structures of Python in detail. These data structures will be essential for writing programs of reasonable size.

Now that we have a lot of the basics of Python in place, we will next see how to design and write a real-world Python program.

----

<div class="paging">
<span class="prev">[[Python_en:Modules|Previous]]</span>
<span class="next">[[Python_en:Problem Solving|Next]]</span>
</div>

</div>

[[Category:A Byte of Python|Data Structures]]

Python en:Appendix FLOSS

2009-01-25T21:21:27Z

Swaroop: Apparently the e is not accented, correction by Tarek

<div class="python book">

== Free/Libre and Open Source Software (FLOSS) ==

[http://en.wikipedia.org/wiki/FLOSS FLOSS] is based on the concept of a community, which itself is based on the concept of sharing, and particularly the sharing of knowledge. FLOSS are free for usage, modification and redistribution.

If you have already read this book, then you are already familiar with FLOSS since you have been using '''Python''' all along and Python is an open source software!

Here are some examples of FLOSS to give an idea of the kind of things that community sharing and building can create:

* '''Linux'''. This is a FLOSS operating system that the whole world is slowly embracing! It was started by Linus Torvalds as a student. Now, it is giving competition to Microsoft Windows. [ [http://www.kernel.org Linux Kernel] ]
* '''Ubuntu'''. This is a community-driven distribution, sponsored by Canonical and it is the most popular Linux distribution today. It allows you to install a plethora of FLOSS available and all this in an easy-to-use and easy-to-install manner. Best of all, you can just reboot your computer and run Linux off the CD! This allows you to completely try out the new OS before installing it on your computer. [ [http://www.ubuntu.com Ubuntu Linux] ]
* '''OpenOffice.org'''. This is an excellent office suite with a writer, presentation, spreadsheet and drawing components among other things. It can even open and edit MS Word and MS PowerPoint files with ease. It runs on almost all platforms. [ [http://www.openoffice.org OpenOffice] ]
* '''Mozilla Firefox'''. This is ''the'' next generation web browser which is giving great competition to Internet Explorer. It is blazingly fast and has gained critical acclaim for its sensible and impressive features. The extensions concept allows any kind of plugins to be used.
* Its companion product Thunderbird is an excellent email client that makes reading email a snap. [ [http://www.mozilla.org/products/firefox Mozilla Firefox], [http://www.mozilla.org/products/thunderbird Mozilla Thunderbird] ]
* '''Mono'''. This is an open source implementation of the Microsoft .NET platform. It allows .NET applications to be created and run on Linux, Windows, FreeBSD, Mac OS and many other platforms as well. [ [http://www.mono-project.com Mono], [http://www.ecma-international.org ECMA], [http://www.microsoft.com/net Microsoft .NET] ]
* '''Apache web server'''. This is the popular open source web server. In fact, it is ''the'' most popular web server on the planet! It runs nearly more than half of the websites out there. Yes, that's right - Apache handles more websites than all the competition (including Microsoft IIS) combined. [ [http://httpd.apache.org Apache] ]
* '''MySQL'''. This is an extremely popular open source database server. It is most famous for it's blazing speed. It is the M in the famous LAMP stack which runs most of the websites on the internet. [ [http://www.mysql.com MySQL] ]
* '''VLC Player'''. This is a video player that can play anything from DivX to MP3 to Ogg to VCDs and DVDs to ... who says open source ain't fun? ;-) [ [http://www.videolan.org/vlc/ VLC media player] ]
* '''GeexBox''' is a Linux distribution that is designed to play movies as soon as you boot up from the CD! [ [http://geexbox.org/en/start.html GeexBox] ]

This list is just intended to give you a brief idea - there are many more excellent FLOSS out there, such as the Perl language, PHP language, Drupal content management system for websites, PostgreSQL database server, TORCS racing game, KDevelop IDE, Xine - the movie player, VIM editor, Quanta+ editor, Banshee audio player, GIMP image editing program, ... This list could go on forever.

To get the latest buzz in the FLOSS world, check out the following websites:

* [http://www.linux.com linux.com]
* [http://www.linuxtoday.com LinuxToday]
* [http://www.newsforge.com NewsForge]
* [http://www.distrowatch.com DistroWatch]

Visit the following websites for more information on FLOSS:

* [http://www.sourceforge.net SourceForge]
* [http://www.freshmeat.net FreshMeat]

So, go ahead and explore the vast, free and open world of FLOSS!

----

<div class="paging">
<span class="prev">[[Python_en:What Next|Previous]]</span>
<span class="next">[[Python_en:Appendix About|Next]]</span>
</div>

</div>

[[Category:A Byte of Python|Appendix FLOSS]]

Python en:Operators and Expressions

2009-01-25T21:19:20Z

Swaroop: /* Expressions */ Fixing typo

<div class="python book">

== Introduction ==

Most statements (logical lines) that you write will contain '''expressions'''. A simple example of an expression is <tt>2 + 3</tt>. An expression can be broken down into operators and operands.

''Operators'' are functionality that do something and can be represented by symbols such as <tt>+</tt> or by special keywords. Operators require some data to operate on and such data is called ''operands''. In this case, <tt>2</tt> and <tt>3</tt> are the operands.

== Operators ==

We will briefly take a look at the operators and their usage:

Note that you can evaluate the expressions given in the examples using the interpreter interactively. For example, to test the expression <tt>2 + 3</tt>, use the interactive Python interpreter prompt:

<source lang="python">
>>> 2 + 3
5
>>> 3 * 5
15
>>>
</source>

<table border="1" cellpadding="10">

<caption>Operators And Their Usage</caption>

<tr>
<th>
Operator
</th>
<th>
Name
</th>
<th>
Explanation
</th>
<th>
Examples
</th>
</tr>

<tr>
<td>
+
</td>
<td>
Plus
</td>
<td>
Adds the two objects
</td>
<td>

<tt>3 + 5</tt> gives <tt>8</tt>. <tt>'a' + 'b'</tt> gives <tt>'ab'</tt>.

</td>
</tr>

<tr>
<td>
-
</td>
<td>
Minus
</td>
<td>

Either gives a negative number or gives the subtraction of one number from the other

</td>
<td>

<tt>-5.2</tt> gives a negative number. <tt>50 - 24</tt> gives <tt>26</tt>.

</td>
</tr>

<tr>
<td>
<nowiki>*</nowiki>
</td>
<td>
Multiply
</td>
<td>

Gives the multiplication of the two numbers or returns the string repeated that many times.

</td>
<td>

<tt>2 * 3</tt> gives <tt>6</tt>. <tt>'la' * 3</tt> gives <tt>'lalala'</tt>.

</td>
</tr>

<tr>
<td>
<nowiki>**</nowiki>
</td>
<td>
Power
</td>
<td>

Returns x to the power of y

</td>
<td>

<tt>3 ** 4</tt> gives <tt>81</tt> (i.e. <tt>3 * 3 * 3 * 3</tt>)

</td>
</tr>

<tr>
<td>
/
</td>
<td>
Divide
</td>
<td>

Divide x by y

</td>
<td>

<tt>4 / 3</tt> gives <tt>1.3333333333333333</tt>.

</td>
</tr>

<tr>
<td>
//
</td>
<td>
Floor Division
</td>
<td>
Returns the floor of the quotient
</td>
<td>

<tt>4 // 3</tt> gives <tt>1</tt>.

</td>
</tr>

<tr>
<td>
%
</td>
<td>
Modulo
</td>
<td>
Returns the remainder of the division
</td>
<td>

<tt>8 % 3</tt> gives <tt>2</tt>. <tt>-25.5 % 2.25</tt> gives <tt>1.5</tt>.

</td>
</tr>

<tr>
<td>
<<
</td>
<td>
Left Shift
</td>
<td>

Shifts the bits of the number to the left by the number of bits specified. (Each number is represented in memory by bits or binary digits i.e. 0 and 1)

</td>
<td>

<tt>2 << 2</tt> gives <tt>8</tt>. <tt>2</tt> is represented by <tt>10</tt> in bits. Left shifting by 2 bits gives <tt>1000</tt> which represents the decimal <tt>8</tt>.

</td>
</tr>

<tr>
<td>
>>
</td>
<td>
Right Shift
</td>
<td>

Shifts the bits of the number to the right by the number of bits specified.

</td>
<td>

<tt>11 >> 1</tt> gives <tt>5</tt>. <tt>11</tt> is represented in bits by <tt>1011</tt> which when right shifted by 1 bit gives <tt>101</tt> which is the decimal <tt>5</tt>.

</td>
</tr>

<tr>
<td>
&
</td>
<td>
Bitwise AND
</td>
<td>
Bitwise AND of the numbers
</td>
<td>

<tt>5 & 3</tt> gives <tt>1</tt>.

</td>
</tr>

<tr>
<td>
<nowiki>|</nowiki>
</td>
<td>
Bit-wise OR
</td>
<td>
Bitwise OR of the numbers
</td>
<td>

<tt>5 | 3</tt> gives <tt>7</tt>

</td>
</tr>

<tr>
<td>
^
</td>
<td>
Bit-wise XOR
</td>
<td>

Bitwise XOR of the numbers

</td>
<td>

<tt>5 ^ 3</tt> gives <tt>6</tt>

</td>
</tr>

<tr>
<td>
~
</td>
<td>
Bit-wise invert
</td>
<td>
The bit-wise inversion of x is -(x+1)
</td>
<td>

<tt>~5</tt> gives <tt>-6</tt>.

</td>
</tr>

<tr>
<td>
<
</td>
<td>
Less Than
</td>
<td>

Returns whether x is less than y. All comparison operators return <tt>True</tt> or <tt>False</tt>. Note the capitalization of these names.

</td>
<td>

<tt>5 < 3</tt> gives <tt>False</tt> and <tt>3 < 5</tt> gives <tt>True</tt>.

Comparisons can be chained arbitrarily: <tt>3 < 5 < 7</tt> gives <tt>True</tt>.

</td>
</tr>

<tr>
<td>
>
</td>
<td>
Greater Than
</td>
<td>
Returns whether x is greater than y
</td>
<td>

<tt>5 > 3</tt> returns <tt>True</tt>. If both operands are numbers, they are first converted to a common type. Otherwise, it always returns <tt>False</tt>.

</td>
</tr>

<tr>
<td>
<=
</td>
<td>
Less Than or Equal To
</td>
<td>

Returns whether x is less than or equal to y

</td>
<td>

<tt>x = 3; y = 6; x <= y</tt> returns <tt>True</tt>.

</td>
</tr>

<tr>
<td>
>=
</td>
<td>
Greater Than or Equal To
</td>
<td>

Returns whether x is greater than or equal to y

</td>
<td>

<tt>x = 4; y = 3; x >= 3</tt> returns <tt>True</tt>.

</td>
</tr>

<tr>
<td>
<nowiki>==</nowiki>
</td>
<td>
Equal To
</td>
<td>

Compares if the objects are equal

</td>
<td>

<tt>x = 2; y = 2; x == y</tt> returns <tt>True</tt>.

<tt>x = 'str'; y = 'stR'; x == y</tt> returns <tt>False</tt>.

<tt>x = 'str'; y = 'str'; x == y</tt> returns <tt>True</tt>.

</td>
</tr>

<tr>
<td>
!=
</td>
<td>
Not Equal To
</td>
<td>

Compares if the objects are not equal

</td>
<td>

<tt>x = 2; y = 3; x != y</tt> returns <tt>True</tt>.

</td>
</tr>

<tr>
<td>
not
</td>
<td>
Boolean NOT
</td>
<td>

If x is <tt>True</tt>, it returns <tt>False</tt>. If x is <tt>False</tt>, it returns <tt>True</tt>.

</td>
<td>

<tt>x = True; not x</tt> returns <tt>False</tt>.

</td>
</tr>

<tr>
<td>
and
</td>
<td>
Boolean AND
</td>
<td>

<tt>x and y</tt> returns <tt>False</tt> if x is <tt>False</tt>, else it returns evaluation of y

</td>
<td>

<tt>x = False; y = True; x and y</tt> returns <tt>False</tt> since x is False. In this case, Python will not evaluate y since it knows that the left hand side of the 'and' expression is <tt>False</tt> which implies that the whole expression will be <tt>False</tt> irrespective of the other values. This is called short-circuit evaluation.

</td>
</tr>

<tr>
<td>
or
</td>
<td>
Boolean OR
</td>
<td>

If x is <tt>True</tt>, it returns True, else it returns evaluation of y

</td>
<td>

<tt>x = True; y = False; x or y</tt> returns <tt>True</tt>. Short-circuit evaluation applies here as well.

</td>
</tr>

</table>

=== Shortcut for math operation and assignment ===

It is common to run a math operation on a variable and then assign the result of the operation back to the variable, hence there is a shortcut for such expressions:

You can write:

<source lang="python">
a = 2; a = a * 3
</source>

as:

<source lang="python">
a = 2; a *= 3
</source>

Notice that <tt>var = var operation expression</tt> becomes <tt>var operation= expression</tt>.

== Evaluation Order ==

If you had an expression such as <tt>2 + 3 * 4</tt>, is the addition done first or the multiplication? Our high school maths tells us that the multiplication should be done first. This means that the multiplication operator has higher precedence than the addition operator.

The following table gives the precedence table for Python, from the lowest precedence (least binding) to the highest precedence (most binding). This means that in a given expression, Python will first evaluate the operators and expressions lower in the table before the ones listed higher in the table.

The following table, taken from the [http://docs.python.org/dev/3.0/reference/expressions.html#evaluation-order Python reference manual], is provided for the sake of completeness. It is far better to use parentheses to group operators and operands appropriately in order to explicitly specify the precedence. This makes the program more readable. See [[Python_en:Operators_and_Expressions#Changing the Order of Evaluation|Changing the Order of Evaluation]] below for details.

<table border="1" cellpadding="5">
<caption>
Operator Precedence
</caption>
<tr>
<th>
Operator
</th>
<th>
Description
</th>
</tr>
<tr>
<td>
lambda
</td>
<td>
Lambda Expression
</td>
</tr>
<tr>
<td>
or
</td>
<td>
Boolean OR
</td>
</tr>
<tr>
<td>
and
</td>
<td>
Boolean AND
</td>
</tr>
<tr>
<td>
not x
</td>
<td>
Boolean NOT
</td>
</tr>
<tr>
<td>
in, not in
</td>
<td>
Membership tests
</td>
</tr>
<tr>
<td>
is, is not
</td>
<td>
Identity tests
</td>
</tr>
<tr>
<td>
<, <=, >, >=, !=, ==
</td>
<td>
Comparisons
</td>
</tr>
<tr>
<td>
<nowiki>|</nowiki>
</td>
<td>
Bitwise OR
</td>
</tr>
<tr>
<td>
^
</td>
<td>
Bitwise XOR
</td>
</tr>
<tr>
<td>
&
</td>
<td>
Bitwise AND
</td>
</tr>
<tr>
<td>
<<, >>
</td>
<td>
Shifts
</td>
</tr>
<tr>
<td>
+, -
</td>
<td>
Addition and subtraction
</td>
</tr>
<tr>
<td>
<nowiki>*, /, //, %</nowiki>
</td>
<td>
Multiplication, Division, Floor Division and Remainder
</td>
</tr>
<tr>
<td>
+x, -x
</td>
<td>
Positive, Negative
</td>
</tr>
<tr>
<td>
~x
</td>
<td>
Bitwise NOT
</td>
</tr>
<tr>
<td>
<nowiki>**</nowiki>
</td>
<td>
Exponentiation
</td>
</tr>
<tr>
<td>
x.attribute
</td>
<td>
Attribute reference
</td>
</tr>
<tr>
<td>
x[index]
</td>
<td>
Subscription
</td>
</tr>
<tr>
<td>
x[index1:index2]
</td>
<td>
Slicing
</td>
</tr>
<tr>
<td>
f(arguments ...)
</td>
<td>
Function call
</td>
</tr>
<tr>
<td>
(expressions, ...)
</td>
<td>
Binding or tuple display
</td>
</tr>
<tr>
<td>
[expressions, ...]
</td>
<td>
List display
</td>
</tr>
<tr>
<td>
{key:datum, ...}
</td>
<td>
Dictionary display
</td>
</tr>
</table>

The operators which we have not already come across will be explained in later chapters.

Operators with the ''same precedence'' are listed in the same row in the above table. For example, <tt>+</tt> and <tt>-</tt> have the same precedence.

== Changing the Order Of Evaluation ==

To make the expressions more readable, we can use parentheses. For example, <tt>2 + (3 * 4)</tt> is definitely easier to understand than <tt>2 + 3 * 4</tt> which requires knowledge of the operator precedences. As with everything else, the parentheses should be used reasonably (do not overdo it) and should not be redundant (as in <tt>2 + (3 + 4)</tt>).

There is an additional advantage to using parentheses - it helps us to change the order of evaluation. For example, if you want addition to be evaluated before multiplication in an expression, then you can write something like <tt>(2 + 3) * 4</tt>.

== Associativity ==

Operators are usually associated from left to right i.e. operators with same precedence are evaluated in a left to right manner. For example, <tt>2 + 3 + 4</tt> is evaluated as <tt>(2 + 3) + 4</tt>. Some operators like assignment operators have right to left associativity i.e. <tt>a = b = c</tt> is treated as <tt>a = (b = c)</tt>.

== Expressions ==

Example:

<source lang="python">
#!/usr/bin/python
# Filename: expression.py

length = 5
breadth = 2

area = length * breadth
print('Area is', area)
print('Perimeter is', 2 * (length + breadth))
</source>

Output:

$ python expression.py
Area is 10
Perimeter is 14

How It Works:

The length and breadth of the rectangle are stored in variables by the same name. We use these to calculate the area and perimeter of the rectangle with the help of expressions. We store the result of the expression <tt>length * breadth</tt> in the variable <tt>area</tt> and then print it using the <tt>print</tt> function. In the second case, we directly use the value of the expression <tt>2 * (length + breadth)</tt> in the print function.

Also, notice how Python 'pretty-prints' the output. Even though we have not specified a space between <tt>'Area is'</tt> and the variable <tt>area</tt>, Python puts it for us so that we get a clean nice output and the program is much more readable this way (since we don't need to worry about spacing in the strings we use for output). This is an example of how Python makes life easy for the programmer.

== Summary ==

We have seen how to use operators, operands and expressions - these are the basic building blocks of any program. Next, we will see how to make use of these in our programs using statements.

----

<div class="paging">
<span class="prev">[[Python_en:Basics|Previous]]</span>
<span class="next">[[Python_en:Control Flow|Next]]</span>
</div>

</div>

[[Category:A Byte of Python|Operators and Expressions]]

Python en:Exceptions

2009-01-16T02:10:39Z

Swaroop: /* The with statement */ Adding explanation of the 'with' protocol

<div class="python book">

== Introduction ==

Exceptions occur when certain ''exceptional'' situations occur in your program. For example, what if you are going to read a file and the file does not exist? Or what if you accidentally deleted it when the program was running? Such situations are handled using '''exceptions'''.

Similarly, what if your program had some invalid statements? This is handled by Python which '''raises''' its hands and tells you there is an '''error'''.

== Errors ==

Consider a simple <tt>print</tt> function call. What if we misspelt <tt>print</tt> as <tt>Print</tt>? Note the capitalization. In this case, Python ''raises'' a syntax error.

>>> Print('Hello World')
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
Print('Hello World')
NameError: name 'Print' is not defined
>>> print('Hello World')
Hello World

Observe that a <tt>NameError</tt> is raised and also the location where the error was detected is printed. This is what an ''error handler'' for this error does.

== Exceptions ==

We will '''try''' to read input from the user. Press <tt>ctrl-d</tt> and see what happens.

>>> s = input('Enter something --> ')
Enter something -->
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
s = input('Enter something --> ')
EOFError: EOF when reading a line

Python raises an error called <tt>EOFError</tt> which basically means it found an ''end of file'' symbol (which is represented by <tt>ctrl-d</tt>) when it did not expect to see it.

== Handling Exceptions ==

We can handle exceptions using the <tt>try..except</tt> statement. We basically put our usual statements within the try-block and put all our error handlers in the except-block.

<source lang="python">
#!/usr/bin/python
# Filename: try_except.py

try:
text = input('Enter something --> ')
except EOFError:
print('Why did you do an EOF on me?')
except KeyboardInterrupt:
print('You cancelled the operation.')
else:
print('You entered {0}'.format(text))
</source>

Output:

$ python try_except.py
Enter something --> # Press ctrl-d
Why did you do an EOF on me?

$ python try_except.py
Enter something --> # Press ctrl-c
You cancelled the operation.

$ python try_except.py
Enter something --> no exceptions
You entered no exceptions

How It Works:

We put all the statements that might raise exceptions/errors inside the <tt>try</tt> block and then put handlers for the appropriate errors/exceptions in the <tt>except</tt> clause/block. The <tt>except</tt> clause can handle a single specified error or exception, or a parenthesized list of errors/exceptions. If no names of errors or exceptions are supplied, it will handle ''all'' errors and exceptions.

Note that there has to be at least one <tt>except</tt> clause associated with every <tt>try</tt> clause. Otherwise, what's the point of having a try block?

If any error or exception is not handled, then the default Python handler is called which just stops the execution of the program and prints an error message. We have already seen this in action above.

You can also have an <tt>else</tt> clause associated with a <tt>try..except</tt> block. The <tt>else</tt> clause is executed if no exception occurs.

In the next example, we will also see how to get the exception object so that we can retrieve additional information.

== Raising Exceptions ==

You can ''raise'' exceptions using the <tt>raise</tt> statement by providing the name of the error/exception and the exception object that is to be ''thrown''.

The error or exception that you can arise should be class which directly or indirectly must be a derived class of the <tt>Exception</tt> class.

<source lang="python">
#!/usr/bin/python
# Filename: raising.py

class ShortInputException(Exception):
'''A user-defined exception class.'''
def __init__(self, length, atleast):
Exception.__init__(self)
self.length = length
self.atleast = atleast

try:
text = input('Enter something --> ')
if len(text) < 3:
raise ShortInputException(len(text), 3)
# Other work can continue as usual here
except EOFError:
print('Why did you do an EOF on me?')
except ShortInputException as ex:
print('ShortInputException: The input was {0} long, expected at least {1}'\
.format(ex.length, ex.atleast))
else:
print('No exception was raised.')
</source>

Output:

$ python raising.py
Enter something --> a
ShortInputException: The input was 1 long, expected at least 3

$ python raising.py
Enter something --> abc
No exception was raised.

How It Works:

Here, we are creating our own exception type. This new exception type is called <tt>ShortInputException</tt>. It has two fields - <tt>length</tt> which is the length of the given input, and <tt>atleast</tt> which is the minimum length that the program was expecting.

In the <tt>except</tt> clause, we mention the class of error which will be stored <tt>as</tt> the variable name to hold the corresponding error/exception object. This is analogous to parameters and arguments in a function call. Within this particular <tt>except</tt> clause, we use the <tt>length</tt> and <tt>atleast</tt> fields of the exception object to print an appropriate message to the user.

== Try .. Finally ==

Suppose you are reading a file in your program. How do you ensure that the file object is closed properly whether or not an exception was raised? This can be done using the <tt>finally</tt> block. Note that you can use an <tt>except</tt> clause along with a <tt>finally</tt> block for the same corresponding <tt>try</tt> block. You will have to embed one within another if you want to use both.

<source lang="python">
#!/usr/bin/python
# Filename: finally.py

import time

try:
f = open('poem.txt')
while True: # our usual file-reading idiom
line = f.readline()
if len(line) == 0:
break
print(line, end='')
time.sleep(2) # To make sure it runs for a while
except KeyboardInterrupt:
print('!! You cancelled the reading from the file.')
finally:
f.close()
print('(Cleaning up: Closed the file)')
</source>

Output:

$ python finally.py
Programming is fun
When the work is done
if you wanna make your work also fun:
!! You cancelled the reading from the file.
(Cleaning up: Closed the file)

How It Works:

We do the usual file-reading stuff, but we have arbitrarily introduced sleeping for 2 seconds after printing each line using the <tt>time.sleep</tt> function so that the program runs slowly (Python is very fast by nature). When the program is still running, press <tt>ctrl-c</tt> to interrupt/cancel the program.

Observe that the <tt>KeyboardInterrupt</tt> exception is thrown and the program quits. However, before the program exits, the finally clause is executed and the file object is always closed.

== The with statement ==

Acquiring a resource in the <tt>try</tt> block and subsequently releasing the resource in the <tt>finally</tt> block is a common pattern. Hence, there is also a <tt>with</tt> statement that enables this to be done in a clean manner:

<source lang="python">
#!/usr/bin/python
# Filename: using_with.py

with open("poem.txt") as f:
for line in f:
print(line, end='')
</source>

How It Works:

The output should be same as the previous example. The difference here is that we are using the <tt>open</tt> function with the <tt>with</tt> statement - we leave the closing of the file to be done automatically by <tt>with open</tt>.

What happens behind the scenes is that there is a protocol used by the <tt>with</tt> statement. It fetches the object returned by the <tt>open</tt> statement, let's call it "thefile" in this case.

It ''always'' calls the <tt>thefile.__enter__</tt> function before starting the block of code under it and ''always'' calls <tt>thefile.__exit__</tt> after finishing the block of code.

So the code that we would have written in a <tt>finally</tt> block is should be taken care of automatically by the <tt>__exit__</tt> method. This is what helps us to avoid having to use explicit <tt>try..finally</tt> statements repeatedly.

More discussion on this topic is beyond scope of this book, so please refer [http://www.python.org/dev/peps/pep-0343/ PEP 343] for comprehensive explanation.

== Summary ==

We have discussed the usage of the <tt>try..except</tt> and <tt>try..finally</tt> statements. We have seen how to create our own exception types and how to raise exceptions as well.

Next, we will explore the Python Standard Library.

----

<div class="paging">
<span class="prev">[[Python_en:Input Output|Previous]]</span>
<span class="next">[[Python_en:Standard Library|Next]]</span>
</div>

</div>

[[Category:A Byte of Python|Exceptions]]

Python en:More

2009-01-14T12:07:54Z

Swaroop: /* exec and eval */

<div class="python book">

== Introduction ==

So far we have covered majority of the various aspects of Python that you will use. In this chapter, we will cover some more aspects that will make our knowledge of Python more well-rounded.

== Passing tuples around ==

Ever wished you could return two different values from a function? You can. All you have to do is use a tuple.

<source lang="python">
>>> def get_error_details():
... return (2, 'second error details')
...
>>> errnum, errstr = get_error_details()
>>> errnum
2
>>> errstr
'second error details'
</source>

Notice that the usage of <tt>a, b = <some expression></tt> interprets the result of the expression as a tuple with two values.

If you want to interpret the results as <tt>(a, <everything else>)</tt>, then you just need to star it just like you would in function parameters:

<source lang="python">
>>> a, *b = [1, 2, 3, 4]
>>> a
1
>>> b
[2, 3, 4]
</source>

This also means the fastest way to swap two variables in Python is:

<source lang="python">
>>> a = 5; b = 8
>>> a, b = b, a
>>> a, b
(8, 5)
</source>

== Special Methods ==

There are certain methods such as the <tt>__init__</tt> and <tt>__del__</tt> methods which have special significance in classes.

Special methods are used to mimic certain behaviors of built-in types. For example, if you want to use the <tt>x[key]</tt> indexing operation for your class (just like you use it for lists and tuples), then all you have to do is implement the <tt>__getitem__()</tt> method and your job is done. If you think about it, this is what Python does for the <tt>list</tt> class itself!

Some useful special methods are listed in the following table. If you want to know about all the special methods, [http://docs.python.org/dev/3.0/reference/datamodel.html#special-method-names see the manual].

<table border="1" cellpadding="5">
<caption>
Some Special Methods
</caption>
<tr>
<th>
Name
</th>
<th>
Explanation
</th>
</tr>
<tr>
<td>
__init__(self, ...)
</td>
<td>

This method is called just before the newly created object is returned for usage.

</td>
</tr>
<tr>
<td>
__del__(self)
</td>
<td>

Called just before the object is destroyed

</td>
</tr>
<tr>
<td>
__str__(self)
</td>
<td>

Called when we use the <tt>print</tt> function or when <tt>str()</tt> is used.

</td>
</tr>
<tr>
<td>
__lt__(self, other)
</td>
<td>

Called when the ''less than'' operator (<) is used. Similarly, there are special methods for all the operators (+, >, etc.)

</td>
</tr>
<tr>
<td>
__getitem__(self, key)
</td>
<td>

Called when <tt>x[key]</tt> indexing operation is used.

</td>
</tr>
<tr>
<td>
__len__(self)
</td>
<td>

Called when the built-in <tt>len()</tt> function is used for the sequence object.

</td>
</tr>
</table>

== Single Statement Blocks ==

We have seen that each block of statements is set apart from the rest by its own indentation level. Well, there is one caveat. If your block of statements contains only one single statement, then you can specify it on the same line of, say, a conditional statement or looping statement. The following example should make this clear:

<source lang="python">
>>> flag = True
>>> if flag: print 'Yes'
...
Yes
</source>

Notice that the single statement is used in-place and not as a separate block. Although, you can use this for making your program ''smaller'', I strongly recommend avoiding this short-cut method, except for error checking, mainly because it will be much easier to add an extra statement if you are using proper indentation.

== Lambda Forms ==

A <tt>lambda</tt> statement is used to create new function objects and then return them at runtime.

<source lang="python">
#!/usr/bin/python
# Filename: lambda.py

def make_repeater(n):
return lambda s: s * n

twice = make_repeater(2)

print(twice('word'))
print(twice(5))
</source>

Output:

$ python lambda.py
wordword
10

How It Works:

Here, we use a function <tt>make_repeater</tt> to create new function objects at runtime and return it. A <tt>lambda</tt> statement is used to create the function object. Essentially, the <tt>lambda</tt> takes a parameter followed by a single expression only which becomes the body of the function and the value of this expression is returned by the new function. Note that even a <tt>print</tt> statement cannot be used inside a lambda form, only expressions.

; TODO
: Can we do a <tt>list.sort()</tt> by providing a compare function created using <tt>lambda</tt>?
<source lang="python">
points = [ { 'x' : 2, 'y' : 3 }, { 'x' : 4, 'y' : 1 } ]
# points.sort(lambda a, b : cmp(a['x'], b['x']))
</source>

== List Comprehension ==

List comprehensions are used to derive a new list from an existing list. Suppose you have a list of numbers and you want to get a corresponding list with all the numbers multiplied by 2 only when the number itself is greater than 2. List comprehensions are ideal for such situations.

<source lang="python">
#!/usr/bin/python
# Filename: list_comprehension.py

listone = [2, 3, 4]
listtwo = [2*i for i in listone if i > 2]
print(listtwo)
</source>

Output:

$ python list_comprehension.py
[6, 8]

How It Works:

Here, we derive a new list by specifying the manipulation to be done (<tt>2*i</tt>) when some condition is satisfied (<tt>if i > 2</tt>). Note that the original list remains unmodified.

The advantage of using list comprehensions is that it reduces the amount of boilerplate code required when we use loops to process each element of a list and store it in a new list.

== Receiving Tuples and Lists in Functions ==

There is a special way of receiving parameters to a function as a tuple or a dictionary using the <tt>*</tt> or <tt>**</tt> prefix respectively. This is useful when taking variable number of arguments in the function.

<source lang="python">
>>> def powersum(power, *args):
... '''Return the sum of each argument raised to specified power.'''
... total = 0
... for i in args:
... total += pow(i, power)
... return total
...
>>> powersum(2, 3, 4)
25

>>> powersum(2, 10)
100
</source>

Because we have a <tt>*</tt> prefix on the <tt>args</tt> variable, all extra arguments passed to the function are stored in <tt>args</tt> as a tuple. If a <tt>**</tt> prefix had been used instead, the extra parameters would be considered to be key/value pairs of a dictionary.

== exec and eval ==

The <tt>exec</tt> function is used to execute Python statements which are stored in a string or file, as opposed to written in the program itself. For example, we can generate a string containing Python code at runtime and then execute these statements using the <tt>exec</tt> statement:

<source lang="python">
>>> exec('print("Hello World")')
Hello World
</source>

Similarly, the <tt>eval</tt> function is used to evaluate valid Python expressions which are stored in a string. A simple example is shown below.

<source lang="python">
>>> eval('2*3')
6
</source>

== The assert statement ==

The <tt>assert</tt> statement is used to assert that something is true. For example, if you are very sure that you will have at least one element in a list you are using and want to check this, and raise an error if it is not true, then <tt>assert</tt> statement is ideal in this situation. When the assert statement fails, an <tt>AssertionError</tt> is raised.

<source lang="python">
>>> mylist = ['item']
>>> assert len(mylist) >= 1
>>> mylist.pop()
'item'
>>> mylist
[]
>>> assert len(mylist) >= 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AssertionError
</source>

The <tt>assert</tt> statement should be used judiciously. Most of the time, it is better to catch exceptions, either handle the problem or display an error message to the user and then quit.

== The repr function ==

The <tt>repr</tt> function is used to obtain a canonical string representation of the object. The interesting part is that you will have <tt>eval(repr(object)) == object</tt> most of the time.

<source lang="python">
>>> i = []
>>> i.append('item')
>>> repr(i)
"['item']"
>>> eval(repr(i))
['item']
>>> eval(repr(i)) == i
True
</source>

Basically, the <tt>repr</tt> function is used to obtain a printable representation of the object. You can control what your classes return for the <tt>repr</tt> function by defining the <tt>__repr__</tt> method in your class.

== Summary ==

We have covered some more features of Python in this chapter and yet we haven't covered all the features of Python. However, at this stage, we have covered most of what you are ever going to use in practice. This is sufficient for you to get started with whatever programs you are going to create.

Next, we will discuss how to explore Python further.

----

<div class="paging">
<span class="prev">[[Python_en:Standard Library|Previous]]</span>
<span class="next">[[Python_en:What Next|Next]]</span>
</div>

</div>

[[Category:A Byte of Python|More]]

Python

2009-01-04T19:17:41Z

Swaroop: Thanks to Duncan Giles via email for alerting me about this

<div class="python book">

<p>Choose your Python version:</p>

<div style="border: thin solid gray;">
<table>
<tr>
<td>
<p>
If you want to learn the current <strong>Python 2.x</strong>, [http://www.ibiblio.org/swaroopch/byteofpython/read/ read here] or [http://www.ibiblio.org/swaroopch/byteofpython/files/120/byteofpython_120.pdf download the PDF]
</p>
</td>
<td>
<p>
If you want to learn the new <strong>Python 3.0</strong>, [[Python_en:Table of Contents|read here]] or {{download|http://www.swaroopch.com/files/byteofpython/byte_of_python_v191.pdf|download the PDF}}
</p>
<p>
[http://www.swaroopch.com/buybook You can also buy a printed hardcopy.]
</p>
</td>
</tr>
</table>
</div>

== Introduction ==

'A Byte of Python' is a book on programming using the Python language. It serves as a tutorial or guide to the Python language for a beginner audience. If all you know about computers is how to save text files, then this is the book for you.

'''This book is updated for the new Python 3.0 language.''' If you are looking for a tutorial on the current Python 2.x version, please [http://www.ibiblio.org/swaroopch/byteofpython/files/120/ download the previous revision of the book]. On the same note, if you're wondering whether to learn Python 2.x or 3.x, then [http://www.b-list.org/weblog/2008/dec/05/python-3000/ read this article by James Bennett].

== Who Reads 'A Byte of Python'? ==

Here are what people are saying about the book:

=== Feedback From Readers ===

<blockquote>

<p>This is the best beginner's tutorial I've ever seen! Thank you for your effort.</p> - <em>Walt Michalik</em> (wmich50-at-theramp-dot-net)
</blockquote>
<blockquote>
<p>You've made the best Python tutorial I've found on the Net. Great work. Thanks! </p> - <em>Joshua Robin</em> (joshrob-at-poczta-dot-onet-dot-pl)
</blockquote>
<blockquote>
<p>
Hi, I'm from Dominican Republic. My name is Pavel, recently I read your book 'A Byte of Python' and I consider it excellent!! :). I learnt much from all the examples. Your book is of great help for newbies like me... </p> - <em>Pavel Simo</em> (pavel-dot-simo-at-gmail-dot-com)
</blockquote>
<blockquote><p>
I recently finished reading Byte of Python, and I thought I really ought to thank you. I was very sad to reach the final pages as I now have to go back to dull, tedious oreilly or etc. manuals for learning about python. Anyway, I really appreciate your book </p> - <em>Samuel Young</em> (sy-one-three-seven-at-gmail-dot-com)
</blockquote>
<blockquote>
<p>
Dear Swaroop, I am taking a class from an instructor that has no interest in teaching. We are using Learning Python, second edition, by O'Reilly. It is not a text for beginner without any programming knowledge, and an instructor that should be working in another field. Thank you very much for your book, without it I would be cluless about Python and programming. Thanks a million, you are able to 'break the message down' to a level that beginners can understand and not everyone can. </p> - <em>Joseph Duarte</em> (jduarte1-at-cfl-dot-rr-dot-com)
</blockquote>
<blockquote><p>
I love your book! It is the greatest Python tutorial ever, and a very useful reference. Brilliant, a true masterpiece! Keep up the good work! </p> - <em>Chris-André Sommerseth</em>
</blockquote>
<blockquote><p>
I'm just e-mailing you to thank you for writing Byte of Python online. I had been attempting Python for a few months prior to stumbling across your book, and although I made limited success with pyGame, I never completed a program.</p>
<p>
Thanks to your simplification of the categories, Python actually seems a reachable goal. It seems like I have finally learned the foundations and I can continue into my real goal, game development.</p>
...
<p>
Once again, thanks VERY much for placing such a structured and helpful guide to basic programming on the web. It shoved me into and out of OOP with an understanding where two text books had failed.</p>
<em>- Matt Gallivan</em> (m-underscore-gallivan12-at-hotmail-dot-com)
</blockquote>
<blockquote>
<p>
I would like to thank you for your book 'A byte of python' which i myself find the best way to learn python. I am a 15 year old i live in egypt my name is Ahmed. Python was my second programming language i learn visual basic 6 at school but didn't enjoy it, however i really enjoyed learning python. I made the addressbook program and i was sucessful. i will try to start make more programs and read python programs (if you could tell me source that would be helpful). I will also start on learning java and if you can tell me where to find a tutorial as good as yours for java that would help me a lot. Thanx.
</p><em> - Ahmed Mohammed</em> (sedo-underscore-91-at-hotmail-dot-com)
</blockquote>
<blockquote>
<p>
A wonderful resource for beginners wanting to learn more about Python is the 110-page PDF tutorial A Byte of Python by Swaroop C H. It is well-written, easy to follow, and may be the best introduction to Python programming available.
</p>
<em> - Drew Ames </em> in an article on [http://www.linux.com/feature/126522 Scripting Scribus] published on Linux.com
</blockquote>
<blockquote>
<p>
Yesterday I got through most of Byte of Python on my Nokia N800 and it's the easiest and most concise introduction to Python I have yet encountered. Highly recommended as a starting point for learning Python.
</p>
<em> - Jason Delport </em> on his [http://paxmodept.com/telesto/blogitem.htm?id=627 weblog]
</blockquote>

=== Academic Courses ===

This book is being used as instructional material in various educational institutions:

# 'Principles of Programming Languages' course at [http://www.few.vu.nl/~nsilvis/PPL/2007/index.html Vrije Universiteit, Amsterdam]
# 'Basic Concepts of Computing' course at [http://www.cs.ucdavis.edu/courses/exp_course_desc/10.html University of California, Davis]
# 'Programming With Python' course at [http://www.people.fas.harvard.edu/~preshman/python_winter.html Harvard University]
# 'Introduction to Programming' course at [http://www.comp.leeds.ac.uk/acom1900/ University of Leeds]
# 'Introduction to Application Programming' course at [http://www.cs.bu.edu/courses/cs108/materials.html Boston University]
# 'Information Technology Skills for Meteorology' course at [http://gentry.metr.ou.edu/byteofpython/ University of Oklahoma]
# 'Geoprocessing' course at [http://www.msu.edu/~ashton/classes/825/index.html Michigan State University]
# 'Multi Agent Semantic Web Systems' course at the [http://homepages.inf.ed.ac.uk/ewan/masws/ University of Edinburgh]

=== Even NASA ===

The book is even used by NASA! It is being used in their [http://dsnra.jpl.nasa.gov/software/Python/byte-of-python/output/byteofpython_html/ Jet Propulsion Laboratory] with their Deep Space Network project.

=== Official Recommendation ===

This book has been listed on the official website for Python in the [http://www.python.org/doc/intros/ Full Tutorials] section, next to the official documentation.

== License ==

# This book is licensed under the [http://creativecommons.org/licenses/by-sa/3.0/ Creative Commons Attribution-Share Alike 3.0 Unported] license.
#* This means:
#** You are free to Share i.e. to copy, distribute and transmit this book
#** You are free to Remix i.e. to adapt this book
#* Under the following conditions:
#** Attribution. You must attribute the work in the manner specified by the author or licensor (but not in any way that suggests that they endorse you or your use of this book).
#** Share Alike. If you alter, transform, or build upon this work, you may distribute the resulting work only under the same or similar license to this one.
#* For any reuse or distribution, you must make clear to others the license terms of this book.
#* Any of the above conditions can be waived if you get permission from the copyright holder.
#* Nothing in this license impairs or restricts the author's moral rights.
# Attribution ''must'' be shown by linking back to http://www.swaroopch.com/notes/Python and clearly indicating that the original text can be fetched from this location.
# All the code/scripts provided in this book is licensed under the [http://www.opensource.org/licenses/bsd-license.php 3-clause BSD License] unless otherwise noted.
# Volunteer contributions to this original book must be under this same license ''and'' the copyright must be assigned to the [[User:Swaroop|main author of this book]].

== Read Now ==

You can [[Python_en:Table of Contents|read the book online]] at [[Python_en:Table of Contents]].

== Buy the Book ==

[http://www.swaroopch.com/buybook A printed hardcopy of the book can be purchased] for your offline reading pleasure, and to support the continued development and improvement of this book.

== Download ==

* [http://www.swaroopch.com/files/byteofpython/byte_of_python_v191.pdf PDF (631KB)]
* [http://www.swaroopch.com/files/byteofpython/byte_of_python_v191.xml Mediawiki XML dump (276KB)] (for advanced users only)

'''If you wish to support the continued development of this book, please consider [https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=swaroop%40swaroopch%2ecom&item_name=A%20Byte%20of%20Python&no_shipping=0&no_note=1&tax=0&currency_code=USD&lc=IN&bn=PP%2dDonationsBF&charset=UTF%2d8 making a donation] or [http://www.swaroopch.com/buybook buy a printed hardcopy]'''.

== Translations ==

If you are interested in reading or contributing translations of this book to other human languages, please see [[Python_en:Translations|Translations]].

<div class="paging">
<span class="next">[[Python_en:Table of Contents|Next]]</span>
</div>

</div>

[[Category:A Byte of Python]]

Python en:Table of Contents

2008-12-22T07:37:06Z

Swaroop: Protected "Python en:Table of Contents" [edit=sysop:move=sysop]

<div class="python book">
*[[Python|Front Page]]

#[[Python en:Translations|Translations]]
#[[Python en:Preface|Preface]]
#[[Python en:Introduction|Introduction]]
#[[Python en:Installation|Installation]]
#[[Python en:First Steps|First Steps]]
#[[Python en:Basics|Basics]]
#[[Python en:Operators and Expressions|Operators and Expressions]]
#[[Python en:Control Flow|Control Flow]]
#[[Python en:Functions|Functions]]
#[[Python en:Modules|Modules]]
#[[Python en:Data Structures|Data Structures]]
#[[Python en:Problem Solving|Problem Solving]]
#[[Python en:Object Oriented Programming|Object Oriented Programming]]
#[[Python en:Input Output|Input Output]]
#[[Python en:Exceptions|Exceptions]]
#[[Python en:Standard Library|Standard Library]]
#[[Python en:More|More]]
#[[Python en:What Next|What Next]]
#[[Python en:Appendix FLOSS|Appendix: FLOSS]]
#[[Python en:Appendix About|Appendix: About]]
#[[Python en:Appendix Revision History|Appendix: Revision History]]

<br>

----
<div class="paging">
<span class="prev">[[Python|Previous]]</span> <span class="next">[[Python en:Translations|Next]]</span>
</div> </div>
[[Category:A_Byte_of_Python|Table of Contents]]

Python en:Translation Howto

2008-09-07T05:32:05Z

Swaroop: Protected "Python en:Translation Howto" [edit=sysop:move=sysop]

<div class="python book">

* Create a [http://www.swaroopch.com/mediawiki/index.php?title=Special:UserLogin&returnto=Python login ID]
* Add 2-3 lines about yourself and which translation you are working on in your user page which is at <tt>User:<your login id></tt> (for example, [[User:Swaroop]])
* Add information about the language, your motivation and the link to the [[Python_en:Translations]] page following the format used by others at the top of the page.
* Choose your two-letter shortcode for your language, such as "en" for English and "cn" for Chinese, or something like "nb-no" for Norwegian bokmål translation.
** This means your translation's pages should be prefixed with "Python:<two-letter shortcode>" such as [[Python_en:Preface]] or [[Python_nb-no:Forord]]
* Choose your category in English such as "A Byte of Python in Norwegian" or "A Byte of Python in Chinese".
** This is important because all your pages can be easily located if they are in the same category.
* The basic template of all of your pages should be:

<pre>
<div class="python book">

Your translation here

</div>

[[Category:A Byte of Python in <your language>|<Page Name>]]
</pre>

</div>

* Start translating with the text from [[Python_en:Table of Contents]]
** See [[Help:Editing]] on how to write in wiki format.
* You can create a [[Help:Collections|Collection]] (such as the [[MediaWiki:Collections/A Byte of Python|English version collection]]) to create PDFs of your translation.
* Do [[User:Swaroop|write to me]] and let me know when you start the translation, as well as if you have any doubts or suggestions.
* All the best!

[[Category:A Byte of Python|Translation_Howto]]

Python en:Appendix Changes for Python 3000

2008-09-03T21:32:30Z

Swaroop:

* Vim and Emacs editors
** http://henry.precheur.org/2008/4/18/Indenting%20Python%20with%20VIM.html
** http://www.enigmacurry.com/2008/05/09/emacs-as-a-powerful-python-ide/
* String - unicode only
** http://docs.python.org/dev/3.0/tutorial/introduction.html#about-unicode
* Non-ASCII identifiers allowed
** http://www.python.org/dev/peps/pep-3131/
* ''print()'' function
** http://www.python.org/dev/peps/pep-3105/
* ''raw_input()'' becomes ''input()''
** http://www.python.org/dev/peps/pep-3111/
* Integer Literal Support and Syntax
** http://www.python.org/dev/peps/pep-3127/
* ''nonlocal'' statement
** http://www.python.org/dev/peps/pep-3104/
* Functions can take * argument (varargs) for lists and keyword-only arguments
** http://www.python.org/dev/peps/pep-3102/
* Functions can have annotations (make a passing note?)
** http://www.python.org/dev/peps/pep-3107/
* Better explanation of modules, packages and their organization (including ''__init__.py'', etc.)
** http://ivory.idyll.org/articles/advanced-swc/#packages
* String ''.format()'' instead of ''%'' operator
** http://www.python.org/dev/peps/pep-3101/
** http://docs.python.org/dev/library/string.html#formatstrings
* Dict method changes
** http://www.python.org/dev/peps/pep-3106/
* Built-in set class, in data structures chapter
* Problem Solving
** Use http://gnuwin32.sourceforge.net/packages/zip.htm on Windows
* Classes
** http://docs.python.org/dev/3.0/reference/datamodel.html
* Metaclasses
** http://www.python.org/dev/peps/pep-3115/
* Abstract Base Classes
** http://www.python.org/dev/peps/pep-3119/
* Not sure if any changes required for New I/O
** http://www.python.org/dev/peps/pep-3116/
* Exception handling
** http://www.python.org/dev/peps/pep-0352/
** http://www.python.org/dev/peps/pep-3109/
** http://www.python.org/dev/peps/pep-3110/
* Standard Library - interesting additions
** Reorganization : http://www.python.org/dev/peps/pep-3108/
** http://docs.python.org/dev/library/warnings.html
** http://docs.python.org/dev/library/logging.html (important)
** http://docs.python.org/dev/library/urllib.html
** http://docs.python.org/dev/library/json.html
** Debugging
*** http://docs.python.org/dev/library/pdb.html
*** http://docs.python.org/dev/3.0/library/trace.html
*** eval, repr/ascii functions
** getopt/optparse - how to write a standard command-line program using python?
*** something like replace?
**** http://hpux.connect.org.uk/hppd/hpux/Users/replace-2.24/man.html
* More
** Unpacking can take * argument
*** http://www.python.org/dev/peps/pep-3132/
** ''with'' statement
*** http://www.python.org/dev/peps/pep-0343/
* What Next?
** Implement 'replace'
*** http://unixhelp.ed.ac.uk/CGI/man-cgi?replace
** Mention use of PyPI
** Q&A
*** http://docs.python.org/dev/howto/doanddont.html
*** http://www.python.org/doc/faq/general/
*** http://norvig.com/python-iaq.html
** Books & Resources
*** http://www.coderholic.com/free-python-programming-books/
*** http://pythonpapers.org
*** http://www.mobilepythonbook.org
*** http://effbot.org/zone/
*** Links at the end of every Python-URL! email
**** http://groups.google.com/group/comp.lang.python.announce/t/37de95ef0326293d
** Examples
*** http://www.rosettacode.org
*** http://dev.fyicenter.com/Interview-Questions/Python/index.html
*** http://www.java2s.com/Code/Python/CatalogPython.htm
** Tips & Tricks
*** http://www.siafoo.net/article/52

[[Category:A_Byte_of_Python|Appendix Changes for Python 3000]]

Python en:Appendix Revision History

2008-09-03T21:25:20Z

Swaroop:

<div class="python book">
*1.90
**04/09/2008 and still in progress
**Revival after a gap of 3.5 years!
**[[Python_en:Appendix Changes for Python 3000|Updating to Python 3.0]]
**Rewrite using MediaWiki (again)
*1.20
**13/01/2005
**Complete rewrite using Quanta+ on FC3 with lot of corrections and updates. Many new examples. Rewrote my DocBook setup from scratch.
*1.15
**28/03/2004
**Minor revisions
*1.12
**16/03/2004
**Additions and corrections.
*1.10
**09/03/2004
**More typo corrections, thanks to many enthusiastic and helpful readers.
*1.00
**08/03/2004
**After tremendous feedback and suggestions from readers, I have made significant revisions to the content along with typo corrections.
*0.99
**22/02/2004
**Added a new chapter on modules. Added details about variable number of arguments in functions.
*0.98
**16/02/2004
**Wrote a Python script and CSS stylesheet to improve XHTML output, including a crude-yet-functional lexical analyzer for automatic VIM-like syntax highlighting of the program listings.
*0.97
**13/02/2004
**Another completely rewritten draft, in DocBook XML (again). Book has improved a lot - it is more coherent and readable.
*0.93
**25/01/2004
**Added IDLE talk and more Windows-specific stuff
*0.92
**05/01/2004
**Changes to few examples.
*0.91
**30/12/2003
**Corrected typos. Improvised many topics.
*0.90
**18/12/2003
**Added 2 more chapters. OpenOffice format with revisions.
*0.60
**21/11/2003
**Fully rewritten and expanded.
*0.20
**20/11/2003
**Corrected some typos and errors.
*0.15
**20/11/2003
**Converted to DocBook XML.
*0.10
**14/11/2003
**Initial draft using KWord.

<br>

----
<div class="paging">
<span class="prev">[[Python en:Appendix About|Previous]]</span> <span class="next">[[Python en:Table of Contents|Back to Table of Contents]]</span>
</div> </div>
[[Category:A_Byte_of_Python|Appendix Revision History]]

Python en:Appendix About

2008-09-03T21:13:21Z

Swaroop: /* Now */

<div class="python book">

== Colophon ==

Almost all of the software that I have used in the creation of this book are ''[[Python_en:Appendix FLOSS|free and open source software]]''.

=== Birth of the Book ===

In the first draft of this book, I had used Red Hat 9.0 Linux as the foundation of my setup and in the sixth draft, I used Fedora Core 3 Linux as the basis of my setup.

Initially, I was using KWord to write the book (as explained in the [[Python_en:Preface#History Lesson|History Lesson]] in the preface).

=== Teenage Years ===

Later, I switched to DocBook XML using Kate but I found it too tedious. So, I switched to OpenOffice which was just excellent with the level of control it provided for formatting as well as the PDF generation, but it produced very sloppy HTML from the document.

Finally, I discovered XEmacs and I rewrote the book from scratch in DocBook XML (again) after I decided that this format was the long term solution.

In the sixth draft, I decided to use Quanta+ to do all the editing. The standard XSL stylesheets that came with Fedora Core 3 Linux were being used. The standard default fonts are used as well. The standard fonts are used as well. However, I had written a CSS document to give color and style to the HTML pages. I had also written a crude lexical analyzer, in Python of course, which automatically provides syntax highlighting to all the program listings.

=== Now ===

For this seventh draft, I'm using [http://www.mediawiki.org MediaWiki] as the basis of my [http://www.swaroopch.com/notes/ setup]. Now I edit everything online and the readers can directly read/edit/discuss within the wiki website.

I still use Vim for editing thanks to the [https://addons.mozilla.org/en-US/firefox/addon/394 ViewSourceWith extension for Firefox] that integrates with Vim.

== About The Author ==

http://www.swaroopch.com/about/

----

<div class="paging">
<span class="prev">[[Python_en:Appendix FLOSS|Previous]]</span>
<span class="next">[[Python_en:Appendix Revision History|Next]]</span>
</div>

</div>

[[Category:A Byte of Python|Appendix About]]