title
stringlengths 10
172
| question_id
int64 469
40.1M
| question_body
stringlengths 22
48.2k
| question_score
int64 -44
5.52k
| question_date
stringlengths 20
20
| answer_id
int64 497
40.1M
| answer_body
stringlengths 18
33.9k
| answer_score
int64 -38
8.38k
| answer_date
stringlengths 20
20
| tags
sequence |
|---|---|---|---|---|---|---|---|---|---|
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 8,759,409 | <p>Using SL4A (which has already been mentioned by itself in other answers) you can <a href="http://groups.google.com/group/web2py/browse_thread/thread/f227e93fe802a902" rel="nofollow">run</a> a full-blown <a href="http://web2py.com/" rel="nofollow">web2py</a> instance (other <a href="http://wiki.python.org/moin/WebFrameworks" rel="nofollow">python web frameworks</a> are likely candidates as well). SL4A doesn't allow you to do native UI components (buttons, scroll bars, and the like), but it does support <a href="http://code.google.com/p/android-scripting/wiki/UsingWebView" rel="nofollow">WebViews</a>. A WebView is basically nothing more than a striped down web browser pointed at a fixed address. I believe the native Gmail app uses a WebView instead of going the regular widget route. </p>
<p>This route would have some interesting features:</p>
<ul>
<li>In the case of most python web frameworks, you could actually develop and test without using an android device or android emulator.</li>
<li>Whatever Python code you end up writing for the phone could also be put on a public webserver with very little (if any) modification.</li>
<li>You could take advantage of all of the crazy web stuff out there: query, HTML5, CSS3, etc.</li>
</ul>
| 18 | 2012-01-06T14:34:25Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 8,784,038 | <p>From the <a href="https://github.com/kivy/python-for-android">Python for android</a> site:</p>
<blockquote>
<p>Python for android is a project to create your own Python distribution including the modules you want, and create an apk including python, libs, and your application.</p>
</blockquote>
| 12 | 2012-01-09T04:46:53Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 9,773,282 | <h3>SL4A</h3>
<p><a href="https://github.com/damonkohler/sl4a" rel="nofollow">Scripting Layer for Android</a> does what you want. You can easily install it directly onto your device from their site, and do not need root.</p>
<p>It supports a range of languages; Python is the most mature. By default, it uses Python 2.6, but there is a <a href="https://code.google.com/p/python-for-android/wiki/Python3" rel="nofollow">3.2 port</a> you can use instead. I have used that port for all kinds of things on a Galaxy S2 and it worked fine.</p>
<h3>API</h3>
<p>SL4A provides a port of their <code>android</code> library for each supported language. The library provides an interface to the underlying Android API through a single <code>Android</code> object.</p>
<pre><code>import android
droid = android.Android()
# example using the text to speech facade
droid.ttsSpeak('hello world')
</code></pre>
<p>Each language has pretty much the same API. You can even use the JavaScript API inside webviews.</p>
<pre><code>var droid = new Android();
droid.ttsSpeak('hello from js');
</code></pre>
<h3>User Interfaces</h3>
<p>For user interfaces, you have three options:</p>
<ul>
<li>You can easily use the generic, native dialogues and menus through the
API. This is good for confirmation dialogues and other basic user inputs.</li>
<li>You can also open a webview from inside a Python script, then use HTML5
for the user interface. When you use webviews from Python, you can pass
messages back and forth, between the webview and the Python process that
spawned it. The UI will not be native, but it is still a good option to
have.</li>
<li>There is <em>some</em> support for native Android user interfaces, but I am not
sure how well it works; I just haven't ever used it.</li>
</ul>
<p>You can mix options, so you can have a webview for the main interface, and still use native dialogues.</p>
<h3>QPython</h3>
<p>There is a third party project named <a href="http://qpython.com" rel="nofollow">QPython</a>. It builds on SL4A, and throws in some other useful stuff.</p>
<p>QPython gives you a nicer UI to manage your installation, and includes a little, touchscreen code editor, a Python shell, and a PIP shell for package management. They also have a Python 3 port. Both versions are available from the Play Store, free of charge. QPython also bundles libraries from a bunch of Python on Android projects, including Kivy, so it is not just SL4A.</p>
<p>Note that QPython still develop their fork of SL4A (though, not much to be honest). The main SL4A project itself is pretty much dead.</p>
<hr>
<ul>
<li>SL4A Project (now on GitHub): <a href="https://github.com/damonkohler/sl4a" rel="nofollow">https://github.com/damonkohler/sl4a</a></li>
<li>SL4A Python 3 Port: <a href="https://code.google.com/p/python-for-android/wiki/Python3" rel="nofollow">https://code.google.com/p/python-for-android/wiki/Python3</a></li>
<li>QPython Project: <a href="http://qpython.com" rel="nofollow">http://qpython.com</a></li>
</ul>
| 34 | 2012-03-19T15:45:27Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 10,519,481 | <p>Yet another attempt: <a href="https://code.google.com/p/android-python27/">https://code.google.com/p/android-python27/</a></p>
<p>This one embed directly the Python interpretter in your app apk.</p>
| 12 | 2012-05-09T15:44:49Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 15,335,213 | <p>You can run your Python code using <a href="http://code.google.com/p/android-scripting/">sl4a</a>. sl4a supports Python, <a href="http://en.wikipedia.org/wiki/Perl">Perl</a>, <a href="http://en.wikipedia.org/wiki/JRuby">JRuby</a>, <a href="http://en.wikipedia.org/wiki/Lua_%28programming_language%29">Lua</a>, BeanShell, JavaScript, <a href="http://en.wikipedia.org/wiki/Tcl">Tcl</a>, and shell script.</p>
<p>You can learn sl4a <a href="http://code.google.com/p/android-scripting/wiki/Tutorials">Python Examples</a>.</p>
| 8 | 2013-03-11T09:36:58Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 17,073,989 | <p>I use the QPython application. It has an editor, a console, and you can run your Python programs with it. The application is free, and the link is <a href="http://qpython.com/">http://qpython.com/</a>.</p>
| 14 | 2013-06-12T19:46:35Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 26,219,028 | <p>Didn't see this posted here, but you can do it with Pyside and Qt now that Qt works on Android thanks to Necessitas.</p>
<p>It seems like quite a kludge at the moment but could be a viable route eventually...</p>
<p><a href="http://qt-project.org/wiki/PySide_for_Android_guide" rel="nofollow">http://qt-project.org/wiki/PySide_for_Android_guide</a></p>
| 4 | 2014-10-06T14:59:14Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 27,271,274 | <p>While there is one book called <strong><em>Developing Android on Android</em></strong>, of which introduce how to develop apps on the Android device by using the Python language, and this book should be a good start for you.</p>
| 0 | 2014-12-03T12:00:59Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 27,913,916 | <h1>Kivy</h1>
<hr>
<p>I want to post this as an extension to what <strong>@JohnMudd</strong> has already answered (<em>but please bare with me as English isn't my first language</em>)</p>
<p>It has been years since then, and <strong>Kivy</strong> has also <em>evoluted</em> to <strong>v1.9-dev</strong>, the biggest selling point of <strong>Kivy</strong> in my opinion is its cross-platform compatibility, you can code and test under your local environment <strong>(Windows/*nix etc.)</strong>, you can also build, debug and package your app to run in your <strong>Android/iOS/Mac/Windows</strong> devices.</p>
<p>With <strong>Kivy</strong>'s own <strong><a href="http://kivy.org/docs/guide/lang.html#kv-language">KV</a></strong> language, one can easily code and build the GUI interface easily (it's just like Java XML, but rather than TextView etc., <strong>KV</strong> has its own <strong>ui.widgets</strong> for the similar translation), which is in my opinion quite easy to adopt.</p>
<p>Currently <strong><a href="https://github.com/kivy/buildozer">Buildozer</a></strong> and <strong><a href="http://python-for-android.readthedocs.org/en/latest/prerequisites/">python-for-android</a></strong> are most recommended tools to build/package your apps. Having tried them both and I can firmly say that they make building Android apps with Python a breeze. Users who feel comfortable in their console/terminal/command prompt should have no problems using them, and their guides are well documented, too.</p>
<p>Futhermore, <strong>iOS</strong> is another big selling point of Kivy, provided that you can use the same code base with little changes required to test-run on your <strong>iOS</strong> device, via <a href="http://kivy.org/docs/guide/packaging-ios.html#create-a-package-for-ios">kivy-ios</a> Homebrew tools, although <strong>Xcode</strong> are required for the build before running on their devices (AFAIK iOS Simulator in Xcode currently doesn't work for the x86-architecture build). There are also some dependency issues which required manually compiled and fiddled around in Xcode to have a successful build, but wouldn't be too difficult to resolve and people in <a href="https://groups.google.com/forum/#!forum/kivy-users">Kivy Google Group</a> are really helpful too.</p>
<p>With all being said, users with good Python knowledge should have no problem picking up the basics in weeks (if not days) to build some simple apps.</p>
<p>Also worth mentioning is that you can <strong>bundle (build recipes)</strong> your Python modules with the build so users can really make use of many existing libraries Python bring us, like <a href="http://docs.python-requests.org/en/latest/">Requests</a> & <a href="http://www.pythonware.com/products/pil/">PIL</a> etc. through <a href="http://kivy.org/docs/api-kivy.ext.html#module-kivy.ext">Kivy's extension support</a>.</p>
<blockquote>
<p>Sometimes your application requires functionality that is beyond the
scope of what Kivy can deliver. In those cases it is necessary to
resort to external software libraries. Given the richness of the
Python ecosystem, there is already a great number of software
libraries that you can simply import and use right away.</p>
</blockquote>
<p>The last but no the least, if you are going to use <strong>Kivy</strong> for more serious/commercial projects, you may find existing modules not satisfactory to what are expected. There are some workable solutions too, with the "work in progress" of <strong><a href="https://github.com/kivy/pyjnius">pyjnius</a></strong> for Andoird, and <strong><a href="https://github.com/kivy/pyobjus">pyobjus</a></strong>, users can now access to Java/Objective-C classes through those modules to control some of the native APIs.</p>
<p>My experience in Kivy is that it will find its best fit with seasonal Python programmers and some serious programmer who wants rapid development or simple code base maintenance. It runs well in multiple platforms, albeit not really at the level of <strong>native</strong> feeling. </p>
<p><strong>I do hope more Python/app programmers find my little information useful and start taking a look of Kivy, it can only get better (with more supports and libraries/modules get ported) if there are great interests from the community.</strong></p>
<p><em>P.S.I have no relationship with Kivy whatsoever, I'm merely a programmer who really likes the idea of bringing Python coding fun to mobile/cross-platform development.</em></p>
| 13 | 2015-01-13T02:08:57Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 28,719,773 | <p>Another option if you are looking for 3.4.2 or 3.5.1 is this archive on GitHub. </p>
<p><a href="https://github.com/rave-engine/python3-android" rel="nofollow">Python3-Android 3.4.2</a> or <a href="https://github.com/GRRedWings/python3-android" rel="nofollow">Python3-Android 3.5.1</a></p>
<p>It currently supports Python 3.4.2 or 3.5.1 and the 10d version of the NDK. It can also support 3.3 and 9c, 11c and 12</p>
<p>It's nice in that you simply download it, run make and you get the .so or the .a</p>
<p>I currently use this to run raw Python on android devices. With a couple modifications to the build files you can also make x86 and armeabi 64 bit</p>
| 4 | 2015-02-25T13:04:47Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 30,294,060 | <p>One more option seems to be <a href="http://pyqt.sourceforge.net/Docs/pyqtdeploy/index.html" rel="nofollow">pyqtdeploy</a> which citing the docs is:</p>
<blockquote>
<p>a tool that, in conjunction with other tools provided with Qt, enables
the deployment of PyQt4 and PyQt5 applications written with Python
v2.7 or Python v3.3 or later. It supports deployment to desktop
platforms (Linux, Windows and OS X) and to mobile platforms (iOS and
Android).</p>
</blockquote>
<p>According to <a href="http://stackoverflow.com/questions/24239684/deploying-pyqt5-application-to-android-via-pyqtdeploy-and-qt5">Deploying PyQt5 application to Android via pyqtdeploy and Qt5</a> it is actively developed, although it is difficult to find examples of working Android apps or tutorial on how to cross-compile all the required libraries to Android. It is an interesting project to keep in mind though!</p>
| 1 | 2015-05-18T01:56:41Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Is there a way to run Python on Android? | 101,754 | <p>We are working on an <a href="http://en.wikipedia.org/wiki/S60_%28software_platform%29">S60</a> version and this platform has a nice Python API. </p>
<p>However, there is nothing official about Python on Android, but since <a href="http://en.wikipedia.org/wiki/Jython">Jython</a> exists, is there a way to let the snake and the robot work together?</p>
| 1,360 | 2008-09-19T13:21:12Z | 39,523,019 | <p>You can use <strong>QPython</strong>:</p>
<p>It has a Python Console, Editor, as well as Package Management / Installers</p>
<p><a href="http://qpython.com/" rel="nofollow">http://qpython.com/</a></p>
<p>It's an open source project with both Python 2 and Python 3 implementations. You can download the source and the Android .apk files directly from github.</p>
<p>QPython 2: <a href="https://github.com/qpython-android/qpython/releases" rel="nofollow">https://github.com/qpython-android/qpython/releases</a></p>
<p>QPython 3: <a href="https://github.com/qpython-android/qpython3/releases" rel="nofollow">https://github.com/qpython-android/qpython3/releases</a></p>
| 0 | 2016-09-16T02:41:18Z | [
"python",
"android",
"ase",
"android-scripting"
] |
Sorting a dict on __iter__ | 102,394 | <p>I am trying to sort a dict based on its key and return an iterator to the values from within an overridden iter method in a class. Is there a nicer and more efficient way of doing this than creating a new list, inserting into the list as I sort through the keys?</p>
| 4 | 2008-09-19T14:43:24Z | 102,438 | <p>By far the easiest approach, and almost certainly the fastest, is something along the lines of:</p>
<pre><code>def sorted_dict(d):
keys = d.keys()
keys.sort()
for key in keys:
yield d[key]
</code></pre>
<p>You can't sort without fetching all keys. Fetching all keys into a list and then sorting that list is the most efficient way to do that; list sorting is very fast, and fetching the keys list like that is as fast as it can be. You can then either create a new list of values or yield the values as the example does. Keep in mind that you can't modify the dict if you are iterating over it (the next iteration would fail) so if you want to modify the dict before you're done with the result of sorted_dict(), make it return a list.</p>
| 2 | 2008-09-19T14:48:21Z | [
"python",
"optimization",
"refactoring"
] |
Sorting a dict on __iter__ | 102,394 | <p>I am trying to sort a dict based on its key and return an iterator to the values from within an overridden iter method in a class. Is there a nicer and more efficient way of doing this than creating a new list, inserting into the list as I sort through the keys?</p>
| 4 | 2008-09-19T14:43:24Z | 102,443 | <p>How about something like this:</p>
<pre><code>def itersorted(d):
for key in sorted(d):
yield d[key]
</code></pre>
| 8 | 2008-09-19T14:49:06Z | [
"python",
"optimization",
"refactoring"
] |
Sorting a dict on __iter__ | 102,394 | <p>I am trying to sort a dict based on its key and return an iterator to the values from within an overridden iter method in a class. Is there a nicer and more efficient way of doing this than creating a new list, inserting into the list as I sort through the keys?</p>
| 4 | 2008-09-19T14:43:24Z | 102,480 | <p>Assuming you want a default sort order, you can used sorted(list) or list.sort(). If you want your own sort logic, Python lists support the ability to sort based on a function you pass in. For example, the following would be a way to sort numbers from least to greatest (the default behavior) using a function. </p>
<pre><code>def compareTwo(a, b):
if a > b:
return 1
if a == b:
return 0
if a < b:
return -1
List.Sort(compareTwo)
print a
</code></pre>
<p>This approach is conceptually a bit cleaner than manually creating a new list and appending the new values and allows you to control the sort logic.</p>
| -1 | 2008-09-19T14:53:03Z | [
"python",
"optimization",
"refactoring"
] |
Sorting a dict on __iter__ | 102,394 | <p>I am trying to sort a dict based on its key and return an iterator to the values from within an overridden iter method in a class. Is there a nicer and more efficient way of doing this than creating a new list, inserting into the list as I sort through the keys?</p>
| 4 | 2008-09-19T14:43:24Z | 103,187 | <pre><code>def sortedDict(dictobj):
return (value for key, value in sorted(dictobj.iteritems()))
</code></pre>
<p>This will create a single intermediate list, the 'sorted()' method returns a real list. But at least it's only one.</p>
| 2 | 2008-09-19T15:54:47Z | [
"python",
"optimization",
"refactoring"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 102,612 | <p>See the "Motivation" section in <a href="http://www.python.org/dev/peps/pep-0255/">PEP 255</a>.</p>
<p>A non-obvious use of generators is creating interruptible functions, which lets you do things like update UI or run several jobs "simultaneously" (interleaved, actually) while not using threads.</p>
| 34 | 2008-09-19T15:07:13Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 102,632 | <p>Generators give you lazy evaluation. You use them by iterating over them, either explicitly with 'for' or implicitly by passing it to any function or construct that iterates. You can think of generators as returning multiple items, as if they return a list, but instead of returning them all at once they return them one-by-one, and the generator function is paused until the next item is requested.</p>
<p>Generators are good for calculating large sets of results (in particular calculations involving loops themselves) where you don't know if you are going to need all results, or where you don't want to allocate the memory for all results at the same time. Or for situations where the generator uses <em>another</em> generator, or consumes some other resource, and it's more convenient if that happened as late as possible.</p>
<p>Another use for generators (that is really the same) is to replace callbacks with iteration. In some situations you want a function to do a lot of work and occasionally report back to the caller. Traditionally you'd use a callback function for this. You pass this callback to the work-function and it would periodically call this callback. The generator approach is that the work-function (now a generator) knows nothing about the callback, and merely yields whenever it wants to report something. The caller, instead of writing a separate callback and passing that to the work-function, does all the reporting work in a little 'for' loop around the generator.</p>
<p>For example, say you wrote a 'filesystem search' program. You could perform the search in its entirety, collect the results and then display them one at a time. All of the results would have to be collected before you showed the first, and all of the results would be in memory at the same time. Or you could display the results while you find them, which would be more memory efficient and much friendlier towards the user. The latter could be done by passing the result-printing function to the filesystem-search function, or it could be done by just making the search function a generator and iterating over the result.</p>
<p>If you want to see an example of the latter two approaches, see os.path.walk() (the old filesystem-walking function with callback) and os.walk() (the new filesystem-walking generator.) Of course, if you really wanted to collect all results in a list, the generator approach is trivial to convert to the big-list approach:</p>
<pre><code>big_list = list(the_generator)
</code></pre>
| 183 | 2008-09-19T15:09:25Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 102,633 | <p>Basically avoiding call-back functions when iterating over input maintaining state.</p>
<p>See <a href="http://www.python.org/dev/peps/pep-0255/">here</a> and <a href="http://www.dabeaz.com/generators/index.html">here</a> for an overview of what can be done using generators.</p>
| 6 | 2008-09-19T15:09:26Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 102,634 | <p>One of the reasons to use generator is to make the solution clearer for some kind of solutions.</p>
<p>The other is to treat results one at a time, avoiding building huge lists of results that you would process separated anyway. </p>
<p>If you have a fibonacci-up-to-n function like this:</p>
<pre><code># function version
def fibon(n):
a = b = 1
result = []
for i in xrange(n):
result.append(a)
a, b = b, a + b
return result
</code></pre>
<p>You can more easily write the function as this:</p>
<pre><code># generator version
def fibon(n):
a = b = 1
for i in xrange(n):
yield a
a, b = b, a + b
</code></pre>
<p>The function is clearer. And if you use the function like this:</p>
<pre><code>for x in fibon(1000000):
print x,
</code></pre>
<p>in this example, if using the generator version, the whole 1000000 item list won't be created at all, just one value at a time. That would not be the case when using the list version, where a list would be created first.</p>
| 71 | 2008-09-19T15:09:28Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 102,667 | <p>My favorite uses are "filter" and "reduce" operations.</p>
<p>Let's say we're reading a file, and only want the lines which begin with "##".</p>
<pre><code>def filter2sharps( aSequence ):
for l in aSequence:
if l.startswith("##"):
yield l
</code></pre>
<p>We can then use the generator function in a proper loop</p>
<pre><code>source= file( ... )
for line in filter2sharps( source.readlines() ):
print line
source.close()
</code></pre>
<p>The reduce example is similar. Let's say we have a file where we need to locate blocks of <code><Location>...</Location></code> lines. [Not HTML tags, but lines that happen to look tag-like.]</p>
<pre><code>def reduceLocation( aSequence ):
keep= False
block= None
for line in aSequence:
if line.startswith("</Location"):
block.append( line )
yield block
block= None
keep= False
elif line.startsWith("<Location"):
block= [ line ]
keep= True
elif keep:
block.append( line )
else:
pass
if block is not None:
yield block # A partial block, icky
</code></pre>
<p>Again, we can use this generator in a proper for loop.</p>
<pre><code>source = file( ... )
for b in reduceLocation( source.readlines() ):
print b
source.close()
</code></pre>
<p>The idea is that a generator function allows us to filter or reduce a sequence, producing a another sequence one value at a time.</p>
| 12 | 2008-09-19T15:13:16Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 102,674 | <p>Buffering. When it is efficient to fetch data in large chunks, but process it in small chunks, then a generator might help:</p>
<pre><code>def bufferedFetch():
while True:
buffer = getBigChunkOfData()
# insert some code to break on 'end of data'
for i in buffer:
yield i
</code></pre>
<p>The above lets you easily separate buffering from processing. The consumer function can now just get the values one by one without worrying about buffering.</p>
| 26 | 2008-09-19T15:14:10Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 102,679 | <p>Piles of stuff. Any time you want to generate a sequence of items, but don't want to have to 'materialize' them all into a list at once. For example, you could have a simple generator that returns prime numbers:</p>
<pre><code>def primes():
primes_found = set()
primes_found.add(2)
yield 2
for i in itertools.count(1):
candidate = i * 2 + 1
if not all(candidate % prime for prime in primes_found):
primes_found.add(candidate)
yield candidate
</code></pre>
<p>You could then use that to generate the products of subsequent primes:</p>
<pre><code>def prime_products():
primeiter = primes()
prev = primeiter.next()
for prime in primeiter:
yield prime * prev
prev = prime
</code></pre>
<p>These are fairly trivial examples, but you can see how it can be useful for processing large (potentially infinite!) datasets without generating them in advance, which is only one of the more obvious uses.</p>
| 1 | 2008-09-19T15:14:43Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 102,682 | <p>The simple explanation:
Consider a <code>for</code> statement</p>
<pre><code>for item in iterable:
do_stuff()
</code></pre>
<p>A lot of the time, all the items in <code>iterable</code> doesn't need to be there from the start, but can be generated on the fly as they're required. This can be a lot more efficient in both </p>
<ul>
<li>space (you never need to store all the items simultaneously) and </li>
<li>time (the iteration may finish before all the items are needed).</li>
</ul>
<p>Other times, you don't even know all the items ahead of time. For example:</p>
<pre><code>for command in user_input():
do_stuff_with(command)
</code></pre>
<p>You have no way of knowing all the user's commands beforehand, but you can use a nice loop like this if you have a generator handing you commands:</p>
<pre><code>def user_input():
while True:
wait_for_command()
cmd = get_command()
yield cmd
</code></pre>
<p>With generators you can also have iteration over infinite sequences, which is of course not possible when iterating over containers.</p>
| 17 | 2008-09-19T15:15:03Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 102,701 | <p>I use generators when our web server is acting as a proxy:</p>
<ol>
<li>The client requests a proxied url from the server</li>
<li>The server begins to load the target url</li>
<li>The server yields to return the results to the client as soon as it gets them</li>
</ol>
| 2 | 2008-09-19T15:17:51Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 740,763 | <p>I have found that generators are very helpful in cleaning up your code and by giving you a very unique way to encapsulate and modularize code. In a situation where you need something to constantly spit out values based on its own internal processing and when that something needs to be called from anywhere in your code (and not just within a loop or a block for example), generators are <em>the</em> feature to use.</p>
<p>An abstract example would be a fibonacci number generator that does not live within a loop and when it is called from anywhere will always return the next number in sequence:</p>
<pre><code>def fib():
first=0
second=1
yield first
yield second
while 1:
next=first+second
yield next
first=second
second=next
fibgen1=fib()
fibgen2=fib()
</code></pre>
<p>Now you have two fibonacci number generator objects which you can call from anywhere in your code and they will always return ever larger fibonacci numbers in sequence as follows:</p>
<pre><code>>>> fibgen1.next(); fibgen1.next(); fibgen1.next(); fibgen1.next()
0
1
1
2
>>> fibgen2.next(); fibgen2.next()
0
1
>>> fibgen1.next(); fibgen1.next()
3
5
</code></pre>
<p>The lovely thing about generators is that they encapsulate state without having to go through the hoops of creating objects. One way of thinking about them is as "functions" which remember their internal state.</p>
<p>I got the fibonacci example from <a href="http://www.neotitans.com/resources/python/python-generators-tutorial.html" rel="nofollow">http://www.neotitans.com/resources/python/python-generators-tutorial.html</a> and with a little imagination, you can come up with a lot of other situations where generators make for a great alternative to for-loops and other traditional iteration constructs.</p>
| 17 | 2009-04-11T20:55:59Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 14,394,854 | <p>I find this explanation which clears my doubt. Because there is a possibility that person who don't know <code>Generators</code> also don't know about <code>yield</code></p>
<p><strong>Return</strong></p>
<p>The return statement is where all the local variables are destroyed and the resulting value is given back (returned) to the caller. Should the same function be called some time later, the function will get a fresh new set of variables.</p>
<p><strong>Yield</strong></p>
<p>But what if the local variables aren't thrown away when we exit a function? This implies that we can <code>resume the function</code> where we left off. This is where the concept of <code>generators</code> are introduced and the <code>yield</code> statement resumes where the <code>function</code> left off.</p>
<pre><code> def generate_integers(N):
for i in range(N):
yield i
</code></pre>
<hr>
<pre><code> In [1]: gen = generate_integers(3)
In [2]: gen
<generator object at 0x8117f90>
In [3]: gen.next()
0
In [4]: gen.next()
1
In [5]: gen.next()
</code></pre>
<p>So that's the difference between return and yield statements in Python. </p>
<p><strong>Yield statement is what makes a function a generator function.</strong></p>
<p>So Generators are a simple and powerful tool for creating iterators. They are written like regular functions but use the yield statement whenever they want to return data. Each time next() is called, the generator resumes where it left-off (it remembers all the data values and which statement was last executed).</p>
| 22 | 2013-01-18T08:17:56Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 23,334,878 | <p>Since the send method of a generator has not been mentioned here is an example:</p>
<pre><code>def test():
for i in xrange(5):
val = yield
print(val)
t = test()
# proceed to yield statement
next(t)
# send value to yield
t.send(1)
t.send('2')
t.send([3])
</code></pre>
<p>It shows the possibility to send a value to a running generator
A more advanced course on generators in the video below (including yield from explination, generators for parallel processing, escaping recursion limit etc.)</p>
<p><a href="http://pyvideo.org/video/2575/generators-the-final-frontier" rel="nofollow">David Beazley on generators at PyCon 2014</a></p>
| 2 | 2014-04-28T07:21:10Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 23,530,101 | <h2>Real World Example</h2>
<p>Lets say you have 100 million domains in your MySQL table and you would like to update alexa rank for each domain.</p>
<p>First thing you need is to select your domain names from the database. </p>
<p>Lets say your database name is <code>domains</code> and table name is <code>domain</code></p>
<p>If you use <code>SELECT domain FROM domains</code> its going to return 100 million rows which is going to consume lot of memory. So your server might crash</p>
<p>So you decided to run the program in batches. Let say our batch size is 1000.</p>
<p>In our first batch we will query the first 1000 rows, check alexa rank for each domain and update the database row. </p>
<p>In our second batch we will work on the next 1000 rows. In our third batch it will be from 2001 to 3000 and so on.</p>
<p>Now we need a generator function which generates our batches. </p>
<p>Here is our generator function</p>
<pre><code>def ResultGenerator(cursor, batchsize=1000):
while True:
results = cursor.fetchmany(batchsize)
if not results:
break
for result in results:
yield result
</code></pre>
<p>As you can see our function keep <code>yield</code>ing the results. If you used the keyword <code>return</code> instead of <code>yield</code>, then the whole function will be ended once it reaches return</p>
<pre><code>return - returns only once
yield - returns multiple times
</code></pre>
<p>If a function uses the keyword <code>yield</code> then its a generator.</p>
<p>Now you can iterate like this</p>
<pre><code>db = MySQLdb.connect(host="localhost", user="root", passwd="root", db="domains")
cursor = db.cursor()
cursor.execute("SELECT domain FROM domains")
for result in ResultGenerator(cursor):
doSomethingWith(result)
db.close()
</code></pre>
| 17 | 2014-05-07T23:20:11Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 26,074,771 | <p>A practical example where you could make use of a generator is if you have some kind of shape and you want to iterate over its corners, edges or whatever. For my own project (source code <a href="https://github.com/Pithikos/python-rectangles">here</a>) I had a rectangle:</p>
<pre><code>class Rect():
def __init__(self, x, y, width, height):
self.l_top = (x, y)
self.r_top = (x+width, y)
self.r_bot = (x+width, y+height)
self.l_bot = (x, y+height)
def __iter__(self):
yield self.l_top
yield self.r_top
yield self.r_bot
yield self.l_bot
</code></pre>
<p>Now I can create a rectangle and loop over its corners:</p>
<pre><code>myrect=Rect(50, 50, 100, 100)
for corner in myrect:
print(corner)
</code></pre>
<p>Instead of <code>__iter__</code> you could have a method <code>iter_corners</code> and call that with <code>for corner in myrect.iter_corners()</code>. It's just more elegant to use <code>__iter__</code> since then we can use the class instance name directly in the <code>for</code> expression.</p>
| 7 | 2014-09-27T12:40:27Z | [
"python",
"generator"
] |
What can you use Python generator functions for? | 102,535 | <p>I'm starting to learn Python and I've come across generator functions, those that have a yield statement in them. I want to know what types of problems that these functions are really good at solving.</p>
| 157 | 2008-09-19T14:58:49Z | 29,079,078 | <p>Some good answers here, however, I'd also recommend a complete read of the python <a href="https://docs.python.org/dev/howto/functional.html" rel="nofollow">Functional Programming tutorial</a> which helps explain some of the more potent use-cases of generators.</p>
<ul>
<li>Particularly interesting is that it is now possible to <a href="https://docs.python.org/dev/howto/functional.html#passing-values-into-a-generator" rel="nofollow">update the yield variable from outside the generator function</a>, hence making it possible to create dynamic and interwoven coroutines with relatively little effort.</li>
<li>Also see <a href="https://www.python.org/dev/peps/pep-0342/" rel="nofollow">PEP 342: Coroutines via Enhanced Generators</a> for more information.</li>
</ul>
| 4 | 2015-03-16T14:17:35Z | [
"python",
"generator"
] |
How do I merge a 2D array in Python into one string with List Comprehension? | 103,844 | <p>List Comprehension for me seems to be like the opaque block of granite that regular expressions are for me. I need pointers.</p>
<p>Say, I have a 2D list:</p>
<pre><code>li = [[0,1,2],[3,4,5],[6,7,8]]
</code></pre>
<p>I would like to merge this either into one long list</p>
<pre><code>li2 = [0,1,2,3,4,5,6,7,8]
</code></pre>
<p>or into a string with separators:</p>
<pre><code>s = "0,1,2,3,4,5,6,7,8"
</code></pre>
<p>Really, I'd like to know how to do both.</p>
| 14 | 2008-09-19T17:21:53Z | 103,873 | <pre><code>import itertools
itertools.flatten( li )
</code></pre>
| -1 | 2008-09-19T17:24:56Z | [
"python",
"list-comprehension"
] |
How do I merge a 2D array in Python into one string with List Comprehension? | 103,844 | <p>List Comprehension for me seems to be like the opaque block of granite that regular expressions are for me. I need pointers.</p>
<p>Say, I have a 2D list:</p>
<pre><code>li = [[0,1,2],[3,4,5],[6,7,8]]
</code></pre>
<p>I would like to merge this either into one long list</p>
<pre><code>li2 = [0,1,2,3,4,5,6,7,8]
</code></pre>
<p>or into a string with separators:</p>
<pre><code>s = "0,1,2,3,4,5,6,7,8"
</code></pre>
<p>Really, I'd like to know how to do both.</p>
| 14 | 2008-09-19T17:21:53Z | 103,883 | <p>To make it a flattened list use either:</p>
<ol>
<li><a href="http://code.activestate.com/recipes/121294/" rel="nofollow">http://code.activestate.com/recipes/121294/</a></li>
<li><a href="http://code.activestate.com/recipes/363051/" rel="nofollow">http://code.activestate.com/recipes/363051/</a></li>
</ol>
<p>Then, <code>join</code> to make it a string.</p>
| 0 | 2008-09-19T17:26:44Z | [
"python",
"list-comprehension"
] |
How do I merge a 2D array in Python into one string with List Comprehension? | 103,844 | <p>List Comprehension for me seems to be like the opaque block of granite that regular expressions are for me. I need pointers.</p>
<p>Say, I have a 2D list:</p>
<pre><code>li = [[0,1,2],[3,4,5],[6,7,8]]
</code></pre>
<p>I would like to merge this either into one long list</p>
<pre><code>li2 = [0,1,2,3,4,5,6,7,8]
</code></pre>
<p>or into a string with separators:</p>
<pre><code>s = "0,1,2,3,4,5,6,7,8"
</code></pre>
<p>Really, I'd like to know how to do both.</p>
| 14 | 2008-09-19T17:21:53Z | 103,886 | <p>There's a couple choices. First, you can just create a new list and add the contents of each list to it:</p>
<pre><code>li2 = []
for sublist in li:
li2.extend(sublist)
</code></pre>
<p>Alternately, you can use the <code>itertools</code> module's <code>chain</code> function, which produces an iterable containing all the items in multiple iterables:</p>
<pre><code>import itertools
li2 = list(itertools.chain(*li))
</code></pre>
<p>If you take this approach, you can produce the string without creating an intermediate list:</p>
<pre><code>s = ",".join(itertools.chain(*li))
</code></pre>
| 5 | 2008-09-19T17:26:51Z | [
"python",
"list-comprehension"
] |
How do I merge a 2D array in Python into one string with List Comprehension? | 103,844 | <p>List Comprehension for me seems to be like the opaque block of granite that regular expressions are for me. I need pointers.</p>
<p>Say, I have a 2D list:</p>
<pre><code>li = [[0,1,2],[3,4,5],[6,7,8]]
</code></pre>
<p>I would like to merge this either into one long list</p>
<pre><code>li2 = [0,1,2,3,4,5,6,7,8]
</code></pre>
<p>or into a string with separators:</p>
<pre><code>s = "0,1,2,3,4,5,6,7,8"
</code></pre>
<p>Really, I'd like to know how to do both.</p>
| 14 | 2008-09-19T17:21:53Z | 103,887 | <p>For the second one, there is a built-in string method to do that :</p>
<pre><code>>>> print ','.join(str(x) for x in li2)
"0,1,2,3,4,5,6,7,8"
</code></pre>
<p>For the first one, you can use join within a comprehension list :</p>
<pre><code>>>> print ",".join([",".join(str(x) for x in li])
"0,1,2,3,4,5,6,7,8"
</code></pre>
<p>But it's easier to use itertools.flatten :</p>
<pre><code>>>> import itertools
>>> print itertools.flatten(li)
[0,1,2,3,4,5,6,7,8]
>>> print ",".join(str(x) for x in itertools.flatten(li))
"0,1,2,3,4,5,6,7,8"
</code></pre>
<p>N.B : itertools is a module that help you to deal with common tasks with iterators such as list, tuples or string... It's handy because it does not store a copy of the structure you're working on but process the items one by one.</p>
<p>EDIT : funny, I am learning plenty of way to do it. Who said that there was only one good way to do it ?</p>
| 0 | 2008-09-19T17:26:52Z | [
"python",
"list-comprehension"
] |
How do I merge a 2D array in Python into one string with List Comprehension? | 103,844 | <p>List Comprehension for me seems to be like the opaque block of granite that regular expressions are for me. I need pointers.</p>
<p>Say, I have a 2D list:</p>
<pre><code>li = [[0,1,2],[3,4,5],[6,7,8]]
</code></pre>
<p>I would like to merge this either into one long list</p>
<pre><code>li2 = [0,1,2,3,4,5,6,7,8]
</code></pre>
<p>or into a string with separators:</p>
<pre><code>s = "0,1,2,3,4,5,6,7,8"
</code></pre>
<p>Really, I'd like to know how to do both.</p>
| 14 | 2008-09-19T17:21:53Z | 103,890 | <p>My favorite, and the shortest one, is this:</p>
<pre><code>li2 = sum(li, [])
</code></pre>
<p>and</p>
<pre><code>s = ','.join(li2)
</code></pre>
<p>EDIT: use <code>sum</code> instead of <code>reduce</code>, (thanks <a href="http://stackoverflow.com/users/17624/thomas-wouters">Thomas Wouters</a>!)</p>
| 5 | 2008-09-19T17:27:43Z | [
"python",
"list-comprehension"
] |
How do I merge a 2D array in Python into one string with List Comprehension? | 103,844 | <p>List Comprehension for me seems to be like the opaque block of granite that regular expressions are for me. I need pointers.</p>
<p>Say, I have a 2D list:</p>
<pre><code>li = [[0,1,2],[3,4,5],[6,7,8]]
</code></pre>
<p>I would like to merge this either into one long list</p>
<pre><code>li2 = [0,1,2,3,4,5,6,7,8]
</code></pre>
<p>or into a string with separators:</p>
<pre><code>s = "0,1,2,3,4,5,6,7,8"
</code></pre>
<p>Really, I'd like to know how to do both.</p>
| 14 | 2008-09-19T17:21:53Z | 103,895 | <p>Like so:</p>
<pre><code>[ item for innerlist in outerlist for item in innerlist ]
</code></pre>
<p>Turning that directly into a string with separators:</p>
<pre><code>','.join(str(item) for innerlist in outerlist for item in innerlist)
</code></pre>
<p>Yes, the order of 'for innerlist in outerlist' and 'for item in innerlist' is correct. Even though the "body" of the loop is at the start of the listcomp, the order of nested loops (and 'if' clauses) is still the same as when you would write the loop out:</p>
<pre><code>for innerlist in outerlist:
for item in innerlist:
...
</code></pre>
| 22 | 2008-09-19T17:28:14Z | [
"python",
"list-comprehension"
] |
How do I merge a 2D array in Python into one string with List Comprehension? | 103,844 | <p>List Comprehension for me seems to be like the opaque block of granite that regular expressions are for me. I need pointers.</p>
<p>Say, I have a 2D list:</p>
<pre><code>li = [[0,1,2],[3,4,5],[6,7,8]]
</code></pre>
<p>I would like to merge this either into one long list</p>
<pre><code>li2 = [0,1,2,3,4,5,6,7,8]
</code></pre>
<p>or into a string with separators:</p>
<pre><code>s = "0,1,2,3,4,5,6,7,8"
</code></pre>
<p>Really, I'd like to know how to do both.</p>
| 14 | 2008-09-19T17:21:53Z | 103,908 | <p>Try that:</p>
<pre><code>li=[[0,1,2],[3,4,5],[6,7,8]]
li2 = [ y for x in li for y in x]
</code></pre>
<p>You can read it like this:<br>
Give me the list of every ys.<br>
The ys come from the xs.<br>
The xs come from li.</p>
<p>To map that in a string:</p>
<pre><code>','.join(map(str,li2))
</code></pre>
| 6 | 2008-09-19T17:29:22Z | [
"python",
"list-comprehension"
] |
How do I merge a 2D array in Python into one string with List Comprehension? | 103,844 | <p>List Comprehension for me seems to be like the opaque block of granite that regular expressions are for me. I need pointers.</p>
<p>Say, I have a 2D list:</p>
<pre><code>li = [[0,1,2],[3,4,5],[6,7,8]]
</code></pre>
<p>I would like to merge this either into one long list</p>
<pre><code>li2 = [0,1,2,3,4,5,6,7,8]
</code></pre>
<p>or into a string with separators:</p>
<pre><code>s = "0,1,2,3,4,5,6,7,8"
</code></pre>
<p>Really, I'd like to know how to do both.</p>
| 14 | 2008-09-19T17:21:53Z | 244,477 | <p>There are many ways to do this problem. I like <a href="http://numpy.scipy.org/" rel="nofollow">Numpy</a>'s tools because it is normally already imported in everything I do. However, if you aren't using Numpy for anything else this probably isn't a good method.</p>
<pre><code>import numpy
li = [[0,1,2],[3,4,5],[6,7,8]]
li2=li[0] #first element of array to merge
i=1
while i<len(li):
li2=numpy.concatenate((li2,li[i]))
i+=1
print li2
</code></pre>
<p>This would print [0 1 2 3 4 5 6 7 8] and then you can convert this into your string too.</p>
| 0 | 2008-10-28T19:17:27Z | [
"python",
"list-comprehension"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 104,426 | <p>This solution implements a generator, to avoid holding all the permutations on memory:</p>
<pre><code>def permutations (orig_list):
if not isinstance(orig_list, list):
orig_list = list(orig_list)
yield orig_list
if len(orig_list) == 1:
return
for n in sorted(orig_list):
new_list = orig_list[:]
pos = new_list.index(n)
del(new_list[pos])
new_list.insert(0, n)
for resto in permutations(new_list[1:]):
if new_list[:1] + resto <> orig_list:
yield new_list[:1] + resto
</code></pre>
| 15 | 2008-09-19T18:41:52Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 104,436 | <p><strong>Starting with Python 2.6</strong> (and if you're on Python 3) you have a <strong>standard-library</strong> tool for this: <a href="https://docs.python.org/2/library/itertools.html#itertools.permutations"><code>itertools.permutations</code></a>.</p>
<hr>
<p>If you're using an <strong>older Python (<2.6)</strong> for some reason or are just curious to know how it works, here's one nice approach, taken from <a href="http://code.activestate.com/recipes/252178/">http://code.activestate.com/recipes/252178/</a>:</p>
<pre><code>def all_perms(elements):
if len(elements) <=1:
yield elements
else:
for perm in all_perms(elements[1:]):
for i in range(len(elements)):
# nb elements[0:1] works in both string and list contexts
yield perm[:i] + elements[0:1] + perm[i:]
</code></pre>
<p>A couple of alternative approaches are listed in the documentation of <code>itertools.permutations</code>. Here's one:</p>
<pre><code>def permutations(iterable, r=None):
# permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC
# permutations(range(3)) --> 012 021 102 120 201 210
pool = tuple(iterable)
n = len(pool)
r = n if r is None else r
if r > n:
return
indices = range(n)
cycles = range(n, n-r, -1)
yield tuple(pool[i] for i in indices[:r])
while n:
for i in reversed(range(r)):
cycles[i] -= 1
if cycles[i] == 0:
indices[i:] = indices[i+1:] + indices[i:i+1]
cycles[i] = n - i
else:
j = cycles[i]
indices[i], indices[-j] = indices[-j], indices[i]
yield tuple(pool[i] for i in indices[:r])
break
else:
return
</code></pre>
<p>And another, based on <code>itertools.product</code>:</p>
<pre><code>def permutations(iterable, r=None):
pool = tuple(iterable)
n = len(pool)
r = n if r is None else r
for indices in product(range(n), repeat=r):
if len(set(indices)) == r:
yield tuple(pool[i] for i in indices)
</code></pre>
| 190 | 2008-09-19T18:43:09Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 104,471 | <p>And in <a href="http://docs.python.org/dev/whatsnew/2.6.html">Python 2.6</a> onwards:</p>
<pre><code>import itertools
itertools.permutations([1,2,3])
</code></pre>
<p>(returned as a generator. Use <code>list(permutations(l))</code> to return as a list.)</p>
| 255 | 2008-09-19T18:48:48Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 105,774 | <p>Forgive my python illiteracy as I won't be offering the solution in python.
As I do not know what method python 2.6 uses to generate the permutations and eliben's one looks like Johnson-Trotter permutation generation, you might look for article
in Wikipedia on <a href="http://en.wikipedia.org/wiki/Permutation#Algorithms_to_generate_permutations" rel="nofollow">Permutations and their generation</a> that looks quite like unrank function in <a href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.43.4521" rel="nofollow">paper by Myrvold and Ruskey</a>.</p>
<p>It would seem to me that this could be used in a generator in the same way as in other replies to lessen the memory requirement considerably. Just remember that the permutations will not be in lexicographic order.</p>
| 2 | 2008-09-19T21:26:48Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 108,651 | <p>The following code is an in-place permutation of a given list, implemented as a generator. Since it only returns references to the list, the list should not be modified outside the generator.
The solution is non-recursive, so uses low memory. Work well also with multiple copies of elements in the input list.</p>
<pre><code>def permute_in_place(a):
a.sort()
yield list(a)
if len(a) <= 1:
return
first = 0
last = len(a)
while 1:
i = last - 1
while 1:
i = i - 1
if a[i] < a[i+1]:
j = last - 1
while not (a[i] < a[j]):
j = j - 1
a[i], a[j] = a[j], a[i] # swap the values
r = a[i+1:last]
r.reverse()
a[i+1:last] = r
yield list(a)
break
if i == first:
a.reverse()
return
if __name__ == '__main__':
for n in range(5):
for a in permute_in_place(range(1, n+1)):
print a
print
for a in permute_in_place([0, 0, 1, 1, 1]):
print a
print
</code></pre>
| 10 | 2008-09-20T16:32:47Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 170,248 | <p><em>The following code with Python 2.6 and above ONLY</em></p>
<p>First, import <code>itertools</code>:</p>
<pre><code>import itertools
</code></pre>
<h3>Permutation (order matters):</h3>
<pre><code>print list(itertools.permutations([1,2,3,4], 2))
[(1, 2), (1, 3), (1, 4),
(2, 1), (2, 3), (2, 4),
(3, 1), (3, 2), (3, 4),
(4, 1), (4, 2), (4, 3)]
</code></pre>
<h3>Combination (order does NOT matter):</h3>
<pre><code>print list(itertools.combinations('123', 2))
[('1', '2'), ('1', '3'), ('2', '3')]
</code></pre>
<h3>Cartesian product (with several iterables):</h3>
<pre><code>print list(itertools.product([1,2,3], [4,5,6]))
[(1, 4), (1, 5), (1, 6),
(2, 4), (2, 5), (2, 6),
(3, 4), (3, 5), (3, 6)]
</code></pre>
<h3>Cartesian product (with one iterable and itself):</h3>
<pre><code>print list(itertools.product([1,2], repeat=3))
[(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
(2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
</code></pre>
| 177 | 2008-10-04T12:18:56Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 5,501,066 | <p>A quite obvious way in my opinion might be also:</p>
<pre><code>def permutList(l):
if not l:
return [[]]
res = []
for e in l:
temp = l[:]
temp.remove(e)
res.extend([[e] + r for r in permutList(temp)])
return res
</code></pre>
| 8 | 2011-03-31T13:58:40Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 7,140,205 | <pre><code>list2Perm = [1, 2.0, 'three']
listPerm = [[a, b, c]
for a in list2Perm
for b in list2Perm
for c in list2Perm
if ( a != b and b != c and a != c )
]
print listPerm
</code></pre>
<p>Output:</p>
<pre><code>[
[1, 2.0, 'three'],
[1, 'three', 2.0],
[2.0, 1, 'three'],
[2.0, 'three', 1],
['three', 1, 2.0],
['three', 2.0, 1]
]
</code></pre>
| 7 | 2011-08-21T18:28:44Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 7,733,966 | <pre><code>def permutations(head, tail=''):
if len(head) == 0: print tail
else:
for i in range(len(head)):
permutations(head[0:i] + head[i+1:], tail+head[i])
</code></pre>
<p>called as:</p>
<pre><code>permutations('abc')
</code></pre>
| 23 | 2011-10-12T00:14:09Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 10,799,849 | <p>One can indeed iterate over the first element of each permutation, as in tzwenn's answer; I prefer to write this solution this way:</p>
<pre><code>def all_perms(elements):
if len(elements) <= 1:
yield elements # Only permutation possible = no permutation
else:
# Iteration over the first element in the result permutation:
for (index, first_elmt) in enumerate(elements):
other_elmts = elements[:index]+elements[index+1:]
for permutation in all_perms(other_elmts):
yield [first_elmt] + permutation
</code></pre>
<p>This solution is about 30Â % faster, apparently thanks to the recursion ending at <code>len(elements) <= 1</code> instead of <code>0</code>.
It is also much more memory-efficient, as it uses a generator function (<code>yield</code>), like in Riccardo Reyes's solution.</p>
| 4 | 2012-05-29T13:08:55Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 11,962,517 | <pre><code>#!/usr/bin/env python
def perm(a,k=0):
if(k==len(a)):
print a
else:
for i in xrange(k,len(a)):
a[k],a[i] = a[i],a[k]
perm(a, k+1)
a[k],a[i] = a[i],a[k]
perm([1,2,3])
</code></pre>
<p>Output:</p>
<pre><code>[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 2, 1]
[3, 1, 2]
</code></pre>
<p>As I'm swapping the content of the list it's required a mutable sequence type as input. E.g. <code>perm(list("ball"))</code> will work and <code>perm("ball")</code> won't because you can't change a string. </p>
<p>This Python implementation is inspired by the algorithm presented in the book <em>Computer Algorithms by Horowitz, Sahni and Rajasekeran</em>.</p>
| 11 | 2012-08-14T23:58:40Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 14,470,271 | <p>Note that this algorithm has an <code>n factorial</code> time complexity, where <code>n</code> is the length of the input list</p>
<p>Print the results on the run:</p>
<pre><code>global result
result = []
def permutation(li):
if li == [] or li == None:
return
if len(li) == 1:
result.append(li[0])
print result
result.pop()
return
for i in range(0,len(li)):
result.append(li[i])
permutation(li[:i] + li[i+1:])
result.pop()
</code></pre>
<p>Example: </p>
<pre><code>permutation([1,2,3])
</code></pre>
<p>Output:</p>
<pre><code>[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
| 5 | 2013-01-23T00:01:57Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 16,446,022 | <pre><code>from __future__ import print_function
def perm(n):
p = []
for i in range(0,n+1):
p.append(i)
while True:
for i in range(1,n+1):
print(p[i], end=' ')
print("")
i = n - 1
found = 0
while (not found and i>0):
if p[i]<p[i+1]:
found = 1
else:
i = i - 1
k = n
while p[i]>p[k]:
k = k - 1
aux = p[i]
p[i] = p[k]
p[k] = aux
for j in range(1,(n-i)/2+1):
aux = p[i+j]
p[i+j] = p[n-j+1]
p[n-j+1] = aux
if not found:
break
perm(5)
</code></pre>
| 1 | 2013-05-08T16:48:44Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 17,391,851 | <p>In a functional style</p>
<pre><code>def addperm(x,l):
return [ l[0:i] + [x] + l[i:] for i in range(len(l)+1) ]
def perm(l):
if len(l) == 0:
return [[]]
return [x for y in perm(l[1:]) for x in addperm(l[0],y) ]
print perm([ i for i in range(3)])
</code></pre>
<p>The result:</p>
<pre><code>[[0, 1, 2], [1, 0, 2], [1, 2, 0], [0, 2, 1], [2, 0, 1], [2, 1, 0]]
</code></pre>
| 7 | 2013-06-30T15:17:16Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 17,504,089 | <p>Here is an algorithm that works on a list without creating new intermediate lists similar to Ber's solution at <a href="http://stackoverflow.com/a/108651/184528">http://stackoverflow.com/a/108651/184528</a>. </p>
<pre><code>def permute(xs, low=0):
if low + 1 >= len(xs):
yield xs
else:
for p in permute(xs, low + 1):
yield p
for i in range(low + 1, len(xs)):
xs[low], xs[i] = xs[i], xs[low]
for p in permute(xs, low + 1):
yield p
xs[low], xs[i] = xs[i], xs[low]
for p in permute([1, 2, 3, 4]):
print p
</code></pre>
<p>You can try the code out for yourself here: <a href="http://repl.it/J9v" rel="nofollow">http://repl.it/J9v</a></p>
| 2 | 2013-07-06T14:56:16Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 18,135,428 | <p>I used an algorithm based on the <a href="http://en.wikipedia.org/wiki/Factorial_number_system" rel="nofollow">factorial number system</a>- For a list of length n, you can assemble each permutation item by item, selecting from the items left at each stage. You have n choices for the first item, n-1 for the second, and only one for the last, so you can use the digits of a number in the factorial number system as the indices. This way the numbers 0 through n!-1 correspond to all possible permutations in lexicographic order.</p>
<pre><code>from math import factorial
def permutations(l):
permutations=[]
length=len(l)
for x in xrange(factorial(length)):
available=list(l)
newPermutation=[]
for radix in xrange(length, 0, -1):
placeValue=factorial(radix-1)
index=x/placeValue
newPermutation.append(available.pop(index))
x-=index*placeValue
permutations.append(newPermutation)
return permutations
permutations(range(3))
</code></pre>
<p>output:</p>
<pre><code>[[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]
</code></pre>
<p>This method is non-recursive, but it is slightly slower on my computer and xrange raises an error when n! is too large to be converted to a C long integer (n=13 for me). It was enough when I needed it, but it's no itertools.permutations by a long shot.</p>
| 4 | 2013-08-08T20:23:50Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 20,014,561 | <p>This is inspired by the Haskell implementation using list comprehension: </p>
<pre><code>def permutation(list):
if len(list) == 0:
return [[]]
else:
return [[x] + ys for x in list for ys in permutation(delete(list, x))]
def delete(list, item):
lc = list[:]
lc.remove(item)
return lc
</code></pre>
| 0 | 2013-11-16T04:10:33Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 23,732,953 | <p>The beauty of recursion:</p>
<pre><code>>>> import copy
>>> def perm(prefix,rest):
... for e in rest:
... new_rest=copy.copy(rest)
... new_prefix=copy.copy(prefix)
... new_prefix.append(e)
... new_rest.remove(e)
... if len(new_rest) == 0:
... print new_prefix + new_rest
... continue
... perm(new_prefix,new_rest)
...
>>> perm([],['a','b','c','d'])
['a', 'b', 'c', 'd']
['a', 'b', 'd', 'c']
['a', 'c', 'b', 'd']
['a', 'c', 'd', 'b']
['a', 'd', 'b', 'c']
['a', 'd', 'c', 'b']
['b', 'a', 'c', 'd']
['b', 'a', 'd', 'c']
['b', 'c', 'a', 'd']
['b', 'c', 'd', 'a']
['b', 'd', 'a', 'c']
['b', 'd', 'c', 'a']
['c', 'a', 'b', 'd']
['c', 'a', 'd', 'b']
['c', 'b', 'a', 'd']
['c', 'b', 'd', 'a']
['c', 'd', 'a', 'b']
['c', 'd', 'b', 'a']
['d', 'a', 'b', 'c']
['d', 'a', 'c', 'b']
['d', 'b', 'a', 'c']
['d', 'b', 'c', 'a']
['d', 'c', 'a', 'b']
['d', 'c', 'b', 'a']
</code></pre>
| 0 | 2014-05-19T08:23:12Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 28,256,360 | <p>This algorithm is the most effective one, it avoids of array passing and manipulation in recursive calls, works in Python 2, 3:</p>
<pre><code>def permute(items):
length = len(items)
def inner(ix=[]):
do_yield = len(ix) == length - 1
for i in range(0, length):
if i in ix: #avoid duplicates
continue
if do_yield:
yield tuple([items[y] for y in ix + [i]])
else:
for p in inner(ix + [i]):
yield p
return inner()
</code></pre>
<p>Usage:</p>
<pre><code>for p in permute((1,2,3)):
print(p)
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)
</code></pre>
| 1 | 2015-01-31T20:46:34Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 30,112,080 | <pre><code>def pzip(c, seq):
result = []
for item in seq:
for i in range(len(item)+1):
result.append(item[i:]+c+item[:i])
return result
def perm(line):
seq = [c for c in line]
if len(seq) <=1 :
return seq
else:
return pzip(seq[0], perm(seq[1:]))
</code></pre>
| 1 | 2015-05-07T21:34:35Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 30,428,753 | <p>For performance, a numpy solution inspired by <a href="http://www.kcats.org/csci/464/doc/knuth/fascicles/fasc2b.pdf" rel="nofollow">Knuth</a>, (p22) :</p>
<pre><code>from numpy import empty, uint8
from math import factorial
def perms(n):
f = 1
p = empty((2*n-1, factorial(n)), uint8)
for i in range(n):
p[i, :f] = i
p[i+1:2*i+1, :f] = p[:i, :f] # constitution de blocs
for j in range(i):
p[:i+1, f*(j+1):f*(j+2)] = p[j+1:j+i+2, :f] # copie de blocs
f = f*(i+1)
return p[:n, :]
</code></pre>
<p>Copying large blocs of memory saves time -
it's 20x faster than <code>list(itertools.permutations(range(n))</code> :</p>
<pre><code>In [1]: %timeit -n10 list(permutations(range(10)))
10 loops, best of 3: 815 ms per loop
In [2]: %timeit -n100 perms(10)
100 loops, best of 3: 40 ms per loop
</code></pre>
| 3 | 2015-05-24T21:56:08Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 32,448,587 | <p>for Python we can use itertools and import both permutations and combinations to solve your problem</p>
<pre><code>from itertools import product, permutations
A = ([1,2,3])
print (list(permutations(sorted(A),2)))
</code></pre>
| -4 | 2015-09-08T02:58:55Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 36,102,351 | <p>Generate all possible permutations</p>
<p>I'm using python3.4:</p>
<pre><code>def calcperm(arr, size):
result = set([()])
for dummy_idx in range(size):
temp = set()
for dummy_lst in result:
for dummy_outcome in arr:
if dummy_outcome not in dummy_lst:
new_seq = list(dummy_lst)
new_seq.append(dummy_outcome)
temp.add(tuple(new_seq))
result = temp
return result
</code></pre>
<p>Test Cases:</p>
<pre><code>lst = [1, 2, 3, 4]
#lst = ["yellow", "magenta", "white", "blue"]
seq = 2
final = calcperm(lst, seq)
print(len(final))
print(final)
</code></pre>
| 0 | 2016-03-19T13:29:06Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 38,793,421 | <p>I see a <em>lot</em> of iteration going on inside these recursive functions, not exactly <em>pure</em> recursion...</p>
<p>so for those of you who cannot abide by even a single loop, here's a gross, totally unnecessary fully recursive solution</p>
<pre><code>def all_insert(x, e, i=0):
return [x[0:i]+[e]+x[i:]] + all_insert(x,e,i+1) if i<len(x)+1 else []
def for_each(X, e):
return all_insert(X[0], e) + for_each(X[1:],e) if X else []
def permute(x):
return [x] if len(x) < 2 else for_each( permute(x[1:]) , x[0])
perms = permute([1,2,3])
</code></pre>
| 0 | 2016-08-05T15:59:00Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
How to generate all permutations of a list in Python | 104,420 | <p>How do you generate all the permutations of a list in Python, independently of the type of elements in that list?</p>
<p>For example:</p>
<pre><code>permutations([])
[]
permutations([1])
[1]
permutations([1, 2])
[1, 2]
[2, 1]
permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
</code></pre>
<p>EDIT:
Eliben pointed to a solution that's similar to mine although simpler, so I'm choosing it as the accepted answer, although Python 2.6+ has a builtin solution in the <strong>itertools</strong> module:</p>
<pre><code>import itertools
itertools.permutations([1, 2, 3])
</code></pre>
| 271 | 2008-09-19T18:41:03Z | 39,925,909 | <p>This way is better than the alternatives I'm seeing, check it out.</p>
<pre><code>def permutations(arr):
if not arr:
return
print arr
for idx, val in enumerate(arr):
permutations(arr[:idx]+arr[idx+1:])
</code></pre>
| 0 | 2016-10-07T21:15:05Z | [
"python",
"algorithm",
"permutation",
"combinatorics",
"python-2.5"
] |
What is "thread local storage" in Python, and why do I need it? | 104,983 | <p>In Python specifically, how do variables get shared between threads?</p>
<p>Although I have used <code>threading.Thread</code> before I never really understood or saw examples of how variables got shared. Are they shared between the main thread and the children or only among the children? When would I need to use thread local storage to avoid this sharing?</p>
<p>I have seen many warnings about synchronizing access to shared data among threads by using locks but I have yet to see a really good example of the problem. </p>
<p>Thanks in advance!</p>
| 62 | 2008-09-19T19:53:19Z | 105,025 | <p>In Python, everything is shared, except for function-local variables (because each function call gets its own set of locals, and threads are always separate function calls.) And even then, only the variables themselves (the names that refer to objects) are local to the function; objects themselves are always global, and anything can refer to them.
The <code>Thread</code> object for a particular thread is not a special object in this regard. If you store the <code>Thread</code> object somewhere all threads can access (like a global variable) then all threads can access that one <code>Thread</code> object. If you want to atomically modify <em>anything</em> that you didn't just create in this very same thread, and did not store anywhere another thread can get at it, you have to protect it by a lock. And all threads must of course share this very same lock, or it wouldn't be very effective.</p>
<p>If you want actual thread-local storage, that's where <code>threading.local</code> comes in. Attributes of <code>threading.local</code> are not shared between threads; each thread sees only the attributes it itself placed in there. If you're curious about its implementation, the source is in <code>_threading_local.py</code> in the standard library.</p>
| 48 | 2008-09-19T19:59:40Z | [
"python",
"multithreading",
"thread-local"
] |
What is "thread local storage" in Python, and why do I need it? | 104,983 | <p>In Python specifically, how do variables get shared between threads?</p>
<p>Although I have used <code>threading.Thread</code> before I never really understood or saw examples of how variables got shared. Are they shared between the main thread and the children or only among the children? When would I need to use thread local storage to avoid this sharing?</p>
<p>I have seen many warnings about synchronizing access to shared data among threads by using locks but I have yet to see a really good example of the problem. </p>
<p>Thanks in advance!</p>
| 62 | 2008-09-19T19:53:19Z | 105,058 | <p>Just like in every other language, every thread in Python has access to the same variables. There's no distinction between the 'main thread' and child threads.</p>
<p>One difference with Python is that the Global Interpreter Lock means that only one thread can be running Python code at a time. This isn't much help when it comes to synchronising access, however, as all the usual pre-emption issues still apply, and you have to use threading primitives just like in other languages. It does mean you need to reconsider if you were using threads for performance, however.</p>
| 0 | 2008-09-19T20:03:30Z | [
"python",
"multithreading",
"thread-local"
] |
What is "thread local storage" in Python, and why do I need it? | 104,983 | <p>In Python specifically, how do variables get shared between threads?</p>
<p>Although I have used <code>threading.Thread</code> before I never really understood or saw examples of how variables got shared. Are they shared between the main thread and the children or only among the children? When would I need to use thread local storage to avoid this sharing?</p>
<p>I have seen many warnings about synchronizing access to shared data among threads by using locks but I have yet to see a really good example of the problem. </p>
<p>Thanks in advance!</p>
| 62 | 2008-09-19T19:53:19Z | 106,560 | <p>You can create thread local storage using <code>threading.local()</code>.</p>
<pre><code>>>> tls = threading.local()
>>> tls.x = 4
>>> tls.x
4
</code></pre>
<p>Data stored to the tls will be unique to each thread which will help ensure that unintentional sharing does not occur.</p>
| 13 | 2008-09-20T00:31:24Z | [
"python",
"multithreading",
"thread-local"
] |
What is "thread local storage" in Python, and why do I need it? | 104,983 | <p>In Python specifically, how do variables get shared between threads?</p>
<p>Although I have used <code>threading.Thread</code> before I never really understood or saw examples of how variables got shared. Are they shared between the main thread and the children or only among the children? When would I need to use thread local storage to avoid this sharing?</p>
<p>I have seen many warnings about synchronizing access to shared data among threads by using locks but I have yet to see a really good example of the problem. </p>
<p>Thanks in advance!</p>
| 62 | 2008-09-19T19:53:19Z | 1,894,371 | <p>Consider the following code:</p>
<pre><code>#/usr/bin/env python
from time import sleep
from random import random
from threading import Thread, local
data = local()
def bar():
print "I'm called from", data.v
def foo():
bar()
class T(Thread):
def run(self):
sleep(random())
data.v = self.getName() # Thread-1 and Thread-2 accordingly
sleep(1)
foo()
</code></pre>
<pre> >> T().start(); T().start()
I'm called from Thread-2
I'm called from Thread-1 </pre>
<p>Here threading.local() is used as a quick and dirty way to pass some data from run() to bar() without changing the interface of foo(). </p>
<p>Note that using global variables won't do the trick:</p>
<pre><code>#/usr/bin/env python
from time import sleep
from random import random
from threading import Thread
def bar():
global v
print "I'm called from", v
def foo():
bar()
class T(Thread):
def run(self):
global v
sleep(random())
v = self.getName() # Thread-1 and Thread-2 accordingly
sleep(1)
foo()
</code></pre>
<pre> >> T().start(); T().start()
I'm called from Thread-2
I'm called from Thread-2 </pre>
<p>Meanwhile, if you could afford passing this data through as an argument of foo() - it would be a more elegant and well-designed way:</p>
<pre><code>from threading import Thread
def bar(v):
print "I'm called from", v
def foo(v):
bar(v)
class T(Thread):
def run(self):
foo(self.getName())
</code></pre>
<p>But this is not always possible when using third-party or poorly designed code.</p>
| 44 | 2009-12-12T18:58:50Z | [
"python",
"multithreading",
"thread-local"
] |
Are locks unnecessary in multi-threaded Python code because of the GIL? | 105,095 | <p>If you are relying on an implementation of Python that has a Global Interpreter Lock (i.e. CPython) and writing multithreaded code, do you really need locks at all?</p>
<p>If the GIL doesn't allow multiple instructions to be executed in parallel, wouldn't shared data be unnecessary to protect?</p>
<p>sorry if this is a dumb question, but it is something I have always wondered about Python on multi-processor/core machines. </p>
<p>same thing would apply to any other language implementation that has a GIL.</p>
| 51 | 2008-09-19T20:07:37Z | 105,127 | <p>You still need to use locks (your code could be interrupted at any time to execute another thread and this can cause data inconsistencies). The problem with GIL is that it prevents Python code from using more cores at the same time (or multiple processors if they are available).</p>
| 1 | 2008-09-19T20:11:18Z | [
"python",
"multithreading",
"locking"
] |
Are locks unnecessary in multi-threaded Python code because of the GIL? | 105,095 | <p>If you are relying on an implementation of Python that has a Global Interpreter Lock (i.e. CPython) and writing multithreaded code, do you really need locks at all?</p>
<p>If the GIL doesn't allow multiple instructions to be executed in parallel, wouldn't shared data be unnecessary to protect?</p>
<p>sorry if this is a dumb question, but it is something I have always wondered about Python on multi-processor/core machines. </p>
<p>same thing would apply to any other language implementation that has a GIL.</p>
| 51 | 2008-09-19T20:07:37Z | 105,145 | <p>No - the GIL just protects python internals from multiple threads altering their state. This is a very low-level of locking, sufficient only to keep python's own structures in a consistent state. It doesn't cover the <em>application</em> level locking you'll need to do to cover thread safety in your own code.</p>
<p>The essence of locking is to ensure that a particular <em>block</em> of code is only executed by one thread. The GIL enforces this for blocks the size of a single bytecode, but usually you want the lock to span a larger block of code than this.</p>
| 20 | 2008-09-19T20:13:54Z | [
"python",
"multithreading",
"locking"
] |
Are locks unnecessary in multi-threaded Python code because of the GIL? | 105,095 | <p>If you are relying on an implementation of Python that has a Global Interpreter Lock (i.e. CPython) and writing multithreaded code, do you really need locks at all?</p>
<p>If the GIL doesn't allow multiple instructions to be executed in parallel, wouldn't shared data be unnecessary to protect?</p>
<p>sorry if this is a dumb question, but it is something I have always wondered about Python on multi-processor/core machines. </p>
<p>same thing would apply to any other language implementation that has a GIL.</p>
| 51 | 2008-09-19T20:07:37Z | 105,175 | <p>This post describes the GIL at a fairly high-level:</p>
<ul>
<li><a href="https://web.archive.org/web/20080516010343/http://www.pyzine.com/Issue001/Section_Articles/article_ThreadingGlobalInterpreter.html" rel="nofollow">https://web.archive.org/web/20080516010343/http://www.pyzine.com/Issue001/Section_Articles/article_ThreadingGlobalInterpreter.html</a></li>
</ul>
<p>Of particular interest are these quotes:</p>
<blockquote>
<p>Every ten instructions (this default
can be changed), the core releases the
GIL for the current thread. At that
point, the OS chooses a thread from
all the threads competing for the lock
(possibly choosing the same thread
that just released the GIL â you don't
have any control over which thread
gets chosen); that thread acquires the
GIL and then runs for another ten
bytecodes.</p>
</blockquote>
<p>and </p>
<blockquote>
<p>Note carefully that the GIL only
restricts pure Python code. Extensions
(external Python libraries usually
written in C) can be written that
release the lock, which then allows
the Python interpreter to run
separately from the extension until
the extension reacquires the lock.</p>
</blockquote>
<p>It sounds like the GIL just provides fewer possible instances for a context switch, and makes multi-core/processor systems behave as a single core, with respect to each python interpreter instance, so yes, you still need to use synchronization mechanisms.</p>
| 6 | 2008-09-19T20:16:33Z | [
"python",
"multithreading",
"locking"
] |
Are locks unnecessary in multi-threaded Python code because of the GIL? | 105,095 | <p>If you are relying on an implementation of Python that has a Global Interpreter Lock (i.e. CPython) and writing multithreaded code, do you really need locks at all?</p>
<p>If the GIL doesn't allow multiple instructions to be executed in parallel, wouldn't shared data be unnecessary to protect?</p>
<p>sorry if this is a dumb question, but it is something I have always wondered about Python on multi-processor/core machines. </p>
<p>same thing would apply to any other language implementation that has a GIL.</p>
| 51 | 2008-09-19T20:07:37Z | 105,272 | <p>The Global Interpreter Lock prevents threads from accessing the <em>interpreter</em> simultaneously (thus CPython only ever uses one core). However, as I understand it, the threads are still interrupted and scheduled <em>preemptively</em>, which means you still need locks on shared data structures, lest your threads stomp on each other's toes.</p>
<p>The answer I've encountered time and time again is that multithreading in Python is rarely worth the overhead, because of this. I've heard good things about the <a href="http://pyprocessing.berlios.de/" rel="nofollow">PyProcessing</a> project, which makes running multiple processes as "simple" as multithreading, with shared data structures, queues, etc. (PyProcessing will be introduced into the standard library of the upcoming Python 2.6 as the <a href="http://www.python.org/dev/peps/pep-0371/" rel="nofollow">multiprocessing</a> module.) This gets you around the GIL, as each process has its own interpreter.</p>
| 7 | 2008-09-19T20:24:50Z | [
"python",
"multithreading",
"locking"
] |
Are locks unnecessary in multi-threaded Python code because of the GIL? | 105,095 | <p>If you are relying on an implementation of Python that has a Global Interpreter Lock (i.e. CPython) and writing multithreaded code, do you really need locks at all?</p>
<p>If the GIL doesn't allow multiple instructions to be executed in parallel, wouldn't shared data be unnecessary to protect?</p>
<p>sorry if this is a dumb question, but it is something I have always wondered about Python on multi-processor/core machines. </p>
<p>same thing would apply to any other language implementation that has a GIL.</p>
| 51 | 2008-09-19T20:07:37Z | 105,369 | <p>You will still need locks if you share state between threads. The GIL only protects the interpreter internally. You can still have inconsistent updates in your own code.</p>
<p>For example:</p>
<pre><code>#!/usr/bin/env python
import threading
shared_balance = 0
class Deposit(threading.Thread):
def run(self):
for _ in xrange(1000000):
global shared_balance
balance = shared_balance
balance += 100
shared_balance = balance
class Withdraw(threading.Thread):
def run(self):
for _ in xrange(1000000):
global shared_balance
balance = shared_balance
balance -= 100
shared_balance = balance
threads = [Deposit(), Withdraw()]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
print shared_balance
</code></pre>
<p>Here, your code can be interrupted between reading the shared state (<code>balance = shared_balance</code>) and writing the changed result back (<code>shared_balance = balance</code>), causing a lost update. The result is a random value for the shared state.</p>
<p>To make the updates consistent, run methods would need to lock the shared state around the read-modify-write sections (inside the loops) or have <a href="http://en.wikipedia.org/wiki/Software_transactional_memory">some way to detect when the shared state had changed since it was read</a>.</p>
| 57 | 2008-09-19T20:34:40Z | [
"python",
"multithreading",
"locking"
] |
Are locks unnecessary in multi-threaded Python code because of the GIL? | 105,095 | <p>If you are relying on an implementation of Python that has a Global Interpreter Lock (i.e. CPython) and writing multithreaded code, do you really need locks at all?</p>
<p>If the GIL doesn't allow multiple instructions to be executed in parallel, wouldn't shared data be unnecessary to protect?</p>
<p>sorry if this is a dumb question, but it is something I have always wondered about Python on multi-processor/core machines. </p>
<p>same thing would apply to any other language implementation that has a GIL.</p>
| 51 | 2008-09-19T20:07:37Z | 241,814 | <p>Adding to the discussion:</p>
<p>Because the GIL exists, some operations are atomic in Python and do not need a lock. </p>
<p><a href="http://www.python.org/doc/faq/library/#what-kinds-of-global-value-mutation-are-thread-safe">http://www.python.org/doc/faq/library/#what-kinds-of-global-value-mutation-are-thread-safe</a></p>
<p>As stated by the other answers, however, you <em>still</em> need to use locks whenever the application logic requires them (such as in a Producer/Consumer problem).</p>
| 7 | 2008-10-28T00:16:12Z | [
"python",
"multithreading",
"locking"
] |
Are locks unnecessary in multi-threaded Python code because of the GIL? | 105,095 | <p>If you are relying on an implementation of Python that has a Global Interpreter Lock (i.e. CPython) and writing multithreaded code, do you really need locks at all?</p>
<p>If the GIL doesn't allow multiple instructions to be executed in parallel, wouldn't shared data be unnecessary to protect?</p>
<p>sorry if this is a dumb question, but it is something I have always wondered about Python on multi-processor/core machines. </p>
<p>same thing would apply to any other language implementation that has a GIL.</p>
| 51 | 2008-09-19T20:07:37Z | 385,446 | <p>A little bit of update from Will Harris's example:</p>
<pre><code>class Withdraw(threading.Thread):
def run(self):
for _ in xrange(1000000):
global shared_balance
if shared_balance >= 100:
balance = shared_balance
balance -= 100
shared_balance = balance
</code></pre>
<p>Put a value check statement in the withdraw and I don't see negative anymore and updates seems consistent. My question is:</p>
<p>If GIL prevents only one thread can be executed at any atomic time, then where would be the stale value? If no stale value, why we need lock? (Assuming we only talk about pure python code)</p>
<p>If I understand correctly, the above condition check wouldn't work in a <em>real</em> threading environment. When more than one threads are executing concurrently, stale value can be created hence the inconsistency of the share state, then you really need a lock. But if python really only allows just one thread at any time (time slicing threading), then there shouldn't be possible for stale value to exist, right?</p>
| 0 | 2008-12-22T02:56:47Z | [
"python",
"multithreading",
"locking"
] |
Are locks unnecessary in multi-threaded Python code because of the GIL? | 105,095 | <p>If you are relying on an implementation of Python that has a Global Interpreter Lock (i.e. CPython) and writing multithreaded code, do you really need locks at all?</p>
<p>If the GIL doesn't allow multiple instructions to be executed in parallel, wouldn't shared data be unnecessary to protect?</p>
<p>sorry if this is a dumb question, but it is something I have always wondered about Python on multi-processor/core machines. </p>
<p>same thing would apply to any other language implementation that has a GIL.</p>
| 51 | 2008-09-19T20:07:37Z | 385,887 | <p>Think of it this way:</p>
<p>On a single processor computer, multithreading happens by suspending one thread and starting another fast enough to make it appear to be running at the same time. This is like Python with the GIL: only one thread is ever actually running.</p>
<p>The problem is that the thread can be suspended anywhere, for example, if I want to compute b = (a + b) * 3, this might produce instructions something like this:</p>
<pre><code>1 a += b
2 a *= 3
3 b = a
</code></pre>
<p>Now, lets say that is running in a thread and that thread is suspended after either line 1 or 2 and then another thread kicks in and runs:</p>
<pre><code>b = 5
</code></pre>
<p>Then when the other thread resumes, b is overwritten by the old computed values, which is probably not what was expected.</p>
<p>So you can see that even though they're not ACTUALLY running at the same time, you still need locking.</p>
| 3 | 2008-12-22T09:49:35Z | [
"python",
"multithreading",
"locking"
] |
Are locks unnecessary in multi-threaded Python code because of the GIL? | 105,095 | <p>If you are relying on an implementation of Python that has a Global Interpreter Lock (i.e. CPython) and writing multithreaded code, do you really need locks at all?</p>
<p>If the GIL doesn't allow multiple instructions to be executed in parallel, wouldn't shared data be unnecessary to protect?</p>
<p>sorry if this is a dumb question, but it is something I have always wondered about Python on multi-processor/core machines. </p>
<p>same thing would apply to any other language implementation that has a GIL.</p>
| 51 | 2008-09-19T20:07:37Z | 20,408,373 | <p>Locks are still needed. I will try explaining why they are needed.</p>
<p>Any operation/instruction is executed in the interpreter. GIL ensures that interpreter is held by a single thread at <strong>a particular instant of time</strong>. And your program with multiple threads works in a single interpreter. At any particular instant of time, this interpreter is held by a single thread. It means that only thread which is holding the interpreter is <strong>running</strong> at any instant of time.</p>
<p>Suppose there are two threads,say t1 and t2, and both want to execute two instructions which is reading the value of a global variable and incrementing it.</p>
<pre><code>#increment value
global var
read_var = var
var = read_var + 1
</code></pre>
<p>As put above, GIL only ensures that two threads can't execute an instruction simultaneously, which means both threads can't execute <code>read_var = var</code> at any particular instant of time. But they can execute instruction one after another and you can still have problem. Consider this situation:</p>
<ul>
<li>Suppose read_var is 0.</li>
<li>GIL is held by thread t1.</li>
<li>t1 executes <code>read_var = var</code>. So, read_var in t1 is 0. GIL will only ensure that this read operation will not be executed for any other thread at this instant.</li>
<li>GIL is given to thread t2.</li>
<li>t2 executes <code>read_var = var</code>. But read_var is still 0. So, read_var in t2 is 0.</li>
<li>GIL is given to t1.</li>
<li>t1 executes <code>var = read_var+1</code> and var becomes 1.</li>
<li>GIL is given to t2.</li>
<li>t2 thinks read_var=0, because that's what it read.</li>
<li>t2 executes <code>var = read_var+1</code> and var becomes 1.</li>
<li>Our expectation was that <code>var</code> should become 2.</li>
<li>So, a lock must be used to keep both reading and incrementing as an atomic operation.</li>
<li>Will Harris' answer explains it through a code example.</li>
</ul>
| 1 | 2013-12-05T19:01:46Z | [
"python",
"multithreading",
"locking"
] |
Making a beta code for a public django site | 105,702 | <p>I'm about to put a beta version of the site I'm working on up on the web. It needs to have a beta code to restrict access. The site is written in django.</p>
<p>I don't want to change the fundamental Auth system to accommodate a beta code, and I don't care particularly that the security of the beta code is iron-clad, just that it's a significant stumbling block.</p>
<p>How should I do this? It's a fairly large project, so adding code to every view is far from ideal.</p>
<hr>
<p>That solution works well. The Middleware Class I ended up with this this:</p>
<pre><code>from django.http import HttpResponseRedirect
class BetaMiddleware(object):
"""
Require beta code session key in order to view any page.
"""
def process_request(self, request):
if request.path != '/beta/' and not request.session.get('in_beta'):
return HttpResponseRedirect('%s?next=%s' % ('/beta/', request.path))
</code></pre>
| 11 | 2008-09-19T21:17:20Z | 105,756 | <p>You should be able to add <code>@login_required</code> decorators across the board and be done with it. Unless you have a boat-load of view functions, it shouldn't be too horrible.</p>
| 0 | 2008-09-19T21:24:56Z | [
"python",
"django",
"authentication",
"django-authentication"
] |
Making a beta code for a public django site | 105,702 | <p>I'm about to put a beta version of the site I'm working on up on the web. It needs to have a beta code to restrict access. The site is written in django.</p>
<p>I don't want to change the fundamental Auth system to accommodate a beta code, and I don't care particularly that the security of the beta code is iron-clad, just that it's a significant stumbling block.</p>
<p>How should I do this? It's a fairly large project, so adding code to every view is far from ideal.</p>
<hr>
<p>That solution works well. The Middleware Class I ended up with this this:</p>
<pre><code>from django.http import HttpResponseRedirect
class BetaMiddleware(object):
"""
Require beta code session key in order to view any page.
"""
def process_request(self, request):
if request.path != '/beta/' and not request.session.get('in_beta'):
return HttpResponseRedirect('%s?next=%s' % ('/beta/', request.path))
</code></pre>
| 11 | 2008-09-19T21:17:20Z | 105,764 | <p>You can probably restrict access to the entire site via apache with htaccess, taking the problem out of the django's project space entirely.</p>
| 4 | 2008-09-19T21:25:38Z | [
"python",
"django",
"authentication",
"django-authentication"
] |
Making a beta code for a public django site | 105,702 | <p>I'm about to put a beta version of the site I'm working on up on the web. It needs to have a beta code to restrict access. The site is written in django.</p>
<p>I don't want to change the fundamental Auth system to accommodate a beta code, and I don't care particularly that the security of the beta code is iron-clad, just that it's a significant stumbling block.</p>
<p>How should I do this? It's a fairly large project, so adding code to every view is far from ideal.</p>
<hr>
<p>That solution works well. The Middleware Class I ended up with this this:</p>
<pre><code>from django.http import HttpResponseRedirect
class BetaMiddleware(object):
"""
Require beta code session key in order to view any page.
"""
def process_request(self, request):
if request.path != '/beta/' and not request.session.get('in_beta'):
return HttpResponseRedirect('%s?next=%s' % ('/beta/', request.path))
</code></pre>
| 11 | 2008-09-19T21:17:20Z | 105,945 | <p>Do what StackOverflow did.</p>
<p>They had a simple email/password form. It had a single hard-coded password (falkensmaze). When the user gets the password right set a cookie. eg. auth=1</p>
<p>Don't worry about it being unsecure. Who care's if someone hacks into the beta?</p>
<p>Apache/htaccess is also a nice and simple solution.</p>
| 2 | 2008-09-19T21:51:26Z | [
"python",
"django",
"authentication",
"django-authentication"
] |
Making a beta code for a public django site | 105,702 | <p>I'm about to put a beta version of the site I'm working on up on the web. It needs to have a beta code to restrict access. The site is written in django.</p>
<p>I don't want to change the fundamental Auth system to accommodate a beta code, and I don't care particularly that the security of the beta code is iron-clad, just that it's a significant stumbling block.</p>
<p>How should I do this? It's a fairly large project, so adding code to every view is far from ideal.</p>
<hr>
<p>That solution works well. The Middleware Class I ended up with this this:</p>
<pre><code>from django.http import HttpResponseRedirect
class BetaMiddleware(object):
"""
Require beta code session key in order to view any page.
"""
def process_request(self, request):
if request.path != '/beta/' and not request.session.get('in_beta'):
return HttpResponseRedirect('%s?next=%s' % ('/beta/', request.path))
</code></pre>
| 11 | 2008-09-19T21:17:20Z | 106,212 | <p>Start with <a href="http://www.djangosnippets.org/snippets/136/">this Django snippet</a>, but modify it to check <code>request.session['has_beta_access']</code>. If they don't have it, then have it return a redirect to a "enter beta code" page that, when posted to with the right code, sets that session variable to <code>True</code>.</p>
<p>Making it a public beta then just consists of removing that middleware from your <code>MIDDLEWARE_CLASSES</code> setting.</p>
| 18 | 2008-09-19T22:43:40Z | [
"python",
"django",
"authentication",
"django-authentication"
] |
Making a beta code for a public django site | 105,702 | <p>I'm about to put a beta version of the site I'm working on up on the web. It needs to have a beta code to restrict access. The site is written in django.</p>
<p>I don't want to change the fundamental Auth system to accommodate a beta code, and I don't care particularly that the security of the beta code is iron-clad, just that it's a significant stumbling block.</p>
<p>How should I do this? It's a fairly large project, so adding code to every view is far from ideal.</p>
<hr>
<p>That solution works well. The Middleware Class I ended up with this this:</p>
<pre><code>from django.http import HttpResponseRedirect
class BetaMiddleware(object):
"""
Require beta code session key in order to view any page.
"""
def process_request(self, request):
if request.path != '/beta/' and not request.session.get('in_beta'):
return HttpResponseRedirect('%s?next=%s' % ('/beta/', request.path))
</code></pre>
| 11 | 2008-09-19T21:17:20Z | 1,249,496 | <p>I'm not sure what version of the Pinax code you're using, but they've built in the ability to close the site off for a private beta so you don't need to do much work yourself.</p>
<p>The link to the specific project template for a private beta site is here: <a href="http://github.com/pinax/pinax/tree/3ad73d1ba44f37365333bae17b507668b0eb7e16/pinax/projects/private_beta_project" rel="nofollow">http://github.com/pinax/pinax/tree/3ad73d1ba44f37365333bae17b507668b0eb7e16/pinax/projects/private_beta_project</a> although I think they might have since added that functionality to all the project templates.</p>
| 0 | 2009-08-08T17:56:36Z | [
"python",
"django",
"authentication",
"django-authentication"
] |
Making a beta code for a public django site | 105,702 | <p>I'm about to put a beta version of the site I'm working on up on the web. It needs to have a beta code to restrict access. The site is written in django.</p>
<p>I don't want to change the fundamental Auth system to accommodate a beta code, and I don't care particularly that the security of the beta code is iron-clad, just that it's a significant stumbling block.</p>
<p>How should I do this? It's a fairly large project, so adding code to every view is far from ideal.</p>
<hr>
<p>That solution works well. The Middleware Class I ended up with this this:</p>
<pre><code>from django.http import HttpResponseRedirect
class BetaMiddleware(object):
"""
Require beta code session key in order to view any page.
"""
def process_request(self, request):
if request.path != '/beta/' and not request.session.get('in_beta'):
return HttpResponseRedirect('%s?next=%s' % ('/beta/', request.path))
</code></pre>
| 11 | 2008-09-19T21:17:20Z | 1,770,902 | <p>Great snippet but it resulted lots of problems for me related OpenId sessions. So I end up relying on Cookies instead of the Session:</p>
<pre><code>class BetaMiddleware(object):
"""
Require beta code cookie key in order to view any page.
"""
set_beta = False
def process_request(self, request):
referer = request.META.get('HTTP_REFERER', '')
if request.method == 'GET' and not 'is_in_beta' in request.COOKIES:
return HttpResponseRedirect('%s?next=%s' % ('/beta/', request.path))
if request.method == 'POST' and 'pass' in request.POST:
code = request.POST['pass']
if code=='beta':
self.set_beta = True
return HttpResponseRedirect('%s' % '/')
def process_response(self, request, response):
if self.set_beta is True:
response.set_cookie('is_in_beta', '1')
return response
</code></pre>
<p>It's not secure but that's enough for me. This also works with just a beta html page.</p>
| 0 | 2009-11-20T14:47:12Z | [
"python",
"django",
"authentication",
"django-authentication"
] |
Why unicode() uses str() on my object only with no encoding given? | 106,630 | <p>I start by creating a string variable with some <strong>non-ascii</strong> <em>utf-8</em> encoded data on it:</p>
<pre><code>>>> text = 'á'
>>> text
'\xc3\xa1'
>>> text.decode('utf-8')
u'\xe1'
</code></pre>
<p>Using <code>unicode()</code> on it raises errors...</p>
<pre><code>>>> unicode(text)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 0:
ordinal not in range(128)
</code></pre>
<p>...but if I know the encoding I can use it as second parameter:</p>
<pre><code>>>> unicode(text, 'utf-8')
u'\xe1'
>>> unicode(text, 'utf-8') == text.decode('utf-8')
True
</code></pre>
<p>Now if I have a class that returns this text in the <code>__str__()</code> method:</p>
<pre><code>>>> class ReturnsEncoded(object):
... def __str__(self):
... return text
...
>>> r = ReturnsEncoded()
>>> str(r)
'\xc3\xa1'
</code></pre>
<p><code>unicode(r)</code> seems to use <code>str()</code> on it, since it raises the same error as <code>unicode(text)</code> above:</p>
<pre><code>>>> unicode(r)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 0:
ordinal not in range(128)
</code></pre>
<p>Until now everything is as planned!</p>
<p><strong>But as no one would ever expect, <code>unicode(r, 'utf-8')</code> won't even try:</strong></p>
<pre><code>>>> unicode(r, 'utf-8')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: coercing to Unicode: need string or buffer, ReturnsEncoded found
</code></pre>
<p>Why? Why this inconsistent behavior? Is it a bug? is it intended? Very awkward.</p>
| 5 | 2008-09-20T00:53:24Z | 106,640 | <p><code>unicode</code> does not guess the encoding of your text. If your object can print itself as <code>unicode</code>, define the <code>__unicode__()</code> method that returns a Unicode string.</p>
<p><hr /></p>
<p>The secret is that <code>unicode(r)</code> is not actually calling <code>__str__()</code> itself. Instead, it's looking for a <code>__unicode__()</code> method. The default implementation of <code>__unicode__()</code> will call <code>__str__()</code> and then attempt to decode it using the <code>ascii</code> charset. When you pass the encoding, <code>unicode()</code> expects the first object to be something that can be decoded -- that is, an instance of <code>basestring</code>.</p>
<p><hr /></p>
<blockquote>
<p>Behavior is weird because it tries to decode as ascii if I don't pass 'utf-8'. But if I pass 'utf-8' it gives a different error...</p>
</blockquote>
<p>That's because when you specify "utf-8", it treats the first parameter as a string-like object to be decoded. Without it, it treats the parameter as an object to be coerced to unicode.</p>
<p>I do not understand the confusion. If you know that the object's <code>text</code> attribute will always be UTF-8 encoded, just define <code>__unicode__()</code> and then everything will work fine.</p>
| 4 | 2008-09-20T00:58:52Z | [
"python",
"unicode",
"encoding"
] |
Why unicode() uses str() on my object only with no encoding given? | 106,630 | <p>I start by creating a string variable with some <strong>non-ascii</strong> <em>utf-8</em> encoded data on it:</p>
<pre><code>>>> text = 'á'
>>> text
'\xc3\xa1'
>>> text.decode('utf-8')
u'\xe1'
</code></pre>
<p>Using <code>unicode()</code> on it raises errors...</p>
<pre><code>>>> unicode(text)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 0:
ordinal not in range(128)
</code></pre>
<p>...but if I know the encoding I can use it as second parameter:</p>
<pre><code>>>> unicode(text, 'utf-8')
u'\xe1'
>>> unicode(text, 'utf-8') == text.decode('utf-8')
True
</code></pre>
<p>Now if I have a class that returns this text in the <code>__str__()</code> method:</p>
<pre><code>>>> class ReturnsEncoded(object):
... def __str__(self):
... return text
...
>>> r = ReturnsEncoded()
>>> str(r)
'\xc3\xa1'
</code></pre>
<p><code>unicode(r)</code> seems to use <code>str()</code> on it, since it raises the same error as <code>unicode(text)</code> above:</p>
<pre><code>>>> unicode(r)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 0:
ordinal not in range(128)
</code></pre>
<p>Until now everything is as planned!</p>
<p><strong>But as no one would ever expect, <code>unicode(r, 'utf-8')</code> won't even try:</strong></p>
<pre><code>>>> unicode(r, 'utf-8')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: coercing to Unicode: need string or buffer, ReturnsEncoded found
</code></pre>
<p>Why? Why this inconsistent behavior? Is it a bug? is it intended? Very awkward.</p>
| 5 | 2008-09-20T00:53:24Z | 106,709 | <p>The behaviour does seem confusing, but intensional. I reproduce here the entirety of the unicode documentation from the <a href="http://docs.python.org/lib/built-in-funcs.html" rel="nofollow">Python Built-In Functions documentation</a> (for version 2.5.2, as I write this):</p>
<blockquote>
<p><strong>unicode([object[, encoding [, errors]]])</strong></p>
<p>Return the Unicode string version of object using one of the following modes:</p>
<p>If encoding and/or errors are given, unicode() will decode the
object which can either be an 8-bit string or a character buffer
using the codec for encoding. The encoding parameter is a string
giving the name of an encoding; if the encoding is not known,
LookupError is raised. Error handling is done according to
errors; this specifies the treatment of characters which are
invalid in the input encoding. If errors is 'strict' (the
default), a ValueError is raised on errors, while a value of
'ignore' causes errors to be silently ignored, and a value of
'replace' causes the official Unicode replacement character,
U+FFFD, to be used to replace input characters which cannot be
decoded. See also the <a href="http://docs.python.org/lib/module-codecs.html" rel="nofollow">codecs</a> module.</p>
<p>If no optional parameters are given, unicode() will mimic the
behaviour of str() except that it returns Unicode strings
instead of 8-bit strings. More precisely, if object is a Unicode
string or subclass it will return that Unicode string without
any additional decoding applied.</p>
<p>For objects which provide a __unicode__() method, it will call
this method without arguments to create a Unicode string. For
all other objects, the 8-bit string version or representation is
requested and then converted to a Unicode string using the codec
for the default encoding in 'strict' mode.</p>
<p>New in version 2.0. Changed in version 2.2: Support for __unicode__() added. </p>
</blockquote>
<p>So, when you call <code>unicode(r, 'utf-8')</code>, it requires an 8-bit string or a character buffer as the first argument, so it coerces your object using the <code>__str__()</code> method, and attempts to decode that using the <code>utf-8</code> codec. Without the <code>utf-8</code>, the <code>unicode()</code> function looks for a for a <code>__unicode__()</code> method on your object, and not finding it, calls the <code>__str__()</code> method, as you suggested, attempting to use the default codec to convert to unicode.</p>
| 7 | 2008-09-20T01:32:09Z | [
"python",
"unicode",
"encoding"
] |
How to bundle a Python application including dependencies? | 106,725 | <p>I need to package my python application, its dependencies and python into a single MSI installer. The end result should desirably be:</p>
<ul>
<li>Python is installed in the standard location</li>
<li>the package and its dependencies are installed in a separate directory (possibly site-packages)</li>
<li>the installation directory should contain the python uncompressed and a standalone executable is not required</li>
</ul>
| 43 | 2008-09-20T01:39:48Z | 106,730 | <p>Kind of a dup of this question about <a href="http://stackoverflow.com/questions/2933/an-executable-python-app"> how to make a python into an executable</a>. </p>
<p>It boils down to: </p>
<p><a href="http://www.py2exe.org/">py2exe</a> on windows, <a href="http://wiki.python.org/moin/Freeze">Freeze</a> on Linux, and
<a href="http://svn.pythonmac.org/py2app/py2app/trunk/doc/index.html">py2app</a> on Mac.</p>
| 25 | 2008-09-20T01:41:20Z | [
"python",
"tkinter",
"packaging"
] |
How to bundle a Python application including dependencies? | 106,725 | <p>I need to package my python application, its dependencies and python into a single MSI installer. The end result should desirably be:</p>
<ul>
<li>Python is installed in the standard location</li>
<li>the package and its dependencies are installed in a separate directory (possibly site-packages)</li>
<li>the installation directory should contain the python uncompressed and a standalone executable is not required</li>
</ul>
| 43 | 2008-09-20T01:39:48Z | 106,731 | <p>py2exe is the best way to do this. It's a bit of a PITA to use, but the end result works very well.</p>
| 1 | 2008-09-20T01:41:36Z | [
"python",
"tkinter",
"packaging"
] |
How to bundle a Python application including dependencies? | 106,725 | <p>I need to package my python application, its dependencies and python into a single MSI installer. The end result should desirably be:</p>
<ul>
<li>Python is installed in the standard location</li>
<li>the package and its dependencies are installed in a separate directory (possibly site-packages)</li>
<li>the installation directory should contain the python uncompressed and a standalone executable is not required</li>
</ul>
| 43 | 2008-09-20T01:39:48Z | 106,733 | <p><a href="http://wiki.python.org/moin/Py2Exe" rel="nofollow">py2exe</a> will make windows executables with python bundled in.</p>
| 1 | 2008-09-20T01:41:47Z | [
"python",
"tkinter",
"packaging"
] |
How to bundle a Python application including dependencies? | 106,725 | <p>I need to package my python application, its dependencies and python into a single MSI installer. The end result should desirably be:</p>
<ul>
<li>Python is installed in the standard location</li>
<li>the package and its dependencies are installed in a separate directory (possibly site-packages)</li>
<li>the installation directory should contain the python uncompressed and a standalone executable is not required</li>
</ul>
| 43 | 2008-09-20T01:39:48Z | 106,756 | <p>I use <a href="http://pyinstaller.python-hosting.com/">PyInstaller</a> (the svn version) to create a stand-alone version of my program that includes Python and all the dependencies. It takes a little fiddling to get it to work right and include everything (as does py2exe and other similar programs, see <a href="http://stackoverflow.com/questions/2933/an-executable-python-app">this question</a>), but then it works very well.</p>
<p>You then need to create an installer. <a href="http://nsis.sourceforge.net/Main_Page">NSIS</a> Works great for that and is free, but it creates .exe files not .msi. If .msi is not necessary, I highly recommend it. Otherwise check out the answers to <a href="http://stackoverflow.com/questions/3767/what-is-the-best-choice-for-building-windows-installers">this</a> question for other options.</p>
| 13 | 2008-09-20T01:52:20Z | [
"python",
"tkinter",
"packaging"
] |
How to bundle a Python application including dependencies? | 106,725 | <p>I need to package my python application, its dependencies and python into a single MSI installer. The end result should desirably be:</p>
<ul>
<li>Python is installed in the standard location</li>
<li>the package and its dependencies are installed in a separate directory (possibly site-packages)</li>
<li>the installation directory should contain the python uncompressed and a standalone executable is not required</li>
</ul>
| 43 | 2008-09-20T01:39:48Z | 114,717 | <p>My company uses the free InnoSetup tool. It is a moderately complex program that has tons of flexibility for building installers for windows. I believe that it creates .exe and not .msi files, however. InnoSetup is not python specific but we have created an installer for one of our products that installs python along with dependencies to locations specified by the user at install time.</p>
| 4 | 2008-09-22T12:58:57Z | [
"python",
"tkinter",
"packaging"
] |
How to bundle a Python application including dependencies? | 106,725 | <p>I need to package my python application, its dependencies and python into a single MSI installer. The end result should desirably be:</p>
<ul>
<li>Python is installed in the standard location</li>
<li>the package and its dependencies are installed in a separate directory (possibly site-packages)</li>
<li>the installation directory should contain the python uncompressed and a standalone executable is not required</li>
</ul>
| 43 | 2008-09-20T01:39:48Z | 18,735,126 | <p>I've had much better results with dependencies and custom folder structures using <a href="http://www.pyinstaller.org/" rel="nofollow">pyinstaller</a>, and it lets you find and specify hidden imports and hooks for larger dependencies like numpy and scipy. Also a PITA, though.</p>
| 3 | 2013-09-11T07:28:07Z | [
"python",
"tkinter",
"packaging"
] |
How to bundle a Python application including dependencies? | 106,725 | <p>I need to package my python application, its dependencies and python into a single MSI installer. The end result should desirably be:</p>
<ul>
<li>Python is installed in the standard location</li>
<li>the package and its dependencies are installed in a separate directory (possibly site-packages)</li>
<li>the installation directory should contain the python uncompressed and a standalone executable is not required</li>
</ul>
| 43 | 2008-09-20T01:39:48Z | 29,111,274 | <p>Ok, I have used py2exe before and it works perfectly except for one thing... It only works on executable windows machines. I then learned about Jython which turn a python script into a .Jar file. Which as you know is executable from any machine that has Java ("To your latest running version") installed. Which is great because both unix, windows, and ios (Most of the time) Run java. That means its executable from all of the following machines. As long as they run Java. No need for "py2mac + py2exe + freeze" just to run on all operating systems. Just Jython</p>
<p>For more information on how it works and how you can use it click here. <br>
<a href="http://www.jython.org/" rel="nofollow">http://www.jython.org/</a></p>
| 0 | 2015-03-17T22:56:41Z | [
"python",
"tkinter",
"packaging"
] |
Unit Testing File Modifications | 106,766 | <p>A common task in programs I've been working on lately is modifying a text file in some way. (Hey, I'm on Linux. Everything's a file. And I do large-scale system admin.)</p>
<p>But the file the code modifies may not exist on my desktop box. And I probably don't want to modify it if it IS on my desktop.</p>
<p>I've read about unit testing in Dive Into Python, and it's pretty clear what I want to do when testing an app that converts decimal to Roman Numerals (the example in DintoP). The testing is nicely self-contained. You don't need to verify that the program PRINTS the right thing, you just need to verify that the functions are returning the right output to a given input.</p>
<p>In my case, however, we need to test that the program is modifying its environment correctly. Here's what I've come up with:</p>
<p>1) Create the "original" file in a standard location, perhaps /tmp.</p>
<p>2) Run the function that modifies the file, passing it the path to the file in /tmp.</p>
<p>3) Verify that the file in /tmp was changed correctly; pass/fail unit test accordingly.</p>
<p>This seems kludgy to me. (Gets even kludgier if you want to verify that backup copies of the file are created properly, etc.) Has anyone come up with a better way?</p>
| 22 | 2008-09-20T01:56:25Z | 106,772 | <p>When I touch files in my code, I tend to prefer to mock the actual reading and writing of the file... so then I can give my classes exact contents I want in the test, and then assert that the test is writing back the contents I expect.</p>
<p>I've done this in Java, and I imagine it is quite simple in Python... but it may require designing your classes/functions in such a way that it is EASY to mock the use of an actual file.</p>
<p>For this, you can try passing in streams and then just pass in a simple string input/output stream which won't write to a file, or have a function that does the actual "write this string to a file" or "read this string from a file", and then replace that function in your tests.</p>
| 2 | 2008-09-20T02:01:20Z | [
"python",
"linux",
"unit-testing"
] |
Unit Testing File Modifications | 106,766 | <p>A common task in programs I've been working on lately is modifying a text file in some way. (Hey, I'm on Linux. Everything's a file. And I do large-scale system admin.)</p>
<p>But the file the code modifies may not exist on my desktop box. And I probably don't want to modify it if it IS on my desktop.</p>
<p>I've read about unit testing in Dive Into Python, and it's pretty clear what I want to do when testing an app that converts decimal to Roman Numerals (the example in DintoP). The testing is nicely self-contained. You don't need to verify that the program PRINTS the right thing, you just need to verify that the functions are returning the right output to a given input.</p>
<p>In my case, however, we need to test that the program is modifying its environment correctly. Here's what I've come up with:</p>
<p>1) Create the "original" file in a standard location, perhaps /tmp.</p>
<p>2) Run the function that modifies the file, passing it the path to the file in /tmp.</p>
<p>3) Verify that the file in /tmp was changed correctly; pass/fail unit test accordingly.</p>
<p>This seems kludgy to me. (Gets even kludgier if you want to verify that backup copies of the file are created properly, etc.) Has anyone come up with a better way?</p>
| 22 | 2008-09-20T01:56:25Z | 106,779 | <p>I think you are on the right track. Depending on what you need to do <a href="http://en.wikipedia.org/wiki/Chroot" rel="nofollow">chroot</a> may help you set up an environment for your scrpits that 'looks' real, but isn't.</p>
<p>If that doesn't work then you could write your scripts to take a 'root' path as an argument.</p>
<p>In a production run the root path is just /. For testing you create a shadow environment under /tmp/test and then run your scripts with a root path of /tmp/test. </p>
| 1 | 2008-09-20T02:04:47Z | [
"python",
"linux",
"unit-testing"
] |
Unit Testing File Modifications | 106,766 | <p>A common task in programs I've been working on lately is modifying a text file in some way. (Hey, I'm on Linux. Everything's a file. And I do large-scale system admin.)</p>
<p>But the file the code modifies may not exist on my desktop box. And I probably don't want to modify it if it IS on my desktop.</p>
<p>I've read about unit testing in Dive Into Python, and it's pretty clear what I want to do when testing an app that converts decimal to Roman Numerals (the example in DintoP). The testing is nicely self-contained. You don't need to verify that the program PRINTS the right thing, you just need to verify that the functions are returning the right output to a given input.</p>
<p>In my case, however, we need to test that the program is modifying its environment correctly. Here's what I've come up with:</p>
<p>1) Create the "original" file in a standard location, perhaps /tmp.</p>
<p>2) Run the function that modifies the file, passing it the path to the file in /tmp.</p>
<p>3) Verify that the file in /tmp was changed correctly; pass/fail unit test accordingly.</p>
<p>This seems kludgy to me. (Gets even kludgier if you want to verify that backup copies of the file are created properly, etc.) Has anyone come up with a better way?</p>
| 22 | 2008-09-20T01:56:25Z | 106,780 | <p>You have two levels of testing.</p>
<ol>
<li><p>Filtering and Modifying content. These are "low-level" operations that don't really require physical file I/O. These are the tests, decision-making, alternatives, etc. The "Logic" of the application.</p></li>
<li><p>File system operations. Create, copy, rename, delete, backup. Sorry, but those are proper file system operations that -- well -- require a proper file system for testing.</p></li>
</ol>
<p>For this kind of testing, we often use a "Mock" object. You can design a "FileSystemOperations" class that embodies the various file system operations. You test this to be sure it does basic read, write, copy, rename, etc. There's no real logic in this. Just methods that invoke file system operations.</p>
<p>You can then create a MockFileSystem which dummies out the various operations. You can use this Mock object to test your other classes.</p>
<p>In some cases, all of your file system operations are in the os module. If that's the case, you can create a MockOS module with mock version of the operations you actually use.</p>
<p>Put your MockOS module on the <code>PYTHONPATH</code> and you can conceal the real OS module.</p>
<p>For production operations you use your well-tested "Logic" classes plus your FileSystemOperations class (or the real OS module.)</p>
| 6 | 2008-09-20T02:05:23Z | [
"python",
"linux",
"unit-testing"
] |
Unit Testing File Modifications | 106,766 | <p>A common task in programs I've been working on lately is modifying a text file in some way. (Hey, I'm on Linux. Everything's a file. And I do large-scale system admin.)</p>
<p>But the file the code modifies may not exist on my desktop box. And I probably don't want to modify it if it IS on my desktop.</p>
<p>I've read about unit testing in Dive Into Python, and it's pretty clear what I want to do when testing an app that converts decimal to Roman Numerals (the example in DintoP). The testing is nicely self-contained. You don't need to verify that the program PRINTS the right thing, you just need to verify that the functions are returning the right output to a given input.</p>
<p>In my case, however, we need to test that the program is modifying its environment correctly. Here's what I've come up with:</p>
<p>1) Create the "original" file in a standard location, perhaps /tmp.</p>
<p>2) Run the function that modifies the file, passing it the path to the file in /tmp.</p>
<p>3) Verify that the file in /tmp was changed correctly; pass/fail unit test accordingly.</p>
<p>This seems kludgy to me. (Gets even kludgier if you want to verify that backup copies of the file are created properly, etc.) Has anyone come up with a better way?</p>
| 22 | 2008-09-20T01:56:25Z | 106,781 | <p>You might want to setup the test so that it runs inside a chroot jail, so you have all the environment the test needs, even if paths and file locations are hardcoded in the code [not really a good practice, but sometimes one gets the file locations from other places...] and then check the results via the exit code.</p>
| 1 | 2008-09-20T02:06:19Z | [
"python",
"linux",
"unit-testing"
] |
Unit Testing File Modifications | 106,766 | <p>A common task in programs I've been working on lately is modifying a text file in some way. (Hey, I'm on Linux. Everything's a file. And I do large-scale system admin.)</p>
<p>But the file the code modifies may not exist on my desktop box. And I probably don't want to modify it if it IS on my desktop.</p>
<p>I've read about unit testing in Dive Into Python, and it's pretty clear what I want to do when testing an app that converts decimal to Roman Numerals (the example in DintoP). The testing is nicely self-contained. You don't need to verify that the program PRINTS the right thing, you just need to verify that the functions are returning the right output to a given input.</p>
<p>In my case, however, we need to test that the program is modifying its environment correctly. Here's what I've come up with:</p>
<p>1) Create the "original" file in a standard location, perhaps /tmp.</p>
<p>2) Run the function that modifies the file, passing it the path to the file in /tmp.</p>
<p>3) Verify that the file in /tmp was changed correctly; pass/fail unit test accordingly.</p>
<p>This seems kludgy to me. (Gets even kludgier if you want to verify that backup copies of the file are created properly, etc.) Has anyone come up with a better way?</p>
| 22 | 2008-09-20T01:56:25Z | 111,199 | <p>You're talking about testing too much at once. If you start trying to attack a testing problem by saying "Let's verify that it modifies its environment correctly", you're doomed to failure. Environments have dozens, maybe even millions of potential variations.</p>
<p>Instead, look at the pieces ("units") of your program. For example, are you going to have a function that determines where the files are that have to be written? What are the inputs to that function? Perhaps an environment variable, perhaps some values read from a config file? Test that function, and don't actually do anything that modifies the filesystem. Don't pass it "realistic" values, pass it values that are easy to verify against. Make a temporary directory, populate it with files in your test's <code>setUp</code> method.</p>
<p>Then test the code that writes the files. Just make sure it's writing the right contents file contents. Don't even write to a real filesystem! You don't need to make "fake" file objects for this, just use Python's handy <code>StringIO</code> modules; they're "real" implementations of the "file" interface, they're just not the ones that your program is actually going to be writing to.</p>
<p>Ultimately you will have to test the final, everything-is-actually-hooked-up-for-real top-level function that passes the real environment variable and the real config file and puts everything together. But don't worry about that to get started. For one thing, you will start picking up tricks as you write individual tests for smaller functions and creating test mocks, fakes, and stubs will become second nature to you. For another: even if you can't quite figure out how to test that one function call, you will have a very high level of confidence that everything which it is calling works perfectly. Also, you'll notice that test-driven development forces you to make your APIs clearer and more flexible. For example: it's much easier to test something that calls an <code>open()</code> method on an object that came from somewhere abstract, than to test something that calls <code>os.open</code> on a string that you pass it. The <code>open</code> method is flexible; it can be faked, it can be implemented differently, but a string is a string and <code>os.open</code> doesn't give you any leeway to catch what methods are called on it.</p>
<p>You can also build testing tools to make repetitive tasks easy. For example, twisted provides facilities for creating temporary files for testing <a href="http://twistedmatrix.com/documents/8.1.0/api/twisted.trial.unittest.TestCase.html#mktemp">built right into its testing tool</a>. It's not uncommon for testing tools or larger projects with their own test libraries to have functionality like this.</p>
| 14 | 2008-09-21T15:16:34Z | [
"python",
"linux",
"unit-testing"
] |
Unit Testing File Modifications | 106,766 | <p>A common task in programs I've been working on lately is modifying a text file in some way. (Hey, I'm on Linux. Everything's a file. And I do large-scale system admin.)</p>
<p>But the file the code modifies may not exist on my desktop box. And I probably don't want to modify it if it IS on my desktop.</p>
<p>I've read about unit testing in Dive Into Python, and it's pretty clear what I want to do when testing an app that converts decimal to Roman Numerals (the example in DintoP). The testing is nicely self-contained. You don't need to verify that the program PRINTS the right thing, you just need to verify that the functions are returning the right output to a given input.</p>
<p>In my case, however, we need to test that the program is modifying its environment correctly. Here's what I've come up with:</p>
<p>1) Create the "original" file in a standard location, perhaps /tmp.</p>
<p>2) Run the function that modifies the file, passing it the path to the file in /tmp.</p>
<p>3) Verify that the file in /tmp was changed correctly; pass/fail unit test accordingly.</p>
<p>This seems kludgy to me. (Gets even kludgier if you want to verify that backup copies of the file are created properly, etc.) Has anyone come up with a better way?</p>
| 22 | 2008-09-20T01:56:25Z | 1,866,162 | <p>For later readers who just want a way to test that code writing to files is working correctly, here is a "fake_open" that patches the open builtin of a module to use StringIO. fake_open returns a dict of opened files which can be examined in a unit test or doctest, all without needing a real file-system.</p>
<pre><code>def fake_open(module):
"""Patch module's `open` builtin so that it returns StringIOs instead of
creating real files, which is useful for testing. Returns a dict that maps
opened file names to StringIO objects."""
from contextlib import closing
from StringIO import StringIO
streams = {}
def fakeopen(filename,mode):
stream = StringIO()
stream.close = lambda: None
streams[filename] = stream
return closing(stream)
module.open = fakeopen
return streams
</code></pre>
| 3 | 2009-12-08T10:45:40Z | [
"python",
"linux",
"unit-testing"
] |
How best to draw in the console? | 106,850 | <p>I'm trying to write a console (as in terminal, not gaming console) pong game in python and I'm having trouble figuring how best to (re)draw the game.</p>
<p>I was thinking of having an 2d array as a sort of bitmap, editing the array to reflect the ball/paddles new positions and then casting each row to a string and printing it. However that means that the old "frames" will remain, and if the dimensions of the game are smaller than the console window, old frames will still be visible.</p>
<p>Is there a way to delete characters from the console? '\b' I've heard is unreliable.</p>
<p>Or is there an easier alternative route to outputting to the console for this sort of app?</p>
| 5 | 2008-09-20T02:45:45Z | 106,851 | <p>It looks like there is a <a href="http://en.wikipedia.org/wiki/Curses_(programming_library)" rel="nofollow">curses</a> port/library for Python:</p>
<p><a href="https://docs.python.org/library/curses.html" rel="nofollow">https://docs.python.org/library/curses.html</a></p>
| 5 | 2008-09-20T02:47:18Z | [
"python",
"console",
"stdout"
] |
How best to draw in the console? | 106,850 | <p>I'm trying to write a console (as in terminal, not gaming console) pong game in python and I'm having trouble figuring how best to (re)draw the game.</p>
<p>I was thinking of having an 2d array as a sort of bitmap, editing the array to reflect the ball/paddles new positions and then casting each row to a string and printing it. However that means that the old "frames" will remain, and if the dimensions of the game are smaller than the console window, old frames will still be visible.</p>
<p>Is there a way to delete characters from the console? '\b' I've heard is unreliable.</p>
<p>Or is there an easier alternative route to outputting to the console for this sort of app?</p>
| 5 | 2008-09-20T02:45:45Z | 106,853 | <p>I would investigate using the <a href="http://python.org/doc/2.5/lib/module-curses.html" rel="nofollow">curses</a> module. It will take care of a lot of the details and let you focus on the higher level stuff.</p>
| 0 | 2008-09-20T02:48:12Z | [
"python",
"console",
"stdout"
] |
Subsets and Splits