Python: Create File

# The 'w' mode creates a new file or overwrites an existing one

# 1. Create a new file with content
with open("new_file.txt", "w") as file:
    file.write("This is a brand new file!\n")
    file.write("Created using 'w' mode.\n")
    file.write("It's ready for use.")

print("File created successfully!")

# 2. Overwrite an existing file
# If the file already exists, 'w' mode will replace it completely
with open("existing_file.txt", "w") as file:
    file.write("This replaces all previous content!\n")
    file.write("The old content is gone forever.")

# 3. Create multiple files at once
file_names = ["report1.txt", "report2.txt", "report3.txt"]
for name in file_names:
    with open(name, "w") as file:
        file.write(f"Report: {name}\n")
        file.write("Generated automatically.\n")
    print(f"Created: {name}")

# 4. Creating files with dynamic content
def create_config_file(filename, config_data):
    """Create a configuration file from dictionary"""
    with open(filename, "w") as file:
        for key, value in config_data.items():
            file.write(f"{key} = {value}\n")

config = {
    "host": "localhost",
    "port": "8080",
    "debug": "True",
    "timeout": "30"
}
create_config_file("app_config.txt", config)

# 5. Writing multiple lines at once
lines = [
    "Line 1: Welcome\n",
    "Line 2: This is a test\n",
    "Line 3: Python file handling\n",
    "Line 4: Created with 'w' mode\n"
]
with open("multi_line.txt", "w") as file:
    file.writelines(lines)

# 6. Creating files with user input
name = input("Enter file name: ")
content = input("Enter file content: ")
with open(name, "w") as file:
    file.write(content)
print(f"File '{name}' created!")

# The 'x' mode creates a new file, but fails if it already exists
# This is the safest way to create new files

# 1. Creating a new file with 'x' mode
try:
    with open("exclusive_file.txt", "x") as file:
        file.write("This file was created with 'x' mode!\n")
        file.write("It's exclusive to this creation.")
    print("File created successfully!")
except FileExistsError:
    print("File already exists! Cannot create.")

# 2. Demonstrating the safety of 'x' mode
# First creation - succeeds
try:
    with open("safe_create.txt", "x") as file:
        file.write("This file was created safely.")
    print("✅ First creation: Success")
except FileExistsError:
    print("❌ First creation: Failed")

# Second creation - fails
try:
    with open("safe_create.txt", "x") as file:
        file.write("This will fail because the file exists.")
    print("✅ Second creation: Success")
except FileExistsError:
    print("❌ Second creation: Failed - File exists!")

# 3. Checking before creation
import os

def create_file_safely(filename):
    """Create a file only if it doesn't exist"""
    if os.path.exists(filename):
        print(f"File '{filename}' already exists. Not creating.")
        return False
    
    try:
        with open(filename, "x") as file:
            file.write("File created safely!\n")
            file.write(f"Created at: {__import__('datetime').datetime.now()}")
        print(f"✅ File '{filename}' created successfully!")
        return True
    except Exception as e:
        print(f"Error creating file: {e}")
        return False

# Usage
create_file_safely("my_data.txt")
create_file_safely("my_data.txt")  # This will fail

# 4. Using 'x' with additional data
def create_report(filename, data):
    """Create a report file exclusively"""
    try:
        with open(filename, "x") as file:
            file.write("=" * 50 + "\n")
            file.write("REPORT\n")
            file.write("=" * 50 + "\n\n")
            for key, value in data.items():
                file.write(f"{key}: {value}\n")
            file.write("\n" + "=" * 50 + "\n")
        return True
    except FileExistsError:
        return False

report_data = {
    "Date": "2026-08-02",
    "User": "Alice",
    "Status": "Completed",
    "Items": "5 processed"
}
if create_report("report.txt", report_data):
    print("Report created successfully!")
else:
    print("Report already exists!")

# The 'a' mode creates a file if it doesn't exist, or appends if it does

# 1. Creating a file with 'a' mode (when it doesn't exist)
with open("append_created.txt", "a") as file:
    file.write("This file was created with 'a' mode.\n")
    file.write("It's ready for appending.\n")
print("File created with append mode!")

# 2. Appending to an existing file
with open("append_created.txt", "a") as file:
    file.write("This is appended content.\n")
    file.write("It goes at the end.\n")
print("Content appended!")

