Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
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: about 2 hours 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 (about 1 year ago)
- Default Branch: main
- Last Pushed: 2024-01-13T06:03:29.000Z (9 months ago)
- Last Synced: 2024-09-24T21:33:53.045Z (3 days 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 [email protected]: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` and `location`. Inside the function, three print statements are used to generate a personalized greeting. The first print statement says hello to the person, the second asks about the location they are in, and the third makes a remark about the day being lovely, addressing the person by name again. This use of parameters within the function allows for dynamic and reusable code.
Finally, the `greet` function is called with `name` and `location` as arguments. This call executes the function with the specific inputs provided by the user, displaying the customized greeting messages.
#### [B. Paint Area Calculator](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-008/Exercises/2-paint-area-calculator.py)
In this exercise, I created a Python program to calculate the number of cans of paint needed to paint a wall, showcasing the use of functions, arithmetic operations, and external libraries.
The program begins by importing the `math` module, which provides access to various mathematical functions. One of these functions, `math.ceil()`, is used later in the code to round up to the nearest whole number.
The core functionality of the program is encapsulated within the `paint_calc` function. This function takes three parameters: `height`, `width`, and `cover`. The `height` and `width` parameters represent the dimensions of the wall to be painted, while `cover` represents the coverage of a single can of paint (in square units).
Inside the function, the total number of cans needed is calculated by dividing the area of the wall (`height * width`) by the coverage per can (`cover`). Since it's not practical to buy a fraction of a can, the result is rounded up to the nearest whole number using `math.ceil()`. This ensures that there is enough paint to cover the entire wall. The function then prints out the number of cans needed.
To use this function, the program prompts the user to input the height and width of the wall. These inputs are captured using `input()` and converted to integers. The variable `coverage` is set to 5, representing the area that a single can of paint can cover.
Finally, the `paint_calc` function is called with the user-provided height and width, along with the predefined coverage. The function calculates and displays the number of paint cans required.
#### [C. Prime Number Check](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-008/Exercises/3-prime-number-check.py)
In this exercise, I developed a Python program to check whether a given number is a prime number, demonstrating the use of functions, loops, and conditional statements.
The program defines a function named `prime_checker` which takes one parameter: `number`. This function is responsible for determining whether the provided number is a prime number. A prime number is a natural number greater than 1 that has no positive divisors other than 1 and itself.
The function first checks if the number is greater than 1, as prime numbers are by definition greater than 1. If the number is not greater than 1, it immediately prints that it's not a prime number.
For numbers greater than 1, the function uses a `for` loop to check for factors other than 1 and the number itself. It iterates through numbers starting from 2 up to, but not including, the number in question. For each number `i` in this range, the function checks if the `number` is divisible by `i` (`number % i == 0`). If any such division is found (indicating the number is divisible by a number other than 1 and itself), the function prints that it's not a prime number and exits the loop using `break`.
If the loop completes without finding any factors, the `else` block corresponding to the `for` loop is executed, indicating that no divisors were found and the number is a prime. The function then prints that it's a prime number.
To use this function, the program prompts the user to input a number. This input is captured using `input()`, converted to an integer, and stored in variable `n`. The `prime_checker` function is then called with `n` as its argument.
This exercise is a good example of how Python can be used to solve mathematical problems and demonstrates the practical application of functions, loops, and conditional logic in programming.
#### [D. Building Caesar Cipher - Part 1](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-008/Exercises/4-caesar-cipher1.py)
In the first part of building a Caesar Cipher in Python, I focused on creating a basic encryption function. The program starts with a list called `alphabet`, which contains all the lowercase letters of the alphabet, repeated twice to facilitate letter shifting for encryption.
The user is prompted to input a message and the number of positions to shift each letter in the message (the shift value). The `encrypt` function is then defined to perform the encryption. It takes the text and the shift value as arguments. Inside the function, for each letter in the input text, its position in the `alphabet` list is found. This position is then shifted by the specified shift amount to find the new letter. The new letter is added to a string `cipher_text`, which accumulates the encrypted message. After processing all letters, the encrypted message is printed.
This part of the exercise demonstrates the basics of string manipulation, use of lists, and iteration with `for` loops in Python, forming the foundation for a simple Caesar Cipher encryption tool.
#### [E. Building Caesar Cipher - Part 2](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-008/Exercises/5-caesar-cipher2.py)
In the second part of the Caesar Cipher exercise, I expanded the functionality to include decryption. The initial setup remains the same with an `alphabet` list and user input for text, direction (encode or decode), and shift amount.
Two functions are defined in this part: `encrypt` (similar to Part 1) and `decrypt`. The `decrypt` function reverses the encryption process. It takes the encrypted text and the shift value, then for each letter in the encrypted text, finds its position in the `alphabet` list. It then shifts the position backwards by the shift amount to retrieve the original letter and constructs the decrypted message.
The program checks the user input for direction and calls the appropriate function (either `encrypt` or `decrypt`). This part of the exercise illustrates how to add more functionality to a program, specifically how to reverse an algorithm's effect, a common requirement in encryption and decryption scenarios.
#### [F. Building Caesar Cipher - Part 3](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-008/Exercises/6-caesar-cipher3.py)
In the final part of the Caesar Cipher exercise, the code is optimized by combining the encryption and decryption functionalities into a single function called `caesar`. The program still starts with the `alphabet` list and takes user inputs for the direction of the operation (encode or decode), the message, and the shift value.
The `caesar` function is designed to handle both encryption and decryption based on the direction specified. It uses modular arithmetic (`% 52`, where 52 is twice the length of the alphabet list) to ensure the new position of each letter wraps around the alphabet list correctly. This is crucial as it deals with the issue of the shift operation moving beyond the end of the list.
For encoding, each letter's position is found and shifted forward; for decoding, the process is reversed by shifting backward. The resulting letters are concatenated to form the encoded or decoded message, which is then printed.
This part of the exercise demonstrates the use of modular arithmetic in programming to create more robust and error-resistant applications. It shows the importance of optimizing code by combining similar functionalities and the practical use of functions to simplify complex tasks.
## Day 9
### Projects (Day 9)
#### [9. Blind Auction](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-009/Projects/5-blind-auction.py)
### Exercises (Day 9)
#### [A. Dictionary](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-009/Exercises/1-dictionary.py)
In this exercise, I demonstrated the use of dictionaries in Python, a powerful data structure for storing key-value pairs. The exercise covered creating a dictionary, adding to it, accessing its elements, and iterating through it.
I created a `programming_dictionary` with initial entries for "Bug" and "Function," each paired with their definitions. I accessed and printed individual definitions using their keys and also displayed the entire dictionary to show its contents.
Next, I expanded the dictionary by adding a new entry for "Loop" and its definition. This step highlighted how to dynamically add new key-value pairs to a dictionary.
Finally, I used a `for` loop to iterate over each key in the dictionary, printing both the key and its associated value. This part of the exercise showcased how to efficiently traverse a dictionary and access its contents.
#### [B. Grading Program](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-009/Exercises/2-grading-program.py)
In this exercise, I implemented a grading program in Python using dictionaries. The program assigned grades to students based on their scores, demonstrating the use of conditional statements and iterating through dictionary items.
I started with a `student_scores` dictionary containing names of students as keys and their scores as values. Then, I created an empty dictionary `student_grades` to store the grades for each student.
Using a `for` loop, I iterated over each key (student's name) in `student_scores`. Within the loop, I used a series of `if-elif` statements to assign grades based on each student's score. The grading criteria were as follows: scores 91 and above were graded as "Outstanding", scores between 81 and 90 as "Exceeds Expectations", scores between 71 and 80 as "Acceptable", and scores 70 or below as "Fail".
After determining the appropriate grade for each student, I added a new key-value pair to `student_grades`, with the student's name as the key and their assigned grade as the value.
Finally, I printed the `student_grades` dictionary to display the assigned grades for each student.
#### [C. Nesting Dictionaries](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-009/Exercises/3-nesting-dictionaries.py)
In this exercise, I worked with nesting dictionaries in Python, a useful technique for creating structured and hierarchical data models. The exercise involved two different approaches to structuring a travel log.
1. **Dictionary of Dictionaries:**
The first `travel_log` is a dictionary where each key is a country name, and the value is another dictionary containing details about travels to that country. For instance, the key "France" maps to a dictionary with keys "cities_visited" (a list of cities) and "total_visits" (an integer indicating the total number of visits).
This structure is useful when you need to access information about travels to a specific country quickly. You can directly access the details by using the country name as a key.
2. **List of Dictionaries:**
The second `travel_log` is a list, with each element being a dictionary that contains information about travels to a particular country. Each dictionary includes keys like "country", "cities_visited", and "total_visits".
This structure is more suitable when you need to iterate over all travel records, as it stores each record as a separate dictionary within a list. This makes it easy to loop through all travel entries.
Both methods showcase different ways of using nested structures in Python. The first method is efficient for direct access using a key, while the second is better for sequential processing of all records.
#### [D. Travel Log](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-009/Exercises/4-travel-log.py)
In this exercise, I worked on expanding a Python program that maintains a travel log using a list of dictionaries. The program demonstrates the use of functions for data manipulation within complex data structures.
I started with a `travel_log` list containing dictionaries, where each dictionary represents a record of visits to a country. Each dictionary has three keys: "country" (the name of the country visited), "visits" (the number of visits to that country), and "cities" (a list of cities visited in that country).
The core functionality of this exercise was the addition of a new function, `add_new_country`, which allows for the addition of new travel records to the `travel_log`. The function takes three parameters: `country_visited` (the name of the country visited), `times_visited` (the number of times visited), and `cities_visited` (a list of cities visited in that country).
Inside the function, a new dictionary `new_country` is created and populated with the provided information. This new dictionary is then appended to the `travel_log` list, effectively updating the travel log with the new travel record.
After defining the function, I tested it by adding a new record for "Russia" with 2 visits and cities ["Moscow", "Saint Petersburg"]. Finally, I printed the updated `travel_log` to verify the addition.
This exercise demonstrates how functions can be used to manage and update complex data structures like lists of dictionaries in Python. It's a practical example of how Python can be used to organize and modify data in a structured and readable format.
## Day 10
### Projects (Day 10)
#### [10. CLI Calculator with Multiple Functions](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-010/Projects/5-calculator.py)
### Exercises (Day 10)
#### [A. Functions with Outputs](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-010/Exercises/1-functions-with-outputs.py)
This exercise explores functions with outputs, focusing on how to define functions, return values, and utilize those returned values.
1. **Simple Multiplication Function:**
- **Function:** `my_function`
- **Purpose:** This function performs a simple calculation (3 multiplied by 2) and returns the result.
- **Return Value:** The function returns the calculated value (6) but does not print it. The result is computed and returned but not used, as there's no print statement or variable assignment to capture the output when `my_function()` is called.
2. **Name Formatting Function:**
- **Function:** `format_name`
- **Parameters:** Two parameters, `f_name` for the first name and `l_name` for the last name.
- **Process:**
- It formats both the first and last names to title case (first letter capitalized and the rest in lowercase) using the `title()` string method.
- The formatted names are then concatenated with a space in between.
- **Return Value:** Returns the formatted full name as a string.
- **Usage Examples:**
- `formatted_string = format_name("JoRdAn", "MULLER")` assigns the formatted name "Jordan Muller" to `formatted_string` and then prints it.
- `print(format_name("JoRdAn", "MULLER"))` directly prints the formatted name "Jordan Muller".
This lesson demonstrates the creation and use of functions with return values, emphasizing on returning processed data and then using it, either by printing it directly or by storing it in a variable for further use. It shows the versatility of functions in handling data and the convenience of separating logic (function definition) from execution (calling the function).
#### [B. Multiple Return Values](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-010/Exercises/2-multiple-return-values.py)
In this exercise, the `format_name` function is enhanced to handle multiple return scenarios, illustrating how Python functions can return different types of values based on conditional logic.
**Function:** `format_name`
- **Parameters:** Two parameters - `f_name` for the first name and `l_name` for the last name.
- **Process:**
- The function begins by checking if either `f_name` or `l_name` is an empty string. This is done using an `if` statement that checks for empty input.
- **Empty Name Check:** If either the first name or last name is empty, the function immediately returns a message: `"Empty Name, Please Provide a Valid Name"`. This safeguard ensures that the function processes only valid names.
- **Name Formatting:** If both names are provided, it formats them to title case (first letter capitalized, the rest in lowercase) using the `title()` string method.
- **Return Value:** Depending on the input, the function either returns a warning message for empty names or a formatted full name as a string.
**Usage:**
- The function is called within a `print` statement. It takes user input directly through the `input()` function for both first and last names.
- Depending on the user input, it either displays a formatted name or a message indicating that a valid name wasn't provided.
#### [C. Days in Month](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-010/Exercises/3-days-in-month.py)
This Python exercise consists of two functions: one to determine if a year is a leap year (`is_leap`), and another to find out the number of days in a given month of a specific year (`days_in_month`).
- The user is prompted to enter a year and a month.
- The `days_in_month` function is then called with these inputs to determine and print the number of days in that month of the specified year.
1. **Leap Year Function: `is_leap(year)`**
- **Purpose:** Determines whether a given year is a leap year.
- **Logic:**
- A year is a leap year if it is divisible by 4.
- However, if the year is also divisible by 100, it must also be divisible by 400 to be a leap year.
- **Return Value:** Returns `True` if the year is a leap year, and `False` otherwise.
2. **Days in Month Function: `days_in_month(year, month)`**
- **Purpose:** Calculates the number of days in a specific month of a given year.
- **Parameters:** Two parameters - `year` and `month`.
- **Process:**
- The function uses a list `month_days` to store the number of days in each month, assuming a non-leap year.
- It then checks if the year is a leap year and if the month is February (month 2). If both conditions are met, it returns 29 (for February in a leap year).
- Otherwise, it returns the number of days from the `month_days` list corresponding to the given month.
- **Return Value:** Number of days in the specified month of the given year.
#### [D. Docstrings](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-010/Exercises/4-docstrings.py)
In this exercise, I learned about creating a function with **docstrings** and implementing conditional logic in Python. The task was to define a function named `format_name` that formats a first and last name into title case.
The function `format_name` takes two parameters, `f_name` and `l_name`, representing the first and last names, respectively. I included a docstring at the beginning of the function definition, which serves as documentation. This docstring explains the purpose of the function: "Take a first and last name and format it to return the title case version of the name."
Inside the function, I added a conditional check to handle cases where either the first or last name is an empty string. If either `f_name` or `l_name` is empty, the function returns a message prompting for a valid name. Otherwise, the function proceeds to format both names to title case using the `.title()` method. This method capitalizes the first letter of each word while making all other letters lowercase. Finally, the function returns the formatted names concatenated with a space in between.
To test the function, I used the `input()` function to capture the user's first and last names. Then, I passed these inputs to the `format_name` function and printed the result.
## Day 11
### Projects (Day 11)
#### [11. Blackjack - CLI Game](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-011/Projects/1-blackjack.py)
## Day 12
### Projects (Day 12)
#### [12. Number Guessing - CLI Game](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-012/Projects/2-guess-num-game.py)
### Exercises (Day 12)
#### [A. Namespaces](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-012/Exercises/1-namespaces.py)
In this exercise, I explored the concept of namespaces and scope in Python, focusing on the differences between local, global, and block scopes.
1. **Modifying Global Scope**:
- Initially, the global variable `enemies` is commented out. Uncommenting and modifying this variable within a function without declaring it as global would have created a local variable inside the function, not affecting the global `enemies`.
- By using the `global` keyword inside `increase_enemies()`, it's possible to modify the global `enemies` variable.
- The exercise demonstrates that without the `global` keyword, a new local variable is created inside the function, which doesn't affect the global variable with the same name.
2. **Global Constants**:
- Constants like `PI`, `URL`, and `USER_NAME` are defined at the top level of the script, making them globally accessible. These are typically written in uppercase to distinguish them as constants that shouldn't be changed.
3. **Local Scope**:
- In the `drink_potion()` function, `potion_strength` is a local variable. It's only accessible within the function itself.
- Attempting to print `potion_strength` outside the function results in an error since it's not defined in the global scope.
4. **Nested Functions and Global Scope**:
- In the `game()` function, there's a nested `drink_potion()` function. This nested function can access variables in the global scope (like `player_health`), but it has its own local scope for variables declared within it.
5. **No Block Scope in Python**:
- Python does not have block scope (unlike languages like JavaScript). Variables declared inside a block (like an `if` statement) are accessible outside the block.
6. **Accessing Variables Outside Their Scope**:
- The last part of the code attempts to print `new_enemy` outside the `create_enemy()` function. Since `new_enemy` is defined within the function, it's not accessible outside, demonstrating the concept of local scope.
This exercise was an insightful exploration of how Python handles variable scopes. It showed the importance of understanding scope rules to avoid unexpected behavior in programs, especially in functions and nested structures. It highlighted that variables have different accessibility depending on where they are defined and that the `global` keyword is necessary to modify global variables within a function.
## Day 13
### Exercises (Day 13)
#### [A. Beginner Debugging](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-013/Exercises/1-beginner-debugging.py)
In this exercise, I delved into the basics of debugging in Python. It covered various debugging techniques and concepts, highlighting common issues that beginners might encounter.
1. **Describe Problem**:
- The function `my_function()` uses a `for` loop to iterate from 1 to 20. The intention is to print "You got it" when `i` equals 20. The loop correctly includes 20 in its range, ensuring the desired message is printed. No apparent issue is present in this snippet.
2. **Reproduce the Bug**:
- The code snippet uses `randint` to simulate a dice roll. The `dice_imgs` list contains symbols for dice faces. Since lists are zero-indexed, `randint(0, 5)` correctly matches the indices of `dice_imgs`. The commented line `print(dice_imgs[6])` would cause an `IndexError` because the list has no element at index 6.
3. **Play Computer**:
- The code asks for a year of birth and categorizes the user as a millennial or Gen Z based on the year. However, there's a logic error: years exactly equal to 1994 are not covered by any condition. Adjusting the conditions to include 1994 in one of the categories would resolve this oversight.
4. **Fix the Errors**:
- This snippet asks for the user's age and prints a message if the age is over 18. The code correctly converts the input to an integer and compares it against 18. There are no errors in this code; it should work as intended.
5. **Print is Your Friend**:
- The code calculates the total number of words based on the number of pages and words per page. The user inputs these values. This snippet correctly computes `total_words` by multiplying `pages` by `word_per_page`. Uncommenting the print statements for `pages` and `word_per_page` would be helpful for debugging if there were issues in the calculations.
6. **Use a Debugger**:
- The `mutate` function takes a list, doubles each item, and appends it to a new list `b_list`. This function appears to work correctly as it iterates over each element, performs the operation, and prints the resulting list.
This exercise provided a general overview of common debugging strategies: understanding the problem, reproducing bugs, stepping through the code, fixing logical errors, using print statements for inspection, and the concept of using a debugger. Each snippet represented a typical debugging scenario, emphasizing the importance of careful code review and testing in programming.
#### [B. Debug Odd & Even Program](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-013/Exercises/2-debug-odd-even.py)
In this exercise, I examined and debugged a Python program designed to check if a given number is odd or even.
##### Original Code with Bug:
The original code snippet had a syntax error:
```python
number = int(input("Which number do you want to check?"))
if number % 2 = 0:
print("This is an even number.")
else:
print("This is an odd number.")
```
The issue here was with the `if` statement. The code used a single equals sign (`=`) instead of a double equals sign (`==`). In Python, `=` is used for assignment, while `==` is used for comparison.
##### Debugged Code:
I corrected the syntax error by replacing `=` with `==` in the `if` statement. The fixed code looks like this:
```python
number = int(input("Which number do you want to check?"))
if number % 2 == 0:
print("This is an even number.")
else:
print("This is an odd number.")
```
##### Explanation:
- The program starts by asking the user to input a number, which is then converted into an integer using `int()`.
- It then checks if the number is even by using the modulus operator `%`. This operator returns the remainder of the division of `number` by 2.
- If the remainder is 0 (`number % 2 == 0`), it means the number is even, and the program prints "This is an even number."
- If the remainder is not 0, the `else` clause executes, and the program prints "This is an odd number."
#### [C. Debug Leap Year Program](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-013/Exercises/3-debug-leap-year.py)
In this exercise, I identified and fixed a bug in a Python program designed to determine whether a given year is a leap year.
##### Original Code with Bug:
The original code snippet had a type-related error:
```python
year = input("Which year do you want to check?")
if year % 4 == 0:
if year % 100 == 0:
if year % 400 == 0:
print("Leap year.")
else:
print("Not leap year.")
else:
print("Leap year.")
else:
print("Not leap year.")
```
The issue here was that the `input()` function returns a string, but the program requires an integer to perform the modulus operation.
##### Debugged Code:
To fix the issue, I converted the input to an integer using `int()`:
```python
year = int(input("Which year do you want to check?"))
if year % 4 == 0:
if year % 100 == 0:
if year % 400 == 0:
print("Leap year.")
else:
print("Not leap year.")
else:
print("Leap year.")
else:
print("Not leap year.")
```
##### Explanation:
- The program begins by prompting the user to enter a year. The input is then converted to an integer.
- The first `if` statement checks if the year is divisible by 4 (`year % 4 == 0`). This is the first condition for a leap year.
- If the year is divisible by 4, the program then checks if it is also divisible by 100. If it is (`year % 100 == 0`), the program further checks for divisibility by 400.
- For a year to be a leap year, if it is divisible by 100, it must also be divisible by 400 (`year % 400 == 0`). If it is, the program prints "Leap year." Otherwise, it prints "Not leap year."
- If the year is divisible by 4 but not by 100, it's also considered a leap year.
#### [D. Debug FizzBuzz Program](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-013/Exercises/4-debug-fizzbuzz.py)
In this exercise, I debugged a Python program designed to implement the FizzBuzz challenge, a common exercise used in programming interviews.
##### Original Code with Bug:
The original code snippet had logical errors related to conditional statements:
```python
for number in range(1, 101):
if number % 3 == 0 or number % 5 == 0:
print("FizzBuzz")
if number % 3 == 0:
print("Fizz")
if number % 5 == 0:
print("Buzz")
else:
print([number])
```
The issues were:
- The first `if` statement incorrectly used `or` instead of `and`, leading to "FizzBuzz" being printed for any number divisible by either 3 or 5, instead of both.
- The use of multiple `if` statements caused numbers divisible by 3, 5, or both to print multiple outputs (e.g., a number divisible by 3 would print both "FizzBuzz" and "Fizz").
- The `else` statement was aligned with the last `if`, causing numbers not divisible by 5 to print as a list `[number]` instead of just the number.
##### Debugged Code:
I corrected the logical errors by adjusting the conditional statements:
```python
for number in range(1, 101):
if number % 3 == 0 and number % 5 == 0:
print("FizzBuzz")
elif number % 3 == 0:
print("Fizz")
elif number % 5 == 0:
print("Buzz")
else:
print(number)
```
##### Explanation:
- The loop iterates through numbers from 1 to 100.
- The first `if` statement checks if a number is divisible by both 3 and 5 (`number % 3 == 0 and number % 5 == 0`). If true, it prints "FizzBuzz."
- The `elif` statements ensure that only one of the conditions is checked and executed. If the number is divisible by 3 but not 5, it prints "Fizz." If divisible by 5 but not 3, it prints "Buzz."
- If none of the above conditions are met, the `else` statement executes, printing the number.
## Day 14
### Projects (Day 14)
#### [1. Higher or Lower - CLI Game](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-014/Projects/1-higher-or-lower.py)
## Day 15
### Projects (Day 15)
#### [15. Coffee Machine Simulator - CLI Application](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-015/Projects/1-coffee-machine.py)
## Day 16
### Projects (Day 16)
#### [16. Coffee Machine Simulator v2 Upgrade - CLI Application](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-016/Projects)
### Exercises (Day 16)
#### [A. Object Oriented Programming](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-016/Exercises)
In this exercise, I analyzed two Python scripts that demonstrate basic concepts in Object-Oriented Programming (OOP) and module usage.
##### Script 1: Object-Oriented Concepts with Turtle Module
The first script, `1-object-oriented.py`, initially contains commented-out code that illustrates the use of the `turtle` module, a popular tool for basic graphics in Python. However, the active portion of the script focuses on using the `prettytable` module.
###### Commented-out Turtle Code:
- The script imports `Turtle` and `Screen` classes from the `turtle` module, along with another custom module `another_module`.
- It prints a variable from `another_module`.
- An instance of `Turtle` named `timmy` is created. This object is then used to draw on the screen, demonstrating basic features of the Turtle class like shape, color, and movement.
- A `Screen` object is created to control the window. The script prints the canvas height and width and uses `exitonclick()` to close the window when clicked.
###### Active PrettyTable Code:
- The script imports `PrettyTable` from `prettytable`.
- It creates an instance of `PrettyTable` named `table`.
- Two columns are added to the table with headers "Pokemon Name" and "Type", along with their respective values.
- The alignment of the table is set to left.
- Finally, the table is printed, showcasing a formatted table with the specified columns and rows.
##### Script 2: another_module.py
This script, named `another_module.py`, simply defines a variable:
```python
another_variable = 12
```
- This module is meant to be imported by other scripts. In the commented-out part of the first script, `another_module.another_variable` is printed, demonstrating how to access variables from imported modules.
##### Key Learnings:
- **Object-Oriented Programming**: The Turtle part of the script shows how to create and manipulate objects, a fundamental concept in OOP.
- **Module Usage**: Both parts of the script illustrate how to import and use modules and classes in Python.
- **PrettyTable Library**: The PrettyTable code demonstrates how third-party libraries can be used to enhance the functionality of Python scripts, in this case for data presentation.
- **Modular Programming**: By separating the variable into `another_module.py`, the script exemplifies the modular programming approach, promoting code reusability and organization.
## Day 17
### Projects (Day 17)
#### [17. Quiz/Trivia Application - CLI Game](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-017/Projects)
### Exercises (Day 17)
#### [A. Classes](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-017/Exercises/classes.py)
In this exercise, I explored the fundamental concepts of classes and objects in Python, specifically focusing on how to create and interact with class instances.
I started by defining a class named `User` using PascalCase, as is the convention for class names in Python. Inside the class, I defined an `__init__` method to initialize new `User` objects with attributes like `user_id`, `username`, `followers`, and `following`. The `followers` and `following` attributes were initialized to 0, assuming new users have no followers or are following anyone initially.
I also implemented a method called `follow`, which simulates one user following another. This method increases the `followers` count of the user being followed and the `following` count of the user who is following.
Next, I created two instances of the `User` class, `user_1` and `user_2`, with unique IDs and usernames. Then, I used the `follow` method to simulate `user_1` following `user_2`. This action increased `user_1`'s `following` count and `user_2`'s `followers` count by 1.
Finally, I printed the details of both users to observe the changes in their `followers` and `following` counts.
## Day 18
### Projects (Day 18)
#### [18. Damien Hirst Spots Paintings with Turtle Graphics](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-018/Projects/spots)
### Exercises (Day 18)
#### [A. Turtle Graphics Challenge](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-018/Exercises/1-turtle-challenge.py)
In this exercise, I delved into the creative and graphical aspect of Python programming using the Turtle Graphics library. This exercise was divided into multiple challenges, each aimed at exploring different functionalities of the Turtle module.
1. **Setting Up Turtle Graphics:**
- I started by importing `Turtle` and `Screen` from the turtle module and `random` for generating random values.
- I created a turtle object named `tim` and set its shape to "turtle". I initially commented out lines to set the turtle's color and make it move in a square pattern.
2. **Creating Helper Functions:**
- `random_color`: This function generates random colors by randomly selecting RGB values.
- `calc_exterior_angles`: It calculates the exterior angles of a regular polygon based on the number of sides.
- `random_angle`: This function returns a random angle in multiples of 90 degrees, useful for random movements.
3. **Drawing Shapes Challenge:**
- I have commented out this challenge. The idea was to use a loop to draw regular polygons with sides ranging from 3 to 10. The `calc_exterior_angles` function would be used to calculate the turning angle for each side of these polygons, and `random_color` would give each shape a unique color.
4. **Random Walk Challenge:**
- Also commented out, this challenge would have the turtle move randomly in straight lines, changing direction at random intervals. The direction changes would be multiples of 90 degrees, and each segment of the walk would be a different random color.
5. **Spirograph Challenge:**
- This was the main focus of my code. Here, I set the turtle's speed to 10 for smoother animation. I used a while loop to draw a series of overlapping circles, each slightly rotated from the last, creating a spirograph-like pattern. For each circle, I changed the turtle's color using `random_color` and rotated it slightly to the right before drawing the next circle.
6. **Screen Settings:**
- I set the screen's color mode to 255 to accommodate RGB color values. The `screen.exitonclick()` command was used to keep the window open until a click event, allowing observation of the final drawing.
Through this exercise, I learned how to use Turtle Graphics in Python for creating simple animations and drawings. It was a fun and visually engaging way to understand loops, functions, and the basics of computer graphics.
## Day 19
### Projects (Day 19)
#### [19a. Etch-a-Sketch](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-019/Projects/1-etch-a-sketch.py)
#### [19b. Turtle Race](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-019/Projects/2-turtle-race.py)
### Exercises (Day 19)
#### [A. Event Listeners](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-019/Exercises/1-event-listeners.py)
In this exercise, I explored the use of event listeners in Python, particularly within the context of the Turtle Graphics library. The primary focus was to understand how to respond to keyboard events and control the turtle using these inputs.
1. **Setting Up Turtle Graphics:**
- I started by importing `Turtle` and `Screen` from the turtle module.
- I created a turtle object named `tim` and a screen object called `screen` to interact with.
2. **Defining Movement Function:**
- I defined a function `move_forwards` that instructs the turtle to move forward by 10 units. This function serves as the event handler for a specific keyboard event.
3. **Setting Up Event Listener:**
- I activated the screen's ability to listen for events using `screen.listen()`.
- I then linked the pressing of the "space" key to the `move_forwards` function using `screen.onkey(fun=move_forwards, key="space")`. This means that whenever the space key is pressed, the `move_forwards` function will be called, causing the turtle to move forward.
4. **Screen Exit on Click:**
- Finally, I used `screen.exitonclick()` to keep the turtle graphics window open until a mouse click event occurs. This allows for continuous interaction with the turtle until the user decides to close the window.
Through this task, I learned how to make Python programs interactive using event listeners. This is a fundamental concept in many graphical user interfaces and interactive applications.
## Day 20
### Projects (Day 20)
#### [20. Snake Game](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-020/Projects)
## Day 21
### Projects (Day 21)
#### [21. Snake Game v2 Upgrade](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-021/Projects)
### Exercises (Day 21)
#### [A. Class Inheritance](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-021/Exercises/1-class-inheritance.py)
In this exercise, I explored the concept of class inheritance in Python, which is a fundamental aspect of object-oriented programming. The task involved creating a base class `Animal` and a derived class `Fish` that inherits from `Animal`.
1. **Defining the Base Class:**
- I started by defining the `Animal` class with a constructor (`__init__` method) initializing an attribute `num_eyes` set to 2.
- I also defined a method `breathe` in the `Animal` class that prints "Inhale, exhale."
2. **Creating the Derived Class:**
- Next, I created the `Fish` class, which inherits from the `Animal` class. Inheritance is indicated by specifying the parent class `Animal` in parentheses next to the class name `Fish`.
- In the `Fish` class, I used `super().__init__()` in its constructor to ensure that it inherits all the properties and behaviors of the `Animal` class. This includes initializing the `num_eyes` attribute.
3. **Overriding and Extending Methods:**
- I overrode the `breathe` method in the `Fish` class to add additional behavior. The `Fish` class's `breathe` method first calls the `breathe` method from the `Animal` class (using `super().breathe()`) to perform the basic breathing action, and then adds a print statement "Doing this underwater" to indicate its adaptation to an aquatic environment.
- Additionally, I introduced a new method `swim` in the `Fish` class with a print statement "Moving in water." This method is specific to the `Fish` class and represents an ability not present in the `Animal` class.
4. **Creating an Instance and Testing Methods:**
- I then created an instance of the `Fish` class named `nemo` and tested its methods and attributes.
- I called `nemo.swim()`, which executed the `swim` method specific to the `Fish` class.
- I called `nemo.breathe()`, which demonstrated the overridden behavior in the `Fish` class, showing both the inherited breathing action and the specialized "Doing this underwater" print statement.
- Finally, I printed `nemo.num_eyes`, which confirmed that `nemo` inherited the `num_eyes` attribute from the `Animal` class.
Through this exercise, I gained a deeper understanding of how inheritance allows a class to inherit attributes and methods from a parent class, how to override methods in the child class, and how to add new methods specific to the child class.
#### [B. Slicing](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-021/Exercises/2-slicing.py)
In this exercise, I delved into the concept of slicing in Python, which is a technique used to access a subset of elements from a list or a similar sequence type. I worked with a list named `piano_keys`, representing the keys of a piano.
1. **Understanding the Basic Slice Notation:**
- The slice notation in Python follows the format `[start:stop:step]`, where `start` is the index where the slice starts, `stop` is the index where the slice ends, and `step` is the interval between each element in the slice.
2. **Slicing Examples and Outputs:**
- `piano_keys[2:5]`: This slice starts at index 2 and goes up to, but not including, index 5. The output is `['c', 'd', 'e']`.
- `piano_keys[2:]`: Here, the slice starts at index 2 and goes to the end of the list. The output is `['c', 'd', 'e', 'f', 'g']`.
- `piano_keys[:5]`: This slice includes elements from the beginning of the list up to, but not including, index 5. The output is `['a', 'b', 'c', 'd', 'e']`.
- `piano_keys[1:6:2]`: This slice starts at index 1, ends at index 6, and takes every 2nd element. The output is `['b', 'd', 'f']`.
- `piano_keys[::2]`: This slice includes the entire list, taking every 2nd element. The output is `['a', 'c', 'e', 'g']`.
- `piano_keys[::-1]`: This is a special case that reverses the list. It starts from the end towards the first element with a step of -1. The output is `['g', 'f', 'e', 'd', 'c', 'b', 'a']`.
Through this task, I learned how slicing is a powerful tool for accessing parts of a sequence in Python. It can be used to extract elements, create sub-lists, and even reverse a list, all with concise and readable syntax. This concept is widely used in Python for various applications, including data manipulation and string handling.
## Day 22
### Projects (Day 22)
#### [22. PONG Game](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-022/Projects)
## Day 23
### Projects (Day 23)
#### [23. Turtle Crossing (Frogger Game)](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-023/Projects)
## Day 24
### Projects (Day 24)
#### [24a. Mail Merge](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-024/Projects/Mail-Merge)
#### [24b. Snake Game v3 Upgrade](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-024/Projects/Snake-Game)
### Exercises (Day 24)
#### [A. Read & Write Methods](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-024/Exercises/read_write.py)
In this exercise, I explored various methods to read from and write to files in Python, using the `open()` function with different modes and the `write()` and `read()` methods.
First, I used the `open()` function with the mode `"w"` for writing. This mode creates a new file or overwrites an existing file. I wrote a line of text to "data.txt" using `file.write("New line of text!")`.
Next, I appended another line to the same file using mode `"a"`, which stands for append. This mode adds content to the end of the file without deleting its existing content. I added "\nAnother line of text!" to "data.txt".
Then, I created a new file named "new_data.txt" by opening it in write mode. Since the file didn't exist, Python created it for me. I wrote two lines of text into this new file.
Lastly, I read the contents of "data.txt" using the default read mode, which is simply `open("data.txt")`. After reading the contents with `file.read()`, I printed them to the console.
This task taught me how to handle files in Python, including creating, writing, appending, and reading files. It demonstrated the importance of understanding file modes and the convenience of Python's context manager (`with` statement) for safe file handling, as it automatically closes the file after the block of code is executed, preventing potential file corruption or leaks.
## Day 25
### Projects (Day 25)
#### [25. United States Guessing Game](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-025/Projects/US-States-Game)
### Exercises (Day 25)
#### [A. Squirrel Census Data Exploration](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-025/Exercises/Squirrel-Census)
In this Python exercise, I worked on exploring and processing data from the "2018 Central Park Squirrel Census" using the pandas library.
First, I imported the pandas library to handle the dataset. I read the data from "2018_Central_Park_Squirrel_Census.csv" into a DataFrame using `pandas.read_csv()`. This CSV file contained various details about each squirrel sighting, including their fur color.
My focus was on the "Primary Fur Color" column. I grouped the data by this column and used the `size()` function to count the number of squirrels of each fur color. This operation provided me with a Series object where the index was the fur color, and the values were the counts.
I then converted this Series into a DataFrame for better readability and manipulation. The DataFrame had two columns: "Primary Fur Color" and "Count", representing the fur color and the respective count.
Next, I sorted this DataFrame by the "Count" column in descending order to see which fur color was the most common. After sorting, I reset the index of the DataFrame with `reset_index(drop=True)` to have a clean, ordered index.
Finally, I saved this processed data into a new CSV file named "squirrel_count.csv" using `df.to_csv()`. This file succinctly summarized the count of squirrels by their primary fur color observed during the census.
Through this task, I learned to read, process, and group data using pandas, which is a powerful tool for data analysis in Python. It also demonstrated how to perform basic data manipulation operations like sorting and resetting indexes. The exercise was a practical application of pandas for real-world data exploration and summarization.
#### [B. Weather Data Exploration](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-025/Exercises/Weather)
In this Python exercise, I delved into exploring and manipulating weather data using the pandas library. The exercise involved various tasks, from reading CSV files to data manipulation and creating new data frames.
Initially, I experimented with basic file reading and CSV reading methods. I commented out the code where I read the "weather_data.csv" file line by line using `open()` and `readlines()`, and also the section where I read the same file using the `csv` module to extract temperature data.
Then, I shifted to using pandas, which is a more powerful and convenient tool for data analysis. I imported the pandas library and read the "weather_data.csv" file into a DataFrame using `pandas.read_csv()`. I explored the types of data structures returned by pandas, like DataFrames and Series, by checking the type of `data` and `data["temp"]`.
I converted the entire DataFrame and the temperature column into a dictionary and a list, respectively, using `to_dict()` and `to_list()`. These operations demonstrated different ways of viewing and manipulating data in pandas.
I then calculated the mean and the maximum temperature directly from the DataFrame without needing to manually convert the temperatures into a list, showcasing pandas' built-in statistical functions.
Additionally, I extracted data based on specific conditions. For instance, I retrieved rows where the day was "Monday" and where the temperature was the maximum in the dataset. This part of the exercise highlighted how to filter and access specific rows in a DataFrame.
I also implemented a custom function `CelsiusToFahrenheit` to convert temperature from Celsius to Fahrenheit. I applied this function to the temperature of Monday, demonstrating how to perform custom operations on DataFrame values.
Lastly, I created a new DataFrame from scratch using a dictionary. This new DataFrame contained student names and their scores. I then exported this DataFrame to a new CSV file named "score_data.csv", illustrating how to create and write DataFrames to CSV files.
## Day 26
### Projects (Day 26)
#### [26. NATO Alphabet Translator](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-026/Projects/NATO-Alphabet)
### Exercises (Day 26)
#### [A. List Comprehension](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-026/Exercises/1-list-comprehension.py)
In this exercise, I learned about list comprehensions in Python, a concise way to create lists. The concept involves constructing a list by iterating over an iterable and optionally applying a condition or operation.
1. First, I created a new list, `new_numbers`, by adding 1 to each element in the original list `numbers`. This was done using the list comprehension `[num + 1 for num in numbers]`.
2. Next, I converted each letter in the string `name` into a list of letters using `[letter for letter in name]`. This demonstrated how list comprehensions can be used with strings.
3. I then worked with a range object, `range_nums`. I created `range_list`, where each number in the range is multiplied by 2, through the comprehension `[n * 2 for n in range_nums]`.
4. In a more complex example, I filtered and transformed elements from a list of names. For `names_list`, I used a condition to include only names with 4 or fewer characters `[name for name in names if len(name) <= 4]`.
5. Finally, I created `upper_names_list` by converting names longer than 4 characters to uppercase. This was done using `[name.upper() for name in names if len(name) >= 5]`.
#### [B. Squaring Numbers](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-026/Exercises/2-squaring-numbers.py)
In this exercise, I practiced using list comprehensions to square each number in a given list. The objective was to transform a list of numbers by squaring each element, all in a single line of code.
The original list, `numbers`, contained a sequence of integers. To achieve the task, I wrote the following list comprehension: `squared_numbers = [num**2 for num in numbers]`. This line of code iterates over each element `num` in the `numbers` list and applies the squaring operation (`num**2`).
When printed, `squared_numbers` displayed the squared value of each number from the original list. This was a straightforward yet effective exercise to understand how list comprehensions can be used for mathematical operations on list elements, showcasing the elegance and power of Python for such operations. It also reinforced the concept that list comprehensions are an efficient way to create new lists by applying an expression to each item in an existing list.
#### [C. Filter Even Numbers](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-026/Exercises/3-filter-even-nums.py)
In this exercise, I focused on filtering elements in a list using a list comprehension in Python, specifically to extract even numbers from a given list.
Given the list `numbers`, which contained a series of integers, I wrote a one-liner list comprehension to create a new list, `result`, containing only the even numbers from the original list. The code for this was `[num for num in numbers if num % 2 == 0]`. This expression iterates through each number in `numbers`, and includes it in `result` if it satisfies the condition `num % 2 == 0` (which checks if the number is even).
Upon executing the code and printing `result`, the output was a list of all even numbers from the original `numbers` list.
#### [D. Dictionary Comprehension](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-026/Exercises/4-dict-comprehension.py)
In this exercise, I learned about dictionary comprehensions, a powerful way to create and manipulate dictionaries dynamically. The task involved generating random scores for a list of students and then filtering those scores to identify students who passed.
1. I started with a list of student names, `names`.
2. I defined a function `RandomScore()` that generates a random score between 1 and 100 using `random.randint(1, 100)`.
3. Using dictionary comprehension, I created a dictionary `student_scores` where each student's name from the `names` list was a key, and their associated value was a random score generated by the `RandomScore()` function. The comprehension was `{name: RandomScore() for name in names}`.
4. To identify students who passed (assuming a passing score is 60 or above), I used another dictionary comprehension to filter `student_scores`. The comprehension was `{student: score for (student, score) in student_scores.items() if score >= 60}`. This created a new dictionary `passed_scores` containing only the students who had scores of 60 or above.
#### [E. Word Length Dictionary](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-026/Exercises/5-word-length-dict.py)
In this exercise, I created a program to generate a dictionary that maps words in a sentence to their respective lengths. The task involved string manipulation and comprehension in Python.
The program starts with a predefined sentence: "What is the Airspeed Velocity of an Unladen Swallow?". Using the `split()` method on this string, I broke it into a list of words, stored in `word_list`. This method splits a string into a list where each word is an item, based on spaces.
Next, I utilized a dictionary comprehension to create a dictionary, `result`, where each key-value pair consists of a word from `word_list` and its corresponding length. The comprehension iterates over each word in `word_list`, using the `len()` function to get the length of each word.
Finally, the program prints the `result` dictionary. This displays each word from the original sentence alongside the number of characters it contains.
#### [F. Weather Dictionary](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-026/Exercises/6-weather-dict.py)
In this exercise, I created a Python program to convert temperatures from Celsius to Fahrenheit for a weekly weather report. This task involved writing a function for the conversion and applying it to a dictionary using comprehension.
The program starts with a predefined dictionary, `weather_c`, containing days of the week as keys and their corresponding temperatures in Celsius as values. My task was to convert these temperatures to Fahrenheit.
I wrote a function named `CelsiusToFahrenheit` that takes a temperature in Celsius as its argument. The function applies the formula for converting Celsius to Fahrenheit: `(Celsius temperature * 9/5) + 32`.
Next, I used a dictionary comprehension to create a new dictionary, `weather_f`. This comprehension iterates over each key-value pair in `weather_c` (representing day and Celsius temperature). It applies the `CelsiusToFahrenheit` function to each temperature value and pairs it with the corresponding day.
Finally, the program prints `weather_f`, displaying the days of the week with their temperatures in Fahrenheit.
This exercise demonstrated practical uses of functions, dictionary comprehensions, and the concept of iterating over key-value pairs in a dictionary. It also reinforced the application of mathematical formulas in programming.
#### [G. Data Overlap Exercise](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-026/Exercises/Data-Overlap-Exercise)
In this exercise, I worked on a Python program to find overlapping data between two files and then sort the results. The task involved file handling, set operations, list comprehension, and sorting.
The program begins by reading the contents of two text files, `file1.txt` and `file2.txt`. Each file contains a list of numbers, one per line. I used the `with open()` statement to open and read the contents of each file, storing them in `file_1_contents` and `file_2_contents` respectively.
After reading the files, I converted the contents of each file into a set using the `split()` method. This method splits the file contents into a list of strings (based on new lines), and `set()` converts these lists into sets, named `numbers_1` and `numbers_2`. The use of sets here is crucial as they automatically remove duplicates and allow for efficient comparison.
Next, I used list comprehension to create a list named `result`. This list is composed of the common elements between `numbers_1` and `numbers_2`. The comprehension iterates over each element in `numbers_1`, checking if it also exists in `numbers_2`. Each common element is converted to an integer before being added to the list.
Then, I sorted `result` in ascending order using the `sorted()` function with `reverse=False`. This rearranges the numbers from the smallest to the largest.
Finally, the program prints the sorted list `result`, which contains the numbers that are present in both files.
This exercise showcased practical applications of file reading, data type conversion, set operations for finding intersections, and sorting techniques in Python. It illustrated how to efficiently process and compare data from different sources.
#### [H. Pandas DataFrame Iterate](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-026/Exercises/Pandas-DataFrame-Iterate)
In this exercise, I explored how to iterate over rows in a Pandas DataFrame in Python. This task was centered around creating a DataFrame from a dictionary and then using a loop to access and print specific data from it.
The program starts by importing the Pandas library, essential for data manipulation and analysis in Python. I then created a dictionary named `student_dict` with two keys: "student" and "score". Each key maps to a list of values representing student names and their corresponding scores.
Next, I used this dictionary to create a Pandas DataFrame called `student_data_frame`. A DataFrame is a two-dimensional, size-mutable, and potentially heterogeneous tabular data structure with labeled axes (rows and columns). It's a fundamental component in Pandas and is useful for representing and manipulating structured data.
The core part of this exercise was to loop through each row in the DataFrame. I used `student_data_frame.iterrows()`, a function that provides an iterator yielding index and row data for each row. In each iteration, `index` represents the index of the row, and `row` is a series containing the row data.
Inside the loop, I printed the values of `row.student` and `row.score`. This demonstrated how to access specific columns in each row of a DataFrame. The commented-out code, which checks if the student's name is "Jordan" and then prints their score, illustrated conditional data access within the DataFrame.
Through this exercise, I learned about data manipulation using Pandas, particularly the creation of DataFrames from dictionaries and iterating over DataFrame rows. It was a practical demonstration of handling tabular data, accessing specific data points, and conditional logic in the context of data analysis.
## Day 27
### Projects (Day 27)
#### [27. Unit Converter App - (Miles to Kilometers)](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-027/Projects/6-miles-km-converter.py)
### Exercises (Day 27)
#### [A. Windows & Labels](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-027/Exercises/1-windows-labels.py)
In this exercise, I created a basic Graphical User Interface (GUI) application using Python's Tkinter library. This program demonstrates the creation of a window, adding widgets like labels and buttons, and updating the label text dynamically based on user interaction.
The program begins by importing the Tkinter library, which is a standard Python interface to the Tk GUI toolkit. I then created a main window for the application using `Tk()`, setting its title to "Python GUI Program" and minimum size to 500x400 pixels.
A label widget, `my_label`, is created with the initial text "I am a label!", using the Arial font at size 24 and bold style. This label is then packed into the window, which means it is added to the window and displayed. The text of the label is changed twice, first to "New Label Text!" and then to "Yet Another Label!" using different methods (`my_label["text"]` and `my_label.config(text=...)`).
Two functions are defined: `button_clicked()` and `input_label()`. `button_clicked()` is designed to update the label text to indicate the number of times a button has been clicked, but it's not used in this program. `input_label()`, on the other hand, updates the label text with the value entered in an input field.
A button widget, `button`, is created with the label "Button!" and is configured to call `input_label()` when clicked. This button is packed into the window below the label. An input field (Entry widget) is also created and packed into the window.
The `window.mainloop()` at the end of the script keeps the window open, allowing for user interaction. Whenever the button is clicked, the text in the input field is used to update the label's text.
Through this exercise, I learned about the basics of creating a GUI in Python using Tkinter, including window creation, adding and configuring widgets, and handling user events and interactions. This program provided a practical introduction to building interactive applications with graphical elements.
#### [B. Many Arguments](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-027/Exercises/2-many-arguments.py)
In this exercise, I explored the use of `*args` in Python, which allows a function to accept an arbitrary number of arguments. I applied this concept in creating a function named `add` that sums up all the arguments provided to it.
Firstly, the `add` function prints the second item in the `args` tuple, demonstrating how individual elements can be accessed. The `args` variable is a tuple containing all the arguments passed to the function.
I then initialized a variable `sum_args` to 0 to keep track of the sum. Using a `for` loop, I iterated over each argument in `args` and added it to `sum_args`. This loop effectively accumulates the sum of all provided arguments.
The function finally returns the total sum. When tested with the input `add(5, 6, 11)`, it correctly calculated and returned the sum of these numbers.
Through this task, I learned about using `*args` for variable-length argument lists and how to manipulate these arguments within a function. This is particularly useful for creating flexible functions that can handle an unknown number of inputs.
#### [C. Many Keyword Arguments](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-027/Exercises/3-many-keyword-args.py)
In this exercise, I delved into the use of `**kwargs` in Python, which enables a function to accept an arbitrary number of keyword arguments. This was demonstrated through two examples: a `calculate` function and the creation of a `Car` class.
##### The `calculate` Function:
- The `calculate` function accepts a standard argument `n` and any number of keyword arguments (`**kwargs`).
- Initially, I printed the `kwargs` to see how Python stores these keyword arguments as a dictionary.
- The function then modifies `n` by adding and multiplying it with values associated with the 'add' and 'multiply' keys in `kwargs`. This showcases how to access and use the values from the `kwargs` dictionary.
- Testing this function with `calculate(2, add=3, multiply=5)` showed how it dynamically adjusts its behavior based on the provided keyword arguments.
##### The `Car` Class:
- I then created a `Car` class where the constructor (`__init__`) uses `**kw` to accept various attributes of a car.
- The class uses the `get` method on the `kw` dictionary to safely assign values to the car's attributes like `make`, `model`, `color`, and `seats`. This method avoids errors if certain attributes are not provided.
- By creating an instance of `Car` with specific attributes, I demonstrated how flexible and adaptable the class is to different sets of data.
- Finally, I printed the attributes of `my_car` to confirm that the class correctly assigns and stores the provided information.
#### [D. Tkinter Widgets](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-027/Exercises/4-tkinter-widgets.py)
In this exercise, I explored various widgets in Tkinter, a popular GUI toolkit in Python, to create an interactive window application. The exercise was a comprehensive introduction to basic GUI elements and their functionalities.
1. **Window Configuration**: I started by creating a new window using `Tk()`, setting its title, and specifying minimum dimensions.
2. **Labels**: I used the `Label` widget to display text. Initially, I set some text and then changed it using the `config` method.
3. **Buttons**: I created a `Button` widget and linked it to a function called `action`, which executes when the button is clicked.
4. **Entries**: The `Entry` widget allowed for single-line text input. I pre-populated it with some text and learned how to retrieve the input value.
5. **Text**: For multi-line text entry, I used the `Text` widget. I added initial text and fetched the current text, understanding its line and character indexing system.
6. **Spinbox**: This widget let users pick from a range of numbers. I connected it to a function that prints the selected value.
7. **Scale**: The `Scale` widget provided a slider interface. I used a function to display the current value as it changes.
8. **Checkbutton**: I created a checkbutton that toggles between two states, learning to use `IntVar` to track its state and execute a function on change.
9. **Radiobuttons**: I used two `Radiobutton` widgets, each tied to the same variable but representing different values, and printed the selected option through a function.
10. **Listbox**: Finally, I added a `Listbox` to display a list of items (fruits) and implemented a function to print the currently selected item.
With this task, I gained hands-on experience with Tkinter's fundamental widgets, understanding how to layout a basic GUI, handle user interactions, and retrieve data from various input elements. This exercise was an excellent foundation for building more complex graphical user interfaces in Python.
#### [E. Layout Managers](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-027/Exercises/5-layout-managers.py)
In this exercise, I explored the layout managers in Tkinter, which are essential for arranging widgets in a Python GUI application. I worked with grid, pack, and place layout managers to understand their differences and use cases.
1. **Window Setup**: I started by creating a Tkinter window, setting its title, and configuring its minimum size and padding.
2. **Label**: I used a `Label` widget to display text and learned how to modify its text and appearance. I experimented with different layout managers (commented out `pack` and `place`) but ultimately placed it using `grid` with specified row and column.
3. **Buttons**: Two buttons were created, each connected to a different function. The first button, when clicked, updated the label with the text from an entry widget. The second button displayed a count of how many times it was clicked, updating the label text accordingly. I placed these buttons using the `grid` layout manager.
4. **Entry**: An entry widget for text input was added. Similar to the other widgets, I placed it using `grid`.
5. **Understanding Layout Managers**:
- **Pack**: This manager organizes widgets in a block, which means they occupy space along their parent container's vertical or horizontal box. I saw this in the commented-out `pack` code.
- **Grid**: This manager places widgets in a two-dimensional grid. It is more versatile than `pack` for complex layouts. I used `grid` for precise positioning of labels and buttons in specified rows and columns.
- **Place**: This manager positions widgets by defining their exact x and y coordinates. I saw its usage in the commented code, which provided an idea of absolute positioning.
I gained a deeper understanding of how different layout managers affect the placement and arrangement of widgets in a Tkinter application. This is very important for creating visually appealing and functionally organized GUIs. The exercise effectively demonstrated the flexibility and specific use cases of each layout manager in Python's Tkinter module.
## Day 28
### Projects (Day 28)
#### [28. Pomodoro Timer](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-028/Projects/Pomodoro-Timer)
In this exercise, I created a Pomodoro timer using Python's Tkinter library, which is used for building graphical user interfaces. The Pomodoro technique is a time management method that involves working for a set period (usually 25 minutes), followed by a short break, and repeating this cycle with a longer break after four work periods.
1. **Constants and Variables**: I defined constants for UI colors, timer settings, and initialized variables to keep track of repetitions and timer marks.
2. **Countdown Mechanism**: The `timer_countdown` function manages the countdown. It converts the remaining time into a mm:ss format and updates the timer display. It uses a recursive approach to decrease the count every second, and when the count reaches zero, it starts the next timer phase.
3. **Timer Control**: The `start_timer` function controls the flow of the Pomodoro cycles. It alternates between work and break phases, changing the timer label and colors accordingly. Every work cycle is followed by a short break and every four work cycles by a longer break, with visual marks (✓) added for each completed phase.
4. **Reset Functionality**: The `reset_timer` function stops the current countdown and resets the timer and UI elements to their default state.
5. **UI Setup**: The user interface is created using Tkinter widgets. It includes a timer label, a canvas to display a tomato image and the countdown, start and reset buttons, and a label to show progress marks.
6. **Event Loop**: Finally, the Tkinter event loop (`mainloop()`) is called to keep the application running.
This exercise demonstrated how to build an interactive GUI application in Python, integrating time-based functions, event handling, and UI customization. It provided practical experience in managing application state, updating UI elements in real-time, and implementing user-driven functionality such as starting and resetting the timer.
## Day 29
### Projects (Day 29)
#### [29. Password Manager](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-029/Projects/Password-Manager)
In this exercise, I developed a Password Manager application using Python, integrating the Tkinter library for the graphical user interface and JSON for data storage. The application includes features for generating random passwords, saving them, searching for existing entries, and displaying them in a user-friendly format.
Key aspects of the program:
1. **Password Generation**: The `gen_password` function creates a secure, random password. It combines a mix of letters, numbers, and symbols, ensuring a strong and unpredictable password. The generated password is then automatically copied to the clipboard for easy use.
2. **Data Storage**: Passwords, along with associated website and email/username details, are stored in a JSON file. This allows for persistent storage of data between application uses.
3. **Search Functionality**: The `search_data` function enables users to search for a password by entering the website name. If the website is found in the data file, it displays the associated email/username and password.
4. **Saving Passwords**: The `save_data` function validates the input fields and then saves the new password entry to the JSON file. It ensures that all fields are filled before saving and updates the existing data file or creates a new one if it doesn't exist.
5. **Error Handling**: The program includes error handling for situations like a missing data file or issues with reading the JSON file. It uses message boxes to inform the user of any issues encountered.
6. **User Interface**: The GUI is built using Tkinter widgets, including labels, entry boxes, buttons, and a canvas to display an image. The layout is organized and user-friendly, making it easy for users to interact with the application.
7. **Event Loop**: The Tkinter event loop (`mainloop()`) is used to keep the application running and responsive to user interactions.
Through this exercise, I gained practical experience in building a complete application with Python, including aspects of GUI design, file handling, data storage, and application logic.
## Day 30
### Exercises (Day 30)
#### [A. Catching Exceptions](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-030/Exercises/1-catching-exceptions.py)
In this exercise, I learned about handling exceptions in Python, which are crucial for writing robust and error-resistant programs. The code snippets provided cover various common exceptions and demonstrate how to manage them effectively using `try`, `except`, `else`, and `finally` blocks.
1. **FileNotFoundError**: When trying to read a file that doesn't exist (`a_file.txt`), I learned to catch this exception. If the file is not found, it's created and written to, preventing the program from crashing.
2. **KeyError**: I learned to handle cases where a key is not found in a dictionary. For instance, attempting to access a non-existent key (`"non-existent-key"`) in `a_dictionary` triggers a KeyError, which I learned to catch and print a custom error message.
3. **TypeError**: I discovered how to deal with operations on incompatible types, such as adding a number to a string (`text + 5`), which is not allowed in Python.
4. **ValueError and Custom Exception**: In the BMI calculator part, I learned how to raise a custom exception (`ValueError`) when the user enters an unrealistic height (over 3 meters). This is a good practice for validating user input.
5. **General Exception Handling Structure**: The `try` block contains code that might cause an exception, while the `except` block handles specific exceptions. The `else` block executes if no exceptions occur, and `finally` ensures some code runs no matter what (like closing a file). The exercise also included an example of intentionally raising an exception (`raise TypeError`) in the `finally` block.
Overall, this task highlighted the importance of anticipating and managing errors in Python, showcasing various scenarios where exception handling is essential. This is a fundamental skill for developing resilient and user-friendly Python applications.
#### [B. Index Error Handling](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-030/Exercises/2-index-error-handling.py)
In this exercise, I learned how to handle IndexError exceptions in Python, specifically in the context of accessing list elements. The task involved modifying a function, `make_pie`, to catch and handle an IndexError when an invalid index is passed to it.
1. **Understanding IndexError**: Initially, the `make_pie` function attempted to access an element in the `fruits` list using a provided index. However, if the index was out of range (like 4 in this case, where the list has only three elements), an IndexError would occur. This is a common error when working with lists or arrays.
2. **Adding Exception Handling**: To prevent the program from crashing due to an IndexError, I added a `try` block around the code that might cause the exception. In the `except` block, I caught the IndexError and implemented an alternative action: printing "Fruit pie" and returning this string. This way, the program continues to run smoothly even when an invalid index is used.
3. **Testing the Function**: After modifying `make_pie`, I tested it by calling it with an index that I knew would cause an IndexError (4). The exception handling worked as expected, printing "Fruit pie" instead of causing a crash.
4. **Redundant Outer Try-Except Block**: The outer `try` and `except` blocks around the `make_pie(4)` call became redundant after adding the exception handling inside the `make_pie` function. Since the function already handles the IndexError internally, there is no need for additional error handling outside the function.
#### [C. Key Error Handling](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-030/Exercises/3-key-error-handling.py)
In this exercise, I explored handling KeyError exceptions in Python, specifically while working with a list of dictionaries. The task involved iterating through `facebook_posts`, a list of dictionaries, and summing up the "Likes" from each post.
1. **Understanding KeyError**: A KeyError occurs when trying to access a key in a dictionary that does not exist. In this case, some dictionaries in the `facebook_posts` list did not have the "Likes" key, which could potentially lead to a KeyError when the code tries to access `post["Likes"]`.
2. **Implementing Exception Handling**: To address this, a `try` block was used around the code that could raise the KeyError (accessing `post["Likes"]`). In the `except` block, I caught the KeyError and used a `pass` statement to do nothing in cases where the "Likes" key is missing. This prevented the program from crashing and allowed it to continue iterating through the list.
3. **Accumulating Likes**: The `total_likes` variable was used to accumulate the count of "Likes" from each post. If a post did not have the "Likes" key, the KeyError was caught, and the loop continued to the next post without modifying `total_likes`.
4. **Result Output**: After iterating through all the posts, the total number of likes was printed out. This gave a sum of likes from posts that contained the "Likes" key, safely ignoring those that didn't.
## Day 31
### Projects (Day 31)
#### [31. Flashcards GUI Application](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-031/Projects/Flashcards-App)
In this exercise, I created a Flashcards GUI application for language learning using Python, Tkinter for the graphical interface, and Pandas for data handling. This application focuses on helping users learn French words by displaying them on flashcards and allowing them to indicate whether they know the word or not.
1. **Data Setup**: The application uses a CSV file containing French words and their English translations. It checks if a separate file for words to learn exists, creating one if it doesn't, or loading it if it does.
2. **Flashcard Functionality**: The main feature is the display of flashcards showing French words. After a set amount of time (defined by `FLIP_TIME`), the card flips to reveal the English translation. The user can then indicate whether they knew the word or not using the right (correct) or wrong (incorrect) buttons.
3. **Interactive Buttons**: Two buttons are provided – one for indicating the word is known (right) and the other for unknown (wrong). Clicking the right button removes the word from the learning list, while the wrong button simply changes to the next word.
4. **Word Management**: When a word is marked as known, the `remove_word_from_learn_list` function removes it from the DataFrame and updates the CSV file. This ensures that the user only sees words they are still learning.
5. **Dynamic Content Update**: The `change_word` function randomly selects a new French word and updates the flashcard. It also manages the automatic flipping of the card to show the English translation after the set interval.
6. **Card Flipping Animation**: The `flip_card` function updates the canvas to show the opposite side of the flashcard (French or English) along with the corresponding text.
7. **User Interface**: The application has a simple and user-friendly interface, using a canvas to display flashcards and buttons with images for user interactions. The UI design is clean and conducive to focused learning.
8. **Event Loop**: The Tkinter event loop (`mainloop()`) keeps the application running and responsive to user actions.
Through this exercise, I learned how to integrate various aspects of Python programming, including GUI design, event handling, file operations with Pandas, and logic to create an interactive and educational application. This project highlights the versatility of Python in creating applications that are both functional and engaging for users.
## Day 32
### Projects (Day 32)
#### [32. Calculator GUI App](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-032/Projects/Calculator-App/main.py)
In this exercise, I built a basic calculator application named "EasyCalc" using Python and Tkinter for the graphical interface. This calculator allows users to perform basic arithmetic operations and displays the results in a user-friendly manner.
1. **User Input Handling**: The `number_clicked` function captures the number clicked by the user and updates the current input. This allows users to input multi-digit numbers.
2. **Operation Functions**: Separate functions (`handle_plus_button`, `handle_minus_button`, `handle_mul_button`, `handle_div_button`, `handle_mod_button`) handle the arithmetic operations. These functions store the current input and the respective operation symbol in `full_calculation` list and reset `current_input` for the next input.
3. **Special Functions**:
- `handle_ac_button` clears all inputs and resets the application to its initial state.
- `handle_dec_button` adds a decimal point to the current input if not already present.
- `handle_pos_neg_button` toggles the current input between positive and negative.
4. **Calculation and Display**: The `handle_equal_button` function combines the inputs and operations stored in `full_calculation` and evaluates the expression using Python's `eval` function. It then updates the display to show the result. Error handling is included to display an error message in case of an invalid calculation.
5. **Dynamic Display Update**: The `update_display` function refreshes the calculator's display after each input or operation. It also dynamically adjusts the font size based on the length of the text to be displayed using the `dynamic_font_size` function.
6. **UI Layout and Design**: The layout includes two main canvas areas for displaying the last calculation and the current result, operational buttons (like AC, ±, %, ÷, x, -, +, =), a decimal button, and number buttons (0-9). The design is inspired by a concept on Dribbble, featuring a clean and modern look.
7. **Event Loop**: The Tkinter event loop (`mainloop()`) keeps the application running and responsive to user interactions.
Through this exercise, I learned how to create a functional and visually appealing calculator application in Python. It involved implementing logic for arithmetic operations, managing user input, updating the GUI dynamically, and ensuring a user-friendly experience.
## Day 33
### Projects (Day 33)
#### [33. Calculator GUI App v2 Upgrade](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-033/Projects/Calculator-App)
In this enhanced version of the EasyCalc calculator application, I incorporated several advanced features and functionalities, making it more versatile and user-friendly. This version includes theme cycling, expanded calculator view, and additional mathematical operations.
1. **Theme Cycling**: The application now supports multiple color themes, which can be cycled through using a dedicated function, `cycle_theme`. Themes are defined in the `THEMES` dictionary, and the `apply_theme` function applies the selected theme colors to the calculator's UI elements. This feature adds a customizable and dynamic visual appeal to the application.
2. **Expanded View**: I introduced an expandable calculator view, toggled by the `handle_expand_button`. When expanded, the calculator's width doubles, providing more space for additional features or future enhancements. The `fill_empty_spaces` and `remove_expanded_buttons` functions manage the appearance and removal of placeholder buttons in this expanded view.
3. **Additional Mathematical Operations**:
- **Square Root**: The `handle_sqrt_button` calculates the square root of the current input.
- **Exponentiation**: The `handle_exp_button` squares the current input.
- **Factorial**: The `handle_fact_button` calculates the factorial of the current input.
4. **Improved Operation Handling**: The `handle_operation` function has been generalized to handle different arithmetic operations, reducing repetitive code and enhancing maintainability.
5. **Dynamic Canvas Size**: The `get_canvas_width` function dynamically determines the canvas width based on whether the calculator is in expanded mode or not. This ensures that the display text is always correctly aligned.
6. **Keyboard Input Handling**: The application now responds to keyboard inputs, allowing users to interact with the calculator using their keyboard. The `on_key_press` function maps key presses to corresponding calculator functions, such as number entry, operations, and theme cycling.
7. **UI Update and Refactoring**: The user interface has been updated to accommodate the new features. I refactored the button creation process into the `create_button` function for better code organization and readability.
8. **Error Handling**: The application includes error handling for operations like square root and factorial to manage invalid inputs or calculations.
Through this upgrade, the calculator application has become more powerful and user-friendly, offering a variety of functionalities and a customizable interface. This project demonstrates the adaptability and scalability of Python and Tkinter in creating sophisticated GUI applications.
## Day 34
### Projects (Day 34)
#### [34. Quizzler Quiz App - GUI Application](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-034/Projects/Quizzler)
In this exercise, I developed a "Quizzler" application using Python, which is an interactive quiz app with a graphical user interface (GUI). The application fetches quiz questions from the Open Trivia Database API and presents them to the user in a true/false format.
1. **Data Fetching and Parsing (`data.py`)**:
- Uses the `requests` library to fetch quiz questions from an online API.
- The parameters specify the number of questions (`amount`) and their type (`boolean`).
- The fetched data is parsed into a JSON format, and the relevant `question_data` is extracted.
2. **Question Model (`question_model.py`)**:
- Defines a `Question` class to represent each quiz question, with attributes for the question text and the correct answer.
3. **Quiz Logic (`quiz_brain.py`)**:
- Implements the `QuizBrain` class to manage the quiz logic.
- It tracks the current question number, the user's score, and the list of question objects.
- The `still_has_questions` method checks if there are more questions to be asked.
- The `next_question` method retrieves the next question and formats it for display.
- The `check_answer` method compares the user's answer to the correct answer and updates the score accordingly.
4. **User Interface (`ui.py`)**:
- Builds the GUI for the quiz using Tkinter.
- Sets up a window with a title, score label, and a canvas to display questions.
- Includes 'True' and 'False' buttons for the user to submit their answers.
- The `get_next_question` method updates the display with the next question or shows the final score if the quiz is finished.
- The `true_pressed` and `false_pressed` methods handle button clicks and pass the user's answer to the quiz logic for validation.
- The `give_feedback` method provides visual feedback (changing the canvas color) based on whether the user's answer was correct or incorrect.
5. **Main Application Flow (`main.py`)**:
- Constructs a list of `Question` objects from the `question_data`.
- Initializes the `QuizBrain` with the question bank.
- Creates the `QuizInterface` object, passing the `QuizBrain` instance to it.
- After the quiz completes, it prints the final score to the console.
This project demonstrates the integration of various Python modules and concepts, such as API requests, object-oriented programming, and GUI development with Tkinter. The application offers a dynamic quiz experience, fetching different sets of questions each time it's run, and provides immediate feedback to users on their answers.
## Day 35
### Projects (Day 35)
#### [35. Quizzler Quiz App v2 Upgrade - GUI Application](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-035/Projects/Quizzler)
In this upgraded version of the "Quizzler" application, I introduced new features to enhance user interactivity and quiz customization. The application now includes category selection and difficulty level options, making the quiz experience more diverse and tailored to the user's preferences.
1. **Category Selection (`CategorySelector` in `ui.py`)**:
- A new class, `CategorySelector`, allows users to select a quiz category from a list fetched from the Open Trivia Database API.
- The user interface for category selection is created using Tkinter, featuring a dropdown menu to choose from various categories.
- The selected category ID is returned and used to fetch relevant quiz questions.
2. **Difficulty Selection (`DifficultySelector` in `ui.py`)**:
- The `DifficultySelector` class lets users choose the difficulty level of the quiz questions (easy, medium, or hard).
- This selection is reflected in the API request to fetch questions of the selected difficulty.
3. **Enhanced Data Fetching (`get_question_data` in `data.py`)**:
- The `get_question_data` function is now capable of fetching questions based on the chosen category and difficulty.
- If no questions are available for the selected category at the specified difficulty, the function iteratively checks for questions at lower difficulty levels.
4. **Main Application Flow with User Choices (`main.py`)**:
- The application flow now starts with the difficulty and category selection.
- If no questions are available for the selected combination, the user is prompted to select a different category.
- Once a valid set of questions is fetched, the quiz proceeds as in the previous version.
5. **Quiz Interface (`QuizInterface` in `ui.py`)**:
- The `QuizInterface` class remains the central part of the user interface, now starting after the user has made their selections.
- It handles question display, user responses, score updates, and provides visual feedback based on the correctness of the answers.
6. **Improved Error Handling and User Feedback**:
- The application includes enhanced error handling and user feedback, particularly when dealing with unavailable question categories or difficulties.
Through these upgrades, the Quizzler app has become more interactive and customizable. Users can now enjoy a more personalized quiz experience by selecting their preferred categories and difficulty levels. This project exemplifies the use of API integration, advanced GUI development with Tkinter, and logical structuring of an application to improve user experience and functionality.
## Day 36
### Projects (Day 36)
#### [36. Tic-Tac-Toe GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-036/Projects/Tic-Tac-Toe)
In this exercise, I developed a simple Tic-Tac-Toe game using Python and Tkinter. The application features a graphical user interface that allows two players to play the game by clicking on a grid to place their 'X' or 'O'.
1. **User Interface (`ui.py`)**:
- The `UserInterface` class creates the main window for the game with a title "Tic-Tac-Toe".
- A 3x3 grid of canvases is created where players can click to place their 'X' or 'O'.
- The `turn_label` displays which player's turn it is ('X' or 'O') with corresponding background color changes.
- The game randomly decides who starts first.
- Images for 'X' and 'O' are loaded and resized to fit the canvas.
2. **Game Interaction**:
- Players place an 'X' or 'O' by clicking left or right mouse buttons, respectively.
- The `place_x` and `place_o` methods handle these actions and update the canvas and the game state.
- After each move, the application checks if there is a winner using the `check_win` method.
3. **Winning Logic (`check_win` method)**:
- The method checks all possible winning combinations (rows, columns, diagonals) to see if either player has won.
- If a player wins, the `end_game` method is called to update the UI and disable further moves.
4. **Ending and Resetting the Game**:
- The `end_game` method changes the `turn_label` to show the winner and changes the background color to green.
- It unbinds click events to prevent further moves and displays a "REPLAY" button.
- The `reset_game` method is linked to the "REPLAY" button, which resets the game to its initial state for a new round.
5. **Main Application Flow (`main.py`)**:
- The main script initializes the `UserInterface` class, thereby starting the game.
Through this project, I learned how to build a basic interactive game using Tkinter, handle events, manage application state, and update the user interface based on game logic.
## Day 37
### Projects (Day 37)
#### [37. Habit Tracker App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-037/Projects/Habit-Tracker-App)
In this exercise, I developed a Habit Tracker application using Python, the Pixela API, and environment variables for secure token storage. The application allows users to track their daily habits by creating a graph on Pixela and updating it with their progress.
1. **Environment Variable Loading**:
- The `dotenv` library is used to load environment variables from a `.env` file. This is crucial for securely storing and accessing sensitive information like the Pixela API token.
2. **Pixela API Integration**:
- The Pixela API is used for creating a user account, generating graphs, and adding or updating "pixels" (data points) to track habits.
3. **User Registration**:
- A user account is created on Pixela with a predefined username and token. The user agrees to the terms of service and confirms they are not a minor (`agreeTermsOfService` and `notMinor`).
4. **Graph Creation and Configuration**:
- A graph is configured with specific settings like ID, name, unit of measurement, data type, and color. This graph is used to track the user's habit.
5. **Adding and Updating Pixels**:
- The application can add a new pixel to the graph for the current date, representing the completion of a habit for that day.
- The user can also update the quantity for a specific date's pixel, allowing them to modify their habit tracking data.
6. **Date Formatting**:
- The current date is formatted to match Pixela's required format (`%Y%m%d`) using Python's `datetime` module.
7. **HTTP Requests**:
- The `requests` library is used to make HTTP requests to the Pixela API. This includes creating a user, creating and configuring a graph, adding a new pixel, updating an existing pixel, and deleting a pixel.
- Each request includes appropriate headers for authentication using the user's token.
8. **Commented Requests**:
- Certain API request lines are commented out, indicating that they were likely used for testing purposes and are not part of the main application flow.
This Habit Tracker application demonstrates practical use of external APIs, secure handling of sensitive data using environment variables, and HTTP request handling in Python. It provides a foundation for building a habit tracking tool that can be further extended with more features like different types of habits, visualization of progress, or integration with other services.
## Day 38
### Projects (Day 38)
#### [38. Tic-Tac-Toe GUI App v2 Upgrade](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-038/Projects/Tic-Tac-Toe)
In the upgraded version of the Tic-Tac-Toe game, I introduced several new features to enhance gameplay and user experience. These include score tracking, round management, and determining the overall winner of a series of games.
1. **Score and Round Tracking**:
- The game now keeps track of scores for both 'X' and 'O' players, as well as the current round number.
- A new `score_canvas` is created at the top of the window to display the scores and round information.
2. **Visual Enhancements for Score Display**:
- The score display includes stylized rectangles and texts to indicate players' scores and the current round number.
- Different colors are used to represent each player ('red' for 'X' and 'blue' for 'O').
3. **Gameplay Mechanics**:
- The game still alternates turns between 'X' and 'O', with each player placing their mark by clicking the left or right mouse button.
- The `place_x` and `place_o` methods have been updated to check for a draw condition in addition to a win.
4. **Win and Draw Handling**:
- When a player wins a round, the game updates the respective player's score and displays a 'Next Round' button.
- In case of a draw, the game also indicates this outcome and displays the 'Next Round' button.
- The `end_draw_game` method handles the draw scenario, similar to the `end_game` method for winning.
5. **Next Round and Game Reset**:
- The `reset_game` method prepares the game for the next round by resetting the board and incrementing the round number.
- The scores are updated, and the game continues until one player wins two out of three rounds.
6. **Determining the Overall Winner**:
- The `check_game_over` method checks if either player has won two rounds and ends the overall game if so.
- The `end_whole_game` method displays the overall winner and changes the 'Next Round' button to 'Restart Game'.
7. **Restarting the Game**:
- The `restart_game` method resets the scores, round number, and the game board, allowing players to start a new series of games.
Through these upgrades, the Tic-Tac-Toe game has become more interactive and engaging, offering a competitive series of rounds and clear tracking of scores and rounds.
## Day 39
### Projects (Day 39)
#### [39. Rock Paper Scissors - GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-039/Projects/Rock-Paper-Scissors-App)
In this exercise, I developed a graphical user interface (GUI) for a Rock Paper Scissors game using Python's Tkinter library, along with a basic game logic implementation.
The `Game` class, defined in `game.py`, manages the game's core functionality. It keeps track of the player's and computer's scores and the possible choices ("rock", "paper", "scissors"). The class provides methods for the player's move, the computer's random move, calculating the result of a round, and retrieving the current scores.
In `ui.py`, the `UserInterface` class creates and manages the GUI for the game. This class uses Tkinter to build the window, including buttons for the player's choices (rock, paper, scissors) and a canvas to display the scores and results. The images for the buttons are loaded and resized using the `PhotoImage` class. I set up the layout using the `Canvas` widget and added text and rectangles to create a visually appealing interface.
The buttons for rock, paper, and scissors are linked to the `make_player_move` method, which in turn calls the `player_move` method from the `Game` class. This interaction triggers the game logic and updates the GUI with the results and updated scores. The method `update_game_canvas` displays the player's choice, the computer's choice, and the round result, while `update_score_canvas` updates the scores on the score canvas.
Mouse-over effects on the buttons are achieved using the `bind` method, changing the text color when the mouse hovers over them.
## Day 40
### Projects (Day 40)
#### [40. Rock Paper Scissors v2 Upgrade - GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-040/Rock-Paper-Scissors-App)
In this upgraded version of the Rock Paper Scissors game, I enhanced both the game logic and the user interface, adding new features and improving the overall user experience.
**Enhancements in Game Logic (`game.py`):**
1. **Reset Functionality:** I introduced a `reset` method in the `Game` class, which resets both the player's and the computer's scores to zero. This method is crucial for starting a new game after a game over scenario.
**Enhancements in User Interface (`ui.py`):**
1. **Visual Upgrades:** The UI has been visually enhanced with new colors and a round rectangle function, `round_rectangle`, which adds rounded rectangles to the canvas for a more polished look.
2. **Game Over Mechanism:** I added a `game_over` method that is triggered when either the player or the computer reaches a score of 5. This method displays the winner, disables the choice buttons, and adds a "Replay" button.
3. **Replay Functionality:** The "Replay" button is linked to a `reset_game` method that resets the game to its initial state, allowing for consecutive rounds of play without restarting the application.
4. **Dynamic Result Display:** The `update_game_canvas` method now includes more dynamic elements, such as highlighting the winner's choice and displaying a detailed result string.
5. **Improved Result String:** The `generate_result_string` method provides a more detailed description of the round's outcome, explaining which choice won over the other or if it was a draw.
**Key Learnings and Skills Applied:**
- **Advanced Tkinter Usage:** This version required a more sophisticated use of Tkinter widgets and methods, demonstrating an advanced level of GUI design.
- **Game State Management:** Managing the state of the game, especially with the addition of a reset function and a game over mechanism, required careful planning and implementation.
- **User Experience Design:** Attention to user experience was evident in the visual enhancements and the addition of clear game state messages and actions (like the "Replay" button).
- **Dynamic Content Update:** The ability to update the canvas dynamically based on game state and results showed an understanding of real-time GUI updates in response to user interactions.
## Day 41
### Projects (Day 41)
#### [41. Introduction to HTML](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-041/Projects/Introduction-to-HTML)
[Introduction to HTML - Image](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-041/041-intro-to-html.png)
In this exercise, I refreshed my knowledge of HTML by creating a simple webpage titled "Favorite Movie Tracker". This webpage serves as a platform to showcase someone named Jordan's top three movies of all time.
**Key Elements of the Exercise:**
1. **Basic HTML Structure:**
- The `` declaration defines the document as an HTML5 document.
- The `` element with a `lang` attribute set to `"en"` specifies that the document is in English.
- Inside the `` tag, there are two main sections: `` and ``.
2. **Head Section:**
- The `` section contains meta-information about the webpage.
- `` ensures that the document renders with UTF-8 encoding, which includes most characters from most human-written languages.
- `` makes the webpage responsive and optimized for mobile devices.
- The `` tag sets the title of the webpage as seen in the browser's title bar or tab.
3. **Body Section:**
- The `` tag encompasses the content of the webpage.
- I used heading tags (`
`, ``, ``) for titles and subtitles, creating a clear hierarchy of content.
- The `
` tag creates a thematic break or horizontal line, serving as a visual separator between sections.
- Paragraphs (`
`) provide descriptions of each movie, offering insights into why they are favored.
4. **Content Organization:**
- The webpage is organized in a clear and logical manner, with a main heading, a subheading, and individual sections for each movie.
- Each movie title is a subheading (`
`), followed by a paragraph describing the movie.
5. **Accessibility and SEO:**
- Using semantic HTML elements like `
`, ``, ``, and `
` improves accessibility and SEO, as these tags provide meaning and structure to the webpage.
**Main Reminders:**
- **HTML Syntax and Structure:** The importance of a well-structured HTML document, including doctype, language attribute, and the separation of the head and body sections.
- **Semantic Markup:** Using appropriate tags for headings and paragraphs to create a meaningful document structure.
- **Meta Tags:** The role of meta tags in defining the character set and ensuring mobile responsiveness.
- **Content Presentation:** How to present content in a clear, organized, and visually appealing manner using HTML.
This exercise served as a solid foundation for integrating web technologies in future projects, particularly in the context of Python web development. It emphasized the importance of starting with a strong HTML base to ensure a well-structured and accessible webpage.
### Exercises (Day 41)
#### [A. Heading Elements](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-041/Exercises/Heading-Element)
[Heading Elements - Image](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-041/041-heading-element.png)
In this exercise, I explored the basics of HTML, particularly focusing on using heading elements to structure content. The HTML document starts with the standard `` declaration and includes language, character encoding, and viewport meta tags in the `
` section, ensuring proper rendering and accessibility.
The main learning point was the use of different heading levels (`
` through ``) in the `` section. I created a hierarchy of headings to represent a book's structure: the `` tag for the book title, `` tags for chapters, `` tags for sections within chapters, and an `` tag for a diagram within a section.
This structure not only provided a clear visual representation of the book's organization but also demonstrated the semantic importance of using headings correctly in HTML. It highlighted how headings help in defining the document's structure and outline, making it more readable and accessible, especially for screen readers and search engines.
Overall, this exercise was an effective introduction to HTML headings and their role in creating well-structured, accessible web content.
#### [B. Paragraph Elements](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-041/Exercises/Paragraph-Element)
[Paragraph Elements - Image](https://github.com/itsjordanmuller/2023-python-100-days/blob/main/Day-041/041-paragraph-element.png)
In this HTML exercise, I learned how to use paragraph elements to structure text content within a webpage. The HTML document begins with the standard declaration and includes essential meta tags in the `` section, ensuring proper encoding and responsive design.
The key focus was on the `
` tag, used to define paragraphs in the `
` section. I created three distinct paragraphs, each enclosed in its own `` element. These paragraphs contained a block of Lorem Ipsum text, a common placeholder text in the design and typesetting industry.
This exercise demonstrated the importance of the paragraph element in HTML for organizing and presenting text content in a readable and structured manner. Using `
` tags helps in creating clear divisions between different blocks of text, enhancing the overall readability and aesthetic appeal of the webpage.
Through this task, I gained practical experience in formatting text content on a webpage, understanding the role of paragraph elements in HTML, and the significance of clean, well-organized content structure for user experience and accessibility.
#### [C. Void Elements](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-041/Exercises/Void-Elements)
In this HTML exercise, I learned about void elements, which are special HTML elements that do not require a closing tag. The exercise focused on two such elements: `
` and `
`.
The document structure follows the standard HTML5 template, including the DOCTYPE declaration, language attribute, character encoding, and viewport settings for responsiveness. The content is organized within the `` tag, starting with a `
` heading for the title "William Blake."
The first key learning was the use of the `
` (break) element within a paragraph. This element is used to create a line break in the text, which I applied in an address format. By inserting `
` tags after each line of the address, I was able to format the address properly, with each part starting on a new line.
The second key element was the `
` (horizontal rule) tag, which creates a thematic break or a horizontal line in the document. I used it to visually separate the address from the biographical paragraph about William Blake, enhancing the readability and aesthetic appeal of the page.
Through this exercise, I gained a practical understanding of how void elements work in HTML and how they can be used to format content effectively. It highlighted the importance of these elements in controlling the layout and flow of text on a webpage, contributing to a better user experience and content presentation.
## Day 42
### Projects (Day 42)
#### [42. Birthday Invite Project](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-042/Projects/Birthday-Invite-Project)
In this project, I created an HTML webpage for a birthday invitation. The goal was to design a simple yet engaging invitation that includes essential details about the birthday celebration.
1. **Basic HTML Document Structure:**
- I used the `` declaration to define the document as HTML5.
- The `` tag specifies that the content is in English, which is helpful for accessibility and search engine optimization.
2. **Head Section:**
- The `` ensures proper encoding of the text.
- `` makes the webpage responsive to various screen sizes.
- The `` tag sets "Birthday Invitation" as the page title.
3. **Body Section:**
- I used `
` and `` for the main headings, announcing the birthday and the date of the event.
- An image of a birthday cake, hosted externally, was embedded using the `![]()
` tag, complete with an `alt` attribute for accessibility.
- A list (``) with `- ` items was used to inform guests about what to bring to the party.
- For the location, I provided a Google Maps link using the `` tag, allowing guests to easily find the venue.
**Accessibility and User Experience:**
- **Alt Text for Image:** The alt text "A Birthday Cake with Lit Candles" describes the image, which is crucial for users who rely on screen readers.
- **Clear Instructions:** The list format for what to bring and the direct link to the location make the invitation user-friendly and informative.
**Learnings and Skills Applied:**
- **HTML Syntax and Tags:** I practiced using different HTML tags appropriately to structure content.
- **Embedding External Resources:** I learned how to embed external images and links into an HTML page.
- **Accessibility Considerations:** The importance of alt attributes and clear, descriptive text was reinforced.
- **Responsive Design Basics:** Using the viewport meta tag to ensure the invitation looks good on different devices.
This project served as a practical exercise in creating a functional and aesthetically pleasing webpage using HTML. It combined basic web development skills with a focus on user experience and accessibility.
### Exercises (Day 42)
#### [A. Anchor Elements](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-042/Exercises/Anchor-Elements)
In this exercise, I began to use anchor elements in HTML to create hyperlinks. The HTML document is structured with standard elements including the DOCTYPE declaration, meta tags for character encoding and viewport settings, and a meaningful title in the `` section.
The main focus was on creating a list of hyperlinks using the `
` (anchor) tag. The body of the document features a heading `` that introduces the list as "My Top 5 Favorite Websites." I then used an ordered list `` to enumerate the websites. Each list item `- ` contains an anchor element. The anchor elements are written as `Link Text`, where `href` is an attribute specifying the URL of the page the link goes to, and the link text is the clickable text that appears to the user.
For example, `Product Hunt` creates a hyperlink to the Product Hunt website, with "Product Hunt" as the clickable text. This pattern is repeated for each favorite website, creating an interactive list where each item is a link to a different website.
#### [B. Boilerplate](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-042/Exercises/Boilerplate)
In this exercise, I learned about the basic structure of an HTML document, often referred to as the "boilerplate". This boilerplate is the foundation for creating web pages and includes essential elements that define the document's type, language, character encoding, viewport settings, and the document title.
1. **DOCTYPE Declaration**: `` is the first line of the document, declaring the document type and version of HTML being used. In this case, it specifies HTML5, the latest standard.
2. **HTML Element with Language Attribute**: The `` tag defines the root of the HTML document and includes a language attribute (`lang="en"`) specifying that the document is in English. This is important for accessibility and search engine optimization.
3. **Head Section**: Inside the `` tag, several key elements are included:
- **Meta Charset**: `` sets the character encoding to UTF-8, which includes most characters from all known human languages, making the content more universally readable and preventing text display issues.
- **Meta Viewport**: `` is crucial for responsive web design. It ensures that the page scales correctly on different devices, especially on mobile screens.
- **Title**: `Document` sets the title of the web page, which appears in the browser tab and is used by search engines.
4. **Body Section**: The `` tag is where the content of the HTML document that will be visible to users is placed. In this boilerplate, the body is empty, serving as a placeholder for future content.
#### [C. Image Elements](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-042/Exercises/Image-Elements)
In this HTML exercise, I learned how to incorporate image elements into a webpage and use basic CSS for layout styling. The exercise focused on displaying two images, one of a kitten and one of a puppy, in a two-column layout.
1. **Image Elements**: The `![]()
` tag is used to embed images. Each image element has a `src` attribute specifying the URL of the image and an `alt` attribute providing alternative text for screen readers or in cases where the image cannot be displayed. For example, `
`.
2. **CSS Styling**: The `` tag in the head section contains CSS to style the webpage.
- The `.two-columns` class applies a flexbox layout to display content in two columns.
- The `.column` class ensures each column has equal width and margin.
- The `img` selector styles all images to have a maximum width of 100% of their container and automatic height to maintain aspect ratio.
This exercise was an excellent introduction to adding and styling images in HTML, demonstrating the use of the `<img>` tag and basic CSS. It highlighted the importance of responsive images in web design and provided practical experience in creating visually appealing and accessible web content.
#### [D. List Elements](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-042/Exercises/List-Elements)
In this HTML exercise, I learned how to create and format lists using unordered (`<ul>`) and ordered (`<ol>`) list elements. The exercise involved creating a web page for "Jordan's Cinnamon Roll Recipe," with sections for ingredients and instructions.
1. **Unordered Lists for Ingredients**: I used `<ul>` tags to create lists of ingredients for both the dough and the filling. Each ingredient is listed within a `<li>` (list item) tag. Unordered lists are typically used when the order of items is not important.
2. **Ordered List for Instructions**: The instructions are organized in an ordered list `<ol>`, where each step in the recipe is placed in a `<li>` tag. Ordered lists are appropriate here as the sequence of steps is crucial for the recipe's success.
3. **Section Headings**: The document uses `<h1>`, `<h2>`, and `<h3>` tags for headings and subheadings, providing a clear structure and hierarchy to the content.
#### [E. Nesting and Indentation](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-042/Exercises/Nesting-and-Indentation)
In this exercise, I learned about nesting and indentation, two crucial aspects of writing clean, readable, and well-structured HTML code. The exercise involved creating a list with multiple levels of nested sub-lists, demonstrating how elements can be nested within each other to represent hierarchical relationships in content.
1. **Nesting Elements**: The main list is an unordered list (`<ul>`), containing several list items (`<li>`). Within these list items, I nested ordered lists (`<ol>`) and additional unordered lists to create a hierarchy. For example, under the list item "B", there's an ordered list with items "B1" and "B2", and under "B2", there are further nested unordered lists with items "B2a", "B2b", etc.
2. **Proper Indentation**: Each nested element is indented relative to its parent element. This indentation is not just for aesthetics; it makes the structure of the HTML document clear and understandable. For instance, the nested lists under "B2" are indented more than "B2" itself, clearly showing their relationship in the hierarchy.
3. **Hierarchy Representation**: The exercise demonstrates how to represent hierarchical data in HTML using nested lists. The depth of nesting effectively shows the relationship between different items and sub-items.
This exercise was essential in understanding how nesting and indentation work in HTML, showing the importance of these practices in creating well-organized and easily navigable web content.
## Day 43
### Projects (Day 43)
#### [43. Color Vocabulary Project](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-043/Projects/Color-Vocab)
In the Color Vocabulary Project, I created a webpage to teach the colors in Spanish and styled it using CSS. The project involved linking an external CSS stylesheet to an HTML document and applying specific styles to elements within that document.
1. **HTML Structure:**
- The document starts with the standard `<!DOCTYPE html>` declaration and `<html lang="en">` tag.
- The `<head>` section includes a `<meta>` tag for character encoding, a `<title>` for the page, and a link to the external CSS file.
- The `<body>` contains `<h1>` and `<h2>` elements for headings and `<img>` tags for displaying images corresponding to each color.
2. **External CSS Stylesheet:**
- I created a separate CSS file and linked it to the HTML using `<link rel="stylesheet" href="./style.css" />`.
- This separation of content (HTML) and presentation (CSS) is a best practice in web development.
3. **CSS Styling:**
- Each color title (`<h2>` element with a class of `color-title`) received an individual color styling using its ID. For example, `h2#red { color: red; }` applies a red color to the text of the element with the ID `red`.
- The CSS rule `.color-title { font-weight: normal; }` sets the font weight of all elements with the class `color-title` to normal, overriding any default browser styles.
- For the images, I used the `img` selector to set a uniform width and height of 200px, ensuring consistency in the presentation of the images.
**Learnings and Skills Applied:**
- **CSS Selectors and Properties:** I practiced using different types of selectors (like element, class, and ID selectors) and properties (like `color`, `font-weight`, `width`, and `height`) to style the webpage.
- **External Stylesheets:** I learned how to link and apply an external stylesheet, separating the presentation from the HTML content.
- **Responsive Web Design Basics:** While this project did not delve deeply into responsiveness, setting specific sizes for images is a step towards understanding how elements are displayed on different devices.
This project was a practical application of CSS to add styles to a webpage. It reinforced the importance of using CSS for styling while keeping the HTML for content and structure, adhering to the principles of web development best practices.
### Exercises (Day 43)
#### [A. Adding CSS](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-043/Exercises/Adding-CSS)
In this exercise, I explored the three primary methods of adding CSS to an HTML document: inline, internal, and external styling. Each method has its own use cases and benefits.
1. **Inline CSS**:
- In `inline.html`, CSS is applied directly to HTML elements using the `style` attribute.
- Example: `<h1 style="color: blue">Style Me in Blue!</h1>` applies a blue color to the heading.
- Inline CSS is useful for quick, one-off styling but lacks scalability and can lead to cluttered HTML.
2. **Internal CSS**:
- In `internal.html`, CSS is included within a `<style>` tag in the `<head>` section of the HTML document.
- Example: `h1 { color: red; }` styles all `<h1>` elements in red.
- Internal CSS is good for single-page styles but doesn't promote reuse across multiple pages.
3. **External CSS**:
- In `external.html`, CSS is defined in a separate file (`style.css`) and linked to the HTML document using a `<link>` tag.
- Example: The `style.css` file contains `h1 { color: green; }`, which styles all `<h1>` elements in green.
- External CSS is the most efficient method for styling large websites, as it keeps HTML and CSS separate and allows for style reuse across multiple pages.
This exercise was instrumental in understanding the different ways to apply CSS to HTML documents. It highlighted the importance of choosing the appropriate method based on the project's scope and the need for maintainability and scalability in web development. It also demonstrated how CSS enhances the visual presentation of web pages, making them more appealing and user-friendly.
#### [B. CSS Selectors](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-043/Exercises/CSS-Selectors)
In this exercise, I learned about different types of CSS selectors and how they are used to apply styles to HTML elements. The HTML document `index.html` provided the structure to demonstrate each selector type, and the corresponding CSS in `style.css` applied specific styles based on these selectors.
1. **Element Selector**:
- Targets elements based on their HTML tag name.
- Example: `p { color: red; }` applies red color to all paragraph (`<p>`) elements.
2. **Class Selector**:
- Targets elements based on the value of their `class` attribute.
- Example: `.note { font-size: 20px; }` sets the font size to 20px for all elements with a class of "note".
3. **ID Selector**:
- Targets an element based on the value of its `id` attribute.
- Example: `#id-selector-demo { color: green; }` applies green color to the element with the id "id-selector-demo".
4. **Attribute Selector**:
- Targets elements based on their attributes and values.
- Example: `li[value="4"] { color: blue; }` applies blue color to `<li>` elements that have the `value` attribute set to "4".
5. **Universal Selector**:
- Targets all elements.
- Example: `* { text-align: center; }` centers the text of all elements on the page.
## Day 44
### Projects (Day 44)
#### [44. Motivational Meme Website](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-044/Projects/Motivation-Meme-Site)
In the Motivational Meme Project, I created a simple yet visually striking webpage that displays a motivational meme. The project involved using HTML for the structure and external CSS for styling, with specific design requirements.
1. **HTML Structure:**
- The HTML document begins with the `<!DOCTYPE html>` declaration and uses the `<html lang="en">` tag.
- In the `<head>`, I included meta tags for character encoding and responsiveness, the page title, and a link to the external CSS file.
- The `<body>` contains a `<div>` with the class `container`, which wraps an `<img>` tag for the meme image, an `<h1>` for the main text, and a `<p>` for the subtitle.
2. **CSS Styling:**
- I imported the 'Libre Baskerville' font from Google Fonts using `@import url(...)`.
- Global margins were reset to zero for consistency across browsers (`* { margin: 0; }`).
- The body background was set to black with white text (`background-color: #000; color: #fff;`).
- The `.container` class styles the div to center its content using flexbox, with a top margin of 50px for spacing.
- The image received a 5px solid white border and was set to fill its container (`border: 5px solid #fff;`).
- The `<h1>` was styled with the 'Libre Baskerville' font, uppercase text, and specific margins and font size for visual impact.
- The paragraph's font size was set to enhance readability.
- **HTML and CSS Integration:** I practiced integrating HTML and CSS to create a web design that meets specific aesthetic requirements.
- **Font Importing and Usage:** I learned how to import and use a custom font from Google Fonts.
- **Flexbox for Layout:** The use of flexbox for centering content demonstrated a fundamental skill in CSS layout techniques.
- **CSS Properties and Selectors:** I employed various CSS properties (`text-transform`, `margin`, `border`, `font-family`, `background-color`, `color`) and selectors to style the webpage.
- **Responsive Design Principles:** Although not extensively covered, the use of `meta viewport` tag hints at responsive design practices.
This project was a hands-on exercise in creating a visually appealing webpage that conveys a simple message through a combination of text and imagery. It showcased how CSS can significantly enhance the presentation of HTML content.
### Exercises (Day 44)
#### [A. CSS Box Model](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-044/Exercises/CSS-Box-Model)
In this HTML and CSS exercise, I explored the CSS Box Model, a fundamental concept in web design that defines how different parts of a webpage's layout work together. The exercise involved creating three boxes with different styles to understand how padding, borders, and margins interact.
1. **Box Creation and Sizing**:
- Three `<div>` elements with the class `.box` were created, each set to a height and width of 200px.
2. **Styling and Background Colors**:
- Each box was given a distinct background color (`cadetblue`, `gold`, and `indianred`).
3. **Padding and Border**:
- The first box (`.green`) was styled with 20px padding and a 10px solid black border.
- The paragraph inside the first box had its margin set to 0 to remove any default spacing.
4. **Different Border Sizes**:
- The second box (`.yellow`) had a varying border thickness, with 20px on the top and bottom, and 10px on the left and right sides.
5. **Margin Adjustment**:
- Margins were adjusted to ensure the corners of each box touched. The `.yellow` box was shifted to the right by setting its left margin to 260px, and the `.red` box was slightly shifted by setting its left margin to 40px.
#### [B. CSS Colors](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-044/Exercises/CSS-Colors)
In this exercise, I learned about applying different color styles using CSS. The exercise involved styling the background of the webpage and the text and background colors of headings (`<h1>` and `<h2>`).
1. **Webpage Background Color**:
- The background of the entire webpage was set to "antiquewhite" using `body { background-color: antiquewhite; }`. This changes the background color of the entire page.
2. **Heading (`<h1>`) Styles**:
- The `<h1>` element was styled with two color properties: `color: whitesmoke;` for the text color and `background-color: darkseagreen;` for the background color of the heading.
3. **Heading (`<h2>`) Styles**:
- The `<h2>` element received a similar treatment with different colors: `color: #faf8f1;` for the text color (using a hex color code) and `background-color: #c58940;` for the background color.
These styles were directly applied within a `<style>` tag in the head of the HTML document, demonstrating how CSS can be used to enhance the visual presentation of web content.
This exercise was particularly useful for understanding how to use CSS for coloring and how different color formats (like named colors, hex codes) can be applied in web design. It highlighted the importance of color in creating visually appealing and accessible web pages.
#### [C. Font Properties](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-044/Exercises/Font-Properties)
In these exercises, I learned about various font properties in CSS, how to apply them, and their effects on the appearance of text in a webpage. The exercises were divided into two parts: exploring different font sizes and experimenting with various font families.
1. **Font Properties (index.html)**:
- **Color**: The `color` property was used to change the text color of a paragraph to coral.
- **Size**: The `font-size` property, using `rem` units, was applied to change the size of the text to twice the root font size.
- **Weight**: The `font-weight` property was set to 900, making the text bold.
- **Family**: The `font-family` property was used to apply the Google font "Caveat" to a paragraph.
- **Align**: The `text-align` property was used to right-align a paragraph.
2. **Font Size (font-size.html)**:
- This part of the exercise involved using different units for font sizes, including pixels (`px`), points (`pt`), `em`, and `rem`.
- The `font-size` property was applied to various paragraphs to demonstrate how each unit influences the size of the text.
3. **Font Family (font-family.html)**:
- This exercise demonstrated the use of various font families, including Helvetica, Arial, serif, sans-serif, cursive, monospace, and fantasy.
- Each paragraph was styled with a different `font-family` value to showcase the appearance of these font styles.
Through these exercises, I gained a practical understanding of how different CSS font properties and units can be used to control the appearance of text on a webpage.
I learned about the significance of choosing the right font size, weight, and family for enhancing readability and the aesthetic appeal of web content. Additionally, it provided insight into how different units like pixels, points, em, and rem are used in defining font sizes and how they relate to each other and the parent or root elements.
## Day 45
### Projects (Day 45)
#### [45. 100 Movies You Must Watch](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-045/Projects/100-Movies-You-Must-Watch)
In this exercise, I learned how to use Python to scrape movie titles from a web page and manipulate the data. Here's a summary of what was done:
1. Imported necessary libraries:
- Imported `BeautifulSoup` from the `bs4` library to parse HTML.
- Imported `requests` to send HTTP requests and retrieve the web page's content.
2. Sent a GET request to a web page:
- Used the `requests.get()` method to retrieve the content of a web page. The URL used was for a page listing 100 must-watch movies.
3. Created a BeautifulSoup object:
- Used BeautifulSoup to parse the HTML content obtained from the web page.
4. Selected HTML elements:
- Used the `soup.select()` method to select HTML elements that matched a specific CSS selector. The selector was `.article-title-description__text .title`, which targeted movie titles on the page.
5. Extracted movie titles:
- Iterated through the selected HTML elements and extracted the text content of each movie title using `movie.getText()`.
- Appended each movie title to the `movie_texts` list.
6. Wrote movie titles to a text file:
- Opened a file named "movies.txt" in append mode and wrote each movie title followed by a newline character.
7. Read movie titles from the text file:
- Opened "movies.txt" in read mode and read the movie titles into the `movies` list using `f.readlines()`.
8. Reordered movie titles:
- Reversed the order of movie titles in the `movies` list using slicing (`movies[::-1]`) to have them in reverse order.
9. Wrote reordered movie titles to a new text file:
- Opened a new file named "reordered_movies.txt" in write mode and wrote the reversed movie titles to this file.
Overall, this exercise demonstrated web scraping, HTML parsing, file handling, and data manipulation in Python. The end result is a text file containing the 100 must-watch movies in reverse order.
### Exercises (Day 45)
#### [A. Parsing HTML and Making Soup](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-045/Exercises/Parsing-HTML-Making-Soup)
In this exercise, I explored web scraping in Python using the BeautifulSoup library and requests module. The exercise was divided into two main parts.
First, I used `requests.get()` to fetch the HTML content of a webpage (in this case, Hacker News). By printing `response.text`, I was able to see the HTML structure of the webpage, which is essential for scraping data.
Next, the exercise focused on parsing local HTML content. This was done by reading a local HTML file named `website.html`, which contains a simple personal site structure. I used `BeautifulSoup` to parse this HTML content.
Several key functionalities of BeautifulSoup were demonstrated:
1. Accessing and printing the page title using `soup.title.name` and `soup.title.string`.
2. Formatting and viewing the prettified HTML structure with `soup.prettify()`.
3. Extracting the first anchor tag using `soup.a`.
4. Finding and iterating over all anchor tags with `soup.find_all(name="a")` to print their href attributes.
5. Locating specific elements by HTML tags and attributes, like `soup.find(name="h1", id="name")` for an `<h1>` tag with a specific id.
6. Using CSS selectors to find elements, such as `soup.select_one(selector="p a")` and `soup.select(selector=".heading")`.
Through this exercise, I learned how to scrape and parse web page data, manipulate HTML content, and extract specific information using BeautifulSoup's various methods. This is a foundational skill in web scraping, enabling the extraction of data from web pages for analysis or data gathering purposes.
#### [B. Scraping a Live Site](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-045/Exercises/Scraping-a-Live-Site)
In this exercise, I learned to scrape live website data using BeautifulSoup and requests in Python. The primary objective was to extract article titles and their corresponding links from the Hacker News website.
Here's a breakdown of what I did:
1. **Fetching Web Page Content**: I used `requests.get("https://news.ycombinator.com/news")` to send an HTTP request to the Hacker News website and stored the response, which is the HTML content of the page, in `yc_web_page`.
2. **Creating a BeautifulSoup Object**: Next, I passed `yc_web_page` to `BeautifulSoup` with the parser `html.parser`. This created a BeautifulSoup object (`soup`) that represents the parsed HTML, making it easier to navigate and search the document structure.
3. **Selecting Specific Elements**: The goal was to find all article titles and their URLs. To achieve this, I used `soup.select(selector=".titleline > a")` to select all `<a>` tags that are direct children of elements with the class `titleline`. This CSS selector effectively targeted the links of the articles.
4. **Extracting Text and URLs**: I initialized two lists, `article_texts` and `article_links`, to store the titles and URLs, respectively. Then, I looped through the tags obtained in the previous step. For each tag, I used `tag.getText()` to get the article title and `tag.get("href")` to get the URL. These values were appended to the respective lists.
5. **Printing the Results**: Finally, I printed `article_texts` and `article_links` to see the extracted information.
This exercise was an excellent practice in live web scraping, particularly in using CSS selectors to precisely target HTML elements and extracting relevant information from a real-world website.
## Day 46
### Projects (Day 46)
#### [46. Billboard Hot 100 Playlist Creator - CLI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-046/Projects/Billboard-Hot-100)
In this Python script, I learned how to scrape Billboard Hot 100 data for a specific date, search for corresponding tracks on Spotify, and create a playlist. Here's a summary of what was done:
1. **Setting up the Environment**:
- The script begins by importing necessary libraries, including `os`, `requests`, `json`, `BeautifulSoup`, and `spotipy`. It also loads environment variables using the `dotenv` library.
2. **Directory and File Handling**:
- The script defines a base directory for storing scraped data and checks if it exists. If not, it creates the directory.
- It defines functions to extract the date from a URL, save scraped data to files, and load scraped data from files.
3. **User Input**:
- The script prompts the user to input a year, month, and day to construct the URL for the Billboard Hot 100 chart for a specific date.
4. **Scraping Billboard Data**:
- It checks if data for the specified date has been scraped before. If not, it sends an HTTP request to the Billboard website, retrieves the HTML content, and saves it to a file.
- It uses BeautifulSoup to parse the HTML content and extracts song titles and artists from the chart.
5. **Spotify Integration**:
- The script initializes the Spotify API using the `spotipy` library, providing the client ID and secret.
- It defines a function to search for Spotify tracks based on song title and artist.
- It iterates through the scraped song data, searches for each song on Spotify, and collects the Spotify track IDs.
6. **Playlist Creation**:
- The script asks the user if they want to create a playlist on Spotify. If the user agrees, it creates a private playlist with the name "Billboard Top 100 - {date_string}" and adds the collected track IDs to the playlist.
- It uses the Spotify OAuth flow to authenticate and obtain the necessary permissions.
7. **User Interaction**:
- Throughout the script, there are user prompts and messages to guide the user and obtain their input.
Overall, this script demonstrates web scraping, API integration (Spotify), file handling, and user interaction in Python. It allows users to create Spotify playlists based on the Billboard Hot 100 chart for a specific date.
## Day 47
### Projects (Day 47)
#### [47. Amazon Price Tracker](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-047/Projects/Amazon-Price-Tracker)
The code you provided is a Python script for an Amazon Price Tracker. This script allows users to track the prices of items on Amazon and perform various actions such as viewing tracked items, adding new items to track, modifying or removing tracked items, and exiting the program. Here's a breakdown of the key functionality and components of the code:
1. **Data Directory and Items File**:
- The script defines a `DATA_DIR` variable to specify the directory where data related to tracked items will be stored.
- An `ITEMS_FILE` variable is defined to specify the path to the JSON file (`items.json`) where information about tracked items is stored.
2. **Functions**:
- Several functions are defined in the script to handle different aspects of the price tracking process:
- `load_items()`: Loads tracked items from the `items.json` file, returning an empty list if the file does not exist.
- `save_items(items)`: Saves a list of tracked items to the `items.json` file.
- `add_item()`: Allows users to add a new item to track by providing the item's name, Amazon URL, and desired price.
- `view_items()`: Displays a list of tracked items and their details, allowing users to choose specific items to check their prices.
- `check_prices(selected_items)`: Retrieves and checks the current prices of selected items on Amazon, updating their price history and notifying users if the price drops to or below the desired price.
- `modify_item()`: Allows users to modify or delete an existing tracked item, including options to change the item's name, Amazon URL, desired price, or delete the item entirely.
- `exit_program()`: Exits the program with a farewell message.
3. **Main Program Loop**:
- The script runs a while loop to continuously present the user with a menu of options.
- The user can select one of the following options:
1. View all items and check prices.
2. Add a new item to track.
3. Modify or remove an item.
4. Exit the program.
4. **User Input and Actions**:
- The user's input is used to determine which action to perform.
- Based on the user's choice, the corresponding function is called to execute the selected action.
5. **Data Storage**:
- Tracked items and their details are stored in a JSON file (`items.json`) in the specified data directory.
- The price history of each tracked item is updated when the prices are checked.
6. **User Interface**:
- The script provides a simple command-line interface for user interaction.
This script serves as a basic Amazon price tracking tool, allowing users to keep an eye on the prices of items they are interested in purchasing and receive notifications if the price drops to their desired level. Users can manage their tracked items and perform various actions to keep their tracking list up to date.
## Day 48
### Projects (Day 48)
#### [48. Cookie Clicker Automation](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-048/Projects/Cookie-Clicker)
The code you provided is for automating the Cookie Clicker game using Selenium, a web automation library for Python. Cookie Clicker is an incremental game where the player clicks on a big cookie to earn "cookies" and can use these cookies to purchase various upgrades and items. The script simulates clicking the cookie and purchasing items in an automated manner. Here's a breakdown of the code:
1. **Import Statements**:
- The script imports the necessary modules, including `time`, `webdriver` from `selenium`, and `By` from `selenium.webdriver.common.by`.
2. **Chrome WebDriver Configuration**:
- Chrome WebDriver is configured with some options. The `add_experimental_option("detach", True)` option is used to keep the Chrome window open even after the script finishes execution.
3. **Web Page Access**:
- The script launches a Chrome browser using the WebDriver and navigates to the Cookie Clicker game's URL: "https://orteil.dashnet.org/experiments/cookie/".
4. **Variables**:
- `cookie`: The script finds the HTML element with the ID "cookie," which represents the clickable cookie in the game.
- `money`: A variable to keep track of the in-game currency (cookies) earned.
- `milliseconds_between_clicks`: The time interval (in milliseconds) between each click on the cookie.
5. **Main Loop**:
- The script enters an infinite loop using `while True`.
6. **Cookie Clicking**:
- Within the loop, the script simulates clicking on the cookie element using `cookie.click()`.
- It then sleeps for a short duration (`milliseconds_between_clicks / 1000`) before the next click to control the clicking rate.
7. **Purchase Items**:
- The script searches for store items that are available for purchase using the CSS selector `#store div:not(.grayed)`. These items are represented as HTML `div` elements that are not grayed out (i.e., they can be purchased).
- It attempts to click on each store item. If clicking the item fails (e.g., if the player doesn't have enough cookies), it prints an error message and continues to the next item.
8. **Update Money**:
- The script finds the element with the ID "money" and extracts the player's current money (cookie count) as a floating-point number. It cleans up the extracted text by removing commas and splitting it to get the numerical value.
9. **Final Output**:
- The script continuously loops, accumulating cookies and purchasing items as long as it runs. The final money (cookie count) is never printed because the script remains in the infinite loop.
10. **Termination**:
- The script doesn't have a termination condition to exit the infinite loop. To stop the script, you would typically need to manually terminate the execution.
Please note that the script is designed to continuously play the Cookie Clicker game until manually stopped, and it doesn't have a specific goal or termination condition. You can add a condition to exit the loop when a certain goal is reached, or you can manually stop the script when you're satisfied with the progress. Additionally, consider adding a delay between purchasing items to make it more realistic and efficient.
### Exercises (Day 48)
#### [A. Selenium Basics](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-048/Exercises/Selenium%20Basics)
In this exercise, I learned the basics of web automation using Selenium, a powerful tool for controlling web browsers through programs. The task involved interacting with the PyPI (Python Package Index) website to extract information about a specified Python package.
Here's what I did:
1. **Setting Up Selenium WebDriver**: I imported necessary modules from Selenium and set up Chrome WebDriver with certain options, including `chrome_options.add_experimental_option("detach", True)` to keep the browser window open after the script execution.
2. **User Input for Package Name**: I used `input()` to prompt for and capture the name of a Python package from the user.
3. **Navigating to the Package Page**: Using `driver.get()`, I navigated to the specific page for the user-specified package on PyPI by appending the package name to the base URL.
4. **Extracting Package Information**: I used `driver.find_element()` with various CSS selectors to locate and extract information from the web page. This included the package's name, pip install command, release date, description, and maintainers. For maintainers, I used `driver.find_elements()` to gather multiple elements and then processed them into a list of maintainer names.
5. **Interacting with Elements**: I demonstrated how to interact with a button on the page (`copy_btn.click()`) and how to use the search function by sending keys to the search input field, including simulating an Enter key press with `Keys.ENTER`.
6. **Printing Extracted Data**: I formatted and printed the extracted data to the console, showing details like the package name, installation command, release date, description, and maintainers.
7. **Browser Control**: Although commented out, the code included options to either close the current tab (`driver.close()`) or the entire browser instance (`driver.quit()`).
Through this exercise, I gained hands-on experience in using Selenium for web scraping and automation. I learned how to navigate web pages, select elements based on their attributes, interact with page elements like buttons and input fields, and extract text data from a website. This is highly useful for tasks that require automation of browser activities, such as testing web applications, automating repetitive web tasks, or scraping data from websites that require interaction.
## Day 49
### Projects (Day 49)
#### [49. Color Madness Game](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-049/Projects/Color-Madness)
In this exercise, I developed a "Color Madness" game using Python, involving concepts like GUI creation with Tkinter, working with colors and events, and data handling.
The game features a user interface where players select the color that best describes the color shown in a circle. This interface is created using Tkinter, with different components like buttons and canvases for display and interaction.
Key concepts covered include:
1. **Tkinter for GUI:** I used the Tkinter library to create the game's graphical interface. This included setting up windows, canvases for drawing shapes (like the color circle), and buttons for user interaction.
2. **Color Handling:** The `colors.py` module contains a dictionary mapping color names to their hexadecimal codes. I also wrote a function, `get_random_color()`, to generate random color codes. This was crucial for the game's functionality, as it provided the random colors displayed to the player.
3. **Event Handling:** The game reacts to user inputs, like clicking buttons. Each button is linked to a function that logs the color choice and updates the game state. Special attention was given to the "Black" color button, changing its text color on mouse hover for better visibility.
4. **Data Storage and Retrieval:** I implemented functions to save and load color choices made by players. This data is stored in a JSON file, allowing the game to remember past choices and use them for future color suggestions.
5. **Color Comparison Logic:** The game includes a method to calculate the 'distance' between two colors. This is used to suggest two colors closest to the current one displayed in the game, helping guide the player's choices.
6. **Dynamic UI Updates:** The game dynamically updates the color displayed in the circle and the color suggestions based on user interactions and internal logic.
Through this project, I gained practical experience in building an interactive game with Python, handling colors and user events, working with external files for data storage, and dynamically updating the UI based on program logic and user inputs.
## Day 50
### Projects (Day 50)
#### [50. Billboard Hot 100 Playlist Creator v2 Upgrade - GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-050/Projects/Billboard-Hot-100)
In this upgraded version of the Billboard Hot 100 playlist creator, a graphical user interface (GUI) has been added using the `tkinter` library to provide a more user-friendly experience. Here's a summary of the main features and changes in the code:
**main.py**:
1. **UserInterface Class**:
- The `main.py` script now includes a `UserInterface` class that handles the GUI components.
- The class initializes the main window, sets its title, and configures its dimensions.
- It creates a header canvas for displaying the Billboard Hot 100 logo and title.
- It creates a calendar canvas for selecting the date.
- It includes instructions and a calendar widget for date selection.
- It updates a label to display the selected date.
- It binds the `<<CalendarSelected>>` event to a method that updates the selected date label.
2. **Control Canvas**:
- The script creates a control canvas on the right side of the window.
- It includes buttons for searching songs and creating playlists.
3. **Button Actions**:
- The "Search Songs" button is linked to a `search` method in the `UserInterface` class.
- The "Create Playlist" button is currently set to the same `search` method. However, it can be customized to create a playlist in the future.
4. **Calendar Integration**:
- The selected date from the calendar is displayed in the GUI.
- When the "Search Songs" button is clicked, it currently prints "Searching for Songs, Please Wait..." to the console.
**ui.py**:
1. **User Interface Elements**:
- This script defines the structure and appearance of the user interface elements using `tkinter`.
2. **Canvas Widgets**:
- It creates canvas widgets for displaying the Billboard logo, date selection, and control buttons.
3. **Buttons**:
- It defines buttons for "Search Songs" and "Create Playlist." The "Create Playlist" button is currently commented out.
4. **Event Handling**:
- The `on_date_selected` method updates the selected date label when a date is chosen in the calendar.
5. **Update Selected Date Label**:
- The `update_selected_date_label` method sets the text of the selected date label based on the chosen date.
6. **Search Method**:
- The `search` method is called when the "Search Songs" button is clicked. It currently prints a message to indicate that the search process has started.
Overall, this upgraded version provides a visual interface for users to select a date and initiate the search for Billboard Hot 100 songs. The "Create Playlist" button can be further developed to create Spotify playlists based on the selected date and searched songs.
## Day 51
### Projects (Day 51)
#### [51. Billboard Hot 100 Playlist Creator v3 Upgrade - GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-051/Projects/Billboard-Hot-100)
In this upgraded version (V3) of the Billboard Hot 100 playlist creator, the code structure has been further modularized and organized into separate files. Here's a summary of the main features and changes in the code:
**main.py**:
1. **GUI Initialization**:
- The `GUI` class from the `gui.py` module is imported and instantiated to create the graphical user interface.
**gui.py**:
1. **GUI Class**:
- This class defines the graphical user interface for the application.
- It includes labels, entry fields, buttons, and status labels to interact with the user.
- Users can enter the year, month, and day, click buttons to perform actions, and receive status updates.
- The `search_date`, `search_songs`, and `create_playlist` methods are defined to handle user interactions and actions.
**scrape.py**:
1. **Scraper Class**:
- This class, named `Scraper`, is responsible for scraping Billboard Hot 100 data and creating Spotify playlists.
- It initializes the Spotify API with the provided credentials and stores scraped data.
- The `scrape` method retrieves Billboard data and saves it to a JSON file.
- The `create_playlist` method creates a Spotify playlist based on the scraped data.
- The `search_track` method searches for Spotify tracks based on song and artist names.
**Summary**:
- The code has been modularized into separate files for better organization and readability.
- The graphical user interface allows users to input a date, search for songs, and create playlists.
- Status labels provide feedback to the user at each step of the process.
- The core functionality of scraping and playlist creation is encapsulated within the `Scraper` class.
- Spotify API credentials are loaded from environment variables.
This version provides a more organized and maintainable code structure while retaining the functionality of the Billboard Hot 100 playlist creator with a graphical user interface.
## Day 52
### Projects (Day 52)
#### [52. Billboard Hot 100 Playlist Creator v4 Upgrade - GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-052/Projects/Billboard-Hot-100)
In this upgraded version (V4) of the Billboard Hot 100 playlist creator, several improvements and enhancements have been made to the graphical user interface (GUI) and code structure. Here's a summary of the key features and changes:
**main.py**:
1. **GUI Initialization**: The `GUI` class from the `gui.py` module is instantiated to create the graphical user interface.
**gui.py**:
1. **GUI Redesign**: The GUI has been redesigned for a more user-friendly experience with new features.
2. **Date Selection**: Users can select a date using the calendar or manually input the year, month, and day.
3. **Real-Time Date Updates**: The selected date is displayed in real-time as users interact with the calendar or input fields.
4. **Date Validation**: Input fields have been enhanced with validation to ensure valid date entries.
5. **Buttons and Status Labels**: Buttons for searching the date, searching songs, and creating a playlist have been added. Status labels provide feedback on the actions.
6. **Entry Update Handling**: The `entry_updated` method updates the calendar and selected date label when an entry field is updated.
7. **Initial Values**: The current date is set as the initial selected date, and year, month, and day entry fields are populated accordingly.
8. **Improved Layout**: The layout and organization of elements have been improved for a cleaner look.
**scrape.py**:
1. **No Significant Changes**: The `Scraper` class, responsible for scraping Billboard Hot 100 data and creating Spotify playlists, remains largely unchanged from the previous version.
**Summary**:
- The GUI has been redesigned to provide a more intuitive date selection process.
- Real-time date updates make it easier for users to visualize the selected date.
- Input fields are validated to prevent invalid date entries.
- Buttons and status labels provide clear feedback to the user during each step of the process.
- The core functionality of scraping and playlist creation remains the same, encapsulated within the `Scraper` class.
This upgraded version (V4) of the Billboard Hot 100 playlist creator offers an improved user interface and experience, making it more user-friendly and visually appealing.
## Day 53
### Projects (Day 53)
#### [53. BMI Calculator v3 Upgrade - GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-053/Projects/BMI%20Calculator%20GUI%20App)
In the development of the BMI Calculator V3, I further advanced my skills in creating interactive and user-friendly applications with Python, particularly using Tkinter for graphical user interface (GUI) design.
1. **Graphical User Interface (GUI) with Tkinter**: Unlike previous versions, V3 features a full-fledged GUI. I used Tkinter to create various elements such as canvases for displaying information, and buttons for user interaction.
2. **Layout and Design**: The application's layout includes multiple sections for displaying BMI, age, weight, height, and gender. Each section is created using a `Canvas` widget, and carefully placed using grid layout management in Tkinter. This helped me learn how to organize visual elements in a GUI effectively.
3. **Static Display Elements**: This version showcases static elements like text and rectangles within the canvases. These elements display predefined information like "BMI CALCULATOR" or "BODY MASS INDEX", and are essential for guiding the user through the application.
4. **Dynamic Content Representation**: The application includes placeholders for dynamic content, such as BMI value and health category, which are intended to be updated based on user input. This demonstrates the concept of dynamic content in GUI applications, even though the current version doesn't implement the functionality to update these values in real-time.
5. **Stylized UI Components**: I learned to apply basic styling to the UI components, such as colors, fonts, and shapes, to make the interface more appealing and user-friendly. For instance, the use of different colors for text and backgrounds, and creating oval buttons for interactions.
6. **Interactivity Foundations**: The application lays the foundation for interactivity, with elements like oval shapes in the `gender_canvas` and `height_canvas` that resemble buttons. This is a stepping stone towards making the application interactive in future iterations.
7. **Understanding GUI Constraints**: While this version showcases the design aspect of a BMI calculator, it does not yet implement the interactive functionalities like taking user inputs and calculating BMI. This highlighted the importance of not just designing a GUI but also integrating backend logic for a fully functional application.
In summary, BMI Calculator V3 was an insightful step into the world of GUI development with Python. It provided a hands-on experience in designing user interfaces with Tkinter, arranging and styling UI components, and setting up a framework for future interactive capabilities.
## Day 54
### Projects (Day 54)
#### [54. Create Your Own Python Decorator](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-054/Projects/Create%20Your%20Own%20Python%20Decorator)
In this lesson, I created my own Python decorator to measure the execution time of different functions. Here's a summary of what I did and learned:
1. **Understanding Decorators**: A decorator in Python is a function that extends the behavior of another function without explicitly modifying it. Decorators are a powerful feature in Python, allowing for clean and reusable code.
2. **Setting Up the Decorator**:
- I defined a decorator function `speed_calc_decorator` which takes another function as its argument.
- Inside the decorator, I defined an inner function `time_difference` that calculates the time before and after calling the passed function.
3. **Measuring Execution Time**:
- In `time_difference`, I used `time.time()` to get the current time in seconds before and after the execution of the function.
- I calculated the difference in these times, which gives the execution time of the function.
4. **Displaying Results**: After executing the function, `time_difference` prints the name of the function and its execution time in seconds.
5. **Applying the Decorator**:
- I applied the `speed_calc_decorator` to two functions, `fast_function` and `slow_function`, using the `@` syntax.
- Each of these functions performs a simple computation in a loop, with `slow_function` running a longer loop and expectedly taking more time.
6. **Testing the Functions**: I called both `fast_function` and `slow_function` to see the decorator in action. The decorator effectively reported the execution time for each function, demonstrating the difference in their performance.
Through this exercise, I learned how to write custom decorators in Python and use them to augment the functionality of other functions. This is particularly useful for adding common functionality (like logging, timing, or access control) to several functions in a consistent manner. This project was a practical introduction to advanced Python concepts like decorators, function wrappers, and timing code execution.
### Exercises (Day 54)
#### [A. Introduction to Flask](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-054/Exercises/Introduction%20to%20Flask)
In this exercise, I got an introduction to Flask, a lightweight and powerful web framework for Python. Flask is widely used for creating web applications due to its simplicity and flexibility. Here's a summary of what I did and learned:
1. **Setting Up Flask**: I started by importing Flask from the flask module. This is the main class in Flask and is the backbone of any Flask application.
2. **Creating a Flask App Instance**: I created an instance of the Flask class. `__name__` is a special variable in Python that is used as an argument in the Flask class. It represents the name of the current Python module, which Flask uses to find resources, templates, and static files.
3. **Defining a Route**: I used the `@app.route("/")` decorator to tell Flask what URL should trigger the function that follows. In this case, the function `hello_world` is linked to the root URL ("/"). This is known as defining a route.
4. **Creating a View Function**: The `hello_world` function is a view function. When this route is accessed through a web browser or a HTTP request, this function gets executed. It returns a simple HTML string: `"<p>Hello, World!</p>"`.
5. **Running the App**: Finally, I used `app.run()` within the `if __name__ == "__main__":` block. This is a Python idiom that checks whether the script is executed as the main program and ensures that the Flask application runs only if the script is executed directly, not if it's imported as a module.
Through this exercise, I learned how to set up a basic Flask application. This included creating a Flask instance, defining routes with view functions, and running a simple web server. This is the foundation of web development with Flask, demonstrating how to serve web pages and handle routing in a Python application.
#### [B. Python Decorators](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-054/Exercises/Python%20Decorators)
In this exercise, I delved into the concept of Python decorators, which are a powerful and versatile feature in Python programming. Decorators allow for the modification or enhancement of functions without changing their actual code. Here’s a summary of what I did and learned:
1. **Defining a Decorator Function**: I created a decorator function named `delay_decorator`. This function takes another function as its argument (`function`) and defines a nested function inside it, called `wrapper_function`.
2. **Functionality of the Decorator**: Inside `wrapper_function`, I added a delay of 2 seconds before calling the passed function, using `time.sleep(2)`. The passed function is then executed twice, demonstrating how decorators can modify the behavior of functions.
3. **Returning the Wrapper Function**: The `delay_decorator` function returns `wrapper_function` without executing it. This is key to how decorators work: they replace the original function with the wrapper function, which can then add additional behavior before or after the original function's execution.
4. **Applying the Decorator**: I used the decorator on three different functions (`say_hello`, `say_bye`, and `say_greeting`) to modify their behavior. The `@delay_decorator` syntax is a syntactic sugar in Python that simplifies the application of decorators.
- For `say_hello` and `say_bye`, I applied the decorator directly using the `@` syntax.
- For `say_greeting`, I demonstrated the decorator's use without the syntactic sugar by manually passing the function to `delay_decorator` and storing the returned function in `decorated_function`. This was then called like a regular function.
5. **Understanding Decorators**: Through this exercise, I gained a deeper understanding of decorators as functions that take another function as an argument, return a function, and are used to modify or extend the behavior of the original function in a non-intrusive manner.
#### [C. Python Functions](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-054/Exercises/Python%20Functions)
In this lesson on Python functions, I learned the following key concepts:
1. **Functions can have inputs, functionality, and outputs**:
- Functions like `add`, `subtract`, `multiply`, and `divide` were defined with parameters (`n1` and `n2`) to accept input values. Each function performs a specific operation and returns the result using the `return` statement.
2. **Functions are first-class objects**:
- Functions in Python are treated as first-class objects, which means they can be assigned to variables, passed as arguments to other functions, and returned from other functions. In the example, the `calculate` function takes another function as an argument, demonstrating how functions can be passed around.
3. **Nesting functions**:
- Functions can be nested within other functions. In the `outer_function`, there is a nested `nested_function`. When `outer_function` is called, it prints "I'm outer" and then calls `nested_function`, which prints "I'm inner." This illustrates the concept of function nesting.
4. **Functions can be returned from other functions**:
- The `outer_function` also demonstrates that functions can be returned from other functions. In this case, `outer_function` returns the `nested_function`, and it can be assigned to a variable (`inner_function`) and subsequently called.
Overall, this lesson introduced me to the versatility of functions in Python, showcasing their ability to accept inputs, perform operations, be passed as arguments, be nested, and even be returned from other functions. This understanding is fundamental for building modular and reusable code in Python.
## Day 55
### Projects (Day 55)
#### [55. Higher or Lower Dynamic Routes/URLs](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-055/Projects/Higher%20or%20Lower%20URLs)
In this lesson, I developed a simple web-based game using Flask that involves guessing a random number. Here's a summary of what I did and learned:
1. **Flask Setup**: I started by setting up a Flask application, defining the necessary imports and initializing the Flask app instance. Flask serves as the backend to handle web requests.
2. **Random Number Generation**: I used Python's `random` module to generate a random number between 0 and 9. This number is the target that users try to guess.
3. **Creating Routes**:
- The root route (`"/"`) displays a message inviting the user to guess a number and includes an image for visual appeal.
- The dynamic route (`"/<int:guess>"`) takes the user's guess as a URL parameter. This route checks if the guess matches the randomly generated number and provides feedback accordingly.
4. **Conditional Responses**: Depending on the user's guess, the dynamic route responds with:
- A success message and an image if the guess is correct.
- A message indicating the guess is too low with an accompanying image if the guess is lower than the target number.
- A message indicating the guess is too high with a different image if the guess is higher than the target number.
5. **HTML Response**: The responses are structured in HTML, allowing the incorporation of styles and images directly in the Flask app's return statements.
6. **Debug Mode**: The Flask app is run with `debug=True`, which is useful for development as it provides detailed error messages and auto-reloads the server upon code changes.
Through this project, I learned about setting up and routing in a Flask application, dynamically handling URLs, and generating and using random numbers. This exercise also demonstrated how to provide interactive feedback to the user based on their input, enhancing the overall user experience. The project was a practical introduction to creating simple, interactive web applications with Flask.
### Exercises (Day 55)
#### [A. Advanced Decorators](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-055/Exercises/Advanced%20Decorators)
In this section, I explored advanced concepts of Python decorators, furthering my understanding of this powerful feature. Decorators are used to modify or extend the functionality of functions in Python. Here's what I did and learned:
1. **User Authentication Decorator**:
- **Purpose**: I implemented a decorator named `is_authenticated_decorator` to check if a user is authenticated before allowing certain actions (like creating a blog post).
- **Implementation**: This decorator takes a function as an argument and returns a nested function, `authenticate`. Inside `authenticate`, it checks if the first argument (assumed to be a user) is logged in. If so, it allows the function to execute.
- **Usage**: I applied this decorator to a function `create_blog_post`, demonstrating its use by creating an instance of a `User` class and toggling their `is_logged_in` status. This showcased how decorators can be used for access control in applications.
2. **Logging Decorator Challenge**:
- **Objective**: To create a logging decorator named `logging_decorator` that logs the details of function calls.
- **Functionality**: This decorator wraps around a function and prints out the function's name, the arguments it was called with, and the result it returned.
- **Application**: I applied this decorator to `a_function`, which performs a multiplication operation. The decorator effectively logged the call details, demonstrating its utility in debugging and monitoring function usage.
**Advanced Decorators - Key Learnings**:
- **Decorator Mechanics**: Both exercises reinforced the concept that decorators are functions that return other functions, allowing for dynamic modification of function behavior.
- **Practical Use Cases**: The user authentication decorator illustrated a practical use of decorators in managing access control, while the logging decorator highlighted their utility in logging and debugging.
- **Flexibility and Power**: These exercises showcased the flexibility and power of decorators in Python, demonstrating how they can be applied to a wide range of scenarios to add functionality to existing code in a clean and maintainable way.
Overall, these exercises deepened my understanding of decorators in Python, showing how they can be leveraged to write more efficient, cleaner, and more maintainable code.
#### [B. Flask Practice](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-055/Exercises/Flask%20Practice)
In this exercise, I practiced using Flask, a popular micro web framework in Python, to build a simple web server with various routes and decorators for HTML text formatting.
The script starts by importing `Flask` and creating a Flask app instance. Then, I defined three decorator functions, `make_bold`, `make_emphasis`, and `make_underlined`. Each of these decorators takes a function and wraps its output in HTML tags (`<b>`, `<em>`, and `<u>`, respectively) for bold, italic, and underlined text.
Next, I defined three routes using the `@app.route` decorator:
1. The root route (`"/"`) returns a basic HTML page with a heading, a paragraph, and an image. This route is a straightforward demonstration of serving HTML content with Flask.
2. The `"/bye"` route is decorated with the previously defined decorators to apply bold, italic, and underline formatting to its output. The layered use of decorators here showcases how to combine multiple decorators to enhance a function's output.
3. The `"/username/<name>/<int:age>"` route demonstrates Flask's ability to capture variable path segments. This route accepts a `name` (string) and `age` (integer) as URL parameters and displays them in a formatted string. This exemplifies how to dynamically respond to user input in URLs.
Finally, the script runs the app with `debug=True`, enabling the debug mode for easier development and troubleshooting.
Through this task, I continued to learn about Flask. Specifically expanding on: setting up a Flask applications, routing, dynamic URL parameters, HTML formatting in Flask, and the use of decorators to modify the behavior of functions. This exercise provided a practical foundation for web development with Flask.
## Day 56
### Projects (Day 56)
#### [56. Name Card Website](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-056/Projects/Name%20Card%20Website)
In this lesson, I created a simple personal name card website using Flask, HTML, and CSS. Here's a summary of what I did and learned:
1. **Flask Setup**: I started by setting up a Flask application in `server.py`. This script initializes the Flask app and defines a single route (`"/"`) that renders `index.html`. Flask serves as the backend framework to manage the web server.
2. **HTML Structure**: In `index.html`, I created a structured layout for the name card. I included a header section with an avatar image, a name (Jordan Muller), and a brief description (New Grad - BS in Computer Science).
3. **CSS and JavaScript Integration**: I linked the CSS and JavaScript files located in the `/static/assets/` directory. These files are crucial for styling and adding interactivity to the webpage. The CSS files are responsible for the visual design, while the JavaScript ensures compatibility with older browsers and removes the loading class once the page is fully loaded.
4. **Design Aesthetics**: The HTML template uses a design from HTML5 UP, known for providing elegant and responsive website templates. I customized it to fit the personal branding and information of the individual, Jordan Muller.
5. **Footer Content**: The footer includes social media icons for LinkedIn and GitHub, allowing visitors to connect with Jordan on these platforms. Additionally, there's a copyright notice and a credit to HTML5 UP for the design.
6. **Responsive Design**: The website is designed to be responsive, ensuring it looks good on various devices. This is particularly important for a name card website, as it needs to be accessible and readable on all screen sizes.
7. **Static Files Organization**: The static files like images, CSS, and JavaScript are well-organized in the `static/` directory. This organization is crucial for maintaining the website and for quick updates or changes in the future.
Through this project, I learned how to create a personal name card website using Flask, how to integrate and customize a third-party HTML template, and the importance of a well-structured and organized project directory. This exercise was a great way to understand the basics of web development with Flask and front-end design principles.
### Exercises (Day 56)
#### [A. Open Source Template](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-056/Exercises/Open%20Source%20Template)
In this exercise, I explored the basics of setting up a web application using Flask, a popular Python web framework, along with incorporating HTML templates and static assets.
The Python script uses Flask to create a simple web server. The `Flask` class from the `flask` module is used to initialize the app, and the `render_template` function is employed to render HTML pages.
A route is defined using the `@app.route` decorator. The function `hello_world()` is linked to the root URL ("/"). When this URL is accessed, the function returns the rendered `index.html` template.
The `if __name__ == "__main__"` block checks if the script is executed directly (and not imported as a module in another script). If so, `app.run(debug=True)` starts the Flask application with debug mode enabled, allowing for real-time updates and detailed error logs.
The Flask application is configured to serve static assets from the `static/assets` folder, which is organized into subfolders for CSS, JavaScript, SASS, and webfonts. This structure is essential for managing various frontend components like stylesheets, scripts, and font resources.
The `templates/index.html` file is an HTML document that structures the web page. It includes references to the CSS stylesheet (`main.css`) and JavaScript files stored in the `static/assets` directory. The HTML template features sections like header, navigation, main content areas, and footer, showcasing different elements like images, links, and text blocks.
This setup demonstrates how to use Flask for serving dynamic web content, manage static files, and render HTML templates. It's a foundational step in web development with Python, showcasing how to structure a project, serve static assets, and create a basic web page layout.
#### [B. Resume Site Template](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-056/Exercises/Resume%20Site%20Template)
In this exercise, I created a personal resume website using Flask and HTML. The goal was to develop a web application that showcases a professional profile, including education, projects, technical skills, and contact information.
The Flask setup remained straightforward, with the application initialized and a single route defined. This route, mapped to the root URL ("/"), returns the rendered HTML page `resume.html` located in a subfolder `cv` within the `templates` directory. This structure illustrates how Flask can manage templates organized in subdirectories, offering a neat way to structure larger projects.
The HTML template `resume.html` is crafted as a personal resume. It begins with standard HTML document headers, including a link to a CSS stylesheet (`styles.css`) stored in the `static` folder. This CSS file presumably contains custom styles to enhance the visual appeal of the resume.
The body of the `resume.html` is structured to include various sections typical of a resume:
1. **Personal Information and Contact:** It starts with an image tag displaying a portrait (referenced from the `static` folder) and continues with basic contact information and social media links.
2. **Education:** This section lists academic qualifications, including the institution, graduation date, degree, and relevant coursework.
3. **Projects:** Several projects are detailed, each with a title, technologies used, and a brief description. This section highlights practical skills and experiences.
4. **Technical Skills:** A comprehensive list of technical skills, languages, libraries, frameworks, developer tools, certifications, and hobbies is provided.
The HTML structure of the resume is simple yet effective, using headings, paragraphs, lists, and divisions to organize the content. It demonstrates how to present detailed professional information in a clear, readable format on a web page.
## Day 57
### Projects (Day 57)
#### [57. Blog Site](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-057/Projects/Blog%20Site)
In this lesson, I created a blog site using Flask, a micro web framework in Python, and enhanced it with HTML and CSS for styling. Here's a summary of what I did and learned:
1. **Flask Application Setup**: I started by setting up a basic Flask application in `server.py`. This included importing Flask, rendering templates, and handling routes. Flask serves as the backend framework to handle web requests and serve HTML pages.
2. **Data Retrieval**: I fetched blog post data from an external API using the `requests` library in Python. The data is stored in `all_posts`, which is a JSON object containing blog posts.
3. **Routing**: Two main routes were created in the Flask app:
- The home route (`"/"`) renders `index.html`, displaying all blog posts.
- The blog post route (`"/posts/<id>"`) renders `post.html`, showing the details of a specific blog post based on its ID.
4. **Templates with Jinja2**: Flask uses Jinja2 for templating. In `index.html`, I used a for loop (`{% for blogPost in posts %}`) to iterate over `all_posts` and display each post's title, subtitle, and a link to the full post. In `post.html`, I displayed the details of a single post using the `postID` variable passed from the Flask app.
5. **HTML Structure**: Each HTML file has a basic structure with `head` and `body` sections. I included external links to the Raleway font and the CSS stylesheet.
6. **CSS Styling**: In `styles.css`, I defined styles for the body, wrapper, card, and other elements to create a visually appealing layout. This included background colors, font styles, box shadows, and responsive widths.
7. **Front-End Interactivity**: I implemented navigation between the home page and individual blog posts. Each blog post on the index page links to its detailed view through the `/posts/<id>` route.
8. **Footer**: A fixed footer was added to both HTML templates, giving a consistent look across pages.
Through this project, I gained hands-on experience in combining Flask with front-end technologies like HTML and CSS. I learned how to fetch and display data from an API, use Jinja2 templating effectively, and create a basic but functional web application layout. This exercise was a great way to understand how front-end and back-end technologies integrate to build dynamic websites.
### Exercises (Day 57)
#### [A. Jinja Template Introduction](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-057/Exercises/Jinja%20Template%20Introduction)
In this exercise, I was introduced to using Jinja templates with Flask, a popular Python web framework. Jinja is a powerful template engine for Python, enabling dynamic content generation in HTML files.
The `server.py` file serves as the backbone of the application. It uses Flask to create web routes and serve HTML templates. The application includes three primary routes:
1. **Home Route ("/")**: This route generates a random number and the current year, passing them to `index.html` using Jinja's template syntax. The template dynamically displays these values.
2. **Guess Route ("/guess/<name>")**: This route takes a name as a parameter and tries to guess the age and gender of the person. It first checks if the data is already stored in a local JSON file (`data.json`). If not, it fetches the data using external APIs (`agify.io` and `genderize.io`), stores it in the JSON file, and then passes it to `demographics.html`. This demonstrates API interaction, file handling, and dynamic content rendering using Jinja.
3. **Blog Route ("/blog/<num>")**: This route fetches blog posts from an external API and displays a specific post in `blog.html` based on the passed ID. It showcases how to handle and display lists of data using Jinja.
The HTML templates (`index.html`, `demographics.html`, and `blog.html`) are designed to display the data passed from the server. They use Jinja's templating syntax (e.g., `{{ variable }}`, `{% for %}`, `{% if %}`) to embed Python-like expressions and control structures into the HTML, allowing for dynamic content rendering based on the server-side data.
Through this exercise, I learned how to:
- Set up a basic Flask application.
- Use routes to handle different URLs.
- Pass data from the server to the templates.
- Use Jinja's templating features to render dynamic content in HTML.
- Interact with APIs and handle JSON data.
- Perform basic file operations (read/write JSON).
- Utilize Flask's `url_for` function for generating URLs.
This was a practical introduction to web development with Flask and Jinja, highlighting how Python can be used to create dynamic, data-driven websites.
## Day 58
### Projects (Day 58)
#### [58. TinDog App Landing Page](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-058/Projects/TinDog%20Project)
In this lesson, I created a landing page for a fictional app called "TinDog," which is a playful take on a dating app for dogs. Here's a summary of what I did and learned:
1. **HTML Structure**: I started by setting up the basic HTML structure, defining the `DOCTYPE`, `html`, `head`, and `body` tags. I made sure to set the language attribute to English and included meta tags for character set and viewport settings for responsiveness.
2. **Bootstrap Integration**: I integrated Bootstrap by linking to its CDN in the `head` section. This allowed me to utilize Bootstrap's grid system and pre-defined CSS classes for styling and layout, making the development process smoother and more efficient.
3. **Custom CSS Styles**: I wrote custom CSS styles within a `<style>` tag. This included a gradient background for certain sections of the page, animation for the gradient, and styles for specific classes like `.icon-square` and `.circle-img`. These styles added visual appeal and distinctiveness to the page.
4. **Web Page Sections**: The webpage was divided into several sections:
- **Title Section**: Featured a catchy headline, a download button, and an image, providing a clear and engaging introduction to the app.
- **Features Section**: Outlined the app's main features using Bootstrap's grid system for a clean layout, accompanied by icons and brief descriptions.
- **Testimonial Section**: Included a customer testimonial and an image to build trust and relatability.
- **Pricing Section**: Displayed different pricing plans in a card layout, making use of Bootstrap's card component.
- **Footer**: Contained navigational links and copyright information, structured using Bootstrap's grid system.
5. **Responsive Design**: Throughout the development, I paid attention to making the page responsive. This involved using Bootstrap's responsive classes and ensuring that the custom styles also supported various screen sizes.
6. **External Libraries**: Besides Bootstrap, I linked a Bootstrap JavaScript bundle at the end of the body for enabling interactive components.
7. **Content and Imagery**: I learned the importance of content placement and imagery in making a web page visually appealing and user-friendly.
Through this exercise, I honed my skills in HTML and CSS, learned to effectively use Bootstrap for layout and styling, and understood the principles of responsive web design. It was an engaging and practical project that combined creativity with technical skills.
### Exercises (Day 58)
#### [A. Bootstrap Introduction](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-058/Exercises/Bootstrap%20Introduction)
In this exercise, I've learned how to create a responsive card layout using Bootstrap, a popular CSS framework that helps design web pages quickly and efficiently.
The `index.html` file is structured with a `<!DOCTYPE html>` declaration, followed by HTML5 elements structured with a `head` and a `body`. In the `head` section, Bootstrap's CSS file is included from a CDN (Content Delivery Network), which gives me access to Bootstrap's pre-defined classes for styling and responsiveness.
The style section within the `head` defines a `flex-container` class that uses Flexbox to center its contents both vertically and horizontally within the viewport height. This is a common design pattern for centering content, especially in a card-based layout.
In the `body`, the `flex-container` class is applied to a `div` element, which wraps around the Bootstrap card component. The card component is constructed using `div` elements with specific Bootstrap classes:
- `card`: This class defines the basic card structure.
- `card-img-top`: This class is used for the image at the top of the card.
- `card-body`: This class contains the content of the card, including a title (`card-title`), text content (`card-text`), and a button (`btn btn-primary`).
The image displayed on the card is referenced locally from `./flower.jpg`. The card's title, text, and button are defined with placeholder text and styled using Bootstrap's classes.
Finally, Bootstrap's JavaScript bundle is included just before the closing `body` tag. This bundle contains Bootstrap's JavaScript components, which can add interactive behavior to Bootstrap elements if needed.
In summary, I've learned how to:
- Include Bootstrap's CSS and JS files using a CDN.
- Utilize Bootstrap classes for styling and layout, such as cards and buttons.
- Implement Flexbox for centering content using custom CSS classes.
- Structure HTML for a Bootstrap card component with an image, title, text, and button.
By understanding these concepts, I can now create a visually appealing and responsive card layout that can be further customized as needed for web development projects.
#### [B. Bootstrap Components](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-058/Exercises/Bootstrap%20Components)
In this exercise, I applied Bootstrap components to build a comprehensive webpage for a moving service company, "Move It". Using Bootstrap 5, I created a user-friendly, responsive design that adapts to various devices.
Here's a breakdown of what I learned and implemented:
**Navigation Bar**: I incorporated a responsive navigation bar that includes the company logo and navigation links like 'Home', 'About', 'Services', and a search bar for postcode checking. Bootstrap's classes made it simple to create a collapsible menu for smaller screens.
**Hero Section**: For the hero section, I used a centered text layout with a call to action, introducing the site with a warm welcome message and offering quick access to 'Get a Quote' and 'Contact Us' buttons. This area is designed to make a strong first impression and drive user engagement.
**Features Section**: I showcased the company's key selling points in a three-column layout for larger screens, which collapses into a single column on smaller devices. Each feature is accompanied by an SVG icon and a brief description of services like 'Professional', 'Countrywide', and 'Personal Touch', highlighting the brand's values and services.
**Carousel**: I added a Bootstrap carousel to display multiple images that users can browse through. This interactive component can highlight different aspects of the service, such as family-friendly and pet-friendly moves.
**Footer**: The footer is structured with multiple columns, providing quick navigation links and mirroring the navigation bar's design. It reinforces the site's structure and offers additional resources for users.
**Styling**: Custom styles were added to adjust specific elements, such as the size of the SVG icons and the company logo. This ensures brand consistency and visual appeal throughout the site.
**Script Inclusion**: Bootstrap's JavaScript bundle is included at the end of the body to enable dynamic components like the carousel and collapsible navbar.
Through this exercise, I not only practiced implementing Bootstrap components but also enhanced my understanding of web design patterns and responsive layouts. I learned how to piece together different Bootstrap elements to create a cohesive and functional website, paying attention to both aesthetics and user experience.
## Day 59
### Projects (Day 59)
#### [59. Upgraded Blog](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-059/Projects/Upgraded%20Blog)
## Day 60
### Projects (Day 60)
#### [60. BMI Calculator v4 Upgrade - GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-060/Projects/BMI%20Calculator%20GUI%20App)
In the development of the BMI Calculator GUI App V4, I expanded on the foundational concepts of graphical user interface (GUI) design in Python, integrating interactive elements and backend logic for real-time calculations and display. This version showcases a significant leap in functionality compared to its predecessors.
1. **Interactive GUI with Tkinter**: The major advancement in this version is the introduction of interactive elements. Users can now adjust their weight, height, and view their BMI calculation in real-time. Tkinter is used for all GUI components, demonstrating its versatility for creating dynamic interfaces.
2. **BMI Calculation Integration**: The GUI is integrated with the BMI calculation logic from `calc.py`. This integration enables the application to calculate and display the BMI based on user input, illustrating how to connect frontend and backend in an application.
3. **Real-Time User Input Handling**: The application allows users to modify their weight and height using interactive buttons. This is achieved through event bindings in Tkinter, where clicking on buttons triggers specific functions to increment or decrement the values.
4. **Dynamic Content Update**: The BMI value and category, along with the corresponding colors, are updated dynamically based on user inputs. This not only provides immediate feedback to the user but also demonstrates effective use of Tkinter's canvas and text widgets for dynamic content management.
5. **Conditional Logic for BMI Categories**: Like the previous version, V4 categorizes BMI results into health categories such as "Underweight," "Normal," "Overweight," and "Obese." This categorization is achieved using conditional logic in `calc.py`, which is then reflected in the GUI.
6. **Color Coding for Health Categories**: Each BMI category is represented by a different color, enhancing the visual appeal and user experience. This introduces an additional layer of user interaction, as the color change provides a quick visual cue about the health category.
7. **Event Bindings and Callbacks**: I learned about the importance of event handling in GUI applications. The buttons for incrementing and decrementing weight and height are bound to corresponding functions. This understanding is crucial for creating interactive applications.
8. **Hover Effects for Enhanced UX**: To improve user experience, hover effects were added to the buttons, changing their colors when the mouse cursor is over them. This is a subtle yet effective way to make GUIs more intuitive and responsive.
This project covers aspects of event handling, dynamic content updates, and integrating logical operations with a graphical interface, providing a robust understanding of building practical and interactive applications with Tkinter.
## Day 61
### Projects (Day 61)
#### [61. Flask WTForms](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-061/Projects/Flask%20WTForms)
In this lesson, I implemented a simple web application using Flask and WTForms, which included a login functionality with basic validation. Here’s a summary of what I did and learned:
1. **Using Flask and WTForms**:
- Flask is a micro web framework in Python used for web development.
- WTForms is a flexible forms validation and rendering library for Python web development. It integrates seamlessly with Flask through the Flask-WTF extension.
2. **Creating a LoginForm Class**:
- I defined a `LoginForm` class inheriting from `FlaskForm`.
- The form included an email field, a password field, and a submit button.
- Custom validators for the email and password fields were added to check for the presence of an "@" and ".", and to ensure the password is at least 8 characters long, respectively.
3. **Setting Up Flask Routes**:
- The `"/"` route renders the homepage (`index.html`).
- The `"/login"` route handles both displaying the login form and processing form data on submission.
- The `"/success"` and `"/denied"` routes render pages for successful and unsuccessful login attempts.
4. **HTML Templates**:
- I used Jinja2 templating to create HTML templates for different routes.
- `base.html` serves as a base template including the Bootstrap CSS framework.
- `index.html`, `login.html`, `success.html`, and `denied.html` extend from `base.html` and represent different pages of the application.
5. **Login Functionality**:
- In the `login` route, the form is instantiated and rendered in `login.html`.
- Upon form submission, the form data is validated.
- If the email and password match the hardcoded credentials ("[email protected]" and "password"), the user is redirected to the success page; otherwise, they are redirected to the denied page.
6. **Environment Variables**:
- The Flask app configuration uses an environment variable for `SECRET_KEY` to maintain security, especially for form handling.
7. **Front-End Design**:
- The use of Bootstrap enhances the UI with minimal custom styling.
- The login form provides feedback on validation errors directly on the form fields.
Through this project, I gained experience in creating web forms with validation in Flask, understanding the flow of data in a Flask application, and using templates for rendering pages. This exercise demonstrated the practical application of Flask and WTForms in building web applications with user input and validation logic.
## Day 62
### Projects (Day 62)
#### [62. Coffee & Wi-Fi Website - Accessing CSV](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-062/Projects/Coffee%20and%20Wi-Fi)
## Day 63
### Projects (Day 63)
#### [63. Library App - Accessing SQLite DB](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-063/Projects/Library%20App)
### Exercises (Day 63)
#### [A. SQLite Practice](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-063/Exercises/SQLite%20Practice)
In this exercise, I practiced using SQLite with Python to manage a simple database. SQLite is a C library that provides a lightweight disk-based database and allows for a self-contained, serverless, zero-configuration, and transactional SQL database engine.
Here’s what I learned:
1. **Database Connection**:
I started by connecting to an SQLite database named `books-collection.db` using `sqlite3.connect`. This method returns a connection object.
2. **Creating a Cursor**:
Using the connection object, I created a cursor object by calling `db.cursor()`. The cursor is used to execute SQL commands.
3. **Creating a Table**:
I learned to create a new table named `books` with columns for `id`, `title`, `author`, and `rating`. The `id` is set as the PRIMARY KEY, which means each value must be unique and not null. The `title` and `author` are stored as strings (`varchar(250)`) and are not nullable, with the `title` also being unique. The `rating` is a floating-point number. The SQL command for creating a table is written as a string and executed by the cursor with the `execute` method.
```sql
CREATE TABLE books (id INTEGER PRIMARY KEY, title varchar(250) NOT NULL UNIQUE, author varchar(250) NOT NULL, rating FLOAT NOT NULL)
```
This command was commented out after the initial run because you only need to create the table once.
4. **Inserting Data**:
I inserted a new row into the `books` table with values for each column. The SQL command for inserting is also a string executed by the cursor.
```sql
INSERT INTO books VALUES(1, 'The Sixth Extinction', 'Elizabeth Kolbert', '9.8')
```
5. **Committing Changes**:
After executing an insertion, I learned to commit the changes to the database using `db.commit()`. It's essential to commit after modifications, or the changes won't be saved.
6. **Handling Unique Constraints**:
Since the `title` column is unique, I would need to handle exceptions if I tried to insert a book with a title that already exists in the database. This would raise an `sqlite3.IntegrityError`, which I would need to catch and handle appropriately.
Through this exercise, I understood the basics of SQLite database operations in Python, including connecting to a database, creating a table, inserting data, and committing changes. This knowledge is fundamental for any application that requires data persistence.
#### [B. SQLAlchemy Practice](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-063/Exercises/SQLAlchemy%20Practice)
In this exercise, I practiced how to use SQLAlchemy, an Object-Relational Mapping (ORM) library for Python, with a Flask application to interact with an SQLite database. Here's what I learned:
**Setting Up the Environment**:
- I initialized a Flask app and used the Flask-SQLAlchemy extension to integrate SQLAlchemy into the Flask app.
- Configured the app to connect to an SQLite database named `new-books-collection.db`.
**Creating a Database Model**:
- Defined a `Book` class as a model that represents a table in the database. The class inherits from `db.Model`.
- Specified columns for the table: `id`, `title`, `author`, and `rating`. Each column is an instance of `db.Column` with type and constraints (like `primary_key` and `nullable`) defined.
**Creating the Table**:
- Used the `db.create_all()` function within the Flask app's application context to create the table in the database according to the schema defined in the `Book` class.
**CRUD Operations**:
1. **Create (Commented Out)**:
- Created a new book record with given values and added it to the session, then committed the session to save changes to the database.
2. **Read All Records (Commented Out)**:
- Executed a query to select all books, ordered by title, and printed the result.
3. **Read a Specific Record by Query (Commented Out)**:
- Executed a query to find a specific book by its title.
4. **Update a Record by Query (Commented Out)**:
- Found a book by its title, updated its rating, and committed the changes.
5. **Update a Record by Primary Key (Commented Out)**:
- Found a book by its `id`, updated its title, and committed the changes.
6. **Delete a Specific Record by Primary Key (Commented Out)**:
- Found a book by its `id`, deleted it from the session, and committed the changes to remove it from the database.
Throughout this exercise, I learned how to:
- Set up and integrate SQLAlchemy with a Flask app.
- Define a model class with SQLAlchemy.
- Perform basic CRUD (Create, Read, Update, Delete) operations using SQLAlchemy ORM.
- Use Flask's application context to perform database operations.
The use of SQLAlchemy ORM allows for writing Pythonic code that translates to SQL queries, which abstracts away the complexity of direct SQL statements and provides a more readable, maintainable codebase. This is especially helpful in larger projects where database schemas and operations can become quite complex.
## Day 64
### Projects (Day 64)
#### [64. Favorite Movies Website](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-064/Projects/Favorite%20Movies%20Website)
## Day 65
### Projects (Day 65)
#### [65. Notes GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-065/Projects/Notes%20GUI%20App)
## Day 66
### Projects (Day 66)
#### [66. Cafe API - Flask REST API](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-066/Projects/Cafe%20REST%20API)
## Day 67
### Projects (Day 67)
#### [67. Blog API - Flask REST API](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-067/Projects/Blog%20REST%20API)
## Day 68
### Projects (Day 68)
#### [68. Flask Authentication](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-068/Projects/Flask%20Authentication)
## Day 69
### Projects (Day 69)
#### [69. Blog with Users & Authentication](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-069/Projects/Blog%20with%20Users)
## Day 70
### Projects (Day 70)
#### [70. Using Git/GitHub](https://github.com/itsjordanmuller/2023-python-100-days/tree/main#day-70)
The original purpose of this lesson was to start learning how to use Git for version control and GitHub for version control hosting. However, I started this project from Day 1 using Git/GitHub.
I might come back to this at some point to make a Git helper script/application using Python, but I decided to give myself a free pass for now since I've been using Git from Day 1!
## Day 71
### Projects (Day 71)
#### [71. Folder File Scanner](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-071/Projects/Folder%20File%20Scanner)
## Day 72
### Projects (Day 72)
#### [72. College Major Salary Data Exploration](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-072/Projects/College%20Major%20Salary%20Data%20Exploration)
## Day 73
### Projects (Day 73)
#### [73. Programming Language Analysis](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-073/Projects/Programming%20Language%20Analysis)
## Day 74
### Projects (Day 74)
#### [74. LEGO Data Analysis](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-074/Projects/LEGO%20Data%20Analysis)
## Day 75
### Projects (Day 75)
#### [75. Google Trends Data Analysis](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-075/Projects/Google%20Trends%20Data%20Analysis)
## Day 76
### Projects (Day 76)
#### [76. Google Play Store App Analytics](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-076/Projects/Google%20Play%20Store%20App%20Analytics)
## Day 77
### Projects (Day 77)
#### [77. NumPy & N-Dimensional Arrays](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-077/Projects/NumPy%20and%20N-Dimensional%20Arrays)
## Day 78
### Projects (Day 78)
#### [78. Linear Regressions & Seaborn](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-078/Projects/Linear%20Regressions%20and%20Seaborn)
## Day 79
### Projects (Day 79)
#### [79. Nobel Prize Analysis](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-079/Projects/Nobel%20Prize%20Analysis)
## Day 80
### Projects (Day 80)
#### [80. Distributions and t-Tests](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-080/Projects/Distributions%20and%20t-Tests)
## Day 81
### Projects (Day 81)
#### [81. Predict House Prices](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-081/Projects/Predict%20House%20Prices)
## Day 82
### Projects (Day 82)
#### [82. Morse Code Converter](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-082/Projects/Morse%20Code%20Converter)
## Day 83
### Projects (Day 83)
#### [83. Portfolio Site](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-083/Projects/Portfolio%20Site)
## Day 84
### Projects (Day 84)
#### [84. Tic-Tac-Toe vs Bot](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-084/Projects/Tic-Tac-Toe%20vs%20Bot)
## Day 85
### Projects (Day 85)
#### [85. Image Watermarking GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-085/Projects/Image%20Watermarking%20GUI%20App)
## Day 86
### Projects (Day 86)
#### [86. Typing Speed Test GUI App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-086/Projects/Typing%20Speed%20Test%20GUI%20App)
## Day 87
### Projects (Day 87)
#### [87. Breakout Game](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-087/Projects/Breakout%20Game)
## Day 88
### Projects (Day 88)
#### [88. Full Stack Coffee & Wi-Fi](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-088/Projects/Full%20Stack%20Coffee%20and%20Wi-Fi)
## Day 89
### Projects (Day 89)
#### [89. Todo List Site](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-089/Projects/Todo%20List%20Site)
## Day 90
### Projects (Day 90)
#### [90. Disappearing Text Writing App](https://github.com/itsjordanmuller/2023-python-100-days/tree/main/Day-090/Projects/Disappearing%20Text%20Writing%20App)
## Day 91
## Day 92
## Day 93
## Day 94
## Day 95
## Day 96
## Day 97
## Day 98
## Day 99
## Day 100
<div align="right"><a href="#top">(back to top)</a></div>
<hr>
</details>
<a id="acknowledgements-section"></a>
<details open>
<summary align="center"><h2>🌟 Acknowledgements</h2></summary>
<a id="special-thanks"></a>
<div align="left">
<h3>💌 Special Thanks</h3>
<blockquote>
<p>Dear Dr. Angela Yu,</p>
<p>I want to express my deepest appreciation for your course, "100 Days of Code: The Complete Python Pro Bootcamp for 2023." Your unique approach to teaching Python and its applications has been both inspiring and transformative for me.</p>
<p>Your detailed explanations and practical exercises have made learning complex topics enjoyable and effective. The way you incorporated topics like Environment Variables, PyPi, and Virtual Environments was particularly enlightening, offering me insights into the real-world application of Python.</p>
<p>The depth and breadth of knowledge you have shared through this course have not only improved my programming abilities but also significantly boosted my confidence in tackling advanced coding challenges. Your passion for teaching and commitment to student success is evident in every lesson and has made a lasting impact on my skills & attitude as a developer.</p>
<p>Thank you for your dedication to creating such a comprehensive and engaging learning experience. Your course has been a pivotal part of my coding journey, and I am truly grateful for all the knowledge and expertise you have shared.</p>
<p>Sincerely,<br><strong><em>Jordan Muller</em></strong></p>
</blockquote>
</div>
<div align="right"><a href="#top">(back to top)</a></div>
<hr>
</details>
<a id="contact-section"></a>
<details open>
<summary align="center"><h2>📬 Contact Information</h2></summary>
<div align="center">
<blockquote>
<img src="https://github.com/itsjordanmuller.png" width="160px"/><br>
<em>If you have questions/feedback, I would love to hear from you. Thanks for stopping by!<br>- <strong>Jordan Muller</strong></em>
</blockquote>
[](https://www.linkedin.com/in/itsjordanmuller)
[](mailto:[email protected])
[](https://jordanmuller.com/)
</div>
Please feel free to reach out if you have any suggestions or run into any issues with viewing this project.<br>
I am always looking for feedback from other people! I'd be more than happy to answer any questions you may have as well as assist with getting the project working on your machine.<br>
Be sure to view the <a href="#setup-section"><strong><em>Setup Instructions</em></strong></a> in the README, as well as any specific README files for that specific project as they contain more details and may already have the answer to your question(s)!
<div align="right"><a href="#top">(back to top)</a></div>
<hr>
</details>
<a id="resources-section"></a>
<details open>
<summary align="center"><h2>🔗 Links & Citations</h2></summary>
[100 Days of Code: The Complete Python Pro Bootcamp for 2023](https://www.udemy.com/course/100-days-of-code/) course by [Dr. Angela Yu](https://www.udemy.com/user/4b4368a3-b5c8-4529-aa65-2056ec31f37e/) on [Udemy](https://www.udemy.com/)
<div align="right"><a href="#top">(back to top)</a></div>
<hr>
</details>
<a id="license-section"></a>
<details open>
<summary align="center"><h2>📜 License Details</h2></summary>
<table>
<thead>
<tr>
<th>
<a href="https://github.com/itsjordanmuller/2023-python-100-days/blob/main/LICENSE.md">LICENSE.md</a>
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<blockquote>
<p>The content within this repository was created as part of a personal educational project, following the <a href="https://www.udemy.com/course/100-days-of-code/">100 Days of Code: The Complete Python Pro Bootcamp for 2023</a> course by <a href="https://www.udemy.com/user/4b4368a3-b5c8-4529-aa65-2056ec31f37e/">Dr. Angela Yu</a> on <a href="https://www.udemy.com/">Udemy</a>. This repository is intended for personal use only and serves as a record of my learning progress. This repository & the content within it are not intended for commercial use, distribution, or replication. All rights to the original course content and methodologies belong to the respective copyright holders.</p>
<p>THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.</p>
<p>Copyright © 2024 <a href="https://jordanmuller.com/">Jordan Muller</a>. All Rights Reserved.</p>
</blockquote>
</td>
</tr>
</tbody>
</table>
<div align="right"><a href="#top">(back to top)</a></div>
</details>
