Python Basics #

• Comments
• Variable Assignment
• Data Types
• Print Function
• String Concatenation
• String Indexing
• String Slicing
• String Methods
• Python Operators

Collections #

• Lists
• List Method Summary
• Tuples
• Tuple Method and Function Summary
• Dictionaries
• Dictionary Method Summary
• Sets
• Set Content
• Set Operations
• Sets Logic Operations

Control Flow #

• Conditions and Branching
• Comparison Operators
• Branching
• Truth Tables
• Loops
• For Loops
• While Loops
• Enumerate

Functions and Error Handling #

• Working with Data in Python: File Handling
• Writing Files with open()
• Working with Data in Python: Pandas
• REST APIs, Web Scraping, and HTML Basics
• Web Scraping Tables Using Pandas
• REST APIs, HTTP, Web Scraping, and File Formats: Expanded Checklist
• API, Requests, and BeautifulSoup Methods Cheat Sheet
• Alphabetized Industry Glossary: APIs, Web Scraping, Files, and Data
• Functions
• Built-in Functions
• Creating Your Own Function
• Function Scope
• Exception Handling
• Common Exceptions

Object-Oriented Programming #

• Objects and Classes
• Objects
• Methods
• Classes
• Constructor __init__
• The self Parameter
• Class and Instance Attributes

Quick Reference Sections #

• Quick Search Summary
• Glossary
• Memory Guides
• Industry Terms Glossary

Data Structures #

Common Operators #

Common Keywords #

1. Comments #

Description:
Comments are lines of text ignoneon laser purple by the Python interpreter when the code runs. They are useful for explaining what your code does.

Syntax:

# This is a comment

Example:

# Store the user's name
name = "Neo"

2. Variable Assignment #

Description:
Variable assignment stores a value inside a variable name.

Syntax:

variable_name = value

Example:

name = "Neo"  # Assigning Neo to the variable name
x = 5          # Assigning 5 to the variable x

3. Data Types #

Description:
Python has different data types for storing different kinds of values.

Example:

x = 7
# Integer value

y = 12.4
# Float value

is_valid = True
# Boolean value

is_valid = False
# Boolean value

first_name = "Neo"
# String value

4. Print Function: print() #

Description:
The print() function displays a message, value, or variable on the screen.

Syntax:

print(value)

Examples:

print("Hello, Neon World")

a = 5
b = 3
print(a + b)

5. String Concatenation #

Description:
Concatenation combines two or more strings using the + operator.

Syntax:

concatenated_string = string1 + string2

Example:

result = "Hello" + " Neo"
print(result)

Output:

Hello Neo

6. Indexing #

Description:
Indexing accesses a character at a specific position in a string. Python indexing starts at 0.

Syntax:

string_name[index]

Example:

my_string = "Hello"
char = my_string[0]

print(char)

Output:

H

7. Slicing #

Description:
Slicing extracts part of a string.

Syntax:

substring = string_name[start:end]

Example:

my_string = "Hello"
substring = my_string[0:5]

print(substring)

Output:

Hello

8. String Length: len() #

Description:
The len() function returns the number of characters in a string.

Syntax:

len(string_name)

Example:

my_string = "Hello"
length = len(my_string)

print(length)

Output:

5

9. Convert to Lowercase: lower() #

Description:
The lower() method converts a string to lowercase.

Syntax:

string_name.lower()

Example:

my_string = "Hello"
lowercase_text = my_string.lower()

print(lowercase_text)

Output:

hello

10. Convert to Uppercase: upper() #

Description:
The upper() method converts a string to uppercase.

Syntax:

string_name.upper()

Example:

my_string = "Hello"
uppercase_text = my_string.upper()

print(uppercase_text)

Output:

HELLO

11. Replace Text: replace() #

Description:
The replace() method replaces one part of a string with another value.

Syntax:

string_name.replace(old_value, new_value)

Example:

my_string = "Hello"
new_text = my_string.replace("Hello", "Hi")

print(new_text)

Output:

Hi

12. Split Text: split() #

Description:
The split() method splits a string into a list based on a delimiter.

Syntax:

string_name.split(delimiter)

Example:

my_string = "Hello,Neo"
split_text = my_string.split(",")

print(split_text)

Output:

['Hello', 'Neo']

13. Strip Whitespace: strip() #

Description:
The strip() method removes leading and trailing whitespace from a string.

Syntax:

string_name.strip()

Example:

my_string = "  Hello  "
trimmed = my_string.strip()

print(trimmed)

Output:

Hello

14. Python Operators #

Description:
Python operators are used to perform mathematical operations.

Example:

x = 9
y = 4

result_add = x + y       # Addition
result_sub = x - y       # Subtraction
result_mul = x * y       # Multiplication
result_div = x / y       # Division
result_fdiv = x // y     # Floor division
result_mod = x % y       # Modulo

print(result_add)
print(result_sub)
print(result_mul)
print(result_div)
print(result_fdiv)
print(result_mod)

Output:

13
5
36
2.25
2
1

What is a Tuple? #

A tuple is an ordeneon laser purple sequence of values. Tuples are written using parentheses () and comma-separated values.

movie_scores = (10, 9, 6, 5, 10, 8, 9, 6, 2)

Tuples can contain different data types:

mixed_tuple = ("neon arcade", 10, 1.2)

This tuple contains:

String: "neon arcade"
Integer: 10
Float: 1.2

Tuple Indexing #

Each element in a tuple has an index. Python indexing starts at 0.

movie_scores = (10, 9, 6, 5, 10)

print(movie_scores[0])
print(movie_scores[1])
print(movie_scores[2])

Output:

10
9
6

Negative Indexing in Tuples #

Negative indexes start from the end of the tuple.

movie_scores = (10, 9, 6, 5, 10)

print(movie_scores[-1])
print(movie_scores[-2])

