Yes, `if bar is not None` is more explicit, and thus better, assuming it is indeed what you want. That&#39;s not always the case, there are subtle differences: `if not bar:` will execute if `bar` is any kind of zero or empty container, or `False`.
Many people do use `not bar` where they *really do* mean `bar is not None`.

I am trying to move only the contents of one repository (`repo1`) to another existing repository (`repo2`) using the following commands:

    git clone repo1
    git clone repo2
    cd repo1
    git remote rm origin
    git remote add repo1
    git push

But it&#39;s not working. I reviewed a similar post, but I only found one moving the folder, not the contents.



Moving Git repository content to another repository preserving history

I am trying to synchronise a project that I have on in my Android Studio folder to GitHub, but I am not fully sure what to do other than adding my credentials in the options menu. Could someone give me a quick guide, please?


How do you synchronise projects to GitHub with Android Studio?

I&#39;m a bit confused about how/why so many python developers use `if not` in their conditional statements. 

for example, lets say we had a function, 

    def foo(bar = None):
        if not bar:
            bar = 2

But why go about this way? I mean, wouldn&#39;t doing `if bar != None` or `if bar is not None`be more explicit? What does `if not` try to say? 

Python &#39;If not&#39; syntax

I'm a bit confused about how/why so many python developers use <code>if not</code> in their conditional statements.
for example, lets say we had a function,
<pre><code class="hljs language-ini">def foo(bar = None):
 if not bar:
 bar = 2
</code></pre>
But why go about this way? I mean, wouldn't doing <code>if bar != None</code> or <code>if bar is not None</code>be more explicit? What does <code>if not</code> try to say?

Which is the most recommended/pythonic way of handling live incoming data with pandas?

