Python lec1

Swarup Kr Ghosh
MIS Group
IIM Calcutta
swarupg1@gmail.com

 History
 Why is it called Python?
 Features and Philosophy
 Installing and Running of Python
 Applications
 Who uses python today?
 Python Interactive Shell
 Basic data types and operator on Python
4/5/2015 2Swarup Kr Ghosh

 Its Implementation was started in December 1989 in
CWI ( Centrum Wiskunde & Informatica) in
Netherlands
 Invented by Guido van Rossum, early 90s (Feb‟91)
 It is successor of ABC Programming Language
 Python 2.0 was released in October 2000, with
many new features including a full garbage
collector and Unicode
 Python 3.0 was released in December 2008.
 Open sourced from the beginning.

 Name should be short, unique, interesting and
something mysterious
 A published scripts from ”Monty Python‟s Flying
Circus”
◦ a BBC comedy series from the seventies
 So the language called Python

“Python is an experiment in
how much freedom
programmers need. Too
much freedom and nobody
can read another's code; too
little and expressive-ness is
endangered.”
- Guido van Rossum

 Open Source
 Coherence
◦ not hard to read, write and maintain
 power
 scope
◦ rapid development + large systems
 objects
 integration
◦ hybrid systems

 Scripting-Extension Language
◦ Object-Oriented scripting language
 Class, Object (instances of classes), Encapsulation, Abstraction, Inheritance,
Polymorphism
 Multi paradigm language
◦ Object Oriented, Structure Programming, Functional Programming
 Classes, module and exception
 Runs on many different Operating System
◦ No compiling and linking
 Simple, shorter and more flexible
◦ No type declarations
 Automatic memory management
◦ Garbage collection

 Fewer restriction and rules
◦ Without using brackets
 Interactive and dynamic in nature
◦ Run time program construction
 System tools, GUIs, persistence, databases
 Modules and package
◦ Code can be grouped
 IDLE
◦ Bundled development environment
 elements from C++, Modula-3 (modules), ABC
 same family as Perl, Tcl, Scheme, REXX, BASIC dialects

 Python is pre-installed on most Unix systems, including
Linux and MAC OS X
 The pre-installed version may not be the most recent
one (2.7.9 and 3.4.3 as of July‟14)
 Download from http://python.org/download/
 Python comes with a large library of standard modules
 There are several options for an IDE
◦ IDLE – works well with Windows
◦ Emacs with python-mode or your favorite text editor

 IDLE is an Integrated Development Environment for Python, typically
used on Windows
 Multi-window text editor with syntax highlighting, auto-completion,
smart indent and other.
 Python shell with syntax highlighting
 Integrated debugger with
stepping, persistent
break points, and call stack
visibility

 Substitute of C, C++, C#, Objective C, Java
 Serve as scripting language
◦ Web application
 Data mapper
 Text mining
◦ NLP
 Used in AI Programming (Prolog, Exsys Corvid)
 Bioinformatics
◦ Using library Biopython and Astropy
 Scientific and Mathematical computing
◦ Using library NumPy, SciPy, Matplotlib etc
 Information security
 Image and video processing

 Google: web search system & app engine web.
 You Tube video sharing service.
 ‘Bit Torrent’ peer-to-peer file sharing.
 ‘Maya’ 3D modeling and animation system.
 NASA uses python for cryptography & intelligence
system.
 Intel, Cisco, Hewlett-Packard, Seagate, Qualc-
omm, and IBM for Hardware testing.
 ‘iRobot‟ uses Python to develop commercial and
military robotic devices.

 Learning Python by Mark Lutz, 5th Edition
 Python Essential by David Beazley
 A Python Book: Beginning Python, Advanced
Python, and Python Exercises by Dave Kuhlman
 https://wiki.python.org/moin/PythonBooks
 https://www.python.org/about/gettingstarted/
 http://www.learnpython.org/
 http://www.tutorialspoint.com/python/

