In Python 2.7, `-O` has the following effect:

  * the byte code extension changes to `.pyo`
  * [sys.flags.optimize gets set to 1](https://stackoverflow.com/a/17317851/6650102)
  * `__debug__` is False
  * asserts don&#39;t get executed

In addition `-OO` has the following effect:

  * [sys.flags.optimize gets set to 2](https://stackoverflow.com/a/17317851/6650102)
  * doc strings are not available

To verify the effect for a different release of CPython, grep the source code for `Py_OptimizeFlag`.

Link to official documentation: https://docs.python.org/2.7/tutorial/modules.html#compiled-python-files

I have this method in one of my Android Activities:

	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event)
	{
		if(keyCode == KeyEvent.KEYCODE_BACK)
		{
			Log.d(&quot;Test&quot;, &quot;Back button pressed!&quot;);
		}
		else if(keyCode == KeyEvent.KEYCODE_HOME)
		{
			Log.d(&quot;Test&quot;, &quot;Home button pressed!&quot;);
		}
		return super.onKeyDown(keyCode, event);
	}

But, even though the KEYCODE_HOME is valid, the log method never fires. This works for the back button though. Does anyone know why this is and how to get this to work?


Call method when home button pressed

How do I output a variable value to the log from MSBuild?

I am trying to debug an MSBuild script and would like to output a variable&#39;s value to the log.


How to output a variable value to the log from MSBuild

The docs only say that Python interpreter performs &quot;basic optimizations&quot;, without going into any detail. Obviously, it&#39;s implementation dependent, but is there any way to get a feel for what type of things could be optimized, and how much run-time savings it could generate?

Is there any downside to using -O?

The only thing I know is that -O disables `assert`, but presumably one shouldn&#39;t use `assert` for things that could still go wrong in production.

What does Python optimization (-O or PYTHONOPTIMIZE) do?

The docs only say that Python interpreter performs "basic optimizations", without going into any detail. Obviously, it's implementation dependent, but is there any way to get a feel for what type of things could be optimized, and how much run-time savings it could generate?
Is there any downside to using -O?
The only thing I know is that -O disables <code>assert</code>, but presumably one shouldn't use <code>assert</code> for things that could still go wrong in production.

I understand the basic user stuff.  I know authentication, login, creating accounts, etc. But now I want to work on groups and permissions.

Where is the documentation for django groups/permissions? This is not it: http://docs.djangoproject.com/en/dev/topics/auth/

How do I use Django groups and permissions?

I first saw it used in building regular expressions across multiple lines as a method argument to `re.compile()`, so I assumed that `r` stands for RegEx.

For example:

	regex = re.compile(
		r&#39;^[A-Z]&#39;
		r&#39;[A-Z0-9-]&#39;
		r&#39;[A-Z]$&#39;, re.IGNORECASE
	)

So what does `r` mean in this case? Why do we need it?

What does preceding a string literal with &quot;r&quot; mean?

I am trying to ```import Tkinter```. However, I get an error stating that ```Tkinter``` has not been installed:
```python
ImportError: No module named _tkinter, please install the python-tk package
```
I could probably install it using synaptic manager (can I?), however, I would have to install it on every machine I program on. Would it be possible to add the Tkinter library into my workspace and reference it from there?

Install tkinter for Python

I&#39;m trying to get the links from a page with xpath. The problem is that I only want the links inside a table, but if I apply the xpath expression on the whole page I&#39;ll capture links which I don&#39;t want.

For example:

    tree = lxml.html.parse(some_response)
    links = tree.xpath(&quot;//a[contains(@href, &#39;http://www.example.com/filter/&#39;)]&quot;)

The problem is that applies the expression to the whole document. I located the element I want, for example:

    tree = lxml.html.parse(some_response)
    root = tree.getroot()
    table = root[1][5] #for example
    links = table.xpath(&quot;//a[contains(@href, &#39;http://www.example.com/filter/&#39;)]&quot;)

But that seems to be performing the query in the whole document as well, as I still am capturing the links outside of the table. &lt;a href=&quot;http://codespeak.net/lxml/xpathxslt.html&quot;&gt;This page&lt;/a&gt; says that &quot;When xpath() is used on an Element, the XPath expression is evaluated against the element (if relative) or against the root tree (if absolute):&quot;. So, what I using is an absolute expression and I need to make it relative? Is that it?

Basically, how can I go about filtering only elements that exist inside of this table?

Python: Using xpath locally / on a specific element

I created a custom group in Django&#39;s admin site.

In my code, I want to check if a user is in this group. How do I do that?

In Django, how do I check if a user is in a certain group?

I have legacy C++ code that I&#39;m supposed to remove unused code from. The problem is that the code base is large.

How can I find out which code is never called/never used?


How can I know which parts in the code are never used?

assuming the texture, vertex, and shader data are already on the graphics card, you don&#39;t need to send much data to the card. there&#39;s a few bytes to identify the data, and presumably a 4x4 matrix, and some assorted other parameters.

so where is all of the overhead coming from? do the operations require a handshake of some sort with the gpu?

why is sending a single mesh containing a bunch of small models, calculated on the CPU, often faster than sending the vertex id and transformation matrices? (the second option looks like there should be less data sent, unless the models are smaller than a 4x4 matrix)

why are draw calls expensive?

Optimising Python dictionary access code

I&#39;m working on a high-performance Android application (a game), and though I try to code for readability first, I like to keep in the back of my mind a picture of what is happening under the hood. With C++, I&#39;ve developed a fairly good intuition about what the compiler will and won&#39;t do for me. I&#39;m trying to do the same for Java/Android.

Hence this question. I could find very little about this topic on the web. Will the Java compiler, Dalvik converter (dx) and/or JITter (on Android 2.2+) perform optimizations like the following?

* Method inlining. Under what conditions? `private` methods can always safely be inlined; will this be done? How about `public final` methods? Methods on objects of other classes? `static` methods? What if the runtime type of the object can easily be deduced by the compiler? Should I declare methods as `final` or `static` wherever possible?

* Common subexpression elimination. For example, if I access `someObject.someField` twice, will the lookup be done only once? What if it&#39;s a call to a getter? What if I use some arithmetic expression twice; will it be evaluated only once? What if I use the result of some expression, whose value I know not to change, as the upper bound of a `for` loop?

* Bounds checking on array lookups. Will the toolchain eliminate this in certain conditions, like the archetypical `for` loop?

* Value inlining. Will accesses to some `public static final int` always be inlined? Even if they&#39;re in another class? Even if they&#39;re in another package?

* Branch prediction. How big an issue is this even? Is branching a large performance hit on a typical Android device?

* Simple arithmetic. Will `someInt * 2` be replaced by `someInt &lt;&lt; 1`?

Etcetera...

What optimizations can I expect from Dalvik and the Android toolchain?

I&#39;m developing a game for Android. It uses a surface view and uses the sort of standard 2D drawing APIs provided. When I first released the game, I was doing all sorts of daft things like re-drawing 9-patches on each frame and likewise with text. I have since optimised much of this by drawing to Bitmap objects and drawing them each frame, only re-drawing onto the Bitmap objects when required. 

I&#39;ve received complaints about battery drain before, and following my modifications I&#39;d like to know (scientifically) if I&#39;ve made any improvements. Unfortunately, I don&#39;t have any prior data to go by, so it would be most useful to compare the performance to some other game.

I&#39;ve been running Traceview, and using the results of it mostly for the purposes of identifying CPU-time-consuming methods. 

So -- **what&#39;s the best way of determining my app&#39;s battery performance, and what&#39;s a good benchmark?**

I know I can look at the %s of different apps through the settings, but this is again unscientific, as the figure I get from this also depends on what&#39;s happening in all of the other apps. I&#39;ve looked through (most of) Google&#39;s documentation, and although the message is clear that you *should* be saving battery (and it gives the occasional tip as to how), there is little indication of how I can measure how well my app is performing. The last thing I want are more complaints of battery drain in the Android Market!

Thanks in advance.

***

EDIT
----

Thanks for all your helpful advice/suggestions. What I really want to know is **how I can use the data coming from Traceview (ie: CPU time in ms spent on each frame of the game) to determine battery usage** (if this is at all possible). Reading back on my original question, I can see I was a bit vague. Thanks again.


Is my Android App Draining Battery?

Although I have never needed this, it just struck me that making an immutable object in Python could be slightly tricky. You can&#39;t just override [`__setattr__`][1], because then you can&#39;t even set attributes in the [`__init__`][2]. Subclassing a tuple is a trick that works:

    class Immutable(tuple):
        
        def __new__(cls, a, b):
            return tuple.__new__(cls, (a, b))

        @property
        def a(self):
            return self[0]
            
        @property
        def b(self):
            return self[1]

        def __str__(self):
            return &quot;&lt;Immutable {0}, {1}&gt;&quot;.format(self.a, self.b)
        
        def __setattr__(self, *ignored):
            raise NotImplementedError
    
        def __delattr__(self, *ignored):
            raise NotImplementedError

But then you have access to the `a` and `b` variables through `self[0]` and `self[1]`, which is annoying.

Is this possible in Pure Python? If not, how would I do it with a C extension?

(Answers that work only in Python 3 are acceptable).


**Update:** 

As of Python 3.7, the way to go is to use the [`@dataclass`](https://docs.python.org/3/library/dataclasses.html) decorator, see the newly accepted answer.


  [1]: https://docs.python.org/3/reference/datamodel.html#object.__setattr__
  [2]: https://docs.python.org/3/reference/datamodel.html#object.__init__

How to make an immutable object in Python?

Is there a known date/timeframe when python 2.7 will not be supported any more in favor of python 3?

End of support for python 2.7?

Why is Python assignment a statement rather than an expression? If it was an expression which returns the value of the right hand side in the assignment, it would have allowed for much less verbose code in some cases. Are there any issues I can&#39;t see?

For example:

    # lst is some sequence
    # X is come class
    x = X()
    lst.append(x)

could have been rewritten as:

    lst.append(x = X())

Well, to be precise, the above won&#39;t work because `x` would be treated as a keyword argument. But another pair of parens (or another symbol for keyword arguments) would have resolved that.

Why does Python assignment not return a value?

    u&#39;abcde(date=\&#39;2/xc2/xb2\&#39;,time=\&#39;/case/test.png\&#39;)&#39;

All I need is the contents inside the parenthesis.

Regular expression to return text between parenthesis

In Java, I can override the `toString()` method of my class. Then Java&#39;s print function prints the string representation of the object defined by its `toString()`. Is there a Python equivalent to Java&#39;s `toString()`?

For example, I have a PlayCard class. I have an instance c of PlayCard. Now:

    &gt;&gt;&gt; print(c)
    &lt;__main__.Card object at 0x01FD5D30&gt;
But what I want is something like:
    
    &gt;&gt;&gt; print(c)
    A♣

How do I customize the string representation of my class instances?

I&#39;m using Python 3.x


Content Type	Original Author	Original Content on Stackoverflow
Question	max	View Question on Stackoverflow
Solution 1 - Python	Martin v. Löwis	View Answer on Stackoverflow

What does Python optimization (-O or PYTHONOPTIMIZE) do?

Python Problem Overview

Python Solutions

Solution 1 - Python

How to output a variable value to the log from MSBuild

Call method when home button pressed

Attributions