What if you have a ternary operator that’s very long?
var = 'I want to learn Python' if 42**2<166 else 'I want to learn Go programming'
print(var)
# I want to learn Go programming
Problem: How to write the ternary operator in multiple lines?
Short Recap: Ternary Operator
Ternary Operator: The most basic ternary operator x if c else y consists of three operands x, c, and y. It is an expression with a return value. The ternary operator returns x if the Boolean expression c evaluates to True. Otherwise, if the expression c evaluates to False, the ternary operator returns the alternative y.
Syntax: The three operands are written as x if c else y which reads as “return x if c else return y“. Let’s write this more intuitively as:
<OnTrue> if <Condition> else <OnFalse>
Operand
Description
<OnTrue>
The return expression of the operator in case the condition evaluates to True
<Condition>
The condition that determines whether to return the <On True> or the <On False> branch.
<OnFalse>
The return expression of the operator in case the condition evaluates to False
var = 'I want to learn Python' if 42**2<166 else 'I want to learn Go programming'
print(var) var = ('I want to learn Python' if 42**2<166 else 'I want to learn Go programming')
print(var)
# I want to learn Go programming
This is the PEP8 standard way of breaking long lines—if you cannot do it in a more natural way (such as avoiding the ternary operator and using the if statement in this example).
Try it yourself:
Exercise: Write a nested ternary operator and break it into multiple lines!
Where to Go From Here?
Enough theory, let’s get some practice!
To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?
Practice projects is how you sharpen your saw in coding!
Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?
Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.
Do you want to learn Python but you’re overwhelmed and you don’t know where to start? Learn with Python cheat sheets! They compress the most important information in an easy-to-digest 1-page format.
Here’s the new Python cheat sheet I just created—my goal was to make it the world’s most concise Python cheat sheet!
You may know the ternary operator x if c else y in Python which reads as “return x if c else return y“. But you may not know that you can also write the ternary operator in a shorter form as (y, x)[c]. Let’s dive into this concise way of hacking your own ternary operator!
A shorthand form of the ternary operator is the following tuple syntax hack.
Syntax: You can use the tuple syntax (x, y)[c] consisting of a tuple (x, y) and a condition c enclosed in a square bracket. Here’s a more intuitive way to represent this tuple syntax.
(<OnFalse>, <OnTrue>)[<Condition>]
Operand
Description
<OnTrue>
The return expression of the operator in case the condition evaluates to True
<Condition>
The condition that determines whether to return the <On True> or the <On False> branch.
<OnFalse>
The return expression of the operator in case the condition evaluates to False
Tuple Syntax of the Ternary Operator
Exercise: Run the code and compare both ternary operators—the original and the tuple syntax hack.
In fact, the order of the <OnFalse> and <OnTrue> operands is just flipped when compared to the basic ternary operator. First, you have the branch that’s returned if the condition does NOT hold. Second, you run the branch that’s returned if the condition holds.
age = 17
print(('wtf', 'What?')[age<20]) 'What?'
The condition age<20 holds so the return value passed into the print() function is the <OnTrue> branch 'What?'. Don’t worry if this confuses you—you’re not alone. Let’s clarify why this tuple syntax works the way it does!
First, you create a tuple ('wtf', 'What?'). To access the first tuple value 'wtf', you’d use the standard indexing syntax('wtf', 'What?')[0]. To access the second tuple value 'What?', you’d use the standard indexing syntax ('wtf', 'What?')[1].
Second, you create a condition age<20. You use this condition as the indexing value. You end up with either ('wtf', 'What?')[False] or ('wtf', 'What?')[True]. As you may know, the Booleans False and True are represented through integers 0 and 1 in Python. Thus, you get ('wtf', 'What?')[0] and ('wtf', 'What?')[1], respectively.
In other words: if your condition evaluates to False, you access the first tuple value. If your condition evaluates to True, you access the second tuple value.
Where to Go From Here?
Enough theory, let’s get some practice!
To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?
Practice projects is how you sharpen your saw in coding!
Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?
Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.
Ternary (from Latin ternarius) is an adjective meaning “composed of three items”. (source) So, literally, the ternary operator in Python is composed of three operands.
Syntax: The three operands are written in an intuitive combination ... if ... else ....
<On True> if <Condition> else <On False>
Operand
Description
<On True>
The return expression of the operator in case the condition evaluates to True
<Condition>
The condition that determines whether to return the <On True> or the <On False> branch.
<On False>
The return expression of the operator in case the condition evaluates to False
Operands of the Ternary Operator
Let’s have a look at a minimum example in our interactive code shell:
Exercise: Run the code and input your age. What’s the output? Run the code again and try to change the output!
Let’s dive into the different variants of the Ternary operator in Python!
Python Ternary Examples
Let’s have a quick overview of a few examples on different methods to use the ternary operator:
age = 17 # Method 1: Basic Ternary
print('wtf' if age<20 else 'What?') 'wtf' # Method 2: Ternary Tuple
# (onFalse, onTrue) [condition]
print(('wtf', 'What?') [age<20]) 'What?' # Method 3: Ternary Dictionary
# Use Dictionary True/False values
print({True: 'wtf', False: 'What?'} [age<20]) 'wtf' # Method 4: Ternary Lambda
# Lambda function with 0 arguments
# Execute only one branch expression --> more efficient
print((lambda: 'wtf', lambda:'What?') [age<20]()) 'What?'
Some of them are pretty confusing, right? Stay with me for a moment because you’ll learn about each of those next!
Python Ternary Tuple
Python Ternary Dictionary
Python Ternary Lambda
Python Ternary Multiple Lines
Python Ternary Elif
Python Ternary Nested
Python Ternary Plot
Python Ternary Diagram
Python Ternary Evaluation Order
Python Ternary Try Except
Python Ternary Tree
Python Ternary in List Comprehension
Python Ternary Pep8 Pythonic
Python Ternary Can’t Assign to Conditional Expression
Python Ternary For Loop
Python Ternary Break
Python Ternary None
Python Ternary Multiple Conditions
Where to Go From Here?
Enough theory, let’s get some practice!
To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?
Practice projects is how you sharpen your saw in coding!
Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?
Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.
Python programmers will improve their computer science skills with these useful one-liners.
Python One-Linerswill teach you how to read and write “one-liners”: concise statements of useful functionality packed into a single line of code. You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.
The book’s five chapters cover tips and tricks, regular expressions, machine learning, core data science topics, and useful algorithms. Detailed explanations of one-liners introduce key computer science concepts and boost your coding and analytical skills. You’ll learn about advanced Python features such as list comprehension, slicing, lambda functions, regular expressions, map and reduce functions, and slice assignments. You’ll also learn how to:
• Leverage data structures to solve real-world problems, like using Boolean indexing to find cities with above-average pollution • Use NumPy basics such as array, shape, axis, type, broadcasting, advanced indexing, slicing, sorting, searching, aggregating, and statistics • Calculate basic statistics of multidimensional data arrays and the K-Means algorithms for unsupervised learning • Create more advanced regular expressions using grouping and named groups, negative lookaheads, escaped characters, whitespaces, character sets (and negative characters sets), and greedy/nongreedy operators • Understand a wide range of computer science topics, including anagrams, palindromes, supersets, permutations, factorials, prime numbers, Fibonacci numbers, obfuscation, searching, and algorithmic sorting
By the end of the book, you’ll know how to write Python at its most refined, and create concise, beautiful pieces of “Python art” in merely a single line.
In this one-liner tutorial, you’ll learn about the popular sorting algorithm Quicksort. Surprisingly, a single line of Python code is all you need to write the Quicksort algorithm!
Problem: Given a list of numerical values (integer or float). Sort the list in a single line of Python code using the popular Quicksort algorithm!
Example: You have list [4, 2, 1, 42, 3]. You want to sort the list in ascending order to obtain the new list [1, 2, 3, 4, 42].
Short answer: The following one-liner solution sorts the list recursively using the Quicksort algorithm:
q = lambda l: q([x for x in l[1:] if x <= l[0]]) + [l[0]] + q([x for x in l if x > l[0]]) if l else []
You can try it yourself using the following interactive code shell:
Now, let’s dive into some details!
A Conceptual Introduction
The following introduction is based on my new book “Python One-Liners”(Amazon Link) that teaches you the power of the single line of code (use it wisely)!
Introduction: Quicksort is not only a popular question in many code interviews – asked by Google, Facebook, and Amazon – but also a practical sorting algorithm that is fast, concise, and readable. Because of its beauty, you won’t find many introduction to algorithm classes which don’t discuss the Quicksort algorithm.
Overview: Quicksort sorts a list by recursively dividing the big problem (sorting the list) into smaller problems (sorting two smaller lists) and combining the solutions from the smaller problems in a way that it solves the big problem. In order to solve each smaller problem, the same strategy is used recursively: the smaller problems are divided into even smaller subproblems, solved separately, and combined. Because of this strategy, Quicksort belongs to the class of “Divide and Conquer” algorithms.
Algorithm: The main idea of Quicksort is to select a pivot element and then placing all elements that are larger or equal than the pivot element to the right and all elements that are smaller than the pivot element to the left. Now, you have divided the big problem of sorting the list into two smaller subproblems: sorting the right and the left partition of the list. What you do now is to repeat this procedure recursively until you obtain a list with zero elements. This list is already sorted, so the recursion terminates.
The following Figure shows the Quicksort algorithm in action:
Figure: The Quicksort algorithm selects a pivot element, splits up the list into (i) an unsorted sublist with all elements that are smaller or equal than the pivot, and (ii) an unsorted sublist with all elements that are larger than the pivot. Next, the Quicksort algorithm is called recursively on the two unsorted sublists to sort them. As soon as the sublists contain maximally one element, they are sorted by definition – the recursion ends. At every recursion level, the three sublists (left, pivot, right) are concatenated before the resulting list is handed to the higher recursion level.
This brings us to the following code:
Python One-Liner Quicksort [Code]
Create a function q which implements the Quicksort algorithm in a single line of Python code – and thus sorts any argument given as a list of integers.
## The Data
unsorted = [33, 2, 3, 45, 6, 54, 33] ## The One-Liner
q = lambda l: q([x for x in l[1:] if x <= l[0]]) + [l[0]] + q([x for x in l if x > l[0]]) if l else [] ## The Result
print(q(unsorted))
Listing: One-liner solution for the Quicksort algorithm using recursion.
What is the output of this code? Let’s see…
Explanation Quicksort One-Liner
We have already discussed the recursive Quicksort algorithm above. The one-liner resembles exactly the discussed algorithm. First, we create a new lambda function q which takes only one list argument l.
The lambda function has the following structure:
lambda l: q(left) + pivot + q(right) if l else []
The lambda function returns the empty list [] in the recursion base case (that is – the list to be sorted is empty and, therefore, trivially sorted).
In any other case, it selects the pivot element as the first element of list l, divides all elements into two sublists (left and right) based on whether they are smaller or larger than the pivot. To achieve this, we use simple list comprehension.
As the two sublists are not necessarily sorted, we recursively execute the Quicksort algorithm on them. Finally, we combine all three lists and return the sorted list. Therefore, the result is:
## The Result
print(q(unsorted))
# [2, 3, 6, 33, 33, 45, 54]
Related: For an interactive experience of what you’ve just learned, check out our Instagram post about the Quicksort algorithm:
To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?
Practice projects is how you sharpen your saw in coding!
Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?
Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.
This is a running document in which I’ll answer all questions regarding the single line of Python code. If you want to check out my book “Python One-Liners” and become a one-liner wizard—be my guest!
Let’s get started!
Python One Line If Without Else
Python One Line If Else
Python One Line Elif
Python One Line Function
Python One Line For Loop
Python One Line For Loop If
Python One Line For Loop Lambda
Python One Line While Loop
Python One Line HTTP Web Server
Want to create your own webserver in a single line of Python code? No problem, just use this command in your shell:
$ python -m http.server 8000
The terminal will tell you:
Serving HTTP on 0.0.0.0 port 8000
To shut down your webserver, kill the Python program with CTRL+c.
This works if you’ve Python 3 installed on your system. To check your version, use the command python --version in your shell.
You can run this command in your Windows Powershell, Win Command Line, MacOS Terminal, or Linux Bash Script.
You can see in the screenshot that the server runs on your local host listening on port 8000 (the standard HTTP port to serve web requests).
Note: The IP address is NOT 0.0.0.0—this is an often-confused mistake by many readers. Instead, your webserver listens at your “local” IP address 127.0.0.1 on port 8000. Thus, only web requests issued on your computer will arrive at this port. The webserver is NOT visible to the outside world.
Python 2: To run the same simple webserver on Python 2, you need to use another command using SimpleHTTPServerinstead of http:
$ python -m SimpleHTTPServer 8000
Serving HTTP on 0.0.0.0 port 8000 ...
If you want to start your webserver from within your Python script, no problem:
import http.server
import socketserver PORT = 8000 Handler = http.server.SimpleHTTPRequestHandler with socketserver.TCPServer(("", PORT), Handler) as httpd: print("serving at port", PORT) httpd.serve_forever()
You can execute this in our online Python browser (yes, you’re creating a local webserver in the browser—how cool is that)!
This code comes from the official Python documentation—feel free to read more if you’re interested in setting up the server (most of the code is relatively self-explanatory).
In this one-liner tutorial, you’ll learn about the popular sorting algorithm Quicksort. Surprisingly, a single line of Python code is all you need to write the Quicksort algorithm!
Problem: Given a list of numerical values (integer or float). Sort the list in a single line of Python code using the popular Quicksort algorithm!
Example: You have list [4, 2, 1, 42, 3]. You want to sort the list in ascending order to obtain the new list [1, 2, 3, 4, 42].
Short answer: The following one-liner solution sorts the list recursively using the Quicksort algorithm:
q = lambda l: q([x for x in l[1:] if x <= l[0]]) + [l[0]] + q([x for x in l if x > l[0]]) if l else []
You can try it yourself using the following interactive code shell:
Now, let’s dive into some details!
The following introduction is based on my new book “Python One-Liners”(Amazon Link) that teaches you the power of the single line of code (use it wisely)!
Introduction: Quicksort is not only a popular question in many code interviews – asked by Google, Facebook, and Amazon – but also a practical sorting algorithm that is fast, concise, and readable. Because of its beauty, you won’t find many introduction to algorithm classes which don’t discuss the Quicksort algorithm.
Overview: Quicksort sorts a list by recursively dividing the big problem (sorting the list) into smaller problems (sorting two smaller lists) and combining the solutions from the smaller problems in a way that it solves the big problem. In order to solve each smaller problem, the same strategy is used recursively: the smaller problems are divided into even smaller subproblems, solved separately, and combined. Because of this strategy, Quicksort belongs to the class of “Divide and Conquer” algorithms.
Algorithm: The main idea of Quicksort is to select a pivot element and then placing all elements that are larger or equal than the pivot element to the right and all elements that are smaller than the pivot element to the left. Now, you have divided the big problem of sorting the list into two smaller subproblems: sorting the right and the left partition of the list. What you do now is to repeat this procedure recursively until you obtain a list with zero elements. This list is already sorted, so the recursion terminates.
The following Figure shows the Quicksort algorithm in action:
Figure: The Quicksort algorithm selects a pivot element, splits up the list into (i) an unsorted sublist with all elements that are smaller or equal than the pivot, and (ii) an unsorted sublist with all elements that are larger than the pivot. Next, the Quicksort algorithm is called recursively on the two unsorted sublists to sort them. As soon as the sublists contain maximally one element, they are sorted by definition – the recursion ends. At every recursion level, the three sublists (left, pivot, right) are concatenated before the resulting list is handed to the higher recursion level.
You create a function q which implements the Quicksort algorithm in a single line of Python code – and thus sorts any argument given as a list of integers.
## The Data
unsorted = [33, 2, 3, 45, 6, 54, 33] ## The One-Liner
q = lambda l: q([x for x in l[1:] if x <= l[0]]) + [l[0]] + q([x for x in l if x > l[0]]) if l else [] ## The Result
print(q(unsorted))
What is the output of this code?
## The Result
print(q(unsorted))
# [2, 3, 6, 33, 33, 45, 54]
Python One Line With Statement
Python One Line Exception Handling
Python One Line Try Except
Python One Line Execute
Python One Line Reverse Shell
Python One Line Read File
Python One Line Return If
Python One Line Regex Match
Python One Line Recursion
Python One Line Regex
Python One Line Read File to List
Python One Line Read Stdin
Python One Line Replace
Python One Line Ternary
Ternary (from Latin ternarius) is an adjective meaning “composed of three items”. (source) So, literally, the ternary operator in Python is composed of three operands.
Syntax: The three operands are written in an intuitive combination ... if ... else ....
<On True> if <Condition> else <On False>
Operand
Description
<On True>
The return expression of the operator in case the condition evaluates to True
<Condition>
The condition that determines whether to return the <On True> or the <On False> branch.
<On False>
The return expression of the operator in case the condition evaluates to False
Operands of the Ternary Operator
Let’s have a look at a minimum example in our interactive code shell:
Exercise: Run the code and input your age. What’s the output? Run the code again and try to change the output!
Problem: Say, you have a dictionary {0: 'Alice', 1: 'Bob'} and you want to create a list of dictionaries with copies of the original dictionary: [{0: 'Alice', 1: 'Bob'}, {0: 'Alice', 1: 'Bob'}, {0: 'Alice', 1: 'Bob'}].
d = {0: 'Alice', 1: 'Bob'} dicts = [{**d} for _ in range(3)]
print(dicts)
# [{0: 'Alice', 1: 'Bob'}, {0: 'Alice', 1: 'Bob'}, {0: 'Alice', 1: 'Bob'}]
You use list comprehension with a “throw-away” loop variable underscore _ to create a list of 3 elements. You can change the value 3 if you need more or fewer elements in your list.
Only the first dictionary in the list contains the new key value pair (2: 'Frank') which proves that the dictionaries don’t point to the same object in memory. This would be the case if you’d use the following method of copying a list with a single dictionary:
To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?
Practice projects is how you sharpen your saw in coding!
Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?
Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.
Short answer: Per default, the zip() function returns a zip object of tuples. To obtain a list of lists as an output, use the list comprehension statement [list(x) for x in zip(l1, l2)] that converts each tuple to a list and stores the converted lists in a new nested list object.
Intermediate Python coders know the zip() function. But if you’re like me, you’ve often cursed the output of the zip function: first of all, it’s a zip object (and not a list), and, second, the individual zipped elements are tuples. But what if you need a list of lists as output? This article will show you the most Pythonic way of doing this.
Problem: Given a number of lists l1, l2, .... How ot zip the i-th elements of those lists together and obtain a list of lists?
Example: Given two lists [1, 2, 3, 4] and ['Alice', 'Bob', 'Ann', 'Liz'] and you want the list of lists [[1, 'Alice'], [2, 'Bob'], [3, 'Ann'], [4, 'Liz']].
This is efficient but not the most concise way of accomplishing this task.
Method 2: List Comprehension
A better way is to use list comprehension which is like a generator expression but it creates a list directly without the need to convert an iterable to a list (as in Method 1).
Coders who don’t like list comprehension and generator expressions (or, who don’t understand these beautiful Python features) often use a simple for loop. In the loop body, you convert each tuple in the zip object to a list and append this list to the nested list zipped.
This method is often used by coders who know neither the zip() method, nor list comprehension, nor generator expressions: loop over all indices and append a new list obtained by grouping the i-th elements to the list.
However, this method is least Pythonic, lengthy, and it works only for equally-sized lists.
Exercise: What happens if the first list has more elements than the second list?
Method 5: Zip() + Map() + List()
A functional way of solving this problem is the map() function that applies a function to each element of an iterable and returns a map object. You can pass the list() constructor to the map() function to convert each tuple in the zip object to a list. You can then convert the map object to a list.
I don’t recommend this method because functional programming may be difficult to understand for many beginner coders. Guido van Rossum, the creator of Python, disliked functional programming as well.
Discussion
The most Pythonic way to create a list of lists by zipping together multiple lists is the list comprehension statement [list(x) for x in zip(l1, l2)]. List comprehension is fast, efficient, concise, and readable. You can also extend it to the general case by adding more lists to the zip function: [list(x) for x in zip(l1, l2, l3, ..., ln)]. The zip() function is also robust against lists of different lengths. In this case, the elements up to the maximal index of the shortest list are zipped.
Where to Go From Here?
Enough theory, let’s get some practice!
To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?
Practice projects is how you sharpen your saw in coding!
Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?
Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.
Do you want to initialize a list with some random numbers? In this article, I’ll show you four different way of accomplishing this—along with a short discussion about “the most Pythonic way”.
Problem: Given an integer n. Create a list of n elements in a certain interval (example interval: [0, 20]).
Then, you create a list of random floats by repeatedly calling random.random() that generates a random float number between 0 and 1 each time it is called.
You call it ten times as defined in the context part for _ in range(10). Note that the underscore serves as a “throw-away” variable as you don’t actually need it to create the list.
Also note that the list comprehension statement evaluates the expression multiple times—and not only once in the beginning. That’s why all the numbers in the list are different.
You can easily extend the creation of floats in a larger interval by multiplying the randomly created float with a constant: [random.random() * 999 for _ in range(10)] would create a list of random floats in the interval [0, 999].
If you struggle with understanding list comprehension, watch my explainer video:
Using list comprehension to generate a list of random numbers is readable, concise, and efficient. Were it not for the fourth method, I’d consider this to be the most Pythonic way to create a list of random floats.
Method 2: List Comprehension to Random Integer List [0, 999]
Just for the sake of completeness, here’s the list comprehension statement that creates a list of random integers in the interval [0, 999]:
# Method 2: List Comprehension Random Int List [0, 999]
import random
randlist = [random.randint(0, 999) for _ in range(10)]
You use the random.randint(0, 999) function to create a random integer value between start value 0 and end value 999, so all created integers are in the interval [0, 999].
This is a very Pythonic and readable way to create a list of random integers. You can stop reading right away and use it in your own code.
Method 3: For Loop Random Int List [0, 99]
An alternative that’s often used by non-Python coders is to use a simple for loop that does the same thing as list comprehension (but demanding more space):
# Method 3: For Loop Random Int List [0, 99]
import random
randlist = []
for _ in range(10): randlist.append(random.randint(0, 99))
Again, you use the throw-away underscore variable as the random number is not a function of a loop variable. Each two calls to the random.randint() function are independent.
I’d consider this the least Pythonic way to solve this problem.
Method 4: random.sample()
Finally, we arrive at the most Pythonic way to solve this problem: stand on the shoulders of giants and use existing built-in functionality. The random.sample() method takes a “universe” from which the random numbers are drawn and a list size n—and draws n random numbers from your universe.
# Method 4: random.sample()
import random
# Generate 10 random numbers between 0 and 20 (included)
randlist = random.sample(range(20), 10)
You use the universe range(20) of the first 20 integer numbers 0, …, 19 and draw 10 random elements from the universe. Note that per default, no duplicates are allowed. If the universe is small than the list size n, an error is thrown:
ValueError: Sample larger than population or is negative
Discussion
In this tutorial, you’ve learned four methods to solve the problem of creating a list of random numbers. Objectively, the most Pythonic way to accomplish this is the fourth method: use the random.sample() function as it’s implemented to do exactly this.
But subjectively, I’d use the first or second method based on list comprehension to create a list of random floats or integers.
Why? Because I’m lazy and knowing the random.random() and random.randint() functions is already enough to solve the problem effectively. In practice, I don’t want to waste too much energy trying to remember code functions that do neither improve readability, nor efficiency of my code.
Where to Go From Here?
Enough theory, let’s get some practice!
To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?
Practice projects is how you sharpen your saw in coding!
Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?
Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.
To create a list of n placeholder elements, multiply the list of a single placeholder element with n. For example, use [None] * 5 to create a list [None, None, None, None, None] with five elements None. You can then overwrite some elements with index assignments. In the example, lst[2] = 42 would result in the changed list [None, None, 42, None, None].
Let’s play with an interactive code shell before you’ll dive into the detailed solution!
Exercise: Initialize the list with n=20 placeholder elements -1 and run the code.
Next, you’ll learn about the more formal problem and dive into the step-by-step solution.
Problem: Given an integer n. How to initialize a list with n placeholder elements?
n = 5
lst = [None] * n
print(lst)
# [None, None, None, None, None]
You can modify the element n as you like. In subsequent operations, you can overwrite all placeholder None list elements using simple index assignment operations:
In the following visualization, you can see how each element now refers to an independent list object in memory:
Exercise: Run the visualization and convince yourself that only one element is modified! Why is this the case?
Where to Go From Here?
Enough theory, let’s get some practice!
To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?
Practice projects is how you sharpen your saw in coding!
Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?
Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.
