Just add the following to the class definition and you should be good to go:

    __rmul__ = __mul__

Implement `__rmul__` as well.

    class Foo(object):
        def __mul__(self, other):
            print &#39;__mul__&#39;
            return other
        def __rmul__(self, other):
            print &#39;__rmul__&#39;
            return other
    
    x = Foo()
    2 * x # __rmul__
    x * 2 # __mul__

I just recently started looking at dump files to help me analyze crashes of the w3wp process on our production environment at work...

And I would like to know, what are the differences between a minidump and a fulldump file ?

minidump vs. fulldump?

I have an array with a list of objects. I want to split this array at one particular index, say 4 (this in real is a variable). I want to store the second part of the split array into another array. Might be simple, but I am unable to think of a nice way to do this.

split an array into two based on a index in javascript

So, I&#39;ve got a custom class that has a `__mul__` function which works with ints. However, in my program (in libraries), it&#39;s getting called the other way around, i.e., `2 * x` where `x` is of my class. Is there a way I can have it use my `__mul__` function for this?

Python: multiplication override

<p>So, I've got a custom class that has a <code>__mul__</code> function which works with ints. However, in my program (in libraries), it's getting called the other way around, i.e., <code>2 * x</code> where <code>x</code> is of my class. Is there a way I can have it use my <code>__mul__</code> function for this?</p>


