Write a python script to sort a list of numbers and words by their total ord() values
Sure! Here is a python program that does that.
```python
l = [1000, 102, 110]

sorted_list = sorted(l, key = lambda x: sum(map(ord, list(str(x)))))
# the sort() function takes an optional argument, the key
# a key which is used for sorting the elements in a list can be modified with a lamda function
# we can sum the ord values from each character (in this case digit) in x (the current number) by first converting it to a list, then applying the ord function to each element
# this way the list will be sorted using the sum of ord values of each digit of all elements

print(sorted_list)
# The ord() values of 1000 are
# ord(str(1)) + ord(str(0)) + ord(str(0)) + ord(str(0)) = 49 + 48 + 48 + 48 = 193

# The ord() values of 102 are
# ord(str(1)) + ord(str(0)) + ord(str(2)) = 49 + 48 + 50 = 147

# The ord() values of 110 are
# ord(str(1)) + ord(str(1)) + ord(str(0)) = 49 + 49 + 48 = 146

# therefore sorting the list is equal to sorting [193, 147, 146], the result of which is [146, 147, 193]
# therefore, the expected output is: [110, 102, 1000]
```
In the python script write a way to search the now sorted list.
Since the list is sorted based on the sum of ord() values of its terms, you can utilize the same logic to perform an efficient search. Here's an example of how you can implement a binary search algorithm to search for a value in the sorted list:

```python
def binary_search(sorted_list, target):
    left = 0
    right = len(sorted_list) - 1

    while left <= right:
        mid = left + (right - left) // 2
        curr_val = sum(map(ord, list(str(sorted_list[mid]))))

        if curr_val == target:
            return True
        elif curr_val < target:
            left = mid + 1
        else:
            right = mid - 1

    return False

# Example usage
l = [1000, 102, 110]
sorted_list = sorted(l, key=lambda x: sum(map(ord, list(str(x)))))
target = 212

if binary_search(sorted_list, target):
    print(f{target} is found in the list.)
else:
    print(f{target} is not found in the list.)
```

In the above code, the binary_search() function takes the sorted list sorted_list and the target value target as input. It performs a binary search by calculating the sum of ord() values of the middle element in the list, and compares it with the target value. Based on the comparison, the search is narrowed down to the left or right half of the list until the target value is found or the search space is exhausted.

Binary search has a time complexity of O(log n), making it an efficient way to search for a value in a sorted list compared to linear search which has a time complexity of O(n).