Python Programming

Unit 1: Python Programming

Python Basics
Python combines features of C and Java, offering concise code and object orientation.
Developed by Guido Van Rossum in 1989, officially released on February 20, 1991.
Features:
Simple and easy to learn.
High-level language using English words.
Dynamically typed (no need to declare types).
Platform independent (byte code runs on any OS).
Portable (same result on any computer).
Procedure and object-oriented.
Freeware and open source.
Interpreted and byte-compiled.
Extensible and embedded.
Huge library and scripting language.
Database connectivity and scalable.
Statements and Syntax:
Comments begin with #.
Continuation using \.
Suites (code blocks) delimited by indentation.
Multiple statements on a line using ;.
Modules are Python scripts.
Variable Assignment:
= is the assignment operator.
Multiple assignment: x = y = z = 1.
Multiple objects to multiple variables: x, y, z = 1, 2, 'abc'.
Swapping variables: (x, y) = (y, x).
Identifiers:
Must start with a letter or underscore _.
Case-sensitive.
Cannot use reserved words (keywords).
Keywords:
Examples: True, False, None, and, or, not, if, else, while, for, import, from, class, def, etc.
Built-ins: Names available at all levels of Python code.
Special Underscore Identifiers:
_xxx: request private name
__xxx: System-defined name
__xxx__: margling in classes.
Python Objects: Capture data for manipulation.
Identity: Unique identifier (memory address), obtained using id().
Type: Indicates the kind of values an object can hold, obtained using type().
Value: Data item represented by the object.
Standard Types:
Numbers (int, float, complex)
 String
List
Tuple
Dictionary
Numbers:
Integer (int): Represents integer numbers.
Floating point (float): Numbers with fractions or decimal points.
Complex: Made up of two floating-point values (real and imaginary parts). Access with
x.real and x.imag. Imaginary part represented by j.
String:
Set of characters enclosed in single or double quotes. Immutable.
List:
Sequence of values of different datatypes, mutable and indexed, enclosed in square
brackets [].
Tuple:
Similar to lists but immutable, enclosed in parentheses ().
Dictionary:
Key-value pairs, enclosed in curly braces {}. Keys are usually numbers or strings.
Other Built-in Types:
Type, None, File, Function, Module, Class, Class instance, Method.
Internal Types:
Code, Frame, Traceback, Slice, Ellipsis, Xrange.
Standard Type Operators:
Value comparison: <, >, <=, >=, ==, !=.
Object identity comparison: is, is not.
Boolean: not, and, or.
Standard Type Built-in Functions:
cmp(obj1, obj2): Compares two objects.
repr(obj): Returns evaluatable string representation.
str(obj): Returns printable string representation.
type(obj): Determines the type of object.
Unsupported Types:
Boolean (use integers instead).
Char and byte (use strings).
Pointer (memory managed automatically).
int vs. short vs. long (Python uses C longs for integers).
float vs. double (Python float is C double).
Numbers:
Creating and Assigning: a = 12, b = 3.14, c = 1.23 + 4.56j.
Updating: Reassigning a variable.
Removing: Using del.
Integers:
Represented in decimal, binary (prefix 0b), octal (prefix 0o), or hexadecimal (prefix 0x).
Long Integers:
Superset of integers, denoted by L or l suffix.
Floating Point:
Represented with decimal points and optional scientific notation (e.g., 1.23e-5).
Complex Numbers:
 Made up of real and imaginary parts, accessed via x.real and x.imag.
Number Attributes:
num.real: Real component.
num.imag: Imaginary component.
Operators:
Arithmetic, Relational, Bitwise, Logical, Membership, Identity.
Built-in Functions:
Conversion: int(), long(), float(), complex().
Operational: abs(), coerce(), divmod(), pow(), round().
Integer specific: hex(), oct(), chr(), ord().
Related Modules:
array, math/cmath, operator, random.
Sequences:
Strings, Lists, Tuples, Mapping types (Dictionaries), Set types.
Strings:
Immutable sequences of characters in quotes.
Accessing values using slices [] and [:].
Updating: Creating a new string.
Membership: in, not in.
Concatenation: +.
Repetition: *.
Format operator: %.
Built-in functions: cmp(), len(), max(), min().
Lists:
Mutable sequences of values in square brackets [].
Accessing, updating, and removing elements using slices, append(), del, and remove().
Operators: Comparison, Slices, membership, concatenation, repetition.
Built-in methods: append(), count(), extend(), index(), insert(), remove(), reverse(), sort().
Tuples:
Immutable sequences of values in parentheses ().
Accessing values using slices.
Operators and built-in functions similar to lists (except modification).
Mapping Type (Dictionaries):
Key-value pairs in curly braces {}.
Accessing values using dict['key'].
Updating and removing elements.
Methods: clear(), get(), items(), keys(), pop(), popitem(), values().
Sets:
Unordered collections of unique elements in curly braces {}.
Set and frozen set datatypes.

Unit 2: Command-line Arguments, Files, Exceptions,

