I have coco style annotations (json format) with Both segmentations And bboxes.
Most of the segmentations are given as list-of-lists of the pixels (polygon).
The problem is that some segmentations are given as a dictionary (with 'counts' and 'size' keys) that represent RLE values, and in these cases the 'iscrowd' key is equal to 1 (normally it is equal to 0).
I would like to convert all the 'annotations' with iscrowd==1 to be represented as polygons instead of RLE.
I do not need the mask as suggested here, but just the json file to have only polygon shaped segmentations.
Here is an example of a few annotations (from the same image), note how in the first two the segmentation is in polygon shape, and the latter two it is in RLE shape:
{'id': 53, 'image_id': 4, 'category_id': 2037037930, 'segmentation': [[344.51, 328.83, 316.02, 399.73, 358.3, 399.78, 375.85, 336.07]], 'area': 2561.4049499999965, 'bbox': [316.02, 328.83, 59.83000000000004, 70.94999999999999], 'iscrowd': 0, 'extra': {}}
{'id': 54, 'image_id': 4, 'category_id': 2037037930, 'segmentation': [[376.43, 233.52, 368.93, 250.71, 375.96, 252.89, 369.4, 269.76, 378.62, 273.83, 372.21, 292.42, 400.09, 302.34, 400.09, 302.11, 400.1, 242.04]], 'area': 1596.5407000000123, 'bbox': [368.93, 233.52, 31.170000000000016, 68.81999999999996], 'iscrowd': 0, 'extra': {}}
{'id': 67, 'image_id': 4, 'category_id': 2037037930, 'segmentation': {'counts': [55026, 2, 396, 4, 394, 7, 391, 9, 389, 12, 386, 14, 384, 17, 381, 19, 379, 21, 377, 24, 374, 26, 372, 29, 369, 31, 367, 33, 365, 36, 362, 38, 360, 41, 357, 43, 355, 46, 352, 48, 350, 50, 348, 53, 345, 55, 343, 58, 340, 38, 1, 21, 338, 37, 5, 21, 335, 37, 7, 21, 335, 34, 10, 19, 338, 32, 12, 16, 340, 33, 11, 14, 342, 33, 11, 11, 346, 33, 11, 8, 348, 33, 10, 7, 350, 33, 8, 8, 351, 34, 5, 11, 351, 33, 3, 13, 351, 49, 351, 49, 352, 49, 351, 49, 351, 49, 352, 48, 352, 49, 351, 49, 352, 46, 354, 44, 356, 41, 359, 39, 362, 36, 364, 35, 365, 35, 366, 35, 365, 35, 365, 35, 366, 34, 366, 34, 366, 35, 366, 34, 366, 34, 366, 32, 368, 29, 372, 25, 375, 23, 377, 20, 381, 18, 382, 19, 381, 19, 382, 18, 382, 18, 382, 19, 382, 18, 382, 18, 382, 19, 381, 19, 382, 16, 384, 13, 387, 9, 392, 5, 395, 2, 73808], 'size': [400, 400]}, 'area': 2598.0, 'bbox': [137, 174, 79, 65], 'iscrowd': 1, 'extra': {}}
{'id': 68, 'image_id': 4, 'category_id': 2037037930, 'segmentation': {'counts': [76703, 2, 396, 4, 394, 7, 391, 9, 389, 11, 387, 14, 384, 16, 382, 19, 379, 21, 377, 23, 375, 26, 372, 28, 370, 30, 368, 33, 365, 35, 364, 37, 363, 37, 364, 36, 364, 37, 364, 36, 364, 36, 364, 37, 364, 36, 364, 37, 363, 37, 364, 36, 364, 37, 364, 36, 364, 36, 364, 37, 364, 15, 1, 20, 364, 13, 4, 19, 365, 10, 6, 20, 363, 9, 8, 20, 361, 9, 11, 20, 358, 9, 13, 20, 356, 11, 14, 19, 354, 14, 13, 20, 351, 16, 13, 20, 348, 20, 13, 19, 346, 22, 13, 20, 343, 24, 13, 20, 341, 27, 13, 20, 338, 29, 13, 20, 336, 32, 13, 19, 334, 34, 13, 20, 331, 37, 12, 20, 331, 37, 13, 19, 332, 36, 12, 21, 331, 37, 8, 24, 332, 36, 5, 28, 331, 37, 1, 31, 331, 69, 332, 69, 331, 69, 332, 68, 332, 69, 331, 69, 332, 68, 332, 69, 332, 68, 332, 69, 331, 69, 332, 68, 332, 48, 1, 20, 331, 45, 5, 19, 332, 41, 8, 19, 332, 38, 12, 19, 332, 36, 13, 19, 332, 37, 12, 20, 331, 37, 13, 19, 332, 36, 13, 19, 332, 37, 13, 19, 332, 36, 13, 19, 332, 37, 12, 19, 332, 37, 13, 19, 332, 36, 13, 19, 332, 37, 13, 19, 332, 36, 12, 20, 332, 36, 10, 22, 332, 37, 6, 26, 332, 36, 4, 28, 332, 37, 1, 28, 335, 63, 337, 61, 339, 59, 342, 56, 344, 53, 348, 50, 350, 48, 352, 46, 355, 43, 357, 40, 360, 38, 363, 35, 365, 33, 368, 30, 370, 28, 372, 25, 376, 22, 378, 20, 381, 17, 383, 15, 385, 12, 389, 9, 391, 7, 394, 4, 396, 2, 40521], 'size': [400, 400]}, 'area': 4551.0, 'bbox': [191, 253, 108, 82], 'iscrowd': 1, 'extra': {}}
Failed test 1:
I already tried the following:
for annotation in coco_data['annotations']:
if type(annotation['segmentation']) == dict:
# Get the values of the dictionary
height = annotation['segmentation']['size'][0]
width = annotation['segmentation']['size'][1]
counts = annotation['segmentation']['counts']
# Decode the RLE encoded counts
rle = np.array(counts).reshape(-1, 2)
starts, lengths = rle[:, 0], rle[:, 1]
starts -= 1
ends = starts + lengths
pixels = []
for lo, hi in zip(starts, ends):
pixels.extend(range(lo, hi))
pixels = np.array(pixels)
# Convert the 1D pixels array to a 2D array
segments = np.zeros((height, width), dtype=np.uint8)
segments[pixels // width, pixels % width] = 1
segments = np.where(segments == 1)
# Update the segmentation and iscrowd fields
annotation['segmentation'] = [segments[1].tolist(), segments[0].tolist()]
annotation['iscrowd'] = 0
But got the following error:
ValueError Traceback (most recent call last)
<ipython-input-29-1bf7f4af292c> in <module>
16
17 # Decode the RLE encoded counts
---> 18 rle = np.array(counts).reshape(-1, 2)
19 starts, lengths = rle[:, 0], rle[:, 1]
20 starts -= 1
ValueError: cannot reshape array of size 183 into shape (2)
afaik, it expectes RLE to be an even length? not sure where is the problem and how to solve it.
Failed test 2:
then i tried something a bit different with import pycocotools.mask as mask and import skimage.measure as measure and the following function:
def rle_to_polygon(rle, height, width):
if isinstance(rle, list):
rle = mask.frPyObjects(rle, height, width)
rle = mask.decode(rle)
contours = measure.find_contours(rle, 0.5)
polygon = []
for contour in contours:
contour = np.fliplr(contour) - 1
contour = contour.clip(min=0)
contour = contour.astype(int)
if len(contour) >= 4:
polygon.append(contour.tolist())
return polygon
I receive
<ipython-input-43-84d17a601509> in rle_to_polygon(rle, height, width)
79 def rle_to_polygon(rle, height, width):
80 if isinstance(rle, list):
---> 81 rle = mask.frPyObjects(rle, height, width)
82 rle = mask.decode(rle)
83 contours = measure.find_contours(rle, 0.5)
pycocotools/_mask.pyx in pycocotools._mask.frPyObjects()
TypeError: object of type 'int' has no len()
Any suggestions would be highly appreciated!
This is my code for the task:
import logging
import cv2
from pycocotools import mask as cocomask
import copy
def rle_to_coco(annotation: dict) -> list[dict]:
"""Transform the rle coco annotation (a single one) into coco style.
In this case, one mask can contain several polygons, later leading to several `Annotation` objects.
In case of not having a valid polygon (the mask is a single pixel) it will be an empty list.
Parameters
----------
annotation : dict
rle coco style annotation
Returns
-------
list[dict]
list of coco style annotations (in dict format)
"""
annotation["segmentation"] = cocomask.frPyObjects(
annotation["segmentation"],
annotation["segmentation"]["size"][0],
annotation["segmentation"]["size"][1],
)
maskedArr = cocomask.decode(annotation["segmentation"])
contours, _ = cv2.findContours(maskedArr, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
segmentation = []
for contour in contours:
if contour.size >= 6:
segmentation.append(contour)
if len(segmentation) == 0:
logging.debug(
f"Annotation with id {annotation['id']} is not valid, it has no segmentations."
)
annotations = []
else:
annotations = list()
for i, seg in enumerate(segmentation):
single_annotation = copy.deepcopy(annotation)
single_annotation["segmentation_coords"] = (
seg.astype(float).flatten().tolist()
)
single_annotation["bbox"] = list(cv2.boundingRect(seg))
single_annotation["area"] = cv2.contourArea(seg)
single_annotation["instance_id"] = annotation["id"]
single_annotation["annotation_id"] = f"{annotation['id']}_{i}"
annotations.append(single_annotation)
return annotations
You need opencv and pycocotoolsto use this code:
pip install opencv-python
pip install pycocotools
Note that the input annotation is one of the items inside the coco dict annotations key. Something like this:
{
"image_id": 1,
"category_id": 1,
"bbox": [
485.0489501953125,
660.6587524414062,
13.161041259765625,
10.61248779296875
],
"score": 0.8787025809288025,
"segmentation": {
"size": [
960,
1280
],
"counts": "jXX>1mm03O1N10000000000001NY]mf0"
},
"id": 1,
"iscrowd": 0,
"attributes": {
"occluded": false
}
},
If a mask in rle format contains more than one mask not connected, the function will return a list with each of those masks in coco format.
Hope it helps!
Related
I have two lists and I would like to calculate the permutations between the two. I have been able to successfully do this using itertools, but am having trouble taking it further.
I have two nested lists:
list_1 = [0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 16, 114, 210, 22, 87, 28, 125][10, 216, 67, 120, 70, 717, 42, 43, 445, 14, 87, 289, 125]
list_2 = [10, 9, 2, 1, 0][10, 216, 7, 10, 70, 717, 42, 3, 445, 14, 162, 87, 289, 125]
The first entry of list_1 ([0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 16, 114, 210, 22, 87, 28, 125]) needs to be permutated with the first entry of list_2 ([10, 9, 2, 1, 0]). Then I need to get the permutations of the second entry of list_1 with the second entry of list_2, etc.
The issue is that there will be no set number of entries in each list, so it is not feasible to simply make variables for list_1[0], list_2[0], etc.
What would be the simplest way to do this?
import itertools
list_1 = ([0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 16, 114, 210, 22, 87, 28, 125],
[10, 216, 67, 120, 70, 717, 42, 43, 445, 14, 87, 289, 125])
list_2 = ([10, 9, 2, 1, 0],
[10, 216, 7, 10, 70, 717, 42, 3, 445, 14, 162, 87, 289, 125])
count = 0
for list1_item, list2_item in zip(list_1, list_2):
print(f"{list1_item=} {list2_item=}")
for permutation in itertools.permutations(itertools.chain(list1_item, list2_item)):
if count % 10**8 == 0: # print once in a while
print(permutation)
count += 1
print(count)
print(f"last permutation: {permutation}")
gives
list1_item=[0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 16, 114, 210, 22, 87, 28, 125] list2_item=[10, 9, 2, 1, 0]
(0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 16, 114, 210, 22, 87, 28, 125, 10, 9, 2, 1, 0)
(0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 210, 125, 10, 9, 114, 22, 0, 87, 2, 1, 16, 28)
(0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 28, 16, 210, 22, 125, 9, 1, 2, 87, 10, 114, 0)
...
list1_item=[10, 216, 67, 120, 70, 717, 42, 43, 445, 14, 87, 289, 125] list2_item=[10, 216, 7, 10, 70, 717, 42, 3, 445, 14, 162, 87, 289, 125]
(10, 216, 67, 120, 70, 717, 42, 43, 445, 14, 87, 289, 125, 10, 216, 7, 10, 70, 717, 42, 3, 445, 14, 162, 87, 289, 125)
...
I have a dataset in xlsx with some discrete values(name:saoi) and i want to see which discrete distribution fitts better to them.
I made some Histograms:
[Full Histogram]
[Hist with values until 5000]
[Hist with values until 10000]
The code is this:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
df = pd.read_excel('dataset.xlsx', sheet_name=0)
aoi = df ["social AoI"]
saoi = pd.Series(aoi).array
saoi = np.around(saoi)
saoi = saoi.astype(int)
h = plt.hist(saoi)
plt.title('Hist of Social AoI')
plt.xlabel('Values')
plt.ylabel('Freq')
plt.axis([0,20000, 0, 200])
plt.show()
The values are these:
In [21]:saoi
Out[21]:
array([ 0, 13, 101, 106, 10, 22, 73, 30, 1,
54, 44, 2, 4, 52, 106, 70, 1, 11,
3, 50, 2, 9, 2, 28, 32, 15, 2,
42, 53, 16, 13, 70, 12, 91, 11, 43,
18, 53, 91, 9, 52, 9, 19, 27, 18,
53, 19, 242, 19, 22, 24, 53, 90, 82,
100, 62, 111, 20, 22, 8, 41, 134, 51,
72, 10, 1, 23, 3, 32, 1, 30, 18,
164, 10, 32, 35, 65, 79, 19, 21, 37,
20, 55, 32, 75, 489, 61, 111, 54, 46,
68, 53, 12, 7, 95, 43, 48, 11, 241,
7, 295, 284, 55, 69, 223, 4, 66, 278,
33, 22, 26, 197, 117, 242, 252, 29, 325,
289, 76, 28, 84, 21, 204, 74, 189, 11,
162, 85, 35, 510, 4, 135, 299, 211, 406,
149, 99, 2, 10, 1150, 427, 337, 16, 157,
620, 95, 257, 45, 368, 428, 108, 1041, 189,
32, 246, 38, 351, 578, 151, 240, 905, 309,
7, 8, 25, 226, 22, 50, 637, 74, 825,
152, 543, 1484, 893, 524, 866, 5, 236, 1608,
387, 1038, 83, 147, 2871, 6669, 2058, 577, 1634,
2522, 4915, 9, 298, 3074, 856, 29, 7164, 1641,
1270, 143, 508, 476, 2145, 1678, 2135, 86, 1085,
4106, 967, 266, 1302, 11875, 6011, 63, 1470, 2321,
9080, 19216])
I tried to fit some discrete distribution with this code(using likelihoods):
import pandas as pd
from scipy.stats import nbinom, poisson, geom, dlaplace, randint, yulesimon
import math
import numpy as np
x = pd.Series(saoi)
mean = x.mean()
var = x.var()
likelihoods = {}
#nbinom
p = mean / var
r = p * mean / (1-p)
likelihoods['nbinom'] = x.map(lambda val: nbinom.pmf(val, r, p)).prod()
#poisson
lambda_ = mean
likelihoods['poisson'] = x.map(lambda val: poisson.pmf(val, lambda_)).prod()
#geometric
p = 1 / mean
likelihoods['geometric'] = x.map(lambda val: geom.pmf(val, p)).prod()
#dlaplace
a = math.sqrt(var/2)
likelihoods['dlaplace'] = x.map(lambda val: dlaplace.pmf(val, a)).prod()
#randint
low = 0
high = 242
likelihoods['randint'] = x.map(lambda val: randint.pmf(val, low, high)).prod()
#yulesimon
p = mean / (mean-1)
likelihoods['yulesimon'] = x.map(lambda val: yulesimon.pmf(val, p)).prod()
best_fit = max(likelihoods, key=lambda x: likelihoods[x])
print("Best fit:", best_fit)
print("Likelihood:", likelihoods[best_fit])
but the results are bad as the likelihoods are 0.
How could i find a better fitting discrete distribution? There are many ways for continuous but what about the discrete ones?
Why my boxplot is not showing the expected output? I can see only circles and instead I'll want to see a traditional boxplot. How can I fix it?
import matplotlib as plt
collection_0 = [826, 58, 305, 161, 341, 25, 50, 1303, 1241, 406, 4318, 14330, 62, 45, 17, 809, 2560, 2901, 1988, 1755, 2584, 1924, 218, 13, 140, 156, 591, 109, 17, 563, 242, 23, 156, 179, 85, 59, 78, 55, 57, 27, 33, 62, 499, 685, 1418, 70, 155, 388, 205, 62, 22, 358, 688, 273, 27, 107, 85, 856, 375, 144, 476, 161, 33, 1748, 315, 106, 347, 85, 43, 157, 770, 616, 220, 13, 170, 156, 200, 165, 1211, 138, 163, 61, 78, 140, 318, 1296, 14, 386, 19, 918, 193, 381, 178, 106, 91, 109, 261, 72, 436, 194, 176, 237, 28, 201, 36, 166, 1928, 358, 611, 58, 82, 59, 37, 269, 223, 836, 45, 425, 166, 26, 63, 387, 270, 180, 331, 342, 629, 610, 46, 67, 151, 57, 188, 70, 96, 41, 92, 79, 26, 56, 188, 466, 214, 45, 39, 161, 70, 134, 370, 70, 401, 85, 113, 224, 60, 508, 58, 71, 49, 56, 400, 1308, 22, 124, 74, 63, 56, 84, 144, 26, 29, 33, 20, 241, 25, 17, 25, 45, 37, 100, 93, 175, 27, 308, 134, 28, 203, 195, 161, 168, 364, 102, 66, 53, 57, 195, 30, 55, 108, 110, 75, 42, 531, 25, 17, 156, 24, 29, 303, 77, 36, 184, 67, 15, 92, 124, 206, 51, 87, 83, 23, 134, 64, 50, 99, 451, 144, 265, 228, 96, 357, 39, 14, 91, 46, 110, 75, 18, 30, 93, 61, 31, 203, 226, 92, 162, 415, 30, 48, 86, 51, 79, 130, 181, 17, 64, 57, 168, 153, 72, 57, 34, 234, 18, 30, 72, 98, 44, 114, 58, 23, 54, 24, 126, 37, 28, 73, 8, 38, 86, 214, 46, 34, 63, 79, 72, 111, 37, 499, 382, 76, 589, 72, 139, 108, 301, 63, 158, 17, 12, 103, 337, 65, 17, 56, 32, 27, 14, 224, 33, 40, 55, 60, 76, 18, 24, 56, 99, 135, 23, 50, 102, 74, 114, 29, 24, 50, 84, 33, 316, 52, 38, 112, 61, 10, 22, 17, 71, 22, 99, 51, 84, 34, 32, 18, 91, 240, 29, 141, 121, 67, 40, 303, 78, 86, 48, 149, 102, 57, 42, 88, 137, 133, 89, 88, 70, 31, 24, 73, 7, 53, 46, 156, 17, 133, 85, 103, 70, 26, 145, 26, 112, 81, 37, 27, 98, 14, 84, 26, 31, 43, 42, 19, 38, 32, 35, 92, 168, 53, 175, 25, 30, 48, 84, 98, 57, 62, 32, 38, 75, 11, 33, 29, 38, 48, 52, 244, 303, 135, 10, 52, 12, 43, 78, 34, 50, 51, 49, 68, 68, 53, 18, 50, 64, 17, 27, 17, 21, 12, 46, 29, 35, 31, 93, 93, 25, 20, 18, 18, 43, 61, 29, 16, 40, 28, 26, 15, 30, 41, 67, 75, 53, 64, 105, 15, 35, 41, 22, 54, 20, 38, 31, 21, 105, 23, 37, 12, 29, 38, 16, 16, 21, 57, 66, 83, 44, 43, 14, 28, 48, 51, 17, 21, 16, 7, 34, 50, 23, 14, 18, 23, 32, 91, 29, 31, 23, 9, 14, 17, 15, 43, 16, 17, 20, 11, 16, 7, 13, 11, 49, 42, 13, 23, 18, 28, 38, 23, 10, 32, 9, 34, 16, 18, 9, 23, 16, 12, 65, 31, 37, 16, 9, 34, 8, 12, 22, 55, 17, 30, 13, 25, 27, 14, 7, 78, 19, 11, 41, 54, 22, 27, 8, 18, 22, 6, 29, 16, 35, 27, 8, 10, 7, 51, 9, 23, 12, 9, 6, 15, 16, 8, 7, 14, 12, 10, 14, 17, 10, 13, 18, 8, 7, 9, 10, 10]
collection_1 = [1353, 25, 2430, 1995, 1209, 1291, 564, 68, 1184, 81, 132, 140, 1463, 258, 143, 338, 63, 38, 144, 534, 130, 2742, 392, 157, 301, 193, 620, 2303, 2269, 84, 1464, 148, 593, 191, 102, 1194, 211, 11, 2498, 359, 808, 552, 96, 334, 238, 46, 1771, 536, 160, 195, 318, 193, 684, 280, 249, 19, 235, 15, 144, 2030, 104, 619, 523, 106, 902, 31, 13, 55, 9, 21, 68, 51, 45, 92, 41, 432, 436, 137, 81, 57, 210, 254, 34, 28, 301, 72, 134, 409, 30, 53, 112, 106, 267, 33, 57, 35, 18, 143, 52, 45, 36, 183, 43, 66, 40, 100, 194, 139, 18, 280, 262, 62, 331, 196, 604, 56, 43, 181, 82, 171, 57, 22, 34, 52, 46, 260, 125, 50, 46, 23, 69, 83, 28, 219, 94, 32, 82, 31, 200, 20, 78, 725, 225, 107, 58, 59, 31, 44, 18, 136, 180, 74, 20, 44, 28, 90, 69, 48, 47, 50, 74, 18, 50, 20, 75, 127, 19, 80, 23, 163, 30, 103, 27, 10, 37, 37, 44, 41, 46, 49, 48, 55, 14, 19, 42, 79, 50, 45, 36, 15, 45, 128, 122, 46, 38, 21, 21, 81, 24, 12, 15, 53, 9, 26, 43, 23, 16, 79, 9, 45, 146, 58, 17, 30, 13, 8, 17, 24, 56, 6, 12, 17, 9, 15, 11, 13, 13, 12, 14, 21, 10, 8, 15, 8, 28, 8, 11, 24, 9, 13, 30, 14, 15, 7, 9, 25, 7, 8, 10, 5, 7, 7, 6, 7, 6, 7, 8, 9]
data_to_plot = [collection_0, collection_1]
box = plt.boxplot(data_to_plot,patch_artist=True, labels=["Contracting", "Expanding"])
colors = ['red', 'green']
for patch, color in zip(box['boxes'], colors):
patch.set_facecolor(color)
plt.ylabel("Unique adopters")
plt.show()
Your data varies over 4 orders of magnitude with a majority of data lying close to less than 1000. The mean of your data is around 170 and so the whole box plot appears compressed due to the huge outlier value of above 14000. You can see this via a histogram
plt.hist(collection_0);
You should try using a log scale for your expected visualization
plt.yscale('log')
I'm interested in plotting the probability distribution of a set of points which are distributed as a power law. Further, I would like to use logarithmic binning to be able to smooth out the large fluctuations, especially those observed in the tail. I made the code:
plt.figure()
plt.grid(True)
plt.loglog(x, y, 'bo')
plt.savefig('distribution.png', dpi=400)
plt.show()
plt.close()
Where x and y are lists with the data. I know I should use numpy.logspace, but I'm not sure how to do it.
I attach the lists and image of the graph:
Graphic: 1
x=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 44, 45, 46, 48, 50, 53, 54, 55, 56, 57, 58, 59, 63, 64,
66, 71, 72, 73, 76, 79, 81, 84, 85, 86, 90, 95, 97, 99, 100, 101, 103,
105, 114, 117, 118, 120, 122, 129, 141, 159, 166, 168, 172, 199, 201,
206, 218, 226, 243, 260, 262, 263, 265, 273, 274, 278, 281, 292, 300,
390, 404, 420, 443, 491, 849, 939, 1036, 1156, 1191, 1389, 1551, 1742,
2082]
y=[0.0, 0.3508771929824561, 0.4259259259259261, 0.4400278940027895,
0.439337474120083, 0.43933333333333335, 0.4165445665445665,
0.4361247947454843, 0.4325877825877826, 0.4820728291316526,
0.42828042328042315, 0.35761299632267374, 0.3491461529923068,
0.4079423222280365, 0.43694194694194693, 0.34069215098626865,
0.3449795896319961, 0.3633688071188071, 0.30852671293847767,
0.4242381075714409, 0.20068791049183207, 0.24466260863319686,
0.12237645395540135, 0.37624875124875123, 0.28918557997841887,
0.25374977395437753, 0.4761346678013344, 0.41219336219336217,
0.19267411510058569, 0.30895915678524377, 0.18104998922645982,
0.2407892107892108, 0.23937740965604742, 0.3727204759813455,
0.23712669683257917, 0.2567023619655199, 0.33474793703626654,
0.3520767731294047, 0.2475947884643537, 0.3738888888888889,
0.5274725274725275, 0.33489003749873314, 0.18518518518518517,
0.15181358496575886, 0.3152953084067635, 0.17919413919413918,
0.20858299108299105, 0.21746880570409982, 0.1915602105707053,
0.2972972972972973, 0.18115942028985507, 0.25, 0.32707722385141735,
0.33894302848575714, 0.21774193548387097, 0.34782608695652173,
0.27608756290137165, 0.17296320127462694, 0.2727272727272727,
0.2879728132387707, 0.06535947712418301, 0.083710407239819,
0.28118393234672306, 0.1951219512195122, 0.09254361251031618,
0.3062211259885678, 0.002663622526636225, 0.27311522048364156,
0.0506558118498417, 0.1044776119402985, 0.06284153005464481,
0.18588399720475193, 0.2129032258064516, 0.14903846153846154,
0.021532091097308487, 0.3089430894308943, 0.301010101010101,
0.3761904761904762, 0.10466269841269842, 0.07138047138047138,
0.21709633649932158, 0.019401589527816735, 0.017575757575757574,
0.15817805383022773, 0.025306629405371837, 0.20850040096230954,
0.0001638001638001638, 0.04357084357084357, 0.09221213569039656,
0.14047410008779632, 0.002560163850486431, 0.0031680440771349864,
0.12334152334152335, 0.6428571428571429, 0.012745098039215686,
0.0058073399287151255, 0.0012413644214162348, 0.013532269257460098,
0.04368752313957793, 0.20265151515151514, 0.0018470281790196543,
0.023099982366425676, 0.03265807243707796, 0.00695970695970696,
0.003737745098039216, 0.009634076615208691, 0.024085079762277136,
0.0062196422224854876, 0.030849549121974372, 0.01636020744931636,
0.003922512815882666, 0.005677708965459911, 0.04833570605382686,
0.014331723027375202]
I want to multiply only every second number on a list(0-100) but I just can't get it to work.
[x*10 for x in range(100) if x%2==0] # take vale to be multiply instead of 10, use x if you want to multiply with number it self
below code will only multiply even elements and keep other as it is.
def iterate_lis(get_list):
ls = []
for x in get_list:
if x%2==0:
ls.append(x*2)
else:
ls.append(x)
print(ls)
return ls
iterate_count = 5 # list will be iterate 5 times
for i in range(iterate_count):
if i ==0:
get_lis = iterate_lis(range(100))
else:
get_lis = iterate_lis(get_lis)
result for iterate_count=5 will be as follow:
>>>
[0, 1, 4, 3, 8, 5, 12, 7, 16, 9, 20, 11, 24, 13, 28, 15, 32, 17, 36, 19, 40, 21, 44, 23, 48, 25, 52, 27, 56, 29, 60, 31, 64, 33, 68, 35, 72, 37, 76, 39, 80, 41, 84, 43, 88, 45, 92, 47, 96, 49, 100, 51, 104, 53, 108, 55, 112, 57, 116, 59, 120, 61, 124, 63, 128, 65, 132, 67, 136, 69, 140, 71, 144, 73, 148, 75, 152, 77, 156, 79, 160, 81, 164, 83, 168, 85, 172, 87, 176, 89, 180, 91, 184, 93, 188, 95, 192, 97, 196, 99]
[0, 1, 8, 3, 16, 5, 24, 7, 32, 9, 40, 11, 48, 13, 56, 15, 64, 17, 72, 19, 80, 21, 88, 23, 96, 25, 104, 27, 112, 29, 120, 31, 128, 33, 136, 35, 144, 37, 152, 39, 160, 41, 168, 43, 176, 45, 184, 47, 192, 49, 200, 51, 208, 53, 216, 55, 224, 57, 232, 59, 240, 61, 248, 63, 256, 65, 264, 67, 272, 69, 280, 71, 288, 73, 296, 75, 304, 77, 312, 79, 320, 81, 328, 83, 336, 85, 344, 87, 352, 89, 360, 91, 368, 93, 376, 95, 384, 97, 392, 99]
[0, 1, 16, 3, 32, 5, 48, 7, 64, 9, 80, 11, 96, 13, 112, 15, 128, 17, 144, 19, 160, 21, 176, 23, 192, 25, 208, 27, 224, 29, 240, 31, 256, 33, 272, 35, 288, 37, 304, 39, 320, 41, 336, 43, 352, 45, 368, 47, 384, 49, 400, 51, 416, 53, 432, 55, 448, 57, 464, 59, 480, 61, 496, 63, 512, 65, 528, 67, 544, 69, 560, 71, 576, 73, 592, 75, 608, 77, 624, 79, 640, 81, 656, 83, 672, 85, 688, 87, 704, 89, 720, 91, 736, 93, 752, 95, 768, 97, 784, 99]
[0, 1, 32, 3, 64, 5, 96, 7, 128, 9, 160, 11, 192, 13, 224, 15, 256, 17, 288, 19, 320, 21, 352, 23, 384, 25, 416, 27, 448, 29, 480, 31, 512, 33, 544, 35, 576, 37, 608, 39, 640, 41, 672, 43, 704, 45, 736, 47, 768, 49, 800, 51, 832, 53, 864, 55, 896, 57, 928, 59, 960, 61, 992, 63, 1024, 65, 1056, 67, 1088, 69, 1120, 71, 1152, 73, 1184, 75, 1216, 77, 1248, 79, 1280, 81, 1312, 83, 1344, 85, 1376, 87, 1408, 89, 1440, 91, 1472, 93, 1504, 95, 1536, 97, 1568, 99]
[0, 1, 64, 3, 128, 5, 192, 7, 256, 9, 320, 11, 384, 13, 448, 15, 512, 17, 576, 19, 640, 21, 704, 23, 768, 25, 832, 27, 896, 29, 960, 31, 1024, 33, 1088, 35, 1152, 37, 1216, 39, 1280, 41, 1344, 43, 1408, 45, 1472, 47, 1536, 49, 1600, 51, 1664, 53, 1728, 55, 1792, 57, 1856, 59, 1920, 61, 1984, 63, 2048, 65, 2112, 67, 2176, 69, 2240, 71, 2304, 73, 2368, 75, 2432, 77, 2496, 79, 2560, 81, 2624, 83, 2688, 85, 2752, 87, 2816, 89, 2880, 91, 2944, 93, 3008, 95, 3072, 97, 3136, 99]
You can`t multiply with 0 , because the result will be always 0.
result=1
for i in range (1 , 10 ):
if i%2==0:
result*=i
print(result)
import numpy as np
l = range(100)
np.product(l[0::2])
This will give you every second element of your list and multiply all.
I want to change to list so: 1,2,3,4,5,6,7,8 becomes 1,4,3,8,5,16 etc.
Though I don't understand how you multiply 6 to end up with 16, I assume this is what you need:
new_list = []
for x in range(1,100):
if x % 2 == 0: new_list.append(x*2)
else: new_list.append(x)
print(new_list)
If the number is divisible by 2, you multiply it with 2 and append it to a new list. If not, you just append it without multiplying.
Running this program, you get the following output:
[1, 4, 3, 8, 5, 12, 7, 16, 9, 20, 11, 24, 13, 28, 15, 32, 17, 36, 19, 40, 21, 44, 23, 48, 25, 52, 27, 56, 29, 60, 31, 64, 33, 68, 35, 72, 37, 76, 39, 80, 41, 84, 43, 88, 45, 92, 47, 96, 49, 100, 51, 104, 53, 108, 55, 112, 57, 116, 59, 120, 61, 124, 63, 128, 65, 132, 67, 136, 69, 140, 71, 144, 73, 148, 75, 152, 77, 156, 79, 160, 81, 164, 83, 168, 85, 172, 87, 176, 89, 180, 91, 184, 93, 188, 95, 192, 97, 196, 99]
Use range() to generate the indexes of the entries you want to change...
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
for i in range(1, len(numbers), 2):
numbers[i] *= 2
will result in numbers containing the list
[1, 4, 3, 8, 5, 12, 7, 16]