|
|
# [SECTION] Lists
|
|
|
# Lists are similar to arrays in JavaScript in the sense that they can contain a collection of data.
|
|
|
# To create a list, square brackets ([]) are used.
|
|
|
|
|
|
names = ["John", "Paul", "George", "Ringo"] # String list
|
|
|
programs = ['developer career', 'pi-shape', 'tech career package']
|
|
|
durations = [260, 180, 20] # Number list
|
|
|
truth_values = [True, False, True, True, False] # Boolean list
|
|
|
|
|
|
# A list can contain elements of different data types:
|
|
|
sample_list = ["Apple", 3, False, "Potato", 4, True]
|
|
|
|
|
|
# Problems may arise if you try to use lists with multiple types for something that expects them to be all the same type.
|
|
|
|
|
|
# Problems may arise if you try to use lists with multiple types for something that expects them to be all the same type.
|
|
|
|
|
|
print("Lists:")
|
|
|
|
|
|
# Getting list size
|
|
|
# The number of elements in a list can be counted using the len() function.
|
|
|
|
|
|
print(len(programs))
|
|
|
# Result: 3
|
|
|
|
|
|
# Accessing values in lists
|
|
|
# List elements can be accessed by providing their index number.
|
|
|
# Indexing in lists starts at 0 and goes up to n - 1, where n is the number of elements.
|
|
|
|
|
|
print(names[0])
|
|
|
# Result: John
|
|
|
|
|
|
# Accessing the last item in the lists
|
|
|
print(names[-1])
|
|
|
# Result: Ringo
|
|
|
|
|
|
# Accesing the whole list
|
|
|
print(durations)
|
|
|
# Result: [260, 180, 20]
|
|
|
|
|
|
# Accessing a range of values
|
|
|
# SYNTAX: list[start index : end index]
|
|
|
print(programs[0:2])
|
|
|
# Result: ['developer career', 'pi-shape']
|
|
|
|
|
|
# Mini Exercise 1:
|
|
|
# Create a list of names of 5 students
|
|
|
# Create a list of grades for the 5 students
|
|
|
# Use a loop to iterate through the lists, printing in the following format: "The grade of <student> is <grade>".
|
|
|
|
|
|
# Solution:
|
|
|
students = ["Mary", "Matthew", "Tom", "Anna", "Thomas"]
|
|
|
grades = [100, 85, 88, 90, 75]
|
|
|
|
|
|
count = 0
|
|
|
while count < len(students):
|
|
|
print(f"The grade of {students[count]} is {grades[count]}")
|
|
|
count += 1
|
|
|
|
|
|
# Result:
|
|
|
# The grade of Mary is 100
|
|
|
# The grade of Matthew is 85
|
|
|
# The grade of Tom is 88
|
|
|
# The grade of Anna is 90
|
|
|
# The grade of Thomas is 75
|
|
|
|
|
|
# Updating List Elements
|
|
|
|
|
|
# Print the current value
|
|
|
print(f'Current value: {programs[2]}')
|
|
|
# Result: Current value: tech career package
|
|
|
|
|
|
# Update the value
|
|
|
programs[2] = 'short courses'
|
|
|
|
|
|
# Print the new value
|
|
|
print(f'New value: {programs[2]}')
|
|
|
# Result: New value: short courses
|
|
|
|
|
|
# [SECTION] List Manipulation
|
|
|
# Lists have methods that can be used to manipulate their elements.
|
|
|
|
|
|
# Adding list items – the append() method allows you to insert items at the end of the list.
|
|
|
|
|
|
programs.append('global')
|
|
|
print(programs)
|
|
|
# Result: ['developer career', 'pi-shape', 'Short Courses', 'global']
|
|
|
|
|
|
# Deleting list items – the "del" keyword can be used to delete elements from the list.
|
|
|
|
|
|
# Add a new item to the durations list
|
|
|
durations.append(360)
|
|
|
print(durations)
|
|
|
# Result: [260, 180, 20, 360]
|
|
|
|
|
|
# Delete the last item on the list
|
|
|
del durations[-1]
|
|
|
print(durations)
|
|
|
# Result: [260, 180, 20]
|
|
|
|
|
|
# Membership Checks – The "in" keyword checks if an element is in the list and returns True or False.
|
|
|
print(20 in durations)
|
|
|
# Result: True
|
|
|
print(500 in durations)
|
|
|
# Result: False
|
|
|
|
|
|
# Sorting lists - the sort() method sorts the list alphanumerically, ascending, by default.
|
|
|
names.sort()
|
|
|
print(names)
|
|
|
# Result: ['George', 'John', 'Paul', 'Ringo']
|
|
|
|
|
|
# Emptying the list - the clear() method is used to empty the contents of the list.
|
|
|
test_list = [1, 3, 5, 7, 9]
|
|
|
print(test_list)
|
|
|
|
|
|
test_list.clear()
|
|
|
print(test_list)
|
|
|
# Result: []
|
|
|
|
|
|
# [SECTION] Dictionaries
|
|
|
# Dictionaries are used to store data values in key:value pairs. This is similar to objects in JavaScript.
|
|
|
# A dictionary is a collection that is ordered, changeable, and does not allow duplicates.
|
|
|
# Ordered means that the items have a defined order, and that order will not change.
|
|
|
# Changeable means that values can be modified.
|
|
|
# To create a dictionary, curly braces ({}) are used, and key-value pairs are written as key: value.
|
|
|
|
|
|
print("Dictionaries:")
|
|
|
|
|
|
person1 = {
|
|
|
"name" : "Brandon",
|
|
|
"age" : 28,
|
|
|
"occupation" : "student",
|
|
|
"is_enrolled" : True,
|
|
|
"subjects" : ["Python", "SQL", "Django"]
|
|
|
}
|
|
|
|
|
|
# To get the number of key-pairs in the dictionary, the len() method can be used.
|
|
|
print(len(person1))
|
|
|
# Result: 5
|
|
|
|
|
|
# To get a value from the dictionary, you can refer to its key using square brackets ([]).
|
|
|
print(person1["name"])
|
|
|
# Result: Brandon
|
|
|
|
|
|
# The keys() method returns a view object containing all the keys in the dictionary.
|
|
|
print(person1.keys())
|
|
|
# Result: dict_keys(['name', 'age', 'occupation', 'is_enrolled', 'subjects'])
|
|
|
|
|
|
# The values() method returns a view object containing all the values in the dictionary.
|
|
|
print(person1.values())
|
|
|
# Result: dict_values(['Brandon', 28, 'student', True, ['Python', 'SQL', 'Django']])
|
|
|
|
|
|
# The items() method returns each item in the dictionary as key-value pairs in a view object.
|
|
|
print(person1.items())
|
|
|
# Result: dict_items([('name', 'Brandon'), ('age', 28), ('occupation', 'student'), ('is_enrolled', True), ('subjects', ['Python', 'SQL', 'Django'])])
|
|
|
|
|
|
# Adding key-value pairs can be done either by assigning a new key using square brackets, or by using the update() method.
|
|
|
|
|
|
# Using new index
|
|
|
person1["nationality"] = "Filipino"
|
|
|
print(person1)
|
|
|
# Result: {'name': 'Brandon', 'age': 28, 'occupation': 'student', 'is_enrolled': True, 'subjects': ['Python', 'SQL', 'Django'], 'nationality': 'Filipino'}
|
|
|
|
|
|
# Using update() method
|
|
|
person1.update({"fav_food" : "Sinigang"})
|
|
|
print(person1)
|
|
|
# Result: {'name': 'Brandon', 'age': 28, 'occupation': 'student', 'is_enrolled': True, 'subjects': ['Python', 'SQL', 'Django'], 'nationality': 'Filipino', 'fav_food': 'Sinigang'}
|
|
|
|
|
|
# Deleting entries can be done using the pop() method or the del keyword
|
|
|
|
|
|
# Using pop() method
|
|
|
person1.pop("fav_food")
|
|
|
print(person1)
|
|
|
# Result: {'name': 'Brandon', 'age': 28, 'occupation': 'student', 'is_enrolled': True, 'subjects': ['Python', 'SQL', 'Django'], 'nationality': 'Filipino'}
|
|
|
|
|
|
# Using del keyword
|
|
|
del person1["nationality"]
|
|
|
print(person1)
|
|
|
# Result: {'name': 'Brandon', 'age': 28, 'occupation': 'student', 'is_enrolled': True, 'subjects': ['Python', 'SQL', 'Django']}
|
|
|
|
|
|
# Emptying the Dictionary
|
|
|
|
|
|
person2 = {
|
|
|
"name" : "John",
|
|
|
"age" : 18
|
|
|
}
|
|
|
|
|
|
print(person2)
|
|
|
# Result: {'name': 'John', 'age': 18}
|
|
|
|
|
|
# The clear() method empties the dictionary
|
|
|
person2.clear()
|
|
|
|
|
|
print(person2)
|
|
|
# Result: {}
|
|
|
|
|
|
# Looping through dictionaries
|
|
|
print("Looping through dictionaries:")
|
|
|
|
|
|
for key in person1:
|
|
|
print(f"The value of {key} is {person1[key]}")
|
|
|
|
|
|
# Result:
|
|
|
# The value of name is Brandon
|
|
|
# The value of age is 28
|
|
|
# The value of occupation is student
|
|
|
# The value of is_enrolled is True
|
|
|
# The value of subjects is ['Python', 'SQL', 'Django']
|
|
|
|
|
|
# Nested dictionaries - dictionaries can be nested inside each other
|
|
|
person3 = {
|
|
|
"name": "Monika",
|
|
|
"age": 20,
|
|
|
"occupation": "poet",
|
|
|
"is_enrolled": True,
|
|
|
"subjects": ["Python", "SQL", "Django"]
|
|
|
}
|
|
|
|
|
|
classroom = {
|
|
|
"student1" : person1,
|
|
|
"student2" : person3
|
|
|
}
|
|
|
print(classroom)
|
|
|
# Result: {'student1': {'name': 'Brandon', 'age': 28, 'occupation': 'student', 'is_enrolled': True, 'subjects': ['Python', 'SQL', 'Django']}, 'student2': {'name': 'Monika', 'age': 20, 'occupation': 'poet', 'is_enrolled': True, 'subjects': ['Python', 'SQL', 'Django']}}
|
|
|
|
|
|
# [SECTION] Functions
|
|
|
# Functions are blocks of code that run when called.
|
|
|
# The "def" keyword is used to create a function.
|
|
|
# SYNTAX: def function_name():
|
|
|
|
|
|
def my_greeting():
|
|
|
# Code to be run when my_greeting is called
|
|
|
print('Hello User!')
|
|
|
|
|
|
print("Functions:")
|
|
|
|
|
|
# Calling/invoking a function
|
|
|
my_greeting()
|
|
|
# Result: Hello User!
|
|
|
|
|
|
# Parameters in functions allow you to specify what inputs the function expects and provide more control over how the function behaves.
|
|
|
def greet_user(username):
|
|
|
# prints out the value of the username parameter
|
|
|
print(f'Hello, {username}!')
|
|
|
|
|
|
# Arguments are the actual values that are passed into the function when it is called.
|
|
|
greet_user("Bob")
|
|
|
# Result: Hello, Bob!
|
|
|
greet_user("Amy")
|
|
|
# Result: Hello, Amy!
|
|
|
|
|
|
# The "return" keyword allows a function to return values.
|
|
|
def addition(num1, num2):
|
|
|
return num1 + num2
|
|
|
|
|
|
sum = addition(5, 10)
|
|
|
print(f"The sum is {sum}")
|
|
|
# Result: The sum is 15
|
|
|
|
|
|
# A lambda function is a small, anonymous function that can be used for callbacks or short, throwaway operations.
|
|
|
# It works like any regular Python function, but it has no name and is defined using a single line of code.
|
|
|
# A lambda function can take any number of arguments but can only contain one expression.
|
|
|
|
|
|
greeting = lambda person : f'Hello {person}!'
|
|
|
print(greeting("Jane"))
|
|
|
# Result: Hello Jane!
|
|
|
|
|
|
multiplication = lambda a, b : a * b
|
|
|
print(multiplication(3, 5))
|
|
|
# Result: 15
|
|
|
|
|
|
# Mini Exercise 2:
|
|
|
# Create a function that returns the square of a number.
|
|
|
# Use 5 as argument, result should be 25.
|
|
|
# Print "The square is {result}."
|
|
|
|
|
|
# Solution:
|
|
|
def sqr(num):
|
|
|
return num * num # or return num ** 2
|
|
|
|
|
|
result = sqr(5)
|
|
|
print(f"The square is {result}.")
|
|
|
# Result: The square is 25.
|
|
|
|
|
|
# [SECTION] Classes
|
|
|
# Classes serve as blueprints that describe the concept of objects.
|
|
|
# Each object has characteristics (called properties) and behaviors (called methods).
|
|
|
# Imagine the concept of a car: a car has a brand, model, and year of make, and it can drive, brake, and turn.
|
|
|
# To create a class, use the "class" keyword followed by a class name that starts with an uppercase letter.
|
|
|
# SYNTAX: class ClassName():
|
|
|
|
|
|
class Car():
|
|
|
# The properties that all Car objects must have are defined in a method called __init__.
|
|
|
# Any number of parameters can be passed to __init__(), but the first parameter should always be self.
|
|
|
# self refers to the current instance of the class
|
|
|
# When a Car instance is created, that instance is automatically passed to the self parameter.
|
|
|
def __init__(self, brand, model, year_of_make):
|
|
|
self.brand = brand
|
|
|
self.model = model
|
|
|
self.year_of_make = year_of_make
|
|
|
|
|
|
# Other properties can be added and assigned hard-coded values.
|
|
|
self.fuel = "Gasoline"
|
|
|
self.fuel_level = 0
|
|
|
|
|
|
# Methods are functions defined inside a class.
|
|
|
# Method to simulate filling the fuel tank
|
|
|
def fill_fuel(self):
|
|
|
print(f'Current fuel level: {self.fuel_level}')
|
|
|
print('filling up the fuel tank...')
|
|
|
self.fuel_level = 100
|
|
|
print(f'New fuel level: {self.fuel_level}')
|
|
|
# Mini Exercise solution
|
|
|
def drive(self, distance):
|
|
|
print(f"The car has driven {distance} kilometers")
|
|
|
print(f"The fuel level left: {self.fuel_level - distance}")
|
|
|
|
|
|
# Creating a new instance is done by calling the class and providing the required arguments
|
|
|
new_car = Car("Nissan", "GT-R", "2019")
|
|
|
|
|
|
print("Classes:")
|
|
|
|
|
|
# Displaying attributes can be done using dot notation
|
|
|
print(f"My car is a {new_car.brand} {new_car.model}")
|
|
|
# Result: My car is a Nissan GT-R
|
|
|
|
|
|
# Calling methods on the instance
|
|
|
new_car.fill_fuel()
|
|
|
# Result:
|
|
|
# Current fuel level: 0
|
|
|
# filling up the fuel tank...
|
|
|
# New fuel level: 100
|
|
|
|
|
|
# Mini Exercise solution
|
|
|
new_car.drive(50)
|
|
|
# Result:
|
|
|
# The car has driven 50 kilometers
|
|
|
# The fuel level left: 50 |