http://www.physicsbook.gatech.edu/api.php?action=feedcontributions&feedformat=atom&user=Yzh79850 2026-04-24T15:58:26Z User contributions MediaWiki 1.42.7 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47800 2025-12-02T23:26:22Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible, unlike lists from other languages, such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order in which the elements were added<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc.)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resize when needed. When an object is stored in a list, it is stored as a reference, so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending on whether the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|5 disco balls rapidly changing colors (click to see the gif if you can't)]]<br /> <br /> ===Difficult===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First, we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuously update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> [[File:BallSpinning.gif|thumb|various cyan balls spinning counter clockwise in a circle (click to see the gif if you can't)]]<br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> <br /> ==Connectedness==<br /> Lists are incredibly important, and they interact naturally with other data structures in VPython. Combinations like lists, vector math, 3D rendering, loops, and randomness make VPython an incredibly versatile and ideal teaching model for students. Not only will they be able to review physics concepts, but students will also begin to think computationally and develop more programming skills. In the state of the world, even understanding a bit of programming is vital.<br /> <br /> ==History==<br /> The word ''list'' comes from the Middle Ages, where it was used to refer to the bordered grounds of a jousting field. This early meaning, being derived from Germanic roots of the word ''band'' or ''border'', was meant to emphasize order and structure. Over the following centuries, the term began to expand. Medieval administrations kept names on &quot;rolls&quot;, merchants in the 1600s &quot;listed&quot; goods for sale, and political revolutions formalized &quot;ordered&quot; records through roll calls. By the 19th century, mail-order catalogs and growing commercial record-keeping practices helped establish the list as a standard tool for organizing information.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Later, the computational list began to emerge in the 20th century due to the introduction of data-processing machines that could arrange information sequentially on punch cards. This idea reached a major milestone in 1958 with the creation of LISP, a programming language built entirely around list processing. As computer science progressed, the term became essential to data structures for storing ordered collections of values. VPython integrates lists perfectly within its own language, creating something for you and me to learn and experiment with.<br /> <br /> <br /> ==See Also==<br /> [http://www.physicsbook.gatech.edu/VPython_Animation VPython Animation]<br /> [http://www.physicsbook.gatech.edu/VPython_Loops VPython Loops]<br /> <br /> ===External Links===<br /> https://medium.com/circa-navigate/the-long-listed-history-of-the-list-4c4da36a4ed5<br /> https://www.glowscript.org/#/user/yzh79850/folder/MyPrograms/program/WikiTest<br /> <br /> ==References==<br /> https://www.youtube.com/watch?v=4RVZ9UvLoB0<br /> https://www.youtube.com/watch?v=upMOE4XhpJk<br /> https://www.geeksforgeeks.org/python/python-lists/<br /> https://medium.com/circa-navigate/the-long-listed-history-of-the-list-4c4da36a4ed5<br /> https://www.w3schools.com/python/python_lists.asp</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47792 2025-12-02T23:18:41Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|5 disco balls rapidly changing colors (click to see the gif if you can't)]]<br /> <br /> ===Difficult===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuosly update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> [[File:BallSpinning.gif|thumb|various cyan balls spinning counter clockwise in a circle (click to see the gif if you can't)]]<br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> <br /> ==Connectedness==<br /> Lists are incredibly important, and they interact naturally with other data structures in VPython. Combinations like lists, vector math, 3D rendering, loops, and randomness makes VPython an incredibly versatile and ideal teaching model for students. Not only will they be able to review physics concepts, students begin to think computationally and develop more programming skills. In the state of the world, even understanding a bit of programming is vital.<br /> <br /> ==History==<br /> The word ''list'' comes from the Middle Ages where it was used to refer to bordered grounds of a jousting field. This early meaning, being derived from Germanic roots of the word ''band'' or ''border'', was meant to emphasize order and structure. Over the following centuries, the term began to expand. Medieval administrations kept names on &quot;rolls&quot;, merchants in the 1600s &quot;listed&quot; goods for sale, and political revolutions formalized &quot;ordered&quot; records through roll calls. By the 19th century, mail-order catalogs and growing commercial record-keeping practices helped establish the list as a standard tool for organizing information.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Later, the computational list began to emerge in the 20th century due to the introduction of data-processing machines that could arrange information sequentially on punch cards. This idea reached a major milestond in 1958 with the creation of LISP, a programming language built entirely around list processing. As computer science progressed, the term became essential to data structures for storing ordered collections of values. VPython integrates lists perfectly within its own language, creating something for you and me to learn and experiment with.<br /> <br /> <br /> ==See Also==<br /> [http://www.physicsbook.gatech.edu/VPython_Animation VPython Animation]<br /> [http://www.physicsbook.gatech.edu/VPython_Loops VPython Loops]<br /> <br /> ===External Links===<br /> https://medium.com/circa-navigate/the-long-listed-history-of-the-list-4c4da36a4ed5<br /> https://www.glowscript.org/#/user/yzh79850/folder/MyPrograms/program/WikiTest<br /> <br /> ==References==<br /> https://www.youtube.com/watch?v=4RVZ9UvLoB0<br /> https://www.youtube.com/watch?v=upMOE4XhpJk<br /> https://www.geeksforgeeks.org/python/python-lists/<br /> https://medium.com/circa-navigate/the-long-listed-history-of-the-list-4c4da36a4ed5<br /> https://www.w3schools.com/python/python_lists.asp</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47789 2025-12-02T23:17:50Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|5 disco balls rapidly changing colors]]<br /> <br /> ===Difficult===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuosly update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> [[File:BallSpinning.gif|thumb|various cyan balls spinning counter clockwise in a circle]]<br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> <br /> ==Connectedness==<br /> Lists are incredibly important, and they interact naturally with other data structures in VPython. Combinations like lists, vector math, 3D rendering, loops, and randomness makes VPython an incredibly versatile and ideal teaching model for students. Not only will they be able to review physics concepts, students begin to think computationally and develop more programming skills. In the state of the world, even understanding a bit of programming is vital.<br /> <br /> ==History==<br /> The word ''list'' comes from the Middle Ages where it was used to refer to bordered grounds of a jousting field. This early meaning, being derived from Germanic roots of the word ''band'' or ''border'', was meant to emphasize order and structure. Over the following centuries, the term began to expand. Medieval administrations kept names on &quot;rolls&quot;, merchants in the 1600s &quot;listed&quot; goods for sale, and political revolutions formalized &quot;ordered&quot; records through roll calls. By the 19th century, mail-order catalogs and growing commercial record-keeping practices helped establish the list as a standard tool for organizing information.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Later, the computational list began to emerge in the 20th century due to the introduction of data-processing machines that could arrange information sequentially on punch cards. This idea reached a major milestond in 1958 with the creation of LISP, a programming language built entirely around list processing. As computer science progressed, the term became essential to data structures for storing ordered collections of values. VPython integrates lists perfectly within its own language, creating something for you and me to learn and experiment with.<br /> <br /> <br /> ==See Also==<br /> [http://www.physicsbook.gatech.edu/VPython_Animation VPython Animation]<br /> [http://www.physicsbook.gatech.edu/VPython_Loops VPython Loops]<br /> <br /> ===External Links===<br /> https://medium.com/circa-navigate/the-long-listed-history-of-the-list-4c4da36a4ed5<br /> https://www.glowscript.org/#/user/yzh79850/folder/MyPrograms/program/WikiTest<br /> <br /> ==References==<br /> https://www.youtube.com/watch?v=4RVZ9UvLoB0<br /> https://www.youtube.com/watch?v=upMOE4XhpJk<br /> https://www.geeksforgeeks.org/python/python-lists/<br /> https://medium.com/circa-navigate/the-long-listed-history-of-the-list-4c4da36a4ed5<br /> https://www.w3schools.com/python/python_lists.asp</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47786 2025-12-02T23:15:38Z

