VPython MapReduceFilter - Revision history

Sabrinayang: /* Lambda Expressions */

2026-04-27T01:09:34Z

Lambda Expressions

← Older revision		Revision as of 21:09, 26 April 2026
Line 73:		Line 73:

	'''Lambda vs def — when to use which:'''		'''Lambda vs def — when to use which:'''
	* Use a lambda when the function is short, only needed once, and passed right		* Use a lambda when the function is short, only needed once, and passed right into another function
	into another function
	* Use <code>def</code> when the function is longer or used in multiple places		* Use <code>def</code> when the function is longer or used in multiple places

	'''GlowScript note:''' Lambdas do not work in GlowScript ~~at all~~. Always use		'''GlowScript note:''' Lambdas do not work in GlowScript. Always use <code>def</code> when writing code for Trinket.
	<code>def</code> when writing code for Trinket.

	----		----

Sabrinayang: /* Lambda Expressions */

2026-04-27T01:08:25Z

Lambda Expressions

← Older revision		Revision as of 21:08, 26 April 2026
Line 48:		Line 48:
	lambda <parameters>: <expression>		lambda <parameters>: <expression>

	The function only exists at the point where it is used. These two do the ~~exact~~ same ~~thing~~:		The function only exists at the point where it is used. These two functions achieve the same output:

	# Regular way		# Regular way
	def square(x):		def square(x):

Sabrinayang: /* Background */

2026-04-27T01:07:56Z

Background

← Older revision		Revision as of 21:07, 26 April 2026
Line 35:		Line 35:

	A few reasons why writing code this way is efficient:		A few reasons why writing code this way is efficient:
	* '''It is easy to read:''' You can immediately tell what the program		* '''It is easy to read:''' You can immediately tell what the program is trying to achieve. There is no complex decoding required.
	~~is doing. It~~ is ~~obvious that the program is saying~~ to ~~"apply this formula to every mass~~."		* '''Fewer bugs:''' Every time you write a for-loop you have to manually keep track of index variables, which is easy to make mistakes. These functions automatically handle the indices, so there is less room for errors.
	There is no complex decoding required.		* '''You can chain them:''' The output of <code>map()</code> goes straight into <code>filter()</code> or <code>reduce()</code> without extra steps, which keeps the amount variables needed to a minimum.
	* '''Fewer bugs:''' Every time you write a for-loop you have to manually keep track of index
	variables, which is easy to make mistakes. These functions
	handle the indices, so there is less room for errors.
	* '''You can chain them:''' The output of <code>map()</code> goes straight into
	<code>filter()</code> or <code>reduce()</code> without extra steps, which keeps
	the variables ~~clean and short~~.

	----		----

Sabrinayang: /* Introduction */

2026-04-27T01:02:18Z

Introduction

← Older revision		Revision as of 21:02, 26 April 2026
Line 11:		Line 11:
	allowing you to focus on the point of the code itself.		allowing you to focus on the point of the code itself.

	Each function does ~~something~~ different:		Each function does has a different job:
	* <code>map()</code>: applies a function to every element in a list		* <code>map()</code>: applies a function to every element in a list
	* <code>filter()</code>: iterates through a list and only keeps the elements that meet a certain condition		* <code>filter()</code>: iterates through a list and only keeps the elements that meet a certain condition

Sabrinayang: /* Interactive Simulation */

2026-04-27T01:01:30Z

Interactive Simulation

