Strings: Beginner

A string is a run of characters that Python keeps in order, from first to last: the letters of a city name, the digits of a postcode, a whole paragraph of an email. You write one by placing the text between quotes. The quotes mark where the text starts and stops, and they're not stored with the value: "Oslo" holds 4 characters, the capital O and the 3 small letters after it.

Python accepts either double quotes or single quotes, and the value is the same either way: the last line prints True because both literals hold the same 4 characters. The type of every string is str, and the third line confirms it: type(city) == str is True. Pick one quote style for a program and keep to it, so a reader scanning your code sees the same shape on every line.

Putting digits between quotes makes a string. "42" is 2 characters that happen to be digits, and 42 is an integer the computer can add and multiply. They're stored differently and never compare equal, so a value that arrives from a form field or a spreadsheet cell as text stays text until something converts it. Arithmetic works on the integer and leaves the string alone.

A ZIP code such as "02134" must stay a string: stored as the integer 2134 it loses its leading zero and the address lookup fails. Phone numbers behave the same way, and so do product codes and account identifiers. In data work, if you would never add 2 of them together, keep them as strings.

A for loop over a string visits its characters one at a time, in order, the same way a loop over range(4) visits the numbers 0 through 3. Each pass hands the loop variable 1 character, which is itself a tiny string holding that single character. Counting the passes tells you how many characters the string has, and the animation below does that for "Oslo".

The loop body ran 4 times, so count finished at 4 and the last line printed characters: 4. Run the same loop over the empty string "" and the body never executes: count stays 0 and only the final line is printed. A space is a character like any other, so "New York" counts to 8, including the gap between the words.

Two strings compare equal with == only when they hold the same characters in the same order. Python checks them one position at a time, and a capital letter is a different character from its small form, so "Oslo" == "oslo" is False. A trailing space counts too: "Oslo " has 5 characters and never equals the 4-character "Oslo", even though both look alike on screen.

Counting works the same whatever kind of characters a string holds. Every character gives the loop 1 pass, spaces and punctuation included, so the product code "X9-7" counts to 4 and the postcode "02134" counts to 5. The loop visits each character in turn without looking at what kind it is.

Some text runs across several lines: an email body, a receipt, the help message of a command. A string can span as many lines as you like if you open and close it with 3 quotes in a row. Both """ and ''' work, and every line break you type between the opening and closing quotes is stored as part of the string. The string ends only at the matching 3 quotes.

One print call produced 3 lines because the string itself contains a line break after shipped. and another after Thursday.. Nothing special happened at print time: print wrote the characters it was given, and 2 of those characters moved the cursor to the next line.

Pressing Enter straight after the opening """ puts a line break at the very start of the string, so the first thing printed is an empty line. This is the most common surprise with triple quotes. The program below prints a blank line before Welcome, and done shows where the string ended.

To begin with Welcome on the first printed line, type it on the same line as the opening quotes, as the shipping message above does. Likewise, a line break before the closing quotes adds a trailing blank line to whatever you print.

The content of a string is text rather than code, so Python does not require it to be indented. Writing Paid: 40 flush against the left margin, inside the function, removes the leading spaces while the rest of the function stays indented as usual. It looks odd in the editor and prints correctly.

You have met triple quotes already: a docstring is a triple-quoted string written as the first statement of a function, and it keeps the line breaks you type like any other. Its later lines can still sit at the function body's indentation, because documentation tools strip the indentation those lines share before showing the text, and Python itself does the same when it stores a docstring from version 3.13 onward. An ordinary triple-quoted string such as the receipt above gets no such treatment, so its leading spaces stay.

A function can build a multiline string and hand it back with return, and the caller prints it like any other value. The same rules apply inside the function: the text starts with whatever follows the opening quotes, so the first line of the message goes right after them. Continuation lines sit at the left margin, because spaces typed before them would be stored.

The output has exactly 2 lines of message and no blank line above them, because Meeting at 10 begins on the line of the opening quotes and Room 4B begins at column 0. Move Meeting at 10 down a line and the printed message would open with an empty line.

The + operator joins 2 strings end to end and gives back a new string containing both. Nothing is inserted between them: if you want a space, you concatenate a space. Swapping the operands changes the result, so "Ada" + "Lovelace" is a different string from "Lovelace" + "Ada".

Each of the 3 expressions produces a new string. first and last are unchanged afterwards. + reads the strings it is given and produces a fresh result, which you then print or store in a variable. The strings you started with are never modified.

