Python Strings

String is a sequence of characters enclosed in ‘ ‘or “”

Creating strings:
1. Create instance of str class.
s=str()
s=“abc”

2. Assign string to a variable

s=“abc”

3. Multiline strings: enclose in triple quotes

msg=‘’’ hi
how r u?
fine? ‘’’
Refer string characters:
Characters are referred by index. Index begins with zero.
msg=“welcome”
msg[0]=‘w’, msg[1]=‘e’, msg[2]=l , ……….
 Python Strings: Formatting
• Use string format operator %. % with format symbol followed by % with value to be printed
• Value can be static text or variable

Print static data

Ex1: print("My name is %s “ % ‘xyz') // print static string
output: My name is xyz

Ex2: print "My age is %d “ % 20) // print number

output: My age is 20

Ex3: print "My name is %s age is %d“ % (‘xyz‘,20)) // print multiple values
Output: My name is xyz age is 20
Print value of variable
Ex:
name=“raj”
print "My name is %s “ % name) // %s will be replaced by value of variable name
 Python Strings: : Format Specifiers
Sr.No Format Symbol & Conversion
1 %c character
2 %s string conversion via str() prior to formatting
3 %i signed decimal integer
4 %d signed decimal integer
5 %u unsigned decimal integer
6 %o octal integer
7 %x hexadecimal integer (lowercase letters)

8 %X hexadecimal integer (UPPERcase letters)

9 %e exponential notation (with lowercase 'e')

10 %E exponential notation (with UPPERcase 'E')

11 %f floating point real number

12 %g the shorter of %f and %e

13 %G the shorter of %f and %E

 Python Strings: built in functions
1. len(s) function: calculates Length of string s
Ex: s=“hello” len(s) gives 5

2. lower(): Converts a string into lower case

Ex: s=“Hello” s.lower() gives ‘hello’

3. upper(): Converts a string into upper case

Ex: s=“Hello” s.upper() gives ‘HELLO’

4. split(separator_char): Splits the string at the specified separator, and returns a list
Ex: s=“hi all” s.split() gives list [‘hi’, ‘all’]

5. title(): Make the first letter in each word upper case

Ex: s=“hi all” s.title() gives “Hi All”

6. capitalize(): Upper case the first letter in this string

Ex: s=“hi all” s.capitalize() gives “Hi all”
 Python Strings: built in functions
7. count(value): Return the number of times the value appears in the string
Ex: s=“hi how are you. Are you fine?” s.count(‘you’) gives 2

8. find(substring): if substring is present,returns the index where substring occurs. If not, returns -1
Ex: s=“hi how are you?” s.find(‘how’) gives 3, s.find(‘wel’) gives -1

9. join(): Joins the elements of an iterable to the end of the string

Ex: words=[‘I’, ‘am’, ‘learning’] s=‘ ‘.join(words) gives ‘I am learning’

10. replace(substring1,substring2): Replace substring1 by substring2 in original string

Ex: s=“I like mango” s.replace(‘mango’,’pineapple’) gives s=“I like pineapple”

11. strip(): removes leading and trailing spaces in a string

Ex: s=‘ hi hello ‘ s.strip() gives s=‘hi hello’

12. islower(): Returns True if all characters in the string are lower case
Ex: s=‘Hello’ s.islower() gives False
 Python Strings: built in functions
13. center(space,pad_char): center align the string, using a specified character (space is default) as the fill character.
Ex: s=“welcome” s.center(10) gives ‘ welcome ’

8. find(substring): if substring is present,returns the index where substring occurs. If not, returns -1
Ex: s=“hi how are you?” s.find(‘how’) gives 3, s.find(‘wel’) gives -1

9. join(): Joins the elements of an iterable to the end of the string

Ex: words=[‘I’, ‘am’, ‘learning’] s=‘ ‘.join(words) gives ‘I am learning’

10. replace(substring1,substring2): Replace substring1 by substring2 in original string

Ex: s=“I like mango” s.replace(‘mango’,’pineapple’) gives s=“I like pineapple”

11. strip(): removes leading and trailing spaces in a string

Ex: s=‘ hi ‘ s.strip() gives s=‘hi’

12. islower(): Returns True if all characters in the string are lower case
Ex: s=‘hello’ s.islower() gives True
 Python Strings: operations
1. String Concatenation: use + operator
S1=“hi”
S2=“hello”
S3=s1+s2 gives “hi hello”

2. Slicing : extract portion of string,

• use slice operator [startindex:endindex]
• Returns substring starting at startindex and ending at endindex-1.

Ex: s=“hi hello. How are you?”

S[0:2] gives “hi”
S[3:8] gives “hello”

S[:2] gives “hi” // if 1st index is omitted then it extracts from the beginning.
S[10:] gives “How are you” // if 2nd index is omitted then it extracts upto the end.
 Python Strings: operations
Negative indexing: extract from the end

Ex: s=“hi hello. How are you?”

S[-5:-1] gives “you?”

S[-5:] gives “you?”

Escape Character: \ escapes characters from their reserved meaning.

Ex: s=‘ \\ ***\\welcome to DYPIU\\***\\’ gives output

\***\ welcome to DYPIU\***\

 Assignment: check if string is palindrome or not
s=‘hello’

str_rev=s[::-1]

If s==str_rev:
print(“string is palindrome”)
Else:
print(“not palindrome”)
 List
• Lists are used to store multiple items in a single variable.
• Store dissimilar type of data
• used to store collections of data
• ordered, mutable, and allow duplicate values
• Elements are referenced by index position.
• Index begins at 0. index of last element is 1- total no of elements in list

Ex. mylist = ["apple", 10, "banana", "cherry“, 4.5]

print(mylist)

Creating list:

Method1. Enlist elements in square brackets

e.g. fruits= ["apple", "banana", "cherry“]

Method2. use list() constructor function.

e.g. courses=list(“c”, “C++”, “Java”,”TCS”)
 List
• Lists are used to store multiple items in a single variable.
• Store dissimilar type of data
• used to store collections of data
• ordered, mutable, and allow duplicate values
• Elements are referenced by index position.
• Index begins at 0. index of last element is 1- total no of elements in list

Ex. mylist = ["apple", 10, "banana", "cherry“, 4.5]

print(mylist)

Creating list:
Method1. Enlist elements in square brackets
e.g. fruits= ["apple", "banana", "cherry“]

Method2. use list() constructor function.

e.g. courses=list(“c”, “C++”, “Java”,”TCS”)
 List indexing
Access list Items
List items are indexed and you can access them by referring to the index number:
courses=list(“c”, “C++”, “Java”,”TCS”)
positive Indexing
• positive indexing starts from the beginning.
• 0 refers to the first item, 1 refers to the second item etc.
Ex: courses[0] gives “c” , courses[1] gives “C++”

Negative Indexing
• Negative indexing starts from the end.
• -1 refers to the last item, -2 refers to the second last item etc.
• Ex: courses[-1] gives “TCS” , courses[-2] gives “Java” Range of Indexes

Range of Index
• You can specify a range of indexes by slice operator.
• All the values within the range will be returned.
• Ex: course[0:2] gives [“c”, “C++”]
 List operations
Length of list
Syntax: len(listobject)
Ex: fruits = ["apple", "banana", "cherry"]
print(len(fruits))
Append Items
Syntax: listobject.append(item)
Ex: fruits.append(“guava”)

Remove Specified Item

Syntax: listobject.remove(item)
Ex: fruits.remove(“guava”)

Remove item at Specified Index

Syntax: listobject.pop(index)
Ex: fruits.pop(1) // item at index 1 will be removed

If index is not specified, then last item is removed.

fruits.pop() // last item will be removed
 List operations
Count specific item in a list
Syntax: listobject.count(item)
Ex: fruits = ["apple", "banana", "cherry“, "apple"]
fruits.count(“apple”) gives 2
Clear list
Syntax: listobject.clear() // Removes all elements from the list
Ex: fruits.clear() gives []

Get index of Specified Item

Syntax: listobject.index(item)
Ex: fruits.index(“banana”) gives 1
fruits.index(“guava”) // error

insert item at Specified Index

Syntax: listobject.insert(index,item)
Ex: fruits.insert(1,”pineapple”) // insert “pineapple” at index 1
Gives ["apple", ”pineapple”,"banana", "cherry“, "apple"]
 List operations
Sort List
Syntax: listobject.sort()
Ex1: fruits = ["apple", "cherry“, "banana"]
fruits.sort() // sorts alphabetically
gives ["apple", "banana“, "cherry“]
Ex2: numbers=[10,5,34,56,45]
numbers.sort() // sorts in ascending order
gives [5,10,34,45,56]
Ex2: numbers=[10,5,34,56,45]
numbers.sort(reverse=True) // sorts in descending order
gives [56,45,34,10,5]

Copy list
Syntax: listobject.copy()
Ex: fruitlist2=fruits.copy() // new list with same items is generated.
Join items of two Lists
Syntax: listobject1.extend(listobject2)
Ex: fruits.extend(numbers) gives ["apple", "cherry“, "banana“, 10,5,34,56,45]
 List Traversal
Traverse a list: use loop

Ex1: fruits = ["apple", "cherry“, "banana"]

for x in fruits:
print(x)

Ex2: for each number in a list, print its square.

Numbers=[1,4,3,7]
for x in numbers:
print(x*x)
 List Compehension
List comprehension offers a shorter syntax to create a new list based on the values of an existing list.

Ex: make the squares of numbers in a given list and store in another list.

numbers=[2,6,-16,4]
squares = [x*x for x in numbers]

Ex. Create a list containing only even numbers from another list
Even= [x for x in numbers if x%2==0]
[('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)]
[('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)] Dictionary
• Dictionaries are used to store data values in {key:value} pairs.
[('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)]

• ordered,
[('brand', 'Ford'), ('model', 'Mustang'), ('year',
mutable 1964)]

• do not allow duplicates. No two keys can be the same.

Ex:
cars = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
Accessing values in dictionary : accessed by using the key name
Ex: cars[“brand”] gives “Ford”
cars.get(“brand”) gives “Ford”
Access Keys
Syntax: dictobject.keys()
Ex: cars.keys() gives ['brand', 'model', 'year']
Access key, value pairs
Syntax: dictobject.items()
Ex: cars.items() gives
[('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)]
[('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)] Dictionary operations
Add[('brand',
item to 'Ford'),
dictionary :
('model', 'Mustang'), ('year', 1964)]

Method1. create
[('brand', new ('model',
'Ford'), key and'Mustang'),
assign value to 1964)]
('year', it.
Syntax: dictobject[“newkey”]=value
Ex: cars[“price”]= 1000000 // create price key and store value 1000000
Method2. use update() method. Provide {key:val} pair to update method.
Cars.update({“price”:1000000})

Change item value

Syntax: dictobject[key]=newvalue
Ex: cars[“price”]=1500000

Remove item with specific key

Syntax: dictobject.pop(keyname)
Ex: cars.pop(“price”) removes price key along with its value
Copy a Dictionary
Syntax: dictobject.copy()
Ex. Carscopy=cars.copy() // creates new dictionary carscopy with all the items in cars dictionary.
[('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)]
[('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)] Nested Dictionary
Disctionary inside other dictionary: uses multiple key levels to access values
[('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)]

students ={
[('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)]
“student1" : { 1. Print the name of student1
"name" : "Emili",
“PRN" : 12345, students[“student1”][“name”]
“gender”:”female”
2. Print info of all students
“grade” :”O”
}, For student in students:
“student2" : { print(students[student])
"name" : “akash",
“PRN" : 12346, 3. Print grade of student with PRN 12346
“gender”:”male”
for student in students:
“grade” :”O”
if students[student]["PRN"]==12347:
},
print(students[student]["grade"])
“student3" : {
"name" : “seema", 4. Add new student
“PRN" : 12347, stud={"name":"akanksha","PRN":12348,"gender":"female","grade" :"O"}
“gender”:”female” students.update({"student4":stud})
“grade” :”A”
}} 5. Delete student 3 record
students.pop("student3")