Python OpenAI API

⚙️ CHAPTER 1: SETUP & INSTALLATION SETUP

CH.1

# Install OpenAI library pip install openai # Basic setup import openai import os # Set your API key openai.api_key = "your-api-key-here" # Or set as environment variable # os.environ["OPENAI_API_KEY"] = "your-api-key-here" # Initialize client (for newer versions) from openai import OpenAI client = OpenAI(api_key="your-api-key-here")

💬 CHAPTER 2: CHATGPT EXAMPLES CHAT

CH.2

Simple Chat

import openai

def simple_chat(message):
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": message}
        ],
        max_tokens=150,
        temperature=0.7
    )
    return response.choices[0].message.content

# Usage
message = "Explain quantum computing in simple terms"
response = simple_chat(message)
print(response)

# With newer API
from openai import OpenAI
client = OpenAI()

def chat_with_gpt(message):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": message}]
    )
    return response.choices[0].message.content

Conversation History

from openai import OpenAI
client = OpenAI()

class ChatBot:
    def __init__(self):
        self.conversation_history = []

    def add_message(self, role, content):
        self.conversation_history.append(
            {"role": role, "content": content}
        )

    def chat(self, user_message):
        self.add_message("user", user_message)
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=self.conversation_history,
            max_tokens=200
        )
        assistant_message = response.choices[0].message.content
        self.add_message("assistant", assistant_message)
        return assistant_message

    def get_history(self):
        return self.conversation_history

# Usage
bot = ChatBot()
response1 = bot.chat("Hello, how are you?")
response2 = bot.chat("What's the weather like?")
print("History:", bot.get_history())

🧠 CHAPTER 3: GPT-4 EXAMPLES GPT-4

CH.3

Code Generation

from openai import OpenAI
client = OpenAI()

def generate_code(description, language="python"):
    prompt = f"""Generate {language} code for:
{description}

Please provide:
1. Clean, well-commented code
2. Brief explanation of the approach
3. Example usage if applicable"""

    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are an expert programmer. Generate clean, efficient code with proper comments."},
            {"role": "user", "content": prompt}
        ],
        max_tokens=1000,
        temperature=0.3
    )
    return response.choices[0].message.content

# Usage
description = "Create a function to find the longest common subsequence"
code = generate_code(description, "python")
print(code)

Text Analysis

from openai import OpenAI
client = OpenAI()

def analyze_text(text, analysis_type="sentiment"):
    analysis_prompts = {
        "sentiment": "Analyze the sentiment (positive, negative, neutral) with a confidence score.",
        "summary": "Provide a concise summary in 2-3 sentences.",
        "keywords": "Extract the main keywords and key phrases.",
        "tone": "Analyze the tone and writing style."
    }

    prompt = f"{analysis_prompts.get(analysis_type, 'Analyze this text')}\n\nText: {text}"

    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a text analysis expert. Provide clear, structured analysis."},
            {"role": "user", "content": prompt}
        ],
        max_tokens=300,
        temperature=0.2
    )
    return response.choices[0].message.content

# Usage
text = "I'm really excited about this new project!"
print(f"Sentiment: {analyze_text(text, 'sentiment')}")
print(f"Summary: {analyze_text(text, 'summary')}")

⚡ CHAPTER 4: ADVANCED FEATURES ADVANCED

CH.4

Function Calling

from openai import OpenAI
import json

client = OpenAI()

# Define functions the model can call
functions = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City name"
                }
            },
            "required": ["location"]
        }
    }
]

def get_weather(location):
    return f"Weather in {location}: Sunny, 25 C"

def chat_with_functions(message):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": message}],
        functions=functions,
        function_call="auto"
    )
    msg = response.choices[0].message
    if msg.function_call:
        fn_name = msg.function_call.name
        fn_args = json.loads(msg.function_call.arguments)
        if fn_name == "get_weather":
            result = get_weather(fn_args["location"])
            response = client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "user", "content": message},
                    {"role": "function", "name": fn_name, "content": result}
                ]
            )
            return response.choices[0].message.content
    return msg.content

result = chat_with_functions("What's the weather in Tokyo?")
print(result)

Streaming Responses

from openai import OpenAI

client = OpenAI()

def stream_chat(message):
    stream = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": message}],
        stream=True
    )

    full_response = ""
    for chunk in stream:
        if chunk.choices[0].delta.content is not None:
            content = chunk.choices[0].delta.content
            print(content, end='', flush=True)
            full_response += content

    return full_response

def stream_with_callback(message, callback=None):
    stream = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": message}],
        stream=True
    )

    full_response = ""
    for chunk in stream:
        if chunk.choices[0].delta.content is not None:
            content = chunk.choices[0].delta.content
            full_response += content
            if callback:
                callback(content)

    return full_response

# Usage
def print_chunk(chunk):
    print(chunk, end='', flush=True)

message = "Write a short story about a robot learning to paint"
response = stream_with_callback(message, print_chunk)

📖 QUICK REFERENCE CHEATSHEET

Popular Models

gpt-3.5-turbo — Fast, cost-effective
gpt-4 — Most capable
gpt-4-turbo — Latest GPT-4 variant
text-embedding-ada-002 — Embeddings

Key Parameters

max_tokens — Response length limit
temperature — Creativity (0–2)
top_p — Nucleus sampling
stream — Real-time responses