Python Programming

The source book of this course is illustrated below

The University of Turkish Aeronautical Associaiton

Computer Eng. dept.
2020-2021

Dr. Eng. Abdullatif BABA Fifth Chapter

 Python Programming
Strings

In the last chapters, we describe some features of Strings

Here we speak in detail about strings
String Indexing: to print a string’s individual characters. Python uses square brackets to
index strings
>>> s = 'apple'
>>> s[0]
'a'
>>> s[1]
'p'
>>> s[2]
'p'
>>> s[3] If s labels a string of length n, s[0] is the first character, s[1] is the
'l' second character, s[2] is the third character, and so on up to s[n-1],
>>> s[4] which is the last character.
'e'
If you try to index past the right end of the string, you will get an “out of range” error:
>>> s[5]
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
s[5]
IndexError: string index out of range
 Python Programming
Strings

Python has a convenient way of accessing characters near the right end of a string
called: negative indexing.
The idea is that the characters of a string are indexed with negative numbers going from right
to left:

>>> s = 'apple'
>>> s[-1]
'e'
>>> s[-2]
'l'
>>> s[-3]
'p'
>>> s[-4]
'p'
>>> s[-5]
'a'
 Python Programming
Strings

Characters
Strings consist of characters, and characters themselves have a corresponding character code
that you can find using the ord function; i.e. Ord() returns the number representing the
Unicode of a specified character.
>>> ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
Given a character code number, you can retrieve its corresponding character using
the chr function:
>>> chr(97)
'a'
>>> chr(98)
'b'
>>> chr(99)
'c'
Character codes are assigned using Unicode, which is a large and complex standard for
encoding all the symbols and characters that occur in all the world’s languages.
 Python Programming
Strings
Accessing characters with a for-loop

If you need to access every character of a string in sequence, a for-loop can be helpful.
Example:
>>> ord('H')
72
>>> ord('i')
# codesum.py 105
>>> ord(' ')
def codesum (s):
32
""" Returns the sums of the ...
character codes of s.
"""
total = 0
for c in s: # At the beginning of each iteration the loop variable c is
total = total + ord(c) set to be the next character in s. The indexing into s is
handled automatically by the for-loop.
return total

>>> codesum ('Hi teacher')

941
>>> codesum ('3251235')
357
 Python Programming
Strings
Accessing characters with a for-loop

If you need to access every character of a string in sequence, a for-loop can be helpful.

Example:
An alternative solution is illustrated here:

# codesum.py
def codesum (s):
""" Returns the sums of the
character codes of s.
"""
total = 0
for i in range(len(s)):
total = total + ord(s[i])
return total
The Rise of Unicode
In the 1960s, ’70s, and ’80s, the most popular character encoding scheme was ASCII (American Standard Code for Information Interchange). ASCII is far simpler than
Unicode, but its fatal flaw is that it can represent only 256 different characters—enough for English and French and a few other similar languages, but nowhere near enough
to represent the huge variety of characters and symbols found in other languages. For instance, Chinese alone has thousands of ideograms that could appear in text
documents.
Essentially, Unicode provides a far larger set of character codes. Conveniently, Unicode mimics the ASCII code for the first 256 characters, so if you are only dealing with
English characters (as we are in this book), you’ll rarely need to worry about the details of Unicode. For more information, see the Unicode home page (www.unicode.org).
 Python Programming
Strings
Escape characters

Escape character is a single character should be led by a (Backslash) \ to tell Python that
this is a special character, but that \ does not count as an extra character when
determining a string’s length.

>>> len('\\')
1
>>> len('a\nb\nc')
5

The most commonly used escape characters.

 Python Programming
Strings
Escape characters

To handle whitespace and other unprintable characters, Python uses a special notation
called escape sequences, or escape characters.

>>> print('\' and \" are quotes')

' and " are quotes
>>> print('\\ must be written \\\\')
\ must be written \\

The standard way in Python for ending a line is to use the \n character:

>>> print('one\ntwo\nthree')
one
two
three
 Python Programming
Strings
Slicing Strings

Slicing is how Python lets you extract a substring from a string. To slice a string, you
indicate both the first character you want and one past the last character you want.
s[begin:end] returns the substring starting at index begin and ending at index end - 1.
>>> food = 'apple pie'
>>> food[0:5]
'apple'
>>> food[6:9]
'pie'
If you leave out the begin index of a slice, then Python assumes you mean 0; and if you
leave off the end index, Python assumes you want everything to the end of the string. For
instance:
>>> food = 'apple pie'
>>> food[:5]
'apple'
>>> food[6:]
'pie'
>>> food[:]
'apple pie'
 Python Programming
Strings
Slicing Strings

