🌺 Python Turtle The Colorful Spirograph Bloom

 

Code:

import turtle import time s = turtle.Screen() s.setup(750, 750) s.bgcolor("#100719") s.title("Spirograph Flower") s.tracer(1) t = turtle.Turtle() t.hideturtle() t.speed(0) t.pensize(2) colors = ["#FF4D9D", "#A855F7", "#00E5FF", "#FFD166"] # Layered curved petals for layer in range(3): radius = 100 + layer * 35 for i in range(24): t.penup() t.goto(0, 0) t.setheading(i * 15 + layer * 5) t.pendown() t.pencolor(colors[(i + layer) % 4]) t.circle(radius, 70) t.left(110) t.circle(radius, 70) s.update() time.sleep(0.035) # Decorative center t.penup() t.goto(0, -18) t.pendown() t.pencolor("#FFD166") t.fillcolor("#FF4D9D") t.begin_fill() t.circle(18) t.end_fill() # Tiny outer dots for i in range(36): t.penup() t.goto(0, 0) t.setheading(i * 10) t.forward(245) t.dot(5, colors[i % 4]) s.update() time.sleep(0.025) turtle.done()

Explanation:

1. Import Libraries

import turtleimport time

- turtle draws the flower design.

- time adds pauses to the animation.

2. Create the Screen

s = turtle.Screen()s.setup(750, 750)s.bgcolor("#100719")s.title("Spirograph Flower")s.tracer(1)

- Creates a 750 × 750 window.

- Sets a dark purple background.

- Adds the title “Spirograph Flower”.

- Enables screen updates during drawing.

3. Configure the Turtle

t = turtle.Turtle()t.hideturtle()t.speed(0)t.pensize(2)

- Creates the drawing turtle.

- Hides the cursor.

- Sets the fastest drawing speed.

- Sets the line thickness to 2.

4. Define Neon Colors

colors = ["#FF4D9D", "#A855F7", "#00E5FF", "#FFD166"]

Defines four colors: pink, purple, cyan, and golden yellow.

5. Create Three Flower Layers

for layer in range(3):    radius = 100 + layer * 35

- Creates three layers of petals.

- Increases the radius for each layer: 100, 135, and 170.

6. Set Petal Positions

for i in range(24):    t.penup()    t.goto(0, 0)    t.setheading(i * 15 + layer * 5)    t.pendown()

- Draws 24 curved patterns per layer.

- Moves the turtle to the center.

- Rotates each pattern by 15° plus a small layer offset.

- Puts the pen down to start drawing.

7. Draw Curved Petals

t.pencolor(colors[(i + layer) % 4])t.circle(radius, 70)t.left(110)t.circle(radius, 70)

- Changes colors for a multicolored effect.

- Draws a 70° curved arc.

- Turns left by 110°.

- Draws another arc to form a petal-like shape.

8. Animate the Flower

s.update()time.sleep(0.035)

- Refreshes the screen.

- Adds a short pause so the drawing animation is visible.

9. Draw the Center

t.penup()t.goto(0, -18)t.pendown()t.pencolor("#FFD166")t.fillcolor("#FF4D9D")t.begin_fill()t.circle(18)t.end_fill()

- Moves to the center area.

- Sets a golden outline and pink fill.

- Draws a filled circle of radius 18.

10. Add Decorative Outer Dots

for i in range(36):    t.penup()    t.goto(0, 0)    t.setheading(i * 10)    t.forward(245)    t.dot(5, colors[i % 4])

- Creates 36 decorative dots.

- Rotates by 10° for each dot.

- Moves 245 units from the center.

- Uses different neon colors for the dots.

11. Finish the Program

turtle.done()

Keeps the graphics window open after the drawing finishes.

Read More

Modern Machine Learning with Elixir: A Practical Beginner's Guide to Building AI Models with Nx, Axon, Deep Learning, and Real-World Projects

 

