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]