Python Facts
Python2 is backward compatible; whereas Python3 is backward
INCOMPATIBLE.
Python supports OOPs concepts. But, in python, both private
and protected modes are having same authority. This is the
only limitation in python becoming complete OOP language.
Python interpreter generates byte-code, so the python
applications are platform-independent.
Python runs faster than java, but slower than C language.
Python was written in C language.
Pre/Post increment/decrement like x++,x--,--x,++x, are INVALID
in python
Compound operations such as +=,-=,*=,/= are VALID in Python
Python is case-sensitive i.e., variable “work” is different
from variable “Work”, or “WORK”
Using underscores (eg:price_at_opening) and Camel-casing
(eg:PriceAtOpening)is VALID
Multiple Assignments are VALID in python.
Eg: x=y=z=1
Parallel assignment (or unpacking) is POSSIBLE in python
Eg: a,b=1,2
(x,y,z)=1,2,3
But,(x,y,z)=12 is not possible.
In python 2, Print is a statement. In python 3, print is a
function.
To use print() function of python 3 in python2, place this
statement in the first lines of script:
from __future__ import print_function
= assignment operator
== Operator to check value equivalence
is Operator to check identity of objects; looks at object
level
in Operator to check identity of objects; looks at index
level
!= not-equal-to operator
<> not-equal-to operator. Available only in python2.
# comment operator in python; called as
octothorpe/pound/hash/mesh
>>> Input operator, shows readiness of interpreter. Called as
chevron
^ bit-wise operator. Not power operator. Called as caret
; used to separate TWO or more statements in the same line.
„„„ ‟‟‟ or “““ ””” docstrings. Used for multiple-line
comment in python scripts. Differs from using #. Appears
in the output. Useful, especially, in modules.
#! Called shebang. Used as the first character in python
script.
\ line-continuation operator. Used when a statement spans
more than one line.
Eg: print “Udhay\
Prakash”
() used for tuples
[] used for lists
{} used for dictionaries
([]) used for sets
Switch-case condition is not defined in python. Instead, If-
elif-else ladder can be used. Also, dictionary of
functions can be used.
Eg:
>>> result={
... 'a':lambda x :x*5,
... 'b':lambda x:x+7,
... 'c':lambda x:x-2}
>>> result['b'](10)
17
Indentation is both boon and bane (for beginners) for python.
Use spaces instead of Tabs in scripts.
Eg:
>>> a=2
>>> a
2
>>> a=2
Traceback ( File "<interactive input>", line 1
a=2
^
IndentationError: unexpected indent
Running python with –t option prints warning messages when
tabs and spaces are mixed inconsistently within the same
program block.
Running python with –tt option turns these warning messages in
to TabError exception.
raw_input() takes any input as string type.
input() takes any input type dynamically.
&&,|| are defined operators in python
and boolean operator for AND operation
or boolean operator for OR operation
not Boolean operator for NOT operation
set operators
| union operator for sets
& intersection operator for sets
- Set difference operator
Eg: c=t-s# set c contains items in set t, but not in set s
^ Symmetric difference operator for sets
Eg: d=t^s # set d contains items in set t or set s, but
not common items in both.
bitwise Operators
& bit-wise AND operator
| bit-wise OR operator
^ bit-wise XOR operator
~ bit-wise invert operator. Eg: ~5 results in -6
Bit-wise invert of x is –(x+1)
>> left shift operator
Eg: 15>>1
7
Explanation: 15-1111 (in 8421 convention)
15>>1 means shifting one position left.
It becomes 0111 i.e., 7
<< right shift operator
** power of operator
/ division operator
// floor division operator (only in python3)
% modulo operator. Returns remainder of a division.
PEP8 suggests (not mandatory) for a white space around any
operator.
It is suggested to define default parameters in the last, for
functions.
By default, Python source files are treated as encoded in UTF-
8.
To use different encoding for source files, it must be
specified in the second line, after #! line, in the script.
Format: # -*- coding: encoding -*-
When you use Python interactively, it is frequently handy to
have some standard commands executed every time the
interpreter is started. You can do this by setting an
environment variable named PYTHONSTARTUP to the name of a file
containing your start-up commands. This is similar to the
.profile feature of the Unix shells.
range(init_value,final_value,step_size)returns integers from
init_value, till final_value, in steps of step_size. It
doesn’t include final_value. The step_size MUST be either
positive or negative integer; not a float value.
xrange() is same as range(); but, results in values only when
essential. Available only in python2.
Python supports range() data-type. So, xrange() is not
required.
{} are used to create both a dictionary type and set type.
Set contains only (unrepeated) elements; whereas dictionary
contains keys and elements. Keys can’t be repeated, but
elements in dictionary can be repeated.
Empty set must be created as var_name=set(), instead of
var_name={}. The later creates an empty dict type variable.
When the Python interpreter is invoked with -O flag, code
optimized .pyo files, are generated. This optimizer only
removes assert statements. When -O is used, all bytecode
is optimized; .pyc files are ignored and .py files are
compiled to optimized bytecode.
Similarly, passing two -O flags to the Python interpreter (-
OO) will cause the bytecode compiler to perform optimizations.
Currently only __doc__ strings are removed from the bytecode,
resulting in more compact .pyo files.
Only difference between .pyc and .pyo code is the speed with
which they are loaded.
The module compileall can create .pyc files (or .pyo files
when -O is used) for all modules in a directory.
One space will be added between arguments, when print
function/statement is used, in py3/py2 respectively.
Str.zfill() pads a numeric string on the left with zeros. It
understands both plus and minus signs.
Eg:
>>> '23'.zfill(6)
'000023'
>>> '-3.14'.zfill(6)
'-03.14'
>>> '-3.14'.zfill(8)
'-0003.14'
Str.format()
>> print "This is {} and {}".format('GOOD','BAD')
This is GOOD and BAD
>> print "This is {1} and {0}".format('GOOD','BAD')
This is BAD and GOOD
>>print "This {food} is {adjective}".format(food='RICE',adjective="THE BEST ")
This RICE is THE BEST
>>> ord('a')
97
>>> chr(97)
'a'
>>> '\u011f'
'ğ'
Hidden precision Limitation for python:
>>> 0.1+0.1
0.2
>>> 0.1+0.1+0.1
0.30000000000000004
>>> 0.1+0.1+0.1+0.1
0.4
It is recommended not to follow precision values.
Python can store any large number. Practically, it depends on
the system memory of the machine.
Float is not exact.
>>> 4294967296.0**2
1.8446744073709552e+19
>>> 4294967296**2
18446744073709551616
1.8446744073709552×1019 18446744073709552000- 18446744073709551616=384
Float can be accurate upto 17 significant figures.
floating point numbers have limits both in terms of the
largest and smallest numbers they can contain.
In total, floating point values have limited size and limited
precision.
Textual comparison
>>> 'cat'<'dog'#Alphabetic ordering
True
>>> 'Cat'<'cat'#Uppercase before lowercase
True
>>> 'Dog'<'cat'#All uppercase before lowercase
True
Note: Ordering text is called “collation”, and is a
complicated field. Python inequalities use Unicode character
numbers for collation.
Order of precedence for OPERATIONS:
From highest to least:
x**y -x +x x%y x/y x*y x-y x+y x==y x!=y x>=y x>y x<=y x<y
not x x and y x or y
>>> -3**2 #** has higher precedence, compared to -
-9
>>> (-3)**2
9
All the operators except ** are left-associated, that means that the application of the
operators starts from left to right.
Unpacking
>>> a,b=10,7
>>> (a,b)=(a+b,a-b)#tuples
>>> a,b
(17, 3)
>>> a,b=a+b,a-b #lists
>>> a,b
(20, 14)
Four spaces’ indentation indicates a “block” of code in
python. This can be observed in any for, while….blocks
The immutability of tuples means they’re faster than lists.
Lists
>>> l=[1,2,[3,4,[5,6,7]]]
>>> len(l)
3
No arithmetic operation can be performed between lists.
+ acts as a appending operator
>> a=[1,2]
>>> b=[2,3]
>>> a+b
[1, 2, 2, 3]
>>> a*3
[1, 2, 1, 2, 1, 2]