# extension.py
>>> get_ext('hello.text')
def get_ext(fname):
'text'
""" Returns the extension of file fname.
>>> get_ext('pizza.py')
"""
'py'
dot = fname.rfind('.')
>>> get_ext('pizza.old.py')
if dot == -1:
'py'
return ''
>>> get_ext('pizza')
else:
''
return fname[dot + 1:]

The get_ext function works by determining the index position of the rightmost '.' (hence the
use of rfind to search for it from right to left). If there is no '.' in fname, the empty string is
returned; otherwise, all the characters from the '.' onward are returned.
 Python Programming
Strings
Slicing with negative indexes

>>> food = 'apple pie'

>>> food[-9:-4] #n+1
'apple'
>>> food[:-4]
'apple'
>>> food[-3:0]
''
>>> food[-3:]
'pie'
 Python Programming
Strings
Standard String Functions

Python strings come prepackaged with a number of useful functions; use dir on any
string (for example, dir('')) to see them all.

>>> s= ('apple')
>>> s.endswith('t')
False
>>> s.endswith('e')
True
>>> s.isnumeric()
False
>>> s.islower()
True
>>> s.isdecimal()
False
>>> s.isprintable()
True
 Python Programming
Strings
Standard String Functions
There are several ways to find substrings within a string. The difference between index and find
functions is what happens when they don’t find what they are looking for.
>>> s = 'cheese'
>>> s.find('s')
>>> s.index('eee')
4
Traceback (most recent call last):
>>> s.find('eee')
File "<pyshell#18>", line 1, in
-1
<module> In general, find and index return
>>> s.rfind('e') the smallest index where the
s.index('eee') passed-in string starts,
5
ValueError: substring not found and rfind and rindex return the
>>> s.find('e') largest index where it starts.
>>> s.index('ee')
2
2
>>> s.index('c')
0
>>> s.index('s')
4
>>> s.find('ee')
2
>>> s.find('c')
0
 Python Programming
Strings
Case-changing functions
For all these functions, Python creates and returns a new string. But, it doesn’t modify them

>>> S =('a new design of a flying robot')

>>> S.title()
'A New Design Of A Flying Robot'
 Python Programming
Strings
string-formatting functions
The string-formatting functions listed below help you to make strings look nicer for presenting to the
user or printing to a file.

>>> S.center(40,'R')
'RRRRRa new design of a flying robotRRRRR'
>>> S.ljust(40,'R')
'a new design of a flying robotRRRRRRRRRR'
• They are replaced by the values of the corresponding
>>> '{1} likes {0}'.format('ice cream','Jack') strings or variables
'Jack likes ice cream' • You can also refer to the names of keyword parameters

>>> '{who} {pet} has fleas'.format (pet = 'dog', who = 'my')

'my dog has fleas'
 Python Programming
Strings
Stripping functions
The stripping functions are used for removing unwanted characters from the beginning or the end of a
string. By default, whitespace characters are stripped, and if a string argument is given, the characters in
that string are stripped.

>>> name = ' Gill Bates '

>>> name.lstrip()
'Gill Bates '
>>> name.rstrip()
' Gill Bates'
>>> name.strip()
'Gill Bates'
>>> title = '_-_- Happy Days!! _-_-'
>>> title.strip('_-')
' Happy Days!! '
>>> title.strip('_ -')
'Happy Days!!'
 Python Programming
Strings
Splitting functions
The splitting functions are used cut a string into substrings

>>> url = 'www.google.com'

>>> url.partition('.')
('www', '.', 'google.com')
>>> url.rpartition('.')
('www.google', '.', 'com')

>>> txt = "Thank you for the music\nWelcome to the

jungle"
>>> txt.splitlines()
['Thank you for the music', 'Welcome to the jungle']

>>> url = 'www.google.com'

>>> url.split('.')
['www', 'google', 'com']
>>> story = 'A long time ago, a princess ate an apple.'
>>> story.split()
['A', 'long', 'time', 'ago,', 'a', 'princess', 'ate', 'an',
'apple.']
The split function always returns a list of strings; a Python list always begins with a [ and ends with a ], and uses
commas to separate elements
 Python Programming
Strings
Replacement functions
Replace function can easily be used to delete substrings within a string:

>>> s = 'up, up and away'

>>> s.replace('up', 'down')
'down, down and away'
>>> s.replace('up', '')
', and away'
>>> str = 'xyz\t12345\tabc'
>>> str.expandtabs(2)
'xyz 12345 abc'
 Python Programming
Strings
Other functions

>>> leet_table = ''.maketrans ('EIOBT', '31087') >>> ' '.join(['once', 'upon', 'a', 'time'])
>>> 'BE COOL. SPEAK LEET!'.translate (leet_table) 'once upon a time'
'83 C00L. SP3AK L337!' >>> '-'.join(['once', 'upon', 'a', 'time'])
>>> S 'once-upon-a-time'
'a new design of a flying robot' >>> ''.join(['once', 'upon', 'a', 'time'])
>>> S.count('a') 'onceuponatime'
2
>>> S.zfill(40)
'0000000000a new design of a flying robot'
 Python Programming
