{"id":2648,"date":"2026-10-19T10:30:41","date_gmt":"2026-10-19T10:30:41","guid":{"rendered":"https:\/\/prwatech.in\/blog\/?p=2648"},"modified":"2026-10-20T02:13:27","modified_gmt":"2026-10-20T02:13:27","slug":"python-strings-tutorials-with-examples","status":"publish","type":"post","link":"https:\/\/prwatech.in\/blog\/python\/python-data-types\/python-strings-tutorials-with-examples\/","title":{"rendered":"Python Strings Tutorials with Examples"},"content":{"rendered":"

Python Strings Tutorial for Beginners With Examples<\/b><\/strong><\/h1>\n

Every program works with text. A login form reads a name, a report prints a title, a web scraper pulls headlines from a page, and a chatbot reads what you type. In Python, all of that text lives in one data type: the string. You will use strings in almost every program you ever write, so it pays to learn them properly.<\/p>\n

A string is a sequence of characters, such as letters, digits, spaces and symbols, written inside quotes. Python gives you a rich set of tools for strings: you can join them, cut pieces out, search them, change their case, clean them and fill them with values. One rule surprises every beginner: a string cannot be changed after it is created. We will see what that means and how to work with it.<\/p>\n

In this tutorial, we start with how to write strings and use quotes, then cover multiline strings, joining strings, indexing and slicing. We go through the most useful string methods, with every example run and its real output shown, including f strings, join and the difference between find and index. We end with common mistakes and the full program. The outputs on this page come from a real run on Python 3.13.<\/p>\n

What is a String in Python?<\/h2>\n

A string is an ordered sequence of characters. You create one by putting text inside quotes. Each character has a position, called an index, counted from 0 at the left. You can also count from the right with negative numbers, where minus 1 is the last character.<\/p>\n

    \n
  • Ordered.<\/strong> The characters stay in the order you wrote them.<\/li>\n
  • Indexed.<\/strong> You can reach any character by its position.<\/li>\n
  • Immutable.<\/strong> Once created, a string cannot be changed. Any change makes a new string.<\/li>\n<\/ul>\n

    String Literals in Python<\/h2>\n

    A string literal is text written directly in your code. Python accepts single quotes, double quotes and triple quotes. The first three lines below print the same word:<\/p>\n

    \n
    python<\/div>\n
    print('Python')\r\nprint(\"Python\")\r\nprint('''Python''')<\/pre>\n
    output<\/div>\n
    Python\r\nPython\r\nPython<\/pre>\n<\/div>\n
    Why have two kinds of quote? It lets you put one inside the other without trouble. For example, “It’s easy” works because the apostrophe is safe inside double quotes.<\/p>\n
    How to Assign a String to a Variable?<\/h2>\n
    Give the string a name with an equals sign, then use the name.<\/p>\n
    \n
    python<\/div>\n
    text = \"python\"\r\nprint(text)<\/pre>\n
    output<\/div>\n
    python<\/pre>\n<\/div>\n
    Multiline Strings in Python<\/h2>\n
    Triple quotes, either three single or three double, let a string run across several lines. Line breaks inside become part of the string.<\/p>\n
    \n
    python<\/div>\n
    poem = \"\"\"Welcome to\r\nthe python\r\nworld\"\"\"\r\nprint(poem)<\/pre>\n
    output<\/div>\n
    Welcome to\r\nthe python\r\nworld<\/pre>\n<\/div>\n
    Concatenation of Python Strings<\/h2>\n
    Concatenation means joining strings with a plus sign. Python adds nothing between them, so add a space yourself if you want one.<\/p>\n
    \n
    python<\/div>\n
    x = \"wireless\"\r\ny = \"network\"\r\nprint(x + y)\r\nprint(x + \" \" + y)<\/pre>\n
    output<\/div>\n
    wirelessnetwork\r\nwireless network<\/pre>\n<\/div>\n
    You can also repeat a string with a star:<\/p>\n
    \n
    python<\/div>\n
    print(\"ha\" * 3)<\/pre>\n
    output<\/div>\n
    hahaha<\/pre>\n<\/div>\n
    Strings as Sequences: Indexing<\/h2>\n
    Strings behave like an ordered collection of characters, so you can pick one character by its position. They are not Python arrays, but they do support indexing in the same way. Here is how python is numbered:<\/p>\n
    \n\n\n\n\n\n
    How python is numbered<\/caption>\n
    Letter<\/th>\np<\/td>\ny<\/td>\nt<\/td>\nh<\/td>\no<\/td>\nn<\/td>\n<\/tr>\n
    From the left<\/th>\n0<\/td>\n1<\/td>\n2<\/td>\n3<\/td>\n4<\/td>\n5<\/td>\n<\/tr>\n
    From the right<\/th>\n-6<\/td>\n-5<\/td>\n-4<\/td>\n-3<\/td>\n-2<\/td>\n-1<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    \n
    python<\/div>\n
    a = \"python\"\r\nprint(a[0], a[2], a[-1])\r\nprint(len(a))<\/pre>\n
    output<\/div>\n
    p t n\r\n6<\/pre>\n<\/div>\n
    A single character is itself a string of length 1. A string that starts with a space gives a space at position 0, so check for stray spaces when an index looks wrong.<\/p>\n
    Strings Cannot Be Changed<\/h2>\n
    Try to change a character in place and Python refuses:<\/p>\n
    \n
    python<\/div>\n
    a = \"python\"\r\ntry:\r\n    a[0] = \"P\"\r\nexcept TypeError as error:\r\n    print(\"TypeError:\", error)<\/pre>\n
    output<\/div>\n
    TypeError: 'str' object does not support item assignment<\/pre>\n<\/div>\n
    To get a changed version, build a new string, for example \"P\" + a[1:]<\/code> gives Python.<\/p>\n
    String Slicing<\/h2>\n
    Slicing cuts a piece out of a string. The pattern is string[start:end:step]<\/code>. The start position is included, and the end position is not. Leave out a number and Python uses the beginning or end. Negative numbers count from the right.<\/p>\n
    \n
    python<\/div>\n
    a = \"python\"\r\nprint(a[2:])\r\nprint(a[1:4])\r\nprint(a[-4:-2])\r\nprint(a[:3])\r\nprint(a[::2])\r\nprint(a[::-1])<\/pre>\n
    output<\/div>\n
    thon\r\nyth\r\nth\r\npyt\r\npto\r\nnohtyp<\/pre>\n<\/div>\n
    \n\n\n\n\n\n\n\n\n\n\n
    Slice examples for python<\/caption>\n
    Slice<\/th>\nMeaning<\/th>\nResult for python<\/th>\n<\/tr>\n<\/thead>\n
    a[2:]<\/th>\nFrom position 2 to the end<\/td>\nthon<\/td>\n<\/tr>\n
    a[1:4]<\/th>\nPositions 1, 2 and 3<\/td>\nyth<\/td>\n<\/tr>\n
    a[-4:-2]<\/th>\nFrom 4th last up to, not including, 2nd last<\/td>\nth<\/td>\n<\/tr>\n
    a[:3]<\/th>\nFrom the start up to, not including, 3<\/td>\npyt<\/td>\n<\/tr>\n
    a[::2]<\/th>\nEvery second character<\/td>\npto<\/td>\n<\/tr>\n
    a[::-1]<\/th>\nStep backward, which reverses the string<\/td>\nnohtyp<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    String Functions in Python<\/h2>\n
    Strings come with many built in methods. A method is called with a dot after the string. Python is case sensitive, so the names are all lowercase, strip<\/code> and not Strip<\/code>. Remember that methods do not change the original string. They return a new one.<\/p>\n
    strip()<\/h3>\n
    strip<\/code> removes spaces, tabs and new lines from both ends. lstrip<\/code> does the left end only, and rstrip<\/code> the right end only. Here the repr<\/code> function shows the spaces:<\/p>\n
    \n
    python<\/div>\n
    b = \"   Hello python   \"\r\nprint(repr(b.strip()), repr(b.lstrip()), repr(b.rstrip()))<\/pre>\n
    output<\/div>\n
    'Hello python' 'Hello python   ' '   Hello python'<\/pre>\n<\/div>\n
    len()<\/h3>\n
    len<\/code> is a function, not a string method. It counts the characters, including spaces.<\/p>\n
    \n
    python<\/div>\n
    print(len(\"Pythonworld\"))<\/pre>\n
    output<\/div>\n
    11<\/pre>\n<\/div>\n
    lower() and upper()<\/h3>\n
    They change the case of every letter, and keep spaces.<\/p>\n
    \n
    python<\/div>\n
    t = \"Hello PyThon\"\r\nprint(t.lower())\r\nprint(t.upper())\r\nprint(t.title())\r\nprint(\"hello world\".capitalize())<\/pre>\n
    output<\/div>\n
    hello python\r\nHELLO PYTHON\r\nHello Python\r\nHello world<\/pre>\n<\/div>\n
    title<\/code> makes the first letter of every word a capital. capitalize<\/code> does it only for the first letter of the whole string.<\/p>\n
    replace()<\/h3>\n
    replace<\/code> swaps every matching part of the string for new text.<\/p>\n
    \n
    python<\/div>\n
    print(\"Tree\".replace(\"T\", \"F\"))<\/pre>\n
    output<\/div>\n
    Free<\/pre>\n<\/div>\n
    format() and f Strings<\/h3>\n
    format<\/code> fills the curly braces in a string with values. The value can be a number, text or anything else, not only a number.<\/p>\n
    \n
    python<\/div>\n
    score = 85\r\nprint(\"Your Maths Score is {}\".format(score))<\/pre>\n
    output<\/div>\n
    Your Maths Score is 85<\/pre>\n<\/div>\n
    Modern Python code usually uses f strings instead. Put the letter f before the opening quote and write the name inside braces. You can even do a calculation or set the format inside the braces.<\/p>\n
    \n
    python<\/div>\n
    score = 85\r\nname = \"Asha\"\r\nprint(f\"{name} scored {score} marks, which is {score \/ 100:.0%}\")<\/pre>\n
    output<\/div>\n
    Asha scored 85 marks, which is 85%<\/pre>\n<\/div>\n
    count()<\/h3>\n
    count<\/code> tells you how many times a piece of text appears.<\/p>\n
    \n
    python<\/div>\n
    c = \"This string is immutable\"\r\nprint(c.count(\"i\"))<\/pre>\n
    output<\/div>\n
    4<\/pre>\n<\/div>\n
    find() and index()<\/h3>\n
    Both give the position where the text first appears. The difference is what happens when it is not found. find<\/code> returns minus 1, and index<\/code> raises a ValueError.<\/p>\n
    \n
    python<\/div>\n
    c = \"This string is immutable\"\r\nprint(c.find(\"is\"))\r\nprint(c.find(\"zzz\"))\r\ntry:\r\n    c.index(\"zzz\")\r\nexcept ValueError as error:\r\n    print(\"ValueError:\", error)<\/pre>\n
    output<\/div>\n
    2\r\n-1\r\nValueError: substring not found<\/pre>\n<\/div>\n
    The first is at position 2, inside the word This.<\/p>\n
    split() and join()<\/h3>\n
    split<\/code> breaks a string into a list of pieces at the text you give. With no argument, it splits on spaces. join<\/code> does the opposite. It glues a list of strings together, using the string it is called on as the glue.<\/p>\n
    \n
    python<\/div>\n
    print(\"Primary\".split(\"r\"))\r\nwords = \"to be or not to be\".split()\r\nprint(words)\r\nprint(\"-\".join(words))<\/pre>\n
    output<\/div>\n
    ['P', 'ima', 'y']\r\n['to', 'be', 'or', 'not', 'to', 'be']\r\nto-be-or-not-to-be<\/pre>\n<\/div>\n
    startswith() and endswith()<\/h3>\n
    These check how a string begins or ends. Note that startswith<\/code> checks only the beginning, so it does not test whether a character is present anywhere.<\/p>\n
    \n
    python<\/div>\n
    print(\"network\".startswith(\"w\"), \"wireless\".startswith(\"w\"), \"wireless\".endswith(\"ss\"))<\/pre>\n
    output<\/div>\n
    False True True<\/pre>\n<\/div>\n
    Checking With in and not in<\/h3>\n
    To check whether a character or phrase appears anywhere in a string, use the in<\/code> word. Use not in<\/code> for the opposite. Both give True or False.<\/p>\n
    \n
    python<\/div>\n
    sentence = \"Strings are immutable but lists are mutable\"\r\nprint(\"are\" in sentence, \"sets\" in sentence, \"are\" not in sentence, \"sets\" not in sentence)<\/pre>\n
    output<\/div>\n
    True False False True<\/pre>\n<\/div>\n
    Other Handy Checks<\/h3>\n
    \n
    python<\/div>\n
    print(\"123\".isdigit(), \"abc\".isalpha(), \"abc123\".isalnum())<\/pre>\n
    output<\/div>\n
    True True True<\/pre>\n<\/div>\n
    Escape Characters and Raw Strings<\/h2>\n
    A backslash gives a special meaning to the character after it. It lets you put quotes inside a string and add new lines. A raw string, with an r before the quote, turns this off, which is useful for file paths.<\/p>\n
    \n
    python<\/div>\n
    print(\"She said \\\"hi\\\"\")\r\nprint(\"Line one\\nLine two\")\r\nprint(r\"C:\\new\\table\")<\/pre>\n
    output<\/div>\n
    She said \"hi\"\r\nLine one\r\nLine two\r\nC:\\new\\table<\/pre>\n<\/div>\n
    Quick Reference<\/h2>\n
    \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    String methods at a glance<\/caption>\n
    Method<\/th>\nWhat it does<\/th>\nExample result<\/th>\n<\/tr>\n<\/thead>\n
    strip()<\/th>\nRemoves spaces from both ends<\/td>\n‘Hello python’<\/td>\n<\/tr>\n
    lower(), upper()<\/th>\nChanges case<\/td>\nhello python<\/td>\n<\/tr>\n
    title()<\/th>\nCapital letter on each word<\/td>\nHello Python<\/td>\n<\/tr>\n
    replace(old, new)<\/th>\nSwaps matching text<\/td>\nFree<\/td>\n<\/tr>\n
    find(text)<\/th>\nPosition of text, or minus 1<\/td>\n2<\/td>\n<\/tr>\n
    index(text)<\/th>\nPosition of text, or an error<\/td>\n2<\/td>\n<\/tr>\n
    count(text)<\/th>\nHow often text appears<\/td>\n4<\/td>\n<\/tr>\n
    split(sep)<\/th>\nBreaks into a list<\/td>\n[‘P’, ‘ima’, ‘y’]<\/td>\n<\/tr>\n
    join(list)<\/th>\nGlues a list into a string<\/td>\nto-be-or-not<\/td>\n<\/tr>\n
    startswith(), endswith()<\/th>\nChecks the beginning or end<\/td>\nTrue<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    Common Mistakes<\/h2>\n
      \n
    • Using curly quotes.<\/strong> They look right, but Python rejects them. Type straight quotes in a code editor.<\/li>\n
    • Trying to change a character in place.<\/strong> Strings are immutable, so build a new string.<\/li>\n
    • Forgetting that methods return a new string.<\/strong> Writing text.upper()<\/code> alone changes nothing. Save it with text = text.upper()<\/code>.<\/li>\n
    • Forgetting the space when joining.<\/strong> x + y<\/code> gives wirelessnetwork.<\/li>\n
    • Capital letters in method names.<\/strong> Write strip<\/code>, not Strip<\/code>.<\/li>\n
    • Mixing up the end of a slice.<\/strong> The end position is not included.<\/li>\n
    • Using index when the text may be missing.<\/strong> It raises an error. Use find<\/code>, or check with in<\/code> first.<\/li>\n
    • Joining text and numbers with plus.<\/strong> \"Score: \" + 85<\/code> is a TypeError. Use an f string.<\/li>\n<\/ul>\n
      Try It Yourself: The Full Program<\/h2>\n
      The program below holds every example in this tutorial. Copy it into a file, run it, and compare the output with what you see above.<\/p>\n
      \n
      python<\/div>\n
      import sys\r\nprint(\"Python\", sys.version_info.major, sys.version_info.minor)\r\n\r\n# Creating strings\r\nprint('Python')\r\nprint(\"Python\")\r\nprint('''Python''')\r\ntext = \"python\"\r\nprint(text)\r\n\r\n# Multiline\r\npoem = \"\"\"Welcome to\r\nthe python\r\nworld\"\"\"\r\nprint(poem)\r\n\r\n# Joining and repeating\r\nx = \"wireless\"\r\ny = \"network\"\r\nprint(x + y)\r\nprint(x + \" \" + y)\r\nprint(\"ha\" * 3)\r\n\r\n# Indexing: each character has a position, starting at 0\r\na = \"python\"\r\nprint(a[0], a[2], a[-1])\r\nprint(len(a))\r\ntry:\r\n    a[0] = \"P\"\r\nexcept TypeError as error:\r\n    print(\"TypeError:\", error)\r\n\r\n# Slicing\r\nprint(a[2:])\r\nprint(a[1:4])\r\nprint(a[-4:-2])\r\nprint(a[:3])\r\nprint(a[::2])\r\nprint(a[::-1])\r\n\r\n# Cleaning and changing case\r\nb = \"   Hello python   \"\r\nprint(repr(b.strip()), repr(b.lstrip()), repr(b.rstrip()))\r\nt = \"Hello PyThon\"\r\nprint(t.lower())\r\nprint(t.upper())\r\nprint(t.title())\r\nprint(\"hello world\".capitalize())\r\nprint(\"Tree\".replace(\"T\", \"F\"))\r\n\r\n# Formatting\r\nscore = 85\r\nprint(\"Your Maths Score is {}\".format(score))\r\nname = \"Asha\"\r\nprint(f\"{name} scored {score} marks, which is {score \/ 100:.0%}\")\r\n\r\n# Searching and counting\r\nc = \"This string is immutable\"\r\nprint(c.count(\"i\"))\r\nprint(c.find(\"is\"))\r\nprint(c.find(\"zzz\"))\r\ntry:\r\n    c.index(\"zzz\")\r\nexcept ValueError as error:\r\n    print(\"ValueError:\", error)\r\n\r\n# Splitting and joining\r\nprint(\"Primary\".split(\"r\"))\r\nwords = \"to be or not to be\".split()\r\nprint(words)\r\nprint(\"-\".join(words))\r\n\r\n# Testing\r\nprint(\"network\".startswith(\"w\"), \"wireless\".startswith(\"w\"), \"wireless\".endswith(\"ss\"))\r\nsentence = \"Strings are immutable but lists are mutable\"\r\nprint(\"are\" in sentence, \"sets\" in sentence, \"are\" not in sentence, \"sets\" not in sentence)\r\nprint(\"123\".isdigit(), \"abc\".isalpha(), \"abc123\".isalnum())\r\n\r\n# Escape characters and raw strings\r\nprint(\"She said \\\"hi\\\"\")\r\nprint(\"Line one\\nLine two\")\r\nprint(r\"C:\\new\\table\")<\/pre>\n<\/div>\n