Summary of Top 10 SQL Commands

SELECT – Retrieve Data from a Table

SELECT * FROM Employees;
SELECT Name, Age FROM Employees WHERE Age > 30;

✅ Fetches data from a database table.

2️⃣ INSERT – Add New Records

INSERT INTO Employees (Name, Age, City) 
VALUES ('John Doe', 28, 'New York');

✅ Inserts new data into a table.

3️⃣ UPDATE – Modify Existing Records

UPDATE Employees 
SET Age = 29 
WHERE Name = 'John Doe';

✅ Updates existing data in a table.

4️⃣ DELETE – Remove Records

DELETE FROM Employees WHERE Age < 25;

✅ Removes specific records from a table.

5️⃣ CREATE TABLE – Define a New Table

CREATE TABLE Employees (
    ID INT PRIMARY KEY AUTO_INCREMENT,
    Name VARCHAR(100),
    Age INT,
    City VARCHAR(50)
);

✅ Creates a new table in the database.

6️⃣ ALTER TABLE – Modify an Existing Table

ALTER TABLE Employees ADD COLUMN Salary DECIMAL(10,2);

✅ Adds, removes, or modifies columns in an existing table.

7️⃣ DROP TABLE – Delete an Entire Table

DROP TABLE Employees;

✅ Completely removes a table from the database.

8️⃣ JOIN – Combine Data from Multiple Tables

SELECT Employees.Name, Departments.DepartmentName 
FROM Employees 
INNER JOIN Departments ON Employees.DepartmentID = Departments.ID;

✅ Retrieves data from multiple related tables.

9️⃣ GROUP BY & HAVING – Aggregate Data

SELECT City, COUNT(*) AS EmployeeCount 
FROM Employees 
GROUP BY City 
HAVING COUNT(*) > 5;

✅ Groups records and filters aggregates.

🔟 ORDER BY – Sort Query Results

SELECT * FROM Employees ORDER BY Age DESC;

✅ Sorts data in ascending or descending order.

1️⃣ Show All Databases

show dbs

✅ Lists all databases in the MongoDB server.

2️⃣ Use a Specific Database

use myDatabase

✅ Switches to a specific database (creates it if it doesn’t exist).

3️⃣ Show All Collections

show collections

✅ Lists all collections (tables) inside the current database.

4️⃣ Insert a Document

db.employees.insertOne({ name: "John Doe", age: 30, city: "New York" })

✅ Adds a new record into the employees collection.

5️⃣ Find (Retrieve) Documents

db.employees.find()
db.employees.find({ age: { $gt: 25 } })

✅ Fetches all documents or filters by conditions.

6️⃣ Update a Document

db.employees.updateOne({ name: "John Doe" }, { $set: { age: 31 } })

✅ Modifies specific fields in a document.

7️⃣ Delete a Document

db.employees.deleteOne({ name: "John Doe" })

✅ Removes a single document from the collection.

8️⃣ Create an Index (Improve Query Performance)

db.employees.createIndex({ name: 1 })

✅ Adds an index to speed up queries.

9️⃣ Aggregate (Group & Process Data)

db.employees.aggregate([
    { $group: { _id: "$city", total: { $sum: 1 } } }
])

✅ Groups documents and performs operations like sum, count, etc.

🔟 Drop a Collection (Delete a Table)

db.employees.drop()

✅ Removes the entire collection from the database.

1️⃣ Find Documents Greater Than a Specific Date ($gt)

👉 Get orders placed after 2024-02-05

db.orders.find({ orderDate: { $gt: ISODate("2024-02-05T00:00:00Z") } })

✅ Returns orders after 2024-02-05

2️⃣ Find Documents Less Than a Specific Date ($lt)

👉 Get orders placed before 2024-02-05

db.orders.find({ orderDate: { $lt: ISODate("2024-02-05T00:00:00Z") } })

✅ Returns orders before 2024-02-05

3️⃣ Find Documents Between Two Dates ($gte and $lte)

👉 Get orders placed between 2024-02-01 and 2024-02-10

db.orders.find({ 
    orderDate: { 
        $gte: ISODate("2024-02-01T00:00:00Z"), 
        $lte: ISODate("2024-02-10T23:59:59Z") 
    } 
})

✅ Returns orders within the specified date range

4️⃣ Find Documents on an Exact Date ($eq)

