Ah, Mario Party – a series full of bright colours, charming characters and absolute, rage-inducing gameplay that can make even the strongest of friendships end in tatters.

Lots has been said about the series’ dice rolls in the past, with some players believing that you must have some control over the rolls you make, others thinking it’s probably random, and some going as far as to suggest it’s likely rigged. When you consider the importance of each roll – higher numbers tend to offer better opportunities for board progression – it’s quite surprising that we still know so little about how it all actually works.

That is, until now. The folks over at DidYouKnowGaming? have explored each and every Mario Party title to determine once and for all how the dice roll is calculated. In the video below, the team presents their results after testing the original game on N64 right through to Super Mario Party on Switch, looking ultra-closely at gameplay footage frame-by-frame and consulting speedrunning experts for their advice and thoughts on the matter.

As you can see, it appears that each and every game in the series, no matter how the dice rolls are presented on screen, does not allow the player to influence the dice roll in any way whatsoever. In some cases, the roll is already pre-determined before you even hit the thing, while in others you’re simply receiving a random number, no matter how well you try and time your hit.

It was perhaps to be expected, but next time you have a Mario Party dice rolling around above your character’s head, finding yourself trying to time a perfect strike to get a lovely ’10’, don’t waste your time.

This tutorial shows you how to use Python’s built-in eval() function.

Why Using It? The main application of eval() is to take user input at runtime and run it as a Python expression. This way, you can create a calculator or allow users to perform custom computations on a computing cluster. However, this use also poses the biggest security risk: the user can run byzantine (=harmful) code on your server environment!

How does it work? TLDR;

Python eval(s) parses the string argument s into a Python expression, runs it, and returns the result of the expression. This poses a security risk because a user can use it to run code on your computer. For example, if you allow eval(input()), a user could type os.system('rm -R *') to delete all files in your home directory.

Usage Examples

Learn by example! Here are some examples of how to use the eval() built-in function:

>>> eval('2+2')

4

>>> eval('[1, 2, 3]*3')

[1, 2, 3, 1, 2, 3, 1, 2, 3]

>>> eval('[x for x in range(10)]')

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> eval('"Alice".replace("e", "")') 'Alic'

You can run any Python code that has a return value within the eval() code. You can even create your own function and run it within eval():

>>> def f(): return 42 >>> eval('f()')

42

This gives you great flexibility in how you use the function to run any string expression you may encounter in Python and it allows you to create Python code programmatically and evaluate it at runtime.

Syntax eval()

You can use the eval() method with three different argument lists.

Syntax: 

eval(string)

eval(string, globals)

eval(string, globals, locals) 

Arguments	string	A string to be evaluated.
	globals	Optional, default None. A dictionary in which you can define variables that should be globally accessible by the executed object (local namespace).
	locals	Optional, default None. A dictionary in which you can define variables that should be locally accessible by the executed object (global namespace).
Return Value	object	Returns the result of parsing the string argument and running it as a Python expression.

Python eval() Return Value

The return value of eval() is a Python object that is the result of parsing the string argument and running it as a Python expression. The code can have side effects which means that it may change the state of your program or even your computer!

---

But before we move on, I’m excited to present you my brand-new Python book Python One-Liners (Amazon Link).

If you like one-liners, you’ll LOVE the book. It’ll teach you everything there is to know about a single line of Python code. But it’s also an introduction to computer science, data science, machine learning, and algorithms. The universe in a single line of Python!

The book is released in 2020 with the world-class programming book publisher NoStarch Press (San Francisco).

Link: https://nostarch.com/pythononeliners

[Danger Zone] Python eval(input()) User Input

You can use the eval() function to run code that is typed in dynamically by the user:

def dangerous_function(): # Do nasty stuff like removing files # or creating trojan horses print('You were hacked!') return 42 eval(input())

This is how the user may interact with your code at runtime:

dangerous_function()

You were hacked! 42

You see that the dangerous_function() was executed which could contain all kinds of dangerous code. If you run this on your server, the user may attempt to remove all files on your server! For example, the user may use the command os.system('rm -rf *') to remove all files and folders.

Interactive Jupyter Notebook eval()

Exercise: Run the following interactive code and try to run the dangerous function in the interactive Jupyter notebook!

---

Python exec() vs eval()

Python’s exec() function takes a Python program, as a string or executable object, and runs it. The eval() function evaluates an expression and returns the result of this expression. There are two main differences:

• exec() can execute all Python source code, whereas eval() can only evaluate expressions.
• exec() always returns None, whereas eval() returns the result of the evaluated expression.
• exec() can import modules, whereas eval() cannot.

exec('x=2;y=2;z=x*y;print(z)')

# 4 print(eval('2*2'))

# 4

Python eval() import

Can you import a Python library within the eval() function? No, you can’t! The import statement is a statement, not an expression. But eval() can only execute expressions. A simple workaround is to create a function with side effects that imports the module within the function body:

def f(): import random return random.randint(0, 9) print(eval('f()'))

# 4

