TL;DR Of course we have Python! You just need to specify if you want Python 3 or 2 as we didn’t want to set a default. Give yum install python3 and/or yum install python2 a try. Or, if you want to see what we recommend you install yum install @python36 or yum install @python27. Read on for why:

For prior versions of Red Hat Enterprise Linux, and most Linux Distributions, users have been locked to the system version of Python unless they got away from the system’s package manager. While this can be true for a lot of tools (ruby, node, PERL, php) the Python use case is more complicated because so many Linux tools (like yum) rely on Python. In order to improve the experience for RHEL 8 users, we have moved the Python used by the system “off to the side” and we introduced the concept of Application Streams based on Modularity.

Through Application Streams, in combination with Python’s ability to be parallel installed, we can now make multiple versions of Python available and easily installable, from the standard repositories, into the standard locations. No extra things to learn or manage. Now, users can choose what version of Python they want to run in any given userspace and it simply works. For more info, see my article, Introducing Application Streams in RHEL 8.

To be honest, the system maintainers also get some advantages of not being locked to an aging version of Python for our system tools. With users not relying on a particular version of Python coming with the system installation, we have the freedom to take advantage of new language features, performance improvements, and all the other goodness a developer gets when tracking near the upstream version.

However, this has resulted in a dilemma. When a user sits down at a fresh installation of RHEL 8 they will naturally expect that /usr/bin/python will run some version of Python. If you follow the recommendation in Python Enhancement Proposal (PEP) 394, that will be Python 2. However, at some point, a new PEP will likely want to change that recommendation to Python 3, probably during, the typically *10* year, life of RHEL 8!  To put this in perspective, consider that RHEL 7 was released in 2014, and will be supported until 2024!  

So, what do we do? Well, if we follow the current recommendation, we make some present day users happy. However, when the Python Community shifts to recommending Python 3 as the default, we will make new users unhappy.

As a result, we came to the tough conclusion, don’t provide a default, unversioned Python at all. Ideally, people will get used to explicitly typing python3 or python2. However for those that want an unversioned command,  let them chose from the beginning which version of Python they actually want. So, yum install python results in a 404.

However, we do try to make it as easy as possible to get Python 2 or 3 (or both) on to your system. We recommend using yum install @python36 or yum install @python27 to take advantage of the recommended set of packages to install. If all you really need is *just* the Python binaries, you can use yum install python3 or yum install python2.

We have also setup the alternatives infrastructure so that when you install either (or both) you can easily make /usr/bin/python point to the right place using alternatives --config python. However, as we explained above, and aligned with the Python PEP, we don’t recommend relying on /usr/bin/python being the correct python for your application.

Note: the same issue arises for Python wrapper scripts like pip. Installing Python 3 will put pip3 in your path, but not unversioned pip. With Python modules like pip, venv, and virtualenv, you can avoid confusion and get the right version by running those as a module: python3 -m pip and avoiding the wrapper scripts. Using Python virtual environments is a best practice that also avoids the issues with version ambiguity, see How to install Python 3 on Red Hat Enterprise Linux 7 for virtual environment details and advice.

To conclude, yes, Python is included in RHEL 8! And, it will be even better than in the past! If you want more details on anything in this post, please see the How To Guide on Red Hat Developers.

Oh and if you haven’t downloaded RHEL 8 yet—go to developers.redhat.com/rhel8 now.

Additional Information

• Red Hat Enterprise Linux 8 Beta for developers
• Introducing Application Streams in RHEL 8.
• Petr Viktorin’s Python on RHEL 8 article (see the discussion of Platform Python)
• Introducing CodeReady Linux Builder
• Containers without daemons: Podman and Buildah available in RHEL 7.6 and RHEL 8 Beta

The post What, No Python in RHEL 8 Beta? appeared first on RHD Blog.

UNIX/Linux systems offer special mechanisms to communicate between each individual process. One of these mechanisms are signals, and belong to the different methods of communication between processes (Inter Process Communication, abbreviated with IPC).

In short, signals are software interrupts that are sent to the program (or the process) to notify the program of significant events or requests to the program in order to run a special code sequence. A program that receives a signal either stops or continues the execution of its instructions, terminates either with or without a memory dump, or even simply ignores the signal.

Although it is defined in the POSIX standard, the reaction actually depends on how the developer wrote the script and implemented the handling of signals.

In this article we explain what are signals, show you how to sent a signal to another process from the command line as well as processing the received signal. Among other modules, the program code is mainly based on the signal module. This module connects the according C headers of your operating system with the Python world.

An Introduction to Signals

On UNIX-based systems, there are three categories of signals:

• System signals (hardware and system errors): SIGILL, SIGTRAP, SIGBUS, SIGFPE, SIGKILL, SIGSEGV, SIGXCPU, SIGXFSZ, SIGIO

• Device signals: SIGHUP, SIGINT, SIGPIPE, SIGALRM, SIGCHLD, SIGCONT, SIGSTOP, SIGTTIN, SIGTTOU, SIGURG, SIGWINCH, SIGIO

• User-defined signals: SIGQUIT, SIGABRT, SIGUSR1, SIGUSR2, SIGTERM

