Simply call `list` on the generator.

    lst = list(gen)
    lst

Be aware that this affects the generator which will not return any further items.

You also cannot directly call `list` in IPython, as it conflicts with a command for listing lines of code.

Tested on this file:

    def gen():
        yield 1
        yield 2
        yield 3
        yield 4
        yield 5
    import ipdb
    ipdb.set_trace()
    
    g1 = gen()
    
    text = &quot;aha&quot; + &quot;bebe&quot;
    
    mylst = range(10, 20)

which when run:

    $ python code.py 
    &gt; /home/javl/sandbox/so/debug/code.py(10)&lt;module&gt;()
          9 
    ---&gt; 10 g1 = gen()
         11 
    
    ipdb&gt; n
    &gt; /home/javl/sandbox/so/debug/code.py(12)&lt;module&gt;()
         11 
    ---&gt; 12 text = &quot;aha&quot; + &quot;bebe&quot;
         13 
    
    ipdb&gt; lst = list(g1)
    ipdb&gt; lst
    [1, 2, 3, 4, 5]
    ipdb&gt; q
    Exiting Debugger.

# General method for escaping function/variable/debugger name conflicts

There are debugger commands `p` and `pp` that will `print` and `prettyprint` any expression following them.

So you could use it as follows:

    $ python code.py 
    &gt; /home/javl/sandbox/so/debug/code.py(10)&lt;module&gt;()
          9 
    ---&gt; 10 g1 = gen()
         11 
    
    ipdb&gt; n
    &gt; /home/javl/sandbox/so/debug/code.py(12)&lt;module&gt;()
         11 
    ---&gt; 12 text = &quot;aha&quot; + &quot;bebe&quot;
         13 
    
    ipdb&gt; p list(g1)
    [1, 2, 3, 4, 5]
    ipdb&gt; c

There is also an `exec` command, called by prefixing your expression with `!`, which forces debugger to take your expression as Python one.

    ipdb&gt; !list(g1)
    []

