DEV Community: Lourenço Costa

Python course: Loops

Lourenço Costa — Sun, 29 Jun 2025 20:28:00 +0000

This concept assumes you have read the Conditionals and Lists posts.

A loop is a control structure that allows your program to execute a task repeatedly, stopping only when certain conditions are met. The most basic example to demonstrate this concept is iterating the elements in a list.

The `for` loop

This is a loop style more suitable when you know the number of times a task is to be repeated. In the following case I know it will be the same number as the quantity of elements in the list. This subtle detail will become more relevant ahead in this chapter.

branches = ["scranton", "buffalo", "stamford", "utica"]

for i in branches: 
    print(i)

Output:

"scranton" 
"buffalo" 
"stamford" 
"utica"

The syntax is very straightforward, but it is important to understand what is actually going on.

For each element in branches, I am declaring a variable i, then print() it. There's no problem in using the same variable name for all the elements, because for each element there's a new task repetition cycle (iteration), so this variable is re-declared for each element, in every new iteration.

In case you are wondering why I named a variable i, it's a common practice to use single letters in this very specific context (iterating a collection of elements). But this is a matter of taste, as many people tend to adopt something more descriptive, such as the singular version of the list name. In this case, it would be "branch". Personally, I dislike this approach, since normally these two variables' names become very similar, so it gets easy to mistake them. Learn more about these naming practices in the Naming conventions post.

Iterating over indexes in a collection

As seen in the previous example with branches, each iteration returns the value of the element. But it's also possible to obtain the indexes along with the values, by using the enumerate() built-in class :

winners = ["dwight", "pam", "angela"]

for i, v in enumerate(winners): 
    print(f"Index: {i}, Value: {v}")

# This produces the same output: 
for x in enumerate(winners):
    print(f"Index: {x[0]}, Value: {x[1]}")

Index: 0, Value: dwight 
Index: 1, Value: pam 
Index: 2, Value: angela

If the syntax of for i, v in enumerate(winners) looks unfamiliar to you, this is a concept explained in the Deconstructing post.

You can also use enumerate() with tuples, sets and dicts.

The `while` loop

Even though I know the number of times this task is to be repeated (a typical use case for the for loop), let's rewrite the example above using the while loop style, so it's easier to visualize what it does.

branches = ["scranton", "buffalo", "stamford", "utica"]

counter = 0
while counter < len(branches): 
    print(branches[counter]) 
    counter = counter + 1

As you can see, it became a lot more verbose than the for example. I initiated counter as 0, and while the value of counter is less than the quantity of elements in branches (which is 4), the program performs the following tasks:

print() the index counter (0 at this moment) in branches.
Increments the value of counter by 1 (0 + 1 = 1).

Then it moves up to the next iteration, maintaining the new updated value of counter (which just became 1), and repeats both tasks again. In other words, counter starts at 0, then it becomes 1, then 2, then 3...then it stops, because 3 is less than 4 (remember that len(branches) is 4). This signals that the loop is over.

Another way of interpreting the while loop is like saying: "for as long as this condition is met (counter being less than the quantity of elements in branches), perform the following tasks."

Instead of counter = counter + 1, you may write it as counter += 1. It's a shortcut for the same thing and it's more commonly used. See more about this syntax in the Operators post.

Let's see a more suitable use case for the while loop, which is when you don't know how many times a task will be repeated:

while True:
    employee_name = input("Employee name: ") 
    if employee_name == "michael":
        break

# Whatever you write after the "break" will be ignored by the loop iteration!
print("Hello, world's best boss!")

Let's analyze the implementation:

while True
The while keyword needs to evaluate a boolean condition. Here, True is a way of saying that the condition for the loop is already met, so the ﬁrst loop iteration can take place.

Now let's see what happens inside the loop (tasks to be performed):

employee_name = input("Employee name: ")
The input() function does something very interesting and useful: it asks (prompts) the program user (you) to interact with it by writing a text. This text will become the value of employee_name.

if employee_name == "michael"
Here you can see a new keyword: break. It signals that the loop must be exited immediately if this condition is met. This is a very important detail, because it means that whatever you happen to write after this keyword will be ignored by the loop!

With that concept in mind, the task is to check whether employee_name is equal to "michael". If so, then the loop is over. Otherwise, it moves up to the next iteration.

print("Hello, world's best boss!")
This is another important concept to grasp. I don't know how many iterations will be required before you (the user) decide to type "michael"...you might feel like writing all the other employees’ names as far as I know. So, in theory, this loop could run forever! That's the point of using the break keyword, so the loop can be exited after the condition (employee_name being equals to "michael") is met.

With that in mind, it's only after the loop is over that this ﬁnal print() will get executed. Remember: the program is stuck in an inﬁnite loop, so nothing else happens for as long as the condition is not met!

You may use while with other types too, as long as they are validated as boolean. Let’s change the previous function to implement a number of attempts, instead of having an infinite loop:

attempts = 3
counter = 1
while counter <= attempts:
    print(f"Attempt {counter}/{attempts}")
    employee_name = input("Employee name: ")

    if employee_name == "michael":
        print("Hello, world's best boss!")
        break
    counter += 1

In this case, the while loop requires that counter <= attempts. The counter variable starts at 1, which gives a green light to the while loop. Then counter is incremented by 1 at each iteration. But if employee_name == “michael”, the loop is exited via the break keyword. If counter reaches 3, it means the user did not type “michael” after 3 attempts, then the loop is exited too. Notice I added a nice message so the user can see the remaining attempts they have.

Continue

Alongside break, continue is another keyword used to cause interruptions in a loop. But in this case, to skip only the current iteration. Let’s see how it works:

for name in ["pam", "jim", "michael", "jan", "kelly"]:
    if name.startswith("j"):
        # Move up to the next element right now
        continue

    print(name)

Output:

pam
michael
kelly

In this program, each name in the list is expected to be printed, except if it starts with the letter “j”. In this case, the name will be skipped, and the iteration will move up to the next name.

In a way, both continue and break are similar in their nature. While break exits the whole loop, continue exits only the current element in the loop. Also, both can be used in for and while loops.

😊 Enjoying this series? The full book contains even more content! Support my work by purchasing the complete book in digital or paperback formats. Click below to find out more.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

Python course: Deconstructing

Lourenço Costa — Sun, 29 Jun 2025 19:55:09 +0000

This is a process of extracting values from data structures such as lists, tuples, and dicts, and assigning them to isolated variables in a single statement. This is also known as "unpacking".

name, position = ("oscar", "accountant") 
print(name) # => oscar
print(position) # => accountant

# In dicts we use the values (method ".values()") below
branch_name, active = {"name": "scranton", "is_active": True}.values() 

print(branch_name) # => scranton
print(active) # => True

A few remarks:

Notice that the order matters here. The variables will match their respective position in the collection.
When deconstructing a dict, the variable's names do not need to match the keys' names. Only the position matters. See that I deconstructed branch_name to the "name" key and active to the "is_active" key.