Machine learning has traditionally been strongly associated with Python, but the growth of the Elixir ecosystem is creating another interesting path for building intelligent applications. Elixir brings the strengths of functional programming, concurrency, fault tolerance, and the Erlang virtual machine into the world of machine learning.

Modern Machine Learning with Elixir focuses on learning machine learning through the Elixir ecosystem, particularly with Nx and Axon. The book's practical approach connects fundamental machine-learning concepts with real applications, allowing readers to move from basic ideas toward neural networks, computer vision, natural-language processing, time-series prediction, transformers, and production applications.

---

Why Machine Learning with Elixir?

Python remains one of the most widely used languages for machine learning, but machine learning is not limited to Python.

Elixir offers a different programming environment. It is built on the Erlang virtual machine, commonly known as the BEAM, which is well known for concurrency, fault tolerance, and distributed systems.

This creates an interesting combination:

• Functional programming

• Machine learning

• Concurrent applications

• Distributed systems

• Fault-tolerant services

• Real-time applications

The goal is not simply to replace Python. Instead, Elixir provides an alternative environment where machine-learning models can be integrated closely with scalable applications.

---

Understanding Nx

Nx is one of the central technologies in the Elixir machine-learning ecosystem.

It provides numerical computing capabilities that allow developers to work with tensors and perform mathematical operations efficiently.

The book introduces Nx early because understanding numerical computation is essential before moving into more advanced machine-learning concepts. Its contents include sections on thinking in tensors, using Nx operations, representing the world numerically, and working with numerical functions.

Nx helps developers work with:

• Tensors

• Numerical data

• Mathematical operations

• Machine-learning computations

• Hardware acceleration

• Data transformations

This makes Nx an important foundation for machine learning in Elixir.

---

What Are Tensors?

Tensors are fundamental data structures used in modern machine learning.

A simple number can be considered a basic numerical object. Multiple numbers can form vectors, and collections of vectors can form matrices. Larger collections create higher-dimensional tensors.

Machine-learning models use these structures to represent:

• Images

• Text

• Audio

• Time-series data

• Features

• Model parameters

• Neural-network activations

Understanding tensors is therefore an important step toward understanding how machine-learning models process information.

---

The Mathematics Behind Machine Learning

The book does not treat machine learning purely as a collection of programming techniques.

It also introduces the mathematical thinking required to understand machine-learning systems.

The book's foundations section includes topics related to machine-learning mathematics, data representation, probability, and optimization.

Important areas include:

• Mathematical reasoning

• Probability

• Data representation

• Optimization

• Gradients

• Generalization

• Model performance

This makes the learning process more meaningful because readers can understand not only what the code does but also why the algorithm behaves in a particular way.

---

Learning Through Optimization

Machine learning involves finding useful patterns and adjusting models so that they perform better.

Optimization provides the foundation for this learning process.

A model begins with parameters and gradually adjusts them based on its performance.

The book introduces concepts such as:

• Optimization

• Regularization

• Gradient-based learning

• Generalization

• Model improvement

These concepts are essential for understanding how neural networks actually learn rather than treating training as a black-box operation.

---

Traditional Machine Learning

Before moving into deep learning, the book introduces traditional machine-learning approaches.

This is important because not every machine-learning problem requires a large neural network.

Traditional approaches can be effective when:

• Datasets are relatively structured

• Problems are simpler

• Interpretability is important

• Training resources are limited

• Deep learning would be unnecessary

The book covers areas including linear learning, learning from surrounding data, clustering, and decision-making.

---

Clustering and Unsupervised Learning

Clustering is a useful machine-learning technique for discovering groups within data.

Instead of providing predefined categories, the algorithm attempts to identify naturally occurring structures.

This can be useful for:

• Customer segmentation

• Data exploration

• Pattern discovery

• Grouping similar observations

• Detecting unusual behavior

Understanding clustering also provides an introduction to unsupervised learning, where models learn from data without explicit target labels.

