Please Master These 10 Python Functions…

Summary

This script offers an in-depth exploration of ten essential Python functions that every programmer should master. Starting with the versatile 'print' function, it covers its advanced parameters like 'Sep' and 'end'. The script then introduces the 'help' function for quick access to documentation, followed by 'range', 'map', 'filter', 'sum', 'sorted', 'enumerate', 'zip', and the file handling 'open' function. Each function is explained with examples and use cases, emphasizing their efficiency and utility in coding, concluding with best practices for file operations using context managers.

Takeaways

• 📝 The `print` function in Python is versatile, allowing for customization of separators and end characters to control the output format.
• 🔍 The `help` function serves as an in-built documentation tool, providing quick access to a function's docstrings without needing to search online.
• 🔢 The `range` function is essential for generating sequences of numbers with customizable start, stop, and step values, and can be converted to a list for direct usage.
• 🗺️ The `map` function applies a given function to every item in an iterable, streamlining the process of performing operations across collections.
• 📝 The `filter` function selectively filters items in an iterable based on a provided function that returns a boolean value, deciding whether to include each item.
• 🌐 The `sum` function quickly calculates the total of numbers in an iterable, with the option to set a custom starting value for the summation.
• 🔄 The `sorted` function sorts iterables in ascending or descending order, with the ability to define custom sort keys through a function.
• 🔑 The `enumerate` function pairs each item in an iterable with its index, simplifying loops that require both index and value access.
• 🔗 The `zip` function combines multiple iterables into a single iterable of tuples, efficiently merging corresponding elements from each iterable.
• 📖 The `open` function is crucial for file operations, offering different modes for reading, writing, and appending, with the emphasis on using context managers for proper resource management.

Q & A

What is the primary purpose of the 'print' function in Python?

The 'print' function in Python is used to display output to the console or terminal. It can handle a mix of strings and variables, and allows for customization of the separator and end parameters to control the format of the output.

How can the 'print' function's default behavior of separating arguments with a space be changed?

The default behavior of the 'print' function can be changed by passing a different value to the 'sep' argument. For example, setting 'sep' to a pipe character '|' will replace the space with a pipe between arguments.

What does the 'end' argument in the 'print' function do?

The 'end' argument in the 'print' function determines what is printed at the end of the line. By default, it adds a newline character (' '), but it can be changed to any string, allowing for printing on the same line consecutively.

What is the 'help' function in Python and how is it used?

The 'help' function in Python is used to display the documentation of a given function or module. It reads the docstrings to provide information on usage and parameters, which is useful for quickly accessing documentation without needing to search online.

Can the 'help' function be used with user-defined functions?

Yes, the 'help' function can be used with user-defined functions as well. It prints the docstring associated with the function, which should be provided when the function is defined to describe its purpose and usage.

What is the 'range' function in Python and how does it work?

The 'range' function in Python generates a sequence of numbers. It can take one, two, or three arguments for start, stop, and step values, respectively. By default, it starts at 0 and steps by 1, going up to but not including the stop value.

How can the 'map' function be used to apply a function to every item in an iterable?

The 'map' function takes a function and an iterable as arguments, then applies the function to each item in the iterable. The results are returned as a map object, which can be converted to a list to view all the results at once.

What is the purpose of the 'filter' function in Python?

The 'filter' function is used to filter items in an iterable based on a given function. If the function returns True for an item, it is included in the result; otherwise, it is excluded.

What does the 'sum' function do and can it accept a starting value?

The 'sum' function calculates the total sum of all numeric items in an iterable. It can accept an optional 'start' parameter, which allows the summation to begin from a value other than zero.

How does the 'sorted' function work and what arguments can be used to modify its behavior?

The 'sorted' function sorts an iterable in ascending order by default. It can be modified by passing the 'reverse' argument set to True for descending order, or by using the 'key' argument with a function to determine the sorting criteria.

What is the 'enumerate' function used for and how does it simplify loops?

The 'enumerate' function is used to iterate over an iterable while having access to both the index and the value of each item. It simplifies loops by returning a tuple containing the index and value for each iteration, eliminating the need for manual index tracking.

Can the 'zip' function be used to combine multiple lists and how does it handle lists of different lengths?

Yes, the 'zip' function combines multiple iterables into a single iterable of tuples. It stops at the shortest iterable, thus handling lists of different lengths by not causing an index out of bounds exception.

