DEV Community: Abdikhafar

How Pulse Manor is Redefining Property Security: Preventing Data Leaks and Fraud with AI

Abdikhafar — Mon, 23 Mar 2026 11:17:58 +0000

The real estate industry is no longer just about buildings, tenants, and rent collection.
It has quietly become a data-driven ecosystem — and with that comes a serious risk:

👉 Data leaks, fraud, and unauthorized access.

From tenant identities to financial records and legal documents, property management systems today handle highly sensitive data. One mistake, one vulnerability, and the consequences can be devastating.

But here’s the shift happening right now:

Modern property systems — powered by AI — are not just managing properties anymore. They are actively protecting them.

🚨 The Growing Risk in Property Management

Traditional property management methods were never built for today’s digital risks.

Common vulnerabilities include:

Manual record keeping (spreadsheets, paper files)
Weak access controls
Shared logins across staff
Poor data isolation between properties or organizations
Unsecured document storage (leases, IDs, contracts)

These gaps create opportunities for:

Data breaches
Identity theft
Financial fraud
Cross-organization data exposure

In multi-tenant systems (like modern SaaS platforms), the risk becomes even higher if data is not strictly isolated per organization, property, and user role.

🧠 Enter AI-Powered Property Systems

Modern platforms like Pulse Manor are redefining how property data is handled — by combining:

Intelligent automation
Advanced access control
Real-time monitoring
AI-driven anomaly detection

This isn’t just software.

👉 It’s an active security layer.

🔒 1. Strict Data Isolation (Multi-Tenant Security)

At the core of secure property systems is one principle:

👉 Every piece of data must belong to the correct organization — and only that organization.

Modern systems enforce:

Organization-level isolation
Property-level segmentation
Unit-level data boundaries

This ensures that:

A tenant from Property A can never see data from Property B
A property manager cannot access another organization’s records
Reports, analytics, and exports remain fully scoped

This eliminates one of the most dangerous risks in SaaS systems:
👉 Cross-organization data leakage

👥 2. Role-Based Access Control (RBAC)

Not everyone should see everything.

Modern systems define precise roles, such as:

Property Admin
Property Manager
Tenant
Buyer
Caretaker
Facility Manager

Each role has strict permissions, for example:

Tenants cannot access financial records of others
Caretakers cannot view legal documents
Managers cannot override ownership-level data

AI enhances this further by:

👉 Detecting unusual access patterns and flagging suspicious behavior.

🤖 3. AI-Powered Fraud Detection

This is where things get powerful.

AI doesn’t just store and protect data — it understands behavior.

Modern systems use AI to:

Detect unusual payment patterns
Identify duplicate or suspicious transactions
Flag abnormal login activity
Monitor access attempts across roles and locations

Example:

If a user suddenly tries to access multiple tenant records across different properties,
👉 the system can instantly flag or block it.

This turns your system from passive storage into:

👉 A real-time fraud detection engine

🔐 4. Secure Document Handling

Property systems handle sensitive documents like:

National IDs
Passports
Lease agreements
Ownership contracts

Modern architecture separates document storage by risk level:

Low-risk files (images, maintenance uploads)
High-risk documents (legal, identity, financial data)

These are stored in segregated environments, often with:

Encryption at rest
Access-restricted URLs
Signed access tokens

AI can also scan documents for anomalies or mismatches, reducing fraud during onboarding.

📊 5. Real-Time Monitoring & Audit Logs

Every action in a modern system is tracked.

This includes:

Who accessed what
When it happened
What changes were made

With AI, this becomes even more powerful:

Detects abnormal patterns over time
Identifies insider threats
Predicts potential risks before they happen

This creates full transparency and accountability across the system.

⚡ 6. Automated Workflows Reduce Human Error

Most data breaches don’t happen because of hackers.

They happen because of:

👉 Human mistakes.

Modern systems eliminate this by automating:

Tenant onboarding
Billing and invoicing
Payment tracking
Communication flows

Less manual handling = fewer opportunities for errors or manipulation.

🌍 7. The Shift to Intelligent, Self-Protecting Systems

We are entering a new era where property systems are not just tools.

They are:

Self-monitoring
Self-correcting
Self-protecting

AI is making it possible for systems to:

Learn from behavior
Adapt to threats
Prevent issues before they occur
🚀 Why This Matters Now

As real estate becomes more digital:

Data volume is increasing
Threats are becoming more sophisticated
Regulations around data privacy are tightening

Any system that is not built with security at its core is a liability.

🏁 Final Thoughts

The future of property management is not just about automation.

It’s about trust.

And trust is built on:

Security
Transparency
Intelligence

Modern property systems — powered by AI — are setting a new standard:

👉 Not just managing properties
👉 But actively protecting people, data, and assets

🔗 Experience the Future

Pulse Manor is built with enterprise-grade security, AI intelligence, and strict data isolation at its core.

👉 From tenant management to financial tracking and document security — everything is designed to prevent leaks, fraud, and operational risk.

Ready to see it in action?
Explore Pulse Manor and experience the future of secure property management.

SQL: The Backbone of Modern Data Management

Abdikhafar — Thu, 10 Oct 2024 22:51:45 +0000

Memory updated
SQL: The Backbone of Modern Data Management
In today’s digital age, where vast amounts of data are generated every second, managing this data effectively is crucial for businesses and organizations. Structured Query Language (SQL) is the tool that powers this data-driven world, serving as the standard language for managing and manipulating relational databases. Whether you’re a seasoned developer, a data analyst, or just starting your journey in tech, understanding SQL can significantly enhance your ability to work with data.

What is SQL?
SQL, pronounced “sequel” or “S-Q-L,” stands for Structured Query Language. It was designed in the 1970s to interact with relational databases, a system where data is organized into tables. Each table consists of rows and columns, much like a spreadsheet, and SQL allows users to query, insert, update, delete, and manipulate this data in a highly structured manner.

SQL is an industry-standard language, used in various systems like MySQL, PostgreSQL, Microsoft SQL Server, SQLite, and Oracle Database. Despite slight differences in syntax between these systems, the core SQL commands remain the same, making it a universally valuable skill.

Why is SQL Important?
SQL is essential for several reasons:

Data Management: SQL allows users to efficiently manage and retrieve data from large databases. You can store data, retrieve specific records, and update information all within a few lines of SQL commands.
Data Analysis: With SQL, analysts can extract meaningful insights from raw data, allowing businesses to make informed decisions. Complex queries can be written to analyze trends, filter information, or join multiple datasets.
Widely Used in Industries: SQL is used across industries like finance, healthcare, retail, and technology. Any industry that uses data relies on SQL to process and retrieve it.
High Demand Skill: As more companies rely on data to drive their decision-making processes, SQL has become a high-demand skill. It's often listed as a required skill in job descriptions for roles like data analyst, database administrator, and software engineer.
SQL Basics: Core Concepts
Let’s explore some of the basic concepts of SQL that form the foundation of this language.

Databases and Tables:

A database is a collection of related data, and within a database, data is stored in tables.
Tables are made up of rows (records) and columns (fields). Each column holds a specific type of data like text, integers, or dates.
SQL Queries: SQL queries are the commands that you write to interact with a database. They can be as simple as retrieving all data from a table or as complex as joining multiple tables with specific conditions.

Here are some of the basic SQL commands:

SELECT: Retrieves data from one or more tables.
INSERT: Adds new rows to a table.
UPDATE: Modifies existing data in a table.
DELETE: Removes rows from a table.
Example:

SELECT * FROM customers;

This query selects all columns from the "customers" table.
Filtering Data: The WHERE clause is used to filter records based on specific conditions.

SELECT * FROM customers WHERE age > 30;

This query will retrieve all customers older than 30 years.

Joins: SQL allows you to combine data from multiple tables using JOIN clauses. This is useful when you have related data spread across several tables.

Example:

SELECT orders.order_id, customers.name
FROM orders
JOIN customers ON orders.customer_id = customers.customer_id;

This query retrieves order IDs along with customer names by joining the "orders" table and the "customers" table on a common column.

Aggregate Functions: SQL provides functions to perform calculations on data, such as:

COUNT(): Counts the number of rows.
AVG(): Finds the average value of a column.
SUM(): Adds up the values in a column.
Example:

SELECT COUNT(*) FROM orders WHERE order_status = 'completed';

This counts the total number of completed orders.

Indexes: Indexes improve the speed of data retrieval in large databases. By indexing certain columns, SQL queries can be executed faster, as it reduces the need to scan entire tables.

Advanced SQL Concepts
Once you are comfortable with the basics, you can move on to more advanced SQL concepts.

Subqueries: A subquery is a query within another query, useful when you need to perform multiple operations to get your result.

SELECT name FROM customers WHERE customer_id IN (SELECT customer_id FROM orders WHERE order_date > '2024-01-01');

Transactions: Transactions ensure that a group of SQL operations are executed atomically, meaning either all succeed, or none do. This helps maintain data integrity.

BEGIN TRANSACTION;
UPDATE account SET balance = balance - 100 WHERE account_id = 1;
UPDATE account SET balance = balance + 100 WHERE account_id = 2;
COMMIT;

Stored Procedures: A stored procedure is a set of SQL statements saved in the database, which can be executed as a single unit. This is helpful for tasks that need to be repeated frequently.

CREATE PROCEDURE get_customers()
BEGIN
   SELECT * FROM customers;
END;

Views: Views are virtual tables that result from a SQL query. They simplify complex queries by storing the results in a table-like format.

CREATE VIEW active_customers AS
SELECT * FROM customers WHERE status = 'active';

Best Practices for Writing SQL Queries
Writing SQL queries effectively is an important skill to develop. Here are a few best practices:

Write Readable Queries: Use indentation, aliases, and comments to make your queries more readable, especially when dealing with complex joins and conditions.
Use Proper Indexing: Indexing can dramatically speed up your queries, but excessive indexing can slow down data insertion. Use it wisely.
Limit the Number of Rows: When querying large datasets, use LIMIT to reduce the number of rows returned. This can save processing time.

SELECT * FROM customers LIMIT 100;

*Avoid SELECT : Instead of selecting all columns, choose only the columns you need. This reduces the amount of data being processed and speeds up the query.

SELECT name, email FROM customers;

SQL in the Real World
SQL is used in a wide range of applications. Here are a few real-world use cases that demonstrate the power of SQL:

E-commerce Platforms: SQL is used to manage product inventories, customer data, orders, and payments. Advanced SQL queries help analyze purchasing behavior and optimize product recommendations.

Banking Systems: Banks use SQL to manage transactions, customer accounts, loans, and reports. SQL ensures that transactions are processed securely and accurately, preventing issues like double payments or incorrect balances.