👉 Get orders placed exactly on 2024-02-05

db.orders.find({ orderDate: { $eq: ISODate("2024-02-05T00:00:00Z") } })

✅ Returns orders with the exact date

5️⃣ Find Orders Within the Last 7 Days ($gte and new Date())

db.orders.find({ 
    orderDate: { 
        $gte: new Date(new Date().setDate(new Date().getDate() - 7))
    } 
})

The post Daily used commands for a Developer first appeared on TheCodeBuzz.

Databricks is a powerful platform for big data analytics and machine learning that runs on Apache Spark. Here are some Best practices in Databricks to follow with use cases and examples.

To provide a comprehensive overview of best practices in Databricks, including use cases and examples, let’s delve into various aspects such as cluster management, performance optimization, security, collaboration, monitoring, cost management, machine learning practices, and documentation/training.

This approach will cover a wide range of scenarios and illustrate how Databricks can be effectively utilized in real-world applications.

1. Cluster Management

Cluster management in Databricks involves configuring and managing Apache Spark clusters to optimize performance and cost-efficiency based on workload requirements.

Best Practices:

• Cluster Sizing and Auto-scaling: Determine optimal cluster sizes based on workload characteristics. Use Databricks’ auto-scaling feature to automatically adjust the number of worker nodes based on workload demands. Example:
  Suppose a retail company needs to process sales data for quarterly reports. During peak times (e.g., end of quarter), the workload increases significantly. By setting up auto-scaling in Databricks, the cluster can dynamically add nodes to handle the increased data processing load. This ensures timely generation of reports without manual intervention.
• Idle Cluster Management: Terminate idle clusters to avoid unnecessary costs. Configure Databricks to automatically terminate clusters when they are not in use based on defined idle timeouts. Use Case:
  A financial services firm uses Databricks for periodic data analysis tasks that are scheduled to run daily. After each task completes, the cluster remains idle until the next scheduled task. By setting an idle timeout policy, the clusters automatically terminate during idle periods, reducing cloud infrastructure costs.

2. Performance Optimization

Optimizing performance in Databricks involves tuning Apache Spark configurations, optimizing data processing workflows, and leveraging Spark’s capabilities for efficient data handling.

Best Practices:

• Data Partitioning: Partition data appropriately based on access patterns and query requirements to optimize query performance and reduce data shuffling. Example:
  In a telecommunications company, customer call records are stored in a large dataset. By partitioning the data based on date and customer ID, queries that filter by date or specific customer IDs can be executed more efficiently, leveraging Spark’s partition pruning.
• Caching and Persistence: Cache frequently accessed datasets or intermediate results in memory or disk storage to speed up subsequent queries and computations. Use Case:
  An e-commerce platform uses Databricks for real-time analytics of customer behavior. The platform caches product catalog data in memory across Spark jobs to quickly retrieve and analyze product trends, improving responsiveness for dynamic pricing adjustments.
• Optimized Transformations: Use efficient Spark transformations (map, filter, join, etc.) to minimize data movement and optimize processing logic. Example:
  A healthcare provider analyzes patient data stored in a Databricks Delta table. By optimizing transformations and leveraging Delta’s capabilities for incremental updates (MERGE operation), the provider efficiently processes and updates patient records while ensuring data consistency.

3. Security

Ensuring robust security measures in Databricks involves managing access controls, securing data, and implementing encryption mechanisms to protect sensitive information.

Best Practices:

• Access Control: Define and enforce fine-grained access controls using Databricks workspace and cluster-level permissions to restrict access based on roles and responsibilities. Use Case:
  A government agency uses Databricks for analyzing sensitive healthcare data. Access to patient records and analysis notebooks is restricted based on user roles (e.g., data scientists, administrators) to ensure compliance with data privacy regulations (e.g., HIPAA).
• Data Encryption: Encrypt data at rest and in transit using Databricks’ built-in encryption features or cloud provider-managed encryption services (e.g., AWS KMS, Azure Key Vault). Example:
  A financial institution processes credit card transaction data in Databricks. Data at rest is encrypted using Azure Disk Encryption, and data in transit is secured using HTTPS encryption. This ensures that sensitive financial information is protected from unauthorized access.
