Largest of x random numbers def find_largest(x,y): largest = 0; count = 0; while count < x: rnum =...

transcript

Largest of x random numbers

def find_largest(x,y): largest = 0; count = 0; while count < x: rnum = randrange(0,y)

if rnum > largest: largest = rnum

count +=1 return(largest);print(find_largest(7,50))

Write a function that takes 2 integers (x and y) as input parameters , and generates x random numbers between 0 and y. It finds the largest of those random numbers.

What do we get?

def q(x,y): ct = 0 while (ct < x): ct2 = 0

while (ct2 < y): print(ct + ct2) ct2 += 1

ct += 1 return

q(4,3)

Rules: The contents of the

while loop is only what is indented under the while loop

We do the contents of the while loop over and over until the while loop’s condition becomes false.

Only then do we do what is below the while loop.

What does this print out?def h(x):

ct = 1

while (ct <= x):

ct2 = ct

while (ct2<=x):

print(ct2, end=“\t") #prints a tab after every ct2

ct2 += 1

ct += 1

print("\n") #this is a line break (starts a new line)

return

Can you reverse it Output:1 2 3 4 5 2 3 4 5 3 4 5 4 5 5

def h(x): ct = 1 while (ct <= x): ct2 = ct while (ct2<=x): print(ct2, end=" ") ct2 += 1 ct += 1 print("\n") print("\n")

returnh(5)

def h(x): ct = 1 while (ct <= x): ct2 = 1 while (ct2<=ct): print(ct2, end=" ")

ct2 += 1 ct += 1 print("\n") print("\n")h(5)

Output:1 1 2 1 2 3 1 2 3 4 1 2 3 4 5

What do we get?

def g(a,b):

while (a != b):

while (a > b):

a = a-b

while(b>a):

b = b-a

return(a)

print(g(6,20))

def f14(x): k = 0 n = -1 v = x while k <= (x*2): m = 0 while (m < v): print(v, end = "") m += 1 if (v == 0): n = 1 else: print() v += n k+=1 print()f14(3)

Lists: a new type!

We've got: ints

floats

booleans

strings

and now… (drum roll)

LISTS!sets of a thing (e.g., sets of ints)

Creating Lists

To create a list, put a number of expressions in square brackets:

listvar = [ ] #Empty list with nothing in it.

A list with things in it:

# create a list with some items

listvar1 = [2,10,8,4,17]

listvar2 = [“spider leg”,”toe of frog”,”eye of newt”, “bat wing”, “slug butter”, ”snake dandruff”]

First list is a list of ints

Second list is a list of strings.

Lists Overview

The list type is a container that holds a number of objects, in a given order.

Lists have an order to them Like a string, in which the order of the characters matters

Examples of lists: Sound files: a long list of numbers measuring vibrations in the air

any vibrational measurements

The order of the measurements of vibration is dependent on when they occurred in time.

List of class participants

Measurements of movements (e.g., weather)

Lists:listvar2 = [“spider leg”,”toe of frog”,”eye of newt”, “bat wing”, “slug butter”,”snake dandruff”]

Index 0 1 2 3 4 5

listvar1 = [2, 10, 8, 4, 17]

Index 0 1 2 3 4

So to use a particular item in the list:

x=listvar2[3] #”bat wing”

y=listvar1[1] #10

z=listvar2[0] #”spider leg”

Lists:Like strings, we can use:

listvar2 = [“spider leg”,”toe of frog”,”eye of newt”, “bat wing”, “slug butter”,”snake dandruff”]

listvar1 = [2, 10, 8, 4, 17]

get the length of a list

len(listvar2) # will give you 6

if “eye of newt" in listvar2:

return(“we can do chemistry!")

return(“Sorry, no chemistry today.”)

Lists:Index: 0 1 2 3 4 5

Slice: 0 1 2 3 4 5 6

-6 -5 -4 -3 -2 -1

listvar1 = [2, 10, 8, 4, 17]

Slicing:

x = listvar2[3:5] #x now holds [“bat wing”,”slug butter”]

y = listvar1[1:2] #y now holds [10]

Lists:Slicing (Different from Indexing)Index: 0 1 2 3 4 5

Slice: 0 1 2 3 4 5 6

-6 -5 -4 -3 -2 -1

def f():

return(listvar[0:6])

>>[“spider leg”,”toe of frog”,”eye of newt”, “bat wing”, “slug butter”,”snake dandruff”]

def g():

return(listvar2[1:3])

>>[”toe of frog”,”eye of newt”]

def h():

return(listvar2[-4:-2])

>>[”eye of newt”,”bat wing”]

def i():

return(listvar2[-4:4])

>>[”eye of newt”,”bat wing”]

ShortcutsIndex: 0 1 2 3 4 5

Slice: 0 1 2 3 4 5 6

-6 -5 -4 -3 -2 -1

listvar2[0:4]

[“spider leg”,”toe of frog”,”eye of newt”,”bat wing”]

listvar2[:4]

[“spider leg”,”toe of frog”,”eye of newt”,”bat wing”]

listvar2[3:6] [“bat wing”, “slug butter”,”snake dandruff”]

listvar2[3:]

[“bat wing”, “slug butter”,”snake dandruff”]

listvar2[:] [“spider leg”,”toe of frog”,”eye of newt”, “bat wing”, “slug butter”,”snake dandruff”]

Stuff we can do to lists that we can’t do with strings:)

listofstuff = [“ant", “bear", “cat", “dog“,”elephant”,”fox”]

# assign by indexlistofstuff[0] = “aardvark"print(listofstuff)>>>[“aardvark", “bear", “cat", “dog“,”elephant”,”fox”]

# assign by slicelistofstuff[3:5] = [“dolphin"]print(listofstuff)>>>[“aardvark", “bear", “cat", “dolphin”,”fox”]

# delete an elementdel listofstuff[2]print(listofstuff)>>>[“aardvark", “bear", “dolphin”,”fox”]

# delete a slicedel listofstuff[:2]print(listofstuff)>>>[ “dolphin”,”fox”]

Concatenate(join) listslist1 = [“skeletons", “zombies ", “witches"]

list2 = [“vampires", “ghouls ", “werewolves"]

list3 = list1 + list2

print(list3)

>>>[“skeletons", “zombies ", “witches“,”vampires", “ghouls ", “werewolves"]

list1 +=list2

print(list1)

>>>[“skeletons", “zombies ", “witches“,”vampires", “ghouls ", “werewolves"]

list1[3]?

list1[0]?

list1[6]?

Note: adding to the end of the list:list1 = [“skeletons", “zombies ", “witches“,”vampires", “ghouls ", “werewolves"]

We CAN do:

list1[4] = “ghosts”

print(list1)

>>> [“skeletons", “zombies ", “witches“,”vampires", “ghosts ", “werewolves"]

We CAN’T do:

list1[6] = “poltergeists”

(why not?)

Appending to end of list:list1 = [“skeletons", “zombies ", “witches“,”vampires", “ghouls ", “werewolves"]

We CAN’T do:

list1[6] = “poltergeists”

Instead:

list1.append(“poltergeists”)

print(list1)

>>[“skeletons", “zombies ", “witches“,”vampires", “ghouls ", “werewolves“, ”poltergeists”]

Append adds an element to the end of a list (sets aside more RAM memory)

Always to the end!

It is a method (function) that belongs to anything that is of the list type

Appending doesn’t work with strings (They’re immutable!)

List Methods Methods are functions that manipulate lists specifically

lists are objects (object-oriented programming)

Objects have methods (functions) associated with them.

E.g., dog objects might have a walking function

Square objects might have a calc_area function

List objects have functions: e.g.,

Add an element

reverse the list

Sort a list

Removing an item from the list: list1=[“skeletons", “zombies ", “witches“,”vampires", “ghouls ", “werewolves“,

”poltergeists”]

list1.remove(“werewolves”)>>[“skeletons", “zombies ", “witches“,”vampires", “ghouls ",”poltergeists”]

Trying to remove something that isn’t in the list gives you an error:list1.remove(“ghosts”) #ERROR

So check:if “vampires” in list1: list1.remove(“vampires”)print (list1)>>>[“skeletons", “zombies ", “witches“, “ghouls ", ”poltergeists”]

remove() ONLY removes the first occurrence of an item in the list:list2 = [8,2,3,1,5,3,8,4,2,3,5]list2.remove(2)print(list2)>>[8,3,1,5,3,8,4,2,3,5]

list1=[“skeletons", “zombies ", “witches“, “ghouls ", ”poltergeists”]

Reversing the order of the list:list1.reverse()>>>[‘poltergeist’,’ghouls’,’witches’,’zombies’,’sk

eletons’]

Sorting the listlist1.sort()>>>[‘ghouls’,’poltergeists’,’skeletons’,’witches’,’

zombies’]

Sorting the listlist1.sort(reverse = True)>>>[‘zombies’,’witches’,’skeletons’,’poltergeists

’,’ghouls’]

Other methods available for lists

count(value) – counts the number of times value occurs in list list2 = [8,2,3,1,5,3,8,4,2,3,5,3]

x = list2.count(3)print(x)>>>4

index(value) – returns index of first occurrence of valuelist1=[“skeletons", “zombies ", “witches“, “ghouls ", ”poltergeists”]y = list1.index(“witches”)print(y)>>>2

pop([f]) – returns value at position f and removes value from list. Without f, it pops the last element off the listlist1=[“skeletons", “zombies ", “witches“, “ghouls ", ”poltergeists”]x=list1.pop()print(x)>>”poltergeists”print (list1)>> =[“skeletons", “zombies ", “witches“, “ghouls ”]

x=list1.pop(2)print(x)>>”witches”print (list1)>> [“skeletons", “zombies ", “ghouls ”]

insert(f,value)- inserts value at position flist1.insert(1,’dragons”)print(list1)>>>[“skeletons", “dragons”, “zombies ", “ghouls ”]

def rg(x,y):

while len(x) > 0:

y.append(x.pop())

return(y)

print(rg(['witch','ghost','werewolf','vampire'],[]))

def rf(y,ls):

while ls.count(y)>0:

if y in ls:

z = ls.index(y)

ls.pop(z)

return(ls)

x = ['a','c','b','a','d','b','a','c','b','f','c','b']

print(rf('c',x))

def k(x,y):

k = True

while y < len(x)//2:

if (x[y] != x[len(x) - y-1]):

k=False

return (x[y] == x[len(x) - y-1]) and k

print(k("rotator",0))

print(k("clue",0))

def lr2(x,y,ls): while x < len(ls): if (ls[x] > y): y=ls[x]

x += 1return(y)

listarr = [3,2,7,3,1]print(lr2(0,0,listarr))

def g(x,y):

while (len(x) > 1):

i = randrange(len(x))

y+=x[i]

x = x[:i]+x[i+1:]

return(y+x)

print(g("computer",""))

#A game comes to mind…

def f(x,y,z): while x < len(z): if y> z[x]: y=z[x] x+=1 return(y)print(f(0,"zzyrgy",['ghoul','zombie','werewolf','vampire','ghost','pumpkin']))

def g(x,z): while x < len(z): q = f(0,"zzyrgy",z[x:]) i = z.index(q) t = z[x] z[x] = z[i] z[i] = t x+=1 return(z)print(g(0,['ghoul','zombie','werewolf','vampire','ghost','pumpkin']))

def h(x):

y = ""

while k<len(x):

y+=(x[k][k])

return(y)

ls = ['coffin','creepy','hayride','corpse','ghastly']

print(h(ls))

Largest of x random numbers def find_largest(x,y): largest = 0; count = 0; while count < x: rnum =...

Documents