# 3. Creating a log file with timestamps
import datetime

def log_message(message, log_file="log.txt"):
    """Append a timestamped message to the log file"""
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    with open(log_file, "a") as file:
        file.write(f"[{timestamp}] {message}\n")

log_message("Application started")
log_message("User logged in: Alice")
log_message("Data processing completed")
log_message("Application shut down")

print("Log entries created in log.txt")

# 4. Creating multiple files with 'a' mode
def create_csv_header(filename, headers):
    """Create a CSV file with headers"""
    with open(filename, "a") as file:
        file.write(",".join(headers) + "\n")
    print(f"CSV file '{filename}' created with headers.")

create_csv_header("data.csv", ["Name", "Age", "City"])

# 5. Appending data to CSV
def append_csv_row(filename, row_data):
    """Append a row to a CSV file"""
    with open(filename, "a") as file:
        file.write(",".join(str(item) for item in row_data) + "\n")

append_csv_row("data.csv", ["Alice", "25", "NYC"])
append_csv_row("data.csv", ["Bob", "30", "LA"])
append_csv_row("data.csv", ["Charlie", "35", "Chicago"])

print("Data appended to data.csv")

# 6. Creating a unique file with timestamp
def create_timestamp_file(prefix="file"):
    """Create a file with a timestamp in its name"""
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"{prefix}_{timestamp}.txt"
    with open(filename, "w") as file:
        file.write(f"File created at {datetime.datetime.now()}\n")
        file.write("Unique timestamp file\n")
    return filename

new_file = create_timestamp_file("report")
print(f"Created: {new_file}")

# Sometimes you need to create directories before creating files

import os

# 1. Creating a single directory
try:
    os.mkdir("my_new_folder")
    print("Directory created: my_new_folder")
except FileExistsError:
    print("Directory already exists!")

# 2. Creating nested directories
# os.mkdir("folder1/folder2")  # This will fail if folder1 doesn't exist
# Instead use:
os.makedirs("folder1/folder2/folder3", exist_ok=True)
print("Nested directories created!")

# 3. Creating directories with exist_ok (Python 3.2+)
# exist_ok=True prevents error if directory exists
os.makedirs("data/year/month/day", exist_ok=True)

# 4. Creating directories and files together
def create_project_structure(base_path):
    """Create a project folder structure"""
    folders = ["src", "tests", "data", "docs"]
    
    for folder in folders:
        path = os.path.join(base_path, folder)
        os.makedirs(path, exist_ok=True)
        print(f"Created: {path}")
    
    # Create a README file
    with open(os.path.join(base_path, "README.md"), "w") as file:
        file.write("# My Project\n")
        file.write("## Description\n")
        file.write("This project was created automatically.\n")
    
    print("Project structure created!")

# create_project_structure("my_project")

# 5. Creating a file in a new directory
def create_file_in_directory(filename, content, directory="data"):
    """Create a file inside a specific directory"""
    os.makedirs(directory, exist_ok=True)
    filepath = os.path.join(directory, filename)
    
    with open(filepath, "w") as file:
        file.write(content)
    
    print(f"File created: {filepath}")

create_file_in_directory("user_data.txt", "User: Alice\nAge: 25")
create_file_in_directory("user_data.txt", "User: Bob\nAge: 30", "data/users")

# 6. Checking and creating directories
def ensure_directory(path):
    """Ensure a directory exists, create if it doesn't"""
    if not os.path.exists(path):
        os.makedirs(path)
        print(f"Created directory: {path}")
    else:
        print(f"Directory already exists: {path}")
    return path

data_path = ensure_directory("project/data/reports")

# Creating files requires handling various errors

# 1. Comprehensive file creation function
def create_file_safely(filename, content="", mode="w"):
    """
    Create a file safely with error handling
    
    Args:
        filename: Name of the file to create
        content: Content to write (optional)
        mode: File mode ('w', 'x', or 'a')
    
    Returns:
        bool: True if successful, False otherwise
    """
    try:
        with open(filename, mode) as file:
            if content:
                file.write(content)
        print(f"✅ File '{filename}' created successfully!")
        return True
    
    except FileExistsError:
        print(f"❌ File '{filename}' already exists!")
        return False
    
    except PermissionError:
        print(f"❌ Permission denied for '{filename}'!")
        return False
    
    except IsADirectoryError:
        print(f"❌ '{filename}' is a directory, not a file!")
        return False
    
    except OSError as e:
        print(f"❌ OS Error: {e}")
        return False
    
    except Exception as e:
        print(f"❌ Unexpected error: {e}")
        return False

