If you weren’t able to catch the Sonic The Hedgehog movie in cinemas before the COVID-19 outbreak, there’s no need to worry as Paramount Pictures has decided to bring forward the film’s digital release.

It’ll now be made available at the end of this month on 31st March, which is pretty crazy considering its theatrical release was Valentine’s Day. This digital launch will be followed by the Blu-ray and 4K Ultra HD release on 19th May.

Sonic the Hedgehog is one of the many films scoring an early release on digital because of the current global pandemic. Various upcoming movies like No Time to Die and Black Widow have been delayed.

Fortunately, this decision is unlikely to impact Sonic’s box office sales, as it’s already banked USD $306 million worldwide and managed to surpass Pokémon Detective Pikachu as the highest-grossing video game film of all-time in North America.

Did you manage to catch Sonic while he was in cinemas? Have you been holding out for the digital release? Tell us below.

News | Bungie.net”> News | Bungie.net”>

PlayStation Xbox Live Steam Stadia Twitch Battle.net

Dave Lang is founder of Iron Galaxy Studios, known for Killer Instinct, Extinction, Divekick, and world class ports of games like Skyrim, Overwatch, and the venerable Street Fighter III: 3rd Strike Online Edition.

Lang has a storied past in game development and shares his learnings about how to make a studio that’s built to last, his take on quality of life in game development, and much more (including addressing rumors about a mafia-run Midway Games, how the 2008 recession totally worked out for him, and all that Windjammers stuff).

Listen now on iTunes, Google Play Music, and Spotify

GDC Podcast music by Mike Meehan.

“Basically the reason Iron Galaxy exists…is because I’d been at so many companies that closed overnight on me. Sculptured [Software] kicked out the management, it wasn’t the company I loved anymore, Kodiak [Interactive] literally closed overnight on me, Microsoft, a company with like 10 billion in the bank told me I’m not welcome there anymore essentially, I need to find a new job. Midway disintegrated around me. It’s like no place is safe and I just wanted to build a game developer where I could work with my friends until I was done making games, right? I want to build a place that you can retire from if you wanna retire from.

“So stability is the thing we care about most in the world, and as such we tend to work on a bunch of projects at once, and a bunch of varieties of projects at once. And so we started off doing just tech consulting, firefighting stuff. Then we branched into doing ports, then we branched into doing original development and kind of our portfolio now, ideally, we’ve got one really big creative project in the works, whether it’s Killer Instinct or Extinction or whatever is next for us which we can’t talk about quite yet.

“We’re doing some ports—we helped Blizzard do Overwatch, Diablo III, we helped with Skyrim on the Switch port with Bethesda, and we still are doing a lot of co-development. We have people embedded on teams at Bethesda and Blizzard and other places I can’t mention yet.

“We do all this different work and we do 10-12 different things at once. We don’t do it because it’s easy, we do it because if one of [the projects] goes away, no one has to lose their job. There’s plenty of work to go around for everyone else.

“When people start at IG, what I tell them is ‘Ok, if you’re coming here and you have a game in your head that needs to get out, this is probably not the best place for you to be. Because we’re not saying we’re not gonna make it, I’m not saying it’s impossible, I’m saying it’s not a priority. What’s important here is making sure this company is built to last and we’re going to make robust decisions around ensuring that other peoples’ bad decisions or games’ bad performances don’t affect us in any way, shape, or form.“

Oh it’s definitely better. [It] couldn’t be any worse than it was when I started. And I do want to clarify something—I do tend to get asked about this a lot. One thing I universally do a bad job at explaining [is] Iron Galaxy has not always been this place where we don’t crunch. In the beginning I’d say the first three or four years or whatever, we all worked our asses off.

