DEV Community: Vicki Langer

TIE: What is an MVC framework?

Vicki Langer — Mon, 25 Apr 2022 18:14:20 +0000

Explaining concepts that can be hard to understand. You can expect relatable examples without jargon, foo, bar, and math examples.

Jump to:

Official explanation
TechItEasy explanation
More Info

Have you heard of this MVC thing? If not, you might look it up and run into a description like this. ⬇️ 😬 If you'd like an easier to understand explanation, you're welcome to jump down to the TechItEasy explanation.

Scary Jargon-filled Explanation

MVC (Model-View-Controller) is a pattern in software design commonly used to implement user interfaces, data, and controlling logic. It emphasizes a separation between the software's business logic and display. This "separation of concerns" provides for a better division of labor and improved maintenance.

The three parts of the MVC software-design pattern can be described as follows:

Model: Manages data and business logic.

View: Handles layout and display.

Controller: Routes commands to the model and view parts.

source: MDN

Does this chart make sense? If not, I bet it will once you're done reading this TechItEasy explanation.

TIE: MVC framework

Wait! What's a Framework?

Glad you asked. We should probably know that before we get into some real life examples.

A framework is a set of pre-made pieces used to help speed up building and give a standard way to make applications. These pre-made pieces of code are typically called components. Frameworks can include components for user management. User management may include creating, reading, updating, deleting, send forgotten password emails, etc. Frameworks are helpful because they remove the need to write code for things that get used all the time.

Why Use Frameworks?

If you haven't heard it before, DRY stands for Don't Repeat Yourself. This is an ideology that says we shouldn't have to write the same code multiple times. If you wrote code on how to make a cat, you wouldn't want to write it again and again for every cat that comes into existence. In this way, MVC has components that make it so the common things don't have to be written again. MVC frameworks help keep your code DRY.

Of note, MVC frameworks follow a pattern to help you think of each part of an app separately. There are other design patterns, but it seems MVC frameworks are most common. I'd guess they're common for a reason.

MVC frameworks simplify the building process. That's not to say it's easy, but to mean that it's generally easier than building a whole web app without a framework.

Right, now, What are the M, V, and C?

Models

Models are like a template or chart for data/info needed for an item or object. For example, if your pet has data. Some of the data is needed and some is nice to have but not required. Models allow you to say what each piece of data is whether or not it is required, and lots of other things. Here's a table representing a dog model.

Name	Date Type	Required?
`pet_name`	string	no
`spayed_neutered`	boolean	yes
`weight_lbs`	number	yes
`favorite_toy`	string	no

Each name in this table represents a column in a database. You could imagine it looking like this.

id	pet_name	spayed_neutered	weight_lbs	favorite_toy
2	Cheeto	true	11.1	BALL
5	Remmy	true	12.8	fishing pole
6	Wiley	true	32.3	beheaded dragon
8	Chip	false	0.00440925	crashed helicopter
9	Beans	true	9.6	random piece of foam

Notice we've added IDs. Sometimes these are referred to as uid which is short for "unique identifier". In this case, each new pet is given a number that belongs to them. We use an ID because everything else can change and we need to have access to reference the specific pet.

Views

Views are the code behind the pretty stuff. This is your front-end user interface code. It's generally some combination of HTML and CSS. It can also be done in other languages that get rendered/translated into HTML and CSS.

Controller

Controllers do the controlling. Good? Make sense? No? I didn't think so. Controllers are where you'll write code on how things should work. This is where the logic goes.

Okay, but How Do They Work Together?

Controllers change models. Models change the views. Views send info to the controllers. Controllers sometimes send info back to the views. For extra confusion, models also talk to databases. Are you confused yet? How about we jump into some real-life MVC frameworks.

Example with Your Body

Whether you knew it or not, your body has models, views, and controllers.

Models

You could look at your skeleton as a model. Your bones define the shape and structure of your body. Regardless of what bones you do and don't have, they are your model. By themselves, bones don't do anything but give structure. If you want the bones to look pretty, you'll need your views. For them to do things, you'll need controllers.

Views

Next time you get out of the shower, look in a mirror or take a selfie. What you see is your view. For your body, the view is your physical appearance. Your view includes skin, textures, colors, hair, and anything else that naturally exists as part of you. This would be like the HTML structure of a web page.

If you choose to, you may put clothes on, use prosthetics, move parts to get the right shape, use jewelry, use assistive devices, or do any number other things to change the outward appearance of your body. This is very similar to using CSS to make a webpage more interesting.

Views can send info to controllers. In the case of your body, you could imagine that something happened or you sensed that it happened. For example, a mosquito may land on you. Whether you saw it or felt it, this was your body's view send data to your controller.

Controller

Your brain contains your controllers. Your brain houses all of the logic for your body. If a mosquito landed on you, your avoid_mosquito_bite controller is then going to send out a job for you to move your limbs and address the intruder.

Your brain knows how to handle things because you have taught or coded it to do them. You may not recall, but at some point you may have learned how count, read, brush your teeth, and all of your other daily tasks.

There are also controllers for things you never had to learn. They came pre-coded. Most of the time, we have the ability to breathe, process food, pump blood, and all sorts of other body processes. These pre-coded bodily functions are similar to an MVC framework's pre-built controllers for things like login and user profiles.

Now for How They Work Together

If you've lived this long, I think it's safe to assume you know your skin works with your skeleton and your brain and vice versa.

Your brain (controller) uses logic to tell your skeleton to move in certain ways. When your skeleton (model) has been told to move, your skin (view) moves and changes with it. When your skin receives input from the outside world, it will send a message to the brain. From there, the brain may tell the skeleton to move a different way.

Your skeleton (model) may also talk to a database. In this case, we could call your memory the database. Every time your brain tells your skeleton to change shapes, your memory saves it for future reference.

I think, at this point, this chart may make a little bit more sense. What do you think?

Still having trouble? Try thinking of the sites you use regularly. Their controllers will likely include actions like creating, reading, updating, and deleting. The models are going to be the things those actions happen to (ie characters, posts, products, etc). The views are the pretty (or maybe not) visual part you see on your browser.

Other Things Worth Knowing

There are plenty of options when it comes to MVC frameworks. There are even multiples for different languages. Here are a few popular ones and the official getting started projects.

Language	Framework	More Info
Python	Django	Polls tutorial
Ruby	Rails	Blog Tutorial
JavaScript	Angular JS	Catalog tutorial
.NET	ASP.NET	ASP.NET Getting Started
PHP	Laravel	Laravel Quickstart

MVC frameworks make it easier and quicker to create full stack apps than it would be if you wrote everything from scratch. It will take some time to learn how things are put together, but you will reap the reward of being able to make things relatively quickly. Once you've got the basics, congrats! You're a full stack developer.

Btw, what's TIE?

TIE: What is Tech It Easy (TIE)?

Vicki Langer ・ Mar 21 '22

#codenewbie #beginners

TIE: What is a Cascading Delete?

Vicki Langer — Tue, 22 Mar 2022 15:45:39 +0000

Explaining concepts that can be hard to understand. You can expect relatable examples without jargon, foo, bar, and math examples.

Jump to:

Official explanation
TechItEasy explanation
More Info

Scary Jargon-filled Explanation

In a relational database, a foreign key with cascade delete means that if a record in the parent table is deleted, then all associated records in the child tables will automatically be deleted.

TIE: Cascading Delete

First, we must mention, cascading deletes are used with databases who are made up of tables. Deleting means to remove something. Cascades are like waterfalls. So, imagine a delete that flows and takes out all the things attached to the item being deleted.

Let's try out on few ideas to make sure there is a relatable explanation that fits you.

Example at the Vet Clinic

A customer has moved and you need to delete an owner from owners_table and all of their pet records that are in different tables. Here you would used a cascading delete to remove the owner and all of their pets.

Example in Social Media

The most important part of a social media site, like MySpace, is made up of users and their posts. This means there is a table with all users and a table with all posts. Let's say user XxDinoHottie13xX has 379 posts. Before you ask, yes, they are mostly shit posts.

If XxDinoHottie13xX decides they no longer want to have an account on MySpace, they click on a delete button. When they click on the delete button, what do you think should delete? With a cascading delete, it will delete the user, their posts, and anything else that is attached or owned by that user.

Other Things Worth Knowing

There are soft and hard deletes. A cascading delete is a type of hard delete, the data is gone forever. A soft delete hides data from view, but keeps it in the background. Data that is soft deleted is often given a deleted_at column.

If there is any possible reason the data being deleted may be needed in the future, a cascading delete may be a bad idea. Sometimes this reason can be as simple as "we need to know that we had the record at one point in time".

You may think about your placing files in your computer's recycle bin as a soft delete. Then when you empty the bin and it asks you if you want to "permanently erase the items". If you say yes, you've done a hard delete.

From the social media example, a hard delete would be one where all of a users data is permanently removed. A soft delete would be like deactivating the account. A soft delete would keep all the data but make it hidden from the actual site.

Btw, what's TIE?

TIE: What is Tech It Easy (TIE)?

Vicki Langer ・ Mar 21 ・ 3 min read

#codenewbie #beginners

TIE: What is Tech It Easy (TIE)?

Vicki Langer — Mon, 21 Mar 2022 16:52:56 +0000

Hi! Welcome! Have you ever had a hard time understanding a code or programming concept? Then you're in the right place.

What is TechItEasy?

TechItEasy is a developer community built to resemble Reddit's Explain Like I'm Five (ELI5) subreddit. If you're not familiar with it, ELI5 is a forum with requests for concepts to be explained in jargon-free simplified terms.

TechItEasy is your place to ask about those things you just cannot comprehend, have a hard time understanding, and could really use some help with.

TechItEasy is also your place to help others understand concepts that you know.

Vicki Langer

@vicki_langer

Hey friends, do you have something you're having or had trouble understanding and you'd like explained in a relatable way?

Tweet to this community and start your tweet with "TIE: " then add your question.

Example: "TIE: What is control flow and how does it work?"

19:51 PM - 02 Mar 2022

A Few Basic Rules

➡️ Do start Tweets with TIE:

This will keep TechItEasy tweets easy to recognize and search for.

➡️ Do give relatable explanations without scary tech jargon

Some ideas: cats, doing dishes, weather, music, cutting vegetables, cats knocking over trashcans, games, reading, and so so so many other things

➡️ Keep tweets on topic

Tweets shall only include Requests for Explanations, Suggestions or Complaints, or Praise. Tweets should add to the community and not distract from the purpose.

➡️ Avoid vague Requests for Explanation

(e.g. "TIE: What is Programming?", "TIE: What causes this error?", )

➡️ Be respectful && Report the jerks

We are all human. We are not perfect. If someone is wrong, kindly help them understand, tag someone to help explain, or just ignore it.

Some Do's && Don'ts

Asking Questions

Do ask...

for help understanding a concept, idea, or how things work
for explanations in relatable terms
your question even if you think it's "simple" or "should be easy". I promise, there are others that don't understand either

Good Examples
✨ TIE: What is control flow and how does it work?
✨ TIE: What is a cascading delete?
✨ TIE: How is a tuple different from a list?
✨ TIE: Why does 0.1 + 0.2 not equal to 0.3?

Don't ask...

for opinions
controversial or loaded questions
for anyone to do your homework

Bad Examples
🚫 TIE: Light or dark mode?
🚫 TIE: What language should I start with
🚫 TIE: What is Programming?

Answering Questions

assume zero prior experience
use relatable examples (ideas)
use descriptive names
avoid circular definitions

