Introduction to Python Programming

Introduction to Python

• A computer program consists of instructions executed sequentially
• Instructions include:
  • Input: Data from files, keyboard, touchscreen, or network
  • Process: Computations on the data (e.g., x + y)
  • Output: Placing data in a file, on a screen, or network
• Variables store data (e.g., x, y, z). Variable values change during execution
• An algorithm is a sequence of instructions to solve a problem

Programming using Python

• A Python interpreter executes Python code
• An interactive interpreter allows executing code line by line
• Code is the textual representation of a program (also called coding)
• Statements are program instructions, usually per line
• Expressions are code that returns values (e.g., wage * hours * weeks = salary)
• Variables are named references to values (e.g., wage, hours, weeks, salary)
• Assignments use the = symbol (e.g., salary = wage * hours * weeks)
• print() displays variables or expressions
• # denotes comments (optional)

Basic Input and Output

• print() function outputs text
• Strings use quotes (e.g., "Hello")
• Escape sequences (e.g., "\n", "\t") specify special characters
• \n creates a new line
• \t inserts a tab
• Comments use #
• input() reads user input

Errors

• SyntaxError: Invalid code that cannot be understood (e.g., multiple prints on one line)
• IndentationError: Incorrect indentation (e.g., misaligned code blocks)
• ValueError: Invalid input value, (e.g., giving letters as input to int())
• NameError: Trying to use a non-existent variable
• TypeError: Using incorrect types in an operation (e.g., adding integer to a string)
• Logic Error: Program runs but produces incorrect results; also called bug.

Development Environment

• Integrated Development Environment (IDE) typically used

Computers and Programs (General)

• Digital circuits process 0s and 1s (bits)
• Processors perform instructions
• Memory stores data

Language History

• Programming languages were created for human readability

White Space Matters

• White space (blank spaces or newlines) is crucial for correct program execution in Python
• Programs require precise formatting to work correctly

Variables and Expressions

• Variables are named containers for values
• Assignment statements give values to variables (e.g., x = 5)
• Incrementing a variable increases its value by 1

Identifiers

• Identifiers (names) consist of letters, underscores, and digits, and must start with a letter or an underscore
• Python is case-sensitive

Reserved Words (Keywords)

• Cannot be used as variable names (e.g., if, else, for)

Experimenting with Objects

• Objects represent values
• Garbage collection automatically reclaims unused memory

Numeric Types, Floating-Point, and Literals

• Python supports float data types
• Float literals can involve the "e" for scientific notation
• OverflowError occurs when a floating-point value is too large to store

Arithmetic Expressions

• Evaluated according to the order of standard mathematics (precedence rules)

Python Expressions

• Unary minus is negative
• Compound operators (e.g., +=) are shorthand for updates

Division and Modulo

• Division (/) returns a float
• Floor division (//) rounds down to the nearest integer
• Modulo operator (%) returns the remainder

Modules

• Python modules are code in separate files.
• import statements bring module code into the current program
• Dot notation accesses objects within a module (e.g., math.sqrt)

Math Module

• Provides more advanced mathematical operations
• Includes functions like fabs(x), floor(x), and others
• Use via import statement.

Random Numbers

• Random generated by time each call.
• randrange(), randint() functions for integers
• random() function for floating-point numbers

Representing Text

• Unicode represents characters as numbers
• Escape sequences (e.g., '\n', '"') denote special characters in strings

String Basics

• Strings (e.g., "Hello") are sequences of characters.

List Basics

• Lists are ordered collections of items enclosed in square brackets ([]).

Tuple Basics

• Tuples are similar to lists but immutable (unchangeable).

Set Basics

• Sets hold unique elements, order does not matter.

Dictionary Basics

• Dictionaries store key-value pairs.

Type Conversions

• Conversion from one data type to others (e.g., from int to float).

Binary Numbers

• Base-2 numbers (comprising 0s and 1s).

String Formatting

• Format specifications control output of string values

Branching

• if-else statement to execute codes conditionally
  • if statement is True
  • else statement is False
  • elif (else if) for further conditions

Logical Operators

• and, or, not to combine conditions
  • checking multiple ranges, or gaps in ranges
  • True or False Boolean Values are used

Comparing Data Types and Common Errors

• How to compare data types in programming with common errors

Membership and Identity Operators

• in operator to check whether a smaller string is in a larger string
• is operator to compare if two operands refer to the same object

Order of Evaluation

• Precedence rules determine order of operations in expressions

Code Blocks and Indentation

• Code blocks are defined by indentation

Conditional Expressions

• Short-hand way to write conditional code blocks

Loops

• while loops run as long as an expression is True
• for loops iterate through each item in a container

String Methods

• Various methods for working with strings

Functions

• Group statements for reusable operation
• Parameters (inputs) and return to produce output
• Functions may need to use other function calls

Dynamic Typing

• Python determines object types during run time

Reasons for Defining Functions

• Reduce program code redundancy and prevent code bloat

Writing Mathematical Functions

• Functions can be used with mathematical equations to produce output based on input

Function Stubs

• Placeholders for functionalities not yet implemented in the program

Functions with Branches/Loops

Raising Exceptions

• raise statement causes immediate exit, allowing exception handler to handle errors

Custom Exception Types

• Create your own data types to define errors and exceptions

Files

• Reading from files
• Writing to files
• Utilizing specific modes (e.g. binary data mode)
• Standard Library os and csv modules

Classes: Introduction

• Classes group data and operations
• Objects are instances of classes
• Data is accessed via operators (e.g., dot notation)

Classes: Grouping Data

• How to group data and functionalities together in classes

Classes: Instance Methods

• How define a method inside a class

Classes: Class and Instance Object Types

• How to create class attributes that are shared between objects
• How to create instance attributes that are unique to each object

Classes: Class Constructors

• Modifying or creating class states using __init__ method

Classes: Class Customization

• Modify common class behaviors through methods

Operator Overloading

• Redefining operators within classes

Memory Allocation and Garbage Collection

• How Python allocates memory
• Process of reclaiming unused memory

Inheritance

• Derived classes inheriting attributes and methods from base classes

Testing Code

• Using unittest module for repeatable testing

Exceptions

• Exception handling using try-except blocks
• Raising exceptions (raise statement)
• Using finally to specify clean-up steps