https://www.analyticsvidhya.com/learning-paths-data-science-business-analytics-business-intelligence-big-data/learning-path-data-science-python/

Comprehensive learning path – #Data_Science in Python
Journey from a Python noob to a Kaggler on Python

So, you want to become a data scientist or may be you are already one and want to expand your tool repository. You have landed at the right place. The aim of this page is to provide a comprehensive learning path to people new to python for data analysis. This path provides a comprehensive overview of steps you need to learn to use Python for #data_analysis. If you already have some background, or don’t need all the components, feel free to adapt your own paths and let us know how you made changes in the path.

You can also check the mini version of this learning path
#Deep_Learning

Django Q on Windows

We're developing with Django Q and Mac OS and it runs on our Linux Servers. Now we hired external developers which work on Windows machines and we discovered that Django Q is not working on Windows due to missing fork implementation.

Does anyone use Django Q on Windows?

answer:

Use #Docker with local windows code directory mounted inside container,
run the docker container interactively and forward a port 8000 to host machine,
then run migrations, test server and other stuff inside the container.

https://www.analyticsvidhya.com/blog/2016/08/deep-learning-path/?utm_content=bufferd56c5&utm_medium=social&utm_source=linkedin.com&utm_campaign=buffer

#Deep_Learning, a prominent topic in #Artificial_Intelligence domain, has been in the spotlight for quite some time now. It is especially known for its breakthroughs in fields like Computer Vision and Game playing (Alpha GO), surpassing human ability. Since the last survey, there has been a drastic increase in the trends. (click here to check out the survey)



Here is what Google trends shows us:

https://magenta.tensorflow.org/welcome-to-magenta

We’re happy to announce #Magenta, a project from the Google Brain team that asks: Can we use #machine_learning to create compelling art and music? If so, how? If not, why not? We’ll use #TensorFlow, and we’ll release our models and tools in open source on our GitHub. We’ll also post demos, tutorial blog postings and technical papers. Soon we’ll begin accepting code contributions from the community at large. If you’d like to keep up on Magenta as it grows, you can follow us on our GitHub and join our discussion group.

http://wiki.qt.io/PySide

Welcome to the PySide documentation wiki page. The #PySide project provides LGPL-licensed Python bindings for the Qt. It also includes complete toolchain for rapidly generating bindings for any Qt-based C++ class hierarchies. PySide Qt bindings allow both free open source and proprietary software development and ultimately aim to support #Qt_platforms.

https://groups.google.com/forum/#!topic/pyside-dev/pqwzngAGLWE

Dear #Pyside2 contributors,



As you might know, Pyside was originally developed for Nokia while it was the owner of the #Qt technology. When Nokia sold Qt to Digia (and now The Qt Company), all the copyrights over the original Pyside code for Qt 4 got transferred to The Qt Company as well.



For different reasons, it was not possible for The Qt Company to push Pyside forward as much as we would have wished over the last few years. Fortunately this changed now, and The Qt Company is today in a position, where it can and will invest into Pyside. The goal is to ensure Pyside becomes a fully supported part of the Qt product family, with a similar development and licensing model as the rest of Qt. We want to make sure Pyside works on new Qt releases when they come out and are committed to invest long term into the technology.

https://github.com/tyiannak/pyAudioAnalysis

#pyAudioAnalysis is a Python library covering a wide range of audio analysis tasks. Through pyAudioAnalysis you can:

Extract #audio features and representations (e.g. mfccs, spectrogram, chromagram)
Classify unknown #sounds
Train, parameter tune and evaluate classifiers of audio segments
Detect audio events and exclude silence periods from long recordings
Perform supervised segmentation (joint segmentation - classification)
Perform unsupervised segmentation (e.g. speaker diarization)
Extract audio thumbnails
Train and use audio regression models (example application: emotion recognition)
Apply dimensionality reduction to visualize audio data and content similarities

https://www.digitalocean.com/community/tutorials/how-to-use-cron-to-automate-tasks-on-a-vps

One of the most standard ways to run tasks in the #background on Linux machines is with #cron jobs. They’re useful for #scheduling_tasks on the VPS and automating different maintenance-related jobs. “Cron” itself is a daemon (or program) that runs in the background. The schedule for the different jobs that are run is in a configuration file called “crontab.”

@reboot echo "System #start_up "

https://help.ubuntu.com/community/CronHowto

#Cron is a system daemon used to #execute desired #tasks (in the background) at designated times.

A crontab file is a simple text file containing a list of commands meant to be run at specified times. It is edited using the crontab command. The commands in the crontab file (and their run times) are checked by the cron daemon, which executes them in the system background.

http://selenium-python.readthedocs.io/

Selenium Python bindings provides a simple #API to write functional/acceptance tests using Selenium WebDriver. Through Selenium Python API you can access all functionalities of Selenium #WebDriver in an intuitive way.

Selenium Python bindings provide a convenient API to access Selenium WebDrivers like Firefox, Ie, Chrome, Remote etc. The current supported Python versions are 2.7, 3.2 and above.

https://gist.github.com/hugs/830011

Example code for using the #Selenium 2 Python bindings.

http://sahandsaba.com/understanding-asyncio-node-js-python-3-4.html