• Secrets Management: Store and manage sensitive information (e.g., API keys, database credentials) securely using Databricks secrets to avoid hard-coding credentials in notebooks or scripts. Use Case:
  A retail company integrates Databricks with external APIs for inventory management. API keys and credentials are stored as secrets in Databricks, ensuring secure access without exposing sensitive information in notebook code.

4. Collaboration and Development

Facilitating collaboration and streamlining development workflows in Databricks involves version control, code reusability, and automation of data pipelines.

Best Practices:

• Notebook Versioning: Use version control (e.g., Git integration with Databricks) to manage and track changes in notebooks, facilitating collaboration among data teams. Example:
  A media streaming company uses Databricks notebooks for analyzing viewer engagement data. Data scientists collaborate on notebook development and analysis scripts using Git integration in Databricks, enabling version history tracking and code reviews.
• Shared Libraries: Create and manage reusable code libraries and dependencies using Databricks Libraries to share common functions across notebooks and clusters. Use Case:
  An insurance company develops machine learning models in Databricks for fraud detection. Common feature engineering functions and model evaluation metrics are packaged as a Databricks Library, ensuring consistent data preprocessing and model evaluation across multiple notebooks.
• Jobs and Automation: Schedule jobs in Databricks to automate data processing workflows and analytics tasks at specified intervals or in response to triggers. Example:
  A transportation logistics firm uses Databricks to process real-time sensor data from delivery vehicles. Jobs are scheduled to run hourly, processing sensor data to optimize delivery routes and monitor vehicle performance automatically.

5. Monitoring and Logging

Monitoring cluster performance, application logs, and setting up alerts in Databricks ensures proactive management and troubleshooting of issues.

Best Practices:

• Cluster Monitoring: Monitor cluster metrics (e.g., CPU utilization, memory usage, disk I/O) using Databricks workspace or external monitoring tools to optimize resource allocation. Use Case:
  A technology startup analyzes user behavior data in Databricks for personalized recommendations. Monitoring cluster performance metrics helps identify bottlenecks in data processing pipelines and scale resources accordingly during peak usage periods.
• Application Logging: Enable logging in Databricks notebooks and applications to capture runtime errors, warnings, and informational messages for troubleshooting and performance tuning. Example:
  A cybersecurity firm uses Databricks for analyzing network traffic logs. Logging in Databricks notebooks captures query execution times and data processing errors, enabling data engineers to diagnose and optimize query performance for anomaly detection algorithms.
• Alerting and Notifications: Set up alerts and notifications for critical metrics (e.g., job failures, resource constraints) using Databricks’ built-in alerting capabilities or integration with external monitoring systems. Use Case:
  An e-commerce platform uses Databricks for real-time sales analytics. Alerts are configured to notify data analysts via email or Slack when sales data processing jobs fail or encounter data quality issues, ensuring timely resolution and continuity of analytics operations.

6. Cost Management

Managing costs effectively in Databricks involves optimizing cluster usage, monitoring resource consumption, and leveraging cost-saving strategies.

Best Practices:

• Cost Awareness: Monitor and analyze Databricks usage and associated costs using cost management tools or Databricks workspace insights. Example:
  A fintech startup uses Databricks for analyzing financial market data. Cost reports in Databricks workspace provide visibility into cluster usage patterns and help identify opportunities for optimizing resource allocation and reducing cloud infrastructure costs.
• Cluster Lifecycles: Implement automated policies for starting, terminating, and resizing clusters based on workload demand and scheduling requirements. Use Case:
  A healthcare analytics company processes electronic health records (EHR) data in Databricks. Clusters are automatically provisioned and resized based on scheduled data processing jobs, ensuring compute resources are available only when needed and minimizing idle time.

7. Machine Learning Practices

Applying best practices for machine learning in Databricks involves managing experiments, deploying models, and ensuring scalability and reproducibility of machine learning workflows.

Best Practices:

• Experiment Tracking: Use MLflow integration in Databricks for tracking and managing machine learning experiments, including parameters, metrics, and model artifacts. Example:
  A retail analytics firm trains and evaluates customer segmentation models in Databricks. MLflow experiment tracking captures model training configurations and performance metrics, facilitating model selection and comparison for targeted marketing campaigns.