Each signal is represented by an integer value, and the list of signals that are available is comparably long and not consistent between the different UNIX/Linux variants. On a Debian GNU/Linux system, the command kill -l displays the list of signals as follows:

$ kill -l
 1) SIGHUP   2) SIGINT   3) SIGQUIT  4) SIGILL   5) SIGTRAP
 6) SIGABRT  7) SIGBUS   8) SIGFPE   9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM  
16) SIGSTKFLT   17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP  
21) SIGTTIN 22) SIGTTOU 23) SIGURG  24) SIGXCPU 25) SIGXFSZ  
26) SIGVTALRM   27) SIGPROF 28) SIGWINCH    29) SIGIO   30) SIGPWR  
31) SIGSYS  34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3  
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8  
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13  
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12  
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7  
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2  
63) SIGRTMAX-1  64) SIGRTMAX  

The signals 1 to 15 are roughly standardized, and have the following meaning on most of the Linux systems:

• 1 (SIGHUP): terminate a connection, or reload the configuration for daemons
• 2 (SIGINT): interrupt the session from the dialogue station
• 3 (SIGQUIT): terminate the session from the dialogue station
• 4 (SIGILL): illegal instruction was executed
• 5 (SIGTRAP): do a single instruction (trap)
• 6 (SIGABRT): abnormal termination
• 7 (SIGBUS): error on the system bus
• 8 (SIGFPE): floating point error
• 9 (SIGKILL): immmediately terminate the process
• 10 (SIGUSR1): user-defined signal
• 11 (SIGSEGV): segmentation fault due to illegal access of a memory segment
• 12 (SIGUSR2): user-defined signal
• 13 (SIGPIPE): writing into a pipe, and nobody is reading from it
• 14 (SIGALRM): the timer terminated (alarm)
• 15 (SIGTERM): terminate the process in a soft way

In order to send a signal to a process in a Linux terminal you invoke the kill command with both the signal number (or signal name) from the list above and the id of the process (pid). The following example command sends the signal 15 (SIGTERM) to the process that has the pid 12345:

$ kill -15 12345

An equivalent way is to use the signal name instead of its number:

$ kill -SIGTERM 12345

Which way you choose depends on what is more convenient for you. Both ways have the same effect. As a result the process receives the signal SIGTERM, and terminates immediately.

Using the Python signal Library

Since Python 1.4, the signal library is a regular component of every Python release. In order to use the signal library, import the library into your Python program as follows, first:

import signal  

Capturing and reacting properly on a received signal is done by a callback function - a so-called signal handler. A rather simple signal handler named receiveSignal() can be written as follows:

def receiveSignal(signalNumber, frame):  
    print('Received:', signalNumber)
    return

This signal handler does nothing else than reporting the number of the received signal. The next step is registering the signals that are caught by the signal handler. For Python programs, all the signals (but 9, SIGKILL) can be caught in your script:

if __name__ == '__main__':  
    # register the signals to be caught
    signal.signal(signal.SIGHUP, receiveSignal)
    signal.signal(signal.SIGINT, receiveSignal)
    signal.signal(signal.SIGQUIT, receiveSignal)
    signal.signal(signal.SIGILL, receiveSignal)
    signal.signal(signal.SIGTRAP, receiveSignal)
    signal.signal(signal.SIGABRT, receiveSignal)
    signal.signal(signal.SIGBUS, receiveSignal)
    signal.signal(signal.SIGFPE, receiveSignal)
    #signal.signal(signal.SIGKILL, receiveSignal)
    signal.signal(signal.SIGUSR1, receiveSignal)
    signal.signal(signal.SIGSEGV, receiveSignal)
    signal.signal(signal.SIGUSR2, receiveSignal)
    signal.signal(signal.SIGPIPE, receiveSignal)
    signal.signal(signal.SIGALRM, receiveSignal)
    signal.signal(signal.SIGTERM, receiveSignal)

Next, we add the process information for the current process, and detect the process id using the methode getpid() from the os module. In an endless while loop we wait for incoming signals. We implement this using two more Python modules - os and time. We import them at the beginning of our Python script, too:

import os  
import time  

In the while loop of our main program the print statement outputs "Waiting...". The time.sleep() function call makes the program wait for three seconds.

    # output current process id
    print('My PID is:', os.getpid())

    # wait in an endless loop for signals 
    while True:
        print('Waiting...')
        time.sleep(3)

Finally, we have to test our script. Having saved the script as signal-handling.py we can invoke it in a terminal as follows:

$ python3 signal-handling.py 
My PID is: 5746  
Waiting...  
...

In a second terminal window we send a signal to the process. We identify our first process - the Python script - by the process id as printed on screen, above.

$ kill -1 5746

The signal event handler in our Python program receives the signal we have sent to the process. It reacts accordingly, and simply confirms the received signal:

...
Received: 1  
...

Ignoring Signals

The signal module defines ways to ignore received signals. In order to do that the signal has to be connected with the predefined function signal.SIG_IGN. The example below demonstrates that, and as a result the Python program cannot be interrupted by CTRL+C anymore. To stop the Python script an alternative way has been implemented in the example script - the signal SIGUSR1 terminates the Python script. Furthermore, instead of an endless loop we use the method signal.pause(). It just waits for a signal to be received.