And then at some point, I just kind of decided, ‘You know what, if this is the way it has to be, then it’s kind of not worth doing.’ It wasn’t overnight, but we slowly built a culture of no crunching and zero tolerance of that sort of thing. Some people still work hard and put in extra hours because they’re passionate about stuff but it’s something we try to monitor and the company will never ever ask anybody to work for more than 40 a week…As long as you’re giving me your best 40, that’s all I care about. It’s something I feel pretty strongly about now and I think we’ve proven you can do it.

The hard part with creative project and no-crunch policy…a game can always, always be better…And developers know what can be better. We’re not blind—we play the game and we see these problems. So having the discipline to walk that line and to take care of yourself while you feel like you’re doing your best work is very challenging on creative projects. I think the industry still sucks at it, but through the lens of ‘wow that’s a really hard problem.’ I’m not sure what the solution long-term is.

Find out more about GDC Summer, taking place August 4-6 in San Francisco. Subscribe to regular updates via Facebook, Twitter, or RSS.

This tutorial shows you everything you need to know to help you master the essential reverse() method of the most fundamental container data type in the Python programming language.

Definition and Usage:

The list.reverse() reverses the order of the elements in the list. If you want to create a new list with reversed elements, use slicing with negative step size list[::-1].

Here’s a short example:

>>> lst = [1, 2, 3, 4]

>>> lst.reverse()

>>> lst

[4, 3, 2, 1]

In the first line of the example, you create the list lst. You then reverse the order of the elements in the list and print it to the shell.

Code Puzzle — Try It Yourself:

Now you know the basics. Let’s deepen your understanding with a short code puzzle—can you solve it?

You can also solve this puzzle and track your Python skills on our interactive Finxter app.

Syntax: You can call this method on each list object in Python. Here’s the syntax:

list.reverse()

Arguments: The reverse method doesn’t take any arguments.

Return value: The method list.reverse() has return value None. It reverses the elements of the list in place (but doesn’t create a new list). Thus, a return value is not needed.

Python List reverse() Time Complexity

The time complexity of the reverse() operation is O(n) for a list with n elements. The standard Python implementation cPython “touches” all elements in the original list to move them to another position. Thus, the time complexity is linear in the number of list elements.

You can see a plot of the time complexity of the reverse() method for growing list size here:

The figure shows how the elapsed time of reversing lists with growing number of elements grows linear to the number of elements.

If you’re interested in the code I used to generate this plot with Matplotlib, this is it:

import matplotlib.pyplot as plt

import time y = []

for i in [100000 * j for j in range(10,100)]: lst = list(range(i)) t0 = time.time() x = lst.reverse() t1 = time.time() y.append(t1-t0) plt.plot(y)

plt.xlabel("List elements (10**5)")

plt.ylabel("Time (sec)")

plt.show()

Python List reverse() In Place

If you call the list.reverse() method on any list object in Python, it reverses the list elements of this particular list object. You say that the reverse method happens in place.

This is a common mistake of many Python beginners. They assume that the reverse() method creates a new list with the elements in reversed order. This is not the case: the reverse() method modifies only the existing list object.

You can see this in the following example:

>>> lst = [1, 2, 3]

>>> lst.reverse()

>>> lst

[3, 2, 1]

In the example, you only reversed the existing list lst. But you didn’t create a new list!

Python List reverse() None

The return value of the list.reverse() method is None. Why? Because the method reverses the list in place. This means that no new list is created. Instead, the method modifies the old list object.

You’ve seen an example of this in the previous section.

Python List Reverse List Without reverse()

You can also reverse a list without using the reverse() method. Let’s have a look at the following table that shows all reverse() alternatives:

There is a fifth solution using recursion. But it’s highly inefficient and you shouldn’t use it in practice. If you want to learn about it anyways, read on. But don’t tell me you haven’t been warned!

Python List Reverse Recursive

You can create a recursive function to reverse any list. I’ll give you the code first and explain it later:

>>> reverse = lambda lst: reverse(lst[1:]) + [lst[0]] if lst else []

Let’s check if it does what it’s supposed to do (reversing the list):

