Python - Variables

Any computer application captures and stores data and processes it to produce information to make it available to the user. Computer in that sense is a data processing device.  Data is a raw and factual representation of objects. Computer program is a predefined set of instructions to process data and generate meaningful information.

Data types

Data of students will consist of name, gender, class, marks, age, fee etc.
Data of books in library will have title, author, publisher, price, pages, year of publication etc.
Data of employees in an office will be name, designation, salary, department, branch, etc.

Data items similar to above examples can be classified in distinct types. Data type represents a kind of value and determines what operations can be done on it. Each programming language follows its own classification system.

Standard or built-in data types in Python are as follows:

Numbers: Numeric literals, results of arithmetic operations and built-in functions represent data which has numeric value. Python identifies following types of numbers

• Integer : Positive or negative whole numbers (without fractional part)

Examples: 8436, -765, 0x7A (‘x’ followed by 0 to represent hexadecimal number) 0O402 (‘O’ followed by 0 to represent octal number)

• Boolean : Data with one of two built-in values True or False representing 1 and 0 respectively.
• Float : Any real number with a floating point representation in which fractional component is denoted by decimal symbol or scientific notation

Examples: -55.550, 0.005, 1.32E10 (scientific notation)

• Complex number: This number has a real and an imaginary component. It is represented as x+yj.  x and y are floating point numbers and j is -1 (square root of -1 called imaginary number)

Examples: 4+6J, -2.3+6.4J

• Sequences : Sequence is an ordered collection of items of similar or different data types. Each item’s position in collection has an index. Python has following built-in sequence data types:
• String: String object is a collection of one or more characters put in single, double or triple quotes.

Examples: 'Hello Python', "Hello Python",  '''Hello Python''', """Hello Python"""

• List : List object is an ordered collection of one or more data items, not necessarily of same type, put in square brackets

Example:  [1,"Ram", 99.99, True]

• Tuple: Tuple object is an ordered collection of one or more data items separated by comma and put in parentheses. They may or may not necessarily be of same type.

Example : (10,"Thomas", 3.142, True)

• Dictionary : A dictionary object is an unordered collection (items not accessed by index) of data in key:value pair form. Collection of such pairs is enclosed in curly brackets.

Example: {1:"Python", 2:"Java", 3:"Ruby", 4: "Perl"}

• Set : Set is an unordered collection of unique items separated by comma and enclosed within curly brackets.

Example: {1,2,3,4,5}

Variable

Object of a certain data type is stored in computer’s memory. Python interpreter assigns a random location to each object.

The location can be known by using built-in function id().

In   [1]    :id(1500)
Out[1]  : 2799045298768
In   [2]    :id("Hello")
Out[2]  :2799045418096
In   [3]    :id([1,2,3])
Out[3]   :2799045388040

However to refer to the object repeatedly by its id will be difficult. Hence in order to conveniently refer to it, the object given a suitable name. An object is bound to a name by assignment operator ‘=’

In [4]  :price=1500
           word="Hello"
           numbers=[1,2,3]
In [5]   : price*2
Out [5] : 3000
In [6]    : word
Out [6] : 'Hello'
In [7]    : numbers[1]
Out [7] : 2

Here ‘price’ is a variable that refers to integer object 1500 in computer memory. Similarly ‘numbers’ variable refers to list object and ‘word’ refers to string object.

Dynamic typing

Python is a dynamically typed language. A variable in Python is not bound permanently to a specific data type. This is unlike statically typed Programming languages such as C, C++, Java, C# etc. Variable in these languages is a name of memory location itself. Prior declaration of variable and type of value before actually assigning it is must. Hence, name of variable is permanently bound with data type. Type of variable and data must match or else the compiler reports error.

Since variable in Python only serves as a label to an object, prior declaration it’s data type is not possible and hence not required. In Python, the data assigned to variable decides its data type and not the other way round.