import signal  
import os  
import time

def receiveSignal(signalNumber, frame):  
    print('Received:', signalNumber)
    raise SystemExit('Exiting')
    return

if __name__ == '__main__':  
    # register the signal to be caught
    signal.signal(signal.SIGUSR1, receiveSignal)

    # register the signal to be ignored
    signal.signal(signal.SIGINT, signal.SIG_IGN)

    # output current process id
    print('My PID is:', os.getpid())

    signal.pause()

Handling Signals Properly

The signal handler we have used up to now is rather simple, and just reports a received signal. This shows us that the interface of our Python script is working fine. Let's improve it.

Catching the signal is already a good basis but requires some improvement to comply with the rules of the POSIX standard. For a higher accuracy each signal needs a proper reaction (see list above). This means that the signal handler in our Python script needs to be extended by a specific routine per signal. This works best if we understand what a signal does, and what a common reaction is. A process that receives signal 1, 2, 9 or 15 terminates. In any other case it is expected to write a core dump, too.

Up to now we have implemented a single routine that covers all the signals, and handles them in the same way. The next step is to implement an individual routine per signal. The following example code demonstrates this for the signals 1 (SIGHUP) and 15 (SIGTERM).

def readConfiguration(signalNumber, frame):  
    print ('(SIGHUP) reading configuration')
    return

def terminateProcess(signalNumber, frame):  
    print ('(SIGTERM) terminating the process')
    sys.exit()

The two functions above are connected with the signals as follows:

    signal.signal(signal.SIGHUP, readConfiguration)
    signal.signal(signal.SIGTERM, terminateProcess)

Running the Python script, and sending the signal 1 (SIGHUP) followed by a signal 15 (SIGTERM) by the UNIX commands kill -1 16640 and kill -15 16640 results in the following output:

$ python3 daemon.py
My PID is: 16640  
Waiting...  
Waiting...  
(SIGHUP) reading configuration
Waiting...  
Waiting...  
(SIGTERM) terminating the process

The script receives the signals, and handles them properly. For clarity, this is the entire script:

import signal  
import os  
import time  
import sys

def readConfiguration(signalNumber, frame):  
    print ('(SIGHUP) reading configuration')
    return

def terminateProcess(signalNumber, frame):  
    print ('(SIGTERM) terminating the process')
    sys.exit()

def receiveSignal(signalNumber, frame):  
    print('Received:', signalNumber)
    return

if __name__ == '__main__':  
    # register the signals to be caught
    signal.signal(signal.SIGHUP, readConfiguration)
    signal.signal(signal.SIGINT, receiveSignal)
    signal.signal(signal.SIGQUIT, receiveSignal)
    signal.signal(signal.SIGILL, receiveSignal)
    signal.signal(signal.SIGTRAP, receiveSignal)
    signal.signal(signal.SIGABRT, receiveSignal)
    signal.signal(signal.SIGBUS, receiveSignal)
    signal.signal(signal.SIGFPE, receiveSignal)
    #signal.signal(signal.SIGKILL, receiveSignal)
    signal.signal(signal.SIGUSR1, receiveSignal)
    signal.signal(signal.SIGSEGV, receiveSignal)
    signal.signal(signal.SIGUSR2, receiveSignal)
    signal.signal(signal.SIGPIPE, receiveSignal)
    signal.signal(signal.SIGALRM, receiveSignal)
    signal.signal(signal.SIGTERM, terminateProcess)

    # output current process id
    print('My PID is:', os.getpid())

    # wait in an endless loop for signals 
    while True:
        print('Waiting...')
        time.sleep(3)

Further Reading

Using the signal module and an according event handler it is relatively easy to catch signals. Knowing the meaning of the different signals, and to react properly as defined in the POSIX standard is the next step. It requires that the event handler distinguishes between the different signals, and has a separate routine for all of them.

The Django meetup was at Prezi. They have a great space. They are big Django users.

Goodbye REST: Building APIs with Django and GraphQL

Jaden Windle, @jaydenwindle, lead engineer at Jetpack.

https://github.com/jaydenwindle/goodbye-rest-talk

They moved from Django REST Framework to GraphQL.

It sounds like a small app.

They're using Django, React, and React Native.

I think he said they used Reason and moved away from it, but I could be wrong.

They had to do a rebuild anyway, so they used GraphQL.

He said not to switch to GraphQL just because it's cool, and in general, avoid hype-driven development.

GraphQL is a query language, spec, and collection of tools, designed to operate over a single endpoint via HTTP, optimzing for perf and flexibility.

Key features:

• Query for only the data you need.
• Easily query for multiple resources in a single request.
• Great front end tooling for handling caching, loading / error states, and updates.

