Python Basics

General Class Itinerary

• An overview of class includes: Announcements for updates, a Q&A for students clarifications, a lecture delivering the content, ending with hands-on lab practice

Class Times

• Lectures begin at 8:00 AM
• There is a 20 minutes break at 9:20 AM
• Practice lab starts at 9:40 AM
• Class ends at 10:50 AM
• Times may differ mid term, presentations and final

Weekly Course Objectives

• The weekly objectives include lessons on: Python, Math, Operators, Data Types, Flow Control, Functions, Variables, File I/O, Try Exception Blocks, and OPP / Classes

Python key features

• Easy to learn and read
• GUI programming, Broad Standard Library, Database Interfaces, Interactive Mode, Portable, Easy to Maintain

Python Reserved Words (Keywords)

• Keywords can be accessed with help("keyword") in the Python console.
• Python 3.13.1 has 36 keywords
• Keywords are lowercase, True, False and None being the exceptions.
• Keywords are always available without importing.
• Keywords differ from Python's built-in functions and types, as the restrictive usage of keywords don't apply to built-in functions.
• Keywords cannot be used as identifiers.

Lines and Indentation

• Python enforces code block with line indentation
• A convention of 4 paces is standard and the style guide for python programs can be found at peps.python.org/pep-0008/.
• Statements end with a newline unless there is \ to continue the statement on a second line.
• Line continuation character is not needed inside brackets.

Quotation and Comments

