Updated : 2019-05-27 00:02:15 UTC






Increase rate

( New / Total ) * 100



Update Rate

( Update / Total ) * 100



Star 1000+


Star 100+


Sum stars of Top 30 repos

sum ( repos.stars )

Fork 1000+ Repos


Fork 100+


Sum forks of Top 30 repos

sum ( repos.forks )


Top Star Repos


  1. 67836
    A curated list of awesome Python frameworks, libraries, software and resources
  2. 63659
    Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.
  3. 57383
    A collective list of free APIs for use in software and web development.
  4. 53260
    Models and examples built with TensorFlow
  5. 50788
    Command-line program to download videos from YouTube.com and other video sites
  6. 44350
    The Python micro framework for building web applications.
  1. 43899
    Magnificent app which corrects your previous console command.
  2. 42976
    All Algorithms implemented in Python
  3. 41766
    The Web framework for perfectionists with deadlines.
  4. 41614
    As easy as httpie /aitch-tee-tee-pie/ 🥧 Modern command line HTTP client – user-friendly curl alternative with intuitive UI, JSON support, syntax highlighting, wget-like downloads, extensions, etc. https://twitter.com/clihttp
  5. 41452
    Deep Learning for humans
  6. 40025
    A curated list of awesome Machine Learning frameworks, libraries and software.
  7. 38747
    Python HTTP Requests for Humans™ ✨🍰✨
  8. 37362
    Ansible is a radically simple IT automation platform that makes your applications and systems easier to deploy. Avoid writing scripts or custom code to deploy and update your applications — automate in a language that approaches plain English, using SSH, with no agents to install on remote systems. https://docs.ansible.com/ansible/
  9. 35331
    scikit-learn: machine learning in Python
  10. 32963
    Scrapy, a fast high-level web crawling &amp; scraping framework for Python.
  11. 32480
    The Big List of Naughty Strings is a list of strings which have a high probability of causing issues when used as user-input data.
  12. 27653
    a web proxy tool
  13. 25101
    Certbot is EFF&#39;s tool to obtain certs from Let&#39;s Encrypt and (optionally) auto-enable HTTPS on your server. It can also act as a client for any other CA that uses the ACME protocol.
  14. 24556
    :arrow_double_down: Dumb downloader that scrapes the web
  15. 24478
    The Python programming language
  16. 24190
    The world&#39;s simplest facial recognition api for Python and the command line
  17. 23867
    :house_with_garden: Open source home automation that puts local control and privacy first
  18. 23473
    2018/2019/校招/春招/秋招/算法/机器学习(Machine Learning)/深度学习(Deep Learning)/自然语言处理(NLP)/C/C++/Python/面试笔记
  19. 23233
    100 Days of ML Coding
  20. 22928
    Deep Learning papers reading roadmap for anyone who are eager to learn this amazing tech!
  21. 22831
    The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++
  22. 22497
    :books: Simplified and community-driven man pages
  23. 20945
    Sentry is cross-platform application monitoring, with a focus on error reporting.

