recursion in python - appending to a list

Last Update : 2022-10-14 08:33 am
Techknowledgy : python

You could use a intermediate list to append to in each recursive call. That avoids these redefinition problems you're encountering currently:

def replicate_recur(times, data, result = None): if result is None: # create a new resultif no intermediate was givenresult = []if times == 1: result.append(data)else: result.append(data)replicate_recur(times - 1, data, result) # also pass in the "result"return result

When called:

>>> replicate_recur(4, 2)[2, 2, 2, 2]

To make your code work, you need to extend the list in the current execution with the output of the next recursive call. Also, the lowest depth of the recursion should be defined by times = 1:

def replicate_recur(times, data): result2 = []if times == 1: result2.append(data)else: result2.append(data)result2.extend(replicate_recur(times - 1, data))return result2

On another note, you can simply replicate your list with:

def replicate(times, data): return [data] * times

You can use xrange for this, there is no point to use recursion unless it is a coding test.

def replicate(times, data): result2 = []for i in xrange(times): result2.append(data)return result2

Same function can be written in a recursive way like this:

def replicate_recur(times, data, listTest = None): # If a list has not been passed as argument create an empty oneif (listTest == None): listTest = []# Return the listif we need to replicate 0 more timesif times == 0: return listTest# If we reach here at least we have to replicate oncelistTest.append(data)# Recursive call to replicate more times,if needed andreturn the resultreplicate_recur(times - 1, data, listTest)return listTest

Also you could consider doing data*times to replicate if data is a list or simply do

(result2.append(data)) * times

In the recursion, each time replicate_recur is called, a fresh result2 in new name space is created.

[data] * times

Suggestion : 2

The “left” child of the tree must contain a value lesser than its parent. ,We can use recursion to find the element with the minimum value in a list, as shown in the code below. ,The “right” child of the tree must contain a value greater than it’s parent. ,Computing the value of a Fibonacci number can be implemented using recursion. Given an input of index N, the recursive function has two base cases – when the index is zero or 1. The recursive function returns the sum of the index minus 1 and the index minus 2.

def myfunction(n): if n == 0: return nelse: return myfunction(n - 1) myfunction(1000) #results in stack overflow error

Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

 5 / \/ \ 3 8 /\ / \2 4 7 9

def flatten(mylist): flatlist = []for element in mylist: if type(element) == list: flatlist += flatten(element)else: flatlist += elementreturn flatlist print(flatten(['a', ['b', ['c', ['d']], 'e'], 'f'])) # returns['a', 'b', 'c', 'd', 'e', 'f']

def fibonacci(n): if n <= 1: return nelse: return fibonacci(n - 1) + fibonacci(n - 2)

def countdown(value): call_stack = []while value > 0: call_stack.append({ "input": value}) print("Call Stack:", call_stack) value -= 1 print("Base Case Reached") while len(call_stack) != 0: print("Popping {} from call stack".format(call_stack.pop())) print("Call Stack:", call_stack) countdown(4)'''Call Stack: [{'input ': 4}] Call Stack: [{'input ': 4}, {'input ': 3}] Call Stack: [{'input ': 4}, {'input ': 3}, {'input ': 2}] Call Stack: [{'input ': 4}, {'input ': 3}, {'input ': 2}, {'input ': 1}] Base Case Reached Popping {'input ': 1} from call stack Call Stack: [{'input ': 4}, {'input ': 3}, {'input ': 2}] Popping {'input ': 2} from call stack Call Stack: [{'input ': 4}, {'input ': 3}] Popping {'input ': 3} from call stack Call Stack: [{'input ': 4}] Popping {'input ': 4} from call stack Call Stack: []'''

Suggestion : 3

I'm trying to create a recursive function that takes a JSON dictionary and stores any value with key names 'rate' into a list. I will then take that list and find the lowest value. My code looks like this right now, but is producing multiple empty lists within the list.,The optional arguments start and end are interpreted as in the slice notation and are used to limit the search to a particular subsequence of the list. The returned index is computed relative to the beginning of the full sequence rather than the start argument.,A call to index searches through the list in order until it finds a match, and stops there. If you expect to need indices of more matches, you should use a list comprehension, or generator expression.,Wrap the index call in a try/except block which catches ValueError (probably faster, at least when the list to search is long, and the item is usually present.)