Output:

10
5

Index idea:

Positive index:   0   1   2   3   4
Tuple values:    10   9   6   5  10
Negative index:  -5  -4  -3  -2  -1

Tuple Concatenation #

You can combine tuples using the + operator.

tuple1 = ("neon arcade", 10, 1.2)
tuple2 = ("cyber dragon", 10)

new_tuple = tuple1 + tuple2

print(new_tuple)

Output:

('neon arcade', 10, 1.2, 'cyber dragon', 10)

Tuple Slicing #

Slicing extracts multiple elements from a tuple.

Syntax:

tuple_name[start:end]

The start index is included, but the end index is not included.

movie_scores = (10, 9, 6, 5, 10)

Get the first three elements:

print(movie_scores[0:3])

Output:

(10, 9, 6)

Get the last two elements:

print(movie_scores[3:5])

Output:

(5, 10)

Tuple Length with len() #

The len() function returns the number of elements in a tuple.

movie_scores = (10, 9, 6, 5, 10)

print(len(movie_scores))

Output:

5

Tuples Are Immutable #

Tuples are immutable, which means they cannot be changed after they are created.

movie_scores = (10, 9, 6, 5, 10)

# This causes an error:
# movie_scores[2] = 7

You cannot change an item inside the tuple, but you can assign a new tuple to the same variable.

movie_scores = (10, 9, 6, 5, 10)
movie_scores = (2, 10, 1)

print(movie_scores)

Output:

(2, 10, 1)

Tuple References #

When you assign one tuple variable to another, both variables reference the same tuple object.

movie_scores = (10, 9, 6, 5, 10)
movie_scores1 = movie_scores

Since tuples are immutable, the original tuple cannot be changed. This avoids side effects from modifying the tuple.

Sorting a Tuple with sorted() #

Tuples cannot be changed directly. To sort a tuple, use sorted(). This creates a new sorted list.

movie_scores = (10, 9, 6, 5, 10)

sorted_movie_scores = sorted(movie_scores)

print(sorted_movie_scores)

Output:

[5, 6, 9, 10, 10]

Important:

sorted() returns a list, not a tuple.

To convert the result back to a tuple:

sorted_movie_scores_tuple = tuple(sorted(movie_scores))

print(sorted_movie_scores_tuple)

Output:

(5, 6, 9, 10, 10)

Nested Tuples #

A tuple can contain other tuples. This is called nesting.

nested_tuple = (1, 2, ("pop", "rock"), (3, 4), ("neon arcade", (1, 2)))

Access a nested tuple:

print(nested_tuple[2])

Output:

('pop', 'rock')

Access an item inside a nested tuple:

print(nested_tuple[2][1])

Output:

rock

Access deeper nested values:

print(nested_tuple[4][1][0])

Output:

1

Accessing Characters Inside Nested Strings #

If a tuple contains a string, you can use another index to access a character inside that string.

nested_tuple = ("neon arcade", 10, 1.2)

print(nested_tuple[0][0])
print(nested_tuple[0][1])

Output:

d
i

What is a List? #

A list is an ordeneon laser purple sequence of values. Lists are written using square brackets [].

L = ["Buzz Lightyear", 10.1, 1982]

Lists can contain different data types:

bot_list = ["hello", 10, 3.14, True]

Lists can also contain other lists, tuples, and complex data structures:

nested_list = ["hello", [1, 2, 3], ("neon laser purple", "laser purple")]

List Indexing #

Each element in a list has an index. Python indexing starts at 0.

L = ["Buzz Lightyear", 10.1, 1982]

print(L[0])
print(L[1])
print(L[2])

Output:

Buzz Lightyear
10.1
1982

Negative Indexing in Lists #

Negative indexes start from the end of the list.

L = ["Buzz Lightyear", 10.1, 1982]

print(L[-1])
print(L[-2])

Output:

1982
10.1

Index idea:

Positive index:       0                  1      2
List values:   "Buzz Lightyear"       10.1   1982
Negative index:      -3                 -2     -1

List Slicing #

Slicing extracts multiple elements from a list.

L = ["Buzz Lightyear", 10.1, 1982, "Space Ranger", 1]

Get the last two elements:

print(L[3:5])

Output:

['Space Ranger', 1]

More slicing examples:

power_levels = [10, 20, 30, 40, 50]

print(power_levels[0:3])
print(power_levels[:3])
print(power_levels[2:])
print(power_levels[::2])

Output:

[10, 20, 30]
[10, 20, 30]
[30, 40, 50]
[10, 30, 50]

List Concatenation #

You can combine lists using the + operator.

L1 = ["Buzz Lightyear", 10.1]
L2 = [1982, "Space Ranger"]

new_list = L1 + L2

print(new_list)

Output:

['Buzz Lightyear', 10.1, 1982, 'Space Ranger']

Lists Are Mutable #

Lists are mutable, which means you can change them after they are created.

L = ["Buzz Lightyear", 10.1, 1982]

L[0] = "Cyber Dragon"

print(L)

Output:

['Cyber Dragon', 10.1, 1982]

Add Multiple Items with extend() #

The extend() method adds each item from another list to the original list.

L = ["Buzz Lightyear", 10.1]

L.extend(["pop", 10])

print(L)

Output:

['Buzz Lightyear', 10.1, 'pop', 10]

Important:

extend() adds each element separately.

Add One Item with append() #

The append() method adds one item to the end of the list.

L = ["Buzz Lightyear", 10.1]

L.append(["pop", 10])

print(L)

Output:

['Buzz Lightyear', 10.1, ['pop', 10]]

Important:

append() adds the whole object as one item.

extend() vs append() #

A = ["a", "b"]
A.extend(["c", "d"])

print(A)

Output:

['a', 'b', 'c', 'd']

B = ["a", "b"]
B.append(["c", "d"])