Social Media Platforms: Platforms like Facebook, Twitter, and Instagram rely on SQL databases to store vast amounts of user data. SQL helps in retrieving user profiles, managing relationships between users, and providing personalized content.

Healthcare: In healthcare, SQL databases are used to manage patient records, medical histories, and billing information. Hospitals use SQL to analyze data for improving patient care and streamlining operations.

The Future of SQL
While new database technologies, like NoSQL, have emerged, SQL continues to remain relevant. The structured nature of relational databases and SQL's ability to handle large-scale data operations ensure its longevity.

The future of SQL is expected to evolve alongside trends like:

Cloud Databases: SQL databases are moving to the cloud with platforms like Amazon RDS, Google Cloud SQL, and Azure SQL Database, offering scalable and cost-effective solutions.
Big Data Integration: SQL is increasingly being used in conjunction with big data technologies like Hadoop and Spark, ensuring structured querying capabilities even in large, unstructured datasets.
AI and Machine Learning: SQL databases are now being optimized to handle AI-driven queries

Conclusion
SQL is a powerful and versatile language that forms the backbone of modern data management. From simple queries to complex transactions, it allows you to handle massive datasets efficiently. Whether you’re analyzing customer data, building backend systems, or managing large-scale applications, SQL is an invaluable tool.

By mastering SQL, you not only gain a crucial technical skill but also unlock the ability to extract meaningful insights from data, contributing to better decision-making and business outcomes.

So, what’s next? Start practicing! Dive into databases, explore different SQL systems like MySQL or PostgreSQL, and apply what you’ve learned in real-world scenarios. As you continue to refine your SQL skills, you’ll see how it empowers you to harness the full potential of data.

Happy querying!

Introduction to Data Structures and Algorithms.

Abdikhafar — Thu, 10 Oct 2024 22:18:56 +0000

Why do I need to learn Data Structures and Algorithms in the first place? Will I use them in my workspace?

Hello and welcome. We are going to demystify the importance of familiarizing oneself with data structures and algorithms and why the interviewers prefer them in the interviews.
Set? Buckle up and let's set off...

To start off, what is a Data Structure as well as an Algorithm?
From Wikipedia, a data structure is a data organization, management, and storage format that enables efficient access and modification. In simple terms, a data structure is a way of storing data in an efficient or structured manner. In the real world examples, we have examples like a book rack, kitchen cabinets and shoe racks.
In my Python from the word ...Go article, I have covered inbuilt python data structures which comprise: lists, dictionaries, tuples, and sets. Inbuilt data structures mean that they come with ready syntax to be used by the user. In addition to inbuilt data structures, we have user-defined data structures which comprise: array, stack, queue, linked list, tree, graph, and hashmap. This means that the user has to create them from scratch.
We will not go into depths on the inbuilt data structures but can be found explained in depths in the article.

What then is an algorithm?
An algorithm is a collection of steps to solve a particular problem which can be understood by non-technical people as well. There can be multiple ways and steps to solve a given problem hence there can be multiple algorithms for a specific problem.

Why are Data Structures and Algorithms important?
To start off, data structures and algorithms in interviews act as a clear demonstration to the interviewer on your problem-solving skills.
Secondly, data structures refer to the way we organize information on our computers and you can guess that the way we organize information can have a lot of impact on the performance. A good example is a library. Suppose, one wants to have a book on Calculus from a library, to do so, one has to first go to the math section, then to the Calculus section. If these books had not been organized in this manner and just distributed randomly then it would have been really a cumbersome process to find the book.
In addition, an Algorithm is a step-by-step process in solving a given task. They are developed to help perform a task more efficiently by one applying a predefined approach or methodology. If you write code as per your perception and judgement without applying any predefined algorithm, your code will probably be botched up after a certain time.

To sum up, they help one write efficient code and solve problems in optimal or near-optimal ways. Without them, one will be reinventing the wheel which is not always successfully.

Built-in Data Structures
List
Lists are data structures used to store data in a sequential manner.
They use square brackets.
Every single element in a list is indexed from index 0.
Negative indexing in lists is also supported where the last item in a list is given a -1 index. This helps access of elements from the last to the first.
Data in lists can be modified.
Example of a list:


sample_list = [3, 5, "hello", True, 4.76]
Output: [3, 5, "hello", True, 4.76]

Tuples
Tuples work like lists but data in tuples cannot be modified (immutable).
They use parenthesis/round brackets.
Example of a tuple:


sample_tuple = (1, 3, "Abdikhafar")
Output: (1, 3, "Abdikhafar")

Dictionaries
Data in dictionaries is stored as key-value pairs.
The pairs can be accessed, added, and deleted when needed.
Data is stored in curly braces.
Example:


sample_dict = {"first":"Abdikhafar", "Second":"Issack"}
Output: sample_dict{'first': 'Abdikhafar', 'Second': 'Issack'}

Sets
Sets, like dictionaries, use curly brackets.
They store a collection of unordered unique elements where each data element must be unique.
Example:


my_set = {1, 2, 3, 3, 4, 5, 5}
Output: {1, 2, 3, 4, 5}
Assuming you have a 'stack' of books, to get a book in the middle of the stack, one has to get the book at the top book first followed by the second book... to the book that the person wants to access. In Stack, this approach is known as LIFO (Last-in First-out).
This means that it is a linear data structure where elements are accessed only from the top position.
In Stack, elements can be pushed, accessed, and popped as required.

User-defined data structures
Stack

Assuming you have a 'stack' of books, to get a book in the middle of the stack, one has to get the book at the top book first followed by the second book... to the book that the person wants to access. In Stack, this approach is known as LIFO (Last-in First-out).
This means that it is a linear data structure where elements are accessed only from the top position.
In Stack, elements can be pushed, accessed, and popped as required.


stack = ['first', 'second', 'third']
print(stack)

print()

# pushing elements
stack.append('fourth')
stack.append('fifth')
print(stack)
print()

# printing top
n = len(stack)
print(stack[n-1])
print()

# poping element
stack.pop()
print(stack)

------
(Output)

[‘first’, ‘second’, ‘third’]

[‘first’, ‘second’, ‘third’, ‘fourth’, ‘fifth’]

fifth

[‘first’, ‘second’, ‘third’, ‘fourth’]

Advanced Python

Abdikhafar — Thu, 10 Oct 2024 21:05:37 +0000

Basics Part2

Helloooo there! Welcome back!!

Wait, are you new here? Don't worry, I got you covered. Here, we are breaking the flow. Have you checked "Python from the word ...Go" Basics Part1? It's an awesome resource to first check out if you are not familiar with Python's variables and data types which comprise a few in-built Python data structures.
They are really gonna come in handy for this section.

Set? Lets' go!!

In the previous module, we learnt about the fundamental Python data types and also covered some of the terms used when talking about code like variables, statements, expressions, functions, methods ...etc.
Most importantly, we covered how to perform actions on the data types (Both functions and methods for each data type).
Up until now, we were still scratching the surface. Every time we write code, we wrote it line by line and hence our interpreter would go line by line running each code up to the last line.

>>> #do something
>>> #do something
>>> #do something
>>> #do something

We are now going to incorporate the idea of running multiple lines over and over to discover the true power of programming for machines, haha!
Hence, in this section, we gonna talk about the idea of conditions and conditional logic. We gonna discuss more on looping and loops where we can perform actions multiple times over and over.
We are now going to break into a new world where instead of going from line by line in order, we gonna loop over till a condition is met.

Conditional Logic
We previously covered Boolean variables (True or False). When we come to conditional logic, Booleans are super important.
Example:
A person(a) wants to purchase a car from a company with specific conditions:

The car must be new.
The car must have a license.
Hence for person(a) to purchase the car:

is_new = True

is_licensed = True

In conditional logic, we use the 'if' keyword.
"If the car is new and licensed, then person(a) can purchase it".
Then, if any of the conditions in purchasing the car is not met, person(a) cannot purchase the car.

Example2:
Let's assume that for one to get into a specific event, the person has to be old(35 years and above). Create a program to only allow old people to the event.
If is_old = True, "allowed to get into the event."
For the syntax:

>>> is_old = True
>>> if is_old:
>>>   print("You are allowed to get in")
You are allowed to get in

>>> is_old = False
>>> if is_old:
>>>   print("You are allowed to get in")
#nothing will be printed out.

Note: Any code that comes after the colon in the condition is automatically indented hence run if the condition is True whereas any code that ain't indented after the condition is not under the condition and hence run separately.
Example:

>>> is_old = True
>>> if is_old:
>>>   print("You are allowed to get in")
>>> print("Hello there")
You are allowed to get in
Hello there

>>> is_old = False
>>> if is_old:
>>>   print("You are allowed to get in")
>>> print("Hello there")
Hello there

What if when a condition is not met(False), we want to perform another condition?

Here is an example:
I leave my house;
If it's cloudy, I bring an umbrella;
otherwise, I bring sunglasses.

We use the keyword 'else'.
Using our example of letting people in for the event, we can add:
If is_old = True, "allowed to get into the event.", otherwise if is_old = False, "not allowed to get in",

>>> is_old = True
>>> if is_old:
>>>   print("You are allowed to get in")
>>> else:
>>>   print("Not allowed in")
You are allowed to get in

>>> is_old = False
>>> if is_old:
>>>   print("You are allowed to get in")
>>> else:
>>>   print("Not allowed in")
Not allowed in

What if by chance you have more than one condition?

Example:
I'm in a restaurant;
If I want meat, I order steak;
otherwise, If I want Pasta, I order spaghetti and meatballs;
otherwise, I order salad.

For such cases, we use the 'elif' keyword (else if).
Using a different example.

A person(b) wants to order chicken pizza. If there is no chicken pizza, the person(b) can order beef pizza; otherwise, if there is none, the person(b) can order rice.

>>> chicken_pizza = True
>>> beef_pizza = True

>>> if chicken_pizza:
>>>   print("Serve me chicken pizza.")
>>> elif beef_pizza:
>>>   print("Serve me beef pizza.")
>>> else:
>>>   print("Serve me rice.")
Serve me chicken pizza.

>>> chicken_pizza = False
>>> beef_pizza = True

>>> if chicken_pizza:
>>>   print("Serve me chicken pizza.")
>>> elif beef_pizza:
>>>   print("Serve me beef pizza.")
>>> else:
>>>   print("Serve me rice.")
Serve me beef pizza.

>>> chicken_pizza = False
>>> beef_pizza = False