Because + returns a new string, building text piece by piece means assigning the result back to the same variable on each pass. The animation walks the digits of a date code and attaches each one to label with a dash in front of it, while day keeps its original value throughout.

Each pass replaces label with a longer string. It starts as d-0 and grows through d-0-3 and d-0-3-0 until it reaches d-0-3-0-1. The last line prints 0301, confirming that reading characters from day left it as it was. This assign-back pattern, label = label + something, is how you build a CSV row from its fields, and report lines and log messages get assembled the same way.

Multiplying a string by an integer repeats it that many times, which is the quickest way to draw a separator or pad a column. "-" * 10 is 10 dashes, and "ab" * 3 is ababab. Multiplying by 0 gives the empty string. As with numbers, * runs before +, so "=" * 3 + "end" repeats first and joins second.

+ between a string and a number stops the program. Python won't guess whether you wanted Order 42 or arithmetic, so it raises a TypeError and the lines after it never run. The error message names both types, which is how you find the mistake in a longer program.

You already have a tool that prints mixed values side by side: print with commas. It accepts strings and numbers alike and puts 1 space between each pair. Use + when you need the joined text as a value you can store or return, and commas when all you need is to display it.

The number on the right of * can come from a variable, which lets a count decide how long a piece of text is. Here a string and an int meet in one expression without an error: * accepts an int and repeats the text, while + refuses one. A string on both sides of * fails the other way, with TypeError: can't multiply sequence by non-int of type 'str'.

Both pieces of bar are computed first, because * runs before +, and then the brackets are concatenated around the result. Change done to 4 and left to 1 and the bar redraws as [####.] with no other edit.

The tab is the odd one out: it moves the cursor to the next tab stop, usually every 8 columns, rather than inserting a fixed number of spaces. Short values followed by \t therefore line up in the same column, which is handy for a quick table printed to the screen.

You type 2 symbols, but the string stores 1 character. "a\nb" has 3 characters, and "C:\\temp" has 7, with a single backslash sitting between the colon and the t. A loop that counts characters confirms both figures.

The line breaks you typed inside triple quotes in the previous section are these same \n characters. A 2-line triple-quoted string and a string written with one pair of quotes and \n in the middle are equal, character for character. Choose triple quotes when the text is long enough that seeing its shape helps, and \n when the string is short or built from parts with +.

A backslash in text you paste from elsewhere, a Windows folder path for instance, is read as the start of an escape. "C:\new folder" contains \n, so the path breaks across 2 lines when printed and the letter n is gone. Doubling every backslash restores the intended characters.

Between its quotes the source line has 29 typed symbols, and the loop counts 24 characters: each of the 5 escapes was typed as 2 symbols and stored as 1. The tab after Plays: puts 12 in the same column as the quoted name, because both labels end before the first tab stop.

A string carries a set of built-in operations called methods. You call one by putting a dot after the string and then the method name with parentheses, the same way you call a function you defined with def, except the string comes first. name.upper() asks the string in name for a copy of itself with every letter in capitals. The 5 case methods below are the ones you will use most.

A method returns a new string and leaves the one it was called on as it was. If you want the converted text, store the result: shout = name.upper(). Calling name.upper() on a line by itself computes the capitals and throws them away, which is the most common mistake with these methods.

After the second line runs, name still prints ada and shout prints ADA. To change what name holds, assign back to it: name = name.upper(), the same shape as growing a string with +.

Text typed by people arrives in whatever case they felt like: Yes, yes, YES. Comparing with == would need a branch per spelling. Lowercasing both sides first collapses them to one spelling, so a single comparison handles them all. The function below returns a boolean, so an if statement can use it directly.

The same trick joins records whose keys were typed by different teams. A warehouse table might store OSLO while a partner's export says Oslo. Lowering both before the comparison, or upper-casing both, makes the match succeed without changing either source.

Only letters have case, so the methods pass every other character through unchanged. title() decides where a word starts by looking for a character that isn't a letter, which gives a surprise on text like 3rd street: the r after the digit is treated as the start of a word and gets capitalized.

To keep a conversion, put the method call on the right of an =. Assigning to a new name keeps both versions, and assigning back to the same name replaces the old text, which is what you want when the original casing has no further use. The program below calls title() twice: once on a line by itself and once in an assignment.

The first print shows lima because the result of the bare call was discarded. The second shows Lima because city now names the new string. A conversion that appears to do nothing is almost always a call whose result nobody stored.