You can use a list comprehension to produce a list of dictionaries, then convert that:

json_string = json.dumps([ob.__dict__ for ob in list_name])

or use a default function; json.dumps() will call it for anything it cannot serialise:

def obj_dict(obj):
    return obj.__dict__

json_string = json.dumps(list_name, default=obj_dict)

The latter works for objects inserted at any level of the structure, not just in lists.

Personally, I'd use a project like marshmallow to handle anything more complex; e.g. handling your example data could be done with

from marshmallow import Schema, fields

class ObjectSchema(Schema):
    city = fields.Str()
    name = fields.Str()

object_schema = ObjectSchema()
json_string = object_schema.dumps(list_name, many=True)

import json

array = '{"fruits": ["apple", "banana", "orange"]}'
data  = json.loads(array)
print(data['fruits']) 
# the print displays:
# ['apple', 'banana', 'orange']

You had everything you needed. data will be a dict, and data['fruits'] will be a list

What you are looking to do is deserialize a json object to a class, I'm sure there are better answers than this one but here goes.

First Step: convert json array to python list

import json
# assuming it is a json object for now, you can loop through an do the same
json = {'completed': 0, 'content': 'do smtng', 'deadline': 'Mon, 22 Nov 2021 00:00:00 GMT', 'id': 4, 'user_id': 7}
job = json.loads(json)

Second Step: Converting our list to a class

There's not really a consensus here on how to do this. You can try libraries like attrs if your json is already formatted with the exact naming of your class, or you can do something manual like this:

import json
from dataclasses import dataclass


@dataclass
class Task:
    completed: int
    content: str
    deadline: str
    id: int
    user_id: int
    
    @classmethod
    def from_dict(cls, dict):
        return cls(completed=dict["completed"], content=dict["content"],
                   deadline=dict["deadline"], id=dict["id"],
                   user_id=dict["user_id"])

    @classmethod
    def from_json(cls, json_str: str):
        return cls.from_dict(json.loads(json_str))

You can perform input validation here too if you want but trying to keep it basic

Solved the problem this way:

elements = json.loads(contents, object_hook=lambda d: Element(**d))

You should code a dump method in your object and use it when sending things to json module:

class IpPort:
    def __init__(self, ip, port, time, status):
        self.ip = ip
        self.port = port
        self.time = time
        self.status = status

    def dump(self):
        return {"IpPortList": {'ip': self.ip,
                               'port': self.port,
                               'time': self.time,
                               'status': self.status}}

And when converting data to json:

json.dumps([o.dump() for o in my_list_of_ipport])

You can even make it more automatic by creating a custom encoder for your JSON but it seems like overkill here.

Edit:

To answer the comment on the load part, if you just want a list of dict json.loads is the way to go. If you want a list of IpPort you have to ways to do it, either you do the following (considering that your dumped dicts are flat):

ip_ports = [IpPort(**attrs) for attrs in json.loads(dumped_ipports)]

Note: The ** operator transform a dict into keyword arguments.

If your dumped dicts are not flat (which is your case), you should create a static method load which returns an instance of the object created from a dump:

class IpPort:
    ... blablabla ...

    @staticmethod
    def load(dumped_obj):
        return IpPort(dumped_obj['IpPortList']['ip'],
                      dumped_obj['IpPortList']['port'],
                      dumped_obj['IpPortList']['time'],
                      dumped_obj['IpPortList']['status'])

And the way to make it a list:

my_ip_ports = [IpPort.load(dumped_ipport)
               for dumped_ipport in json.loads(dumped_stuff)]

make it this way:

def getTasks(filename):
    f = open(filename, 'r')
    a = open('tasksJSON', 'w')
    x = []
    d = xmltodict.parse(f)
    l = d.get('Project').get('Tasks').get('Task')
    for task in l:
        if (task['Name'] == 'dinner'):  #criteria for desirable tasks
            #j = json.dumps(task)
            x.append(task)
            #a.write (str(j))   
            #a.write(',')         

    a.write(json.dumps(x))
    f.close()
    a.close()