← Older revision		Revision as of 21:01, 26 April 2026
Line 327:		Line 327:
	----		----

	== '''~~Interactive~~ Simulation''' ==		== '''Simulation''' ==

	The following GlowScript simulation shows all three functions working together		The following GlowScript simulation shows all three functions working together
	in a real physics example:		in a real-world physics example:
	[https://trinket.io/glowscript/9e53d57b352f map(), filter(), and reduce() in VPython Physics — Trinket]		[https://trinket.io/glowscript/9e53d57b352f map(), filter(), and reduce() in VPython Physics — Trinket]

	The simulation ~~puts~~ five spheres in a row, each with a different mass between		The simulation has five spheres in a row, each with a different mass between
	1 and 8 kg and a different speed between 1.5 and 6 m/s. The size of each sphere		1 and 8 kg and a different speed between 1.5 and 6 m/s. The size of each sphere
	matches its mass ~~so you can see the difference right away~~.		matches its mass.

	* '''map()''' goes through every mass and calculates the weight using F = mg.		* '''map()''' goes through every mass and calculates the weight using F = mg.

Sabrinayang: /* Combining map(), filter(), and reduce() */

2026-04-27T01:00:20Z

Combining map(), filter(), and reduce()

← Older revision		Revision as of 21:00, 26 April 2026
Line 288:		Line 288:
	== '''Combining map(), filter(), and reduce()''' ==		== '''Combining map(), filter(), and reduce()''' ==

	It is ~~also~~ efficient that functions ~~can be~~ chained together.		It is extremely efficient that these functions work well when chained together.

	'''Example: kinetic energy'''		'''Example: kinetic energy'''
Line 294:		Line 294:
	from functools import reduce		from functools import reduce

	# Step 1: filter() — drop all values below 3.0 m/s		# Step 1: filter(): drop all values below 3.0 m/s
	moving = list(filter(lambda p: p.speed > 3.0, particles))		moving = list(filter(lambda p: p.speed > 3.0, particles))

	# Step 2: map() — calculate KE for each remaining particle		# Step 2: map(): calculate the kinetic energy for each remaining particle
	ke_list = list(map(lambda p: 0.5 * p.mass * p.speed**2, moving))		ke_list = list(map(lambda p: 0.5 * p.mass * p.speed**2, moving))

	# Step 3: reduce() — add them all up		# Step 3: reduce(): add them all up
	total_ke = reduce(lambda acc, ke: acc + ke, ke_list, 0.0)		total_ke = reduce(lambda acc, ke: acc + ke, ke_list, 0.0)
	print("Total KE of fast particles:", round(total_ke, 2), "J")		print("Total KE of fast particles:", round(total_ke, 2), "J")

	This filter → map → reduce pattern shows up ~~all the time in~~ physics simulations.		This filter → map → reduce pattern shows up very commonly physics simulations.
	Pick a group of objects, apply a formula to each one, then get one final number		Pick a group of objects, apply a formula to each one, then get one final number
	out of it. ~~That is basically what~~ these ~~three~~ functions ~~are built for~~.		out of it. Below are some examples of these functions chained together.

	----		----

Sabrinayang: /* Reduce() */

2026-04-27T00:58:30Z

Reduce()

← Older revision		Revision as of 20:58, 26 April 2026
Line 227:		Line 227:
	=== How it works ===		=== How it works ===

	<code>reduce(function, list, starting value)</code> takes a ~~whole~~ list and returns ~~one~~ single value~~. Unlike <code>map()</code>~~		<code>reduce(function, list, starting value)</code> takes a list and returns a single value.
	~~and <code>filter()</code>, you do not get a list back — you get one number~~.

	The function you pass in needs to take two inputs:		The function you pass in needs to take two inputs:

Sabrinayang: /* Background */

2026-04-27T00:56:45Z

Background

← Older revision		Revision as of 20:56, 26 April 2026
Line 29:		Line 29:
	== '''Background''' ==		== '''Background''' ==

	In Python, functions are objects ~~just like numbers or strings. That means~~ you can:		In Python, functions are objects, meaning you can:
	* Store a function in a variable		* Store a function in a variable
	* Pass a function into another function as an argument		* Pass a function into another function as an argument
	* Get a function back as a return value		* Get a function back as a return value

	~~This is what makes <code>map()</code>, <code>filter()</code>, and <code>reduce()</code>~~		A few reasons why writing code this way is efficient:
	~~work. When you write <code>map(calc_weight, masses)</code>, you are passing the~~		* '''It is easy to read:''' You can immediately tell what the program
	~~function <code>calc_weight</code> itself into <code>map()</code>. Then~~		is doing. It is obvious that the program is saying to "apply this formula to every mass."
	~~<code>map()</code> runs it on every item in the list so you don't have to.~~		There is no complex decoding required.

	~~There are a~~ few reasons why writing code this way is efficient:
	* '''It is easy to read:''' You can ~~look at the code and~~ immediately tell what it
	is doing ~~— like if you see~~ "apply this formula to every mass" ~~you just get it,~~
	no decoding required
	* '''Fewer bugs:''' Every time you write a for-loop you have to manually keep track of index		* '''Fewer bugs:''' Every time you write a for-loop you have to manually keep track of index
	variables, which is easy to make mistakes on. These functions		variables, which is easy to make mistakes. These functions
	handle the indices, so there is less room for errors.		handle the indices, so there is less room for errors.
	* '''You can chain them:''' The output of <code>map()</code> ~~can go~~ straight into		* '''You can chain them:''' The output of <code>map()</code> goes straight into
	<code>filter()</code> or <code>reduce()</code> without extra steps, which keeps		<code>filter()</code> or <code>reduce()</code> without extra steps, which keeps
	the variables clean and short.		the variables clean and short.

Sabrinayang: /* Introduction */

2026-04-27T00:51:57Z

Introduction

← Older revision		Revision as of 20:51, 26 April 2026
Line 5:		Line 5:
	In Python, <code>map()</code>, <code>filter()</code>, and <code>reduce()</code> are		In Python, <code>map()</code>, <code>filter()</code>, and <code>reduce()</code> are
	known as higher-order functions. Higher-order functions are functions that		known as higher-order functions. Higher-order functions are functions that
	take other functions as arguments. ~~A typical~~ VPython ~~simulation can~~ have hundreds of		take other functions as arguments. VPython simulations usually have hundreds of
	objects that all follow the same physics equations, and writing for-loops to do the same		objects that all follow the same physics equations, and writing for-loops to do the same
	calculation over and over can be inefficient. <code>map()</code>,		calculation over and over can be inefficient. <code>map()</code>,
Line 16:		Line 16:
	* <code>reduce()</code>: takes a whole list and turns it into one single value		* <code>reduce()</code>: takes a whole list and turns it into one single value

	'''Python 3 note:''' <code>map()</code> and <code>filter()</code> do not ~~actually work~~ until you ask for the results. Wrap them in <code>list()</code> to get		'''Python 3 note:''' <code>map()</code> and <code>filter()</code> do not execute until you ask for the results. Wrap them in <code>list()</code> to get
	~~a list back~~. <code>reduce()</code> has to be imported before you can use it:		the results. <code>reduce()</code> has to be imported before you can use it:
	from functools import reduce		from functools import reduce

Sabrinayang at 00:24, 27 April 2026

2026-04-27T00:24:34Z

Show changes