Per default, the eval() function has access to all names in the dir() namespace, so you can also import the library globally and use it within the eval() function:

import random

print(eval('random.randint(0, 9)'))

How to Restrict the Use of Built-in Functions Within eval()

If you don’t want to allow users to access built-in functions, you can restrict this by providing the globals argument as follows:

eval(expression, {'__builtins__': None})

For example:

>>> eval('sum([1, 2, 3])')

6

>>> eval('sum([1, 2, 3])', {'__builtins__': None})

Traceback (most recent call last): File "<pyshell#13>", line 1, in <module> eval('sum([1, 2, 3])', {'__builtins__': None}) File "<string>", line 1, in <module>

TypeError: 'NoneType' object is not subscriptable

After restricting the built-in functions in the second call, Python raises an error NoneType object is not subscriptable. This reduces the security risks of your application.

Summary

Python eval(s) parses the string argument s into a Python expression, runs it, and returns the result of the expression.

>>> eval('2+2')

4

This poses a security risk because a user can use it to run code on your computer. For example, if you allow eval(input()), a user could type import os; os.system('rm -R *') to delete all files in your home directory.

---

I hope you enjoyed the article! To improve your Python education, you may want to join the popular free Finxter Email Academy:

Do you want to boost your Python skills in a fun and easy-to-consume way? Consider the following resources and become a master coder!

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.

Join my free webinar “How to Build Your High-Income Skill Python” and watch how I grew my coding business online and how you can, too—from the comfort of your own home.

Join the free webinar now!

The post Python eval() first appeared on Finxter.

The new AirPods Max are turning heads with a high price tag and excellent audio quality. But is what you get worth the $549?

AirPods Max design

That case…

Smart capabilities and battery life

AirPods Max connectivity

Block out external noise — and letting it in

ANC

Transparency mode

AirPods Max Audio fidelity

Going the wired route

Are AirPods Max worth the splurge?

Rating: 4 out of 5

— assuming you’re embedded deeply in the Apple ecosystem. Otherwise, maybe look at some of the other options we’ve mentioned above.

Where to buy AirPods Max

Christmas is a time of cheer, of merriment, and of brotherly love, right? Well, that includes love between consoles. We might be a Nintendo website, but we can enjoy good work when we see it, and these gorgeous Christmas cards come courtesy of the PlayStation blog, where they’re featured a selection from a few of the best studios in the biz.

Quite a few of them are also on Switch, so we’re featuring our personal faves for you to enjoy, too, with the likes of Cuphead, Grindstone, and Wargroove making an appearance.

Awww, isn’t that lovely. Which studio would you love to get a Christmas card from? Let us know in the comments!

Starting today, Fortnite has issued a bunch of “Wakanda Forever Challenges” to all players, and the prize is the badass Wakanda Forever emote – a tribute to the actor who played the Wakandan King, Chadwick Boseman, who died earlier this year.

Players who complete the challenges before January 12th will receive the emote for free. Fortnite Insider has the scoop on what the challenges will involve:

– Play Matches (10)
– Outlast Opponents (500)
– Play Duo or Squad Matches (5)

The emote might not be the only Black Panther-related goodie that Fortnite players receive. In a cryptic emoji tweet, the Fortnite Twitter account hinted at what could be the addition of some new characters, including a black cat:

Which characters do you think these emojis correspond to? Let us know in the comments below!

Exponents are superscript numbers that describe how many times you want to multiply a number by itself. Calculating a value raised to the power of another value is a fundamental operation in applied mathematics such as finance, machine learning, statistics, and data science. This tutorial shows you how to do it in Python!

Definition

For pow(x, y), the pow() function returns the value of x raised to the power y. It performs the same function as the power operator ** , i.e. x**y, but differs in that it comes with an optional argument called mod.

Examples without mod

>>> pow(5, 2)

25

>>> pow(-3, 3)

-27

>>> pow(2, -2)

0.25

Parameters and Syntax

pow(base, exp, mod=None)

The pow() function includes two compulsory arguments, base and exp, and one optional argument, mod, whose default value is None. All arguments must be of numeric data type.

Parameter	Description
exp	A number that represents the base of the function, whose power is to be calculated.
base	A number that represents the exponent of the function, to which the base will be raised.
mod	A number with which the modulo will be computed.

Return value: The output of base raised to the power exp and will be a numeric data type, int, float or complex, depending on what you input.

Using the pow() function without the mod argument

When using the pow(x, y) function without the optional mod argument, it will perform the same operation as the power operator x**y, raising x to the power y.

Comparison of the two methods

>>> pow(6, 4)

1296

>>> 6 ** 4

1296

The pow() function accepts all numeric data types, i.e. int, float and even complex numbers. In general the return value will depend on what data types you input. The example above shows that both arguments are type int, therefore, an int type is returned. However, if you were to instead use a float number as one or both of the arguments, the function will automatically return a float type.

Examples using float types

>>> pow(3.0, 4)

81.0

>>> pow(4.5, 2.3)

31.7971929089206

