For a Python dict to JSON conversion, use json.dumps() when you need JSON text in memory. Use json.dump() when you need to write the dictionary directly to a file. Both functions serialize Python data, but they produce different outputs.

To convert a dict to JSON in Python, import the standard-library json module and pass your dictionary to the appropriate function. JSON uses double-quoted strings and standardized values, so str() or repr() is not a substitute for serialization.

Python dict to JSON with json.dumps(): Get JSON Text

json.dumps() returns a JSON-formatted Python string. It does not create a file or modify the original dictionary.

import json
data = {“name”: “Ada”, “active”: True, “roles”: [“admin”, “editor”]}
json_text = json.dumps(data)

The value of json_text is a string such as {“name”: “Ada”, “active”: true, “roles”: [“admin”, “editor”]}. Notice that Python’s True becomes JSON’s true. Use this approach when sending a payload through an API, storing serialized text in a database, or passing JSON to another component.

For readable output, add formatting options directly to the call:

json_text = json.dumps(data, indent=2)

The return type remains str, whether the output is compact or indented.

Write a dict to a JSON file with json.dump() using UTF-8 encoding

json.dump() writes JSON to an open, file-like object and returns None. Open the file with write mode and explicit UTF-8 encoding:

with open(“data.json”, “w”, encoding=”utf-8″) as file:
    json.dump(data, file, indent=2, ensure_ascii=False)

This creates or replaces data.json. The file contains JSON, while data remains a Python dictionary in memory. The with statement closes the file even if an error occurs. Unlike json.dumps(), json.dump() does not return the serialized document as a string.

Use encoding=”utf-8″ for predictable handling of names, labels, and other non-ASCII characters. The encoding controls how Python writes characters to the file; it is separate from JSON’s formatting options.

Format dict to JSON in Python with indent, Unicode, and sorted keys

• indent=2 adds two spaces per nesting level. Use indent=4 for more spacing, or omit it for compact output.
• ensure_ascii=False keeps characters such as é and 東京 readable. The default, True, escapes them with Unicode sequences such as \u00e9.
• sort_keys=True writes object keys in alphabetical order. This makes generated files easier to compare and produces stable output for tests.

For a consistently formatted JSON string, combine the options: json.dumps(data, indent=2, ensure_ascii=False, sort_keys=True). Key ordering affects presentation, not the meaning of a JSON object.

Convert a Python dict to JSON with supported types and a default handler

The built-in encoder supports dictionaries, lists, tuples, strings, integers, floating-point numbers, booleans, and None. These become JSON objects, arrays, strings, numbers, true, false, and null. JSON object keys should be strings; Python also accepts some simple non-string keys and converts them to strings.

Values such as sets, bytes, dates, decimals, and most custom objects are not serializable by default. The encoder raises TypeError when it encounters one. Supply a default function that converts a known type into a JSON-supported value:

from datetime import date, datetime
def encode_value(value):
    if isinstance(value, (date, datetime)):
        return value.isoformat()
    raise TypeError(f”Unsupported type: {type(value).__name__}”)

Then pass it to either serializer: json.dumps(data, default=encode_value) or json.dump(data, file, default=encode_value). This strategy stores dates as ISO 8601 strings and fails clearly for types you have not deliberately mapped.

To learn how to print variables in Python, start with the built-in print() function. It displays a value in your program’s output, adds a newline by default, and can show strings, numbers, lists, and other objects.

The basic way to print a variable in Python is to pass its name to print(). Python evaluates the variable and displays its current value.

How do you print a variable in Python?

Assign a value to a variable, then provide that variable as the argument to print():

name = ‘Mina’; print(name)

Output: Mina

This works with numeric values as well:

age = 29; print(age)

Output: 29

When the variable contains a string, print() displays the characters without quotation marks. For numbers, it displays the numeric value directly. You do not need to convert either value before passing it to print().

How do you print labels and several values?

