I'm trying to change the numbers in a list from any given list to half their values. I do not know what the list is going to be when I start, just need to assert that the function is working after.
Here is what I have so far:
def halve_values(a):
for index in range(len(a)):
index /= 2
return index
a = [1, 2, 3]
print(halve_values(a))
The problem for me is that the list can be changed so I cannot define list a at the beginning. The program has to work if the list is given after for example:
a = [1, 4, 5, 6, 8, 13]
What am I doing wrong?
Thank you! :)
def half_values(a):
return [x/2 for x in a]
a = [1, 4, 5, 6, 8, 13]
b=half_values(a)
print(b)
def half_values(a):
return [x/2 for x in a]
Related
I do not want to use any other built-in functions so just want to experiment the available list methods.
I am trying to flatten the list with the code below:
my_list = [1, 2, 3, 6, 4, [0, 8, 9]]
new_list = []
for num in my_list:
new_list.extend([num])
print(new_list)
Expecting an output like this: [1, 2, 3, 6, 4, 0, 8, 9]
Getting the following output: [1, 2, 3, 6, 4, [0, 8, 9]]
The extend function is used to append all the elements of an iterable to the existing list. But the above code isn't working.
You have a mixed array so you need to check for that. So a function like
def flatlist(l):
if l== []:
return []
elif type(l) is not list:
return [l]
else:
return flatlist(l[0]) + flatlist(l[1:])
Hey I'm new to lists and modules can you show me how to do this. I actually tried this code but it seems to be giving me a wrong answer
l = [1, 2, 3, 4, 5]
fact = 1
for i in l:
for number in range(1,i+1):
fact=fact*number
print ("Factorial of", i, "is", fact)
def factorial(n):
if n < 2:
return 1
else:
return n * factorial(n-1)
l = [1, 2, 3, 4, 5]
for number in l:
fact = factorial(number)
print("Facotrial of ",number," is",fact)
Here is a working example.
You can use the balise code to better show your code, I have trouble to read it so I can't really comment on what you did wrong
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
reversed_list = my_list.sort(reverse=True)
print(reversed_list)
When i type this code python returns the word "None" and i can not figure out why i can't assign a variable to act as a reversed list. An explanation or a solution for this problem will be greatly appreciated.
The method sort() does not return anything. Instead, it changes the list in place. So the correct code would be:
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
reversed_list = my_list.copy()
reversed_list.sort(reverse=True)
print(reversed_list)
If you don't need both lists, you can avoid copying and do the sorting on my_list instead, thus saving some memory.
U can use sorted() if u don't wanna change ur list object. sorted() function can sort any iterable & return a list of items in that iterable sorted manner.
Eg. sorted('abicd', reverse=True) will return ['i', 'd', 'c', 'b', 'a']
Sort changes ur list object in place & doesn't return anything i. e, None in python.
U can better code it like:
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
reversed_list = sorted(my_list, reverse=True)
print(reversed_list)
If I have an input like this (1, 2, 3, 4, 5, 6)
The output has to be ... [[1, 2], [3, 4], [5, 6]].
I know how to deal with if it's one element but not two.
x=[]
for number in numbers:
x.append([number])
I'll appreciate your any help!
Something like this would work:
out = []
lst = (1,2,3,4,5,6,7,8,9,10)
for x in range(len(lst)):
if x % 2 == 0:
out.append([lst[x], lst[x+1]])
else:
continue
To use this, just set lst equal to whatever list of numbers you want. The final product is stored in out.
There is a shorter way of doing what you want:
result = []
L = (1,2,3,4,5,6,7,8,9,10)
result = [[L[i], L[i + 1]] for i in range(0, len(L) - 1, 2)]
print(result)
You can use something like this. This solution also works for list of odd length
def func(lst):
res = []
# Go through every 2nd value | 0, 2, 4, ...
for i in range(0, len(lst), 2):
# Append a slice of the list, + 2 to include the next value
res.append(lst[i : i + 2])
return res
# Output
>>> lst = [1, 2, 3, 4, 5, 6]
>>> func(lst)
[[1, 2], [3, 4], [5, 6]]
>>> lst2 = [1, 2, 3, 4, 5, 6, 7]
>>> func(lst2)
[[1, 2], [3, 4], [5, 6], [7]]
List comprehension solution
def func(lst):
return [lst[i:i+2] for i in range(0, len(lst), 2)]
Slicing is better in this case as you don't have to account for IndexError allowing it to work for odd length as well.
If you want you can also add another parameter to let you specify the desired number of inner elements.
def func(lst, size = 2): # default of 2 it none specified
return [lst[i:i+size] for i in range(0, len(lst), size)]
There's a few hurdles in this problem. You want to iterate through the list without going past the end of the list and you need to deal with the case that list has an odd length. Here's one solution that works:
def foo(lst):
result = [[x,y] for [x,y] in zip(lst[0::2], lst[1::2])]
return result
In case this seems convoluted, let's break the code down.
Index slicing:
lst[0::2] iterates through lst by starting at the 0th element and proceeds in increments of 2. Similarly lst[1::2] iterates through starting at the 1st element (colloquially the second element) and continues in increments of 2.
Example:
>>> lst = (1,2,3,4,5,6,7)
>>> print(lst[0::2])
(1,3,5,7)
>>> print(lst[1::2])
(2,4,6)
zip: zip() takes two lists (or any iterable object for that matter) and returns a list containing tuples. Example:
>>> lst1 = (10,20,30, 40)
>>> lst2 = (15,25,35)
>>> prit(zip(lst1, lst2))
[(10,15), (20,25), (30,35)]
Notice that zip(lst1, lst2) has the nice property that if one of it's arguments is longer than the other, zip() stops zipping whenever the shortest iterable is out of items.
List comprehension: python allows iteration quite generally. Consider the statement:
>>> [[x,y] for [x,y] in zip(lst1,lst2)]
The interior bit "for [x,y] in zip(lst1,lst2)" says "iterate through all pairs of values in zip, and give their values to x and y". In the rest of the statement
"[[x,y] for [x,y] ...]", it says "for each set of values x and y takes on, make a list [x,y] to be stored in a larger list". Once this statement executes, you have a list of lists, where the interior lists are all possible pairs for zip(lst1,lst2)
Very Clear solution:
l = (1, 2, 3, 4, 5, 6)
l = iter(l)
w = []
for i in l:
sub = []
sub.append(i)
sub.append(next(l))
w.append(sub)
print w
This question already has answers here:
How do I split a list into equally-sized chunks?
(66 answers)
Closed 6 years ago.
What is the simplest and reasonably efficient way to slice a list into a list of the sliced sub-list sections for arbitrary length sub lists?
For example, if our source list is:
input = [1, 2, 3, 4, 5, 6, 7, 8, 9, ... ]
And our sub list length is 3 then we seek:
output = [ [1, 2, 3], [4, 5, 6], [7, 8, 9], ... ]
Likewise if our sub list length is 4 then we seek:
output = [ [1, 2, 3, 4], [5, 6, 7, 8], ... ]
[input[i:i+n] for i in range(0, len(input), n)] # Use xrange in py2k
where n is the length of a chunk.
Since you don't define what might happen to the final element of the new list when the number of elements in input is not divisible by n, I assumed that it's of no importance: with this you'll get last element equal 2 if n equal 7, for example.
The documentation of the itertools module contains the following recipe:
import itertools
def grouper(n, iterable, fillvalue=None):
"grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
args = [iter(iterable)] * n
return itertools.izip_longest(fillvalue=fillvalue, *args)
This function returns an iterator of tuples of the desired length:
>>> list(grouper(2, [1,2,3,4,5,6,7]))
[(1, 2), (3, 4), (5, 6), (7, None)]
A really pythonic variant (python 3):
list(zip(*(iter([1,2,3,4,5,6,7,8,9]),)*3))
A list iterator is created and turned into a tuple with 3x the same iterator, then unpacked to zip and casted to list again. One value is pulled from each iterator by zip, but as there is just a single iterator object, the internal counter is increased globally for all three.
I like SilentGhost's solution.
My solution uses functional programming in python:
group = lambda t, n: zip(*[t[i::n] for i in range(n)])
group([1, 2, 3, 4], 2)
gives:
[(1, 2), (3, 4)]
This assumes that the input list size is divisible by the group size. If not, unpaired elements will not be included.