I spent this summer working on a #web_platform running on #Node.js. This was the first time I worked full-time with Node.js and one thing that became quite apparent after a few weeks of working with it was that many developers, including myself at the time, lack clarify on exactly how the #asynchronous features of Node.js work, and how they are implemented at a lower level. Since I believe the only way to use a platform efficiently is to have a clear understanding of how it works, I decided to dig deeper. This curiosity also made me start playing around with implementing similar asynchronous features in other languages, in particular Python, it being my go-to language for experimenting and learning. This led me to Python 3.4's asynchronous IO library asyncio in particular, which intersected with my already existing interest in coroutines (see my post on combinatorial generation using coroutines in Python.) This post is about exploring the questions and answers that came up while I was learning more about this subject, which I hope can help clarify and answer some questions for others as well.

http://www.giantflyingsaucer.com/blog/?p=5557

In spring 2014 Python 3.4 shipped a provisional package (#asyncio) which according to the docs “provides infrastructure for writing single-threaded #concurrent code using #coroutines, #multiplexing I/O access over #sockets and other resources, running network clients and servers, and other related primitives“. I can’t possibly cover everything in this article but I can introduce some of the things you can do with it. As per my New’s Years resolution I’ll be building these #examples using Python 3.4.2 (Asyncio has been ported back to Python 3.3 now as well).

http://masnun.com/2015/11/20/python-asyncio-future-task-and-the-event-loop.html

On any platform, when we want to do something #asynchronously, it usually involves an #event loop. An event loop is a loop that can register #tasks to be executed, execute them, delay or even cancel them and handle different events related to these operations. Generally, we #schedule multiple async functions to the event loop. The loop runs one function, while that function waits for #IO, it pauses it and runs another. When the first function completes IO, it is resumed. Thus two or more functions can #co_operatively run together. This the main goal of an event loop.

http://masnun.com/2015/11/20/python-asyncio-future-task-and-the-event-loop.html

Python #asyncio: #Future, #Task and the #Event Loop

https://blog.miguelgrinberg.com/post/designing-a-restful-api-with-python-and-flask

In recent years #REST (REpresentational State Transfer) has emerged as the standard architectural design for #web services and web #APIs.

In this article I'm going to show you how easy it is to create a RESTful web service using Python and the Flask microframework.

What is REST?
The characteristics of a REST system are defined by six design rules:

Client-Server: There should be a separation between the #server that offers a service, and the #client that consumes it.
Stateless: Each request from a client must contain all the information required by the server to carry out the #request. In other words, the server cannot store information provided by the client in one request and use it in another request.
Cacheable: The server must indicate to the client if requests can be cached or not.
Layered System: Communication between a client and a server should be standardized in such a way that allows intermediaries to respond to requests instead of the end server, without the client having to do anything different.
Uniform Interface: The method of communication between a client and a server must be uniform.
Code on demand: Servers can provide executable code or scripts for clients to execute in their context. This constraint is the only one that is optional.

http://lucumr.pocoo.org/2016/12/29/careful-with-str-format/
#security
This should have been obvious to me for a longer time, but until earlier today I did not really realize the severity of the issues caused by str.format on untrusted user input. It came up as a way to bypass the Jinja2 Sandbox in a way that would permit retrieving information that you should not have access to which is why I just pushed out a security release for it.

However I think the general issue is quite severe and needs to be a discussed because most people are most likely not aware of how easy it is to exploit.

http://stackoverflow.com/questions/6434482/python-function-overloading

I know that Python does not support method #overloading, but I've run into a problem that I can't seem to solve in a nice Pythonic way.

I am making a #game where a character needs to shoot a variety of bullets, but how do I write different functions for creating these bullets? For example suppose I have a function that creates a bullet travelling from point A to B with a given speed.

https://www.python.org/dev/peps/pep-0443/

This PEP proposes a new mechanism in the #functools standard library module that provides a simple form of generic programming known as #single_dispatch #generic functions.

A generic function is composed of multiple functions implementing the same operation for different types. Which implementation should be used during a call is determined by the #dispatch algorithm. When the implementation is chosen based on the type of a single argument, this is known as #single_dispatch .
#overloading

https://pawelmhm.github.io/asyncio/python/aiohttp/2016/04/22/asyncio-aiohttp.html

👌Making 1 million requests with python -#aiohttp
Apr 22, 2016 - by Paweł Miech - about: #asyncio, aiohttp, #python

In this post I’d like to test limits of python aiohttp and check its performance in terms of requests per minute. Everyone knows that asynchronous code performs better when applied to network operations, but it’s still interesting to check this assumption and understand how exactly it is better and why it’s is better. I’m going to check it by trying to make 1 million #requests with aiohttp client. How many requests per minute will aiohttp make? What kind of exceptions and crashes can you expect when you try to make such volume of requests with very primitive scripts? What are main gotchas that you need to think about when trying to make such volume of requests?

https://pymotw.com/3/asyncio/subprocesses.html

Working with Subprocesses

It is frequently necessary to work with other programs and processes, to take advantage of existing code without rewriting it or to access libraries or features not available from within Python. As with network I/O, asyncio includes two abstractions for starting another program and then interacting with it.
Using the Protocol Abstraction with #Subprocesses

This example uses a coroutine to launch a process to run the Unix command df to find the free space on local disks. It uses subprocess_exec() to launch the process and tie it to a protocol class that knows how to read the df command output and parse it. The methods of the protocol class are called automatically based on I/O events for the subprocess. Because both the stdin and stderr arguments are set to None, those communication channels are not connected to the new process.