>>> reverse([1, 2, 3])

[3, 2, 1]

>>> reverse(["Ann", 1, 42, 0])

[0, 42, 1, 'Ann']

>>> reverse([])

[]

>>> reverse([1])

[1]

Okay, it works!

The recursive one-liner solution uses several Python features you have to understand before you can understand it entirely:

• The lambda function lambda x: y creates an anonymous function with argument x and return value y. You can read the detailed tutorial on the Finxter blog.
• List concatenation [a, b, c] + [d] creates the new list [a, b, c, d]. You can read the detailed tutorial on the Finxter blog.
• Slicing lst[start:stop] carves out a subsequence from the list between the start and stop indices. You can read the detailed tutorial on the Finxter blog.
• The ternary operator x if y else z returns the value x if y is True. In all other cases, it returns the value z. You can read the detailed tutorial on the Finxter blog.

Phew! Quite some information to digest! But that’s not all. If you’ve understood all of the above, you also need to understand recursion. That’s too much to teach in a single paragraph so I’d send you over to my blog article about recursion.

I’ll say only that much: to understand recursion, you first need to understand recursion!

Python List Reverse Slice

Slicing is the easiest way to reverse a list.

To reverse the list lst, you simply use slicing operation lst[::-1] with default start and stop indices (not given) and negative step size -1 (given).

There’s only one case where you shouldn’t use slicing to reverse the list and this is if you don’t want to create a new list. In this case, stick to the lst.reverse() method which reverses the list in place.

Here’s an example of slicing to reverse a given list:

>>> friends = ["Ann", "Carsten", "Bob", "Alice"]

>>> r_friends = friends[::-1]

>>> friends

['Ann', 'Carsten', 'Bob', 'Alice']

>>> r_friends

['Alice', 'Bob', 'Carsten', 'Ann']

You see that the two lists friends and r_friends are independent objects in memory because the slicing operation creates a new list.

Related articles:

• Introduction to Slicing in Python

Python List Reverse Copy

There are two ways to copy a list and reverse the order of its elements:

• Use slicing list[::-1], or
• Call the reversed(list) method and convert the result to a list using the list(...) constructor.

Here are both in action:

>>> lst_1 = ['Alice', 'Bob', 'Ann']

>>> lst_2 = lst_1[::-1]

>>> lst_3 = list(reversed(lst_1))

>>> lst_1

['Alice', 'Bob', 'Ann']

>>> lst_2

['Ann', 'Bob', 'Alice']

>>> lst_3

['Ann', 'Bob', 'Alice']

Python List Partial Reverse

To partially reverse a list lst, use slicing with negative step size: lst[start:stop:-1]. The start and stop values define the part of the list to be reversed and the step size -1 means that you go through the list in reversed order.

Here’s an example of some partial list reversals:

>>> lst = ['a', 'b', 'c', 'd', 'e']

>>> lst[5:2:-1]

['e', 'd']

>>> lst[:1:-1]

['e', 'd', 'c']

>>> lst[3:2:-1]

['d']

All of those slicing operations reversed a subsequence of the original list. Note that the start index must be larger or equal than the stop index because you traverse the list in negative order (well, if you don’t want to have an empty slice object).

Python List Reverse List Comprehension

You can reverse a list with Python’s powerful list comprehension method. (Although I cannot imagine a scenario where this would actually make sense.)

Related article:

• Introduction to List Comprehension

List comprehension is a compact way of creating lists. The simple formula is [ expression + context ].

• Expression: What to do with each list element?
• Context: What list elements to select? It consists of an arbitrary number of for and if statements.

For example, the expression [x for x in range(3)] creates the list [0, 1, 2].

Here’s how you’d use list comprehension to reverse a list:

[lst[i] for i in range(len(lst)-1,-1,-1)]

You go over all indices in negative order—starting with the last list index len(lst)-1 and ending in the first list index 0. Note that the stop index is not included in the index sequence so I used the value -1 as the stop index for the range() built-in function.

