https://github.com/itsjordanmuller/2023-python-100-days
Self-Paced Learning Sandbox for Python with Virtual Environments, Tkinter, Turtle Graphics, Flask, Jupyter Notebooks, HTML & CSS
https://github.com/itsjordanmuller/2023-python-100-days
css flask html ipynb jupyter-notebook python tkinter turtle-graphics virtual-environments
Last synced: 5 months ago
JSON representation
Self-Paced Learning Sandbox for Python with Virtual Environments, Tkinter, Turtle Graphics, Flask, Jupyter Notebooks, HTML & CSS
- Host: GitHub
- URL: https://github.com/itsjordanmuller/2023-python-100-days
- Owner: itsjordanmuller
- License: other
- Created: 2023-08-13T03:06:27.000Z (almost 3 years ago)
- Default Branch: main
- Last Pushed: 2024-01-13T06:03:29.000Z (over 2 years ago)
- Last Synced: 2025-01-12T17:09:16.602Z (over 1 year ago)
- Topics: css, flask, html, ipynb, jupyter-notebook, python, tkinter, turtle-graphics, virtual-environments
- Language: HTML
- Homepage:
- Size: 129 MB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
100 Days of Python
100 Days of Python Lessons, Exercises & Projects. A Self-Paced Learning Sandbox for Python with NumPy, Pandas, Jupyter, Flask, matplotlib, Plotly, scikit-learn, SQLite, SQLAlchemy, Environment Variables, PyPi, Virtual Environments, Prettier, Black Formatter, Visual Studio Code, Git & GitHub
[](https://jordanmuller.com/portfolio/tags/python/)
[](https://jordanmuller.com/portfolio/tags/flask/)
[](https://jordanmuller.com/portfolio/tags/sqlite/)
[](https://jordanmuller.com/portfolio/tags/sql-alchemy/)
[](https://jordanmuller.com/portfolio/tags/matplotlib/)
[](https://jordanmuller.com/portfolio/tags/jinja/)
[](https://jordanmuller.com/portfolio/tags/num-py/)
[](https://jordanmuller.com/portfolio/tags/pandas/)
[](https://jordanmuller.com/portfolio/tags/plotly/)
[](https://jordanmuller.com/portfolio/tags/redis/)
[](https://jordanmuller.com/portfolio/tags/scikit-learn/)
[](https://jordanmuller.com/portfolio/tags/sci-py/)
[](https://jordanmuller.com/portfolio/tags/seaborn/)
[](https://jordanmuller.com/portfolio/tags/selenium/)
More Technologies 📀
[](https://jordanmuller.com/portfolio/tags/html/)
[](https://jordanmuller.com/portfolio/tags/css/)
[](https://jordanmuller.com/portfolio/tags/javascript/)
[](https://jordanmuller.com/portfolio/tags/dotenv/)
[](https://jordanmuller.com/portfolio/tags/bash/)
[](https://jordanmuller.com/portfolio/tags/beautiful-soup/)
[](https://jordanmuller.com/portfolio/tags/black-formatter/)
[](https://jordanmuller.com/portfolio/tags/bootstrap/)
[](https://jordanmuller.com/portfolio/tags/colorgram/)
[](https://jordanmuller.com/portfolio/tags/json/)
[](https://jordanmuller.com/portfolio/tags/jupyter/)
[-6F1E51?style=for-the-badge&logo=python&logoColor=ffffff)](https://jordanmuller.com/portfolio/tags/pillow-pil/)
[](https://jordanmuller.com/portfolio/tags/prettier/)
[](https://jordanmuller.com/portfolio/tags/postman/)
[](https://jordanmuller.com/portfolio/tags/pyperclip/)
[](https://jordanmuller.com/portfolio/tags/py-pi/)
[](https://jordanmuller.com/portfolio/tags/requests/)
[](https://jordanmuller.com/portfolio/tags/kubuntu/)
[](https://jordanmuller.com/portfolio/tags/kde/)
[](https://jordanmuller.com/portfolio/tags/ubuntu/)
[](https://jordanmuller.com/portfolio/tags/debian/)
[](https://jordanmuller.com/portfolio/tags/linux/)
[](https://jordanmuller.com/portfolio/tags/github/)
[](https://jordanmuller.com/portfolio/tags/git/)
[](https://jordanmuller.com/portfolio/tags/markdown/)
[](https://jordanmuller.com/portfolio/tags/vs-code/)
Glossary - Overview of Tools & Tech 💻
Overview of Technologies
| **Technology** | **Overview** | **Release Year** |
|:---:|:---:|:---:|
| [](https://jordanmuller.com/portfolio/tags/dotenv/)
[.env](https://web.archive.org/web/20190427235415/http://environmentvariables.org/) | Environment variables are determined values to provide the ability that can affect the way programs, applications and services will behave. We can use environment variables to affect and change the way our applications run. An environment variable is made up of a name/value pair, like this: API_KEY=1234567890. | [1979](https://en.wikipedia.org/wiki/Environment_variable) |
| [](https://jordanmuller.com/portfolio/tags/bash/)
[Bash](https://www.gnu.org/software/bash/) | Bash is a Unix shell and command language written by Brian Fox for the GNU Project as a free software replacement for the Bourne shell. First released in 1989, it has been used as the default login shell for most Linux distributions and it was one of the first programs Linus Torvalds ported to Linux, alongside GCC. | [1989](https://en.wikipedia.org/wiki/Bash_(Unix_shell)) |
| [](https://jordanmuller.com/portfolio/tags/beautiful-soup/)
[Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/) | Beautiful Soup is a Python package for parsing HTML and XML documents. It creates a parse tree for parsed pages that can be used to extract data from HTML, which is useful for web scraping. | [2004](https://en.wikipedia.org/wiki/Beautiful_Soup_(HTML_parser)) |
| [](https://jordanmuller.com/portfolio/tags/black-formatter/)
[Black Formatter](https://pypi.org/project/black/) | Black is the uncompromising Python code formatter. By using it, you agree to cede control over minutiae of hand-formatting. In return, Black gives you speed, determinism, and freedom from pycodestyle nagging about formatting. You will save time and mental energy for more important matters. | [2019](https://github.com/psf/black/releases) |
| [](https://jordanmuller.com/portfolio/tags/bootstrap/)
[Bootstrap](https://getbootstrap.com/) | Bootstrap is a free and open-source CSS framework directed at responsive, mobile-first front-end web development. It contains HTML, CSS and JavaScript-based design templates for typography, forms, buttons, navigation, and other interface components. | [2011](https://en.wikipedia.org/wiki/Bootstrap_(front-end_framework)) |
| [](https://jordanmuller.com/portfolio/tags/colorgram/)
[Colorgram](https://pypi.org/project/colorgram.py/) | Colorgram is a library for Python & JavaScript that lets you extract colors from images. Compared to other libraries, the colorgram algorithm’s results are more intense. | [2016](https://github.com/obskyr/colorgram.py) |
| [](https://jordanmuller.com/portfolio/tags/css/)
[CSS](https://www.w3.org/TR/CSS/#css) | Cascading Style Sheets is a style sheet language used for specifying the presentation and styling of a document written in a markup language such as HTML or XML. CSS is a cornerstone technology of the World Wide Web, alongside HTML and JavaScript. | [1996](https://en.wikipedia.org/wiki/CSS) |
| [](https://jordanmuller.com/portfolio/tags/debian/)
[Debian](https://www.debian.org/) | Debian, also known as Debian GNU/Linux, is a Linux distribution composed of free and open-source software and proprietary software developed by the community-supported Debian Project, which was established by Ian Murdock on August 16, 1993. | [1993](https://en.wikipedia.org/wiki/Debian) |
| [](https://jordanmuller.com/portfolio/tags/flask/)
[Flask](https://palletsprojects.com/p/flask/) | Flask is a micro web framework written in Python. It is classified as a microframework because it does not require particular tools or libraries. It has no database abstraction layer, form validation, or any other components where pre-existing third-party libraries provide common functions. | [2010](https://en.wikipedia.org/wiki/Flask_(web_framework)) |
| [](https://jordanmuller.com/portfolio/tags/git/)
[Git](https://git-scm.com/) | Git is a distributed version control system that tracks changes in any set of computer files, usually used for coordinating work among programmers who are collaboratively developing source code during software development. Its goals include speed, data integrity, and support for distributed, non-linear workflows. | [2005](https://en.wikipedia.org/wiki/Git) |
| [](https://jordanmuller.com/portfolio/tags/github/)
[GitHub](https://github.com/) | GitHub is a developer platform that allows developers to create, store, and manage their code. It uses Git software, providing the distributed version control of Git plus access control, bug tracking, software feature requests, task management, continuous integration, and wikis for every project. | [2008](https://en.wikipedia.org/wiki/GitHub) |
| [](https://jordanmuller.com/portfolio/tags/html/)
[HTML](https://html.spec.whatwg.org/) | HyperText Markup Language or HTML is the standard markup language for documents designed to be displayed in a web browser. It defines the content and structure of web content. It is often assisted by technologies such as Cascading Style Sheets and scripting languages such as JavaScript. | [1993](https://en.wikipedia.org/wiki/HTML) |
| [](https://jordanmuller.com/portfolio/tags/javascript/)
[JavaScript](https://ecma-international.org/publications-and-standards/standards/ecma-262/) | JavaScript frameworks, such as React Native, Ionic, NativeScript, and Apache Cordova, enable developers to build native and hybrid mobile apps for Android and iOS. Facebook, Google, Uber, and Instagram all use JavaScript to build their mobile apps. JS is fast, efficient, and straightforward. | [1995](https://en.wikipedia.org/wiki/JavaScript) |
| [](https://jordanmuller.com/portfolio/tags/jinja/)
[Jinja](https://palletsprojects.com/p/jinja/) | Jinja is a web template engine for the Python programming language. It was created by Armin Ronacher and is licensed under a BSD License. Jinja is similar to the Django template engine but provides Python-like expressions while ensuring that the templates are evaluated in a sandbox. | [2008](https://en.wikipedia.org/wiki/Jinja_(template_engine)) |
| [](https://jordanmuller.com/portfolio/tags/json/)
[JSON](https://www.json.org/json-en.html) | JSON is an open standard file format and data interchange format that uses human-readable text to store and transmit data objects consisting of attribute–value pairs and arrays. It is a common data format with diverse uses in electronic data interchange, including that of web applications with servers. | [2001](https://en.wikipedia.org/wiki/JSON) |
| [](https://jordanmuller.com/portfolio/tags/jupyter/)
[Jupyter](https://jupyter.org/) | Jupyter Notebook (formerly known as IPython Notebook) is an interactive web application for creating and sharing computational documents. The project was first named IPython and later renamed Jupyter in 2014. It is a fully open-source product, and users can use every functionality available for free. | [2015](https://en.wikipedia.org/wiki/Project_Jupyter) |
| [](https://jordanmuller.com/portfolio/tags/kde/)
[KDE](https://kde.org/) | KDE is an international free software community that develops free and open-source software. As a central development hub, it provides tools and resources that allow collaborative work on this kind of software. | [1996](https://en.wikipedia.org/wiki/KDE) |
| [](https://jordanmuller.com/portfolio/tags/kubuntu/)
[Kubuntu](https://kubuntu.org/) | Kubuntu is an official flavor of the Ubuntu operating system that uses the KDE Plasma Desktop instead of the GNOME desktop environment. As part of the Ubuntu project, Kubuntu uses the same underlying systems. Kubuntu shares the same repositories as Ubuntu and is released regularly on the same schedule as Ubuntu. | [2006](https://en.wikipedia.org/wiki/Kubuntu) |
| [](https://jordanmuller.com/portfolio/tags/linux/)
[Linux](https://kernel.org/) | Linux is a family of open-source Unix-like operating systems based on the Linux kernel, an operating system kernel first released on September 17, 1991, by Linus Torvalds. | [1991](https://en.wikipedia.org/wiki/Linux) |
| [](https://jordanmuller.com/portfolio/tags/markdown/)
[Markdown](https://daringfireball.net/projects/markdown/) | Markdown is a lightweight markup language for creating formatted text using a plain-text editor. John Gruber created Markdown in 2004 as a markup language that is easy to read in its source code form. | [2004](https://en.wikipedia.org/wiki/Markdown) |
| [](https://jordanmuller.com/portfolio/tags/matplotlib/)
[Matplotlib](https://matplotlib.org/) | Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python. Matplotlib makes easy things easy and hard things possible. Create publication quality plots. Make interactive figures that can zoom, pan, update. Customize visual style and layout. | [2003](https://en.wikipedia.org/wiki/Matplotlib) |
| [](https://jordanmuller.com/portfolio/tags/num-py/)
[NumPy](https://numpy.org/) | NumPy (Numerical Python) is an open source Python library that's used in almost every field of science and engineering. It's the universal standard for working with numerical data in Python, and it's at the core of the scientific Python and PyData ecosystems. | [1995](https://en.wikipedia.org/wiki/NumPy) |
| [](https://jordanmuller.com/portfolio/tags/pandas/)
[Pandas](https://pandas.pydata.org/) | Pandas is a software library written for the Python programming language for data manipulation and analysis. In particular, it offers data structures and operations for manipulating numerical tables and time series. It is free software released under the three-clause BSD license. | [2008](https://en.wikipedia.org/wiki/Pandas_(software)) |
| [-6F1E51?style=for-the-badge&logo=python&logoColor=ffffff)](https://jordanmuller.com/portfolio/tags/pillow-pil/)
[Pillow (PIL)](https://python-pillow.org/) | Python Imaging Library is a free and open-source additional library for the Python programming language that adds support for opening, manipulating, and saving many different image file formats. It is available for Windows, Mac OS X and Linux. | [1995](https://en.wikipedia.org/wiki/Python_Imaging_Library) |
| [](https://jordanmuller.com/portfolio/tags/plotly/)
[Plotly](https://plotly.com/) | Plotly's Python & JavaScript graphing libraries make interactive, publication-quality graphs. | [2012](https://en.wikipedia.org/wiki/Plotly) |
| [](https://jordanmuller.com/portfolio/tags/postman/)
[Postman](https://www.postman.com/) | Postman is an API platform for developers. The company is headquartered in San Francisco and maintains an office in Bangalore, where it was founded. As of February 2023, Postman reports having more than 30 million registered users and 75,000 open APIs, which it says constitutes the world's largest public API hub. | [2012](https://en.wikipedia.org/wiki/Postman_(software)) |
| [](https://jordanmuller.com/portfolio/tags/prettier/)
[Prettier](https://prettier.io/) | Prettier, known for its strong formatting opinions, supports a broad range of programming languages. It seamlessly integrates with the majority of code editors and offers a streamlined set of configuration options. | [2017](https://github.com/prettier/prettier/releases) |
| [](https://jordanmuller.com/portfolio/tags/pyperclip/)
[Pyperclip](https://pypi.org/project/pyperclip/) | Pyperclip is a cross-platform Python module for copy and paste clipboard functions. | [2014](https://github.com/asweigart/pyperclip) |
| [](https://jordanmuller.com/portfolio/tags/py-pi/)
[PyPI](https://pypi.org/) | PyPI, short for Python Package Index, is the official third-party package repository for the Python programming language. It is a central repository that hosts and distributes software packages for Python developers to use. Developers can upload Python packages to PyPI where they can be easily accessed by others. | [2003](https://en.wikipedia.org/wiki/Python_Package_Index) |
| [](https://jordanmuller.com/portfolio/tags/python/)
[Python](https://www.python.org/) | Python is a high-level, general-purpose programming language. Its design philosophy emphasizes code readability with the use of significant indentation. Python is dynamically typed and garbage-collected. It supports multiple programming paradigms, including structured, object-oriented and functional programming. | [1991](https://en.wikipedia.org/wiki/Python_(programming_language)) |
| [](https://jordanmuller.com/portfolio/tags/redis/)
[Redis](https://redis.io/) | Redis is an open-source in-memory storage, used as a distributed, in-memory key–value database, cache and message broker, with optional durability. | [2009](https://en.wikipedia.org/wiki/Redis) |
| [](https://jordanmuller.com/portfolio/tags/requests/)
[Requests](https://pypi.org/project/requests/) | Requests allows you to send HTTP/1.1 requests extremely easily. There’s no need to manually add query strings to your URLs, or to form-encode your POST data. Keep-alive and HTTP connection pooling are 100% automatic, thanks to urllib3. | [2011](https://github.com/psf/requests) |
| [](https://jordanmuller.com/portfolio/tags/scikit-learn/)
[scikit-learn](https://scikit-learn.org/stable/) | scikit-learn (formerly scikits.learn and also known as sklearn) is a free software machine learning library for the Python programming language. features various classification, regression and clustering algorithms including support-vector machines, random forests, gradient boosting, k-means and DBSCAN, and is designed to interoperate with the Python numerical and scientific libraries NumPy and SciPy. | [2007](https://en.wikipedia.org/wiki/Scikit-learn) |
| [](https://jordanmuller.com/portfolio/tags/sci-py/)
[SciPy](https://scipy.org/) | SciPy is a free and open-source Python library used for scientific computing and technical computing. SciPy contains modules for optimization, linear algebra, integration, interpolation, special functions, FFT, signal and image processing, ODE solvers and other tasks common in science and engineering. | [2001](https://en.wikipedia.org/wiki/SciPy) |
| [](https://jordanmuller.com/portfolio/tags/seaborn/)
[Seaborn](https://seaborn.pydata.org/) | Seaborn is a Python data visualization library based on matplotlib. It provides a high-level interface for drawing attractive and informative statistical graphics. | [2013](https://github.com/mwaskom/seaborn) |
| [](https://jordanmuller.com/portfolio/tags/selenium/)
[Selenium](https://www.selenium.dev/) | Selenium is an open source umbrella project for a range of tools and libraries aimed at supporting browser automation. It provides a playback tool for authoring functional tests across most modern web browsers, without the need to learn a test scripting language. | [2004](https://en.wikipedia.org/wiki/Selenium_(software)) |
| [](https://jordanmuller.com/portfolio/tags/sql-alchemy/)
[SQLAlchemy](https://www.sqlalchemy.org/) | SQLAlchemy is a popular SQL toolkit and Object Relational Mapper. It is written in Python and gives full power and flexibility of SQL to an application developer. It is an open source and cross-platform software released under MIT license. | [2006](https://en.wikipedia.org/wiki/SQLAlchemy) |
| [](https://jordanmuller.com/portfolio/tags/sqlite/)
[SQLite](https://sqlite.org/index.html) | SQLite is an embedded, server-less relational database management system. It is an in-memory open-source library with zero configuration and does not require any installation. Also, it is very convenient as it's less than 500kb in size, which is significantly lesser than other database management systems. | [2000](https://en.wikipedia.org/wiki/SQLite) |
| [](https://jordanmuller.com/portfolio/tags/ubuntu/)
[Ubuntu](https://ubuntu.com/) | Ubuntu is a Linux distribution based on Debian and composed mostly of free and open-source software. Ubuntu is officially released in multiple editions: Desktop, Server, and Core for Internet of things devices and robots. | [2004](https://en.wikipedia.org/wiki/Ubuntu) |
| [](https://jordanmuller.com/portfolio/tags/vs-code/)
[VS Code](https://code.visualstudio.com/) | Visual Studio Code is a streamlined code editor with support for development operations like debugging, task running, and version control. It aims to provide just the tools a developer needs for a quick code-build-debug cycle and leaves more complex workflows to fuller featured IDEs, such as Visual Studio IDE. | [2015](https://en.wikipedia.org/wiki/Visual_Studio_Code) |
Table of Contents 🗃️
- 💌 Special Thanks
📖 About The Project
📂 Project Introduction
In 2023, I started the 100 Days of Code: The Complete Python Pro Bootcamp for 2023, led by Dr. Angela Yu. This intensive course was a deep dive into Python, offering a unique blend of building 100 projects over 100 days. It covered a vast range of topics from web and app development to data science and machine learning. The hands-on approach of the course meant that every day was a new opportunity to develop practical skills and apply Python in various real-world scenarios, such as game development, web scraping, and data analysis.
⛳ Learning Objectives & Goals
My goal in joining this course was to gain a comprehensive and practical understanding of Python. I aimed to learn not just the syntax, but also how to apply Python in diverse areas like automation, building websites, and data science. Mastering tools like Selenium, Flask, Pandas, and NumPy was also part of my learning objectives. By the end of the course, I was looking to not only be proficient in Python but also have a portfolio of 100 projects, showcasing my skills in various aspects of Python programming.
🗓️ Project Timeline
I started this Python journey on August 12th, 2023. The course was structured to learn and build a project each day, dedicating an hour daily. Starting with foundational Python concepts, I quickly moved on to more complex applications, including web development, automation, and data science. This steady progression allowed me to reinforce learning with practical implementation, ensuring a deep understanding of Python and its real-world applications. By the end of the 100 days, I had not only mastered Python but also created a diverse range of projects, from games like Blackjack and Pong to a fully fledged blog website.
💡 Usage Guide
🚀 Getting Started
Looking for Live Demos? 🌐
If you're eager to simply see the results of this project, most, if not all of the projects have a Live Demo associated with them. I have linked them all in the overview for each specific project/section. To view these live demos, simply follow the links provided with each project. You'll see them alongside buttons that look like this:
Click the button/link and you should be taken to the Live Demo for that specific project. Please note that some projects don't have a Live Demo, and if that's the case there will not be a button/link. I'm hoping to get all of the projects on the internet at some point in the near future, so check back soon and you might find a link!
Want to View the Projects on Your Local Machine? 💻
I have provided detailed instructions for how to clone/download this repository to your local machine in the Setup Instructions section. In that section, you should find everything you need to be able to get these projects running and working on your own machine. Please note that a few of the projects use external APIs that include verification, so you will need to setup your own accounts/API keys for those services.
If you plan on running the code on your local machine, be sure to check the specific project you're trying to run to see if it needs any additional information or setup for the connections to the API to work. In most cases, I will try to include a `.env.example` file. You will need to open this file, and read the instructions inside to obtain your own API key. Once that's done, you'll need to make sure you've renamed the file from `.env.example` to `.env` only.
If you want to avoid setting up environment variables, check to see if the project has a Live Demo associated with it. For all of the projects that I have hosted on the internet, you'll be able to use them without any API configuration required. This is often a simpler way of viewing more complicated projects, since everything will already be running for you to view, use & explore.
Just Hoping to Learn More About Programming? 📚
I have provided a variety of resources and guides throughout this README for new developers. From the absolute basics, to specific videos and guides that helped me get unstuck in certain situations, I tried to include every single resource I ended up utilizing over the course of my journey.
We are so lucky to live in a time where almost all of this information is available for free on the internet. The only thing I paid for was the course itself, which can be purchased for about $20 on sale at Udemy. Besides that, I was able to complete the project with a low-spec Lenovo Thinkpad T480 I purchased for just under $300. It's proven to be a perfect machine for development & running Kubuntu Linux.
A full list of tech, tools, and other links & resources can be found towards the bottom of this README in the Links & Citations section.
💾 Installation
For detailed installation instructions, please refer to the Setup Instructions section below.
🛠️ Setup Instructions
📋 Prerequisites
Required Software 💽
To be able to clone/download & view these projects, or to start learning Python as well as programming in general, you'll need a few essential tools. At a minimum, you should have a basic text editor/integrated development environment, a web browser, and an internet connection.
I used the following:
- **Text Editor/IDE:** I use [Visual Studio Code](https://code.visualstudio.com/) as my main integrated development environment. VS Code can be customized to work with just about any technology, making it a great choice for a general all-purpose IDE, it also has a large and helpful community for support.
- **Web Browser:** I prefer to use [Google Chrome](https://www.google.com/chrome/) for their comprehensive set of [Chrome DevTools](https://developers.google.com/web/tools/chrome-devtools/). While most if not all of the tools are available in other browsers/Developer Tools such as [Firefox DevTools](https://firefox-source-docs.mozilla.org/devtools-user/index.html), [Safari Web Inspector](https://webkit.org/web-inspector/), and [Edge DevTools](https://docs.microsoft.com/microsoft-edge/devtools-guide-chromium/landing/), I am most familiar & comfortable with the layout of Chrome.
- **Internet Connection:** Aim to have at least 2-3 Mbps or more to speed up development, especially if you'll be downloading large files or loading video/image based resources. Most libraries and a variety of public places can have high-speed Wi-Fi available for visitors free-of-charge.
Based on the fact that you're reading this right now, you probably already have a browser & internet connection!
[Windows](https://www.microsoft.com/en-us/windows), [macOS](https://www.apple.com/macos/), and most [Linux distributions](https://en.wikipedia.org/wiki/Linux_distribution) should include a text editor by default, which in this case should be more than enough to view and edit HTML, CSS & JavaScript files.
For those using mobile devices, I advise switching to a laptop or desktop for a more streamlined experience. While mobile development is feasible on Android or iOS, the ease of a full-sized computer, keyboard, and mouse is unmatched. Visual Studio Code is accessible via most browsers on any device, however, you would still need to serve/host it from another machine. For optimal functionality, a personal computer remains the best choice.
System Requirements 🖥️
System requirements for these projects can vary due to the fact that they use different amounts of client-side processing power and resources. In general, a recent operating system like [Windows](https://www.microsoft.com/en-us/windows), [macOS](https://www.apple.com/macos/), or a popular [Linux distribution](https://en.wikipedia.org/wiki/Linux_distribution) usually suffices. Modern computers, especially those purchased in the last few years, should meet these needs adequately.
Performance will heavily rely on your specific hardware setup, including processor speed, RAM capacity, storage type, and graphics card quality. The operating system choice and its configuration also play a significant role in speed.
To give you a practical example, I personally used a [Lenovo Thinkpad T480](https://www.amazon.com/dp/B0842X4BNF) for the entirety of my recent projects. This laptop, has been great for a variety of daily tasks, including programming.
The computer I used for the entire project features the following specifications:
- **Operating System:** [Kubuntu Linux 22.04](https://cdimage.ubuntu.com/kubuntu/releases/22.04/release/)
- **Processor:** 8th Gen Intel Core Duo i5-8350U
- **RAM:** 16GB DDR4 RAM
- **Storage:** 512GB SSD of data
- **Graphics:** Intel UHD Graphics 620
- **Display:** 14.0" Screen with FHD 1920x1080 resolution.
This configuration was more than sufficient for both my project and other tasks. Interestingly, working on a less powerful laptop has its advantages, such as highlighting inefficient code that consumes excessive resources.
If you're unsure, I recommend testing your setup with the intended software. Should you encounter any errors, feel free to reach out for assistance. Your feedback can also help in making projects more adaptable to diverse hardware, operating systems, and browsers.
📦 Installation Guide
Download/Clone This Repo ⬇️
Below you will find various methods that are available to download/clone this repository.
Feel free to use whichever option you are most comfortable & familiar with. You can also read GitHub's guide on [downloading source code archives](https://docs.github.com/en/repositories/working-with-files/using-files/downloading-source-code-archives) & [cloning repositories](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository).
| 💡 Download Method Details |
|:--|
Clone with SSH ★
1. **Ensure SSH Key Setup**: Before you can clone with SSH, make sure you have an SSH key set up and added to your GitHub account. If you haven't done this, refer to GitHub's documentation on setting up a new SSH key.
2. **Copy SSH URL**: Navigate to the repository on GitHub. Click the 'Code' button and switch to the 'SSH' tab in the dropdown menu. Click the clipboard icon to copy the SSH URL.
3. **Open Terminal or Command Prompt**: Open your terminal or command prompt. Navigate to the directory where you want the cloned repository to be placed.
4. **Run Clone Command**: Type `git clone` followed by the copied SSH URL. For this project, that's:
```
git clone git@github.com:itsjordanmuller/2023-python-100-days.git
```
5. **Access Cloned Repository**: Once the cloning process is complete, you will have a local copy of the repository. Navigate into the newly created directory to access the repository files.
Note: Cloning with SSH is secure and allows for easy repository updates without repeatedly entering credentials.
Download ZIP File
1. **Navigate to the Repository**: Open your web browser and go to the main page of the repository.
2. **Find the 'Code' Button**: On the repository's main page, locate the 'Code' button. This is usually found near the top right, just above the file list.
3. **Download ZIP Option**: Click on the 'Code' button. A dropdown menu will appear. Select the 'Download ZIP' option from this menu.
4. **Save the ZIP File**: Choose a location on your computer where you want to save the ZIP file and confirm the download.
5. **Extract Files**: Once the download is complete, navigate to the downloaded file. Right-click on the ZIP file and select 'Extract All...' or use your preferred extraction tool. Choose where you want the extracted folder to be placed.
6. **Access Repository Contents**: Open the extracted folder to access the contents of the repository.
Note: Downloading a ZIP file is a great way to get a copy of the repository without using Git commands.
Clone with HTTPS
1. **Copy HTTPS URL**: Go to the GitHub page of the repository. Click on the 'Code' button. Under the dropdown menu, select the 'HTTPS' tab and click the clipboard icon to copy the HTTPS URL.
2. **Open Terminal or Command Prompt**: Access your terminal (Linux/Mac) or command prompt (Windows). Navigate to the directory where you want the repository to be cloned.
3. **Execute Clone Command**: Type `git clone` followed by the copied HTTPS URL. In this case:
```
git clone https://github.com/itsjordanmuller/2023-python-100-days.git
```
4. **Enter GitHub Credentials**: If prompted, enter your GitHub username and password. This step is usually required the first time you use HTTPS to clone a repository.
5. **Access Cloned Repository**: After the cloning process completes, a local copy of the repository will be created. Navigate into the directory that was just created to start working with the files.
Note: HTTPS cloning is straightforward but may require you to enter your GitHub credentials more frequently compared to SSH.
Clone with GitHub CLI
The GitHub CLI (`gh`) provides a convenient way to interact with GitHub from your command line. Here’s how to use `gh` to clone the repository `itsjordanmuller/2023-python-100-days`:
1. **Install GitHub CLI**: If you haven't already, you need to install the GitHub CLI. You can find installation instructions on the [official GitHub CLI page](https://cli.github.com/).
2. **Authenticate GitHub CLI**: Open your terminal and authenticate the GitHub CLI using the command `gh auth login`. Follow the prompts to complete the authentication process.
3. **Clone the Repository**: To clone this repository, use the following command:
```
gh repo clone itsjordanmuller/2023-python-100-days
```
This command will clone the repository into a new directory named `2023-python-100-days` in your current working directory.
4. **Navigate to the Repository**: Once the cloning process is complete, navigate into the repository directory with:
```
cd 2023-python-100-days
```
5. **Start Working**: You now have a local copy of the repository and can begin working on it.
Note: The GitHub CLI streamlines various GitHub operations and is particularly useful for those who prefer command-line tools.
★ When I have the option, I personally prefer to use the `Clone with SSH` method. Alternatively, `Download ZIP File` can be a quick and easy way to simply download the files without a terminal or Git.
⚙️ Configuration
API Keys/Environment Variables 🔐
🔍 Sections & Projects
## Day 1
### Projects (Day 1)
#### [1. Band Name Generator](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-001/Projects/band-name-generator.py)
> Ask use to input `city` and `pet`
>
> The user begins to input their city name: "San Francisco"
In this exercise, I created an "Automatic Band Name Generator" using Python. This program is an enjoyable way to use simple string concatenation to generate creative names.
The script begins by welcoming the user and explaining what the program does. It then prompts the user for two pieces of information: the name of the city or town they grew up in, and the name of a beloved pet.
> Concatenate `city` and `pet` name to generate and print a band name
>
> City Name: "San Francisco"
> Pet Name: "Scout"
> Band Name: "The San Francisco Scouts"
After receiving this input, the program combines these two strings, adding an 's' to the end of the pet's name to craft a band name. It then displays this generated band name to the user in a friendly message.
This exercise taught me how to solicit user input, concatenate strings to form a new string, and display the result to the user.
### Exercises (Day 1)
#### [A. Hello World](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-001/Exercises/0-hello-world.py)
In this exercise, I learned about handling user input, string manipulation, and outputting data. I used the `input()` function to prompt for and receive the user's name. This taught me how to interact with users and capture their responses in a program.
Next, I used the `len()` function to calculate the length of the entered name, which showed me how to work with string properties and perform basic calculations. Finally, I printed both the name and its length to the console, reinforcing my understanding of how to display output in Python.
#### [B. Printing](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-001/Exercises/1-printing.py)
This exercise involved printing text to the console, a fundamental skill in many language, not just Python. I learned how to structure the `print` function and the syntax for outputting strings.
I printed multiple lines, each demonstrating a different aspect of the print function. Starting with a basic introduction line, I moved on to describe how the function is declared, and then displayed an example of the `print` function in action. This helped me understand the basics of displaying text in Python, a key component in many programming tasks.
#### [C. Debugging Practice](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-001/Exercises/2-debugging-practice.py)
In this exercise, I focused on debugging Python code, specifically addressing syntax errors in string manipulation and print statements. I encountered issues like a missing quotation mark, inconsistent use of single and double quotes, and an indentation error.
By correcting these errors, I practiced paying close attention to syntax details, the nuances between single and double quotes, and how proper indentation is crucial. This task was a practical lesson in troubleshooting and refining my understanding of Python syntax, particularly in relation to string handling and output formatting.
#### [D. Input Function](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-001/Exercises/3-input-function.py)
In this exercise, I learned to use the `input()` function to capture user input and the `len()` function to calculate the length of a string.
The program first prompts the user to enter their name, storing the response in variable `a`. Then, it calculates and prints the length of the inputted name using `len(a)`.
This demonstrated how to interact with users and process their input, as well as basic string manipulation.
#### [E. Variables](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-001/Exercises/4-variables.py)
The challenge of this exercise was to swap the values of two variables without altering the given input and output code sections.
Initially, the program collected user inputs for variables `a` and `b`. My task was to write code in the designated area to swap the values of these two variables.
To achieve this, I introduced two new variables, `export_a` and `export_b`, to temporarily hold the values of `a` and `b`. Then, I reassigned the values of a and b by swapping them using the temporary variables.
The final output then reflected the swapped values, demonstrating successful variable manipulation. Through this exercise, I learned a practical application of variables.
## Day 2
### Projects (Day 2)
#### [2. Tip Calculator](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-002/Projects/tip-calculator.py)
> Ask user to input values for `total_bill`, `tip_input` and `num_people` to provide a `cost_per_person` when evenly split
>
> Total Bill: $150
> Tip Input: 12%
> Number of People: 5
> Split Amount: $33.60
In this exercise, I built a "Tip Calculator" in Python. The program is designed to evenly split a restaurant bill, including a tip, among a group of people.
The script starts by displaying a simple heading, "Tip Calculator". It then asks the user for the total bill amount, the percentage of the tip they wish to give, and the number of people splitting the bill. For the tip percentage, it offers the user common options of 10, 12, or 15 percent.
I learned to perform the following tasks in this exercise:
- Prompting the user for input and storing these inputs using the `input()` function.
- Converting string inputs to floats for the bill and tip percentage, and to an integer for the number of people.
- Calculating the tip by converting the percentage into a decimal and adding it to the total bill amount.
- Dividing the total bill by the number of people to get the amount each person should pay.
- Rounding the result to two decimal places for currency formatting.
- Finally, I learned to print out the result in a user-friendly format using an f-string.
Through this task, I gained a practical understanding of user input handling, type conversion, arithmetic calculations, and string formatting in Python. It showed me how to use Python to solve real-world problems, like splitting a restaurant bill.
### Exercises (Day 2)
#### [A. Primitive Data Types](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-002/Exercises/0-primitive-data-types.py)
In this exercise, I focused on different primitive data types and their operations. I worked with strings, accessing and manipulating characters, integers and floats, performing basic arithmetic operations, and understanding the nuances of different number types.
A significant part of the exercise was learning about type conversion, such as changing integers to strings or strings to floats. I used the `type()` function for identifying data types. The exercise also covered Python's order of operations (PEMDAS), including standard division, floor division, and rounding numbers.
Finally, I practiced incrementing variables and formatting strings to include multiple variables, enhancing my understanding of Python's data handling and string formatting capabilities.
#### [B. Data Types](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-002/Exercises/1-data-types.py)
In this exercise, I worked on manipulating and calculating with string and integer data types in Python. The challenge was to take a two-digit number as a string input, extract each digit, convert them into integers, and then sum them.
After capturing the two-digit number as a string input, I extracted the first and second digits using indexing. Then, I converted these string digits into integers using the `int()` function. Finally, I added these two integer values together and printed the result.
This exercise taught me about string indexing, type conversion from strings to integers, and basic arithmetic operations in Python. It was a practical application of combining several fundamental programming concepts.
#### [C. BMI Calculator](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-002/Exercises/2-bmi-calculator.py)
> Ask user to input values for `height` and `weight` to return the `bmi` as an integer
>
> 1.77 meters and 71 kilograms returns a BMI of 22
In this exercise, I developed a basic BMI (Body Mass Index) calculator in Python. The program begins by asking the user to input their height in meters and weight in kilograms.
To calculate the BMI, I first converted the height and weight inputs from strings to floats using the `float()` function. Then, I applied the BMI formula, which is weight divided by height squared. Finally, I converted the resulting BMI value to an integer using the `int()` function for a cleaner output and printed the result.
This task was a practical application of input handling, type conversion, arithmetic operations, and output formatting in Python. It demonstrated how to build a simple yet functional tool using basic programming concepts.
#### [D. Life in Weeks](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-002/Exercises/3-life-in-weeks.py)
> Ask user to input current `age` to calculate `years_remaining` in life and then print the `days_remaining`, `weeks_remaining`, and `months_remaining`
>
> 25 years of age currently leaves you with 780 months, AKA 3,380 weeks or 23,725 days, depending on which you prefer
In this exercise, I created a program to calculate the time a person has left in days, weeks, and months, assuming they live up to 90 years old. The user inputs their current age, and the program computes the remaining time.
First, I converted the user's age from a string to an integer. Then, I calculated the years remaining by subtracting the user's age from 90. Using this value, I determined the months, weeks, and days left by multiplying the years remaining with the number of months, weeks, and days in a year, respectively.
The final output was formatted using a Python f-string to neatly display the calculated days, weeks, and months remaining. This exercise taught me about basic arithmetic operations, type conversion, and string formatting in Python, along with providing a practical application of these skills.
## Day 3
### Projects (Day 3)
#### [3. Treasure Island - Choose Your Adventure CLI Game](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-003/Projects/treasure-island.py)
> Ask user for a `direction`, depending on direction, offer the different options.
In this Python exercise, I created a text-based adventure game named "Treasure Island." This task was an engaging blend of storytelling and programming, with a strong emphasis on conditional logic.
The game begins with an impressive ASCII art display, setting a thematic tone for the adventure. The player is then introduced to their mission of finding treasure on the island.
At each step of the game, the player is prompted to make choices, guiding the narrative forward. The initial decision involves choosing a direction, which leads to different scenarios and further choices. Each decision point is structured using nested `if` statements, allowing the story to branch out based on the player's input.
> For certain directions, the program will ask for a `swim` input, or `door` if you get far enough...
The adventure is filled with intriguing situations and choices, each with its own unique outcome. The design of these scenarios effectively demonstrates the use of conditional logic in programming. It also highlights the importance of user input handling and string manipulation in creating an interactive and engaging user experience.
Overall, this exercise was a great practice in using Python to craft an interactive story, showcasing how decision-making structures can shape user-driven narratives in programming.
### Exercises (Day 3)
#### [A. Control Flow](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-003/Exercises/0-control-flow.py)
In this exercise, I learned about implementing control flow in Python using conditional statements. The program simulates a rollercoaster ticketing system that determines eligibility and ticket pricing based on the user's height and age.
The program starts by welcoming the user and asking for their height in centimeters. It then initializes a variable `bill` to 0, which will later be used to calculate the total ticket cost.
The first `if` statement checks if the user is tall enough to ride the rollercoaster (height >= 120 cm). If so, it proceeds to ask for the user's age to determine the ticket price:
- If the user is under 12 years old, they are charged $5.
- If the user is between 12 and 18 years old, they are charged $7.
- If the user is between 45 and 55 years old, they ride for free.
- All other ages are considered adults and are charged $12.
Next, the program asks if the user wants a photo taken. If the answer is "Y" for yes, an additional $3 is added to the bill.
Finally, the total bill is calculated and displayed. If the user is not tall enough to ride, the program prints a message indicating they cannot ride the rollercoaster.
#### [B. Odd or Even](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-003/Exercises/1-odd-or-even.py)
> Ask the user for a `number`, check if it's odd or even and then print the corresponding message
>
> 4 is an even number
> 7 is an odd number
In this exercise, I focused on creating a simple program in Python to determine if a number is odd or even. The program begins by prompting the user to input a number, which is then converted to an integer using the `int()` function.
The core of this program lies in the use of the modulus operator (`%`) to check if the number is odd or even. The modulus operator returns the remainder of a division operation. In this case, it checks the remainder of the number divided by 2.
The `if` statement checks if the remainder of the number divided by 2 is equal to 1 (`number % 2 == 1`):
- If true, it means the number is odd, and the program prints "This is an odd number."
- If false (i.e., the remainder is 0), it means the number is even, and the program prints "This is an even number."
This exercise was a straightforward yet effective demonstration of using the modulus operator to perform a common mathematical check in programming and covered essential concepts like input handling, type conversion, conditional statements, and basic arithmetic operations in Python.
#### [C. BMI Calculator V2 Upgrade](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-003/Exercises/2-bmi-calculator-v2.py)
> Ask user for `height` and `weight`, then calculate and return `bmi` integer along with a message that places the BMI into a descriptive category
>
> 1.77 meters tall and 71 kilograms = BMI of (23 - Normal Weight)
> 1.8 meters tall and 55 kilograms = BMI of (17 - Underweight)
In this exercise, I progressed to an advanced version of the BMI (Body Mass Index) Calculator (version 2), enhancing the functionality to provide more detailed feedback based on the BMI value. Compared to version 1, this version includes conditional statements to categorize the BMI result into different health categories.
Key changes and learnings in this version include:
1. **Immediate Type Conversion of Inputs**: Unlike version 1 where the height and weight inputs were initially taken as strings and then converted to floats, version 2 directly converts the user inputs to floats. This streamlines the code.
2. **Rounded BMI Calculation**: The BMI is calculated using the same formula as in version 1 (weight divided by height squared). However, in version 2, the `round()` function is used to round the BMI to the nearest whole number, providing a more user-friendly output.
3. **Conditional Statements for Health Categories**: The program uses a series of `if-elif-else` statements to categorize the BMI value:
- A BMI less than 18.5 is categorized as underweight.
- A BMI from 18.5 to less than 25 is considered normal weight.
- A BMI from 25 to less than 30 is categorized as slightly overweight.
- A BMI from 30 to less than 35 is considered obese.
- A BMI of 35 or more is categorized as clinically obese.
Each category triggers a specific print statement, providing the user with both their BMI value and the corresponding health category.
#### [D. Leap Year Checker](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-003/Exercises/3-leap-year.py)
> Ask the user for a `year`, check if it's a leap year or not and print the corresponding message
>
> 1993 is not a leap year
> 2024 is a leap year
In this exercise, I developed a program in Python to determine whether a given year is a leap year. The program employs nested conditional statements to apply the rules that define a leap year.
The process begins with prompting the user to input a year, which is then converted into an integer using the `int()` function.
The rules for determining a leap year are as follows:
1. **Divisible by 4**: The year must be evenly divisible by 4.
2. **Century Years**: If the year is a century (divisible by 100), it must also be divisible by 400 to be a leap year.
The program's logic is structured as:
- First, it checks if the year is divisible by 4. If not, it's not a leap year.
- If the year is divisible by 4, it then checks if it's a century year (divisible by 100).
- If it is a century year, it must also pass the check of being divisible by 400 to be considered a leap year.
- If it's not a century year, it is a leap year.
This arrangement of `if-else` statements within each other, known as nested conditional statements, effectively applies these rules. Based on these checks, the program prints either "Leap year." or "Not leap year." accordingly.
This exercise was an excellent demonstration of how nested conditional statements can be used to solve problems that require multiple layers of decision-making. It covered concepts like input handling, arithmetic operations with the modulus operator, and complex conditional logic in Python.
#### [E. Pizza Order Creator](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-003/Exercises/4-pizza-order.py)
> Ask user for `size`, and whether they'd like to `add_pepperoni` or `extra_cheese` to their pizza and calculate a total
>
> Large Pizza with Pepperoni and Extra Cheese is $29
> Small Pizza with Pepperoni and Regular Cheese is $17
In this exercise, I created a simple pizza order calculator in Python to demonstrate conditional logic and basic arithmetic operations. The program simulates a pizza ordering process, calculating the total cost based on the customer's choices.
The program begins by welcoming the user to "Python Pizza Deliveries" and prompts them to choose the size of the pizza (Small, Medium, or Large), whether they want pepperoni, and if they desire extra cheese.
The logic of the program is structured as follows:
1. **Base Price for Pizza Size**: The program first checks the size of the pizza. Depending on whether it's Small (S), Medium (M), or Large (L), a base price is set (15, 20, or 25 dollars respectively).
2. **Adding Cost for Pepperoni**: If the user opts for pepperoni, an additional cost is added. This cost varies based on the size of the pizza (2 dollars for Small, 3 dollars for Medium and Large).
3. **Extra Cheese Addition**: Independently of the size and pepperoni choice, if the user wants extra cheese, an additional 1 dollar is added to the total price.
After considering all these choices, the final bill is calculated and printed to the user.
This exercise was a practical application of using `if-elif-else` statements to handle multiple conditions and update a variable based on these conditions. It also demonstrated string comparison in conditional statements and basic arithmetic operations for calculating the total price.
#### [F. Love Calculator](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-003/Exercises/5-love-calculator.py)
> DISCLAIMER:
>
> This program is not actually able to calculate the chances of a successful relationship, use with caution!
>
> I'm pretty sure this "algorithm" comes from a BuzzFeed article of some sort!
> Ask for user's name (`name1`) and another name (`name2`), to return a `love_score
>
> John and Jane return `love_score` of 12
> Trevor and Lauren return `love_score` of 75
In this exercise, I created a playful "Love Calculator" program in Python, which combines string manipulation, arithmetic operations, and conditional logic. The program calculates a "love score" based on the names of two individuals.
The program starts by welcoming the user to the Love Calculator and prompts them to input two names. The logic of the program is as follows:
1. **Combine and Lowercase Names**: The entered names are concatenated and converted to lowercase. This is to ensure that the counting of letters is not case-sensitive.
2. **Counting Specific Letters for 'TRUE' and 'LOVE'**:
- It counts the occurrences of each letter in 'TRUE' (t, r, u, e) within the combined string.
- Similarly, it counts the occurrences of each letter in 'LOVE' (l, o, v, e) within the combined string.
- The counts for each set of letters are then summed to form two numbers.
3. **Calculating the Love Score**: The love score is formed by concatenating the sums of 'TRUE' and 'LOVE' counts and converting this string back to an integer.
4. **Conditional Statements for Output**:
- If the love score is less than 10 or greater than 90, a humorous message is printed, indicating a volatile combination.
- If the love score is between 40 and 50, it prints a message suggesting moderate compatibility.
- For all other scores, the love score is simply printed.
This exercise was a fun and creative way to apply various Python programming concepts & excellent for understanding basic programming concepts in a light-hearted context. It involved string concatenation, the use of the `count()` method for strings, arithmetic operations, type conversions, and implementing conditional logic based on calculated values.
## Day 4
### Projects (Day 4)
#### [4. Rock Paper Scissors - CLI Game](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-004/Projects/4-rock-paper-scissors.py)
> Ask for `user_input` of either `rock`, `paper` or `scissors`, get random choice for `computer_input`, determine and display outcome of game with a message
>
> Scissors (Player) vs Rock (Computer) = Computer Wins
In this exercise, I created a Rock Paper Scissors game in Python, incorporating basic control structures, user input, and random number generation.
The program begins with ASCII art representations for Rock, Paper, and Scissors. I then created a list `rock_paper_scissors` containing these representations. The game starts by printing a welcome message and prompting the user to choose Rock, Paper, or Scissors, represented by numbers 1, 2, and 3, respectively.
> Paper (Player) vs Rock (Computer) = Player Wins
After adjusting the user input for zero-based indexing, I used an `if` statement to check for invalid inputs (like numbers outside the range 0-2). For valid inputs, the program displays the user's choice using the ASCII art from the list.
Next, the program generates a random choice for the computer using `random.randint(0, 2)`, and displays this choice similarly. The game's outcome is then determined by comparing the user's choice and the computer's choice, using a series of `if-elif` statements.
Through this exercise, I learned to handle user input, implement conditional logic, and use lists and random number generation in Python. The game effectively demonstrated the application of these concepts in creating a simple interactive program.
### Exercises (Day 4)
#### [A. Random Module](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-004/Exercises/0-random-module.py)
In this exercise, I explored various aspects of Python programming, including the use of the `random` module, list manipulation, and commenting out code. The program is a collection of small snippets demonstrating different concepts.
1. **Using the `random` Module**:
- The program starts by importing the `random` module, which provides functions for generating random numbers.
- `random.randint(1, 10)` generates a random integer between 1 and 10.
- `random.random() * 5` generates a random floating-point number between 0 and 5.
2. **Generating a Random Love Score**:
- The program uses `random.randint(1, 100)` to simulate a random love score between 1 and 100, showcasing a practical application of generating random numbers. This is just as scientific as the first method used (neither is scientific in any way).
3. **List Manipulation and Access**:
- A list named `states_of_america` is created, containing names of U.S. states.
- The program demonstrates accessing the first and last elements of the list using index `0` and `-1` respectively.
- Although there are commented lines for modifying the list (like changing an element and extending the list), they are not executed in the current version.
4. **Nested Lists and List Concatenation**:
- The `dirty_dozen` list is created by concatenating two lists, `fruits` and `vegetables`, into a nested list. This illustrates how lists can store other lists, allowing for complex data structures.
5. **Commenting Out Code**:
- Several lines in the script are commented out (e.g., `import my_module`, modifications to `states_of_america`, and the original `dirty_dozen` list). This demonstrates how to temporarily disable code in Python without deleting it, useful for testing and debugging.
This exercise provided a broad overview of different Python features, from random number generation and list manipulation to commenting and basic data structures.
#### [B. Heads or Tails](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-004/Exercises/1-heads-or-tails.py)
> Uses `random` module to get a random value for a coin flip, display ASCII art for coin
>
> A flip of a coin shows tails
> A flip of a coin shows heads
In this exercise, I created a simple "Heads or Tails" program using Python's `random` module. This exercise demonstrates the use of random number generation and basic conditional logic.
The program works as follows:
1. **Import the Random Module**: The first step is importing the `random` module, which provides functions for generating random numbers.
2. **Generate a Random Integer**: The program uses `random.randint(0, 1)` to generate a random integer that's either 0 or 1. This simulates the two possible outcomes of a coin flip.
3. **Conditional Logic to Determine the Outcome**:
- I used an `if` statement to check the generated value: if it's 0, the program prints the ASCII art for tails, and if it's 1, it prints the ASCII art for heads.
- This binary choice effectively simulates the flipping of a coin.
#### [C. Banker Roulette](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-004/Exercises/2-banker-roulette.py)
> Ask user for `names_string`: a comma separated list of names, return a random name from the list of split `names` with random number from length of list: `name_len`
>
> Francisco is the person who will pay for this meal out of 7 options
> Max is the person who will pay for this meal out of 6 options
In the "Banker Roulette" exercise, I implemented a program in Python that randomly selects a person from a list to "buy the meal today." This exercise demonstrates string manipulation, list handling, and the use of the `random` module for generating random numbers.
The program's workflow is as follows:
1. **Input and String Splitting**:
- The program starts by asking the user to input a string of names separated by commas.
- It then uses the `split(", ")` method on the input string to create a list of names. This method splits the string at every comma followed by a space, effectively turning a single string into a list of individual names.
2. **Importing and Using the Random Module**:
- The `random` module is imported at the beginning of the program.
- To select a random name, the program first calculates the length of the names list and adjusts it to align with Python's zero-based indexing (hence `len(names) - 1`).
3. **Random Selection**:
- `random.randint(0, name_len)` is used to generate a random index between 0 and the last index of the names list.
- The program then uses this index to select a random name from the list.
4. **Output**:
- Finally, the program prints out a message stating which name (person) is selected to buy the meal.
#### [D. Treasure Map](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-004/Exercises/3-treasure-map.py)
> Ask user for `column_input` and `row_input` to plot an X on a grid map with top left corner being (1, 1)
>
> 2 and 3 places an X at (2, 3) - bottom center square
> 3 and 3 places an X at (3, 3) - bottom right square
In the "Treasure Map" exercise, I developed a program in Python that simulates placing a treasure mark on a simple grid map. This exercise is a great example of using lists, indexing, and conditional logic in Python.
1. **Creating the Map**:
- The map is represented by a list of lists (`map`), where each sublist (`row1`, `row2`, `row3`) represents a row in the map.
- Each row contains square symbols (`"⬜️"`) to represent empty spaces.
2. **Displaying the Initial Map**:
- The initial state of the map is printed using formatted strings, showing the three rows of the map.
3. **User Input for Treasure Location**:
- The program asks the user to input the position for placing the treasure. This position input is expected to be a two-digit number where the first digit represents the column and the second digit represents the row.
4. **Parsing the Input**:
- The input string is processed to determine the specific row and column. The first digit (column) is adjusted by subtracting 1 to align with Python's zero-based indexing.
- The second digit is used directly to identify the row as the input is in a user-friendly format (starting from 1).
5. **Updating the Map**:
- Conditional statements (`if-elif-else`) determine which row to update based on the user's input.
- The appropriate row is then updated by replacing the corresponding square symbol with an "X" to mark the treasure's location.
6. **Printing the Updated Map**:
- Finally, the updated map is printed, showing the new position of the treasure.
This exercise effectively demonstrates how to manipulate lists and use indexing in Python. It also provides a clear example of how user input can be taken and processed to interact with data structures, in this case, updating a list based on the input.
## Day 5
### Projects (Day 5)
#### [5. Password Generator](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-005/Projects/5-password-generator.py)
> Ask user for `num_letters`, `num_symbols` and `num_numbers` to create two passwords, the plain `simple_pass`, or a scrambled `complex_pass`
>
> 5 letters, 4 symbols and 3 numbers returns:
> - Simple: qblQf$())276
> - Scrambled: qQf(b716)$2)
> 3 letters, 5 symbols and 7 numbers returns:
> - Simple: vL0!)#+(4503919
> - Scrambled: L+!(#10O)543v99
In this exercise, I created a PyPassword Generator, a program that generates both simple and complex random passwords based on user input. The program uses Python's `random` module to select random characters from predefined lists of letters, numbers, and symbols.
1. **Character Sets**: Defined lists for letters (both lowercase and uppercase), numbers, and symbols to be used in the password.
2. **User Input**: Asked the user for the number of letters, symbols, and numbers they want in their password.
3. **Password Construction**:
- Initialized an empty string for the password.
- Used a for loop to add the specified number of random letters, symbols, and numbers to the password. For each element, I used `random.randint` to select a random index from the corresponding list.
- Added spaces between each character for easy splitting later.
4. **Generating Simple Password**:
- Split the password string into a list.
- Joined the list into a string without shuffling to create a simple password.
5. **Generating Complex Password**:
- Shuffled the list using `random.shuffle` for a more secure, complex password.
- Joined the shuffled list into a string to form the final password.
6. **Output**: Displayed both the simple and complex passwords.
This task was a great exercise in using lists, loops, random selection, string manipulation, and basic user input handling in Python.
### Exercises (Day 5)
#### [A. Basic Loops](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-005/Exercises/0-basic-loops.py)
In this exercise, I explored the use of basic loops in Python, focusing on the `for` loop with two distinct examples.
The first part of the exercise involved iterating over a list of fruits. I defined a list named `fruits` containing "Apple", "Peach", and "Pear". Using a `for` loop, I iterated through each item in the list. For each fruit, the loop printed the fruit's name and then the fruit's name followed by " Pie". This demonstrated how to access and manipulate list elements within a loop, a fundamental skill in Python for working with collections of data.
The second part of the exercise demonstrated the use of the `range` function with a `for` loop. I initialized a variable `total_number` to 0 and used a `for` loop to iterate over a range of numbers from 1 to 100. In each iteration, the loop added the current number to `total_number`. This section illustrated how `range` can be used for numeric iteration and how to accumulate a sum within a loop. The final print statement displayed the total sum of numbers from 1 to 100.
Overall, these examples served as an introduction to `for` loops in Python. They showed how loops can be used for iterating over lists and performing repeated calculations. Such techniques are essential in Python for automating tasks, processing data, and carrying out calculations over sequences.
#### [B. Average Height](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-005/Exercises/1-average-height.py)
> Ask user for comma separated list of `student_heights`, return `average_height`
>
> Average Height = 150
> Average Height = 165
In this exercise, I created a program to calculate the average height from a list of student heights in Python, demonstrating basic data collection, type conversion, and arithmetic operations.
The program begins by prompting the user to input a list of student heights, which are entered as a space-separated string. This string is then split into a list of individual height strings using `.split()`. The `for` loop that follows converts each string in the list to an integer, updating the `student_heights` list with these integer values. This conversion is crucial for the arithmetic operations that follow.
The next part of the code involves calculating the total height and counting the number of students. Two separate `for` loops are used for this purpose. The first loop iterates over each height in the `student_heights` list, adding the heights to the `total_height` variable. The second loop counts the number of students by incrementing `student_count` for each element in the `student_heights` list.
Finally, the average height is calculated by dividing the `total_height` by `student_count` and rounding the result to the nearest whole number. This average is then printed out. This exercise effectively demonstrates handling user input, iterating over lists, basic arithmetic operations, and type conversion in Python. It's a practical example of how Python can be used to process and analyze data inputs.
#### [C. High Score Checker](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-005/Exercises/2-high-score.py)
> Ask user for comma separated list of `student_scores`, return `high_score`
>
> High Score = 97
> High Score = 88
In this Python exercise, I developed a program to find the highest score in a list of student scores. The exercise emphasized the use of loops, conditional statements, and handling user input.
The program starts by requesting the user to input a list of student scores as a space-separated string. This string is then split into a list of individual score strings using the `.split()` method. A `for` loop is then employed to iterate through this list, converting each string score to an integer. This conversion is essential for the comparison operations that follow.
Once the scores are converted into integers, the code aims to identify the highest score. To achieve this, a variable `high_score` is initialized to 0. The program then iterates over each score in the `student_scores` list using a `for` loop. Within this loop, a conditional statement checks if the current score is greater than the value stored in `high_score`. If it is, `high_score` is updated with this new value. This loop-and-check mechanism ensures that at the end of the iteration, `high_score` holds the maximum score from the list.
The final step is to print the highest score. The program outputs this information in a formatted string, clearly indicating the highest score found in the class.
#### [D. Adding Even Numbers](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-005/Exercises/3-adding-even-nums.py)
In this exercise, I implemented a Python program to calculate the sum of all even numbers from 1 to 100, demonstrating the use of loops, conditional statements, and arithmetic operations.
The program defines a variable `total_number` initialized to 0. This variable is used to accumulate the sum of even numbers. A `for` loop is then used to iterate over a range of numbers from 1 to 100. The `range(1, 101)` function generates a sequence of numbers starting from 1 and ending at 100.
Within the loop, a conditional statement checks whether each number is even. This is done using the modulus operator (`%`), which returns the remainder of a division. If a number divided by 2 has a remainder of 0 (`number % 2 == 0`), it is an even number. When an even number is identified, it is added to `total_number`.
After the loop completes, the program prints `total_number`, which by then contains the sum of all even numbers from 1 to 100.
#### [E. FizzBuzz Challenge](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-005/Exercises/4-fizz-buzz.py)
> FizzBuzz prints numbers 1-100 labeling any integers divisible by three as `Fizz,` integers divisible by five as `Buzz` and integers divisible by both three and five as `FizzBuzz`
>
> Head of FizzBuzz Challenge Console Print: Values 1-40
> Tail of FizzBuzz Challenge Console Print: Values 60-100
In this exercise, I implemented the classic "FizzBuzz" program in Python, a common test used in programming interviews. The task was to print each number from 1 to 100, but for multiples of three, print "Fizz" instead of the number, and for the multiples of five, print "Buzz". For numbers which are multiples of both three and five, print "FizzBuzz". This exercise highlighted the use of loops, conditional statements, and modulo operations.
The program utilizes a `for` loop to iterate over a range of numbers from 1 to 100. For each number in this range, a series of conditional checks are performed:
1. The first `if` statement checks if the number is divisible by both 3 and 5 (`num % 3 == 0 and num % 5 == 0`). If true, "FizzBuzz" is printed. This check is important to perform first to ensure that numbers like 15, which are divisible by both, are correctly identified as "FizzBuzz" rather than just "Fizz" or "Buzz".
2. The `elif` (else if) statement then checks if the number is divisible by 3 (`num % 3 == 0`). If true, it prints "Fizz".
3. Another `elif` statement checks if the number is divisible by 5 (`num % 5 == 0`). If true, it prints "Buzz".
4. Finally, the `else` statement covers all other cases where the number is neither divisible by 3 nor 5. In these cases, the number itself is printed.
This exercise demonstrates the practical application of loops for iterating over a range, the use of modulo operator to check divisibility, and the implementation of conditional logic to determine what to print based on these divisibility checks.
## Day 6
### Projects (Day 6)
#### [6. Reeborg Maze](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-006/Projects/5-reeborg-maze.py)
### Exercises (Day 6)
#### [A. Functions](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-006/Exercises/0-functions.py)
#### [B. Reeborg Square](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-006/Exercises/1-reeborg-square.py)
#### [C. Reeborg Hurdles](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-006/Exercises/2-reeborg-hurdles.py)
#### [D. Reeborg Variable Width Hurdles](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-006/Exercises/3-reeborg-width-hurdles.py)
#### [E. Reeborg Variable Height Hurdles](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-006/Exercises/4-reeborg-height-hurdles.py)
## Day 7
### Projects (Day 7)
#### [7. Parachute Man - CLI Game](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-007/Projects/4-parachute-man.py)
### Exercises (Day 7)
#### [A. Building Parachute Man - Part 1](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-007/Exercises/1-parachute-man.py)
#### [B. Building Parachute Man - Part 2](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-007/Exercises/2-parachute-man.py)
#### [C. Building Parachute Man - Part 3](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-007/Exercises/3-parachute-man.py)
## Day 8
### Projects (Day 8)
#### [8. Caesar Cipher](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-008/Projects/7-caesar-cipher.py)
### Exercises (Day 8)
#### [A. Greet Function](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-008/Exercises/1-greet-function.py)
In this exercise, I developed a Python program that demonstrates the use of functions, specifically focusing on creating a custom function for greeting a user. The task involved obtaining user input for a name and location, and then using these inputs in a personalized greeting.
The program starts by asking the user two questions: the name of the person they are greeting and where that person lives. These inputs are captured using the `input()` function and stored in the variables `name` and `location`, respectively.
Following this, a function named `greet` is defined. This function takes two parameters: `name`