What is the 'open' function used for and what are the common modes for file operations?

The 'open' function is used to open a file for various operations like reading, writing, and appending. The common modes are 'r' for reading, 'w' for writing (which truncates the file), and 'a' for appending to the end of the file.

Why is it recommended to use a context manager with the 'open' function?

Using a context manager with the 'open' function ensures that the file is properly closed after its operations are completed, even if an error occurs during the file manipulation process. It prevents memory leaks and ensures the file is not left open unintentionally.

Outlines

00:00

📘 Mastering Essential Python Functions

This paragraph introduces ten fundamental Python functions that are crucial for Python programmers to master due to their time-saving capabilities. The print function is highlighted as the first function, which is often the initial exposure for beginners. The paragraph explains the basic use of print, such as outputting strings and variables, and then delves into advanced features like the Sep and end arguments that modify the print behavior. It also touches on the help function, which is used to access the documentation of any Python function without needing to search online, and the range function, which is essential for generating sequences of numbers in loops or as lists. The importance of understanding these functions is emphasized for efficient Python programming.

05:00

🔢 Exploring Python's Range and Map Functions

The second paragraph continues the discussion on Python functions, focusing on the range function's ability to generate sequences of numbers with different start, stop, and step values. It demonstrates how to create ascending and descending sequences and how to convert a range object to a list for direct usage. The map function is introduced as a tool for applying a function to every item in an iterable, such as strings, lists, or tuples. Examples are given to show how map can simplify the process of applying functions like length to a list of strings or using lambda functions for custom operations on iterables.

10:01

📝 Understanding Python's Filter, Sum, and Sorted Functions

This paragraph delves into the filter function, which retains items in an iterable based on a condition set by a function. The sum function is then explained as a tool for calculating the total of numbers in an iterable, with the option to set a starting value for the sum. The sorted function is introduced for arranging items in an iterable in ascending or descending order, with additional arguments like reverse and key for custom sorting criteria. Practical examples are provided to illustrate the use of these functions in processing and manipulating data.

15:02

🔄 The Power of Enumerate and Zip Functions in Python

The fourth paragraph discusses the enumerate function, which simplifies the process of looping through an iterable with access to both the index and the value. It contrasts the traditional method of using range and index with the more concise enumerate approach. The zip function is then introduced as a powerful tool for combining multiple iterables into a single iterable of tuples, which is particularly useful when dealing with corresponding values in different lists. The paragraph demonstrates how zip can handle iterables of varying lengths and emphasizes its utility in cleaning up code and improving readability.

20:05

📖 Working with Files using Python's Open Function

The final paragraph of the script discusses the open function for file operations in Python. It explains how to open a file in different modes, such as read ('r'), write ('w'), and append ('a'), with a focus on the write mode that overrides existing files. The paragraph demonstrates writing to a file, the importance of closing the file to prevent memory leaks, and the best practice of using a context manager (the 'with' statement) to ensure files are properly closed after operations. It also touches on reading from files and appending content without overwriting existing data.

Keywords

💡print function

The 'print function' is a fundamental aspect of Python programming, used to display output to the console. It is introduced as the first function in the script, showcasing its simplicity yet powerful customization through arguments like 'sep' and 'end', which can alter the default behavior of separating printed items with a space and appending a newline character, respectively. For example, the script demonstrates changing the separator to a pipe symbol and the terminator to a space, which helps in formatting the output in a specific way.

💡help function

The 'help function' in Python serves as an interactive tool to access documentation for built-in functions, libraries, or user-defined functions without needing to search the internet. It reads and displays the docstrings, which are strings that describe what the function does, its parameters, and return values. The script illustrates using the help function with the 'print' function itself, as well as with a custom function called 'test_func', to show how it can be used to quickly access and understand the functionality of any function.

💡range function

The 'range function' is a versatile tool in Python for generating a sequence of numbers. It can be used with one, two, or three arguments to specify the start, stop, and step values, respectively. In the script, the range function is explained through various examples, such as generating a sequence from 0 to 9, starting from 2 up to but not including 10, and even creating a negative sequence by using a negative step value. It is also noted that 'range' returns an iterator, which must be converted to a list if a complete list of values is desired.

💡map function

The 'map function' applies a given function to each item of an iterable (like a list, tuple, or string) and returns a map object, which is an iterator. In the script, the map function is demonstrated by applying the 'len' function to a list of strings to get their lengths, and also by using a lambda function to append an 's' to each string in a list. This function is highlighted for its utility in performing operations on iterables in a concise and efficient manner.