Python List reverse() vs reversed()

What’s the difference between the method list.reverse() and the built-in function reversed(list)?

• list.reverse() modifies an existing list in place and reverses the order of elements in this list object. No new list object is created.
• reversed(list) creates a new iterable object by reversing the order of elements of the original list.

So you should use the former if you don’t want to create a new list and the latter if you want to create a new iterable without modifying the existing list.

An example is the following:

>>> lst_1 = [1, 2, 3]

>>> lst_1.reverse()

>>> lst_1

[3, 2, 1]

>>> reversed(lst_1)

<list_reverseiterator object at 0x0000025B58FEC9B0>

The output is not very intuitive but it only means that the reversed() function returns an iterable object.

Python List Deep Reverse

What if you want not only to reverse a list but running a deep reverse where all nested lists are also reversed in a recursive manner?

Here’s how you can do it:

def deep_reverse(lst): ''' Reverses a nested list in place''' # Reverse top-level list lst.reverse() # Recursively reverse all nested lists for element in lst: if isinstance(element, list): deep_reverse(element) lst = [1, 2, 3, [4, 5, 6]]

deep_reverse(lst)

print(lst)

This generates the output:

# OUTPUT: [[6, 5, 4], 3, 2, 1]

Not only the first-level list is reversed but also the second-level list. The code is loosely inspired from this article.

Python List Reverse Enumerate

The enumerate(list) built-in function returns a list of tuples with the first tuple value being the list index and the second tuple value being the list element.

You can reverse the order of enumerated tuples by stacking together the enumerate() function and the list.reverse() method as follows:

>>> for i, el in enumerate(list(reversed([1, 2, 3]))): print(i, el) 0 3

1 2

2 1

This way, you first reverse the list which creates an iterator. You then transform it into a list. The result can be enumerated.

If you want to reverse the order of the indices as well, simply switch the order of both functions:

>>> for i, el in reversed(list(enumerate([1, 2, 3]))): print(i, el) 2 3

1 2

0 1

By first enumerating, you calculate the indices based on the original list. Then you reverse them in the outer function.

Python List Reverse Iterator

The reversed(list) method returns an iterator, not a new list. This is different: an iterator is more efficient than a list. You can easily convert the iterator object into a list by using the list(...) built-in function.

Here’s an example:

>>> reversed([1, 2, 3])

<list_reverseiterator object at 0x0000021735E070B8>

>>> for i in reversed([1, 2, 3]): print(i) 3

2

1

The iterator object doesn’t look pretty in the shell but it’s a more efficient way to iterate over a sequence of values than using lists. Why? Because lists need to maintain all values in memory. Iterators don’t.

Python List Reverse Sort

Do you want to sort a list in descending order? Use the reverse=True argument of the sorted() method. Here’s an example:

>>> sorted([42, 1, 99])

[1, 42, 99]

>>> sorted([42, 1, 99], reverse=True)

[99, 42, 1]

Python List reverse() Index

Rather than just using positive list indices, you can use reverse indexing in Python lists, too. The negative integer index -1 accesses the last element. The negative integer index -2 accesses the second last element and so on. Here’s an example:

>>> lst = ["Alice", "Bob", "Ann"]

>>> lst[-1] 'Ann'

>>> lst[-2] 'Bob'

>>> lst[-3] 'Alice'

Python List Reverse range()

Do you want to iterate over a range of integer values in reverse order? Say, you want to iterate over the numbers from 10 to 0 in reverse order: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0. You can simply achieve this by specifying the start, stop, and step arguments of the range(start, stop, step) method:

>>> for i in range(10, -1, -1): print(i) 10

9

8

7

6

5

4

3

2

1

0

Note that the start argument is included in the range but the stop argument isn’t.

Python List reverse() Doesn’t Work

