DEV Community: Ugbem Job

Day 11: Regular Expressions (Regex)

Ugbem Job — Tue, 28 Feb 2023 08:30:53 +0000

What I learnt

Regular Expressions
Regex Syntax
Regex functions/methods
Regex Flags
Regular Expression Character

Regular Expressions

Regular Expressions (Regex) are used in text data to match patterns. They are used to find specific patterns in strings or collections of strings. They may also be used to search for (find), change, and modify text data. They can also be utilized to validate user input like email addresses and phone numbers.

We need to import the re module to use regex in python.

Regex Syntax

Before we get into the syntax, we must understand that regex is a language. It has its own syntax and rules.
Regex is found in python and other programming languages like Java, C, JavaScript, PHP, etc. So if you have used regex in any of these languages, you will find that the syntax is the same.

Below are some of the most common syntax that makes up regex:

. - any character except newline
^ - start of string
$ - end of string
* - 0 or more occurrences of the preceding character
+ - 1 or more occurrences of the preceding character
? - 0 or 1 occurrences of the preceding character
{3} - exactly 3 occurrences of the preceding character
{3,4} - 3 to 4 occurrences of the preceding character
{3,} - 3 or more occurrences of the preceding character
[a-z] - any lowercase letter
[A-Z] - any uppercase letter
[0-9] - any digit
[0-9a-zA-Z] - any alphanumeric character (combination of the 3 syntaxes above)
[aeiou] - any vowel
[^aeiou] - any non-vowel (opposite of [aeiou])
[0-9]{3} - any 3 digit number
[0-9]{3,4} - any 3 or 4 digit number
[a-zA-Z]{8} - any 8 letter word
[a-zA-Z]{8,} - any word with 8 or more letters
\w - any alphanumeric character
\w+ - any alphanumeric character followed by 1 or more alphanumeric characters
\W - any non-alphanumeric character (opposite of \w)
\s - any whitespace character
\S - any non-whitespace character (opposite of \s)
\d - any digit
\D - any non-digit (opposite of \d)
\b - any word boundary
\B - any non-word boundary

Regex functions/methods

re.compile() - returns a regex pattern object, which can be used to match all occurences of a pattern
re.match() - returns a match object if the text matches the pattern
re.search() - returns a match object if there is a match anywhere in the text
re.findall() - returns a list of strings containing all matches
re.split() - returns a list of strings where the string has been split at each match
re.sub() - replaces one or many matches with a string

Regex Flags

re.I - ignore case (uppercase and lowercase)
re.M - multi-line (newline)
re.S - dot matches all (newline)
re.U - unicode (Python 3 only)
re.X - verbose (ignore whitespace and comments)

Example

import re

"""
The search() method returns a match object if there is a match anywhere in the string. If there is more than one match, only the first occurrence of the match will be returned.
"""

string = 'The quick brown fox jumps over the lazy dog.'
search = re.search(r'fox', string, re.I) # r - raw string

print(search) # <re.Match object; span=(16, 19), match='fox'>

print(search.span()) # (16, 19) # returns a tuple containing the start-, and end positions of the match.

print(search.start()) # 16 # returns the start position of the match.

print(search.end()) # 19 # returns the end position of the match.

print(search.group()) # fox # returns the part of the string where there was a match. This is more useful when there's multiple searches.

print(re.search('Fox', string)) # None # returns None if no match was found.

"""
The compile() method returns a regex pattern object, which can be used to match all occurrences of a pattern.
"""

pattern = re.compile('fox')

print(pattern.search(string)) # <re.Match object; span=(16, 19), match='fox'>

"""
The findall() method returns a list of strings containing all matches.

"""

print(pattern.findall(string))

"""
The match() method returns a match object if the text matches the pattern. If there is more than one match, only the first occurrence of the match will be returned.

"""

print(pattern.match(string)) # None # returns None if no match was found.

To read more about regex, visit the W3schools docs here.

Also, you can practice regex on Regex101 as it will help you understand regex more.

Regular Expression Character

. - Any character (except newline character)
\d - Digit (0-9)
\D - Not a digit (0-9)
\w - Word character (a-z, A-Z, 0-9, _) - any alphanumeric character

Example


string = 'Hey how are you!'
pattern = re.compile(r"([a-zA-Z]).([a])") # r - raw string # . - any character except newline # () - capturing group # [a-zA-Z] - any lowercase letter or uppercase letter  # [a] - any vowel

search_re = pattern.search(string)
print(search_re.group())

# More Examples
# 1. Validate email address using regex

pattern = re.compile(
r"([a-zA-Z0-9.-]+)@([a-zA-Z-]+)\.([a-zA-Z]{2,5})")
email = 'thisisjustatestemail@gmail.com'
valid_email = pattern.search(email)
print(valid_email.group())



# 2. Validate phone number using regex

pattern = re.compile(r"([0-9]{3})-([0-9]{3})-([0-9]{4})")
phone_number = '234-904-112-0034'
valid_phone_number = pattern.search(phone_number)
print(valid_phone_number.group())


# 3. Validate password using regex (password must be at least 8 characters long)

password = 'Passw@#12!ord'
pattern = re.compile(r"[A-Za-z0-9@#$%&!]{8,}")

"""
- fullmatch() - returns a match object if the string matches the pattern
"""

try:
valid_password = pattern.fullmatch(password)
print(valid_password.group())
except AttributeError:
print('Invalid password. Password must be at least 8 characters long')


# 4. Validate URL using regex

url = 'https://dev.to'
pattern = re.compile(r"https?://(www\.)?(\w+)(\.\w+)") # ? - optional # \ - escape character # \w - any alphanumeric character # \. - any period character
valid_url = pattern.fullmatch(url)
valid_url2 = pattern.search(url)
print(valid_url.group())
print(valid_url2.group())

Conclusion

In this article, we have learned about some regular expressions (regex) and how to use it in Python.
We have also learned about the different regex functions/methods and flags. We have also learned about the different regex characters. We have also learned how to validate email addresses, phone numbers, passwords, and URLs using regex as examples.

I hope you found this article helpful and if you have any questions, please leave a comment below.
I'd love to hear from you, and please share this post with your friends and follow me on my journey here on Dev.to for more articles like this.

Thank you for taking the time to read this.

References

If you found this article helpful, please leave a comment and share with your friends.

Day 10: Files I/O

Ugbem Job — Thu, 23 Feb 2023 08:00:24 +0000

What I learnt

Files
Open a file
Context Manager
Reading and writing files using the context manager
Reading contents of a file in chunks
Copying a file
File paths in different operating systems

Files

File I/O is the process of reading and writing to files to disk storage or your computer programmatically. There is a high probability that you will need to read and write to files in your Python projects.

Open a file

To open a file, we use the open() function. The open() function takes two parameters; filename, and mode.

Usually, when a file is opened, it is opened in the same directory as the Python file. However, you can specify the path to the file if it is not in the same directory.

There are four different methods (modes) for opening a file:

"r" - Read - Default value. Opens a file for reading, error if the file does not exist
"a" - Append - Opens a file for appending, creates the file if it does not exist
"w" - Write - Opens a file for writing, creates the file if it does not exist
"x" - Create - Creates the specified file, returns an error if the file exists

Example