• Model Deployment: Deploy machine learning models trained in Databricks using MLflow or integration with cloud-based model deployment services (e.g., Azure Machine Learning, AWS SageMaker). Use Case:
  An insurance company develops predictive models for claim fraud detection in Databricks. MLflow model registry facilitates model deployment to production environments, ensuring consistent model versioning and deployment pipelines across development, staging, and production stages.
• Scalability and Performance: Design machine learning workflows in Databricks to handle large-scale datasets and optimize model training and inference performance using distributed computing capabilities of Apache Spark. Example:
  A manufacturing company uses Databricks for predictive maintenance of production equipment. Distributed training of machine learning models on historical sensor data scales seamlessly across Spark clusters, enabling timely detection of equipment failures and reducing downtime.

8. Documentation and Training

Maintaining comprehensive documentation and providing training resources in Databricks ensures knowledge sharing and effective use of platform capabilities across teams.

Best Practices:

• Documentation: Document Databricks notebooks, workflows, and cluster configurations to provide context and facilitate understanding for new team members and collaborators. Use Case:
  A media company uses Databricks for analyzing viewer engagement metrics. Documentation in Databricks notebooks includes detailed explanations of data pipelines, data transformations, and analytical models, enabling data scientists to replicate and build upon existing analyses.
• Training and Onboarding: Provide training sessions, workshops, and knowledge base articles to onboard new users and teams to Databricks platform functionalities and best practices. Example:
  A healthcare research institute adopts Databricks for genomic data analysis. Training sessions cover Databricks fundamentals, Spark programming, and best practices for managing and analyzing large-scale genomic datasets, empowering researchers to leverage Databricks effectively for scientific discovery.

By following these best practices in Databricks, organizations can optimize data processing workflows, enhance collaboration among data teams, ensure robust security and compliance, and effectively manage costs while leveraging the scalability and performance capabilities of Apache Spark for data analytics and machine learning applications.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Best practices in Databricks Apache spark – Use case and example first appeared on TheCodeBuzz.

To access two huge zip files from Azure Storage and process only the differences with Python, you can follow these general steps.

Before we start creating the logic, let’s look at whether the prerequisites are set correctly.

Create a Databricks cluster with the necessary configurations and libraries installed, including any required Python packages for processing the zip files and computing differences.

Additionally, You can mount the Azure Blob Storage container to the Databricks file system or use Azure Storage SDKs directly within Databricks notebooks.

Here’s a simplified example code snippet to illustrate how you can perform these steps within a Databricks notebook,

Add using import namespaces

import zipfile

from io import BytesIO

from azure.storage.blob import BlobServiceClient

Define your Azure Blob Storage connection string and container names

connection_string = "your_connection_string"
container_name1 = "container_name1"
container_name2 = "container_name2"
blob_name1 = "largefile1.zip"
blob_name2 = "largefile2.zip"

Create a blob service client

blob_service_client = BlobServiceClient.from_connection_string(connection_string)

Get blob clients for the two files

<pre class="wp-block-syntaxhighlighter-code"># Get blob clients for the first files
blob_client1 = blob_service_client.get_blob_client(container=container_name1, blob=blob_name1)


 # Get <a href="https://www.thecodebuzz.com/read-huge-big-azure-blob-storage-file-best-practices/">blob clients for the second files</a>
blob_client2 = blob_service_client.get_blob_client(container=container_name2, blob=blob_name2)

</pre>

Get the contents of the two zip files

#Read the contents of the first file 

file_contents1 = read_file_from_blob(blob_client1)


#Read the contents of the second file 

file_contents2 = read_file_from_blob(blob_client2)

Read the contents of a zip file from Azure Blob Storage method read_file_from_blob() is defined as below

Get the Differences between the 2 files

The below code example computes the symmetric difference between the contents of the two files to identify the differing files.

differences = set(file_contents1).symmetric_difference(set(file_contents2))

If needed, one can add custom processing logic within the loop to further analyze or process the differing files.

Process the differences in the file

The next step is to process the differences,

 # Process the differences
    for file_name in differences:
        # Example: Print the file name
        print("Difference found:", file_name)

        # Further processing logic can be added here

except Exception as ex:
    print("An error occurred:", ex)

That’s all! Happy coding!

Does this help you fix your issue?

Do you have any better solutions or suggestions? Please sound off your comments below.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Python Azure storage Read and Compare file content first appeared on TheCodeBuzz.