The function `foo` below returns a string `&#39;foo&#39;`. How can I get the value `&#39;foo&#39;` which is returned from the thread&#39;s target?

    from threading import Thread

    def foo(bar):
        print(&#39;hello {}&#39;.format(bar))
        return &#39;foo&#39;
    
    thread = Thread(target=foo, args=(&#39;world!&#39;,))
    thread.start()
    return_value = thread.join()

The &quot;one obvious way to do it&quot;, shown above, doesn&#39;t work: `thread.join()` returned `None`.

How to get the return value from a thread in Python?

They are same, but which one should I use?

http://docs.python.org/library/os.html:

&gt; `os.sep`
&gt;
&gt; &gt;The character used by the operating system to separate pathname components. This is &#39;/&#39; for   POSIX and &#39;\\&#39; for Windows. Note that knowing this is not sufficient to be able to parse or concatenate pathnames — use os.path.split() and os.path.join() — but it is occasionally useful. Also available via os.path.

which one should I use: os.sep or os.path.sep?

    l = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;]

I want to convert this list to a dictionary like:

    d = {&quot;a&quot;: &quot;b&quot;, &quot;c&quot;: &quot;d&quot;, &quot;e&quot;: &quot;&quot;}

So basically, the evens will be keys whereas the odds will be values. I know that I can do it in a &quot;non-pythonic&quot; way such as a for loop with if statements but I believe that there should be a more &quot;pythonic&quot; way to accomplish this. So, I appreciate any help :) 

Convert list into a dictionary

As I only now noticed after commenting on [this answer](https://stackoverflow.com/questions/6900955/python-convert-list-to-dictionary/6900977#6900977), slices in Python 3 return shallow copies of whatever they&#39;re slicing rather than views. Why is this still the case? Even leaving aside numpy&#39;s usage of views rather than copies for slicing, the fact that `dict.keys`, `dict.values`, and `dict.items` all return views in Python 3, and that there are many other aspects of Python 3 geared towards greater use of iterators, makes it seem that there would have been a movement towards slices becoming similar. `itertools` does have an `islice` function that makes iterative slices, but that&#39;s more limited than normal slicing and does not provide view functionality along the lines of `dict.keys` or `dict.values`.

As well, the fact that you can use assignment to slices to modify the original list, but slices are themselves copies and not views, is a contradictory aspect of the language and seems like it violates several of the principles illustrated in [the Zen of Python](http://www.python.org/dev/peps/pep-0020/).

That is, the fact you can do

    &gt;&gt;&gt; a = [1, 2, 3, 4, 5]
    &gt;&gt;&gt; a[::2] = [0, 0, 0]
    &gt;&gt;&gt; a
    [0, 2, 0, 4, 0]

But not

    &gt;&gt;&gt; a = [1, 2, 3, 4, 5]
    &gt;&gt;&gt; a[::2][0] = 0
    &gt;&gt;&gt; a
    [0, 2, 3, 4, 5]

or something like

    &gt;&gt;&gt; a = [1, 2, 3, 4, 5]
    &gt;&gt;&gt; b = a[::2]
    &gt;&gt;&gt; b
    view(a[::2] -&gt; [1, 3, 5])   # numpy doesn&#39;t explicitly state that its slices are views, but it would probably be a good idea to do it in some way for regular Python
    &gt;&gt;&gt; b[0] = 0
    &gt;&gt;&gt; b
    view(a[::2] -&gt; [0, 3, 5])
    &gt;&gt;&gt; a
    [0, 2, 3, 4, 5]

Seems somewhat arbitrary/undesirable.

I&#39;m aware of http://www.python.org/dev/peps/pep-3099/ and the part where it says &quot;Slices and extended slices won&#39;t go away (even if the `__getslice__` and `__setslice__` APIs may be replaced) nor will they return views for the standard object types.&quot;, but the linked discussion provides no mention of why the decision about slicing with views was made; in fact, the majority of the comments on that specific suggestion out of the suggestions listed in the original post seemed to be positive.

What prevented something like this from being implemented in Python 3.0, which was specifically designed to not be strictly backwards-compatible with Python 2.x and thus would have been the best time to implement such a change in design, and is there anything that may prevent it in future versions of Python?

Why are slices in Python 3 still copies and not views?

What would be the best way to split a string on the first occurrence of a delimiter?

For example:

    &quot;123mango abcd mango kiwi peach&quot;

splitting on the first `mango` to get:

    &quot;abcd mango kiwi peach&quot;

Splitting on first occurrence

So, I&#39;m trying to figure out the best (most elegant with the least amount of code) way to allow overriding specific functions of a property (e.g., just the getter, just the setter, etc.) in python.  I&#39;m a fan of the following way of doing properties, due to the fact that all of their methods are encapsulated in the same indented block of code (it&#39;s easier to see where the functions dealing with one property stop and the functions dealing with the next begin):

    @apply
    def foo():
        &quot;&quot;&quot;A foobar&quot;&quot;&quot;
        def fget(self):
            return self._foo
        def fset(self, val):
            self._foo = val
        return property(**locals())

However, if I want to inherit from a class that defines properties in this manner, and then, say, override the `foo` setter function, it seems tricky.  I&#39;ve done some searching and most of the answers I&#39;ve found have been to define separate functions in the base class (e.g. `getFoo` and `setFoo`), explicitly create a property definition from them (e.g. `foo = property(lambda x: x.getFoo(), lambda x, y: x.setFoo(y), lambda x: x.delFoo())`), and then override `getFoo`, `setFoo`, and `delFoo` as needed.

I dislike this solution because it means I have to define lambas for every single property, and then write out each function call (when before I could have just done `property(**locals())`).  I also don&#39;t get the encapsulation that I had originally.

Ideally, what I would like to be able to do would be something like this:

    class A(object):
        def __init__(self):
            self.foo = 8
        @apply
        def foo():
            &quot;&quot;&quot;A foobar&quot;&quot;&quot;
            def fget(self):
                return self._foo
            def fset(self, val):
                self._foo = val
            return property(**locals())

    class ATimesTwo(A):
        @some_decorator
        def foo():
            def fset(self, val):
                self._foo = val * 2
            return something

And then the output would look something like:

    &gt;&gt;&gt; a = A()
    &gt;&gt;&gt; a.foo
    8
    &gt;&gt;&gt; b = ATimesTwo()
    &gt;&gt;&gt; b.foo
    16

Basically, `ATimesTwo` inherits the getter function from `A` but overrides the setter function.  Does anybody know of a way to do this (in a manner that looks similar to the example above)?  What function would the `some_decorator` look like, and what should the `foo` function return?

Overriding properties in python

Is there any way of forcing child classes to override a non-abstract method of super class?

I need to be able to create instances of parent class, but if a class extends this class, it must give its own definition of some methods.

Is there a way to make a method which is not abstract but must be overridden?

I am trying to override equals method in Java. I have a class `People` which basically has 2 data fields `name` and `age`. Now I want to override `equals` method so that I can check between 2 People objects. 

My code is as follows

    public boolean equals(People other){
		boolean result;
		if((other == null) || (getClass() != other.getClass())){
			result = false;
		} // end if
		else{
			People otherPeople = (People)other;
			result = name.equals(other.name) &amp;&amp;  age.equals(other.age);
		} // end else
		
		return result;
	} // end equals

But when I write `age.equals(other.age)` it gives me error as equals method can only compare String and age is Integer. 

## Solution ##

I used `==` operator as suggested and my problem is solved.

How to override equals method in Java

I have this Base class:

    abstract class Base
    {
      public int x
      {
        get { throw new NotImplementedException(); }
      }
    }

And the following descendant:

    class Derived : Base
    {
      public int x
      {
        get { //Actual Implementaion }
      }
    }


 When I compile I get this warning saying Derived class&#39;s definition of `x` is gonna hide Base&#39;s version of it. Is is possible to override properties in c# like methods?

Can I override a property in c#? How?

Should we refer to &quot;replacing an implementation&quot; as overwriting or overriding? Is it language-specific?

Overwrite or override

When it comes to constructors, adding the keyword `explicit` prevents an enthusiastic compiler from creating an object when it was not the programmer’s first intention. Is such mechanism available for casting operators too?

    struct Foo
    {
        operator std::string() const;
    };


Here, for instance, I would like to be able to cast `Foo` into a `std::string`, but I&#160;don’t want such cast to happen implicitly.

Can a cast operator be explicit?

I&#39;m reading SCJP Java 6 by Kathy Sierra and Bert Bates and this book is confusing me so much. On page 245 they state that the following code below.

    Integer i1 = 1000;
    Integer i2 = 1000;
    if(i1 != i2)
    System.out.println(&quot;different objects&quot;);

    //Prints output
    different objects

Then on the very next page they have the following code

    Integer i3 = 10;
    Integer i4 = 10;
    if(i3 == i4)
    System.out.println(&quot;same objects&quot;);

    //Prints output
    same objects

I&#39;m so confused! When I try this out on my own it seems that you cannot use the == to compare the same way you would use equals() method. Using the == always gives me &#39;false&#39; even if the Integer variables are set to the same value (i.e. 10). Am I correct? Using the == to compare the same Integer object (with same values) will always result in &#39;false&#39;

Using == operator in Java to compare wrapper objects

I found the following code in a JS project:

    var a = new Array();
    a[0] = 0;
    for (var b = 0; b &lt; 10; b++) {
      a[0] |= b; 
    }

What does the `|=` do in the body of the for loop?

The code example is dubious, but has been presented [here](http://www.html5rocks.com/en/tutorials/speed/v8/#toc-topic-numbers) by V8 for an example of improved performance.

**Updated Example**

The above example is equivalent to `var a = [15];` for most intents and purposes.  A more realistic example for the `|=` operator would be to set up binary flags in a single variable, for example on a permission object:

    //Set up permission masks
    var PERMISSION_1_MASK = parseInt(&#39;0001&#39;,2);
    var PERMISSION_2_MASK = parseInt(&#39;0010&#39;,2);
    ..

    //Set up permissions
    userPermissions = 0;
    userPermissions |= hasPermissionOne &amp;&amp; PERMISSION_1_MASK;
    userPermissions |= hasPermissionTwo &amp;&amp; PERMISSION_2_MASK;
    ..

    //Use permissions
    if(userPermissions &amp; PERMISSION_1_MASK){
        ..//Do stuff only allowed by permission 1
    }

What does the operator |= do in JavaScript?

I have the following code:

    # initialize
    a = []
    
    # create the table (name, age, job)
    a.append([&quot;Nick&quot;, 30, &quot;Doctor&quot;])
    a.append([&quot;John&quot;,  8, &quot;Student&quot;])
    a.append([&quot;Paul&quot;, 22, &quot;Car Dealer&quot;])
    a.append([&quot;Mark&quot;, 66, &quot;Retired&quot;])    
    
    # sort the table by age
    import operator
    a.sort(key=operator.itemgetter(1))    
    
    # print the table
    print(a)

It creates a 4x3 table and then it sorts it by age. My question is, what exactly `key=operator.itemgetter(1)` does? Does the `operator.itemgetter` function return the item&#39;s value? Why can&#39;t I just type something like `key=a[x][1]` there? Or can I? How could with operator print a certain value of the form like `3x2` which is `22`?

1. How does exactly Python sort the table? Can I reverse-sort it?

2. How can I sort it based on two columns like first age, and then if age is the same b name?

3. How could I do it without `operator`?


How do operator.itemgetter() and sort() work?

I notice that I can do things like `2 &lt;&lt; 5` to get 64 and `1000 &gt;&gt; 2` to get 250.

Also I can use `&gt;&gt;` in `print`:

    print &gt;&gt;obj, &quot;Hello world&quot;

What is happening here?

Content Type	Original Author	Original Content on Stackoverflow
Question	Colin DeClue	View Question on Stackoverflow
Solution 1 - Python	Karl Knechtel	View Answer on Stackoverflow
Solution 2 - Python	Cat Plus Plus	View Answer on Stackoverflow

Python: multiplication override

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

split an array into two based on a index in javascript

minidump vs. fulldump?

Attributions