As with float type inputs leading to float outputs, the same reasoning applies to complex numbers. If you enter a complex number as one or both of the arguments, a complex number will be returned.

Example using complex numbers

>>> pow(4+2j, 3)

(16+88j)

The return type will also depend on whether your arguments are non-negative or negative, as is shown in the below table.

base	exp	Return type
Non-negative	Non-negative	int
Non-negative	Negative	foat
Negative	Non-negative	int
Negative	Negative	float

Examples of return values with different input types

>>> pow(7, 2)

49

>>> pow(4, -5)

0.0009765625

>>> pow(-6, 3)

-216

>>> pow(-9, -4)

0.00015241579027587258

Using the pow() function with a mod argument

What sets the pow() function apart from the ** operator is its third optional argument, mod, which gives you the ability to do a modulo operation within the function. 

The process of operations when using the mod argument is as follows:

If we have pow(x, y, z), the function first performs the task of raising x to the power y and then that result is used to perform the modulo task with respect to z. It would be the equivalent of (x**y) % z .

Examples using mod

>>> pow(14, 7, 5)

4

>>> pow(-8, 3, 5)

3

>>> pow(2, 4, -3)

-2

The general rule for using the mod argument is that all values must be of integer type, the exp argument must be non-negative and the mod argument must be non-zero. However, Python 3.8 now comes with the functionality of computing modular inverses. In this case, the exp argument may be negative, on the condition that base is relatively prime to mod, i.e, the only common integer divisor of base and mod is 1.

So, when using the pow() function with negative exp, the function will perform as follows:

pow(inv_base, -exp, mod)

In other words, the function will compute the modular inverse of base and mod first and then that result will be used in the pow() function as base to be computed as normal with the  exp argument being converted to its non-negative counterpart.

Example of modular inverse

>>> pow(87, -1, 25)

23

In this example, the straight modular inverse is calculated because inv_base will be raised to the power 1.

Example of modular inverse when exp is not -1

>>> pow(34, -5, 19)

10

# The modular inverse of 34 mod 19 is 14, therefore, we end up with the function pow(14, 5, 19)

>>> pow(14, 5, 19)

10

Calculating the nth root of a number using pow()

Unfortunately, Python does not have a built-in function to calculate the nth root of a number. The math module only has a function to calculate square roots, math.sqrt(), therefore, we have to get creative in order to calculate nth roots.

We know that nx is equivalent to x1n. Thus, using this knowledge we can calculate the nth root in Python by using either pow(x, (1/n)) or x**(1/n). 

Examples of calculating nth roots

>>> pow(625, (1/4))

4.0

>>> 729**(1/3)

8.999999999999998

Note that performing an nth root calculation will always return a float when not using complex numbers. Since Python’s float type works on approximations, it will often return the approximation rather than the exact number, even when an exact answer is possible. This is demonstrated in the second example above.

When calculating the nth root of a negative number, the return value will be a complex number whether an integer number is possible or not.

Examples of calculating nth roots of negative bases

>>> pow(-16, (1/2))

(2.4492935982947064e-16+4j)

>>> pow(-27, (1/3))

(1.5000000000000004+2.598076211353316j)

We would expect the second example above, the cubed root of -27, to result in -3, but instead we get a complex number. This is because Python returns the principal root rather than the real root. For an explanation of these different types of roots, you can look up the Fundamental theorem of algebra.

math.pow() Function

In the math module of Python, there is a similar function called math.pow(). To use this we first need to import the math function, thus, the built-in pow() function will be very slightly faster. The main differences between the two functions is that math.pow() does not allow for the optional mod argument and it will always return a float. So if you want to ensure that you get a float result, math.pow() is a better option.

Example of using math.pow()

>>> import math

>>> math.pow(9, 5)

59049.0

When to use the pow() function vs when to use the ** operator

When deciding between using the pow() function or the ** operator, the most important factor to consider would be the efficiency of your code. We can use the timeit.timeit() function from the timeit module to find out how fast Python executes our code.

Examples of using timeit with simple numbers

>>> import timeit

>>> timeit.timeit('pow(5, 2)')

0.25059129999863217

>>> timeit.timeit('5**2')

0.008814800001346157

When performing a simple power computation, the ** operator appears to be much faster.

Examples using modulo

>>> timeit.timeit('pow(52, 2, 4)')

0.7482693000001746

>>> timeit.timeit('52**2 % 4')

0.012026999998852261

The same is true even when we include a modulo operation.

However, when we want to perform power operations with very large numbers, the pow() function is much quicker, showing that the power of the pow() function lies in executing longer computations.

Examples using large numbers

>>> timeit.timeit('pow(5234, 2341, 124)')

0.9020593000004737

>>> timeit.timeit('5234**2341 % 124')

152.56075580000106

Here the pow() function is extremely fast compared to the ** operator. Therefore, we can generalize these findings by saying that when you want to perform short, simple calculations, the ** operator is the better option, however, if your operations involve very large numbers, the pow() function is much more efficient.

The post A Guide to Python’s pow() Function first appeared on Finxter.