#strings in python

Python Strings | Strings in Python | Python from Basics to Exploratory ...

This is a quick documentation on Python string operations.

Writing string to variable (assignment) using equal (=) operator

a = "test string" print(a)

test string

Line-breaks within a string (multi-line string) using three quotes

b = """This is first line, second line, thrid line""" print(b)

This is first line, second line, thrid line

Strings can be handled as if they…

This post is the eighth of many that attempts to document everything I have been learning about Python.

Strings are ordered collections of single characters. They are part of the family of sequences. Python does not have a type that is used to represent single characters.

You create a string by enclosing a piece of data in either single or double quotes.

You can run built-in sequence operations on strings.

>>> cartmans_song = 'The lazy river has never been lazier' >>> # Built-in sequence operations >>> len(cartmans_song) 36

Strings can have escape characters embedded in them. You start a special character using a \ backslash. Internally, these are just replaced with their ASCII values.

>>> # \n is a new line escape character >>> str_with_escape_char = 'the lazy river \nhas never been lazier' >>> print(str_with_escape_char) the lazy river has never been lazier >>>

Raw strings are useful when you don’t want to interpret a backslash as start of a special character. To indicate that a string is a raw string, add a r or R before the opening quote. A raw string cannot end in a single backslash.

>>> raw_string = r'This is a raw string. Escape chars will be \n igonred' >>> print(raw_string) This is a raw string. Escape chars will be \n igonred >>>

Triple quotes are used when you want to represent multiline strings. You can use either single or double quotes. These strings are displayed as-is, which means that if you have any line breaks in the string, it will be displayed with those line breaks.

>>> >>> triple_quoted_string = """Eric Cartman Stan Marsh Kyle Broflovski Kenny McCormik""" >>> >>> triple_quoted_string 'Eric Cartman\nStan Marsh\nKyle Broflovski\nKenny McCormik' >>> >>> print(triple_quoted_string) Eric Cartman Stan Marsh Kyle Broflovski Kenny McCormik >>>

Python will always display a non printable character using the hex notation.

Basic String Operations

len() to find the length of the string.

+ for concatenation, * for repetition, these operators are overloaded for the string type.

in can be used to check for membership, it is like the find() string method, but instead of returning the offset it returns a bool value.

>>> cartmans_song = 'the lazy river has never been lazier' >>> >>> # use the in memebership operator to search for a string within another string >>> 'lazy' in cartmans_song True >>> >>> cartmans_song = 'The lazy river has never been lazier' >>> # gets the length of the string >>> len(cartmans_song) 36 >>> # concatenate >>> 'New England' + ' Patriots' 'New England Patriots' >>> >>> # repeat >>> 'But maa ' * 4 'But maa But maa But maa But maa ' >>>

Indexing

You can retrieve specific characters from a string by specifying the index. The offset starts at 0. You can also specify a negative index to specify the offsets from right. The rightmost offset is -1.

>>> cartmans_song = 'The lazy river has never been lazier' >>> # gets the character at the first offset >>> cartmans_song[0] 'T' >>> # gets the character at the last offset >>> cartmans_song[-1] 'r' >>>

Slicing

You can parse out a set of characters from a string using slicing.

S[i:j] - start at the offset i and get all characters up to but not including j. You can also choose to omit the lower and upper bound, in which case they will switch to using defaults which is 0 for lower bound and the length of the string for the upper bound.

>>> cartmans_song = 'The lazy river has never been lazier' >>> cartmans_song[4:30] 'lazy river has never been ' >>> cartmans_song[:30] 'The lazy river has never been ' >>> cartmans_song[4:] 'lazy river has never been lazier' >>>

If you slice without specifying either bounds, you are effectively creating another object in memory, it will have the same value as the string you are slicing.

>>> # this just creates a new string >>> new_str = cartmans_song[:] >>> new_str 'The lazy river has never been lazier' >>>

Slicing using 3 indexes