def recurse_keys(df): rates = []for key, value in df.items(): if key == 'rate': rates.append(value)if isinstance(df[key], dict): recurse_keys(df[key])

You need to combine the results from the recursion, and return it:

def recurse_keys(df): rates = []for key, value in df.items(): if key == 'rate': rates.append(value)if isinstance(df[key], dict): rates += recurse_keys(df[key])return rates

if not a: print("List is empty")

1._

>>> ["foo", "bar", "baz"].index("bar")1

2._

list.index(x[, start[, end]])

An index call checks every element of the list in order, until it finds a match. If your list is long, and you don't know roughly where in the list it occurs, this search could become a bottleneck. In that case, you should consider a different data structure. Note that if you know roughly where to find the match, you can give index a hint. For instance, in this snippet, l.index(999_999, 999_990, 1_000_000) is roughly five orders of magnitude faster than straight l.index(999_999), because the former only has to search 10 entries, while the latter searches a million:

>>>import timeit >>> timeit.timeit('l.index(999_999)', setup = 'l = list(range(0, 1_000_000))', number = 1000)9.356267921015387 >>> timeit.timeit('l.index(999_999, 999_990, 1_000_000)', setup = 'l = list(range(0, 1_000_000))', number = 1000)0.0004404920036904514

A call to index results in a ValueError if the item's not present.

>>> [1, 1].index(2)Traceback (most recent call last):File "<stdin>", line 1, in <module> ValueError: 2 is not in list

list.index(x[, start[, end]])

Suggestion : 4

Python Program to Count the Occurrences of Elements in a Linked List using Recursion ,This is a Python Program to find the sum of elements in a list recursively.,Here is source code of the Python Program to find the sum of elements in a list recursively. The program output is also shown below.,Python Program to Count the Occurrences of Elements in a Linked List without Recursion

def sum_arr(arr, size): if (size == 0): return 0else: return arr[size - 1] + sum_arr(arr, size - 1)n = int(input("Enter the number of elements for list:"))a = []for i in range(0, n): element = int(input("Enter element:"))a.append(element)print("The list is:")print(a)print("Sum of items in list:")b = sum_arr(a, n)print(b)

Case 1: Enter the number of elementsfor list: 3Enter element: 3Enter element: 56Enter element: 7The list is: [3, 56, 7]Sum of items in list: 66Case 2: Enter the number of elementsfor list: 5Enter element: 23Enter element: 45Enter element: 62Enter element: 10Enter element: 56The list is: [23, 45, 62, 10, 56]Sum of items in list: 196

Suggestion : 5

In the last Chapter, we discussed Python Lists, how theStream object is similar to a List, and howwe can put Note objects into a Stream, lookat their offsets, and .show() the Stream in MusicXML or as text.We ended by putting one Stream inside another Stream, whichseemed like a neat trick until we discovered that we couldn’t get at theelements inside the inner Stream.,In this chapter we will work on how to exploit the power of nestedStreams. We’ll begin with a discussion of recursive lists (sinceStreams work a lot like lists). Those with some programming willprobably want to skip to the following section.,Oh, and since each of these is the last elements of their respectivelists, we could instead write:,In this chapter we looked at how we can look inside lists of lists,which will be important when we consider how to work with Streams ofStreams in music21, to look at Measures within Parts withina Score. We also learned how to define a function and writerecursive functions to do powerful work in just a few lines of code. Inthe next chapter we apply all this to music withStreams of Streams.

listA = [10, 20, 30]listB = [1, 2, 3, listA]

listB

 [1, 2, 3, [10, 20, 30]]

len(listB)

listB[3]

Trending Technology

android × 15970
angular × 18982
api × 5999
css × 155656
html × 23420
java × 29699
javascript × 58592
json × 19745
php × 23600
python × 454736
reactjs × 27451
sql × 2974
typescript × 8420
xml × 3800

recursion in python - appending to a list - splunktool (2023)