# Open a file
my_file = open('sample.txt', 'r')
print(my_file.name) # sample.txt
print(my_file.mode) # prints mode of file
my_file.close()

Read a file

To read a file, we use the read() method. The read() method returns the whole text, but you can also specify how many characters you want to return.

NOTE: When you are done working with a file, it is a good practice to close it. This can be done by using the close() method.

Example

# Read a file
my_file = open('sample.txt', 'r')
print(my_file.read()) # prints contents of file
my_file.close()

Context Manager

The context manager is a way to open a file and close it automatically. This is done by using the with statement. This is the preferred way to open a file and the most commonly used method.

Example

with open('sample.txt', 'r') as file:
    print(file.read()) # prints contents of file
    print(file.read(10)) # prints first 10 characters of file
    print(file.readline())  # prints first line of file
    print(file.readlines()) # prints all lines of file as a list
    for line in file:
        print(line, end='') # prints each line of file

Usually, when using the context manager, you don't need to close the file using the close() method because it is done automatically.
However, if you want to close the file, you can do so by using the close() method.

Reading and writing files using the context manager

Read a file The read() method returns the whole text, but you can also specify how many characters you want to return. Also, there is a readline() method that returns one line, and a readlines() method that returns a list of lines in the file.

Example


with open('sample.txt', 'r') as file:
    print(file.read())  # prints contents of file
    print(file.read(10))  # prints first 10 characters of file
    print(file.readline())  # prints first line of file
    print(file.readlines())  # prints all lines of file as a list
    for line in file:
        print(line, end='')
    file.seek(0)  # resets the cursor to the beginning of the file
    print(file.tell())  # returns the position of the cursor (in bytes
    print(file.read())

Append to a file To append to a file, you need to open the file in append mode. The append mode is 'a'. When you append into a file, the cursor is at the end of the file. So, if you want to append to the beginning of the file, you need to reset the cursor to the beginning of the file.


with open('sample.txt', 'a') as file:

file.write('You could also append to the file. \n')

Read and Write to a file To read and write to a file, you need to open the file in read and write mode. The read and write mode is 'r+'.


with open('sample.txt', 'r+') as file:

print(file.read())

file.write('This is a new line!!')

Write to a file (Create a file)


with open('new_file.txt', 'w') as file:
    file.write('This is a new file')

Exercise:

Write a program to read a text file and print its contents line by line.

with open('test.md', 'r') as file:
    for line in file:
        print(line, end='')

Reading contents of a file in chunks

When you are reading a file (especially large files). You can read each file in chunks and process the chunks. This is more efficient than reading the whole file at once.


with open('test.md', 'r') as file:
    chunk_size = 20
    content = file.read(chunk_size)
    while len(content) > 0:
        print(content, end='')
        content = file.read(chunk_size) # reads next chunk of file and this continues until the end of the file

Copying a file

    To copy a file, you need to open the file in read mode and open the new file in write mode. Then, you can read the contents of the file and write it to the new file.

with open('test.md', 'r') as rf:
    with open('test_copy.md', 'w') as wf:
        for line in rf:
            wf.write(line)

Copying a file in chunks

with open('test.md', 'r') as rf:
    with open('test_copy.md', 'w') as wf:
        chunk_size = 20
        content = rf.read(chunk_size)
        while len(content) > 0:
            wf.write(content)
            content = rf.read(chunk_size)

File paths in different operating systems

The files for our operating systems are different or slightly different from each other.
In Windows, the file path is separated by a backslash () while in Linux and Mac OS, the file path is separated by a forward slash (/).
To make sure that your code works in different operating systems, you need to use the python os module.

File paths

A file path is a string that represents the location of a file. There are two types of file paths; absolute file path and relative file path.

Absolute file path An absolute file path is a file path that starts from the root folder. The root folder is the folder that contains all the other folders in your computer. The root folder is usually named C:\ on Windows and / on Linux and Mac.

## Absolute file path
# Linux and Mac OS

with open('C:/Users/Dummy/Documents/test.md', 'r') as file:
        print(file.read())

#  Windows OS
with open('C:\\Users\\Dummy\\Documents\\test.md', 'r') as file:
    print(file.read())

Relative file path A relative file path is a file path that is relative to the current working directory. The current working directory is the folder that contains the Python file that you are running.

  # Relative file path
with open('test.md', 'r') as file:
    print(file.read())

Conclusion

In this article, I shared what I learnt with File Objects and also how to manipulate files in Python.

I hope you found this article helpful. If you have any questions, please leave a comment below.
I'd love to hear from you, and please share this post with your friends and follow me on my journey here on Dev.to for more articles like this.
Thank you for taking the time to read this.

Day 9: Python Built In Modules

Ugbem Job — Wed, 22 Feb 2023 01:47:16 +0000

What I learnt

Built-in modules
importing builtin modules
using the datetime module

Built-in modules

The Python Built-in Modules are a set of pre-installed modules that come with Python.

Example of built-in modules

Using the random module This module implements pseudo-random number generators for various distributions. It is used to generate random numbers for various purposes like generating a random password, selecting a random item from a list, etc.

# import random
data = [1, 2, 3, 4, 5, 6, 7]
print(random.random())
# Output: 0.123456789 (randomly selected float between 0 and 1)
print(random.randint(1, 10))
# Output: 5 (randomly selected integer between 1 and 10)
print(random.choice(data))  # Output: 4 (randomly selected from the list)

Using the datetime module The datetime module provides a set of classes to work with dates and times. It is used to get the current date and time, add or subtract days, months, or years, etc.

from datetime import date, datetime
today = date.today()
tomorrow = date.today() + date.resolution
yesterday = date.today() - date.resolution
print("Today's date is:", today)  # Output: Today's date is: 2023-02-17
print("Tomorrow's date is:", tomorrow)  # Output: Tomorrow's date is: 2023-02-18
print("Yesterday's date:", yesterday)
# Output: Yesterday's date: 2023-02-16

Exercise

1. Using the datetime module, print the current time and date. Hint: Use the datetime module and the now() method.

from datetime import datetime, date
today_time = datetime.now()
current_time = today_time.strftime('%H:%M:%S')  # 24 hour format
current_date = date.today()
print(f'Today\'s is {current_date} and the time is {current_time}')
print(current_time)
print(current_date)

Using the time module

Exercise

2. Using the time module, create a clock that prints the current time every second.

import time
while True:
    localtime = time.localtime()
    result = time.strftime("%I:%M:%S %p", localtime) # the strftime() method takes two arguments, the format and the time object to format and returns a string representing the time.
    print(result)
    time.sleep(1)

Using the argv in sys module

The argv module is used to get the command line arguments passed to a script.
It is also good to note that the first argument is the name of the script.
i.e. the first argument is the name of the script and the second argument is the first command line argument.

import sys

print(sys.argv) # Output: ['built_in_modules.py']

Exercise

Using the argv module, create a script that takes two arguments and prints the sum of the two numbers.

num_1 = int(sys.argv[1])

num_2 = int(sys.argv[2])

sum = (num_1 + num_2)

print(sum)

Using the os module The os module provides a way of using operating system dependent functionality.

print(os.getcwd()) # This method returns the current working directory.

Exercise

3. Using the os module, create a script that creates a new directory inside the current directory and also rename a file in the current directory.

