{"id":25560,"date":"2023-04-02T08:08:42","date_gmt":"2023-04-02T02:38:42","guid":{"rendered":"https:\/\/tocxten.com\/?page_id=25560"},"modified":"2023-04-02T18:27:32","modified_gmt":"2023-04-02T12:57:32","slug":"strings","status":"publish","type":"page","link":"https:\/\/tocxten.com\/index.php\/strings\/","title":{"rendered":"Strings"},"content":{"rendered":"\n

In Python, a string is a sequence of characters enclosed within either single quotes (‘ ‘) or double quotes (” “). Strings are one of the basic data types in Python, and they are used to store and manipulate text-based data.<\/p>\n\n\n\n

Example :<\/em><\/strong>\u00a0\u2018Hello World!\u2019<\/strong>\u00a0, \u201cPython Programming<\/strong>\u201c ,\u00a0\u00a0 \u201d\u2019apple<\/em><\/strong>\u201d\u2019<\/p>\n\n\n\n

Creating String<\/strong><\/p>\n\n\n\n

In Python, you can create a string by enclosing a sequence of characters within either single quotes (‘ ‘) or double quotes (” “). Here are some examples:<\/p>\n\n\n\n

my_string_1 = 'This is a string created with single quotes'\r\nmy_string_2 = \"This is a string created with double quotes\"<\/code><\/pre>\n\n\n\n
In these examples, my_string_1<\/code> and my_string_2<\/code> are both strings that contain the text “This is a string created with single quotes” and “This is a string created with double quotes”, respectively.<\/p>\n\n\n\n
You can also create strings that contain special characters such as newlines (\\n) and tabs (\\t):<\/p>\n\n\n\n
my_string_3 = \"This string\\nhas a newline\"\r\nmy_string_4 = \"This string\\t has a tab\"<\/code><\/pre>\n\n\n\n
In these examples, my_string_3<\/code> contains a newline character, which causes the text “has a newline” to appear on a new line, and my_string_4<\/code> contains a tab character, which causes a tab space before the text “has a tab”.<\/p>\n\n\n\n
Example : <\/strong><\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Triple quotes can extend multiple lines as illustrated below<\/strong>\u00a0:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Length of a string<\/strong><\/p>\n\n\n\n
In Python, you can use the built-in len()<\/code> function to get the length of a string, which returns the number of characters in the string. Here’s an example:<\/p>\n\n\n\n
my_string = \"Hello, World!\"\r\nprint(len(my_string)) # Output: 13<\/code><\/pre>\n\n\n\n
In this example, the len()<\/code> function is called on the my_string<\/code> string, which returns the number of characters in the string (which is 13 in this case).<\/p>\n\n\n\n
Note that the len()<\/code> function counts all characters in the string, including spaces and special characters. For example:<\/p>\n\n\n\n
my_string = \"This string\\nhas a newline\"\r\nprint(len(my_string)) # Output: 22<\/code><\/pre>\n\n\n\n
In this example, the my_string<\/code> string contains a newline character (\\n), which is counted as a single character by the len()<\/code> function.<\/p>\n\n\n\n
You can use the length of a string in various ways in your code, such as checking if a string is empty, looping through the characters in a string, or performing string slicing operations.<\/p>\n\n\n\n
You can find the length of a string in Python without using the built-in len()<\/code> function by iterating through the characters in the string using a loop and counting them. Here’s an example:<\/p>\n\n\n\n
my_string = \"Hello, World!\"\r\ncount = 0\r\nfor char in my_string:\r\n    count += 1\r\nprint(count) # Output: 13<\/code><\/pre>\n\n\n\n
In this example, a variable count<\/code> is initialized to 0, and then a for<\/code> loop is used to iterate through each character in the my_string<\/code> string. For each character, the count<\/code> variable is incremented by 1. After the loop has finished, the count<\/code> variable contains the length of the string (which is 13 in this case).<\/p>\n\n\n\n
Note that this method is not as efficient as using the built-in len()<\/code> function, especially for longer strings, because it involves iterating through each character in the string. However, it can be a useful exercise in understanding how strings are represented and manipulated in Python.<\/p>\n\n\n\n
One can get last letter of string using\u00a0len( )<\/strong>\u00a0function as illustrated below :<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
To get the last letter of a string in Python, you can use string indexing with a negative index of -1, which refers to the last character in the string. Here’s an example:<\/p>\n\n\n\n
my_string = \"Hello, World!\"\r\nlast_letter = my_string[-1]\r\nprint(last_letter) # Output: !<\/code><\/pre>\n\n\n\n
In this example, the my_string<\/code> string is indexed using a negative index of -1, which refers to the last character in the string (which is the exclamation mark in this case). The last_letter<\/code> variable is then assigned this character using string indexing.<\/p>\n\n\n\n
Note that this method assumes that the string is not empty. If the string is empty, attempting to index it with -1 will result in an IndexError<\/code>. To avoid this, you should first check if the string is non-empty before indexing it.<\/p>\n\n\n\n
String Indexing<\/strong><\/p>\n\n\n\n
In Python, you can use indexing to access individual characters in a string. String indexing is done by specifying the position of the character within square brackets ([]<\/code>) immediately following the string. There are two types of indexing in Python: positive indexing and negative indexing.<\/p>\n\n\n\n
my_string = \"Hello, World!\"\r\nprint(my_string[0]) # Output: H\r\nprint(my_string[1]) # Output: e\r\nprint(my_string[6]) # Output: ,<\/code><\/pre>\n\n\n\n
In this example, the my_string<\/code> string is indexed using positive indices. The first print<\/code> statement outputs the first character of the string (which is “H”), the second print<\/code> statement outputs the second character of the string (which is “e”), and the third print<\/code> statement outputs the seventh character of the string (which is “,”).<\/p>\n\n\n\n
Negative indexing, on the other hand, starts from the rightmost character of the string, with the index of the last character being -1, the second-to-last character being -2, and so on. For example:<\/p>\n\n\n\n
my_string = \"Hello, World!\"\r\nprint(my_string[-1]) # Output: !\r\nprint(my_string[-2]) # Output: d\r\nprint(my_string[-7]) # Output: <\/code><\/pre>\n\n\n\n
In this example, the my_string<\/code> string is indexed using negative indices. The first print<\/code> statement outputs the last character of the string (which is “!”), the second print<\/code> statement outputs the second-to-last character of the string (which is “d”), and the third print<\/code> statement outputs the seventh-to-last character of the string (which is a space).<\/p>\n\n\n\n
In Python string can be indexed in forward( start to end) and backward(end to start) direction as illustrated in the figure below :<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Consider a string\u00a0name = \u201d Sophia<\/strong>\u201c. Here string Sophia is made up of 6 characters. Each character of the string can be accessed by using either forward indexing or backward indexing as illustrated below:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
String Traversal <\/strong><\/p>\n\n\n\n
String traversal in Python involves iterating over each character of a string. This can be done in both forward and reverse order using loops.Forward traversal using a while loop:<\/p>\n\n\n\n
my_string = \"hello world\"\r\ni = 0\r\nwhile i < len(my_string):\r\n    print(my_string[i])\r\n    i += 1\n# Output:\nh\r\ne\r\nl\r\nl\r\no\r\n\r\nw\r\no\r\nr\r\nl\r\nd<\/code><\/pre>\n\n\n\n
In this example, we initialize the index i<\/code> to 0 and use a while loop to iterate through each character of the string. The loop continues as long as i<\/code> is less than the length of the string. At each iteration, we print the character at the current index i<\/code> and then increment i<\/code> by 1 to move to the next character.<\/p>\n\n\n\n
Forward traversal using a for loop:<\/p>\n\n\n\n
my_string = \"hello world\"\r\nfor char in my_string:\r\n    print(char)\n# output\nh\r\ne\r\nl\r\nl\r\no\r\n\r\nw\r\no\r\nr\r\nl\r\nd<\/code><\/pre>\n\n\n\n
In this example, we use a for loop to iterate through each character of the string. The loop variable char<\/code> takes on the value of each character in the string in turn, allowing us to access and print each character.<\/p>\n\n\n\n
Reverse traversal using a while loop:<\/p>\n\n\n\n
my_string = \"hello world\"\r\ni = len(my_string) - 1\r\nwhile i >= 0:\r\n    print(my_string[i])\r\n    i -= 1\n#Output:\nd\r\nl\r\nr\r\no\r\nw\r\n\r\no\r\nl\r\nl\r\ne\r\nh<\/code><\/pre>\n\n\n\n
In this example, we initialize the index i<\/code> to the last index of the string (which is the length of the string minus one) and use a while loop to iterate through each character of the string in reverse order. The loop continues as long as i<\/code> is greater than or equal to 0. At each iteration, we print the character at the current index i<\/code> and then decrement i<\/code> by 1 to move to the previous character.<\/p>\n\n\n\n
Reverse traversal using a for loop:<\/p>\n\n\n\n
my_string = \"hello world\"\r\nfor char in reversed(my_string):\r\n    print(char)\n#output\nd\r\nl\r\nr\r\no\r\nw\r\n\r\no\r\nl\r\nl\r\ne\r\nh<\/code><\/pre>\n\n\n\n
In this example, we use the built-in reversed()<\/code> function to reverse the order of the characters in the string, and then use a for loop to iterate through each character in the reversed order. The loop variable char<\/code> takes on the value of each character in the string in turn, allowing us to access and print each character.<\/p>\n\n\n\n
Lists aren\u2019t the only data types that represent ordered sequences of values.For example, strings and lists are actually similar, if you consider a string to be a \u201clist\u201d of single text characters. Many of the things you can do with lists\u00a0 can also be done with strings:\u00a0indexing; slicing; and using them with for loops, with len(), and with the in and not in operators<\/em><\/strong>.<\/p>\n\n\n\n
String Slicing<\/strong><\/p>\n\n\n\n
String slicing is a technique in Python that allows you to extract a portion of a string by specifying its start and end positions. This is done using the slice operator :<\/code>. The basic syntax for string slicing is as follows:<\/p>\n\n\n\n
string[start:end:step]<\/code><\/pre>\n\n\n\n
  • start<\/code> is the index of the first character to include in the slice (inclusive)<\/li>
  • end<\/code> is the index of the last character to include in the slice (exclusive)<\/li>
  • step<\/code> is the number of characters to skip between each included character (optional)<\/li><\/ul>\n\n\n\n
    Here are some examples of string slicing:<\/p>\n\n\n\n
    my_string = \"Hello, World!\"\r\n\r\n# Extract the first 5 characters\r\nprint(my_string[0:5])    # Output: \"Hello\"\r\n\r\n# Extract the characters from index 7 to the end\r\nprint(my_string[7:])     # Output: \"World!\"\r\n\r\n# Extract the last 6 characters\r\nprint(my_string[-6:])    # Output: \"World!\"\r\n\r\n# Extract every other character\r\nprint(my_string[::2])    # Output: \"Hlo ol!\"\r\n\r\n# Reverse the string\r\nprint(my_string[::-1])   # Output: \"!dlroW ,olleH\"<\/code><\/pre>\n\n\n\n
    In the first example, we use the slice operator 0:5<\/code> to extract the first 5 characters of the string “Hello, World!”. This includes the characters at indices 0 through 4 (inclusive).<\/p>\n\n\n\n
    In the second example, we use the slice operator 7:<\/code> to extract the characters from index 7 (the ‘W’ in “World!”) to the end of the string. This includes all characters starting at index 7 and continuing to the end of the string.<\/p>\n\n\n\n
    In the third example, we use negative indexing and the slice operator -6:<\/code> to extract the last 6 characters of the string “Hello, World!”. This includes all characters starting 6 positions from the end of the string and continuing to the end of the string.<\/p>\n\n\n\n
    In the fourth example, we use the slice operator ::2<\/code> to extract every other character of the string “Hello, World!”. This includes the first character, then skips the next character, then includes the third character, and so on.<\/p>\n\n\n\n
    In the fifth example, we use negative step and the slice operator [::-1]<\/code> to reverse the string “Hello, World!”. This includes all characters in the string, but they are extracted in reverse order because the step is -1.<\/p>\n\n\n\n
    Example :<\/strong><\/p>\n\n\n\n
    \"\"<\/figure>\n\n\n\n
    • The : <\/strong>operator in slicing [n:m]<\/strong> returns the part of the string from the \u201cn-eth\u201d character to the \u201cm-eth\u201d character, including the \ufb01rst but excluding the last.<\/li>
    • If you omit the \ufb01rst index (before the colon), the slice starts at the beginning of the string.<\/li>
    • If you omit the second index, the slice goes to the end of the string:
      • fruit = \u2018banana\u2019<\/li>
      • fruit[:3]  gives \u2018ban\u2019<\/li>
      • fruit[3:]  gives \u2018ana\u2019<\/li><\/ul><\/li>
      • If the \ufb01rst index is greater than or equal to the second the result is an empty string, represented by two quotation marks:<\/li>
      • fruit = \u2018banana\u2019<\/li>
      • fruit[3:3]     gives  \u2018 \u2018<\/li>
      • An empty string contains no characters and has length 0, but other than that, it is the same as any other string.<\/li><\/ul>\n\n\n\n
        Example : <\/strong><\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        Strings are immutable<\/strong><\/p>\n\n\n\n
        In Python, strings are immutable objects, which means that once a string is created, it cannot be modified. Immutable objects are objects whose state cannot be changed once they are created.<\/p>\n\n\n\n
        When we modify a string in Python, what actually happens is that a new string is created with the desired modifications, while the original string remains unchanged. This is different from mutable objects like lists, where you can modify their elements in place.<\/p>\n\n\n\n
        Here is an example to demonstrate string immutability:<\/p>\n\n\n\n
        my_string = \"hello\"\r\nmy_string[0] = \"H\"    # This will cause an error<\/code><\/pre>\n\n\n\n
        In this example, we try to modify the first character of the string “hello” to be uppercase. However, this will result in a TypeError, because strings are immutable and cannot be modified in place.<\/p>\n\n\n\n
        Instead, we need to create a new string with the desired modifications. Here is an example:<\/p>\n\n\n\n
        my_string = \"hello\"\r\nnew_string = \"H\" + my_string[1:]\r\nprint(new_string)    # Output: \"Hello\"<\/code><\/pre>\n\n\n\n
        In this example, we create a new string by concatenating the uppercase letter “H” with a slice of the original string that starts at index 1 and goes to the end. This creates a new string “Hello” that has the desired modification.<\/p>\n\n\n\n
        Example : The proper way to\u00a0\u2018mutate<\/strong>\u2018 a string is to\u00a0slice<\/strong>\u00a0and\u00a0concatenate\u00a0<\/strong>to build a new string by copying from parts of the old string as illustrated below :<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        Looping and Counting<\/strong><\/p>\n\n\n\n
        Looping over a string: To loop over a string in Python, you can use a for<\/code> loop. In each iteration of the loop, the loop variable will take on the value of the next character in the string. Here is an example:<\/p>\n\n\n\n
        my_string = \"hello\"\r\nfor char in my_string:\r\n    print(char)\n# Output:\nh\r\ne\r\nl\r\nl\r\no<\/code><\/pre>\n\n\n\n
        Counting occurrences of a character in a string: To count the number of occurrences of a specific character in a string, you can use the count()<\/code> method of the string. This method takes a single argument, which is the character to count. Here is an example:<\/p>\n\n\n\n
        my_string = \"hello\"\r\ncount = my_string.count('l')\r\nprint(count)    # Output: 2<\/code><\/pre>\n\n\n\n
        Counting occurrences of a substring in a string: <\/p>\n\n\n\n
        To count the number of occurrences of a substring in a string, you can use a loop and the count()<\/code> method. Here is an example:<\/p>\n\n\n\n
        my_string = \"hello world\"\r\nsubstring = \"l\"\r\ncount = 0\r\nfor char in my_string:\r\n    if char == substring:\r\n        count += 1\r\nprint(count)    # Output: 3<\/code><\/pre>\n\n\n\n
        In this example, we loop over each character in the string and increment a counter if the character matches the substring we are searching for.<\/p>\n\n\n\n
        <\/p>\n\n\n\n
        Example : <\/strong><\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        Example : usage of in operator for strings<\/strong><\/p>\n\n\n\n
        The in<\/code> operator is a built-in operator in Python that is used to check whether a given value is present in a sequence (such as a string, list, or tuple). When used with a string, the in<\/code> operator checks whether a substring is present in the string. Here are some examples:<\/p>\n\n\n\n
        # Check if a substring is present in a string\r\nmy_string = \"hello world\"\r\nsubstring = \"world\"\r\nif substring in my_string:\r\n    print(\"Substring found\")\r\nelse:\r\n    print(\"Substring not found\")\r\n\r\n# Check if a character is present in a string\r\nmy_string = \"hello\"\r\nchar = \"l\"\r\nif char in my_string:\r\n    print(\"Character found\")\r\nelse:\r\n    print(\"Character not found\")\n#Output\nSubstring found\r\nCharacter found<\/code><\/pre>\n\n\n\n
        In the first example, we use the in<\/code> operator to check whether the substring “world” is present in the string “hello world”. Since it is present, the output is “Substring found”.<\/p>\n\n\n\n
        In the second example, we use the in<\/code> operator to check whether the character “l” is present in the string “hello”. Since it is present twice, the output is “Character found”.<\/p>\n\n\n\n
        Note that the in<\/code> operator is case-sensitive. For example, if you search for the substring “World” in the string “hello world”, it will not be found because the capitalization does not match.<\/p>\n\n\n\n
        Example : <\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        String Comparison using ==,< and > operators<\/strong><\/p>\n\n\n\n
        In Python, you can compare strings using the ==<\/code>, <<\/code>, and ><\/code> operators, just like you can with other data types such as numbers. Here’s how each operator works for string comparison:<\/p>\n\n\n\n
        ==<\/code> (equal to) operator: The ==<\/code> operator checks whether two strings have the same content. It returns True<\/code> if the strings are equal and False<\/code> otherwise. Here’s an example:<\/p>\n\n\n\n
        string1 = \"hello\"\r\nstring2 = \"hello\"\r\nif string1 == string2:\r\n    print(\"The strings are equal\")\r\nelse:\r\n    print(\"The strings are not equal\")\n#Output: The strings are equal<\/code><\/pre>\n\n\n\n
        <<\/code> (less than) and ><\/code> (greater than) operators: <\/p>\n\n\n\n
        The <<\/code> and ><\/code> operators compare two strings lexicographically (i.e., in dictionary order). They return True<\/code> if the first string is less than or greater than the second string, respectively, and False<\/code> otherwise. Here’s an example:<\/p>\n\n\n\n
        string1 = \"apple\"\r\nstring2 = \"banana\"\r\nif string1 < string2:\r\n    print(\"string1 comes before string2 in dictionary order\")\r\nelse:\r\n    print(\"string2 comes before string1 in dictionary order\")\n\n#Output: string1 comes before string2 in dictionary order<\/code><\/pre>\n\n\n\n
        Note that the comparison of strings is case-sensitive, meaning that uppercase letters come before lowercase letters in the ASCII table. Also, the <=<\/code> and >=<\/code> operators can also be used for string comparison, which check whether the first string is less than or equal to, or greater than or equal to the second string, respectively.<\/p>\n\n\n\n
        Useful String methods<\/strong><\/p>\n\n\n\n
        Strings are an example of Python objects. An object contains both data ( the actual string itself ) and methods which are effectively functions that are built into the object and are available to any instance of the object. Using the command\u00a0dir(str)<\/strong>\u00a0one can list all the methods supported by python as illustrated below:<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        Table : String Methods and Description<\/strong><\/p>\n\n\n\n
        Method<\/th>Description<\/th><\/tr>
        capitalize()<\/td>Converts the first character to upper case<\/td><\/tr>
        casefold()<\/td>Converts string into lower case<\/td><\/tr>
        center()<\/td>Returns a centered string<\/td><\/tr>
        count()<\/td>Returns the number of times a specified value occurs in a string<\/td><\/tr>
        encode()<\/td>Returns an encoded version of the string<\/td><\/tr>
        endswith()<\/td>Returns true if the string ends with the specified value<\/td><\/tr>
        find()<\/td>Searches the string for a specified value and returns the position of where it was found<\/td><\/tr>
        index()<\/td>Searches the string for a specified value and returns the position of where it was found<\/td><\/tr>
        isalnum()<\/td>Returns True if all characters in the string are alphanumeric<\/td><\/tr>
        isalpha()<\/td>Returns True if all characters in the string are in the alphabet<\/td><\/tr>
        isdigit()<\/td>Returns True if all characters in the string are digits<\/td><\/tr>
        isidentifier()<\/td>Returns True if the string is an identifier<\/td><\/tr>
        islower()<\/td>Returns True if all characters in the string are lower case<\/td><\/tr>
        isnumeric()<\/td>Returns True if all characters in the string are numeric<\/td><\/tr>
        isspace()<\/td>Returns True if all characters in the string are whitespaces<\/td><\/tr>
        istitle()<\/td>Returns True if the string follows the rules of a title<\/td><\/tr>
        isupper()<\/td>Returns True if all characters in the string are upper case<\/td><\/tr>
        ljust()<\/td>Returns a left justified version of the string<\/td><\/tr>
        lower()<\/td>Converts a string into lower case<\/td><\/tr>
        lstrip()<\/td>Returns a left trim version of the string<\/td><\/tr>
        replace()<\/td>Returns a string where a specified value is replaced with a specified value<\/td><\/tr>
        rjust()<\/td>Returns a right justified version of the string<\/td><\/tr>
        rsplit()<\/td>Splits the string at the specified separator, and returns a list<\/td><\/tr>
        rstrip()<\/td>Returns a right trim version of the string<\/td><\/tr>
        split()<\/td>Splits the string at the specified separator, and returns a list<\/td><\/tr>
        startswith()<\/td>Returns true if the string starts with the specified value<\/td><\/tr>
        strip()<\/td>Returns a trimmed version of the string<\/td><\/tr>
        swapcase()<\/td>Swaps cases, lower case becomes upper case and vice versa<\/td><\/tr>
        title()<\/td>Converts the first character of each word to upper case<\/td><\/tr>
        upper()<\/td>Converts a string into upper case<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
        [Source : https:\/\/www.w3schools.com\/python\/python_ref_string.asp]<\/p>\n\n\n\n
        capitalize() : Converts the first character to upper case<\/strong><\/p>\n\n\n\n
        The capitalize()<\/code> method is a built-in method in Python that converts the first character of a string to uppercase and leaves the rest of the string unchanged. If the first character of the string is already in uppercase, then the method has no effect on that character.<\/p>\n\n\n\n
        Here’s an example:<\/p>\n\n\n\n
        my_string = \"hello world\"\r\ncapitalized = my_string.capitalize()\r\nprint(capitalized)   # Output: \"Hello world\"<\/code><\/pre>\n\n\n\n
        In this example, the capitalize()<\/code> method is used to convert the first character of the string \"hello world\"<\/code> to uppercase, resulting in the string \"Hello world\"<\/code>.<\/p>\n\n\n\n
        Note that capitalize()<\/code> does not modify the original string, but returns a new string with the first character capitalized. Also, if the original string is empty, the capitalize()<\/code> method will return an empty string.<\/p>\n\n\n\n
        lower()<\/strong><\/p>\n\n\n\n
        The lower()<\/code> method is a built-in string method in Python that returns a new string with all the alphabetic characters in the original string converted to lowercase.<\/p>\n\n\n\n
        Here’s an example:<\/p>\n\n\n\n
        my_string = \"Hello, World!\"\r\nlowercase_string = my_string.lower()\r\nprint(lowercase_string)\n# Output: hello, world!<\/code><\/pre>\n\n\n\n
        In this example, the lower()<\/code> method is called on the my_string<\/code> variable and the returned value is assigned to the lowercase_string<\/code> variable. The original string my_string<\/code> is not modified, instead a new string is created with all alphabetic characters in lowercase.<\/p>\n\n\n\n
        Note that lower()<\/code> method only works with alphabetic characters, and any non-alphabetic characters (such as punctuation, numbers, and spaces) are not affected by the method.<\/p>\n\n\n\n
        Example : <\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        upper()<\/strong><\/p>\n\n\n\n
        The upper()<\/code> method is a built-in string method in Python that is used to convert all the lowercase characters in a string to uppercase characters. The method takes no arguments and returns a new string with all the characters in uppercase.<\/p>\n\n\n\n
        Here’s an example:<\/p>\n\n\n\n
        text = \"hello, world!\"\r\nuppercase_text = text.upper()\r\nprint(uppercase_text)\n# Output : HELLO, WORLD!<\/code><\/pre>\n\n\n\n
        In the above example, the upper()<\/code> method is used to convert all the lowercase characters in the string text<\/code> to uppercase characters. The resulting string is then stored in the variable uppercase_text<\/code> and printed to the console.<\/p>\n\n\n\n
        It’s important to note that the upper()<\/code> method does not modify the original string, but instead returns a new string with all the characters in uppercase. If you want to modify the original string, you can assign the result of the upper()<\/code> method back to the original variable:<\/p>\n\n\n\n
        text = \"hello, world!\"\r\ntext = text.upper()\r\nprint(text)\n# Output : HELLO, WORLD!<\/code><\/pre>\n\n\n\n
        Example :<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        casefold(): Converts string into lower case<\/strong><\/p>\n\n\n\n
        Actually, the casefold()<\/code> method in Python is used to convert a string into a lowercase string, just like the lower()<\/code> method. However, the casefold()<\/code> method is more aggressive in its conversion and is often preferred over the lower()<\/code> method when dealing with case-insensitive string comparisons.<\/p>\n\n\n\n
        The casefold()<\/code> method removes all case distinctions from a string and converts it into a form that is suitable for case-insensitive comparisons. This method also handles some special cases, such as the German “sharp s” character (\u00df), which is converted to “ss” when casefolded.<\/p>\n\n\n\n
        Here’s an example:<\/p>\n\n\n\n
        text = \"Hello, World!\"\r\nlowercase_text = text.casefold()\r\nprint(lowercase_text)\n#output\nhello, world!<\/code><\/pre>\n\n\n\n
        In the above example, the casefold()<\/code> method is used to convert the string text<\/code> to lowercase. The resulting string is then stored in the variable lowercase_text<\/code> and printed to the console.<\/p>\n\n\n\n
        Just like the lower()<\/code> method, the casefold()<\/code> method does not modify the original string, but instead returns a new string with all the characters in lowercase. If you want to modify the original string, you can assign the result of the casefold()<\/code> method back to the original variable:<\/p>\n\n\n\n
        text = \"Hello, World!\"\r\ntext = text.casefold()\r\nprint(text)\n# Output:\nhello, world!<\/code><\/pre>\n\n\n\n
        Example:<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        <\/p>\n\n\n\n
        center() : Returns a centered string<\/strong><\/p>\n\n\n\n
        The center()<\/code> method is a built-in string method in Python that returns a centered string. It takes two arguments: width<\/code>, which specifies the total width of the resulting string, and an optional fillchar<\/code> argument that specifies the character to be used for padding.<\/p>\n\n\n\n
        Here’s the syntax for center()<\/code> method:<\/p>\n\n\n\n
        string.center(width[, fillchar])<\/code><\/pre>\n\n\n\n
        The width<\/code> argument is required, and must be a positive integer. The fillchar<\/code> argument is optional, and must be a string of length 1. If fillchar<\/code> is not specified, a space character is used for padding.<\/p>\n\n\n\n
        Here’s an example of how to use the center()<\/code> method:<\/p>\n\n\n\n
        string = \"Hello\"\r\nwidth = 10\r\nfillchar = \"*\"\r\ncentered_string = string.center(width, fillchar)\r\nprint(centered_string)\n# Output:\n**Hello***<\/code><\/pre>\n\n\n\n
        In this example, the original string \"Hello\"<\/code> is centered in a string of width 10<\/code> with the fill character *<\/code>, resulting in the string **Hello***<\/code>.<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        swapcase()<\/strong><\/p>\n\n\n\n
        swapcase()<\/code> is a built-in string method in Python that returns a new string where the case of each character in the original string is swapped. In other words, all uppercase characters are converted to lowercase, and all lowercase characters are converted to uppercase.<\/p>\n\n\n\n
        Here’s the syntax for swapcase()<\/code> method:<\/p>\n\n\n\n
        string.swapcase()<\/code><\/pre>\n\n\n\n
        Here’s an example of how to use the swapcase()<\/code> method:<\/p>\n\n\n\n
        string = \"Hello World\"\r\nswapped_string = string.swapcase()\r\nprint(swapped_string)\n#Output: hELLO wORLD<\/code><\/pre>\n\n\n\n
        In this example, the original string \"Hello World\"<\/code> is swapped using the swapcase()<\/code> method, resulting in the string \"hELLO wORLD\"<\/code>.<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        find()<\/strong><\/p>\n\n\n\n
        find()<\/code> is a built-in string method in Python that returns the lowest index of the first occurrence of a specified substring within a string. If the substring is not found, it returns -1.<\/p>\n\n\n\n
        Here’s the syntax for find()<\/code> method:<\/p>\n\n\n\n
        string.find(substring[, start[, end]])<\/code><\/pre>\n\n\n\n
        The substring<\/code> argument is required, and specifies the substring to be searched within the string. The start<\/code> and end<\/code> arguments are optional, and specify the starting and ending index positions for the search. If start<\/code> is not specified, the search starts from the beginning of the string. If end<\/code> is not specified, the search goes until the end of the string.<\/p>\n\n\n\n
        Here’s an example of how to use the find()<\/code> method:<\/p>\n\n\n\n
        string = \"Hello World\"\r\nsubstring = \"World\"\r\nindex = string.find(substring)\r\nprint(index)\n# output : 6<\/code><\/pre>\n\n\n\n
        In this example, the find()<\/code> method is used to search for the substring \"World\"<\/code> within the string \"Hello World\"<\/code>. The method returns the lowest index of the substring, which is 6<\/code>.<\/p>\n\n\n\n
        If the substring is not found within the string, the find()<\/code> method returns -1:<\/p>\n\n\n\n
        string = \"Hello World\"\r\nsubstring = \"Universe\"\r\nindex = string.find(substring)\r\nprint(index)\n# Output: -1<\/code><\/pre>\n\n\n\n
        Example : <\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        count()<\/strong><\/p>\n\n\n\n
        count()<\/code> is a built-in string method in Python that returns the number of occurrences of a specified substring within a string.Here’s the syntax for count()<\/code> method:<\/p>\n\n\n\n
        string.count(substring[, start[, end]])<\/code><\/pre>\n\n\n\n
        The substring<\/code> argument is required, and specifies the substring to be counted within the string. The start<\/code> and end<\/code> arguments are optional, and specify the starting and ending index positions for the count. If start<\/code> is not specified, the count starts from the beginning of the string. If end<\/code> is not specified, the count goes until the end of the string.Here’s an example of how to use the count()<\/code> method:<\/p>\n\n\n\n
        string = \"Hello World\"\r\nsubstring = \"l\"\r\ncount = string.count(substring)\r\nprint(count)\n# output : 3<\/code><\/pre>\n\n\n\n
        In this example, the count()<\/code> method is used to count the number of occurrences of the substring \"l\"<\/code> within the string \"Hello World\"<\/code>. The method returns the number of occurrences, which is 3<\/code>.<\/p>\n\n\n\n
        You can also use the count()<\/code> method to count the occurrences of a substring within a specific range of the string:<\/p>\n\n\n\n
        string = \"Hello World\"\r\nsubstring = \"l\"\r\nstart = 3\r\nend = 8\r\ncount = string.count(substring, start, end)\r\nprint(count)\n#Output : 1<\/code><\/pre>\n\n\n\n
        In this example, the count()<\/code> method is used to count the number of occurrences of the substring \"l\"<\/code> within the range of the string \"lo Wo\"<\/code>, which starts from index 3<\/code> and ends at index 8<\/code>. The method returns the number of occurrences within the range, which is 1<\/code>.<\/p>\n\n\n\n
        Example : <\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        strip(), lstrip() and rstrip()<\/strong><\/p>\n\n\n\n
        strip()<\/code>, lstrip()<\/code>, and rstrip()<\/code> are built-in string methods in Python that remove leading and\/or trailing characters from a string. strip()<\/code> removes leading and trailing whitespace characters (spaces, tabs, newlines) from a string. Here’s the syntax for strip()<\/code> strip()<\/code>, lstrip()<\/code>, and rstrip()<\/code> methods:<\/p>\n\n\n\n
        string.strip([characters])\nstring.lstrip([characters])\nstring.rstrip([characters])<\/code><\/pre>\n\n\n\n
        The characters<\/code> argument is optional, and specifies the characters to be removed from both ends of the string. If characters<\/code> is not specified, it removes whitespace characters by default.<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        startswith() and endswith()<\/strong><\/p>\n\n\n\n
        startswith()<\/code> and endswith()<\/code> are built-in string methods in Python that are used to check whether a string starts with or ends with a specific substring, respectively.<\/p>\n\n\n\n
        • startswith()<\/code> returns True<\/code> if the string starts with the specified substring, and False<\/code> otherwise.<\/li>
        • endswith()<\/code> returns True<\/code> if the string ends with the specified substring, and False<\/code> otherwise.<\/li><\/ul>\n\n\n\n
          Here’s the syntax for startswith()<\/code> and endswith() method:<\/p>\n\n\n\n
          string.startswith(substring[, start[, end]])\nstring.endswith(substring[, start[, end]])<\/code><\/pre>\n\n\n\n
          Example : <\/p>\n\n\n\n
          \"\"<\/figure>\n\n\n\n
          split()<\/strong><\/p>\n\n\n\n
          split()<\/code> is a built-in string method in Python that is used to split a string into a list of substrings based on a specified separator.<\/p>\n\n\n\n
          Here’s the syntax for split()<\/code> method:<\/p>\n\n\n\n
          string.split(sep=None, maxsplit=-1)<\/code><\/pre>\n\n\n\n
          The sep<\/code> argument is optional, and specifies the separator to use for splitting the string. If sep<\/code> is not specified, the default separator is whitespace.<\/p>\n\n\n\n
          The maxsplit<\/code> argument is optional, and specifies the maximum number of splits to be performed. If maxsplit<\/code> is not specified or set to -1<\/code>, all possible splits are performed.<\/p>\n\n\n\n
          Here’s an example of how to use the split()<\/code> method:<\/p>\n\n\n\n
          string = \"Hello World\"\r\nwords = string.split()\r\nprint(words)\n# ['Hello', 'World']<\/code><\/pre>\n\n\n\n
          Example :<\/p>\n\n\n\n
          string = \"apple,banana,orange\"\r\nfruits = string.split(\",\")\r\nprint(fruits)\n#output: ['apple', 'banana', 'orange']<\/code><\/pre>\n\n\n\n
          Example:<\/p>\n\n\n\n
          \"\"<\/figure>\n\n\n\n
          Example :<\/p>\n\n\n\n
          \"\"<\/figure>\n\n\n\n
          join() <\/strong><\/p>\n\n\n\n
          join()<\/code> is a built-in method in Python that can be used to concatenate a sequence of strings into a single string. The method takes an iterable, such as a list or tuple, and concatenates each element in the iterable into a single string with a separator between them.<\/p>\n\n\n\n
          Here’s an example of how to use join()<\/code><\/p>\n\n\n\n
          words = [\"hello\", \"world\", \"!\"]\r\nseparator = \" \"\r\n\rsentence = separator.join(words)\r\nprint(sentence)\n#output: hello world !<\/code><\/pre>\n\n\n\n
          In this example, we create a list of words and a separator string. We then use the join()<\/code> method to concatenate the words in the list into a single string, with the separator between each word. The resulting string is assigned to the sentence<\/code> variable and printed to the console.<\/p>\n\n\n\n
          Note that the join()<\/code> method can be used with any iterable that contains strings, not just lists. Additionally, the separator string can be any string value, including an empty string.<\/p>\n\n\n\n
          \"\"<\/figure>\n\n\n\n
          ASCII VALUES<\/strong><\/p>\n\n\n\n
          \"\"<\/figure>\n\n\n\n
          \"\"<\/figure>\n\n\n\n
          To print ASCII character for given ASCII Value:<\/strong><\/p>\n\n\n\n
          \"\"<\/figure>\n\n\n\n
          Python String Operators <\/strong><\/p>\n\n\n\n
          Python provides several operators that can be used with strings. Here are some of the most commonly used string operators in Python:<\/p>\n\n\n\n
          1. +<\/code> (concatenation operator): This operator is used to concatenate two or more strings. For example:<\/li><\/ol>\n\n\n\n
            string1 = \"Hello\"\r\nstring2 = \"world\"\r\nresult = string1 + \" \" + string2\r\nprint(result)\n#Output:  Hello world<\/code><\/pre>\n\n\n\n
            2. *<\/code> (repetition operator): This operator is used to repeat a string a certain number of times. For example:<\/p>\n\n\n\n
            string = \"spam\"\r\nresult = string * 3\r\nprint(result)\n# output: spamspamspam<\/code><\/pre>\n\n\n\n
            3. in<\/code> and not in<\/code> (membership operators): These operators are used to check if a string is present in another string. For example:<\/p>\n\n\n\n
            string = \"hello world\"\r\nprint(\"hello\" in string)  # True\r\nprint(\"goodbye\" not in string)  # True<\/code><\/pre>\n\n\n\n
            4. %<\/code> (string formatting operator): This operator is used to format a string with variables. For example:<\/p>\n\n\n\n
            name = \"Alice\"\r\nage = 30\r\nresult = \"My name is %s and I'm %d years old.\" % (name, age)\r\nprint(result)\n# output: My name is Alice and I'm 30 years old.<\/code><\/pre>\n\n\n\n
            5. []<\/code> (indexing operator): This operator is used to access individual characters in a string. For example:<\/p>\n\n\n\n
            string = \"hello\"\r\nprint(string[0])  # 'h'\r\nprint(string[-1])  # 'o'<\/code><\/pre>\n\n\n\n
            6. Range slicing, denoted by [:]<\/code>, is a way to extract a substring from a string in Python. It works by specifying the start and end indices of the substring that you want to extract. For example, consider the following string:<\/p>\n\n\n\n
            s = \"hello world\"\nTo extract the substring \"hello\", you can use the range slicing syntax s[0:5]:\nsubstring = s[0:5]\r\nprint(substring)\nOutput:\nhello\nIn this example, s[0:5] specifies the range from index 0 (inclusive) to index 5 (exclusive), which corresponds to the substring \"hello\".\r\n\r\nYou can also omit the starting or ending index to specify a range that starts from the beginning or ends at the end of the string, respectively. For example, s[:5] extracts the substring \"hello\", and s[6:] extracts the substring \"world\".\nsubstring1 = s[:5]\r\nsubstring2 = s[6:]\r\nprint(substring1)\r\nprint(substring2)\n# output :\nhello\r\nworld\nRange slicing can also be used with negative indices, which count from the end of the string. For example, s[-5:-1] extracts the substring \"worl\".\nsubstring = s[-5:-1]\r\nprint(substring)\n# output:\nworl<\/code><\/pre>\n\n\n\n
            Range slicing is a powerful feature in Python strings that allows you to extract substrings quickly and easily.<\/p>\n\n\n\n
            Format Operators<\/strong><\/p>\n\n\n\n
            Format operators are used in print statement . There are two format operators :<\/p>\n\n\n\n
            1. %<\/strong><\/li>
            2. format<\/strong>()<\/li><\/ol>\n\n\n\n
              Both %<\/code> and format()<\/code> are string formatting operators in Python that allow you to insert values into a string.<\/p>\n\n\n\n
              \u00a0% operator:<\/strong><\/p>\n\n\n\n
              Syntax <\/strong>:<\/p>\n\n\n\n
              print(\"%s1  %s2  %s3 ------\"%(arg1,arg2,arg3,------argn)) <\/strong>\n\nHere, \ns1,s2 ,..........sn are conversion specifiers like d<\/strong>(for int ),f<\/strong>(for float),s<\/strong>(for string) ,etc. \nand \narg1,arg2....argn are variables or values.\n\nThe %<\/code> operator is an older way to format strings and is based on C-style string formatting. It uses placeholders in the string, such as %s<\/code> and %d<\/code>, to indicate where variables should be inserted. Here's an example:\n<\/pre>\n\n\n\n
              name = \"Alice\"\r\nage = 30\r\nresult = \"My name is %s and I'm %d years old.\" % (name, age)\r\nprint(result)\n# Output:\nMy name is Alice and I'm 30 years old.<\/code><\/pre>\n\n\n\n
              In this example, %s<\/code> is a placeholder for a string value and %d<\/code> is a placeholder for an integer value. The variables name<\/code> and age<\/code> are inserted into the string using the %<\/code> operator.<\/p>\n\n\n\n
              Example :<\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              format() function<\/strong><\/p>\n\n\n\n
              Syntax :<\/strong><\/p>\n\n\n\n
              print('{0} {1} ......{n}'.format(agr1,agr2,agr3....argn)\nHere,\n    0,1,2,------are position specifiers  \nand \n    arg1,arg2,-----argn are variables\/values<\/pre>\n\n\n\n
              The format()<\/code> method is a newer way to format strings and is more versatile than the %<\/code> operator. It uses curly braces {}<\/code> to indicate where variables should be inserted. Here’s an example:<\/p>\n\n\n\n
              name = \"Alice\"\r\nage = 30\r\nresult = \"My name is {} and I'm {} years old.\".format(name, age)\r\nprint(result)\n#\nMy name is Alice and I'm 30 years old.<\/code><\/pre>\n\n\n\n
              Example :<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              Sample Programs<\/strong>:<\/p>\n\n\n\n
              1.Write a Python Program to Check if the String is Symmetrical or Palindrome<\/strong>:<\/p>\n\n\n\n
              A\u00a0string\u00a0is said to be symmetrical if both halves of the string are the same, and a string is said to be a palindrome if one half of the string is the opposite of the other half or if the string appears the same whether read forward or backward.<\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              Output 1 :<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              Output 2<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              2. Write a Python Program to find the length of string<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              Output :<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              3. Write a Python Program to Count the Number of Digits, Alphabets, and Other Characters in a String<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              Output :<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              4. Write a Python Program to Count the Number of Vowels in a String<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              5. Write a Python Program to Split and Join a String<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              6. Write a Python program to display a largest word from a string<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              7. Write a Python program to display unique words from a string<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              8.Write a Program to accept a word and display a ASCII value of each character of words<\/strong><\/p>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              Questions for Practice<\/strong>:<\/p>\n\n\n\n
              1. Define String? Explain at least 5 String functions with examples.<\/li>
              2. Write a python program to display presence of given substring in main string.<\/li>
              3. Define Tuple , List , Strings and Dictionary in Python.<\/li>
              4. List any six methods associated with string and explain each of them with example.<\/li>
              5. Write a Python program to swap cases of a given string .
                • Input : Java<\/li>
                • Output : jAVA<\/li><\/ul><\/li>
                • Explain the various string methods for the following operations with examples.
                  • Removing white space characters from the beginning end or both sides of a string<\/li>
                  • To right -justify , left justify and center a string<\/li><\/ul><\/li>
                  • What are escape characters?<\/li>
                  • What do the \\n and \\t escape characters represent?<\/li>
                  • How can you put a \\ backslash character in a string?<\/li>
                  • The string value \u201cHowl\u2019s Moving Castle\u201d is a valid string. Why isn\u2019t it
                    a problem that the single quote character in the word Howl\u2019s isn\u2019t
                    escaped?<\/li>
                  • If you don\u2019t want to put \\n in your string, how can you write a string
                    with newlines in it?<\/li>
                  • What do the following expressions evaluate to?
                    \u2022 \u2018Hello world!'[1]
                    \u2022 \u2018Hello world!'[0:5]
                    \u2022 \u2018Hello world!'[:5]
                    \u2022 \u2018Hello world!'[3:]<\/li>
                  • What do the following expressions evaluate to?
                    • \u2022 \u2018Hello\u2019.upper()<\/li>
                    • \u2022 \u2018Hello\u2019.upper().isupper()<\/li>
                    • \u2022 \u2018Hello\u2019.upper().lower()<\/li><\/ul><\/li>
                    • What do the following expressions evaluate to?
                      • \u2022 \u2018Remember, remember, the fifth of November.\u2019.split()<\/li>
                      • \u2022 \u2018-\u2018.join(\u2018There can be only one.\u2019.split())<\/li><\/ul><\/li>
                      • What string methods can you use to right-justify, left-justify, and center a string?<\/li>
                      • How can you trim whitespace characters from the beginning or end of
                        a string?<\/li>
                      • Write a Python program to calculate the length of a string.<\/li>
                      • Write a program to check if the letter \u2018e\u2019 is present in the word \u2018Umbrella\u2019.<\/li>
                      • Write a program to check if the word \u2018orange\u2019 is present in the \u201cThis is orange juice\u201d.<\/li>
                      • Write a program to find the first and the last occurence of the letter \u2018o\u2019 and character \u2018,\u2019 in \u201cHello, World\u201d.<\/li>
                      • Write a program that takes your full name as input and displays the abbreviations of the first and middle names<\/li>
                      • except the last name which is displayed as it is. For example, if your name is Robert Brett Roser, then the output should be R.B.Roser.<\/li>
                      • Write a program to find the number of vowels, consonents, digits and white space characters in a string.<\/li>
                      • Write a program to make a new string with all the consonents deleted from the string \u201cHello, have a good day\u201d<\/li>
                      • Write a Python program to count the number of characters (character frequency) in a string.<\/li>
                      • Write the string after the first occurrence of \u2018,\u2019 and the string after the last occurrence of \u2018,\u2019 in the string \u201cHello, Good, Morning\u201d. World\u201d.<\/li>
                      • Write a program to print every character of a string entered by user in a new line using loop.<\/li>
                      • Write a program to find the length of the string \u201crefrigerator\u201d without using len function.<\/li>
                      • Write a program to check if the letter \u2018e\u2019 is present in the word \u2018Umbrella\u2019.<\/li>
                      • Write a program to check if the word \u2018orange\u2019 is present in the \u201cThis is orange juice\u201d.<\/li>
                      • Write a program to find the first and the last occurence of the letter \u2018o\u2019 and character \u2018,\u2019 in \u201cHello, World\u201d.<\/li>
                      • Write a program that takes your full name as input and displays the abbreviations of the first and middle names except the last name which is displayed as it is. For example, if your name is Robert Brett Roser, then the output should be R.B.Roser.<\/li>
                      • Check the occurrence of the letter \u2018e\u2019 and the word \u2018is\u2019 in the sentence \u201cThis is umbrella\u201d.<\/li>
                      • Write a program to find the number of vowels, consonents, digits and white space characters in a string.<\/li>
                      • Write a program to make a new string with all the consonents deleted from the string \u201cHello, have a good day\u201d.<\/li><\/ol>\n","protected":false},"excerpt":{"rendered":"
                        In Python, a string is a sequence of characters enclosed within either single quotes (‘ ‘) or double quotes (” “). Strings are one of the basic data types in…<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":"","_links_to":"","_links_to_target":""},"class_list":["post-25560","page","type-page","status-publish","hentry"],"post_mailing_queue_ids":[],"_links":{"self":[{"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/pages\/25560","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/comments?post=25560"}],"version-history":[{"count":105,"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/pages\/25560\/revisions"}],"predecessor-version":[{"id":25775,"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/pages\/25560\/revisions\/25775"}],"wp:attachment":[{"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/media?parent=25560"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}