feat: Exercise #4. Functions and Strings

BREAKING CHANGE: Exercise complete

Author: NicolasOmar

1-basics/basics.py 1-basics/theory.py1-basics/basics.py renamed to 1-basics/theory.py

@@ -11,8 +11,8 @@ def print_names_length(names):
     add__line()
 
 print_names_length(names_list)
-# 2) Add an if check inside the loop to only output names longer than 5 characters.
 
+# 2) Add an if check inside the loop to only output names longer than 5 characters.
 def print_long_names_length(names):
     add__line()
     for name in names:
@@ -21,8 +21,8 @@ def print_long_names_length(names):
     add__line()
 
 print_long_names_length(names_list)
-# 3) Add another if check to see whether a name includes a “n” or “N” character.
 
+# 3) Add another if check to see whether a name includes a “n” or “N” character.
 def print_names_with_n(names):
     add__line()
     for name in names:
@@ -31,8 +31,8 @@ def print_names_with_n(names):
     add__line()
 
 print_names_with_n(names_list)
-# 4) Use a while loop to empty the list of names (via pop() )
 
+# 4) Use a while loop to empty the list of names (via pop() )
 def empty_names_list(names):
   add__line()
   while len(names) > 0:

2-loops/exercise.py

@@ -1,21 +1,45 @@
+def add__line():
+    print('--------------------')
+    
 # 1) Create a list of “person” dictionaries with a name, age and list of hobbies for each person. Fill in any data you want.
 persons_list = [
   { 'name': 'Nicolas', 'age': 22, 'hobbies': ['reading', 'gaming'] },
   { 'name': 'Florencia', 'age': 19, 'hobbies': ['painting', 'cycling'] },
   { 'name': 'Martin', 'age': 25, 'hobbies': ['hiking', 'swimming'] }
 ]
-print(persons_list)
+
+def print_persons_list():
+  add__line()
+  print(persons_list)
+  add__line()
+
+print_persons_list()
 
 # 2) Use a list comprehension to convert this list of persons into a list of names (of the persons).
-person_comprehension = ', '.join([person['name'] for person in persons_list])
-print('The persons names are:', person_comprehension)
+def print_person_names():
+  add__line()
+  person_comprehension = ', '.join([person['name'] for person in persons_list])
+  print('The persons names are:', person_comprehension)
+  add__line()
+
+print_person_names()
 
 # 3) Use a list comprehension to check whether all persons are older than 20.
-all_older_than_20 = all([person['age'] > 20 for person in persons_list])
-print('All persons older than 20:', all_older_than_20)
+def list_all_older_than_20():
+  add__line()
+  all_older_than_20 = ', '.join([person['name'] for person in persons_list if person['age'] > 20])
+  print('All persons older than 20:', all_older_than_20)
+  add__line()
+
+list_all_older_than_20()
 
 # 4) Copy the person list such that you can safely edit the name of the first person (without changing the original list).
-persons_copy = [person.copy() for person in persons_list]
-persons_copy[0]['name'] = 'Matias'
-print('Original list:', persons_list)
-print('Modified copy:', persons_copy)
+def copy_and_edit_persons_list():
+  add__line()
+  persons_copy = [person.copy() for person in persons_list]
+  persons_copy[0]['name'] = 'Matias'
+  print('Original list:', persons_list)
+  print('Modified copy:', persons_copy)
+  add__line()
+
+copy_and_edit_persons_list()

3-data-structures/exercise.py

