Blender Operator Translations

To move an object, definitely make use you use object.location instead of the operator.

ob.location = (1,2,3) # assign new location
ob.location[2] += 1 # move the object up 1 unit in the z-direction
reference_location = ob.location.copy() # Be sure to copy location if you want to save the values

Duplicating using the above operator changes the active selection, active object, and does not conveniently return to you the newly created object (though you could grab it via context.object immediately after the operator runs). It can also be tricky as this operator will also duplicate even hidden objects, so running  bpy.ops.object.select_all(action=’DESELECT’) prior to duplication may not accomplish what you are hoping. Instead, use the following:

ob = bpy.data.objects["some-object"] # object to duplicate
# first, create the datablock
new_ob = bpy.data.objects.new( ob.name, ob.data.copy())
context.scene.objects.link(new_ob) # adds the object to the active scene
new_ob.location = (0,0,0) # set new location, or leave it as-is to keep the same location as the original object. Note, the original selection is unchanged even if the original object wasn't selected or active.

If you wanted to make a linked duplicate, note the minor change of the second line

ob = bpy.data.objects["some-object"] # object to duplicate
new_ob = bpy.data.objects.new( ob.name, ob.data) # this will make a linked copy of ob.data
context.scene.objects.link(new_ob) # adds the object to the active scene
new_ob.location = (0,0,0) # relocate

Speed note: It is my observation that the operator can run faster when duplicating a larger quantity of objects, while duplicating a small number of objects at once is quickest via python API calls.

Simple cube duplication test (times are in seconds):

• Duplicating 3 cubes: Operator (0.00059) is slower than API call (0.00026) by a factor of 2.3
• Duplicating 51 cubes: Operator (0.00484) is about equal but slower than API call (0.00462) by a factor of 1.05
• Duplicating 343 cubes: Operator (0.0732) is faster than API call (0.0913) by a factor of 1.24
• Duplicating 2402 cubes: Operator (5.092) is faster than API call (8.307) by a factor of 1.63

Results when the same test is run on a more complex object (Suzanne model subsurf level 1 applied, with UV map and vertex group, 2,012 verts/1,968 poly):

• Duplicating 3 objects: Operator (0.00182) is slower than API call (0.00129) by a factor of 1.41
• Duplicating 51 objects: Operator (0.0181) is slower than API call (0.0158) by a factor of 1.15
• Duplicating 343 objects: Operator (0.198) is about equal but slower than API call (0.186) by a factor of 1.07
• Duplicating 2402 objects: Operator (7.08) is faster than API call (10.98) by a factor of 1.55

Additional notes

The copying method shown above does not copy everything about the source object. For examples, modifiers and vertex groups (and some other attributes) will not be carried over. You can, however, add them back selectively this way if you choose:

# ob is the original object, new_ob is the new using the above code 
for mod_src in ob.modifiers:
    # create one modifier of the same type on the new object
    dest = new_ob.modifiers.new(mod_src.name, mod_src.type)
    
    # Copy all attributes (settings, drop downs, etc) from the source modifier
    # skipping anything that is read only since those cannot be changed anyways.
    properties = [p.identifier for p in mod_src.bl_rna.properties
                  if not p.is_readonly]
    for prop in properties:
        setattr(dest, prop, getattr(mod_src, prop))

This can be replaced by a simple for-loop as below. One clear benefit of using python API calls in this case is that it is not always clear what the active group may be in the same way the active object may be, so you can be more explicit on which group it operates.

group = bpy.data.groups["group-name"]

# for loop is equivalent to bpy.ops.group.objects_remove_all()
for ob in group.objects:
    group.objects.unlink(ob) # remove from group

If you’re looking to completely remove a group, blender does not provide a single operator to completely remove a group from a blender file – so the best way is via python.

group = bpy.data.groups["group-name"]

# We still want to remove all objects first
for ob in group.objects:
    group.objects.unlink(ob) # remove from group

# then, remove the group itself - no equivalent operator
# group.user_clear() # in some cases, this may be needed
bpy.data.groups.remove(group)

When creating a new image internally in blender using the operator, you don’t immediately get the reference to the image just created. To find it, you would have to compare the list of images before and after the operator. Rather than that, you can use the constructor that comes with data.images:

# Operator method to create a gray, half-transparent 512x512 image
images_before = list(bpy.data.images) # copy the list ahead to get
bpy.ops.image.new( name="newImage", height=512, width=512, color=(0.5,0.5,0.5,0.5), alpha=True, generated_type="BLANK", float=False )
images_after = list(bpy.data.images)
differences = set(images_after).difference(images_before) # do difference of image list before/after
new_image = list(differences)[0] # extract the one new image created

# Low level api method to create a gray, half-transparent 512x512 image
new_img = bpy.data.images.new( name="newImage", height=512, width=512, alpha=True )
# we already have the reference, but need to set initial color.
# For that, the following will work.
# Note that new_img.pixels is a long, 1D list in the format of [# channels e.g. rgba]*[# total pixel count e.g. 512*512]
new_img.pixels = [0.5,0.5,0.5,0.5]*(len(new_img.pixels)/4)

Now for the timing comparison. These tests were each run 100x with each set done in a refreshed blender instance, variances within sets were all statistically non-significant. Timings are in seconds

Generally speaking, creating a single image is quite quick and likely isn’t the critical path for any operator unless it’s trying to generate a large number of images. Regardless, it appears the low level api and operator both have very similar timings for small and large images alike. The operator has a leg up when it comes to setting initial colors; the lower level api takes quite a hit especially at higher resolutions for that second line operation generating all those color values.