and Modules
Files
 File Objects: Abstraction for accessing files.
File Built-in Function open():
file_object = open(file_name, access_mode, buffering).
access_mode: 'r', 'rb', 'r+', 'wb', 'w+', 'ab', 'a+'.
File Built-in Methods:
Input: read(), read(n), readline(), readlines().
Output: write(string), writelines(list_of_lines).
Intra-file motion: seek(), tell().
Miscellaneous: close(), flush(), fileno(), isatty(), truncate().
File Built-in Attributes:
file.name: Name of the opened file.
file.mode: Access mode.
file.closed: Boolean indicating if the file is closed.
Standard Files: stdin, stdout, stderr (available in sys module).
Command-line Arguments:
Accessed via sys.argv (list of strings).
len(sys.argv): Number of arguments.
sys.argv[0]: Program name.

Exceptions
Exceptions: Events disrupting normal program flow.
Common Exceptions:
NameError: Accessing undeclared variable.
ZeroDivisionError: Division by zero.
SyntaxError: Invalid syntax.
IndexError: Out-of-range index.
KeyError: Non-existent dictionary key.
IOError: Input/output error.
Detecting and Handling Exceptions:
try, except, else, finally blocks.
Multiple except clauses.
Raising Exceptions: raise Exception(message).
Assertions: assert condition, message (debugging tool).
Standard Exceptions:
BaseException, Exception, StandardError, etc.
Creating Exceptions:
Create a class that inherits from Exception.
Exceptions and the sys Module:
sys.exc_info(): Returns a tuple containing exception class, instance, and traceback object.

Modules
Modules: Files containing Python code.
Modules and Files: One file equals one module.
Namespaces: Mapping of names to objects.
Built-ins, Global, Local.
 Name Lookup: Local -> Global -> Built-ins.
Importing Modules:
import module1, module2, ....
Importing Module Attributes:
from module import name1, name2, ....
from module import * (imports all names).
Module Built-in Functions:
__import__(), globals(), locals(), reload().
Packages: Hierarchical directory structure containing modules.
__init__.py file indicates a package.
Import subpackages using import package.module.
from package.module import *.
Other Features of Modules:
sys.modules: Dictionary of loaded modules.
Preventing attribute import using underscore prefix (_).

Unit 3: Regular Expressions and Multithreaded

Programming
Regular Expressions
Regular Expressions (REs): Strings with special symbols to match patterns.
Applications: Validation, pattern matching, translators, digital circuits, communication
protocols.
Special Symbols and Characters:
[]: Character set. Example: [a-m].
\: Special sequence. Example: \d.
.: Any character (except newline).
^: Start of string.
$: End of string.
*: 0 or more occurrences.
+: 1 or more occurrences.
?: 0 or 1 occurrence.
{N}: N occurrences.
{M, N}: M to N occurrences.
[^abc]: Match except a, b, and c.
Special Characters:
\d: Digit.
\D: Non-digit.
\s: Whitespace character.
\S: Non-whitespace character.
\w: Word character (alphanumeric).
\W: Non-word character.
Sets:
[a-z]: Lowercase character.
[A-Z]: Uppercase character.
[0-9]: Digit.
[a-zA-Z0-9]: Alphanumeric character.
 [abc]: a, b, or c.
re Module:
compile(pattern, flags=0): Compiles a RE pattern.
match(pattern, string, flags=0): Matches RE pattern at the beginning of the string.
search(pattern, string, flags=0): Searches for the first occurrence of RE pattern in the
string.
findall(pattern, string): Finds all occurrences and returns a list.
split(pattern, string, maxsplit=0): Splits string into a list.
sub(pattern, repl, string, count=0): Replaces all occurrences of RE pattern with repl.

Multithreaded Programming
Thread: Separate path of execution within a program.
Process: Program in execution with its own address space.
Threads are light-weight processes.
Uses of threads: Server-side programs, games, animations.
Global Interpreter Lock (GIL): Ensures only one thread runs at a time.
Exiting Threads: By completing execution, calling thread.exit(), or raising an exception.
Thread Module:
Functions: allocate_lock(), start_new_thread(), exit().
Lock Object Methods: locked(), acquire(), release().
Threading Module:
Thread class and synchronization mechanisms.
Objects: Thread, Lock, RLock, Condition, Event, Semaphore.
Creating Threads:
Without a class: t = Thread(target=function, args=(arg1, arg2)).
Creating a subclass to Thread class.
Start thread with t.start().
Queue Module: Inter-thread communication.
Queue(size): Creates a queue.
qsize(), empty(), full(), put(item), get().
Producer-Consumer Problem: Threads sharing data via a queue.

Unit 4: GUI Programming and Web Programming