💡filter function

The 'filter function' allows for the conditional extraction of elements from an iterable. It takes a function and an iterable, and returns an iterator consisting of those elements for which the function returns True. In the script, a custom function 'longer_than_four' is used to filter strings longer than four characters. The filter function is also shown being used with a lambda function to achieve the same result, demonstrating its use for both simple and complex filtering criteria.

💡sum function

The 'sum function' is used to return the total sum of all numeric values in an iterable. The script mentions that it can take an optional 'start' parameter, which allows the summation to begin from a value other than zero. For instance, adding '10' as the start value results in the initial sum being '10', and then adding the values from the iterable to it. This function is essential for quickly aggregating numerical data.

💡sorted function

The 'sorted function' takes an iterable and returns a new sorted list from the elements of the iterable. It can be customized to sort in ascending or descending order using the 'reverse' parameter, and to sort based on a specific function of the elements with the 'key' parameter. In the script, sorting a list of dictionaries by age using a lambda function as the key is demonstrated, showing how to control the sorting behavior for complex data structures.

💡enumerate function

The 'enumerate function' is used to add a counter to an iterable and return it in a form of an index sequence. It is commonly used in for loops when you need access to both the element and its index. The script explains that using 'enumerate' simplifies the process of looping over a list with access to indexes, as it returns a tuple containing the index and the value, eliminating the need for manual index handling.

💡zip function

The 'zip function' takes multiple iterables and aggregates them into a single iterable of tuples, where each tuple contains the i-th element from each of the input iterables. In the script, 'zip' is used to combine two lists, 'names' and 'ages', into a list of tuples, simplifying the process of iterating over paired data. It is also shown that 'zip' can handle multiple iterables and will stop at the shortest iterable's length, which is useful for aligning data from different sources.

💡open function

The 'open function' is used to open a file and is fundamental when working with file input/output operations in Python. It requires a file name and a mode, such as 'r' for reading, 'w' for writing (which truncates the file), and 'a' for appending. The script emphasizes the importance of closing files after operations to avoid memory leaks and recommends using the 'with' statement as a context manager for automatically handling file closing. It also demonstrates writing to and reading from files using 'open'.

Highlights

The print function in Python can be customized with additional arguments such as 'sep' to change delimiters.

The 'end' argument in the print function can be modified to avoid adding a newline character after printing.

The help function provides quick access to the documentation of any Python function, including custom ones.

The range function can generate sequences of numbers with customizable start, stop, and step values.

The map function applies a given function to every item in an iterable, simplifying operations on lists.

Lambda functions can be used with map for quick, one-liner function applications.

The filter function allows for conditional filtering of items in an iterable based on a provided function.

The sum function can calculate the total of numbers in an iterable and can take a starting value for the sum.

The sorted function can sort any iterable, with options to reverse the order and use a key function for custom sorting.

The enumerate function simplifies loops that require access to both the index and the value of iterable items.

The zip function pairs elements from multiple iterables into tuples, streamlining the process of merging related data.

The open function is essential for file operations in Python, with different modes for reading, writing, and appending.

Using the 'with' statement for file operations ensures proper closure and error handling.

The video provides practical examples of how to use Python's built-in functions to enhance coding efficiency.

Understanding and mastering these functions can significantly save time and improve the quality of Python code.

The video emphasizes the importance of exploring additional parameters of seemingly simple functions to unlock their full potential.

Transcripts

If you write any code in Python, then you'll see these ten Python functions

a ton and it's important you master them.

Some of them may seem simple, but they have a lot of additional parameters

that you need to understand as they can save you a ton of time.

So with that said, let's dive in and look at function number one.

So the first function we'll look at here is the print function.

Now this is probably the first thing you learn when you learn Python.

And it seems super basic.

We can print out a few different things.

We can separate them by commas.

And you can see that we can print a mix of strings and variables.

And when we do that, they'll get printed out separated by a space.

But what you probably didn't know is that we can pass additional arguments

to the print function that modify how it works.

For example, I can pass the Sep argument here.

So Sep is equal to and I'll go with something like a pipe.

And now what will happen is rather than using a space

as the delimiter or what goes in between, the different arguments

we pass to the print function will use this pipe.

So when I run the code now you see we get.

My name is and then pipe Tim pipe and I am pipe 23 pipe years old.