New Repos


  • 5
    These scripts are written to demonstrate the process of Python Memory Allocation, Partitioning and Mapping. The Python ‘tracemalloc’ module is used to trace memory allocations. The tracemalloc module is a debug tool to trace memory blocks allocated by Python. It provides the following information: > Traceback where an object was allocated. > Statistics on allocated memory blocks per filename and per line number: total size, number and average size of allocated memory blocks. > Compute the differences between two snapshots to detect memory leaks. To trace most memory blocks allocated by Python, the module should be started as early as possible by setting the PYTHONTRACEMALLOC environment variable to 1, or by using -X tracemalloc command line option. The tracemalloc.start() function can be called at runtime to start tracing Python memory allocations. Compiled and presented by Vakindu Philliam.
  • 5
    This series of scripts is written to demonstrate the use of Python’s File 'io' module. The io module is the core of tools for working with streams. It provides Python’s main facilities for dealing with various types of I/O. There are three main types of I/O: text I/O, binary I/O and raw I/O. Text I/O: Text I/O expects and produces ‘str’ objects. This means that whenever the backing store is natively made of bytes (such as in the case of a file), encoding and decoding of data is made transparently as well as optional translation of platform-specific newline characters. Binary I/O: Binary I/O (also called buffered I/O) expects bytes-like objects and produces bytes objects. No encoding, decoding, or newline translation is performed. This category of streams can be used for all kinds of non-text data, and also when manual control over the handling of text data is desired. Raw I/O: Raw I/O (also called unbuffered I/O) is generally used as a low-level building-block for binary and text streams; it is rarely useful to directly manipulate a raw stream from user code. Nevertheless, you can create a raw stream by opening a file in binary mode with buffering disabled.
  • 5
    The following scripts demonstrate the use of the Python SQLite API - the sqlite3 module — DB-API 2.0 interface for SQLite databases. SQLite is a C library that provides a lightweight disk-based database that doesn’t require a separate server process and allows accessing the database using a nonstandard variant of the SQL query language. Some applications can use SQLite for internal data storage. It’s also possible to prototype an application using SQLite and then port the code to a larger database such as PostgreSQL or Oracle. The sqlite3 module provides a SQL interface compliant with the DB-API 2.0 specification described by PEP 249. Compiled by Vakindu Philliam.
  • 5
    This series of scripts is written to demonstrate the process of Python Signal Handling. The 'signal' module sets handlers for asynchronous events. This module provides mechanisms to use signal handlers in Python. The signal.signal() function allows defining custom handlers to be executed when a signal is received. A small number of default handlers are installed: SIGPIPE is ignored (so write errors on pipes and sockets can be reported as ordinary Python exceptions) and SIGINT is translated into a KeyboardInterrupt exception. A handler for a particular signal, once set, remains installed until it is explicitly reset (Python emulates the BSD style interface regardless of the underlying implementation), with the exception of the handler for SIGCHLD, which follows the underlying implementation.
  • 5
  • 5
    The following scripts are written to demonstrate the use of the Python Multiprocessing API. The Python multiprocessing package lets Python programs create new processes that will perform a computation and return a result to the parent. The parent and child processes can communicate using queues and pipes, synchronize their operations using locks and semaphores, and can share simple arrays of data. The fundamental class is the ‘Process’, which is passed a callable object and a collection of arguments. The start()' method sets the callable running in a subprocess, after which you can call the is_alive() method to check whether the subprocess is still running and the join() method to wait for the process to exit. A Queue is used to communicate the result of the factorial. The Queue object is stored in a global variable. The child process will use the value of the variable when the child was created; because it’s a Queue, parent and child can use the object to communicate. (If the parent were to change the value of the global variable, the child’s value would be unaffected, and vice versa.) Two other classes, ‘Pool’ and ‘Manager’, provide higher-level interfaces. Pool will create a fixed number of worker processes, and requests can then be distributed to the workers by calling apply() or apply_async() to add a single request, and map() or map_async() to add a number of requests. The other high-level interface, the ‘Manager’ class, creates a separate server process that can hold master copies of Python data structures. Other processes can then access and modify these data structures using proxy objects. Manager’s methods also include Lock(), RLock(), and Semaphore() to create shared locks.) Compiled by Vakindu Philliam.
  • 5
    The following scripts are written to demonstrate basic Python cryptography and probability functions. Also illustrated is how to generate random numbers using Python’s random number generator functions. The ‘random’ Python module generates pseudo-random numbers. This module implements pseudo-random number generators for various distributions. For integers, there is uniform selection from a range. For sequences, there is uniform selection of a random element, a function to generate a random permutation of a list in-place, and a function for random sampling without replacement. On the real line, there are functions to compute uniform, normal (Gaussian), lognormal, negative exponential, gamma, and beta distributions. For generating distributions of angles, the von Mises distribution is available. Compiled and presented by Vakindu Philliam.
  • 5
    This series of scripts is written to demonstrate the various uses of Python Regular Expressions (Regex). The Python ‘re’ module is used to perform regular expression operations. This module provides regular expression matching operations similar to those found in Perl. Both patterns and strings to be searched can be Unicode strings (str) as well as 8-bit strings (bytes). However, Unicode strings and 8-bit strings cannot be mixed: that is, you cannot match a Unicode string with a byte pattern or vice-versa; similarly, when asking for a substitution, the replacement string must be of the same type as both the pattern and the search string. Regular expressions use the backslash character ('\') to indicate special forms or to allow special characters to be used without invoking their special meaning. This collides with Python’s usage of the same character for the same purpose in string literals; for example, to match a literal backslash, one might have to write '\\\\' as the pattern string, because the regular expression must be \\, and each backslash must be expressed as \\ inside a regular Python string literal. Compiled and presented by Vakindu Philliam.
  • 5
    The following scripts are written to demonstrate the use of the Python ‘typing’ module, a component that supports type hints. This module supports type hints as specified by PEP 484 and PEP 526. The most fundamental support consists of the types Any, Union, Tuple, Callable, TypeVar, and Generic. Compiled by Vakindu Philliam.
  • 5
    The following scripts demonstrate the process of Python cryptography and hashing and how to use ‘Crypt’ and ‘hashlib’ module ‘Crypt’ - a function to check Unix passwords. This module implements an interface to the crypt(3) routine, which is a one-way hash function based upon a modified DES algorithm. Possible uses include storing hashed passwords so you can check passwords without storing the actual password, or attempting to crack Unix passwords with a dictionary. Notice that the behavior of this module depends on the actual implementation of the crypt(3) routine in the running system. Therefore, any extensions available on the current implementation will also be available on this module. ‘hashlib’ – a function module for generating secure hashes and message digests. This module implements a common interface to many different secure hash and message digest algorithms. Included are the FIPS secure hash algorithms SHA1, SHA224, SHA256, SHA384, and SHA512 (defined in FIPS 180-2) as well as RSA’s MD5 algorithm (defined in Internet RFC 1321). The terms “secure hash” and “message digest” are interchangeable. Older algorithms were called message digests. The modern term is secure hash. Also demonstrate is how to write Hash algorithms. Compiled and presented by Vakindu Philliam.
  • 5
    The first series of these scripts describes the functionality of Python Concurrent Futures. Python concurrent.futures allows launching parallel tasks. The concurrent.futures module provides a high-level interface for asynchronously executing callables. The asynchronous execution can be performed with threads, using ThreadPoolExecutor, or separate processes, using ProcessPoolExecutor. Both implement the same interface, which is defined by the abstract Executor class. Also explored is the Python ‘asyncore’ module used as an asynchronous socket handler. This module exists for backwards compatibility only. For new code we recommend using asyncio. This module provides the basic infrastructure for writing asynchronous socket service clients and servers. There are only two ways to have a program on a single processor do “more than one thing at a time.” Multi-threaded programming is the simplest and most popular way to do it, but there is another very different technique, that lets you have nearly all the advantages of multi-threading, without actually using multiple threads. It’s really only practical if your program is largely I/O bound. If your program is processor bound, then pre-emptive scheduled threads are probably what you really need. Network servers are rarely processor bound, however. Compiled and presented by Vakindu Philliam.
  • 5
    This set of scripts is written to demonstrate the use of the Python trace module to trace or track Python statement execution. The trace module allows you to trace program execution, generate annotated statement coverage listings, print caller/callee relationships and list functions executed during a program run. It can be used in another program or from the command line. Also demonstrated is the use of the ‘timeit’ module to measure execution time of small code snippets. This module provides a simple way to time small bits of Python code. It has both a Command-Line Interface as well as a callable one. It avoids a number of common traps for measuring execution times. Compiled and presented by Vakindu Philliam.




Followers 100+


Repos per User

repos.Total / users.Total