Python Programming

Course Code – ES303CSM

Unit-1

Python Basics

Objects – Python Objects

All Python objects have the following three characteristics:

1. an identity,
2. a type, and
3. avalue.

1. IDENTITY

Unique identifier that differentiates an object from all others.Using the id()
built-in function (BIF) any object's identifier can be obtained.

2. TYPE

You canuse the type() BIF to reveal the type of a Python object.type() actually
returns an object.

3. VALUE
Data item that is represented by an object.

Object Attributes
Attributes are accessed in the dotted attribute notation. The most familiar
attributes arefunctions and methods.

Objects withdata attributes include (but are not limited to):

i) classes,
ii) class instances,
iii) modules,
iv) complex numbers,and
v) files.

Standard Types
1. Numbers
i) Integer
a) Boolean
b) Long integer
ii) Floating point real number
iii) Complex number
2. String
3. List
4. Tuple
5. Dictionary

Other Built-in Types

1. Type
2. Null object
3. File
4. Set/Frozenset
5. Function/Method
6. Module
7. Class

1. i)Type Objects
You can findout the type of an object by calling type() with that object,

Example
>>>type(42)
<type 'int'>

ii)typeType Object
The type of all type objects is type.
Example
>>>type(type(42))
<type 'type'>

2.None, Python's Null Object

Python has a special type known as the Null object or NoneType. None value is
similar to the C value of NULL. None always evaluates to having a Boolean False
value.

Internal Types
The internal types are

1. Code
2. Frame
3. Traceback
4. Slice
5. Ellipsis
6. Xrange

1. Code Objects
Code objects are executable pieces of Python source that are byte-compiled.
Attribute of code object
The actual byte-compiled code as a code object is one attribute belonging to a
function.

2. Frame Objects
 These are objects representing execution stack frames in Python.
Attributes of frame objects
The attributes include a link to the previous stack frame, dictionaries for the
local and global namespaces, and the current instruction.

Accessing frame object

You can access a frame object is in a traceback object.
3. Traceback Objects
The traceback object holds the stack trace information for an exception and is
created when an exception occurs. If a handler is provided for an exception, this
handler is given access to the traceback object.
Example
If exceptions are not caught or "handled,"
the interpreter exits with some diagnostic information similar to the output
shown below:
Traceback (innermost last):
File "<stdin>", line N?, in ???
ErrorName: error reason

4. Slice Objects
Slice objects are created using the Python extended slice syntax.
This extended syntax allows for different types of indexing. Slice objects can
also be generated by the slice() BIF. These various types of indexing include
stride indexing, multi-dimensional indexing, and indexing using the Ellipsis type.

Example
i) Using stride index
>>> foostr = 'abcde'
>>> foostr[::-1]
'edcba'
>>> foostr[::-2]
'eca'
>>> foolist = [123, 'xba', 342.23, 'abc']
>>> foolist[::-1]
['abc', 342.23, 'xba', 123]

ii) using multi-dimensional indexing

sequence [start1 : end1, start2 : end2]

iii) indexing using the Ellipsis type

sequence [..., start1 : end1]

5. Ellipsis Objects
Ellipsis objects are used to represent the actual ellipses in the slice syntax
(...).

6. XRange Objects
XRange objects are created by the BIF xrange().It is used when memory is
Limited.
 Standard Type Operators

1. Object Value Comparison

Comparison operators are used to determine equality of two data values
between members of the same type. Comparisons yield Boolean TRue or
False values.

Object Value Comparison table

Operator Function
expr1 < expr2 expr1 is less than expr2
expr1 > expr2 expr1 is greater than expr2
expr1 <= expr2 expr1 is less than or equal to expr2
expr1 >= expr2 expr1 is greater than or equal to expr2
expr1 == expr2 expr1 is equal to expr2
expr1 != expr2 expr1 is not equal to expr2 (C-style)
expr1 <> expr2 expr1 is not equal to expr2

Example
>>> 2 == 2
True
>>> 2.46 <= 8.33
True
>>> 'abc' == 'xyz'
False

2. Object Identity Comparison

Python supports directly comparing objects themselves.

Object Identity comparison table

Operator Function
obj1 is obj2 obj1 is the same object as obj2
obj1 is not obj2 obj1 is not the same object as obj2

Example
foo1 and foo2 reference the same object
foo1 = foo2 = 4.3

3. Boolean
Boolean logical operators are and, or, and not. All are python keywords. The not
operator has the highest precedence.

Operator Function
not expr Logical NOT of expr
expr1 and expr2 Logical AND of expr1 and expr2
expr1 or expr2 Logical OR of expr1 and expr2
Example
>>> x, y = 3.1415926536, -1024
>>> not (x is y)
True
>>> (x < 5.0) and (y > 2.718281828)
False
>>> (x < 5.0) or (y > 2.718281828)
True