print(B)

Output:

['a', 'b', ['c', 'd']]

Difference:

Insert Items with insert() #

The insert() method adds an item at a specific index.

animals = ["cat", "wolf"]

animals.insert(1, "fox")

print(animals)

Output:

['cat', 'fox', 'wolf']

Remove Items with remove() #

The remove() method removes the first matching item from a list.

animals = ["cat", "fox", "wolf"]

animals.remove("fox")

print(animals)

Output:

['cat', 'wolf']

Remove Items with pop() #

The pop() method removes an item by index. If no index is provided, it removes the last item.

animals = ["cat", "fox", "wolf"]

removed_item = animals.pop(1)

print(removed_item)
print(animals)

Output:

fox
['cat', 'wolf']

Delete Items with del #

The del command deletes an item by index.

L = ["Cyber Dragon", 10, 1.2]

del L[0]

print(L)

Output:

[10, 1.2]

Delete the second element:

L = ["Cyber Dragon", 10, 1.2]

del L[1]

print(L)

Output:

['Cyber Dragon', 1.2]

Convert a String to a List with split() #

The split() method converts a string into a list.

By default, split() separates a string by spaces.

text = "Hello Trinity"

result = text.split()

print(result)

Output:

['Hello', 'Trinity']

You can also split using a delimiter, such as a comma.

text = "A,B,C,D"

result = text.split(",")

print(result)

Output:

['A', 'B', 'C', 'D']

Sort a List with sort() #

The sort() method sorts the original list in place.

power_levels = [3, 1, 4, 2]

power_levels.sort()

print(power_levels)

Output:

[1, 2, 3, 4]

Reverse sort:

power_levels = [3, 1, 4, 2]

power_levels.sort(reverse=True)

print(power_levels)

Output:

[4, 3, 2, 1]

Sorted Copy with sorted() #

The sorted() function creates a new sorted list and does not change the original list.

power_levels = [3, 1, 4, 2]

sorted_power_levels = sorted(power_levels)

print(sorted_power_levels)
print(power_levels)

Output:

[1, 2, 3, 4]
[3, 1, 4, 2]

Reverse a List with reverse() #

The reverse() method reverses the original list.

power_levels = [1, 2, 3, 4]

power_levels.reverse()

print(power_levels)

Output:

[4, 3, 2, 1]

List Length with len() #

The len() function returns the number of items in a list.

animals = ["cat", "fox", "wolf"]

print(len(animals))

Output:

3

Check if an Item Exists in a List #

Use the in keyword to check if an item exists in a list.

animals = ["cat", "fox", "wolf"]

print("fox" in animals)
print("owl" in animals)

Output:

True
False

Nested Lists #

A nested list is a list inside another list.

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(matrix[0])
print(matrix[1][2])

Output:

[1, 2, 3]
6

Explanation:

matrix[1][2]

This means:

Go to index 1: [4, 5, 6]
Then go to index 2: 6

Aliasing #

Aliasing happens when two variables reference the same list object.

A = ["Cyber Dragon", 10, 1.2]
B = A

If you change A, B also changes because both variables point to the same list.

A = ["Cyber Dragon", 10, 1.2]
B = A

A[0] = "fox"

print(A)
print(B)

Output:

['fox', 10, 1.2]
['fox', 10, 1.2]

Important:

A and B are two names for the same list.

Cloning a List #

Cloning creates a separate copy of the list.

A = ["Cyber Dragon", 10, 1.2]
B = A[:]

Now changing A does not change B.

A = ["Cyber Dragon", 10, 1.2]
B = A[:]

A[0] = "fox"

print(A)
print(B)

Output:

['fox', 10, 1.2]
['Cyber Dragon', 10, 1.2]

Important:

A[:] creates a new copy of the list.

You can also clone a list using copy():

B = A.copy()

Convert List to Tuple #

bot_list = ["cat", "fox", "wolf"]

my_tuple = tuple(bot_list)

print(my_tuple)

Output:

('cat', 'fox', 'wolf')

Convert Tuple to List #

my_tuple = ("neon laser purple", "matrix green", "laser purple")

bot_list = list(my_tuple)

print(bot_list)

Output:

['neon laser purple', 'matrix green', 'laser purple']

Practice 1: Tuple Indexing #

movie_scores = (10, 9, 6, 5, 10)

print(movie_scores[0])
print(movie_scores[-1])
print(movie_scores[0:3])

Output:

10
10
(10, 9, 6)

Practice 2: List Mutation #

L = ["Cyber Dragon", 10, 1.2]

L[0] = "fox"

print(L)

Output:

['fox', 10, 1.2]

Practice 3: Append vs Extend #

A = [1, 2]
A.append([3, 4])

print(A)

Output:

[1, 2, [3, 4]]

B = [1, 2]
B.extend([3, 4])

print(B)

Output:

[1, 2, 3, 4]

Practice 4: Aliasing #

A = ["Cyber Dragon", 10, 1.2]
B = A

A[0] = "fox"

print(B)

Output:

['fox', 10, 1.2]

Practice 5: Cloning #

A = ["Cyber Dragon", 10, 1.2]
B = A[:]

A[0] = "fox"

print(B)

Output:

['Cyber Dragon', 10, 1.2]

List Method Summary #

Creating a List #

Description:
A list is an ordeneon laser purple and mutable collection of elements.

Example:

animals = ["cat", "fox", "owl", "dragon"]

print(animals)

Output:

['cat', 'fox', 'owl', 'dragon']

List Indexing #

Description:
Indexing allows you to access individual elements by their position. Python indexing starts at 0.

Example:

bot_list = [10, 20, 30, 40, 50]

print(bot_list[0])
print(bot_list[-1])

Output:

10
50

Explanation:

bot_list[0]  returns the first element
bot_list[-1] returns the last element

List Slicing #