Python 3.4.2 (v3.4.2:ab2c023a9432, Oct 6 2014, 22:15:05) [MSC v.1600
32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
 Python prompts with „>>>‟
 To exit Python: CTRL-D
You can type things directly into a running Python session:
>>> a=7
>>> a
7
>>> b=8
>>> b
8
>>> a+b
15
>>>

>>> 2+3*4
14
>>> 2**8
256
>>> print(2**8)
256
>>> print(2**100)
1267650600228229401496703205376
>>>print “Hello world”
Hello world
>>> a="Hello world"
>>> a
'Hello world'
>>> len(a) #„len‟- Length of String
11

>>> help(len)
Return the number of items of a sequence or collection.
Similarly >>>help(exit)
>>> name="Andrew"
>>> name=name+'!!!!'
>>> print("Hello", name)
Hello Andrew!!!!

Object Type Examples literals/ creation
Numbers 1234, 3.141, 2+3j, 001101, Decimal(), Fraction()
Strings „Spam‟, “Bob‟s”, b'ax01c„, u'spxc4m„(unicode)
Lists [1,[2,three],4.5], list(range(10))
Tuples (1, „spam‟, 4, „U‟), tuple(„spam‟)
Dictionaries {„user‟: „scott‟, „pswd‟:12345}, dict=(hours=10)
Files Open(„wave.txt‟), open(r 'C:bin', 'wb')
Sets set('abc'), {'a', 'b', 'c'}
Other Data type Boolean

 Arithmetic Operators: +, - ,* ,/,//, %
◦ Special use of „+’ for string concatenation
◦ Special use of „*’ for string repetition
◦ Special use of „–’ for set difference
◦ Special use of % for string formatting (as with printf in C)
◦ „//‟ use for floor division
 Assignment: = and comparison ==
 Logical operators are words (and, or, not)
 The basic printing command is print
 The first assignment to a variable creates it
◦ Variable types don‟t need to be declared
◦ Python figures out the variable types on its own

 Integers (default for numbers)
z = 5+2 # Answer is 7
z=5%2 # Answer is 1
z=5//2 # Answer is 2
 Floats
x = 5/2 # Answer is 2.5
 Strings
◦ Can use “” or „‟ to specify
◦ “abc” „abc‟ (Same thing)
 Unmatched can occur within the string
“matt‟s”
 Use triple double-quotes for multi-line strings or strings
than contain both „and “ inside of them:
“““a„b“c”””

 Integer, float, fraction, complex number, binary, octal,
hexadecimal
>>> 3.1415 * 2
6.283
 Module: just package of additional tool
◦ Math()
>>> import math
>>> math.pi #pi is method
3.141592653589793
>>> math.sqrt(85)
9.219544457292887
◦ Random()
>>> import random
>>> random.random()
0.7082048489415967
>>> random.choice([1, 2, 3, 4])
1
Methods: sqrt(), pow(), round(), trunc(), floor()

Operators Symbols
Arithmetic: +, -, *, /, **, //, %
Logical: and, or, not
Relational: >, <, >=, <=, ==, !=
Bitwise: &, |, ^, ~
Shifting: << (LS), >> (RS)
Membership X in y, x not in y
Object identity X is y, x is not y
Slicing X[i:j:k]
Call(fun, method, class) X(….)
Tuple ( )
List [ ]
Dictionary { }

 E.g. 2+3J
>>> 1J*1J
(-1+0j)
>>> 2+3J*3
(2+9j)
>>> (2+3J)*3
(6+9j)
>>>

 Binary: 0b01010, 0b10001, 0b111111
 Octal: 0o172, 0o03507, 0o53702
 Hexa: 0xFF, 0xff, 0x1abc
>>> 0b0010
2
>>> 0o145
101
>>> 0o172
122
>>> 0xff
255
>>> 0xFF
255
>>> 0x1abc
6844

>>> 0o1,0o20,0o377
(1, 16, 255)
>>> 0b01, 0b10000,0b1111111
(1, 16, 127)
>>> oct(64),bin(64),hex(64)
('0o100', '0b1000000', '0x40')
>>> int('64'), int('100',8),int('40',16),int('1000000',2)
(64, 64, 64, 64)
>>> '{0:o}, {1:x}, {2:b}'.format(64, 64, 64)
'100, 40, 1000000'
>>> '%o, %x, %x, %X' % (64, 64, 255, 255)
'100, 40, ff, FF„
>>> x=0xfffffff #By using method
>>> x
268435455
>>> bin(x)
'0b1111111111111111111111111111'
>>> oct(x)
'0o1777777777'

 Fraction: Numerator, denominator (x/y)
 Module: fractions
>>>from fractions import Fraction
>>> Fraction(2,3)
Fraction(2, 3)
>>> y=Fraction(4,6)
>>> print(y)
2/3
>>> a=Fraction(1,3) #operations on fractions
>>> b=Fraction(2,3)
>>> a+b
Fraction(1, 1)
>>> a-b
Fraction(-1, 3)
>>> a/b
Fraction(1, 2)

>>> Fraction(6,12)
Fraction(1, 2)
# automatically simplifed
>>> Fraction('.25')
Fraction(1, 4)
>>> Fraction('1.25')
Fraction(5, 4)
>>> Fraction('.25')+Fraction('1.25')
Fraction(3, 2)
>>> Fraction(5,0)
Traceback (most recent call last):
File "<pyshell#52>", line 1, in <module>
Fraction(5,0)
File "C:Python34libfractions.py", line 167, in __new__
raise ZeroDivisionError('Fraction(%s, 0)' % numerator)
ZeroDivisionError: Fraction(5, 0)

 Precision and scale:
>>> 1/3
0.3333333333333333
>>> from decimal import Decimal
>>> 1/3
0.3333333333333333
>>> import decimal
>>> decimal.getcontext().prec=2
>>> Decimal(1)/Decimal(3)
Decimal('0.33')
>>> (1/3)+(6/12)
0.8333333333333333
>>> decimal.Decimal(str(1/3)) + decimal.Decimal(str(6/12))
Decimal('0.83')

 Module: set
>>> x=set('abcde')
>>> y=set('bdxyz')
>>> x
{'a', 'd', 'b', 'c', 'e'}
>>> y
{'x', 'd', 'b', 'z', 'y'}
>>> x|y #Union
{'d', 'e', 'y', 'c', 'x', 'a', 'b', 'z'}
>>> x&y # Intersection
{'d', 'b'}
>>> x-y # Set Difference
{'a', 'e', 'c'}
>>> x^y # Symmetric difference
{'e', 'y', 'c', 'x', 'a', 'z'}
>>> x>y,x<y #Superset, Subset
(False, False)

 Different way of set operations:
>>> s=set('spam')
>>> s
{'p', 's', 'a', 'm'}
>>> s={'s','p','a','m'}
>>> s
{'m', 'a', 'p', 's'}
>>> s.add('alot') # Add members in set
>>> s
{'m', 'a', 'p', 's', 'alot'}
>>> {1, 2, 3}.union([3, 4])
{1, 2, 3, 4}
>>> {1, 2, 3}.union({3, 4})
{1, 2, 3, 4}
>>> {1, 2, 3}.union(set([3, 4]))
{1, 2, 3, 4}
>>> {1, 2, 3}.intersection((1, 3, 5))
{1, 3}
>>> {1, 2, 3}.issubset(range(-5, 5))
True

Different way of set operations:
>>>{x**2 for x in [1,2,3,4]}
{16, 1, 9, 4}
>>> {x for x in 'spam'} # Same as: set('spam')
{'m', 's', 'p', 'a'}
>>> {c * 4 for c in 'spam'} # Set of collected expression
{'pppp', 'aaaa', 'ssss', 'mmmm'}
>>> {c * 4 for c in 'spamham'}
{'pppp', 'aaaa', 'hhhh', 'ssss', 'mmmm'}
>>> S = {c * 4 for c in 'spam'}

>>> x = 4.5
>>> y = x
>>> y += 3
>>> x
4.5
>>> y
7.5
x 4.5
y
x 4.5
y 7.5

 Whitespace is meaningful in Python:
especially indentation and placement of newlines
 Use a newline to end a line of code
◦ Use when must go to next line prematurely
 No braces { } to mark blocks of code in Python
◦ Use consistent indentation instead
◦ The first line with less indentation is outside of the block
◦ The first line with more indentation starts a nested block
 Often a colon (:) appears at the start of a new
block.
E.g. for function and class definitions.

 Binding a variable in Python means setting a name to
hold a reference to some object
◦ Assignment creates references, not copies
 Variable creation:
◦ A variable (i.e., name), like „a‟, is created when code first
assigns it a value.
 Variable types:
◦ A variable never has any type information or constraints
associated with it. The notion of type lives with objects, not
names
◦ Variables are generic in nature
 Variable use:
◦ When a variable appears in an expression, it is immediately
replaced with the object that it currently refers to

 Names in Python do not have an intrinsic type, objects
have types
◦ Python determines the type of the reference
automatically based on the data object assigned to it.
 You create a name the first time it appears on the left
side of an assignment expression:
x = 3
 A reference is deleted via garbage collection after any
names bound to it have passed out of scope

 If you try to access a name before it‟s been
properly created you‟ll get an error.
>>> y
Traceback (most recent call last):
File "<pyshell#16>", line 1, in -toplevely
NameError: name „y' is not defined
>>> y = 3
>>> y
3

 You can also assign to multiple names at the
same time
>>> x, y = 2, 3
>>> x
2
>>> y
3

 Names are case sensitive and cannot start with a
number
 Contain letters, numbers, and underscores
◦ Bob, Bob _, bob _2, _bob_, bob_2, bob
 There are some reserved words:
and, assert, break, class, continue, def, del, elif,
else, except, exec, finally, for, from, global, if,
import, in, is, lambda, not, or, pass, print, raise,
return, try, while

 Start comments with #, rest of line is ignored
 Can include a “documentation string” as the first
line of a new function or class you define
 Development environments, debugger, and other
tools use it
def my_function(x, y):
“““This is the docstring. This
function does blah blah blah.”””
# The code would go here...

 Assignment manipulates references:
◦ x = y does not make a copy of the object y references
◦ x = y makes x reference the object y references
 There is a lot going on when we type:
x = 3
◦ First, an integer 3 is created and stored in memory
◦ A name x is created
◦ An reference to the memory location storing the 3 is then
assigned to the name x

 So: When we say that the
value of x is 3
 we mean that x now
refers to the integer 3

 The data 3 we created is of type integer. In Python,
the data types integer, float, and string (and tuple) are
immutable
 This doesn‟t mean we can‟t change the value of „a‟,
i.e. change what „a‟ refers to …
 For example, we could increment a:
>>> a = 1
>>> b=a
>>> a = a + 1
>>> print a
2
>>> print b
1

a
1
b
a
1b
a = 1
a = a+1
b = a
a
1
2
old reference deleted
by assignment (a=...)
new int object created
by add operator (1+1)

n -> newline
t -> tab
-> backslash
w -> word character
d -> digit
s -> white space
S -> non-white space

>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__', 'math', 'random']
>>>dir(re)
['A', 'ASCII', 'DEBUG', 'DOTALL', 'I', 'IGNORECASE', 'L', 'LOCALE',
'M', 'MULTILINE', 'S', 'Scanner', 'T', 'TEMPLATE', 'U', 'UNICODE',
'VERBOSE', 'X', '_MAXCACHE', '__all__', '__builtins__',
'__cached__', '__doc__', '__file__', '__loader__', '__name__',
'__package__', '__spec__', '__version__', '_alphanum_bytes',
'_alphanum_str', '_cache', '_cache_repl', '_compile',
'_compile_repl', '_expand', '_pattern_type', '_pickle', '_subx',
'compile', 'copyreg', 'error', 'escape', 'findall', 'finditer', 'fullmatch',
'match', 'purge', 'search', 'split', 'sre_compile', 'sre_parse', 'sub',
'subn', 'sys', 'template']

Python lec1

More Related Content

What's hot (20)

Similar to Python lec1 (20)

Recently uploaded (20)

Python lec1