INTRODUCTION
Python first appeared in 1991, and it has become one of the most popular interpreted programming languages. It’s often called as “Scripted languages” as it is used to quickly write small programs or scripts to automate tasks.
Among interpreted languages, for various historical and cultural reasons, Python has developed a large and active scientific computing and data analysis community. In the last 10 years, Python has gone from a bleeding-edge or “at your own risk” scientific computing language to one of the most important languages for data science, machine learning, and general software development in academia and industry.
Basics of Programming
Printing to the screen
The simplest way to produce output is using the print statement where you can pass more expressions separated by commas. This function converts the expressions you pass into a string and writes the result to standard output as follows
E.g.: print “roses are red,”,”sky is blue”
And the result produced on standard screen is as follows
roses are red, sky is blue
Python has two basic modes
- Interactive
- Script
Interactive
- It is a command line shells which gives immediate feedback, while running previous statements in active memory. i.e., as we add new line into the interpreter the program is evaluated both in part and in whole
- In interactive mode what we type is immediately run
- If you ever feel the need to play with new python statements of your own go to interactive statement and try them out
E.g.:
> 5
5
> print(5*7)
35
> “hello” * 4
‘hellohellohellohello’
> “hello”.__class__
<type ‘str’>
Script
- Invoking the interpreter with a script parameter begins execution of the script and continues until the script is finished.
- When the script is finished, the interpreter is no longer active.
- Python files have extension .py.
e.g.:
print “Hello, Python!”
Now, try to run this program as follows −
$ python test.py
This produces the following result −
Hello, Python!
VARIABLE TYPES
Variables
- Based on the data type of a variable we store integers, decimals and characters
- The equal sign(=) is used to assign values to the variables
- i.e., 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.
e.g.:
A = 100 # An integer assignment
distance = 1000.0 # A floating point
name = “John” # A string
print A
print distance
print name
In the above example A, distance and name are the names of the variables and 100, 1000.0, “john” are the integer, float and string values assigned to the variables.
Python allows us to assign single value to multiple names and it also allow us to assign multiple objects to multiple variables simultaneously.
e.g.;
x = y= z = 10
a,b,c = 1,2,”john”
STANDARD DATA TYPES
Since the data stored is of many types, Python has various standard data types that are used to define the operations possible on them and the storage method for each of them.
Python has five standard data types
- Number
- String
- List
- Tuple
- Dictionary
Number
Number objects are created when we assign a value to them
d = 1
a= 10
Python supports four different numerical types −
- int (signed integers)
- long (long integers, they can also be represented in octal and hexadecimal)
- float (floating point real values)
- complex (complex numbers)
e.g:
String
It’s a contiguous of characters represented in quotation marks. Python allows for either pairs of single or double quotes. 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.
e.g.:
str = ‘Hello World!’
print str # Prints complete string
print str[0] # Prints first character of the string
print str[2:5] # Prints characters starting from 3rd to 5th
print str[2:] # Prints string starting from 3rd character
print str * 2 # Prints string two times
print str + “TEST” # Prints concatenated string
List:
Lists are the most versatile of Python’s compound data types. A list contains items separated by commas and enclosed within square brackets ([]).The values stored in a list can be accessed using the slice operator ([ ] and [:]) with indexes starting at 0 in the beginning of the list and working their way to end -1. The plus (+) sign is the list concatenation operator, and the asterisk (*) is the repetition operator.
list = [ ‘abcd’, 786 , 2.23, ‘john’, 70.2 ]
tinylist = [123, ‘john’]
print list # Prints complete list
print list[0] # Prints first element of the list
print list[1:3] # Prints elements starting from 2nd till 4th
print list[2:] # Prints elements starting from 3rd element
print tinylist * 2 # Prints list two times
print list + tinylist # Prints concatenated lists
result −
[‘abcd’, 786, 2.23, ‘john’, 70.200000000000003]
abcd
[786, 2.23]
[2.23, ‘john’, 70.200000000000003]
[123, ‘john’, 123, ‘john’]
[‘abcd’, 786, 2.23, ‘john’, 70.200000000000003, 123, ‘john’]
Tuples
Tuple is sequence data type that is similar to the list. A tuple consists of a number of values separated by commas. tuples are enclosed within parentheses.
The main differences between lists and tuples are: Lists are enclosed in brackets ( [ ] ) and their elements and size can be changed, while tuples are enclosed in parentheses ( ( ) ) and cannot be updated. Tuples can be thought of as readonly lists
e.g.:
tuple = ( ‘abcd’, 786 , 2.23, ‘john’, 70.2 )
tinytuple = (123, ‘john’)
print tuple # Prints complete list
print tuple[0] # Prints first element of the list
print tuple[1:3] # Prints elements starting from 2nd till 3rd
print tuple[2:] # Prints elements starting from 3rd element
print tinytuple * 2 # Prints list two times
print tuple + tinytuple # Prints concatenated lists
result −
(‘abcd’, 786, 2.23, ‘john’, 70.200000000000003)
abcd
(786, 2.23)
(2.23, ‘john’, 70.200000000000003)
(123, ‘john’, 123, ‘john’)
(‘abcd’, 786, 2.23, ‘john’, 70.200000000000003, 123, ‘john’)
Dictionary
Python’s dictionaries work like associative arrays and consist of key-value pairs. A dictionary key can be almost any Python type, but are usually numbers or strings. Values, on the other hand, can be any arbitrary Python object.
Dictionaries are enclosed by curly braces ({ }) and values can be assigned and accessed using square braces ([]).
e.g.:
dict = {}
dict[‘one’] = “This is one”
dict[2] = “This is two”
tinydict = {‘name’: ‘john’,’code’:6734, ‘dept’: ‘sales’}
print dict[‘one’] # Prints value for ‘one’ key
print dict[2] # Prints value for 2 key
print tinydict # Prints complete dictionary
print tinydict.keys() # Prints all the keys
print tinydict.values() # Prints all the values
result −
This is one
This is two
{‘dept’: ‘sales’, ‘code’: 6734, ‘name’: ‘john’}
[‘dept’, ‘code’, ‘name’]
[‘sales’, 6734, ‘john’]
BASIC OPERATORS
Operators are constructs which can manipulate the values of operands.
e.g:10-5=5
here 10 and 5 are operands , – is an operator
In python we have the following operators
- Arithmetic Operators
- Comparison (Relational) Operators
- Assignment Operators
- Logical Operators
- Bitwise Operators
- Membership Operators
- Identity Operators
Arithmetic Operators
Arithmetic operators perform arithmetic calculations like addition, subtraction, multiplication, division, modulus etc,
x= 4
y= 5
print(x + y)
print(y – x )
print(x * y)
print(y % x)
print(x ** y)
Comparison (Relational) Operators
These operators compare values and determine the relation between two operand , hence its referred as relational operators.
<,>,<=,>=,<>,!=,== are the comparison operators
x = 4
y = 5
print((‘x > y is’,x>y))
Assignment Operators
These are used for assigning the values from right operand to the left operand
num1 = 4
num2 = 5
print((“Line 1 – Value of num1 : “, num1))
print((“Line 2 – Value of num2 : “, num2))
res = num1 + num2 res += num1
print((“Line 1 – Result of + is “, res))
Logical Operators
These are used for conditional statements like true or false. Logical operators of python are AND,OR and NOT.
a = True
b = False
print((‘a and b is’,a and b))
print((‘a or b is’,a or b))
print((‘not a is’,not a))
Bitwise Operators
Bitwise operator works on bits and performs bit by bit operation.
Assume if a = 60; and b = 13;
Now in binary format they will be as follows −
a = 0011 1100
b = 0000 1101
—————–
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
Membership Operators
These operators test for membership in a sequence such as list,tuple etc..
In , not in- gives result based on variables present or not.
x = 4
y = 8
list = [1, 2, 3, 4, 5 ];
if ( x in list ):
print(“Line 1 – x is available in the given list”)
else:
print(“Line 1 – x is not available in the given list”)
if ( y not in list ):
print(“Line 2 – y is not available in the given list”)
else:
print(“Line 2 – y is available in the given list”)
Identity Operators
It is used to compare the memory locations of two objects.
Is and isnot are the two identity operators
Operator is: It returns true if two variables point the same object and false otherwise
Operator is not: It returns false if two variables point the same object and true otherwise.
About Shwetha S:
Shwetha.S is M.Sc(Mathematics). She is working as Analyst Intern with Nikhil Guru Consulting Analytics Service LLP (Nikhil Analytics), Bangalore.
Be the first to comment on "BASICS OF PYTHON"