Yes. Just override the object&#39;s `__iadd__` method, which takes the same parameters as `add`. You can find more information [here][1].


  [1]: http://docs.python.org/reference/datamodel.html#emulating-numeric-types

When I have a valid Django form, I can access the data with form.cleaned_data.  But how do I get at the data a user entered when the form is not valid i.e., form.is_valid is false.

I&#39;m trying to access forms within a form set, so form.data seems to just give me a mess.

How to access data when form.is_valid() is false

Is there a way to reload an Android application in the emulator without closing the emulator, saving any code changes, and running the emulator again?  If I make even a simple change to the layout, it takes about 30 seconds by time I run it in Eclipse and Android &quot;boots&quot;, and I can unlock the emulator to run the application.  Is there any way to shorten this time when making changes, or is it something I just have to deal with?

Reload Android application in emulator without restarting emulator in Eclipse?

I know about the `__add__` method to override plus, but when I use that to override +=, I end up with one of two problems:

(1) if `__add__` mutates self, then 

    z = x + y

will mutate x when I don&#39;t really want x to be mutated there.

(2) if `__add__` returns a new object, then

    tmp = z
    z += x
    z += y
    tmp += w
    return z

will return something without w since z and tmp point to different objects after `z += x` is executed.

I can make some sort of `.append()` method, but I&#39;d prefer to overload `+=` if it is possible.



Is there a way to overload += in python?

I know about the <code>__add__</code> method to override plus, but when I use that to override +=, I end up with one of two problems:
(1) if <code>__add__</code> mutates self, then
<pre><code class="hljs language-ini">z = x + y
</code></pre>
will mutate x when I don't really want x to be mutated there.
(2) if <code>__add__</code> returns a new object, then
<pre><code class="hljs language-makefile">tmp = z
z += x
z += y
tmp += w
return z
</code></pre>
will return something without w since z and tmp point to different objects after <code>z += x</code> is executed.
I can make some sort of <code>.append()</code> method, but I'd prefer to overload <code>+=</code> if it is possible.

[PEP 263][1] defines how to declare Python source code encoding.

Normally, the first 2 lines of a Python file should start with:

    #!/usr/bin/python
    # -*- coding: &lt;encoding name&gt; -*-

But I have seen a lot of files starting with:

    #!/usr/bin/python
    # -*- encoding: &lt;encoding name&gt; -*-

=&gt; **encoding** instead of **coding**.

So what is the correct way of declaring the file encoding?

Is **encoding** permitted because the regex used is lazy? Or is it just another form of declaring the file encoding?

I&#39;m asking this question because the PEP does not talk about **encoding**, it just talks about **coding**.

  [1]: http://www.python.org/dev/peps/pep-0263/


Correct way to define Python source code encoding

How can I get the file path of a module imported in python. I am using Linux (if it matters). 

Eg: if I am in my home dir and import a module, it should return back the full path of my home directory.

Getting file path of imported module

When you just want to do a try-except without handling the exception, how do you do it in Python?

Is the following the right way to do it?

    try:
        shutil.rmtree(path)
    except:
        pass


How to properly ignore exceptions

As *[function overloading][1]* says:

Function overloading is absent in Python.

As far as I feel this a big handicap since its also an object-oriented (OO) language. Initially I found that unable to differentiate between the argument types was difficult, but the dynamic nature of Python made it easy (e.g. list, tuples, strings are much similar).

However, counting the number of arguments passed and then doing the job is like an overkill.

  [1]: http://web.archive.org/web/20090624083829/http://mail.python.org/pipermail/python-list/2003-May/206149.html


Function overloading in Python: Missing

I need to add leading zeros to integer to make a string with defined quantity of digits ($cnt).
What the best way to translate this simple function from PHP to Python:

    function add_nulls($int, $cnt=2) {
        $int = intval($int);
        for($i=0; $i&lt;($cnt-strlen($int)); $i++)
            $nulls .= &#39;0&#39;;
        return $nulls.$int;
    }

Is there a function that can do this?

Best way to format integer as string with leading zeros?

Background
---------------
I am using interface-based programming on a current project and have run into a problem when overloading operators (specifically the Equality and Inequality operators).

---------------
Assumptions
---------------
 - I&#39;m using C# 3.0, .NET 3.5 and Visual Studio 2008
 
UPDATE - The Following Assumption was False!
  
- Requiring all comparisons to use Equals rather than operator== is not a viable solution, especially when passing your types to libraries (such as Collections).