What if the reverse() method doesn’t work? Chances are that you assume the list.reverse() method has a return value—that is the reversed list. This is not the case! The list.reverse() method returns None because it reverses the list in place. It doesn’t return a new reversed list.

Here’s an example what you’re probably doing:

>>> lst = [1, 2, 3]

>>> print(lst)

[1, 2, 3]

>>> print(lst.reverse())

None

If you really want to have a new list with elements in reversed order, use the Python built-in reversed(list) method:

>>> print(list(reversed([1, 2, 3])))

[3, 2, 1]

The reversed() method reverses the list and returns the reversed list as an iterator object. You need to convert it to a list first before printing it to the shell (and receiving a meaningful output).

Python Reverse List NumPy

To reverse a NumPy array (or even a Python list), you can simply use slicing with negative step size a[::-1]. Here’s an example:

>>> import numpy as np

>>> a = np.array([1, 2, 3])

>>> a[::-1]

array([3, 2, 1])

Python List reverse() Thread Safe

Do you have a multiple threads that access your list at the same time? Then you need to be sure that the list operations (such as reverse()) are actually thread safe.

In other words: can you call the reverse() operation in two threads on the same list at the same time? (And can you be sure that the result is meaningful?)

The answer is yes (if you use the cPython implementation). The reason is Python’s global interpreter lock that ensures that a thread that’s currently working on it’s code will first finish its current basic Python operation as defined by the cPython implementation. Only if it terminates with this operation will the next thread be able to access the computational resource. This is ensured with a sophisticated locking scheme by the cPython implementation.

The only thing you need to know is that each basic operation in the cPython implementation is atomic. It’s executed wholly and at once before any other thread has the chance to run on the same virtual engine. Therefore, there are no race conditions. An example for such a race condition would be the following: the first thread reads a value from the list, the second threads overwrites the value, and the first thread overwrites the value again invalidating the second thread’s operation.

All cPython operations are thread-safe. But if you combine those operations into higher-level functions, those are not generally thread safe as they consist of many (possibly interleaving) operations.

Where to Go From Here?

The list.reverse() method reverses the order of the list elements.

You’ve learned the ins and outs of this important Python list method.

If you keep struggling with those basic Python commands and you feel stuck in your learning progress, I’ve got something for you: Python One-Liners (Amazon Link).

In the book, I’ll give you a thorough overview of critical computer science topics such as machine learning, regular expression, data science, NumPy, and Python basics—all in a single line of Python code!

Get the book from Amazon!

OFFICIAL BOOK DESCRIPTION: Python One-Liners will show readers how to perform useful tasks with one line of Python code. Following a brief Python refresher, the book covers essential advanced topics like slicing, list comprehension, broadcasting, lambda functions, algorithms, regular expressions, neural networks, logistic regression and more. Each of the 50 book sections introduces a problem to solve, walks the reader through the skills necessary to solve that problem, then provides a concise one-liner Python solution with a detailed explanation.

With so many people stuck at home due to the quarantines around the COVID-19 virus, Unity technologies have released Unity Learn Premium for free to developers for the next few months.  Unity Learn Premium is a great source of Unity tutorials, courses, lessons and projects and even included non-Unity related content on topics such as Max and Maya.  You can learn more about Unity Learn in our prior hands-on video.

Details from the State of Unity 2020:

As the world continues to change, we are committed to helping all of you learn new skills and capabilities that can help bring your vision to life. We are pleased to announce that we are giving everyone complimentary access to Unity Learn Premium starting today through June 20. Just log in to access live sessions with Unity experts and more than 350 hours of bite-sized tutorials, hands-on projects, and in-depth courses for game developers and any creator that can benefit from the power of real-time technology. This includes everything from Game Mechanic Design Fundamentals to Getting Started with Post-Processing Stack for VR. Additionally, we are delivering Create with Code Live, live virtual classes taught by Unity experts for students, educators, and anyone who wants to learn how to code, starting on Monday, March 23.

