Pregunta

Según la documentación, son prácticamente intercambiables.¿Existe alguna razón estilística para utilizar uno sobre el otro?

¿Fue útil?

Solución

Me gusta usar comillas dobles alrededor de cadenas que se usan para interpolación o que son mensajes en lenguaje natural, y comillas simples para cadenas pequeñas con forma de símbolos, pero romperé las reglas si las cadenas contienen comillas o si lo olvido.Utilizo comillas dobles triples para cadenas de documentación 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

Otros consejos

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 dobles (").

Entonces no hay diferencia.En cambio, la gente te dirá que elijas el estilo que coincida con el contexto, y ser consistente.Y estoy de acuerdo, añadiendo que no tiene sentido tratar de crear "convenciones" para este tipo de cosas porque sólo terminarás confundiendo a los recién llegados.

yo solía preferir ', especialmente para '''docstrings''', como encuentro """this creates some fluff""".También, ' se puede escribir sin Cambio tecla en mi teclado alemán suizo.

Desde entonces he cambiado a utilizar comillas triples para """docstrings""", conformar a PE 257.

Estoy con Will:

  • comillas dobles para texto
  • Comillas simples para cualquier cosa que se comporte como un identificador.
  • Literales de cadena sin formato con comillas dobles para expresiones regulares
  • Comillas dobles triplicadas para cadenas de documentos

Seguiré con eso incluso si eso significa escapar mucho.

Saco el máximo valor de los identificadores entre comillas simples que se destacan debido a las comillas.El resto de las prácticas están ahí sólo para dar espacio a esos identificadores entre comillas simples.

Si la cadena que tienes contiene uno, entonces deberías usar el otro.Por ejemplo, "You're able to do this", o 'He said "Hi!"'.Aparte de eso, simplemente debes ser lo más consistente 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 "" para cadenas más largas podría ayudar a facilitar la transición.(Asimismo para seguir otros idiomas donde no sean intercambiables).

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

Los comentarios entre comillas triples son un subtema interesante de esta pregunta. PEP 257 especifica comillas triples para cadenas de documentos.Hice una verificación rápida usando Google Code Search y descubrí que comillas dobles triples en Python son aproximadamente 10 veces más populares que comillas simples triples -- 1,3 millones frente a 131.000 apariciones en el código que indexa Google.Entonces, en el caso de varias líneas, 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 por fuera. Siempre

Hablando de tonterías, ¿de qué sirve simplificar los literales de cadena con ' si vas a tener que usar caracteres de escape para representar apóstrofes?¿Ofrece a los programadores leer novelas?¡No puedo imaginar lo dolorosa que fue para ti la clase de inglés en la escuela secundaria!

Python usa comillas 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'

Utilizo comillas dobles en general, pero no por ningún motivo específico; probablemente sea por costumbre de Java.

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

Personalmente me quedo con uno u otro.No importa.Y dar tu propio significado a cualquiera de las citas es sólo confundir a otras personas cuando colaboras.

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

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

En Perl desea utilizar comillas simples cuando tiene una cadena que no necesita interpolar variables o caracteres de escape como , , , etc.

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

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

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

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

Por supuesto, al citar caracteres de comillas, cambiar entre los dos puede 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 multilingüe, es posible que desee fomentar 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 que yo sepa.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 claves hash y cosas así.

Mi objetivo es minimizar tanto los píxeles como la sorpresa.normalmente prefiero ' para minimizar los píxeles, pero " en cambio, si la cadena tiene un apóstrofo, nuevamente para minimizar los píxeles.Para una cadena de documentación, sin embargo, prefiero """ encima ''' porque esto último no es estándar, es poco común y, por lo tanto, sorprendente.Si ahora tengo un montón de cuerdas donde usé " según la lógica anterior, pero también uno que puede salirse con la suya ', todavía puedo usar " en él para preservar la coherencia, sólo para minimizar la sorpresa.

Quizás ayude pensar en la filosofía de minimización de píxeles de la siguiente manera.¿Preferirías que los caracteres ingleses parecieran A B C o AA BB CC?La última opción desperdicia el 50% de los píxeles no vacíos.

Utilizo 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 caracteres requieren la tecla Mayús.

' = "

/ = \ = \\

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 iguales.Una sola barra invertida escapará de los caracteres.Tuviste suerte en ese ejemplo porque \k y \w No son escapes válidos como \t o \n o \\ o \"

Si desea utilizar barras invertidas simples (y que se interpreten como tales), debe utilizar una cadena "sin formato".Puedes hacer esto poniendo un 'r' delante de la cuerda

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.Sin embargo, es evidente que la cuerda en sí es diferente.Sin embargo, no garantizaría que se manejen de esta manera en un dispositivo externo.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top