I have installed **Python version** **3.4.0** and I would like to do a project with MySQL database. I downloaded and tried installing **MySQLdb**, but it wasn&#39;t successful for this version of Python.

Any suggestions how could I fix this problem and install it properly?

Python 3.4.0 with MySQL database

Python 3.4.0 introduced `enum`, I&#39;ve read the [doc][1] but still don&#39;t know the usage of it. From my perspective, `enum.Enum` is an extended `namedtuple` type, which may not be true. So these are what I want to know about `Enum`:

1. When and where to use `Enum`?
2. Why do we need `Enum`? What are the advantages?
3. What exactly is an `Enum`?

[1]:https://docs.python.org/3/library/enum.html

Python Enum, when and where to use?

Python 3.4 [added][1] the ability to define function overloading with static methods. This is essentially the example from the documentation:

    from functools import singledispatch
    
    
    class TestClass(object):
        @singledispatch
        def test_method(arg, verbose=False):
            if verbose:
                print(&quot;Let me just say,&quot;, end=&quot; &quot;)
    
            print(arg)
    
        @test_method.register(int)
        def _(arg):
            print(&quot;Strength in numbers, eh?&quot;, end=&quot; &quot;)
            print(arg)
    
        @test_method.register(list)
        def _(arg):
            print(&quot;Enumerate this:&quot;)
    
            for i, elem in enumerate(arg):
                print(i, elem)
    
    if __name__ == &#39;__main__&#39;:
        TestClass.test_method(55555)
        TestClass.test_method([33, 22, 11])

In its purest form, the `singledispatch` implementation relies on the first argument to identify type, therefore making it tricky to extend this functionality to instance methods. 

Does anyone have any advice for how to use (or jerry-rig) this functionality to get it to work with instance methods?


  [1]: https://docs.python.org/3/library/functools.html#functools.singledispatch

How can I use functools.singledispatch with instance methods?

I am learning asyncio with Python 3.4.2 and I use it to continuously listen on an IPC bus, while gbulb listens on the DBus.

I created a function `listen_to_ipc_channel_layer` that continuously listens for incoming messages on the IPC channel and passes the message to `message_handler`.

I am also listening to SIGTERM and SIGINT. When I send a SIGTERM to the python process running the code you find at the bottom, the script should terminate gracefully.

The problem I am having is the following warning:

```none
got signal 15: exit
Task was destroyed but it is pending!
task: &lt;Task pending coro=&lt;listen_to_ipc_channel_layer() running at /opt/mainloop-test.py:23&gt; wait_for=&lt;Future cancelled&gt;&gt;

Process finished with exit code 0
```

…with the following code:

    import asyncio
    import gbulb
    import signal
    import asgi_ipc as asgi
    
    def main():
        asyncio.async(listen_to_ipc_channel_layer())
        loop = asyncio.get_event_loop()
    
        for sig in (signal.SIGINT, signal.SIGTERM):
            loop.add_signal_handler(sig, ask_exit)
    
        # Start listening on the Linux IPC bus for incoming messages
        loop.run_forever()
        loop.close()
    
    @asyncio.coroutine
    def listen_to_ipc_channel_layer():
        &quot;&quot;&quot;Listens to the Linux IPC bus for messages&quot;&quot;&quot;
        while True:
            message_handler(message=channel_layer.receive([&quot;my_channel&quot;]))
            try:
                yield from asyncio.sleep(0.1)
            except asyncio.CancelledError:
                break

    def ask_exit():
        loop = asyncio.get_event_loop()
        for task in asyncio.Task.all_tasks():
            task.cancel()
        loop.stop()
    
    
    if __name__ == &quot;__main__&quot;:
        gbulb.install()
        # Connect to the IPC bus
        channel_layer = asgi.IPCChannelLayer(prefix=&quot;my_channel&quot;)
        main()

I still only understand very little of asyncio, but I think I know what is going on. While waiting for `yield from asyncio.sleep(0.1)` the signal handler caught the SIGTERM and in that process it calls `task.cancel()`.

Shouldn&#39;t this trigger the `CancelledError` within the `while True:` loop? (Because it is not, but that is how I understand [&quot;Calling cancel() will throw a CancelledError to the wrapped coroutine&quot;](https://docs.python.org/3.4/library/asyncio-task.html#task)).

Eventually `loop.stop()` is called which stops the loop without waiting for either `yield from asyncio.sleep(0.1)` to return a result or even the whole coroutine `listen_to_ipc_channel_layer`.

Please correct me if I am wrong.

