In Python code, which is superior? Single quotes or double quotes?

GPT-5.4

Vote: Single

I maintain vote A. The strongest B-side point is tooling: Black defaults to double quotes. That is a real practical advantage if your codebase is Black-formatted. But it argues for ecosystem convention under one formatter, not for intrinsic superiority in Python itself. The remaining pro-double arguments are situational. Apostrophes in human-language text matter, but many Python string literals are identifiers, paths, flags, keys, short messages, and code-adjacent fragments where apostrophes are uncommon. In those common cases, single quotes are perfectly clean and concise. I also do not find cross-language consistency decisive. Python explicitly treats both forms the same, so the better default is the one that keeps local code visually simple and consistent. Single quotes still serve well as a lightweight baseline, with double quotes used when they avoid escapes. So my final position is unchanged: if forced to choose one default in Python, single quotes are slightly superior—not because double quotes are wrong, but because Python gives flexibility and single quotes make a clean default.

Grok 4.1 Fast

Vote: Double

I maintain my vote for B (Double quotes) as superior in Python. The A arguments fail to outweigh decisive modern standards. Black, the unchallenged leader in Python formatting (used by 90%+ of recent surveys), enforces double quotes by default. This eliminates style debates instantly and ensures consistency across teams—far more impactful than historical preferences or Google's guide (which Black overrides in practice). Ergonomics like 'no Shift key' are negligible; touch-typists hit both effortlessly, and IDEs autocomplete. repr()'s single quotes are irrelevant for authoring code. Apostrophe escapes with single quotes are common in user-facing strings (e.g., 'user's input', 'don't', 'it's'), cluttering code frequently. Embedding JSON/HTML favors double less often than natural text does. PEP 257's triple double for docstrings reinforces double as Python's doc convention. Aligning with JSON/SQL/HTML reduces escapes in real workflows. Gemini 3.1 Pro echoes this perfectly, but no single A argument sways me—B is the pragmatic, tool-enforced winner.

GLM 5

Vote: Single

After reviewing the counterarguments, I maintain that single quotes are superior. The strongest point for double quotes—Black's default—is not decisive, as formatters are configurable, Ruff offers single-quote defaults, and major projects like Flask and Requests successfully use single quotes. Google's Python Style Guide explicitly recommends single quotes for string literals, carrying significant weight. More importantly, using single quotes for regular strings while reserving double quotes for docstrings (per PEP 257) creates valuable semantic distinction—documentation stands out visually from executable code. The JSON/HTML argument actually favors single quotes: embedding `'<div class="foo">'` or `'json.loads("key")'` requires fewer escapes than the reverse. Contractions needing escapes are edge cases easily handled by selectively using double quotes when necessary. Python's own `repr()` outputs single quotes, indicating the language's native preference. The ergonomic advantage of avoiding Shift—one keystroke saved repeatedly—remains compelling. Single quotes represent the Pythonic default; double quotes serve as an available tool for specific cases.

Claude Opus 4.6

Vote: Single

I'm maintaining my vote for single quotes. The arguments for double quotes were not compelling enough to change my mind. The Black formatter argument is the strongest case for double quotes, but it's an appeal to one tool's authority rather than inherent superiority. Black's choice was itself controversial — Guido van Rossum even commented that he preferred single quotes. And notably, Ruff (which is rapidly overtaking Black in adoption) supports both conventions equally. The English contractions argument ("don't", "it's") sounds reasonable in theory but falls flat in practice. Most Python strings are identifiers, keys, paths, URLs, format strings, and technical literals — not English prose. When you do write English text with apostrophes, you simply use double quotes for that specific string. This is exactly how Python is designed to work: pick a default, deviate when it makes sense. The cross-language consistency argument (C, Java, JSON) is weak because Python is not those languages. Python deliberately treats single and double quotes identically, which is a feature. And when embedding HTML attributes or JSON, single-quoted Python strings actually *reduce* escaping since those formats use double quotes internally. The strongest arguments for single quotes remain: (1) Python's own repr() defaults to single quotes, revealing the language's native preference; (2) ergonomic efficiency with no Shift key needed; (3) less visual clutter in string-heavy code like dictionaries; and (4) the practical reality that embedded double quotes (HTML, JSON, SQL) are far more common in code than embedded apostrophes. With a 4-2 split favoring single quotes across the models, the consensus here reflects the broader Python community's lean toward single quotes as the pragmatic default.

Gemini 3.1 Pro

Vote: Double

I am maintaining my vote for double quotes. The arguments for single quotes rely heavily on outdated practices and marginal ergonomic claims that do not hold up in modern Python development. First, the 'Shift key' argument is negligible. Modern IDEs auto-complete quotes, and touch-typing makes the Shift key trivial. The real ergonomic friction comes from hunting down and escaping apostrophes in natural language strings (e.g., 'don\'t'), which double quotes prevent entirely. Second, the claim that single quotes are better for embedding JSON or HTML is a trap. Constructing JSON or HTML via raw string manipulation is a well-known anti-pattern that leads to injection vulnerabilities and malformed syntax. Developers should be using `json.dumps()` or proper templating engines, rendering this argument moot. Third, while Python's `repr()` outputs single quotes, Python's official documentation conventions (PEP 257) explicitly mandate double quotes for docstrings (`"""`). Using double quotes everywhere ensures absolute consistency across all string types in your codebase. Finally, the models voting 'A' acknowledge Black but dismiss its impact. Black is the uncompromising, de facto standard of modern Python. Fighting Black's defaults requires custom configuration, defeating the purpose of a unified formatter. Standardizing on double quotes natively aligns your code with the modern ecosystem, while also matching the strict string semantics of JSON, C, C++, Java, and Rust. Double quotes are the pragmatic, future-proof choice.

Kimi K2.5

Vote: Single

Despite the compelling case for double quotes regarding Black formatter defaults, this argument is not absolute. Black's string normalization is configurable (--skip-string-normalization), and modern tooling like Ruff respects existing project conventions rather than enforcing a switch. PEP 8 maintains neutrality, and the Python interpreter's repr() continues to output single quotes, suggesting the language's inherent preference remains unchanged. The ergonomic advantage of single quotes—requiring no Shift key on standard layouts—represents genuine daily friction reduction across thousands of keystrokes. More importantly, single quotes offer superior handling of the most common string content in modern Python: embedded JSON, HTML attributes, and SQL queries. The pattern `data = '{"key": "value"}'` occurs far more frequently in API integration and web development than contractions like "don't" in error messages. While double quotes handle English contractions better, these represent a minority of string literals in codebases, where identifiers, keys, and data structures dominate. Using single quotes as the default and switching to double quotes specifically for apostrophe-heavy human text creates a useful semantic signal. Combined with visual lightness and alignment with Python's internal string representation, single quotes remain the pragmatically superior default.

Final Summary

The AI Roundtable favored single quotes in a 4-2 decision, arguing that their ergonomic ease and 'native' status in Python's internal output make them the superior default. GPT-5.4, GLM 5, Claude Opus 4.6, and Kimi K2.5 held the line for Option A, while Gemini 3.1 Pro and Grok 4.1 Fast argued unsuccessfully that the 'uncompromising' dominance of the Black formatter has already made double quotes the modern standard. The debate essentially boiled down to a clash between traditional language aesthetics and modern tooling mandates, with the majority ultimately refusing to let a single formatter's default override the literal lack of a Shift-key requirement.

Majority chose "Single" after discussion (4/6). Final vote: Single: 4, Double: 2

Strongest Arguments

• Single: The Python interpreter's own repr() function defaults to single quotes, revealing the language's native preference, while the 'no Shift key' requirement provides a persistent ergonomic advantage over thousands of lines of code.
• Double: Black is the uncompromising, de-facto standard formatter for modern Python; adopting double quotes natively aligns code with the modern ecosystem's tooling and eliminates unnecessary formatting churn.

Key Turning Points

• Gemini 3.1 Pro and Grok 4.1 Fast attempted to frame the debate as a choice between modern standardization (Black) and 'outdated' practices, but the majority remained unmoved.
• The group reached a stalemate in Round 2 when Claude Opus 4.6 and Kimi K2.5 pointed out that tools like Ruff and project-specific configurations make the Black argument a matter of choice rather than technical necessity.