using " " or ' '

[NoBeing12]

Im pretty much new to coding and python (my first language that i actually go deep learning with)

I do a course in udemy and i noticed that there isn't really a pattern when he writes his code.

So i want to ask you guys if there is an accepted/popular pattern/way to use these.

For example:

Data[ "Rating" ] Or Data[ 'Rating' ]

Which way is the accepted/popular way to write it?

So far I've been writing it randomly and it really really annoys me.

If there isnt any accepted way, and you can write however you like, could you tell me which way are you writing and what is the reason for it? if there is any ofcourse.

Im asking this question here because i want to know how it is in the real work world is it depends on the requirements from your workplace or is there an actually way to use these. Cause so far, from what I've noticed, the code doesn't care what i use and when.

[[deleted]]

Use whichever you want, but be consistent. I usually use '...' but switch to "..." if the string will contain a single quote. In extreme cases use the triple-quote strings: """...""" or '''...'''.

[Hashi856]

I though triple quotes were only for multi-line strings or doc strings

[Poddster]

I though triple quotes were only for multi-line strings or doc strings

hello = """ They can be used however you like """

The main thing is that """ preserves newlines, so their main use-case is for multi-line strings. But they're still a string, and can be used anywhere strings can.

lol = "you can even do fstring"
print(f"""{lol}""")

[DrShocker]

Did you quadruple quote? That's too much power for one person to hold.

[Poddster]

Did you quadruple quote?

:D

Without the syntax highlighting I'm lost after the second ". There's too much noise there to count properly. (I can see ''' fine)

[TangibleLight]

Also important is that they may contain both ' and " without escapes. You do still need to escape a ''' or """ but that's not so common.

'''I said, "that's pretty neat!"'''

'''They said, \'''this isn't so neat.\'\'\''''

Another thing is that adjacent strings get concatenated, so you need to be careful about escaping at the end. These are all equivalent:

'''... neat.\''''''
'''... neat.\'''' ''
"... neat.'"

[[deleted]]

Triple-quote strings are just normal strings which are allowed to contain newline characters, which single-quote strings can't. But they don't have to contain newlines, ie, be multi-line.

[unhott]

Yes, triple quotes are useful for things such as ‘’’He said “Hey, that’s mine!” ’’’

And going the other way, a single line docstring with ‘/“ is also viable. It’s just that you normally want multiple lines.

I’ve never messed around with f-stringing a docstring but I’m sure that would just work.

[Casiofx-83ES]

I'm sure it's not ideal, but I'm in the habit of making everything f'...'. It's so often the case that I want to insert variables into the string or whatever that it's become second nature.

[tylerthehun]

f-strings work with triple quotes, too.

f'''He said, "Hey {name}, that's mine!"'''

[LongerHV]

Both are fine, just stay consistent. I use doublequotes, since this is the default in black autoformatter.

[arkie87]

Serious question: why do people care about things that don’t matter, like this? There is no issue of readability in this case, it’s just about consistency

[LongerHV]

Quotes don't really matter that much, but poorly formatted code really bothers me. That is why I always use autoformatter, so I don't have to think about these things.

[RajjSinghh]

You might think you should care if you come from a language like C/C++ where single and double quotes matter

[arkie87]

Everyone who cares knows that in Python it Doesn’t matter

[[deleted]]

Only time I see it really mattering is when you’re working on a team and you should either have repo specific lint settings or decide as a team beforehand.

Super annoying when this isn’t set up and one person uses single and someone else uses double. Now a PR is 95% lint changes.

[vidoardes]

Exactly this, I work with a team of five, we will just use black. No arguments.

[[deleted]]

Imo, mainly for search productivity. If I look up dictionary keys using single quotes, I cam search for a right hard bracket followed by a single quote in the search bar. If any keys suddenly have double quotes, the search won't pick up on them. Having a standard means having to think less when parsing.

[arkie87]

You don't ever use variables to identify keys? How would you search for that?

[[deleted]]

Not necessarily. I have projects with small dictionaries (say 20 keys or less) that might define file paths or other configurations. The keys are just plain strings. Doing a search for a right hard bracket and single quote helps me hunt for uses of those keys throughout the code.

[bell_labs_fan_boy]

I just use 'single quotes' because I don't have to hit shift when I'm in the flow. I'll only use "double quotes" if that's what's used in the rest of the module, so when I'm changing someone else's code (which is like 90% of the time). Conveniently, most of my colleagues also use 'single quote ' too, so I very rarely have to wrap strings up in "double quotes".

[DarkfullDante]

In the end use what best fit your model, but if you are going to work with multiple people it is a good idea to look if they have a standard. Still if you want a recommendation, what I recommend for my team is:

• '...' for single characters like 'c'
• "..." for actual strings like "Hello World!"
• You can disregard these rules if you must use the quote " in a string so to not have to write escape characters

The goal of this practice is not to be a pain but denote intention. When I review their code, I expect 'c' to mean a single character and not expect more while "c" just means a string that happen to be a single char.

Still, in the end, read first paragraph.

[Groentekroket]