Strings
Regular Expressions *, +, ?, |

• Consider the string 'cat'. It represents a single string consisting of the letters c, a, and t. Now
consider the regular expression 'cats?'. Here, the ? does not mean an English question mark but
instead represents a regular expression operator, meaning that the character to its immediate left is
optional. Thus the regular expression 'cats?' describes a set of two strings: ['cat', 'cats']

• Another regular expression operator is |, which means “or.” For example, the regular
expression 'a|b|c' describes the set of three strings 'a', 'b', and 'c'.

• The regular expression 'a*' describes an infinite set of strings: '', 'a', 'aa', 'aaa', 'aaaa', 'aaaaa', and
so on. In other words, 'a*' describes the set of all strings consisting of a sequence of 0 or more 'a's.
The regular expression 'a+' is the same as 'a*' but excludes the empty string ''.

• Finally, within a regular expression you can use round brackets to indicate what substring an operator
ought to apply to. For example, the regular expression '(ha)+!' describes these
strings: 'ha!', 'haha!', 'hahaha!', and so on. In contrast, 'ha+!' describes a very different
set: 'ha!', 'haa!', 'haaa!', and so on.

• You can mix and match these (and many other) regular expression operators in any way you want.
This turns out to be a very useful way to describe many commonly occurring types of strings, such as
phone numbers or email addresses.
 Python Programming
Strings
Matching with regular expressions

The first line of the second version imports Python’s standard regular expression library.
To match a regular expression, we use the re.match(regex, s) function, which
returns None if regex does not match s, and a special regular expression match
object otherwise.
Suppose we decide to add a few more possible stopping strings. For the regular
expression version, we just rewrite the regular expression string to be,
say, 'done|quit|over|finished|end|stop'. In contrast, to make the same change to the first
version, we’d need to include or s == for each string we added, which would make for a
very long line of code that would be hard to read.

def is_done1(s): import re # use regular expressions

return s == 'done' or s == 'quit' def is_done2(s):
return re.match('done|quit', s) != None
 Python Programming
Strings
Matching with regular expressions

Suppose you want to recognize funny strings, which consist of one or more 'ha' strings
followed immediately by one or more '!'s. For example, 'haha!', 'ha!!!!!',
and 'hahaha!!' are all funny strings. It’s easy to match these using regular expressions:

import re
def is_funny(s):
return re.match('(ha)+!+', s) != None
 Python Programming
Example 11

Give a Python number to convert decimal into other number systems

dec = int(input('Enter your decimal number '))

print("The decimal value of", dec, "is:")
print(bin(dec), "in binary.")
print(oct(dec), "in octal.")
print(hex(dec), "in hexadecimal.")
 Python Programming
Example 12
Use the anonymous (lambda) function to give the powers of 2 in one table

terms = int(input("How many terms? "))

# use anonymous function
result = list(map(lambda x: 2 ** x, range(terms))) #The list() constructor returns a
list in Python. Like a dynamic
print("The total terms are:",terms) stack.
#map: map() function returns a
for i in range(terms): result after applying the given
function to each item of a given
print("2 raised to power",i,"is",result[i]) iterable

A lambda function is a small anonymous function.

A lambda function can take any number of arguments, but can only have one expression.
>>> x = lambda a : a + 10
>>> print(x(5))
15
>>> x = lambda a, b : a * b
>>> print(x(5, 6))
30
 Python Programming
Example 13
(Preliminary)
letters = ['a', 'b', 'd', 'e', 'i', 'j', 'o']

# function that filters vowels

def filterVowels(letter):
vowels = ['a', 'e', 'i', 'o', 'u']
if(letter in vowels):
return True
else:
return False

filteredVowels = filter(filterVowels, letters)

print('The filtered vowels are:')

for vowel in filteredVowels:
print(vowel)
The filter() function constructs an iterator from elements of an iterable for which a function returns true.
The syntaxof this function is: filter(function, iterable)
• function - function that tests if elements of an iterable return true or false
If None, the function defaults to Identity function - which returns false if any elements are false
• iterable - iterable which is to be filtered, could be sets, lists, tuples, or containers of any iterators
 Python Programming
Example 13

Use the anonymous (lambda) function inside the filter() built-in function to find all
the numbers divisible by 13 in the given list.

# Take a list of numbers

my_list = [12, 65, 54, 39, 102, 339, 221]

# use anonymous function to filter

result = list(filter(lambda x: (x % 13 == 0), my_list))

# display the result

print("Numbers divisible by 13 are",result)