@@ -0,0 +1,178 @@
+# A built in module that provides functions from python standard library
+import functools
+
+MINING_REWARD = 10
+genesis_block = {
+    'previous_hash': '',
+    'index': 0,
+    'transactions': []
+}
+my_blockchain = [genesis_block]
+open_transactions = []
+waiting_for_input = True
+owner = 'Nicolas'
+participants = set([owner])
+
+def add__line():
+    print('------------------------------')
+
+def generate_options_menu():
+    add__line()
+    print('Please choose an option:')
+    print('1: Add a new transaction')
+    print('2: Mine a new block')
+    print('3: Output all blockchain blocks')
+    print('4: Output all participants')
+    print('h: Manipulate blockchain')
+    print('q: Quit')
+    add__line()
+
+def get_user_input():
+    user_input = input('Please enter your selection: ')
+    add__line()
+    return user_input
+
+def hash_block(block):
+    """ Hash a block using its strucutre as base """
+    return str(block[key] for key in block)
+
+def mine_block():
+    last_block = my_blockchain[-1]
+    hashed_block = hash_block(last_block)
+
+    reward_transaction = {
+        'sender': 'MINING',
+        'recipient': owner,
+        'amount': MINING_REWARD
+    }
+
+    block = {
+        'previous_hash': hashed_block,
+        'index': len(my_blockchain),
+        'transactions': [open_transactions, reward_transaction]
+    }
+    
+    my_blockchain.append(block)
+    print('Block added!')
+    add__line()
+    return True
+
+def get_transaction_value():
+    """ Returns the input of the user (a new transaction amount and its recipient) as a tuple """
+    tx_recipient_input = input('Please enter the recipient of the transaction: ')
+    tx_amount_input = float(input('Please enter your transaction input: '))
+    add__line()
+
+    # When you return a tuple, it does not need to be enclosed in parentheses (is optional i guess)
+    return tx_recipient_input, tx_amount_input
+
+def take_last_blockchain_value():
+    if len(my_blockchain) < 1:
+        return None
+    
+    return my_blockchain[-1]
+
+def verify_transaction(transaction):
+    sender_balance = get_balance(transaction['sender'])
+    
+    if sender_balance >= transaction['amount']:
+        return True
+    return False
+
+def add_transaction(sender, recipient, amount=1):
+    """
+        Add a new transaction to the list of open transactions (which will be added to the next mined block)
+
+        Arguments:
+            :sender: The sender of the coins.
+            :recipient: The recipient of the coins.
+            :amount: The amount of the transaction.
+    """
+
+    new_transaction = {
+        'sender': sender,
+        'recipient': recipient,
+        'amount': amount
+    }
+
+    if verify_transaction(new_transaction):
+        open_transactions.append(new_transaction)
+        participants.add(sender)
+        participants.add(recipient)
+    else:
+        print('Transaction failed! Not enough balance!')
+    add__line()
+
+def return_all_blocks():
+    print('---Outputting all blocks---')
+    
+    for block in my_blockchain:
+        print(f'Outputting block: {block}')
+    add__line()
+    
+def get_balance(participant):
+    # final_balance = 0
+    sent_transactions = [[tx['amount'] for tx in block['transactions'] if tx['sender'] == participant] for block in my_blockchain]
+    recieved_transactions = [[tx['amount'] for tx in block['transactions'] if tx['recipient'] == participant] for block in my_blockchain]
+    open_sent_transactions = [tx['amount'] for tx in open_transactions if tx['sender'] == participant]
+
+    sent_transactions.append(open_sent_transactions)
+    # This function is a reducer that will sum up all the values in a list of lists
+    # The lambda function is an anonymous function that takes two arguments, the first one is the accumulator (the sum of the previous values) and the second one is the current value
+    sent_amounts = functools.reduce(lambda tx_sum, tx_amt: tx_sum + sum(tx_amt) if len(tx_amt) > 0 else tx_amt + 0, sent_transactions, 0)
+    # for sent_amount in sent_transactions:
+    #     if len(sent_amount) > 0:
+    #         final_balance -= sent_amount
+
+    recieved_amounts = functools.reduce(lambda tx_sum, tx_amt: tx_sum + sum(tx_amt) if len(tx_amt) > 0 else tx_amt + 0, recieved_transactions, 0)
+    # for recieved_amount in recieved_transactions:
+    #     if len(recieved_amount) > 0:
+    #         final_balance += recieved_amount
+
+    return recieved_amounts - sent_amounts
+
+def verify_chain():
+    """ The function helps to verify the integrity of the blockchain by checking if each block's previous hash matches the hash of the previous block. """
+    for (index, block) in enumerate(my_blockchain):
+        if index == 0:
+            continue
+        if block['previous_hash'] != hash_block(my_blockchain[index - 1]):
+            return False
+    return True
+
+def verify_transactions():
+    """ The function verifies all open transactions to ensure they are valid. """
+    return all([tx for tx in open_transactions if not verify_transaction(tx)])
+
+while waiting_for_input:
+    generate_options_menu()
+    
+    user_choice = get_user_input()
+    
+    if user_choice == '1':
+        tx_input_data = get_transaction_value()
+        recipient, amount = tx_input_data
+        add_transaction(owner, recipient, amount)
+    elif user_choice == '2':
+        if mine_block():
+            open_transactions = []
+    elif user_choice == '3':
+        return_all_blocks()
+    elif user_choice == '4':
+        print(participants)
+    elif user_choice == 'q':
+        waiting_for_input = False
+    elif user_choice == 'h':
+        if len(my_blockchain) >= 1:
+            my_blockchain[0] = [2.0]
+    else:
+        print('Invalid input, please choose a valid option')
+    if not verify_chain():
+        print('Invalid blockchain!')
+        waiting_for_input = False
+    print(f"Balance of {owner}: {get_balance(owner)}")
+else:
+    print('User left!')
+
+add__line()
+print('Done!')

4-functions-and-strings/blockchain.py

