In 1989, Guido van Rossum, a Dutch computer scientist, started working on a new programming language that would be easy to learn and use. He named it after Monty Python's Flying Circus, his favorite TV show.

The language quickly gained popularity and a cult following among developers who loved its simplicity and ease of use. Python soon became the language of choice for scientific and academic communities.

As Python's popularity grew, it faced some significant hurdles. In the early days, critics panned the language for being slow and inefficient compared to other programming languages. However, the Python community was undeterred and developed several optimization techniques and libraries to improve performance.

In 2000, Guido van Rossum released Python 2.0, which introduced a number of major new features and improvements, including list comprehensions, a garbage collector, and support for Unicode. This version of the language solidified its position as a powerful and versatile programming language.

Over time, Python faced some new challenges. The release of Python 3.0 in 2008 introduced significant changes that caused compatibility issues with earlier versions of the language. However, the Python community rallied to provide tools and resources to help developers transition to the new version.

Despite these challenges, Python has continued to grow and evolve. Today, it is one of the most popular programming languages in the world, with a vast ecosystem of libraries and tools. Python is used for everything from web development and data analysis to scientific computing and artificial intelligence.

When learning Python, you might hear the term “dynamically typed language” frequently. But what does it mean? Let’s break it down.

Typing refers to type-checking—the process of verifying whether the data types in your code are compatible with the operations being performed.

1️⃣ Strongly vs. Weakly Typed Languages

Strongly-Typed Languages (e.g., Python): These languages don’t allow type-coercion (implicit type conversion). For example:

pythonCopy code"1" + 2  # TypeError: cannot concatenate 'str' and 'int'

Weakly-Typed Languages (e.g., JavaScript): These languages allow type-coercion:

javascriptCopy code"1" + 2  // Outputs: "12"

2️⃣ Static vs. Dynamic Typing

Type-checking can occur at two stages:

Static Typing (e.g., Java, C++): Data types are checked before the program runs. You must declare the type of variables explicitly:

javaCopy codeintx=10; 

Dynamic Typing (e.g., Python): Data types are checked during program execution. Variable types are inferred automatically:

pythonCopy codex = 10  # No need to declare 'x' as an integer.

Python: A Dynamically Typed Language

Since Python is an interpreted language, it executes code line by line. Type-checking happens on the fly, allowing you to write flexible and concise code.

Example: pythonCopy codex = "Hello"x = 10  # No error—Python allows 'x' to change types.

This flexibility makes Python beginner-friendly but also increases the risk of runtime errors if types are misused.

Key Takeaway

Dynamic typing simplifies coding by removing the need for explicit type declarations. However, it also requires careful testing to ensure type-related bugs don’t creep in.

Today I am starting off with exercise 13. Exercise 13 introduces the concepts of variables, modules, and argv.

[ID: Exercise 13 code. It imports the argv module from sys, then uses argv to create 4 variables, script, first, second, and third. Next print() is used to print out the different variables /ID]

When calling the program I was confused as to why I got the error of too many variables. Looking into this I found that the first variable of 'argv' is always going to be the script. I then fixed that and added in script as the first variable.

Next for the study drill I wrote a new variable and updated the code to print the retrieved information.

Alrighty then - onto exercise 14. Exercise 14 is about practicing prompts and variables.

In the study drills I updated the script with a new prompt and print statement.

Exercise 15 is a simple program that prints out the contents of a file. An important thing to note is to always close the file when doing things like this!

Exercise 16 practices making a copy of a file and then updating it with 3 lines from user input.

I ended up running into the issue where it was saying that it couldn't read the file. I ended up finding out that .read() starts from the cursor position - and if the cursor is at the end of the file from writing it you will not have your file printed.

Exercise 17 is practicing copying files over and was relatively simple.

I have officially scheduled the jinx-bot tutorial for tomorrow morning! any guesses on what the command will be?

I am so proud to release this tutorial as from conception to frankenstein moment, it is my mind's baby lol. the bot I am basing jinx-bot off of was my first independent discord.py bot and will be have more of its commands featured in tutorials in the future.