I think the only thing I need to do is to make my program wait for the `yield from asyncio.sleep(0.1)` to return a result *and/or* coroutine to break out the while loop and finish.

I believe I confuse a lot of things. Please help me get those things straight so that I can figure out how to gracefully close the event loop without warning.

Please explain &quot;Task was destroyed but it is pending!&quot; after cancelling tasks

What is the BEST way to clear out all the `__pycache__`  folders and `.pyc/.pyo` files from a python3 project. I have seen multiple users suggest the `pyclean` script bundled with Debian, but this does not remove the folders. I want a simple way to clean up the project before pushing the files to my DVS.

Python3 project remove __pycache__ folders and .pyc files

I am using Ubuntu and have installed Python 2.7.5 and 3.4.0. In Python 2.7.5 I am able to successfully assign a variable `x = Value(&#39;i&#39;, 2)`, but not in 3.4.0. I am getting:

    Traceback (most recent call last):
       File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
       File &quot;/usr/local/lib/python3.4/multiprocessing/context.py&quot;, line 132, in Value
          from .sharedctypes import Value
       File &quot;/usr/local/lib/python3.4/multiprocessing/sharedctypes.py&quot;, line 10, in &lt;
    module&gt;
       import ctypes
       File &quot;/usr/local/lib/python3.4/ctypes/__init__.py&quot;, line 7, in &lt;module&gt;
          from _ctypes import Union, Structure, Array
    ImportError: No module named &#39;_ctypes&#39;
I just updated to 3.3.2 through installing the source of 3.4.0. It installed in */usr/local/lib/python3.4*.

Did I update to Python 3.4 correctly?

One thing I noticed that Python 3.4 is installed in *usr/local/lib*, while Python 3.3.2 is still installed in *usr/lib*, so it was not overwritten.

Python3: ImportError: No module named &#39;_ctypes&#39; when using Value from module multiprocessing

I&#39;m trying to split my huge class into two; well, basically into the &quot;main&quot; class and a mixin with additional functions, like so:

`main.py` file:

    import mymixin.py

    class Main(object, MyMixin):
        def func1(self, xxx):
            ...


`mymixin.py` file:

    class MyMixin(object):
        def func2(self: Main, xxx):  # &lt;--- note the type hint
            ...

Now, while this works just fine, the type hint in `MyMixin.func2` of course can&#39;t work. I can&#39;t import `main.py`, because I&#39;d get a cyclic import and without the hint, my editor (PyCharm) can&#39;t tell what `self` is.

I&#39;m using Python 3.4, but I&#39;m willing to move to 3.5 if a solution is available there.

Is there any way I can split my class into two files and keep all the &quot;connections&quot; so that my IDE still offers me auto-completion and all the other goodies that come from it knowing the types?

Python type hinting without cyclic imports

I have the following enum defined:

    from enum import Enum
    class D(Enum):
        x = 1
        y = 2

    print(D.x)

now the printed value is 

    D.x

instead, I wanted the enum&#39;s value to be print 

    1

What can be done to achieve this functionality?

Getting value of enum on string conversion

I want to do parallel http request tasks in `asyncio`, but I find that `python-requests` would block the event loop of `asyncio`. I&#39;ve found [aiohttp](https://github.com/KeepSafe/aiohttp) but it couldn&#39;t provide the service of http request using a http proxy.

So I want to know if there&#39;s a way to do asynchronous http requests with the help of `asyncio`.


How could I use requests in asyncio?

CentOS 7 EPEL now includes Python 3.4: `yum install python34`

However, when I try that, even though Python 3.4 installs successfully, it doesn&#39;t appear to install pip. Which is weird, because `pip` should be included by default with Python 3.4. `which pip3` doesn&#39;t find anything, nor does `which pip`. 

How do I access pip from the Python 3.4 package in CentOS 7 EPEL release?

How to install pip in CentOS 7?