The reason I was concerned about requiring Equals to be used rather than operator== is that I could not find anywhere in the .NET guidelines that it stated it would use Equals rather than operator== or even suggest it. However, after re-reading [Guidelines for Overriding Equals and Operator==][3] I have found this:

&gt; By default, the operator == tests for reference equality by determining whether two references indicate the same object. Therefore, reference types do not have to implement operator == in order to gain this functionality. When a type is immutable, that is, the data that is contained in the instance cannot be changed, overloading operator == to compare value equality instead of reference equality can be useful because, as immutable objects, they can be considered the same as long as they have the same value. It is not a good idea to override operator == in non-immutable types.


and this [Equatable&lt;T&gt; Interface][4]

&gt; The IEquatable&lt;T&gt; interface is used by generic collection objects such as Dictionary&lt;TKey, TValue&gt;, List&lt;T&gt;, and LinkedList&lt;T&gt; when testing for equality in such methods as Contains, IndexOf, LastIndexOf, and Remove. It should be implemented for any object that might be stored in a generic collection.


---------------
Contraints
---------------
 - Any solution must not require casting the objects from their interfaces to their concrete types.

---------------
Problem
---------------
 - When ever both sides of the operator== are an interface, no operator== overload method signature from the underlying concrete types will match and thus the default Object operator== method will be called.
 - When overloading an operator on a class, at least one of the parameters of the binary operator must be the containing type, otherwise a compiler error is generated (Error BC33021 [http://msdn.microsoft.com/en-us/library/watt39ff.aspx][1])
 - It&#39;s not possible to specify implementation on an interface


See Code and Output below demonstrating the issue.

--------------
Question
--------------
**How do you provide proper operator overloads for your classes when using interface-base programming?**

--------------
References
--------------
[== Operator (C# Reference)][2]


For predefined value types, the equality operator (==) returns true if the values of its operands are equal, false otherwise. For reference types other than string, == returns true if its two operands refer to the same object. For the string type, == compares the values of the strings.

--------------
See Also
--------------

--------------
Code
--------------
    using System;

    namespace OperatorOverloadsWithInterfaces
    {
        public interface IAddress : IEquatable&lt;IAddress&gt;
        {
            string StreetName { get; set; }
            string City { get; set; }
            string State { get; set; }
        }

        public class Address : IAddress
        {
            private string _streetName;
            private string _city;
            private string _state;

            public Address(string city, string state, string streetName)
            {
                City = city;
                State = state;
                StreetName = streetName;
            }

            #region IAddress Members

            public virtual string StreetName
            {
                get { return _streetName; }
                set { _streetName = value; }
            }

            public virtual string City
            {
                get { return _city; }
                set { _city = value; }
            }

            public virtual string State
            {
                get { return _state; }
                set { _state = value; }
            }

            public static bool operator ==(Address lhs, Address rhs)
            {
                Console.WriteLine(&quot;Address operator== overload called.&quot;);
                // If both sides of the argument are the same instance or null, they are equal
                if (Object.ReferenceEquals(lhs, rhs))
                {
                    return true;
                }

                return lhs.Equals(rhs);
            }

            public static bool operator !=(Address lhs, Address rhs)
            {
                return !(lhs == rhs);
            }

            public override bool Equals(object obj)
            {
                // Use &#39;as&#39; rather than a cast to get a null rather an exception
                // if the object isn&#39;t convertible
                Address address = obj as Address;
                return this.Equals(address);
            }

            public override int GetHashCode()
            {
                string composite = StreetName + City + State;
                return composite.GetHashCode();
            }

            #endregion

            #region IEquatable&lt;IAddress&gt; Members

            public virtual bool Equals(IAddress other)
            {
                // Per MSDN documentation, x.Equals(null) should return false
                if ((object)other == null)
                {
                    return false;
                }

                return ((this.City == other.City)
                    &amp;&amp; (this.State == other.State)
                    &amp;&amp; (this.StreetName == other.StreetName));
            }

            #endregion
        }

        public class Program
        {
            static void Main(string[] args)
            {
                IAddress address1 = new Address(&quot;seattle&quot;, &quot;washington&quot;, &quot;Awesome St&quot;);
                IAddress address2 = new Address(&quot;seattle&quot;, &quot;washington&quot;, &quot;Awesome St&quot;);

                functionThatComparesAddresses(address1, address2);

                Console.Read();
            }

            public static void functionThatComparesAddresses(IAddress address1, IAddress address2)
            {
                if (address1 == address2)
                {
                    Console.WriteLine(&quot;Equal with the interfaces.&quot;);
                }

                if ((Address)address1 == address2)
                {
                    Console.WriteLine(&quot;Equal with Left-hand side cast.&quot;);
                }

                if (address1 == (Address)address2)
                {
                    Console.WriteLine(&quot;Equal with Right-hand side cast.&quot;);
                }

                if ((Address)address1 == (Address)address2)
                {
                    Console.WriteLine(&quot;Equal with both sides cast.&quot;);
                }
            }
        }
    }

--------------
Output
--------------
    Address operator== overload called
    Equal with both sides cast.

  [1]: http://msdn.microsoft.com/en-us/library/watt39ff.aspx
  [2]: http://msdn.microsoft.com/en-us/library/53k8ybth.aspx
  [3]: http://msdn.microsoft.com/en-us/library/ms173147.aspx
  [4]: http://msdn.microsoft.com/en-us/library/ms131187.aspx

Operator Overloading with Interface-Based Programming in C#

Specifically, I would like to create an Array class and would like to overload the [] operator.

Is it possible to overload operators in PHP?

Python 2.x has two ways to overload comparison operators, [`__cmp__`](http://docs.python.org/2.6/reference/datamodel.html#object.__cmp__) or the &quot;rich comparison operators&quot; such as [`__lt__`](http://docs.python.org/2.6/reference/datamodel.html#object.__lt__).  **The rich comparison overloads are said to be preferred, but why is this so?**

Rich comparison operators are simpler to implement each, but you must implement several of them with nearly identical logic.  However, if you can use the builtin `cmp` and tuple ordering, then `__cmp__` gets quite simple and fulfills all the comparisons:

    class A(object):
      def __init__(self, name, age, other):
        self.name = name
        self.age = age
        self.other = other
      def __cmp__(self, other):
        assert isinstance(other, A) # assumption for this example
        return cmp((self.name, self.age, self.other),
                   (other.name, other.age, other.other))

This simplicity seems to meet my needs much better than overloading all 6(!) of the rich comparisons.  (However, you can get it down to &quot;just&quot; 4 if you rely on the &quot;swapped argument&quot;/reflected behavior, but that results in a net increase of complication, in my humble opinion.)

**Are there any unforeseen pitfalls I need to be made aware of if I only overload `__cmp__`?**

I understand the `&lt;`, `&lt;=`, `==`, etc. operators can be overloaded for other purposes, and can return any object they like.  I am not asking about the merits of that approach, but only about differences when using these operators for comparisons in the same sense that they mean for numbers.

*Update:* As Christopher [pointed out](https://stackoverflow.com/questions/1061283/style-why-lt-instead-of-cmp/1061323#1061323), `cmp` is disappearing in 3.x. **Are there any alternatives that make implementing comparisons as easy as the above `__cmp__`?**

__lt__ instead of __cmp__

Operator overloading in C++ is considered by many to be A Bad Thing(tm), and a mistake not to be repeated in newer languages. Certainly, it was one feature specifically dropped when designing Java.

Now that I&#39;ve started reading up on Scala, I find that it has what looks very much like operator overloading (although technically it doesn&#39;t have operator overloading because it doesn&#39;t have operators, only functions). However, it wouldn&#39;t seem to be qualitatively different to the operator overloading in C++, where as I recall operators are defined as special functions.

So my question is what makes the idea of defining &quot;+&quot; in Scala a better idea than it was in C++?

What makes Scala&#39;s operator overloading &quot;good&quot;, but C++&#39;s &quot;bad&quot;?

I overloaded operator &lt;&lt; 

    template &lt;Typename T&gt;
    UIStream&amp; operator&lt;&lt;(const T);

    UIStream my_stream;
    my_stream &lt;&lt; 10 &lt;&lt; &quot; heads&quot;;

Works but:

    my_stream &lt;&lt; endl;

Gives compilation error:

&gt; error C2678: binary &#39;&lt;&lt;&#39; : no operator found which takes a left-hand operand of type &#39;UIStream&#39; (or there is no acceptable conversion)

What is the work around for making `my_stream &lt;&lt; endl` work?



Content Type	Original Author	Original Content on Stackoverflow
Question	Josh Gibson	View Question on Stackoverflow
Solution 1 - Python	mipadi	View Answer on Stackoverflow

Is there a way to overload += in python?

Python Problem Overview

Python Solutions

Solution 1 - Python

Reload Android application in emulator without restarting emulator in Eclipse?

How to access data when form.is_valid() is false

Attributions