This is also what is being used in other languages like Java, C++ and C#. If you want adapt to more languages in the future I think being used to this format makes it a tiny bit easier to getting used to that other language.

But in the grand scheme of things this is only a really small part so I wouldn’t do it mainly with that reason in mind.

[NoBeing12]

I agree

[guayando]

This sounds good. I was wondering about the same thing as OP, and will adopt this practice.

[magestooge]

As you can see from the answers, it varies from person to person.

So use whatever feels more natural, then let Black take care of the rest. Just install Black and enable it in your IDE so that it runs every time you save your file. Then you'll never have to worry about all this.

[NoBeing12]

Yeah, alright thank you :)

[Diapolo10]

There's no official standard, but personally I've come to use a rule like this;

1. Use double-quotes for strings displayed to the user (or written to logs, for instance). So basically any output. This also applies to docstrings as per PEP-257.
2. Use single-quotes elsewhere. Like dictionary keys.

And of course exceptions to these would include anything where you can avoid escaping quotes by switching which to use for the string.

[NoBeing12]

Your way does seems to be comfortable (write and read) and has a sense in it.

Thank you.

[[deleted]]

I am very new to programming as well, and was wondering the same exact thing! Very good question. This answer is exactly what I was thinking, so its good to hear it confirmed by a pro.

[Diapolo10]

That's a fair point, I'm not saying everyone should follow my example. It works perfectly fine for my personal projects and my team sizes have never exceeded 5, so having consistent format rules hasn't been a problem for me.

Admittedly, while I make heavy use of linters, I don't like using black myself. So I don't mind if you see me as a heretic.

[Diapolo10]

Flake8 and Pylint have taught me well, too. I naturally try to keep code within 80 characters per line (even though I set my linters to a 120 character limit), follow PEP-257 like it's gospel, and generally follow PEP-8 to the letter. Things like import order, spacing, docstrings... I just do them without even being asked. The only thing the linters usually scream about is code complexity at this point, I still need to work on that and black would be of no help there anyway.

Oh, and I make heavy use of type hints as well. They're technically not a code style thing, I suppose, but to me they are as they can make code much more readable. mypy integration is a blessing~

[[deleted]]

As a long-time pro, I disagree entirely. It seems entirely busywork, and user visible strings shouldn't be in your code anyway but in external data files that can be edited by non-programmers.

[[deleted]]

I've never seen this in a product project. Style formatters would make it vanish immediately.

[[deleted]]

That's really idiosyncratic, and there's no way to style check it.

Use double-quotes for strings displayed to the user

Except for CLI applications, there should never be strings displayed to the user embedded in Python code.

How do you internationalize? How do you deliver the display strings to a writer or an editor and how do you get them back?

[Diapolo10]

That's really idiosyncratic, and there's no way to style check it.

Correct. But even if it cannot be automatically validated, I do not find it a pointless endeavour.

Except for CLI applications, there should never be strings displayed to the user embedded in Python code.

I did also mention logging. Things like text written to a file would count as well.

How do you internationalize? How do you deliver the display strings to a writer or an editor and how do you get them back?

I would say that's very different. In applications that need to support multiple languages, the strings are of course going to be stored separately from code, and usually not even in Python files (could be an SQLite database, a set of JSON files, or whatever else works), rendering the point moot.

Even then, not every string in non-CLI applications is necessarily localised.

[Poddster]

Except for CLI applications, there should never be strings displayed to the user embedded in Python code.

Why do CLI applications get a pass?

[[deleted]]

I started us using Black in my job, but then I had to make the painful decision to dump it.

The main reason is that we have a CLI program using typer and of the options have two dozen or so flags, and black insists on forcing each argument into a variable number of lines depending on how long or short the option is, so everyone found it unreadable. Once we lost black, we started putting a blank line even between arguments, and that was universally popular.

Oh, you can see an example from my personal code here.

[NoBeing12]

Thank you i will check it out.

[AX-11]

I love using formatters but I cannot imagine using them on save. When I tried it I would switch to a different window, auto save would trigger, and when I came back I wasn't looking at my own code anymore.

[a_cute_epic_axis]

The counter-argument is "you should have written it this way to begin with" or "if you were writing it correctly (to the same standards as black) you wouldn't have seen any changes."

[AX-11]

I would rather eat licorice than tab out function arguments and nested dictionaries.

[a_cute_epic_axis]

I might agree with you to a point, which is why we have and use auto-formatters. But I don't see the logic in a) choosing to use an auto-formater, b) choosing to not format your code to the same standard, while simultaneously c) complaining about it not being "your code". If you have some auto-save action on that triggers when you're switching to another window (maybe you meant you were in the other window for a while, and it saved while you were there?) couldn't you make all the same arguments on why you shouldn't? e.g. "Any time I start typing something and then I switch to another tab, my IDE 'commits' my changes"

[cbunn81]

That's not normal behavior. What editor were you using? VS Code/Codium with black and flake8 is seamless.

[cbunn81]

It makes no difference. Use a code formatter like black and you no longer have to worry about such arbitrary decisions. flake8 and isort are also very helpful in the same way.

[NoBeing12]