(I wonder if he's talking about Apollo, not just GraphQL. I found out later, that they are using Apollo.)

GraphQL Schema:

• Types
• Queries
• Mutations
• *Subscriptions

Graphene is the goto framework for GraphQL in Django.

He showed an example app.

You create a type and connect it to a model. It's like a serializer in DRF.

(He's using VS Code.)

It knows how to understand relationships between types based on the relationships in the models.

He showed the query syntax.

He showed how Graphene connects to the Django model. You're returning raw Django model objects, and it takes care of serialization.

There's a really nice UI where you can type in a query, and it queries the server. It has autocomplete. I can't tell if this is from Apollo, Graphene, or some other GraphQL tool.

You only pass what you need across the wire.

When you do a mutation, you can also specify what data it should give back to you.

There is some Mutation class that you subclass.

The code looks a lot like DRF.

Subscriptions aren't fully implemented in Graphene. His company is working on implementing and open sourcing something. There are a bunch of other possible real-time options--http://graphql-python/graphql-ws is one.

There's a way to do file uploads.

Important: There's this thing called graphene-django-extras. There's even something to connect to DRF automatically.

Pros:

• Dramatically improves front end DX
• Flexible types allow for quick iteration
• Always up-to-date documentation
• Only send needed data over the wire

Cons:

• Graphene isn't as mature as some other GraphQL implementations (for instance, in JS and Ruby)
• Logging is different when using a single GraphQL endpoint
• REST is currently better at server-side caching (E-Tag, etc.)

Graphene 3 is coming.

In the Q&A, they said they do use Apollo.

They're not yet at a scale where they have to worry about performance.

He's not entirely sure whether it's prone to the N+1 queries problem, but there are GitHub issues related to that.

You can do raw ORM or SQL queries if you need to. Otherwise, he's not sure what it's doing behind the scenes.

You can add permissions to the models. There's also a way to tie into Django's auth model.

Their API isn't a public API. It's only for use by their own client.

The ORM, and When Not To Use It

Christophe Pettus from PostgreSQL Experts.

He thinks the ORM is great.

The first ORM he wrote was written before a lot of the audience was born.

Sometimes, writing code for the ORM is hard.

Database agnosticism isn't as important as you think it is. For instance, you don't make the paint on your house color-agnostic.

Libraries have to be DB agnostic. Your app probably doesn't need to be.

Reasons you might want to avoid the query language:

• Queries that generate sub-optimal SQL
• Queries more easily expressed in SQL
• SQL features not available via the ORM

Django's ORM's SQL is much better than it used to be.

Don't use __in with very large lists. 100 is about the longest list you should use.

Avoid very deep joins.

It's not hard to chain together a bunch of stuff that ends up generating SQL that's horrible.

The query generator doesn't do a separate optimization pass that makes the query better.

It's better to express .filter().exclude().filter() in SQL.

There are so many powerful functions and operators in PostgreSQL!

SomeModel.objects.raw() is your friend!

You can write raw SQL, and yet still have it integrate with Django models.

You can even get stuff back from the database that isn't in the model definition.

There's some WITH RECURSIVE thing in PostgreSQL that would be prohibitively hard to do with the Django ORM. It's not really recursive--it's iterative.

You can also do queries without using the model framework.

The model framework is very powerful, but it's not cheap.

Interesting: The data has to be converted into Python data and then again into model data. If you're just going to serialize it into JSON, why create the model objects? You can even create the JSON directly in the database and hand it back directly with PostgreSQL. But make sure the database driver doesn't convert the JSON back to Python ;) Return it as raw text.

There are also tables that Django can't treat as model tables. For instance, there are logging tables that lack a primary key. Sometimes, you have weird tables with non-Django-able primary keys.

The ORM is great, though. For instance, it's great for basic CRUD.

Interfaces that require building queries in steps are better done with SQL--for instance, an advanced search function.

Summary:

• Don't be afraid to step outside the ORM.
• SQL isn't a bug. It's a feature. It's code like everything else.
• Do use the ORM for operations that it makes easier.
• Don't hesitate to use the full power of SQL.

Q&A:

Whether you put your SQL in model methods or managers is a matter of taste. Having all the code for a particular model in one place (i.e. the model or manager) is useful.

Write tests. Use CI.

Use parameter substitution in order to avoid SQL injection attacks. Remember, all external input is hostile. You can't use parameter substitution if the table name is dynamic--just be careful with what data you allow.

If you're using PostGIS, write your own queries for sure. It's really easy to shoot yourself in the foot with the GIS package.

In this article we are going to create a game over scene for the pygame project, we will use back the start scene class which we have created previously to render our game over scene by slightly modify it for the multi-scenes uses. Here is the modify version of the start scene class, as you can see we have passed in a state variable to the start scene class’s draw method which will be used...

Source

Related posts:

Journey into PyGame — The beginningCreate an explosion manager and explosion class for pygame projectCreate the pool object for Enemy Missile classCreate the Overlap class for Pygame projectThe modify version of the Pygame Missile Manager ClassPygame loads image and background graphic on game sceneCreate a score manager class for pygame projectDetect boundary and respond to key press event in Pygame projectDetect the overlapping between two game objects with PygameMoving the sprite with Vector in Pygame

Lately there’s been a recurring discussion on various social-media outlets about the relevance of academic degrees to a career in programming. Specifically: is a degree in computer science (or some other field perceived as related) a necessity for a career as a programmer? If not, is it still a good idea to have one?

I’ve jumped into a few such threads on Twitter, but I have complex thoughts on the topic, and 140-character or (now) 280-character ...

Read full entry

Hi everyone! I hope all of you are doing well. Things have been super exciting on my side. Just got done with a file system checker project in C for my Operating Systems class. It was mentally draining but equally rewarding. This blog post is not about Python but rather about Emails.

This week I also gave a department wide talk at Colgate University on Email security and privacy and some of the SMTP features which are available at your disposal. It went fairly successful. This was a result of my own independent research on the topic. I tried to cover as much base as possible while also trying to keep the talk engaging.

If you want to learn more about the topic, you can take a look at the slides I used and do some research of your own. If something seems wrong please let me know in the comments below so that we all can benefit. You can also access (I think?) the speaker notes for more context behind the content on the slides.

If you are pressed for time, skip to the last slide to learn about some interesting attacks. One of them makes use of Cyrillic script. If you haven’t heard of Cyrillic script before you would love that slide.

I would love to hear from you all. Please share your views in the comments below about the talk or anything in general.

These are the ten most rated questions at Stack Overflow last week.
Between brackets: [question score / answers count]
Build date: 2018-12-01 21:40:29 GMT

1. Longest word chain from a list of words - [28/9]
2. Why is 2 * x * x faster than 2 * ( x * x ) in Python? - [19/5]
3. Do Python lambda functions help in reducing the execution times? - [14/1]
4. Python function that identifies if the numbers in a list or array are closer to 0 or 1 - [11/10]
5. Finding three integers such that their sum of cosine values become max - [9/5]
6. Finding singulars/sets of local maxima/minima in a 1D-NumPy array (once again) - [9/3]
7. Improve accuracy of image processing to count fungus spores - [9/2]
8. Advanced Python Regex: how to evaluate and extract nested lists and numbers from a multiline string? - [8/2]
9. Count appearances of a value until it changes to another value - [7/5]
10. What is happening when I assign a list with self references to a list copy with the slice syntax `mylist[:] = [mylist, mylist, ...]`? - [7/3]

In this article we will create a next level scene which will be displayed whenever the player has gained 30 points. Just like the previous chapter we are going to use back the start scene class as well as modify the game manager class and the overlap class First of all we will create the next scene surface and draw it on the game scene whenever the state of the game has changed to the next level...

Source

Related posts:

Draw a line with PygameCreate an explosion manager and explosion class for pygame projectCreate Enemy Manager Class and Enemy Class in a Pygame ProjectDetect boundary and respond to key press event in Pygame projectCreating rock on the screen with PygameCreate the spaceship in Rock SweeperDetect the overlapping between two game objects with PygameMoving the sprite with Vector in PygameRotate an object in PygameCreate a score manager class for pygame project

Digital Ocean Developer Trends of the quarter

Submitted by @BryanKimani

Very interesting report by @digitalocean - https://t.co/V3XRozQfdr#OpenSource

— Max (@maksek_ua) November 27, 2018

A great article on learning things in general

Submitted by @dgjustice

Forget Motivation and Double Your Chances of Learning Success https://t.co/fCLNFWw2Eh

— Ilkka Peltola (@ilkkapeltola) November 27, 2018

A conversation with Guido!

Here's my conversation with Guido van Rossum, creator of Python, one of the most popular and impactful programming… https://t.co/ACmfI6YVbZ

— Lex Fridman (@lexfridman) November 22, 2018

music21 - a Python-based toolkit for computer-aided musicology

Submitted by @Dan Shorstein

Really excited to play with the music21 library! Just found out about it https://t.co/7MwZ0KPw7W

— Dan Shorstein (@dtizzlenizzle) November 29, 2018

Shameless plug because we can! CodeChalleng.es can now help your company run coding interviews with Interview Bites!

PyBites can help you acquire #Python top talent! Enterprise Customers can now use our https://t.co/UYcrpuWnxX plat… https://t.co/ryw2AbtrHq

— Pybites (@pybites) November 27, 2018

Thanks to everyone that participated in the TalkPython Black Friday sale!

Wow, the response to the @talkpython#blackfriday sale has been really amazing. Thank you to everyone to bought a c… https://t.co/bhxqIWxDPb

— Talk Python Podcast (@TalkPython) November 25, 2018

Multiple assignment and tuple unpacking improve Python code readability

Submitted by @tryexceptpass

RT @treyhunner:"When you see Python code that uses hard coded indexes there's often a way to use multiple assignment to make your code mor…

— Cristian Medina (@tryexceptpass) November 23, 2018

Nice, TinyDB!

RT @funkatron: My neat new discovery today is TinyDB, a great, small document db for Python. Perfect for the slackbot I’m writing https://t…

— ernest w. durbin iii (@EWDurbin) November 30, 2018

Too handy not to share. Print a list of reverse DNS records for a subnet

for i in 198.187.190.{0..255}; do a=$( dig +short -x $i ); printf "$i: %s\n""$a"; done # Print a list of reverse DNS records for a subnet.

— Command Line Magic (@climagic) November 25, 2018

Check out Jake VanderPlas's Python Data Science Handbook

RT @mf_viz: The "Python Data Science Handbook" is an *excellent* free + open-source resource for learning #Python for #DataScience and #Mac…

— Jake VanderPlas (@jakevdp) November 28, 2018

A great message: Document Everything!

"If it is not written down, it does not exist." - Philippe Kruchten

— Programming Wisdom (@CodeWisdom) November 29, 2018

Some AMAZING responses to the question: "What's the most fun thing you have ever done with data?"

What's the most fun thing you have ever done with data? A project you really enjoyed, or personal data you collect… https://t.co/KkVegyQMPb

— Data Science Renee (@BecomingDataSci) November 30, 2018

Tracking all of your SQL Queries in Git

RT @beeonaposy: New blog post! Git Your SQL Together, on the why and how of tracking all of your SQL queries in git 💫 https://t.co/Tgrq58i…

— David Robinson (@drob) November 28, 2018

Serverless APIs with Python, AWS Lambda & API Gateway

Serverless APIs with Python, AWS Lambda & API Gateway by Hamish Campbell. https://t.co/HhfW7PQXr6

— Python Software (@ThePSF) December 01, 2018

So old...

If you don't want to feel old, stop reading now. 1TB hard drives are now over a decade old. https://t.co/PJiKXBka9Y

— Command Line Magic (@climagic) November 29, 2018

>>>frompybitesimportBob,JulianKeepCalmandCodeinPython!

from __future__ import print_function

"""
This is the code for the Perl version by Mark Jason Dominus:

sub hanoi {
    my ($n, $start, $end, $extra) = @_;
    if ($n == 1) {
        print "Move disk #1 from $start to $end.\n"; # Step 1
    } else {
    hanoi($n-1, $start, $extra, $end); # Step 2
    print "Move disk #$n from $start to $end.\n"; # Step 3
    hanoi($n-1, $extra, $end, $start); # Step 4
    }
}
"""

# This is my Python version ported from the Perl version above:

def hanoi(n, start, end, extra):
"""
    Function hanoi(n, start, end, extra)
    Solve Tower of Hanoi problem for a tower of n disks,
    of which the largest is disk #n. Move the entire tower from
    peg 'start' to peg 'end', using peg 'extra' as a work space.
"""
    if n == 1:
        print("Move disk #1 from {} to {}.\n".format(start, end))
    else:
        # Recursive call #1
        hanoi(n - 1, start, extra, end)
        print("Move disk #{} from {} to {}.\n".format(n, start, end))
        # Recursive call #2
        hanoi(n - 1, extra, end, start)

# Call to hanoi() with 3 disks, i.e. n = 3:
hanoi(3, 'A', 'C', 'B')

$ python hanoi_01.py
Move disk #1 from A to C.

Move disk #2 from A to B.

Move disk #1 from C to B.

Move disk #3 from A to C.

Move disk #1 from B to A.

Move disk #2 from B to C.

Move disk #1 from A to C.

from __future__ import print_function
from msvcrt import getch

"""
Tower of Hanoi program
---
By Vasudev Ram
Web site: https://vasudevram.github.io
Blog: https://jugad2.blogspot.com
Twitter: https://mobile.twitter.com/vasudevram
Product store: https://gumroad.com/vasudevram
---
Translated to Python from the Perl version in the book Higher-Order Perl
by Mark Jason Dominus: https://hop.perl.plover.com/book/ , with some 
minor enhancements related to interactivity.
"""

def hanoi(n, start, end, extra):
"""
    Function hanoi(N, start, end, extra)
    Solve Tower of Hanoi problem for a tower of N disks,
    of which the largest is disk #N. Move the entire tower from
    peg 'start' to peg 'end', using peg 'extra' as a work space.
"""
    assert n > 0
    if n == 1:
        print("Move disk #1 from {} to {}.".format(start, end))
    else:
        hanoi(n - 1, start, extra, end)
        print("Move disk #{} from {} to {}.".format(n, start, end))
        hanoi(n - 1, extra, end, start)

for n in range(1, 5):
    print("\nTower of Hanoi with n = {}:".format(n))
    hanoi(n, 'A', 'C', 'B')
    if n < 4:
        print("\nPress q to quit, any other key for next run: ")
        c = getch()
        if c.lower() == 'q':
            break

$ python hanoi_02.py

Tower of Hanoi with n = 1:
Move disk #1 from A to C.

Press q to quit, any other key for next run:

Tower of Hanoi with n = 2:
Move disk #1 from A to B.
Move disk #2 from A to C.
Move disk #1 from B to C.

Press q to quit, any other key for next run:

Tower of Hanoi with n = 3:
Move disk #1 from A to C.
Move disk #2 from A to B.
Move disk #1 from C to B.
Move disk #3 from A to C.
Move disk #1 from B to A.
Move disk #2 from B to C.
Move disk #1 from A to C.

Press q to quit, any other key for next run:

• My blog jugad2
• Gumroad
• LinkedIn
• Twitter

Summary

Keeping up with the work being done in the Python community can be a full time job, which is why Dan Bader has made it his! In this episode he discusses how he went from working as a software engineer, to offering training, to now managing both the Real Python and PyCoders properties. He also explains his strategies for tracking and curating the content that he produces and discovers, how he thinks about building products, and what he has learned in the process of running his businesses.

Preface

• Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great.
• When you’re ready to launch your next app or want to try a project you hear about on the show, you’ll need somewhere to deploy it, so check out Linode. With 200 Gbit/s private networking, scalable shared block storage, node balancers, and a 40 Gbit/s public network, all controlled by a brand new API you’ve got everything you need to scale up. Go to podcastinit.com/linode to get a $20 credit and launch a new server in under a minute.
• Visit the site to subscribe to the show, sign up for the newsletter, and read the show notes. And if you have any questions, comments, or suggestions I would love to hear them. You can reach me on Twitter at @Podcast__init__ or email hosts@podcastinit.com)
• To help other people find the show please leave a review on iTunes, or Google Play Music, tell your friends and co-workers, and share it on social media.
• Join the community in the new Zulip chat workspace at podcastinit.com/chat
• Your host as usual is Tobias Macey and today I’m interviewing Dan Bader about finding, filtering, and creating resources for Python developers at Real Python, PyCoders, and his own trainings

