Please Master These 10 Python Functions…

Summary

このビデオでは、Pythonのプログラミングにおいて習得すべき重要な10の関数について解説します。基本的なprint関数から始まり、help関数、range関数、map関数、filter関数、sum関数、sorted関数、enumerate関数、zip関数、そしてファイル操作に使うopen関数まで、各関数の使い方とその応用例を詳しく説明します。また、各関数の追加引数や便利な使い方も紹介しています。このビデオを通じて、これらの関数をマスターすることで、Pythonプログラミングの効率が大幅に向上するでしょう。

Takeaways

• 📝 Pythonの基本的な関数として、`print`関数が紹介され、その引数`sep`と`end`を用いた高度なフォーマット方法が解説されています。
• 📚 `help`関数は、Pythonの関数のドキュメントを簡単に表示できる便利なツールとして紹介されています。
• 🔢 `range`関数は、数値の範囲を生成する際に非常に有用で、開始値、終了値、ステップ値を指定できます。
• 🗺️ `map`関数は、iterableオブジェクトの各要素に関数を適用し、新しいiterableを生成する機能を有しています。
• 🎭 `filter`関数は、iterableオブジェクトから特定の条件を満たす要素を選択的に抽出する際に使用されます。
• ➕ `sum`関数は、iterableオブジェクト内の数値を合計し、オプションで開始値を指定できます。
• 🔄 `sorted`関数は、iterableオブジェクトをソートし、`reverse`や`key`引数を用いてソートの挙動を変更できます。
• 🔑 `enumerate`関数は、forループでインデックスと要素値の両方を取得する際に便利です。
• 🔗 `zip`関数は、複数のiterableオブジェクトをタプルのリストに結合し、同時に複数のリストをループする際に非常に有用です。
• 📖 `open`関数は、ファイルを開いて読み書きする際に使用され、ファイルのモードやコンテキストマネージャーの重要性が強調されています。

Q & A

Pythonで最初に学ぶことは何ですか？

最初に学ぶのはprint関数です。基本的に画面にメッセージを表示するために使用されます。

print関数で使用できる追加の引数は何ですか？

print関数ではsep引数とend引数を使用できます。sep引数は区切り文字を指定し、end引数は行の終わりに追加する文字を指定します。

help関数の役割は何ですか？

help関数はPythonの関数のドキュメントを表示するために使用されます。ドキュメント文字列を読み取って、関数の使い方を教えてくれます。

range関数の基本的な使い方は何ですか？

range関数は数値の範囲を生成します。開始値、終了値、およびステップ値を指定できます。デフォルトでは0から指定した値までの数値を1ずつ増やして生成します。

map関数はどのように使用されますか？

map関数は指定した関数を反復可能オブジェクトの各要素に適用します。例えば、文字列リストの各文字列の長さを計算する場合に使用できます。

filter関数の使い方を説明してください。

filter関数は反復可能オブジェクトの各要素に指定した関数を適用し、関数がTrueを返す要素のみを保持します。例えば、長さが4以上の文字列のみをリストから抽出できます。

sum関数の用途は何ですか？

sum関数は反復可能オブジェクト内の数値の合計を計算します。開始値を指定することも可能です。

sorted関数の主要な引数は何ですか？

sorted関数の主要な引数にはreverseとkeyがあります。reverse引数は並べ替え順序を指定し、key引数は各要素に適用する関数を指定します。

enumerate関数の利点は何ですか？

enumerate関数は反復可能オブジェクトをループする際に、要素とそのインデックスを同時に取得できる利点があります。

zip関数はどのように機能しますか？

zip関数は複数の反復可能オブジェクトを組み合わせ、それらをタプルのリストとして返します。対応する要素を同時に処理する場合に便利です。

Outlines

00:00

📘 Pythonの基本的な10の関数の紹介

この段落では、Pythonで書かれるコードによく使われる10の関数が紹介されています。これらの関数は単純そうに見えるかもしれませんが、多くの追加のパラメータがあり、時間を節約するのに役立ちます。まず最初に紹介されたprint関数は、文字列や変数を表示するための基本的な関数ですが、Sep引数を用いてデリミタを変更したり、end引数を変更して行の最後に何を表示するかをカスタマイズすることができます。次に紹介されたhelp関数は、Python関数のドキュメントを簡単に取得できる便利な関数です。

05:00

🔢 range関数の使い方とmap関数の紹介

この段落では、range関数の使い方とmap関数の機能が説明されています。range関数はデフォルトでは1から始まり、指定された数値まで（ただしその数値は含まない）の範囲の数値を生成します。また、start、stop、stepの3つの引数を指定して、任意の範囲の数値を生成することができます。逆方向の数値の範囲も生成可能です。map関数は、iterableオブジェクトの各要素に指定された関数を適用し、結果をまとめて返します。組み合わせるlambda関数の使用例も紹介されています。

10:01

🌐 filter関式とsum関数の活用

filter関数は、iterableオブジェクトの各要素に対して関数を適用し、その関数がTrueを返す要素だけを結果として返します。この段落では、文字列のリストから長さが4を超える要素を選択する例が紹介されています。また、sum関数はiterableオブジェクトの数値を合計し、オプションで開始値を指定することができます。

