From b4fa51980aa657892f06f62e4a0fd81c24ca76c8 Mon Sep 17 00:00:00 2001 From: Kilokem Date: Fri, 13 Sep 2024 15:12:25 +0200 Subject: [PATCH] FinishedTheBasics --- LearnTheBasics/10_ClassesAndObjects.py | 65 ++++++++++++++++ LearnTheBasics/11_Dictionaries.py | 49 ++++++++++++ LearnTheBasics/12_ModulesAndPackages.py | 48 ++++++++++++ .../{HelloWorld.py => 1_HelloWorld.py} | 0 ...blesAndTypes.py => 2_VariablesAndTypes.py} | 0 LearnTheBasics/{Lists.py => 3_Lists.py} | 0 LearnTheBasics/4_BasicOperators.py | 47 +++++++++++ LearnTheBasics/5_StringFormatting.py | 29 +++++++ LearnTheBasics/6_BasicStringOperations.py | 70 +++++++++++++++++ LearnTheBasics/7_Conditions.py | 78 +++++++++++++++++++ LearnTheBasics/8_Loops.py | 78 +++++++++++++++++++ LearnTheBasics/9_Functions.py | 46 +++++++++++ 12 files changed, 510 insertions(+) create mode 100644 LearnTheBasics/10_ClassesAndObjects.py create mode 100644 LearnTheBasics/11_Dictionaries.py create mode 100644 LearnTheBasics/12_ModulesAndPackages.py rename LearnTheBasics/{HelloWorld.py => 1_HelloWorld.py} (100%) rename LearnTheBasics/{VariablesAndTypes.py => 2_VariablesAndTypes.py} (100%) rename LearnTheBasics/{Lists.py => 3_Lists.py} (100%) create mode 100644 LearnTheBasics/4_BasicOperators.py create mode 100644 LearnTheBasics/5_StringFormatting.py create mode 100644 LearnTheBasics/6_BasicStringOperations.py create mode 100644 LearnTheBasics/7_Conditions.py create mode 100644 LearnTheBasics/8_Loops.py create mode 100644 LearnTheBasics/9_Functions.py diff --git a/LearnTheBasics/10_ClassesAndObjects.py b/LearnTheBasics/10_ClassesAndObjects.py new file mode 100644 index 0000000..10de608 --- /dev/null +++ b/LearnTheBasics/10_ClassesAndObjects.py @@ -0,0 +1,65 @@ +#A very basic class would look something like this: +class MyClass: + variable = "blah" + + def function(self): + print("This is a message inside the class.") + + +#We'll explain why you have to include that "self" as a parameter a little bit later. First, to assign the above class(template) to an object you would do the following: +class MyClass2: + variable = "blah" + + def function(self): + print("This is a message inside the class.") + +myobjectx = MyClass2() +#To access a function inside of an object you use notation similar to accessing a variable: +myobjectx.function() + +#To access the variable inside of the newly created object "myobjectx" you would do the following: +x = myobjectx.variable +print(x) + + +#The __init__() function, is a special function that is called when the class is being initiated. It's used for assigning values in a class. +class NumberHolder: + + def __init__(self, number): + self.number = number + + def returnNumber(self): + return self.number + +var = NumberHolder(7) +print(var.returnNumber()) #Prints '7' + + +# Exercise +# We have a class defined for vehicles. Create two new vehicles called car1 and car2. Set car1 to be a red convertible worth $60,000.00 with a name of Fer, and car2 to be a blue van named Jump worth $10,000.00. + +# define the Vehicle class +class Vehicle: + name = "" + kind = "car" + color = "" + value = 100.00 + def description(self): + desc_str = "%s is a %s %s worth $%.2f." % (self.name, self.color, self.kind, self.value) + return desc_str +# your code goes here +car1 = Vehicle() +car1.name = "Fer" +car1.value = 60000.00 +car1.kind = "convertible" +car1.color = "red" + +car2 = Vehicle() +car2.name = "Jump" +car2.kind = "van" +car2.color = "blue" +car2.value = 10000.00 + +# test code +print(car1.description()) +print(car2.description()) \ No newline at end of file diff --git a/LearnTheBasics/11_Dictionaries.py b/LearnTheBasics/11_Dictionaries.py new file mode 100644 index 0000000..e5c3d53 --- /dev/null +++ b/LearnTheBasics/11_Dictionaries.py @@ -0,0 +1,49 @@ +# A dictionary is a data type similar to arrays, but works with keys and values instead of indexes. Each value stored in a dictionary can be accessed using a key, which is any type of object (a string, a number, a list, etc.) instead of using its index to address it. +# For example, a database of phone numbers could be stored using a dictionary like this: + +phonebook = {} +phonebook["John"] = 938477566 +phonebook["Jack"] = 938377264 +phonebook["Jill"] = 947662781 +print(phonebook) + +#Alternatively, a dictionary can be initialized with the same values in the following notation: +phonebook = { + "John" : 938477566, + "Jack" : 938377264, + "Jill" : 947662781 +} +print(phonebook) + +#Dictionaries can be iterated over, just like a list. However, a dictionary, unlike a list, does not keep the order of the values stored in it. To iterate over key value pairs, use the following syntax: +for name, number in phonebook.items(): + print("Phone number of %s is %d" % (name, number)) + +#To remove a specified index, use either one of the following notations: +del phonebook["John"] +print(phonebook) + +phonebook["John"] = 938477566 #To add it back in + +#alternative solution: +phonebook.pop("John") +print(phonebook) + +# Exercise +# Add "Jake" to the phonebook with the phone number 938273443, and remove Jill from the phonebook. + +phonebook = { + "John" : 938477566, + "Jack" : 938377264, + "Jill" : 947662781 +} +# your code goes here +phonebook["Jake"] = 938273443 +del phonebook["Jill"] + +# testing code +if "Jake" in phonebook: + print("Jake is listed in the phonebook.") + +if "Jill" not in phonebook: + print("Jill is not listed in the phonebook.") \ No newline at end of file diff --git a/LearnTheBasics/12_ModulesAndPackages.py b/LearnTheBasics/12_ModulesAndPackages.py new file mode 100644 index 0000000..2c70b80 --- /dev/null +++ b/LearnTheBasics/12_ModulesAndPackages.py @@ -0,0 +1,48 @@ +# Modules in Python are just Python files with a .py extension. The name of the module is the same as the file name. A Python module can have a set of functions, classes, or variables defined and implemented. The example above includes two files: +# mygame/ +# mygame/game.py +# mygame/draw.py +# The Python script game.py implements the game. It uses the function draw_game from the file draw.py, or in other words, the draw module that implements the logic for drawing the game on the screen. +# Modules are imported from other modules using the import command. In this example, the game.py script may look something like this: + +# game.py +# import the draw module +import draw + +def play_game(): + pass + +def main(): + result = play_game() + draw.draw_game(result) + +# this means that if this script is executed, then +# main() will be executed +if __name__ == '__main__': + main() + + +# A namespace is a system where every object is named and can be accessed in Python. We import the function draw_game into the main script's namespace by using the from command. +# game.py +# import the draw module +from draw import draw_game #To import all objects instead of "draw_game" write '*' + +def main(): + result = play_game() + draw_game(result) + + +# Exercise +# In this exercise, print an alphabetically sorted list of all the functions in the re module containing the word find. +import re + +# Your code goes here +import re + +# Your code goes here +find_members = [] +for member in dir(re): + if "find" in member: + find_members.append(member) + +print(sorted(find_members)) \ No newline at end of file diff --git a/LearnTheBasics/HelloWorld.py b/LearnTheBasics/1_HelloWorld.py similarity index 100% rename from LearnTheBasics/HelloWorld.py rename to LearnTheBasics/1_HelloWorld.py diff --git a/LearnTheBasics/VariablesAndTypes.py b/LearnTheBasics/2_VariablesAndTypes.py similarity index 100% rename from LearnTheBasics/VariablesAndTypes.py rename to LearnTheBasics/2_VariablesAndTypes.py diff --git a/LearnTheBasics/Lists.py b/LearnTheBasics/3_Lists.py similarity index 100% rename from LearnTheBasics/Lists.py rename to LearnTheBasics/3_Lists.py diff --git a/LearnTheBasics/4_BasicOperators.py b/LearnTheBasics/4_BasicOperators.py new file mode 100644 index 0000000..6d4a67a --- /dev/null +++ b/LearnTheBasics/4_BasicOperators.py @@ -0,0 +1,47 @@ +numbers = 1 + 1 + 2 * 3 / 4.0 +print(numbers) + +#Another operator available is the modulo (%) operator, which returns the integer remainder of the division. dividend % divisor = remainder. + +remainder = 5 % 6 +print(remainder) + +#square +square = 6 ** 2 +print(square) + +helloworld = "hello" + " " + "world" +print(helloworld) + +#Python also supports multiplying strings to form a string with a repeating sequence: +lotsofhellos = "hello" * 10 +print(lotsofhellos) + +#Lists can be joined with the addition operators: +even_numbers = [2,4,6,8] +odd_numbers = [1,3,5,7] +all_numbers = odd_numbers + even_numbers +print(all_numbers) +print([1,2,3] * 3) + + +# Exercise +# The target of this exercise is to create two lists called x_list and y_list, which contain 10 instances of the variables x and y, respectively. You are also required to create a list called big_list, which contains the variables x and y, 10 times each, by concatenating the two lists you have created. + +x = object() +y = object() + +# TODO: change this code +x_list = [x] * 10 +y_list = [y] * 10 +big_list = x_list + y_list + +print("x_list contains %d objects" % len(x_list)) +print("y_list contains %d objects" % len(y_list)) +print("big_list contains %d objects" % len(big_list)) + +# testing code +if x_list.count(x) == 10 and y_list.count(y) == 10: + print("Almost there...") +if big_list.count(x) == 10 and big_list.count(y) == 10: + print("Great!") \ No newline at end of file diff --git a/LearnTheBasics/5_StringFormatting.py b/LearnTheBasics/5_StringFormatting.py new file mode 100644 index 0000000..212c4e2 --- /dev/null +++ b/LearnTheBasics/5_StringFormatting.py @@ -0,0 +1,29 @@ +#Let's say you have a variable called "name" with your user name in it, and you would then like to print(out a greeting to that user.) + +# This prints out "Hello, John!" +name = "John" +print("Hello, %s!" % name) + +# This prints out "John is 23 years old." +name = "John" +age = 23 +print("%s is %d years old." % (name, age)) + +# This prints out: A list: [1, 2, 3] +mylist = [1,2,3] +print("A list: %s" % mylist) + +# Here are some basic argument specifiers you should know: + # %s - String (or any object with a string representation, like numbers) + # %d - Integers + # %f - Floating point numbers + # %.f - Floating point numbers with a fixed amount of digits to the right of the dot. + # %x/%X - Integers in hex representation (lowercase/uppercase) + +# Exercise +# You will need to write a format string which prints out the data using the following syntax: Hello John Doe. Your current balance is $53.44. + +data = ("John", "Doe", 53.44) +format_string = "Hello" + +print(format_string, "%s, %s, %f" % data) \ No newline at end of file diff --git a/LearnTheBasics/6_BasicStringOperations.py b/LearnTheBasics/6_BasicStringOperations.py new file mode 100644 index 0000000..2b689e6 --- /dev/null +++ b/LearnTheBasics/6_BasicStringOperations.py @@ -0,0 +1,70 @@ +#Strings are bits of text. They can be defined as anything between quotes: +astring = "Hello world!" +astring2 = 'Hello world!' + +astring = "Hello world!" +print("single quotes are ' '") +print(len(astring)) + +print(f"Location of the letter 'o' in '{astring}':",astring.index("o")) #First instance of the letter o +print(f"Location of the letter 'l' in '{astring}':",astring.index("l"), "\n") #First instance of the letter o + + +print(f"Amount of letter 'l' in '{astring}':",astring.count("l")) #amount of letters +print(f"Amount of letter 'o' in '{astring}':",astring.count("o"), "\n") #amount of letters + +#specified characters ofa string: +print(f"specific characters '[3:7]' in '{astring}':",astring[3:7]) +print(f"specific characters '[3:7:2]' in '{astring}':",astring[3:7:2]) #This prints the characters of string from 3 to 7 skipping one character. This is extended slice syntax. The general form is [start:stop:step]. + +print(f"specific characters '[::-1]' in '{astring}':",astring[::-1], "\n") + +print(f"Capitalised version of '{astring}':",astring.upper()) +print(f"Lowercase version of '{astring}':",astring.lower()) + +#true false values +print(astring.startswith("Hello")) +print(astring.endswith("asdfasdfasdf")) + +#plitting the texts into a list +afewwords = astring.split(" ") +print(afewwords) + + +# Exercise +# Try to fix the code to print out the correct information by changing the string. + +s = "Strings are awesome!" +# Length should be 20 +print("Length of s = %d" % len(s)) + +# First occurrence of "a" should be at index 8 +print("The first occurrence of the letter a = %d" % s.index("a")) + +# Number of a's should be 2 +print("a occurs %d times" % s.count("a")) + +# Slicing the string into bits +print("The first five characters are '%s'" % s[:5]) # Start to 5 +print("The next five characters are '%s'" % s[5:10]) # 5 to 10 +print("The thirteenth character is '%s'" % s[12]) # Just number 12 +print("The characters with odd index are '%s'" %s[1::2]) #(0-based indexing) +print("The last five characters are '%s'" % s[-5:]) # 5th-from-last to end + +# Convert everything to uppercase +print("String in uppercase: %s" % s.upper()) + +# Convert everything to lowercase +print("String in lowercase: %s" % s.lower()) + +# Check how a string starts +if s.startswith("Str"): + print("String starts with 'Str'. Good!") + +# Check how a string ends +if s.endswith("ome!"): + print("String ends with 'ome!'. Good!") + +# Split the string into three separate strings, +# each containing only a word +print("Split the words of the string: %s" % s.split(" ")) \ No newline at end of file diff --git a/LearnTheBasics/7_Conditions.py b/LearnTheBasics/7_Conditions.py new file mode 100644 index 0000000..1f0dd6a --- /dev/null +++ b/LearnTheBasics/7_Conditions.py @@ -0,0 +1,78 @@ +x = 2 +print(x == 2) # prints out True +print(x == 3) # prints out False +print(x < 3) # prints out True + + +#The "and" and "or" boolean operators allow building complex boolean expressions, for example: +name = "John" +age = 23 +if name == "John" and age == 23: + print("Your name is John, and you are also 23 years old.") + +if name == "John" or name == "Rick": + print("Your name is either John or Rick.") + + +#The "in" operator could be used to check if a specified object exists within an iterable object container, such as a list: +name = "John" +if name in ["John", "Rick"]: + print("Your name is either John or Rick.") + + +#Here is an example for using Python's "if" statement using code blocks: +statement = False +another_statement = True +if statement is True: + # do something + pass +elif another_statement is True: # else if + # do something else + pass +else: + # do another thing + pass + +x = 2 +if x == 2: + print("x equals two!") +else: + print("x does not equal to two.") + + +#Unlike the double equals operator "==", the "is" operator does not match the values of the variables, but the instances themselves. For example: +x = [1,2,3] +y = [1,2,3] +print(x == y) # Prints out True +print(x is y) # Prints out False + +#Using "not" before a boolean expression inverts it: +print(not False) # Prints out True +print((not False) == (False)) # Prints out False + +# Exercise +# Change the variables in the first section, so that each if statement resolves as True. + +# change this code +number = 16 +second_number = False +first_array = [True, True, True] +second_array = [True,2] + +if number > 15: + print("1") + +if first_array: + print("2") + +if len(second_array) == 2: + print("3") + +if len(first_array) + len(second_array) == 5: + print("4") + +if first_array and first_array[0] == 1: + print("5") + +if not second_number: + print("6") diff --git a/LearnTheBasics/8_Loops.py b/LearnTheBasics/8_Loops.py new file mode 100644 index 0000000..f8eb854 --- /dev/null +++ b/LearnTheBasics/8_Loops.py @@ -0,0 +1,78 @@ +#For loops iterate over a given sequence. Here is an example: +primes = [2, 3, 5, 7] +for prime in primes: + print(prime) + +# Prints out the numbers 0,1,2,3,4 +for x in range(5): + print(x) + +# Prints out 3,4,5 +for x in range(3, 6): + print(x) + +# Prints out 3,5,7 +for x in range(3, 8, 2): + print(x) + +#While loops repeat as long as a certain boolean condition is met. For example: +# Prints out 0,1,2,3,4 + +count = 0 +while count < 5: + print(count) + count += 1 # This is the same as count = count + 1 + +#break is used to exit a for loop or a while loop, whereas continue is used to skip the current block, and return to the "for" or "while" statement. A few examples: +# Prints out 0,1,2,3,4 + +count = 0 +while True: + print(count) + count += 1 + if count >= 5: + break + +# Prints out only odd numbers - 1,3,5,7,9 +for x in range(10): + # Check if x is even + if x % 2 == 0: + continue + print(x) + +#Unlike languages like C,CPP.. we can use else for loops. When the loop condition of "for" or "while" statement fails then code part in "else" is executed. If a break statement is executed inside the for loop then the "else" part is skipped. Note that the "else" part is executed even if there is a continue statement. +# Prints out 0,1,2,3,4 and then it prints "count value reached 5" +count=0 +while(count<5): + print(count) + count +=1 +else: + print("count value reached %d" %(count)) + +# Prints out 1,2,3,4 +for i in range(1, 10): + if(i%5==0): + break + print(i) +else: + print("this is not printed because for loop is terminated because of break but not due to fail in condition") + + +# Exercise +# Loop through and print out all even numbers from the numbers list in the same order they are received. Don't print any numbers that come after 237 in the sequence. +numbers = [ + 951, 402, 984, 651, 360, 69, 408, 319, 601, 485, 980, 507, 725, 547, 544, + 615, 83, 165, 141, 501, 263, 617, 865, 575, 219, 390, 984, 592, 236, 105, 942, 941, + 386, 462, 47, 418, 907, 344, 236, 375, 823, 566, 597, 978, 328, 615, 953, 345, + 399, 162, 758, 219, 918, 237, 412, 566, 826, 248, 866, 950, 626, 949, 687, 217, + 815, 67, 104, 58, 512, 24, 892, 894, 767, 553, 81, 379, 843, 831, 445, 742, 717, + 958, 609, 842, 451, 688, 753, 854, 685, 93, 857, 440, 380, 126, 721, 328, 753, 470, + 743, 527 +] + +# your code goes here +for number in numbers: + if number == 237: + break + if number%2 == 0: + print(number) \ No newline at end of file diff --git a/LearnTheBasics/9_Functions.py b/LearnTheBasics/9_Functions.py new file mode 100644 index 0000000..4779a4c --- /dev/null +++ b/LearnTheBasics/9_Functions.py @@ -0,0 +1,46 @@ +#As we have seen on previous tutorials, Python makes use of blocks. +# A block is a area of code of written in the format of: + +#Functions in python are defined using the block keyword "def", followed with the function's name as the block's name. For example: +def my_function(): + print("Hello From My Function!") + +#Functions may also receive arguments (variables passed from the caller to the function). For example: +def my_function_with_args(username, greeting): + print("Hello, %s , From My Function!, I wish you %s"%(username, greeting)) + +#Functions may return a value to the caller, using the keyword- 'return' . For example: +def sum_two_numbers(a, b): + return a + b + +#Simply write the function's name followed by (), placing any required arguments within the brackets. For example, lets call the functions written above (in the previous example): +# print(a simple greeting) +my_function() + +#prints - "Hello, John Doe, From My Function!, I wish you a great year!" +my_function_with_args("John Doe", "a great year!") + +# after this line x will hold the value 3! +x = sum_two_numbers(1,2) +print(x) + +# Exercise +# In this exercise you'll use an existing function, and while adding your own to create a fully functional program. +# Add a function named list_benefits() that returns the following list of strings: "More organized code", "More readable code", "Easier code reuse", "Allowing programmers to share and connect code together" +# Add a function named build_sentence(info) which receives a single argument containing a string and returns a sentence starting with the given string and ending with the string " is a benefit of functions!" +# Run and see all the functions work together! + +# Modify this function to return a list of strings as defined above +def list_benefits(): + return ["More organized code", "More readable code", "Easier code reuse", "Allowing programmers to share and connect code together"] + +# Modify this function to concatenate to each benefit - " is a benefit of functions!" +def build_sentence(benefit): + return benefit + " is a benefit of functions!" + +def name_the_benefits_of_functions(): + list_of_benefits = list_benefits() + for benefit in list_of_benefits: + print(build_sentence(benefit)) + +name_the_benefits_of_functions() \ No newline at end of file