🌌 Python Turtle The Neon Wave Tunnel

 

Code:

import turtle import math import time screen = turtle.Screen() screen.setup(700, 700) screen.bgcolor("#020208") t = turtle.Turtle() t.hideturtle() t.speed(0) t.width(2) colors = [ "#00ffff", "#7c4dff", "#ff2d75", "#00ff9d", "#ffe600" ] for layer in range(35): t.color(colors[layer % len(colors)]) t.penup() for i in range(180): x = -260 + i * 3 wave = math.sin(i * 0.09 + layer * 0.35) * (35 + layer) y = wave + layer * 2 if i == 0: t.goto(x, y) t.pendown() else: t.goto(x, y) screen.update() time.sleep(0.003) time.sleep(0.08) # ✨ Center glow for r in range(30, 2, -3): t.penup() t.goto(0, -r) t.dot(r, colors[r % len(colors)]) screen.update() time.sleep(0.06) turtle.done()

Explanation:

1. Import Libraries

import turtle

import math

import time

turtle → Creates the drawing.

math → Calculates the wave pattern.

time → Controls animation speed.

2. Create the Screen

screen = turtle.Screen()

screen.setup(700, 700)

screen.bgcolor("#020208")

Creates a 700 × 700 canvas.

Sets a dark background.

3. Configure the Turtle

t = turtle.Turtle()

t.hideturtle()

t.speed(0)

t.width(2)

Creates the turtle.

Hides the turtle cursor.

Sets maximum speed.

Sets line thickness to 2.

4. Define Neon Colors

colors = [

    "#00ffff", "#7c4dff",

    "#ff2d75", "#00ff9d",

    "#ffe600"

]

Stores five neon colors.

These colors are used for different wave layers.

5. Create Multiple Wave Layers

for layer in range(35):

Creates 35 separate wave layers.

Each layer forms part of the tunnel effect.

6. Select the Layer Color

t.color(colors[layer % len(colors)])

Cycles through the neon colors.

layer % len(colors) prevents the index from going out of range.

7. Prepare for Drawing

t.penup()

Lifts the pen before moving to the starting point.

8. Generate Wave Points

for i in range(180):

Creates 180 points for every wave.

9. Calculate X Position

x = -260 + i * 3

Starts at -260.

Moves 3 pixels to the right each time.

10. Calculate the Wave

wave = math.sin(i * 0.09 + layer * 0.35) * (35 + layer)

Uses sin() to create a smooth wave.

layer * 0.35 shifts each layer.

(35 + layer) gradually increases the wave size.

11. Calculate Y Position

y = wave + layer * 2

Combines the wave movement with the layer offset.

Moves each layer slightly upward.

12. Start the Wave

if i == 0:

    t.goto(x, y)

    t.pendown()

Moves to the first point without drawing.

Then starts drawing the wave.

13. Continue the Wave

else:

    t.goto(x, y)

Connects each calculated point.

Creates the continuous wave line.

14. Animate the Wave

screen.update()

time.sleep(0.003)

Updates the screen.

Adds a tiny delay for smooth animation.

15. Pause Between Layers

time.sleep(0.08)

Adds a short pause after each wave layer.

Makes the tunnel formation visible.

16. Create the Center Glow

for r in range(30, 2, -3):

Creates several shrinking circles.

The radius decreases from 30 to 3.

17. Draw the Glow

t.penup()

t.goto(0, -r)

t.dot(r, colors[r % len(colors)])

Moves to the center.

Draws colorful dots of decreasing size.

Creates a glowing-center effect.

18. Animate the Glow

screen.update()

time.sleep(0.06)

Updates the screen.

Adds a small delay between glow layers.

19. Finish

turtle.done()

Keeps the Turtle window open.

Ends the animation.

Read More

Python Coding Challenge - Question with Answer (ID 031026)

 

Explanation:

🟢 Line 1: Complete Code