os.mkdir('new_dir') # This method creates a new directory.
os.rename('new_dir', 'new_dir_2') # This method renames a file or directory.

Exercise


'''
You have been tasked to create a random number guessing game.
The game should generate a random number between 1 and 20 (inclusive).

Instructions:
- Ask user to pick range of numbers (min and max)
- Generate a random number between the min and max then store it in a variable
- Ask user to guess a number
- Compare user's guess to the random number generated
- If user guesses correctly, print "You win!"
- If user guesses incorrectly, print "You lose!"
'''

import sys
import random

try:
    min_number = int(sys.argv[1])
    max_number = int(sys.argv[2])

    if max_number <= min_number:
        print('Sorry, your maximum number must be higher than your minimum number')
    if min_number < 1:
        print('The minimum number you can enter should be 1')
    if max_number >= 21:
        print('The maximum number you can enter should be 20')

    print(
        f'Hello and welcome to our game \n You numbers will be generated between {min_number} and { max_number}')

    while True:
        try:
            user_input = int(
                input(f'Pick a number between {min_number} and {max_number} \n >>>'))

            # Generate a random int
            computer_guess = random.randrange(min_number, max_number, 1)

            # Compare User input to computer guess
            if computer_guess == user_input:
                print('You are rock! 🤘🏾')
                break

            elif (user_input < min_number):
                print('Your number choice is too small!')
            elif (user_input > max_number):
                print('Your number choice is too high!')

        except ValueError:
            print('Only numbers are allowed!')

        else:
            print('Incorrect guess, please try again!🙁')
except ValueError:
    # Handle invalid input
    print('Only numbers are allowed')

Conclusion

This article is a continuation of my Day 8-Python Modules and Packages article.
In this article, we learnt about the built-in modules in Python. We also learnt how to import and use the built-in modules. This is a very important concept in Python and it is good to know how to use the built-in modules.

Resources

If you found this article helpful, please leave a comment and share with your friends.

Day 8: Python Modules and Packages

Ugbem Job — Fri, 17 Feb 2023 16:26:34 +0000

What I learnt

Modules
Built-in modules
How to import modules
Python Package

Modules

Modules are files containing Python code, for example: example.py, is called a module, and its module name would be example.
They can define functions, classes, and variables, and can also include runnable code. Modules help us break down large programs into small manageable and organized files.

Built-in modules

Python comes with a large standard library of packages that provide a wide range of functionality, such as os for working with the operating system, datetime for working with dates and times, and re for regular expressions.

Additionally, there are many third-party packages available on the Python Package Index (PyPI) that you can install and use in your Python programs.

The math module is a built-in module that contains many mathematical functions such as sqrt(), pow(), sin(), cos(), tan() etc. We can use these functions to perform calculations on numbers.

How to import modules

To use a module in your Python program, you first need to import it using the import statement. Here's an example:

import math
# or
from math import sqrt, pow

import math
x = math.sqrt(25)
print(x)  # Output: 5.0

In the above example, we are importing the math module, which provides a number of mathematical functions. We then use the sqrt() function from the math module to calculate the square root of 25.

You can also import specific functions or variables from a module using the from statement. Here's an example:

from datetime import date

today = date.today()
print("Today's date:", today) # Output: Today's date: 2023-02-17

In this example, we are importing the date class from the datetime module, which provides classes for working with dates and times. We then create an instance of the date class using the today() method and print the current date.

You can also create your own modules in Python. To do this, you simply create a new file with a .py extension and define your variables, functions, and classes. Here's an example:

my_module.py

def greet(name):
print("Hello, " + name + "!")

def square(x):
return x*x

To use this module in another Python code, you can simply import it using the import statement. Here's an example:

import my_module

my_module.greet("Jobizil") # Output: Hello, Jobizil!

print(my_module.square(5)) # Output: 25

In this example, we are importing the my_module module, which contains the greet() and square() functions.
We then use the greet() function to greet Jobizil and the square() function to calculate the square of 5.

Python Package

In Python, a package is a collection of modules that are organized into a directory hierarchy. A package can contain sub-packages as well as modules, and it is used to group related functionality together.

To create a package, you simply create a directory and include an empty __init.__py file in it. This file tells Python that the directory should be treated as a package.

Here's an example of a simple package:

my_package/
    __init__.py
    module1.py
    module2.py

In this example, the my_package directory is a package that contains two modules, module1 and module2. The __init__.py file is required to make the my_package directory a package.

To use a module from a package, you first need to import the package using the import statement, and then import the module using dot notation. Here's an example:

import my_package.module1

my_package.module1.my_function()

In this example, we are importing themy_package package, and then importing the my_function() function from the module1 module.

You can also import a module from a package using the from statement. Here's an example:

from my_package import module2

module2.my_function()

In this example, we are importing the module2 module from the my_package package, and then calling the my_function() function.

Conclusion

In this article, we learned about modules, built-in modules, how to import modules, and Python packages. We also learned how to create our own modules and packages.

Resources

Please contact me through Twitter or LinkedIn if you have any questions or recommendations.

Additionally, do leave a comment below if you have any queries or recommendations. I'd love to hear from you, and please share this post with your friends and subscribe to Dev.to for more articles like this.
Thank you for taking the time to read this.

Day 7: Generators

Ugbem Job — Thu, 16 Feb 2023 16:00:00 +0000

What I learnt

Generators
Range
Yield
Generator Expressions
Generator Functions
Generator Comprehensions

Generators

Generators in Python are functions that allow you to iterate over a sequence of values without creating a list in memory. Generators are used to create iterators, but with a different approach than the usual functions. Instead of returning all the values at once, generators return them one at a time, which makes them more memory efficient.
In simple terms; generators are a special type of function that return an iterable set of items, one at a time, in a special way.

Generator functions are functions that return a generator object some examples of generator functions are range(), enumerate() etc.

range() - This is a built-in generator function that takes in two parameters (start and stop) and returns an iterator object that can be used to iterate over the sequence of numbers from start to stop.
enumerate() - This is another built-in generator function that takes in an iterable object and returns an iterator object with index-value pairs for each element in the given iterable object.
yield - The yield keyword is used inside generator functions to return values one at a time instead of returning all the values at once.

Example

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

def square_numbers(nums):
    result = []
    for i in nums:
        result.append(i * i)
    return result

square_num = square_numbers(num_list)
print(square_num)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

The above code is returning a list and it is not memory efficient. We need to use generators to solve this problem.

def square_numbers(nums):
    for i in nums:
        yield i * i

square_num = square_numbers(num_list)
<generator object square_numbers at 0x7f9b8c0b9f50>
print(square_num)
print(next(square_num))  # This will return the next value in the generator object until there are no more values to return.

Instead of returning a list, the above code is returning a generator object. We can iterate over the generator object to get the values one at a time.

To get all the values from the generator object, we can use a for loop.

for num in square_num:
    print(num)  # 1 4 9 16 25 36 49 64 81 100

Python Generators vs List Comprehension

List Comprehension: is a concise way to create lists in Python. It is a very powerful tool that can be used to create lists in a very efficient way.

Example

squares = [i * i for i in range(1, 11)]
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Generators: are a special type of function that return an iterable set of items, one at a time, in a special way. Generators are memory efficient and are used to create iterators.