Today in this article, we will see how to use Python Databricks Dataframe Nested Arrays in Pyspark. We will see details on Handling nested Arrays in Pyspark.

Towards the end of this article, we will also cover, when working with PySpark DataFrame transformations and handling arrays, there are several best practices to keep in mind to ensure efficient and effective data processing.

I have below sample JSON which contains a mix of array fields and objects as below,

[
  {
    "name": "Alice",
    "date_field": "2022-03-30",
    "area": {

      "city": {
        "city_code": "asdas",
        "date_field": "2022-03-30"
      },
      "projects": [
        {
          "area_code": "sdas",
          "date_field": "2022-03-30"
        }
      ]
    }
  }
]

PySpark DataFrame transformations

PySpark DataFrame transformations involve operations used to manipulate data within DataFrames.

There are various ways and common use cases where this transformations can be applied.

1. Filtering Data: Use the filter() or where() functions
2. Selecting Columns: Use the select() function to choose specific columns from the DataFrame. This is useful when you only need certain columns for further processing or analysis.
3. Grouping and Aggregating: Use functions like groupBy() and agg() to group data based on one or more columns and perform aggregations such as sum, count, average, etc.
4. Joining DataFrames: Use the join() function to combine two DataFrames based on a common key.
5. Sorting Data: Use the orderBy() or sort() functions to sort the DataFrame based on one or more columns. =
6. Adding or Removing Columns: Use functions like withColumn() and drop() to add new columns to the DataFrame or remove existing columns, respectively.
7. String Manipulation: Use functions like substring(), trim(), lower(), upper(), etc., to perform string operations on DataFrame columns.
8. Date and Time Manipulation: Use functions like to_date(), year(), month(), dayofmonth(), etc., from the pyspark.sql.functions module to work with date and time columns.

If you have basic data source and need to transform few fields like performing the Date and time manipulation, one can try below steps to achieve the transformation.

Define StructType schema in PySpark

# Define the schema
schema = StructType([
    StructField("name", StringType(), True),
    StructField("date_field", StringType(), True),
    StructField("area_code", StructType([
        StructField("city", StructType([
            StructField("city_code", StringType(), True),
            StructField("date_field", StringType(), True)
        ]), True),
        StructField("projects", ArrayType(StructType([
            StructField("area_code", StringType(), True),
            StructField("date_field", StringType(), True)
        ])), True)
    ]))
])

Modify date field datatype in DataFrame schema

Updated schema type as below for date field where , we will be converting string type timestamp type

StructField("date_field", TimestampType(), True)

# Define the schema
schema = StructType([
    StructField("name", StringType(), True),
    StructField("date_field", TimestampType(), True),
    StructField("area", StructType([
        StructField("city", StructType([
            StructField("SpecCode", StringType(), True),
            StructField("date_field", TimestampType(), True)
        ]), True),
        StructField("projects", ArrayType(StructType([
            StructField("code", StringType(), True),
            StructField("date_field", TimestampType(), True)
        ])), True)
    ]))
])

Convert JSON list to JSO string with indentation

# Convert the JSON list to a JSON string with indentation


json_string = json.dumps(json_list, indent=2)

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType, StructField, StringType, ArrayType, DateType
from pyspark.sql.functions import col, explode, to_date

# Initialize SparkSession
spark = SparkSession.builder \
    .appName("Transform JSON Data") \
    .getOrCreate()


# Convert the JSON list to a JSON string with indentation
json_string = json.dumps(json_list, indent=2)

# Create DataFrame from JSON data with defined schema
df = spark.read.schema(schema).json(spark.sparkContext.parallezie(Json_string))


# Write DataFrame to destination
df.write.format("destination").mode("append").save()



# Stop SparkSession
spark.stop()

Above is a generic implementation and can be used to push the data to any destination as required including MongoDB, SQL etc.

Approach 2- Explode nested array in DataFrame

One can also use the data frame explode method to convert a string field to the date field as explained in the below example.

 #Apply transformations to nested fields

df_transformed = df \
    .withColumn("date_field", to_date(col("date_field"))) \
    .withColumn("area.city.date_field", convert_to_date("area.city.date_field")) \
    .withColumn("area.projects", explode(col("area.projects"))) \
    .withColumn("area.projects.date_field", convert_to_date("area.projects.date_field"))

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Python Databricks Dataframe Nested Arrays in Pyspark- Guidelines first appeared on TheCodeBuzz.