Good Examples
✨ watermelon_count = (5 - spoiled_watermelons) / people
✨ A customer has moved and you need to delete an owner from owners_table and all of their pet records that are in different tables. Here you would used a cascading delete to remove the owner and all of their pets.

Don't...

use foo, bar, or other non-descriptive names
use math examples (unless the the original poster is a mathematician)

Bad Examples
🚫 x = (5 - y)/2
🚫 baz has many foo and if we want to delete foo and all associated records, we'd call that a cascading delete

Where do I start?

Remember, start questions with TIE: and make sure answers are as simplified as possible.

Twitter

Join us in the TechItEasy community on Twitter. From there it's up to you to ask a question or answer someone else's. I look forward to seeing you there.

Other places, like right here on Dev.to

Create a new post, start your title with TIE:, then tag your post with #help.

Charming Python with Lists

Vicki Langer — Thu, 06 Jan 2022 14:22:05 +0000

If learning to code with foo, bar, and math examples are your kryptonite, keep reading. This series uses relatable examples like flipping coins, books, bread, and groceries.

Don't forget, while writing your code, there are lots of tools there to help you.

Jump To:

What are Data Structures
Indexing
Slicing
Mutability
Nested Lists
Let's Build!
Practice Challenges

What are Data Structures

Data structures are collections or groups of data. Typically, data structures hold data types and other data structures. Think of data structures as boxes that have certain rules for what can go in them. You can fit other boxes inside this box as well as other things too.

Python has two types of data structures. There are primitives, which you already learned about, and there are collections. Data types, or primitives, include the basic structures we talked about earlier: integers, floats, strings, and boolean. Primitives also include a type called complex. We haven’t and won’t go over these as they are used in very few things (eg electrical engineering, physics, etc). Oftentimes, we will want to group primitives together. We do this using collections.

Collections allow us to group objects with similarities together. A collection can hold as many objects as you want. Objects can be primitives or collections. Yes, we can put collections inside of other collections. Then we can even put that collection of collections in another collection. I’m sure that was super confusing, but don’t worry. We will go over this in detail later in the section about nesting.

For now, let’s stick to talking about what the built-in data structures are. In Python, we have lists, dictionaries, sets, and tuples. You can build, or implement, data structures of your own (eg stack, queue, tree, etc), but we really should continue learning the fundamentals first. First up, shall we talk about lists?

Lists

Lists are exactly what they sound like. They help you group similar things or objects together. Typically these things have something in common. You’ve used them in real life whether you realize it or not. Lists also have the benefit of being ordered or numbered. We’ll talk about this soon.

Real-life examples

Keeping track of scores in a card game

You likely start with a blank piece of paper. Even though it’s empty, we could call it a list because we know you’re about to write down scores for the game. Each time someone gains points, you add them to the end of the list. Tada! You have a list with values on it.

Have you ever made and used a grocery list?

You likely start with a blank piece of paper. Even though it’s empty, we could call it a list because we know you’re about to write down items we need to get at the store. Every time you think of something you need at the store, you add it to your list. Tada! You have a list with values on it.

Now for the important part of that grocery list. You’re at the store. Every time you find an item and put it in your basket, you can remove the item from your list. Hopefully, by the time you’re done, the list will be empty.

Syntax

Lists can have any number of items or even zero items. You’ll find that since a list is often expected to have multiple items, its name will typically be plural. Many times, you’ll see each item and its comma on a separate line. For space reasons, most of our example lists will be on one line.

# make an empty list
pets_list = []

# list with items
my_scores_list = [12, 23, 7, 5, 54]
your_scores_list = [9, 21, 14, 35]

Lists can contain any mix of data structures, variables, and hard-coded data. This means we can have lists inside of lists, but again, we'll go over that shortly in the section about nesting. For now, know that we can include any mix of variables and hard-coded data in a list.

flipper = "spatula"
chopper = "knife"
scooper = "spoon"
stabber = "fork"

cooking_equipment_list = [flipper, chopper, scooper, stabber, "bowl"]

Make note that even though you gave the list the variables, the list used the variables to find the actual value of each variable.

Did you notice anything weird about how the list items show up in Python Tutor or the screenshots? The items are numbered, but what number was given to the first item in the list?

Relearn How To Count with Zero-Based Numbering

Typically, when we learn to count we start from 1, right? In Python, and most other programming languages, we start counting from zero. We call this zero-based numbering. This means the first thing in your list will always be at the position, or index, zero.

By the way, we can also index backwards, using negative numbers. This would make the last item in your list index position -1 and the second to last item in your list index position -2. This can help when you are trying to get an item from the end of your list.

Finding your Maximum Index

This also means your last index position will always be one less than the length of your list. Do you know why? Look at the cooking_equipment_list above. It is 5 items long and its last or biggest index is 4. You’ll find it is common to save len(list) - 1 into a variable called max_index or last_index. This will become helpful soon when we learn how to get items from a list. This could look like last_index = len(box_contents_list) - 1 and it could be read as “the last index is the length of the box_contents_list minus one”.

Of course, if you know how long the list is, you could hard-code the length. This will work at first, but what if you add to the list later? If you hard-code it, you would have to go back and fix this part too. This could become painful, especially with longer lists where we don’t know the length or if other people are adding to the list and didn’t know something else needed to be changed too.

What can we do with lists?

Getting an Index

What is this “getting” you speak of? A lot of programming is based on the computer’s ability to get things and set things. Getting means that you have asked for the item and setting means you have changed an item. Let’s use hobbies as an example. Just like when we made a list, when we want to get or set indices, we use [].

# Ceora has some hobbies
music = "K-pop"
curiosity = "asking awesome questions"
ceora_hobbies_list = [music, curiosity, "memes", "advocacy", "DX", "Hamilton"]

# get hobby from index 2
print("hobby at index 2:", ceora_hobbies_list[2])

# set/change/update then print hobby at index 2
ceora_hobbies_list[2] = "Philly"
print("changed hobby at index 2:", ceora_hobbies_list[2])

# get hobby from second to last index
print("2nd from last index:", ceora_hobbies_list[-2])

Did you notice we used the same index for the first two sections after creating the list? This is on purpose. In the first section, we want to “get the current hobby at index 2 and print it”. In the next part, we want to “set or change the hobby at index 2 and print it” to verify that it changed. The last bit is just showing how we can use negative indices.

You could also choose to get the index and save it into a variable like this code below.

# get hobby from index 2
hobby_3 = ceora_hobbies_list[2]
print("hobby at index 2:", hobby_3)

If you haven’t already, go ahead and give this indexing a try before moving forward.

Slicing

If you ever wanted a certain portion of a list, you can get it by cutting from one position to another. We call this slicing. Let’s say we have a loaf of bread and we want all the slices, except the pieces on either end. You might initially think we need to know how many slices there are, but we don’t.

To get the parts of the loaf we want, we can use slicing. Slicing also uses [] but it requires more info. When slicing, you’ll use square brackets with two numbers in between. The two numbers will be separated by a colon :. It should look like this [2:7]. This would mean you want everything from index 2 up to but not including index 7.

From what we know so far, there are multiple ways we could get all slices of bread without the end pieces. We will need to combine slicing with either negative indexing or the max index that we talked about earlier. Let’s see how this can be done both ways. I think it’s time to make a sandwich, what do you think?

# get sandwich bread 2 different ways
bread_loaf_list = ["end piece", "slice", "slice", "slice", "other end piece"]

# use slicing with negative indexing
bread_loaf_without_ends = bread_loaf_list[1:-1]
print("sandwich bread retrieved with negative indexing:", bread_loaf_without_ends)

# use slicing with max index
last_index = len(bread_loaf_list) - 1
different_loaf_without_ends = bread_loaf_list[1:last_index]
print("sandwich bread retrieved with max index:", different_loaf_without_ends)

Notice, -1 and the last_index variable refer to the same index position and they are not included in the sliced section you asked for.

We used two different ways to get the same result. Remember, there are often different ways things can be done with code. This means there is no one right way to do things, but there are some guidelines on why we would choose one way over another. There are two main goals when deciding which way to code something. Generally, we prioritize readability or how easy this code is to read without assistance. The other goal is performance or how quickly the computer can read and process the code. This is important, but not near as important as being able to understand the code. When you’re learning, prioritize readability and you can learn about performance later. For readability, you could also have chosen to use loops to iterate through the list.

Iterating

If you don’t recall what a loop is, you can always go back to refresh your memory Or, take a look at this example and see if it’s enough to conjure up the memory. Remember, “iterating” and “running a loop” are used interchangeably where one iteration is one use of the loop.

bread_loaf_list = ["end piece", "slice", "slice", "slice", "other end piece"]

# get sandwich bread a 3rd way, with a loop
for slice in bread_loaf_list:
    if slice == "slice":
        print(slice, end=", ")

If you run this example, clicking the “next” button in Python Tutor will show you what happens at each step.

Here we have a list, the same one we used before. Then we are using a loop to say “I want to look at the first piece of the loaf to check if it is a slice. If it is a slice, it will get printed with a comma and a space , after it.” That would be one iteration. After our first iteration, we’ve checked the first piece of bread. The loop then moves to the next piece and does the same thing as it did the first time. Then it repeats until it gets to the last item in the list.

Printing is fun and all, but let’s see what else we can do with lists.

Some Methods You Can Use with Lists

We have a bunch of list methods.

append(item) - adds an item to the end of a given list
insert(index, item) - adds a given item at a given position
pop(index) - remove and return the item at the given position in the list
count(item) - return the number of times a given item is in the list
reverse() - reverse order of the list
clear() - remove all items from the list

Unlike string methods that give you a new string, list methods actually change the list you’re working with. This happens because lists are mutable and strings are immutable. Mutable means that it can change or mutate. Immutable means it cannot change or it cannot mutate. Lists being mutable or changeable is incredibly helpful. Think about your real-life lists. We’re constantly adding to them, removing things, counting the items, and so much more. Python allows us to do all of these things.

In real life, a chalkboard or notebook would be mutable and art in a museum would be considered immutable. A published book could also be considered immutable, but plans for reading a book may be changed based on different things.

Here is a list example with some examples of methods. Try running the making of the list and start by running each method separately to see what happens. If you run all methods at once, the final output will include all of the methods performed in the order they were given. Once you’ve run each one individually, try figuring out what the end result should be. Then go ahead and add them together and see what the end result is.

prologue_str = "Once upon a time, I yelled at an alpaca while riding a motorcycle."
chapter_1_str = "I jumped on a birdbath in a library because a zebra told me to."
chapter_2_str = "Then, I kicked a pickle on a table because I found 1,000 gold bars"
chapter_3_str = "I sang to a spoon in line at the bank because I can't control myself!"
cat_picture_str = "cat"

planned_reading_list = [prologue_str, chapter_1_str, chapter_2_str]

# you have extra time, let's read chapter 3 too
planned_reading_list.append(chapter_3_str)

# never mind, you don't have time for the list chapter
planned_reading_list.pop(-1)

# oh wait, there was a picture after chapter 1
planned_reading_list.insert(1, cat_picture_str)

# want to see how goofy the book is backward?
planned_reading_list.reverse()

# anyway, how many items are "cat"?
cat_count = planned_reading_list.count("cat")
print(cat_count)

# done reading? Clear your reading to-do list
planned_reading_list.clear()

By the way, if you had even more reading to do, you can also add multiple lists together. Try making some lists and adding them together. When you add them together, they will be in the order you typed them. In the example below, not_mammals_list will be first, then mammals_list.

mammals_list = ["cat", "dog"]
not_mammals_list = ["snake", "cat", "fish"]

animals = not_mammals_list + mammals_list

Nesting Lists

