top of page


Outline Python Computer Programming Language

  1. Introduction to Python:

    • Basic concepts and syntax

    • Setting up the Python development environment

    • Running Python programs

  2. Variables and Data Types:

    • Working with different data types (strings, numbers, booleans)

    • Variable assignment and naming conventions

    • Type conversion and casting

  3. Control Flow and Loops:

    • Conditional statements (if, else, elif)

    • Looping constructs (for loops, while loops)

    • Break and continue statements

  4. Data Structures:

    • Lists, tuples, and dictionaries

    • Accessing and manipulating elements in data structures

    • List comprehensions

  5. Functions and Modules:

    • Defining and calling functions

    • Parameters and return values

    • Importing and using modules

  6. File Handling:

    • Reading and writing to files

    • Working with file objects and file modes

    • Handling exceptions and errors

  7. Object-Oriented Programming (OOP):

    • Introduction to OOP concepts (classes, objects, methods)

    • Creating and using classes

    • Inheritance and polymorphism

  8. Error Handling and Debugging:

    • Common types of errors and exceptions

    • Exception handling with try-except blocks

    • Debugging techniques and tools

  9. Working with Libraries and APIs:

    • Introduction to popular Python libraries (e.g., NumPy, Pandas, Matplotlib)

    • Installing and importing external libraries

    • Interacting with APIs and making HTTP requests

  10. Project Development:

    • Applying Python skills to develop small-scale projects

    • Combining various concepts learned throughout the course

    • Emphasizing good coding practices and project organization

  11. Advanced Topics (Optional):

    • Generators and iterators

    • Decorators

    • Context managers

    • Regular expressions

  12. Final Project:

    • Undertake a comprehensive project that showcases proficiency in Python

    • Apply programming concepts and libraries to solve a real-world problem

    • Document and present the project, highlighting key features and functionalit

Chapter 1: Introduction to Python

Welcome to the world of Python programming! In this chapter, we will introduce you to the fundamentals of Python, including its syntax, setting up the development environment, and running Python programs. By the end of this chapter, you will have a solid foundation to start writing your first lines of Python code.

1.1 What is Python?

Python is a high-level, general-purpose programming language that emphasizes code readability and simplicity. It was created by Guido van Rossum and first released in 1991. Python is known for its clean syntax, which allows developers to express concepts in fewer lines of code compared to other programming languages. It has gained tremendous popularity among beginners and experienced programmers alike due to its versatility and extensive range of libraries and frameworks.

Python is an interpreted language, meaning that it does not need to be compiled before execution. This allows for quick development and testing, making it an excellent choice for prototyping, scripting, and automation tasks. Furthermore, Python supports multiple programming paradigms, including procedural, object-oriented, and functional programming styles, giving programmers the flexibility to choose the most suitable approach for their projects.

1.2 Setting up the Python Development Environment

Step 1: Installing Python

  • Visit the official Python website at

  • Navigate to the Downloads section and choose the appropriate installer for your operating system (Windows, macOS, or Linux).

  • Run the installer and follow the instructions to complete the installation. Make sure to select the option to add Python to the system PATH.

Step 2: Verifying the Installation

  • Open a terminal or command prompt and type python --version. This command will display the installed Python version, confirming that the installation was successful.