def square_numbers(nums):
    for i in nums:
        yield i * i

square_num = square_numbers(range(1, 11))
 print(square_num)  # <generator object square_numbers at 0x7f9b8c0b9f50>

for num in square_num:
    print(num)  # 1 4 9 16 25 36 49 64 81 100

Using list comprehension

squares = [i * i for i in range(1, 11)]
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Using a generator expression

squares = (i * i for i in range(1, 11))
print(squares)  # <generator object <genexpr> at 0x7f9b8c0b9f50>

Exercise:

Write a generator function that takes in two numbers (start and end) as parameters and yields all the even numbers between start and end (inclusive).

def even_numbers(start, end):
    for i in range(start, end + 1):
        if i % 2 == 0:
            yield i

my_even_numbers = even_numbers(1, 50)
for num in my_even_numbers:
    print(num)

Write a generator function that takes in two numbers (start and end) as parameters and yields all the prime numbers between start and end (inclusive).

def prime_numbers(start, end):
    for i in range(start, end + 1):
        if i > 1:
            for j in range(2, i):
                if i % j == 0:
                    break
            else:
                yield i


my_prime_numbers = prime_numbers(1, 50)
for num in my_prime_numbers:
    print(num)

Conclusion

In this article, we learnt about generators and how to use them. We also learnt about how much more efficient generators are compared to lists. So the next time you need to create a list of values, you should consider using generators instead of list comprehensions.

Resources

You can learn more on Python Generators here.
Corey Schafer has a great video on generators. I highly recommend you to watch it.

Please contact me through Twitter or LinkedIn if you have any questions or recommendations.

Day 6: Exceptions

Ugbem Job — Wed, 15 Feb 2023 16:00:00 +0000

What I learnt

Exceptions & Common Exceptions
Raising Exceptions
Handling Exceptions
Error Handling in functions

Exceptions

Exceptions in Python are errors that occur during the execution of a program. They are used to indicate that something has gone wrong and can be handled by the program to prevent it from crashing.
An exception is a description of what went wrong and a traceback to where it happened.

Common Exceptions:

Some of the most common exceptions are:

1. ZeroDivisionError
2. NameError
3. TypeError
4. IndexError
5. KeyError
6. AttributeError
7. ValueError
8. SyntaxError
9. IndentationError
10. ModuleNotFoundError

Examples of common exceptions

# 1. ZeroDivisionError
print(1/0)

# 2. NameError
print(age)

# 3. TypeError
print('1' + 1)

# 4. IndexError
fruits = ['Apple', 'Orange']
print(fruits[2])

# 5. KeyError
fruits = {'Apple': 1, 'Orange': 2}
print(fruits['Banana'])

# 6. AttributeError
fruits = ['Apple', 'Orange']
fruits.append(1)
print(fruits)

# 7. ValueError
int('a')