Standard Type Built-in Functions

Python provides some built-in-functions such as
1. cmp(),
2. repr(),
3. str(),
4. type()
Standard Built-in Function table

Function Operation

Compares obj1 and obj2, returns integer i where:

i < 0 if obj1 < obj2
i > 0 if obj1 > obj2
cmp(obj1, obj2) i == 0 if obj1 == obj2
repr(obj) or `obj` Returns evaluatable string representation of obj
str(obj) Returns printable string representation of obj
type(obj) Determines type of obj and return type object

1. cmp()
The cmp() BIF CoMPares two objects, say, obj1 and obj2. It returns a negative
number (integer) if obj1 is less than obj2, a positive number if obj1 is greater
than obj2, and zero if obj1 is equal to obj2.

Example

>>> a, b = -4, 12
>>> cmp(a,b)
-1
>>> cmp(b,a)
1
>>> b = -4
>>> cmp(a,b)
0

2. repr()
repr() REPResentation BIFs or the single back or reverse quote operator ( `` )
replicates elements of a list.

Example

>>> repr([0, 5, 9, 9])

'[0, 5, 9, 9]'
>>>
>>> `[0, 5, 9, 9]`
'[0, 5, 9, 9]'

3. str()

str() has the job of delivering a "printable" string representation of an object.

Example
>>> str(1)
'1'
>>> str(2e10)
'20000000000.0'
>>>
>>> str([0, 5, 9, 9])
'[0, 5, 9, 9]'

4. type()
type() takes an object and returns its type. The return value is a
type object.

Syntax
type(object)

Example

>>> type(4) # int type

<type 'int'>
>>>
>>> type('Hello World!') # string type
<type 'string'>
>>>
>>> type(type(4)) # type type
<type 'type'>

Standard Type Operators and Built-in Functions Table

Operator/
Function Description Result
cmp(obj1, obj2) Compares two objects Int
repr(obj) String representation Str
str(obj) String representation Str
Determines object
type(obj) type Type

Categorizing the Standard Types

1. Storage Model
We can categorize the types is by how many objects can be stored in an object
of this type.

i) Atomic or Scalar storage

A type which holds a single literal object we will call atomic or scalar storage.

ii) Container storage

A type which can hold multiple objects we will refer to as container storage.
Container objects are also referred to as composite or compound objects.

Types Categorized by the Storage Model

Storage Model Category Python Types That Fit Category

Numbers (all numeric types),
Scalar/atom strings (all are literals)
Container Lists, tuples, dictionaries

2. Update Model
Certain types allow their values to be updated and others do not.

i) Mutable objects

Mutable objects are those whose values can be changed.

ii) Immutable objects

Immutable objects are those whose values cannot be changed.

Types Categorized by the Update Model

Update Model Category Python Types That Fit Category

Mutable Lists, dictionaries
Immutable Numbers, strings, tuples

3. Access Model
We use the access model to access the values of our stored data. There are
three categories under the access model: direct, sequence, and mapping.

i) Direct types

Direct types indicate single-element, non-container types.

Examples
All numeric types fit into this category.

ii) Sequence types

 Sequence types are those whose elements are sequentially accessible via
index values starting at 0. Accessed items can be either single elements or in
groups, better known as slices.

Examples

Types that fall into this category include strings, lists, and tuples.

iii) Mapping types

Mapping type elements (values) are unordered and accessed with a key, thus
making mapping types a set of hashed key-value pairs.

Examples
Dictionaries

Types Categorized by the Access Model

Access Model Category Types That Fit Category

Direct Numbers
Sequence Strings, lists, tuples
Mapping Dictionaries

Categorizing the Standard Types

Storage Update Access

Data Type Model Model Model
Numbers Scalar Immutable Sequence
Strings Scalar Immutable Sequence
Lists Container Mutable Sequence
Tuples Container Immutable Sequence
Dictionarie
s Container Mutable Mapping

Unsupported Types
A list of types that are not supported by Python.

1. char or byte

Python does not have a char or byte type to hold either single character or 8-
bit integers.

2. pointer
 Since Python manages memory for you, there is no need to access pointer
addresses.

3. int versus short versus long

Python's plain integers are the universal "standard" integer type, obviating
the need for three different integer types, e.g., C's int, short, and long. You only
need to use a single type, the Python integer.

4. float versus double

Python does not support a single-precision floating point ( float) type.
Python's float type is actually a C double-precision (double) type.

Numbers
Introduction to Numbers

Numbers provide literal or scalar storage and direct access. A number is also
an immutable type, meaning that changing or updating its value results in a
newly allocated object.

How to Create and Assign Numbers (Number Objects)

Creating numbers is as simple as assigning a value to a variable:

anInt = 1
aLong = -9999999999999999L
aFloat = 3.1415926535897932384626433832795
aComplex = 1.23+4.56J

How to Update Numbers