So we can override that default behavior, which is to use a space to separate

all the different things we're printing.

And in this case, we use a pipe.

Now maybe instead we want to use a comma.

So let's go back here and change that to a comma and print this out.

And now you can see that we're printing things with a comma.

This is quite useful especially when you want

to print out things that have a certain formatting.

And you don't want to do the manual formatting yourself.

Now another thing we should know about the print

function is how we change what gets printed at the end of the line.

So you may not know this,

but by default when you print something with this function, it's

going to actually add a backslash n which is a new line

character which will force the terminal to go to the next line.

So when you print something else, it won't be on the same line.

Now typically this is what you want.

And that means when I run the code here you'll see

we get these two print statements on separate lines.

But sometimes you actually want to print things on the same line.

So how do you do that.

Well what we can actually do is we can override this end argument here,

and we can pass this something different than the new line character.

So I could pass a and is equal to a pipe and maybe put some spaces around it.

And if we clear here and run you'll see.

Now we get hello world.

And at the end of this print statement it prints the pipe with the spaces.

And then when we go to print the next line, it will happen on the same line here

because we didn't move down to the next line.

So now we're going to dive into the second function here which is the help function.

But first I need to share with you something that's going to be very helpful.

And that is the sponsor of this video.

Today's video is sponsored by Male Trap,

an email delivery platform that developers love.

Now, what's cool about Male Trap?

It's actionable analytics, the best in the industry

with full statistics and drill down reports on each and every email you send.

Male trap

offers separate streams for transactional and bulk emails,

SMTp and API integrations,

plus SDK for major programing languages.

At Male Trap, human support is available round the clock for all customers.

Try today at Male trap.io.

So hopefully you appreciated that segue there.

But now let's have a look at the help function.

Now the help function allows us to print out the documentation of a Python function.

So we don't need to go to the internet to look it up.

And we can really quickly get access to how a function works.

Now what this will do is read the docstrings of a function

and simply give it to us.

So what I can do is something like help

and then I can pass to this maybe the print function.

And notice I'm not calling the print function, I'm just writing the name of it.

And now when I run the code,

you'll see that I actually print out all of the documentation for the print function.

This is what's contained in the docstring for it.

So you can see it says print kind of shows you an example of how it works.

And then it gives you a description

of the different arguments or the parameters for this function.

Now this also works for your own functions.

So let me show you that.

So you can see here I've written a custom function called test func

and I've just written a docstring for it just as an example.

So we can see how this works.

Now when I run my code here, notice it will actually give me

the documentation of this function.

So it says a b and then the return type.

Again it's really just printing it with the docstring is that's written here.

So this is useful for built in functions.

But also when you're working with a library or code written by other people.

So you don't need to search through and find the actual function definition.

You can just use this help function.

It will print it out for you.

So the next function on my list is a very common one.

And you've probably seen this, especially if you're working with a for loop.

And that is range.

Now as much as range can be used to iterate through values in a for loop.

We can also use it just to generate a list of numbers.

And I'll quickly walk through how it works because it is a very important function.

So what range will do is generate a range of numbers starting at some value,

stopping at some value, and stepping by some value.

Now, by default, when you only pass

one value here to the range function, this acts as the stop.

That means it's going to go up to but not include this number.

And it's going to start at one and step by one, which means go up by one each time.

So if I run the code here,

you can see that this gives us the values zero through nine again

because we go to the stopping point, but we do not include it.

Now if I have a second value here, something like two and then ten,

this will act as the start value and this will act as the stop value.

And now when I run this, you see that we will simply start at two.

And we will go up to ten but not include it.

If I decide to add a third value here, something like two,

this will act as the step value

and this will be the increment that we will go up by each time.

So if I run this here we get 246, eight.

Now this is quite useful.

And we can do this

in many different kind of ways to generate a lot of different sequences of numbers.

For example,

I can change this to a negative two and I can swap these values around and go

maybe ten.

And maybe we're actually going to go to something like negative ten.

And now this will give us a negative range where we start at ten.

And we subtract two each time until we hit the stopping value of negative ten,

which we do not include.

Very useful for for loops.

But also if you convert this range into a list,

then you can simply use it as a list of values.

One thing to note if you print out range itself, which we can do here,

you'll see that we actually get a range object.

That's because range returns to a something known as an iterator.

An iterator is something that we step through using kind of a specific process

that I don't need to get into in this video.