---

Introducing Axon

After establishing the fundamentals, the book moves into deep learning with Axon.

Axon is a deep-learning framework designed for the Elixir ecosystem and built around Nx.

It allows developers to define neural networks in a way that fits naturally with Elixir's functional programming style.

The book covers:

• Neural-network fundamentals

• Model architecture

• Building neural networks

• Training

• Evaluation

• Deep-learning workflows

Axon was created by Sean Moriarity, who is also a co-creator of Nx.

---

Understanding Neural Networks

Neural networks are models designed to learn complex relationships from data.

A neural network consists of interconnected layers that transform information as it moves through the model.

Different layers can learn different types of representations.

For example, in computer vision, a model can gradually move from simple visual patterns toward more meaningful structures.

The book introduces neural networks from a practical perspective so readers can understand how these models are constructed and trained using Axon.

---

Computer Vision with Elixir

One of the practical applications covered by the book is computer vision.

Computer vision allows machines to process and understand visual information.

The book uses an image-classification example involving cats and dogs to introduce important concepts in computer vision and convolutional neural networks.

Computer vision applications include:

• Image classification

• Object recognition

• Image analysis

• Visual search

• Quality inspection

• Medical imaging

• Automated image processing

This makes the learning process more practical because readers can see how deep-learning concepts are applied to real visual data.

---

Convolutional Neural Networks

Convolutional Neural Networks, commonly called CNNs, are particularly important for image-related problems.

CNNs are designed to learn spatial patterns from images.

Instead of treating every pixel independently, convolutional architectures can learn local structures and combine them into increasingly complex representations.

They are widely used in:

• Image classification

• Object detection

• Facial recognition

• Medical imaging

• Visual inspection

• Computer vision systems

The book introduces CNNs through practical image-classification examples before moving toward more advanced applications.

---

Transfer Learning

Training a deep-learning model from scratch can require substantial amounts of data and computing resources.

Transfer learning provides another approach.

Instead of starting with a completely untrained model, developers can take an existing trained model and adapt it to a new problem.

The book covers fine-tuning and transfer learning as part of its computer-vision section.

Benefits of transfer learning include:

• Faster development

• Less training data

• Reduced computational requirements

• Reuse of existing knowledge

• Better performance on smaller datasets

This is particularly valuable for practical machine-learning projects.

---

Natural Language Processing

Machine learning is not limited to images.

The book also explores natural language processing, allowing readers to work with text-based problems.

One example involves classifying movie reviews.

NLP systems can analyze and process:

• Reviews

• Documents

• Messages

• Questions

• Conversations

• Search queries

• Customer feedback

This demonstrates how the same machine-learning principles can be adapted to completely different types of data.

---

Recurrent Neural Networks

The book introduces Recurrent Neural Networks, or RNNs, as part of its natural-language-processing material.

RNNs are designed to work with sequential information.

Sequence-based data appears in many applications:

• Text

• Speech

• Sensor readings

• Time series

• User activity

• Financial data

The important idea is that the order of information matters.

RNNs attempt to preserve information from previous elements of a sequence while processing new information.

---

Time-Series Prediction

Another practical area explored in the book is time-series prediction.

Time-series data is information collected over time.

Examples include:

• Stock prices

• Weather measurements

• Sales

• Website traffic

• Energy consumption

• Sensor readings

The book uses stock-price prediction as an example and discusses both convolutional and recurrent approaches to time-series prediction.

However, the book also emphasizes the importance of maintaining realistic expectations around prediction. Financial markets are complex and noisy, so a machine-learning model should not automatically be assumed to produce reliable future predictions simply because it performs well on historical data.

---

Transformers

Transformers have become one of the most influential architectures in modern AI.

They introduced a different way of processing sequences by focusing on relationships between different parts of the input.

The book introduces the ideas behind attention and then moves from recurrent approaches toward transformer-based models.