>>> if chicken_pizza:
>>>   print("Serve me chicken pizza.")
>>> elif beef_pizza:
>>>   print("Serve me beef pizza.")
>>> else:
>>>   print("Serve me rice.")
Serve me rice.

"For a person to be legalized to drive a car in public, one must have a national identification card and a driving license."
These are two conditions that one must have to avoid being fined by the cops.
To develop such a program, we must have both conditions True hence we can use the keyword 'and' to check whether both conditions are True.
When using 'and' both conditions must be True to execute the condition, if any of them is False, the program will run the 'elif' and 'else' part.

>>> has_id = True
>>> has_license = True

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Allowed to drive

>>> has_id = False
>>> has_license = True

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Not allowed to drive

>>> has_id = True
>>> has_license = False

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")

Not allowed to drive
Python Indentation
The interpreter in python finds meaning in the spacing hence indentation(tabs) and white spaces in python is essential.

Truthy Vs Falsy
In python, whenever there's a value, the interpreter recognizes that as True. Otherwise, when there's a zero(0) or no value, python interpreter recognizes that as False.
These are referred to as Truthy and Falsy values.

>>> print(bool('hello'))
>>> print(bool(5))
>>> print(bool(''))
>>> print(bool(0))
>>> print(bool(None))
True
True
False
False
False

All values are considered "truthy" except the following; which are considered "falsy":

None

False

0.0

Decimal(0)

Fraction(0, 1)

[] - an empty list

{} - an empty dict

() - an empty tuple

'' - an empty str

b'' - an empty bytes

set() - an empty set

range(0) - an empty range

Objects for which:

obj.bool() returns False
obj.len() returns 0
Note: A "truthy" value will satisfy the check performed by if or while statements. We use "truthy" and "falsy" to differentiate from the bool values True and False.
Example:

>>> has_id = 'hello'
>>> has_license = 5

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Allowed to drive

>>> has_id = 'hello'
>>> has_license = 0

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Not allowed to drive

>>> has_id = None
>>> has_license = True

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Not allowed to drive

>>> has_id = True
>>> has_license = ''

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Not allowed to driv

e
A good though not perfect example on the use of "truthy" and "falsy" application is in forms or in keying in log in credentials.

Image description

When a field is set to as 'a required field', the system expects the field to be "truthy" hence should not be left blank as this will lead to it being assigned "falsy".

Ternary Operator (Conditional Expression)
This is another way to do conditional logic. This works the same as 'if statements' but can in a way be referred to as a 'shortcut' so can only be used in certain conditional logic.
In this mode, we start with the condition then incorporate the "if statement".
"condition_if_true" if condition else "condition_if_false"

Example:
Let's use an example to determine if a user is your friend (eg. on Facebook whether the user can message you).

>>> is_friend = True
>>> can_message = "Message allowed" if is_friend else "not allowed to message"
>>> print(can_message)
Message allowed

>>> is_friend = True
>>> can_message = "Message allowed" if is_friend else "not allowed to message"
>>> print(can_message)
not allowed to message

Short Circuiting
Previously we saw how to use the 'and' keyword to validate whether both statements are True:

>>> is_friend = True
>>> is_user = True
>>> print(is_friend and is_user)
True

>>> is_friend = True
>>> is_user = False
>>> print(is_friend and is_user)
False

In short circuiting, the interpreter ignores one part of the condition(despite it being false) and returns either True or False.
Example, using the 'or' keyword, if the first part of the condition is True the interpreter returns True without checking the second part.
When we use the 'and' keyword, when the the first part of the statement is False, the interpreter ignores(short circuits) the second part and returns False.
An example using the 'or' keyword:

>>> is_friend = True
>>> is_user = False
>>> print(is_friend or is_user)
True

>>> is_friend = True
>>> is_user = True
>>> print(is_friend or is_user)
True

>>> is_friend = False
>>> is_user = True
>>> if is_friend or is_user:
>>>   print("Best friends forever")
Best friends forever

>>> is_friend = False
>>> is_user = True
>>> if False or is_user:
>>>   print("Best friends forever")
>>> else:
>>>   print("Never friends")
Best friends forever

>>> is_friend = True
>>> is_user = False
>>> if False or is_user:
>>>   print("Best friends forever")
>>> else:
>>>   print("Never friends")
Never friends

>>> if True or True:
>>>   print("Best friends forever")
>>> else:
>>>   print("Never friends")
Best friends forever

Logical Operators
We have looked at a few logical operators previously 'and' and 'or'. A logical operator allows us to perform logic between two things.
Other logical operators include:

Greater than >

Less than <

Equal to ==

Greater than or equal to >=

Less than or equal to <=

Not equal to != (Opposite of equal to)

not keyword / Function - It negates the statement. Can also be written with bracket: not().


They return either True or False:
>>> print(4 > 5)
False

>>> print(4 < 5)
True

>>> print(4 == 5)
False

>>> print(1 >= 0)
True

>>> print(1 <= 0)
False

>>> print(0 >= 0)
True

>>> print(0 != 0)
False

>>> print(not(True))
False

>>> print(not True)
False

>>> print(not False)
True

>>> print(not(1 == 1))
False

>>> print(not(1 != 1))
True

Note: A single equal sign = symbol is used in assigning values to variables hence to use the "equal to" operator for comparison, we use a double == symbol.

>>> print('a' > 'b')
False

>>> print('a' > 'A')
True

But why/how is 'a' > 'b' False; and 'a' > 'A' True?

In the case of strings, Python compares the ASCII values of the characters. Hence, 'a' ASCII value is 97, 'b' is 98 and 'A' ASCII value is 65 that's why 'a' is greater than 'A' and 'b' is greater than 'a'.

*optional
In the case of, print('abc' < 'bac'), the result will be True. (Though this is a bit beyond the scope of the course).
This kind of comparison uses lexicographical ordering: first the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared, and so on, until either sequence is exhausted.

Lexicographical ordering for strings uses the Unicode code point number to order individual characters.

>>> print(1 < 2 < 3 < 4)
True

>>> print(1 < 2 > 3 < 4)
False

Exercise1 (Done below)
You have been hired by a gaming company to create a program for a game where the character has magic powers and is an expert.
If the character has magic and is an expert, the output should be "You are a master magician". Otherwise, if the character has magic but is not an expert, the output should be "At least you're getting there". Else, if the character has no magic, the output should be "You need magic powers".

>>> print("Enter '1'(Yes) or '0'(No) for each question.")
>>> has_magic = bool(int(input("Does the character has magic? ")))
>>> is_expert = bool(int(input("Is the character an expert? ")))

>>> if has_magic and is_expert:
>>>   print("You are a master magician.")
>>> elif has_magic and not is_expert:
>>>   print("At least you're getting there.")
>>> elif not has_magic:
>>>  print("You need magic powers.")
Enter '1'(Yes) or '0'(No) for each question.
Does the character has magic? _1_
Is the character an expert? _1_
You are a master magician.

(Re-run the program)
Enter '1'(Yes) or '0'(No) for each question.
Does the character has magic? 0
Is the character an expert? 1
You need magic powers.

(Re-run the program)
Enter '1'(Yes) or '0'(No) for each question.
Does the character has magic? 1
Is the character an expert? 0
At least you're getting there.
'is' keyword
Unlike the double equal sign ==, which compares the equality in values, is is a keyword that checks if the location in memory where one value is stored is the same as the other's.

Example:
>>> print(True == 1)
>>> print('' == 1)
>>> print('1' == 1)
>>> print([] == 0)
>>> print(10 == 10.0)
>>> print([] == [])
>>> print([1, 2, 3] == [1, 2, 3])
True
False
False
False
True
True
True

>>> print(True is 1)
>>> print('' is 1)
>>> print('1' is 1)
>>> print([] is 0)
>>> print(10 is 10.0)
>>> print([] is [])
>>> print([1, 2, 3] is [1, 2, 3])
False
False
False
False
False
False
False

>>> print(True is True)
True

>>> print('1' is '1')
True

>>> print(10 is 10)
True

Once a list is created, it is stored in different memory space hence print([] is []) or print([1, 2, 3] is [1, 2, 3]) will always evaluate to False.

All Data Structures in Python are stored in different memory locations.

For Loops
Loops are one of the most powerful features of a programming languages. The concept of looping allows us to run lines of code over and over till we accomplish a specific task.
In creating a for loop, we use the keyword 'for'.
Example: for i in 'name':
'i' in the loop is a variable for each element in the loop and can be any different name: for item in 'name':, for teddy in 'name': and is created for each item in 'name'(iterable).
An iterable is something that can be looped over.

>>> for item in 'name':
>>>    print(item)
n
a
m
e

>>> for item in [1, 2, 3, 4]:
>>>    print(item)
1
2
3
4

>>> name = 'Mark'
>>> for i in name:
>>>    print(i)
M
a
r
k

>>> for item in {1, 2, 3, 4}:
>>>    print(item)
1
2
3
4

>>> for item in (1, 2, 3, 4):
>>>    print(item)
1
2
3
4

>>> for item in (1, 2, 3, 4):
>>>    print(item)
>>>    print(item)
>>>    print(item)
>>> print("Hello")

1
1
1
2
2
2
3
3
3
4
4
4
Hello

>>> for item in (1, 2, 3, 4):
>>>    print(item)
>>>    print(item)
>>>    print(item)
>>> print(item)
1
1
1
2
2
2
3
3
3
4
4
4
4
Nested for loops
>>> for item in (1, 2, 3, 4, 5):
>>>     for x in ['a', 'b', 'c']:
>>>         print(item, x)
1 a
1 b
1 c
2 a
2 b
2 c
3 a
3 b
3 c
4 a
4 b
4 c
5 a
5 b
5 c

Iterables
An iterable is an object or a collection that can be iterated over (looped over).
An iterable can be a list, tuple, dictionary, set and string. This means that one can go one by one checking each item in the collection.

Iterating over a dictionary

>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for item in user:
>>>     print(item)
name
age
can_swim

When we iterate over a dictionary we only get the keys but can use the dictionary methods to loop over the dictionary items which includes its values.

One is 'x.items()' where we get the key-value pairs in tuples form.

>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for item in user.items():
>>>     print(item)
('name', 'Mark')
('age', 30)
('can_swim', False)

Second is 'x.values()' where we get only the values in the

dictionary.
>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for item in user.values():
>>>     print(item)
Mark
30
False

Third is 'x.keys()' where we get only the keys in the dictionary. Works the same as iterating the dictionary without including a method.

>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for item in user.keys():
>>>     print(item)
name
age
can_swim

What if you want to print the items (key and values) in the dictionary separately? We can use tuple unpacking.