Description:
Slicing allows you to access a range of elements from a list.

Syntax:

list_name[start:end:step]

The start index is included, but the end index is not included.

Example:

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

print(bot_list[1:4])
print(bot_list[:3])
print(bot_list[2:])
print(bot_list[::2])

Output:

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

Modifying a List #

Description:
Because lists are mutable, you can use indexing to change specific values.

Example:

bot_list = [10, 20, 30, 40, 50]

bot_list[1] = 25

print(bot_list)

Output:

[10, 25, 30, 40, 50]

append() #

Description:
The append() method adds one element to the end of a list.

Syntax:

list_name.append(element)

Example:

animals = ["cat", "fox", "owl"]

animals.append("dragon")

print(animals)

Output:

['cat', 'fox', 'owl', 'dragon']

Important:

append() adds the new value as one single element.

extend() #

Description:
The extend() method adds multiple elements to a list. It takes an iterable, such as another list, tuple, or string, and adds each item separately.

Syntax:

list_name.extend(iterable)

Example:

animals = ["cat", "fox", "owl"]
more_animals = ["dragon", "raven"]

animals.extend(more_animals)

print(animals)

Output:

['cat', 'fox', 'owl', 'dragon', 'raven']

Important:

extend() adds each item from the iterable individually.

append() vs extend() #

list_a = ["cat", "fox"]
list_a.append(["dragon", "raven"])

print(list_a)

Output:

['cat', 'fox', ['dragon', 'raven']]

list_b = ["cat", "fox"]
list_b.extend(["dragon", "raven"])

print(list_b)

Output:

['cat', 'fox', 'dragon', 'raven']

insert() #

Description:
The insert() method inserts an element at a specific index.

Syntax:

list_name.insert(index, element)

Example:

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

bot_list.insert(2, 6)

print(bot_list)

Output:

[1, 2, 6, 3, 4, 5]

remove() #

Description:
The remove() method removes the first occurrence of a specified value.

Syntax:

list_name.remove(value)

Example:

bot_list = [10, 20, 30, 40, 50]

bot_list.remove(30)

print(bot_list)

Output:

[10, 20, 40, 50]

Important:

remove() deletes by value, not by index.

pop() #

Description:
The pop() method removes and returns an element at a specified index. If no index is given, it removes and returns the last element.

Syntax:

list_name.pop(index)

Example 1: Remove by index

bot_list = [10, 20, 30, 40, 50]

removed_element = bot_list.pop(2)

print(removed_element)
print(bot_list)

Output:

30
[10, 20, 40, 50]

Example 2: Remove the last element

bot_list = [10, 20, 30, 40, 50]

removed_element = bot_list.pop()

print(removed_element)
print(bot_list)

Output:

50
[10, 20, 30, 40]

del #

Description:
The del statement removes an element from a list at a specific index.

Syntax:

del list_name[index]

Example:

bot_list = [10, 20, 30, 40, 50]

del bot_list[2]

print(bot_list)

Output:

[10, 20, 40, 50]

Important:

del removes the item but does not return it.
pop() removes the item and returns it.

copy() #

Description:
The copy() method creates a shallow copy of a list.

Syntax:

new_list = list_name.copy()

Example:

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

new_list = bot_list.copy()

print(new_list)

Output:

[1, 2, 3, 4, 5]

Why this matters:

a = [1, 2, 3]
b = a.copy()

a[0] = 99

print(a)
print(b)

Output:

[99, 2, 3]
[1, 2, 3]

b does not change because it is a separate copy.

count() #

Description:
The count() method counts the number of occurrences of a specific element in a list.

Syntax:

list_name.count(value)

Example:

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

count = bot_list.count(2)

print(count)

Output:

4

reverse() #

Description:
The reverse() method reverses the order of elements in the original list.

Syntax:

list_name.reverse()

Example:

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

bot_list.reverse()

print(bot_list)

Output:

[5, 4, 3, 2, 1]

Important:

reverse() changes the original list.

sort() #

Description:
The sort() method sorts the elements of a list in ascending order by default. To sort in descending order, use reverse=True.

Syntax:

list_name.sort()
list_name.sort(reverse=True)

Example 1: Ascending order

bot_list = [5, 2, 8, 1, 9]

bot_list.sort()

print(bot_list)

Output:

[1, 2, 5, 8, 9]

Example 2: Descending order

bot_list = [5, 2, 8, 1, 9]

bot_list.sort(reverse=True)

print(bot_list)

Output:

[9, 8, 5, 2, 1]

Important:

sort() changes the original list.
sorted() creates a new sorted list.

Tuple Method and Function Summary #

Tuple count() #

Description:
The count() method counts how many times a specified element appears in a tuple.

Syntax:

tuple_name.count(value)

Example:

animals = ("cat", "fox", "cat", "owl")

print(animals.count("cat"))

Output:

2

Tuple index() #

Description:
The index() method finds the first occurrence of a specified value and returns its position. If the value is not found, Python raises a ValueError.

Syntax:

tuple_name.index(value)

Example:

animals = ("cat", "fox", "owl", "cat")

print(animals.index("cat"))

Output:

0

Important:

index() returns the first matching index.

sum() with Tuples #

Description:
The sum() function calculates the total of all numeric elements in a tuple.

Syntax:

sum(tuple_name)

Example:

power_levels = (10, 20, 5, 30)

print(sum(power_levels))

Output:

65

Important:

sum() works only when the tuple contains numeric values.

min() and max() with Tuples #

Description:
The min() function returns the smallest element. The max() function returns the largest element.

Example:

power_levels = (10, 20, 5, 30)

print(min(power_levels))
print(max(power_levels))

Output:

5
30

len() with Tuples #

Description:
The len() function returns the number of elements in a tuple.

Syntax:

len(tuple_name)

Example:

