Python Training session 2

Students copy

Variable

A variable is a name that refers to a value.

A variable is user defined identifier to reserve memory locate to store values. That means when some
values are assigned it will allocate some space in memory.

Python is a dynamically typed language. No advance declaration of identifier with a particular data type.
You can store integers, decimals, or characters in these variables.

Assigning value to a variable:

Python variables do not have to be explicitly declared to reserve memory space. The declaration
happens automatically when you assign a value to a variable. The equal sign (=) is used to assign values
to variables.
The operand to the left of the = operator is the name of the variable, and the operand to the right of the
= operator is the value stored in the variable.
Best Practices Use variables names more like English words something related to the instance. Also used
for easy memorizing.
x = 100 instead of x=100 it’s easier to read.
For example:

cars = 100 # An integer assignment

space_in_a_car = 4.0 # A floating point
name_of_company = “Car World” # A string
drivers = 30
passengers = 90
cars_not_driven = cars - drivers
cars_driven = drivers
carpool_capacity = cars_driven * space_in_a_car
average_passengers_per_car = passengers / cars_driven

print "There are", cars, "cars available in ", name_of_company

print "There are only", drivers, "drivers available."
print "There will be", cars_not_driven, "empty cars today."
print "We can transport", carpool_capacity, "people today."
print "We have", passengers, "to carpool today."
print "We need to put about", average_passengers_per_car, "in each car."

While running this program, this will produce following result:

There are 100 cars available.

There are only 30 drivers available.
There will be 70 empty cars today.
We can transport 120.0 people today.
We have 90 to carpool today.
We need to put about 3 in each car.

Type (Variable)  gives the Type

Akhil
 Python Training session 2
Students copy

Multiple Assignments:
You can also assign a single value to several variables simultaneously. For example:
a=b=c=1

Here, an integer object is created with the value 1, and all three variables are assigned to the same
memory location. You can also assign multiple objects to multiple variables. For example:
a, b, c = 1, 5.4, "Hello World"

Here two integer objects with values 1 and 2 are assigned to variables a and b, and one string object
with the value "john" is assigned to the variable c.

In interactive mode, the last printed expression is assigned to the variable _. Useful when using python
as desk calculator.

Data Type:
Apart from True False None python has five standard Data types Number, String, List, Tuple and
Dictionary.

Mutable and immutable

del is a statement to delete the reference to any allocated data type objects.
Python supports four different numerical types:

int (signed integers)

long (long integers [can also be represented in octal and hexadecimal])
float (floating point real values)
complex (complex numbers)
Python allows you to use a lowercase L with long, but it is recommended that you use only an uppercase
L to avoid confusion with the number 1. Python displays long integers with an uppercase L.

A complex number consists of an ordered pair of real floating point numbers denoted by a + bj, where a
is the real part and b is the imaginary part of the complex number.

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5.0*6) / 4
5.0
>>> 8 / 5.0
1.6

Besides numbers, Python can also manipulate strings, which can be expressed in several ways. They can
be enclosed in single quotes ('...') or double quotes ("...") with the same result, \ can be used to escape
quotes:
>>> 'spam eggs' # single quotes
'spam eggs'
>>> 'doesn\'t' # use \' to escape the single quote...

Akhil
 Python Training session 2
Students copy

"doesn't"
>>> "doesn't" # ...or use double quotes instead
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

String literals can span multiple lines. One way is using triple-quotes: """...""" or '''...'''. End of lines are
automatically included in the string

Strings can be concatenated (or appended) with the + operator, and repeated with *:
The plus ( + ) sign is the string concatenation operator, and the asterisk ( * ) is the repetition operator.

>>> # 3 times 'un', followed by 'ium'

>>> 3 * 'un' + 'ium'
'unununium'

>>> prefix = 'Py'

>>> prefix 'thon' # can't concatenate a variable and a string literal

>>> prefix + 'thon'

'Python This feature is particularly useful when you want to break long strings:
>>> text = ('Put several strings within parentheses '
'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

Remember: ordinal == ordered, 1st; cardinal == cards at random, 0.

Subsets of strings can be taken using the slice operator ( [ ] and [ : ] ) with indexes starting at 0 in the
beginning of the string and working their way from -1 at the end. Also called as negative indexing.

Strings can be indexed (subscripted), with the first character having index 0. There is no separate
character type; a character is simply a string of size one:

>>> word = 'Python'

>>> word[0] # character in position 0
'P'
>>> word[5] # character in position 5
'n'

Indices may also be negative numbers, to start counting from the right:

Akhil
 Python Training session 2
Students copy

>>> word[-1] # last character

'n'
>>> word[-2] # second-last character
'o'
>>> word[-6]
'P'
Note that since -0 is the same as 0, negative indices start from -1.

In addition to indexing, slicing is also supported. While indexing is used to obtain individual
characters, slicing allows you to obtain a substring:

>>> word[0:2] # characters from position 0 (included) to 2 (excluded)

'Py'
>>> word[2:5] # characters from position 2 (included) to 5 (excluded)
'tho'
Note how the start is always included, and the end always excluded. This makes sure that s[:i] + s[i:] is
always equal to s:

>>> word[:2] + word[2:]

'Python'
>>> word[:4] + word[4:]
'Python'
Slice indices have useful defaults; an omitted first index defaults to zero, an omitted second index
defaults to the size of the string being sliced.
>>>
>>> word[:2] # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:] # characters from position 4 (included) to the end
'on'
>>> word[-2:] # characters from the second-last (included) to the end
'on'
One way to remember how slices work is to think of the indices as pointing between characters, with
the left edge of the first character numbered 0. Then the right edge of the last character of a string of n
characters has index n, for example:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
The first row of numbers gives the position of the indices 0...6 in the string; the second row gives the
corresponding negative indices. The slice from i to j consists of all characters between the edges labeled
i and j, respectively.
For non-negative indices, the length of a slice is the difference of the indices, if both are within bounds.
For example, the length of word[1:3] is 2.
Attempting to use a index that is too large will result in an error:
>>>
>>> word[42] # the word only has 7 characters
Traceback (most recent call last):

Akhil
 Python Training session 2
Students copy

File "<stdin>", line 1, in <module>

IndexError: string index out of range
However, out of range slice indexes are handled gracefully when used for slicing:
>>>
>>> word[4:42]
'on'
>>> word[42:]
''
Python strings cannot be changed — they are immutable. Therefore, assigning to an indexed position in
the string results in an error:
>>>
>>> word[0] = 'J'
...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
...
TypeError: 'str' object does not support item assignment
If you need a different string, you should create a new one:
>>>
>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'
The built-in function len() returns the length of a string:
>>>
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

Strings are immutable

Akhil