You want `df.loc[df.index &lt; &#39;2013-10-16 08:00:00&#39;]` since you&#39;re selecting by label (index) and not by value.

[selecting by label][1]


  [1]: http://pandas.pydata.org/pandas-docs/stable/indexing.html#selection-by-label

You can use [`query`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.query.html) for a more concise option:

    df.query(&quot;index &lt; &#39;2013-10-16 08:00:00&#39;&quot;)

Right now I am detecting the end of my ValueAnimator by checking when the progress has reached 100...

    //Setup the animation
    ValueAnimator anim = ValueAnimator.ofInt(progress, seekBar.getMax());
    
    //Set the duration
    
    anim.setDuration(Utility.setAnimationDuration(progress));
    
    anim.addUpdateListener(new AnimatorUpdateListener() 
    {

        @Override
        public void onAnimationUpdate(ValueAnimator animation) 
        {
            int animProgress = (Integer) animation.getAnimatedValue();
            
            if ( animProgress == 100)
            {
            	//Done
            }
            	
            else
            {
            	seekBar.setProgress(animProgress);
            }
        }
    });

Is this the correct way?  I read through the docs and couldn&#39;t find any kind listener or callback for when it completes.  I tried using `isRunning()` but it didn&#39;t work as well.

Detecting when ValueAnimator is done

I have read the Ansible documentation but I am still a bit confused about the three following parameters in ansible playbooks: user, sudo, sudo_user. 

I have tried the following playbooks with different combination of the parameters:

1. user:deploy =&gt; Works

2. user:deploy and sudo: True =&gt; **Hangs on the git task**

3. user:deploy, sudo: True and sudo_user: deploy =&gt; Works

What does sudo_user actually do?
When and why should I use each of these combinations?

    - hosts: all
      user: deploy
      sudo: True
      sudo_user: deploy
     
      tasks:
          - name: Ensure code directory
            file: dest=/home/deploy/code state=directory
      
          - name: Deploy app
            git: repo=git@bitbucket.org:YAmikep/djangotutorial.git dest=/home/deploy/code


Thanks

user vs sudo vs sudo_user in ansible playbooks

I have a pandas DataFrame from 6:36 AM to 5:31 PM.  I want to remove all observations where the time is less than 8:00:00 AM.  Here is my attempt:

    df = df[df.index &lt; &#39;2013-10-16 08:00:00&#39;]

This does nothing, please help.

Filter Pandas DataFrame by time index

I have a pandas DataFrame from 6:36 AM to 5:31 PM. I want to remove all observations where the time is less than 8:00:00 AM. Here is my attempt:
<pre><code class="hljs language-bash">df = df[df.index &#x3C; '2013-10-16 08:00:00']
</code></pre>
This does nothing, please help.

Is there a way to remove a NaN values from a panda series? I have a series that may or may not have some NaN values in it, and I&#39;d like to return a copy of the series with all the NaNs removed.

Remove NaN from pandas series

Restarting the Django server displays the following error:

    this port is already running....

This problem occurs specifically on Ubuntu and not other operating systems. How can I free up the port to restart the server?


Django Server Error: port is already in use

I have the following lines of code that initialize logging.
I comment one out and leave the other to be used. 
The problem that I&#39;m facing is that the one that is meant to log to the file not logging to file. It is instead logging to the console.
Please help.

## For logging to Console:

    logging.basicConfig(level=logging.INFO,
            format=&#39;%(asctime)s [%(levelname)s] (%(threadName)-10s) %(message)s&#39;,)



## for file logging

    logging.basicConfig(filename=&#39;server-soap.1.log&#39;,level=logging.INFO,
            format=&#39;%(asctime)s [%(levelname)s] (%(threadName)-10s) %(message)s&#39;)

python logging file is not working when using logging.basicConfig

I have two files

spike.py
    
    class T1(object):
        def foo(self, afd):
            return &quot;foo&quot;
    
        def get_foo(self):
            return self.foo(1)
    
    
    def bar():
        return &quot;bar&quot;

test_spike.py:
    
    from unittest import TestCase
    import unittest
    from mock import patch, MagicMock
    from spike import T1, bar
    
    
    class TestStuff(TestCase):
        @patch(&#39;spike.T1.foo&#39;, MagicMock(return_value=&#39;patched&#39;))
        def test_foo(self):
            foo = T1().get_foo()
            self.assertEqual(&#39;patched&#39;, foo)
    
        @patch(&#39;spike.bar&#39;)
        def test_bar(self, mock_obj):
            mock_obj.return_value = &#39;patched&#39;
            bar = bar()
            self.assertEqual(&#39;patched&#39;, bar)
    
    
    if __name__ == &quot;__main__&quot;:
        unittest.main()

When I run `python test_spike.py`, the first test case would pass, but the second would fail.
and I switch to use `nosetests test_spike.py`, then both two are failed.

I don&#39;t understand how this happened? These cases supposed to pass all.

Why python mock patch doesn&#39;t work?

This message is a a bit long with many examples, but I hope it
will help me and others to better grasp the full story of variables
and attribute lookup in Python 2.7. 

I am using the terms of PEP 227
(http://www.python.org/dev/peps/pep-0227/) for code blocks (such as
modules, class definition, function definitions, etc.) and
variable bindings (such as assignments, argument declarations, class
and function declaration, for loops, etc.)

I am using the terms variables for names that can be called without a
dot, and attributes for names that need to be qualified with an object
name (such as obj.x for the attribute x of object obj).

There are three scopes in Python for all code blocks, but the functions:

 - Local
 - Global
 - Builtin


There are four blocks in Python for the functions only (according to
PEP 227):

 - Local
 - Enclosing functions
 - Global
 - Builtin

The rule for a variable to bind it to and find it in a block is
quite simple:

 - any binding of a variable to an object in a block makes this variable
local to this block, unless the variable is declared global (in that
case the variable belongs to the global scope)
 - a reference to a variable is looked up using the rule LGB (local,
global, builtin) for all blocks, but the functions
 - a reference to a variable is looked up using the rule LEGB (local,
enclosing, global, builtin) for the functions only. 

Let me know take examples validating this rule, and showing many
special cases. For each example, I will give my understanding. Please
correct me if I am wrong. For the last example, I don&#39;t understand the
outcome. 

example 1:

    x = &quot;x in module&quot;
    class A():
        print &quot;A: &quot;  + x                    #x in module
        x = &quot;x in class A&quot;
        print locals()
        class B():
            print &quot;B: &quot; + x                 #x in module
            x = &quot;x in class B&quot;
            print locals()
            def f(self):
                print &quot;f: &quot; + x             #x in module
                self.x = &quot;self.x in f&quot;
                print x, self.x
                print locals()
 
    &gt;&gt;&gt;A.B().f()
    A: x in module
    {&#39;x&#39;: &#39;x in class A&#39;, &#39;__module__&#39;: &#39;__main__&#39;}
    B: x in module
    {&#39;x&#39;: &#39;x in class B&#39;, &#39;__module__&#39;: &#39;__main__&#39;}
    f: x in module
    x in module self.x in f
    {&#39;self&#39;: &lt;__main__.B instance at 0x00000000026FC9C8&gt;}

There is no nested scope for the classes (rule LGB) and a function in
a class cannot access the attributes of the class without using a
qualified name (self.x in this example). This is well described in
PEP227. 

example 2:

    z = &quot;z in module&quot;
    def f():
        z = &quot;z in f()&quot;
        class C():
            z = &quot;z in C&quot;
            def g(self):
                print z
                print C.z
        C().g()
    f()
    &gt;&gt;&gt; 
    z in f()
    z in C

Here variables in functions are looked up using the LEGB rule, but if
a class is in the path, the class arguments are skipped. Here again,
this is what PEP 227 is explaining.

example 3: 

    var = 0
    def func():
        print var
        var = 1
    &gt;&gt;&gt; func()

    Traceback (most recent call last):
      File &quot;&lt;pyshell#102&gt;&quot;, line 1, in &lt;module&gt;
	func()
      File &quot;C:/Users/aa/Desktop/test2.py&quot;, line 25, in func
	print var
    UnboundLocalError: local variable &#39;var&#39; referenced before assignment


We expect with a dynamic language such as python that everything is
resolved dynamically. But this is not the case for functions. Local
variables are determined at compile time. PEP 227  and 
http://docs.python.org/2.7/reference/executionmodel.html describe this
behavior this way

 &quot;If a name binding operation occurs anywhere within a code block, all
uses of the name within the block are treated as references to the
current block.&quot;

example 4: 

    x = &quot;x in module&quot;
    class A():
        print &quot;A: &quot; + x
        x = &quot;x in A&quot;
        print &quot;A: &quot; + x
        print locals()
        del x
        print locals()
        print &quot;A: &quot; + x
    &gt;&gt;&gt; 
    A: x in module
    A: x in A
    {&#39;x&#39;: &#39;x in A&#39;, &#39;__module__&#39;: &#39;__main__&#39;}
    {&#39;__module__&#39;: &#39;__main__&#39;}
    A: x in module

But we see here that this statement in PEP227 &quot;If a name binding
operation occurs anywhere within a code block, all uses of the name
within the block are treated as references to the current block.&quot;  is
wrong when the code block is a class. Moreover, for classes, it seems
that local name binding is not made at compile time, but during
execution using the class namespace. In that respect,
PEP227 and the execution model in the Python doc is misleading and for
some parts wrong. 

example 5:

    x = &#39;x in module&#39;
    def  f2():
        x = &#39;x in f2&#39;
        def myfunc():
            x = &#39;x in myfunc&#39;
            class MyClass(object):
                x = x
                print x
            return MyClass
        myfunc()
    f2()
    &gt;&gt;&gt; 
    x in module

my understanding of this code is the following. The instruction x = x
first look up the object the right hand x of the expression is referring
to. In that case, the object is looked up locally in the class, then
following the rule LGB it is looked up in the global scope, which is
the string &#39;x in module&#39;. Then a local attribute x to MyClass is
created in the class dictionary and pointed to the string object. 

example 6: 

Now here is an example I cannot explain.
It is very close to example 5, I am just changing the local MyClass
attribute from x to y.

    x = &#39;x in module&#39;
    def  f2():
        x = &#39;x in f2&#39;
        def myfunc():
            x = &#39;x in myfunc&#39;
            class MyClass(object):
                y = x
                print y
            return MyClass
        myfunc()
    f2()
    &gt;&gt;&gt;
    x in myfunc

Why in that case the x reference in MyClass is looked up in the
innermost function? 



How references to variables are resolved in Python

I have a dictionary which looks like this: `di = {1: &quot;A&quot;, 2: &quot;B&quot;}`

I would like to apply it to the `col1` column of a dataframe similar to:

         col1   col2
    0       w      a
    1       1      2
    2       2    NaN

to get:

         col1   col2
    0       w      a
    1       A      2
    2       B    NaN

How can I best do this? For some reason googling terms relating to this only shows me links about how to make columns from dicts and vice-versa :-/ 

Remap values in pandas column with a dict, preserve NaNs

Is it feasible to sort pandas dataframe by values of a column, but also by index?

If you sort a pandas dataframe by values of a column, you can get the resultant dataframe sorted by the column, but unfortunately, you see the order of your dataframe&#39;s index messy within the same value of a sorted column.

So, can I sort a dataframe by a column, such as the column named `count` but also sort it by the value of index? And is it also feasible to sort a column by descending order, but whereas sort a index by ascending order?

I know how to sort multiple columns in dataframe, and also know I can achieve what I&#39;m asking here by first `reset_index()` the index and sort it, and then create the index again. But is it more intuitive and efficient way to do it?

Sort pandas dataframe both on values of a column and index?

I understand that to drop a column you use df.drop(&#39;column name&#39;, axis=1). Is there a way to drop a column using a numerical index instead of the column name?

python dataframe pandas drop column using int

How do you programmatically retrieve the number of columns in a pandas dataframe? I was hoping for something like:

    df.num_columns

Content Type	Original Author	Original Content on Stackoverflow
Question	user2113095	View Question on Stackoverflow
Solution 1 - Python	Kevin Stone	View Answer on Stackoverflow
Solution 2 - Python	rachwa	View Answer on Stackoverflow

Filter Pandas DataFrame by time index

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

user vs sudo vs sudo_user in ansible playbooks

Detecting when ValueAnimator is done

Attributions