Even if you are an existing Premium subscriber, Unity have you covered there, having released the following email:

Monthly Subscribers
We are pausing your monthly payments for three months, from March 19 until June 20. If your payment date falls within this period, you will not be charged for Unity Learn Premium. You don’t need to do anything – we’ll take care of it.

Annual Subscribers
We are adding three months of access to your Unity Learn Premium subscription. For example, if your subscription is scheduled to renew on October 1, 2020, it will now renew on January 1, 2021. No action is required on your part; we’ll automatically shift your renewal date.

30-day Trial Subscribers
If you are currently in a trial period and want to continue using Learn Premium past this trial period, we will waive your monthly payments through June 20.

Class move by Unity in these troubling times.  You can learn more about the announcement in the video below.

GameDev News Unity

<!–

–>

By AppleInsider Staff
Saturday, March 21, 2020, 09:14 pm PT (12:14 am ET)

Apple this weekend updated its Siri voice assistant with information and assets designed to triage users who believe they are suffering from COVID-19.

Siri’s response to COVID-19 queries.

With the new capability, built using information provided by the U.S. Public Health Service and the Centers for Disease Control, Siri guides users through a set of questions designed in part to screen for the new coronavirus. Depending on user responses, the process branches to provide additional information about the disease and, if necessary, contact emergency services or a health provider.

The feature is triggered by queries like “Hey Siri, do I have the coronavirus?” and “Hey Siri, I think I have COVID-19.”

Siri first asks if users are exhibiting symptoms including fever, dry cough, or shortness of breath. A positive answer leads to a follow-up question regarding severity which, depending on the response, results in an option to automatically call 911. Those without symptoms are asked if they have been exposed to someone who tested positive for COVID-19.

Users who answer “yes” to certain questions, specifically those referencing COVID-19 symptoms, are urged to isolate and closely monitor the situation, or contact a medical provider if the condition worsens, are age 65 or over, or have a serious medical condition.

If the situation is not dire, Siri directs users to the CDC’s COVID-19 webpage or the App Store, the latter of which currently features a PSA on social distancing from the White House Coronavirus Task Force. The same PSA is in rotation on the Apple.com homepage and in the “Browse” section of Apple Music.

Siri’s COVID-19 protocol is currently restricted to the U.S., likely because the feature’s underlying information was derived from American health authorities. Whether Apple is working on similar solutions for other regions is unknown.

CNBC reported on the new Siri capability on Saturday.

In addition to user-facing resources, Apple is assisting the general public through monetary donations and the contribution of face masks in the U.S. and abroad.

Streets of Rage 4 might not have a release date yet, but that hasn’t stopped DotEmu, Lizardcube and Guard Crush Games from revealing more about this upcoming release. Following on from the news the legendary composer Yuzo Koshiro would be returning to help out with the newest entry in the series, Olivier Derivière has now been revealed as the fourth outing’s main composer.

This talented individual has previously worked on the soundtracks for A Plague Tale: Innocence, Assassin’s Creed IV: Black Flag and Dying Light 2. He’ll also be receiving support from a number of guests musicians, including contributions from Scattle (both Hotline Miami games), Das Mörtal (Hotline Miami 2), XL Middleton, and Groundislava.

I’m very grateful and humble for being the main composer on Streets of Rage 4. Of course the legendary @yuzokoshiro has also brought his magic! Many thanks to @Dotemu @Guard_Crush @lizardcube and @SEGA to have given me this opportunity!

When queried over on Twitter about who would be covering what in the game (as touched on in the video above), Olivier explained how Yuzo wrote “every” iconic music track such as the main theme, character selection, intro level, and “some” boss fights, whereas he contributed the following “all new” material:

I wrote all the levels in dynamic music celebrating 25 years of music styles since the last SOR

If you like the sound of this, feel free to head over to Limited Run games and pre-order a classic or standard edition of the game for Nintendo Switch.