PEP:	289
Title:	Generator Expressions
Author:	python at rcn.com (Raymond Hettinger)
Status:	Final
Type:	Standards Track
Created:	30-Jan-2002
Python-Version:	2.4
Post-History:	22-Oct-2003

The utility of generator expressions is greatly enhanced when combined with reduction functions like sum, min, and max. The heapq module in Python 2.4 includes two new reduction functions: nlargest and nsmallest. Both work well with generator expressions and keep no more than n items in memory at one time.

Contents

May 27, 2019 This way you’ve gotten access to the keys (key) and values (adictkey) of adict at the same time, and you’ll be able to perform any action on them. Iterating Through.values It’s also common to only use the values to iterate through a dictionary in Python. Nov 21, 2018  Dictionary in Python is an unordered collection of data values, used to store data values like a map, which unlike other Data Types that hold only single value as an element, Dictionary holds key:value pair. Key value is provided in the dictionary to make it more optimized. Each key-value pair in a Dictionary is separated by a colon:, whereas each key is separated. Python: How do I randomly select a value from a dictionary key? Ask Question Asked 4 years, 9 months ago. How to remove a key from a Python dictionary? Hot Network Questions Science-fiction short story ending with the line 'Twenty years later, it didn't seem so funny.' A dictionary is a collection which is unordered, changeable and indexed. In Python dictionaries are written with curly brackets, and they have keys and values.

This PEP introduces generator expressions as a high performance,memory efficient generalization of list comprehensions [1] andgenerators [2].

Experience with list comprehensions has shown their widespreadutility throughout Python. However, many of the use cases donot need to have a full list created in memory. Instead, theyonly need to iterate over the elements one at a time.

For instance, the following summation code will build a full list ofsquares in memory, iterate over those values, and, when the referenceis no longer needed, delete the list:

Memory is conserved by using a generator expression instead:

Similar benefits are conferred on constructors for container objects:

Generator expressions are especially useful with functions like sum(),min(), and max() that reduce an iterable input to a single value:

Generator expressions also address some examples of functionals codedwith lambda:

These simplify to:

List comprehensions greatly reduced the need for filter() and map().Likewise, generator expressions are expected to minimize the needfor itertools.ifilter() and itertools.imap(). In contrast, theutility of other itertools will be enhanced by generator expressions:

Having a syntax similar to list comprehensions also makes it easy toconvert existing code into a generator expression when scaling upapplication.

Early timings showed that generators had a significant performanceadvantage over list comprehensions. However, the latter were highlyoptimized for Py2.4 and now the performance is roughly comparablefor small to mid-sized data sets. As the data volumes grow larger,generator expressions tend to perform better because they do notexhaust cache memory and they allow Python to re-use objects betweeniterations.

(None of this is exact enough in the eye of a reader from Mars, but Ihope the examples convey the intention well enough for a discussion inc.l.py. The Python Reference Manual should contain a 100% exactsemantic and syntactic specification.)

1. The semantics of a generator expression are equivalent to creatingan anonymous generator function and calling it. For example:

   is equivalent to:

   Only the outermost for-expression is evaluated immediately, the otherexpressions are deferred until the generator is run:

   is equivalent to:

2. The syntax requires that a generator expression always needs to bedirectly inside a set of parentheses and cannot have a comma oneither side. With reference to the file Grammar/Grammar in CVS,two rules change:

   1. The rule:

      changes to:

      where testlist_gexp is almost the same as listmaker, but onlyallows a single test after 'for' .. 'in':

   2. The rule for arglist needs similar changes.

   This means that you can write:

   but you would have to write:

   and also:

   i.e. if a function call has a single positional argument, it can bea generator expression without extra parentheses, but in all othercases you have to parenthesize it.

   The exact details were checked in to Grammar/Grammar version 1.49.

3. The loop variable (if it is a simple variable or a tuple of simplevariables) is not exposed to the surrounding function. Thisfacilitates the implementation and makes typical use cases morereliable. In some future version of Python, list comprehensionswill also hide the induction variable from the surrounding code(and, in Py2.4, warnings will be issued for code accessing theinduction variable).

   For example:

4. List comprehensions will remain unchanged. For example:

   Unfortunately, there is currently a slight syntactic difference.The expression:

   is legal, meaning:

   But generator expressions will not allow the former version:

   is illegal.

   The former list comprehension syntax will become illegal in Python3.0, and should be deprecated in Python 2.4 and beyond.

   List comprehensions also 'leak' their loop variable into thesurrounding scope. This will also change in Python 3.0, so thatthe semantic definition of a list comprehension in Python 3.0 willbe equivalent to list(<generator expression>). Python 2.4 andbeyond should issue a deprecation warning if a list comprehension'sloop variable has the same name as a variable used in theimmediately surrounding scope.

After much discussion, it was decided that the first (outermost)for-expression should be evaluated immediately and that the remainingexpressions be evaluated when the generator is executed.

Asked to summarize the reasoning for binding the first expression,Guido offered [5]:

Various use cases were proposed for binding all free variables whenthe generator is defined. And some proponents felt that the resultingexpressions would be easier to understand and debug if bound immediately.

However, Python takes a late binding approach to lambda expressions andhas no precedent for automatic, early binding. It was felt thatintroducing a new paradigm would unnecessarily introduce complexity.