Interview

• Introductions
• How did you get introduced to Python?
• Let’s start by discussing your primary job these days and how you got to where you are.
  • In the past year you have also taken over management of the Real Python site. How did that come about and what are your responsibilities?
  • You just recently took over management of the PyCoders newsletter and website. Can you describe the events that led to that outcome and the responsibilities that came along with it?
• What are the synergies that exist between your various roles and projects?
  • What are the areas of conflict? (e.g. time constraints, conflicts of interest, etc.)
• Between PyCoders, Real Python, your training materials, your Python tips newsletter, and your coaching you have a lot of incentive to keep up to date with everything happening in the Python ecosystem. What are your strategies for content discovery?
  • With the diversity in use cases, geography, and contributors to the landscape of Python how do you work to counteract any bias or blindspots in your work?
• There is a constant stream of information about any number of topics and subtopics that involve the Python language and community. What is your process for filtering and curating the resources that are ultimately included in the various media properties that you oversee?
• In my experience with the podcast one of the most difficult aspects of maintaining relevance as a content creator is obtaining feedback from your audience. What do you do to foster engagement and facilitate conversations around the work that you do?
• You have also built a few different product offerings. Can you discuss the process involved in identifying the relevant opportunities and the creation and marketing of them?
• Creating, collecting, and curating content takes a significant investment of time and energy. What are your avenues for ensuring the sustainability of your various projects?
• What are your plans for the future growth and development of your media empire?
• As someone who is so deeply involved in the conversations flowing through and around Python, what do you see as being the greatest threats and opportunities for the language and its community?