>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for item in user.items():
>>>     key, value = item
>>>     print(key, value)
name Mark
age 30
can_swim False

(second way of unpacking)


>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for key, value in user.items():
>>>     print(key, value)
name Mark
age 30
can_swim False

Exercise2 (Done below)
Building a simple 'counter' to loop over a list and sum up the items in the list. The list is provided below.
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> sum = 0
>>> for i in my_list:
>>>     sum += i
>>> print (sum)
55

range() in loops
It returns an object that produces a sequence of integers from the start (which is inclusive) to stop (exclusive).

>>> print(range(100))
range(0, 100)

>>> print(range(0, 100))
range(0, 100)

We can iterate a range of numbers.

>>> for num in range(20)
>>>    print(num)
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

>>> for i in range(2, 15)
>>>    print(i)
2
3
4
5
6
7
8
9
10
11
12
13
14

>>> for i in range(10):
>>>    print('my name is')
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is

When one 'does not want to use' a variable name in the loop, the person can use an underscore _:

>>> for _ in range(20)
>>>    print(_)
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

>>> for _ in range(10):
>>>    print('my name is')
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is
(start: stop: stepover) in range()
>>> for _ in range(0, 10, 2)
>>>    print(_)
0
2
4
6
8

>>> for _ in range(0, 10, -1)
>>>    print(_)
#nothing will be printed out

>>> for _ in range(10, 0, -1)
>>>    print(_)
10
9
8
7
6
5
4
3
2
1

>>> for _ in range(10, 0, -2)
>>>    print(_)
10
8
6
4
2