The point is,

if you want to actually

get an entire list of values, you do need to manually convert this to a list.

Okay, so to do that, we just write the list function around range.

And then as you saw before, it gives us a list of values

rather than this range object which again is an iterator.

Now the next function we're looking at is the map function.

Now a map function

allows us to apply a function to every single item in an iterable object.

An iterable object is anything that you can loop through.

So something like a string, a list, a tuple, something like a set.

It works for all of those.

So let's have a look at a quick example.

So let's say that

what we want to do is

we want to get the length of all of the different strings in this list.

Well we could iterate through every single one of these strings, manually

apply the length function, and then just print it out or store in a new list.

But instead we can actually use the map function that does all of this for us.

So I can say the length is equal to and then I can use my map function.

And the first thing I pass to the map function is the function that I want

to apply to all of the different items in my iterable.

So in this case, I pass the Len function.

We can pass our own function or in this case a built in one in Python.

And then I pass the iterable that I want to apply this to which is strings.

Now what I can do is I can print out and I need to convert this to a list

because again this is going to return an iterator.

So it's going to return a map object.

If we want to see all of the results then we need to first convert it to a list.

And now if I run my code you see that it gives me the length

of all of these different items.

So it simply took this function, applied it to every single item

that was in this list, and then gave me that result inside of,

in this case, a new list or really a new iterable that we converted to a list.

Now in this case we used a built in function in Python,

but we can also use a custom function that we write ourself.

Now it's common here to use what's known as a lambda function.

A lambda function is a one line anonymous function

where you can do something like lambda.

You can pass a parameter. In this case it will be x.

And then if we want we could do something like x plus s.

Now what this is going to do is, is going to pass

every single one of the strings to this function as the parameter x.

And we're simply going to add an s to all of these different strings.

So now what I'm going to do is write run this code.

Sorry.

And you can see we get an S tacked on to every single one of these strings.

Now if you don't want to use a lambda function you can define your own functions.

So we can say add underscore s.

We can take in our string okay.

And then we can say something like return and then string plus s.

And now we can just put the name of this function.

Notice I'm not calling it I'm just putting it as the name.

And then when I run this you can see that we get the exact same result.

So that is map.

It is extremely useful. Again you pass the function.

You pass the iterable object.

And then it will apply this function

to every single item and give you all of the results.

So now we're moving on to the next function which is the filter function

which is closely related to the map function.

The way the filter function will work

is it will take every single item in our iterable object.

It will pass it to some function.

In this case it's called the filter function.

And if that function returns true,

it will keep that item, otherwise it will remove it from the result.

So let me show you an example.

We'll just say filter is equal to.

And then we're going to use filter.

Same thing. We're going to pass our function.

In this case I'm going to pass this custom function I wrote called longer than four

which just returns true if the length of a string is greater than four.

And then I am going to pass by iterable which is strings,

and we are going to print out the list

of our filtered okay.

So let's spell that correctly.

And let's run our code.

And notice that we only get World and Apple.

The reason for

that is what really happens here is we take every single one of our items.

So we start with mine. We pass it to this function.

This function returns false because my is not a length greater than four.

We pass world.

We return true because this is length five.

Same thing with Apple like five pairs length four.

So it's not greater than length four. So we don't include it.

So we end up with world and Apple.

Obviously this is a very simple function.

We can write very complex functions.

And this allows us to filter in iterable

object based on some function which can be very very useful.

Mess around with this.

And also remember that you can use the lambda function as well.

So we could have written it like this lambda x.

And then we could say Len x is greater than four.

And to prove that to you if we type this correctly

and we run the code, you see that we get the exact same result.

So the next function to look at here is a simple one.

And this is the sum function.

The sum function is simply going to return the sum of all of the different numbers

that you pass it from some kind of iterable object.

In this case, we're passing an iterable, which is a set.

We could pass a list.

We could pass a tuple.

Doesn't matter so long as the values inside of the iterable are numbers

if they are not numeric, so not an int or a float,

then you are going to get some kind of error so quickly.

We can run the code here, and you can see that we get the sum of 35.5.

Now one thing you might not know about the sum function

is that you can actually pass to this a start value.

So we can pass a start of say ten.

And now we will start summing at ten.

So now you'll see we get 45.5.

Now of course we can make this a negative value as well.

So let's go ahead and do that.

And you can see that this works perfectly fine.

Now the next function on my list is the sorted function.