It also explores using transformers through Bumblebee, another important component of the Elixir AI ecosystem.

Transformers are important for:

• Natural language processing

• Text generation

• Question answering

• Translation

• Summarization

• Conversational AI

• Large language models

Their inclusion makes the book relevant to modern AI development rather than limiting the discussion to older neural-network architectures.

---

Learning Without Supervision

The book also explores machine learning without labeled training data.

This section introduces approaches where models attempt to learn useful representations or structures without being explicitly told the correct answer.

Topics include:

• Autoencoders

• Latent representations

• Generative models

• GANs

• Unsupervised learning

These techniques demonstrate that machine learning can be used not only to predict labels but also to discover and generate information.

---

Autoencoders

Autoencoders are neural networks that learn useful representations of data.

They can be used for:

• Data compression

• Representation learning

• Feature extraction

• Noise reduction

• Anomaly detection

The book uses autoencoders to introduce the idea of learning structured latent representations from data.

This provides a useful transition from traditional supervised learning toward more advanced generative and representation-learning approaches.

---

Generative Adversarial Networks

Generative Adversarial Networks, or GANs, are another topic included in the book.

GANs use two interacting components to learn how to generate new examples that resemble the training data.

They have been used for:

• Image generation

• Synthetic data

• Style transformation

• Data augmentation

• Creative applications

Studying GANs gives readers an introduction to the generative side of deep learning.

---

Machine Learning in Real Applications

One of the strongest aspects of the book is its movement from theory toward practical application.

The final section focuses on putting machine learning into an actual application rather than keeping everything inside isolated examples.

The book discusses integrating Nx with Phoenix, setting up an application, working with databases, and building an interactive search interface with LiveView.

This is important because building a machine-learning model is only one part of developing an AI-powered application.

---

Nx and Phoenix

Phoenix is one of the major web-development frameworks in the Elixir ecosystem.

Combining Phoenix with Nx creates an interesting architecture for applications that need both:

• Web application functionality

• Machine-learning capabilities

This makes it possible to integrate intelligent features directly into Elixir applications rather than treating machine learning as a completely separate service.

---

LiveView and Machine Learning

LiveView allows developers to build interactive web experiences using Elixir.

When combined with machine-learning capabilities, it becomes possible to create applications where users interact directly with AI-powered features.

Potential applications include:

• Intelligent search

• Recommendation systems

• Classification tools

• Interactive analytics

• AI dashboards

• Real-time prediction systems

This demonstrates one of the key advantages of the Elixir ecosystem: application development and machine learning can exist within the same broader technology stack.

---

Why Elixir Is Interesting for AI Applications

Elixir brings several characteristics that can be valuable for production systems.

Concurrency

Elixir is designed to handle many concurrent processes efficiently.

Fault Tolerance

The BEAM ecosystem has a strong focus on building systems that can continue operating despite failures.

Distributed Systems

Elixir applications can take advantage of the distributed capabilities of the Erlang ecosystem.

Functional Programming

Functional programming encourages clear data transformations and predictable program behavior.

Real-Time Applications

Elixir and Phoenix are particularly well suited to applications that require real-time interaction.

These characteristics can be useful when machine-learning models need to operate as part of larger production applications.

---

Hardware Acceleration

Machine learning can require significant computational resources.

The Elixir ecosystem can take advantage of technologies designed to accelerate numerical workloads.

Nx can work with different computation backends, while more demanding workloads can use accelerator technologies such as CUDA, ROCm, or Google TPUs where supported. The book's documentation notes that some compute-intensive examples can use accelerators, while many examples can also run on CPUs.

This allows developers to experiment with machine learning at different scales.

---

Distributed Machine Learning

The Elixir ecosystem has an interesting relationship with distributed computing.

Nx can support computation across multiple machines and multiple GPUs in suitable environments. Livebook has also demonstrated distributed machine-learning capabilities across machines and GPUs.