<p>Yzh79850: /* See Also */</p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|5 disco balls rapidly changing colors]]<br /> <br /> ===Difficult===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuosly update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> [[File:BallSpinning.gif|thumb|various cyan balls spinning counter clockwise in a circle]]<br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> <br /> ==Connectedness==<br /> Lists are incredibly important, and they interact naturally with other data structures in VPython. Combinations like lists, vector math, 3D rendering, loops, and randomness makes VPython an incredibly versatile and ideal teaching model for students. Not only will they be able to review physics concepts, students begin to think computationally and develop more programming skills. In the state of the world, even understanding a bit of programming is vital.<br /> <br /> ==History==<br /> The word ''list'' comes from the Middle Ages where it was used to refer to bordered grounds of a jousting field. This early meaning, being derived from Germanic roots of the word ''band'' or ''border'', was meant to emphasize order and structure. Over the following centuries, the term began to expand. Medieval administrations kept names on &quot;rolls&quot;, merchants in the 1600s &quot;listed&quot; goods for sale, and political revolutions formalized &quot;ordered&quot; records through roll calls. By the 19th century, mail-order catalogs and growing commercial record-keeping practices helped establish the list as a standard tool for organizing information.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Later, the computational list began to emerge in the 20th century due to the introduction of data-processing machines that could arrange information sequentially on punch cards. This idea reached a major milestond in 1958 with the creation of LISP, a programming language built entirely around list processing. As computer science progressed, the term became essential to data structures for storing ordered collections of values. VPython integrates lists perfectly within its own language, creating something for you and me to learn and experiment with.<br /> <br /> <br /> ==See Also==<br /> [http://www.physicsbook.gatech.edu/VPython_Animation VPython Animation]<br /> [http://www.physicsbook.gatech.edu/VPython_Loops VPython Loops]<br /> <br /> ===External Links===<br /> https://medium.com/circa-navigate/the-long-listed-history-of-the-list-4c4da36a4ed5<br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47785 2025-12-02T23:15:11Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|5 disco balls rapidly changing colors]]<br /> <br /> ===Difficult===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuosly update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> [[File:BallSpinning.gif|thumb|various cyan balls spinning counter clockwise in a circle]]<br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> <br /> ==Connectedness==<br /> Lists are incredibly important, and they interact naturally with other data structures in VPython. Combinations like lists, vector math, 3D rendering, loops, and randomness makes VPython an incredibly versatile and ideal teaching model for students. Not only will they be able to review physics concepts, students begin to think computationally and develop more programming skills. In the state of the world, even understanding a bit of programming is vital.<br /> <br /> ==History==<br /> The word ''list'' comes from the Middle Ages where it was used to refer to bordered grounds of a jousting field. This early meaning, being derived from Germanic roots of the word ''band'' or ''border'', was meant to emphasize order and structure. Over the following centuries, the term began to expand. Medieval administrations kept names on &quot;rolls&quot;, merchants in the 1600s &quot;listed&quot; goods for sale, and political revolutions formalized &quot;ordered&quot; records through roll calls. By the 19th century, mail-order catalogs and growing commercial record-keeping practices helped establish the list as a standard tool for organizing information.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Later, the computational list began to emerge in the 20th century due to the introduction of data-processing machines that could arrange information sequentially on punch cards. This idea reached a major milestond in 1958 with the creation of LISP, a programming language built entirely around list processing. As computer science progressed, the term became essential to data structures for storing ordered collections of values. VPython integrates lists perfectly within its own language, creating something for you and me to learn and experiment with.<br /> <br /> <br /> ==See Also==<br /> [http://www.physicsbook.gatech.edu/VPython_Animation VPython Animation]<br /> <br /> ===External Links===<br /> https://medium.com/circa-navigate/the-long-listed-history-of-the-list-4c4da36a4ed5<br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47784 2025-12-02T23:14:47Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|5 disco balls rapidly changing colors]]<br /> <br /> ===Difficult===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuosly update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> [[File:BallSpinning.gif|thumb|various cyan balls spinning counter clockwise in a circle]]<br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> <br /> ==Connectedness==<br /> Lists are incredibly important, and they interact naturally with other data structures in VPython. Combinations like lists, vector math, 3D rendering, loops, and randomness makes VPython an incredibly versatile and ideal teaching model for students. Not only will they be able to review physics concepts, students begin to think computationally and develop more programming skills. In the state of the world, even understanding a bit of programming is vital.<br /> <br /> ==History==<br /> The word ''list'' comes from the Middle Ages where it was used to refer to bordered grounds of a jousting field. This early meaning, being derived from Germanic roots of the word ''band'' or ''border'', was meant to emphasize order and structure. Over the following centuries, the term began to expand. Medieval administrations kept names on &quot;rolls&quot;, merchants in the 1600s &quot;listed&quot; goods for sale, and political revolutions formalized &quot;ordered&quot; records through roll calls. By the 19th century, mail-order catalogs and growing commercial record-keeping practices helped establish the list as a standard tool for organizing information.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Later, the computational list began to emerge in the 20th century due to the introduction of data-processing machines that could arrange information sequentially on punch cards. This idea reached a major milestond in 1958 with the creation of LISP, a programming language built entirely around list processing. As computer science progressed, the term became essential to data structures for storing ordered collections of values. VPython integrates lists perfectly within its own language, creating something for you and me to learn and experiment with.<br /> <br /> <br /> ==See Also==<br /> [http://www.physicsbook.gatech.edu/VPython VPython Animation]<br /> <br /> ===External Links===<br /> https://medium.com/circa-navigate/the-long-listed-history-of-the-list-4c4da36a4ed5<br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47783 2025-12-02T23:13:14Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|5 disco balls rapidly changing colors]]<br /> <br /> ===Difficult===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuosly update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> [[File:BallSpinning.gif|thumb|various cyan balls spinning counter clockwise in a circle]]<br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> <br /> ==Connectedness==<br /> Lists are incredibly important, and they interact naturally with other data structures in VPython. Combinations like lists, vector math, 3D rendering, loops, and randomness makes VPython an incredibly versatile and ideal teaching model for students. Not only will they be able to review physics concepts, students begin to think computationally and develop more programming skills. In the state of the world, even understanding a bit of programming is vital.<br /> <br /> ==History==<br /> The word ''list'' comes from the Middle Ages where it was used to refer to bordered grounds of a jousting field. This early meaning, being derived from Germanic roots of the word ''band'' or ''border'', was meant to emphasize order and structure. Over the following centuries, the term began to expand. Medieval administrations kept names on &quot;rolls&quot;, merchants in the 1600s &quot;listed&quot; goods for sale, and political revolutions formalized &quot;ordered&quot; records through roll calls. By the 19th century, mail-order catalogs and growing commercial record-keeping practices helped establish the list as a standard tool for organizing information.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Later, the computational list began to emerge in the 20th century due to the introduction of data-processing machines that could arrange information sequentially on punch cards. This idea reached a major milestond in 1958 with the creation of LISP, a programming language built entirely around list processing. As computer science progressed, the term became essential to data structures for storing ordered collections of values. VPython integrates lists perfectly within its own language, creating something for you and me to learn and experiment with.<br /> <br /> <br /> ==See Also==<br /> <br /> ===External Links===<br /> https://medium.com/circa-navigate/the-long-listed-history-of-the-list-4c4da36a4ed5<br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47766 2025-12-02T22:49:53Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|5 disco balls rapidly changing colors]]<br /> <br /> ===Difficult===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuosly update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> [[File:BallSpinning.gif|thumb|various cyan balls spinning counter clockwise in a circle]]<br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47761 2025-12-02T22:23:13Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|5 disco balls rapidly changing colors]]<br /> <br /> ===Middling===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuosly update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> [[File:BallSpinning.gif|thumb|various cyan balls spinning counter clockwise in a circle]]<br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47760 2025-12-02T22:21:59Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|Please show up please please]]<br /> <br /> ===Middling===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuosly update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> [[File:BallSpinning.gif|thumb|Bro]]<br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=File:BallSpinning.gif&diff=47759 2025-12-02T22:20:59Z

<p>Yzh79850: </p> <hr /> <div></div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47758 2025-12-02T22:17:22Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco1.png|thumb|Caption for your GIF]]<br /> [[File:Disco2.png|thumb|Caption for your GIF]]<br /> <br /> ===Middling===<br /> For more of a challenge, let's create a circle of balls and make them rotate! First we would need to create a few variables just to define how many balls and how big the circle is. For this example, we use two lists. One for the individual balls, and the other for their corresponding position/angle in the circle. We can see now how important it is that we can access each ball and its position quickly using a list. Finally, we create a while loop to continuosly update the balls' position so that they appear to be rotating in a circle! <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> For a bonus challenge, what would we do to make the balls turn in the opposite direction?<br /> <br /> &lt;pre&gt;<br /> num_balls = 50<br /> radius = 5.0<br /> omega = 0.5<br /> <br /> balls = []<br /> angles = []<br /> <br /> for k in range(num_balls):<br /> theta = 2*3.14 * k / num_balls<br /> pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> b = sphere(pos=pos, radius=0.15, color=color.cyan)<br /> balls.append(b)<br /> angles.append(theta)<br /> <br /> dt = 0.01<br /> while True:<br /> rate(100)<br /> for k in range(num_balls):<br /> angles[k] += omega * dt<br /> theta = angles[k]<br /> balls[k].pos = vector(radius * cos(theta), radius * sin(theta), 0)<br /> &lt;/pre&gt;<br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47755 2025-12-02T22:09:24Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco1.png|thumb|Caption for your GIF]]<br /> [[File:Disco2.png|thumb|Caption for your GIF]]<br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47754 2025-12-02T22:08:50Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco1.png|thumb|Caption for your GIF]]<br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=File:Disco2.png&diff=47752 2025-12-02T22:08:28Z

