Develop Reference

Construct list of intervals consisting of midpoints of successive input values

I have a Python list consisting of data:
[60, 120, 180, 240, 480]
I need to calculate the intervals between the elements in the list and get the value in between the elements. For the above list, I'm looking for this output:
[[60, 90], [90, 150], [150, 210], [210, 360], [360, 480]]
The first and last values of the list is directly transferred, but the values in-between are obtained by the following method: e.g. for 60 and 120: (120 - 60 = 60 / 2 = 30 + 60 = 90)
I cannot work out how to do this in a simple pythonic fashion, and I have buried myself in if/else statements to solve it.

You can do this fairly simply with pairwise. It's included in Python as of version 3.10, but if you're on an earlier version, you can get it from more_itertools or implement it yourself. (I also use mean, which is a handy convenience even though it's trivial to reimplement.)
from itertools import pairwise
from statistics import mean
original = [60, 120, 180, 240, 480]
midpoints = [mean(pair) for pair in pairwise(original)]
output = list(pairwise([original[0], *midpoints, original[-1]]))
print(output)
[(60, 90), (90, 150), (150, 210), (210, 360), (360, 480)]
Note that this outputs each pair as a tuple, rather than a list, as in your sample output. I think this is more idiomatic, and I would prefer it in my own code. However, if you'd prefer lists, it's a simple change:
from itertools import pairwise
from statistics import mean
original = [60, 120, 180, 240, 480]
midpoints = [mean(pair) for pair in pairwise(original)]
output = [
list(pair) for pair in pairwise([original[0], *midpoints, original[-1]])
]
print(output)
[[60, 90], [90, 150], [150, 210], [210, 360], [360, 480]]

We can replace inner points by midpoints and then turn adjacent pairs into intervals:
a[1:-1] = map(mean, pairwise(a))
a[:] = pairwise(a)
As non-modifying function (Try it online!):
from itertools import pairwise
from statistics import mean
def intervals(a):
a = a[:]
a[1:-1] = map(mean, pairwise(a))
return list(pairwise(a))
print(intervals([60, 120, 180, 240, 480]))
Output:
[(60, 90), (90, 150), (150, 210), (210, 360), (360, 480)]
The intervals are tuples instead of lists, but like CrazyChucky I think that tuples are more idiomatic for this (unless you actually have a need for them to be lists).

The shortest version that i can do
A = [60, 120, 180, 240, 480]
B = []
for i in range(len(A)):
if i == 0:
B.append([A[i], (A[i] + A[i+1])//2])
else:
if(i < len(A)-1):
B.append([B[i - 1][1], (A[i] + A[i+1])//2])
else:
B.append([B[i - 1][1], A[i]])
print(B)

x_list = [60, 120, 180, 240, 480]
y = []
for i in range(len(x_list) - 1):
y.append(int((x_list[i]+x_list[i+1])/2))
print(y)
z = [[x_list[0], y[0]]]
for i in range(0, len(y)-1):
z.append([y[i], y[i+1]])
print(z)
z.append([y[-1], x_list[-1]])
print(z)
Try the above.
The first line printed are the midpoints, and the last row shows the final list.
It's a matter of understanding indices. There are probably faster ways to do it, but learning, it's better to iterate.
$ python example.py
[90, 150, 210, 360]
[[60, 90], [90, 150], [150, 210], [210, 360], [360, 480]]
$

You can use the following:
def getIntervals(l):
l2 = []
l2.append(l[0])
for i in range(0, len(l) - 1):
l2.append((l[i] + l[i+1]) // 2)
l2.append(l[-1])
ret = []
for i in range(len(l2) - 1):
ret.append([l2[i], l2[i+1]])
return ret
And then you can call it like this:
x = [60, 120, 180, 240, 480]
y = getIntervals(x)
print(y) # prints [[60, 90], [90, 150], [150, 210], [210, 360], [360, 480]]
Basically, you iterate through the list, and then you find the endpoints of each interval, and then you iterate through again and form the pairs of endpoints.

Most pythonic way I can come up with:
from itertools import pairwise # python ≥3.10 only
l = [60, 120, 180, 240, 480]
mid_points = map(lambda pair: sum(pair)//2, pairwise(l)) # [90, 150, 210, 360]
all_values = l[0], *mid_points, l[-1] # pre/append 60 and 480 resp. to mid_points
# all_values: (60, 90, 150, 210, 360, 480)
list(pairwise(all_values))
# [(60, 90), (90, 150), (150, 210), (210, 360), (360, 480)]
If you don't have Python 3.10 you can emulate pairwise with:
from itertools import tee
def pairwise(iterable):
# pairwise('ABCDEFG') --> AB BC CD DE EF FG
a, b = tee(iterable)
next(b, None)
return zip(a, b)

Solution written in function format (without needing to import anything):
Function:
def get_interval_list(my_list):
interval_start = 0
interval_end = 0
interval_list = []
for i in range(len(my_list)):
if i == 0:
interval_start = my_list[0]
else:
interval_start = interval_end
if i == len(my_list)-1:
interval_end = my_list[-1]
else:
current_num = my_list[i]
next_num = my_list[i+1]
interval_end = (current_num + next_num) / 2
interval_list.append([int(interval_start), int(interval_end)])
return interval_list
Function with commented explanations:
def get_interval_list(my_list):
# variables (self explanatory... interval_list temporarily stores the interval start and
# end pair for each number being iterated through)
interval_start = 0
interval_end = 0
interval_list = []
# for loop iterates through the conditional statements for a number of times dependent on the
# length of my_list, finds interval_start and interval_end for each number in my_list,
# and then add each pair to interval_list
for i in range(len(my_list)):
# conditional statement checks if the current number is the first item in my_list,
# and if it is, assigns it to interval_start - if it isn't, the interval_end for the
# previous number will be the same as the interval_start for the
# current number (as per your requested output)
if i == 0:
interval_start = my_list[0]
else:
interval_start = interval_end
# conditional statement checks if the current number is the last item in my_list,
# and if it is, assigns it to interval_end - if it isn't, we calculate interval_end by
# adding the current number and the next number in my_list and dividing by 2
if i == len(my_list)-1:
interval_end = my_list[-1]
else:
current_num = my_list[i]
next_num = my_list[i+1]
interval_end = (current_num + next_num) / 2
# values of interval_start and interval_end are added as a pair to interval_list
# (use int() here if you do not want your interval pairs to be returned as floats)
interval_list.append([int(interval_start), int(interval_end)])
return interval_list
Sample run using function above:
list_of_numbers = [60, 120, 180, 240, 480]
print(get_interval_list(list_of_numbers))
Output:
[[60, 90], [90, 150], [150, 210], [210, 360], [360, 480]]
(Could be written more simply but I didn't want to sacrifice readability)
Just a side note: we don't need to use (120 - 60 = 60 / 2 = 30 + 60 = 90) to calculate the midpoints. There is a much simpler way; all we have to do is add the upper and lower limits and divide by 2 like so:
(60 + 120) / 2 = 90
(This mathematical method of finding midpoints works for any "range")

This is the best i can come up with, but i'm really unsure if this is the simplest approach:
def generate_split_intervals(input_list):
first_list_value = input_list[0]
last_list_value = input_list[-1]
return_list = []
last_append = 0
for idx, item in enumerate(input_list):
if item == first_list_value:
last_append = int(first_list_value + (abs(input_list[idx+1]-first_list_value)/2))
return_list.append([first_list_value, last_append ])
elif item == last_list_value:
return_list.append([last_append, last_list_value])
else:
this_append = int(item + (abs(input_list[idx+1]-item)/2))
return_list.append([last_append, this_append])
last_append = this_append
return return_list

arr = [60, 120, 180, 240, 480]
def foo(x, i):
return [(x[i] + x[max(0, i - 1)])//2,
(x[i] + x[min(len(x) - 1, i + 1)])//2]
[foo(arr, i) for i in range(len(arr))]
# [[60, 90], [90, 150], [150, 210], [210, 360], [360, 480]]
OR
lz = zip((zip(arr, [arr[0]] + arr[:-1])),
(zip(arr, arr[1:] + [arr[-1]])))
[[sum(a)//2, sum(b)//2] for a, b in lz]
# [[60, 90], [90, 150], [150, 210], [210, 360], [360, 480]]

How to split a list into 2 unsorted groupings based on the median

I am aiming to sort a list into two subsections that don't need to be sorted.
Imagine I have a list of length 10 that has values 0-9 in it.
arr = [50, 30, 20, 10, 90, 40, 100, 70, 60, 80]
I would want to sort it in a way that indices 0 through 4 contain values 10, 20, 30, 40, and 50 in any ordering.
For example:
# SPLIT HERE V
[40, 30, 20, 50, 10, 70, 60, 80, 90, 100]
I've looked into various divide and conquer sorting algorithms, but I'm uncertain which one would be the best to use in this case.
My current thought is to use quicksort, but I believe there is a better way to do what I am searching to do since everything does not need to be sorted exactly, but sorted in a "general" sense that all values are on their respective side of the median in any ordering.

to me this seems to do the trick , unless you exactly need the output to be unordered :
arr = [50, 30, 20, 10, 90, 40, 100, 70, 60, 80]
sorted_arr = sorted(arr)
median_index = len(arr)//2
sub_list1, sub_list2 = sorted_arr[:median_index],sorted_arr[median_index:]
this outputs :
[10, 20, 30, 40, 50] [60, 70, 80, 90, 100]

The statistics package has a method for finding the median of a list of numbers. From there, you can use a for loop to separate the values into two separate lists based on whether or not it is greater than the median:
from statistics import median
arr = [50, 30, 20, 10, 90, 40, 100, 70, 60, 80]
med = median(arr)
result1 = []
result2 = []
for item in arr:
if item <= med:
result1.append(item)
else:
result2.append(item)
print(result1)
print(result2)
This outputs:
[50, 30, 20, 10, 40]
[90, 100, 70, 60, 80]

If you would like to solve the problem from scratch you could implement Median of Medians algorithm to find median of unsorted array in linear time. Then it depends what is your goal.
If you would like to make the reordering in place you could use the result of Median of Medians algorithm to select a Pivot for Partition Algorithm (part of quick sort).
On the other hand using python you could then just iterate through the array and append the values respectively to left or right array.

Other current other answers have the list split into two lists, and based on your example I am under the impression there is two groupings, but the output is one list.
import numpy as np
# setup
arr = [50, 30, 20, 10, 90, 40, 100, 70, 60, 80]
# output array
unsorted_grouping = []
# get median
median = np.median(arr)
# loop over array, if greater than median, append. Append always assigns
# values at the end of array
# else insert it at position 0, the beginning / left side
for val in arr:
if val >= median:
unsorted_grouping.append(val)
else:
unsorted_grouping.insert(0, val)
# output
unsorted_grouping
[40, 10, 20, 30, 50, 90, 100, 70, 60, 80]

You can use the statistics module to calculate the median, and then use it to add each value to one group or the other:
import statistics
arr = [50, 30, 20, 10, 90, 40, 100, 70, 60, 80]
median = statistics.median(arr)
bins = [], [] # smaller and bigger values
for value in arr:
bins[value > median].append(value)
print(bins[0]) # -> [50, 30, 20, 10, 40]
print(bins[1]) # -> [90, 100, 70, 60, 80]

You can do this with numpy (which is significantly faster if arr is large):
import numpy as np
arr = [50, 30, 20, 10, 90, 40, 100, 70, 60, 80]
arr = np.array(arr)
median = np.median(arr)
result1 = arr[arr <= median]
result2 = arr[arr > median]
Output:
array([50, 30, 20, 10, 40])
array([ 90, 100, 70, 60, 80])
And if you want one list as the output, you can do:
[*result1, *result2]
Output:
[50, 30, 20, 10, 40, 90, 100, 70, 60, 80]

My first Python program, so please bear with me.
Basically does QuickSort, as you suggest, but only sub-sorts the partition that holds the median index.
arr = [50, 30, 20, 10, 90, 40, 100, 70, 60, 80]
def partition(a, left, right):
pivot = (left + right)//2
a[left],a[pivot] = a[pivot], a[left] # swap
pivot = left
left += 1
while right >= left :
while left <= right and a[left] <= a[pivot] :
left += 1
while left <= right and a[right] > a[pivot] :
right -= 1
if left <= right:
a[left] , a[right] = a[right], a[left]
left += 1
right -= 1
else:
break
a[pivot], a[right] = a[right] , a[pivot]
return right
def medianSplit(array):
left = 0;
right = len(array) - 1;
med = len(array) // 2;
while (left < right):
pivot = partition(array, left, right)
if pivot > med:
right = pivot - 1;
else:
left = pivot + 1;
def main():
medianSplit(arr)
print(arr)
main()

List slicing without numpy

I have the ohlc list as below:
ohlc = [["open", "high", "low", "close"],
[100, 110, 70, 100],
[200, 210, 180, 190],
[300, 310, 300, 310]]
I want to slice it as:
[["open"],[100],[200],[300]]
We can easily slice that list using numpy, but I don't know how to do it without numpy's help.
I tried the method listed below but it didn't show the value I wanted:
ohlc[:][0]
ohlc[:][:1]
ohlc[0][:]

The zip function gets you tuples containing elements from the i-th index of every sublist:
In [217]: ohlc = [["open", "high", "low", "close"],
...: [100, 110, 70, 100],
...: [200, 210, 180, 190],
...: [300, 310, 300, 310]]
...:
In [218]: for t in zip(*ohlc): print(t)
('open', 100, 200, 300)
('high', 110, 210, 310)
('low', 70, 180, 300)
('close', 100, 190, 310)
You're looking for the first one of these, you call on your friend next().
In [219]: next(zip(*ohlc))
Out[219]: ('open', 100, 200, 300)
But that's just a single tuple with all the elements and not a list of lists like you wanted, so use a list comprehension:
In [220]: [[t] for t in next(zip(*ohlc))]
Out[220]: [['open'], [100], [200], [300]]

You can iterate over the list and take the element in index in every sub list
ohlc = [["open", "high", "low", "close"],
[100, 110, 70, 100],
[200, 210, 180, 190],
[300, 310, 300, 310]]
index = 0
result = [[o[index]] for o in ohlc] # [['open'], [100], [200], [300]]

Can it be the right solution this?
list_ = []
for i in ohlc:
list_.append((i[0]))

def slice_list(input):
ans = []
for x in input:
ans.append(x[0])
return ans

Subtract 3 lists in a tuple from 1 tuple

What is the best way to do this? Looking to take the difference but not like this horrible way. For each A, B, C it is subtracted from subtract from
A = [500, 500, 500, 500, 5000]
B = [100, 100, 540, 550, 1200]
C = [540, 300, 300, 100, 10]
triples= [tuple(A),tuple(B), tuple(C)]
subtract_from = tuple([1234,4321,1234,4321,5555])
diff = []
for main in subtract_from:
for i in range(len(triples)):
for t in triples[i]:
diff[i].append(main-t)

Try something like this:
all_lists = [A, B, C]
[[i-j for i,j in zip(subtract_from,l)] for l in all_lists]
[
[734, 3821, 734, 3821, 555],
[1134, 4221, 694, 3771, 4355],
[694, 4021, 934, 4221, 5545]
]
It is the best practice of doing this. no need to import any library, just use builtins.

You could try using map and operator:
import operator
A = [500, 500, 500, 500, 5000]
B = [100, 100, 540, 550, 1200]
C = [540, 300, 300, 100, 10]
l = [A, B, C]
subtract_from = [1234,4321,1234,4321,5555]
diff = list((list(map(operator.sub, subtract_from , i)) for i in l))
print(diff)
# [[734, 3821, 734, 3821, 555], [1134, 4221, 694, 3771, 4355], [694, 4021, 934, 4221, 5545]]

First of all, if you want tuples, use tuples explicitly without converting lists. That being said, you should write something like this:
a = 500, 500, 500, 500, 5000
b = 100, 100, 540, 550, 1200
c = 540, 300, 300, 100, 10
vectors = a, b, c
data = 1234, 4321, 1234, 4321, 5555
diff = [
[de - ve for de, ve in zip(data, vec)]
for vec in vectors
]
If you want list of tuples, use tuple(de - ve for de, ve in zip(data, vec)) instead of [de - ve for de, ve in zip(data, vec)].

I think everyone else nails it with list comprehensions already so here's a few odd ones in cases if you are using a mutable lists and reusing it in an imperative style is acceptable style, then the following code can be done
A = [500, 500, 500, 500, 5000]
B = [100, 100, 540, 550, 1200]
C = [540, 300, 300, 100, 10]
subtract_from = (1234,4321,1234,4321,5555)
for i,x in enumerate(subtract_from):
A[i], B[i], C[i] = x-A[i], x-B[i], x-C[i]
# also with map
#for i,x in enumerate(zip(subtract_from,A,B,C)):
# A[i], B[i], C[i] = map(x[0].__sub__, x[1:])
diff = [A,B,C]
It's less elegant but more efficient*(...I have not done any benchmark for this claim)

Define variables with the same list data but different objects using python

this is my code :
attackUp = [10, 15,10, 15,10, 15]
defenceUp = [10, 15,10, 15,10, 15]
magicUp = [10, 15,10, 15,10, 15]
attType = [1,1,1,1,1,1]
weightDown = [10, 15,10, 15,10, 15]
#装饰器数据
accAttackSword = [100, 100,100, 100,100, 100]
accAttackSaber = [100, 100,100, 100,100, 100]
accAttackAx = [100, 100,100, 100,100, 100]
accAttackHammer = [100, 100,100, 100,100, 100]
accAttackSpear = [100, 100,100, 100,100, 100]
accAttackFight = [100, 100,100, 100,100, 100]
accAttackBow = [100, 100,100, 100,100, 100]
accAttackMagicGun = [100, 100,100, 100,100, 100]
accAttackMagic = [100, 100,100, 100,100, 100]
mStrInstrument = [100, 100,100, 100,100, 100]
mStrCharms = [100, 100,100, 100,100, 100]
accDefencePhy = [100, 100,100, 100,100, 100]
accDefenceMag = [100, 100,100, 100,100, 100]
accWeight = [100, 90, 0, 0, 100, 90]
#战术书数据
bookTurn = [1,1]
bookAttackPhy = [100, 100]
bookAttackMag = [100, 100]
bookStrInstrument = [100, 100]
bookStrCharms = [100, 100]
bookDefencePhy = [100, 100]
bookDefenceMag = [100, 100]
bookWeight = [100, 100]
you can see that : Many variables has the same value , but i cant define them like this :
bookAttackPhy = bookAttackMag =bookStrInstrument=bookStrCharms=bookDefencePhy=[100, 100]
because all change if one of them changes.
Which is the best and easiest to define these variables?

Well, a step in the right direction would be to create a base list and then copy it using slice notation:
base = [100, 100, 100, 100]
value_a = base[:]
value_b = base[:]
and so on. This doesn't gain you much for the shorter lists, but it should be useful for the longer ones at least.
But I think more generally, a richer data structure would be better for something like this. Why not create a class? You could then use setattr to fill up class members in a fairly straightforward way.
class Weapons(object):
def __init__(self, base):
for weapon in ["saber", "sword", "axe"]:
setattr(self, weapon, base[:])
w = Weapons([100, 100, 100])
print w.__dict__
#output: {'sword': [100, 100, 100],
# 'saber': [100, 100, 100],
# 'axe': [100, 100, 100]}
w.axe[0] = 10
print w.axe # output: [10, 100, 100]
print w.sword # output: [100, 100, 100]

Define them all as empty arrays, then group the ones that need the same values into a list and iterate through that list, assigning the common values to each variable.

You could do something like:
defaultAttack = [100, 100,100, 100,100, 100]
accAttackSword = list(defaultAttack)
accAttackSaber = list(defaultAttack)
The list() constructor makes a copy of the list, so they will be able to change independently.

You can use list multiplication
accAttackSword = [100]*6
....
bookWeight = [100]*2
....
You might consider grouping all of the variables with similar prefixes either into dictionaries or nested lists (EDIT - or classes/objects). This could have benefits later for organization, and would allow you to iterate thru and set them all to the same initial values.
bookVars = ['AttackPhy', 'AttackMag', 'StrInstrument', 'StrCharms']
bookValues = dict()
for i in bookVars:
bookValues[i] = [100]*2
And to access...
bookValues
{'AttackMag': [100, 100], 'StrCharms': [100, 100], 'StrInstrument': [100, 100], 'AttackPhy': [100, 100]}
bookValues['AttackMag']
[100, 100]
EDIT - check out senderle's thing too. at a glance his seems a little better, but id definitely consider using one of our ideas - the point is to structure it a little more. whenever you have groups of variables with similar prefixed names, consider grouping them together in a more meaningful way. you are already doing so in your mind, so make the code follow!