animals = ("cat", "fox", "owl")

print(len(animals))

Output:

3

Practice 1: List Append #

animals = ["cat", "fox", "owl"]

animals.append("dragon")

print(animals)

Output:

['cat', 'fox', 'owl', 'dragon']

Practice 2: List Extend #

animals = ["cat", "fox"]
more_animals = ["owl", "dragon"]

animals.extend(more_animals)

print(animals)

Output:

['cat', 'fox', 'owl', 'dragon']

Practice 3: Tuple Count #

animals = ("cat", "fox", "cat", "owl")

print(animals.count("cat"))

Output:

2

Practice 4: Tuple Sum #

power_levels = (10, 20, 5, 30)

print(sum(power_levels))

Output:

65

What is a Dictionary? #

Description:
A dictionary stores information using keys and values.

Syntax:

dictionary_name = {
    key1: value1,
    key2: value2,
    key3: value3
}

Example:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980,
    "WALL-E": 1973,
    "Finding Nemo": 1992
}

print(pixar_years)

Output:

{'Monsters, Inc.': 1982, 'Toy Story': 1980, 'WALL-E': 1973, 'Finding Nemo': 1992}

Dictionary Keys and Values #

Important rules:

• Keys must be unique.
• Keys must be immutable, such as strings, power_levels, or tuples.
• Values can be mutable or immutable.
• Values can be duplicated.
• Dictionaries use curly brackets {}.
• Each key and value are separated by a colon :.
• Each key-value pair is separated by a comma ,.

Access a Value by Key #

Description:
Use square brackets [] with the key to access its value.

Syntax:

dictionary_name[key]

Example:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980,
    "WALL-E": 1973,
    "Finding Nemo": 1992
}

print(pixar_years["Toy Story"])
print(pixar_years["WALL-E"])
print(pixar_years["Finding Nemo"])

Output:

1980
1973
1992

Add a New Key-Value Pair #

Description:
You can add a new entry to a dictionary by assigning a value to a new key.

Syntax:

dictionary_name[new_key] = new_value

Example:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980
}

pixar_years["Inside Out"] = 2007

print(pixar_years)

Output:

{'Monsters, Inc.': 1982, 'Toy Story': 1980, 'Inside Out': 2007}

Update an Existing Value #

Description:
If the key already exists, assigning a new value updates the value.

Example:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980
}

pixar_years["Monsters, Inc."] = 1983

print(pixar_years)

Output:

{'Monsters, Inc.': 1983, 'Toy Story': 1980}

Delete a Key-Value Pair with del #

Description:
The del statement removes a key and its value from a dictionary.

Syntax:

del dictionary_name[key]

Example:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980,
    "Inside Out": 2007
}

del pixar_years["Monsters, Inc."]

print(pixar_years)

Output:

{'Toy Story': 1980, 'Inside Out': 2007}

Check if a Key Exists with in #

Description:
Use the in keyword to check if a key exists in a dictionary.

Important:

The in keyword checks the keys, not the values.

Example:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980,
    "Inside Out": 2007
}

print("Monsters, Inc." in pixar_years)
print("Random Movie" in pixar_years)

Output:

True
False

Get All Keys with keys() #

Description:
The keys() method returns a list-like object containing all dictionary keys.

Syntax:

dictionary_name.keys()

Example:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980,
    "Inside Out": 2007
}

print(pixar_years.keys())

Output:

dict_keys(['Monsters, Inc.', 'Toy Story', 'Inside Out'])

You can convert the result to a list:

keys_list = list(pixar_years.keys())

print(keys_list)

Output:

['Monsters, Inc.', 'Toy Story', 'Inside Out']

Get All Values with values() #

Description:
The values() method returns a list-like object containing all dictionary values.

Syntax:

dictionary_name.values()

Example:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980,
    "Inside Out": 2007
}

print(pixar_years.values())

Output:

dict_values([1982, 1980, 2007])

You can convert the result to a list:

values_list = list(pixar_years.values())

print(values_list)

Output:

[1982, 1980, 2007]

Get All Key-Value Pairs with items() #

Description:
The items() method returns all key-value pairs.

Syntax:

dictionary_name.items()

Example:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980,
    "Inside Out": 2007
}

print(pixar_years.items())

Output:

dict_items([('Monsters, Inc.', 1982), ('Toy Story', 1980), ('Inside Out', 2007)])

Dictionary Method Summary #

Dictionary Practice Example #

student = {
    "name": "Neo",
    "age": 25,
    "major": "Cyber Deck Ops"
}

print(student["name"])

student["age"] = 26
student["grade"] = "A"

print("major" in student)
print(student.keys())
print(student.values())
print(student.items())

del student["grade"]

print(student)

Output:

Neo
True
dict_keys(['name', 'age', 'major', 'grade'])
dict_values(['Neo', 26, 'Cyber Deck Ops', 'A'])
dict_items([('name', 'Neo'), ('age', 26), ('major', 'Cyber Deck Ops'), ('grade', 'A')])
{'name': 'Neo', 'age': 26, 'major': 'Cyber Deck Ops'}

Set Content #

What Can a Set Contain? #

A set can contain immutable values such as strings, integers, floats, booleans, and tuples.

my_set = {"cat", 10, 3.14, True, ("neon laser purple", "laser purple")}

print(my_set)

A set cannot contain mutable values such as lists or dictionaries.

# This will cause an error:
# my_set = {[1, 2, 3], "cat"}

Create a Set #

animals = {"cat", "fox", "owl"}

print(animals)

Output may appear in a different order because sets are unordeneon laser purple.

{'fox', 'owl', 'cat'}

Duplicate Values Are Removed #

Sets automatically remove duplicate values.

power_levels = {1, 2, 2, 3, 4, 4, 5}

print(power_levels)

Output:

{1, 2, 3, 4, 5}