Another interesting use case is to use deconstructed values as function arguments.

def print_names(*names): 
    for i in names:
        print(i)

employee_list = ["oscar", "meredith", "pam"]
print_names("oscar", "meredith", "pam") 
print_names(*employee_list)

The output of both calls to print_names() is the same:

oscar 
meredith 
pam

And another example using a dict as a **kwargs argument:

def print_employee_info(name: str, age: int, gender: str): 
    print("Name:", name)
    print("Age:", age) 
    print("Gender:", gender)

employee = {"gender": "male", "age": 37, "name": "Dwight"} 
print_employee_info(**employee)

Output:

Name: Dwight 
Age: 37 
Gender: male

Notice that in the previous example, the order of the keys in the employee dict doesn't match the respective deconstructed variables described as parameters in the print_employee_info() function. So, based on the rules I mentioned earlier, it should not work. But it does work!

The reason it works is because employee was passed to the function as a ** kwargs argument. If you recall from the Functions post, there's a very distinct difference in calling a function with unnamed arguments (* args) and named arguments (** kwargs).

As a result, what matters here is that the keys in employee have an exact match to the parameters' names in the print_employee_info() function.

In other words, employee["name"] gets mapped to name, employee["gender"] to gender, and employee["age"] to age, regardless of their position in the dict!

😊 Enjoying this series? The full book contains even more content! Support my work by purchasing the complete book in digital or paperback formats. Click below to find out more.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

Python course: Conditionals

Lourenço Costa — Sun, 29 Jun 2025 12:58:55 +0000

This is a very basic and essential logical concept used in programming. It's used to represent decision trees.

Consider this diagram example as a decision tree:

In programming, "Did Ryan start the ﬁre?" could be represented as a boolean variable. If True, then the result could be the string "Sing 'Ryan started the ﬁre' ". But if False, then "It was the toaster".

Let's hop into some Python examples:

ream_paper_price = 40.0

# This evaluates to a boolean (True/False)
if ream_paper_price > 10.0:
    percent_discount = 20.0
else:
    percent_discount = 10.0

final_ream_paper_price = ream_paper_price * (100 - percent_discount) / 100 

message = f"The final price for a ream of paper is € {final_ream_paper_price} ({ream_paper_price} - {percent_discount}%)"

print(message) # => The final price for a ream of paper is € 32.0 (40.0 - 20.0%)