This is particularly interesting because distributed systems are one of Elixir's traditional strengths.

It creates opportunities for combining:

• Machine learning

• Concurrency

• Distributed computing

• Fault tolerance

• Real-time services

---

Livebook for Machine Learning

Livebook provides an interactive environment for Elixir development and experimentation.

It can be thought of as a notebook-style environment where developers can write code, execute it interactively, document experiments, and visualize results.

This makes it particularly useful for:

• Learning machine learning

• Experimenting with models

• Teaching

• Data exploration

• Prototyping

• Demonstrating AI concepts

The Elixir ecosystem has also expanded Livebook's machine-learning capabilities with support for modern model-based tasks and interactive workflows.

---

From Learning to Production

A major lesson from the book is that machine learning does not end after model training.

A complete AI application requires additional components.

A practical workflow may involve:

• Understanding the problem

• Preparing data

• Selecting an appropriate model

• Training the model

• Evaluating performance

• Integrating the model into an application

• Serving predictions

• Monitoring the system

• Improving the model over time

This perspective is particularly valuable for developers because it connects machine learning with real software engineering.

---

Who Should Read This Book?

This book is especially useful for:

• Elixir developers interested in AI

• Software developers learning machine learning

• Machine-learning beginners

• Functional-programming enthusiasts

• Backend developers

• AI application developers

• Students interested in alternative ML ecosystems

• Developers building real-time AI applications

It is also useful for experienced machine-learning developers who want to explore how the BEAM ecosystem can be used for AI.

---

What You Can Learn

By working through the material, readers can build knowledge across several areas.

Machine Learning Foundations

Understand fundamental machine-learning concepts before moving into deep learning.

Numerical Computing

Learn how Nx represents and manipulates numerical data.

Neural Networks

Build an understanding of neural-network architectures through Axon.

Computer Vision

Work with image classification and convolutional neural networks.

Natural Language Processing

Explore text classification and sequence-based models.

Time-Series Modeling

Learn how machine learning can be applied to temporal data.

Transformers

Understand modern transformer-based approaches.

Generative AI

Explore autoencoders and generative adversarial networks.

Production Applications

Learn how machine learning can be integrated with Phoenix and LiveView.

These areas closely follow the progression outlined in the book's contents.

---

Elixir vs Traditional Machine-Learning Ecosystems

Python continues to dominate machine-learning research and production tooling, largely because of its huge ecosystem.

Elixir offers something different.

Its strongest value may appear when machine learning needs to live inside applications that also require:

• High concurrency

• Real-time communication

• Distributed processing

• Fault tolerance

• Scalable backend infrastructure

Therefore, Elixir does not necessarily need to replace Python to be valuable in machine learning.

Instead, it provides another option for developers who want to combine AI with the strengths of the BEAM ecosystem.

---

Key Takeaways

1. Elixir Can Be Used for Modern Machine Learning

The Elixir ecosystem now provides tools for traditional machine learning, deep learning, NLP, computer vision, and modern AI workflows.

2. Nx Provides the Numerical Foundation

Nx enables numerical computing and tensor-based operations required for machine-learning workloads.

3. Axon Makes Deep Learning More Accessible

Axon provides an Elixir-native approach to defining and training neural networks.

4. Machine Learning Goes Beyond Training Models

The book emphasizes moving from algorithms toward complete applications.

5. Elixir's BEAM Ecosystem Is a Major Advantage

Concurrency, fault tolerance, and distributed computing make Elixir particularly interesting for production AI systems.

6. Modern AI Topics Are Included

The material progresses beyond basic machine learning into CNNs, RNNs, transformers, autoencoders, GANs, and practical AI applications.

Hard Copy:Modern Machine Learning with Elixir: A Practical Beginner's Guide to Building AI Models with Nx, Axon, Deep Learning, and Real-World Projects

