Added the generator concepts code files

sreekanthpogula · sreekanthpogula · commit 931d8487873c · 2023-03-29T13:00:38.000+05:30
diff --git a/generator_methods.py b/generator_methods.py
@@ -0,0 +1,28 @@
+# .send method 
+import asyncio
+
+
+def isPrime(n):
+    if n < 2 or n % 1 > 0:
+        return False
+    elif n == 2 or n == 3:
+        return True
+    for x in range(2, int(n**0.5) + 1):
+        if n  % x == 0 :
+            return False
+    return True
+
+def getPrimes():
+    value = 0 
+    while True:
+        if isPrime(value):
+            i = yield value
+            if i is not None:
+              value = i
+        value += 1
+
+prime_gen = getPrimes()
+print(next(prime_gen))
+print(prime_gen.send(1000))
+print(next(prime_gen))
+
diff --git a/infinite_sequence.py b/infinite_sequence.py
@@ -0,0 +1,26 @@
+a = range(5)
+print(list(a))
+
+
+def infinite_sequence():
+    num = 0 
+    while True:
+        yield num
+        num += 1
+    for i in infinite_sequence():
+        print(i, end=" ")
+gen = infinite_sequence()
+print(next(gen))
+print(next(gen))
+print(next(gen))
+print(next(gen))
+
+
+def multiple_yield():
+    value = "I'm here for the first time"
+    yield value
+    value = "My Second time here"
+    yield value
+
+multi_gen = multiple_yield()
+print(next(multi_gen))
diff --git a/lazy_evaluation.py b/lazy_evaluation.py
@@ -0,0 +1,18 @@
+# Lazy evaluation is a programming technique in which the evaluation of an expression is delayed until its value is actually needed. This can be useful for improving the performance of programs, especially when dealing with large data sets or complex computations.
+
+# In lazy evaluation, expressions are not evaluated immediately when they are created, but are instead stored in a data structure such as a thunk or a promise. When the value of the expression is eventually needed, the thunk or promise is "forced" to evaluate the expression and return its value. This can reduce the amount of unnecessary computation that is performed, because only the parts of the program that are actually used are evaluated.
+
+#Sample program
+# Define a function that generates a sequence of Fibonacci numbers
+def fibonacci():
+    a, b = 0, 1
+    while True:
+        yield a
+        a, b = b, a + b
+
+# Define a generator expression that generates the first 10 Fibonacci numbers
+fibonacci_sequence = (n for i, n in enumerate(fibonacci()) if i < 10)
+
+# Print the first 10 Fibonacci numbers
+for n in fibonacci_sequence:
+    print(n)
diff --git a/reading_files_using_generator.py b/reading_files_using_generator.py
@@ -0,0 +1,12 @@
+def csv_reader(file_name):
+    for row in open(file_name, "r"):
+        yield row
+csv_gen = csv_reader("testfile.txt")
+row_count = 0
+
+for row in csv_gen:
+    row_count += 1
+
+print(f"Row count is {row_count}")
+
+# csv_gen = (row for row in open("testfile.txt"))
diff --git a/send_method_coroutine.py b/send_method_coroutine.py
@@ -0,0 +1,52 @@
+# import asyncio
+
+# async def my_coroutine():
+#     print('Coroutine started')
+#     value = await asyncio.sleep(1)
+#     print(f'Coroutine received value: {value}')
+#     result = await asyncio.sleep(1)
+#     print(f'Coroutine received result: {result}')
+
+# async def main():
+#     coro = my_coroutine()
+#     print('Main coroutine started')
+#     await asyncio.sleep(0.5)
+#     print('Main coroutine sending value to my_coroutine')
+#     await coro  # This will start the coroutine and reach the first yield statement
+#     try:
+#         coro.send('Hello')
+#     except StopIteration:
+#         pass
+#     await asyncio.sleep(0.5)
+#     print('Main coroutine sending result to my_coroutine')
+#     try:
+#         coro.send(42)
+#     except StopIteration:
+#         pass
+
+# asyncio.run(main())
+
+# Sample program
+def isPrime(n):
+    if n < 2 or n % 1 > 0:
+        return False
+    elif n == 2 or n == 3:
+        return True
+    for x in range(2, int(n**0.5) + 1):
+        if n % x == 0:
+            return False
+    return True
+
+def getPrimes():
+    value = 0
+    while True:
+        if isPrime(value):
+            i = yield value
+            if i is not None:
+                value = i
+        value += 1
+
+prime_gen = getPrimes()
+print(next(prime_gen))
+print(prime_gen.send(1000))
+print(next(prime_gen))  
diff --git a/testfile.txt b/testfile.txt
@@ -1 +1,5 @@
-I love python
+I love python
+bfsbflfjkdbnfnqjbqqjbqkdlbdvqhjb dns dj dfkld d n dj dc j clsd;clscml;njvdv vnmsnkbdvdjvdmvnmabvnbvd   dvkjdbvkbadkjvkadbjvbdkvbdkv 
+vdjbvkjdvkjdbjvkbdkbvd
+nkbjdbfnkvbldfsvdvhdjvbdsfjsvbhkvfdvbjdhsbvjfbhvbjvbdfbvjbvhfbvfdvbfdjivbfkjvnfkbvfbvjbvjv
+bfjvjv fdjhvbdf vhbvjhflbvhfvmbvjbv bvjvndlvavnbvbdjv sjd dv dfjh vhjdfbvjdbvbad
diff --git a/yield_from.py b/yield_from.py
@@ -0,0 +1,24 @@
+# yield returns from a simple generator function, yield from allows you to yield from another generator function. This comes in handy when you need to use two functions in a generator such as when we did merge sort in the sorting 
+def yieldOnly():
+    yield "A"
+    yield "B"
+    yield "C"
+
+def yieldFrom():
+    for i in [1, 2, 3]:
+        yield from yieldOnly()
+
+test = yieldFrom()
+for i in test:
+    print(i)
+
+
+# Sample program for yield from
+def sample_generator(i):
+    for j in range(i):
+        yield j
+
+def yf_generator(i):
+    yield from sample_generator(i)
+for value in yf_generator(5):
+    print(value)