In this example we are using the if and else keywords as a decision tree about a discount to be applied. In other words: if ream_paper_price is greater than 10.0, then percent_discount is 20.0. Otherwise (that's what else means), percent_discount is 10.0. In our case, the condition is True (40.0 > 10.0), so percent_discount is 20.0.

The remaining part is a pure mathematical operation to get the ﬁnal price with the discount applied.

But what if the decision tree requires more than two possibilities? That's where the elif keyword comes in:

sales = 1200.0

if sales >= 1000.0: # Possibility A
    bonus = 100.0
    message = f"Your bonus is € {bonus} and you get a trip to the Bahamas!"

elif sales >= 500.0: # Possibility B
    bonus = 50.0
    message = f"Your bonus is € {bonus}."

else: # Possibility C
    message = "You get no bonus..."

print(message)  # => Your bonus is € 100.0 and you get a trip to the Bahamas!

In this example, there are three possibilities that will inﬂuence both bonus and message variables according to the value of sales:

Possibility “A”: if >= 1000.0, then bonus is 100.0
Possibility “B”: if >= 500.0. Here we used the elif keyword, which roughly translates into “otherwise, if…”, then bonus is 50.0.
Possibility “C”: if none of these 2 previous possibilities are met, we use what is stated by the else keyword, that is the equivalent to saying "otherwise…", then there’s no bonus variable. That's the reason I didn't need to state elif sales < 500.0, for example; because this conclusion is already implicit! In other words, this possibility works as a fallback/default scenario.

You may add elif multiple times for 4+ possibilities. Although there are better alternatives for that, such as match cases (See Match statement post), dicts, or even ternaries (see next) in some situations.

Ternary conditional

This is not a different conditional type per se, but rather an alternative way of using a conventional if-elif-else statement. Its syntax may not seem very clear at ﬁrst glance, so let's take a different approach this time. We have a problem to solve, but instead of jumping into the code implementation, we will first gather more details about the problem itself:

A triangle may be classified in three types, accordingly to the length of its sides:

Type	Definition
Equilateral	All sides of equal length
Isosceles	Two sides of equal length and one side that is different
Scalene	All three sides of different length

Also, the sum of any two sides of a triangle must be greater than the third side. If this condition is not met, then it's not a valid triangle... For instance, try to draw a triangle having sides 6 cm, 3 cm and 2 cm. You cannot connect all their ends to form a triangle, right?

Now that we have more details about the problem, let's implement its solution as a function that uses a ternary to validate the possibilities and return the correct triangle type:

def get_triangle_type(side_1: int, side_2: int, side_3: int) -> str:
    # PART 1
    invalid = (
        (side_1 + side_2) <= side_3
        or (side_2 + side_3) <= side_1
        or (side_3 + side_1) <= side_2
    )
    if invalid:
        return "invalid"

    # PART 2
    triangle_type = (
        "equilateral"
        if side_1 == side_2 == side_3
        else "isosceles"
        if side_1 == side_2 or side_1 == side_3
        else "scalene"
    )
    return triangle_type


print(get_triangle_type(6, 3, 2))  # => invalid
print(get_triangle_type(5, 4, 3))  # => scalene
print(get_triangle_type(4, 4, 4))  # => equilateral
print(get_triangle_type(4, 4, 3))  # => isosceles

Now let's go over the implementation details:

PART 1
The ﬁrst thing to do is ensure the sides are valid. After all, there's no point in checking the triangle type if their sides cannot form a triangle in the ﬁrst place... So we perform this validation ﬁrst. If the sides are not valid, we exit the function by returning "invalid".

PART 2
Here's the fun part. Notice that the validation works as a cascade, where each validation only takes place if the previous one is False. It returns the value assigned to triangle_type: which may be "equilateral", but only if side_1 == side_2 == side_3. If this is False, then it is "isosceles", but only if side_1 == side_2 or side_1 == side_3. If this is also False, then it is "scalene", which works here as a fallback/default value.

As mentioned earlier, the ternary syntax is a little unfamiliar, so it may take some time to get used to. Practicing is the key!

You rarely need “else”

Take a look again at the get_triangle_type() function. Notice we didn’t use an else statement to check that the triangle has 3 valid sides. If you recall from the Functions post, whenever the return keyword is found in a function, the function is exited immediately!

We could have placed an else right after part 1 (that checks that the sides are valid), but because we added a return, there’s no need for that.

Let’s consider another problem: say that a person is only allowed to drive at 18 years old, so we will write a function to check that. It should receive the person’s age as a parameter, and return True if they are allowed to drive, or False otherwise. Here’s three different implementations:

def can_drive_v1(age: int) -> bool:
    if age >= 18:
        return True
    else:
        return False

def can_drive_v2(age: int) -> bool:
    if age >= 18:
        return True
    return False

def can_drive_v3(age: int) -> bool:
    return age >= 18

can_drive_v1
This is what we would call a naive approach. The classic structure of theif-elif-else statements “trains” us to think that we must add this else, because there’s another condition to be verified (age not being >= 18).

can_drive_v2
That’s why it’s important to understand what return does. The function returns False by default, but if age >= 18, it returns True.

can_drive_v3
Here’s an example of how helpful a boolean can be (see more in the Boolean logic post). The validation of age >= 18 is, itself, a boolean. So we simply return it.

The main reason why you should avoid using else in functions is clarity. See for yourself. It requires less cognitive effort and time to understand what can_drive_v3 does, compared to the other two ones.

Dict as an alternative to conditionals

If you have 3+ conditionals, a dict (covered in the Dictionaries post) can be another interesting alternative to an if-elif-else conditional:

def get_employees_by_department(department: str) -> list[str]:
    department_map = {
        "sales": ["jim", "dwight", "phyllis", "stanley", "andy"],
        "human resources": ["toby"],
        "accounting": ["oscar", "angela", "kevin"],
    }
    try:
        return department_map[department]
    except KeyError:
        return []


print(get_employees_by_department("accounting")) # => ["oscar", "angela", "kevin"]
print(get_employees_by_department("management"))  # => []

In this example, the keys (department names) in department_map are roughly the equivalent to if-elif conditionals. If the department parameter is found in department_map, then its respective value (a list with people in the department) gets returned. But if it’s not found, then an empty list is returned. Wish to add a new “condition”? Just add a new key: value pair (department name and list of people, respectively) to department_map!

The try and except keywords are covered in the Error/exception handling post. For now, keep in mind that if the department argument is not a key in department_map, then an empty list is returned.

Python course: Operators

Lourenço Costa — Sun, 29 Jun 2025 11:54:45 +0000

Arithmetic operators

Operator	Description	Example
+	Addition	3 + 5 returns 8
-	Subtraction	7 - 2 returns 5
*	Multiplication	2 * 4 returns 8
/	Division (float)	7 / 2 returns 3.5
//	Division (integer)	7 // 2 returns 3
%	Modulus (remainder)	7 % 2 returns 1
**	Exponentiation	2 ** 3 returns 8

Assigning operators

Operator	Example	Equivalent to
=	x = 5	x = 5
+=	x += 3	x = x + 3
-=	x -= 2	x = x - 2
*=	x *= 4	x = x * 4
/=	x /= 2	x = x / 2
//=	x //= 3	x = x // 3
%=	x %= 2	x = x % 2
**=	x **= 3	x = x ** 3

Comparison operators

Operator	Description	Example	Evaluates to
==	Equals to	5 == 5	True
!=	Not equals to	5 != 5	False
>	Greater than	5 > 3	True
<	Less than	5 < 3	False
>=	Greater than or equals to	5 >= 5	True
<=	Less than or equals to	5 <= 3	False

Operator `is`

This is a special comparison operator used to check whether the memory address is the same.

Checking for equality of memory addresses is not something you come across very often in Python programs, as it is a low-level concept. But it's nice to know some basic details about it.

See next some examples to clarify the differences between the is and == operators:

a = [1, 2]
b = [1, 2]

is_a_same_value_as_b = (a == b) # Do they have the same value? 
print(is_a_same_value_as_b) # => True 

is_a_same_memory_address_as_b = (a is b) # Do they point to the same memory address ?
print(is_a_same_memory_address_as_b) # => False 

memory_address_of_a = id(a) 
print(memory_address_of_a) # => 140712901292736 

memory_address_of_b = id(b)
print(memory_address_of_b) # => 140712899331840

Logical operators

Operator	Description	Example
and	Returns `True` if all operands are `True`	`True` and `False` returns `False`
or	Returns `True` if at least one operand is `True`	`True` or `False` returns `True`
not	Returns `True` if the operand is `False`	not `True` returns `False`

More examples:

# OPERATOR "AND":
a = True and True # Both are True 
print(a) # => True

b = True and (1 == 2) and True # At least one is False 
print(b) # => False

c = ("jim" == "jim") and True and (5 > 1) # All are True 
print(c) # => True

d = False and False and (1 == 1) # At least one is False 
print(d) # => False

# OPERATOR "OR":
e = True or False or False # At least one is True 
print(e) # => True

f = (1 == 1) or (2 == 2) # Parentheses are crucial here to remove ambiguity.
# Also, at least one is True 
print(f) # => True

g = (1 > 2) or (2 == 1) or False # None of them are True 
print(g) # => False

h = False or False # None of them are True 
print(h) # => False

😊 Enjoying this series? The full book contains even more content! Support my work by purchasing the complete book in digital or paperback formats. Click below to find out more.

Membership operators

Operator	Description	Example
`in`	Evaluates to `True` if a value is found in a collection	`3 in [1, 2, 3, 4]`returns `True`
`not in`	Evaluates to `True` if a value is not found in a collection	`5 not in [1, 2, 3, 4]` returns `True`

These operators work with collections such as tuples, lists, sets and dicts:

some_dict = {"name": "angela", "salary": 1000.0} 

a = "name" in some_dict.keys()
print(a) # => True 

b = "name" in some_dict # Uses some_dict.keys() as default
print(b) # => True 

c = "angela" in some_dict.values()
print(c) # => True 

d = "name" not in some_dict
print(d) # => False 

some_tuple = ("jim", "pam", "kevin") 
e = "michael" not in some_tuple
print(e) # => True 

f = "jim" in some_tuple
print(f) # => True

Operator precedence

This is an important concept, since it deﬁnes the order in which operations are performed. It works the same as in mathematical operations, where parentheses has higher precedence, meaning they are evaluated ﬁrst:

a = (1 + 10) - (6 + 4) # Meaning (11) - (10)
print(a) # => 1

Bitwise operators

In Python, bitwise operators (| , & , ^, ~, <<, and >>) are mainly used for integer values and binary data. They can also be used for boolean values (True and False) which are internally represented as integers (1 and 0).

These operators are more used in the context of binary manipulation, which is a concept covered in the Bytes chapter. Read more about them here.

Both | and & operators are used for concatenation and intersection, respectively. If you have read the Sets post, then you have already seen them.

Be aware that you are eligible get a Wise card or your first international transfer, up to 500 EUR, free! I've been using their service for years and it's a great way to send/receive money abroad, creating disposable virtual cards, and more. Get it here: Sponsored link.

By now you may have heard of ElevenLabs. Their AI voice cloning service is simply off the charts! Check them out: Sponsored link.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

Python course: Boolean logic

Lourenço Costa — Sun, 29 Jun 2025 10:49:44 +0000

This is a data type used to represent a situation that can assume only one out of two possibilities. It's like the outcome of flipping a coin: it must be either head or tails. There's no third option. Despite its simplicity, it's a very useful data type that can help remove ambiguity and provide clarity and elegance to your programs.

The two possible values for a boolean are True or False.

# PART 1
print(1 > 2) # => False 
print(1 < 2) # => True 
print(2 >= 2) # => True 
print(6 > 6) # => False 
print(5 == 5) # => True 
tricky = 1 == 1 
print(tricky) # => True

# PART 2
print("ryan" == "kelly") # => False 
print("ryan" == "ryan") # => True 
print("ryan" != "kelly") # => True 
print(["pam"] == ["pam"]) # => True
print(("michael", "jan") == ("michael", "holly")) # => False

# PART 3
def is_michael(name: str) -> bool: 
    return name == "michael"

print(is_michael("michael")) # => True 
print(is_michael("stanley")) # => False

PART 1
This is a basic mathematical comparison between numbers using the operators greater than (>), less than (<), and greater than or equals (>=).

tricky
This can cause confusion sometimes, because the operator for assigning values (=) is very similar to the operator for equivalence (==). Here, the value of this variable is equal to the output of the operation 1 == 1 (which is True, since 1 is equal to 1). In this case, adding parentheses may improve readability. Feel free to write it as: tricky = (1 == 1). Read more about operators in the Operators post.

PART 2
The comparison works for strings and other data types as well. Notice that in print("ryan" != "kelly") I used the not equal operator (!=). In other words, it's like asking: is "ryan" different than "kelly"? The answer is yes (True).

PART 3
This is a more realistic use case of a boolean. The is_michael() function returns the equality check between the name argument and the string "michael". Where it returns True if name is equals to (==) "michael". Otherwise, it returns False. There is not a third possibility!

Notice I didn't need to explicitly write True or False as return options. This is the elegance and simplicity that I mentioned earlier about booleans.

😊 Enjoying this series? The full book contains even more content! Support my work by purchasing the complete book in digital or paperback formats. Click below to find out more.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

Python course: Sets

Lourenço Costa — Sun, 29 Jun 2025 10:29:55 +0000

This is another data type used to store values as a collection in Python. Sets offer a very interesting feature, though: uniqueness of elements. This means that if you add the same element twice (or more) to a set, it will be ignored! This is useful if you want to ensure your collection does not contain any duplicated elements:

group_1 = {"jim", "michael", "michael", "jan"} # Notice that "michael" was added twice

group_1.add("pam") # This is how you can add new elements

group_2 = set(["jim", "ryan", "kelly", "ryan"]) # It can be created this way too. Also, notice that "ryan" was added twice

print(group_1) # => {'pam', 'jan', 'jim', 'michael'}
print(group_2) # => {'ryan', 'kelly', 'jim'}

Notice that group_1 and group_2 don't contain any repeated elements, even though I tried to add duplicates into them.

Also, notice that when I print() them, the order of the elements is not respected! This has to do with some internal specifications on how Python stores these values in memory (it uses hash tables). As a consequence of that, you cannot access individual elements by index in a set, as we do in lists and tuples! As a workaround to this limitation, you can easily create a list out of a set:

group_1 = list({"jim", "michael", "michael", "jan", "pam"}) # A list created out of a set. the second "michael" will be ignored

print(group_1) # => ['jan', 'jim', 'pam', 'michael']

This procedure of converting a type into another (in this case, a set into a list), is known as “casting”.

Apart from this validation for uniqueness, another interesting use case for sets is performing union and intersection operations of elements in different sets.


group_1 = {"jim", "michael", "michael", "jan", "pam"}
group_2 = {"jim", "ryan", "kelly", "ryan"}

group_difference = group_1.difference(group_2)
print(group_difference) # => {'michael', 'pam', 'jan'} 

group_union = group_1.union(group_2)
print(group_union) # => {'jim', 'pam', 'jan', 'ryan', 'kelly', 'michael'}

easier_union = group_1 | group_2 # The same as the one above 
print(easier_union) # => {'jim', 'pam', 'jan', 'ryan', 'kelly', 'michael'}

group_intersection = group_1.intersection(group_2)
print(group_intersection) # => {'jim'} 

easier_intersection = group_1 & group_2 # The same as the one above 
print(easier_intersection) # => {'jim'}

If the symbols "|" and "&" are unfamiliar to you (as seen in easier_union and easier_intersection), check out the bitwise operators in the Operators post.

😊 Enjoying this series? The full book contains even more content! Support my work by purchasing the complete book in digital or paperback formats. Click below to find out more.

Be aware that you are eligible get a Wise card or your first international transfer, up to 500 EUR, free! I've been using their service for years and it's a great way to send/receive money abroad, creating disposable virtual cards, and more. Get it here: Sponsored link.

By now you may have heard of ElevenLabs. Their AI voice cloning service is simply off the charts! Check them out: Sponsored link.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

Python course: Dictionaries

Lourenço Costa — Sat, 28 Jun 2025 14:21:29 +0000

This is a way of creating mapping relationships in Python. Each element is composed of two parts: a key and a value. The syntax of a dict in Python is: {<key_1>: <value_1>, <key_2> : <value_2>, <key_n> : <value_n>}. See an example:

employee = {
    "name": "michael scott",
    "position": "regional manager", 
    "age": 46,
    "past lovers": ["jan", "holly", "donna"], 
    "married": False
}

print(employee["past lovers"]) # => ["jan", "holly", "donna"] 

print(employee["past lovers"][0]) # => jan 

print(employee.get("name")) # => michael scott 

print(employee.get("branch", "scranton")) # => scranton

employee["gender"] = "male" # I can add new items 

employee.update({"house owner": False}) # A new item can be added this way too

print(employee.get("gender")) # => male

print(employee.keys()) #=> dict_keys(['name', 'position', 'age', 'past lovers', 'married', 'gender', 'house owner'])

print(employee.values()) #=> dict_values(['michael scott', 'regional manager', 46, ['jan', 'holly', 'donna'], False, 'male', False])

employee["past lovers"]

Note that this syntax is similar to the one used for getting elements by indexes in lists and tuples. But here, instead of an index, you use the "past lovers" key.

employee["past lovers"][0]

As you noticed, the value of employee["past lovers"] is a list containing three elements, so we can use the index to access a particular one.

employee.get("name")

This is an alternative way of accessing a value. It's the same as employee["name"].

employee.get("branch", "scranton")

Do you see a key named "branch" in employee? No. This syntax is a way of setting a default value in case a given key is missing. So if a "branch" key was present and it had a value "x", then "x" would be returned instead of "scranton". This is a handy feature in a variety of situations.

employee["gender"]

Dictionaries are mutable, which means you can add this new key "gender" to it. You can change them too.

employee.update({"house owner": False})

This is an alternative way of adding new items.

Dict comprehension

This concept assumes you have read the Loops, Deconstructing and Conditionals posts.

This is an interesting feature in Python that allows you to create dicts out of collections, such as lists or tuples. By using a more concise and readable syntax:

employees_list = [("angela", 50), ("michael", 46), ("pam", 30)]
employees_dict = {k: v for k, v in employees_list} 
employees_dict_over_30 = {k: v for k, v in employees_list if v > 30}

print(employees_dict) # => {'angela': 50, 'michael': 46, 'pam': 30} 
print(employees_dict_over_30) # => {'angela': 50, 'michael': 46}

employees_dict

This is a dict created with dict comprehension. Let's go over its details in two parts:

Deﬁnes what will be in the new dict: k: v (k for the key and v for the value)
Deﬁnes the iteration over the original list: for k, v in employees_list (a tuple used as a iterator)

employees_dict_over_30

Also a dict created with dict comprehension. There's a third part now:

Deﬁnes what will be in the new dict: k: v (same as the previous example)
Deﬁnes the iteration over the original list: for k, v in employees_list (same as the previous example)
Deﬁnes a conditional for k: v to be added to the dict: if v > 30 (if the value of "v" is greater than 30)

😊 Enjoying this series? The full book contains even more content! Support my work by purchasing the complete book in digital or paperback formats. Click below to find out more.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

Python course: Tuples

Lourenço Costa — Sat, 28 Jun 2025 14:01:12 +0000

Similar to lists, a tuple is another way of creating a collection of values in Python. Apart from its syntax, the main difference between lists and tuples is that tuples are immutable, which means you cannot alter, add or remove elements in a tuple after it has been created!

people_a = ("dwight", "darryl", "angela") 
people_b = "dwight", "darryl", "angela"
person_a = "dwight",
person_b = ("dwight",)
crazy_tuple = ("banana", 1, True, ["A", "B"], 50.0, {}) 

print(people_a[1]) # => darryl

A few remarks:

people_a and people_b

Both are the same thing. The parentheses are optional when declaring tuples, although using them is the most used format. It's the comma-separation that actually creates a tuple!

person_a and person_b

Also both are the same. Notice the comma at the end, even if there's no second element. If no comma was present, it would be a string!

crazy_tuple

In a similar way to lists, a tuple can hold values of different types.

Tuple comprehension

This concept assumes you have read the Loops and the Conditionals posts.

This is an interesting feature in Python that allows you to create tuples using a more concise and readable syntax:

winners = ("dwight", "pam", "angela")

winners_uppercase = tuple(i.upper() for i in winners)
winners_containing_letter_a = tuple(i for i in winners if "a" in i)

print(winners_uppercase) # => ('DWIGHT', 'PAM', 'ANGELA') 
print(winners_containing_letter_a) # => ('pam', 'angela')

Explaining:

winners_uppercase

This is a tuple created with tuple comprehension. Let's go over its details in two parts:

Deﬁnes what will be in the new tuple: i.upper()
Deﬁnes the iteration over the original tuple: for i in winners

winners_containing_letter_a

Also a tuple created with tuple comprehension. There's a third part now:

Deﬁnes what will be in the new tuple: i
Deﬁnes the iteration over the original tuple: for i in winners
Deﬁnes a conditional for i to be added to the new tuple: if "a" in i (if the letter "a" is found in i)

Accessing indexes in tuples

The indexing rules and syntax for getting targeted elements and slices as seen in the Lists post are valid for tuples too:

people = "jim", "pam", "dwight", "angela"

print(people[2])  # => dwight
print(people[-1])  # => angela
print(people[:2])  # => ('jim','pam')

😊 Enjoying this series? The full book contains even more content! Support my work by purchasing the complete book in digital or paperback formats. Click below to find out more.

Tuples vs Lists

In case you are wondering when to use lists or tuples, since they are so similar, here's a few points for your consideration:

Tuples are a good choice when you want to ensure the elements are not accidentally modified. This is because tuples are immutable, meaning their elements cannot be changed once the tuple is created. If you have data that should remain constant, then using a tuple is a suitable option.
Tuples are optimized for performance in certain operations. They are faster for operations such as iterating over their elements or accessing them via index. If you need to access or iterate over the elements of a collection but don't need to modify it, using a tuple can be more suitable compared to a list.
Lists provide more flexibility compared to tuples. They allow you to change, add, or delete elements in a collection. If you anticipate needing to modify the elements of a collection or require more flexibility in general, then a list would be a more suitable choice.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

Python course: Lists

Lourenço Costa — Sat, 28 Jun 2025 12:43:39 +0000

This is one of the most typical ways in Python to store collections of values.

winners = ["dwight", "darryl", "angela", "kevin", "phyllis", "toby", "oscar"]
crazy_list = ["banana", 1, True, ["A", "B"], 50.0, {}]

As seen in crazy_list, a list may hold values of different types.

Accessing elements in a list

A crucial concept to grasp in order to work with lists is "indexes". Each element in a list is automatically assigned a number, starting at 0, according to their position.

So in the winners list:

Element	Index	Negative index
dwight	0	-7
darryl	1	-6
angela	2	-5
kevin	3	-4
phyllis	4	-3
toby	5	-2
oscar	6	-1

With that in mind, you can access individual elements by referring to their indexes:

print(winners[0]) # => dwight
print(winners[1:4]) # => ['darryl', 'angela', 'kevin']
print(winners[-1]) # => oscar
print(winners[:3]) # => ['dwight', 'darryl', 'angela']
print(winners[4:]) # => ['phyllis', 'toby', 'oscar']

A few notes:

winners[1:4]

Note that the syntax for slicing a list is <list>[<ﬁst index> : <last index>]. The ﬁrst index is inclusive, and the last index is exclusive. What it means in practice is that "1:4" actually ranges the elements starting at index 1 and ﬁnishing at index 3 (4-1). This characteristic is inherited from the mathematical concept of intervals. In this case, the first index 1 is a closed (inclusive) interval, and the second index 4 is an open (exclusive) interval. See below a visual representation of this idea:

1	4
[ x ]	[ ]

winners[-1]

By using a negative number, the index number is counted backwards, where -1 means the last element in the list. So, in this case "oscar" can be accessed by both indexes 6 and -1, "toby" by 5 and -2, and so on.

Being able to select the negative index is very convenient. Let's say you have a huge list and you wish to access its last element. Instead of visually checking its position, you can simply select the index -1.

winners[:3]

Omitting the ﬁrst index is a shortcut for the ﬁrst index (0), so this is the same as 0:3.

winners[4:]

Omitting the last index is a shortcut for the last index (-1), so this is the same as 4:-1.

Validation if a list has elements

This concept assumes you have read both Functions and Conditionals posts.

Consider the following situation: you have a function that receives a list. If the list has elements, the function performs action "A", but if the list is empty, then it performs action "B".

You may use the len() function to get the number of elements in a list.

winners = ["dwight", "pam", "angela", "kevin", "phyllis", "toby", "oscar"]
losers = []

print(len(winners)) # => 7
print(len(losers)) # => 0

The len() function can be used with other types too, such as dicts and strings.

It's very common for people to assume you need to check whether the quantity of elements in the list is greater than 0 ( len(winners) > 0 ) to accomplish that. But in Python there's a convenient abstraction for checking whether a list has elements or is empty:

winners = ["dwight", "pam", "angela", "kevin", "phyllis", "toby", "oscar"] 
losers = []

def handle_list(some_list: list) -> None: 
    if some_list:
        print("list has values") 
    else:
        print("list is empty")

handle_list(winners) # => list has values 
handle_list(losers) # => list is empty

List comprehension

This concept assumes you have read the Loops post.

This is an interesting feature in Python that allows you to create lists using a more concise and readable syntax:

winners = ["dwight", "pam", "angela", "kevin", "phyllis", "toby", "oscar"]

winners_uppercase = [i.upper() for i in winners]
print(winners_uppercase) #=> ['DWIGHT', 'PAM', 'ANGELA', 'KEVIN', 'PHYLLIS', 'TOBY', 'OSCAR']

winners_containing_letter_a = [i for i in winners if "a" in i]
print(winners_containing_letter_a) #=> ['pam', 'angela', 'oscar']

# Another interesting example is creating a list of numbers...
numbers_from_1_to_5 = [i for i in range(1, 6)]
print(numbers_from_1_to_5) # => [1, 2, 3, 4, 5]

# ...and creating a list with the alphabet letters:
alphabet_letters = [chr(i) for i in range(ord("A"), ord("B") + 25)]
print(alphabet_letters) #=> ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']

Explaining:

winners_uppercase

This is a list created with list comprehension. Let's go over its details in two parts:

Deﬁnes what will be in the new list: i.upper()
Deﬁnes the iteration over the original list: for i in winners

winners_containing_letter_a

Also a list created with list comprehension. There's a third part now:

Deﬁnes what will be in the new list: i
Deﬁnes the iteration over the original list: for i in winners
Deﬁnes a conditional for i to be added to the new list: if "a" in i(if the letter "a" is found in i)

Some methods in lists

There are many built-in methods to extend the capabilities of a list. Visit here to see them all. Next, a few of the most popular ones:

winners = ["dwight", "pam", "angela", "kevin", "phyllis", "toby", "oscar"]

winners.pop(1) # The element at index 1 ("pam") was removed from the list

winners.append("jim") # Now "jim" is included in the list

winners.sort() # Now the list is in alphabetical order

print(winners) # => ['angela', 'dwight', 'jim', 'kevin', 'oscar', 'phyllis', 'toby']

😊 Enjoying this series? The full book contains even more content! Support my work by purchasing the complete book in digital or paperback formats. Click below to find out more.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

Python course: Functions

Lourenço Costa — Thu, 26 Jun 2025 19:38:04 +0000

Functions in Mathematics
Functions in Python
Type hints
Parameter vs argument in functions
Functions with a dynamic number of parameters
Functions as parameters
Documenting functions
Anonymous/lambda functions
Function chaining

The concept of function in programming is derived from the mathematical concept with the same name. In mathematics, a function is a rule that maps a set of input values to a set of outputs.

As a real-world analogy, think of a function as a vending machine. In order to use it, you select the product you want and insert the payment. Both of them can be seen as the inputs. Then the machine processes them and gives you the desired product, which can be seen as the output of the function.

Functions in Mathematics

As a basic example:

f(x) = x + 2
Where:
f: the name of the function
x: the input
x + 2: the output

In this case, the function f receives a number x and returns this same number plus two (x + 2).

Some examples of how this function can be used:

f(1) = 3
f(2) = 4
f(10) = 12

Functions in Python

In programming, these input values are known as parameters, and the output is known as return.

This same function previously described can be represented in Python as such:

def add_two(x: int) -> int: 
    return x + 2

# This also works 
def add_two_v2(x):
    return x + 2

print(add_two(5))  # => 7 
print(add_two_v2(5))  # => 7

Unlike the mathematical example, in programming we usually adopt more descriptive names for functions, so that a reader can infer what the function does just by looking at its name. Using phrasal verbs is a good approach, since functions typically perform some sort of action.

The print() command, that we have been using a lot throughout this series, is actually a function. It's a built-in function, which means it is natively available in any Python program.

In order to execute a function in Python, the function needs to be followed by parentheses enclosing any necessary arguments. This is known as "calling" a function:

# here I am calling the print() function with "hello" as an argument
print("hello")

Type hints

In the previous example, the add_two_v2() function does the exact same thing as add_two(). The difference is that add_two() provides more explicit information by letting you know that the x parameter is an integer (x: int) and that it returns and integer as well (-> int). This approach of specifying the types of parameters and return values is known as "type hints". It improves readability, and is the convention adopted in the series.

Parameter vs argument in functions

These terms are often used interchangeably, but they actually have different meanings. Parameter is a variable or placeholder that represents an input value that will be passed to the function.
Argument, on the other hand, is the actual value passed into a function when the function is called. See this example:

def introduce_myself(name: str, age: int) -> str:
    return f"My name is {name}, and I am at least {age} years old"

introduce_myself("Michael Scott", 46)

In this example, the introduce_myself() function accepts two parameters: name and age. Then I called it with the arguments "Michael Scott" and 46, they became the values of the name and age parameters, respectively.

A function can accept multiple parameters with different types. Also, you can assign variables to function calls. See below:

def introduce_myself(name: str, age: int) -> str:
    return f"My name is {name}, and I am at least {age} years old"

# Assigning the return of calling "introduce_myself('Michael Scott', 46)" to the "introduction" variable:
introduction = introduce_myself("Michael Scott", 46)

print(introduction) # => My name is Michael Scott, and I am at least 46 years old

Speaking of parameter types, a parameter can be represented as multiple types simultaneously using the "|" operator. For example, the following function can accept a string, an integer, or a float as an argument:

def handle_many_types(some_type: str | int | float) -> None:
    received_type = type(some_type)     
    print(received_type)

handle_many_types("jim") # => <class 'str'>
handle_many_types(10) # => <class 'int'>
handle_many_types(60.0) # => <class 'float'>

A Python function does not necessarily require parameters or an explicit return value. In the following example, there are no parameters, and it does not explicitly return anything, although it implicitly returns None, which is a concept explained in the Absence of a value post.

def say_hi():
    print("Hi")

say_hi() #=> Hi

Speaking of the return keyword, there is an essential aspect of this keyword that may not be obvious when you first start learning about functions: whenever a function encounters a return statement, the function is exited immediately! As a result, anything written after a return statement will be ignored! Take a moment to absorb this information.

😊 Enjoying this series? The full book contains even more content! Support my work by purchasing the complete book in digital or paperback formats. Click below to find out more.

Functions with a dynamic number of parameters

First, take a look at this function:

def greet(person_name: str) -> str:
    return f"Hello, {person_name}"

# Non-named parameter
print(greet("Michael"))

# Named parameter. The parameter “name” is specified
print(greet(person_name="Michael"))

As you can see, I can call the function either by simply passing "Michael", or by explicitly stating that the person_name parameter is "Michael".

Typically, that's how you call functions in Python. But in certain situations, you may want to enforce one approach over the other.

Understanding this concept is crucial to comprehend how it's also possible to call a Python function with a dynamic quantity of parameters.

With unnamed parameters (*args)

Here's a function to be called with multiple unnamed parameters:

def get_multiple_unnamed_parameters(*args):
    return args

a = get_multiple_unnamed_parameters("Scranton", 10)
b = get_multiple_unnamed_parameters(1, "Kelly", 52.5, True, [1,2])

print(a) # => (Scranton, 10)
print(b) # => (1, 'Kelly', 52.5, True, [1,2])
print(type(a)) # => <class 'tuple'>

Notice that in both calls to the get_multiple_unnamed_parameters() function, the arguments are not named (they are simply passed in a sequence). Also, notice that I called it with different quantities of arguments.

About args: this variable name is just a convention. Any other name can be used. The important part is the "" before the name.

Note that the function above returned args as a tuple. This is an important concept! You will learn about it in the Tuples post.

With named parameters (**kwargs)

In a similar way, a function that requires multiple named parameters can be deﬁned as such:

def get_multiple_named_parameters(**kwargs):
    return kwargs

a = get_multiple_named_parameters(name="Ryan", age=25)
b = get_multiple_named_parameters(code=2, color="red", active=False)

print(a) # => {'name': 'Ryan', 'age': 25}
print(b) # => {'code': 2, 'color': 'red', 'active': False}
print(type(a)) # => <class 'dict'>

About **kwargs: this variable name is just a convention. Any other name can be used. The important part is the "**" before the name.

Note that the function above returns kwargs as a dict. This is an important concept! You will learn about it in the Dictionaries post.

Functions with default parameters

It's also possible to set default values to function parameters, so that if the function is called without the arguments, the default values get used. But if the arguments are passed, they override the default ones.

In this following example, I am setting default values to both name and age parameters, but I decided to call the function by passing only the age parameter. As a result, the function call will take the default value for name and the passed argument value for age:

def introduce_myself(name: str = "Darryl", age: int = 46) -> str:
    return f"My name is {name}, and I am {age} years old"

print(introduce_myself(age=35)) # => My name is Darryl, and I am 35 years old

Functions as parameters

In Python, functions can also be used as parameters to other functions:

def get_sum(x: int, y: int) -> int: 
    return x + y

def get_multiplication(x: int, y: int) -> int: 
    return x * y

def calculate(fun: callable, x: int, y: int) -> int: 
    return fun(x, y)

calc_sum = calculate(get_sum, 5, 10) 
calc_mult = calculate(get_multiplication, 5, 10)

print(calc_sum) # => 15
print(calc_mult) # => 50

In this example, calculate() is a function that receives a callable fun parameter ("callable" is the type hint for functions), plus two integers x and y. Then, inside it, the fun function is called using x and y as arguments. Notice that now I can call calculate with both get_sum() and get_calculation() functions as arguments!

Another detail to pay attention to is the fact that when I call calculate(), its argument functions get_sum and get_calculation are not called (notice the absence of parentheses in the arguments). This means I am passing only a reference to these functions as arguments, as opposed to the outputted result of calling them. In other words, if I passed get_sum(5,10) instead, it would be the same as passing the integer 15, which is not what you want.

As you may have noticed, it would have made more sense to just call get_sum() and get_calculation() functions individually, rather than using this new calculate() function with them. But this is just a basic example to demonstrate the concept, which can be far more useful in other situations.

Documenting functions

In certain situations, you may want to provide a clearer explanation of what a function does, its parameters, and its return values.

Instead of using comments "#", the suggestion is that you use function documentation, also known as "docstrings". The syntax if very basic: the ﬁrst string you place after the function deﬁnition will be treated as its documentation:

def add(a: int, b: int) -> int: 
    """
    Add two numbers and return the result.

    Parameters:
        a (int): The first number to add. b (int): The second number to add.

    Returns:
        int: The sum of a and b. 
    """
    return a + b

# This can be used to output the function's docstring 
print(add.__doc__)

If you are using an IDE or other text editor with support for docstrings, you should also be able to see this documentation by hovering over the function's deﬁnition with your mouse pointer.

Anonymous/lambda functions

In many programming languages there's this special kind of function called "anonymous functions". In Python, they are known as "lambda" functions. Basically they are used for writing short operations. Its syntax is: lambda <parameters> : <returned expression>.

The syntax of a lambda function may look unfamiliar at ﬁrst glance, so let's go through some examples in order to make it clearer:

add_two = lambda x: x + 2 
multiply_two_numbers = lambda x, y: x * y
get_stanley_only = lambda x: "stanley hudson" if x == "sh" else None

print(add_two(5)) # => 7 
print(multiply_two_numbers(5, 2)) # => 10
print(get_stanley_only("sh")) # => stanley hudson 
print(get_stanley_only("ms")) # => None

About the lambda functions in the previous example:

add_two

Receives one parameter x and returns x plus 2.

multiply_two_numbers

Receives two parameters x and y and returns x multiplied by y.

get_stanley_only

Receives a parameter x and returns either "stanley hudson" (if x is equals to "sh"), or None (if x is any other value).

Function chaining

It’s also possible to attach the return of a function to another function, making them work as a chain:

# CASE 1
last_letter_upper = "a-c".replace("c", "b").upper().split("-").pop()
print(last_letter_upper) #=> “B”

# CASE 2
starts_with_1 = int(40).__add__(60).__str__().startswith("1")
print(starts_with_1) #=> True

CASE 1

I am replacing “c” with “b”, then turning the string into uppercase. The split() function turns the string into a list, separating the elements by “-”, which returns list([“A”,”B”]). Finally, pop() returned the last element of the list, which is "B". So, 4 functions were chained to output the desired result!

CASE 2

Now I am adding 60 to 40, which outputs 100. Then turning it into a string, then checking if this string starts with “1”, which is True.

Be aware that you are eligible get a Wise card or your first international transfer, up to 500 EUR, free! I've been using their service for years and it's a great way to send/receive money abroad, creating disposable virtual cards, and more. Get it here: Sponsored link.

By now you may have heard of ElevenLabs. Their AI voice cloning service is simply off the charts. Check them out: Sponsored link.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

Python course: Numbers

Lourenço Costa — Thu, 26 Jun 2025 19:11:46 +0000

In Python, numbers can be represented as three different types:

Int

Short for "integer". This type is used to represent whole numbers. Being positive, negative, or zero.

a = 5
b = 123456789101112
c = -45
d = 0

# Use type(<some_variable>) to return the type of a variable:

print(type(a)) # => <class 'int'>
print(type(b)) # => <class 'int'>
print(type(c)) # => <class 'int'>
print(type(d)) # => <class 'int'>

Float

Also can be positive, negative or zero. It's used to represent decimal numbers. Floats can also be used to represent scientific notation, adopting "e" to indicate the power of 10.

a = 1.50
b = 0.0
c = -48.68
d = 4e3 # scientific notation, equals to 4000.0 
e = 4e-3 # scientific notation, equals to 0.004

print(type(a)) # => <class 'float'> 
print(type(b)) # => <class 'float'> 
print(type(c)) # => <class 'float'> 
print(type(d)) # => <class 'float'> 
print(type(e)) # => <class 'float'>

Complex

A "complex" is a number with a real and an imaginary part, where the imaginary part is a multiple of the imaginary unit "j".

a = 3 + 5j 
b = 5j
c = -5j

print(type(a)) # => <class 'complex'> 
print(type(b)) # => <class 'complex'> 
print(type(c)) # => <class 'complex'>

Be aware that you are eligible get a Wise card or your first international transfer, up to 500 EUR, free! I've been using their service for years and it's a great way to send/receive money abroad, creating disposable virtual cards, and more. Get it here: Sponsored link.

By now you may have heard of ElevenLabs. Their AI voice cloning service is simply off the charts. Check them out: Sponsored link.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

Python course: Strings

Lourenço Costa — Thu, 26 Jun 2025 18:52:09 +0000

Replicating strings
Escape sequences
Raw strings
Slicing
Some methods

Strings are used to represent text in Python. Any of these syntaxes are valid strings:

name_1 = 'Stanley Hudson'
name_2 = "Stanley Hudson"
name_3 = """
Stanley
Hudson
"""
name_4 = """
Stanley Hudson
"""

name_3 and name_4: these are ways of representing multi-line strings.

In more realistic scenarios, you are more likely to use strings composed by regular text plus other values obtained from variables. Let's say you want a string to greet someone based on their name:

This process is also known as “string interpolation”.

name = "Angela"
animal = "cat"
greeting_1 = f"Welcome, {name}"
greeting_2 = "Welcome, " + name
greeting_3 = "Welcome, %s" % name
greeting_4 = "Welcome, {}. Are you a {} person ?".format(name,
animal)
print(greeting_1) # => "Welcome, Angela"
print(greeting_2) # => "Welcome, Angela"
print(greeting_3) # => "Welcome, Angela"
print(greeting_4) # => "Welcome, Angela. Are you a cat person ?

Some explanation about these string variables:

greeting_1
This is the convention adopted throughout this series of articles, since I ﬁnd it more convenient to use and readable. Also, it’s the most modern approach.

Notice the “f” must be placed right before the beginning of the string.

greeting_2
Notice the “+” sign. When dealing with strings, it means concatenation (joining). If you use it with numbers, such as integers or ﬂoats, it means a mathematical sum. This ability to perform different actions according to how it’s used is called polymorphism (poly=many, morph=form). So, in Python, the “+” sign is polymorphic. You will see about numbers in the Numbers article.

greeting_3
The “%s” stands for “string”. If the name variable was an integer, for
instance, then “%i” should be used instead of “%s”.

greeting_4
The format method was used here (you’ll learn more about this in the Classes article), and the contents inside the curly brackets “{}” were replaced by the name and animal variables, respectively.

Replicating strings

An interesting use case for strings is being able to replicate it multiple times by using the * operator, the same one used for multiplying numbers.

branch = "Buffalo" 
many_times = branch * 3
print(many_times) # => "BuffaloBuffaloBuffalo"

Escape sequences

These are special characters that can be used in strings to provide some additional features. They are denoted by a backslash " \ ", followed by the character:

Character	Meaning
\n	Newline character
\t	Tab character
‘	Single quote
“	Double quote
\b	Backspace character
\r	Carriage return character

Examples:

print("This is a\ttabbed string.")
print("This is a\nstring with a new line.")
print("This is a string with a backslash: \\")
print('This is a string with a single quote: \'')
print("This is a string with a double quote: \"")

Output seen in the command-line:

This is a       tabbed string.
This is a
string with a new line.
This is a string with a backslash: \
This is a string with a single quote: '
This is a string with a double quote: "«

😎 Enjoying this series so far? Did you know you can get the whole content as a book, both as digital and paperback formats? Check it out below!

Raw strings

In certain situations, you may want to actually use these escaped characters demonstrated above. A common use case is for ﬁle paths on Windows computers, which include the backslash "\" character. This can be accomplished by appending "r" right before the beginning of a string:

jan_photo = r"C:\Users\Michael\princess_of_jamaica.jpg"
print(jan_photo) # => C:\Users\Michael\princess_of_jamaica.jpg

Slicing strings

You can get parts of a string by accessing their indexes. In Python, we start counting indexes/positions at 0, and negative indexes are counted backwards, from end to start. The concept of indexes and slicing will be covered in the Lists article.

name = "RYAN"

print(name[0]) # => R
print(name[1]) # => Y
print(name[2]) # => A
print(name[3]) # => N
print(name[-1]) # => N
print(name[1:3]) # => YA

Some string methods

Here are some usages of popular methods available for strings. Check them at https://docs.python.org/3/library/stdtypes.html#str.capitalize. The concept of "method" will be explained in the Classes article. For now, keep in mind they are a way of providing extra-capabilities to objects such as strings in this case. For example, turning a string into uppercase or lowercase.

name = "jim"

print("jim".upper())  # => JIM
print(name.capitalize())  # => Jim
print("JIM".lower()) # => jim

# how many times 'f' is repeated in 'Buffalo'
print("Buffalo".count("f"))  # => 2

Be aware that you are eligible get a Wise card or your first international transfer, up to 500 EUR, free! I've been using their service for years and it's a great way to send/receive money abroad, creating disposable virtual cards, and more. Get it here: Sponsored link.

By now you may have heard of ElevenLabs. Their AI voice cloning service is simply off the charts. Check them out: Sponsored link.

Follow me around:
LinkedIn Buy me a coffee GitHub Dev.to

DEV Community: Lourenço Costa

Python course: Loops

The for loop

Iterating over indexes in a collection

The while loop

Continue

Python course: Deconstructing

Python course: Conditionals

Ternary conditional

You rarely need “else”

Dict as an alternative to conditionals

Python course: Operators

Arithmetic operators

Assigning operators

Comparison operators

Operator is

Logical operators

Membership operators

Operator precedence

Bitwise operators

Python course: Boolean logic

Python course: Sets

Python course: Dictionaries

Dict comprehension

Python course: Tuples

Tuple comprehension

Accessing indexes in tuples

Tuples vs Lists

Python course: Lists

Accessing elements in a list

Validation if a list has elements

List comprehension

Some methods in lists

Python course: Functions

Functions in Mathematics

Functions in Python

Type hints

Parameter vs argument in functions

Functions with a dynamic number of parameters

With unnamed parameters (*args)

With named parameters (**kwargs)

Functions with default parameters

Functions as parameters

Documenting functions

Anonymous/lambda functions

Function chaining

Python course: Numbers

Int

Float

Complex

Python course: Strings

Replicating strings

Escape sequences

Raw strings

Slicing strings

Some string methods

The `for` loop

The `while` loop

Operator `is`