Comillas simples versus comillas dobles en Python [cerrado]

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

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

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.

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 .

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.

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.

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.

"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!

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'

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.

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.

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.

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.

Elegí usar comillas dobles porque son más fáciles de ver.

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 ...

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 '

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í.

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.

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.

' = "

/= \=\\

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.