<p>Yzh79850: balls</p> <hr /> <div>== Summary ==<br /> balls</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=File:Disco1.png&diff=47750 2025-12-02T22:07:57Z

<p>Yzh79850: </p> <hr /> <div></div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47748 2025-12-02T22:05:36Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|Caption for your GIF]]<br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47745 2025-12-02T22:00:34Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> [[File:Disco.gif|thumb|Caption]]<br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=File:Disco.gif&diff=47744 2025-12-02T21:59:02Z

<p>Yzh79850: 5 balls rapidly changing colors</p> <hr /> <div>== Summary ==<br /> 5 balls rapidly changing colors</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47738 2025-12-02T21:48:26Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> Let's say we want to create 5 disco balls and make them change colors repeatedly. We first create a list and set how many balls we want. Afterwards, we add all of the balls into the scene and the list. Finally, we create a loop that changes the color of each ball depending if the variable 't' is even or odd.<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 5<br /> <br /> for i in range(num_balls):<br /> pos = vector(i*2-3, 0, 0)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.white)<br /> <br /> ball_list.append(ball)<br /> <br /> <br /> t = 0<br /> dt = 1<br /> while True:<br /> rate(100)<br /> t += dt<br /> if t % 2 == 0 :<br /> ball_list[0].color = color.blue<br /> ball_list[1].color = color.red<br /> ball_list[2].color = color.green<br /> ball_list[3].color = color.yellow<br /> ball_list[4].color = color.orange<br /> else :<br /> ball_list[0].color = color.red<br /> ball_list[1].color = color.green<br /> ball_list[2].color = color.blue<br /> ball_list[3].color = color.purple<br /> ball_list[4].color = color.yellow<br /> &lt;/pre&gt;<br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47687 2025-12-02T18:47:40Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Computational Model===<br /> In creating the basic list, there are two components: the name and the contents. If we look at the first part of this line of code, we can see that we have named the list as 'ball_list'.<br /> &lt;pre&gt;<br /> ball_list = [];<br /> &lt;/pre&gt;<br /> <br /> A list can have any kind of name. It could be called 'x', 'alotofballs','billnyethescienceguy', or anything you want. However, the best names are intuitive and help both you and other people understand your code easily. <br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> The second part of creating a list is the contents. The contents of a list can either be empty or have something already there.<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.1)<br /> ball2 = sphere(color=color.red, radius=0.2)<br /> ball3 = sphere(color=color.yellow, radius=0.3)<br /> <br /> ball_list = [ball1, ball2, ball3]<br /> box_list = []<br /> duck_list = [sphere(color=color.white, radius=0.2)]<br /> &lt;/pre&gt;<br /> <br /> These are just some examples!<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> Lists are dynamic arrays that automatically resizes when needed. When an object is stored in a list, it is stored as a reference so changing an item in the list will update itself in the scene instantly. The access cost is also O(1), making updates and finding objects fast. For searching, the time complexity is O(n). It takes a while, but it gets the job done.<br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> <br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47665 2025-12-02T16:23:14Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> &lt;p&gt;&lt;/p&gt;<br /> <br /> VPython lists are pretty flexible unlike lists from other languages such as:<br /> *containing duplicate items<br /> *easily modifying, replacing, or removing elements<br /> *keeps track of the order elements were added in<br /> *elements accessed through their position<br /> *containing different data types (integers, strings, booleans, etc)<br /> <br /> ===A Mathematical Model===<br /> <br /> <br /> ===A Computational Model===<br /> <br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> <br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47663 2025-12-02T16:16:30Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> &lt;p&gt;<br /> An introduction to creating and using lists in VPython.<br /> &lt;/p&gt;<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> ===A Mathematical Model===<br /> <br /> <br /> ===A Computational Model===<br /> <br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> <br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47662 2025-12-02T16:14:48Z