@@ -0,0 +1,42 @@
+def add__line():
+    print('--------------------')
+    
+# 1) Write a normal function that accepts another function as an argument. Output the result of that other function in your “normal” function.
+def normal_function(callback):
+  return callback()
+
+def callback_function():
+  return "Hello from callback function!"
+
+print(normal_function(callback_function))
+add__line()
+
+# 2) Call your “normal” function by passing a lambda function – which performs any operation of your choice – as an argument.
+print(normal_function(lambda: "Hello from lambda function!"))
+add__line()
+
+# 3) Tweak your normal function by allowing an infinite amount of arguments on which your lambda function will be executed.
+number_list = [1, 2, 3, 4, 5]
+def normal_function_with_infinite_args(callback, *args):
+  return callback(*args)
+
+def callback_infinite_args(*args):
+  return args
+
+print(normal_function_with_infinite_args(callback_infinite_args, *number_list))
+add__line()
+
+# 4) Format the output of your “normal” function such that numbers look nice and are centered in a 20 character column.
+def normal_function_centered(callback, number):
+  return callback(number)
+
+def callback_function_centered(number):
+  return f"{number:^20}"
+
+print(normal_function_centered(callback_function_centered, 5))
+print(normal_function_centered(callback_function_centered, 6))
+print(normal_function_centered(callback_function_centered, 7))
+print(normal_function_centered(callback_function_centered, 8))
+print(normal_function_centered(callback_function_centered, 9))
+print(normal_function_centered(callback_function_centered, 10))
+add__line()

4-functions-and-strings/exercise.py

@@ -0,0 +1,65 @@
+# ---STRING FORMATTING (BEFORE PYTHON 3.6)---
+name = "Nicolas"
+age = 33
+
+# This version of a concatenated string is the base idea to start working, but it becoames hard to read
+string_name="My name is " + name + " and I am " + str(age) + " years old."
+print(string_name) # Returns My name is Nicolas and I am 33 years old.
+
+# A better way to format strings is using the format method, which inserts the variables in the string and has no arguments limit
+string_name = "My name is {} and I am {} years old.".format(name, age)
+print(string_name) # Returns My name is Nicolas and I am 33 years old.
+
+# An alternative way to inject the variables is by using positional arguments
+# On this case, it will put first the age and then the name (because arguments are 0 indexed)
+string_name = "My name is {1} and I am {0} years old.".format(name, age)
+print(string_name) # Returns My name is 33 and I am Nicolas years old.
+
+# Another alternative way to inject the variables is by using named arguments
+# By assigning a name to each argument, we can use them in any order
+string_name = "My name is {name} and I am {years} years old.".format(name=name, years=age)
+print(string_name) # Returns My name is Nicolas and I am 33 years old.
+
+founds = 150.978
+
+founds_statement = "Founds: {}.".format(founds)
+print(founds_statement) # Returns Founds: 150.97.
+
+# We can also format numbers, in this case, we can ask to show a float number. By default, it shows 6 decimals
+founds_statement = "Founds: {:f}.".format(founds)
+print(founds_statement) # Returns Founds: 150.978000.
+
+# If you want to reduce the number of decimals, you can specify it after the point
+founds_statement = "Founds: {:.2f}.".format(founds)
+print(founds_statement) # Returns Founds: 150.98.
+
+# ---STRING INTERPOLATION (AFTER PYTHON 3.6)---
+
+# After Python 3.6, we can use f-strings, which are more readable and easier to use
+# In this case, you can directly inject the variables in the string using {}
+string_name = f"My name is {name} and I am {age} years old."
+print(string_name) # Returns My name is Nicolas and I am 33 years old.
+
+# And can be extended to formatting numbers as well
+string_name = f"My name is {name} and I am {age:.1f} years old."
+print(string_name) # Returns My name is Nicolas and I am 33.0 years old.
+
+# ---LIST MAPPING AND LAMBDA FUNCTIONS---
+simple_list = [1, 2, 3, 4, 5]
+
+# The map function applies a function to all items in an iterable (like a list) and returns a map object (which is an iterator)
+# First arguments is the same as an callback function in javascript, the second argument is the iterable to apply the function to
+def multiply_by_two(item):
+    return item * 2
+
+mapped_list = map(multiply_by_two, simple_list)
+print(mapped_list) # Returns <map object at 0x...>
+
+# You can convert the map object to a list or a tuple using the list() or tuple
+print(list(mapped_list)) # Returns [2, 4, 6, 8, 10]
+# TO HAVE IN MIND: It is recommended to use list comprehensions instead of map function for better readability and performance
+
+# An alternative way to use the map function is by using a lambda function as the first argument
+# A lambda function is an anonymous function that can take any number of arguments, but can only have one expression
+mapped_list = map(lambda item: item * 2, simple_list)
+print(list(mapped_list)) # Returns [2, 4, 6, 8, 10]

4-functions-and-strings/theory.py

@@ -60,6 +60,11 @@ python3 exercise.py # Or any .py file
     - How to check value validity (if is true) with methods such as `all` or `any`.
   - How to use `set`.
   - Use built-in converter methods like `enumerate`.
+- Functions and Strings (`4-functions-and-strings` folder)
+  - How to use `format` method for strings.
+  - How to use string interpolation with the `f` method.
+  - How to map lists with map method and `lambda functions`.
+  - How to summarize data with `reduce` method.
 
 ## Other practice repos
 | Node | React | Angular | GraphQL | HTML & CSS | Styling | Typescript | NextJs | Docker |