Converting JSON to a string (as JSON serialization) is often necessary in various scenarios, such as data serialization, handling HTTP requests and responses, etc purposes.

JSON-to-string conversion or JSON-to-string Serialization is often needed for various needs.

We will dive into various reasons required for this conversion.

• Data Serialization:
  • Nee to transmit data over a network or store it in a file, you often need to convert it to a string format for transmission or storage. JSON strings are a common choice for data serialization due to their lightweight and human-readable nature.

• Interoperability:
  • JSON strings are a universal format for data exchange between different systems and programming languages. Converting JSON objects to strings allows them to be easily transmitted and interpreted by systems that may not directly support JSON objects.

• API Requests and Responses:
  • When interacting with web APIs, data is often sent and received in JSON format. Serializing JSON objects to strings allows you to include them in HTTP requests or responses, facilitating communication between clients and servers.

• Caching and Persistence:
  • In caching systems or persistent storage mechanisms like databases, JSON strings may be stored as text fields. Serializing JSON objects to strings allows them to be stored and retrieved efficiently.

• Configuration Files:
  • JSON strings are commonly used for configuration files in software applications. Converting JSON objects to strings allows them to be written to and read from configuration files easily.

• Logging and Debugging:
  • When logging data or debugging applications, JSON strings provide a structured and readable format for representing complex data structures. Converting JSON objects to strings allows them to be logged or displayed in a human-readable format.

Converting JSON to a JSON string (serialization) is often necessary in various scenarios, such as:

What is JSON Object

Example

{
        "name": "Alice",
        "date_field": "2022-03-30",
        "demo": {
            "projects": [
                {"code": "sdas", "date_field": "2022-03-30"}
            ]
        }
    }

• This is a standard representation of a list containing JSON objects.
• Each element in the list is a separate JSON object.
• This format is commonly used when dealing with structured data, such as when storing records in databases or transmitting data over networks.
• It allows easy access to individual objects in the list and facilitates operations such as filtering, mapping, and aggregation.

Example Use Cases – Convert JSON object to string :

• Sending JSON data as part of HTTP requests in RESTful APIs.
• Storing JSON data in NoSQL databases like MongoDB or document-oriented databases.
• Caching JSON responses from external APIs or database queries.
• Writing JSON data to configuration files for application settings.
• Logging JSON data for debugging purposes in applications.

JSON as Strings – Significance

{
        "name": "Alice",
        "date_field": "2022-03-30",
        "demo": {
            "projects": [
                {"code": "sdas", "date_field": "2022-03-30"}
            ]
        }
    }

• This is a representation where each element is a JSON string.
• The JSON strings themselves represent JSON objects.
• This format is useful when you need to serialize a list of JSON objects into a single string, such as when storing the data in a file or transmitting it over a communication channel.
• It preserves the structure of individual JSON objects allowing you to reconstruct the original objects when needed.
• However, operations such as filtering or accessing individual objects become more cumbersome since you need to parse each JSON string to work with the underlying JSON objects.
• his is a list of JSON strings where each string represents a JSON object. The string representation includes newline characters (\n) and indentation (\t) for readability. Each string is enclosed in quotes and can be interpreted as a JSON object when parsed. This format is suitable for scenarios where you need to store JSON data as text, for example, when writing to a file or transmitting over a network.

Example – JSON to raw JSON string

['{\n  "name": "Alice",\n  "date_field": "2022-03-30",\n  "demo": {\n    "projects": [\n      {\n        "code": "sdas",\n        "date_field": "2022-03-30"\n      }\n    ]\n  }\n}']

Python Example – How to Convert JSON to JSON string

import json

json_data = [
    {
        "name": "Alice",
        "date_field": "2022-03-30",
        "demo": {
            "projects": [
                {"code": "sdas", "date_field": "2022-03-30"}
            ]
        }
    }
]

# Convert each dictionary in json_data to a JSON string
json_strings = [json.dumps(item, indent=2) for item in json_data]

# Print the list of JSON strings
print(json_strings)

ASP.NET Core Example – How to Convert JSON to JSON string

• How to return Raw JSON string from API Controller

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

The post Convert JSON object to string – Guidelines first appeared on TheCodeBuzz.