• String literals can be denoted with single ('), double ("), or triple quotes (""" or ''').
• Triple quotes can span strings across multiple lines.
• Comments begin with a hash sign (#) and are ignored by interpreters, from sign to end of the physical line.
• Multi-line comments start and end with 3 quotes

Module and functions for math

• Math module is used for: number-theoretic and representative functions, power and logarithmic functions, trigonometric, hyperbolic, special and constance like Pi
• Random module generates simulations, and privacy features

Arithmetic Operators in Example x and y

• Addition + adds two operands: x+y
• Subtraction - subtracts two operands: x-y
• Multiplication * multiplies two operands: x*y
• Division / divides the first operand by the second x/y
• Floor division // performs division and returns integer quotient x//y
• Modulus % gives the remainder of division x%y
• Exponent ** is the power operator to raise the first to the power of the second x**y

Relational Operators in Example x and y

• Equal == checks if operands are equal x==y
• Not equal != checks if operands are NOT equal x!=y
• Greater than > compares the two operands: x>y
• Greater than or equal to >= compares the two operands: x>=y
• Less than < compares the two operands: x<y
• Less than or equal to <= compares the two operands: x<=y

Assignment operators with variables a and b

• Assign = sets to left operand result of expression from right operand, x=y+z
• Add and assign += adds the operands and assigns value to left, a += b
• Subtract and assign -= subtracts the operands and assigns value to left, a -= b
• Multiply and assign *= multiplies the operands and assigns value to left, a *= b
• Divide and assign /= divides the operands and assigns value to left,a /= b
• Modulus and assign %= returns modulus and assigns value to left, a %= b
• Floor divide and assign //= returns floor and assigns value to left, a //= b
• Exponent and assign **= returns exponent and assigns value to left, a **= b
• Bitwise AND assign &= preforms and calculation and assigns value to left, a &= b
• Bitwise OR assign |= preforms or calculation and assigns value to left, a |= b
• Bitwise XOR assign ^= preforms xor calculation and assigns value to left, a ^= b
• Bitwise right shift assign>>= preforms right shift and assigns value to left, a >>= b
• Bitwise left shift assign <<= preforms left shift and assigns value to left, a <<= b

data types

• Explicit declarations are not required.
• Data type conversions: int(x [,base]), float(x)

Data type characteristics:

• String: text encapsulated in quotations, uses slice operator ([] and [:]) to call subsets, + to concatenate, * to repeat string, and string formatting operators (%) are %s, %d, %f, %.<number of digits>f
• List: items are separated by commas and enclosed in [], the values stores are accessed by the slice operator at indexes starting at 0 and ending at list[length] -1, and lists can be use concatenation and repetition
• Tuple: elements enclosed in “()”. It's best when data is unchangeable. Can convert to lists and uses same list functions
• Dictionary: key-value pairs, with ":" separating pairs, and "," to separate items

Flow Control Structures:

• If statements: Simple conditional check
• If / else Statements: Conditional checks that offers and alternative block
• If / elif / else Statements: Allowing multiple conditions
• Nested If statements: Conditional statements within conditional statements
• Conditional statements end with ":", and code must be indented
• Code must be indented by four spaces
• End a code block be un-indenting to same level

Loop control structures

• While: executes block as long as statement true. Boolean conditional, and block statement. While <statement>: <statment(s)>
• for…in: iterates over sequence until is exhausted. Has variable being iterated and block statement. for <iterating variable> in <Sequence>: statment (s)
• For/While...else: Else statement executes if loop terminates normally
• Decisional structures have ":" and indentation apply

Flow control: Loop structure

• A break statement is used to terminate a loop iteration process and continues code execution to statements outside of loop block. For nested lookups, break terminates loop and resumes next line of code.
• Use continue statements to skip current iteration and recheck the condition

Functions: Introduction

• Functions enable reuse of code segments accross programs, operate independently, and encapsulate specific tasks
• Functions allow for organised code structure, combine to create applications, and can be defined once and called multiple times
• The anatomy is def function-name(parameters ): "function_docstring" Block of statements return [expression] (optional)

Function Parameters:

• The number of arguments in the function call must match with the function, unless there is a variable length argument list.
• A parameter is the variable inside the parentheses in the function definition.
• An argument is value that is sent to the function when it's called.

Function - Optional Parameters

• The default parameter has values that are provided when defining functions and assigning the assignment operator (=).
• When calling default parameters are becoming optional.
• Providing values overrides default values.
• Functions contain any number of default parameters and should be non-default.

Functions: Positional and Keyword Parameters

• Parameters are given keyword, so there’s no need to maintain order
• When calling keyword arguments match parameters define in function
• Default can be skipped with optional parameters
• Arguments must be entered with an appropriate value, the function will still work unless using keywords
• Keyword and positional can be used with order using keywords

Function - Variable length parameters

• Functions can accepts variable number of arguments and variable number of keyword arguments.

Variable Scope

• Local variables are defined inside function and cannot be accessed
• Variables can also be defined in the program and are global variable

File Operations and Attributes

• Open file = open(file_name [, access_mode])
• Access mode where "r" opens for reading and "w" for writing
• Close file.close()
• Write file.write(string) to the file
• Determine the working mode of the file: file.mode – returns code
• Call the name of the file file.name
• Confirm that a file is closed: file.closed returns T or F

Try Blocks

• Try handles errors while program is processing. If error occurs during try...except structure the states is set, error handles and program runs normally.
• Structures contains try, except, else, and can contain finally
• try: "<type code to test here>" runs a block of code that might have error
• except “<type of exception>": “<code of exception>" runs if error in code is detected
• "else: “<code executes if no exception>" run alternative code if there is no error
• Finally always executed and always executes

Object Oriented Programming (OOP)

• Methods and entities are wrapped in entities. Important in big development.
• The two main concepts are Class the framework, and Object the instance.
• The object stores variables which access throughout the class or variables for methods.

Classes

• Classes create a new class with name, data, methods and attributes.
• class ClassName: is the basic structure
• Instance Name = class_name (arg...) will create instance of class
• __import__ allows for data to me initialized. The process is to initialize that information, set to our demands.
• Pascal Notation PascalCase capitalizes each word in the title.

Modules and Packages

• The Python Standard Library is a collection of modules for platform independent APIs
• modules are distributed with Python and are available on your Python program. They are used to write code from scratch by delivering readily available solutions
• help(), dir() to understand the capabilities of a library: help() provides review and dir() lists attributes
• Module Examples: os and sys, datetime and time, random, collections, json, csv and others

Name space

• A container that holds a collection of names (identifiers) and maps them to corresponding objects. Namespaces unique and can be used without conflicts
• They consist of built-in objects and functions available throughout program. The global is top level for modules, but can surpassed by local and encapsulated
• Order (LEGB rule) will determine how these functions will be implemented as you progress
• Built in -> Global - > Enclosed -> Local

Imports

• Imports helps share load/reuse code from modules or packages.
• To use a module, use the import statement in another Python file.
• Modules also create their own ceces to avoid name conflicts.

Python files, code

• Modules organize Vital Python code and allow it to be reusable.
• You create folder with " init". This is Python file that can initialize
• Create files extension ".py"
• Create subpackages within folder that contains " _init _.py": import then call

Asyncio

• Concurrency is handled at overlapping times.
• Parallelism is similar execution at the same time through multiple mediums.
• Asyncio is when tasks don't always come due to the time that takes

The structure components are:

• The standard library is helpful for writing code
• An even loop provides a code management or tasks
• Asyncio is helpful for concurrency servers that are in high concurrency

Loop components functions:

• Define functions when working with "async def" for execution
• Loop component manages execution through events
• Futures allow representation during communication, with a way to retrieve result when completed
• task to or future by management of loop
• Run Run a Coroutine: takes a single co-routine as its argument and runs it until it completes. Manages Loop: It automatically creates and starts an event loop. Once the coroutine finishes, it stops and closes the event loop, ensuring proper cleanup. Async Code: It allows asynchronous code to run from a synchronous context
• Syntax for Await: It pauses the execution of the coroutine until the awaitable object it is waiting on completes.
• Syntax for await asyncio.sleep(2)
• Task creates a task object with wraps with Coroutine with in event run

How loops work

• Used to schedule the execution of a coroutine concurrently with other - loop object.
• The new features make the program runs immediately as control is acquired after each cycle.
• Gather allows one or more and provides coroutines are used to allow function and manages coroutines to be executed and managed properly with code
• Gather allows for async.gather (*coroutines)

Libraries in Asyncio

• Library is used for many features such as async wait, to manage the operation in code.
• The Asynchronous HTTP is useful for scale, clients operations and servers. Async provides asynchronous database features. The library reads/ writes async
• Httpx is a asynchronous client with versatile. Motor asynchronous with Monogo, Trio with alternative style
• Useful for IO bound operations in network requests, or GUI - asynchronous in system requests
• Easy for programming, data processing. Helpful as user handling that is high

Asyncio - Threading:

• Asyncio is more efficient for IO related tasks, threading is a simple
• Threading takes a lot of energy