<p>Yzh79850: </p> <hr /> <div>'''Yu Zhou Fall 2025'''<br /> An introduction to creating and using lists in VPython.<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> ===A Mathematical Model===<br /> <br /> <br /> ===A Computational Model===<br /> <br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> <br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47659 2025-12-02T07:21:41Z

<p>Yzh79850: </p> <hr /> <div>Yu Zhou Fall 2025<br /> An introduction to creating and using lists in VPython.<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> # This is where we create our list<br /> ball_list = []<br /> <br /> # We set how many balls to add to our list<br /> num_balls = 1000<br /> <br /> # Inside this loop, we add num_balls amount of balls to the list<br /> for i in range(num_balls):<br /> <br /> # Every time we add a ball, we put it next to the previous ball<br /> pos = vector(0, 0, i)<br /> <br /> # radius is 1 for the ball<br /> radius = 1<br /> <br /> # We create the ball<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> # Finally, we add it to the list<br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> ===A Mathematical Model===<br /> <br /> <br /> ===A Computational Model===<br /> <br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> <br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47658 2025-12-02T07:18:59Z

<p>Yzh79850: </p> <hr /> <div>Yu Zhou Fall 2025<br /> An introduction to creating and using lists in VPython.<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls to help you stop a 17, 500 kg block of mass sliding right at you using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized, and you probably don't want to count all the way to 'ball12000'. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 1000<br /> <br /> for i in range(num_balls):<br /> pos = vector(0, 0, i)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> ===A Mathematical Model===<br /> <br /> <br /> ===A Computational Model===<br /> <br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> <br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47657 2025-12-02T07:16:51Z