Kindle: Modern Machine Learning with Elixir: A Practical Beginner's Guide to Building AI Models with Nx, Axon, Deep Learning, and Real-World Projects

Final Thoughts

Modern Machine Learning with Elixir presents an interesting alternative perspective on AI development.

Instead of treating machine learning as something that exists separately from application development, the Elixir ecosystem allows developers to explore machine learning within a language known for concurrency, reliability, and distributed systems.

The combination of Elixir, Nx, Axon, Livebook, Phoenix, and related tools creates an increasingly capable environment for building intelligent applications. The book's progression from machine-learning fundamentals to deep learning, computer vision, NLP, time-series prediction, transformers, generative models, and production integration makes it particularly useful for readers who want both conceptual knowledge and practical experience.

For beginners, it provides a structured way to enter machine learning through Elixir. For experienced developers, it demonstrates how AI can be integrated into the broader Elixir ecosystem.

Most importantly, the book shows that the future of machine learning does not have to be limited to a single programming language. Different ecosystems can bring different strengths to AI development, and Elixir's combination of machine learning with concurrency, scalability, and fault-tolerant application development makes it a particularly interesting technology to explore.

Read More

Python Machine Learning By Example: Unlock machine learning best practices with real-world use cases (Free PDF)

 

Python Machine Learning by Example: Unlock Machine Learning Best Practices with Real-World Use Cases is a practical resource for learners who want to move beyond machine learning theory and understand how ML techniques are applied to real-world problems.

The book follows a hands-on, example-driven approach, making it useful for Python developers, data science students, and machine learning practitioners who want to strengthen their practical skills.

What Is This Book About?

Machine learning is much more than selecting an algorithm and calling .fit().

A complete ML workflow usually involves:

• Understanding the problem
• Preparing the data
• Exploring patterns
• Selecting useful features
• Training models
• Evaluating performance
• Improving the model
• Deploying or using predictions

This book focuses on these practical aspects through real-world use cases.

Download the PDF for free: https://github.com/PacktPublishin

Learning Through Examples

One of the strongest aspects of an example-based approach is that concepts are introduced in the context of actual problems.

Instead of learning an algorithm in isolation, you can understand:

Problem → Data → Python → Model → Evaluation → Solution

This makes it easier to understand why a particular machine learning technique is useful.

Python as the Main Tool

Python plays a central role in modern machine learning because of its extensive ecosystem.

A practical ML workflow commonly brings together tools such as:

• NumPy
• Pandas
• Matplotlib
• scikit-learn
• Other Python machine learning libraries

Working with these tools together helps learners develop skills that are closer to real data science workflows.

Data Preparation

Before training a model, the data needs to be prepared carefully.

Real datasets can contain missing information, inconsistent values, irrelevant features, and other issues.

The book's practical approach helps emphasize an important part of machine learning:

Model performance depends heavily on the quality and preparation of the data.

Feature Engineering

Feature engineering is another important part of practical machine learning.

The goal is to transform raw information into useful representations that allow machine learning models to identify meaningful patterns.

This can involve:

• Selecting useful variables
• Transforming features
• Creating new features
• Removing unnecessary information
• Preparing categorical data

Feature engineering can make a significant difference in the quality of a machine learning solution.

Machine Learning Algorithms

A practical machine learning project may require different algorithms depending on the problem.

The learning process can involve techniques for:

Classification

Predicting categories or classes.

Regression

Predicting continuous values.

Clustering

Discovering groups or patterns without predefined labels.

Dimensionality Reduction

Reducing the number of variables while retaining useful information.

The important lesson is not simply memorizing algorithms, but understanding when and why to use them.

Model Evaluation

A machine learning model should not be judged only by how well it performs on its training data.

Evaluation helps determine whether the model can generalize to new, unseen data.

This introduces practical concepts such as:

• Training and testing data
• Validation
• Performance metrics
• Overfitting
• Underfitting
• Model comparison

