Automated Rendering of Multiple Objects
You will definitely have to adjust and ignore some code, paths etc, but most of it is reusable. You also need the MultiCamera addon.

import bpy
import time
import numpy as np
from datetime import datetime
import os
startTime = datetime.now()


def delThisObj(obj):
    bpy.data.scenes[0].objects.unlink(obj)
    bpy.data.objects.remove(obj)
    return


def setupCamera(scene, c):
    pi = np.pi

    scene.camera.rotation_euler[0] = c[0] * (pi / 180.0)
    scene.camera.rotation_euler[1] = c[1] * (pi / 180.0)
    scene.camera.rotation_euler[2] = c[2] * (pi / 180.0)

    scene.camera.location.x = c[3]
    scene.camera.location.y = c[4]
    scene.camera.location.z = c[5]

    return

# Assumes there is only the car object (no camera etc.)
# example use:  oldmat = [['body'], ['M_0056_Yellow']], newMat = 'Body_Pain_new'
def changeMaterialColor(old, new):
    for o in old:
        for mat in bpy.data.objects[0].data.materials:
            if mat.name == o:
                bpy.data.objects[0].material_slots[mat.name].material = bpy.data.materials[new]
    return

def setEnvironmentTexture():
    # TODO: Load all environment textures if possible
    # TODO: and just exchange which one will be used for curret render

    # Add Environment-texture to image collection
    fileName = 'shanghai_bund_8k.hdr'
    filePath = 'D:\\Anon\\HDRIs\\' + fileName
    fileDir = 'D:\\Anon\\HDRIs\\'
    bpy.ops.image.open(filepath=filePath, directory=fileDir)

    # [4.9.1] Set HDRI background

    # Add nodes
    bpy.data.worlds['World'].use_nodes = True
    texEnv = bpy.data.worlds['World'].node_tree.nodes.new(type='ShaderNodeTexEnvironment')
    nodeMap = bpy.data.worlds['World'].node_tree.nodes.new(type='ShaderNodeMapping')
    texCoord = bpy.data.worlds['World'].node_tree.nodes.new(type='ShaderNodeTexCoord')
    background = bpy.data.worlds['World'].node_tree.nodes['Background']

    # Link Nodes
    links = bpy.data.worlds['World'].node_tree.links
    links.new(texCoord.outputs[0], nodeMap.inputs[0])
    links.new(nodeMap.outputs[0], texEnv.inputs[0])
    links.new(texEnv.outputs[0], background.inputs[0])

    bpy.data.worlds['World'].node_tree.nodes['Environment Texture'].image = bpy.data.images[fileName]

def main(model):
    # [1] Reset Scene, based on factory settings
    if list(bpy.data.objects).__len__() == 3:
        defaultCube = bpy.data.objects['Cube']
        defaultLamp = bpy.data.objects['Lamp']
        defaultCamera = bpy.data.objects['Camera']

        delThisObj(defaultCube)
        delThisObj(defaultLamp)
        delThisObj(defaultCamera)

    for item in bpy.data.meshes:
        bpy.data.meshes.remove(item)

    # [2] Change to Cycles Render
    bpy.context.scene.render.engine = 'CYCLES'

    # [3] import .obj
    filepath = model + '\model.obj'
    bpy.ops.import_scene.obj(filepath=filepath)

    # [4.9.2] Create shadowcatcher
    # Create plane
    bpy.ops.mesh.primitive_plane_add()

    # Make it a shadow-catcher
    bpy.data.objects["Plane"].cycles.is_shadow_catcher = True

    # Scale the plane to match modelsize
    bpy.ops.transform.resize(value=(10, 10, 10))

    # [5] Enable multi-camera addon
    bpy.ops.wm.addon_enable(module="multiplecamera")

    # [6] Add Sun and position it
    #x, y, z = 1, 2, 3
    #bpy.ops.object.lamp_add(type="SUN")
    #sun = bpy.data.objects['Sun']
    #sun.location[0] = x
    #sun.location[1] = y
    #sun.location[2] = z

    # [7] Add cameras and position them
    numberOfCameras = 4
    scene = bpy.data.scenes["Scene"]

    # [euler0, euler1, euler2, x, y, z]
    cam0 = [77.487, -0.000244, 91.4015, 13.6156, 0.094522, 2.19869]
    cam1 = [70.2677, -0.000819, 173.623, 1.1328, 11.1731, 3.33687]
    cam2 = [85.5084, 0.000169, -90.6852, -12.8706, 0.355527, 1.29131]
    cam3 = [74.6794, -0.002039, 11.1926, 3.2923, -15.5643, 4.444]

    camList = [cam0, cam1, cam2, cam3]

    for i in range(numberOfCameras):
        bpy.ops.object.camera_add()
        newCamera = bpy.data.objects['Camera']
        newCamera.name = 'c' + str(i)

        newCamera.rotation_mode = 'XYZ'
        scene.camera = newCamera

        config = camList[i]
        setupCamera(scene=scene, c=config)

    # [7.5] Set resolution
    bpy.data.scenes["Scene"].render.resolution_percentage = 100

    # [8] Enable CUDA and activate GPU
    # code from https://developer.blender.org/T54099

    scene = bpy.context.scene
    scene.cycles.device = 'GPU'

    prefs = bpy.context.user_preferences
    cprefs = prefs.addons['cycles'].preferences

    # Attempt to set GPU device types if available
    for compute_device_type in ('CUDA', 'OPENCL', 'NONE'):
        try:
            cprefs.compute_device_type = compute_device_type
            break
        except TypeError:
            pass

    # Enable all CPU and GPU devices
    for device in cprefs.devices:
        device.use = True

    # [9] Select all cameras
    for i in range(numberOfCameras):
        camera = 'c' + str(i)
        bpy.data.objects[camera].select = True

    # [10] Render selected cameras with mutli-camera addon

    # define outputpath
    path = r'C:\Users\Anon\Desktop\3DModels\TestRenderings4\\'

    bpy.data.scenes['Scene'].MultiOutputDir = path+model.split('\\')[-1] + '\\'
    # render
    bpy.ops.render.multiple_camera_render()

    # [12] Delete every object in the scene
    bpy.ops.object.mode_set(mode='OBJECT')
    bpy.ops.object.select_by_type(type='MESH')
    bpy.ops.object.delete(use_global=False)

    for item in bpy.data.meshes:
        bpy.data.meshes.remove(item)

if __name__ == "__main__":
    print(datetime.now() - startTime)

    listOfModels = [
        '1a30678509a1fdfa7fb5267a071ae23a',
        '1a4337da899da1936909632a947fc19b',
        '1a7125aefa9af6b6597505fd7d99b613',
        '1a7d2c9d3a084885afa2ee0adc62d22',
         ]

    setEnvironmentTexture()

    for p in range(listOfModels.__len__()):
        main(model=r'C:\Users\Anon\Desktop\3DModels\02958343\\' + listOfModels[p])

    print(datetime.now() - startTime)