Create separate lists for each opened file in 'for' loop

I don't know for sure what's in your csv files but you're doing some redundant work, and some pointless work. Let's break these down a bit:

for idx, (f_in, des) in enumerate(zip(file_list, des_list)):

idx never appears in the body of the loop at all, so you don't need the enumerate.

des does appear in the body of the list but its first occurrence is in the construct:

with open(f_in) as des:

so that the one inside the loop is a different des, being the stream from opening the file. So presumably you don't need the zip either. Dropping both, you could just do:

for f_in in file_list:

Next, you read the file once (list(csv.reader(...)) which is fine. The result is saved under the name cread.

Then you have these two list comprehensions run over the result of sorted, which itself is given the result of a list comprehension run over the result of applying .items() to a dictionary comprehension. The point of the outer list comprehensions is to extract one or the other item from the list: first i, then j, from [... for i, j in ...].

That might be appropriate depending on what's happening inside the sorted, so let's take a look at that:

sorted(..., key = lambda v: v[1])

This means the list-elements must themselves be index-able and you're sorting by the second item (the first being v[0] of course).

When you're sorting by the second item, then taking the first item and discarding the second, it's at least not redundant. But if you're sorting by the second item, then taking the second item and discarding the first, you could simply take the second items, and then sort and be done. (But let's check one more thing before we go that far. :-) )

Last, let's look at the dictionary comprehensions and the .items() invocation. The dictcomp itself is, in both cases:

{i: float(j) for i, j in cread}

Presumably your CSV files must give you pairs, and whatever is in the first part can be used as a key while whatever is in the second part is convertible to float. So let's take a simple dictionary with two key-value pairs that are, say, string-and-float:

{'a': 2.71828, 'b': 3.14159}

and apply .items():

>>> {'a': 2.71828, 'b': 3.14159}.items()
[('a', 2.71828), ('b', 3.14159)]

Instead of making up a dictionary and collapsing it back down to a list of 2-element tuples, you could just use a list comprehension to make the two-element tuples. Let's test that out:

>>> cread = [['a', '2.71828'], ['b', '3.14159']]
>>> [(i, float(j)) for i, j in cread]
[('a', 2.71828), ('b', 3.14159)]

Now we can sort this thing once, by its second element. We can use sorted, or make a list and sort it in place, but once we're done let's save it. Before we start, I've picked a bad set of values as they're already sorted, let's add a pair to cread that sorts differently:

>>> cread.append(['c', '0']); print cread
[['a', '2.71828'], ['b', '3.14159'], ['c', '0']]
>>> by_second = sorted([(i, float(j)) for i, j in cread], key = lambda v: v[1])
>>> by_second
[('c', 0.0), ('a', 2.71828), ('b', 3.14159)]

Having saved this sorted thing, we can now get the sample_genes and sample_values lists via the original list-comprehension-to-pick-item. I'll change a few names too:

for path in file_list:
    with open(path) as stream:
        data = list(csv.reader(stream, delimiter = '\t'))
    data = sorted([(i, float(j)) for i, j in data], key = lambda v: v[1])
    sample_genes = [i for i, j in data]
    sample_values = [j for i, j in data]

The next step is of course to save these samples somehow. Presumably you were going to use either idx or des_list to name them, but it seems more direct to index them by csv-path-name:

    somedict[path] = (sample_genes, sample_values)

where somedict is initially an empty dictionary (created before entering the for loop). At some point here it's reasonable to start thinking about proper data structures and create a class, though.