AHDHFJAICJHRBE GOOD GOD FUCK IVE BEEN LOOKING FOR A BASE PYTHON, NON-ARRAY WAY TO MAKE CUSTOM EVER CHANGING VARIABLE NAMES GOOD GOD THANK YOU FOR CALLING ATTENTION TO THIS

Iterators are also used in built-in functions such as map, any and all: def infinite_gen(): for i in range(19): yield True yield False while True: yield True g = infinite_gen() all(g) # all(g) The above is not an infinite loop! However, if you uncomment the last line, it will become one, since the False will have passed.

site rip off😂

V_I_S_I_T #######solvemyprogrammingtask #########################################V_I_S_I_T #######solvemyprogrammingtask #########################################V_I_S_I_T #######solvemyprogrammingtask #########################################V_I_S_I_T #######solvemyprogrammingtask #########################################

@@Enter54623 Dude, I never knew you could use "yield from" instead of an explicit for loop. Amazing! Thank you!

Pandas is not part of Python, though.

Idk about pandas but i wana see some educational shorts,not those fking double it and give to kinda things

@@mrdcool Um what does a random trend have to do with b001's content...?

@@erikkonstas i want to see his content more in general

@@mrdcool just look for other channels and subscribe if they have shorts. algorithm will do its job eventually

def fetch_lines(filename): with open(filename, 'r') as file: return file.readlines() print(*fetch_lines("filename"), end='')

Yes, but here we want to demonstrate generators.

@@erikkonstas That is a very important feature of generators though, the fact you can iterate through like that. Calling next() for an arbitrary amount of times isnt very useful

@@erikkonstasI think you missed the fact that "zen" here is a generator.

@@LethalLuggage I think what I wanted to say was that that fact was obscured by the loop.

@@erikkonstas fair. I definitely felt it was missing from the video though. Like the person above me said there's very rarely a "call the next thing several times" (unless you're doing number generation) but more commonly a need to iterate over the entire item ala for loop

Yes it does. I wanted to have the for-loop in both the regular function and the generator function so it's easier to see what changes between them.

@@b001 oh..

If you really need to deal with so-called "infinite lists", you're better off with a language with lazy evaluation like Haskell.

SynthWave’84

SynthWave’84

@@b001 Thanks a lot. Love your videos 👍👍

> won’t this hold the file open until all the lines have been read anyway Yes, the file will be open, but having an open file don't cost a lot of memory. An open file, from your OS's perspective, is just a path associated with the position of a kind of cursor that tells where you are. The OS doesn't eagerly load the entire file at once in memory, it's your job to ask it to read data. > what if the client code using the fetch_lines() function quits The next function raises a "StopIteration" exception when called on a generator that is depleted (you can also give it a second argument, in which case it will be returned instead). If the generator raises an exception on its own, calling "next" will raise it too > or hangs The "next" function will simply block until the generator unblocks itself.

You are correct. Also, he could just call file.readlines() to obtain list of lines right away but for educational purposes it's better to iterate line by line.

The point is to demonstrate generators.

his theme is SynthWave '84

To answer your first question: The file is only opened once before the loop is started. The `open` function returns a `File` instance that only needs to be initialised once before you begin iterating. As for your second question: You don't have to close the file again provided you've used the `with` statement, as this does all the cleanup for you. If you simply used `open(filename)` without the `with` statement, you would need to explicitly close the file again, yes.

It doesn't anyway. The operating system is smart enough not to load everything from the beginning. Imagine having four large files of 1GB each, that would have meant you would lose 4GB of RAM on nothing. In fact, files are nothing but a disk entry. When you are calling open (see the open syscall from C), you are getting a pointer to a file structure which also contains a cursor (the current position in in a file). Files are also mapped in memory using the mmap system call, which reserve memory, but don't allocate it initially. You could take a look at demand paging for instance to see the connection with your curiosity. So, as a conclusion, the video is a little misleading, because the operating system deals with optimizing your memory access anyway. The real deal with this generators is when you really don't want to store more than a string with one line at a time. Then would be a problem, because you would have an array of lines, which is terrible if you don't use most of them.

@@idanyel1587 so if I have a function that had a loop where each loop yields something, would the generator store the full result or calculate on demand as next is called?

@@abcdef-fo1tf Generators don't do things while they're suspended; they only resume when you call next or send with them.

​@@abcdef-fo1tf, on demand as I said. When yield is used, that portion of the code is suspended and when you want to use it again the old state is restored and it will continue from there.

Nope; that's the whole reason of using the context manager there, it closes it automatically.

Not sure what you'd have in mind here, but you'd need to manually retain the last result from your generator, which can be done using for-else: last = -1 for n in range(10): pass else: last = n print(last) # 9 If you're wondering where the yield keyword is, the built-in range class offers generator behavior that is pretty much powered by a loop like this: while start < stop: yield start start += step

Synthwave84

Opens a stream to the specified file, depending on the second argument it's either an input or an output stream

SynthWave '84

You can just keep going next until you reach the end of file which raises StopIteration

@@sollertia_ OK, so include a 'try' with an exception check to determine the end of the file? Or a 'while false' loop with the exception check?

@@FreihEitner u can iterate over a generator with a for loop (for line in fetch_lines) and let python do the rest. My point is that you don't really need to know how many values a generator can generate since it will raise StopIteration to notify your try catch or for loop to stop iterating

I wonder if this will work : temp = next(zen) while temp : print(temp) temp = next(zen)

for x in stuff: print(x) I believe that's how yield is supposed to be used

In few words the work of "yield" is to create a function that return a iterator, a iterator is that you can use with either next() and a for-loop, that iterator synchronizes with the next() or with the for-loop, in other words, each time that the function reach "yield", it send the value that you put and then stop temporaly the function in that point, that value you'll receive in either next() or the for-loop, when the for-loop reiterate, or when the next() is called again, the function execution is restored, and then the process is repeated until the function finish, this is the real usage of "yield", a function that has "yield" inside is named "generator function", the iterator is "generator", this is a powerful feature of python since you can make a function to produce only the necessary things and then stop the execution by not iterating again, for for-loops we can use "break", and for next() we simply don't call again, there also exists "yield from" that for example is: def generator(): yield from iterable that is equivalent to: def generator(): for value in iterable: yield value putting "yield" alone is the same as "yield None" that is all you need to know about "yield"

@@gabi_kun3455 Super useful! Thank you

Personally, I wouldn't want to read millions of lines of text with python.

Please do not propagate this mindset; every language has its benefits and drawbacks, and hence its purposes. Saying one is superior to another as an absolute is very disliked upon among software devs, since it indicates a diehard mentality.