15:02

🔄 sorted関式とenumerate関数の使い方

sorted関数はiterableオブジェクトをソートし、指定に応じて昇順または降順で並べ替えることができます。key引数を用いて、ソートの基準を指定することも可能です。enumerate関数は、forループでインデックスと値に同時にアクセスする際に便利で、タプルの形でインデックスと値を返します。

20:05

🔗 zip関式とopen関数の応用

zip関数は複数のiterableオブジェクトを組み合わせて、タプルのリストを作成します。これにより、複数のリストを簡単にループすることができます。open関数はファイルのオープンや書き込みに使用され、with文を用いることでファイルの自動クローズが保証されます。また、読み込みや追記モードについても説明されています。

📝 ファイルを扱う際のベストプラクティス

最後の段落では、ファイルを扱う際のベストプラクティスが紹介されています。with文を用いたファイル操作が推奨され、エラーが発生した場合でもファイルが適切にクローズされることが強調されています。また、読み込みモードや追記モードでのファイル操作の例も提供されています。

Keywords

💡print関数

print関数は、Pythonで標準出力にメッセージを表示するための基本的な関数です。動画では、複数の引数をカンマで区切って出力できること、そしてsepやend引数を使って出力の形式を変更できることが説明されています。例えば、sep引数を使うことで、出力の間にパイプやカンマを挿入することができます。

💡help関数

help関数は、Pythonの関数やモジュールのドキュメントを表示するために使用されます。この動画では、help関数を使うことで、関数の使い方や引数についての詳細な情報を簡単に得られることが強調されています。例えば、print関数に対してhelpを呼び出すと、print関数のドキュメントが表示されます。

💡range関数

range関数は、指定した範囲内の数値のシーケンスを生成するために使用されます。forループでよく使われ、開始値、終了値、ステップ値を指定することで、複数の異なるシーケンスを生成できます。例えば、range(2, 10, 2)は2から始まり、10未満まで2ずつ増加する数値のシーケンスを生成します。

💡map関数

map関数は、指定した関数をイテラブルオブジェクトの各要素に適用して、新しいイテラブルを生成します。動画では、文字列のリストに対してlen関数を適用して、各文字列の長さを得る例が紹介されています。カスタム関数やラムダ関数も使用できます。

💡filter関数

filter関数は、指定した関数の条件を満たす要素のみを抽出するために使用されます。動画では、文字列の長さが4より大きいものをフィルタリングする例が示されています。ラムダ関数を使用して、条件を簡潔に記述することもできます。

💡sum関数

sum関数は、イテラブルオブジェクト内の数値の合計を計算します。動画では、数値のセットに対してsum関数を適用し、合計値を求める例が紹介されています。また、開始値を指定することもでき、例えばsum([1, 2, 3], 10)とすると、10を開始値として合計を計算します。

💡sorted関数

sorted関数は、イテラブルオブジェクトを昇順または降順にソートします。動画では、数値のリストを昇順および降順にソートする方法、さらにキー関数を使用して辞書のリストを特定のキーに基づいてソートする方法が説明されています。

💡enumerate関数

enumerate関数は、イテラブルオブジェクトをループする際に、インデックスと要素の両方にアクセスできるようにします。動画では、タスクのリストをループして、各タスクにインデックス番号を付けて出力する例が示されています。

💡zip関数

zip関数は、複数のイテラブルオブジェクトを組み合わせ、それらの対応する要素をタプルとして返します。動画では、名前と年齢のリストを組み合わせて、それぞれの名前に対応する年齢を出力する方法が説明されています。また、異なる数の要素を持つリストを扱う際の柔軟性も紹介されています。

💡open関数

open関数は、ファイルを開いて読み書き操作を行うために使用されます。動画では、ファイルを開く方法、モード（'r', 'w', 'a'）の違い、そしてwith文を使用してファイルを安全に操作する方法が説明されています。特に、with文を使うことで、ファイルを手動で閉じる必要がないことが強調されています。

Highlights

Pythonコードを書く際に重要な10の関数を学ぶことが重要です。

最初の関数はprint関数で、複数の引数を渡すことで動作を変更できます。

sep引数を使って出力の区切り文字を変更できます。

end引数を使って行の末尾に追加される文字を変更できます。

help関数を使って関数のドキュメントを取得できます。

range関数は数値の範囲を生成するのに使用され、forループで頻繁に使用されます。

range関数は開始、終了、ステップ値を指定できます。

map関数はイテラブルの各要素に関数を適用します。

lambda関数を使って一行の匿名関数を定義できます。

filter関数は条件に合致する要素のみを返します。

sum関数は数値の合計を返します。

sorted関数はイテラブルを昇順または降順にソートします。

enumerate関数はイテラブルをループする際にインデックスと値の両方にアクセスできます。

zip関数は複数のイテラブルを一緒に結合します。

open関数はファイルの読み書きに使用され、with文を使うと自動的にファイルを閉じます。

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.