print(10 // 3 * 2 + 10 % 3 ** 1)

We need to evaluate the operators according to Python's operator precedence.

🟡 Step 1: Evaluate Exponentiation **

Exponentiation has higher precedence than //, *, %, and +.

3 ** 1

So:

3 ** 1 = 3

Expression becomes:

10 // 3 * 2 + 10 % 3

🔵 Step 2: Evaluate //

Now:

10 // 3

Floor division gives:

10 // 3 = 3

Expression becomes:

3 * 2 + 10 % 3

🟣 Step 3: Evaluate *

3 * 2 = 6

Expression becomes:

6 + 10 % 3

🟠 Step 4: Evaluate %

Modulo gives the remainder:

10 % 3

Since:

10 = 3 × 3 + 1

Therefore:

10 % 3 = 1

Expression becomes:

6 + 1

🟢 Step 5: Addition

6 + 1 = 7

So Python effectively executes:

print(7)

🎯 Final Output

7

Books: PYTHON LOOPS MASTERY

Read More

Python Coding challenge - Day 1273| What is the output of the following Python Code?

 

Code Explanation:

1. 🏗️ Creating the Dictionary Subclass

class D(dict):

Here, D is a custom class that inherits from dict.

Therefore, objects of D behave like dictionaries, but we can also add custom behavior.

2. 🔍 Defining __missing__()

def __missing__(self, key):

__missing__() is a special dictionary method.

Python calls it when:

d[key]

is used and the key does not exist.

It is important that __missing__() is triggered by dictionary indexing, not by every dictionary lookup method.

3. 📏 Returning the Key Length

return len(key)

The missing key will be "python".

Therefore:

len("python") = 6

So __missing__() returns:

6

4. 🗂️ Creating the Dictionary

d = D()

An empty object of class D is created.

Initially:

d = {}

There is no "python" key.

5. 🎯 Accessing the Missing Key

x = d["python"]

Python looks for "python" inside d.

It doesn't find it.

Because D defines __missing__(), Python calls:

__missing__("python")

Then:

len("python")

returns:

6

Therefore:

x = 6

6. ⚠️ The Important .get() Difference

y = d.get("python")

This is the tricky line.

Even though "python" is missing, .get() does not call __missing__().

Since there is no "python" key, .get() returns:

None

Therefore:

y = None

7. 🖨️ Print the Result

print(x, y)

We have:

x = 6

y = None

So the output is:

6 None

Book: 400 Days Python Coding Challenges with Explanation

Read More

Python Coding challenge - Day 1272| What is the output of the following Python Code?

 

Code Explanation:

1. 🔧 Define the Generator Function

def gen():

This creates a function named gen.

Because the function contains yield, it becomes a generator function.

A generator does not execute its entire body immediately.

2. 📌 Initialize x

x = 1

When the generator starts running, x is initialized to:

x = 1

3. 🔁 Check the while Condition

while x < 10:

Python checks whether:

1 < 10

This is True, so the loop starts.

4. 🎁 First yield

yield x

At this moment:

yield 1

The generator pauses and sends 1 to whoever called next(g).

So:

next(g)

returns:

1

Important: yield pauses the function instead of ending it.

5. 🔄 Resume and Multiply

x *= 3

When the next next(g) is called, execution resumes from where it paused.

Now:

x = 1 × 3

x = 3

6. 🔁 Second Loop Check

Python reaches:

while x < 10:

Now:

3 < 10

is True.

So the loop continues.

7. 🎁 Second yield

yield x

Now the generator yields:

3

Therefore the second:

next(g)

returns 3.

8. 🖨️ print() Executes

print(next(g), next(g))

Python evaluates the arguments from left to right:

First next(g)  → 1

Second next(g) → 3

So the final output is:

1 3

🔄 Generator Flow

gen()

 ↓

x = 1

 ↓

yield 1

 ↓

pause

 ↓

next(g)

 ↓

x = 3

 ↓

yield 3

 ↓

pause

💡 Key Interview Trick

next() does not restart the generator.

It resumes execution from the previous yield point.

So the sequence produced by this generator would be:

1 → 3 → 9

The two next() calls consume only:

1 → 3

Hence:

✅ Final Answer

1 3

Book: 500 Days Python Coding Challenges with Explanation

Read More

🌀 Python Turtle The Twisted Rainbow Illusion

 

Code:

import turtle import math import time screen = turtle.Screen() screen.setup(700, 700) screen.bgcolor("#000000") t = turtle.Turtle() t.hideturtle() t.speed(0) t.width(1) colors = [ "#ff1744", "#ffea00", "#00ff9d", "#00e5ff", "#2979ff", "#d500f9" ] # Draw many twisted ellipses for i in range(75): t.color(colors[i % len(colors)]) points = 120 phase = i * 0.055 for j in range(points + 1): a = math.radians(j * 360 / points) # Twisted oval x = 260 * math.cos(a) y = 125 * math.sin(a + phase) # Slight rotation rot = math.radians(i * 2.2) X = x * math.cos(rot) - y * math.sin(rot) Y = x * math.sin(rot) + y * math.cos(rot) if j == 0: t.penup() t.goto(X, Y) t.pendown() else: t.goto(X, Y) screen.update() time.sleep(0.035) # Dark center t.penup() t.goto(0, -55) t.dot(105, "#000000") screen.update() time.sleep(1) turtle.done()

Explanation:

1. Import Libraries

import turtle

import math

import time

turtle → Used for drawing.

math → Used for trigonometric calculations.

time → Controls animation speed.

2. Create the Screen

screen = turtle.Screen()

screen.setup(700, 700)

screen.bgcolor("#000000")

Creates a 700 × 700 canvas.

Sets a black background.

3. Configure the Turtle

t = turtle.Turtle()

t.hideturtle()

t.speed(0)

t.width(1)

Creates the turtle.

Hides the cursor.

Sets maximum drawing speed.

Uses a thin line.

4. Define Neon Colors

colors = [

    "#ff1744", "#ffea00",

    "#00ff9d", "#00e5ff",

    "#2979ff", "#d500f9"

]

Stores six bright neon colors.

Colors are reused for different ellipses.

5. Create Multiple Ellipses

for i in range(75):

Creates 75 twisted ellipse layers.

6. Select the Color

t.color(colors[i % len(colors)])

Cycles through the neon colors.

Each ellipse gets a different color.

7. Set Curve Parameters

points = 120

phase = i * 0.055

Uses 120 points for a smooth ellipse.

phase changes the shape of every layer slightly.

8. Generate Ellipse Points

for j in range(points + 1):

Loops through all points of the ellipse.

+1 helps close the curve.

9. Calculate the Angle

a = math.radians(j * 360 / points)

Divides the full 360° circle into 120 sections.

Converts the angle to radians.

10. Calculate the Oval Coordinates

x = 260 * math.cos(a)

y = 125 * math.sin(a + phase)

Calculates the X coordinate using cosine.

Calculates the Y coordinate using sine.

Different X/Y sizes create an oval.

phase creates the twisting effect.

11. Calculate Rotation

rot = math.radians(i * 2.2)

Rotates each ellipse slightly.

Every new layer gets an additional 2.2° rotation.

12. Rotate the X Coordinate

X = x * math.cos(rot) - y * math.sin(rot)

Applies a rotation transformation to the X position.

13. Rotate the Y Coordinate

Y = x * math.sin(rot) + y * math.cos(rot)

Applies the same rotation to the Y position.

Together, X and Y create the rotated ellipse.

14. Start Drawing the Ellipse

if j == 0:

    t.penup()

    t.goto(X, Y)

    t.pendown()

Moves to the first point without drawing.

Starts drawing from that point.

15. Connect the Points

else:

    t.goto(X, Y)

Connects all calculated points.

Forms the smooth twisted ellipse.

16. Animate Each Layer

screen.update()

time.sleep(0.035)

Updates the screen.

Adds a short delay between layers.

17. Create the Dark Center

t.penup()

t.goto(0, -55)

t.dot(105, "#000000")

Moves to the center.

Draws a large black circle.

Creates a dark central hole.

18. Display the Final Design

screen.update()

time.sleep(1)

Updates the final frame.

Keeps the design visible for one second.

19. Finish

turtle.done()

Keeps the Turtle window open.

Ends the program.

Read More

 

🐍 Python Pattern Challenge — Day 18

Pattern printing is a great way to improve your Python loops, spacing, repetition, and logical thinking. For Day 18, let's create a simple Star Hourglass Pattern ⭐.

This pattern starts with a wide row of stars, gradually becomes smaller toward the center, and then expands again. It is a good exercise for understanding increasing and decreasing loops.

Today's Challenge

Write a Python program to print:

Best and cleanest code will be rewarded! 🏆

---

Solution 1 — Using Nested for Loops

n = 5

for i in range(n, 0, -1):
    print("  " * (n - i), end="")

    for j in range(2 * i - 1):
        print("*", end=" ")

    print()

for i in range(2, n + 1):
    print("  " * (n - i), end="")

    for j in range(2 * i - 1):
        print("*", end=" ")

    print()

How it works

The first loop creates the decreasing part:

* * * * * * * * *
  * * * * * * *
    * * * * *
      * * *
        *

The second loop creates the increasing part:

      * * *
    * * * * *
  * * * * * * *
* * * * * * * * *

The expression:

2 * i - 1

controls the number of stars in each row.

---

Solution 2 — Using String Multiplication

n = 5

for i in range(n, 0, -1):
    print("  " * (n - i) + "* " * (2 * i - 1))

for i in range(2, n + 1):
    print("  " * (n - i) + "* " * (2 * i - 1))
This version is shorter because Python can repeat a string using *.

For example:

"* " * 5
produces:

* * * * *

---

Solution 3 — Using a Single Loop

n = 5

for i in list(range(n, 0, -1)) + list(range(2, n + 1)):
    print("  " * (n - i) + "* " * (2 * i - 1))

How it works

The sequence:

5, 4, 3, 2, 1, 2, 3, 4, 5




controls the complete hourglass.

When the value decreases, the pattern shrinks.

When it increases again, the pattern expands.

---

⚡ Short & Clean Code

for i in [5, 4, 3, 2, 1, 2, 3, 4, 5]:
    print("  " * (5-i) + "* " * (2*i-1))

🔥 A single loop is enough to create the complete pattern.

---

🚀 Challenge Yourself

Can you modify this pattern:

• Take n from the user using input()?
• Create the same pattern using a while loop?
• Make the hourglass larger?
• Replace * with another symbol?
• Create a hollow hourglass?
• Generate the sequence without manually writing [5, 4, 3, ...]?

Drop your solution below! 👇

18 Days. 18 Patterns. Stronger Python Logic. 🐍🔥

Learn • Practice • Grow with CLCODING 🚀

Books: PYTHON INTERVIEW QUESTIONS AND ANSWERS

Read More