预计阅读本页时间：-
Python en:Basics
27
Single Quotes
广告：个人专属 VPN，独立 IP，无限流量，多机房切换，还可以屏蔽广告和恶意软件，每月最低仅 5 美元
You can specify strings using single quotes such as 'Quote me on this'. 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 "What's your name?"
Triple Quotes
You can specify multi-line strings using triple quotes - (""" or '''). You can use single quotes and double quotes freely within the triple quotes. An example is:
'''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."
'''
Escape Sequences
Suppose, you want to have a string which contains a single quote ('), how will you specify this string? For example, the string is What's your name?. You cannot specify 'What's
your name?' 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 \' - notice the backslash. Now, you can specify the string as 'What\'s your
name?'.
Another way of specifying this specific string would be "What's your name?" 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 \\.
What if you wanted to specify a two-line string? One way is to use a triple-quoted string as shown previously or you can use an escape sequence for the newline character - \n to
indicate the start of a new line. An example is This is the first line\nThis is the
second line. Another useful escape sequence to know is the tab - \t. 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 "This is the first sentence. This is the second sentence.".
Python en:Basics
28
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 r or R to the string.
An example is r"Newlines are indicated by \n".
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, 'What\'s ' 'your name?' is automatically converted in to "What's your name?".
Note for C/C++ Programmers
There is no separate char 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
'\\1' or r'\1'.
The format Method
Sometimes we may want to construct strings from other information. This is where the
format() method is useful.
#!/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))
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 format method.
Python en:Basics
29
Observe the first usage where we use {0} and this corresponds to the variable name which is the first argument to the format method. Similarly, the second specification is {1}
corresponding to age which is the second argument to the format method.
Notice that we could achieved the same using string concatenation: name + ' is ' +
str(age) + ' years old' but notice how much uglier and error-prone this is. Second, the conversion to string would be done automatically by the format method instead of the
explicit conversion here. Third, when using the format method, we can change the
message without having to deal with the variables used and vice-versa.
What Python does in the format method is that it substitutes each argument value into the place of the specification. There can be more detailed specifications such as:
>>> '{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'
Details of this formatting specification is explained in the Python Enhancement Proposal No. 3101 (http://www.python.org/dev/peps/pep-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, myname and myName are not the same.
Note the lowercase n in the former and the uppercase N in the latter.
• Examples of valid identifier names are i, __my_name, name_23, a1b2_c3 and
resumé_count.
• Examples of invalid identifier names are 2things, this is spaced out, my-name, and
"this_is_in_quotes".
Python en:Basics
30
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 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', we say 'the object'.
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:
1. Open your favorite editor.
1. Enter the program code given in the example.
1. 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 .py.
1. Run the interpreter with the command python program.py or use IDLE to run the
programs. You can also use the executable method as explained earlier.
Example: Using Variables And Literal Constants
# 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)
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 5 to the variable i using the assignment operator (=). This line is called a statement because it states that Python en:Basics
31
something should be done and in this case, we connect the variable name i to the value 5.
Next, we print the value of i using the print statement which, unsurprisingly, just prints the value of the variable to the screen.
Then we add 1 to the value stored in i and store it back. We then print it and expectedly, we get the value 6.
Similarly, we assign the literal string to the variable s 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 print('Hello World') - 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 (;) 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)
Python en:Basics
32
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 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:
i = 5
print('Value is ', i) # Error! Notice a single space at the start of
the line
print('I repeat, the value is ', i)
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 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 Python en:Basics
33
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 from
__future__ import braces 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.
Previous Next
Source: http://www.swaroopch.com/mediawiki/index.php?oldid=2376
Contributors: Swaroop, Vages, 10 anonymous edits
Python en:Operators and Expressions
Introduction
Most statements (logical lines) that you write will contain expressions. A simple example of an expression is 2 + 3. An expression can be broken down into operators and operands.
Operators are functionality that do something and can be represented by symbols such as +
or by special keywords. Operators require some data to operate on and such data is called operands. In this case, 2 and 3 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 2 + 3, use the interactive Python
interpreter prompt:
>>> 2 + 3
5
>>> 3 * 5
15
>>>
Operator
Name
Explanation
Examples
+
Plus
Adds the two objects
3 + 5 gives 8. 'a' + 'b' gives 'ab'.
-
Minus
Either gives a negative
-5.2 gives a negative number. 50 - 24 gives 26.
number or gives the
subtraction of one number
from the other
Python en:Operators and Expressions
34
*
Multiply
Gives the multiplication of the
2 * 3 gives 6. 'la' * 3 gives 'lalala'.
two numbers or returns the
string repeated that many
times.
**
Power
Returns x to the power of y
3 ** 4 gives 81 (i.e. 3 * 3 * 3 * 3)
/
Divide
Divide x by y
4 / 3 gives 1.3333333333333333.
//
Floor Division Returns the floor of the
4 // 3 gives 1.
quotient
%
Modulo
Returns the remainder of the
8 % 3 gives 2. -25.5 % 2.25 gives 1.5.
division
<<
Left Shift
Shifts the bits of the number
2 << 2 gives 8. 2 is represented by 10 in bits. Left
to the left by the number of
shifting by 2 bits gives 1000 which represents the
bits specified. (Each number is decimal 8.
represented in memory by bits
or binary digits i.e. 0 and 1)
>>
Right Shift
Shifts the bits of the number
11 >> 1 gives 5. 11 is represented in bits by 1011
to the right by the number of
which when right shifted by 1 bit gives 101 which is
bits specified.
the decimal 5.
&
Bitwise AND
Bitwise AND of the numbers
5 & 3 gives 1.
|
Bit-wise OR
Bitwise OR of the numbers
5 | 3 gives 7
^
Bit-wise XOR Bitwise XOR of the numbers
5 ^ 3 gives 6
~
Bit-wise
The bit-wise inversion of x is
~5 gives -6.
invert
-(x+1)
<
Less Than
Returns whether x is less than
5 < 3 gives False and 3 < 5 gives True.
y. All comparison operators
Comparisons can be chained arbitrarily: 3 < 5 < 7
return True or False. Note
gives True.
the capitalization of these
names.
>
Greater Than Returns whether x is greater
5 > 3 returns True. If both operands are numbers,
than y
they are first converted to a common type.
Otherwise, it always returns False.
<=
Less Than or
Returns whether x is less than
x = 3; y = 6; x <= y returns True.
Equal To
or equal to y
>=
Greater Than
Returns whether x is greater
x = 4; y = 3; x >= 3 returns True.
or Equal To
than or equal to y
==
Equal To
Compares if the objects are
x = 2; y = 2; x == y returns True.
equal
x = 'str'; y = 'stR'; x == y returns False.
x = 'str'; y = 'str'; x == y returns True.
!=
Not Equal To Compares if the objects are
x = 2; y = 3; x != y returns True.
not equal
not
Boolean NOT If x is True, it returns False. If x = True; not x returns False.
x is False, it returns True.
and
Boolean AND x and y returns False if x is
x = False; y = True; x and y returns False
False, else it returns
since x is False. In this case, Python will not evaluate
evaluation of y
y since it knows that the left hand side of the 'and'
expression is False which implies that the whole
expression will be False irrespective of the other
values. This is called short-circuit evaluation.
Python en:Operators and Expressions
35
or
Boolean OR
If x is True, it returns True,
x = True; y = False; x or y returns True.
else it returns evaluation of y
Short-circuit evaluation applies here as well.
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:
a = 2; a = a * 3
as:
a = 2; a *= 3
Notice that var = var operation expression becomes var operation= expression.
Evaluation Order
If you had an expression such as 2 + 3 * 4, 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 Python reference manual (http:/ / docs. python. org/
dev/ 3. 0/ reference/ expressions. html#evaluation-order), 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 Changing the Order of Evaluation below for details.
Operator
Description
lambda
Lambda Expression
or
Boolean OR
and
Boolean AND
not x
Boolean NOT
in, not in
Membership tests
is, is not
Identity tests
<, <=, >, >=, !=, ==
Comparisons
|
Bitwise OR
^
Bitwise XOR
&
Bitwise AND
<<, >>
Shifts
+, -
Addition and subtraction
*, /, //, %
Multiplication, Division, Floor Division and Remainder
+x, -x
Positive, Negative
Python en:Operators and Expressions
36
~x
Bitwise NOT
**
Exponentiation
x.attribute
Attribute reference
x[index]
Subscription
x[index1:index2]
Slicing
f(arguments ...)
Function call
(expressions, ...)
Binding or tuple display
[expressions, ...]
List display
{key:datum, ...}
Dictionary display
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, + and - have the same precedence.
Changing the Order Of Evaluation
To make the expressions more readable, we can use parentheses. For example, 2 + (3 *
4) is definitely easier to understand than 2 + 3 * 4 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 2 + (3 + 4)).
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 (2 + 3) * 4.
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, 2 + 3 + 4 is evaluated as (2 + 3) + 4.
Some operators like assignment operators have right to left associativity i.e. a = b = c is treated as a = (b = c).
Expressions
Example:
#!/usr/bin/python
# Filename: expression.py
length = 5
breadth = 2
area = length * breadth
print('Area is', area)
print('Perimeter is', 2 * (length + breadth))
Output:
Python en:Operators and Expressions
37
$ 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 length * breadth in the variable area and then print it using the print function. In the second case, we directly use the value of the expression 2
* (length + breadth) in the print function.
Also, notice how Python 'pretty-prints' the output. Even though we have not specified a space between 'Area is' and the variable area, 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.
Previous Next
Source: http://www.swaroopch.com/mediawiki/index.php?oldid=1579
Contributors: Swaroop, 4 anonymous edits
Python en:Control Flow
38
Python en:Control Flow
Introduction
In the programs we have seen till now, there has always been a series of statements and Python faithfully executes them in the same order. What if you wanted to change the flow of how it works? For example, you want the program to take some decisions and do different things depending on different situations such as printing 'Good Morning' or 'Good Evening'
depending on the time of the day?
As you might have guessed, this is achieved using control flow statements. There are three control flow statements in Python - if, for and while.
The if statement
The if statement is used to check a condition and if the condition is true, we run a block of statements (called the if-block), else we process another block of statements (called the else-block). The else clause is optional.
Example:
#!/usr/bin/python
# Filename: if.py
number = 23
guess = int(input('Enter an integer : '))
if guess == number:
print('Congratulations, you guessed it.') # New block starts here
print('(but you do not win any prizes!)') # New block ends here
elif guess < number:
print('No, it is a little higher than that') # Another block
# You can do whatever you want in a block ...
else:
print('No, it is a little lower than that')
# you must have guess > number to reach here
print('Done')
# This last statement is always executed, after the if statement is
executed
Output:
$ python if.py
Enter an integer : 50
No, it is a little lower than that
Done
$ python if.py
Enter an integer : 22
Python en:Control Flow
39
No, it is a little higher than that
Done
$ python if.py
Enter an integer : 23
Congratulations, you guessed it.
(but you do not win any prizes!)
Done
How It Works:
In this program, we take guesses from the user and check if it is the number that we have.
We set the variable number to any integer we want, say 23. Then, we take the user's guess using the input() function. Functions are just reusable pieces of programs. We'll read more about them in the next chapter.
We supply a string to the built-in input function which prints it to the screen and waits for input from the user. Once we enter something and press enter key, the input() function returns what we entered, as a string. We then convert this string to an integer using int and then store it in the variable guess. Actually, the int is a class but all you need to know right now is that you can use it to convert a string to an integer (assuming the string contains a valid integer in the text).
Next, we compare the guess of the user with the number we have chosen. If they are equal, we print a success message. Notice that we use indentation levels to tell Python which statements belong to which block. This is why indentation is so important in Python. I hope you are sticking to the "consistent indentation" rule. Are you?
Notice how the if statement contains a colon at the end - we are indicating to Python that a block of statements follows.
Then, we check if the guess is less than the number, and if so, we inform the user to guess a little higher than that. What we have used here is the elif clause which actually
combines two related if else-if else statements into one combined if-elif-else
statement. This makes the program easier and reduces the amount of indentation required.
The elif and else statements must also have a colon at the end of the logical line
followed by their corresponding block of statements (with proper indentation, of course) You can have another if statement inside the if-block of an if statement and so on - this is called a nested if statement.
Remember that the elif and else parts are optional. A minimal valid if statement is:
if True:
print('Yes, it is true')
After Python has finished executing the complete if statement along with the associated elif and else clauses, it moves on to the next statement in the block containing the if statement. In this case, it is the main block where execution of the program starts and the next statement is the print('Done') statement. After this, Python sees the ends of the program and simply finishes up.
Although this is a very simple program, I have been pointing out a lot of things that you should notice even in this simple program. All these are pretty straightforward (and
surprisingly simple for those of you from C/C++ backgrounds) and requires you to become Python en:Control Flow
40
aware of all these initially, but after that, you will become comfortable with it and it'll feel
'natural' to you.
Note for C/C++ Programmers
There is no switch statement in Python. You can use an if..elif..else statement to
do the same thing (and in some cases, use a dictionary to do it quickly)
The while Statement
The while statement allows you to repeatedly execute a block of statements as long as a condition is true. A while statement is an example of what is called a looping statement. A while statement can have an optional else clause.
Example:
#!/usr/bin/python
# Filename: while.py
number = 23
running = True
while running:
guess = int(input('Enter an integer : '))
if guess == number:
print('Congratulations, you guessed it.')
running = False # this causes the while loop to stop
elif guess < number:
print('No, it is a little higher than that.')
else:
print('No, it is a little lower than that.')
else:
print('The while loop is over.')
# Do anything else you want to do here
print('Done')
Output:
$ python while.py
Enter an integer : 50
No, it is a little lower than that.
Enter an integer : 22
No, it is a little higher than that.
Enter an integer : 23
Congratulations, you guessed it.
The while loop is over.
Done
How It Works:
Python en:Control Flow
41
In this program, we are still playing the guessing game, but the advantage is that the user is allowed to keep guessing until he guesses correctly - there is no need to repeatedly run the program for each guess, as we have done in the previous section. This aptly
demonstrates the use of the while statement.
We move the input and if statements to inside the while loop and set the variable
running to True before the while loop. First, we check if the variable running is True and then proceed to execute the corresponding while-block. After this block is executed, the condition is again checked which in this case is the running variable. If it is true, we execute the while-block again, else we continue to execute the optional else-block and then continue to the next statement.
The else block is executed when the while loop condition becomes False - this may even be the first time that the condition is checked. If there is an else clause for a while loop, it is always executed unless you break out of the loop with a break statement.
The True and False are called Boolean types and you can consider them to be equivalent to the value 1 and 0 respectively.
Note for C/C++ Programmers
Remember that you can have an else clause for the while loop.
The for loop
The for..in statement is another looping statement which iterates over a sequence of objects i.e. go through each item in a sequence. We will see more about sequences in detail in later chapters. What you need to know right now is that a sequence is just an ordered collection of items.
Example:
#!/usr/bin/python
# Filename: for.py
for i in range(1, 5):
print(i)
else:
print('The for loop is over')
Output:
$ python for.py
1
2
3
4
The for loop is over
How It Works:
In this program, we are printing a sequence of numbers. We generate this sequence of numbers using the built-in range function.
What we do here is supply it two numbers and range returns a sequence of numbers
starting from the first number and up to the second number. For example, range(1,5)
Python en:Control Flow
42
gives the sequence [1, 2, 3, 4]. By default, range takes a step count of 1. If we supply a third number to range, then that becomes the step count. For example, range(1,5,2)
gives [1,3]. Remember that the range extends up to the second number i.e. it does not include the second number.
The for loop then iterates over this range - for i in range(1,5) is equivalent to for i in [1, 2, 3, 4] which is like assigning each number (or object) in the sequence to i, one at a time, and then executing the block of statements for each value of i. In this case, we just print the value in the block of statements.
Remember that the else part is optional. When included, it is always executed once after the for loop is over unless a break statement is encountered.
Remember that the for..in loop works for any sequence. Here, we have a list of numbers generated by the built-in range function, but in general we can use any kind of sequence of any kind of objects! We will explore this idea in detail in later chapters.
Note for C/C++/Java/C# Programmers
The Python for loop is radically different from the C/C++ for loop. C# programmers
will note that the for loop in Python is similar to the foreach loop in C#. Java
programmers will note that the same is similar to for (int i : IntArray) in Java
1.5 .
In C/C++, if you want to write for (int i = 0; i < 5; i++), then in Python you
write just for i in range(0,5). As you can see, the for loop is simpler, more
expressive and less error prone in Python.
The break Statement
The break statement is used to break out of a loop statement i.e. stop the execution of a looping statement, even if the loop condition has not become False or the sequence of
items has been completely iterated over.
An important note is that if you break out of a for or while loop, any corresponding loop else block is not executed.
Example:
#!/usr/bin/python
# Filename: break.py
while True:
s = (input('Enter something : '))
if s == 'quit':
break
print('Length of the string is', len(s))
print('Done')
Output:
$ python break.py
Enter something : Programming is fun
Length of the string is 18
Enter something : When the work is done
Length of the string is 21
Python en:Control Flow
43
Enter something : if you wanna make your work also fun:
Length of the string is 37
Enter something : use Python!
Length of the string is 12
Enter something : quit
Done
How It Works:
In this program, we repeatedly take the user's input and print the length of each input each time. We are providing a special condition to stop the program by checking if the user input is 'quit'. We stop the program by breaking out of the loop and reach the end of the program.
The length of the input string can be found out using the built-in len function.
Remember that the break statement can be used with the for loop as well.
Swaroop's Poetic Python
The input I have used here is a mini poem I have written called Swaroop's Poetic Python: Programming is fun
When the work is done
if you wanna make your work also fun:
use Python!
The continue Statement
The continue statement is used to tell Python to skip the rest of the statements in the current loop block and to continue to the next iteration of the loop.
Example:
#!/usr/bin/python
# Filename: continue.py
while True:
s = input('Enter something : ')
if s == 'quit':
break
if len(s) < 3:
print('Too small')
continue
print('Input is of sufficient length')
# Do other kinds of processing here...
Output:
$ python test.py
Enter something : a
Too small
Enter something : 12
Too small
Python en:Control Flow
44
Enter something : abc
Input is of sufficient length
Enter something : quit
How It Works:
In this program, we accept input from the user, but we process them only if they are at least 3 characters long. So, we use the built-in len function to get the length and if the length is less than 3, we skip the rest of the statements in the block by using the continue statement. Otherwise, the rest of the statements in the loop are executed and we can do any kind of processing we want to do here.
Note that the continue statement works with the for loop as well.
Summary
We have seen how to use the three control flow statements - if, while and for along with their associated break and continue statements. These are some of the most often used
parts of Python and hence, becoming comfortable with them is essential.
Next, we will see how to create and use functions.
Previous Next
Source: http://www.swaroopch.com/mediawiki/index.php?oldid=1664
Contributors: Swaroop, 8 anonymous edits
Python en:Functions
Introduction
Functions are reusable pieces of programs. They allow you to give a name to a block of statements and you can run that block using that name anywhere in your program and any number of times. This is known as calling the function. We have already used many built-in functions such as the len and range.
The function concept is probably the most important building block of any non-trivial software (in any programming language), so we will explore various aspects of functions in this chapter.
Functions are defined using the def keyword. This is followed by an identifier name for the function followed by a pair of parentheses which may enclose some names of variables and the line ends with a colon. Next follows the block of statements that are part of this function. An example will show that this is actually very simple:
Example:
#!/usr/bin/python
# Filename: function1.py
def sayHello():
print('Hello World!') # block belonging to the function
# End of function
Python en:Functions
45
sayHello() # call the function
sayHello() # call the function again
Output:
$ python function1.py
Hello World!
Hello World!
How It Works:
We define a function called sayHello using the syntax as explained above. This function takes no parameters and hence there are no variables declared in the parentheses.
Parameters to functions are just input to the function so that we can pass in different values to it and get back corresponding results.
Notice that we can call the same function twice which means we do not have to write the same code again.
Function Parameters
A function can take parameters, which are values you supply to the function so that the function can do something utilising those values. These parameters are just like variables except that the values of these variables are defined when we call the function and are already assigned values when the function runs.
Parameters are specified within the pair of parentheses in the function definition, separated by commas. When we call the function, we supply the values in the same way. Note the
terminology used - the names given in the function definition are called parameters whereas the values you supply in the function call are called arguments.
Example:
#!/usr/bin/python
# Filename: func_param.py
def printMax(a, b):
if a > b:
print(a, 'is maximum')
elif a == b:
print(a, 'is equal to', b)
else:
print(b, 'is maximum')
printMax(3, 4) # directly give literal values
x = 5
y = 7
printMax(x, y) # give variables as arguments
Output:
Python en:Functions
46
$ python func_param.py
4 is maximum
7 is maximum
How It Works:
Here, we define a function called printMax where we take two parameters called a and b.
We find out the greater number using a simple if..else statement and then print the
bigger number.
In the first usage of printMax, we directly supply the numbers i.e. arguments. In the second usage, we call the function using variables. printMax(x, y) causes value of argument x to be assigned to parameter a and the value of argument y assigned to parameter b. The
printMax function works the same in both the cases.
Local Variables
When you declare variables inside a function definition, they are not related in any way to other variables with the same names used outside the function i.e. variable names are local to the function. This is called the scope of the variable. All variables have the scope of the block they are declared in starting from the point of definition of the name.
Example:
#!/usr/bin/python
# Filename: func_local.py
x = 50
def func(x):
print('x is', x)
x = 2
print('Changed local x to', x)
func(x)
print('x is still', x)
Output:
$ python func_local.py
x is 50
Changed local x to 2
x is still 50
How It Works:
In the function, the first time that we use the value of the name x, Python uses the value of the parameter declared in the function.
Next, we assign the value 2 to x. The name x is local to our function. So, when we change the value of x in the function, the x defined in the main block remains unaffected.
In the last print function call, we display the value of x in the main block and confirm that it is actually unaffected.
Python en:Functions
47
Using The global Statement
If you want to assign a value to a name defined at the top level of the program (i.e. not inside any kind of scope such as functions or classes), then you have to tell Python that the name is not local, but it is global. We do this using the global statement. It is impossible to assign a value to a variable defined outside a function without the global statement.
You can use the values of such variables defined outside the function (assuming there is no variable with the same name within the function). However, this is not encouraged and
should be avoided since it becomes unclear to the reader of the program as to where that variable's definition is. Using the global statement makes it amply clear that the variable is defined in an outermost block.
Example:
#!/usr/bin/python
# Filename: func_global.py
x = 50
def func():
global x
print('x is', x)
x = 2
print('Changed global x to', x)
func()
print('Value of x is', x)
Output:
$ python func_global.py
x is 50
Changed global x to 2
Value of x is 2
How It Works:
The global statement is used to declare that x is a global variable - hence, when we assign a value to x inside the function, that change is reflected when we use the value of x in the main block.
You can specify more than one global variable using the same global statement. For
example, global x, y, z.
Python en:Functions
48
Using nonlocal statement
We have seen how to access variables in the local and global scope above. There is another kind of scope called "nonlocal" scope which is in-between these two types of scopes.
Nonlocal scopes are observed when you define functions inside functions.
Since everything in Python is just executable code, you can define functions anywhere.
Let's take an example:
#!/usr/bin/python
# Filename: func_nonlocal.py
def func_outer():
x = 2
print('x is', x)
def func_inner():
nonlocal x
x = 5
func_inner()
print('Changed local x to', x)
func_outer()
Output:
$ python func_nonlocal.py
x is 2
Changed local x to 5
How It Works:
When we are inside func_inner, the 'x' defined in the first line of func_outer is relatively neither in local scope nor in global scope. We declare that we are using this x by nonlocal x and hence we get access to that variable.
Try changing the nonlocal x to global x and also by removing the statement itself and
observe the difference in behavior in these two cases.
Default Argument Values
For some functions, you may want to make some of its parameters as optional and use default values if the user does not want to provide values for such parameters. This is done with the help of default argument values. You can specify default argument values for
parameters by following the parameter name in the function definition with the assignment operator (=) followed by the default value.
Note that the default argument value should be a constant. More precisely, the default argument value should be immutable - this is explained in detail in later chapters. For now, just remember this.
Example:
Python en:Functions
49
#!/usr/bin/python
# Filename: func_default.py
def say(message, times = 1):
print(message * times)
say('Hello')
say('World', 5)
Output:
$ python func_default.py
Hello
WorldWorldWorldWorldWorld
How It Works:
The function named say is used to print a string as many times as specified. If we don't supply a value, then by default, the string is printed just once. We achieve this by specifying a default argument value of 1 to the parameter times.
In the first usage of say, we supply only the string and it prints the string once. In the second usage of say, we supply both the string and an argument 5 stating that we want to say the string message 5 times.
Important
Only those parameters which are at the end of the parameter list can be given default
argument values i.e. you cannot have a parameter with a default argument value
before a parameter without a default argument value in the order of parameters
declared in the function parameter list.
This is because the values are assigned to the parameters by position. For example,
def func(a, b=5) is valid, but def func(a=5, b) is not valid.
Keyword Arguments
If you have some functions with many parameters and you want to specify only some of
them, then you can give values for such parameters by naming them - this is called keyword arguments - we use the name (keyword) instead of the position (which we have been using all along) to specify the arguments to the function.
There are two advantages - one, using the function is easier since we do not need to worry about the order of the arguments. Two, we can give values to only those parameters which we want, provided that the other parameters have default argument values.
Example:
#!/usr/bin/python
# Filename: func_key.py
def func(a, b=5, c=10):
print('a is', a, 'and b is', b, 'and c is', c)
func(3, 7)
Python en:Functions
50
func(25, c=24)
func(c=50, a=100)
Output:
$ python func_key.py
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50
How It Works:
The function named func has one parameter without default argument values, followed by two parameters with default argument values.
In the first usage, func(3, 7), the parameter a gets the value 3, the parameter b gets the value 7 and c gets the default value of 10.
In the second usage func(25, c=24), the variable a gets the value of 25 due to the position of the argument. Then, the parameter c gets the value of 24 due to naming i.e. keyword arguments. The variable b gets the default value of 5.
In the third usage func(c=50, a=100), we use keyword arguments completely to specify
the values. Notice, that we are specifying value for parameter c before that for a even though a is defined before c in the function definition.
VarArgs parameters
TODO
Should I write about this in a later chapter since we haven't talked about lists and
dictionaries yet?
Sometimes you might want to define a function that can take any number of parameters, this can be achieved by using the stars:
#!/usr/bin/python
# Filename: total.py
def total(initial=5, *numbers, **keywords):
count = initial
for number in numbers:
count += number
for key in keywords:
count += keywords[key]
return count
print(total(10, 1, 2, 3, vegetables=50, fruits=100))
Output:
$ python total.py
166
How It Works:
Python en:Functions
51
When we declare a starred parameter such as *param, then all the positional arguments
from that point till the end are collected as a list called 'param'.
Similarly, when we declare a double-starred parameter such as **param, then all the
keyword arguments from that point till the end are collected as a dictionary called 'param'.
We will explore lists and dictionaries in a later chapter.
Keyword-only Parameters
If we want to specify certain keyword parameters to be available as keyword-only and not as positional arguments, they can be declared after a starred parameter:
#!/usr/bin/python
# Filename: keyword_only.py
def total(initial=5, *numbers, vegetables):
count = initial
for number in numbers:
count += number
count += vegetables
return count
print(total(10, 1, 2, 3, vegetables=50))
print(total(10, 1, 2, 3))
# Raises error because we have not supplied a default argument value
for 'vegetables'
Output:
$ python keyword_only.py
66
Traceback (most recent call last):
File "test.py", line 12, in <module>
print(total(10, 1, 2, 3))
TypeError: total() needs keyword-only argument vegetables
How It Works:
Declaring parameters after a starred parameter results in keyword-only arguments. If these arguments are not supplied a default value, then calls to the function will raise an error if the keyword argument is not supplied, as seen above.
If you want to have keyword-only arguments but have no need for a starred parameter, then simply use an empty star without using any name such as def total(initial=5, *,
vegetables).
Python en:Functions
52
The return Statement
The return statement is used to return from a function i.e. break out of the function. We can optionally return a value from the function as well.
Example:
#!/usr/bin/python
# Filename: func_return.py
def maximum(x, y):
if x > y:
return x
else:
return y
print(maximum(2, 3))
Output:
$ python func_return.py
3
How It Works:
The maximum function returns the maximum of the parameters, in this case the numbers
supplied to the function. It uses a simple if..else statement to find the greater value and then returns that value.
Note that a return statement without a value is equivalent to return None. None is a
special type in Python that represents nothingness. For example, it is used to indicate that a variable has no value if it has a value of None.
Every function implicitly contains a return None statement at the end unless you have
written your own return statement. You can see this by running print(someFunction())
where the function someFunction does not use the return statement such as:
def someFunction():
pass
The pass statement is used in Python to indicate an empty block of statements.
Note
There is a built-in function called max that already implements the 'find maximum'
functionality, so use this built-in function whenever possible.
Python en:Functions
53
DocStrings
Python has a nifty feature called documentation strings, usually referred to by its shorter name docstrings. DocStrings are an important tool that you should make use of since it helps to document the program better and makes it easier to understand. Amazingly, we
can even get the docstring back from, say a function, when the program is actually running!
Example:
#!/usr/bin/python
# Filename: func_doc.py
def printMax(x, y):
'''Prints the maximum of two numbers.
The two values must be integers.'''
x = int(x) # convert to integers, if possible
y = int(y)
if x > y:
print(x, 'is maximum')
else:
print(y, 'is maximum')
printMax(3, 5)
print(printMax.__doc__)
Output:
$ python func_doc.py
5 is maximum
Prints the maximum of two numbers.
The two values must be integers.
How It Works:
A string on the first logical line of a function is the docstring for that function. Note that DocStrings also apply to modules and classes which we will learn about in the respective chapters.
The convention followed for a docstring is a multi-line string where the first line starts with a capital letter and ends with a dot. Then the second line is blank followed by any detailed explanation starting from the third line. You are strongly advised to follow this convention for all your docstrings for all your non-trivial functions.
We can access the docstring of the printMax function using the __doc__ (notice the
double underscores) attribute (name belonging to) of the function. Just remember that Python treats everything as an object and this includes functions. We'll learn more about objects in the chapter on classes.
If you have used help() in Python, then you have already seen the usage of docstrings!
What it does is just fetch the __doc__ attribute of that function and displays it in a neat manner for you. You can try it out on the function above - just include help(printMax) in Python en:Functions
54
your program. Remember to press the q key to exit help.
Automated tools can retrieve the documentation from your program in this manner.
Therefore, I strongly recommend that you use docstrings for any non-trivial function that you write. The pydoc command that comes with your Python distribution works similarly to help() using docstrings.
Annotations
Functions have another advanced feature called annotations which are a nifty way of
attaching additional information for each of the parameters as well as the return value.
Since the Python language itself does not interpret these annotations in any way (that functionality is left to third-party libraries to interpret in any way they want), we will skip this feature in our discussion. If you are interested to read about annotations, please see the Python Enhancement Proposal No. 3107 (http:/ / www. python. org/ dev/ peps/
Summary
We have seen so many aspects of functions but note that we still haven't covered all aspects of it. However, we have already covered most of what you'll use regarding Python functions on an everyday basis.
Next, we will see how to use as well as create Python modules.
Previous Next
Source: http://www.swaroopch.com/mediawiki/index.php?oldid=2379
Contributors: Swaroop, Vages, 7 anonymous edits
Python en:Modules
55
Python en:Modules
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
.py 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 C programming language (http://docs.python.org/extending/) 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:
#!/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')
Output:
$ python using_sys.py we are arguments
The command line arguments are:
using_sys.py
we
are
arguments
The PYTHONPATH is ['', '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 sys module using the import statement. Basically, this translates to us telling Python that we want to use this module. The sys module contains functionality related to the Python interpreter and its environment i.e. the sys tem.
Python en:Modules
56
When Python executes the import sys statement, it looks for the sys 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 sys.path 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 argv variable in the sys module is accessed using the dotted notation i.e. sys.argv. It clearly indicates that this name is part of the sys module. Another advantage of this
approach is that the name does not clash with any argv variable used in your program.
The sys.argv variable is a list of strings (lists are explained in detail in a later chapter.
Specifically, the sys.argv 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 python using_sys.py we are arguments, we run the module
using_sys.py with the python command and the other things that follow are arguments
passed to the program. Python stores the command line arguments in the sys.argv
variable for us to use.
Remember, the name of the script running is always the first argument in the sys.argv
list. So, in this case we will have 'using_sys.py' as sys.argv[0], 'we' as sys.argv[1],
'are' as sys.argv[2] and 'arguments' as sys.argv[3]. Notice that Python starts
counting from 0 and not 1.
The sys.path contains the list of directory names where modules are imported from.
Observe that the first string in sys.path is empty - this empty string indicates that the current directory is also part of the sys.path which is same as the PYTHONPATH
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 sys.path.
Note that the current directory is the directory from which the program is launched. Run import os; print(os.getcwd()) 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 .pyc which is an intermediate form that Python transforms the program into (remember the introduction section on how Python works?). This .pyc 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 .pyc files are usually created in the same directory as the corresponding .py
files. If Python does not have permission to write to files in that directory, then the
.pyc files will not be created.
Python en:Modules
57
The from ...import ...statement
If you want to directly import the argv variable into your program (to avoid typing the sys. everytime for it), then you can use the from sys import argv statement. If you want to import all the names used in the sys module, then you can use the from sys import *
statement. This works for any module.
In general, you should avoid using this statement and use the import 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 __name__ attribute of the module.
Example:
#!/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')
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 __name__ defined and if this is '__main__', it implies that the module is being run standalone by the user and we can take appropriate actions.
Python en:Modules
58
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 .py extension. The following example should make it clear.
Example:
#!/usr/bin/python
# Filename: mymodule.py
def sayhi():
print('Hi, this is mymodule speaking.')
__version__ = '0.1'
# End of mymodule.py
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 sys.path.
#!/usr/bin/python
# Filename: mymodule_demo.py
import mymodule
mymodule.sayhi()
print ('Version', mymodule.__version__)
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 from..import syntax:
#!/usr/bin/python
# Filename: mymodule_demo2.py
from mymodule import sayhi, __version__
sayhi()
print('Version', __version__)
Python en:Modules
59
The output of mymodule_demo2.py is same as the output of mymodule_demo.py.
Notice that if there was already a __version__ 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 import statement even though it might make your program a little longer.
You could also use:
from mymodule import *
This will import all public names such as sayhi but would not import __version__
because it starts with double underscores.
Zen of Python
One of Python's guiding principles is that "Explicit is better than Implicit". Run import this to learn more and see this discussion (http:/ / stackoverflow. com/ questions/
228181/zen-of-python) which lists examples for each of the principles.
The dir function
You can use the built-in dir 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 dir() 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:
$ 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',
Python en:Modules
60
'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']
>>>
How It Works:
First, we see the usage of dir on the imported sys module. We can see the huge list of attributes that it contains.
Next, we use the dir 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 dir in action, we define a new variable a and assign it a value and then check dir 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 del statement and the change is reflected again in the output of the dir function.
A note on del - this statement is used to delete a variable/name and after the statement has run, in this case del a, you can no longer access the variable a - it is as if it never existed before at all.
Note that the dir() function works on any object. For example, run dir(print) to learn about the attributes of the print function, or dir(str) for the attributes of the str class.
Python en:Modules
61
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 __init__.py 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 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.
Previous Next
Source: http://www.swaroopch.com/mediawiki/index.php?oldid=2371
Contributors: Swaroop, 7 anonymous edits
Python en:Data Structures
62
Python en:Data Structures
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 list 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 own chapter.
A list is an example of usage of objects and classes. When we use a variable i and assign a value to it, say integer 5 to it, you can think of it as creating an object (i.e. instance) i of class (i.e. type) int. In fact, you can read help(int) 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 append method for the list class which allows you to add an item to the end of the list. For example, mylist.append('an item') will add that string to the list mylist. 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, mylist.field.
Example:
#!/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=' ')
Python en:Data Structures
63
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)
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 shoplist is a shopping list for someone who is going to the market. In
shoplist, 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 for..in 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 section.
Notice the use of the end keyword argument to the print 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 append 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 print statement which prints it neatly.
Then, we sort the list by using the sort 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 Python en:Data Structures