>>> for _ in range(2)
>>>    print(list(range(10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

enumerate()
It returns each item in the iterable with its index in tuple form.

>>> for i in enumerate('mark'):
>>>    print(i)
(0, 'm')
(1, 'a')
(2, 'r')
(3, 'k')

>>> for i, j in enumerate('mark'):
>>>    print(i, j)
0 m
1 a
2 r
3 k

>>> for i, char in enumerate(list(range(100))):
>>>     if char == 50:
>>>         print(f"The index of 50 is: {i}")
The index of 50 is: 50

>>> for i, j in enumerate('Mark'):
>>>     if j == 'r':
>>>         print(f"The index of r is: {i}")
The index of r is: 2

While Loops
In While loop, a command is run when a specific condition is met till the condition becomes false after constant looping.

eg:
>>> i = 0
>>> while 0 < 50:
>>>     print(i)
0
0
0
0
0

will run infinitely for 0 will always be less than 50.


>>> i = 0
>>> while i < 50:
>>>     i += 5
>>>     print(i)
5
10
15
20
25
30
35
40
45
50

break command in while loop
When a break keyword is used in while loop, it breaks the loop after the first run.

>>> i = 0
>>> while 0 < 50:
>>>     print(i)
>>>     break
0

using else in while loop

>>> i = 0
>>> while i < 50:
>>>     i += 5
>>>     print(i)
>>> else:
>>>     print("Done with work")
5
10
15
20
25
30
35
40
45
50
Done with work

>>> i = 0
>>> while i > 50:
>>>     i += 5
>>>     print(i)
>>> else:
>>>     print("Done with work")
Done with work

The else block in while loop will only execute when there is no break statement in the while loop.

>>> i = 0
>>> while i < 50:
>>>     i += 5
>>>     print(i)
>>>     break
>>> else:
>>>     print("Done with work")
0

How for loops and while loops relates

>>> my_list = [1, 2, 3]
>>> for item in my_list:
>>>     print(item)
1
2
3

------------------------------------
>>> my_list = [1, 2, 3]
>>> i = 0
>>> while i < len(my_list):
>>>     print(my_list[i])
>>>     i += 1 
1
2
3

While loops are more flexible for we have a conditional statement but for loops are simpler. With the while loop, we have to remember to hope the loop in the course or use a break statement, to avoid getting an infinite loop.

>>> while True:
>>>     input("Say something: ")
>>>     break
Say something: _hi_

>>> while True:
>>>     response = input("Say something: ")
>>>     if (response == "bye"):
>>>         break
Say something: _hi_
Say something: _hi_
Say something: _bye_

break, continue, pass
The break keyword breaks out of the loop. The continue keyword continues the loop till the condition is met without running the indented line(s) below it. The pass keyword is used to pass to the next line. It is mainly used as a placeholder.

>>> my_list = [1, 2, 3]
>>> for item in my_list:
>>>    continue
>>>    print(item)
#nothing will be printed

>>> i = 0
>>> while i < len(my_list):
>>>    i += 1
>>>    continue
>>>    print(my_list[i])
#nothing will be printed

>>> my_list = [1, 2, 3]
>>> for item in my_list:
>>>    pass

>>> i = 0
>>> while i < len(my_list):
>>>    print(my_list[i])
>>>    i += 1
>>>    pass
1
2
3

Functions
Up until now, we've worked with python functions like print, list, input function and many more that allowed us to perform actions on our data types.
We can also create our own functions and use them on our program.
When creating functions in Python we use the def - 'define' keyword. We then give our function a name (defining the function) as we do with variables then we add the brackets () and a colon at the end.
For one to use a function one has to 'call it'.

>>> def say_hello(): #defining the function
>>>    print("Hellooo")
>>> say_hello() #calling the function

Hellooo
Functions are super useful because the work under the principle of 'DRY - Don't Repeat Yourself' because instead of the programmer re-typing the code each and every time, the programmer can just call the function as many times as possible to run a specific block of code.

Example: Using our Christmas tree example above, we can use the function to output it multiple of times.

>>> picture = [
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 1, 1],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0]
    ]

>>> def show_tree():
>>>    for row in picture:
>>>        for pixel in row:
>>>            if pixel == 0:
>>>                print(" ", end = ' ')
>>>            else:
>>>                print("*", end = ' ')
>>>        print(" ")

>>> show_tree()
>>> show_tree()
>>> show_tree()

      *        
    * * *      
  * * * * *
* * * * * * *
      *
      *
      *
    * * *
  * * * * *
* * * * * * *
      *
      *
      *
    * * *
  * * * * *
* * * * * * *
      *
      *

The function is stored in a specific place in memory once created.

>>> def say_hello(): 
>>>    print("Hellooo")
>>> print(say_hello)
<function say_hello at 0x000002332BB33E20>

The characters '0x000002332BB33E20' show the memory location where the function has been stored.

Arguments Vs Parameters(in functions)
The power of functions beyond it being able to be called multiple times, is the ability of the programmer to make it dynamic. In its brackets, one can pass parameters.
The values which are defined at the time of the function prototype or definition of the function are called as parameters.
When a function is 'called', the actual values that are passed during the 'call' are called as arguments.

>>> def say_hello(name, age): #name and age are parameters.
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello("Abdikhafar", 20) #"Mark" and 20 are arguments.
Hello Abdikhafar, You're 20 yrs

>>> def say_hello(name, age):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello("Mark", 20)
>>> say_hello("Emily", 19)
>>> say_hello("Dan", 17)
Hello Mark, You're 20 yrs
Hello Emily, You're 19 yrs
Hello Dan, You're 17 yrs

The above arguments are referred to as positional arguments because they are required to be in the proper position.

>>> def say_hello(name, age):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello(20, "Abdikhafar")
Hello 20, You're Abdikhafar yrs

Default Parameters and Keyword Arguments
Keyword arguments, as opposed to positional arguments, allow us to not worry about the position hence the arguments can be in any position.
However this makes the code more complicated and not a proper practice way.

>>> def say_hello(name, age):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello(age = 20, name = "Abdikhafar")
Hello Abdikhafar, You're 20 yrs

Default parameters allow us to give constant values as we define the function. Default parameters only work when no values have been passed as arguments to the function.

>>> def say_hello(name = "Emily", age = 17):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello()
Hello Emily, You're 17 yrs

>>> def say_hello(name = "Emily", age = 17):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello("Dan", 23)
>>> say_hello()
Hello Dan, You're 23 yrs
Hello Emily, You're 17 yrs

>>> def say_hello(name = "Emily", age = 17):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello("Irene")
Hello Irene, You're 17 yrs

Return Statement
This is a keyword in python mostly used together with functions.
Functions always have to return something and when there is no return statement, the function will always return None.

>>> def sum(num1, num2):
>>>    num1 + num2
>>> print(sum(4, 5))
None

When the return statement is used;

>>> def sum(num1, num2):
>>>    return num1 + num2
>>> print(sum(4, 5))
9

A function should do one thing really well and/or should return something. This however doesn't mean that the code only has to be one line.

>>> def sum(num1, num2):
>>>    return num1 + num2
>>> total = sum(10, 5)
>>> print(sum(10, total))
25

>>> def sum(num1, num2):
>>>    return num1 + num2
>>> print(sum(10, sum(10, 5)))
25

>>> def sum(num1, num2):
>>>    def another_func(num1, num2):
>>>       return num1 + num2
>>> total = sum(10, 20)
>>> print(total)
None

def sum(num1, num2):
   def another_func(num1, num2):
      return num1 + num2
   return another_func
total = sum(10, 20)
print(total)
<function sum.<locals>.another_func at 0x000002387BF49B40>

>>> def sum(num1, num2):
>>>    def another_func(num1, num2):
>>>       return num1 + num2
>>>    return another_func
>>> total = sum(10, 20)
>>> print(total(10, 20))
30

>>> def sum(num1, num2):
>>>    def another_func(num1, num2):
>>>       return num1 + num2
>>>    return another_func(num1, num2)
>>> total = sum(10, 20)
>>> print(total)
30

To avoid confusion when working with more than one function (function in a function), it is advisable to use different names for the parameter.

>>> def sum(num1, num2):
>>>    def another_func(n1, n2):
>>>       return num1 + num2
>>>    return another_func(num1, num2)
>>> total = sum(10, 20)
>>> print(total)
30
Note: A return keyword automatically exits the function in that any code (to output) below the return statement is never run.
>>> def sum(num1, num2):
>>>    def another_func(n1, n2):
>>>       return num1 + num2
>>>    return another_func(num1, num2)
>>>    return 5
>>>    print("Hello")
>>> total = sum(10, 20)
>>> print(total)
30

Methods Vs Functions
Examples of inbuilt functions in python include : list(), print(), max(), min(), input(). We've also found out that we can use the keyword def to define our own functions.

When using methods, we use the dot(.) notation. Methods are owned by 'whatever is to the left of the dot(.)' be it strings, tuples, integers etc. Methods of the fundamental data types have been covered in the previous module where all the data types have been covered too.
Both Functions and Methods allow us to take actions on the data types.
None: Similar to functions, we can also build our own methods which will be explained in details in the next module as we discuss on 'classes and objects'.

Docstrings
This is using triple quotes ('''...''') to 'comment' multiple lines. It can also be used in functions to give more info about a function.

Image description

It works the same as the more info about a function provided by the developer environments when typing the inbuilt functions.

Image description

Help function
Used to give more info about a function. When a docstring is passed in a function, the help function returns the docstring.

>>> help(print)

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file:  a file-like object (stream); defaults to the current sys.stdout.
sep:   string inserted between values, default a space.
end:   string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.

>>> def test(a):
       '''
       Info: This is a function that prints the testing data.
       '''
       print(a)
>>> help(test)
test(a)

Info: This is a function that prints the testing data.

We can also use the dunder method (Magic method) 'will get into it later in the course' to get more info on a function.

>>> def test(a):
       '''
       Info: This is a function that prints the testing data.
       '''
       print(a)
>>>print(test.__doc___)

Info: This is a function that prints the testing data.
Docstrings are really useful to add comments and definition to a function to enable other people understand what your function does without searching through your multiple files.

Writing clean code

>>> def is_even(num):
>>>    if num % 2 == 0:
>>>      return True
>>>    elif num % 2 != 0:
>>>      return False
>>> print(is_even(50))
True
Vs
>>> def is_even(num):
>>>    if num % 2 == 0:
>>>      return True
>>>    else:
>>>      return False
>>> print(is_even(50))
True
Vs
>>> def is_even(num):
>>>    if num % 2 == 0:
>>>      return True
>>>    return False
>>> print(is_even(50))
True
Vs
>>> def is_even(num):
>>>    return num % 2 == 0
>>> print(is_even(50))
True

*args and **kwargs
*args - arguments
**kwargs - Keyword arguments

In function we have special characters called *args and **kwargs.

>>> def super_func(num):
>>>    return sum(num)
>>> super_func(1, 2, 3, 4, 5)

returns an error because the function should take just 1 positional argument but we gave 5.

_args (adding an asterisk at the start of the parameter) allows one to pass more than one positional argument.

>>> def super_func(*num):
>>>    print(*num)
>>>    return sum(num)
>>> super_func(1, 2, 3, 4, 5)
1 2 3 4 5

>>> def super_func(*num):
>>>    print(num)
>>>    return sum(num)
>>> super_func(1, 2, 3, 4, 5)
(1 2 3 4 5)

>>> def super_func(*num):
>>>    return sum(num)
>>> print(super_func(1, 2, 3, 4, 5))
15

__kwargs allows us to use keyword arguments. It returns a dictionary of the values.

>>> def super_func(*num, **kwargs):
>>>    print(kwargs)
>>> super_func(1, 2, 3, 4, 5, num1=10, num2=15)
{'num1': 10, 'num2': 15}

>>> def super_func(*num, **kwargs):
>>>    print(kwargs)
>>>    total = 0
>>>     for items in kwargs.values():
>>>        total += items
>>>     return sum(num) + total
>>> print(super_func(1, 2, 3, 4, 5, num1=10, num2=15))
{'num1': 10, 'num2': 15}
40

There's a rule of positioning when one is using parameters, default parameters, *args and **kwargs:

parameters, *args, default parameters, **kwargs

>>> def super_func(name, *num, greet="hi", **kwargs):
>>>    print(kwargs)
>>>    total = 0
>>>     for items in kwargs.values():
>>>        total += items
>>>     return sum(num) + total
>>> print(super_func("Andy", 1, 2, 3, 4, 5, num1=10, num2=15))
{'num1': 10, 'num2': 15}
40


>>> my_list = [10, 2, 3, 4, 8, 11]
>>> even_list = []
>>> def highest_even():
>>>    for i in my_list:
>>>       if i % 2 == 0:
>>>          even_list.append(i)
>>>          even_list.sort()
>>>    print(even_list[-1])
>>> highest_even()
10
We can also use the max keyword to return the maximum even number:
>>> my_list = [10, 2, 3, 4, 8, 11]
>>> def highest_even():
>>>    even_list = []
>>>    for i in my_list:
>>>       if i % 2 == 0:
>>>          even_list.append(i)
>>>    return max(even_list)
>>> print(highest_even())
10

Scope
"What variables do I have access to?"
>>> print(name)
#returns an error; NameError: name 'name' is not defined
Once a variable is not defined, one cannot have access to it.
A variable with a global scope is a variable that can be accessed by anybody in the file and can be used anywhere; in the conditional logic; in the while loop; in a function, etc.

total = 100
print(total)
10

0

#total has a global scope
A variable with a functional scope is a variable that can only be accessed in within the function.

def some_func():
total = 100
print(total)

#returns an error; NameError: name 'total' is not defined

def some_func():
total = 100
print(total)
100

Scope Rules
"What would you expect the output of the code below to be?"

a = 1
def confusion():
a = 5
return a
print(a)
print(confusion())

The output will be 1 and 5. This is because the first print function, print(a), outputs the value stored in the a with the global scope while the second print function, print(confusion()), returns the value stored in the a variable in the function.
The a is not modified after the function because of scope.

Rules the interpreter follow in scope:

1. Local Scope - Scope within the functional scope.

a = 1
def confusion():
a = 5
return a
print(confusion())
print(a)
5
1

a = 1
def confusion():
return a
print(confusion())
print(a)
1
1

2. Parent Local scope - Works where there's a function within a function.

a = 1
def parent():
a = 10
def confusion():
return a
return confusion()
print(parent())
print(a)
10
1

3. Global scope

a = 1
def parent():
def confusion():
return a
return confusion()
print(parent())
print(a)
1
1

4. Built in python functions

a = 1
def parent():
def confusion():
return sum
return confusion()
print(parent())
print(a)

1

Note: Parameters are part of the local scope:

b = 10
def confusion(b):
print(b)
confusion(300)
300

b = 10
def confusion(b):
print(b)
confusion(b)
10

Global keyword
"What if one wants to refer to a global variable while in the function without creating a new variable?"
Example:

total = 0
def count():
total += 1
return total
print(count())

#returns an error; UnboundLocalError: local variable 'total' referenced before assignment
The error occurs because the function count does not recognize total. Hence, we have to add a variable total in the function:

total = 0
def count():
total = 0
total += 1
return total
print(count())
1

To avoid recreating another variable in the function we can use the global keyword to tell the interpreter that we want to use the global scope on the variable in the function.

total = 0
def count():
global total
total += 1
return total
print(count())
1

total = 0
def count():
global total
total += 1
return total
count()
count()
print(count())
3

Dependency injection (A simplified version of global scope)

total = 0
def count(total):
total += 1
return total
print(count(total))
1

total = 0
def count(total):
total += 1
return total
print(count(count(count(total))))
3

Nonlocal Keyword
This is a new keyword(feature) in python 3 and its used to refer to the parent local scope.

def outer():
x = "local"
def inner():
nonlocal x
x = "nonlocal"
print("inner:", x)
inner()
print("outer:", x)
outer()
inner: nonlocal
outer: nonlocal

#Without the nonlocal keyword

def outer():
x = "local"
def inner():
x = "nonlocal"
print("inner:", x)
inner()
print("outer:", x)
outer()
inner: nonlocal
outer: local

Why do we need scope?

"Why not just have every variable with a global scope so that everything has access to everything?"
Machines don't have infinite power/memory hence we need to be cautious of the resources we use. Scope is a good demonstration of this.
Eg. When a function is run, we create one memory space hence when for instance we use nonlocal, we instead of creating another memory space, we use an existing one.

Hurraay!! 🥳
We come to the end of the second module. Hope you've learnt a lot and ready to implement the skills in different fields.
As we wrap up, here is a simple exercise for you to try before checking the answer done below:

age = input("What is your age?: ")
if int(age) < 18:
print("Sorry, you are too young to drive this car. Powering off!")
elif int(age) > 18:
print("Powering On. Enjoy the ride!");
else:
print("Congratulations on your first year of driving. Enjoy the ride!")

Given the code above, perform the actions below on the code:

Wrap the above code in a function called checkDriverAge() that whenever you call this function, you will get prompted for age.

Instead of using the input(), make the checkDriverAge() function accept an argument of age, so that if you enter eg. checkDriverAge(92), it returns "Powering On. Enjoy the ride!"

Make the default age set to 0 if no argument is given.

Answer:

def checkDriverAge(age=0):
if int(age) < 18:
print("Sorry, you are too young to drive this car. Powering off")
elif int(age) > 18:
print("Powering On. Enjoy the ride!");
else:
print("Congratulations on your first year of driving. Enjoy the ride!")
checkDriverAge(10)
Sorry, you are too young to drive this car. Powering off



What next? 🤔
Let's meet in the next module #Advanced Python1.

Till next time; bye bye.

Python from the word ...Go

Abdikhafar — Thu, 10 Oct 2024 19:04:51 +0000

Basics Part1
By Abdikhafar Issack

Introduction
What is programming?
In simple terms, programming is a way for us to give instructions to computers. "Giving it an instruction manual, and the computer follows".

Computers don't understand English or any other human language for that matter. Computers speak in 1s and 0s; On or Off (So is all the other electronic component).
But for humans, it would be gibberish or rather difficult to communicate in 1s or 0s. Humans have then developed programming languages that work in between human language and machine language (0s / 1s).
Some programming languages are low-level (closer to machine language) while others are high-level (closer to human language).
Examples of low-level programming languages include:

Assembly
Examples of high-level programming languages include:

Python
JavaScript
What then is a programming language?
A programming language is any set of rules that convert strings, or graphical program elements, to various kinds of machine code output (that is understandable to the computer).

Note: At the end of the day, all programming languages do the same thing, they tell the machine what to do. However, different languages have different modes of doing it.
The beauty is that "most languages have very similar principles."

The hardest part is only in learning the first language.

In between the programming language and the machine language, we need a 'translator' that understands both the programming language (source code) and machine language and hence can translate our code to machine language for the computers to understand.
*The translator ain't a person but rather another program that can either be an interpreter or a compiler.
Like a translator, an interpreter goes line by line throughout the code and executes the code on the machine. In contrast, a compiler takes the code and reads the entire file all at once and translates it to machine code. (Their other major differences are a little complicated and beyond the scope of the course)
Python usually uses an interpreter hence to use python you have to download the interpreter.

First "Hello World" Program
After setting up the interpreter, we can use the terminal (Command Prompt, GIT Bash, PowerShell, Termux ...etc) to run a few of python commands.
Open the terminal and first run 'python' command. Secondly, use the python command "print" to display characters.

>>> print("I am using python") I am using python

Setting up the environment (IDE Setup)
We have previously just run our first python program but in a profession, one cannot run the entire company's program on the terminal. It is mainly used for quick testing.
In most cases, we use code editors or IDEs to run python programs.

Why not write code in a word document or a text file?

In a word document, the code will be in form of text hence in case of a syntax error, no information will be returned. In addition, professional developers need some extra tools that code editors and IDEs provide that help them to be more efficient with their code.

What is a code editor and an IDE, and what is their difference?
Code editors are lightweight and give some features like auto-completion, while IDEs are full-fledged environments and provide a tone of extra features like debugging, auto-completion, code formatting, code snippets ...etc.
The most popular code editors and IDEs for Python include: Sublime Text, Visual Studio Code, PyCharm and Jupyter Notebooks.

Python Basics
In order for any programmer to learn a language, there are 4 key things that they really need to master:

i). Terms of the language - Different words and definitions are used in the language eg. Variables, statements, and instantiation.
ii). Language Data Types - Integers, strings ...etc.
iii). Actions - Using memory and performing some actions.
iv). Best practices of writing a language.