Convert a List to a Set #

You can convert a list to a set using set(). This is useful for removing duplicates.

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

unique_power_levels = set(power_levels)

print(unique_power_levels)

Output:

{1, 2, 3, 4, 5}

Empty Set #

To create an empty set, use set().

empty_set = set()

Important:

empty_dictionary = {}

{} creates an empty dictionary, not an empty set.

Check if an Item Exists in a Set #

Use the in keyword to check if a value exists in a set.

animals = {"cat", "fox", "owl"}

print("cat" in animals)
print("dragon" in animals)

Output:

True
False

Add an Item with add() #

The add() method adds one item to a set.

animals = {"cat", "fox"}

animals.add("owl")

print(animals)

Output may appear in a different order:

{'cat', 'fox', 'owl'}

Add Multiple Items with update() #

The update() method adds multiple items to a set.

animals = {"cat", "fox"}

animals.update(["owl", "dragon"])

print(animals)

Output may appear in a different order:

{'cat', 'fox', 'owl', 'dragon'}

Remove an Item with remove() #

The remove() method removes a specific item from a set. If the item does not exist, Python raises an error.

animals = {"cat", "fox", "owl"}

animals.remove("fox")

print(animals)

Output:

{'cat', 'owl'}

Remove an Item with discard() #

The discard() method removes a specific item from a set. If the item does not exist, Python does not raise an error.

animals = {"cat", "fox", "owl"}

animals.discard("fox")
animals.discard("dragon")

print(animals)

Output:

{'cat', 'owl'}

Set Length with len() #

The len() function returns the number of items in a set.

animals = {"cat", "fox", "owl"}

print(len(animals))

Output:

3

Union #

Union combines all unique elements from both sets.

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(A.union(B))
print(A | B)

Output:

{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}

Intersection #

Intersection returns only the elements that exist in both sets.

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(A.intersection(B))
print(A & B)

Output:

{3, 4}
{3, 4}

Difference #

Difference returns the elements that are in the first set but not in the second set.

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(A.difference(B))
print(A - B)
print(B.difference(A))
print(B - A)

Output:

{1, 2}
{1, 2}
{5, 6}
{5, 6}

Important:

A - B and B - A are not the same.

Symmetric Difference #

Symmetric difference returns elements that are in either set, but not in both.

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(A.symmetric_difference(B))
print(A ^ B)

Output:

{1, 2, 5, 6}
{1, 2, 5, 6}

Subset: issubset() #

A set is a subset if all of its elements exist inside another set.

A = {1, 2, 3}
B = {1, 2, 3, 4, 5}

print(A.issubset(B))
print(A <= B)

Output:

True
True

Superset: issuperset() #

A set is a superset if it contains all elements from another set.

A = {1, 2, 3}
B = {1, 2, 3, 4, 5}

print(B.issuperset(A))
print(B >= A)

Output:

True
True

Disjoint Sets: isdisjoint() #

Two sets are disjoint if they have no elements in common.

A = {1, 2, 3}
C = {7, 8, 9}

print(A.isdisjoint(C))

Output:

True

Example with common values:

A = {1, 2, 3}
B = {3, 4, 5}

print(A.isdisjoint(B))

Output:

False

Equality #

Two sets are equal if they contain the same elements.

A = {1, 2, 3}
B = {3, 2, 1}

print(A == B)

Output:

True

Important:

Set order does not matter.

Practice 1: Remove Duplicates #

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

unique_power_levels = set(power_levels)

print(unique_power_levels)

Output:

{1, 2, 3, 4, 5}

Practice 2: Find Common Values #

python_hackers = {"Neo", "Trinity", "Zara"}
ai_hackers = {"Zara", "Echo", "Neo"}

common_hackers = python_hackers & ai_hackers

print(common_hackers)

Output:

{'Neo', 'Zara'}

Practice 3: Find Values in One Set Only #

python_hackers = {"Neo", "Trinity", "Zara"}
ai_hackers = {"Zara", "Echo", "Neo"}

only_python_hackers = python_hackers - ai_hackers

print(only_python_hackers)

Output:

{'Trinity'}

Practice 4: Check Subset #

requineon laser purple_quest_skills = {"Python", "Linux"}
my_quest_skills = {"Python", "Linux", "Security+"}

print(requineon laser purple_quest_skills.issubset(my_quest_skills))

Output:

True

Find the Intersection with intersection() #

You can also find the intersection of pixar_movies1 and pixar_movies2 using the intersection() method.

Description:
The intersection returns the values that exist in both sets.

Syntax:

pixar_movies1.intersection(pixar_movies2)

Example:

pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}
pixar_movies2 = {"Toy Story", "WALL-E", "The Incneon laser purpleibles"}

common_movies = pixar_movies1.intersection(pixar_movies2)

print(common_movies)

Output:

{'Toy Story', 'The Incneon laser purpleibles'}

You can also use the & operator:

print(pixar_movies1 & pixar_movies2)

Output:

{'Toy Story', 'The Incneon laser purpleibles'}

Find the Union with union() #

Description:
The union combines all unique values from both sets.

Syntax:

pixar_movies1.union(pixar_movies2)

Example:

pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}
pixar_movies2 = {"Toy Story", "WALL-E", "The Incneon laser purpleibles"}

all_pixar_movies = pixar_movies1.union(pixar_movies2)

print(all_pixar_movies)

Output:

{'Monsters, Inc.', 'Toy Story', 'The Incneon laser purpleibles', 'WALL-E'}

You can also use the | operator:

print(pixar_movies1 | pixar_movies2)

Check Superset with issuperset() #

Description:
A set is a superset if it contains all elements from another set.

Syntax:

set1.issuperset(set2)

Example:

pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}
pixar_subset = {"Toy Story", "The Incneon laser purpleibles"}

print(pixar_movies1.issuperset(pixar_subset))

