从 Python 中的字符串列表中提取和舍入数字

Question

I have a Python list that contains strings, integers, and floats

my_list = [['100', '200.1', 'z', '300.9', '400', '100.2']]

I have been trying to figure out how to:

• remove strings
• round floats and converts them to integers
• remove duplicates

The goal is to return a list that looks similar to the list below

new_list = [100, 200, 301, 400]

Is this possible and how should I approach this?

Answer 1

The safest way to remove any alphanumerics and convert rest to rounded int is something like the below:

import re

my_list = [['100', '200.1', 'z', '1000_100', '300.9', '400', '100.2']]
my_list_2 = list(set([round(float(x)) for x in my_list[0] if re.fullmatch("[\d\.]+",x) is not None]))
print(my_list_2)

[200, 400, 100, 301]

A much improved answer thanks to Alexander and Stefan.

Answer 2

Please note that your question has a list containing a list of strings.

If you actually have a list of strings, omit the [0] .

result = []
for item in my_list[0]:
  try:
    v = float(item)
  except ValueError:
    continue
  v = int(round(v))

  if v not in result:
    result.append(v)

Then

print(result)
[100, 200, 301, 400]

Answer 3

Easiest way is to create a helper function that lets you convert to an int without throwing:

my_list = [['100', '200.1', 'z', '300.9', '400', '100.2']]

def make_int(s):
    """
    Convert s to an int, rounding if it is a floating point value. 
    Return None if the conversion cannot be done.
    """

    try:
        return int(round(float(s)))
    except:
        return None

newlist = list(set([i for i in [make_int(s) for s in my_list[0]] if i != None]))

This involves two nested list comprehensions:

The inner one converts the list to rounded floats, returning None for strings: [make_int(s) for s in my_list[0]]

The outer one strips the None 's: [i for i in <inner> if i != None]

This also removes the need to muck with regexes.

Answer 4

It's a one liner

list(dict.fromkeys(x for x in (round_or_none(s) for s in l) if x))

(if, of course, you have defined in advance the round_or_none function,

def round_or_none(s):
    try:
        return round(float(s))
    except ValueError:
        pass

that is:-)

Demo:

>>> def round_or_none(s):
...     try:
...         return round(float(s))
...     except ValueError:
...         pass
... 
>>> l = ['100', '200.1', 'z', '300.9', '400', '100.2']
>>> list(dict.fromkeys(x for x in (round_or_none(s) for s in l) if x))
[100, 200, 301, 400]
>>>

---

Without the extra function

rounded = []
for s in l:
    try:
         rounded.append(round(float(s)))
    except ValueError:
         pass
rounded = list(dict.fromkeys(rounded))

---

This works for Python 3.6 and newer, otherwise use an OrderedDict

from collections import OrderedDict
...
rounded = list(OrderedDict.fromkeys(rounded))

Answer 5

Another approach: use more-itertools .

from more-itertools import map_except, unique_everseen
my_list = ['100', '200.1', 'z', '300.9', '400', '100.2']

intlist = list(unique_everseen(map_except(lambda s: round(float(s)), my_list, ValueError)))
##########################################################################################

print(intlist) #> [100, 200, 301, 400]

Here are the docs

• for unique_everseen ;
• for map_except .

Answer 6

Simplest way is with a "try/catch" and just build the new list from that.

my_list = ['100', '200.1', 'z', '300.9', '400', '100.2']
new_list = []
for item in my_list:
    try:
        new_list.append(int(float(item)))
    except ValueError:
        pass

new_list = list(set(new_list))
print(new_list)

Alternative is to use a list comprehension. Use round instead of int if you want the rounding and not the truncation.

Answer 7

The "pythonic" one-liner:

a = ['100', '200.1', 'z', '300.9', '400', '100.2']
list(set([int(round(float(b))) for b in a if b.isdigit()]))
>>> [400, 100]

Answer 8

Simple Answer

my_list = [['100', '200.1', 'z', '300.9', '400', '100.2']]
new_list=[]
for i in my_list:
    for j in i:
        try:
            num=round(float(j))
            if num not in new_list:
                new_list.append(num)
        except:
            pass
print(new_list)

Answer 9

mmm in order to solve this, i would use a couple of tricks and a list comprehensions.

#with a regex you can define a matching pattern in order to
#clean the list of strings of every alpabetic element

import re
old = ['100', '200.1', 'z', '300.9', '400', '100.2']

# for every element that not match with capitals A to Z, or a to z
# make it a round float into this list.
new = [round(float(x)) for x in old if not re.match(r'[A-Za-z]',x)]
#clean the duplicates and print
print(list(set(new)))

Answer 10

True. I missed the float conversion first - shouldn't answer questions from the phone:) fixed

Answer 11

The format of the list isn't clearly defined. For the sake of this solution, I will assume that the input is a two-dimensional list of strings (AKA a list of list of strings). If your lists follow a different format (multiple levels deep, sublists mixed in with strings, etc.) it is possible that lists are not the data structure you need.

import itertools as itt

def str_to_int(str_in):
    try:
        res = round(float(str_in))
    except ValueError:
        res = None
    return res

def trans_lst(lst_in):
    flat_lst = itt.chain.from_iterable(lst_in)
    parse_res = (str_to_int(item) for item in flat_lst)
    res_lst = list(set((item for item in parse_res if item is not None)))

    return res_lst