Variables Variables are memory locations that store information that can be used in a program. They act like 'containers' that store/hold an item(s). They can hold user(s) input, values ..etc. eg.

>>> name = "Abdikhafar"
>>> print(name)
Abdikhafar

Hence, 'name' is a variable that stores the name, Mark.

>>> iq = 190
>>> print(iq)
190

Note: Assigning a value to a variable is known as binding.

Rules of declaring variables

snake_case is_driving = True

Python Data Types

-Text Type:
str - string

-Numeric Types:
int - integer
float
complex

-Sequence Types:
list
tuple
range

-Mapping Type:
dict - dictionary

-Set Types:
set
frozenset

-Boolean Type:
bool - boolean

-Binary Types:
bytes
bytearray
memoryview

a.) int - Integer
An integer is a whole number with no decimal point; 1, 2, 3, 4, 456, -4643, -77.

>>> print(2 + 4)
6

>>> print(2 - 4)
-2

>>> print(2 * 4)
8

>>> print(type(2))
<class 'int'>

>>> print(type(-29))
<class 'int'>

>>> print(type(2 + 4))
<class 'int'>

>>> print(type(2 - 4))
<class 'int'>

b.) float
These are numbers with a decimal point; 5.7, 8.0, 3.5554, 0.00003, -0.543, -4.229.

>>> print(2 / 4)
0.5

>>> print(type(2.7))
<class 'float'>

>>> print(type(-27.554))
<class 'float'>

>>> print(type(2.8 + 4))
<class 'float'>

>>> print(type(2 / 4))
<class 'float'>

Note: - floats take up a lot of space in memory than integers.
This is because the number(s) need to be stored in memory in binary form. But when there's a decimal place eg. 10.56, it is difficult to represent that in a binary form(0s / 1s) because of the point '.' hence a floating-point number is stored in two different locations eg. one for 10 and the other for 56.

Operations on integers and floats.
operators + , - , * , / , ** , // , %

----- addition
----- subtraction
----- multiplication / ----- division

** ---- 'power of'

>>> print(2 ** 4)
16

>>> print(7 ** 9)
40,353,607

// ---- 'rounds down the quotient to the nearest whole number'
eg.

>>> print(2 // 4)
0

>>> print(3 // 4)
0

>>> print(4 // 4)
1

>>> print(5 // 4)
1

>>> print(7 // 4)
1

>>> print(9 // 4)
2

Math Functions (Actions performed on integers and floats).
i) round - rounds off the number to the nearest whole number.

>>> print(round(3.1))
3

>>> print(round(3.9))
4

ii) abs - returns the absolute value of the argument.

>>> print(abs(-20))
20

>>> print(abs(-354))
354

>>> print(abs(44))
44

iii) pow - used to calculate a number to its specific power.

>>> print(pow(2,3))
8

>>> print(pow(4,3))
64

iv) max - returns the highest number.

>>> print(max(2,3))
3

>>> print(max(2,-9))
2

v) min - returns the least number.

>>> print(min(3,8))
3

>>> print(min(2,-9))
-9

For most of the other mathematical functions to be used, they have to be 'imported' from the math module.
from math import *
The * symbol means 'everything' hence we import all the functions from the math module.

i) floor - rounds down the number.

>>> from math import *

>>> print(floor(3.7))
3

>>> print(floor(5.9))
5

ii) ceil - rounds up the number.

>>> from math import *

>>> print(ceil(3.2))
4

>>> print(ceil(5.9))
5

>>> print(ceil(5.3))
5

iii) sqrt - returns the square root of a number

>>> from math import *

>>> print(sqrt(4))
2.0

>>> print(sqrt(9))
3.0

>>> print(sqrt(121))
11.0

Operator Precedence (BODMAS)
B - brackets
O - power off
D - division
M - multiplication
A - addition
S - subtraction

>>> print(20 - 3 * 4)
8

>>> print((20 - 3) * 4)
68

>>> print((20 - 3) + 2 ** 2)
21

Working with strings
String Concatenation
Concatenation is the action of linking things together in a series hence, string concatenation is joining multiple strings to one in series.

>>> first_name = "Abdi"
>>> second_name = "khafar"
>>> full_name = first_name + second_name
>>> print(full_name)
Abdikhafar

>>> first_name = "Abdi"
>>> second_name = "Khafar"
>>> full_name = first_name + ' ' + second_name
>>> print(full_name)
Abdi Khafar

Type Conversion
This is converting a value from one data type to another.

>>> print(type(str(100)))
<class 'str'>

>>> a = str(100)
>>> b = int(a)
>>> a_type = type(a)
>>> b_type = type(b)
>>> print(a_type)
<class 'str'>
>>> print(b_type)
<class 'int'>

Escape Sequences
We use a backslash.

>>> weather = 'It\'s sunny'
>>> print(weather)
It's sunny

>>> weather = "It's \"kind of\" sunny"
>>> print(weather)
It's "kind of" sunny

>>> weather = 'It\\s sunny'
>>> print(weather)
It\s sunny

\t is used to add a tab to the output.

>>> weather = '\t It\'s sunny'
>>> print(weather)
    It's sunny

\n is used to take the part after it to a new line.

>>> weather = "It's sunny \n hope you have a good day."
>>> print(weather)
It's sunny
hope you have a good day

Formatted Strings (f-string)
An 'f' is added at the start of the expected output.

>>> name = "Johnny"
>>> age = 55
>>> print ("hi" + name + ". You are" + str(age) + "years old.")
hi Johnny. You are 55 years old.

(can also be written as)

>>> name = "Johnny"
>>> age = 55
>>> print (f"hi {name}. You are {age} years old.")
hi Johnny. You are 55 years old.

String Indexes
A string is stored in a memory as ordered pieces of characters.

my name is
0123456789

To access each character in a string, we use an index. Indexing starts from zero(0).

>>> sentence = "my name is Mark"
>>> print(sentence[3])
n

>>> sentence = "my name is Mark"
>>> print(sentence[8])
i

Extra ways to access the values using the indexes:

>>> number = '01234567'
>>> print(number[1:])
1234567

>>> number = '01234567'
>>> print(number[:5])
01234

>>> number = '01234567'
>>> print(number[::2])
0246

>>> number = '01234567'
>>> print(number[-1])
7

>>> number = '01234567'
>>> print(number[-2])
6

>>> number = '01234567'
>>> print(number[-3])
5

>>> number = '01234567'
>>> print(number[::-1])
76543210

>>> number = '01234567'
>>> print(number[::-2])
7531

Immutability
Strings in Python are immutable (they cannot be changed).

Built-in string Functions and methods
len() - used to find the number of characters in a string.

>>> greet = "Hello"
>>> print(len(greet))
5

x.upper() - capitalizes or changes the entire string to uppercase.

>>> greet = "Hello"
>>> print(greet.upper)
HELLO

x.lower() - changes the entire string to lowercase.

>>> greet = "hello"
>>> print(greet.capitalize)
Hello

x.isupper() - returns either True or False on whether the string is in uppercase.

x.islower() - returns either True or False on whether the string is in lowercase.

Using functions in combination with each other.

>>> phrase = "My name is Mark"
>>> print(phrase.upper().isupper())
True

x.find() - returns the index of the character(s) you're looking for in the string.

>>> quote = "to be or not to be"
>>> print(quote.find("be"))
3

x.replace() - used to replace character(s) in a string with new character(s).

>>> quote = "to be or not to be"
>>> print(quote.replace("be", "me"))
to me or not to me

>>> quote = "to be or not to be"
>>> print(quote.replace("t", "y"))
yo be or noy yo be

x.index - returns the index of a specific character or the index where the characters start.

>>> greet = "hello"
>>> print(greet.index("e"))
1

>>> greet = "hello"
>>> print(greet.index("l"))
2

>>> greet = "hello"
>>> print(greet.index("lo"))
3

d.) bool - booleans
This data type consists of either True or False.

>>> is_cool = True
>>> print(is_cool)
True

>>> is_tall = False
>>> print(is_tall)
False

>>> print(bool(1))
True

>>> print(bool(0))
False

>>> print(bool('True'))
True

>>> print(bool('False'))
True

>>> print(bool())
False

Note: A Boolean value is always True as far as there's a value. 0 or empty data will always return False as shown in the examples above.

Let's kick-off off our next data type:

e.) Lists
A list is an ordered sequence of objects of any type. It is denoted by square brackets [].
It can have a collection of items of different data types and can at times be referred to as an array though there's a slight difference between a list and an array. (Will cover this later in the course).

>>> li = [1, 2, 3, 4, 5]
>>> li2 = ['a', 'b', 'c', 'f']
>>> li3 = [1, 2, 'r', 'u', True]
>>> print(li)
>>> print(li2)
>>> print(li3)
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'f']
[1, 2, 'r', 'u', True]

Lists are Data Structures.
A Data Structure is a data organization, management, and storage format that enables efficient access and modification.

Accessing individual items in a list (using index)

>>> li3 = [1, 2, 'r', 'u', True]
>>> print(li3[2])
>>> print(li3[4])
r
True

>>> amazon_cart = ["notebooks", "sunglasses", "earphones"]
>>> print(amazon_cart[2])
earphones

>>> amazon_cart = ["notebooks", "sunglasses", "earphones"]
>>> print(amazon_cart[3])
#Returns an error for the index is out range.

