This means, that you should rewrite your code as:

    logging.debug(&quot;detect mimetypes faild because %s&quot;, e)

According to https://docs.python.org/2/library/logging.html

&gt; **Logger.debug(msg, *args, **kwargs)**
&gt; 
&gt; ... Logs a message with level DEBUG on this logger. _The `msg` is the message format string, and the `args` are the arguments which are merged into msg using the string formatting operator._ (Note that this means that you can use keywords in the format string, together with a single dictionary argument.) ...

Could you please explain, why does Console.WriteLine write empty line (`Console.WriteLine(null)` give me compilation error) and why there isn&#39;t NullReferenceException (even `a+=1` shouldn&#39;t raise it)?

    int? a = null;
    a++; // Why there is not NullReferenceException? 
    Console.WriteLine(a); // Empty line

Why doesn&#39;t incrementing Nullable&lt;int&gt; throw an exception?

I want to do

    Model.where(&#39;id = ?&#39;, [array of values])

How do I accomplish this look up without chaining OR statements together?


ActiveRecord where field = ? array of possible values

I am using prospector to examine my code. Pylint returned a `logging-not-lazy` warning about my debug message.

    Line: 31
      pylint: logging-not-lazy / Specify string format arguments as logging function parameters (col 16)   Line: 42
      pylint: logging-not-lazy / Specify string format arguments as logging function parameters (col 12)

My code is:

    logging.debug(&quot;detect mimetypes faild because %s&quot; % e )

How do I fix `logging-not-lazy` in pylint?

How to fix pylint logging-not-lazy?

I am using prospector to examine my code. Pylint returned a <code>logging-not-lazy</code> warning about my debug message.
<pre><code class="hljs language-lua">Line: 31
 pylint: logging-not-lazy / Specify string format arguments as logging function parameters (col 16) Line: 42
 pylint: logging-not-lazy / Specify string format arguments as logging function parameters (col 12)
</code></pre>
My code is:
<pre><code class="hljs language-lua">logging.debug("detect mimetypes faild because %s" % e )
</code></pre>
How do I fix <code>logging-not-lazy</code> in pylint?

I am working to set up a Django project on Amazon EC2 with an Ubuntu 14.04 LTS instance. I want to write my code using Python 3. I&#39;ve been advised that the best way to do this is to use `virtualenvwrapper`. I&#39;ve installed `virtualenvwrapper` successfully and put

    export WORKON_HOME=$HOME/.virtualenvs
    export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3.4
    export PROJECT_HOME=$HOME/Devel
    source /usr/local/bin/virtualenvwrapper.sh

into my `.bashrc` file. Now I see:

     /usr/bin/python3.4: Error while finding spec for &#39;virtualenvwrapper.hook_loader&#39; (&lt;class &#39;ImportErro
     r&#39;&gt;: No module named &#39;virtualenvwrapper&#39;)
     virtualenvwrapper.sh: There was a problem running the initialization hooks.     

     If Python could not import the module virtualenvwrapper.hook_loader,
     check that virtualenvwrapper has been installed for
     VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3.4 and that PATH is
     set properly.

How can I fix this?

No module named &#39;virtualenvwrapper&#39;

I have a dataframe with Multiindex and would like to modify one particular level of the Multiindex. For instance, the first level might be strings and I may want to remove the white spaces from that index level:

    df.index.levels[1] = [x.replace(&#39; &#39;, &#39;&#39;) for x in df.index.levels[1]]

However, the code above results in an error:

    TypeError: &#39;FrozenList&#39; does not support mutable operations.

I know I can reset_index and modify the column and then re-create the Multiindex, but I wonder whether there is a more elegant way to modify one particular level of the Multiindex directly.


Pandas: Modify a particular level of Multiindex

I am trying to understand the difference between these two approaches of mocking a method.  Could someone please help distinguish them?  For this example, I use the passlib library.


    from passlib.context import CryptContext
    from unittest import mock
    
    with mock.patch.object(CryptContext, &#39;verify&#39;, return_value=True) as foo1:
        mycc = CryptContext(schemes=&#39;bcrypt_sha256&#39;)
        mypass = mycc.encrypt(&#39;test&#39;)
        assert mycc.verify(&#39;tesssst&#39;, mypass)
    
    with mock.patch(&#39;passlib.context.CryptContext.verify&#39;, return_value=True) as foo2:
        mycc = CryptContext(schemes=&#39;bcrypt_sha256&#39;)
        mypass = mycc.encrypt(&#39;test&#39;)
        assert mycc.verify(&#39;tesssst&#39;, mypass)

What is the difference between mock.patch.object(... and mock.patch(

I&#39;m trying to apply a function to all rows of a pandas DataFrame (actually just one column in that DataFrame)

I&#39;m sure this is a syntax error but I&#39;m know sure what I&#39;m doing wrong

    df[&#39;col&#39;].apply(lambda x, y:(x - y).total_seconds(), args=[d1], axis=1)

The `col` column contains a bunch a `datetime.datetime` objects and and `d1` is the earliest of them.  I&#39;m trying to get a column of the total number of seconds for each of the rows

**EDIT** I keep getting the following error

    TypeError: &lt;lambda&gt;() got an unexpected keyword argument &#39;axis&#39;

I don&#39;t understand why `axis` is getting passed to my `lambda` function

**EDIT 2**

I&#39;ve also tried doing

    def diff_dates(d1, d2):
        return (d1-d2).total_seconds()

    df[&#39;col&#39;].apply(diff_dates, args=[d1], axis=1)

And I get the same error

Trouble passing in lambda to apply for pandas DataFrame

Till now, I used to end my Tkinter programs with: `tk.mainloop()`, or nothing would show up! See example:

    from Tkinter import *
    import random
    import time
    
    tk = Tk()
    tk.title = &quot;Game&quot;
    tk.resizable(0,0)
    tk.wm_attributes(&quot;-topmost&quot;, 1)
    
    canvas = Canvas(tk, width=500, height=400, bd=0, highlightthickness=0)
    canvas.pack()
    
    class Ball:
        def __init__(self, canvas, color):
            self.canvas = canvas
            self.id = canvas.create_oval(10, 10, 25, 25, fill=color)
            self.canvas.move(self.id, 245, 100)
        def draw(self):
            pass
    
    ball = Ball(canvas, &quot;red&quot;)
    
    tk.mainloop()

However, when tried the next step in this program (making the ball move by time), the book am reading from, says to do the following. So I changed the draw function to:

    def draw(self):
        self.canvas.move(self.id, 0, -1)

and add the following code to my program:

    while 1:
        ball.draw()
        tk.update_idletasks()
        tk.update()
        time.sleep(0.01)

But I noticed that adding this block of code, made the use of `tk.mainloop()` useless, since everything would show up even without it!!!

*At this moment I should mention that my book never talks about `tk.mainloop()` (maybe because it uses Python 3) but I learned about it searching the web since my programs didn&#39;t work by copying book&#39;s code!*

So I tried doing the following that would not work!!!

    while 1:
        ball.draw()
        tk.mainloop()
        time.sleep(0.01)

What&#39;s going on? What does `tk.mainloop()`? What does `tk.update_idletasks()` and `tk.update()` do and how that differs from `tk.mainloop()`? Should I use the above loop?`tk.mainloop()`? or both in my programs?



Tkinter understanding mainloop

For the following code:

    logger.debug(&#39;message: {}&#39;.format(&#39;test&#39;))

`pylint` produces the following warning:

&gt; **logging-format-interpolation (W1202):**
&gt; 
&gt; Use % formatting in logging functions and pass the % parameters as
&gt; arguments Used when a logging statement has a call form of
&gt; “logging.&lt;logging method&gt;(format_string.format(format_args...))”. Such
&gt; calls should use % formatting instead, but leave interpolation to the
&gt; logging function by passing the parameters as arguments.

I know I can turn off this warning, but I&#39;d like to understand it. I assumed using `format()` is the preferred way to print out statements in Python 3. Why is this not true for logger statements?

PyLint message: logging-format-interpolation

Imagine a function which *dynamically* adds attributes to an object using `setattr`. The reason for doing so is that I want to map some external structure (e.g. a given parameter tree) to an object:

    my_object = SomeClass()
    apply_structure(my_object, some_descriptor)
    my_object.device1.enabled = True

Technically this works but of course Pylint rightly complains about &#39;device1&#39; being not a member of `SomeClass`.

I could disable the warning but that would be bad (because I still want to get the warning in all cases when the attribute does not exist because of misspelling, etc).

Is there a common and legal (Pylint-proof) way to dynamically add members to an object that not leads to warnings?

Alternatively: Can I disable Pylint for just one *object* rather than a line/block/file?

**Explanation**:

You might wonder why I should equip an object with member attributes dynamically when I plan to access these attributes in a hard-coded way later.

The reason is: I have a dynamic part of the program (where the decoration happens) and a static part which is *specialized* for a certain *scenario*. So I **could** also create a static class for this scenario but that would be overkill in a lot of situations. 

The following *specialized* code might allow access to some parameter of a device which might be attached to some bus:

    class MyDeviceHandler:
       on_get_some_subtree_element(self):
          return _some_internal_value
       on_set_some_subtree_element(self, value):
          _some_internal_value = value

    dev = MyDeviceHandler()
    
    decorate_object_with_device_structure(dev, &#39;some/attached/device&#39;)

    dev.some.subtree.element = 5       &lt;--- will call the set-callback
    x = dev.some.subtree.element       &lt;--- will call the get-callback

So the structure behind `&#39;some/attached/device&#39;` might be arbitrary and very complex and I don&#39;t want to reproduce it in a class structure.

One way to get rid of this warning would be to create/access a `dict` based tree:

    dev[&#39;some&#39;][&#39;subtree&#39;][&#39;element&#39;] = 5

But this is harder to write and not nice to read - I would only do this to quieten Pylint.


Avoid Pylint warning E1101: &#39;Instance of .. has no .. member&#39; for class with dynamic attributes

I have 

    find . -iname &quot;*.py&quot; -exec pylint -E {} ;\

and

    FILES=$(find . -iname &quot;*.py&quot;)
    pylint -E $FILES

If I understand correctly, the first command will run pylint for each of the Python files, the second one will run pylint once for all files. I expected that both commands would return the same output, but they return different results. I think this diff is somehow related to imports and F (failure) pylint messages, which occurs when a import fails and is *not* output by pylint -E. 

Has someone already experienced this and could explain why the diff happens and what is the best way to run pylint?

Run Pylint for all Python files in a directory and all subdirectories

I want to configure Pylint as an external tool in my entire project directory for a Python project that I&#39;m working on. I&#39;ve tried to use the repository as a module with ```__init__.py``` and without, and it&#39;s not working either way.

I&#39;m having difficulty setting up Pylint to run with PyCharm. I know that I should be running it as an external tool, however the settings confuse me.

The authoritative source on their documentation is broken, so I can&#39;t check that up either.



How to run Pylint with PyCharm

Considering this code snippet:

    from os import walk

    files = []
    for (dirpath, _, filenames) in walk(mydir):
        # More code that modifies files
    if len(files) == 0: # &lt;-- C1801
        return None

I was alarmed by Pylint with this message regarding the line with the if statement:

&gt; [pylint] C1801:Do not use `len(SEQUENCE)` as condition value

The rule C1801, at first glance, did not sound very reasonable to me, and the [definition on the reference guide][1] does not explain why this is a problem. In fact, it downright calls it an _incorrect use_.

&gt; **len-as-condition (C1801)**:
&gt;      _Do not use `len(SEQUENCE)` as condition value Used when Pylint detects incorrect use of len(sequence) inside conditions._

My search attempts have also failed to provide me a deeper explanation. I do understand that a sequence&#39;s length property may be lazily evaluated, and that `__len__` can be programmed to have side effects, but it is questionable whether that alone is problematic enough for Pylint to call such a use incorrect. Hence, before I simply configure my project to ignore the rule, I would like to know whether I am missing something in my reasoning.

When is the use of `len(SEQ)` as a condition value problematic? What major situations is Pylint attempting to avoid with C1801?

  [1]: https://pylint.readthedocs.io/en/latest/reference_guide/features.html#id19




Content Type	Original Author	Original Content on Stackoverflow
Question	Valeriy Solovyov	View Question on Stackoverflow
Solution 1 - Python	Zada Zorg	View Answer on Stackoverflow

How to fix pylint logging-not-lazy?

Python Problem Overview

Python Solutions

Solution 1 - Python

ActiveRecord where field = ? array of possible values

Why doesn't incrementing Nullable<int> throw an exception?

Attributions