Pass several arguments to print(), separated by commas. Python converts each value for display and places a space between arguments by default:

name = ‘Mina’; age = 29; print(‘Name:’, name, ‘Age:’, age)

Output: Name: Mina Age: 29

This approach is useful for quick status messages because it safely displays text and non-string values together. It also avoids trying to combine text and numbers with an incompatible string operation.

Use the sep parameter to replace the default space between arguments:

print(‘2025′, ’03’, ’08’, sep=’-‘)

Output: 2025-03-08

The end parameter controls what follows the printed value. Its default is a newline. Set it to another string when output should continue on the same line:

print(‘Loading’, end=’…’); print(‘done’)

Output: Loading…done

How does printing variables in Python work with f-strings?

F-strings place variable values inside a text template. Add the letter f before the opening quote, then put each variable or expression inside braces:

name = ‘Mina’; score = 94; print(f'{name} scored {score} points.’)

Output: Mina scored 94 points.

F-strings are usually the clearest choice when a message contains labels and several values. They also support conversion and formatting specifiers. Add a colon inside the braces to format a number:

price = 19.5; print(f’Price: ${price:.2f}’)

Output: Price: $19.50

Here, :.2f displays a floating-point number with two digits after the decimal point. Use a comma to group large numbers:

total = 1234567; print(f'{total:,}’)

Output: 1,234,567

Expressions can also appear inside an f-string:

items = 3; price = 4.5; print(f’Total: ${items * price:.2f}’)

Output: Total: $13.50

How do str and repr help when debugging?

For ordinary output, print() uses a value’s human-readable string form, called str. This keeps displayed text easy to read. The repr form is designed for debugging and aims to reveal the value more precisely.

The difference is especially visible with strings containing escape characters:

message = ‘A\nB’; print(message)

This displays A and B on separate lines. By contrast:

print(repr(message))

Output: ‘A\nB’

The repr() result shows quotation marks and the literal escape sequence, making hidden characters easier to identify. It is also useful for distinguishing a string from a number or spotting extra spaces.

Use the !r conversion inside an f-string when you need that debug-friendly representation:

print(f’message={message!r}’)

Output: message=’A\nB’

Use !s when you explicitly want the normal string form. For routine messages, use standard interpolation or comma-separated arguments; reserve repr() and !r for inspecting values and diagnosing unexpected output.

In Python, __init__.py is the package’s initialization module. A directory containing it is recognized as a regular package, and the file can be empty. If you are asking what is __init__.py, it is the place where a package can define setup code, metadata, and convenient package-level names.

What does __init__.py do? Python runs its top-level code when the package is imported. It also lets a package expose a smaller, clearer public API instead of making users import every name from an internal module.

How Python __init__.py Defines Package Behavior

A regular package is a directory that normally contains __init__.py. The file tells Python to treat that directory as one package and gives the package a module body that can configure its behavior. It is unrelated to a class’s __init__ method, which initializes an object instance.

For example, this small package tree contains a pricing module and a nested web package:

• shop/
  • __init__.py
  • pricing.py
  • web/
    • __init__.py
    • routes.py

With this structure, users can write import shop, from shop import pricing, or from shop.web.routes import home, assuming the corresponding names exist. An empty initializer is enough when the package only needs this structure and does not need package-level setup.

What Is __init__.py? Package Discovery and Import Timing

When Python evaluates import shop.web.routes, it loads shop/__init__.py first, then shop/web/__init__.py, and finally routes.py. Each module’s top-level statements execute as that module is loaded. Python normally caches the resulting modules in sys.modules, so a second import in the same process does not repeat ordinary initialization.

This timing makes imports inside an initializer useful for setup and composition. For example, shop/__init__.py might contain from .pricing import TaxRule. Importing shop then loads pricing.py and binds TaxRule on the package object. Code elsewhere can use from shop import TaxRule without knowing where the class is implemented.

Initialization code also runs when a user imports a submodule, because Python must initialize each parent package first. An exception raised in __init__.py causes the package import to fail. Importing the package alone does not automatically execute every other module in its directory; those modules run only when imported directly or by the initializer.

What Does __init__.py Do for Re-Exports and __all__?

A re-export imports a name from an internal module and makes it available through the package’s top-level namespace. A concise initializer might contain:

from .pricing import TaxRule
from .pricing import calculate_total

Users can then write from shop import TaxRule, calculate_total. This creates a stable public entry point even if the implementation later moves from pricing.py to another module. Re-export only names that belong to the supported API; importing too much can increase startup time and create circular-import problems.

The special variable __all__ declares names for wildcard imports such as from shop import *. For the example above, an initializer could define __all__ = [“TaxRule”, “calculate_total”]. The listed names should be available in the package namespace, usually through imports in the same file.

__all__ does not prevent explicit imports and is not a security boundary. It documents the intended wildcard surface and controls which names that form imports. An initializer can also define metadata such as __version__, package-level constants, or a small configuration value.

When Is an Empty __init__.py Enough?

Leave the file empty when the package needs only a regular package boundary and direct submodule imports. This choice avoids unnecessary work during every package import and reduces the risk of circular imports or surprising side effects. Add code only when package-level re-exports, metadata, registration, or lightweight setup provides a clear benefit.

Not every Python package needs an __init__.py file. Since Python 3.3, namespace packages can be formed from directories without an initializer. Their portions can be distributed across multiple directories or installed distributions and combined under one package name. Because there is no initializer, there is also no package-specific file in which to run initialization code or define re-exports.

Use a regular package when you want explicit initialization and a controlled top-level API. Use an empty initializer when that boundary is useful but no setup is needed. Avoid network calls, expensive I/O, and unrelated application work in __init__.py; imports should remain predictable and lightweight.

Python loads a local file as a module when its directory is available on Python’s module search path. To load a local module, use its filename without the .py extension. A Python import of another Python file works the same way whether the file contains functions, classes, or constants.

The simplest setup keeps both files in one directory, then expands to packages when the project grows.

Import Python file from the same directory

Suppose a directory contains main.py and helpers.py. The module name is helpers, not helpers.py.

• helpers.py: GREETING = “Hello” and def greet(name): return f”{GREETING}, {name}”.
• main.py: import helpers, from helpers import greet, print(helpers.GREETING), and greet(“Mina”).

The statement import helpers imports the module and keeps its names under the helpers namespace. Use helpers.GREETING or helpers.greet() to access them. The statement from helpers import greet binds only greet in main.py, so you can call greet() directly.

Do not include the .py extension, and avoid filenames containing spaces, hyphens, or names that conflict with standard-library modules.

How to import another Python file selectively

Use from module import name when you need specific functions, classes, or constants:

• from helpers import greet, GREETING imports two names.
• from helpers import greet as say_hello assigns an alias.
• import helpers as h shortens the module reference while retaining its namespace.

Selective imports make calls shorter, but they can make the source of a name less obvious. Use the module form when a file exposes many similarly named objects or when clarity matters. Python executes a module’s top-level code during its first import, then normally reuses the loaded module.

Import another Python file from a package

A package is a directory containing related modules. A predictable structure might look like this:

• app/__init__.py
• app/main.py
• app/tools/__init__.py
• app/tools/formatters.py

Inside app/main.py, an absolute import can be from app.tools.formatters import clean. A package-relative import can be from .tools.formatters import clean. The leading dot means “from this package”; two dots refer to the parent package, as in from ..shared import settings.

The parent directory of app must be on the search path for the absolute form to work. An __init__.py file makes package boundaries explicit and supports consistent behavior across tools, even though modern Python also supports namespace packages without one.

Fix module search paths, entry points, and circular imports

Python searches sys.path, which commonly includes the directory containing the launched script, the current directory for interactive or module execution, configured PYTHONPATH entries, the standard library, and installed packages. A ModuleNotFoundError usually means the module’s directory or the package’s parent is missing from that list.

1. Run a package module from the project’s parent directory: python -m app.main. This gives relative imports the package context they require.
2. Use if __name__ == “__main__”: to separate reusable definitions from script-only behavior. Put startup code in a main() function, then call it beneath the guard. Importing the file will define its functions without launching the script.
3. Check spelling, capitalization, package names, and the directory from which the command runs. Also check that a local file is not shadowing a standard-library or installed module.

Running python app/main.py directly can break a relative import because Python treats the file as a standalone script rather than as part of app. Prefer python -m app.main or configure the project as an installed package. Arbitrary sys.path mutation may hide the underlying structure problem and should not be the default fix.

Circular imports occur when a.py imports b.py while b.py imports a.py. Typical symptoms include “cannot import name,” a “partially initialized module” message, or missing attributes during startup. Move shared functions or constants into a third module, make imports flow in one direction, or defer a genuinely optional import inside a function.

Python drawing is straightforward with the standard turtle module. This example uses Python turtle graphics to draw a blue square, move without leaving a line, and add a centered label.

The complete example also shows how to draw in Python with movement, turns, pen controls, a loop, coordinates, color, line width, and turtle.write.

Python Drawing: Create a Turtle Screen and Pen

Import the built-in module first. Then create a screen and a turtle object that acts as your drawing pen:

import turtle
screen = turtle.Screen()
pen = turtle.Turtle()

screen is the drawing window, while pen stores the turtle’s position, direction, color, and pen state. A new turtle starts at coordinate (0, 0), usually facing right. The screen uses ordinary x and y coordinates: positive x moves right, and positive y moves up.

Use Python turtle commands to Move, Turn, and Repeat a Shape

The main Python turtle commands control distance and direction. pen.forward(120) moves 120 pixels in the current direction and draws a line. pen.backward(40) moves backward while drawing. pen.left(90) and pen.right(90) turn the turtle by 90 degrees without moving it.

A square needs four equal sides and four 90-degree turns. A for loop repeats those two actions:

for _ in range(4):
    pen.forward(120)
    pen.left(90)

The underscore means that the loop count itself is not needed. Each repetition draws one side and turns the turtle for the next side. When the loop ends, the turtle returns to its starting coordinate and direction.

How to draw in Python: Control Position, Color, Width, and Pen State

Use pen.penup() to move without drawing and pen.pendown() to resume drawing. This prevents an unwanted line when moving from the completed square to its label.

pen.goto(60, 60) moves directly to a specific coordinate. With the pen raised, it creates no line. Use pen.color(“royalblue”) to set the drawing color and pen.width(3) to make the outline three pixels wide. Call these methods before the action they should affect.

For example, set the square’s color and width before the loop, then raise the pen before using goto(). If a diagonal line appears between the square and the label, penup() was omitted or called too late.

Add a Label with turtle.write and Keep the Window Open

Run these lines in order. The two indented lines belong inside the loop:

1. import turtle
2. screen = turtle.Screen()
3. pen = turtle.Turtle()
4. pen.shape(“turtle”)
5. pen.color(“royalblue”)
6. pen.width(3)
7. for _ in range(4):
   • pen.forward(120)
   • pen.left(90)
8. pen.penup()
9. pen.goto(60, 60)
10. pen.pendown()
11. pen.color(“darkgreen”)
12. turtle.write(“Square”, align=”center”, font=(“Arial”, 16, “bold”))
13. screen.mainloop()

turtle.write() places text at the turtle’s current position. Here, align=”center” centers “Square” at coordinate (60, 60), while the font setting specifies the typeface, size, and bold style. The module-level function writes at the active turtle’s position; pen.write() is the equivalent object-based form.

screen.mainloop() keeps the turtle window open after the drawing finishes. The finished result is a 120-by-120 blue square with a green label centered inside it.