For more details see `help p`, `help pp` and `help exec` when in debugger.

    ipdb&gt; help exec
    (!) statement
    Execute the (one-line) statement in the context of
    the current stack frame.
    The exclamation point can be omitted unless the first word
    of the statement resembles a debugger command.
    To assign to a global variable you must always prefix the
    command with a &#39;global&#39; command, e.g.:
    (Pdb) global list_options; list_options = [&#39;-l&#39;]

I want to create a class that can store objects conforming to a certain protocol.  The objects should be stored in a typed array. According to the Swift documentation protocols can be used as types:&amp;nbsp;

&gt; Because it is a type, you can use a protocol in many places where other types are allowed, including:
&gt;
&gt; - As a parameter type or return type in a function, method, or initializer
&gt; - As the type of a constant, variable, or property
&gt; - As the type of items in an array, dictionary, or other container

However the following generates compiler errors: 
&gt; Protocol &#39;SomeProtocol&#39; can only be used as a generic constraint because it has Self or associated type requirements

How are you supposed to solve this:

    protocol SomeProtocol: Equatable {
        func bla()
    }
    
    class SomeClass {
        
        var protocols = [SomeProtocol]()
        
        func addElement(element: SomeProtocol) {
            self.protocols.append(element)
        }
        
        func removeElement(element: SomeProtocol) {
            if let index = find(self.protocols, element) {
                self.protocols.removeAtIndex(index)
            }
        }
    }

Usage of protocols as array types and function parameters in swift

One of our application screens requires us to place a `UICollectionView` inside of a `UITableViewCell`.  This `UICollectionView` will have a dynamic number of items, resulting in a height which must be calculated dynamically as well.  However, I am running into problems trying to calculate the height of the embedded `UICollectionView`.

Our overarching `UIViewController` was created in Storyboards and does make use of auto layout.  But, I don&#39;t know how to dynamically increase the height of the `UITableViewCell` based on the height of the `UICollectionView`.

Can anyone give some tips or advice on how to accomplish this?

UICollectionView inside a UITableViewCell -- dynamic height?

When I&#39;m debugging in Python using IPython, I sometimes hit a break-point and I want to examine a variable that is currently a generator. The simplest way I can think of doing this is converting it to a list, but I&#39;m not clear on what&#39;s an easy way of doing this in one line in `ipdb`, since I&#39;m so new to Python.

Convert generator object to list for debugging

<p>When I'm debugging in Python using IPython, I sometimes hit a break-point and I want to examine a variable that is currently a generator. The simplest way I can think of doing this is converting it to a list, but I'm not clear on what's an easy way of doing this in one line in <code>ipdb</code>, since I'm so new to Python.</p>


I have a fairly large dataset in the form of a dataframe and I was wondering how I would be able to split the dataframe into two random samples (80% and 20%) for training and testing.

Thanks!

How do I create test and train samples from one dataframe with pandas?

In debugging my code, I want to use a list comprehension. However, it seems I cannot evaluate a list comprehension from the debugger when I&#39;m inside a function.

I am using Python 3.4.

**Script contents**:

    $ cat test.py 
    #!/usr/bin/python
    
    def foo():
        x = [1, 2, 3, 3, 4]
    
        print(x)
    
    foo()

**Interactive debugging:**

    $ python3 -mpdb test.py                                                                                                                                           
    &gt; /tmp/test.py(3)&lt;module&gt;()
    -&gt; def foo():
    (Pdb) step
    &gt; /tmp/test.py(8)&lt;module&gt;()
    -&gt; foo()
    (Pdb) 
    --Call--
    &gt; /tmp/test.py(3)foo()
    -&gt; def foo():
    (Pdb) 
    &gt; /tmp/test.py(4)foo()
    -&gt; x = [1, 2, 3, 3, 4]
    (Pdb) 
    &gt; /tmp/test.py(6)foo()
    -&gt; print(x)
    (Pdb) p [x for _ in range(1)]
    *** NameError: name &#39;x&#39; is not defined
    (Pdb) p x
    [1, 2, 3, 3, 4]

Why is `x` unknown to the list comprehension?  How could I evaluate a list comprehension from the debugger, or achieve an equivalent behaviour?  Is this a bug, or is it some sort of fundamental limitation to the debugger?

List comprehension scope error from Python debugger

I looked at previous similar questions and got only more confused.

In python 3.4, I want to read an html page as a string, given the url.

In perl I do this with LWP::Simple, using get().

A matplotlib 1.3.1 example says: `import urllib; u1=urllib.urlretrieve(url)`.
python3 can&#39;t find `urlretrieve`.

I tried `u1 = urllib.request.urlopen(url)`, which appears to get an `HTTPResponse` object, but I can&#39;t print it or get a length on it or index it.

`u1.body` doesn&#39;t exist. I can&#39;t find a description of the `HTTPResponse` in python3.

Is there an attribute in the `HTTPResponse` object which will give me the raw bytes of the html page?

(Irrelevant stuff from other questions include `urllib2`, which doesn&#39;t exist in my python, csv parsers, etc.)

**Edit:**

I found something in a prior question which partially (mostly) does the job:

    u2 = urllib.request.urlopen(&#39;http://finance.yahoo.com/q?s=aapl&amp;ql=1&#39;)

    for lines in u2.readlines():
        print (lines)

I say &#39;partially&#39; because I don&#39;t want to read separate lines, but just one big string.

I could just concatenate the lines, but every line printed has a character &#39;b&#39; prepended to it.

Where does that come from?

Again, I suppose I could delete the first character before concatenating, but that does get to be a kloodge.


How to read html from a url in python 3

Jinja unfortunately does not support executing arbitrary Python code, such as

    {% if len(some_var)&gt;1 %} ... {% endif %}

My current workaround is to use the deprecated, ugly, double-underscore method:

    {% if some_var.__len__()&gt;1 %} ... {% endif %}

Although this works, I&#39;m afraid that some future implementation of strings might break this code. Is there a better way to do this?

Length of string in Jinja/Flask

I hit this TypeError exception recently, which I found very difficult to debug. I eventually reduced it to this small test case:

    &gt;&gt;&gt; &quot;{:20}&quot;.format(b&quot;hi&quot;)
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
    TypeError: non-empty format string passed to object.__format__

This is very non-obvious, to me anyway. The workaround for my code was to decode the byte string into unicode:

     &gt;&gt;&gt; &quot;{:20}&quot;.format(b&quot;hi&quot;.decode(&quot;ascii&quot;))
     &#39;hi                  &#39;

What is the meaning of this exception? Is there a way it can be made more clear?

Python TypeError: non-empty format string passed to object.__format__

(This question is related to [this one][1] and [this one][2], but those are pre-walking the generator, which is exactly what I want to avoid)

I would like to split a generator in chunks. The requirements are:

- do not pad the chunks: if the number of remaining elements is less than the chunk size, the last chunk must be smaller.
- do not walk the generator beforehand: computing the elements is expensive, and it must only be done by the consuming function, not by the chunker
- which means, of course: do not accumulate in memory (no lists)

I have tried the following code:

    def head(iterable, max=10):
        for cnt, el in enumerate(iterable):
            yield el
            if cnt &gt;= max:
                break
    
    def chunks(iterable, size=10):
        i = iter(iterable)
        while True:
            yield head(i, size)
    
    # Sample generator: the real data is much more complex, and expensive to compute
    els = xrange(7)
    
    for n, chunk in enumerate(chunks(els, 3)):
        for el in chunk:
            print &#39;Chunk %3d, value %d&#39; % (n, el)

And this somehow works:

    Chunk   0, value 0
    Chunk   0, value 1
    Chunk   0, value 2
    Chunk   1, value 3
    Chunk   1, value 4
    Chunk   1, value 5
    Chunk   2, value 6
    ^CTraceback (most recent call last):
      File &quot;xxxx.py&quot;, line 15, in &lt;module&gt;
        for el in chunk:
      File &quot;xxxx.py&quot;, line 2, in head
        for cnt, el in enumerate(iterable):
    KeyboardInterrupt

Buuuut ... it never stops (I have to press `^C`) because of the `while True`. I would like to stop that loop whenever the generator has been consumed, but I do not know how to detect that situation. I have tried raising an Exception:

    class NoMoreData(Exception):
        pass
    
    def head(iterable, max=10):
        for cnt, el in enumerate(iterable):
            yield el
            if cnt &gt;= max:
                break
        if cnt == 0 : raise NoMoreData()
    
    def chunks(iterable, size=10):
        i = iter(iterable)
        while True:
            try:
                yield head(i, size)
            except NoMoreData:
                break

    # Sample generator: the real data is much more complex, and expensive to compute    
    els = xrange(7)
    
    for n, chunk in enumerate(chunks(els, 2)):
        for el in chunk:
            print &#39;Chunk %3d, value %d&#39; % (n, el)


But then the exception is only raised in the context of the consumer, which is not what I want (I want to keep the consumer code clean)

    Chunk   0, value 0
    Chunk   0, value 1
    Chunk   0, value 2
    Chunk   1, value 3
    Chunk   1, value 4
    Chunk   1, value 5
    Chunk   2, value 6
    Traceback (most recent call last):
      File &quot;xxxx.py&quot;, line 22, in &lt;module&gt;
        for el in chunk:
      File &quot;xxxx.py&quot;, line 9, in head
        if cnt == 0 : raise NoMoreData
    __main__.NoMoreData()

How can I detect that the generator is exhausted in the `chunks` function, without walking it?

  [1]: https://stackoverflow.com/q/8290397/647991
  [2]: https://stackoverflow.com/q/312443/647991


Split a generator into chunks without pre-walking it

That is, how do I express

    function *(next) {}

with arrow syntax? I&#39;ve tried all the combinations I could think of, and I can&#39;t find any documentation on it.

(I am currently using Node.js v0.11.14.)




Can I use ES6&#39;s arrow function syntax with generators? (arrow notation)

The typical way to loop `x` times in JavaScript is:

    for (var i = 0; i &lt; x; i++)
      doStuff(i);

But I don&#39;t want to use the `++` operator or have any mutable variables at all. So is there a way, in ES6, to loop `x` times another way? I love Ruby&#39;s mechanism:

    x.times do |i|
      do_stuff(i)
    end

Anything similar in JavaScript/ES6? I could kind of cheat and make my own generator:

    function* times(x) {
      for (var i = 0; i &lt; x; i++)
        yield i;
    }
    
    for (var i of times(5)) {
      console.log(i);
    }

Of course I&#39;m still using `i++`. At least it&#39;s out of sight :), but I&#39;m hoping there&#39;s a better mechanism in ES6.

Is there a mechanism to loop x times in ES6 (ECMAScript 6) without mutable variables?

The following behaviour seems rather counterintuitive to me (Python 3.4):

    &gt;&gt;&gt; [(yield i) for i in range(3)]
    &lt;generator object &lt;listcomp&gt; at 0x0245C148&gt;
    &gt;&gt;&gt; list([(yield i) for i in range(3)])
    [0, 1, 2]
    &gt;&gt;&gt; list((yield i) for i in range(3))
    [0, None, 1, None, 2, None]

The intermediate values of the last line are actually not always `None`, they are whatever we `send` into the generator, equivalent (I guess) to the following generator:

    def f():
       for i in range(3):
          yield (yield i)

It strikes me as funny that those three lines work at all. The [Reference](https://docs.python.org/3/reference/expressions.html#yield-expressions) says that `yield` is only allowed in a function definition (though I may be reading it wrong and/or it may simply have been copied from the older version). The first two lines produce a `SyntaxError` in Python 2.7, but the third line doesn&#39;t.

Also, it seems odd

- that a list comprehension returns a generator and not a list
- and that the generator expression converted to a list and the corresponding list comprehension contain different values.

Could someone provide more information?

yield in list comprehensions and generator expressions

I was just reading this fantastic article &#171;[Generators][1]&#187; and it clearly highlights this function, which is a helper function for handling generator functions:

&lt;!-- language: lang-js --&gt;

    function async(makeGenerator){
      return function () {
        var generator = makeGenerator.apply(this, arguments);
    
        function handle(result){
          // result =&gt; { done: [Boolean], value: [Object] }
          if (result.done) return Promise.resolve(result.value);
    
          return Promise.resolve(result.value).then(function (res){
            return handle(generator.next(res));
          }, function (err){
            return handle(generator.throw(err));
          });
        }
    
        try {
          return handle(generator.next());
        } catch (ex) {
          return Promise.reject(ex);
        }
      }
    }

*which I hypothesize is more or less the way the `async` keyword is implemented with `async`/`await`.* So the question is, if that is the case, then what the heck is the difference between the `await` keyword and the `yield` keyword? Does `await` always turn something into a promise, whereas `yield` makes no such guarantee? That is my best guess!

You can also see how `async`/`await` is similar to `yield` with generators in this article where he describes the &#39;spawn&#39; function [ES7 async functions][2].

  [1]: https://www.promisejs.org/generators
  [2]: https://jakearchibald.com/2014/es7-async-functions

Difference between async/await and ES6 yield with generators

Recently when adding the `pdb` debugger to my Python 2.7.10 code, I get this message:

	Traceback (most recent call last):
	  File &quot;/Users/isaachess/Programming/vivint/Platform/MessageProcessing/vivint_cloud/queues/connectors/amqplib_connector.py&quot;, line 191, in acking_callback
	    callback(message.body)
	  File &quot;/Users/isaachess/Programming/vivint/Platform/MessageProcessing/vivint_cloud/queues/consumable_message_queue.py&quot;, line 32, in deserialized_callback
	    self._callback_method(msg)
	  File &quot;/Users/isaachess/Programming/vivint/Platform/BusinessLogic/businesslogic/util/statsd_util.py&quot;, line 95, in _time_func
	    retVal = f(*args, **kwargs)
	  File &quot;/Users/isaachess/Programming/vivint/Platform/MessageProcessing/vivint_cloud/net/router.py&quot;, line 226, in handle
	    try:
	  File &quot;/Users/isaachess/Programming/vivint/Platform/MessageProcessing/vivint_cloud/net/router.py&quot;, line 226, in handle
	    try:
	  File &quot;/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/bdb.py&quot;, line 49, in trace_dispatch
	    return self.dispatch_line(frame)
	  File &quot;/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/bdb.py&quot;, line 68, in dispatch_line
	    if self.quitting: raise BdbQuit
	BdbQuit

This is after inserting the line:

`import pdb; pdb.set_trace()`

in the code.

I cannot figure out why this is happening. I&#39;ve read up on Bdb and Bdbquit, but cannot figure out why this is happening in my code. Can anyone provide me with some hints of why this happens in general? I *really* want to get the debugger working again.

BdbQuit raised when debugging Python with pdb

I&#39;m using jupyter (or Ipython) notebook with firefox, and want to debug some python code in the cell. I am using &#39;import ipdb; ipdb.set_trace()&#39; as kind of breakpoint, for example my cell has the following code: 

    a=4
    import ipdb; ipdb.set_trace()
    b=5
    print a
    print b
which after execution with Shift+Enter gives me this error:

    --------------------------------------------------------------------------
    MultipleInstanceError                     Traceback (most recent call last)
    &lt;ipython-input-1-f2b356251c56&gt; in &lt;module&gt;()
          1 a=4
    ----&gt; 2 import ipdb; ipdb.set_trace()
          3 b=5
          4 print a
          5 print b
    
    /home/nnn/anaconda/lib/python2.7/site-packages/ipdb/__init__.py in &lt;module&gt;()
         14 # You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.
         15 
    ---&gt; 16 from ipdb.__main__ import set_trace, post_mortem, pm, run, runcall, runeval, launch_ipdb_on_exception
         17 
         18 pm                       # please pyflakes
    
    /home/nnn/anaconda/lib/python2.7/site-packages/ipdb/__main__.py in &lt;module&gt;()
         71         # the instance method will create a new one without loading the config.
         72         # i.e: if we are in an embed instance we do not want to load the config.
    ---&gt; 73         ipapp = TerminalIPythonApp.instance()
         74         shell = get_ipython()
         75         def_colors = shell.colors
    
    /home/nnn/anaconda/lib/python2.7/site-packages/traitlets/config/configurable.pyc in instance(cls, *args, **kwargs)
        413             raise MultipleInstanceError(
        414                 &#39;Multiple incompatible subclass instances of &#39;
    --&gt; 415                 &#39;%s are being created.&#39; % cls.__name__
        416             )
        417 
    
    MultipleInstanceError: Multiple incompatible subclass instances of TerminalIPythonApp are being created.

The same error appears if I use this code not in the jupyter notebook in the browser, but in jupyter qtconsole. 
What does this error mean and what to do to avoid it? 
Is it possible to debug code in the cell step-by-step, using next, continue, etc commands of pdb debugger?

using ipdb to debug python code in one cell (jupyter or Ipython)

Can I step out of a function after stepping into it with `step` while using pdb / ipdb debugger?

And if there&#39;s no such option - what is the fastest way to get out of the stepped-in function?

Content Type	Original Author	Original Content on Stackoverflow
Question	Seanny123	View Question on Stackoverflow
Solution 1 - Python	Jan Vlcinsky	View Answer on Stackoverflow

Convert generator object to list for debugging

Python Problem Overview

Python Solutions

Solution 1 - Python

General method for escaping function/variable/debugger name conflicts

UICollectionView inside a UITableViewCell -- dynamic height?

Usage of protocols as array types and function parameters in swift

Attributions