Comillas simples versus comillas dobles en Python [cerrado]


718

Según la documentación, son bastante intercambiables. ¿Hay alguna razón estilística para usar uno sobre el otro?

Respuestas:


525

Me gusta usar comillas dobles alrededor de las cadenas que se usan para la interpolación o que son mensajes en lenguaje natural, y comillas simples para pequeñas cadenas similares a símbolos, pero romperé las reglas si las cadenas contienen comillas, o si lo olvido. Utilizo comillas dobles triples para cadenas de documentos y literales de cadena sin formato para expresiones regulares, incluso si no son necesarias.

Por ejemplo:

LIGHT_MESSAGES = {
    'English': "There are %(number_of_lights)s lights.",
    'Pirate':  "Arr! Thar be %(number_of_lights)s lights."
}

def lights_message(language, number_of_lights):
    """Return a language-appropriate string reporting the light count."""
    return LIGHT_MESSAGES[language] % locals()

def is_pirate(message):
    """Return True if the given message sounds piratical."""
    return re.search(r"(?i)(arr|avast|yohoho)!", message) is not None

44
Interesante, los uso exactamente de la misma manera. No recuerdo haber leído nada para empujarme en esa dirección. También uso comillas simples triples para cadenas largas no destinadas a humanos, como html sin formato. Tal vez sea algo relacionado con las reglas de cotización en inglés.
Mike A

12
La mayoría de los codificadores de Python lo codifican de esa manera. No existe una regla explícita, pero debido a que a menudo leemos el código de esa manera, se convierte en un hábito.
e-satis

Me pregunto si las comillas simples para cosas parecidas a símbolos en realidad provienen del atajo de expresión de comillas en Lisp / Scheme. En cualquier caso, es intuitivo. Además, amigos míos, si seguimos las pautas de estilo PEP 8, las funciones realmente deberían llamarse lights_message () y is_pirate ().
yukondude

8
Creo que Perl hizo una distinción entre cadenas de comillas simples (sin interpolación) y cadenas de comillas dobles (con interpolación) y que los codificadores de Python podrían haber heredado el hábito o nunca dejarlo ir.
Daren Thomas

2
Utilizo la misma convención, y abuso de ella haciendo que vim resalte todo dentro de comillas simples triples como SQL.
RoundTower

96

Citando los documentos oficiales en https://docs.python.org/2.0/ref/strings.html :