Keep In Touch

• @dbader_org on Twitter
• Website
• dbader on GitHub

Picks

• Tobias
  • Data Engineering Podcast
• Dan
  • Black code formatter
  • Łukasz Langa

Links

• Dan Bader
• Nerd Lettering
• Real Python
• PyCoders
• Computer Science
• Vancouver, BC
• Django
• Raymond Hettinger
• Data Science
• Flask
• Pythonista Cafe
• Python Tricks

The intro and outro music is from Requiem for a Fish The Freak Fandango Orchestra / CC BY-SA

In this article we will create a pop up win scene when the player has won all the levels which it will then ask the player whether he wants to start the game all over again or not? We will also create a framework for the level manager class which we will further add in more features in the next chapter. First of all, we will modify the start scene class again to include in a win scene graphic.

Source

Related posts:

Create a next level scene for pygame projectCreate the pool object for Enemy Missile classCreate a background object class in PygamePygame’s Color class demoHow to distribute the pygame program for windows osDetect overlapping more accurately with circle detection methodCreate a base class and a subclassHow to detect boundary in PygameDraw lines with PygameHow to draw a rectangle with Pygame

Throughout this tutorial, we'll learn about CSS Grid Layout. We'll be using a Django template.

There are many popular techniques for creating responsive layouts. In this tutorial, we'll be building a simple Django web application with a modern UI styled with CSS Grid layout.

