1,760
edits
Changes
no edit summary
<font color='red'>
'''** DO NOT USE - TO BE UPDATED FOR CENTOS 8.0 **'''
</font>
= OBJECTIVES =
:The '''first investigation''' in this lab will focus on '''Data Structures'''. Each data structure has its own advantages and limitations. This lab will provide you will additional scripting tools to help us write even more effective Python scripts to be applied to practical application involving VM management and deployment in future labsemphasize the most important differences between them.
=== PYTHON REFERENCE ===
:As you develop your Python scripting skills, you may start to be "overwhelmed" with the volume of information that you have absorbed over these labs. One way to help, is to write what you have learned in your labs into your lab logbook. Also, in programming, it is important learn to use online references effectively in order to obtain information regarding Python scripting techniques and tools.
:Below is a table with links to useful online Python reference sites (by category). You may find these references useful when performing assignments, etc.
|}
= INVESTIGATION 1: DATA STRUCTURES =
:In this investigation, you will learn several tools when using data structures commonly used in Python scripting.:These tools include '''tupleslists''', '''setstuples''', '''dictionariessets''', and more '''advanced list functionsdictionaries'''.
== PART 1 - Tuples ==
:Many often confuse a '''tuple''' with a '''list''' (which you learned about in a previous lab). A '''tuple''' is a type of list whose values cannot be changeschanged. In fact, the structure of nothing in a tuple cannot can be changed after it's created (like adding, removing list elements).
:There are many advantages to using tuples when creating Python scripts:
::*'''Data protection''' (eg. values are are NOT allowed to change like income tax rate, social insurance number, etc)::*The data structure in a tuple cannot be changed (eg. '''structure cannot be corrupted''so you won't modify them accidentally)
::*Tuples can be used as '''keys in data dictionaries''' (which are NOT allowed to change)
::*Tuples allow for '''faster access''' than lists
:Term The term to indicate that a data structure cannot be changed is called '''immutable''' (as opposed to ''"mutable"'' which means the data structure can be changed).
:'''Perform the Following Steps:'''
:#Launch your ipython3 shell:<source>ipython3</source>Let's create two tuplesin a temporary Python file, so we can learn how to use them and learn how they differ from lists.<br><br>Note: '''tuples are defined by using parenthesis ( )''' as opposed to '''lists which are defined by using square brackets [ ]'''<br><br>:#Issue the following:<sourcelang="python">
t1 = ('Prime', 'Ix', 'Secundus', 'Caladan')
t2 = (1, 2, 3, 4, 5, 6)
</source>
:#Values from a tuple can be retrieved in the same way as a list. For example, issue the following:<sourcelang="python">print(t1[0])print(t2[2:4])
</source>
:#You can also check to see whether a value exists inside a tuple or not. To demonstrate, issue the followingtry:<sourcelang="python">print('Ix' in t1)print('Geidi' in t1)</source>Let's now see how a tuple differs from a list. We will now create a list and note the difference between them.<br><br>:#Issue the following to create a list:<sourcelang="python">
list2 = [ 'uli101', 'ops235', 'ops335', 'ops435', 'ops535', 'ops635' ]
</source>
:#See if you can change the value of your list by issuing the following:<sourcelang="python">
list2[0]= 'ica100'
print(list2[0])
print(list2)
</source>.You should have been successful in changing the value of your list.<br><br>:#Now, try changing the value of your previously-created tuple by issuing:<sourcelang="python">
t2[1] = 10
</source>Did it work? Once created the tuple values will not be able to change.<br><br>If you would like a tuple with different values than the tuple you currently have, then you must create a new one.<br><br>
:#To create The following creates a new tuple, issue (t3) with a contents from a slice of the t2 tuple. Slicing works the followingsame way for tuples as for lists:<sourcelang="python">
t3 = t2[2:3]
</source>
for item in t1:
print('item: ' + item)
::*Sets '''cannot contain duplicate values'''
:Since new duplicate entries will be automatically removed when using sets, they are very useful for performing tasks such as '''comparisons''': '''finding similarities or differences in multiple sets'''. Also, sets are considered to be fast!
s1 = {'Prime', 'Ix', 'Secundus', 'Caladan'}
s2 = {1, 2, 3, 4, 5}
s3 = {4, 5, 6, 7, 8}
</source>Note: '''Sets are defined by using braces { }''' as opposed to tuples that which use parenthesis ( ), or lists that which use square brackets [ ]'''<br/><br/>:#Try to issue the following to access a set through the index.:<sourcelang="python">print(s1[0])</source>This should have created caused an '''error''', this is not how to . You cannot access data inside a set this way because they the elements inside are '''un-orderedunordered'''. Instead, you should use the '''in''' method (used in the previous section) to check to see if whether a value is contained within in the set.<br><br>:#To demonstrate, issue the following:<sourcelang="python">print('Ix' in s1)print('Geidi' in s1)
</source><br>'''Sets can be combined''', but it is important to note that any '''duplicate values (shared among sets) will be deleted'''.<br><br>
:#Issue Print the following, contents of the sets and note the items (and values) that are common to the following sets:<sourcelang="python">print(s2)print(s3)
</source>
:#Now, issue the following to return This is how you get a set containing only UNIQUE values (no duplicates) from both sets:<source>print(s2 | s3 ) # returns a set containing all values from both setsprint(s2.union(s3)) # same as s2 | s3</source>Notice that both methods above provides have the same result, but the first method requires less keystrokeswhich one you choose depends purely on your style.<br><br>Instead of combining sets, we can display '''values that are common to both sets'''. This is known in mathematical terms as an '''intersection''' between the lists.<br><br>:#To demonstrate intersection between sets s2 and s3, issue the following:<sourcelang="python">print(s2 & s3 ) # returns a set containing all values that s2 and s3 shareprint(s2.intersection(s3)) # same as s2 & s3
</source>
:#Sets can also have their values compared against other sets. First find out what items are in '''s2''' but not in '''s3'''. This is also called a '''difference'''. But notice that it only shows values that '''s2''' contains, specifically values that '''s3''' doesn't have. So this isn't really the <u>true</u> difference between the sets.:<sourcelang="python">print(s2)print(s3)print(s2 - s3 ) # returns a set containing all values in s2 that are not found in s3print(s2.difference(s3)) # same as s2 - s3
</source>
:#In order to see <u>every</u> difference between both sets, you need to find the '''symmetric difference'''. This will return a set that shows all numbers that both sets do not share together.<br><br>:#To demonstrate, issue the following:<sourcelang="python">print(s2 ^ s3 ) # returns a set containing all values that both sets DO NOT shareprint(s2.symmetric_difference(s3)) # same as s2 ^ s3</source>Note: the '''set()''' function can make convert lists into sets, and the '''list()''' function can make convert sets into lists<br><br>These powerful features . The operations in this section can only be useful and efficient. Unfortunately, lists <u>cannot</u> perform these operations, unless we have applied to convert the lists into sets. In order to that, so if you should first need to perform a comparisonunion, then convert the list to a set.<br><br>There are two problems with performing the above-mentioned technique:::::*Sets are '''un-ordered''' so if the list order is important this will cause problems and remove order::::*Sets '''cannot contain duplicate values'''intersection, if the list contains any duplicate values they will be deleted. :::Howeveror difference between lists, if the list does not have any of the above requirements this is a great solution you need to convert them to some problemssets first. :::10. To demonstrate, issue the followingFor example:<sourcelang="python">
l2 = [1, 2, 3, 4, 5]
l3 = [4, 5, 6, 7, 8]
</source>
:'''Perform the Following Instructions'''
#!/usr/bin/env python3
def join_sets(set1s1, set2s2): # join_sets will return a set that has contains every value from both set1 s1 and set2 inside its2
def match_sets(set1s1, set2s2): # match_sets will return a set that contains all values found in both set1 s1 and set2s2
def diff_sets(set1s1, set2s2):
# diff_sets will return a set that contains all different values which are not shared between the sets
</source>
set1: {1, 2, 3, 4, 5, 6, 7, 8, 9}
set2: {5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
diff: {1, 2, 3, 4, 10, 11, 12, 13, 14}
</source>
import lab4a
set1 = {1,2,3,4,5}
set2 = {2,1,0,-1,-2}
print(lab4a.join_sets(set1,set2))# Will output {-2, -1, 0, 1, 2, 3, 4, 5}print(lab4a.match_sets(set1,set2))# Will output {1, 2}print(lab4a.diff_sets(set1,set2))# Will output {-2, -1, 0, 3, 4, 5}
</source>
<ol><li value='3' style="margin-left:::3. Exit the ipython3 shell, download 25px;">Download the checking script and check your work. Enter the following commands from the bash shell.:<sourcelang="bash">
cd ~/ops435/lab4/
pwd #confirm that you are in the right directory
ls CheckLab4.py || wget matrix.senecachttps://raw.ongithubusercontent.cacom/~acoatleySeneca-willisCDOT/ops435/master/LabCheckScripts/CheckLab4.py
python3 ./CheckLab4.py -f -v lab4a
</source></li><li style="margin-left:::4. 25px;">Before proceeding, make certain that you identify any and all errors in lab4a.py. When the checking script tells you everything is OK before proceeding - proceed to the next step.</li></ol>
:'''Perform the Following Instructions'''
#!/usr/bin/env python3
def join_lists(list1l1, list2l2): # join_lists will return a list that contains every value from both list1 l1 and list2 inside itl2
def match_lists(list1l1, list2l2): # match_lists will return a list that contains all values found in both list1 l1 and list2l2
def diff_lists(list1l1, list2l2):
# diff_lists will return a list that contains all different values, which are not shared between the lists
print('diff: ', diff_lists(list1, list2))
</source>
list1: [1, 2, 3, 4, 5, 6, 7, 8, 9]
list2: [5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
join: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
match: [8, 9, 5, 6, 7, 8, 9]
diff: [1, 2, 3, 4, 10, 11, 12, 13, 14]
</source>
import lab4b
list1 = [1,2,3,4,5]
list2 = [2,1,0,-1,-2]
print(lab4b.join_lists(list1,list2)))# Will output [0, 1, 2, 3, 4, 5, -2, -1]print(lab4b.match_lists(list1,list2) ) # Will output [81, 9, 5, 6, 72]print(lab4b.diff_lists(list1,list2) ) # Will output [1, 20, 3, 4, 105, 11-2, 12, 13, 14-1]
</source>
cd ~/ops435/lab4/
pwd #confirm that you are in the right directory
python3 ./CheckLab4.py -f -v lab4b
</source>
== PART 3 - Dictionaries ==
::'''Perform the Following Steps:'''
dict_york = {'Address': '70 The Pond Rd', 'City': 'Toronto', 'Postal Code': 'M3J3M6'}
</source>You should note that the syntax to define a dictionary is similar to defining sets (i.e. using '''{}''').<br>Unlike , but unlike sets, dictionaries use '''<code>key:value</code>''' pairs within the dictionary, each ''key:value'' pair in turn, are is separated by commas.<br><br>You can get help associated with your dictionary by using functions such as '''dir()''' and '''help()'''.<br><br>::#Issue All the following and note all the available functions available and how to obtain assistance with values in a dictionary objects:<source>dir(dict_york)help(dict_york)</source>All values can be viewed retrieved by using the '''dictionary.values()''' function. This particular function provides a '''list''' containing all values.<br><br>::#To demonstrate, issue the following:<sourcelang="python">helpprint(dict_york.values()dict_york.values()</source>All keys to access the ''key:pair'' values within a dictionary can be viewed by retrieved using the '''dictionary.keys()''' function. This function provides a '''list''' containing all keys<br><br>::#To demonstrate this, issue the following:<sourcelang="python">help(dict_york.keys)
dict_york.keys()
</source>Armed with this information, We can retrieve <u>individual</u> values from a dictionary by provide providing the key associated with the key:pair value<br><br>::#For example, issue the following:<sourcelang="python">print(dict_york['Address'])print(dict_york['Postal Code'])
</source>
::#Dictionary keys can be any '''immutable''' values (i.e. not permitted for value to be changed). Types of values include: '''strings''', '''numbers''', and '''tuples'''. Trying ::#Try adding a couple new keys key and values value to the dictionary by issuing:<sourcelang="python">
dict_york['Country'] = 'Canada'
print(dict_york)print(dict_york.values())print(dict_york.keys())
</source>
::#Let's add another key:value pair to our dictionary to change the province key:pair value to BC:<sourcelang="python">
dict_york['Province'] = 'BC'
print(dict_york)print(dict_york.values())print(dict_york.keys())</source>'''WARNING: Dictionary keys must be unique'''. Attempting to add a key that already exists in the dictionary will <u>overwrite</u> the existing value for that key!<br><br>::#To demonstrate, issue the followingFor example:<sourcelang="python">
dict_york['Province'] = 'ON'
print(dict_york)print(dict_york.values())print(dict_york.keys())</source>You should notice that key value for the 'Province' key has been changed back to 'ON'.<br><br>These The lists that contain the values and keys of the dictionary are not <u>real</u> python lists - they are "views of the dictionary" and therefore are <u>immutable</u>. You could change these views into usable lists by using the '''list()''' function (where the index can be used to access individual values).<br><br>::#For example, issue the following:<sourcelang="python">
list_of_keys = list(dict_york.keys())
print(list_of_keys[0])
</source>
list_of_keys = list(dict_york.keys())
for key in list_of_keys:
print(key)
for value in dict_york.values():
print(value)
</source>
:'''Perform the Following Instructions'''
::#Create the '''~/ops435/lab4/lab4c.py''' script. The purpose of this script will be to create dictionaries, extract data from dictionaries, and to make comparisons between dictionaries.
::#Use the following as a template:<sourcelang="python">
#!/usr/bin/env python3
# Place code here - refer to function specifics in section below
def shared_values(dict1, dict2):
# Place code here - refer to function specifics in section below
york = create_dictionary(list_keys, list_values)
print('York: ', york)
common = shared_values(dict_york, dict_newnham)
print('Shared Values', common)
</source>
:::*The script should contain '''threetwo''' functions::::::'''create_dictionary()'''<ol><li>'''accepts''' two lists as arguments keys and values, '''combines''' these lists together to '''create''' a dictionary</li><libr>('''returns a dictionaryTip:''' that has use a while loop to access elements in both the keys and associated values from lists at the listssame time)</li></ol>:::::'''split_dictionary()'''<ol><li>'''accepts''' returns a single dictionary as a argument and '''splits''' that has the dictionary into two lists, keys and associated values</li><li>'''returns two lists''': The return function can return multiple from the lists (separated by a comma). In our case, use: '''return keys, values'''</li></ol>
:::::'''shared_values()''' <ol><li>'''accepts''' two dictionaries as arguments and '''finds''' all values that are shared between the two dictionaries<br>('''Tip:''' generate sets containing only values for each dictionary, then use a function mentioned in a previous section to store the values that are common to <u>both</u> lists)</li><li>'''returns a set''' containing '''ONLY values''' found in '''BOTH dictionaries'''</li></ol>
:::*make sure the functions have the correct number of arguments required
:::*The script should contain no errors
::::'''Sample Run 1:'''<source>
York: {'Country': 'Canada', 'Postal Code': 'M3J3M6', 'Address': '70 The Pond Rd', 'Province': 'ON', 'City': 'Toronto'}
Shared Values {'Canada', 'ON', 'Toronto'}
</source>
::::'''Sample Run 2(with import):'''<source>
import lab4c
dict_york = {'Address': '70 The Pond Rd', 'City': 'Toronto', 'Country': 'Canada', 'Postal Code': 'M3J3M6', 'Province': 'ON'}
list_values = ['70 The Pond Rd', 'Toronto', 'Canada', 'M3J3M6', 'ON']
york = lab4c.create_dictionary(list_keys, list_values) york{'Address': '70 The Pond Rd', 'City': 'Toronto', 'Country': 'Canada', 'Postal Code': 'M3J3M6', 'Province': 'ON'} keys, values = split_dictionary(dict_newnham) keys['Country', 'Postal Code', 'Address', 'Province', 'City'] values['Canada', 'M2J2X5', '1750 Finch Ave E', 'ON', 'Toronto'] keys, values = split_dictionary(york) keys['Country', 'Postal Code', 'Address', 'Province', 'City']
common = lab4c.shared_values(dict_york, dict_newnham)
print(common)# Will print: {'Canada', 'ON', 'Toronto'}
</source>
:::3. Exit the ipython3 shell, download Download the checking script and check your work. Enter the following commands from the bash shell.<sourcelang="bash">
cd ~/ops435/lab4/
pwd #confirm that you are in the right directory
ls CheckLab4.py || wget matrix.senecachttps://raw.ongithubusercontent.cacom/~acoatleySeneca-willisCDOT/ops435/master/LabCheckScripts/CheckLab4.py
python3 ./CheckLab4.py -f -v lab4c
</source>
:::4. Before proceeding, make certain that you identify any and all errors in lab4c.py. When the checking script tells you everything is OK before proceeding proceed to the next step.<br><br> == PART 4 - List Comprehension == :We have already have had an introduction to lists. We will now explore advanced functions that use and generate lists. This is a very common practice in Python: understanding how to generate, manipulate, and apply functions to items inside a list can be incredibly useful. List comprehension is a way to build new lists from existing list and to do it faster than simply looping over lists. :'''Perform the Following Steps''' :#Let's start by creating a list and then applying some functions to each item in that list. Issue the following to create a list and then display the square for each item within that list:<source>l1 = [1, 2, 3, 4, 5]for item in l1: print(item ** 2)</source>In order to store these results (i.e. squares) for later use, you would have to create a new list and append the squares to it. This will generate a new list that contains squared values in the same positions of the first list. In this way, you are using an existing list in order to create a new (larger) list.<br><br>:#To demonstrate, issue the following:<source>l1 = [1, 2, 3, 4, 5]l2 = []for item in l1: l2.append(item ** 2)l1l2</source>Since this may be a repetitive task, it makes more sense to create a function that will append the squares to a new item within an existing list.<br><br> :#Issue the following to see how that can be performed:<source>def square(number): return number ** 2 l1 = [1, 2, 3, 4, 5]l2 = []for item in l1: l2.append(square(item)) l1l2</source>The '''map()''' function can be used to apply a function on each item in a list. This is exactly what happened in the previous example; however, using the ''map()'' function provides for better syntax, and removes the loop (including the variable that was created inside the loop). Therefore, using the ''map()'' function will make your Python script more efficient while performing the same task.<br><br>:#To demonstrate, issue the following:<source>def square(number): return number ** 2 l1 = [1,2,3,4,5]l2 = list(map(square, l1)) l1l2</source>The above ''map()'' function requires another function as well as a list. This means that before using (calling) the map() function, that other function would have to have been defined earlier in the script. This entire process can be avoided through the use of '''anonymous functions'''. This is the ability to create a simple function without defining it, and pass it on to other function calls. You will use the the '''lambda anonymous function''', which will return a function that you can use in that function immediately (i.e. without having to declare it in your script). The function takes 1 argument (called: x), and it will square that value.<br><br>:#To demonstrate, issue the following:<source>square = lambda x: x ** 2l1 = [1,2,3,4,5]l2 = list(map(square, l1)) l1l2</source>:#The above code is actually not particularly good, the whole purpose of using lambda here is we were avoiding the function definition and just quickly returning a function. However this does break down exactly what lambda does, it returns a function for use. Fix this by removing the square function and just use the return function from lambda. Now remember what map requires? map's first argument is a function, and map's second argument is a list. Here lambda will return a function and provide it as the first argument.<source>l1 = [1,2,3,4,5]l2 = list(map(lambda x: x ** 2, l1)) l1l2</source>:#Using the list comprehensions above our code will be faster and more efficient than using multiple variables and loops.
= INVESTIGATION 2: STRINGS =
:Strings are basically a list of characters (bits of text). Strings store text so that they can be later for manipulation (by a wide range of functions). This section will investigate strings in more detail such as '''cutting strings into sub-strings''', '''joining strings''', '''formatting strings''', '''searching through strings''', and '''matching strings against patterns'''.<br><br>Strings are '''immutable''' data objects - this means that once a string is created, it <u>cannot</u> be modified. In order to make a change inside a string, you would first make a copy of the part of the string (i.e. sub-string) for manipulation.
== PART 1 - Strings and Substrings ==
:'''Perform the Following Steps:'''
:#Launch the ipython3 shell<source>ipython3</source>:#Issue the following to create Create some stringsin a temporary Python file:<sourcelang="python">
course_name = 'Open System Automation'
course_code = 'OPS435'
course_number = '435'</source>Strings can contain any '''characters''' inside them, whether they are '''letters''', '''numbers''', or '''symbols'''. In our ipython3 shell the values inside each string variable can be seen just by typing the string variable name. However, when writing python scripts, these string variables should be placed inside '''print()''' functions in order to display on the screen.<br><br> :#Strings can also be '''concatenated''' (i.e. "combined together") by using the '''+''' sign, just make sure string are only concatenating other strings with strings(no lists, no numbers, no dictionaries, etc.).<br><br>:#To demonstrate what was previously mentioned, issue the following:<sourcelang="python">course_namecourse_codecourse_number
print(course_name)
print(course_code)
print(str(course_number))
print(course_name + ' ' + course_code + ' ' + str(course_number))
print('Line 1\nLine 2\nLine 3\n')
</source>
:#By using both Strings have many built-in functions that we can use to manipulate text. [https://docs.python.org/3/library/stdtypes.html#string repetition and -methods Here's a newline character, multiple lines can be created at oncelist]. Issue the following:#Lets try out several different functions:<sourcelang="python">print('Line 1' + '\n'*4 + 'Line 5\nLine 6'course_name.lower()) # Returns a string in lower-case lettersprint(course_name.upper()) # Returns a string in upper-case lettersprint(course_name.swapcase()) # Returns a string with upper-case and lower-case letters swappedprint(course_name.title()) # Returns a string with upper-case first letter of each word, lowercase for remaining textprint(course_name.capitalize()) # Returns a string with upper-case first letter only, lowercase for remaining text
</source>
lower_name = course_name.lower() # Save returned string lower-case string inside new string variable
print(lower_name)
lower_name.split(' ') # Provide the split() function with a character to split on
</source>The above example will return a list of strings, which we can access just like all of lists. <br><br>
:#Let's practice more string manipulation by issuing the following:<sourcelang="python">
list_of_strings = lower_name.split(' ') # Split string on spaces and store the list in a variable
print(list_of_strings ) # Display listprint(list_of_strings[0] ) # Display first item in list</source>Since lists are actually a list of '''strings''', you should be able to use any function that works with a string on a list.<br><br>:#To demonstrate, issue the following:<sourcelang="python">
list_of_strings[0].upper() # Use the function after the index to affect a single string within a list
first_word = list_of_strings[0]
print(first_word)
</source>The '''index''' that is used to access <u>items</u> within a list, can also be used to access <u>characters</u> within a string. For practice, let's create a new string, and start accessing the strings index.<br><br>:#Issue the following:<source>
course_name = 'Open System Automation'
course_code = 'OPS435'
course_number = 435
print(course_code[0] ) # Return a string that is Print the first character in course_codeprint(course_code[2] ) # Return a string that is Print the third character in course_codeprint(course_code[-1] ) # Return a string that is Print the last character in course_codeprint(str(course_number)[0] ) # Turn the integer into a string, return first character in that string, and print itprint(course_code[0] + course_code[1] + course_code[2])</source>:#You can use a technique that uses index numbers of a string to '''cut-out''' or '''"parse"''' smaller portions of text within a string. This term is referred to as a '''substring'''. We can use this to create a new string or display only a small portion of it<br><br>:#To demonstrate, issue the following:<sourcelang="python">print(course_name[0:4] ) # Return Print the first four characters (values of index numbers 0,1,2, and 3)
first_word = course_name[0:4] # Save this substring for later use
print(course_code[0:3] ) # Return Print the first three characters (values of index numbers 0,1,and 2)
</source>
:# The index allows a few '''extra functions''' using the same parsing technique:<sourcelang="python">
course_name = 'Open System Automation'
print(course_name[12:] ) # Return Print the substring '12' index until end of stringprint(course_name[5:] ) # Return Print the substring '5' index until end of stringprint(course_name[-1] ) # Return Print the last character</source>With '''negative indexesindices''', '''-1''' index would represent the '''last''' character, '''-2''' index would represent the '''second last''' character, etc.<br><br>:#To demonstrate, issue the following:<sourcelang="python">
course_name = 'Open System Automation'
print(course_name[-1])print(course_name[-2])
</source>
:# Issue the following to practice Practice some of the skills that you have learned in this section:<source>
course_name = 'Open System Automation'
print(course_name[-10:] ) # Return the last ten charactersprint(course_name[-10:-6] ) # Try and figure out what this is returning print(course_name[0:4] + course_name[-10:-6] ) # Combine substrings together
substring = course_name[0:4] + course_name[-10:-6] # Save the combined substring as a new string for later
print(substring)
</source>
:# The real power found in substrings goes beyond just manually writing index values and getting back words. The next part of this investigation will cover how to search through a string for a specific word, letter, number, and return the index to that search result.
'''Create a Python Script Demostrating Substrings'''
:'''Perform the Following Instructions'''
#!/usr/bin/env python3
# Strings 1
</source>
Hello
Senec
Send!!
</source>
import lab4d
str1 = 'Hello World!!'
str2 = 'Seneca College'
num1 = 1500
num2 = 1.50
print(lab4d.first_five(str1))# Will output 'Hello'print(lab4d.first_five(str2))# Will output 'Senec'print(lab4d.last_seven(str1))# Will output 'World!!'print(lab4d.last_seven(str2))# Will output 'College'print(lab4d.middle_number(num1))# Will output '50'print(lab4d.middle_number(num2))# Will output '.5'print(lab4d.first_three_last_three(str1, str2))# Will output 'Helege'print(lab4d.first_three_last_three(str2, str1))# Will output 'Send!!'
</source>
cd ~/ops435/lab4/
pwd #confirm that you are in the right directory
ls CheckLab4.py || wget matrix.senecachttps://raw.ongithubusercontent.cacom/~acoatleySeneca-willisCDOT/ops435/master/LabCheckScripts/CheckLab4.py
python3 ./CheckLab4.py -f -v lab4d
</source>
= LAB 4 SIGN-OFF (SHOW INSTRUCTOR) =
:'''Have Ready to Show Your Instructor:'''
::<span style="color:green;font-size:1.5em;">✓</span> xOutput of: <code>./CheckLab4.py -f -v</code>::<span style="color:green;font-size:1.5em;">✓</span> x:Output of:<span style="color:green;font-size:1code>cat lab4a.py lab4b.py lab4c.py lab4d.5em;">✓py</spancode> Lab4 logbook notes completed = LAB REVIEW =
# What is the purpose of a '''tuple'''? How does a tuple differ from a list?# How do you define elements within a tuple?# Write Python code to confirm if the string ''''OPS435'''' exists within the tuple called '''courses'''.# What is the purpose of a '''set'''? How do sets differ from lists or tuples?# How do you define elements within a set?# Assuming you have defined two sets called '''set1''' and '''set2'''. Write Python code to:<ol type= Practice For Quizzes"a"><li>Return a set containing all values of both sets</li><li>Returns a set containing all values in set1 that are not found in set2</li><li>Return a set containing all values that both sets DO NOT share</li></ol># What is the purpose of a dictionary?# How do you define elements within a dictionary?# Write Python commands to display for a dictionary called '''my_dictionary''' the dictionary key called '''my_key''' and a dictionary value for that key?# What is the purpose for the '''range()''', Tests'''len()''', Midterm & Final Exam '''append()''', and '''map()''' functions for a dictionary?# List and briefly explain the following functions (methods) that can be used with strings:<br>'''lower()''' , '''upper()''' , '''swapcase()''' , '''title()''' , '''captilize()''' , '''split()'''# Assume you issued the following command in your ipython3 shell:<br>'''course_name = 'Programming with Python''''<br>What will be the output for each of the following Python commands?<ol type="a"><li>'''course_name[3:11]'''</li><li>'''course_name[10:]'''</li><li>'''course_name[-1]</li></ol>