Remember earlier when I mentioned lists could be inside lists? We call these nested lists or a list of lists. Why would we even need that? Let’s talk about a couple of examples.

Think of a home as a list of lists. How could you categorize a home? Rooms could be lists inside the home. Then things inside the room could be items in the room’s list. If one of the rooms has a cabinet, that would be another list, and items inside the cabinet could be items in the cabinet list.

You could also look at a book as a nested list. You can run this code or make something similar that makes sense to you. In Python Tutor, it will draw arrows to show you where each of the lists is being used. You can hover your mouse over the arrows to highlight them. If it’s getting confusing, Try commenting out a chapter or two. Once you understand what is happening you can add them back in one at a time.

# some sentences
sentence_1_list = ["I", "jumped", "on", "a", "birdbath", "in", "a", "library", "because", "a", "bird", "told", "me", "to."]
sentence_2_list = ["I", "karate", "chopped", "a", "pickle", "at", "the", "dinner", "table", "because", "someone", "offered", "me", "1,000,000", "gold", "bars"]
sentence_3_list = ["I", "sang", "to", "a", "spoon", "in", "line", "at", "the", "bank", "because", "I", "can't", "control", "myself!"]
sentence_4_list = ["I", "yelled", "at", "an", "alpaca", "while", "riding", "a", "motorcycle", "because", "I", "like", "getting", "wet."]
sentence_5_list = ["The", "glamorous", "alien", "squashed", "an", "angry", "ant",]
sentence_6_list = ["The", "scrawny", "elephant", "squeezed", "a", "slimy", "doctor",]

# some chapters that contain sentences
chapter_1_list = [sentence_1_list, sentence_2_list]
chapter_2_list = [sentence_3_list, sentence_4_list]
epilogue_list = [sentence_5_list, sentence_6_list]

# a book that contains chapters that contains sentences
book_list = [chapter_1_list, chapter_2_list, epilogue_list]

# want to see the goofy story backward?
book_list.reverse()

Indexing Nested Lists

What if we wanted the 3rd item of the 4th list of the 1st list? Remember indexing? We can index nested lists too! It looks like this home_list[-1][3][21]. This would read something like “I want the last list in home_list. Then I want the item from index position 3 or the 4th item in that list. Now that I have that list, I want the object from index 21.” Try the below code with your nested list practice. Can you guess what it is before you run the code?

# get 2nd item from booklist, then 2nd item from that item, then 2nd item from that item
print(book_list[1][1][1])

# get 1st item from booklist, then the third from last item from that item, then 3rd item from that item
print(book_list[0][-3][2])

Getting indices from nested lists can be confusing. Try reading them one index at a time and that should help. There’s really no limit to how many indices there can be other than the capability of the computer.

Were nested lists hard to understand? If so, don’t be hard on yourself. They’re a more advanced concept. You can absolutely keep coding and come back to these later.

Let’s Build Mad Libs

Mad Libs are stories with words removed and replaced by blanks where you get to fill in the words and make a goofy story. Typically, the blanks are labeled and meant for certain types of words like verbs or adjectives. For this, we will make some lists, then choose words based on an index.

# make some lists of available words
verbs_list = ["yelled", "swam", "vanished", "kicked", "slept", "questioned", "scattered", "escaped", "chased", "jumped"]
adjectives_list = ["slimy", "gooey", "jumpy", "melted", "damaged", "fierce", "victorious", "sparkling", "rotten", "fluffy"]
nouns_list = ["donkey", "sidewalk", "zebra", "cactus", "playground", "toothbrush", "celery stalk", "umbrella", "bottle of poison", "ghost"]
adverbs_list = ["seemingly", "suspiciously", "foolishly", "greedily", "famously", "viciously", "awkwardly", "cleverly", "recklessly", "frantically"]

# get some user input
your_name = input("What's your name?").title()
num = int(input("Give a number 1-10"))
index = num - 1

# Publish your story using indices
print(your_name, adverbs_list[index], verbs_list[index], "on a", nouns_list[index], "in a", nouns_list[index-1])

First we made our lists. Then we ask a user for their name and a number. We forced the number input to be an integer because it is a string by default. Next, we subtract 1 from the number they gave because in most programming languages we start counting at 0. Lastly, we used a print statement and list indexing to build our story.

This story is less than perfect. The strings in the print statement don’t always work because those words should change based on the chosen words from the lists. Still, this does show us a way to use lists and how to use indices. I bet you know enough to use code to help make decisions on which words to use. Do you remember what kind of statements we use to make decisions?

All of our words are hard-coded and it really would be better if they were filled in randomly. Later, we will go over how to make this into a random sentence generator.

Let’s Build a Better Coin-Flipping Game

Do you recall how we talked about making a functional program then adding features later? We’re going to do that again. Our first rendition of this coin-flipping game was only a few lines then we added scoring. Now, we’re going to use lists to make this game even better.

rounds_won = 0  # start with 0 at beginning
rounds_lost = 0  # start with 0 at beginning
total_rounds = 0  # start with 0 at beginning
coin_landed_possibilities_list = ["heads", "tails"]

game_results_list = []  # starting a list to keep track of results

while total_rounds < 3:
    your_choice = input("Heads or Tails?").lower()
    coin_landed = coin_landed_possibilities_list[0]  # you can change this index
    if coin_landed == your_choice:
        print("You win this round")
        rounds_won = rounds_won + 1
        game_results_list.append("won")
    else:
        print("You lost this round")
rounds_lost = rounds_lost + 1
        game_results_list.append("lost")
total_rounds = total_rounds + 1

# calculate who won
if total_rounds == 3 and rounds_won >= 2:
    print("You win! You got best 2 out of 3")
else:
    print("You lose! Computer got best 2 out of 3")

# print results summary
print("summary of games:", game_results_list)

This is a little better, right? We can keep track of our wins and losses with game_results_list. The coin_landed is no longer a string, but it is still hardcoded. The coin is always going to land on heads unless you changed it to a different index. Later, when we go over modules, we’ll talk about how to make coin_landed random. We’ll also talk about how to code a fix for what happens if someone types in something you don’t expect, like “kitties jumping on a trampoline.”. In reality, we know people are unlikely to type that, but they may type “hedds” or “tales”.

Did you see how we started that empty list? We call this “initializing a list”. It’s very much like getting out a piece of paper to start a list. You want to start or initialize this list so that it is ready for you to add things to it later.

Why lists and when to use them?

Lists allow us to categorize things by similarities and they work well with loops. Now would be a great time to go back to the loop section to see if you can make those fake list examples into real lists that work. Don’t forget lists are ordered or numbered. This helps us when creating, reading, updating, and deleting things because we can specify exactly where you want these actions to take place.

Do you remember?

Here's some practice challenges. Let’s practice what we’ve learned so far. Go ahead and comment on this post with your answers. Do you remember? If not, you can always go back to read sections again.

Give an example of a list, then follow these steps

Make a list of something you might do in real life
Get rid of the second to last item
Flip the order of your list
Make everything in your list uppercase
Add something to the end of the list
Add something to the middle of the list using the max index
Flip the order of your list
Add an item at position 1
Empty your list

Show us:

# what your beginning list was

# the code you made

# the list you ended up with.

Was there anything that didn’t work? Do you know why?

Can You Fix What’s Wrong with This?

There may be more than one way to fix each line of code.