By building the UI using CSS Grid, you'll learn about many useful and easy techniques for achieving popular requirements such as centering and spanning items, switching layouts depending on the screen size and creating responsive UIs.

Before, we dive into practical steps, let's first introduce CSS Grid.

What is CSS Grid?

CSS Grid is a modern 2-dimentionnal system for creating HTML layouts. It's now supported by most web browsers. It makes creating professional and complex layouts more easier than ever!

CSS Grid Layout allows you to build advanced grid layouts in CSS instead of HTML like the case for tables for example.

Unlike CSS floats and HTML tables you can create a grid layout in a straightforward way. You simply need to use an HTML element with its display property set to grid or inline-grid. This way, any elements contained in the parent element or the container becomes grid items. If you don't specify any other CSS Grid property, the items will be automatically arranged in a grid structure thanks to a powerful grid algorithm.

If you need more control over the grid items, you can use different CSS Grid properties to specify the different options for the items including position.

Prerequisites

If you want to follow this tutorial, step by step to build a CSS Grid UI for your Django application. You will need a few requirements. You need to have;

• A development environment ready with Python 3 and PIP installed,
• Basic knowledge of Python,
• Working knowledge of Django.

Creating a Virtual Environment & Installing Django

Now let's start by creating a virtual environment that will allow you to isolate your project's dependencies from the other Python dependencies installed on your system.