S[i:j:k] here k is called the step, so you start from i through j by stepping through k number of characters. If you omit both i and j and use -1 as k, you are effectively reversing a string, also if you do specify i, j and a k with a negative offset the lower(i) and upper(j) bounds get reversed.

>>> cartmans_song = 'The lazy river has never been lazier' >>> # start from the beginning and print every 4th character >>> cartmans_song[0:36:4] 'Tl eae nz' >>> # negative step index, reverses the bounds. >>> cartmans_song[36:0:-1] 'reizal neeb reven sah revir yzal eh' >>> cartmans_song[::-1] 'reizal neeb reven sah revir yzal ehT' >>>

You can use a slice object in the index to get a slice:

>>> cartmans_song[slice(1,4)] 'he ' >>> cartmans_song[slice(None, None)] 'The lazy river has never been lazier' >>>

Conversions

To convert something to a string you can pass it to the str() method.

You can convert a character to its ASCII value by passing it to the ord() method.

You can convert a number to its equivalent character by passing it to the chr() method

You can use string formatting expressions to generate strings.

>>> >>> # Create a new string >>> new_string = str("this is a new string") >>> >>> # get the ASCII value of a character >>> ord('a') 97 >>> >>> # get the character by passing in a ASCII value >>> chr(97) 'a' >>> >>> # string formatting expression. >>> '{0} is a string'.format('this') 'this is a string' >>>

String methods

Built-in operators and expressions can be used on a variety of types, string methods can only be used on the string type.

Some string methods:

find() - returns the offset where it finds the string.

replace() - replaces all occurrences of the pattern with the passed in second argument, if you pass in a third arugment, it will replace it only for those many number of occurences.

join() - takes in any iterable as a parameter and joins the values in that iterable by using the string it is being called on as a delimiter.

split() will split a string into a list based on a delimiter which is passed in.

>>> >>> # Create a new string >>> new_string = str("this is a new string") >>> >>> # get the ASCII value of a character >>> ord('a') 97 >>> >>> # get the character by passing in a ASCII value >>> chr(97) 'a' >>> >>> # string formatting expression. >>> '{0} is a string'.format('this') 'this is a string' >>> >>> # find the offset in the string that matches the argument. >>> new_string.find('is') 2 >>> # replace one value with another. >>> new_string.replace('string', 'simple string') 'this is a new simple string' >>> >>> # join a iterable using the string on which the join operation is being called on. >>> '.'.join('string') 's.t.r.i.n.g' >>> >>> # upper case >>> new_string.upper() 'THIS IS A NEW STRING' >>> >>> # check if all the values are alphabets >>> new_string.isalpha() False >>> cartmans_song = 'the lazy river has never been lazier' >>> >>> # split the string using a empty space as the delimiter >>> cartmans_song.split(' ') ['the', 'lazy', 'river', 'has', 'never', 'been', 'lazier'] >>>

String module in older 2.x had most of these string methods, it has been removed in 3.0. You should always use string methods not the methods in the old string module. The string module itself has been retained because it contains some other advanced string processing tools.

String formatting expressions

You can use string formatting expressions to create strings. You can use formatting characters as place holders and use a single value to the right hand of the % or use a tuple in case of multiple values.

You can also pull up values from a dictionary by using:

>>> '%(first)s %(second)d' % {'first' : 'eric', 'second' : 5} 'eric 5' >>>

The built in function vars(), generates a dictionary of all the variables and values that have been loaded in the current thread, you can use this on the right hand side of the % to pull values for formatting strings using a dictionary.

String formatting methods

You can use the format method in Python to create strings. This is new in 2.6 and 3.x. You have to use either positional or named arguments. You can also use object attributes.

>>> >>> # positional string formatting. >>> "{0} and {1}".format("Eric", "Stan") 'Eric and Stan' >>> >>> # named string formatting. >>> >>> "{0[eric]}".format({"eric" : "cartman"}) 'cartman' >>> >>> # string formatting using object attributes >>> import sys >>> "{0.platform}".format(sys) 'win32' >>> >>> # variant of string formatting using object attributes >>> "{names[SouthPark]}, {sys.platform}".format(names = {"SouthPark" : "Eric Cartman"}, sys = sys) 'Eric Cartman, win32' >>>