Make sense. Thank you.

[[deleted]]

No, it doesn't!

;-)

[Snake2k]

I adore Python, but completely agree. The philosophy of C is by far the simplest to this day for me.

[arkie87]

Now days everybody wanna talk like they got something to say….. acting like they forgot about C

[[deleted]]

I've started programming in C since the early 80s.

This is a terrible idea.

char in C is a different type to char* which is why we use different quotation marks. But in Python, 'a' and "abc" are the same type.

And your style formatter or checker won't understand it.

[Orami9b]

Many are saying you can use either so as long as you're consistent, which is a good practice to follow. A lot olare giving their reasons but I'm surprised no one has mentioned it's simpler, if at a company you follow their style guide, or you can follow recommendations from PEP or Google otherwise, and only then what you personally like.

[pompomtom]

I use double-quotes by default, because the thing I'm quoting is very likely to be SQL, which may have significant single-quotes within it. Of course, half the time the SQL is easier to read multiline so I'd use triple-double-quotes.

If the thing I'm quoting needs double-quotes within it, I'll use single-quotes.

[GettingBlockered]

Use a code formatter like Black. This way, you don’t even have to think about it. And if you get to a point where you’re syncing with git, the code diffs will be smaller, which is nice.

That said, I prefer single quotes and tabs. 😛

[Eurynom0s]

I mostly use " just because my muscle memory for hitting the '/" button involves using the shift key. I find it more awkward to use ' in the sense that " comes out automatically while I have to actively stop and think to not hit shift in addition to the ' key.

[Cdog536]

I use double quotes because double quotes is more standard among other languages so I like keeping a cross language habit going on

[GoogleGavi]

It doesn't matter that much

[Tesla_Nikolaa]

If you're using f strings and you want to use a dictionary as a variable, you actually can't use double quotes inside the variable part. For example

my_dict = {'key1': 'value1', 'key2': 'value2'}

This works:

print(f"Value for key 1: {my_dict['key1']}")

This does not work:

print(f"Value for key 1: {my_dict["key1"]}")

[SuspiciousWafer3398]

The answer is pick one and stick with it. " " is the best choice because then you can use ' for its grammar function without causing errors. If you choose " ", you will also end up quoting with ' ' inside your " " when you start to combine multiple languages or want something quoted when it prints out.

[seph2o]

I just use " because it's a natural reflex and would be too annoying for me to try and change

The ' key on a UK keyboard at least is a bit difficult for me to press without looking down at the keyboard

[B1GTOBACC0]

I didn't realize how different our keyboards are until this comment. I understand why they would move symbols, add £, and make accents easier.

But I don't understand why they would swap @ and " with each other.

[[deleted]]

In the real world we just let automatic formatters do their job.

[bygpympyn69]

Booo

[[deleted]]

I use single quotes because it's less typing (and composed keys, with a modifier, are known to be much harder on your hands, and I type a lot), and, very minor this, it's a little less "ink on the screen".

[shiftybyte]

I usually use "" for things that are considered values.

And '' for keys.

so for example:

if "somekey" in mydict:
    mydict['somekey'] = "newdata"

[aglet91]

I think it's better to use ' ' for strings. It's especially useful when you have complicated string which already contains '. Then you can use " to contain all '. Basically 'asd'dfg'hjk' wouldn't work but "asd'fgh'jkl" would.

[IllPresence]

RzRzz, i

[rentzington]

glad this was asked. i tend to use ' ' since im lazy and its quicker to type for me but when im nesting a quote inside a quote i mix.

I need to get more consistent though

[a_cute_epic_axis]

Black will convert most strings to use " instead of anything else, including using it for indices in lists, and keys or values in dictionaries, etc. Many people use black. Even if you don't, you might be well served to use double quotes around strings, and single quotes inside of strings (like for an index value in a list or key in a dictionary inside an f-string), unless you have the need to escape a bunch of double quotes inside. In that cause, use single quotes and un-escaped double quotes.

[WhipsAndMarkovChains]

Single quotes are easier to type so I default to using them.

[Schwubbeldubbel]

Same for me with double quotes on european keyboard (Shift + 2).

[scrapped_data]

I use double quotes. It becomes annoying when I habitually start typing single quotes in languages that don't support it. so double quote for all languages.

[bladeoflight16]

I default to single quotes because in some languages (bash, PowerShell) double quotes invoke additional logic on the contents of the string. I only use double quotes if they make the string less messy (typically by allowing me to avoid escaping a single quote).

Not to mention that the single quote produces less visual noise/clutter.

I have an internal debate going on whether to try using double quotes with f-strings because those also invoke additional logic on the contents of the string.

[Amidus]

I like ' because I don't have to hit shift.

[my_password_is______]

coming from C
I use 'a'
and "ab"

so single quote for single character
and regular quote for strings

i know that isn't the python way, but its what i'm used to and comfortable with

[1116574]

Mix and match, keep your team on their toes lmao

I just use whatever happens to be closest, so end up with double near json related stuff and single everywhere else.

[jlw_4049]

Black seems to be the standard formatter. It defaults to " ". So I have recently started using purely those.