Introduction to Python & its Data types

Introduction to Python Scripting Language

Python is a high-level, interpreted scripting language developed in the late 1980s by Guido van Rossum at the National Research Institute for Mathematics and Computer Science in the Netherlands. The initial version was published at the alt.sources newsgroup in 1991, and version 1.0 was released in 1994.
Python 2.0 was released in 2000, and the 2.x versions were the prevalent releases until December 2008. At that time, the development team made the decision to release version 3.0, which contained a few relatively small but significant changes that were not backward compatible with the 2.x versions. Python 2 and 3 are very similar, and some features of Python 3 have been backported to Python 2. But in general, they remain not quite compatible.
Both Python 2 and 3 have continued to be maintained and developed, with periodic release updates for both. As of this writing, the most recent versions available are 2.7.15 and 3.6.5. However, an official End Of Life date of January 1, 2020 has been established for Python 2, after which time it will no longer be maintained. If you are a newcomer to Python, it is recommended that you focus on Python 3, as this tutorial will do.
Python is still maintained by a core development team at the Institute, and Guido is still in charge, having been given the title of BDFL (Benevolent Dictator For Life) by the Python community. The name Python, by the way, derives not from the snake, but from the British comedy troupe Monty Python’s Flying Circus, of which Guido was, and presumably still is, a fan. It is common to find references to Monty Python sketches and movies scattered throughout the Python documentation.



Python Data Types

Variables can hold values of different data types. Python is a dynamically typed language hence we need not define the type of the variable while declaring it. The interpreter implicitly binds the value with its type.
Python enables us to check the type of the variable used in the program. Python provides us the type() function which returns the type of the variable passed.
Consider the following example to define the values of different data types and checking its type.

  1.  A=10  
  2. b="Hi Python"  
  3. c = 10.5  
  4. print(type(a));   
  5. print(type(b));   
  6. print(type(c));   

Output:
<type 'int'>
<type 'str'>
<type 'float'>

Standard data types

A variable can hold different types of values. For example, a person's name must be stored as a string whereas its id must be stored as an integer.
Python provides various standard data types that define the storage method on each of them. The data types defined in Python are given below.
  1. Numbers
  2. String
  3. List
  4. Tuple
  5. Dictionary

Numbers

Number stores numeric values. Python creates Number objects when a number is assigned to a variable. For example;
  1. a = 3 , b = 5  #a and b are number objects  
Python supports 4 types of numeric data.
  1. int (signed integers like 10, 2, 29, etc.)
  2. long (long integers used for a higher range of values like 908090800L, -0x1929292L, etc.)
  3. float (float is used to store floating point numbers like 1.9, 9.902, 15.2, etc.)
  4. complex (complex numbers like 2.14j, 2.0 + 2.3j, etc.)
Python allows us to use a lower-case L to be used with long integers. However, we must always use an upper-case L to avoid confusion.
A complex number contains an ordered pair, i.e., x + iy where x and y denote the real and imaginary parts respectively).

String

The string can be defined as the sequence of characters represented in the quotation marks. In python, we can use single, double, or triple quotes to define a string. 
String handling in python is a straightforward task since there are various inbuilt functions and operators provided. 
In the case of string handling, the operator + is used to concatenate two strings as the operation "hello"+" python" returns "hello python".
The operator * is known as repetition operator as the operation "Python " *2 returns "Python Python ".
The following example illustrates the string handling in python.
  1. str1 = 'hello javatpoint' #string str1  
  2. str2 = ' how are you' #string str2  
  3. print (str1[0:2]) #printing first two character using slice operator  
  4. print (str1[4]) #printing 4th character of the string  
  5. print (str1*2) #printing the string twice  
  6. print (str1 + str2) #printing the concatenation of str1 and str2  
Output:
he
o
hello javatpointhello javatpoint
hello javatpoint how are you

List

Lists are similar to arrays in C. However; the list can contain data of different types. The items stored in the list are separated with a comma (,) and enclosed within square brackets []. 
We can use slice [:] operators to access the data of the list. The concatenation operator (+) and repetition operator (*) works with the list in the same way as they were working with the strings.
Consider the following example.
  1. l  = [1, "hi", "python", 2]  
  2. print (l[3:]);  
  3. print (l[0:2]);  
  4. print (l);  
  5. print (l + l);  
  6. print (l * 3);   
Output:
[2]
[1, 'hi']
[1, 'hi', 'python', 2]
[1, 'hi', 'python', 2, 1, 'hi', 'python', 2]
[1, 'hi', 'python', 2, 1, 'hi', 'python', 2, 1, 'hi', 'python', 2]

Tuple

A tuple is similar to the list in many ways. Like lists, tuples also contain the collection of the items of different data types. The items of the tuple are separated with a comma (,) and enclosed in parentheses (). 
A tuple is a read-only data structure as we can't modify the size and value of the items of a tuple.
Let's see a simple example of the tuple.
  1. t  = ("hi", "python", 2)  
  2. print (t[1:]);  
  3. print (t[0:1]);  
  4. print (t);  
  5. print (t + t);  
  6. print (t * 3);   
  7. print (type(t))  
  8. t[2] = "hi";  
Output:
('python', 2)
('hi',)
('hi', 'python', 2)
('hi', 'python', 2, 'hi', 'python', 2)
('hi', 'python', 2, 'hi', 'python', 2, 'hi', 'python', 2)
<type 'tuple'>
Traceback (most recent call last):
  File "main.py", line 8, in <module>
    t[2] = "hi";
TypeError: 'tuple' object does not support item assignment

Dictionary

Dictionary is an ordered set of a key-value pair of items. It is like an associative array or a hash table where each key stores a specific value. Key can hold any primitive data type whereas value is an arbitrary Python object. 
The items in the dictionary are separated with the comma and enclosed in the curly braces {}.
Consider the following example.
  1. d = {1:'Jimmy', 2:'Alex', 3:'john', 4:'mike'};   
  2. print("1st name is "+d[1]);  
  3. print("2nd name is "+ d[4]);  
  4. print (d);  
  5. print (d.keys());  
  6. print (d.values());  
Output:
1st name is Jimmy
2nd name is mike
{1: 'Jimmy', 2: 'Alex', 3: 'john', 4: 'mike'}
[1, 2, 3, 4]
['Jimmy', 'Alex', 'john', 'mike']

Comments

Post a Comment