diff --git a/README.md b/README.md index bcb40e8..675bb91 100644 --- a/README.md +++ b/README.md @@ -39,4 +39,14 @@ files, and the full tutorial for each collection of code is available below. 32. [Python Interface Design Pattern](https://vegibit.com/python-interface-design-pattern/) 33. [Composition Over Inheritance](https://vegibit.com/composition-over-inheritance/) 34. [What Are Python Magic Methods](https://vegibit.com/what-are-python-magic-methods/) -35. [Python Data Class](https://vegibit.com/python-data-class/) \ No newline at end of file +35. [Python Data Class](https://vegibit.com/python-data-class/) +36. [Python Yield Keyword](https://vegibit.com/python-yield-keyword/) +37. [Python Datetime Module Tutorial](https://vegibit.com/python-datetime-module-tutorial/) +38. [Python os Module Tutorial](https://vegibit.com/python-os-module-tutorial/) +39. [What Is A Python Decorator](https://vegibit.com/what-is-a-python-decorator/) +40. [What Is if \_\_name\_\_ == "\_\_main\_\_": main()](https://vegibit.com/python-if-__name__-__main__-main/) +41. [What Is A Pandas Dataframe](https://vegibit.com/what-is-a-pandas-dataframe/) +42. [Python Stack Data Structure](https://vegibit.com/python-stack-data-structure/) +43. [Python Queue Example](https://vegibit.com/python-queue-example/) +44. [Python Deque Vs Queue](https://vegibit.com/python-deque-vs-queue/) +45. [Python Binary Search Tree](https://vegibit.com/python-binary-search-tree/) \ No newline at end of file diff --git a/decorators.py b/decorators.py new file mode 100644 index 0000000..a89dc1e --- /dev/null +++ b/decorators.py @@ -0,0 +1,18 @@ +def my_decorator(func): + '''Decorator Function''' + + def wrapper(): + '''Wrapper Function''' + result = func() + return result.title().replace(' ', ' !##! ') + + return wrapper + + +@my_decorator +def to_be_decorated(): + return 'output to decorate' + + +result = to_be_decorated() +print(result) \ No newline at end of file diff --git a/deque.py b/deque.py new file mode 100644 index 0000000..0d41a13 --- /dev/null +++ b/deque.py @@ -0,0 +1,36 @@ +class Deque: + + def __init__(self): + self.items = [] + + def add_front(self, item): + self.items.insert(0, item) + + def add_rear(self, item): + self.items.append(item) + + def remove_front(self): + if self.items: + return self.items.pop(0) + return None + + def remove_rear(self): + if self.items: + return self.items.pop() + return None + + def peek_front(self): + if self.items: + return self.items[0] + return None + + def peek_rear(self): + if self.items: + return self.items[-1] + return None + + def size(self): + return len(self.items) + + def is_empty(self): + return self.items == [] diff --git a/howtoyield.py b/howtoyield.py new file mode 100644 index 0000000..c087ca2 --- /dev/null +++ b/howtoyield.py @@ -0,0 +1,30 @@ +import memory_profiler as mem_profile +import random +import time + +mem_before = mem_profile.memory_usage()[0] +print(f'Before calling the function, Python is using {mem_before} MB of memory') + + +def cubed_list(n): + result = [] + for i in range(n): + result.append(i ** 3) + return result + + +def cubed_generator(n): + for i in range(n): + yield i ** 3 + + +time_start = time.perf_counter() +cubes = cubed_generator(5000000) +time_end = time.perf_counter() +elapsed = time_end + time_start + +mem_after = mem_profile.memory_usage()[0] +mem_usage = mem_after - mem_before + +print(f'After calling the function, Python is using {mem_after} MB of memory') +print(f'It Took {elapsed} Seconds to cube 5,000,000 integers') \ No newline at end of file diff --git a/namemain.py b/namemain.py new file mode 100644 index 0000000..9ef98b1 --- /dev/null +++ b/namemain.py @@ -0,0 +1,6 @@ +def main(): + print("Hello World!") + + +if __name__ == "__main__": + main() diff --git a/pandasdataframe.py b/pandasdataframe.py new file mode 100644 index 0000000..6bd9ed0 --- /dev/null +++ b/pandasdataframe.py @@ -0,0 +1,21 @@ +import pandas as pd + +simple_list = ['Sam', 'Bob', 'Joe', 'Mary', 'Sue', 'Sally'] + +named_column = {'Name': simple_list, + 'Favorite Color': ['Blue', 'Red', 'Green', 'Blue', 'Red', 'Green'], + 'Favorite Food': ['Italian', 'Mediterranean', 'Thai', 'Chinese', 'Mexican', 'Spanish']} + +pd.set_option('display.max_columns', None) +pd.set_option('display.expand_frame_repr', False) + +data = pd.DataFrame(named_column) + +formula_result = [] +for i in range(len(data)): + formula_result.append(f'{data.iloc[i]["Name"]} likes {data.iloc[i]["Favorite Food"]}' + f' food and the color {data.iloc[i]["Favorite Color"]}') + +data['About Me'] = formula_result + +print(data) diff --git a/queue.py b/queue.py new file mode 100644 index 0000000..b005592 --- /dev/null +++ b/queue.py @@ -0,0 +1,24 @@ +class Queue: + def __init__(self): + self.items = [] + + def enqueue(self, item): + self.items.insert(0, item) + + def dequeue(self): + if self.items: + return self.items.pop() + else: + return None + + def size(self): + return len(self.items) + + def peek(self): + if self.items: + return self.items[-1] + else: + return None + + def is_empty(self): + return self.items == [] diff --git a/stack.py b/stack.py new file mode 100644 index 0000000..acfba7d --- /dev/null +++ b/stack.py @@ -0,0 +1,24 @@ +class Stack: + def __init__(self): + self.items = [] + + def push(self, item): + self.items.append(item) + + def pop(self): + if self.items: + return self.items.pop() + else: + return None + + def size(self): + return len(self.items) + + def is_empty(self): + return self.items == [] + + def peek(self): + if self.items: + return self.items[-1] + else: + return None diff --git a/tree.py b/tree.py new file mode 100644 index 0000000..ff1d371 --- /dev/null +++ b/tree.py @@ -0,0 +1,118 @@ +class Node: + def __init__(self, data): + self.data = data + self.left = None + self.right = None + + def traversePreorder(self): + print(self.data) + if self.left: + self.left.traversePreorder() + if self.right: + self.right.traversePreorder() + + def traverseInorder(self): + if self.left: + self.left.traverseInorder() + print(self.data) + if self.right: + self.right.traverseInorder() + + def traversePostorder(self): + if self.left: + self.left.traversePostorder() + if self.right: + self.right.traversePostorder() + print(self.data) + + def search(self, target): + if self.data == target: + print("Found it!") + return self + + if self.left and self.data > target: + return self.left.search(target) + + if self.right and self.data < target: + return self.right.search(target) + + print("Value is not in tree") + + def getNodesAtDepth(self, depth, nodes=[]): + if depth == 0: + nodes.append(self.data) + return nodes + + if self.left: + self.left.getNodesAtDepth(depth - 1, nodes) + else: + nodes.extend([None] * 2 ** (depth - 1)) + + if self.right: + self.right.getNodesAtDepth(depth - 1, nodes) + else: + nodes.extend([None] * 2 ** (depth - 1)) + return nodes + + def height(self, h=0): + leftHeight = self.left.height(h + 1) if self.left else h + rightHeight = self.right.height(h + 1) if self.right else h + return max(leftHeight, rightHeight) + + +class Tree: + def __init__(self, root, name=''): + self.root = root + self.name = name + + def _nodeToChar(self, n, spacing): + if n is None: + return '_' + (' ' * spacing) + spacing = spacing - len(str(n)) + 1 + return str(n) + (' ' * spacing) + + def print(self, label=''): + print(self.name + ' ' + label) + height = self.root.height() + spacing = 3 + width = int((2 ** height - 1) * (spacing + 1) + 1) + # Root offset + offset = int((width - 1) / 2) + for depth in range(0, height + 1): + if depth > 0: + # print directional lines + print(' ' * (offset + 1) + (' ' * (spacing + 2)).join(['/' + (' ' * (spacing - 2)) + '\\'] * (2 ** (depth - 1)))) + row = self.root.getNodesAtDepth(depth, []) + print((' ' * offset) + ''.join([self._nodeToChar(n, spacing) for n in row])) + spacing = offset + 1 + offset = int(offset / 2) - 1 + print('') + + def traverseInorder(self): + self.root.traverseInorder() + + def traversePreorder(self): + self.root.traversePreorder() + + def traversePostorder(self): + self.root.traversePostorder() + + def search(self, target): + return self.root.search(target) + + def getNodesAtDepth(self, depth): + return self.root.getNodesAtDepth(depth) + + def height(self): + return self.root.height() + + +tree = Tree(Node(20)) +tree.root.left = Node(15) +tree.root.right = Node(25) +tree.root.left.left = Node(12) +tree.root.left.right = Node(16) +tree.root.right.left = Node(23) +tree.root.right.right = Node(100) + +tree.print() diff --git a/xmlelementtree.py b/xmlelementtree.py index de619c4..118404e 100644 --- a/xmlelementtree.py +++ b/xmlelementtree.py @@ -16,7 +16,7 @@ def main(): for elem in doc.findall('post'): print(elem.tag) - # Count the number of posts + # CountDecorator the number of posts postCount = len(doc.findall('post')) entryCount = len(doc.findall('.//entry')) @@ -27,7 +27,7 @@ def main(): newPost = etree.SubElement(doc, 'post') newPost.text = 'This is a new post' - # Count the number of posts + # CountDecorator the number of posts postCount = len(doc.findall('post')) entryCount = len(doc.findall('.//entry'))