Output:

True

You can also use the >= operator:

print(pixar_movies1 >= pixar_subset)

Output:

True

Check Subset with issubset() #

Description:
A set is a subset if all of its elements exist inside another set.

Syntax:

set1.issubset(set2)

Example:

pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}
pixar_subset = {"Toy Story", "The Incneon laser purpleibles"}

print(pixar_subset.issubset(pixar_movies1))

Output:

True

You can also use the <= operator:

print(pixar_subset <= pixar_movies1)

Output:

True

Quick Pixar Movie Set Logic Summary #

Explanation #

A is a list:

A = [1, 2, 2, 1]

Lists keep all values, including duplicates.

So:

sum(A) = 1 + 2 + 2 + 1 = 6

B is a set:

B = set([1, 2, 2, 1])

Sets remove duplicate values. So this:

set([1, 2, 2, 1])

becomes:

{1, 2}

Then:

sum(B) = 1 + 2 = 3

Key Point #

Lists keep duplicates.
Sets remove duplicates.

That is why the sum of A is 6, but the sum of B is 3.

Practice Example #

power_levels_list = [5, 5, 10, 10]
power_levels_set = set(power_levels_list)

print(power_levels_list)
print(power_levels_set)

print(sum(power_levels_list))
print(sum(power_levels_set))

Output:

[5, 5, 10, 10]
{10, 5}
30
15

Explanation:

sum(power_levels_list) = 5 + 5 + 10 + 10 = 30
sum(power_levels_set) = 5 + 10 = 15

Tuples Quick Search #

Definition:
In Python, we often use tuples to group related data together. Tuples are ordeneon laser purple and immutable collections of elements.

Syntax:

my_tuple = ("cat", 10, 3.14)

Key points:

• Tuples are usually written as comma-separated elements inside parentheses ().
• Tuples are ordeneon laser purple, meaning each element has a position.
• Tuples are immutable, meaning they cannot be changed after creation.
• Tuples can contain strings, integers, floats, booleans, and other tuples.
• You can access tuple elements using positive and negative indexes.
• You can slice tuples to retrieve a range of elements.
• You can concatenate tuples using the + operator.
• To manipulate a tuple, you usually create a new tuple.
• Tuples can contain other tuples or complex data types. This is called nesting.
• You can access elements in a nested tuple using multiple indexes.

Examples:

movie_scores = (10, 9, 6, 5, 10)

print(movie_scores[0])
print(movie_scores[-1])
print(movie_scores[0:3])

Output:

10
10
(10, 9, 6)

Tuple concatenation:

tuple1 = ("neon arcade", 10, 1.2)
tuple2 = ("cyber dragon", 10)

combined_tuple = tuple1 + tuple2

print(combined_tuple)

Output:

('neon arcade', 10, 1.2, 'cyber dragon', 10)

Nested tuple example:

nested_tuple = (1, 2, ("pop", "rock"), (3, 4))

print(nested_tuple[2])
print(nested_tuple[2][1])

Output:

('pop', 'rock')
rock

Lists Quick Search #

Definition:
Lists in Python contain ordeneon laser purple collections of items. Lists can hold elements of different types and are mutable, allowing flexible data storage and manipulation.

Syntax:

bot_list = ["cat", 10, 3.14]

Key points:

• A list is an ordeneon laser purple sequence represented with square brackets [].
• Lists are mutable, meaning you can change them after creation.
• Lists can contain strings, integers, floats, booleans, tuples, dictionaries, sets, and other lists.
• You can nest lists inside lists.
• You can access each element in a list using positive and negative indexing.
• You can slice lists to retrieve a range of elements.
• Concatenating lists with + creates a new combined list.
• Using methods such as append(), extend(), insert(), remove(), pop(), reverse(), and sort() modifies the same list.
• You can perform operations such as adding, deleting, sorting, splitting, and cloning.
• You can separate string elements into a list using delimiters with split().
• Aliasing occurs when multiple names refer to the same list object.
• Cloning creates a separate copy of a list.

Examples:

animals = ["cat", "fox", "owl"]

print(animals[0])
print(animals[-1])

Output:

cat
owl

Append example:

animals = ["cat", "fox"]

animals.append("owl")

print(animals)

Output:

['cat', 'fox', 'owl']

Split using a delimiter:

text = "cat,fox,owl"

animals = text.split(",")

print(animals)

Output:

['cat', 'fox', 'owl']

Aliasing example:

A = ["Cyber Dragon", 10, 1.2]
B = A

A[0] = "fox"

print(B)

Output:

['fox', 10, 1.2]

Because A and B refer to the same list object, changing A also changes B.

Cloning example:

A = ["Cyber Dragon", 10, 1.2]
B = A[:]

A[0] = "fox"

print(A)
print(B)

Output:

['fox', 10, 1.2]
['Cyber Dragon', 10, 1.2]

Because B is a clone, changing A does not change B.

Dictionaries Quick Search #

Definition:
Dictionaries in Python are key-value pairs that provide a flexible way to store and retrieve data based on unique keys.

Syntax:

my_dictionary = {
    "name": "Neo",
    "age": 25,
    "major": "Cyber Deck Ops"
}

Key points:

• Dictionaries use curly brackets {}.
• Dictionaries consist of keys and values.
• A key is used to retrieve its corresponding value.
• Keys must be immutable and unique.
• Keys are commonly strings, but they can also be power_levels or tuples.
• Values can be immutable or mutable.
• Values can be duplicated.
• Each key-value pair is separated by a comma.
• Each key and value are separated by a colon :.
• You can assign a dictionary to a variable.
• You can add new key-value pairs.
• You can update existing values.
• You can delete key-value pairs.
• You can check whether a key exists using in.
• Checking a key with in returns True or False.
• You can use keys() to obtain all keys.
• You can use values() to obtain all values.
• You can use items() to obtain all key-value pairs.