I am trying to properly understand and implement two concurrently running [`Task`](https://docs.python.org/3/library/asyncio-task.html#task) objects using Python 3&#39;s relatively new [`asyncio`](https://docs.python.org/3/library/asyncio.html) module.

In a nutshell, asyncio seems designed to handle asynchronous processes and concurrent `Task` execution over an event loop. It promotes the use of `await` (applied in async functions) as a callback-free way to wait for and use a result, without blocking the event loop. (Futures and callbacks are still a viable alternative.)

It also provides the `asyncio.Task()` class, a specialized subclass of `Future`  designed to wrap coroutines. Preferably invoked by using the `asyncio.ensure_future()` method. The intended use of asyncio tasks is to allow independently running tasks to run &#39;concurrently&#39; with other tasks within the same event loop. My understanding is that `Tasks` are connected to the event loop which then automatically keeps driving the coroutine between `await` statements.

I like the idea of being able to use concurrent Tasks without needing to use one of the [`Executor`](https://docs.python.org/dev/library/concurrent.futures.html) classes, but I haven&#39;t found much elaboration on implementation. 

This is how I&#39;m currently doing it:

&lt;!-- lang-all: python --&gt;


    import asyncio
    
    print(&#39;running async test&#39;)
    
    async def say_boo():
        i = 0
        while True:
            await asyncio.sleep(0)
            print(&#39;...boo {0}&#39;.format(i))
            i += 1
    
    async def say_baa():
        i = 0
        while True:
            await asyncio.sleep(0)
            print(&#39;...baa {0}&#39;.format(i))
            i += 1
    
    # wrap in Task object
    # -&gt; automatically attaches to event loop and executes
    boo = asyncio.ensure_future(say_boo())
    baa = asyncio.ensure_future(say_baa())
    
    loop = asyncio.get_event_loop()
    loop.run_forever()

In the case of trying to concurrently run two looping Tasks, I&#39;ve noticed that unless the Task has an internal `await` expression, it will get stuck in the `while` loop, effectively blocking other tasks from running (much like a normal `while` loop). However, as soon the Tasks have to (a)wait, they seem to run concurrently without an issue. 

Thus, the `await` statements seem to provide the event loop with a foothold for switching back and forth between the tasks, giving the effect of concurrency.

Example output with internal `await`:

    running async test
    ...boo 0
    ...baa 0
    ...boo 1
    ...baa 1
    ...boo 2
    ...baa 2

Example output _without_ internal `await`:

    ...boo 0
    ...boo 1
    ...boo 2
    ...boo 3
    ...boo 4


# Questions

Does this implementation pass for a &#39;proper&#39; example of concurrent looping Tasks in `asyncio`? 

Is it correct that the only way this works is for a `Task` to provide a blocking point (`await` expression) in order for the event loop to juggle multiple tasks?

How to properly create and run concurrent tasks using python&#39;s asyncio module?

I installed `openpyxl` with

    $ pip install openpyxl

when I try the command

    from openpyxl import Workbook

I get

    Traceback (most recent call last):
     File &quot;&lt;pyshell#0&gt;&quot;, line 1, in &lt;module&gt;
    from openpyxl import Workbook
    ImportError: No module named &#39;openpyxl&#39;

I am using Python 3.4 and Ubuntu 14.04, 32-bit OS type

No module named &#39;openpyxl&#39; - Python 3.4 - Ubuntu

I am trying to create a stacked bar graph that replicates the picture, all my data is separate from that excel spreadsheet.

![enter image description here][1]

I cant figure out how to make a dataframe for it like pictured, nor can I figure out how to make the stacked bar chart. All examples I locate work in different ways to what I&#39;m trying to create.

My dataframe is a csv of all values narrowed down to the following with a pandas dataframe.

    
          Site Name	   Abuse/NFF
    0	 NORTH ACTON	   ABUSE
    1	 WASHINGTON	        -
    2	 WASHINGTON	       NFF
    3	 BELFAST	        -
    4	 CROYDON	        - 

I have managed to count the data with totals and get individual counts for each site, I just cant seem to combine it in a way to graph.

Would really appreciate some strong guidance.


  [1]: http://i.stack.imgur.com/z6Hzd.jpg


Completed code, many thanks for the assistance completing.

    test5 = faultdf.groupby([&#39;Site Name&#39;, &#39;Abuse/NFF&#39;])[&#39;Site Name&#39;].count().unstack(&#39;Abuse/NFF&#39;).fillna(0)

    test5.plot(kind=&#39;bar&#39;, stacked=True)
 

Pandas - Plotting a stacked Bar Chart

I was trying the following code:

    import asyncio
    
    @asyncio.coroutine
    def func_normal():
            print(&quot;A&quot;)
            yield from asyncio.sleep(5)
            print(&quot;B&quot;)
            return &#39;saad&#39;
    
    @asyncio.coroutine
    def func_infinite():
        i = 0
        while i&lt;10:
            print(&quot;--&quot;+str(i))
            i = i+1
        return(&#39;saad2&#39;)
    
    loop = asyncio.get_event_loop()
    
    tasks = [
        asyncio.async(func_normal()),
        asyncio.async(func_infinite())]
    
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()

I can&#39;t figure out how to get values in variables from these functions. I can&#39;t do this:

    asyncio.async(a = func_infinite())
as this would make this a keyword argument. How do I go about accomplishing this?

Getting values from functions that run as asyncio tasks

I am trying to call a Python file &quot;hello.py&quot; from within the python interpreter with subprocess. But I am unable to resolve this error. [Python 3.4.1]. 

    import subprocess    
    subprocess.call([&#39;hello.py&#39;, &#39;htmlfilename.htm&#39;])
    Traceback (most recent call last):
      File &quot;&lt;pyshell#42&gt;&quot;, line 1, in &lt;module&gt;
        subprocess.call([&#39;hello.py&#39;, &#39;htmlfilename.htm&#39;])
      File &quot;C:\Python34\lib\subprocess.py&quot;, line 537, in call
        with Popen(*popenargs, **kwargs) as p:
      File &quot;C:\Python34\lib\subprocess.py&quot;, line 858, in __init__
        restore_signals, start_new_session)
      File &quot;C:\Python34\lib\subprocess.py&quot;, line 1111, in _execute_child
        startupinfo)
    OSError: [WinError 193] %1 is not a valid Win32 application

Also is there any alternate way to &quot;call a python script with arguments&quot; other than using subprocess?

OSError: [WinError 193] %1 is not a valid Win32 application

I have an event loop that runs some co-routines as part of a command line tool. The user may interrupt the tool with the usual &lt;kbd&gt;Ctrl&lt;/kbd&gt; + &lt;kbd&gt;C&lt;/kbd&gt;, at which point I want to clean up properly after the interrupted event loop.

Here&#39;s what I tried.

&lt;!-- language: python --&gt;

    import asyncio
    
    
    @asyncio.coroutine
    def shleepy_time(seconds):
        print(&quot;Shleeping for {s} seconds...&quot;.format(s=seconds))
        yield from asyncio.sleep(seconds)
    
    
    if __name__ == &#39;__main__&#39;:
        loop = asyncio.get_event_loop()
    
        # Side note: Apparently, async() will be deprecated in 3.4.4.
        # See: https://docs.python.org/3.4/library/asyncio-task.html#asyncio.async
        tasks = [
            asyncio.async(shleepy_time(seconds=5)),
            asyncio.async(shleepy_time(seconds=10))
        ]
    
        try:
            loop.run_until_complete(asyncio.gather(*tasks))
        except KeyboardInterrupt as e:
            print(&quot;Caught keyboard interrupt. Canceling tasks...&quot;)
    
            # This doesn&#39;t seem to be the correct solution.
            for t in tasks:
                t.cancel()
        finally:
            loop.close()

Running this and hitting &lt;kbd&gt;Ctrl&lt;/kbd&gt; + &lt;kbd&gt;C&lt;/kbd&gt; yields:

    $ python3 asyncio-keyboardinterrupt-example.py 
    Shleeping for 5 seconds...
    Shleeping for 10 seconds...
    ^CCaught keyboard interrupt. Canceling tasks...
    Task was destroyed but it is pending!
    task: &lt;Task pending coro=&lt;shleepy_time() running at asyncio-keyboardinterrupt-example.py:7&gt; wait_for=&lt;Future cancelled&gt; cb=[gather.&lt;locals&gt;._done_callback(1)() at /usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/lib/python3.4/asyncio/tasks.py:587]&gt;
    Task was destroyed but it is pending!
    task: &lt;Task pending coro=&lt;shleepy_time() running at asyncio-keyboardinterrupt-example.py:7&gt; wait_for=&lt;Future cancelled&gt; cb=[gather.&lt;locals&gt;._done_callback(0)() at /usr/local/Cellar/python3/3.4.3/Frameworks/Python.framework/Versions/3.4/lib/python3.4/asyncio/tasks.py:587]&gt;

Clearly, I didn&#39;t clean up correctly. I thought perhaps calling `cancel()` on the tasks would be the way to do it.

What&#39;s the correct way to clean up after an interrupted event loop?

All Python 3.4 Solutions on Gang of Coders

Total of 16 Python 3.4 Solutions

Python 3.4.0 with MySQL database

Python Enum, when and where to use?

How can I use functools.singledispatch with instance methods?

Please explain "Task was destroyed but it is pending!" after cancelling tasks

Python3 project remove pycache folders and .pyc files

Python3: ImportError: No module named '_ctypes' when using Value from module multiprocessing