Go to your terminal and run the following command to create a virtual environment using the venv module included in Python 3.

$ cd ~
$ python3 -m venv env

Next, you need to activate this environment using:

$ source env/bin/activate

Now, you can install Django using pip:

$ pip install django

Creating a Django Project

After installing Django, you now need to create a project. Head back to your terminal and run the following command:

$ django-admin start css

$ django-admin.py startproject cssgriddemo

This command will generate a project named cssgriddemo.

Creating a Django Application

Now that you have created a Django project, you need to create a Django application. Head over to your terminal and run the following command to create the app:

$ python manage.py startapp gridui 

Next, add it to the list of installed apps in the settings.py file:

INSTALLED_APPS=[# [...]'gridui']

Next, we need to add a template and a view function.

Open the gridui/views.py file and add the following import:

fromdjango.views.generic.baseimportTemplateView```Nextaddthefollowingviewclass:```pythonclassHome(TempateView):template_name='gridui/index.html'

Next, add the gridui/index.html template with the following code:

<!DOCTYPE html><htmllang="en"><head><metacharset="utf-8"><title>Django UI with CSS Grid Layout</title></head><body><divclass="header"><h1>Django UI with CSS Grid Layout</h1></div><divclass="sidebar">
.sidebar
</div><divclass="main"><divclass="item"><span>1</span></div><divclass="item"><span>2</span></div><divclass="item"><span>...</span></div><divclass="item"><span>12</span></div></div><divclass="footer">
Copyright 2018
</div></body></html>

We create an HTML template with the header, sidebar, main and footer sections. In the main section, we include a set of items.

Finally, let's add an URL to our urls.py file

fromdjango.urlsimportpathfromgriduiimportviewsurlpatterns=[# [...]path('',views.Home.as_view())]

You can now migrate your database and run the Django server:

$ python manage.py migrate
$ python manage.py runserver

You application will be running from localhost:8000.

This is a screenshot of our interface at this point:

Next, let's add basic CSS styling. Add a <style> tag and add the following styles:

<style>body{background:#478dee;margin:5px;padding:0px;font-family:-apple-system,BlinkMacSystemFont,“SegoeUI”,“Roboto”,“Oxygen”,“Ubuntu”,“Cantarell”,“FiraSans”,“DroidSans”,“HelveticaNeue”,sans-serif;}div.header{text-transform:uppercase;}</style>

This is a screenshot of the interface:

Adding CSS Grid

Now that we have created a simple HTML structure, we can proceed by styling the UI using CSS Grid.

First we need to make the <body> element a grid container and define the grid columns, rows and areas:

body{//[...]display:grid;grid-gap:0.2vw;height:100vh;grid-template-columns:150px1fr;grid-template-rows:120px1fr61px;grid-template-areas:"header   header""sidebar content""footer footer";}

We use display:grid pair to make <body> a grid container. We also set a grid gap of _0.2vw.

We make use of grid-template-columns to define two columns, the first column has a fixed width of 150px and the second column has the remaining width.

fr is a fractional unit and 1fr means the element should take 1 part of the available space.

Next, we use grid-template-rows to define three rows:

• The first row has a fixed height of 120px ,
  
• The third row has a fixed height of 61px,
• The second row has the remaining space (1fr).
  

We finally use grid-template-areas for assigning the virtual cells, resulted from the intersection of columns and rows, to areas.

Now we need to define those areas specified in the areas template using grid-area:

div.header{grid-area:header;}div.sidebar{grid-area:sidebar;background:#0769f3;}div.footer{grid-area:footer;background:#3581eb;}div.main{grid-area:content;}

This is the screen shot of the result now:

Adding a Nested CSS Grid

Now that we have created the main layout of the page, let's use CSS Grid to create a nested grid in the content area.

Grid children can also be Grid containers.

Let's define the content area as a grid container. In the <style> tag, add the following CSS:

div.main{display:grid;grid-gap:0.2vw;grid-template-columns:repeat(auto-fill,minmax(150px,1fr));grid-template-rows:repeat(auto-fill,minmax(150px,1fr));}

Here we use repeat, auto-fill and minmax to define columns and rows.

Also add the following style to use an image background for items:

div.item{background-image:url('https://source.unsplash.com/daily');}

This is the screen shot of the result after adding more <div class="item"> elements: :

CSS Grid grid-column, grid-row and span

CSS Grid enables you to control the position of grid elements using grid-column and grid-row.

You can also use span to define how much columns or rows a specified element takes.

Now back to our project. Let's span the second item of the content area across five columns and two rows and position it from column line 2 and row line 1 (default location).

div.main>div.item:nth-child(2){grid-column:2/span5;grid-row:1/span2;}

This is a screen shot of the result:

Conclusion

In this tutorial you've seen how to create a beautiful UI for a Django application using CSS Grid Layout.