rna-transcription approach: a few improvements

exercises/practice/rna-transcription/.approaches/dictionary-join/content.md

@@ -5,7 +5,7 @@ LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
 
 
 def to_rna(dna_strand):
-    return ''.join(LOOKUP[chr] for chr in dna_strand)
+    return ''.join(LOOKUP[char] for char in dna_strand)
 
 ```
 
@@ -16,15 +16,32 @@ but the `LOOKUP` dictionary is defined with all uppercase letters, which is the
 It indicates that the value is not intended to be changed.
 
 In the `to_rna()` function, the [`join()`][join] method is called on an empty string,
-and is passed the list created from a [list comprehension][list-comprehension].
+and is passed the list created from a [generator expression][generator-expression].
 
-The list comprehension iterates each character in the input,
+The generator expression iterates each character in the input,
 looks up the DNA character in the look-up dictionary, and outputs its matching RNA character as an element in the list.
 
-The `join()` method collects the list of RNA characters back into a string.
+The `join()` method collects the RNA characters back into a string.
 Since an empty string is the separator for the `join()`, there are no spaces between the RNA characters in the string.
 
+A generator expression is similar to a [list comprehension][list-comprehension], but instead of creating a list, it returns a generator, and iterating that generator yields the elements on the fly.
+
+A variant that uses a list comprehension is almost identical, but note the additional square brackets inside the `join()`:
+
+```python
+LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
+
+
+def to_rna(dna_strand):
+    return ''.join([LOOKUP[char] for char in dna_strand])
+```
+
+For a relatively small number of elements, using lists is fine and is usually even faster, but as the size of the data increases, the memory consumption increases and performance decreases.
+See also [this discussion][list-comprehension-choose-generator-expression] regarding when to choose one over the other.
+
 [dictionaries]: https://docs.python.org/3/tutorial/datastructures.html?#dictionaries
 [const]: https://realpython.com/python-constants/
 [join]: https://docs.python.org/3/library/stdtypes.html?#str.join
 [list-comprehension]: https://realpython.com/list-comprehension-python/#using-list-comprehensions
+[list-comprehension-choose-generator-expression]: https://realpython.com/list-comprehension-python/#choose-generators-for-large-datasets
+[generator-expression]: https://realpython.com/introduction-to-python-generators/#building-generators-with-generator-expressions

exercises/practice/rna-transcription/.approaches/dictionary-join/snippet.txt

@@ -2,4 +2,4 @@ LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
 
 
 def to_rna(dna_strand):
-    return ''.join(LOOKUP[chr] for chr in dna_strand)
+    return ''.join(LOOKUP[char] for char in dna_strand)

exercises/practice/rna-transcription/.approaches/introduction.md

@@ -30,15 +30,15 @@ LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
 
 
 def to_rna(dna_strand):
-    return ''.join(LOOKUP[chr] for chr in dna_strand)
+    return ''.join(LOOKUP[char] for char in dna_strand)
 
 ```
 
 For more information, check the [dictionary look-up with `join()` approach][approach-dictionary-join].
 
 ## Which approach to use?
 
-The `translate()` with `maketrans()` approach benchmarked over four times faster than the dictionary look-up with `join()` approach.
+The `translate()` with `maketrans()` approach benchmarked many times faster than the dictionary look-up with `join()` approach.
 
 [ASCII]: https://www.asciitable.com/
 [approach-translate-maketrans]: https://exercism.org/tracks/python/exercises/rna-transcription/approaches/translate-maketrans