Add files via upload

Author: Techiral

Z/zipf-curve/README.md

@@ -0,0 +1,3 @@
+To run this code, install:
+- `pip install -r requirements.txt`
+- The `texts` folder already exists if you want to use it.

Z/zipf-curve/requirements.txt

@@ -0,0 +1,3 @@
+numpy
+matplotlib
+scipy

Z/zipf-curve/texts/Calculator with tkinter.txt

@@ -0,0 +1,371 @@
+# Calculator with tkinter
+**How to make a simple calculator with tkinter which has a history function and variable insertion.**
+
+## Idea
+In this tutorial, we are going to make a calculator with Tkinter the built-in GUI Library in python. We are going to make a 3 by 3 Grid with buttons that represent the possible inputs, a live result showing system, a history of calculations feature, and variable insertion.
+
+So let's get right into it.
+
+## Imports
+As always we start with the imports. Because we make the UI with tkinter we need to import it, we import everything from `tkinter` so we don't have to write less code later on. We also import the font module from tkinter so we can change the fonts on our elements later.
+
+We continue by getting the `partial` function from `functools`. This is a genius function that excepts another function as a first argument and some args and kwargs and it will return a reference to this function with those arguments. This is especially useful when we want to insert one of our functions to a command argument of a button or a key binding.
+
+In the next line, we import `ctypes`, which allows us to enable high dpi, making our window look way sharper. This is done with the function call in the last line of this sections code block.
+
+Because we'll save our history in a JSON file we import the `json` module to parse json and stringify lists.
+
+We also need `re` the built-in regex module for our variable insertion feature.
+
+Last but not least we get math, but we do not don't need it we just import it so it can be used in the line edit of the calculator.
+
+```python
+from tkinter import *
+import tkinter.font as font
+from functools import partial
+import ctypes
+import json
+import re
+
+# so the functions that can be used from the math module can be used in the line edit.
+import math
+
+ctypes.windll.shcore.SetProcessDpiAwareness(1)
+```
+
+## Variables and tkinter setup
+
+Next up we make some variables and we set up the tkinter.
+
+The first two variables are just colors for our buttons and for the background of the history panel.
+
+Next, we set up tkinter by calling its Tk class and saving this object in the `root` variable. We then set the window dimensions with the `geometry()` method and the window title with `title()`.
+
+We then import an image from our directory which we can set to be the icon of our program.
+
+Last but not least we import the font `Consolas` in the size 12. We do this with the `Font` class from the font module of tkinter.
+
+```python
+# Colors
+buttonColor = (255, 255, 255)
+historyPanelBackground = (255, 255, 255)
+
+# Tkinter Setup
+root = Tk()
+root.geometry("550x270")
+root.title("Calculator")
+
+# Setting icon for the Application
+photo = PhotoImage(file = "icon.png")
+root.iconphoto(False, photo)
+
+# Loading Font from font name
+myFont = font.Font(family='Consolas', size=12)
+```
+
+## Formulas and variable insertions
+
+Now I am going to explain the variable insertion feature or at least I will try to! So the idea is that we can have a space after our equations where we declare variables that are inserted into the equation by placeholders. Let us look at this in a concrete example. If we type text below into the line edit.
+
+```
+{a} * {b} ? a=7 & b=3
+```
+
+... should net us this result ...
+
+```
+21
+```
+... because where `a` was the 7 will be placed and where the `b` is we will insert the 3 and after that the equation will be evaluated and this will be `21`.
+
+We will later look at how this is done in practice.
+
+Below we also have a list of formulas that can be inserted into the line edit. We will make them pickable from a Menu.
+
+```python
+# Formula Templates
+formulas = [
+    ['Pythagoras->c', '(({a}**2)+({b}**2))**0.5 ? a=5 & b=5'],
+    ['Pythagoras->c**2', '({a}**2)+({b}**2) ? a=5 & b=5'],
+    ['pq->(x1, x2)', '-({p}/2) + sqrt(({p}/2)**2 - ({q})), -({p}/2) - sqrt(({p}/2)**2 - ({q})) ? p=-1 & q=-12'],
+    ['abc->(x1, x2)', 'quadratic_formula({a}, {b}, {c}) ? a=1 & b=5 & c=6'],
+    ['Incline->y', '{m}{x} + {q} ? m=4 & x=5 & q=6'],
+]
+```
+
+## History setup
+
+Next, we set up the history feature.
+
+We start by declaring a list that will hold our history items. Then we have a variable that holds the location of the `history.json` file. 
+
+In the end, we have a try and except block, where there is an attempt to make the file at the specified location. This is just done so the file exists in all cases.
+
+```python
+# All the history equations are in this list.
+history = []
+
+# Where the history file is located.
+historyFilePath = 'history.json'
+
+print("Reading history from: ",historyFilePath )
+
+# Creating History file if it does not exist.
+try:
+    with open(historyFilePath, 'x') as fp:
+        pass
+    print("Created file at:", historyFilePath)
+except:
+    print('File already exists')
+```
+
+## RGB to hex and math function.
+
+Now we talk about two functions that hold only minor importance. 
+
+The first one simply converts RGB colors to hex colors because tkinter only allows color names and hex colors.
+
+The second one is a custom math function that can be used in the line edit.
+
+```python
+# converting RGB values to HEX
+def rgb_to_hex(rgb):
+    return "#%02x%02x%02x" % rgb
+
+def quadratic_formula(a, b, c):
+    disc = b**2 - 4 * a * c
+
+    x1 = (-b - math.sqrt(disc)) / (2 * a)
+    x2 = (-b + math.sqrt(disc)) / (2 * a)
+
+    return(x1, x2)
+```
+
+## Helper functions
+
+Now we will go over the several helper functions that are needed to make the program work.
+
+### `addSymbol`
+
+This function will be called from the buttons to insert operators like `*` or `+` and numbers into the line edit. That's where the symbol parameter comes in. Now if the symbol is `<` we won't append it, we will shorten the current input. We actually change the String Variable which holds the current input.
+
+```python
+# Add something to the current calculation
+def addSymbol(event=None, symbol=None):
+
+    if symbol == '<':
+        entryVariable.set(entryVariable.get()[:-1])
+    else:
+        entryVariable.set(entryVariable.get()+symbol)
+```
+
+### `varChange`
+
+This function will be connected to change events on the input variable. In this function, we will also evaluate the equation and insert it into the result label.
+
+Earlier we took a look at how the variable insertion feature functioned and now we look at how we do this in practice.
+
+As you see we first split the input string by the `?` and then we save this to the `evaluationString` variable.
+
+After that, we check if the input string split by `?` would result in a list with two items. If that's the case we know that there are insertion variables. Then we get this side of the string and we loop over another splitted version of this where the separator is `&`. There we modify the `evaluationString` with these variables.
+
+In either case, we will try to insert the evaluated value into the result label. Now it could be that this doesn't work because the input is invalid so we cover that case.
+
+```python
+def varChange(*args):
+    evaluationString = entryVariable.get().replace(' ', '').split('?')[0]
+
+    print('Before insertion: ',evaluationString)
+
+    if len(entryVariable.get().split('?')) == 2:
+
+        parameters = entryVariable.get().replace(' ', '').split('?')[1]
+
+        for param in parameters.split('&'):
+            where, what = param.split('=')
+            evaluationString = re.sub('{'+where+'}', what, evaluationString)
+
+    try:
+        print('After insertion: ', evaluationString)
+        resultLabel.config(text=str(eval(evaluationString)))
+    except:
+        resultLabel.config(text='Invalid Input')
+```
+
+### `saveCurrentInputToHistory`
+
+This function simply saves the current line edit input to the history file. We first check if the value is already in the list so we don't have duplicates. We then save the history list to the history file. Here we use the `json.dump()` function. and in the end, we call the `updateListBox` function, which will be explained later.
+
+```python
+def saveCurrentInputToHistory(event=None):
+    if entryVariable.get() in history:
+        return
+
+    history.append(entryVariable.get())
+
+    with open(historyFilePath, 'w') as file:
+        file.write(json.dumps(history))
+
+    updateListBox()
+```
+
+### `updateListBox`
+
+This function will delete all the contents of the history list and display them again, that's why need the history variable here. We then delete all the stuff in the list with the `delete(start, end)` method. Then we get open the history file and get the json from there. And in the end, we loop over the history list and insert those values into the history list.
+
+```python
+def updateListBox(event=None):
+    global history
+
+    historyList.delete(0, END)
+
+    try:
+        with open(historyFilePath, 'r') as file:
+            history = json.loads(file.read())
+    except json.decoder.JSONDecodeError:
+        print('File does not contain JSON')
+
+    for index, item in enumerate(history):
+        historyList.insert(index, item)
+```
+
+### `setEntryFromHistory` and `addFormula`
+
+These two functions have simple jobs.
+
+The `setEntryFromHistory` enables us to click on a list item and this item will then be inserted into the line edit.
+
+The `addFormula` function will do the same just for the formulas chosen from the dropdownmenu.
+
+```python
+def setEntryFromHistory(event=None):
+    historyItem = historyList.get(historyList.curselection()[0])
+    entryVariable.set(historyItem)
+
+def addFormula(formula=''):
+    saveCurrentInputToHistory()
+    entryVariable.set(formula)
+```
+
+## UI
+
+Now we will make the UI. I wont go into detail to much. There are some different to take away from the code.
+
+The layout is done with the `pack` method of all widgets, and make the two-column setup by using `Frame`'s
+
+```python
+# Work with Frames to split the window in two parts: the calculator and the History Panel.
+
+# Calculation Panel
+calcSide = Frame(root)
+calcSide.pack(side=LEFT, fill=BOTH, expand=1)
+
+# Entry Variable for the calculations
+entryVariable = StringVar(root, '4/2**2')
+entryVariable.trace('w', varChange)
+
+Entry(calcSide, textvariable=entryVariable, font=myFont, borderwidth=0).pack(fill=X, ipady=10, ipadx=10)
+resultLabel = Label(calcSide, text='Result', font=myFont, borderwidth=0,anchor="e")
+resultLabel.pack(fill=X, ipady=10)
+
+# History Panel
+historySide = Frame(root, bg=rgb_to_hex(historyPanelBackground))
+historySide.pack(side=LEFT, fill=BOTH, expand=1)
+
+historyTopBar = Frame(historySide)
+historyTopBar.pack(fill=X)
+Label(historyTopBar, text='History').pack(side=LEFT)
+Button(historyTopBar, text='Save Current Input', bg=rgb_to_hex(buttonColor), borderwidth=0, command=saveCurrentInputToHistory).pack(side=RIGHT)
+
+historyList = Listbox(historySide, borderwidth=0)
+historyList.pack(fill=BOTH, expand=True)
+historyList.bind("<Double-Button-1>", setEntryFromHistory)
+```
+
+We also call this function so the list updates on startup.
+```python
+# Insert stuff into the history
+updateListBox()
+```
+Below you see how the Buttons are made. We first define a list with other lists in it where the symbols on the button are layed out.
+
+Then we loop over this first list and make a new frame for each row. we continue by looping over these inner lists and generating buttons with the given symbols.
+
+We set the background color on these buttons to our button color and then we lower every number from the button color tuple, this will give us a nice gradient for the buttons.
+
+```python
+# Button Symbols (and their position)
+symbols = [
+    ['1', '2', '3', '+'],
+    ['4', '5', '6', '-'],
+    ['7', '8', '9', '/'],
+    ['0', '.', '<', '*'],
+]
+
+for rowList in symbols:
+
+    # Make a row
+    row = Frame(calcSide)
+    row.pack(fill=BOTH, expand=True)
+    for symbol in rowList:
+
+        # Making and packing the Button
+        Button(
+            row,
+            text=symbol,
+            command=partial(addSymbol, symbol=symbol),
+            font=myFont,
+            bg=rgb_to_hex(buttonColor),
+            borderwidth=0
+            ).pack(
+                side=LEFT,
+                fill=BOTH,
+                expand=1
+            )
+
+        # Change button color each iteration for gradient.
+        buttonColor = (buttonColor[0] - 10, buttonColor[1] - 10, buttonColor[1] - 2)
+```
+
+We also make a menu where we have all our formulas ready to be inserted.
+
+```python
+menubar = Menu(root)
+
+filemenu = Menu(menubar, tearoff=0)
+
+# Add all Formulas to the dropdown menu.
+for formula in formulas:
+    filemenu.add_command(label=formula[0], command=partial(addFormula, formula[1]))
+
+filemenu.add_separator()
+
+# Quit command
+filemenu.add_command(label="Exit", command=root.quit)
+
+menubar.add_cascade(menu=filemenu, label='Formulas')
+
+root.config(menu=menubar)
+```
+
+Now, in the end, we call the `valueChange` function so the input is evaluated on startup and we call the `mainloop()` method.
+
+```python
+# Call the var change once so it is evaluated without actual change.
+varChange('foo')
+
+root.mainloop()
+```
+
+## Showcase
+
+Below you see a little showcase of how the calculator works.
+
+![enter image description here](https://raw.githubusercontent.com/Maximinodotpy/calculator/main/showcase%20%282%29.gif)
+
+## Conclusion
+
+Excellent! You have successfully created a calculator using Python code! See how you can add more features to this program such as more formulas or a converter for different things like inches to centimers
+## Conclusion
+
+Excellent! You have successfully created a **...** using Python code! See how you can add more features to this program such as **...** .

Z/zipf-curve/texts/Harry Potter and the Sorcerer's Stone.txt

@@ -0,0 +1,172 @@
+# Password Generator with Python
+**How to make a password generator with python and its modules argparse and random**
+
+## Idea
+In this tutorial, we will make a Command-line tool for generating passwords. We will use the argparse module to make it easier to parse the command line arguments the user has provided. We make it so the user can define the letters which should be included, how many passwords should be created and if they shall be saved to a .txt file.
+
+Let us get started.
+
+## Imports
+Let us import some Modules. For this program, we just need the `ArgumentParser` Class from `argparse` and the `shuffle()` and `choice()` functions from `random`. We also get the `string` module, which has some letters and numbers collections. We don't have to install any of these because they come with python. 
+
+```python
+from argparse import ArgumentParser
+from random import shuffle, choice
+import string
+```
+
+## Setting up the argument parser.
+
+Now we continue with setting up the argument parser. To do this we sav,e a new instance of the `ArgumentParser` class to our `parser` variable. We give the parser a name and a description. This information will appear if the user provides the `-h` argument when running our program, it will also tell them the possible arguments.
+
+```python
+# Setting up the Argument Parser
+parser = ArgumentParser(
+    prog='Password Generator.',
+    description='Generate any number of passwords with this tool.'
+)
+```
+
+We continue by adding arguments to the parser. The first four will be the amounts of each character type. That's why we set them all to 2 by default. We check if they are of type integer.
+
+```python
+# Adding the arguments to the parser
+parser.add_argument('-numNumbers', default=2, type=int)
+parser.add_argument('-numLowercaseLetters', default=2, type=int)
+parser.add_argument('-numCapitalLetters', default=2, type=int)
+parser.add_argument('-numSpecialChars', default=2, type=int)
+```
+
+The subsequent two arguments are the desired length and the number of passwords. We set the length to be eight by default because most platforms have this requirement. We check for the length and amount if it is of type int because a string or float would not make sense in this case. The store argument is a flag that just tells the program whether to store the passwords in a text file or not. By default, this is false that is why the action is `"store_true"`.
+
+```python
+# The amount is a number so we check it to be of type int.
+parser.add_argument('-amount', default=1, type=int)
+parser.add_argument('-store', default=False, action='store_true')
+```
+
+Last but not least we parse the command line for these arguments with the `parse_args()` method of the `ArgumentParser` class. If we don't call this method the parser won't check for anything and won't raise any exceptions.
+
+```python
+# Parsing the command line arguments.
+arguments = parser.parse_args()
+```
+
+## The Password Loop
+
+We continue with the main part of the program: the Password loop. Here we generate the number of passwords specified by the user.
+
+That is why we define a passwords list that will hold all the generated passwords. We don't need the number which is returned by the range generator.
+
+```python
+passwords = []
+
+# Looping through the number of passwords.
+for _ in range(int(arguments.amount)):
+```
+
+After that, we make a password list which will first hold all the possible letters and then the password string.
+
+```python
+password = []
+```
+
+Now we add the possible letters, numbers, and special characters to the password list. For each of the types, we check if it is true in the namespace of the parser. We get the respective letters from the string module.
+
+```python
+	# If / how many Numbers the password should contain
+	for _ in range(arguments.numNumbers):
+		password.append(choice(string.digits))
+
+	# If / how many Capital Characters the password should contain
+	for _ in range(arguments.numCapitalLetters):
+		password.append(choice(string.ascii_uppercase))
+
+	# If / how many lowercase Characters the password should contain
+	for _ in range(arguments.numLowercaseLetters):
+		password.append(choice(string.ascii_lowercase))
+
+	# If / how many Special Characters the password should contain
+	for _ in range(arguments.numSpecialChars):
+		password.append(choice(string.punctuation))
+```
+
+Then we use the `shuffle` function from `random` to mix up the list. This is done in place.
+
+```python
+	# Shuffle the list with all the possible letters, numbers, and symbols.
+    shuffle(password)
+```
+
+After this, we get the first items of the list until the length specified by the user and then we join the resulting with `""` so we have the string version of it.
+
+```python
+    # Get the letters of the string up to the length argument and then join them.
+    password = ''.join(password)
+```
+
+Last but not least we append this password to the passwords list.
+
+```python
+    # Append this password to the overall list of passwords.
+    passwords.append(password)
+```
+
+## Saving the Passwords
+
+After the password loop, we check if the user said he or she wanted to save the passwords to a file. if that is the case we simply open a file, which will be made if it does not exist.
+
+```python
+# Store the password to a .txt file.
+if arguments.store:
+    with open('passwords.txt', 'w') as f:
+        f.write('\n'.join(passwords))
+```
+
+In all cases, we print out the passwords.
+
+```python
+print('\n'.join(passwords))
+```
+
+
+## Examples
+
+Now you will see some useful examples of the generator. Keep in mind this will be different for you.
+
+```
+C:\Users\Maxim> main.py
+^G~0,NU4
+```
+```
+C:\Users\Maxim> main.py -amount 5
+j@BJk#IO
+F~§!]G_E
+nGg#MAW-
+fh=5c)-§
+cjFPy?]A
+```
+```
+C:\Users\Maxim> main.py -amount 2
+1*~G^n%K
+2ouVq)ç¬
+```
+```
+C:\Users\Maxim> main.py -numCapitalLetters 6
+O1AdJ]FQmR&7
+```
+## Imports
+
+## Setting up the argument parser.
+
+## Specifying the possible characters.
+
+**show trick to speed up process**
+
+## The Password Loop
+
+## Saving the Passwords
+
+## Conclusion
+
+Excellent! You have successfully created a Password Generator using Python code! See how you can add more features to this program such as hashing the passwords or more options.

Z/zipf-curve/texts/How to Make a Password Generator in Python.txt

@@ -0,0 +1,222 @@
+# Planet Simulation with Python and Pygame
+**How to make a planet-class with python and its game-making module pygame.**
+
+## Idea
+In this tutorial, we are going to make a little planet simulation with python and the game-making library pygame. Pygame has a handy vector class that can help us when simulating the planets and their heading.
+
+So let us start with the imports.
+
+## Imports
+
+All of the modules we import are built-in except the pygame library, which we have to install with `pip install pygame`. We also need `sys`, but it will simply be used to stop the game when pressing on the x at the top left of the window. After that, we get the `Vector2` class from `pygame.math`. It offers some interesting methods to use when we want to work with vectors. The `randrange()` function from random will just be used when we make some planets. We also get `ctypes` to enable high DPI. This is often used with `tkinter` but we can also use it here, even though it has not as great an effect.
+
+```python
+# Imports
+import pygame
+import sys
+
+# We will work with Vector2 because it has some useful functions.
+from pygame.math import Vector2
+
+from random import randrange
+
+import ctypes
+
+# Enable High Dots Per Inch so the image displayed on the window is sharper.
+ctypes.windll.shcore.SetProcessDpiAwareness(1)
+```
+
+## Pygame Setup
+
+Next, we set up pygame, to do this we start with `pygame.init()` this has to be called so all the modules work. After that, we define the game's fps and we make a clock object which will handle the game speed in combination with the defined fps.
+
+```python
+# Configuration
+pygame.init()
+fps = 60
+fpsClock = pygame.time.Clock()
+```
+
+We continue by defining the window size and making the window with these sizes.
+
+```python
+# Window Size
+windowdim = Vector2(800, 800)
+screen = pygame.display.set_mode((int(windowdim.x), int(windowdim.y)))
+```
+
+## Planet Class
+Let us get into the planet-class this is the main part of this program's code because it allows us to make an infinite amount of planets that will react to each other.
+
+Outside of the class we just need to define a list that holds all of the planets. Then in the main loop, we loop over this list and call a method on all of these objects.
+
+```python
+# all the Planets are stored here
+# They will append themselves.
+planets = []
+```
+
+### Constructor Function
+
+Let us first talk about the constructor of the class. We provide each planet with a starting position and we have the following optional arguments; delta, which is the velocity, the radius of the planet, and if the planet is immovable. We set all of these inputs to a variable available to the class.
+
+```python
+# The Planet Class which will handle drawing and calculating planets.
+class Planet():
+    def __init__(self, position, delta=Vector2(0, 0), radius=10, imovable=False):
+
+        # Where the planet is at the moment
+        self.position = position
+
+        # The Radius determines how much this planet affects others
+        self.radius = radius
+
+        # The Velocity
+        self.delta = delta
+
+        # If this planet is moving
+        self.imovable = imovable
+
+        # If this planet can be eaten by others.
+        self.eatable = False
+```
+
+At the end of the constructor, we append the object itself to the planet list so we don't have to do this manually.
+
+```python
+        # Appending itself to the list so its process
+        # function will later be called in a loop.
+        planets.append(self)
+```
+
+### Process Function
+
+Let us talk about the process function. This will be called for each planet in each frame. The whole of the movement code will be skipped if the `imovable` property is set to True. If the planet can move it will loop through every other planet and if the planet is not the object itself we continue.
+
+If the planet is too near to this one it will be eaten this is done by adding the radius of this planet to the other one and removing this planet from the list.
+
+If that's, not the case we calculate the vector to the other planet and then we add it to the delta. Now, this whole code is in a try-except block because it won't work if the planets are on top of each other. After that, we add the delta to the position.
+
+```python
+        # This function will be called once every frame 
+        # and it is responsible for calculating where the planet will go.
+
+        # No Movement Calculations will happen if the planet doesn't move at all.
+        # it also won't be eaten.
+        if not-self.imovable:
+            for i in planets:
+
+                if not i is self:
+                    try:
+                        if self.eatable:
+                            if self.position.distance_to(i.position) < self.radius + i.radius:
+                                print('Eaten')
+
+                                i.radius += self.radius
+
+                                planets.remove(self)
+
+                        dir_from_obj  = (i.position - self.position).normalize() * 0.01 * (i.radius / 10)
+                        self.delta += dir_from_obj
+
+                    except:
+                        print('In the same spot')
+
+            self.position += self.delta
+```
+
+In the end, we draw the planet at its position this is done even if the planet is immovable.
+
+```python
+        # Drawing the planet at the current position.
+        pygame.draw.circle(
+            screen,
+            [255, 255, 255],
+            self.position,
+            self.radius,
+        )
+```
+
+## Main Loop
+
+Last but not least we have the mainloop which will cool the process function on each planet in the planets list every frame.
+
+```python
+# Game loop.
+while  True:
+    screen.fill((0, 0, 0))
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            pygame.quit()
+            sys.exit()
+
+    for p in planets:
+        p.process()
+
+    pygame.display.flip()
+    fpsClock.tick(fps)
+```
+
+Now, this code won't spawn planets by itself. In the next part, we look at some examples.
+
+## Examples
+
+### Sun and two opposing Planets
+
+This code is run right before the main loop. and it will spawn three planets. After the code, you see it in action.
+
+```python
+# Sun and two opposing Planets
+Planet(Vector2(400, 400), radius=50, imovable=True)
+
+Planet(Vector2(400, 200), delta=Vector2(3, 0), radius=10)
+Planet(Vector2(400, 600), delta=Vector2(-3, 0), radius=10)
+```
+
+![enter image description here](https://maximmaeder.com/wp-content/uploads/2022/06/p1.gif)
+
+### Sun and four opposing Planets
+
+```python
+# Sun and four opposing Planets
+Planet(Vector2(400, 400), radius=50, imovable=True)
+
+Planet(Vector2(400, 200), delta=Vector2(3, 0), radius=10)
+Planet(Vector2(400, 600), delta=Vector2(-3, 0), radius=10)
+Planet(Vector2(600, 400), delta=Vector2(0, 3), radius=10)
+Planet(Vector2(200, 400), delta=Vector2(0, -3), radius=10)
+```
+
+![enter image description here](https://maximmaeder.com/wp-content/uploads/2022/06/p2.gif)
+
+### Two Suns and two planets
+
+```python
+# Two Suns and two planets
+Planet(Vector2(600, 400), radius=20, imovable=True)
+Planet(Vector2(200, 400), radius=20, imovable=True)
+
+Planet(Vector2(400, 200), delta=Vector2(0, 0), radius=10)
+Planet(Vector2(400, 210), delta=Vector2(1, 2), radius=5)
+```
+
+![enter image description here](https://maximmaeder.com/wp-content/uploads/2022/06/p3.gif)
+
+### Grid
+
+```python
+# Grid
+gridDimension = 10
+gridgap = 80
+for x in range(gridDimension):
+    for y in range(gridDimension):
+        Planet(Vector2(gridgap * x + 40, gridgap * y + 40), radius=3, imovable=True)
+
+Planet(Vector2(200, 200), delta=Vector2(randrange(-3, 3), 2), radius=5)
+```
+
+![enter image description here](https://maximmaeder.com/wp-content/uploads/2022/06/p4.gif)
+
+## Conclusion
+
+Excellent! You have successfully created a Planet Simulation using Python code! See how you can add more features to this program such as a UI to place planets or more settings for the planets.

Z/zipf-curve/texts/Planet Simulation with Python and Pygame.txt

@@ -0,0 +1,204 @@
+# Simple Text editor with Tkinter.
+**How to make a simple program capable of opening, editing, and saving text files.**
+
+## Idea
+We are going to make a simple text editor with the Tkinter module which comes with python so we don't have to install anything. It will have the following features.
+- Open text files.
+- Edit text files.
+- Save text files.
+- Open With (our Editor)
+
+## Imports
+We start by importing some Modules which we all later need. We import Everything from `Tkinter` so we have all the variables available and we also import the `scrolledText` and `filedialog` classes individually. The Scrolled text will be the Text Area where we write and the file dialog allows us to trigger the `askfileopen` window.
+
+```python
+# Import
+from tkinter import *
+from tkinter import scrolledtext
+from tkinter import filedialog
+```
+
+Next, we import ctypes to enable high DPI (Dots per inch) so our window looks sharper. Below the Code, you will find a comparison.
+
+```python
+import ctypes
+```
+**Low DPI**
+![enter image description here](https://i.imgur.com/hOyvTtq.png)
+
+**High DPI**
+![enter image description here](https://i.imgur.com/Z6MPMFD.png)
+
+Last but not least we import `sys` so we can analyze the arguments given through the command line. We later use this to enable *open with*.
+
+```python
+import sys
+```
+
+## Variable Setup
+Now we set up some variables for our little program. The first two variables are used to keep consistency when titling our program. The `currentFilePath` is used when saving the file so we know where to save it. This String will also be appended to the window title like many programs do to show what file is being edited. At last, we define which file types can be opened with our editor. We used this variable in the file dialogues.
+
+```python
+# Setup Variables
+appName = 'Simple Text Editor'
+nofileOpenedString = 'New File'
+
+currentFilePath = nofileOpenedString
+
+# Viable File Types, when opening and saving files.
+fileTypes = [("Text Files","*.txt"), ("Markdown","*.md")]
+```
+
+## Tkinter Setup
+Next, we are going to set up the Tkinter window. To do that we make a new `Tk` object. After that, we give the window a title, and we use the variables we defined earlier. Because we have no file opened at the moment it will say `Simple Text Editor - New File`. We will also make it so an asterisk will be added in front of the file name so we know when we have unsaved changes. Then we set the initial window Dimensions in pixels with the `geometry` method of tkinter. Last but not least we set the first column to take up 100% of the space so our text area will be the full width.
+
+```python
+# Tkinter Setup
+window = Tk()
+
+window.title(appName + " - " + currentFilePath)
+
+# Window Dimensions in Pixel
+window.geometry('500x400')
+
+# Set the first column to occupy 100% of the width
+window.grid_columnconfigure(0, weight=1)
+```
+
+## Handler Functions
+Now we are going to set up two functions that are connected to some events called by tkiner widgets.
+
+### File Actions
+The first function is called when we press any of the file buttons so we can save open and make new files. Later you will see how we connect them. We have to get the `currentFilePath` because it was defined outside this function. Our function will take one argument namely the action, which defines what we want to do. We will check for this argument and do stuff dependent on that.
+
+So if the action is `open` we will trigger an `askopenfilename` through the dialog class. We supply it with the filetypes we defined earlier so the user will only be able open these file types. After we chose the file, the function will return the path of the file. Then we set the Window Title to our `appName - File Path`. After that, we set our `currentFilePath` to this file path. Now we just open the file and insert the content into our text area called `txt` after we cleared it with the `delete` method.
+
+```python
+# Handler Functions
+def fileDropDownHandeler(action):
+    global currentFilePath
+
+    # Opening a File
+    if action == "open":
+        file = filedialog.askopenfilename(filetypes = fileTypes)
+
+        window.title(appName + " - " + file)
+
+        currentFilePath = file
+
+        with open(file, 'r') as f:
+            txt.delete(1.0,END)
+            txt.insert(INSERT,f.read())
+```
+
+If the action is `new` we will set the file path to `New File`. Then we also delete the text in the text area and we reset the window title.
+
+```python
+    # Making a new File
+    elif action == "new":
+        currentFilePath = nofileOpenedString
+        txt.delete(1.0,END)
+        window.title(appName + " - " + currentFilePath)
+```
+Last but not least we will check for `save` or `saveAs`. Now if the file is new or we pressed the Save As button we will ask the user where he wants to save the file. Then we open the file and save the text from the text area there. After that, we reset the window title because there probably was an asterisk.
+```python
+    # Saving a file
+    elif action == "save" or action == "saveAs":
+        if currentFilePath == nofileOpenedString or action=='saveAs':
+            currentFilePath = filedialog.asksaveasfilename(filetypes = fileTypes)
+
+        with open(currentFilePath, 'w') as f:
+            f.write(txt.get('1.0','end'))
+
+        window.title(appName + " - " + currentFilePath)
+```
+
+### Text Change
+Now for a simple function. Whenever the text area is changed well call this function to simply add an asterisk in from of the current file Path to show the user that there are unsaved changes.
+
+```python
+def textchange(event):
+    window.title(appName + " - *" + currentFilePath)
+```
+
+## Widgets
+Now we are going to set up the Graphical Elements.
+
+### Text Area
+
+First, we set up the Text Area and set its height to 999 so it spans the full height. then we set its position through the `grid` method. `sticky=N+S+E+W` to tell the widget to grow in all directions when the user resizes the window. with the bind method, we say that whenever a key is pressed in the text area we call the `textchange` function.
+
+```python
+# Text Area
+txt = scrolledtext.ScrolledText(window, height=999)
+txt.grid(row=1,sticky=N+S+E+W)
+
+# Bind event in the widget to a function
+txt.bind('<KeyPress>', textchange)
+```
+
+### Menu
+
+Now set up our Dropdown menu for file interactions. We first make a new `Menu` which has the root window. Then we make a second one that has the root of the first menu. We set the `tearoff` to false so the user won't be able to `tearoff` this menu to have it as a separate window.
+
+Then we add commands to this menu with its `add_command` method. We have to supply this function with a label that represents the displayed text and a command which is then called function if the button is pressed. We need to make a `lambda` which calls our `fileDropDownHandler` function. We have to do this so we can supply our function with an argument. We can also add separators with the `add_seperator` method. In the end, we add this menu as a cascade to the menu button and we set this menu to be the main menu.
+
+```python
+# Menu
+menu = Menu(window)
+
+# set tearoff to 0
+fileDropdown = Menu(menu, tearoff=False)
+
+# Add Commands and and their callbacks
+fileDropdown.add_command(label='New', command=lambda: fileDropDownHandeler("new"))
+fileDropdown.add_command(label='Open', command=lambda: fileDropDownHandeler("open"))
+
+# Adding a seperator between button types.
+fileDropdown.add_separator()
+fileDropdown.add_command(label='Save', command=lambda: fileDropDownHandeler("save"))
+fileDropdown.add_command(label='Save as', command=lambda: fileDropDownHandeler("saveAs"))
+
+menu.add_cascade(label='File', menu=fileDropdown)
+
+# Set Menu to be Main Menu
+window.config(menu=menu)
+```
+
+## Open with
+
+Now we enable the user to open a file directly with our program with this little code snippet. We check if the system argument length equates to two we know that the second argument is the path of the desired file. So we now set the `currentFilePath` to this path. After that, we do essentially the same as with the open with handler function.
+
+```python
+# Enabling "open with" by looking if the second argument was passed.
+if len(sys.argv) == 2:
+    currentFilePath = sys.argv[1]
+
+    window.title(appName + " - " + currentFilePath)
+
+    with open(currentFilePath, 'r') as f:
+        txt.delete(1.0,END)
+        txt.insert(INSERT,f.read())
+```
+
+## Main Loop
+In the end we also call the main loop method on the window so the window even displays. Without this, it would not work.
+
+```python
+# Main Loop
+window.mainloop()
+```
+
+## Showcase
+
+Now you will see how the program works in a short gif.
+![enter image description here](https://i.imgur.com/hsKSEg4.gif)m capable of opening, editing and saving text files.**
+
+## Idea
+
+## Imports
+
+
+```python
+pass
+```

Z/zipf-curve/texts/Simple Text editor with Tkinter.txt

@@ -0,0 +1,103 @@
+# Imports
+import os
+from matplotlib import pyplot as plt
+import string
+import numpy as np
+from scipy.interpolate import make_interp_spline
+
+# define some dictionaries
+texts = {}
+textlengths = {}
+textwordamounts = {}
+
+unwantedCharacters = list(string.punctuation)
+
+# How many ranks well show
+depth = 10
+xAxis = [str(number) for number in range(1, depth+1)]
+
+# Getting all files in text folder
+filePaths = os.listdir('texts')
+
+# Getting text from .txt files in folder
+for path in filePaths:
+    with open(os.path.join('texts', path), 'r', encoding='UTF-8') as f:
+        texts[path.split('.')[0]] = f.read()
+
+
+# Cleaning and counting the Text
+for text in texts:
+    # Remove unwanted characters from the texts
+    for character in unwantedCharacters:
+        texts[text] = texts[text].replace(character, '').lower()
+
+    splittedText = texts[text].split(' ')
+
+    # Saving the text length to show in the label of the line later
+    textlengths[text] = len(splittedText)
+
+    # Here will be the amount of occurence of each word stored
+    textwordamounts[text] = {}
+
+    # Loop through all words in the text
+    for i in splittedText:
+
+        # Add to the word at the given position if it already exists
+        # Else set the amount to one essentially making a new item in the dict
+        if i in textwordamounts[text].keys():
+            textwordamounts[text][i] += 1
+        else:
+            textwordamounts[text][i] = 1
+
+    # Sorting the dict by the values with sorted
+    # define custom key so the function knows what to use when sorting
+    textwordamounts[text] = dict(
+        sorted(
+            textwordamounts[text ].items(),
+            key=lambda x: x[1],
+            reverse=True)[0:depth]
+        )
+
+# Get the percentage value of a given max value
+def percentify(value, max):
+    return round(value / max * 100)
+
+# Generate smooth curvess
+def smoothify(yInput):
+
+    x = np.array(range(0, depth))
+    y = np.array(yInput)
+
+    # define x as 600 equally spaced values between the min and max of original x
+    x_smooth = np.linspace(x.min(), x.max(), 600) 
+
+    # define spline with degree k=3, which determines the amount of wiggle
+    spl = make_interp_spline(x, y, k=3)
+    y_smooth = spl(x_smooth)
+
+    # Return the twe x and y axis
+    return x_smooth, y_smooth
+
+# Make the perfect Curve
+ziffianCurveValues = [100/i for i in range(1, depth+1)]
+
+x, y = smoothify(ziffianCurveValues)
+
+plt.plot(x, y, label='Ziffian Curve', ls=':', color='grey')
+
+
+# Plot the texts
+for i in textwordamounts:
+    maxValue = list(textwordamounts[i].values())[0]
+
+    yAxis = [percentify(value, maxValue) for value in list(textwordamounts[i].values())]
+
+    x, y = smoothify(yAxis)
+
+    plt.plot(x, y, label=i+f' [{textlengths[i]}]', lw=1, alpha=0.5)
+
+plt.xticks(range(0, depth), xAxis)
+
+plt.legend()
+plt.savefig('wordamounts.png', dpi=300)
+plt.show()

Z/zipf-curve/wordamounts.png

@@ -0,0 +1,7 @@
+# To run this:
+- `pip3 install -r requirements.txt`
+- Cracking `secret.zip` file with the password list in `wordlist.txt` file, use the following command:
+    ```
+    python zip_cracker.py secret.zip wordlist.txt
+    ```
+- For a bigger list, consider downloading [rockyou](https://github.com/brannondorsey/naive-hashcat/releases/download/data/rockyou.txt) wordlist.

Z/zipf-curve/zipf_curve.py

@@ -0,0 +1 @@
+tqdm

Z/zipfile-cracker/README.md

@@ -0,0 +1,25 @@
+from tqdm import tqdm
+
+import zipfile
+import sys
+
+# the password list path you want to use
+wordlist = sys.argv[2]
+# the zip file you want to crack its password
+zip_file = sys.argv[1]
+# initialize the Zip File object
+zip_file = zipfile.ZipFile(zip_file)
+# count the number of words in this wordlist
+n_words = len(list(open(wordlist, "rb")))
+# print the total number of passwords
+print("Total passwords to test:", n_words)
+with open(wordlist, "rb") as wordlist:
+    for word in tqdm(wordlist, total=n_words, unit="word"):
+        try:
+            zip_file.extractall(pwd=word.strip())
+        except:
+            continue
+        else:
+            print("[+] Password found:", word.decode().strip())
+            exit(0)
+print("[!] Password not found, try other wordlist.")