# 8. SyntaxError
print('Hello)

# 9. IndentationError
def greet():
print('Hello')

greet()

# 10. ModuleNotFoundError
import module

Raising Exceptions

You can raise exceptions by using the raise keyword. You can also raise exceptions with a custom error message.

raise Exception('This is an error message')

Handling Exceptions

Handling exceptions is a way to prevent your program from crashing when an exception occurs. You can handle exceptions by using the try and except keywords. The try block lets you test a block of code for errors. The except block lets you handle the error. The finally block lets you execute code, regardless of the result of the try- and except blocks.

try:
    # code that might throw an exception
except:
    # code that runs if an exception is thrown
else:
    # code that runs if no exception is thrown
finally:
    # code that runs no matter what

Examples on Handling Exceptions

while True:
    try:
        age = int(input('Input your age: '))
        print(10/age)
    except ValueError:
        print('Please enter a valid number')
    except ZeroDivisionError:
        print('Please enter an age higher than 0')
    else:
        break

Error Handling in functions

def divide(dividend, divisor):
'''Divides two numbers and returns the result.'''
    try:
        print(type(dividend), type(divisor))
    except ZeroDivisionError as error:
        return error
    except TypeError as error:
        return error
    else:
        return dividend/divisor
    finally:  return 'This is the finally block'

print(divide(101, 10))

print(divide(1, 'a'))

Exercise

# 1. Write a function that reads the content of a file and measures the time it takes to read the file.

import logging
import time


def read_file(path):
    '''Reads the content of a file and measure the time it takes to read the file.'''
    logging.basicConfig(filename='exceptions.log', level=logging.DEBUG)
    logger = logging.getLogger()
    start = time.time()
    try:
        time.sleep(2)
        file = open(path)
        data = file.read()
        return data

    except FileNotFoundError as error:
        logger.error(error)

    else:
        file.close()
    finally:
        end = time.time()
        time_difference = end - start
        logger.info((f'Time taken to read file: {time_difference}s'))

data = read_file('sample.txt')

print(data)

Conclusion

Now, we know how to handle exceptions in Python. We also learnt how to raise exceptions and handle them. We also learnt how to handle errors in functions. We also learnt how to log errors in a file. It is important to handle exceptions in your code to prevent your program from crashing.

Resources

Python Exceptions - Github Repo

Day 5: Advanced Python: Decorators

Ugbem Job — Tue, 14 Feb 2023 16:00:00 +0000

What I learnt

Decorators

Decorators are a way to modify or extend the functionality of a class,method or function without changing the source code. Some implementations where decorators are commonly used are logging, caching, authentication and authorization.
Decorators are usually written as functions that takes another function as argument and return a modified version of the original function.

Example of decorators

def decorator_func(func):
    def wrapper_func():
        print(f'This executes before {func.__name__}')
         return func()
    return wrapper_func

@decorator_func
def greeting():
    print('You\'re a great learner!')

greeting()

# Another common way decorators are being written is shown below
def greeting():
    print("You're doing well")

greet = decorator_func(greeting)
greet()

Decorating our functions allows us to easily add extra functionalities to existing function by adding that functionality inside of our wrapper.

Decorators with Arguments

def decorator_func(func):
    def wrapper_func(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper_func

@decorator_func
def user():
    print('User function called')

user()

@decorator_func
def user_profile(username, email, age):
    print('This is your profile info: \nUsername:{} \nEmail:{} \nAge:{}'.format(username, email, age))

user_profile('Jobizil', 'jobizil@email.com', '22')

Using classes as decorators

class decorator_class(object):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, \*\*kwargs):
        print(f'This executes before {self.func.__name__}')
    return self.func(*args, **kwargs)

@decorator_class
def user():
    print('User function called')
user()

@decorator_class
def user_profile(username, email, age):
    print('This is your profile info: \nUsername:{} \nEmail:{} \nAge:{}'.format(username, email, age))

user_profile('Jobizil', 'jobizil@email.com', '22')

Other Practical examples with Decorators

1. Using decorators for logging

from functools import wraps
import time

def logger(func):
    import logging
    logging.basicConfig(filename='{}.log'.format(
    func.**name**), level=logging.INFO)

    @wraps(func)
    def wrapper(*args, **kwargs):
        logging.info(f'Ran with args:{args}, and kwargs:{kwargs}')
        return func(*args, **kwargs)
    return wrapper

@logger
def user_profile(username, email, age):
    time.sleep(2)
    print('This is your profile info: \nUsername:{} \nEmail:{} \nAge:{}'.format( username, email, age))

user_profile('Jobizil', 'jobizil@email.com', '22')

2. Using decorators as timers to determine how long a function took to complete execution

def timer(func):
    from time import time

    @wraps(func)
    def wrapper(*args, **kwargs):
        t1 = time()
        result = func(*args, **kwargs)
        t2 = time() - t1
        print(f'{func.__name__} took {t2}s to complete its execution.')
        return result
    return wrapper

@timer

def user_profile(username, email, age):
    time.sleep(2)
    print('This is your profile info: \nUsername:{} \nEmail:{} \nAge:{}'.format(username, email, age))

To stack multiple decorators, we need to import the wraps decorator from the functools module as this helps preserve the original names of the functions.

@timer
@logger
def user_profile(username, email, age):
    time.sleep(2)
    print('This is your profile info: \nUsername:{} \nEmail:{} \nAge:{}'.format(username, email, age))

user_profile('Jobizil', 'jobizil@email.com', '22')

Exercises

#  Create an @authenticated decorator that only allows the function to run is user1 has 'valid' set to True:
user = {
    'name': 'Sorna',
    'valid': False
}


def authenticated(fn):
    # Your code here

@authenticated
def message_friends(user):
    print('message has been sent')


message_friends(user)

Resources

Conclusion

I learnt about decorators and how they can be used to modify the functionality of a function without changing the source code. I also learnt how to write decorators and how to use them to add extra functionalities to existing functions.

Day 4: Functional Programming

Ugbem Job — Mon, 13 Feb 2023 17:25:38 +0000

What I learnt

Reduce
Lambda Expressions
List Comprehension
Set Comprehension
Dictionary Comprehension

Reduce

The reduce() function is defined in the functools module. It takes a function and a sequence as arguments, and returns a single value. The reduce() function is useful when you need to apply a function to an iterable and reduce it to a single cumulative value. The function can be found in the functools module and it takes two parameters:

function : It is a function that is called with two arguments. function has to return a value.
sequence : It is a sequence like list, tuple, etc.
The reduce() function returns a single value.

Reduce is a method for combining an array of values into a single value. Reduce might, for example, be used to sum all the integers in an array or to concatenate all the strings in an array. To use reduce, you must first give a function that instructs reduce on how to combine the data. Two parameters will be supplied to the function: the current value and the next value. The function should return a single value that will be utilized in the reduction.

Some Examples using Reduce

- 1 - Using reduce to sum all the elements in a list

from functools import reduce
def add(x, y):
    return x + y

# print(reduce(add, [1, 2, 3, 4, 5]))


- 2 - Using reduce to concatenate all the elements in a list

def concat(x, y):
    return x + y

# print(reduce(concat, ['a', 'b', 'c', 'd', 'e']))


- 3 - Using reduce to find the maximum element in a list


def find_max(x, y):
    return x if x > y else y

# print(reduce(find_max, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))


- 4 - Using reduce to find the minimum element in a list


def find_min(x, y):
    return x if x < y else y

# print(reduce(find_min, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))

Lambda Expressions

Lambda functions are annonymous functions that are only used once within the code. They are also called as anonymous functions because they are not declared in the standard manner by using the def keyword. You can use the lambda keyword to create small anonymous functions.

Syntax: lambda arguments : expression

The expression is executed and the result is returned:
Lambda functions are annonymous functions that are only used once within the code.

Lambda can be used with built-in functions like filter(), map() and reduce().

Example


test_scores = [73, 20, 65, 19, 76, 100, 88]
exam_scores = [12, 4, 9, 14, 16, 19]


1: Use lambda on a map to multiply scores

multiply_scores = list(map(lambda score: score \* 2, test_scores))

print('Multiplied Scores', multiply_scores)

# 2: Add multiple list using

add_scores = tuple(map(lambda exam_score, test_score: exam_score +
test_score, exam_scores, test_scores))
print('Added Scores', add_scores)

# 3: Get the squared value of the list

items = [5, 4, 3, 2]
squared_list = list(map(lambda item: item\*\*2, items))
print('Squared List', squared_list)

# 4: Use lambda to filter through a list of scores

filter_scores = list(filter(lambda score: score < 50, exam_scores))
print('Filtered Scores =>', filter_scores)

# 5 Sorting list of tuple with lambda

my_list = [(0, 2), (4, 3), (10, -1), (9, 9)]

my_list.sort(key=lambda item: item[1])
print('Sorted List', my_list)

List Comprehensions

This is used to create a new list from an existing list. It is a more concise way to create a new list from an existing list. It is also more readable and faster than using a for loop to create a new list.

The format is:

[param for param in iterable]
[char for char in 'comprehension']

NOTE: I'd suggest you set your list comprehension into a discriptive function name. This will help you understand what the code is doing.

Example of List Comprehension

numb_range = [num for num in range(0, 26)]  # Prints a list of number from 0-25
num_multiple = [num**2 for num in range(0, 11)]
print(num_multiple)

# Print using Conditions
# The format is: [param for param in iterable if condition]


def is_even():
    even_num = [num**2 for num in range(0, 11) if num % 2 == 0]
    return even_num


print('Even Number', is_even())

users = [{'username': 'Jobizil', 'email': 'jobizil@email.com', 'age': 26},
         {'username': 'Lauren', 'email': 'lauren@email.com', 'age': 23},
         {'username': 'Quill', 'email': 'quill@email.com', 'age': 20},
         {'username': 'Luna', 'email': 'luna@email.com', 'age': 15},
         {'username': 'Jane', 'email': 'jane@email.com', 'age': 18}]

# Get users by email
user_email = [item['email'] for item in users]
print('User Email', user_email)

# Get users by age older than 20
user_age = [item['age'] for item in users if item['age'] >= 20]

print('User Age', user_age)

Dictionary Comprehensions

This is used to create a new dictionary from an existing dictionary. It is a more concise way to create a new dictionary from an existing dictionary. It is also more readable and faster than using a for loop to create a new dictionary.
The format is: {key:value for (key,value) in iterable}

Example

user = {'user1':
        {'username': 'Quill',
         'email': 'quill@email.com',
         'age': 25,
         'color': 'red',
         'is_active': False,
         'is_admin': False,
         'is_staff': True},
        'user2':
        {'username': 'Jobizil',
         'email': 'jobizil@email.com',
         'age': 15,
         'color': 'blue',
         'is_active': True,
         'is_admin': True,
         'is_staff': False,
         }}
user_profile = {key: value for key, value in user.items()}


def get_user_by_age():
    profile_age = {key: value
                   for key, value in user.items() if value['age'] < 20}
    return profile_age


print('User Profile', user_profile)
print('Profile Age', get_user_by_age())

Set Comprehensions

This is used to create a new set from an existing set. It is a more concise way to create a new set from an existing set. It is also more readable and faster than using a for loop to create a new set.

The format is:

{param for param in iterable}

Example

```python
num_set = {num for num in range(0, 11)}
print(num_set)
```

Conclusion

We've covered the fundamentals of Python comprehensions in this post. List comprehensions, dictionary comprehensions, and set comprehensions have all been addressed. We've also spoken about lambda expressions and reduce functions. I hope you found this information interesting. If you have any questions, please feel free to ask in the comments section below.

References

To learn more about functional programming, check out the python documentation on functional programming here.

Day 3: Functional Programming

Ugbem Job — Sat, 11 Feb 2023 09:00:00 +0000

Day 3: Functional Programming

What I learnt

Pure Functions
Immutability
Built-in Functions

Functional Programming is a programming paradigm - a style of building the structure and elements of computer programs - that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.

Pure Functions

Pure functions are functions that return the same result if given the same arguments, and do not cause any observable side effects.

Example

def multiply_by2(items):
    new_list = []
    for item in items:
        new_list.append(item\*2)
    return new_list

print(multiply_by2([1, 2, 3]))

Benefits of Pure Functions

1. They are easier to test.
2. They are easier to reason about.
3. They are easier to compose.
4. They are easier to parallelize.

Immutability

In functional programming, immutability is the absence of state change over time. If a program is stateless, then it's output is only determined by its input.

Example

a = 2
b = a
print(a)
print(b)
a = 3
print(a)
print(b)

Example 2

my_list = [1, 2, 3]
my_list_copy = my_list
print(my_list)
print(my_list_copy)
my_list.append(4)
print(my_list)
print(my_list_copy)

The first example shows that the variable b is a copy of a. The second example shows that the variable my_list_copy is a reference to my_list. This is because lists are mutable. If we want to make a copy of a list, we can use the list() function.

Built-in Functions

Some built-in functions that return new lists are: map(), filter(), and zip(). These functions do not change the original list.

map(): The map() function applies a function to every item in an iterable and returns a new iterable with the results. The map() function takes two parameters:
- fun : It is a function to which map passes each element of given iterable.
- iter : It is a iterable which is to be mapped.

It is good to know that the map function separates the function from the data(iterable) which is a very important concept in functional programming.

Examples

1. Using map on a list to get the double of each element

my_list = [1, 2, 3, 4, 5, 6, 7, 8]
def myltiplyElement(li):
  return li * 2
mapped_list = map(myltiplyElement, [1, 2, 3, 4, 5])

#print(list(mapped_list))
#print(tuple(mapped_list))
#print(set(mapped_list))

2. Using map on a set to get the length of each element

def get_length(item):
return len(item)

length_of_element = map(
get_length, {'apple', 'banana', 'orange', 'apple', 'mango'})
print(list(length_of_element))

3. Using map on a dictionary to get the length of each key

def item_length(item):
  return len(item)

length_of_key = map(item_length, {'apple': 1, 'banana': 2, 'orange': 3})
print(list(length_of_key))

filter(): The filter() function creates a new list with only the items that return true when passed into a function. Just like the map function, the filter() function takes two parameters: fun: It is a function to which filter passes each element of given iterable. iter: It is a iterable which is to be filtered.

Example

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

def is_even(item):
  return item % 2 == 0

even_list = filter(is_even, my_list)
print(list(even_list))

zip(): The zip() function ta kes iterables (can be zero or more), aggregates them in a tuple, and return it. The syntax of zip() is: zip(*iterables). This function takes iterables as arguments and returns an iterator. The returned iterator generates a series of tuples containing elements from each iterable. The iterator stops when the shortest input iterable is exhausted.

Example

username = ['john', 'jane', 'joe', 'josh']
email = ['john@email.com', 'jane@email.com', 'joe@email.com']

print(set(zip(username, email)))

# Example 2

names = ['john', 'jane', 'joe', 'josh']
ages = [23, 24, 25, 26]
heights = [180, 175, 178, 182]

print(list(zip(names, ages, heights)))

Exercise

1 Capitalize all of the pet names and print the list

my_pets = ['sisi', 'bibi', 'titi', 'carla']

2 Zip the 2 lists into a list of tuples, but sort the numbers from lowest to highest.

my_strings = ['a', 'b', 'c', 'd', 'e']
my_numbers = [5, 4, 3, 2, 1]

3 Filter the scores that pass over 50%

scores = [73, 20, 65, 19, 76, 100, 88]

This exercise is from the Complete Python Developer course.
You can find the solution here.

Conclusion

In this article, we learnt about pure functions, immutability, and built-in functions. We also learnt how to use the map(), filter(), and zip() functions.

References

To learn more about functional programming, check out the python documentation on functional programming here.

Day 2: Object Oriented Programming (OOP)

Ugbem Job — Fri, 10 Feb 2023 09:00:00 +0000

What I learnt

Classes
Objects
Inheritance
Encapsulation
Abstraction

Classes

A class is a blueprint for creating objects. A class defines the properties and behaviours that all objects of that class share.

Example of a class with attributes

    class User:
        def __init__(self, name, email, age):
            self.name = name
            self.email = email
            self.age = age

        def greeting(self):
            return f'My name is {self.name} and I am {self.age}'

Example of an object with attributes

    user_1 = User('Jobizil','jobizil@email.com', 25)

    print(user_1.name)
    print(user_1.email)
    print(user_1.greeting())

Class Methods

init() => This method is used to initialize the attributes of an object
self => This is a reference to the current instance of the class and is used to access variables that belong to the class
__init__ () => This method is called automatically every time the class is being used to create a new object
super() => This is used to access methods and properties of the parent class

Common Class Patterns

Creating multiple objects && Creating a class method

    class User:
        def __init__(self, name, email, age):
            self.name = name
            self.email = email
            self.age = age

        def greeting(self):
            return f'My name is {self.name} and I am {self.age}'

        def has_birthday(self):
            self.age += 1
            return f'Happy {self.age}th, {self.name}'


    # Init user object

    user_1 = User('Jobizil', 'jobizil@email.com', 25)

    print(user_1.age)
    print(user_1.greeting())
    print(user_1.has_birthday())

Inheritance

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

    class User:
        def __init__(self, name, email, age):
            self.name = name
            self.email = email
            self.age = age

        def greeting(self):
            return f'My name is {self.name} and I am {self.age}'

        def has_birthday(self):
            self.age += 1
            return f'Happy {self.age}th, {self.name}'


    class Customer(User):
        def __init__(self, name, email, age):
            super().__init__(name, email, age)
            self.balance = 0

        def set_balance(self, balance):
            self.balance = balance
            return self.balance

        def greeting(self):
            return f'My name is {self.name} and I am {self.age} and my balance is {self.balance}'


    # Init customer object
    customer_1 = Customer('Quill', 'quilltech57@gmail.com', 22)
    customer_1.set_balance(500)
    print(customer_1.greeting())

Encapsulation

Encapsulation is the process of wrapping up data and methods into a single unit. This is done to prevent accidental modification of data. In Python, we denote private attributes using an underscore as the prefix i.e single _ or double __.

    class User:
        def __init__(self, name, email, age):
            self.name = name
            self.email = email
            self.age = age

        def greeting(self):
            return f'My name is {self.name} and I am {self.age}'

        def has_birthday(self):
            self.age += 1
            return f'Happy {self.age}th, {self.name}'

Abstraction

Abstraction is the process of hiding the implementation details from the user, only the functionality will be provided to the user. In Python, we use abstract classes and interfaces.

    from abc import ABC, abstractmethod

    class User(ABC):
        def __init__(self, name, email, age):
            self.name = name
            self.email = email
            self.age = age

        def greeting(self):
            return f'My name is {self.name} and I am {self.age}'

        def has_birthday(self):
            self.age += 1
            return f'Happy {self.age}th, {self.name}'

        @abstractmethod
        def has_birthday(self):
            pass

Simple exercise


# Use the Cat class to create 3 cat objects
# Assign the objects to 3 variables of your choice
# Create a method that finds the oldest cat
# Print out: "The oldest cat is x years old.". x will be the oldest cat age by using the function in #4

class Cat:
    species = 'mammal'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def oldest_cat(*args):
        return max(args)

    def best_name(self):
        return f'{self.name} is the best name'


cat_1 = Cat('Tom', 5)
cat_2 = Cat('Jerry', 3)
cat_3 = Cat('Mickey', 7)

oldest_cat = Cat.oldest_cat(cat_1.age, cat_2.age, cat_3.age)

print(f'The oldest cat is {oldest_cat} years old.')

Resources

You can learn more about OOP using the python official documentation here.

60 Days of Learning Python

Ugbem Job — Thu, 09 Feb 2023 10:10:08 +0000

Day 1: Data Types

What I learnt

Numbers
Strings
Booleans
Lists
Tuples
Sets
Dictionaries

Numbers

Numbers are used to represent integers, floating point numbers, and complex numbers.

Integers

>>> 1
1
>>> 2
2

Floats: Floating point numbers are represented in Python using decimal points. Also known as real numbers.

  >>> 1.1
  1.1

Complex Numbers: Complex numbers are written in the form, x + yj, where x is the real part and y is the imaginary part.

  >>> 1 + 2j
  (1+2j)

Strings

Strings are used to represent text data, the text is given under quote marks. Python treats single quotes the same as double quotes.

Single Quotes
Double Quotes
Triple Quotes: Triple quotes are used to span the string across multiple lines.

>>> 'Hello World'
'Hello World'
>>> "Hello World"
'Hello World'
>>> """Hello World"""
'Hello World'

String Concatenation: Strings can be concatenated (glued together) with the + operator, and repeated with *:

>>> 'Hello' + 'World'
'HelloWorld'
>>> 'Hello' * 3
'HelloHelloHello'

String Slicing: Strings can be sliced (subscripted), with the syntax [start:stop:step]. If start is omitted, it is default to 0. If stop is omitted, it is default to the end of the string. If step is omitted, it is default to 1.

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'
>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'
>>> word[:2] + word[2:]
'Python'

String Methods: Strings have a bunch of useful methods. Some of them are listed below.

>>> word = 'Python'
>>> word.upper()
'PYTHON'
>>> word.lower()
'python'
>>> word.startswith('P')
True
>>> word.endswith('n')
True

You can find more string methods here.

Booleans

Booleans represent one of two values: True or False.

>>> True
True
>>> False
False

Lists

A list is a collection of items in a particular order.
You can make a list that includes the letters of the alphabet, the digits from 0-9.
You can put anything you want into a list, and the items in your list don't have to be related in any particular way.
The syntax for defining a list is to enclose the items in square brackets, with commas between them.

>>> [1, 2, 3]
[1, 2, 3]
>>> ['Hello', 'World']
['Hello', 'World']
>>> [1, 'Hello', 2.5]
[1, 'Hello', 2.5]

Characteristics of Lists:

Ordered
Mutable
Allows Duplicate Elements

Example of List and Manipulating it

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
 print(bicycles)
 print(bicycles[0])

Slicing a list => When slicing a list, just as strings, it has 3 parts i.e [start:stop:stepover]

    print(bicycles[1:3])

Duplicating a list - [:] is used to create an entirely new copy of the existing list

    new_bicycles = bicycles[1::2]
    new_bicycles[0] = 'seat'
    print(new_bicycles)
    print(bicycles)

    ```
{% endraw %}


- Matrix: A matrix is a two-dimensional data structure that can store numbers or other types of data ie it's a liat that stores another list inside of them.

### Example of Matrix
{% raw %}


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

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



### List Methods

- append() => This method adds an item to the end of the list



```python
 bicycles.append('word')

insert() => This method adds an item at a specific index

bicycles.insert(0, 'shoo')

extend() => This method adds multiple items to the end of the list

bicycles.extend(['word2', 'word3'])

remove() => This method removes an item from the list by its value and not by its index

bicycles.remove('word2')

pop() => This method removes the last item from the list and returns the popped item

new_bask = bicycles.pop(0)

clear() => This method removes all the items from the list and returns an empty list

bicycles.clear()

index() => This method returns the index of the first item with the specified value and returns an error if the value is not found
You can learn more about the index method here

print(bicycles.index('word3'))

count() => This method returns the number of times the specified value appears in the list

print(bicycles.count('word3'))

Common List Patterns

bicycles.sort()
bicycles.reverse()

print(bicycles[::-1]) # This is used to reverse a list and it creates a new copy of the list
print(bicycles)

List Unpacking: This is used to assign multiple variables at once

a, b, c, *rest, d = bicycles

print(rest)

print(d)

Looping through a list

For Loop

for bicycle in bicycles:
    print(bicycle)

Remove duplicates from a list

names = ['John', 'Bob', 'Mosh', 'Sarah', 'Mosh', 'John', 'Anne', 'Jane', 'Bob', 'Anne']

duplicate_names = []
unique_names = []

for name in names:
    if name not in unique_names:
        unique_names.append(name)
    else:
        duplicate_names.append(name)
print(unique_names)
print(duplicate_names)


pictures = [
[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]
]

for row in pictures:
    for pixels in row:
        if pixels == 1:
            print('\*', end='')
        else:
            print(' ', end='')
    print('') # This is used to print a new line after each row

While Loop

 i = 0
 while i < len(bicycles):
    print(bicycles[i])
    i += 1

Looping through a list of dictionaries

users = [{'username': 'Jobizil', 'email': 'jobizil@email.com','age': 26},
{'username': 'Quill', 'email': 'quill@email.com', 'age': 22}]

for user in users:
    print(user['username'])

List Comprehension: This is used to create a new list from an existing list

new_list = [expression for item in list if conditional]
new_list = [item['email'] for item in users]
 print(new_list)

List Comprehension with if statement

new_list = [item['email'] for item in users if item['age'] > 25]
print(new_list)

Tuples: Just like Lists, Tuples are used to store multiple items in a single variable but they are stored within brackets (elements).

    >>> (1, 2, 3)
    (1, 2, 3)
    >>> ('Hello', 'World')
    ('Hello', 'World')
    >>> (1, 'Hello', 2.5)
    (1, 'Hello', 2.5)

Characteristics of Tuple:

Ordered
Immutable
Allows Duplicate Elements

Tuple Methods: You can learn more about the tuple methods here

Sets

A set is a collection which is unordered and unindexed. In Python, sets are written with curly brackets.

>>> {1, 2, 3}
{1, 2, 3}
>>> {'Hello', 'World'}
{'Hello', 'World'}
>>> {1, 'Hello', 2.5}
{1, 'Hello', 2.5}

Characteristics of Sets:

Unordered
Mutable
Does Not Allow Duplicate Elements

Example of a set

fruits = {'apple', 'orange', 'apple', 'grape', 'pear', 'banana'}
fruits_2 = {'babana', 'pawpaw', 'apple', 'orange', 'pear', 'banana', 'mango'}
print(fruits)

Common Set Patterns

Convert a list to a set

 fruits_list = ['apple', 'orange', 'apple', 'grape', 'pear', 'banana']
 fruits_set = set(fruits_list)
 print(list(fruits_set))

Remove duplicates from a list

 fruits_list = ['apple', 'orange', 'apple', 'grape', 'pear', 'banana']
fruits_set = set(fruits_list)
print(list(fruits_set))

Find the intersection of two lists

fruits_list = ['apple', 'orange', 'apple', 'grape', 'pear', 'banana']

fruits_list_2 = ['apple', 'orange', 'apple', 'grape', 'pear', 'banana', 'mango']

 fruits_set = set(fruits_list)
 fruits_set_2 = set(fruits_list_2)

 print(fruits_set.intersection(fruits_set_2))

Find the difference between two lists

print(fruits_set.difference(fruits_set_2))
print(fruits_set_2.difference(fruits_set))

Find the union of two lists

print(fruits_set.union(fruits_set_2))

Set Methods

add() => This method adds an element to the set

fruits.add('mango')
 print(fruits)

clear() => This method removes all the elements from the set

fruits.clear()
 print(fruits)

copy() => This method returns a copy of the set

fruits_copy = fruits.copy()
 print(fruits_copy)

difference() => This method returns a set containing the difference between two or more sets

print(fruits.difference(fruits_2))
print(fruits_2.difference(fruits))

difference_update() => This method removes the items in this set that are also included in another, specified set and returns a set

print(fruits.difference_update(fruits_2))
print(fruits)

discard() => This method removes the specified element from the set

fruits.discard('apple')
print(fruits)

intersection() => This method returns a set that contains the similarity between two or more sets

print(fruits.intersection(fruits_2))

intersection_update() => This method removes the items in this set that are not present in other, specified set(s) and returns a set

print(fruits.intersection_update(fruits_2))

isdisjoint() => This method returns True if two sets have a null intersection

print(fruits.isdisjoint(fruits_2))

issubset() => This method returns True if another set contains this set

print(fruits.issubset(fruits_2))
print(fruits_2.issubset(fruits))

issuperset() => This method returns True if this set contains another set

print(fruits.issuperset(fruits_2))
print(fruits_2.issuperset(fruits))

union() => This method returns a set that contains all items from the original set, and all items from the specified sets

print(fruits.union(fruits_2))

You can learn more about the set methods here

Dictionaries

A dictionary in Python is a collection of key-value pairs usually unordered. Each key is connected to a value, and you can use a key to access the value associated with that key. A key's value can be a number, a string, a list, or even another dictionary. In fact, you can use any object that you can create in Python as a value in a dictionary.
They store data values in key:value pairs within curly braces {elements}.

>>> {'name': 'John', 'age': 30}
{'name': 'John', 'age': 30}
>>> {'name': 'John', 'age': 30, 'name': 'Jane'}
{'name': 'Jane', 'age': 30}

Characteristics of Dictionaries:

Unordered
Mutable
Does Not Allow Duplicate Keys

Example of a dictionary

user = {'username': 'Jobizil',
        'email': 'jobizil@email.com',
        'age': 25,
        'color': 'blue',
        'is_active': True,
        'is_admin': True,
        'is_staff': False,
        }
 print(user['username'])

Dictionary Methods

get() => This method returns the value of the specified key

  print(user.get('username'))

keys() => This method returns a list of all the keys in the dictionary

  print(user.keys())
  print(user.values())

items() => This method returns a list of tuples containing the key-value pairs

  print(user.items())

clear() => This method removes all the items from the dictionary and returns an empty dictionary

  print(user.clear())

pop() => This method removes the item with the specified key name and returns the value of the removed item

  print(user.pop('username'))

popitem() => This method removes the last inserted item and returns a tuple containing the key-value pair of the removed item

  print(user.popitem())

copy() => This method returns a copy of the dictionary

  user_2 = user.copy()
  print(user_2)

update() => This method updates the dictionary with the specified key-value pairs

  user.update({'username': 'Quill', 'email': 'quill@email.com'})
  user_3 = user.copy()
  print(user_3)

Common Dictionary Patterns

Looping through a dictionary
```
```python
```
for key, value in user.items():
print(f'Key: {key}')
print(f'Value: {value}')

Looping through a dictionary keys

for key in user.keys():
    print(key)
    ```
{% endraw %}

Looping through a dictionary values
{% raw %}

for value in user.values():
print(value)

Dictionary Comprehension:

Dictionary comprehension is a way to create a dictionary in a single line of code. It is a combination of a for loop and a dictionary.

Example of Dictionary Comprehension

```python
squared = {num: num**2 for num in [1, 2, 3, 4, 5]}
 print(squared)
```

Dictionary Comprehension with conditional logic

Dictionary comprehension with conditional logic is a way to create a dictionary in a single line of code. It is a combination of a for loop, a conditional statement and a dictionary.

Example of Dictionary Comprehension with conditional logic

```python
squared = {num: num**2 for num in [1, 2, 3, 4, 5] if num % 2 == 0}
print(squared)
```

Conclusion

I might not have covered everything in this article but I hope it helps you understand the basics of Python data structures. You can learn more about Python data structures here.

Also, I might not be able to update this article series as soon as I learn new things within my learning journey. But I will ensure I update it on my GitHub repo. You can check it out here.

Compare Hash Passwords Using Crypto Module using the Node.js [part 2]

Ugbem Job — Fri, 03 Feb 2023 01:48:30 +0000

This article is a continuation of my previous article on Hash Passwords Using Crypto Module using Node.js. This aims at teaching you how to convert crypto hash passwords into their original form using the Crypto Module.

In the previous article, we discussed how to hash passwords using the Crypto module in Node.js. In this article, we'll be discussing how to compare the hashed password with the original password.

From the previous article, we created a simple function that takes a password as input and returns its hashed version. Let's use this function to hash a password and store it in a variable.

const crypto = require('crypto')
const hashPassword = password => {
    return crypto.createHash('sha256').update(password).digest('hex')
}
const password = hashPassword('secret')
console.log(password)

Compare Hash Passwords Using Crypto Module using the Node.js

const hashedPassword = '2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b'

// Compare the hashed password with the original password


const compareHashPassword = (password, hashedPassword) => {
    if (hashPassword(password) === hashedPassword) {
        return { success: true, message: 'Password matched' }
    }
    return { success: false, message: 'Password not matched' }
}

const result = compareHashPassword('secret', hashedPassword)
console.log(result)

// Output
// { success: true, message: 'Password matched' }

In this article, we discussed how to compare the hashed password with the original password using the Crypto module in Node.js.

Note: This article is a continuation of my previous article on Hash Passwords Using Crypto Module using Node.js. This aims at teaching you how to convert crypto hash passwords into their original form using the Crypto Module and it is important to note that this is just a basic example of how to compare hashed passwords in a Node.js application using the crypto module.

You can find the previous article on Hash Passwords Using Crypto Module using the Node.js here.

If you enjoyed this article, you might also like:

Encrypting and decrypting data in nodejs using aes-256 algorithm