type() is another built-in function in Python. It returns the data type (class) of object. Let us define a ‘invoiceno’ variable to store reference to an integer. The type() function tells us that it stores object of int type.

In  [8]   :  invoiceno=1256
In  [9]   :  type(invoiceno)
Out [9] :  int

However, we can use same name (invoiceno) to store reference to a string object in it. The type(invoiceno) will now be str. Now the Python interpreter won’t object if same variable is used to store reference to object of another type.

n  [10]    : invoiceno="Sept/2018/1256"
In  [11    : type(invoiceno)
Out [11] : str

Above example clearly shows that type of variable changes dynamically as per the object whose reference has been assigned to it.

Mutability of Objects

Objects of above data types are stored in computer’s memory. Some type of objects can be modified after creation, but others can’t be altered once they are created in the memory.

Number objects, strings, and tuple objects are immutable which means their contents can’t be altered after creation.

If some numeric variable is assigned a different value, it in fact is pointing to different object. The id() function will confirm this:

In [12] :a=10
In [13] :id(a)
Out [13] : 1403481440
In [14] :a=20
In [15] :id(a)
Out [15] :1403481760

Here, the variable ‘a’ is just pointing towards new object (20) at different location. The object at earlier object(10) is not modified.

The string and tuple objects are sequences. If we try to modify any item or try to insert/delete new item in it, it is not allowed – thus confirming that they are immutable.

In [16] : word="computer"
char=word[2]
In [17] : char
Out [17] : m
In [18] : word[2]="z"
Out [18] : ---------------------------------------------------------------------------
           TypeError                                    Traceback (most recent call last)
          <ipython-input-18-293b5c6cc0bd> in <module>()
           ----> 1 word[2]="z"
           TypeError: 'str' object does not support item assignment

On the other hand, items in List or Dictionary object can be modified. It is possible to add, delete, insert, and rearrange items in a list or dictionary. Hence they are mutable objects.

In [19]  :numbers=[10,12,14] #list object
             marks={1:50, 2:60, 3:70} #dictionary
In [20]  :numbers[1]=20 #change value at index 1 - index count starts from 0
             marks[2]=100 # change value of key=2
In [21]  :numbers
Out [21]:[10, 20, 14]
In [22]   :marks
Out [22]:{1: 50, 2: 100, 3: 70}

input() function

User interacts with Python program mainly using two built-in functions. The input() function reads the data from standard input device i.e. keyboard as a string object. It can be referred to by a variable having suitable name. Signature of input() function is as follows:

var = input(prompt=None)

The prompt is an optional string. If given, it is printed before reading input.

In [*] : price=input("Enter the price ")
Enter the price 50

Enter the data in front of the prompt – ‘Enter the price’ and press Enter. Here variable ‘price’ refers to the object created. We can check the value of the variable by just typing its name in the input cell.

In  [24]   : price
Out [24] : 50

print() function

This built-in function is the default output statement in Python. It displays value of any Python expression on the Python shell. More than one expressions can be displayed by single print() function by separating them with comma (',') 

In  [25] : rad=5
           area=3.142*5*5
In  [26] : print ("radius=",rad, "area=",area)
Out [26] : radius= 5 area= 78.55

To use separator character between expressions define sep parameter. In following example ‘=’ is defined as sep parameter 

In  [27]   :print ("radius",rad, "area",area, sep="=")
Out [27] :radius= 5 area= 78.55

By default, a newline character is automatically issued at the end of print() output. To change it to other value use end parameter. In following code end parameter is defined as " ".As a result, output of next print() will not start with new line but in continuation of first print() statement.

In  [28] : print ("radius:",rad, end=" ")
           print ("area:",area)
Out [28] : radius: 5 area: 78.55

In this chapter we learned about data types and variables in Python. Python variables are dynamically typed. Numbers, string and tuple objects are immutable where as list and dictionaries are mutable. Python’s built-in functions input() and print() read user input and display output respectively.

In the next chapter, numeric data types will be discussed in more details.