You can use list indexes or dictionary names as the values in the squared brackets

You cannot use negative index offsets in the string literal that is being used as a template.

You can use the formatting method to specify left / right justification, alignment and precision.

The format built in function calls the types internal format method.

You can in 3.1 and later skip the positional index all together, and Python will use relative indexing.

You can in 3.1 and later, use a comma to print out numbers with comma sperating thousands

This post is the fourth of many that attempts to document everything I have been learning about Python.

Python is dynamically typed, there are no type declarations. It keeps track of types for you and is a strongly typed language. Types are created when expressions are evaluated. Only operations valid on a type can be performed on it.

Python provides built-in object types that you can start using in your programs right away. Objects like lists, dictionaries, tuples and strings are part of the core language.

In most cases, these built-in objects are all that you need to model your application domain. Moreover, these objects are implemented using C which means you get a good deal of performance by using them.

In cases where you have to define your own, Python allows you to define your own types which can in turn leverage the functionality provided by Python's core built-in objects.

Python types are either immutable (cannot be changed in place) or mutable (can be changed in place).

Strings, numbers, tuples, sets are immutable.

Lists & Dictionaries are mutable.

Numbers

Numbers in python  are integers, floating point numbers, fixed precision decimals, complex and rational numbers.

In 3.0 integers can hold values no matter how large, in 2.6 a separate long integer type holds values that are beyond the range of integers.

Strings

Strings in Python are positional ordered collection of single characters. They are part of the family of sequences. You can operations like index and slice on them.

Indexing a string:

>>> >>> # string in Python >>> day_job = 'human genome project' >>> >>> # indexing a string to retrieve the >>> # character at the index (offset) >>> >>> day_job[0] 'h' >>> >>> # Negative offsets can be used >>> # start from the end of the string >>> >>> day_job[-1] 't' >>>

Slicing a string:

You can extract parts of a string by slicing it. The syntax is val[i:j] where i is the starting offset and the string is sliced all the way up to but not including offset j

>>> >>> day_job = "human genome project" >>> >>> # slicing a string >>> day_job[6:12] 'genome' >>>

You can slice using negative offsets. If you skip the indexes all together, they default - 0 for the lower bound and the length of the string for the upper bound.

>>> day_job = "human genome project" >>> >>> # slicing a string >>> # using negative offsets >>> day_job[0:-3] 'human genome proj' >>> >>> # slicing a string >>> # using offset defaults >>> day_job[:-7] 'human genome ' >>> day_job[5:] ' genome project' >>>

The indexing and slice operations are built in Python operations and are applicable to any type that is a sequence.

You can apply operations on strings. + is used to concatenate strings, whereas a * will repeat the string a certain number of times.

>>> >>> # concatenation >>> "day" + " job" 'day job' >>> >>> # repetition >>> "day job" * 3 'day jobday jobday job' >>>

Operations that are type specific are available as callable methods on that type.

>>> >>> day_job = "human genome project" >>> >>> # returns the index of the string >>> # location of the string. >>> day_job.find('genome') 6 >>> >>> # replaces the old value with the new one >>> day_job.replace('project', 'assignment') 'human genome assignment' >>>

To get a list of all string methods, you can use the dir method by passing in the type as parameter. You can then invoke the help method by passing the type and its attribute to learn more about its usage.

>>> >>> day_job = "human genome project" >>> dir(day_job) ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] >>> >>> help(day_job.upper) Help on built-in function upper: upper(...) S.upper() -> str Return a copy of S converted to uppercase. >>>

You can create strings using string literals, string format expressions, string format functions (new in version 3.x), strings with special characters, multiline strings that are printed as-is created using 3 quotes (either single or double).