GUI Programming
GUI (Graphical User Interface): Enables interaction through graphical icons.
GUI programs in Python are typically developed with the tkinter module.
Tkinter.Tk(): Creates a top-level window object.
Widgets: Components like buttons, labels, list boxes.
Events: Actions like button press, mouse movement.
Geometry Managers: Packer and Grid.
Packer: Specifies size, alignment and positions.
Grid: Places widgets in grid coordinates.
Adding Tk to Applications:
1. Import tkinter
2. Create a top-level window
3. Build GUI components
4. Connect components to application code
5. Enter the main event loop using Tkinter.mainloop()

Tk Widgets:
Button: Performs a task on click. Example: b = Button(master, text='Exit',
command=top.quit).
Label: Displays a message. Example: label = Label(top, text='Welcome!').
Tk Interface Extensions (Tix):
Extends the capabilities of TCL/Tk.
Python Mega Widgets (PMW):
Extends Tkinter with high-level compound widgets.
wxWidgets and wxPython:
wxWidgets: Cross-platform toolkit.
wxPython: Python binding for wxWidgets.
GTK+ and PyGTK:
GTK+: GIMP Toolkit for creating GUIs.
PyGTK: Python wrapper for GTK+.
Related Modules:
Tkinter, Tix, EasyGUI, PMW, wxPython, PyGTK, PyQt.

Web Programming
Web Surfing: Client/Server Computing
Clients (browsers) request data from servers.
HTTP protocol.
URL (Uniform Resource Locator): Specifies the address of resources.
prot_sch://net_loc/path;params?query#frag.
prot_sch: Protocol (e.g., http, ftp).
net_loc: Network location.
path: File path.
query: Key-value pairs.
frag: Fragment identifier.
urlparse Module:
urlparse(): Parses URL into components.
urlunparse(): Merges components into a URL.
urljoin(): Joins base URL with a new URL.
urllib Module:
urlopen(): Opens a web connection.
Methods: info(), read(), geturl(), close(), readline(), readlines(), fileno().
urlretrieve(): Downloads a URL to a local file.
quote(): Encodes URL data.
unquote(): Decodes URL data.
urlencode(): Encodes a dictionary of key-value pairs.
urllib2 Module:
Handles complex URL opening, such as websites with basic authentication.
 Advanced Web Clients:
Crawlers, web page caching.
CGI (Common Gateway Interface):
Interface for writing client-server applications.
Client requests, server executes a program, and returns the output.
CGI Architecture
CGI Environment Variables
CGI Redirection
Forms and Results Pages:
Generating HTML forms to collect data from users.
Processing form data and generating results pages.
Advanced CGI:
Multipart form submission for file uploading:
<FORM enctype="multipart/form-data"...>.
<INPUT type="file" name="...">.
Multi-valued fields: handling multiple values from checkboxes.
Cookies:
Small objects of information stored on the web browser system.
The server can connect requests from a particular client to previous and subsequent
requests, the server can also provide a customized interface to the client based on his/her
preferences. A cookie consists of a name and a value. It is created by some software
system on the server and included as a part of the HTTP header.
Web Servers:
Delivers content to end-users over the Internet.
Uses HTTP.
Handlers: SimpleHTTPRequestHandler, BaseHTTPRequestHandler,
CGIHTTPRequestHandler.

Unit 5: Database Programming

Connecting to Databases
Requires importing a database connector module (e.g., mysql.connector).
Installation using pip: pip install mysql-connector.
Steps to connect:

1. Import the connector module.

2. Create a connection object.
3. Create a cursor object.
4. Execute queries.

Creating the Connection:

myconn = mysql.connector.connect(host=hostname, user=username,
password=password, database=databasename).

Working with Cursors

 Cursor: Abstraction for executing SQL statements and retrieving data.
Creating a Cursor Object:
cur = myconn.cursor().

Basic Database Operations

Show Databases: cur.execute("show databases").
Creating a New Database: cur.execute("create database PythonDB2").
Creating a Table: cur.execute("create table Employee (name varchar(20) not null, id int
primary key, salary float not null, Dept_Id int not null)").
Alter Table: cur.execute("alter table Employee add branch_name varchar(20) not null").

Insert Operation
INSERT INTO statement:
sql = "insert into Employee(name, id, salary, dept_id, branch_name) values (%s, %s, %s, %s,
%s)".
val = ("John", 110, 25000.00, 201, "Newyork").
cur.execute(sql, val).
myconn.commit() (to save changes).
Insert Multiple Rows:
val = [("John", ...), ("David", ...), ("Nick", ...)].
cur.executemany(sql, val).
Row ID: cur.lastrowid (gets the ID of the last inserted row).

Read Operation
SELECT statement:
cur.execute("select * from Employee").
result = cur.fetchall() (fetches all rows).
fetchone(): Fetches only one row at a time.
Iterate through the result to get individual rows.

Object Relational Managers (ORM)

An object-relational mapper (ORM) is a code library that automates the transfer of data
stored in relational database tables into objects that are more commonly used in application
code.
In an ORM system, each class maps to a table in the underlying database.
ORM Implementations
SQLAlchemy
Peewee
The Django ORM
PonyORM
SQLObject
Tortoise ORM