<p>Yzh79850: </p> <hr /> <div>Yu Zhou Fall 2025<br /> An introduction to creating and using lists in VPython.<br /> <br /> ==The Main Idea==<br /> Let's say you want to create 100 or maybe even ''12,000'' tennis balls using VPython. Now, you could perhaps do it like this:<br /> <br /> &lt;pre&gt;<br /> ball1 = sphere(color=color.blue, radius=0.2)<br /> ball2 = sphere(color=color.blue, radius=0.2)<br /> ball3 = sphere(color=color.blue, radius=0.2)<br /> ball4 = sphere(color=color.blue, radius=0.2)<br /> ball5 = sphere(color=color.blue, radius=0.2)<br /> &lt;/pre&gt;<br /> <br /> and so on and so on. However, this can get really disorganized. Fortunately, we can use lists to contain all of these balls!<br /> <br /> &lt;pre&gt;<br /> ball_list = []<br /> <br /> num_balls = 1000<br /> <br /> for i in range(num_balls):<br /> pos = vector(0, 0, i)<br /> radius = 1<br /> ball = sphere(pos=pos, radius=radius, color=color.red)<br /> <br /> ball_list.append(ball)<br /> &lt;/pre&gt;<br /> <br /> Now that's a lot of balls.<br /> <br /> ===A Mathematical Model===<br /> <br /> <br /> ===A Computational Model===<br /> <br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> <br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47656 2025-12-02T06:53:52Z