List Slicing
As we did in strings, we can use the index [start:stop] to access a specific range of items in a list.
Remember eg. [1:7] selects all items from index 1 to but not including the item in index 7 hence the last item is the item in index 6.

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> print(amazon_cart[0:4])
['notebooks', 'sunglasses', 'earphones', 'toys']

Modifying elements in a list
Lists, unlike strings, are mutable hence one can modify elements in a list.

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> amazon_cart[0] = "Laptop"
>>> print(amazon_cart)
['Laptop', 'sunglasses', 'earphones', 'toys', 'grapes']

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> amazon_cart[0] = "Laptop"
>>> new_cart = amazon_cart[0:3]
>>> new_cart[1] = "gum"
>>> print(new_cart)
>>> print(amazon_cart)
['Laptop', 'gum', 'earphones']
['Laptop', 'sunglasses', 'earphones', 'toys', 'grapes']

Note: When you assign a list to a different variable, it points to the memory location of the original list hence modification of the list in the new variable leads to modification of the original list in the previous variable.
Example:

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> amazon_cart[0] = "Laptop"
>>> new_cart = amazon_cart
>>> new_cart[0] = "gum"
>>> print(new_cart)
>>> print(amazon_cart)
['gum', 'sunglasses', 'earphones', 'toys', 'grapes']
['gum', 'sunglasses', 'earphones', 'toys', 'grapes']

To avoid modification of the original list after one has modified the list assigned in the new variable, we use [:] after the list variable to copy the entire list and store it as a new list in a different variable.

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> amazon_cart[0] = "Laptop"
>>> new_cart = amazon_cart[:]
>>> new_cart[0] = "gum"
>>> print(new_cart)
>>> print(amazon_cart)
['gum', 'sunglasses', 'earphones', 'toys', 'grapes']
['Laptop', 'sunglasses', 'earphones', 'toys', 'grapes']

Matrix (These are multi-dimensional lists/arrays)

>>> matrix = [
      [2, 4, 6],
      [9, 5, 7],
      [3, 8, 1]
    ]
>>> print(matrix)
[[2, 4, 6], [9, 5, 7], [3, 8, 1]]

Accessing elements in a multi-dimensional list/array.

>>> matrix = [
      [2, 4, 6],
      [9, 5, 7],
      [3, 8, 1]
    ]
>>> print(matrix[1][2])
>>> print(matrix[0][1])
7
4

>>> matrix = [
      [2, 4, 6],
      [9, 5, 7],
      [3, 8, 1]
    ]
>>> print(matrix[2][3])
#Returns an error for the index is out of range.

List Functions and Methods/Actions
len() - Find the length of a list (number of items in a list).

List Functions and Methods/Actions
len() - Find the length of a list (number of items in a list).

x.append() - Used to add a value to an original list.
It modifies the list inplace hence does not create a copy of the original list.

>>> basket = [1, 2, 3, 4, 5]
>>> basket.append(100)
>>> print(basket)
[1, 2, 3, 4, 5, 100]

>>> basket = [1, 2, 3, 4, 5]
>>> new_list = basket.append(100)
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 5, 100]
None

>>> basket = [1, 2, 3, 4, 5]
>>> basket.append(100)
>>> new_list = basket
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 5, 100]
[1, 2, 3, 4, 5, 100]

x.insert() - Used to insert a value anywhere in the list on a specific index.
It too modifies the list inplace hence does not create a copy of the original list.

>>> basket = [1, 2, 3, 4, 5]
>>> new_list = basket.insert(4, 100)
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 100, 5]
None

>>> basket = [1, 2, 3, 4, 5]
>>> basket.insert(4, 100)
>>> new_list = basket
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 100, 5]
[1, 2, 3, 4, 100, 5]

x.extend() - Used to append another list to the original list.
It too modifies the list inplace hence does not create a copy of the original list.

>>> basket = [1, 2, 3, 4, 5]
>>> new_list = basket.extend([100, 101, 107])
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 5, 100, 101, 107]
None

>>> basket = [1, 2, 3, 4, 5]
>>> basket.extend([100, 101, 107])
>>> new_list = basket
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 5, 100, 101, 107]
[1, 2, 3, 4, 5, 100, 101, 107]

numbers = [1, 2, 3, 4]
friends = ["Kelvin", "Karen", "Jim"]
friends.extend(numbers)
print(friends)
['Kelvin', 'Karen', 'Jim', 1, 2, 3, 4]

x.pop() - Automatically removes (pops off) the last element from the list or from the given index. It returns the element that has been popped off.

>>> basket = [1, 2, 3, 4, 5]
>>> basket.pop()
>>> print(basket)
[1, 2, 3, 4]

>>> friends = ["Kelvin", "Karen", "Jim"]
>>> friends.pop()
>>> print(friends)
['Kelvin', 'Karen']

>>> basket = [1, 2, 3, 4, 5]
>>> basket.pop(0)
>>> print(basket)
[2, 3, 4, 5]

>>> basket = [1, 2, 3, 4, 5]
>>> basket.pop(2)
>>> print(basket)
[1, 2, 4, 5]

>>> basket = [1, 2, 3, 4, 5]
>>> new_list = basket.pop(4)
>>> print(new_list)
5

x.remove() - Removes an element/value from a list. Works 'inplace'.

>>> basket = [1, 2, 3, 4, 5]
>>> basket.remove(4)
>>> print(basket)
[1, 2, 3, 5]

x.clear() - Clears the entire list. Works 'inplace'.

>>> basket = [1, 2, 3, 4, 5]
>>> basket.clear()
>>> print(basket)
[]

x.index() - Used to check the index of an element in the list.

>>> basket = ['a', 'b', 'c', 'd', 'e']
>>> print(basket.index('d'))
3

Checking from a specific index in the list.

>>> basket = ['a', 'b', 'c', 'd', 'e']
>>> print(basket.index('d', 0, 3)) #Checking from index 0 to index 3 (but not including index 3).
#returns an error as 'd' is in index 3 yet index 3 is not included in the range.

Finding whether an element is or is not in a list.
We use the keyword 'in' which returns whether True or False.

>>> basket = ['a', 'b', 'c', 'd', 'e']
>>> print('d' in basket)
True

>>> basket = ['a', 'b', 'c', 'd', 'e']
>>> print('i' in basket)
False

>>> print('a' in 'My name is Mark')
True

>>> print('z' in 'What is the time?')
False

x.count() - Used to count the number of items an element appears in the list.

>>> basket = ['a', 'b', 'c', 'd', 'e']
>>> print(basket.count('d'))
1

>>> basket = [1, 2, 3, 4, 2, 5, 2]
>>> print(basket.count(2))
3

x.sort() - Used to sort the list in ascending order. If the list contains names, they are sorted in alphabetical order. Works 'inplace'.

>>> basket = [5, 2, 3, 4, 1, 3, 2]
>>> basket.sort()
>>> print(basket)
[1, 2, 2, 3, 3, 4, 5]

>>> friends = ["Karen", "Toby", "Elijah"]
>>> friends.sort()
>>> print(friends)
['Elijah', 'Karen', 'Toby']

sorted() - Used to sort the list in ascending order. If the list contains names, they are sorted in alphabetical order. Unlike the method x.sort(), sorted() is a function that produces a new array and hence does not work in place.

>>> friends = ["Karen", "Toby", "Elijah"]
>>> print(sorted(friends))
['Elijah', 'Karen', 'Toby']

>>> basket = [5, 2, 3, 4, 1, 3, 2]
>>> print(sorted(basket))
[1, 2, 2, 3, 3, 4, 5]

x.copy() - Works the same as [:] by copying the entire list and creating a new one exactly like the original list.

>>> friends = ["Karen", "Toby", "Elijah"]
>>> new_friends = friends.copy()
>>> print(new_friends)
['Karen', 'Toby', 'Elijah']

x.reverse() - Used to reverse the elements in the list from the element in the last index to the element in the first index. Works 'inplace'.
(It does not follow the ascending or any order; It just swaps the elements).

>>> friends = ["Karen", "Toby", "Elijah"]
>>> friends.reverse()
>>> print(friends)
['Elijah', 'Toby', 'Karen']

>>> numbers = [1, 5, 3, 8, 7]
>>> numbers.reverse()
>>> print(numbers)
[7, 8, 3, 5, 1]

>>> numbers = [1, 5, 3, 8, 7]
>>> numbers.sort()
>>> numbers.reverse()
>>> print(numbers)
[8, 7, 5, 3, 1]

Common List Patterns
Reversing a list with list slicing
This creates a new list from the original, that is, it does not work in place.

numbers = [1, 5, 3, 8, 7]
numbers.sort()
numbers.reverse()
print(numbers)
print(numbers[::-1])
[8, 7, 5, 3, 1]
[1, 3, 5, 7, 8]
Note: You can reverse a list using list slicing (-1) or using the x.reverse() method as shown above.

range() - Generates a list of numbers from up to but not including the last number stated.

>>> print (list(range(1, 50)))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49]

>>> print (list(range(50)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49]

>>> print (list(range(51)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49,
50]

Getting the length of a list - Number of items in a list.

>>> basket = [1, 2, 6, 8, 4, 0]
>>> print(len(basket))
6

>>> names = ["Mark", "Enoch", "Vivian", "Yvonne", "Mercy"]
>>> print(len(names))
5

.join
This is a string method used to join items in a list with the given 'character'. It creates a new item and hence does not work inplace.

>>> sentence = '!'
>>> new_sentence = sentence.join(['hi', 'my', 'name', 'is', 'JOJO'])
>>> print(new_sentence)
hi!my!name!is!JOJO

>>> sentence = '.'
>>> new_sentence = sentence.join(['hi', 'my', 'name', 'is', 'JOJO'])
>>> print(new_sentence)
hi.my.name.is.JOJO

>>> sentence = ' '
>>> sen2 = ['hello', 'welcome', 'to', 'the', 'city']
>>> new_sentence = sentence.join(sen2)
>>> print(new_sentence)
hello welcome to the city

>>> new_sentence = '!'.join(['hi', 'my', 'name', 'is', 'JOJO'])
>>> print(new_sentence)
hi!my!name!is!JOJO

>>> new_sentence = ' '.join(['hi', 'my', 'name', 'is', 'JOJO'])
>>> print(new_sentence)
hi my name is JOJO

List Unpacking
This is assigning a variable to each item in a list. Works like multiple assigning of values in variables.

>>> a,b,c = [1, 2, 3]
>>> print(a)
>>> print(b)
>>> print(c)
1
2

In list unpacking, you can add more values, unpack the values assigned in the variables then store the remaining items in their own variable. You just add the * sign and the name of the variable.

>>> a,b,c *other = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(a)
>>> print(b)
>>> print(c)
>>> print(other)
1
2
3
[4, 5, 6, 7, 8, 9]

>>> a,b,c, *other, d = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(a)
>>> print(b)
>>> print(c)
>>> print(other)
>>> print(d)
1
2
3
[4, 5, 6, 7, 8]
9

f.) None type
This is a special data type that represents the absence of values.

>>> weapons = None
>>> print(weapons)
None

g.) Tuples
These are like lists but immutable data types. Data stored in tuples can never be changed eg. coordinates.