Step 3: Choosing an Integrated Development Environment (IDE) Python offers several IDE options to write, debug, and execute your code effectively. Some popular choices include:

  • PyCharm

  • Visual Studio Code (VS Code)

  • IDLE (Python's built-in IDE)

  • Jupyter Notebook

Select the IDE that suits your preferences and install it by following the instructions provided on their respective websites.

1.3 Running Python Programs

With Python installed and your IDE set up, let's write and execute your first Python program!

Step 1: Launching the IDE

  • Open your chosen IDE. If you're using IDLE, it should launch automatically after installing Python.

Step 2: Writing Your First Python Program

  • In the IDE's editor, create a new file with a .py extension (e.g.,

  • Type the following code:

print("Hello, World!")

  • Save the file.

Step 3: Executing the Program

  • In the IDE, click the "Run" or "Execute" button, or use the keyboard shortcut to run the program.

Congratulations! You have just executed your first Python program. The code print("Hello, World!") tells Python to display the text "Hello, World!" on the screen. This is a common tradition when learning a new programming language.

Examples problems: Neural Net #1,  Neural Net #2,


1.4 Summary

In this chapter, we introduced you to the world of Python programming. You learned what Python is, how to set up the Python development environment, and how to write and execute your first Python program. Now that you have a solid foundation, we can move on to exploring Python's variables and data types in the next chapter.

Chapter 2: Variables and Data Types

In Python programming, understanding the fundamental concepts of variables and data types is crucial. This chapter will take you through the journey of working with different data types, variable assignments, naming conventions, and the idea of type conversion and casting.

2.1 Working with Different Data Types

Python has several built-in data types that are commonly used in different kinds of programming tasks. Let's consider the three primary ones: strings, numbers, and booleans.

Strings: Strings in Python are sequences of characters. They can be created by enclosing characters inside a single quote or double-quotes.

s1 = "Hello, World!"

s2 = 'Python is fun.'

print(s1) # Output: Hello, World!

print(s2) # Output: Python is fun.


Numbers: Python supports integers, floating-point numbers, and complex numbers. They are defined as int, float, and complex classes in Python.

a = 5 # This is an integer

b = 5.1 # This is a floating point number

c = 3+2j # This is a complex number


Boolean is a data type that can have one of two possible values (either True or False).

x = True

y = False

print(x) # Output: True

print(y) # Output: False

2.2 Variable Assignment and Naming Conventions

In Python, variables are created the moment you first assign a value to them. Python uses = for variable assignment.

x = 5

y = "Hello, World!"

As per the naming conventions, a variable name must start with a letter or the underscore character. It can't start with a number, and it can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ ).


Here are a few examples of acceptable variable names:

myVar = "John"

my_var = "John"

_my_var = "John"

myVar2 = "John"

MYVAR = "John"


2.3 Type Conversion and Casting

Python provides a collection of built-in functions that convert from one data type to another, known as type conversion.

#Converting integer to float

x = 5

print(float(x))  # Output: 5.0

# Converting float to integer

y = 5.8

print(int(y)) # Output: 5

# Converting number to string

z = 10

print(str(z)) # Output: "10"

# Converting string to integer

s = "100"

print(int(s)) # Output: 100


Note that while converting from float to int, the value is truncated (not rounded), and not all conversions are possible (for example, a non-numeric string can't be converted to an integer or a float).

In conclusion, variables and data types form the basis of Python programming. Having a solid understanding of these concepts will make it easier to work with data and perform various operations on it. 

Chapter 3: Control Flow and Loops

Control flow and loops are at the heart of how programs work. These structures allow a program to react to different inputs, repeat operations, and execute code blocks conditionally. In this chapter, we will explore how Python implements control flow via conditional statements and loops.

3.1 Conditional Statements (if, else, elif)

Conditional statements in Python are used to perform different computations or actions depending on whether a specified condition evaluates to true or false.

The if statement is used to test a specific condition. If the condition is true, the indented block of code under the if statement will be executed. Here's an example:

x = 10

if x > 0:

print("x is positive")

The else statement follows an if statement, and it contains code that will be executed if the if statement's condition was false:

x = -10

if x > 0:

print("x is positive")


print("x is not positive")

The elif (short for "else if") statement is a combination of else and if. It allows you to check for multiple expressions and execute a block of code as soon as one of the conditions evaluates to true.

x = 0

if x > 0:

print("x is positive") elif x == 0:

print("x is zero")


print("x is negative")


3.2 Looping Constructs (for loops, while loops)

Loops in Python are used to repeatedly execute a block of code. Python provides two types of loops: for and while.

A for loop is used for iterating over a sequence (a list, a tuple, a dictionary, a set, or a string) or other iterable objects. Iterating over a sequence is called traversal.

# Looping through a list fruits = ["apple", "banana", "cherry"] for x in fruits: print(x)

A while loop in Python is used to repeatedly execute a target statement as long as a given condition is true.

# Printing numbers 1 through 5

i = 1

while i <= 5:


i += 1

3.3 Break and Continue Statements

The break and continue statements can alter the flow of a normal loop.

The break statement allows you to exit a loop prematurely when a certain condition is met. When Python encounters a break statement, control flow breaks out of the loop immediately:

for x in range(1, 11): # Prints numbers 1 through 10

if x == 6:



The continue statement allows you to skip the remainder of the loop's code block for the current iteration and move onto the next iteration of the loop:

for x in range(1, 11): # Prints numbers 1 through 10, but not 6

if x == 6:




In conclusion, control flow and loop constructs play a vital role in Python programming, allowing you to add logic and repetition to your programs. In the next chapter, we will explore functions and modules to learn how we can organize our code more effectively.

Chapter 4: Data Structures

Data structures are fundamental components of any programming language, including Python. They are essentially containers that hold data and provide different ways to store, access, and manipulate that data. Python provides several built-in data structures, including lists, tuples, and dictionaries.

4.1 Lists, Tuples, and Dictionaries

Lists: A list in Python is a collection of items which are ordered and changeable. Lists allow duplicate items.

fruits = ["apple", "banana", "cherry", "apple"]

print(fruits) # Output: ['apple', 'banana', 'cherry', 'apple']

Tuples: A tuple is a collection which is ordered and unchangeable. This means that, once a tuple is created, you cannot change its values.

fruits = ("apple", "banana", "cherry")

print(fruits) # Output: ('apple', 'banana', 'cherry')

Dictionaries: A dictionary is a collection which is unordered, changeable, and indexed. Dictionaries are written with curly brackets, and they have keys and values.

car = {"brand": "Ford", "model": "Mustang", "year": 1964}

print(car) # Output: {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}

4.2 Accessing and Manipulating Elements in Data Structures

Elements in lists and tuples can be accessed by their index (0-based). Lists can be modified, whereas tuples cannot.

# Lists fruits = ["apple", "banana", "cherry"]

print(fruits[1]) # Output: 'banana'

fruits[1] = "mango" # Modify the second element

print(fruits) # Output: ['apple', 'mango', 'cherry']

# Tuples

fruits = ("apple", "banana", "cherry")

print(fruits[1]) # Output: 'banana'

# fruits[1] = "mango" # This would result in an error


In dictionaries, data can be accessed by their key. To modify a value, you can simply assign a new value to a specific key.

car = {"brand": "Ford", "model": "Mustang", "year": 1964}

print(car["model"]) # Output: 'Mustang'

car["year"] = 2020

print(car) # Output: {'brand': 'Ford', 'model': 'Mustang', 'year': 2020}

4.3 List Comprehensions

List comprehension is a concise way to create lists based on existing lists. It allows you to transform and filter data in a very efficient manner.

numbers = [1, 2, 3, 4, 5]

squares = [n**2 for n in numbers]

print(squares) # Output: [1, 4, 9, 16, 25]

# With a condition

even_squares = [n**2 for n in numbers if n % 2 == 0]

print(even_squares) # Output: [4, 16]

In conclusion, understanding and being able to work with data structures are critical skills in Python programming. They serve as the building blocks for more complex programming constructs and tasks. In the next chapter, we will delve into the world of functions and how they allow us to create reusable blocks of code.

Chapter 5: Functions and Modules

In this chapter, we dive into another fundamental concept in Python programming - functions and modules. Functions enable us to encapsulate a piece of code that performs a specific task into a reusable unit. Modules, on the other hand, are separate files containing Python code, including functions, that we can use in our current script.

5.1 Defining and Calling Functions

A function is a block of code that only runs when it is called. Functions in Python are defined using the def keyword, followed by the function name and parentheses ().

def greet():

print("Hello, World!")

# Call the function

greet() # Output: Hello, World!


You can call a function by using its name followed by parentheses. If the function requires inputs, you pass them inside the parentheses.

5.2 Parameters and Return Values

Parameters are variables listed inside the parentheses in a function definition. When a function is called, we provide values for these parameters (known as arguments).

def greet(name):

print(f"Hello, {name}!")

# Call the function with an argument

greet("Alice") # Output: Hello, Alice!


A function can return a value back to the caller using the return keyword. If no return statement is encountered or if we do not specify a value with return, the function will return None.

def add(a, b):

return a + b

result = add(5, 3)

print(result) # Output: 8

5.3 Importing and Using Modules

Modules in Python are separate files that contain functions, variables, and other code that we can use in our current script by importing them.

There are several built-in modules in Python, which you can import whenever you like.

import math

print(math.sqrt(16)) # Output: 4.0

We can also import a specific function or variable from a module.

from math import sqrt

print(sqrt(16)) # Output: 4.0

To avoid naming conflicts, we can import a module or function under a different name using the as keyword.

import math as m

print(m.sqrt(16)) # Output: 4.0

Apart from built-in modules, you can create your own modules by writing functions in one Python file and then importing them in another.

In conclusion, functions and modules provide a powerful way to organize your code, improve readability, and promote code reuse. Mastering them is essential for any serious Python programming. In the next chapter, we will learn about file I/O operations and error handling in Python.

Chapter 6: File Handling

File handling is a crucial part of any programming language. It involves performing operations on files like reading data from files, writing data to files, handling errors during these operations, and so on. Python has a set of built-in functions for handling files.

6.1 Reading and Writing to Files

The two primary tasks when working with files are reading data from files (read) and writing data to files (write).

Before you can read or write a file, you have to open it using Python's built-in open() function. This function creates a file object, which would be utilized to call other support methods associated with it.

# Open a file

f = open("test.txt", "r") # 'r' stands for read mode

To write to an existing file, you must add a parameter to the open() function - "a" (append) or "w" (write).

# Write to a file

f = open("test.txt", "w") # 'w' stands for write mode

f.write("Hello, World!")



To read the content of a file, you can use the read() function.

# Read a file

f = open("test.txt", "r") # 'r' stands for read mode




6.2 Working with File Objects and File Modes

In Python, a file operation takes place in the following order:

  • Open a file

  • Read or write (perform operation)

  • Close the file


File objects provide a variety of methods including read(), write(), readline(), close(), etc., to make file handling tasks simpler.

As for file modes, they define whether we can read ('r'), write ('w'), or append ('a') to the file. We can also specify if we are handling binary ('b') or text ('t') files.

6.3 Handling Exceptions and Errors

While working with files, various errors can occur, such as trying to open a non-existing file for reading, or not having permissions to write to a file. Python uses exceptions to handle these errors.


f = open("nonexistentfile.txt", "r")

except FileNotFoundError:

print("The file does not exist")

In this code, Python attempts to execute the code in the try block. If a FileNotFoundError occurs, Python will stop executing the try block and move on to the except block.

It's good practice to handle exceptions when working with files, especially in cases where errors are likely to occur.

In conclusion, file handling is a crucial skill for Python programmers, as it allows you to work with data stored in files. With Python's straightforward syntax and powerful file handling functions, you can easily read, write, and manage files. In the next chapter, we will delve deeper into more advanced Python concepts like classes and objects, inheritance, and more.

Chapter 7: Object-Oriented Programming (OOP)

Object-Oriented Programming (OOP) is a programming paradigm that provides a means of structuring programs so that properties and behaviors are bundled into individual objects. Python, being a multi-paradigm language, supports OOP with classes and objects.

7.1 Introduction to OOP concepts (Classes, Objects, Methods)

Classes are the blueprint for creating objects (a particular data structure), providing initial values for state (member variables, i.e., properties) and implementations of behavior (member functions/methods).

An object is an instance of a class. A class is just a concept, and an object is an instance of a class - a concrete realization of the concept.

Methods are functions defined within the body of a class. They are used to define the behaviors of an object.

class Car: # Class

def __init__(self, brand, model): # Constructor method

self.brand = brand # Property

self.model = model # Property

def display(self): # Method

print(f"This car is a {self.brand} {self.model}.")


7.2 Creating and Using Classes

To create a class, use the keyword class followed by the class name. Inside the class, a special function called the constructor method (__init__) is defined, which gets called every time a new object of that class is instantiated.

class Car:

def __init__(self, brand, model):

self.brand = brand

self.model = model

To create an object of a class (i.e., to instantiate a class), call the class using the class name and pass in whatever arguments its __init__ method accepts.

my_car = Car("Toyota", "Corolla")

To call a method on an object, use the dot notation (.).

my_car = Car("Toyota", "Corolla")

my_car.display() # Output: This car is a Toyota Corolla.


7.3 Inheritance and Polymorphism

Inheritance is a way to form new classes using classes that have already been defined. The newly formed classes are called derived classes, and the classes that we derive from are called base classes.

class Vehicle:

def __init__(self, brand):

self.brand = brand

class Car(Vehicle):

def __init__(self, brand, model): super().__init__(brand)

self.model = model

Polymorphism allows us to use the same method name for different types. In Python, polymorphism occurs naturally, since it allows implicit implementation of an interface right in the class.

class Cat:

def sound(self):

return 'meow'

class Dog:

def sound(self):

return 'woof'


def make_sound(animal):


cat = Cat()

dog = Dog()

make_sound(cat) # Output: meow

make_sound(dog) # Output: woof

In conclusion, OOP allows for code to be reusable, manageable, and easy to maintain. Understanding the principles of OOP and how to implement it in Python is key to writing efficient, effective Python code. In the next chapter, we will explore Python’s exception and error handling capabilities.

bottom of page