# Test the function
create_file_safely("test1.txt", "Hello World!")
create_file_safely("test1.txt", "This will fail", "x")

# 2. Creating files with permission handling
import os

def create_with_permissions(filename, content):
    """Create a file with proper permission checking"""
    # Check if we can write to the directory
    directory = os.path.dirname(filename) or "."
    if not os.access(directory, os.W_OK):
        print(f"Cannot write to directory: {directory}")
        return False
    
    # Check if we need to handle existing file
    if os.path.exists(filename):
        response = input(f"File '{filename}' exists. Overwrite? (y/n): ")
        if response.lower() != 'y':
            print("File creation cancelled.")
            return False
    
    try:
        with open(filename, "w") as file:
            file.write(content)
        print(f"File created: {filename}")
        return True
    except Exception as e:
        print(f"Error creating file: {e}")
        return False

# 3. Creating files with automatic backup
def create_with_backup(filename, content):
    """Create a file with automatic backup of existing file"""
    if os.path.exists(filename):
        backup_name = filename + ".backup"
        try:
            os.rename(filename, backup_name)
            print(f"Existing file backed up as: {backup_name}")
        except Exception as e:
            print(f"Backup failed: {e}")
            return False
    
    try:
        with open(filename, "w") as file:
            file.write(content)
        print(f"File created: {filename}")
        return True
    except Exception as e:
        print(f"Error creating file: {e}")
        return False

# 4. Using contextlib to suppress errors
from contextlib import suppress

def create_quietly(filename, content):
    """Create a file without printing errors"""
    with suppress(Exception):
        with open(filename, "w") as file:
            file.write(content)
        return True
    return False

# Best practices for creating files in Python

# 1. Always use 'with' statement
# ✅ Good
with open("file.txt", "w") as f:
    f.write("Hello")

# ❌ Bad
f = open("file.txt", "w")
f.write("Hello")
# f.close()  # Might be forgotten

# 2. Choose the right mode
# For new files that shouldn't be overwritten
with open("new_file.txt", "x") as f:
    f.write("Content")

# For files you want to replace
with open("existing.txt", "w") as f:
    f.write("New content")

# For files you want to add to
with open("log.txt", "a") as f:
    f.write("New entry\n")

# 3. Check directories before creating files
import os

def safe_create_file(filepath, content):
    """Create a file safely with directory checking"""
    directory = os.path.dirname(filepath)
    if directory and not os.path.exists(directory):
        os.makedirs(directory, exist_ok=True)
    
    with open(filepath, "w") as file:
        file.write(content)
    print(f"File created: {filepath}")

safe_create_file("project/data/report.txt", "Report content")

# 4. Use meaningful file names
# ✅ Good
customer_data_2026_08_02.csv
user_profile_12345.json
error_log_2026_08.txt

# ❌ Bad
temp.txt
file1.txt
data.txt

# 5. Add file headers and metadata
def create_script_file(filename, author, description):
    """Create a Python script file with header"""
    content = f'''#!/usr/bin/env python3
"""
File: {filename}
Author: {author}
Description: {description}
Created: {__import__('datetime').datetime.now().strftime("%Y-%m-%d")}
"""

def main():
    """Main function"""
    print("Hello, World!")

if __name__ == "__main__":
    main()
'''
    with open(filename, "w") as file:
        file.write(content)
    print(f"Script created: {filename}")

create_script_file("example.py", "Alice", "Example Python script")

# 6. Use constants for file paths
# Instead of hardcoding paths:
# DATA_DIR = "data"
# LOG_DIR = "logs"
# REPORT_DIR = "reports"

# Then use:
# import os
# log_path = os.path.join(LOG_DIR, "app.log")
# with open(log_path, "a") as f:
#     f.write("Log entry\n")

# 7. Clean up temporary files
import tempfile
import os

def create_temp_file(content):
    """Create and return a temporary file"""
    with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp:
        temp.write(content)
        temp_path = temp.name
    
    print(f"Temporary file created: {temp_path}")
    # Remember to delete when done
    # os.unlink(temp_path)
    return temp_path