drawer_top = [voltage tester. wire caps, electrical tape,
drawer_middle = (1/4 inch sockets, ratchet. 1/2 inch sockets]
drawer_bottom = [rope, tape, zip ties,]
tool_box = [drawer_top". drawer_mid". drawer_bottom",}

drawer_left = [safety glasses| gloves| mask| ear plugs]
drawer_right = [hammer/ stud finder/ pencil/ scribe,]
work_bench = [drawer_left, drawer_right]

garage_list = [work_bench tool box, shelf]

# I need a 1/2 inch socket to take tire off bike
garage_list[2]{2][3)

How would you read that last line out loud?

Go Ahead! You can build a game of chance

Using the coin-flipping game as an example, try making something like Rock Paper Scissors. Remember, to make the game work first, then add the extra stuff like lists and scoring. If something doesn’t work, no worries that’s normal. Go back to the How Do I Code? Error section for help figuring out the errors.

# scoring for a game using lists

Thanks to @ceeoreo for allowing use of their beautiful name.

All of my gratitude to @yechielk for reviewing yet another post. If you like learning about how ethics and programming go together from a Talmudic perspective, check out their newsletter and book.

DRY Out with Loops

Vicki Langer — Wed, 29 Dec 2021 13:32:52 +0000

If learning to code with foo, bar, and math examples are your kryptonite, keep reading. This series uses relatable examples.

Jump To:

For Loops
- Real-life For Loops
While Loops
- Real-life While Loops
Practice Challenges

A loop is a set of instructions that gets continually repeated a certain amount of times or until a condition is met. A condition could be waiting for something to be true or false. A condition could also refer to waiting on the loop to run enough times. Let’s go through a pseudocode example of doing introductions in a new group of people. After that, we’ll talk about different types of loops.

# repeat these steps for every person in the group
# say hi
# give your name and pronouns
# say what you like to do when you’re bored
# mention something you could talk about for hours

For Loops

Sometimes we do know exactly how many times we want to repeat our steps or run a loop. When this is the case, we should use a for loop. This doesn’t mean you need to know the exact number of times to repeat the code. I know that sounds contradictory, but I promise it’s not. Knowing the exact number of times to repeat the code can mean that you used some code to explain how many times. We often use len() and range() to get the exact number of repetitions. We’ll go over how range() works then jump into some examples.

From the Python documentation, range() gives a “sequence of numbers and is commonly used for looping a specific number of times in for loops.”

range(startNum=0, stopNum, step=1)
- startNum is the beginning of your range. It’s not required. The default is 0.
- stopNum is the end of your range.
- Give only the stopNum and you will get that many numbers, though it will not include the stopNum. This is because computers start counting at 0 and not 1.
- Give startNum and stopNum and you’ll get numbers from startNum to stopNum, but not including stopNum.
- step is like counting by 2s (2, 4, 6, 8). If you give it 5 it will give you every 5th number.

Syntax

# get numbers up to, but not including 100
for i in range(0, 100, 20):
    print(i)

Did you notice how there is space in front of all the lines underneath the for line? These are just like the if blocks. The tab before the line is how Python knows this line is a step that belongs to the loop. The next line(s) that are not tabbed in are not part of a loop and therefore will not be repeated. They will run after the loop is done because computers read code top to bottom.

I would read this example as: “for each number from (or “in the range of”) 0 up to but not including 100 while skipping 20, print the number”. The example code would run 5 times. Do you know why? range() is giving us our exact number of times to run the loop. The range starts at 0, ends at but doesn’t include 100, and counts by or steps over 20. In this case, we get 0, 20, 40, 60, and 80.

What is `i`?

You’ll find outside of giving the syntax above, I will never use i. I find it easier to understand my code when I use a descriptive name. A name is great, but we still need to know what the elusive i is. In a for loop, i is a variable that only gets used within the loop.

This variable is called an iterator variable. It is created in the for line, then it can be used in the block of loop code. With each repetition/iteration of the loop, any uses of the variable in the loop block will change. If the first repetition, the iterator variable was 0, then in the second repetition the iterator variable was 1, and so on.

To make things easier to understand, we could just have easily used num or digit instead of i. Read the syntax to yourself, substituting one of these for the i. Does it make a bit more sense now? Diving into some real-life examples should help explain this better.

Do know that if you’re working with books, tutorials, videos, or even other programmers, they may choose to use i. Know that when you’re reading it, you can substitute what makes sense to you.

What can we do with `for` loops?

Again, for loops should be used when we want to repeat code and we know how many times to repeat it.

Real-life examples

Have you ever washed dishes before? I have and I really don’t enjoy it. Let’s try setting up some code for a dishwashing robot.

# assume we have a list or sink full of 37 dirty dishes called dirty_dishes_list
# for every dish on the counter, wash it

for dish in dirty_dishes_list:
    add_soap()
    scrub_dish()
    rinse_dish()
    dry_dish()
    print(dish + "has been cleaned")

This DishBot 3000 code won’t work because none of these functions have been made. Instead, they are placeholders in an example. If you want to see it work, you could swap each line for a line like: print("DishBot 3000 has added soap"). We are also missing a dirty_dishes_list. Once you learn about lists, come back to this example, make a dirty_dishes_list, and try out the code.

Since DishBot 3000 is done washing dishes, I think it’s time to make some more dirty dishes while making dinner. Shall we read our recipe and write up some pseudocode?

# recipe pseudocode

# put all ingredients in a bowl
# mix for two minutes

# heat stove and dump mixed ingredients in pot on stove
# mix for five minutes

With our pseudocode recipe done, we can figure out what our code should be. How many of those steps include some sort of repetition? For each step with repetition, we will need another separate loop.

# recipe loops

# put all ingredients in a bowl
for ingredient in ingredients_list:
    print(ingredient, "measured")
    print(ingredient, "added to bowl")

# mix for two minutes
bowl_mix_minutes = 2
for minute in range(bowl_mix_minutes):
    print("mixed ingredients for 1 minute")

# heat stove and dump mixed ingredients in pot on stove
print("Stove is turned on")
print("Mixture has been added to the pot")

# mix for two more minutes
stove_mix_minutes = 5
for minute in range(stove_mix_minutes):
    print("mixed ingredients over heat for 1 minute")

These loop examples won’t work as expected because we are using lists, but haven’t made any lists. We’ll talk about lists soon and you can come back to see how these work out.

Do you recall why the stove heating print statements are not part of any of these loops? If not, hop back to the for loop syntax for a refresher.

Code Behind the `.upper()` method

Earlier, we talked about the .upper() method. This method takes a string and makes all of the characters uppercase. You now know enough things to write the magic behind .upper(). Let’s pseudocode it first.

# pseudocoding .upper()

# save a string into a variable
# for every character in the string
# if the character is lowercase
# make the character uppercase and print
# if the character is a space, print the space
# if none of that (meaning the character is already uppercase), print the character

Now that you have this written out in pseudocode, use the steps to guide you in writing some code. Don’t forget, you can turn your pseudocode into comments to explain each line. Another hint, programmers tend to use char because it’s short for “character”.

If you don’t recall the ASCII codes for all of the letters, that’s cool, I don’t either. Flip back to String Built-in Functions or lookup “ASCII letter chart”.

Did you notice our pseudocode used the words for and if? We can mix and match our spoken language with the programming language. This helps us start to form an idea of what we should be coding.

I bet you’ll recall that we use tabs and code blocks in both for loops and if blocks. If you use them together, you’ll use combine the tabs to show Python you intend for one to be a part of another. For example, if you have an if block as part of your for loop, the if line will have one tab to show it is part of the for loop. Then, the lines that are part of the if block have two tabs to show it is part of the if block that is inside a for loop.

# coding .upper()

words = "I smelled a goat at the store because I'm a snowman!"

for char in words:  # for every character in the string
    if ord(char) >= 97 and ord(char) <= 122:  # if the character is lowercase
        new_char_code = ord(char) - 32  # get the uppercase character code
        new_char = chr(new_char_code)  # use new_char_code to get uppercase letter
        print(new_char, end="")  # print new_char with no space at end
    elif char == " ":  # if char is a space
        print(" ", end='')
    else:  # if none of the above (probably: char already uppercase or not a letter)
        print(char, end='')

By the way, you can combine functions together. Taking existing code and modifying it to be easier to read and more efficient is called refactoring. With the above example, we could refactor a few lines.

# original lines
new_char_code = ord(char) - 32  # get the uppercase character code
new_char = chr(new_char_code)  # use new_char_code to get uppercase letter

# possible replacement
new_char = chr(ord(char) - 32)  # get uppercase character code then get letter

Why `for` loops and when to use them?

Without loops, we would have to write a lot more code. That would be a hassle for you, the programmer, and your computer would have bigger files to hold on to. Remember, we use for loops when we can discern exactly how many times we need to repeat the code.

While Loops

Sometimes we really don’t know how many times we want to repeat our steps. When this is the case, we should use a while loop. This means no programmer knows the exact number of times to repeat the code.

Have you ever hit "repeat" on a song? That is a while loop. It's going to repeat until you tell it to stop or until there is no power left for the device. If we were coding, we could say "while there is power, play the song on repeat".

Syntax

counter = 0

while something_true:
    print(counter)
    counter = counter + 1

There are several steps to a while loop. If you skip one of them, your while loop is likely to mess up. Remember, the computer will do what you tell it to, not what you want it to do.

Create the counter - a variable to help know when the loop should end
Give a condition - comparison or logical operator, similar to an if statement
Increment or Decrement the counter - add/subtract every time the loop runs

Avoid Infinite Loops

An infinite loop means code repeats forever until your computer senses it and stops the code. This will often look like your computer or a single program is crashing and not responding. If this is the case, you may need to close the tab or program. Then, go back to your code and make sure you have incremented the counter.

What can we do with `while` loops?

Again, while loops should be used when we want to repeat code and we don’t know how many times to repeat it. Instead, we give a comparison(s) or logical operator(s) to make a condition.

Real-life examples

Have you ever pet a cat before? Most cats are a perfect example of a while loop. Before we start, let’s ask the cat how many times they’d like to be pet. We aren’t going to tell the human doing the petting. We’re just going to use the cat’s answer to define our condition. To ask the cat for this, we will use input(). Sadly, we need a number, and input() gives us strings. So, we have to force the it into a number using int(). This forcing from string to integer is called “casting a string to an integer”. All together, we can save the cat’s response into a variable using the first line in this example.

# first ask the cat how many times they’d like to be pet, but don’t tell the human
preferred_pets_num = int(input("How many times would you like to be pet"))
pet_attempts = 0  # start with 0

while preferred_pets_num > pet_attempts:
    print("You have consent to pet again")
    print("purrrr, that pet was accepted")
    pet_attempts = pet_attempts + 1  # add 1 every time you pet

print("That was 1 too many times. I'm leaving now")

The three tabbed in lines run once for each repetition of the loop. The loop ends when we have gone over the accepted amount of pets. Now that the loop is over, we can print that the cat has decided to leave.

Now that the cat is upset and has left us, let’s check the weather and see if our dog is ready to play. In this example, we’ll combine a bunch of the things we’ve covered like if-then statements, logical operators, casting strings, and a while loop. It’s longer than some of the other examples. We’ll look at the different parts to make it make sense.

dog_wants_to_play = True  # dog always wants to play
sunny_outside = bool(input("Sunny? True/False"))
rainy_outside = bool(input("Raining? True/False"))
warm_outside = bool(input("Warm outside? True/False"))
cold_outside = bool(input("Cold outside? True/False"))

dog_energy = 100  # starting with 100%
outside_spent_energy = 3  # % energy spent fetching one time
inside_spent_energy = 2  # % energy spent fetching one time

while dog_energy > 50:  # gotta leave pup some energy
    if sunny_outside and warm_outside:
    go_outside()  # sets outside to True
    if outside:
        throw_ball()
        print("Go get it!")
        print("Drop it")
        dog_energy = dog_energy - outside_spent_energy
    elif rainy_outside or cold_outside:
        throw_ball()  # throw carefully, you're inside
        print("Go get it!")
        dog_energy = dog_energy - inside_spent_energy

At the top, first chunk of lines, we have some inputs that will later help us decide when and where to play. I would read the second line as: “getting user input string of True or False, cast or force into a boolean, then saved into variable sunny_outside”.
After the inputs, we have three lines that set up our dog’s energy. I’d read these as “dog starts with 100% energy, 3% energy is spent outside, and 2% energy is spent inside.” Now we can get into our while loop. Our first line of the loop could read as “while the dog has more than 50% energy, then we do the stuff below”.
Looks like we’ve run into an if-elif statement. Depending on the inputs, you’ll only do one or the other. There are two options: “If it’s sunny and warm, then do the code in this block” or “If it’s rainy or cold, then do the code in this block”.
At the end of each of the if and elif blocks, we made sure to account for spent energy and subtract from dog’s energy. You could read that line as “current dog’s energy is now = the old dog’s energy minus energy spent”. Without this line, we’d have an infinite loop and our poor dog would be so tired they may get hurt.

Do know, this code won’t work as is because none of these functions have been made. Instead, they are placeholders in an example. If you want to see it work, you could swap each fake function (go_outside() and throw_ball()) for a line like: print("We are outside now."). You would also have to change if outside: to if True:.

We talked about infinite loops earlier, but they’re generally a computer or human problem. There are infinite loops in real life. Do you know about the water cycle? The basic concept doesn’t have a good starting point because it is always happening. So, let’s start with rain, snow, and any other precipitation. Water, in some form, falls from the sky. Then, this water collects somewhere (eg bucket, ocean, lake etc). Once the water collects, it can evaporate. As it evaporates, clouds form and the cycle continues until the end of Earth.

If you run try writing this code, expect it to crash. If you don’t remember why that’s fine. You can jump back to the section on infinite loops.

earth_exists = True

# while the earth_exists
# water falls back to earth - precipitate
# water collects
# water evaporates
# clouds form - condensation

Behind the Scenes: Winning and Losing

Using while loops and if-else statements we can build scoring for your favorite game. No matter the complexity of the scoring, you can write it with while loops and if-else statements. First, we’ll use a coin-flipping game.

Our first step won’t be in a while loop. We’ll add the loop when we adjust the game to have 3 rounds and whoever gets two out of 3 will win. Coins have two sides. We’ll call one side “heads” and the other “tails”. Player one, the computer, flips the coin while player two, you, say which side they think will land facing up. If player two’s choice has landed facing up, they win.

your_choice = input("Heads or Tails?").lower()
coin_landed = "heads"

if coin_landed == your_choice:
    print("You win")
else:
    print("You lost")

For now, we have “hard coded” which side of the coin landed facing up. Hard coding means that we did not use any programming magic to come up with this. Instead, we told it the answer. Later when we talk about Python lists, we will add a couple of things to make the computer’s coin flipping random.

For now, we know who won this game but we should make this fair and try for the best two out of three rounds.

rounds_won = 0  # start with 0
rounds_lost = 0  # start with 0
total_rounds = 0  # start with 0

while total_rounds < 3:
    your_choice = input("Heads or Tails?").lower()
    coin_landed = "heads"  # you can change this
    if coin_landed == your_choice:
        print("You win this round")
        rounds_won = rounds_won + 1
    else:
        print("You lost this round")
        rounds_lost = rounds_lost + 1
total_rounds = total_rounds + 1

# calculate who won
if total_rounds == 3 and rounds_won >= 2:
    print("You win! You got best 2 out of 3")
else:
    print("You lose! Computer got best 2 out of 3")

At the top, the first chunk of lines, we added in some counters to help run the code.
After the counters, we added a while loop and tabbed in the if-else statements and their blocks.
With the input().lower() we are acknowledging that a player may input something with different capitalization and we are making sure it will match out coin_landed exactly.
Looks like we’ve run into an if-else statement. Depending on the outcome of the round, you’ll only do one or the other. There are two options: “the coin side facing up is the same as your choice, then do the code in this block” or “the coin side facing up is not the same as your choice, then do the code in this block”.
At the end of each of the if and else blocks, we made sure to account for the results of the round. Depending on the block, you could read that line as “current rounds won = the old rounds won plus one” or “current rounds lost = the old rounds lost plus one”.
After the else block, but still part of the while loop, we add one to our total rounds. Without this line, we’d have an infinite loop and our game would never end.
At the very end, after the loop ends, we use another if-else statement to decide who won the whole game.

Did you notice how we coded the important guts of the game first, then we added the extra features? This is a typical approach to coding. First, we build a functional project. Once it works, we can add features to it. This helps us keep from getting overwhelmed and allows us to see working parts sooner.

Why `while` loops and when to use them?

Remember, we use while loops when we cannot know exactly how many times we need to repeat the code.

Do you remember?

Give a real-life example of a `for` loop and a `while` loop

You can use print statements or fake functions (like jump() or turn_wheel()) to fill in the if-elif-else then blocks

# coding a for loop

# coding a while loop

What’s Wrong with These? Can You Fix them?

There may be multiple ways to fix these. Have fun and do it whatever way you think makes sense.

# pets are a mix of birds, fish, cats, dogs, and reptiles
    for pet in the range of 1 to 10
feed_pet()
brush_pet()
give_water()
    take_outside()
play()

            while dog_awake:
        if dog_energy is more than 50;
    dog_awake = True
    dog_energy = 100
    chase_cat()
    chew_toy()
    beg_for_pets()
    dog_energy = dog_energy - 5
        else:  # dog_energy low
    nap_time()  # changes dog_awake to False
    print("It’s doggy nap time!")

Go Ahead! You can build it! `.lower()`

# coding .lower()

and maybe even `.title()`

# coding .title()

You got this! Build Scoring for a game

You can use print statements or fake functions (like throw() or move_left()) to fill in the if-elif-else then blocks.

# scoring for any game

Thank you to @yechielk for reviewing. If you like learning about how ethics and programming go together, check out their book and newsletter.

Python Switches to Match-Case

Vicki Langer — Sun, 12 Dec 2021 17:52:43 +0000

If reading about code with foo, bar, and math examples is the bane of your existence, keep reading. Expect examples with sweaters and dogs.

Jump to:

Past
Present
- Benefits
- Example 1
- Example 2
Future

Past

Once upon a time, in 2006, a Python Enhancement Proposal(PEP) was introduced. PEP 3103 detailed many different ways a switch statement could be implemented and why Python should have them. That's a long time ago though. Let's jump into the here and now.

Present

The possibility to use match-case statements in Python has not been around very long. The addition of match-case statements in based on PEP 634. They were introduced in October of 2021 with Python v3.10. If you are using Python v3.9 or older, you won’t be able to try these out. I don’t suspect you’ll be missing out on much as these are relatively new. By the time you need them, I’m sure you’ll pick them up quickly. Either way, keep reading just to get a quick introduction to the concept. If you skip reading this, you won’t miss anything other than some cute examples. I’d suggest at least checking those out.

Worth noting, if you hear others talk about switch-case statements, match-case is pretty much the same thing.

Match-case statements are incredibly similar to if-else statements. Seemingly, they can be used interchangeably. Match-case does have a few benefits though. Your computer can read and understand match-case statements quicker than if-else statements. On that note, it tends to be easier for you and other programmers to read and manage match-case statements.

I think it’s time for an example. Is it time to play with your dog?

dog_name = input("What is your dog's name?")
dog_wants_to_play = True  # they always want to play!
match dog_wants_to_play:
    case True:
        print("Go get it", dog_name)
    case False:
        print("Okay", dog_name, "maybe we'll play later")

Wait, but how would that look as an if-else statement?

dog_name = input("What is your dog's name?")
dog_wants_to_play = True  # they still always want to play!
if dog_wants_to_play:
    print("Go get it", dog_name)
else:
    print("Okay", dog_name, "maybe we'll play later")

Well, that doesn't seem very useful. When making a decision that only has two options, an if-else statement is actually shorter. That's okay because match-case statements really shine and show off their usefulness when we have more options.

Comparison `if-else` vs `match-case` .

Are you cold? I'm cold. Let’s take a trip to the Sleevonista sweater factory. Sleevonista makes one-size-fits-all sweaters with different amounts of sleeves. Here's a long kinda unwieldy if-else example.

if sweater_sleeves == 8:
    print("give to spider, squid, or octopus")
elif sweater_sleeves == 6:
    print("give to butterfly, bumble bee, Octocat™")
elif sweater_sleeves == 4 or sweater_sleeves > 2:
    print("give to 3 or 4 legged dog")
elif sweater_sleeves == 2 or sweater_sleeves == 1:
    print("give sweater to human with 1 or 2 arms")
elif sweater_sleeves == 0:
    print("give sweater to to your snake friend")
else:
    print("sweater is broken, make another one")

Let's turn Sleevonista's into a match-case statment.

sweater_sleeves = int(input("How many sleeves does the sweater have?"))
match sweater_sleeves:
    case 8:
        print("give to spider, squid, or octopus")
    case 6:
        print("give to butterfly, bumble bee, Octocat™")
    case 3 | 4:
        print("give to 3 or 4 legged dog")
    case 2 | 1:
        print("give sweater to human with 1 or 2 arms")
    case 0:
        print("give sweater to to your snake friend")
    case > 8:  # NOTE: unsure on the accuracy of this line's syntax
        print("sweater is broken, make another one")
    case _:
        print("You made a sweater")

Notice the wildcard _. This will always be True and it considered irrefutable. You may only have one irrefutable case and it has to be the at the end.

Future

As time goes by, I imagine match-case statements in python will catch on. Eventually, the'll be as commonplace as switch-case statements in languages like Ruby, Java, and so many other languages. If you'd like more read more on the motivation and rationale behind Python now having match-case statements, checkout PEP 635.

What other examples can you think of? Can you come up with some real life examples? Comment below with what you come up with.

If This... Then That

Vicki Langer — Sun, 05 Dec 2021 14:15:57 +0000

If learning to code with math examples are the bane of your existence, keep reading. This series uses relatable examples like animals.

Jump To:

Comparing
On One Condition or More or Not
Decision Making
Practice Challenges

Let’s Compare

Alligator Signs < & >: Which is which?

In school, many of us were taught < and > by imagining they were alligators and crocodiles, Pac-Man, or a crooked letter “L”. Basically, the big open side eats the bigger thing. If you’re like me, this was super confusing. The concept is great, but it made me focus too hard on knowing which item was greater than the other and less on how to read statements like 1 < 2 and 4 > 3.

Reading these types of statements properly will be immensely helpful to you while coding. For starters, we code from left to right. As you’re reading, the side you get to first is the part you want to pay attention to. If the little pointy side is first, on the left, then that is a less than sign. If the big open mouth side is first, on the left, then it is a greater than sign. Here’s a quick example to help you practice reading them correctly.

# common number of feet for each
dog_feet = 4
person_feet = 2

dog_feet > person_feet
person_feet < dog_feet

We can also say something is <= or >=. If you were deciding whether or not it is freezing outside, you may say “if the temperature is <= 32°F or 0°C, then it is freezing”.

temp_f = 30
freezing = temp_f <= 32

That's Not True

Now that you can definitely read these less than and greater than signs, let’s talk about what we use them for. Remember the type of data we called “boolean”? In code, we use them to help us know if a statement is True or False. In the feet comparison example we just used, both statements are true. Though, this isn’t always the case in code. Sometimes statements are true and sometimes they are false. These are typically used in if statements to help us make decisions. We’ll go over those shortly.

# common number of feet for each
dog_feet = 4
fish_feet = 0  # I hope

fish_feet > dog_feet  # this is False
dog_feet * 2 < fish_feet * 10  # this is also False

Is it or is it not?

A quick reminder: variables use one equals sign = to assign the value on the right to the variable name on the left. That’s not its only job though, the = is overloaded with work. It has lots of jobs in programming. Its first job is to assign values to variables. Its other jobs are to help us compare things, but it will look a little different. If we use two equals signs == it means we are trying to compare whether or not the things on either side are of the same value. The side an item is on doesn’t matter. We just want to know if the items are the same integer, string, boolean, etc. I would read thing_1 == thing_2 as “thing_1 is the same value as thing_2”.

That’s great, but what if we specifically want to know if something is not the same as something else? I’m so glad you asked, we have something for that too. Instead of two equals signs, we use !=. In programming, almost always ! translates to not. So, this time, we’d read thing_1 != thing_2 as “thing_1 is not the same value as thing_2”.

Like < or >, == and != are also generally used with if statements. Really, any time we are comparing things, you’re likely to see some version of an if statement.

# common number of lungs for each
snail_lungs = 1
fish_lungs = 0
horse_lungs = 2
snails = 2  # we have 2 snails

fish_lungs == snail_lungs  # this is False
snail_lungs == fish_lungs # yep, still False
snail_lungs * 2  == horse_lungs  # finally, a True comparison

fish_lungs != snail_lungs  # this is True
snail_lungs != fish_lungs # yep, still True
snail_lungs * 2  != horse_lungs  # this one is False

To test out whether a comparison is True or False, you can print your comparison. Did you know our pet cats aren’t the only ones that meow? Test it out with this example.

house_cat_sound = "meow"
snow_leopard_sound = "meow"
cheetah_sound = "meow"

print(house_cat_sound == snow_leopard_sound == cheetah_sound)
print(house_cat_sound != snow_leopard_sound)

dog_sound = "woof"
print(house_cat_sound == snow_leopard_sound == cheetah_sound == dog_sound)
print(cheetah_sound != dog_sound)

On One Condition or More or Not

Now that we know how to compare, let’s talk about Python’s logical operators. We use these operators, or words, to help us arrange things logically.

Imagine you have a bunch of things to do today. On your to-do list, you have: do laundry, play games, clean the kitchen, and feed dogs. From your to-do list, some of these things must be done and some could wait until later. We can use keywords to explain which ones are necessary, which are maybe getting done, and which ones are not going to be done today.
Here's our to-do list:

We only have enough energy to do three of the four things. We know we must feed the dogs. When we have to do something we use and. This will make a program know this condition or item is required.

When conditions are optional, we use or. You realize the kitchen isn’t actually that messy and you still have enough clothes for tomorrow. Now that you know you don’t have to do both, you will have time to play games. Now, let’s put this into code.

There is the option to do kitchen or laundry, then we know we have to feed the dogs. So, we end up with kitchen or laundry and feed_dogs. Wait, we need games too and only have energy for three things on our list! Today, we decide the kitchen will probably not get done.

With both and and or, we are checking to see if things are True. With and, the condition to the right of it must be True. With or, one or both of the conditions must be True.

Next, we have not, which is generally all by itself. This will use a boolean value, like True, and make it the opposite. Imagine you want to know if it is raining. If someone says it is not raining, that would make raining, False. In our to-do list example, the kitchen needs to be cleaned and we have kitchen = True. If we say, not kitchen, that means we have decided not to clean the kitchen. Here’s what this to-do list could look like in code.

# all tasks need to be done, so we start them as True
kitchen = True
laundry = True
games = True
feed_dogs = True

# if we had energy for all tasks
kitchen or laundry or games and feed_dogs

# only energy for three tasks
not kitchen  # guess we’ll do it tomorrow
chores_done = (laundry or games) and feed_dogs
print(chores_done)

Notice how we have parentheses (). Just like in math, there is an order of how things are done. In Python, and will always happen first, unless there are parentheses. We need them to show we have energy for laundry or games, but we also have to feed the dogs. Without the parentheses, we could be saying we have energy for games and feeding dogs or we have energy for laundry.

Wanna test this further? Try changing around the boolean values for the tasks.

Similar to < or > and == and !=, or, and, and not are also often used with if statements.

Controlling the Flow and Making Decisions

Have you ever made a decision before? Maybe you’ve decided what to eat for dinner, what to wear today, or even what colors to mix to make another color. These are all things we can use code to help us with. The most basic way to make decisions is set up to be read like: “If something is True, then we will do this. If it isn’t True, we will do something else.”

If This

First, let's talk about if statements. I’ve mentioned them a few times and how we can use the comparison operators (<, >, <=, >=, ==, !=) and logical operators (or, and, not) with them. If statements/blocks only cover “If something is True, then we will do this”. Shall we jump into an example?

if current_c_temperature <= 15:  # about 60F
    print("chilly outside, wear warm clothes & limit time outside")

If the first line of our code, the if statement, is True then we will do the code in the if block. An if block is defined by the lines underneath the if line that are tabbed in. The block ends when a line is no longer tabbed in. Great, we know what to do if it’s cold outside, but what if it’s not?

If not, Something Else

If your if statement is False, we can do something else. We can add an else block. An else block includes a line that says else: and the tabbed in lines that happen if the if statement was False. With our temperature example, let’s add in an else block.

if current_c_temperature <= 15:  # about 60F
    print("chilly outside, wear warm clothes & limit time outside")
else:
    print("have fun outside, it’s not too cold")

If we were going to read this out loud, we’d say something like: “If the current celsius temperature is below 15 degrees, we should wear warm clothes and limit time outside. If the current celsius temperature is not below 15 degrees, we shall do something else. We will leave our jackets inside and have fun outside.”

Of course these aren’t the only possible temperatures, right? There’s more than just cold and not cold. For situations like this, we can have multiple test conditions.

Multiple Conditions with Elif

For multiple conditions, we have elif blocks. These look exactly like if blocks, but with an el in front of it. They go in between if and else blocks. Time to adjust our example again.

if current_c_temperature <= 15:  # about 60F
    print("chilly outside, wear warm clothes, limit time outside")
elif current_c_temperature >= 15 and current_c_temperature <= 28:  # between ~60F and ~82F
    print("have fun outside, it’s not too cold or too hot")
else:
    print("Wear light clothes, avoid long time in sun, drink extra water")

Notice that only one of the blocks is actually going to be used. This is the goal. We want to use if-elif-else blocks to help us make decisions.

Temperatures are great and all, but it's chilly. Let’s take a trip to the Sleevonista™ sweater factory. Sleevonista™ makes one-size-fits-all sweaters with different amounts of sleeves.

if sweater_sleeves == 8:
    print("give to spider, squid, or octopus")
elif sweater_sleeves > 4 and sweater_sleeves <8:
    print("give to butterfly, bumble bee, grasshopper")
elif sweater_sleeves == 4 or sweater_sleeves > 2:
    print("give to 3 or 4 legged dog")
elif sweater_sleeves == 2 or sweater_sleeves == 1:
    print("give sweater to human with 1 or 2 arms")
elif sweater_sleeves == 0:
    print("give sweater to your snake friend")
else:
    print("sweater is broken, make another one")

Do you remember?

Give an example of each

	Example	How you’d read it out loud
Comparison Operators
(`<`, `>`, `<=`, `>=`, `==`, `!=`)
Logical Operator `and`
Logical Operator `or`
Logical Operator `not`

Are these `True` or `False`?

You are more than welcome to test these out. Don’t expect yourself to understand everything right away. Do test yourself first though.

	`True` or `False`
`skyscraper_size < bicycle_size`
`eat_food and drink_water`
`your_age == parent_age`
`num_dinosaurs_alive >= num_chickens_alive`
`not millionaire`
`cheetah_top_speed <= sloth_top_speed`
`apple_weight != watermelon_weight`
`snowing or !snowing`
`dog_age_in_human_years * 7 > your_age`

Time to make your own decision!

Don’t forget that you can and probably should start with pseudocode.
Some ideas: when to play with dog, what’s for dinner, what movie you want to watch next, water flowing through pipes, or anything else.

# if something is True, 
    # then we do this
# if not that, maybe this is True, if it is
   # then we do this
# if none of those, something else
   # then we do this

Thank you to @andyhaskell for reviewing and the very first owner of Sleevonista™ Original sweater.

Your First Line of Code

Vicki Langer — Sun, 21 Nov 2021 17:24:46 +0000

If learning to code with math examples are the bane of your existence, keep reading. This series uses relatable examples like dogs and cats.

Jump To:

Your First Program
Practice Challenges

Hello, World!

When learning to code, you must start somewhere. You’re not going to jump in and already know how to do things. Some things will look like magic at first. As you go along you’ll learn more and more about how those magic things actually work.

The first program most programmers start with is called "Hello, World". This program is the starting point because it shows some of the language’s syntax and it feels good when you can see the output of your work. This tradition has been around since 1974 when it was first introduced into a programming tutorial book.

Your First Program!

In whichever editor you choose (eg Python Tutor, Trinket, IDLE, etc), type in the code below and run the code. If you don’t know how to run the code, you can always refer back to the Where Do I Code post.

print("Hello, World!")

Depending on your editor, your output will show a little differently, but it will still be displayed. If you got it to work, congratulations! You’ve built your first program!

Try it again, but this time use your own words. Leave the quotes and put your own words inside them.

Um, It Didn’t Work. Now what do I do?

If your code didn’t work, that is okay. This happens ALL the time. In How Do I Code, we talked about bugs and debugging? You have a bug and you need to debug your program. Here are the steps we want to go through.

Look at the code you last wrote. It’s likely to be the culprit.
Make sure the syntax is good.

We have yet to go over the syntax of anything in this program. So, here are some things to check. If you don’t have them, go ahead and fix your code. You can run your code after every change to see if it works.

print should be lowercase
There should be parentheses surrounding your words
Your words and their punctuation should be surrounded by quotes (like this "puppy")

Some Magic with Print

In How Do I Code, we talked about documentation and the importance of reading it. I know it can be scary, but I promise it will help. Let’s take a look at what Python docs have for this print(). You can go to the docs here: https://docs.python.org/3/library/functions.html#print

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

This is showing us the syntax of a print statement and what arguments are required and allowed. Remember, arguments are the things that go inside the () and are separated by commas. There are five arguments; We’ll go over the first three. Any arguments that have an = are not required as they had defaults set to whatever is after the =. Here are the three we’ll work with.

objects refers to whatever you want to print and the * just means you can put as many things, separated by commas, as you want.
sep=' ' is saying that each of those things, or objects, will be separated by a single space, by default. If you were to give sep=', ' your objects would be separated by , a comma and a space.
end='\n' says that at the end of whatever you are printing, it is giving a new line. It’s basically hitting the enter key after you print. You can change that if you want by giving something other than \n for the end. Sometimes it can be helpful to give a separator and/or a different end of the line. Here are a few examples. Try it out for yourself.

# print() separator example
print("cat", "mouse", "dog")  # prints cat mouse dog
print("cat", "mouse", "dog", sep=", ")  # prints cat, mouse, dog
print("cat", "mouse", "dog", sep="123")  # prints cat123mouse123dog

# print() end example
print("1st print", end=", ")  # prints 1st print,
print("2nd print")

Welcome to the world of programming. Now that you’ve done a couple lines of code, you are a programmer. As a programmer, we are always learning. So, try practicing with these challenges below. Then, you’re welcome to keep going and click the next post at the bottom.

Do you remember?

Here's some practice challenges. Let’s practice what we’ve learned so far. Go ahead and comment on this post with your answers. If you don't remember, no worries, you can always go back to read sections again.

Can You Fix What's Wrong with These?

Some of these have more than one right answer. Believe in yourself and give it a try.


`Print("Hi there")"`
`print"(Bom Dia!, sep="... ")"`
`print("Nǐ hǎo", sep" - ")`
`print("¡Hola"!)`
`print.("Assalamu Alaikum", end=" ")`

Make some example print statements and give their output

	Print Statement	What Would the Output look like
Just words
With a different Separator
With a different End

Words, Numbers, & Variables, Oh My

Vicki Langer ・ Nov 17 '21

#beginners #challenge #codenewbie #python

8 Tools I Wish I Knew About When I started Coding

Vicki Langer — Sun, 21 Nov 2021 17:23:23 +0000

Jump To

Syntax
Reading Docs
Pseudocode
Commenting
I Want It That Way
Eek! Errors :( Tell Me Why
Practice Challenges

Coding can be as easy as typing exactly what you see in a book, video, or tutorial and hoping it works. This will work at first, but it’s better to have some tools to help you learn and really understand what you’re doing along the way. These tools will help you better understand what you’re doing and how things work. All of these tools are things professional programmers depend on.

Understanding Syntax

Whether you’re writing in English, Pashto, Hebrew, or a programming language they all require you to use combinations of characters, numbers, and symbols. These combinations of characters, numbers, and symbols mean something. When you were learning to read you were programming your brain to understand these combinations as different sounds. Then you used these sounds to make words. Once you could read words, you could read sentences. There are rules or syntax that tell us how sounds and words work together. Syntax tells us what the correct format is to write certain things.

In programming, syntax is used to define the correct combinations of characters, numbers, and symbols to make the code work. The syntax is different for each programming language just like it is for written and spoken languages. For every new code thing you learn, you want to make sure you look at the syntax and refer back to it if you don’t remember. If you type the wrong syntax, the computer will not understand and it will give you a SyntaxError. If you get a syntax error, look up the syntax to verify you have the right thing.

When looking up the syntax the best option is to look at the documentation. What is given in a tutorial, video, or book is probably correct, but sometimes things change or there are typos. Documentation is the go-to source for all your syntax needs.

Reading Documentation and Searching the Web

As our go-to source of information, documentation or docs as most programmers call it, is incredibly important. You can go directly to the documentation website (docs.python.org), but sometimes the website isn’t the easiest to navigate when you don’t know all the terms that are on it. Personally, I choose to go to my search engine (e.g. DuckDuckGo, Bing, Google) and type in python docs and the thing I want to look up. Most of the time, one of the first results is exactly what I need. Notice, I included the language I’m working with and the word docs.

Reading documentation can feel daunting at first. Let’s look at an example and figure out what’s what. There are several things we need to look at.

Syntax - the name and required symbols to use, in this case print()
Required things - anything inside the () without an equals sign =
Things Not Required - anything inside the () with an equals sign = These things may look like gibberish, but I promise, no one expects you to understand what any of this means. In the documentation there is a description of each thing in the () underneath this line of code.

Pseudocode

We all program every single day of our lives whether or not we realize it. When you get up in the morning, you plan out your day. This act of planning is creating a script or program for your day. This may not be in a computer programming language, but it is absolutely programming. It’s an informal list of steps or a to-do list. In coding, we actually do something similar to this. We call it pseudocode.

Sounds goofy, right? Why are we learning something that basically means “kinda sorta code”? Believe it or not, this is an integral step. Pseudocode is basically a to-do list. We use informal plain language to describe what we are about to code. You may think of it as an outline, plan, or to-do list.

Once you have a pseudocode outline of what you want to build, you can use the steps to help guide what you want to code. In What is Programming, there was an example about how to build a watch. That was pseudocoding. The steps were written with all the focus on how it should work and not on the programming syntax. Though, in real pseudocode, each line would be a comment instead of a bullet on a list.

If I were going to pseudocode for the watch, it would look something like this. Do know that there is no right or wrong way to pseudocode. You may choose to write it differently than someone else. That’s okay. It’s just a guide.

# Repeat steps forever and ever until end of time or battery dies

# Every 1 second up to 59, add 1 to the seconds on screen then
# Add 1 to the minutes on the screen up to 59 then
# Add 1 to the hours on the screen up to 12

Commenting

In the pseudocode watch example, every line starts with a #. Whenever you use a # you’re saying the computer should ignore what comes after it. What comes after the # is meant for humans. Typically, comments are on the line above your code or at the end of the line. It should be an explanation of the what and why of your code. Think of it as a reminder to a future you and an explanation to anyone else reading your code. Oftentimes, your pseudocode will be repurposed and used to comment your code.

You can also use comments to leave yourself to-do things with pseudocode notes.

print(“The Henna Wars”)  # output title of book
# TODO: output author of book - Adiba Jaigirdar

Note: comments are different in different languages. For example, JavaScript uses //.

I Want it That Way

One of the best and worst things in programming is the fact that we have to name things. Naming can be a lot of fun. Later on, you’ll see that I named something cat_summoning_spell. I promised I giggled when I came up with that. As fun as it can be, naming can be hard too.

Names have to be unique. They can’t be the same as anything else or your program will get confused. Imagine having a cat named “Chicken” and a pet chicken. That would quickly get confusing.

Names should also be memorable and descriptive. Using x or foo doesn’t explain what something is. Instead, you could describe what the thing is. If you’re counting stars, you could use something like star_count, star_num, or num_of_stars. Having descriptive variables will help you avoid errors.

Eek! I got an Error. What now? - Tell Me Why

If your code didn’t work, that is okay. This happens ALL the time. You have a bug and you need to debug your program. Here are the steps we want to go through. We’ll go into each of them in detail shortly. While they are in order, there is nothing saying you have to do them in this order.

Read the Error
Find the Culprit
- Make sure the syntax is good.
- Names match (eg variables, functions, classes, etc)
- Comment out code
Ask for help
- Rubber Duck
- Google it
- Actually ask someone
Take a Break

Understanding the Error Messages

I know, errors are scary and look like you broke something. There’s no need to worry though, it’s trying to help you. Errors tell you where the error is and what the problem might be. Let’s look at an example and figure out what’s what. There are several things we need to look at.

Type of error
Description of error
Line number - which line the error is on

Find the Culprit

Now that the error message has led you in the right direction, let’s look where it said the problem is. When you’re first learning to code, your most common errors will be a SyntaxError and a NameError.

You’ll get a SyntaxError when your syntax is messed up. Verify you have it right. I promise, even if you think you have it right, verify anyway. If you’re not sure, you can always look at documentation. Oftentimes, we assume we typed something right and we made a tiny mistake.

Speaking of tiny mistakes, we get NameError when names don’t match. For example, if you have something called dog_feet but you later tried to use dog_paws or dog_foot you’ll get this NameError.

If you’re having trouble finding the error, you can do what we call “commenting out code”. This means you can put a # in front of that line so the computer will ignore that line. You’ll do this with lines that work perfectly and you know aren’t the problem. This helps narrow down the offending or broken code.

Ask For Help

If the other steps didn’t help, try asking for help. There are lots of ways to do this. You can do what we call “rubber ducking” or “rubber duck debugging.” This just means that you are explaining your code and the problem (to the best of your ability) out loud to something like a rubber duck or maybe your cat. You can also do this by typing out your problem as if you were going to ask a question. Oftentimes, this will solve your problem because you’ll be reading off your code and realize what was wrong.

If explaining your code to a rubber duck, your cat, or your programmer friend hasn’t worked, try googling the problem. Typically this would mean you want to search the language you’re working with and the error. You might search something like python NameError: name 'cats' is not defined. Generally the results will lead you in the right direction. You may have to look at a few different results to get the answer you need.

Take a Break

If all else fails, take a break. Yes, seriously. Get up, walk away from your code. Take a walk, get some water, go play fetch with your dog, anything. I know you’re thinking this won’t work, but try it anyway. When you go back to your code later the problem may be glaringly obvious. It also might not be, but you’ve cleared your mind and are in a better position to find the pesky code. The goal here is to not sit there getting frustrated for a long time. Learning to code should be fun. If you find yourself getting upset with yourself, take a break.

Do you remember?

Let’s practice what we’ve learned so far. Go ahead and comment on this post with your answers. If you don't remember, no worries, you can always go back to read sections again.

Write a Pseudocode example or three

Try writing out the steps on how to do or build a real-life thing. Ideas: make a sandwich, use a TV, ride a bike, use a keyboard, or how water flows through kitchen sink plumbing

Pseudocode Examples
first example
another example
and maybe another?

Words, Numbers, & Variables, Oh My

Vicki Langer — Wed, 17 Nov 2021 18:41:31 +0000

If coding tutorials with math examples are the bane of your existence, keep reading. This series uses relatable examples like dogs and cats.

Jump To:

Words
Numbers
True or False
Variables
Practice Challenges

Programming’s Building Blocks - Data Types

Think about the world around you. There are lots of different types of things, right? We can take all of those things and break them down into different types. For everything we see, we’ll call them different pieces of data or information. Each piece of data can be broken down into different types. These different types are the building blocks of programming. We’ll go into more detail on all of these, but for the most part, we have words, numbers, and true or false things.

Look around you and take in your surroundings. We’re going to use them to make these data types. I’ll give examples with my surroundings, but please do use your own.

For me, my surroundings have:

a bookshelf with 23 books on it
a half-full (or half-empty?) water bottle
a dog bed with 2 cats sleeping on it
a keyboard with 68 keys on it

Strings

The first type of data we’ll use is called a string. A string is a bunch of characters (eg. letters, numbers, symbols) surrounded by quotes. Strings can be a single letter, a word, a sentence, or even a whole book.

Strings can use "" but they can also use single quotes, an apostrophe, ''. They must be in pairs though. If the quotes don’t match on both ends of a string, like this ’puppies”, it won’t work.

From my surroundings, I could have:

"Felix Ever After"
'They Both Die At The End'
"The Dangerous Art of Blending In"
"keyboard"
"Remmy and Beans are the 1 cats on the dog’s bed"

If you want your string to show on multiple lines, you can surround it with three pairs of quotes. Here’s an example of a multi-line string with a dog haiku.

"""How do I love thee?
The ways are numberless as
My hairs on the rug.
-Author unknown
"""

Useful Built-in Functions for Strings

Functions are actions you can use with your data. Python has a bunch that are already pre-built and ready for use. In order to use them, we first need to know the syntax, functionname(“your string”). Some helpful built-in functions for strings are len(), min(), and max().

len() - returns the length
min() - returns the smallest value; “A” being the smallest
max() - returns the biggest value; “z” being the biggest; capitals being smaller than lowercase
chr() - returns the character associated with a given Unicode number, “chr” is short for character
ord() - returns the Unicode number associated with a given character

Here are some examples. Try printing them.

len(“Kitties”)
min(“Kitties”)
max(“Kitties”)
chr(86)
ord("V")

You may not use them often, but with chr() and ord() is it helpful to know that each character is assigned and associated with a unicode code number. You can use ord() to find out what that number is or you can look it up at https://www.lookuptables.com/text/ascii-table. You’ll find that lowercase letters range from 97 to 122 and uppercase numbers range from 65 to 90. With that known, 97 a is the lowercase version of 65 A.

Note, we are about to talk about the .upper() method. Later on, we’ll learn how to code that using chr() and ord().

Some Methods You Can Use with Strings

Methods are special functions available based on an object’s type. We just learned that strings are a type. Let’s go over some methods we can use on strings. First, we should talk about how to use them or the syntax. String methods will look like ”your string”.methodname(). Sometimes there will be something in the parentheses, but not always.

”your string”.upper() - returns string all uppercase
”your string”.title() - returns string with first letter of each word uppercase
”your string”.split() - returns your string cut up at it’s spaces and put into a list Here are some examples. Try printing them.

"Chickens slipping on a fondue fountain".upper()
"Llamas melting on a math recipe".title()
"Snakes jumping on a potato pie".split()

By the way, you can use multiple methods together. We call it method chaining. In order to chain methods, you put one method first, then the next one. They will still be separated by a .. The methods will be applied in the order they are given. The below example will take the string and make each word start with an uppercase letter, then make all of the letters uppercase, lastly, it’ll cut the words apart and put them into a list. We’ll talk about lists later, don’t worry about them yet.

"Llamas melting on a math recipe".title().upper().split()

Yes, this is a goofy example. I can’t actually think of a time it would make sense to chain .title() and .upper(), but it is possible.

Numbers

The next type of data we’ll use is not called numbers. Instead, numbers are broken down into two different types. We have whole numbers and decimal numbers.

Numbers do not need and should not have any quotes around them unless they are part of a string. Being part of a string would make them a string and not a type of number.

Integers

Just like in math class, integers are whole numbers. Integers are never decimals or fractions. They are whole things. For example, you wouldn’t have 1.7 airplanes or 2.3 dogs. For things like this, you want to use the integer data type.

From my surroundings, I could have:

23 # books
2  # cats
68 # keys on the keyboard

Note: unlike real life, we don’t include commas in our numbers. If you have 1,000,000 it would just be 1000000.

Useful Built-in Functions for Integers

We have built-in functions for whole numbers too!

pow() - returns 1st number to the power of the second number, exponents
abs() - returns the absolute value or positive of a negative number Here are some examples. Try printing them.

pow(2, 3)  # 2 * 2 * 2
abs(-3)  # |3|

Floats

Similar to integers, but not the same, we have a type of data called floats. Floats are also called floating-point numbers. Floats are numbers with decimals. Floats can also be whole numbers, but typically only when you may need to count the portion of a thing.

From my surroundings, I could have:

0.5

In this example, I only have the contents of my water bottle. From my surroundings, unless they’re broken, I can’t very well have a decimal number of books, cats, or keyboards.

Useful Built-in Functions for Floats

I’m sure it comes as no surprise that floats have some built-in functions.
Here are some examples. Try printing them.

pow() - returns 1st number to the power of the second number, exponents
`abs()’ - returns the absolute value or positive of a negative number
round() - returns a rounded decimal Here are some examples. Try printing them. python pow(4.1, 2) abs(-3.234) round(3.65) round(1.29)

You’re yes then you’re no - Booleans

The last type of data we are going to cover is boolean. Like numbers, booleans do not need and should not have any quotes. They must start with a capital letter. Your only two options are the keywords True and False.

Booleans use True and False but they can be used as stand-ins for yes/no and on/off. If you choose to think of booleans as, yes/no or on/off, use True for “yes” & “on” then use False for “no” & “off”.

From my surroundings, I could have:

python True # Remmy is sleeping False # Beans is sleeping False # Water bottle is full

Keep Your Data Dry with Variables

Now that we know the different types of data, let’s find a way to use each piece of data without having to type it over and over again. In programming, this concept of not retyping things is called Don’t Repeat Yourself(DRY). Variables help us keep code dry by holding data for us.

Writing variables is incredibly similar to math class where you may have had x = 5 to mean there are 5 watermelons. The biggest and best difference is that we don’t typically use x. Instead, we give descriptive names that help us understand what data we are working with. Instead of a letter variable, we can actually say what the variable stands for. Instead of x = 5 we could have watermelon_count = 5.

Picking out a Name

There are some rules with naming that have to be followed or your code won’t work as expected. Then there are some suggestions that you may or may not find helpful.

Here are the requirements:

Must start with a letter or _
Not allowed to use keywords (words set aside for different processes)
Use lowercase letters and numbers
No spaces, use _ instead

Some suggestions to make your life easier:

Make the names descriptive
Include the data type or structure
Avoid single letter and atypically shortened names
Variables are typically nouns

From my surroundings, I could have:
python books_count_int = 23 cat_one_name = "Remmy" cat_two_name = "Beans" water_level = 0.5 keys_count_int = 68 cat_one_sleeping = True cat_two_sleeping = False

Did you notice that with the variable names, I didn’t have to include comments and you understood what each of those numbers meant? That’s why descriptive names are important. Had I called something x, you wouldn’t have known which thing I was referring to.

Assignment

Did you notice above where we used = for our variables? We call the = an assignment operator. I know it’s an equals sign, but I find it helpful to read it as “is”. In cat_one_name = "Remmy", I would read this out loud as “cat one name is Remmy”.
Whatever is on the left of the = is the variable name. The data on the right side is the value being assigned to the variable.

More Dry with Built-ins and Methods

Remember earlier where we printed the outcome of those built-in functions and methods? Let’s find a better way to get data from those. Before we do that, can we adjust each example line to use a variable?
python cat_str = “Kitties” len(cat_str) min(cat_str) max(cat_str)
Instead of printing each line, we can make them into variables. We call this “saving into a variable”. When you use, or run, a function or method in return it gives you some data. Usually, we will want to save that data to use later.

`python
cat_str = "kitties jumping on a trampoline"
cat_str_len = len(cat_str)
cat_str_min = min(cat_str)
cat_str_max = max(cat_str)
heading = cat_str.title()

print(heading)
print(cat_str, "is", cat_str_len, "characters long")
print(cat_str, "biggest letter:", cat_str_max, "smallest letter:", cat_str_min)
`

In this example, we could have easily counted how long the string was, but not everything will be that short. We were able to save the length of the string into a variable and use it later. This will become even more helpful as we learn more things.

A Teensy Tiny Bit of Math

I know, I know. I said there wouldn’t be a lot of math and it feels like everything has been about math. Whether we like it or not, a lot of the cool things we can do are based on some math concepts. For example, you can add and multiply words. Adding words is called concatenation but if you prefer, you can call it “smashing multiple strings together”.

python short_greeting = "hey" long_greeting = short_greeting * 3 different_greeting = short_greeting + "you"

If you put this code into Python Tutor, you’ll get the below. On the right, it will show you your variables and what values they hold.

Notice that you can mix variables and data when using these math operators.

long_greeting "heyheyhey"
different_greeting "heyyou"
"/>

By the way, we also have addition +, subtraction -, multiplication *, and division /. These all work exactly as you would expect. They follow the same order of operations (eg PEMDAS or BODMAS) that you learned in math class. You may also choose to put parentheses () around things you would like done first.

There is another math operator %, called modulus. It looks like and is a percent sign. However, it does something very different. % is used like / but it gives the remainder instead.

Let’s use some variables and do a little math. We have some fruits and we want to share them with a group of people. If you divide them, you’ll find you would have to cut fruits in order to split them evenly. Instead, we can use % or modulus to find out how many fruits are remaining. You can choose what to do with the remaining fruits.

python kiwis = 10 apples = 7 total_fruits = kiwis + apples people = 6 fruits_per_person = total_fruits / people fruits_left_over = total_fruits % people print(fruits_left_over)

If you run this code in Python Tutor, it will look like this. On the right, it has an output box where all of your print() statements show up. Under that it says “Frames”, that’s where it will show you your variables and what values they hold.

Do you remember?

Match data with their data types

Match each block on the left with its data type on the right. Each data type block should be used only twice.
False
"It’s True"
185
4591.28701
The right has: Boolean, Float, String, Integer"/>

Give an example or three of each Type of Data

	Example 1	Example 2	Example 3
String
Integer
Float
Boolean

Can You Fix What’s Wrong with These?

Some of these have more than one right answer. Believe in yourself and give it a try.


`'234 Puppies in 3 bathtubs"`	`45,345.012`
`true`	`291’345’710.5`
`27,345,192`	`90.0000° N, 135.0000° W`
`"4,823 bunnies frolicking in a field'`	`Off`

Make some Variables with each Type of Data

	Example 1	Example 2	Example 3
String
Integer
Float
Boolean

How would you read these out loud?

Examples
`book_name = "The Meet Cute Diary"` `print(book_name)`
`cat_summoning_spell = "Here, " + ("Kitty " * 3)`
`people = 7` `treasure_chest_loot = 1000000` `gold_coins_leftover = treasure_chest_loot % people`

Why should I code?

Vicki Langer — Mon, 15 Nov 2021 18:41:13 +0000

You call the shots!

With code, you get to do whatever you want. Obviously, there are limitations. We should do things that make the world a better place, not worse. The sky is the limit and actually, that’s not really true either. You’re really just limited by your own creativity.

Those limitations aside, you can build whatever you want. If you want to build a car that transforms into a tiger, you can. If you want to build an app that helps people without homes have access to free resources, you can do that. If you want to program a robot to throw a ball for your dog, you can.

The fun of a challenge

What’s the last thing you learned how to do? It was probably hard at first and then something clicked. Do you remember that awesome “aha, it makes sense” feeling? I promise you will get lots of that when learning to code. Of course, at times, that means it’s going to be hard. That “aha” feeling makes it all worth it. That feeling of accomplishment feels good.

Why Use Python and not [insert other programming language]?

There are hundreds of programming languages. You could choose any one of them and be able to learn the same concepts and probably build all the same projects. Each language is typically built for a purpose, but that doesn’t mean it can’t do other things. Sometimes that purpose is just for fun and sometimes it’s to launch a rocket.

In Python’s case, Python was written to make coding easier to read. This is why many programmers suggest learning to code with Python. You’ll also find that Ruby, JavaScript, and Java are often suggested for learning. There really is no right answer. In my experience, I find both Python and Ruby to be the easiest to read and write. Once you understand a few terms, they kinda read like English.

Where do I code?

Vicki Langer — Mon, 15 Nov 2021 17:02:49 +0000

Don’t I have to use [insert fancy computer] to code? No way! You can use any computer, tablet, or smartphone, it doesn’t even have to be connected to the internet. Though, some of the best resources are on the internet, for free.

Fun fact: if you have one, you can even code with a graphing calculator.

Okay, Cool, but Where on my computer can I code?

This is a hard question to answer because there are tons of places you can code. Let’s talk about a few different ones.

	Free	Easy to Use	Visualize	Can save your work	Online	Requires download
IDLE	✅	✅		✅		✅
PythonTutor.com	✅	✅	✅		✅
Trinket.io	✅	✅		✅	✅

IDLE

This is an editor that comes with Python when you download it. (we’ll talk about downloading in a bit). It pretty much looks like a blank document that you can type in. You can type your code in, hit enter, and it will run your code. It looks like this. See the >>>? That’s telling you where you can type. For now, you can ignore the first 3 lines of what probably looks like gibberish.

Note: IDLE does require that you download Python, which will require some space on your computer. We’ll cover how to install before we start coding.

Python Tutor

Python Tutor is a free website you can use without logging in. It runs and helps visualize code. As you learn more things, I’ll explain what they should look like in Python Tutor. Personally, my vote is for everyone to start using this or something similar. For now, here is what Python tutor looks like when you go to Python Tutor

You don’t have to adjust any of the drop-down menus, the defaults are perfect. You can type where it says 1. This just means you are on line 1 of the code. As you type more, it will number each line of code.

There are two ways to use Python Tutor. With the first option, you may type all of your code, then click Visualize Execution which allows you to click the next button to see what happens at individual steps of your code.

The other option is to click Live Programming Mode or go to Python Tutor Live. In this mode, your code will run as you type. I find this helpful as it immediately shows you what each step is doing.

Most of the work you do, while learning, will run perfectly on Python Tutor. Though, there are a few projects that will work better with Trinket.io.

Trinket.io

Trinket.io is similar to Python Tutor in that it’s free and requires no downloads. It allows us to play with a few modules (already built code) that Python Tutor doesn’t support. You can choose to use Trinket for your projects if you want. Trinket does allow but doesn’t require you, to create an account that will save all of the code you build. If you choose not to create an account, you can use the editor on the Trinket.io webpage. The editor looks like the screenshot below.

To use the trinket editor, select and clear all of the code on the left. Then you can type in that area. Once you want to run, make your code do it’s thing, your code, click on the play symbol (▶). Once you’ve clicked ▶, the result of your code will show on the right.

We’ll use Trinket later in the Modules section to play with emojis, date and time, turtle drawing, graphs and charts, and Wikipedia.

What if I already have a code editor or want one?

That's great. If you know how, go ahead and use it. Python files end with .py. If you don’t know how, I highly suggest using one of the above options. I find it’s easiest to learn just one thing at a time. Learning code and how to use the editor may become a bit stressful and overwhelming.

If you don't have an editor on your computer and want one, you may choose to install one like Atom from https://atom.io/.

Either way, most examples will be explained using Python Tutor.

DEV Community: Vicki Langer

TIE: What is an MVC framework?

Scary Jargon-filled Explanation

TIE: MVC framework

Wait! What's a Framework?

Why Use Frameworks?

Right, now, What are the M, V, and C?

Models

Views

Controller

Okay, but How Do They Work Together?

Example with Your Body

Models

Views

Controller

Now for How They Work Together

Other Things Worth Knowing

Btw, what's TIE?

TIE: What is Tech It Easy (TIE)?

Vicki Langer ・ Mar 21 '22

TIE: What is a Cascading Delete?

Scary Jargon-filled Explanation

TIE: Cascading Delete

Example at the Vet Clinic

Example in Social Media

Other Things Worth Knowing

Btw, what's TIE?

TIE: What is Tech It Easy (TIE)?

Vicki Langer ・ Mar 21 ・ 3 min read

TIE: What is Tech It Easy (TIE)?

Jump to

What is TechItEasy?

A Few Basic Rules

Some Do's && Don'ts

Asking Questions

Answering Questions

Where do I start?

Twitter

Other places, like right here on Dev.to

Charming Python with Lists

What are Data Structures

Lists

Real-life examples

Keeping track of scores in a card game

Have you ever made and used a grocery list?

Syntax

Relearn How To Count with Zero-Based Numbering

Finding your Maximum Index

What can we do with lists?

Getting an Index

Slicing

Iterating

Some Methods You Can Use with Lists

Nesting Lists

Indexing Nested Lists

Let’s Build Mad Libs

Let’s Build a Better Coin-Flipping Game

Why lists and when to use them?

Do you remember?

Give an example of a list, then follow these steps

Can You Fix What’s Wrong with This?

Go Ahead! You can build a game of chance

DRY Out with Loops

For Loops

Syntax

What is i?

What can we do with for loops?

Real-life examples

Code Behind the .upper() method

Why for loops and when to use them?

While Loops

Syntax

Avoid Infinite Loops

What can we do with while loops?

Real-life examples

Behind the Scenes: Winning and Losing

Why while loops and when to use them?

Do you remember?

Give a real-life example of a for loop and a while loop

What’s Wrong with These? Can You Fix them?

What is `i`?

What can we do with `for` loops?

Code Behind the `.upper()` method

Why `for` loops and when to use them?

What can we do with `while` loops?

Why `while` loops and when to use them?

Give a real-life example of a `for` loop and a `while` loop

Go Ahead! You can build it! `.lower()`

and maybe even `.title()`

Comparison `if-else` vs `match-case` .

Are these `True` or `False`?