Can't add elements to it.

Can't erase elements from it.

Can't modify elements in it.

Tuples are also data structures.
They use the parenthesis '()' to store data and can store data of different data types in a single tuple.

>>> my_tuple = (1, 2, 4, 7, 5)
>>> print(my_tuple)
(1, 2, 4, 7, 5)

>>> my_tuple = (1, 2, 'a', True)
>>> print (my_tuple)
(1, 2, 'a', True)

>>> my_tuple = (1, 2, 4, 7, 5)
>>> print(my_tuple[3])
7

>>> my_tuple = (1, 2, 4, 7, 5)
>>> print(3 in my_tuple)
False

>>> my_tuple = (1, 2, 4, 7, 5)
>>> print(5 in my_tuple)
True

>>> my_tuple = (1, 2, 4, 7, 5)
>>> my_tuple[3] = 9
>>> print(my_tuple)
#returns an error as tuples cannot be modified

Tuples can be sliced (similar to list slicing)

>>> my_tuple = (1, 2, 3, 4, 5)
>>> new_tuple = my_tuple[1:4]
>>> print(new_tuple)
(2, 3, 4)

>>> my_tuple = (1, 2, 3, 4, 5)
>>> new_tuple = my_tuple[1:2]
>>> print(new_tuple)
(2,)

>>> x, y, z, *other = (1, 2, 3, 4, 5)
>>> print(x)
>>> print(y)
>>> print(z)
>>> print(other)
1
2
3
[4, 5]

Tuples have two main methods:

x.count()

x.index()

>>> my_tuple = (1, 5, 3, 4, 5)
>>> print(my_tuple.count(5))
2

>>> my_tuple = (1, 5, 3, 4, 5)
>>> print(my_tuple.index(4))
3

To get the length of a tuple:

>>> my_tuple = (1, 5, 3, 4, 5)
>>> print(len(my_tuple))
5

A list of tuples:

>>> coordinates = [(4, 5), (6, 7), (80, 34)]
>>> print(coordinates)
[(4, 5), (6, 7), (80, 34)]

>>> coordinates = [(4, 5), (6, 7), (80, 34)]
>>> print(coordinates[1])
(6, 7)

>>> coordinates = [(4, 5), (6, 7), (80, 34)]
>>> print(coordinates[1][1])

h.) Dictionaries
This is a special data structure that allows one to organize or store data in unordered key-value pairs. It uses curly braces '{}'.

dictionary = {
   'key' : value,
   'key' : value
   }

The key must always be unique (shouldn't be repeated).
To access the value, we use the key.

>>> my_dict = {
      'a' : 1,
      'b' : 2,
      'x' : 4
      }
>>> print(my_dict)
{'a': 1, 'b': 2, 'x': 3}

>>> my_dict = {
      'a' : 1,
      'b' : 2,
      'x' : 4
      }
>>> print(my_dict['b'])
2

>>> my_dict = {
      'a' : 1,
      'b' : 2
      'x' : 4
      }
>>> print(my_dict['c'])
#returns an error for the key is not defined.

Note: Elements in a dictionary are stored in different memory locations which are not necessarily in order:

>>> my_dict = {
      'a' : 1,
      'b' : 2,
      'x' : 4
      }
>>> print(my_dict)
{'a': 1, 'b': 2, 'x': 3}

At times the output may be as shown below.

>>> my_dict = {
      'a' : 1,
      'b' : 2,
      'x' : 4
      }
>>> print(my_dict)
{'x': 4, 'a': 1, 'b': 2}

Dictionary keys can store values of different data types (same as lists and tuples).

>>> my_dict = {
      'a' : [1, 2, 3],
      'b' : "hello",
      'x' : True,
      't' : 5
      }
>>> print(my_dict)
{'a': [1, 2, 3], 'b': 'hello', 'x': True, 't': 5}

>>> my_dict = {
      'a' : [1, 2, 3],
      'b' : "hello",
      'x' : True,
      't' : 5
      }
>>> print(my_dict['a'])
[1, 2, 3]

>>> my_dict = {
      'a' : [1, 2, 3],
      'b' : "hello",
      'x' : True,
      't' : 5
      }
>>> print(my_dict['a'][1])
2

>>> my_dict = {
      'a' : [1, 2, 3],
      'b' : "hello",
      'x' : True,
      't' : 5
      }
>>> print(my_dict['b'][4])
o

A dictionary in a list.

>>> my_list = [
       {
        'a' : [1, 2, 3],
        'b' : "hello",
        'x' : True,
        't' : 5
        },

       {
        'a' : [4, 5, 6],
        'b' : "welcome",
        'x' : False,
        't' : 5
       }
    ]
>>> print(my_list[0]['a'][2])
3

Dictionary Keys
Dictionary keys are immutable types and should be unique. This means that a string, a number, a tuple and a Boolean can be a key while a list cannot.
Note: When one re-assigns a key to another value, the original value in the key is overwritten.

>>> dictionary = {
         123 : [1, 2, 5, 6],
         True : 'hello',
         'a' : ('a', 't', 'u'),
         [100] : False
     }
>>> print (dictionary[100])
#returns an error as a list is mutable and hence cannot be used as a key.

>>> dictionary = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         '123' : ('a', 't', 'u')
     }
>>> print(dictionary['123'])
('a', 't', 'u')

Dictionary Methods
x.get() - A method used to check whether a key is present in a dictionary. At times it returns a default value given if a key is missing.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print(user.get('age'))
None

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print(user.get('age', 55))
55

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u'),
         'age' : 20
     }
>>> print(user.get('age', 55))
20

A second way of creating a dictionary:
By using the keyword 'dict(key = value)'.
The key cannot be an expression, that is, it should be a variable when using 'dict'.

>>> user2 = dict(name = 'John')
>>> print(user2)
{'name': 'John'}

>>> user2 = dict(name = 'John', name2 = 'Mark')
>>> print(user2)
{'name': 'John', 'name2': 'Mark'}

'in' keyword can also be used in dictionaries.
It returns either True or False on whether a key is present or absent in a dictionary.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print('size' in user)
False

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print('basket' in user)
True

x.keys() - Used to check whether a specific key is present in a dictionary.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print('123' in user.keys())
True

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print('age' in user.keys())
False

x.values() - Used to check whether a specific value is present in a dictionary.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print('hello' in user.values())
True

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print(('a', 't', 'u') in user.values())
True

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print([1, 2, 6, 5] in user.values())
False

x.items() - Returns the entire items in a dictionary as tuples.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print(user.items())
dict_items([('123', [1, 2, 5, 6]), (True, 'hello'), ('basket', ('a', 't', 'u'))])

x.clear() - clears the dictionary and returns an empty dictionary.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print(user.clear())
None

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> user.clear()
>>> print(user)
{}

x.copy() - creates a copy of a dictionary.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> user2 = user.copy()
>>> print(user2)
{'123': [1, 2, 5, 6], True: 'hello', 'basket': ('a', 't', 'u')}

x.pop() - Removes key with its value from the dictionary and returns the value.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u'),
         'age' : 20
     }
>>> user.pop('age')
>>> print(user)
20
{'123': [1, 2, 5, 6], True: 'hello', 'basket': ('a', 't', 'u')}

x.popitem() - Removes a random pair of key-value.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u'),
         'age' : 20
     }
>>> user.popitem()
>>> print(user)
('age', 20)
{'123': [1, 2, 5, 6], True: 'hello', 'basket': ('a', 't', 'u')}

x.update() - Used to update the keys in the dictionary or by adding a new key and value.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u'),
         'age' : 20
     }
>>> user.update({'age' : 55})
>>> print(user)
{'123': [1, 2, 5, 6], True: 'hello', 'basket': ('a', 't', 'u'), 'age': 55}

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u'),
         'age' : 20
     }
>>> user.update({'age2' : 55})
>>> print(user)
{'123': [1, 2, 5, 6], True: 'hello', 'basket': ('a', 't', 'u'), 'age': 20, 'age2': 55}

i.) Sets
These are an unordered collection of unique objects. It uses curly brackets and returns only the unique objects.

>>> my_set = {1, 2, 3, 4, 5, 5}
>>> print(my_set)
{1, 2, 3, 4, 5}

>>> my_set = {1, 2, 3, 4, 5, 5}
>>> my_set.add(2)
>>> my_set.add(100)
>>> print(my_set)
{1, 2, 3, 4, 5, 100}

>>> my_list = [1, 2, 2, 3, 5, 5]
>>> print(set(my_list))
{1, 2, 3, 5}

Objects in a set are not indexed and hence cannot be accessed using an index.

>>> my_set = {1, 2, 3, 4, 5, 5}
>>> print(my_set[0])
#returns an error as items cannot be accessed using indexes in sets

>>> my_set = {1, 2, 3, 4, 5, 5}
>>> print(1 in my_set)
True

>>> my_set = {1, 2, 3, 4, 5, 5, 7, 7}
>>> print(6 in my_set)
False

>>> my_set = {1, 2, 3, 4, 5, 5, 7, 7}
>>> print(len(my_set))
6

Converting a set to a list.

>>> my_set = {1, 2, 3, 4, 5, 5, 7, 7}
>>> print(list(my_set))
[1, 2, 3, 4, 5, 7]

x.copy - Copies a set.

>>> my_set = {1, 2, 3, 4, 5, 5, 7, 7}
>>> new_set = my_set.copy()
>>> my_set.clear()
>>> print(new_set)
>>> print(my_set)
{1, 2, 3, 4, 5, 7}
set()

Methods in sets
x.difference() - Finds the difference of two sets.

>>> my_set = {1, 2, 3, 4, 5}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set.difference(your_set))
{1, 2, 3}

x.discard() - Removes an element from a set if it is a member. Works inplace.

x.discard() - Removes an element from a set if it is a member. Works inplace.

x.difference_update() - Removes all elements of another set from the previous set.

x.difference_update() - Removes all elements of another set from the previous set.

x.intersection() - Returns the common values in both sets.

>>> my_set = {1, 2, 3, 4, 5}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set.intersection(your_set))
{4, 5}