Every few seconds I&#39;m receiving a data point in the format below:


    {&#39;time&#39; :&#39;2013-01-01 00:00:00&#39;, &#39;stock&#39; : &#39;BLAH&#39;,
     &#39;high&#39; : 4.0, &#39;low&#39; : 3.0, &#39;open&#39; : 2.0, &#39;close&#39; : 1.0}


I would like to append it to an existing DataFrame and then run some analysis on it.

The problem is, just appending rows with DataFrame.append can lead to performance issues with all that copying.


### Things I&#39;ve tried:

A few people suggested preallocating a big DataFrame and updating it as data comes in:

    In [1]: index = pd.DatetimeIndex(start=&#39;2013-01-01 00:00:00&#39;, freq=&#39;S&#39;, periods=5)
    
    In [2]: columns = [&#39;high&#39;, &#39;low&#39;, &#39;open&#39;, &#39;close&#39;]
    
    In [3]: df = pd.DataFrame(index=t, columns=columns)
    
    In [4]: df
    Out[4]: 
                        high  low open close
    2013-01-01 00:00:00  NaN  NaN  NaN   NaN
    2013-01-01 00:00:01  NaN  NaN  NaN   NaN
    2013-01-01 00:00:02  NaN  NaN  NaN   NaN
    2013-01-01 00:00:03  NaN  NaN  NaN   NaN
    2013-01-01 00:00:04  NaN  NaN  NaN   NaN
    
    In [5]: data = {&#39;time&#39; :&#39;2013-01-01 00:00:02&#39;, &#39;stock&#39; : &#39;BLAH&#39;, &#39;high&#39; : 4.0, &#39;low&#39; : 3.0, &#39;open&#39; : 2.0, &#39;close&#39; : 1.0}
    
    In [6]: data_ = pd.Series(data)
    
    In [7]: df.loc[data[&#39;time&#39;]] = data_
    
    In [8]: df
    Out[8]: 
                        high  low open close
    2013-01-01 00:00:00  NaN  NaN  NaN   NaN
    2013-01-01 00:00:01  NaN  NaN  NaN   NaN
    2013-01-01 00:00:02    4    3    2     1
    2013-01-01 00:00:03  NaN  NaN  NaN   NaN
    2013-01-01 00:00:04  NaN  NaN  NaN   NaN

The other alternative is building a list of dicts. Simply appending the incoming data to a list and slicing it into smaller DataFrames to do the work.

    In [9]: ls = []
    
    In [10]: for n in range(5):
       .....:     # Naive stuff ahead =)
       .....:     time = &#39;2013-01-01 00:00:0&#39; + str(n)
       .....:     d = {&#39;time&#39; : time, &#39;stock&#39; : &#39;BLAH&#39;, &#39;high&#39; : np.random.rand()*10, &#39;low&#39; : np.random.rand()*10, &#39;open&#39; : np.random.rand()*10, &#39;close&#39; : np.random.rand()*10}
       .....:     ls.append(d)
    
    In [11]: df = pd.DataFrame(ls[1:3]).set_index(&#39;time&#39;)
    
    In [12]: df
    Out[12]: 
                            close      high       low      open stock
    time                                                             
    2013-01-01 00:00:01  3.270078  1.008289  7.486118  2.180683  BLAH
    2013-01-01 00:00:02  3.883586  2.215645  0.051799  2.310823  BLAH

or something like that, maybe processing the input a little bit more.

How to handle incoming real time data with python pandas

Basically, I&#39;ve read in several places that `socket.recv()` will return whatever it can read, or an empty string signalling that the other side has shut down  (the official docs don&#39;t even mention what it returns when the connection is shut down... great!). This is all fine and dandy for blocking sockets, since we know that `recv()` only returns when there actually is something to receive, so when it returns an empty string, it **MUST** mean the other side has closed the connection, right?

Okay, fine, but what happens when my socket is non-blocking?? I have searched a bit (maybe not enough, who knows?) and can&#39;t figure out how to tell when the other side has closed the connection using a non-blocking socket. There seems to be no method or attribute that tells us this, and comparing the return value of `recv()` to the empty string seems absolutely useless... is it just me having this problem?

As a simple example, let&#39;s say my socket&#39;s timeout is set to 1.2342342 (whatever non-negative number you like here) seconds and I call `socket.recv(1024)`, but the other side doesn&#39;t send anything during that 1.2342342 second period. The `recv()` call will return an empty string and I have no clue as to whether the connection is still standing or not...


What does Python&#39;s socket.recv() return for non-blocking sockets if no data is received until a timeout occurs?

I have a small GUI test with a &quot;Start&quot; button and a Progress bar. The desired behavior is:

- Click Start
- Progressbar oscillates for 5 seconds
- Progressbar stops

The observed behavior is the &quot;Start&quot; button freezes for 5 seconds, then a Progressbar is displayed (no oscillation).

Here is my code so far:

    class GUI:
        def __init__(self, master):
            self.master = master
            self.test_button = Button(self.master, command=self.tb_click)
            self.test_button.configure(
                text=&quot;Start&quot;, background=&quot;Grey&quot;,
                padx=50
                )
            self.test_button.pack(side=TOP)
        
        def progress(self):
            self.prog_bar = ttk.Progressbar(
                self.master, orient=&quot;horizontal&quot;,
                length=200, mode=&quot;indeterminate&quot;
                )
            self.prog_bar.pack(side=TOP)
            
        def tb_click(self):
            self.progress()
            self.prog_bar.start()
            # Simulate long running process
            t = threading.Thread(target=time.sleep, args=(5,))
            t.start()
            t.join()
            self.prog_bar.stop()
            
    root = Tk()
    root.title(&quot;Test Button&quot;)
    main_ui = GUI(root)
    root.mainloop()

Based on the information from Bryan Oakley [here](https://stackoverflow.com/questions/10847626/tkinter-program-freezing-durint-the-execution-of-a-function), I understand that I need to use threads. I tried creating a thread, but I&#39;m guessing that since the thread is started from within the main thread, it doesn&#39;t help.

I had the idea to place the logic portion in a different class, and instantiate the GUI from within that class, similar to the example code by A. Rodas [here](https://stackoverflow.com/questions/15323574/how-to-connect-a-progress-bar-to-a-function/15323917#15323917).

My question:

I can&#39;t figure out how to code it so that this command:

    self.test_button = Button(self.master, command=self.tb_click)

calls a function that is located in the other class. Is this a Bad Thing to do or is it even possible? How would I create a 2nd class that can handle the self.tb_click? I tried following along to A. Rodas&#39; example code which works beautifully. But I cannot figure out how to implement his solution in the case of a Button widget that triggers an action.

If I should instead handle the thread from within the single GUI class, how would one create a thread that doesn&#39;t interfere with the main thread?

Tkinter: How to use threads to preventing main event loop from &quot;freezing&quot;

How do I print a `bytes` string without the `b&#39;` prefix in Python 3?

```
&gt;&gt;&gt; print(b&#39;hello&#39;)
b&#39;hello&#39;
```

Print without b&#39; prefix for bytes in Python 3

I&#39;m trying to use in Python 3.3 an old library (dating from 2003!). When I import it, Python throws me an error because there are `&lt;&gt;` signs in the source file, e.g.:

    if (cnum &lt; 1000 and nnum &lt;&gt; 1000 and ntext[-1] &lt;&gt; &quot;s&quot;:
        ...

I guess it&#39;s a now-abandoned sign in the language.

What exactly does it mean, and which (more recent) sign should I replace it with?


What does `&lt;&gt;` mean in Python?

I&#39;m coding a REST API with [Django REST framework][1]. The API will be the backend of a social mobile app. After following the tutorial, I can serialise all my models and I am able to create new resources and update them.

I&#39;m using AuthToken for authentication.

My question is:

Once I have the `/users` resource, I want the app user to be able to register. So, is it better to have a separate resource like `/register` or allow anonymous users to POST to `/users` a new resource?

Also, some guidance about permissions would be great.

[1]: http://www.django-rest-framework.org/

How to register users in Django REST framework?

I want to define a class containing `read` and `write` methods, which can be called as follows:

    instance.read
    instance.write
    instance.device.read
    instance.device.write

To not use interlaced classes, my idea was to overwrite the `__getattr__` and `__setattr__` methods and to check, if the given name is `device` to redirect the return to `self`. But I encountered a problem giving infinite recursions. The example code is as follows:

    class MyTest(object):
        def __init__(self, x):
            self.x = x

        def __setattr__(self, name, value):
            if name==&quot;device&quot;:
                print &quot;device test&quot;
            else:
                setattr(self, name, value)

    test = MyTest(1)


As in `__init__` the code tried to create a new attribute `x`, it calls `__setattr__`, which again calls `__setattr__` and so on. How do I need to change this code, that, in this case, a new attribute `x` of `self` is created, holding the value `1`? 

Or is there any better way to handle calls like `instance.device.read` to be &#39;mapped&#39; to `instance.read`? 

As there are always questions about the why: I need to create abstractions of `xmlrpc` calls, for which very easy methods like `myxmlrpc.instance,device.read` and similar can be created. I need to &#39;mock&#39; this up to mimic such multi-dot-method calls.

How to use __setattr__ correctly, avoiding infinite recursion

I am trying to read an excel file this way :
    
    newFile = pd.ExcelFile(PATH\FileName.xlsx)
    ParsedData = pd.io.parsers.ExcelFile.parse(newFile)

which throws an error that says two arguments expected, I don&#39;t know what the second argument is and also what I am trying to achieve here is to convert an Excel file to a DataFrame, Am I doing it the right way? or is there any other way to do this using pandas?



Reading an Excel file in python using pandas

I like to know, which is the best practice to declare dictionary in below 2 approaches and why?

    &gt;&gt;&gt;a=dict(one=2, two=3)  # {&quot;two&quot;:3, &quot;one&quot;:2}
    &gt;&gt;&gt;a={&quot;two&quot;:3, &quot;one&quot;:2}


dict() vs { } in python which is better?

I  want to obtain fig1 exactly of 4 by 3 inch sized, and in tiff format correcting the program below:

```py
import matplotlib.pyplot as plt

list1 = [3,4,5,6,9,12]
list2 = [8,12,14,15,17,20]

plt.plot(list1, list2)
plt.savefig(&#39;fig1.png&#39;, dpi = 300)
plt.close()
```

Content Type	Original Author	Original Content on Stackoverflow
Question	EdgarArout	View Question on Stackoverflow
Solution 1 - Python	user395760	View Answer on Stackoverflow

Python 'If not' syntax

Python Problem Overview

Python Solutions

Solution 1 - Python

How do you synchronise projects to GitHub with Android Studio?

Moving Git repository content to another repository preserving history

Attributions