En inglés simple: los literales de cadena se pueden encerrar entre comillas simples (') o comillas dobles (").

Entonces no hay diferencia. En cambio, las personas le dirán que elija el estilo que coincida con el contexto y que sea coherente . Y estaría de acuerdo, agregando que no tiene sentido tratar de llegar a "convenciones" para este tipo de cosas porque solo terminarás confundiendo a los recién llegados.


3
Sí, para mí la consistencia es clave, así que solo uso singles en todas partes. Menos pulsaciones de teclas, inequívocas y consistentes.
mlissner

90

Solía ​​preferir ', especialmente para '''docstrings''', como encuentro """this creates some fluff""". Además, 'se puede escribir sin elShift tecla en mi teclado alemán suizo.

Desde entonces he cambiado a usar comillas triples para """docstrings"""cumplir con PEP 257 .


2
Tiendo a preferir las comillas simples, ya que escribo código SQL todos los días, y las comillas simples se usan para los literales de cadena en T-SQL. Pero sí uso comillas dobles triples, porque las cadenas de documentos a veces pueden usar un poco de pelusa en ellas.
eksortso

44
El uso de comillas simples en todas partes para cadenas me permite deshabilitar partes del código fuente usando tres comillas dobles, tipo '#if 0' y '#endif'.
tenue

12
"requiere una tecla Mayús solo en un teclado PC QWERTY. En mi teclado, en "realidad es más fácil de escribir.
e-satis

66
en mi teclado "y 'ambos requieren la tecla shift.
Loïc Faure-Lacroix

10
Esta respuesta es contraria a la convención de Python; vea PEP 257 que dice: Por coherencia, use siempre "" "comillas dobles triples" "" alrededor de las cadenas de documentos. python.org/dev/peps/pep-0257
Botones840

44

Estoy con Will:

  • Comillas dobles para el texto
  • Comillas simples para cualquier cosa que se comporte como un identificador
  • Literales de cadena sin procesar con comillas dobles para expresiones regulares
  • Triplicado comillas dobles para docstrings

Me quedaré con eso incluso si eso significa escapar mucho.

Obtengo el mayor valor de los identificadores con comillas simples que se destacan por las comillas. El resto de las prácticas están ahí solo para dar a esos identificadores entre comillas un poco de espacio.


26

Si la cadena que tiene contiene una, entonces debe usar la otra. Por ejemplo "You're able to do this", o'He said "Hi!"' . Aparte de eso, simplemente debe ser lo más coherente posible (dentro de un módulo, dentro de un paquete, dentro de un proyecto, dentro de una organización).

Si su código va a ser leído por personas que trabajan con C / C ++ (o si cambia entre esos lenguajes y Python), entonces use ''para cadenas de un solo carácter, y"" cadenas más largas podría ayudar a facilitar la transición. (Del mismo modo para seguir otros idiomas donde no son intercambiables).

El código Python que he visto en la naturaleza tiende a favorecer "más ', pero sólo un poco. La única excepción es que """these"""son mucho más comunes que '''these''', por lo que he visto.


21

Los comentarios triples son un subtema interesante de esta pregunta. PEP 257 especifica comillas triples para cadenas de documentos . Hice una comprobación rápida con Google Code Search y descubrí que las comillas dobles triples en Python son aproximadamente 10 veces más populares que las comillas simples triples : 1.3M frente a 131K en los códigos de los índices de Google. Entonces, en el caso de líneas múltiples, su código probablemente será más familiar para las personas si usa comillas dobles triples.


13
"If you're going to use apostrophes, 
       ^

you'll definitely want to use double quotes".
   ^

Por esa sencilla razón, siempre uso comillas dobles en el exterior. Siempre

Hablando de pelusa, ¿de qué sirve racionalizar sus literales de cadena con 'si va a tener que usar caracteres de escape para representar apóstrofes? ¿Ofende a los programadores leer novelas? ¡No puedo imaginar lo dolorosa que fue la clase de inglés de secundaria para ti!


11
"Si va a" citar "algo, definitivamente querrá usar comillas simples"
Paolo

Mi opinión ha cambiado mucho sobre esto desde que escribí esto. Ahora es solo una situación en la que argumentaría que usaría comillas dobles. Otro sería el suyo en el contexto del uso de comillas simples. Vea la respuesta aceptada para mi postura actual sobre el asunto con más detalle. Creo que es un gran ejemplo de cómo debería presentarse a un público amplio.
Droogans

7

Python usa citas como esta:

mystringliteral1="this is a string with 'quotes'"
mystringliteral2='this is a string with "quotes"'
mystringliteral3="""this is a string with "quotes" and more 'quotes'"""
mystringliteral4='''this is a string with 'quotes' and more "quotes"'''
mystringliteral5='this is a string with \"quotes\"'
mystringliteral6='this is a string with \042quotes\042'
mystringliteral6='this is a string with \047quotes\047'

print mystringliteral1
print mystringliteral2
print mystringliteral3
print mystringliteral4
print mystringliteral5
print mystringliteral6

Lo que da el siguiente resultado:

this is a string with 'quotes'
this is a string with "quotes"
this is a string with "quotes" and more 'quotes'
this is a string with 'quotes' and more "quotes"
this is a string with "quotes"
this is a string with 'quotes'

2
Pero """This is a string with "quotes""""plantea un SyntaxError. ¿Cómo podría resolverse esta situación? (igual que con '''This is a string with 'quotes'''')
dolma33

1
Inserte un salto de línea entre "comillas" y "" "
Nicolas

1
@ dolma33 La sugerencia de Nicolas cambiaría el contenido de la cadena. Ya hay una mejor solución en la respuesta: si su cadena termina con algún tipo de cita, use el otro tipo de cita triple. Ej '''This is a string with "quotes"'''.
jpmc26

3

Uso comillas dobles en general, pero no por ninguna razón específica: probablemente solo por costumbre de Java.

Supongo que también es más probable que desee apóstrofos en una cadena literal en línea que desea comillas dobles.


3

Personalmente me quedo con uno u otro. No importa. Y proporcionar su propio significado a cualquiera de las citas es solo para confundir a otras personas cuando colabora.


2

Probablemente sea una preferencia estilística más que nada. Acabo de comprobar PEP 8 y ​​no vi ninguna mención de comillas simples versus dobles.

Prefiero comillas simples porque es solo una pulsación de tecla en lugar de dos. Es decir, no tengo que apretar la tecla Mayús para hacer una cita simple.


1
PEP 8 enlaza con PEP 257 en la primera oración bajo "Cadenas de documentación". En PEP 257 dice: Por coherencia, use siempre "" "comillas dobles triples" "" alrededor de las cadenas de documentos. Use r "" "comillas triples crudas" "" si usa barras diagonales inversas en sus cadenas de documentos. Para cadenas de documentos Unicode, use "" "Cadenas de comillas triples Unicode" "". Aún así, me gusta el aspecto limpio de la comilla simple y la razón por la que presionó una tecla.
maxpolk

2

En Perl, desea usar comillas simples cuando tiene una cadena que no necesita interpolar variables o caracteres escapados como \ n, \ t, \ r, etc.

PHP hace la misma distinción que Perl: el contenido en comillas simples no se interpretará (ni siquiera se convertirá \ n), a diferencia de las comillas dobles que pueden contener variables para imprimir su valor.

Python no, me temo. Visto técnicamente, no hay $ token (o similar) para separar un nombre / texto de una variable en Python. Ambas características hacen que Python sea más legible, menos confuso, después de todo. Las comillas simples y dobles se pueden usar indistintamente en Python.


Para reforzar lo que dice \ n va a ser interpretado solamente entre comillas dobles en PHP y Perl, mientras que en Python trabajará tanto entre comillas dobles e individuales
stivlo

1
@stivlo: a menos que haga una cadena sin procesar a partir de ella, agregando rdelante del literal de la cadena. Entonces print 'a\nb'te imprimirá dos líneas, pero print r'a\nb'te imprimirá una.
Tadeck


1

Solo uso lo que me apetece en ese momento; ¡Es conveniente poder cambiar entre los dos a su antojo!

Por supuesto, al citar caracteres de cotización, cambiar entre los dos podría no ser tan caprichoso después de todo ...


0

El gusto de su equipo o las pautas de codificación de su proyecto.

Si se encuentra en un entorno multilenguaje, es posible que desee alentar el uso del mismo tipo de comillas para las cadenas que utiliza el otro idioma, por ejemplo. De lo contrario, personalmente me gusta más el aspecto de '


0

Ninguno hasta donde yo sé. Aunque si observa algún código, "" se usa comúnmente para cadenas de texto (supongo que 'es más común dentro del texto que ") y' 'aparece en hashkeys y cosas así.


0

Mi objetivo es minimizar ambos píxeles y sorprender. Normalmente prefiero 'minimizar los píxeles, pero "si la cadena tiene un apóstrofe, nuevamente para minimizar los píxeles. Para una cadena de documentación, sin embargo, prefiero """más '''ya que este último no es estándar, poco común, y por lo tanto sorprendente. Si ahora tengo un montón de cadenas donde utilicé "según la lógica anterior, pero también una que puede salirse con la suya ', aún puedo usarla "para preservar la consistencia, solo para minimizar la sorpresa.

Quizás sea útil pensar en la filosofía de minimización de píxeles de la siguiente manera. ¿Prefieres que parezcan caracteres ingleses A B Co AA BB CC? La última opción desperdicia el 50% de los píxeles no vacíos.


-1

Uso comillas dobles porque lo he estado haciendo durante años en la mayoría de los lenguajes (C ++, Java, VB ...) excepto Bash, porque también uso comillas dobles en texto normal y porque estoy usando un teclado (modificado) que no está en inglés donde ambos personajes requieren la tecla shift.


-4

' = "

/= \=\\

ejemplo:

f = open('c:\word.txt', 'r')
f = open("c:\word.txt", "r")
f = open("c:/word.txt", "r")
f = open("c:\\\word.txt", "r")

Los resultados son los mismos.

= >> no, no son lo mismo. Una sola barra invertida escapará de los personajes. Simplemente tienes suerte en ese ejemplo porque \ky \wno son escapes válidos como \to \no \\o\"

Si desea utilizar barras diagonales inversas simples (y hacer que se interpreten como tales), debe utilizar una cadena "en bruto". Puede hacer esto poniendo un ' r' delante de la cadena

im_raw = r'c:\temp.txt'
non_raw = 'c:\\temp.txt'
another_way = 'c:/temp.txt'

En lo que respecta a las rutas en Windows, las barras diagonales se interpretan de la misma manera. Claramente, la cadena en sí es diferente. Sin embargo, no garantizaría que se manejen de esta manera en un dispositivo externo.


Santo cielo, esto es viejo, pero quería comentar de todos modos para señalar que el uso de barras diagonales puede funcionar para Windows, pero aún depende del sistema. Para asegurarse de que no tiene dependencias del sistema operativo, useos.path.join()
Adam Smith
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.