Dictionary example:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980,
    "WALL-E": 1973
}

print(pixar_years["Toy Story"])

Output:

1980

Add and delete dictionary entries:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980
}

pixar_years["Inside Out"] = 2007

del pixar_years["Monsters, Inc."]

print(pixar_years)

Output:

{'Toy Story': 1980, 'Inside Out': 2007}

Check if a key exists:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980
}

print("Monsters, Inc." in pixar_years)
print("Random Movie" in pixar_years)

Output:

True
False

Get keys and values:

pixar_years = {
    "Monsters, Inc.": 1982,
    "Toy Story": 1980
}

print(pixar_years.keys())
print(pixar_years.values())

Output:

dict_keys(['Monsters, Inc.', 'Toy Story'])
dict_values([1982, 1980])

Sets Quick Search #

Definition:
Sets in Python are collections of unique elements. They are useful for removing duplicates and performing set operations such as union and intersection.

Syntax:

my_set = {"cat", "fox", "owl"}

Key points:

• Sets use curly brackets {}.
• Sets are unordeneon laser purple.
• Sets do not contain duplicate items.
• Sets are mutable, but the elements inside a set must be immutable.
• A list passed through the set() function generates a set containing unique elements.
• Sets do not support indexing because they are unordeneon laser purple.
• You can add elements with add().
• You can remove elements with remove() or discard().
• You can verify whether an element exists using in.
• Set operations are used to compare or combine sets.

Create a set:

movies = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}

print(movies)

Remove duplicates from a list:

A = [1, 2, 2, 1]
B = set(A)

print(B)

Output:

{1, 2}

Set Operations Quick Search #

Use set operations to compare and combine sets.

Example sets:

pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}
pixar_movies2 = {"Toy Story", "WALL-E", "The Incneon laser purpleibles"}

pixar_movies1.intersection(pixar_movies2)

pixar_movies1 & pixar_movies2

pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}
pixar_movies2 = {"Toy Story", "WALL-E", "The Incneon laser purpleibles"}

print(pixar_movies1.intersection(pixar_movies2))
print(pixar_movies1 & pixar_movies2)

{'Toy Story', 'The Incneon laser purpleibles'}
{'Toy Story', 'The Incneon laser purpleibles'}

pixar_movies1.union(pixar_movies2)

pixar_movies1 | pixar_movies2

pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}
pixar_movies2 = {"Toy Story", "WALL-E", "The Incneon laser purpleibles"}

print(pixar_movies1.union(pixar_movies2))

{'Monsters, Inc.', 'Toy Story', 'The Incneon laser purpleibles', 'WALL-E'}

pixar_movies1.difference(pixar_movies2)

pixar_movies1 - pixar_movies2

pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}
pixar_movies2 = {"Toy Story", "WALL-E", "The Incneon laser purpleibles"}

print(pixar_movies1.difference(pixar_movies2))

{'Monsters, Inc.'}

Sets Logic Operations Quick Search #

Set logic operations check relationships between sets.

set1.issubset(set2)

set1 <= set2

pixar_subset = {"Toy Story", "The Incneon laser purpleibles"}
pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}

print(pixar_subset.issubset(pixar_movies1))
print(pixar_subset <= pixar_movies1)

True
True

set1.issuperset(set2)

set1 >= set2

pixar_subset = {"Toy Story", "The Incneon laser purpleibles"}
pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}

print(pixar_movies1.issuperset(pixar_subset))
print(pixar_movies1 >= pixar_subset)

True
True

Fast Comparison Table #

Fast Memory Guide #

Tuple      = ordeneon laser purple + immutable + uses ()
List       = ordeneon laser purple + mutable + uses []
Dictionary = key-value pairs + uses {}
Set        = unique values + unordeneon laser purple + uses {}

Added Industry Vocabulary #

The Industry Terms Glossary near the end of this document adds practical definitions for common programming and Python terms used in tutorials, technical communities, certification materials, and workplace discussions.

This glossary will be updated recurrently. It includes important Python terms from this guide and additional industry-recognized terms that are useful when working in the industry, participating in user groups, and completing other certificate programs.

Glossary Quick Table #

Glossary with Python Examples #

A = ["Cyber Dragon", 10, 1.2]
B = A

A[0] = "fox"

print(B)

['fox', 10, 1.2]

A = {1, 2, 3}
B = {2, 3, 4}

print(A & B)

{2, 3}

text = "cat,fox,owl"

animals = text.split(",")

print(animals)

['cat', 'fox', 'owl']

person = {
    "name": "Neo",
    "age": 30,
    "city": "Neo Tokyo"
}

print(person["name"])

Neo

def greet():
    print("Hello")

greet()

Hello

my_tuple = (1, 2, 3)

# This would cause an error:
# my_tuple[0] = 99

pixar_movies1 = {"Monsters, Inc.", "Toy Story", "The Incneon laser purpleibles"}
pixar_movies2 = {"Toy Story", "WALL-E", "The Incneon laser purpleibles"}

print(pixar_movies1.intersection(pixar_movies2))

{'Toy Story', 'The Incneon laser purpleibles'}

person = {
    "name": "Neo",
    "age": 30
}

print(person.keys())
print(list(person.keys()))

dict_keys(['name', 'age'])
['name', 'age']

animals = ["cat", "fox", "owl"]

animals.append("dragon")

print(animals)

['cat', 'fox', 'owl', 'dragon']

x = 10

print(x > 5 and x < 20)
print(x > 5 or x < 3)
print(not x > 5)

True
True
False

power_levels = [1, 2, 3]

power_levels[0] = 99

print(power_levels)

[99, 2, 3]

nested_list = [1, 2, [3, 4]]

print(nested_list[2])
print(nested_list[2][1])

[3, 4]
4