After exploring many possibilities, a consensus emerged that bindingissues were hard to understand and that users should be stronglyencouraged to use generator expressions inside functions that consumetheir arguments immediately. For more complex applications, fullgenerator definitions are always superior in terms of being obviousabout scope, lifetime, and binding [6].

The utility of generator expressions is greatly enhanced when combinedwith reduction functions like sum(), min(), and max(). The heapqmodule in Python 2.4 includes two new reduction functions: nlargest()and nsmallest(). Both work well with generator expressions and keepno more than n items in memory at one time. Rhino 5 licence key generator.

• Raymond Hettinger first proposed the idea of 'generatorcomprehensions' in January 2002.
• Peter Norvig resurrected the discussion in his proposal forAccumulation Displays.
• Alex Martelli provided critical measurements that proved theperformance benefits of generator expressions. He also providedstrong arguments that they were a desirable thing to have.
• Phillip Eby suggested 'iterator expressions' as the name.
• Subsequently, Tim Peters suggested the name 'generator expressions'.
• Armin Rigo, Tim Peters, Guido van Rossum, Samuele Pedroni,Hye-Shik Chang and Raymond Hettinger teased out the issues surroundingearly versus late binding [5].
• Jiwon Seo single handedly implemented various versions of the proposalincluding the final version loaded into CVS. Along the way, therewere periodic code reviews by Hye-Shik Chang and Raymond Hettinger.Guido van Rossum made the key design decisions after comments fromArmin Rigo and newsgroup discussions. Raymond Hettinger providedthe test suite, documentation, tutorial, and examples [6].

[1]	PEP 202 List Comprehensionshttp://www.python.org/dev/peps/pep-0202/

[2]	PEP 255 Simple Generatorshttp://www.python.org/dev/peps/pep-0255/

[3]	Peter Norvig's Accumulation Display Proposalhttp://www.norvig.com/pyacc.html

[4]	Jeff Epler had worked up a patch demonstratingthe previously proposed bracket and yield syntaxhttps://bugs.python.org/issue795947

[5]	(1, 2) Discussion over the relative merits of early versus late bindinghttps://mail.python.org/pipermail/python-dev/2004-April/044555.html

[6]	(1, 2) Patch discussion and alternative patches on Source Forgehttps://bugs.python.org/issue872326

This document has been placed in the public domain.

Source: https://github.com/python/peps/blob/master/pep-0289.txt

• Python Basic Tutorial

• Python Advanced Tutorial

• Python Useful Resources

• Selected Reading

Each key is separated from its value by a colon (:), the items are separated by commas, and the whole thing is enclosed in curly braces. An empty dictionary without any items is written with just two curly braces, like this: {}.

Keys are unique within a dictionary while values may not be. The values of a dictionary can be of any type, but the keys must be of an immutable data type such as strings, numbers, or tuples.

Accessing Values in Dictionary

To access dictionary elements, you can use the familiar square brackets along with the key to obtain its value. Following is a simple example −

When the above code is executed, it produces the following result −

If we attempt to access a data item with a key, which is not part of the dictionary, we get an error as follows −

When the above code is executed, it produces the following result −

Updating Dictionary

You can update a dictionary by adding a new entry or a key-value pair, modifying an existing entry, or deleting an existing entry as shown below in the simple example −

Delete Dict Entry Python

When the above code is executed, it produces the following result −

Delete Dictionary Elements

You can either remove individual dictionary elements or clear the entire contents of a dictionary. You can also delete entire dictionary in a single operation.

To explicitly remove an entire dictionary, just use the del statement. Following is a simple example −

This produces the following result. Note that an exception is raised because after del dict dictionary does not exist any more −

Python Remove From Dict

Note − del() method is discussed in subsequent section.

Properties of Dictionary Keys

Dictionary values have no restrictions. They can be any arbitrary Python object, either standard objects or user-defined objects. However, same is not true for the keys.

There are two important points to remember about dictionary keys −

(a) More than one entry per key not allowed. Which means no duplicate key is allowed. When duplicate keys encountered during assignment, the last assignment wins. For example −

When the above code is executed, it produces the following result −

(b) Keys must be immutable. Which means you can use strings, numbers or tuples as dictionary keys but something like ['key'] is not allowed. Following is a simple example −

When the above code is executed, it produces the following result −

Built-in Dictionary Functions & Methods

Python includes the following dictionary functions −

Sr.No.	Function with Description
1	cmp(dict1, dict2) Compares elements of both dict.
2	len(dict) Gives the total length of the dictionary. This would be equal to the number of items in the dictionary.
3	str(dict) Produces a printable string representation of a dictionary
4	type(variable) Returns the type of the passed variable. If passed variable is dictionary, then it would return a dictionary type.

Python includes following dictionary methods −

Sr.No.	Methods with Description
1	dict.clear() Removes all elements of dictionary dict
2	dict.copy() Returns a shallow copy of dictionary dict
3	dict.fromkeys() Create a new dictionary with keys from seq and values set to value.
4	dict.get(key, default=None) For key key, returns value or default if key not in dictionary
5	dict.has_key(key) Returns true if key in dictionary dict, false otherwise
6	dict.items() Returns a list of dict's (key, value) tuple pairs
7	dict.keys() Returns list of dictionary dict's keys
8	dict.setdefault(key, default=None) Similar to get(), but will set dict[key]=default if key is not already in dict
9	dict.update(dict2) Adds dictionary dict2's key-values pairs to dict
10	dict.values() Returns list of dictionary dict's values