Now this is pretty straightforward.

This is going to sort and iterable object in ascending

or descending order depending on what we tell it.

Now in this case we just have a bunch of different numbers.

By default it's going to sort this in ascending order.

So if I run the code here, you can see that we get these numbers sorted in

ascending order.

Now there are a few different arguments

that I can pass to this sorted function to change its behavior.

For example, I can pass reverse.

If we spell this correctly equal to true.

And then when I run my code here, you can see that

we actually get all of the values in reverse order.

But another more interesting argument we can pass here is a key.

Now the key will actually be a Python function.

And we will apply this Python function to every single item inside of our iterable.

And we will sort the items based on what's returned from the key function.

Now I'm going to show you a better example of this.

So stay with me for one second.

Okay, so I just created a better example here so you can see how this works.

So I have a list of people.

And notice

that if I try to sort this list of people we just have Python dictionaries here.

And the sorted function isn't really going to know how to sort this.

It will do some kind of sort for us, but it's going to be pretty unpredictable.

So instead what we do is we pass this a key.

Now this key is a lambda function.

We take in one argument.

In this case it is person.

And in this case we get access to the person's age.

So what we're doing

effectively here is we're sorting these people based on their age.

So now when I run the code here and we print this out, you can see that

we get all of the people sorted in ascending order based on their age,

because we're sorting all of the different items using this key.

Now, if we wanted to go a step further, we could reverse this as well.

And now we could sort this in ascending or descending order.

And you can see we can start with the oldest person and go to the youngest.

Moving on the next function to show you is enumerate.

But in order to see the value of enumerate, we first have to look at what happens

when we don't use it.

So oftentimes when we're iterating with a for loop, we want to have access to both

the index and the value when we're looping through something like a list.

In this case you see that I create a simple for loop.

I say for index in range, and then the length of tasks.

And then I use that index to access the task that's at that specific position.

I then print out index plus one and then the task.

And this gives us kind of a nice list.

So if we run the code here

you can see that we get a list of all of our various tasks.

Now this is fine. There's nothing wrong with this code.

We can clean it up quite a bit by using the enumerate function.

And this is helpful again

when you want the index and the value iterating through some kind of iterable.

So what I'm going to do is change this here to use enumerate.

And I'm going to enumerate over tasks.

Now when I do that the first value that I'm going to have access access to here

sorry is the index.

And the next value will be the task.

So what enumerate will really do is it will return to me a tuple,

a tuple for every single object where the first object inside of

that tuple is the index and the second object is the value.

So now what I can do is I can clear this and I can run.

And you see we get the exact same thing.

So again first variable is going to be the index.

Second value is going to be whatever the value actually is.

And we can use that for enumerate.

Now it's also worth noting that we don't need to use enumerate just in a for loop.

If we print out, for example, the list representation of enumerate,

you will see what we get.

And it is a tuple where we have the index first and then the value,

index value, index value, etc..

So moving on.

The next function on my list is the zip function.

But in order to understand the value of using the zip function,

we first have to see what it looks like when we don't use it.

So in this case you can see we have two lists, right?

We have names and we have ages.

Now these have corresponding values.

So the name at position zero corresponds to the age at position zero.

In the other list.

So what I'm doing here is I'm looping through

both of these lists at the same time.

And then I'm printing out. Name is age years old.

I'm essentially

combining these two values together and using them in some kind of expression.

Now notice that what I had to do here with my range is I had to get

the minimum length of the names and the ages list.

The reason why I had to look for the minimum

is because if we have an extra age or an extra name,

then we'll get an index out of bounds exception

when we try to access the corresponding position in the other list.

For example,

if we add another name like Tim here, and we don't have a corresponding age

when we look for the age at that index, if we were just looping

through the length of names, then we're going to get an error.

So I have to look at the minimum.

Okay.

So when I run this code you can see that we get all of the different

kind of printed out statements here.

Alice is 30, Bob is 25, etc..

And this is fine.

Again, nothing wrong with this code, but let me show you how much easier

it is for us to actually execute this using the zip function.

So I'm going to paste this in here.

And you can see that now we're using the zip function.

Now what the zip function will do

is combine different iterable objects together and automatically handle

when one iterable object has more objects than the other.

So in this case, what's going to happen is is going to combine our names

and ages into actually a list of tuples.

And then this allows us to loop through them really easily.

So let me just run this. You can see how it works.

And then we can break it down more in depth.