<p>Yzh79850: </p> <hr /> <div>Yu Zhou Fall 2025<br /> An introduction to creating and using loops in VPython.<br /> <br /> ==The Main Idea==<br /> <br /> <br /> ===A Mathematical Model===<br /> <br /> <br /> ===A Computational Model===<br /> <br /> <br /> ==Examples==<br /> <br /> <br /> ===Simple===<br /> <br /> <br /> ===Middling===<br /> <br /> <br /> ===Difficult===<br /> <br /> <br /> ==Connectedness==<br /> <br /> ==History==<br /> <br /> <br /> ==See Also==<br /> <br /> ===Further Reading===<br /> <br /> <br /> ===External Links===<br /> <br /> <br /> <br /> ==References==</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=Energy_Graphs&diff=47655 2025-12-02T06:48:23Z

<p>Yzh79850: Blanked the page</p> <hr /> <div></div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=VPython_Lists&diff=47654 2025-12-02T06:48:07Z

<p>Yzh79850: Created page with &quot;Yu Zhou Fall 2025&quot;</p> <hr /> <div>Yu Zhou Fall 2025</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=Energy_Graphs&diff=47653 2025-12-02T06:16:32Z

<p>Yzh79850: </p> <hr /> <div>YU ZHOU FALL 2025<br /> Short Description of Topic<br /> <br /> ==The Main Idea==<br /> <br /> State, in your own words, the main idea for this topic<br /> Electric Field of Capacitor<br /> <br /> ===A Mathematical Model===<br /> <br /> What are the mathematical equations that allow us to model this topic. For example &lt;math&gt;{\frac{d\vec{p}}{dt}}_{system} = \vec{F}_{net}&lt;/math&gt; where '''p''' is the momentum of the system and '''F''' is the net force from the surroundings.<br /> <br /> ===A Computational Model===<br /> <br /> How do we visualize or predict using this topic. Consider embedding some vpython code here [https://trinket.io/glowscript/31d0f9ad9e Teach hands-on with GlowScript]<br /> <br /> ==Examples==<br /> <br /> Be sure to show all steps in your solution and include diagrams whenever possible<br /> <br /> ===Simple===<br /> ===Middling===<br /> ===Difficult===<br /> <br /> ==Connectedness==<br /> #How is this topic connected to something that you are interested in?<br /> #How is it connected to your major?<br /> #Is there an interesting industrial application?<br /> <br /> ==History==<br /> <br /> Put this idea in historical context. Give the reader the Who, What, When, Where, and Why.<br /> <br /> == See also ==<br /> <br /> Are there related topics or categories in this wiki resource for the curious reader to explore? How does this topic fit into that context?<br /> <br /> ===External links===<br /> <br /> Internet resources on this topic<br /> <br /> ==References==<br /> <br /> This section contains the the references you used while writing this page<br /> <br /> [[Category:Which Category did you place this in?]]</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=Energy_Graphs&diff=47652 2025-12-02T06:13:42Z

<p>Yzh79850: </p> <hr /> <div>YU ZHOU FALL 2025<br /> Short Description of Topic<br /> <br /> ==The Main Idea==<br /> <br /> State, in your own words, the main idea for this topic<br /> Electric Field of Capacitor<br /> <br /> ===A Mathematical Model===<br /> <br /> What are the mathematical equations that allow us to model this topic. For example &lt;math&gt;{\frac{d\vec{p}}{dt}}_{system} = \vec{F}_{net}&lt;/math&gt; where '''p''' is the momentum of the system and '''F''' is the net force from the surroundings.<br /> <br /> ===A Computational Model===<br /> <br /> How do we visualize or predict using this topic. Consider embedding some vpython code here [https://trinket.io/glowscript/31d0f9ad9e Teach hands-on with GlowScript]<br /> <br /> ==Examples==<br /> <br /> Be sure to show all steps in your solution and include diagrams whenever possible<br /> <br /> ===Simple===<br /> ===Middling===<br /> ===Difficult===<br /> <br /> ==Connectedness==<br /> #How is this topic connected to something that you are interested in?<br /> #How is it connected to your major?<br /> #Is there an interesting industrial application?<br /> <br /> ==History==<br /> <br /> Put this idea in historical context. Give the reader the Who, What, When, Where, and Why.<br /> <br /> == See also ==<br /> <br /> Are there related topics or categories in this wiki resource for the curious reader to explore? How does this topic fit into that context?<br /> <br /> ===Further reading===<br /> <br /> Books, Articles or other print media on this topic<br /> <br /> ===External links===<br /> <br /> Internet resources on this topic<br /> <br /> ==References==<br /> <br /> This section contains the the references you used while writing this page<br /> <br /> [[Category:Which Category did you place this in?]]</div>

Yzh79850 http://www.physicsbook.gatech.edu/index.php?title=Energy_Graphs&diff=47377 2025-11-28T02:40:11Z

<p>Yzh79850: Created page with &quot;YU ZHOU FALL 2025&quot;</p> <hr /> <div>YU ZHOU FALL 2025</div>

Yzh79850