sorted(list) versus list.sort()

list.sort and sorted are different objects, they do different things both are callable, one is a method and the other is a function since they behave differently you will have to use them differently, even if their purposes are largely the same

list.sort has no return value, instead it has the side effect that the instance of list that it was called on will be sorted after the method has finished

sorted leaves the argument unchanged and instead creates and returns a list consisting of the same elements as the argument that you passed to it

you can look them up in python’s documentation, or you can call the function help:

help(sorted)
help(list.sort)

output:

Help on built-in function sorted in module __builtin__:

sorted(...)
    sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

basically says it takes one argument that you have to supply and then a couple of optional ones, you’d have to look them up for what those optional ones do

Help on method_descriptor:

sort(...)
    L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
    cmp(x, y) -> -1, 0, 1

only optional arguments, and they are the same as that of sorted, cmp, key and reverse - you can probably guess what the reverse one does, the others need to be looked up

documentation for sorted: https://docs.python.org/2/library/functions.html#sorted list.sort: https://docs.python.org/2/tutorial/datastructures.html#more-on-lists (it happens to refer to the documentation of sorted for the full documentation)

the 2 in the url’s can be changed to 3 for python 3 documentation. notably sorted will not return a list, it instead returns an iterable (an object that will yield values when you ask for it, but until you do it does not get evaluated. for example, xrange(1000000) doesn’t make a list of a million integers, instead it gives you one integer at a time and computes the next one each time you ask for it - this is called lazy evaluation

This is mine, works fine::

def median(lists):
    lists = sorted(lists)
    n = len(lists)
    if n % 2 == 0:
         return (lists[n/2-1] + lists[n/2])/2.0
    else:
        return lists[(n/2)]
        
print median([1, 2, 4])

This will also work…

import numpy

def median(list):
      return numpy.median(list)
    
print median([1,2,3,4,5])

Well, say list = [“Hi”, “my name”, “is James”] if you say sorted(list) then it takes the sorted list as an argument, but doesn’t actually do anything to the list, if you print it it will give [“Hi”, “my name”, “is James”], but if you do list.sort() then print the list, it will give [“Hi”, “is James”, “my name”]

list.sort() rearranges the list. sorted(list) has to be assigned. i.e. sorted_list = sorted(unsorted_list)

def median(list_name1):
list_name=sorted(list_name1)
size=len(list_name)
if size%2==0:
    a=list_name[size/2]
    b=list_name[(size/2)-1]
    return (a+b)/2.0
    
else:
    c=list_name[size/2]
    return c        

median([7,12,3,1,6,4,7,8])

I still haven’t fully understood this exercise :/

Here is my code that works 100%

def median(lst): srtlst=sorted(lst) if len(srtlst)%2!=0: return srtlst[int(len(srtlst)/2+0.5)] else: return (srtlst[len(srtlst)/2]+srtlst[len(srtlst)/2-1])/2.0

def median(lst): lst = sorted(lst)

if len(lst) == 1 or len(lst) == 0:
    return lst[0]
elif len(lst) > 1 and len(lst) % 2 == 0:
    median = (lst[len(lst) / 2] + 
              lst[len(lst) / 2 - 1]) / 2.0
    return median
else:
    median = lst[(len(lst) - 1) / 2]
    return median

def median(lst): srtlst=sorted(lst) if len(srtlst)%2!=0: return srtlst[int(len(srtlst)/2+0.5)] else: return (srtlst[len(srtlst)/2]+srtlst[len(srtlst)/2-1])/2.0

list.sort( ) gives out the same result as sorted(list) does in this case

CODE: def purify(num): a = [] for i in num: if i % 2 == 0: a.append(i) return a print purify([1,2,3]) print purify([1,2,3,4,5,6,7,8,9])

RUNNING RESULT: [2] [2, 4, 6, 8]

Why is it necessary to have the decimal point for 2.0 in line five? I have a feeling this was covered before but I can’t remember. It doesn’t work with just 2, why is this?

def median(the_list): new_list=sorted(the_list) middle_number= len(new_list)/2

if len(new_list)==1: return new_list[0] else: if len(new_list)%2==0:

        return (new_list[middle_number-1]+new_list[middle_number])/2.0

    else:
    
        return new_list[middle_number]

Basicaly mine answer doesn’t add anything except “readability” which counts and helps in programming.

def median(listn):
result = sorted(listn)
ln = len(result)
if ln % 2 == 0:
    return (result[ln/2 - 1] + result[ln/2])/2.0
elif len(result) == 1:
    return result[0]
else:
    return result[(ln / 2)]

If you see something that’s incorrect or something that can be shorter pls commen :)

Thats my 8-lines of code that worked well

def median(lista):
new_list = sorted(lista)
odd_avg = new_list[(len(new_list) - 1)/2]
even_avg = (new_list[(len(new_list)/2)] + new_list[((len(new_list)/2) - 1)]) / 2.0
if len(new_list) % 2 == 0:
    return even_avg
else:
    return odd_avg

def median(lst):
lst = sorted(lst)
n = len(lst)
if n % 2 == 0:
    x = lst[n / 2]
    y = lst[(n / 2) - 1]
    return ((x + y) / 2.0)
elif n == 1:
    return lst[0]
else:
    return lst[(n - 1) / 2]

def purify(numbers): b=[] for i in range(0,len(numbers)): if numbers[i]%2==0: b.append(numbers[i]) return b

a=[4,5,5,4,6,7,8,9,10,11,11,12] print purify(a)