These are essential skills for anyone working with machine learning.

Machine Learning Best Practices

The book's focus on best practices is particularly valuable.

A good ML project should be:

• Reproducible
• Properly evaluated
• Well organized
• Based on appropriate data processing
• Carefully validated
• Easy to understand and maintain

Learning these habits early can help prevent common mistakes in real-world projects.

From Notebook to Real Project

Many beginners can train a model inside a Jupyter Notebook but struggle when asked to organize a complete machine learning project.

Practical examples help bridge this gap.

You begin to understand how individual steps connect:

Data Analysis → Feature Engineering → Model Training → Evaluation → Prediction

This workflow is useful when creating portfolio projects or preparing for machine learning interviews.

Why Real-World Use Cases Matter

Real-world datasets rarely look like clean textbook examples.

They can contain unexpected patterns, noisy observations, missing values, and other complications.

Working with realistic scenarios teaches an important skill:

How to adapt machine learning techniques to the problem instead of forcing every problem into the same workflow.

Who Should Read This Book?

This book can be useful for:

• Python developers
• Data science beginners
• Machine learning students
• Aspiring ML engineers
• Data analysts moving toward ML
• Students building ML portfolios
• Developers preparing for ML interviews

A basic understanding of Python and introductory machine learning concepts will make the material easier to follow.

Strengths

1. Practical Learning

The example-driven structure keeps the focus on implementation.

2. Real-World Perspective

Use cases help demonstrate how ML concepts translate into practical solutions.

3. Python-Based

Readers can develop machine learning skills using the Python ecosystem.

4. Best Practices

The focus extends beyond simply getting a model to run.

5. Portfolio Friendly

The project-oriented approach can help learners develop ideas for their own machine learning projects.

Hard Copy:Python Machine Learning By Example: Unlock machine learning best practices with real-world use cases (Free PDF)

Kindle: Python Machine Learning By Example: Unlock machine learning best practices with real-world use cases (Free PDF)

Download the PDF for free: https://github.com/PacktPublishin

Final Thoughts

Python Machine Learning by Example is aimed at learners who want to understand machine learning through practical implementation rather than studying algorithms in isolation.

Its biggest value lies in connecting Python programming, data preparation, machine learning algorithms, evaluation, and real-world problem solving into a single workflow.

For someone progressing from Python → Data Science → Machine Learning → AI, this type of hands-on resource can help turn theoretical knowledge into practical development skills.

Read More

🐍 Python Pattern Challenge — Day 33

 

🐍 Python Pattern Challenge — Day 33 | Star Heart Pattern

Welcome to Day 33 of the Python Pattern Challenge! 🚀

Today, we're practicing a beautiful star pattern that creates a heart-like shape using simple asterisks (*). This challenge is perfect for improving your understanding of loops, spacing, and pattern logic.

The goal is to print the exact arrangement shown below using Python.

🎯 Today's Challenge

Can you recreate this pattern using Python loops? 💻

💻 Python Solution

n = 6

for i in range(1, n + 1):
    for j in range(1, 2 * n + 1):
        if (i == 1 and j in (3, 4, 9, 10)) or \
           (i == 2 and j in (2, 3, 4, 9, 10, 11)) or \
           i >= 3:
            print("*", end=" ")
        else:
            print(" ", end=" ")
    print()

This example demonstrates how conditions can control where stars and spaces appear. You can experiment with the row and column conditions to refine the shape.

🧠 What You'll Learn

• Using for loops to print patterns

• Working with nested loops

• Applying if-else conditions

• Controlling spacing and alignment

• Building creative designs with Python

🚀 Challenge Yourself

• Make the heart bigger or smaller.

• Replace stars with # or other symbols.

• Create the pattern using a while loop.

• Take the pattern size as user input.

• Try printing a hollow heart.

Share your solution in the comments! 👇

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

Learn • Practice • Grow with CLCODING 💻

Read More