So first let's print out what the zip actually looks like.

So I'm going to say print combined.

And you can see when I do that we actually get a bunch of different tuples right.

So we get the name.

Then we get the age name age name age.

And notice it didn't include ten because we didn't have a corresponding age.

Now if we wanted to go a step further, we could actually include another list.

So we could have maybe a gender.

And we have female male and then male.

And now notice if I add my gender in here,

and then we add gender here and we go

and is gender when we print this out, you'll see that

we're only going to get three lines this time.

And that's because the minimum length of all of the different lists

we had was three.

So it can combined as many different intervals as we want

and automatically handle when we have a mismatch number of them.

So again we get Alice, 30 female Bob 25 male Charlie 35 male.

And then we can print all of this out.

ZIP is super, super useful.

I use it all the time, and I'd highly recommend

you use it in your code as well, especially

when you have corresponding values in multiple different iterable objects.

So now we move on to the final function on my list, which is open.

Now open can be used to open a file read to it right from.

It has a lot of different usage.

And let me explain to you how to properly use it.

So first let's create a variable called file.

And we'll use the open function.

And the first argument we pass to open is the file name we want to open.

So I'm going to go with test dot.

Now the second option is going to be the file mode.

There's a lot of other options as well as you can see here.

And there is a lot of different modes.

Now the most common modes

that you're going to need to know about are going to be R, which stands for read,

which stands for right, and then A, which stands for a pet.

Again, there's a lot of other options,

but these are the three main ones you want to know.

Now for now we're going to go with W because we want to create a new file.

And when you use W mode this is going to override a file

if it already exists and essentially clear everything that's inside of it.

So make sure you're careful when you use this.

So now we've opened our file.

What we can do is write to it so we can say file dot right.

And when we write we can just write some string.

So something like hello World.

And if we want to move

to the next line in the file we need to make sure we use a back line

or a new line character.

Sorry and say hello world.

My name is Tim. Like that.

So now if I run my code, you'll see that a new file is created

and we have Flow World.

My name is Tim.

However, it's very important that after we create this file,

we write to it that we close it.

So we need to actually say file dot close just to make sure

that we don't have any memory leaks.

And we don't leave the file open in memory when we actually don't mean to do that.

Now, in this case, everything's fine if we don't actually close it,

but we just want to make sure that we do close closing,

if that's actually why, I'm going to recommend

that when you are working with files, rather than manually opening

and closing them like this, you use the syntax which is the following.

Now this is the with the syntax.

So you're going to say with open.

And then again we can go our test

dot txt put our mode as w and we can say as.

And then in this case of file.

And then we can say file dot right.

And whatever we want to right here.

Okay. That's great.

And now anything that's indented will happen inside of this context manager.

That's what this is referred to.

And as soon as we exit this or as soon as we finish our operations, it's

automatically going to handle closing the file for us.

So this is the best practice when it comes to working with files

rather than opening and closing them yourself.

You always use a context manager which will ensure that the file

is always closed properly, even if an error occurs

inside of the kind of lines where you're trying to manipulate the file.

So just make sure you do that.

Anyways, we have the mode, so we have

we have our

and if we use our mode this allows us to actually read the contents of the file.

So to do that we can say file dot read.

And if we read this we will get all of the text inside of here.

So we can say print and then text.

So let's print that out and you can see hello world.

My name is Tim gets printed.

And then if we want to we can also append to a file.

Now appending to a file is not going to override it.

It's simply going to add to the end.

So if you want to keep adding to the end of a file rather than replacing the contents

inside of it, then you use the append mode.

Now what we can do is say file,

dot, write and do additions like that.

And if we run the code here and we open this up,

you can see that we have the new addition getting added.

And we're just going to get added at the end of wherever the file was.

So in this case we didn't have a new line character.

So it just gets smushed to this line.

If you wanted it to be on a new line,

then you would need to add the new line character like that.

Now there are also combination modes.

So for example, you can do something like

mode right where you're reading and you're writing to the file.

You can have like a mode.

I think that's probably a mode. I'm not sure if that's actually a valid one.

Reading and appending and there are all kinds of other modes

that you can look up, and you can even ask ChatGPT to tell you it.

Just too many for me to cover in this video.

Anyways, with that

said, that is going to cover the ten Python functions that you need to master.

I hope you found this video helpful.

If you did, make sure to leave a like.

Subscribe to the channel and I will see you in the next one.