Finds the absolute max of the numbers in each file and outputs in specific format Inputs:
Files that are named in this scheme:
FAX_99383.txt- (txt files with columns of any width)

==> FAX_99383.txt &lt;== (two rows of 12 numbers)

-93.    -95.    -97.    -96.    -95.    -93.    -91.    -90.    -89.    -88.    -87.    -89.
-99.   -101.   -103.   -102.   -101.    -99.    -97.    -96.    -94.    -93.    -93.    -95.


==> SH1_99383.txt &lt;== (two rows of 12 numbers, like the above)

-2700.  -2677.  -2667.  -2649.  -2619.  -2593.  -2571.  -2552. -2536.  -2523.  -2527.  -2620.
-2788.  -2766.  -2755.  -2738.  -2709.  -2681.  -2659.  -2641.  -2624.  -2610.  -2614.  -2707.


To call

python3.5 maxtxt.py FAX_99383.txt SH1_99383.txt


Output:
MAXES.TXT-

Element    FAX     SH1
   99383   108.0  2923.0


Code works with multiple elements

import numpy as np
import sys

# Retrieve command line txt file entries to process
lis = sys.argv[1:]

# Loop over each txt file and determine the abs max and store in a dictionary
MaxLoads = {}
for file in lis:
    f = open(file, "r")
    X = np.loadtxt(f)
    dof = (file.partition('_'))[0]
    elemid = (file.partition('_'))[2].partition('.')[0]
    if elemid not in MaxLoads:
        MaxLoads.update({
            elemid: {}
        })
    MaxLoads[elemid].update({
        dof: max(X.max(), abs(X.min()))
    })
    f.close()

# Loop over each element and print each max in one line
fw = open("MAXES.TXT", "w")
e = list(MaxLoads.keys())[0]
doflis = sorted(list(MaxLoads[e].keys()))
oline = 'Element    ' + '     '.join(doflis)
fw.write(oline + '\n')
print(oline)
for e in MaxLoads:
    oline = '{:&gt;8}'.format(e)
    for d in doflis:
        oline += '{:&gt;8}'.format(MaxLoads[e][d].__str__())
    print(oline)
    fw.write(oline + '\n')
fw.close()


I'm looking for general feedback on if I am using the best methods to accomplish this goal in Python 3 (both stylistically and effectively). If there is a better language that offers a better solution, those comments are welcome too.  This code is my first operational Python code, goal is to learn Python.
What I would do in no particular order:


Use argparse for noob compatibility (also known as usability).
Run the file through pep8, then understand and apply everything it suggests (for example lower_case variable names). If you keep doing this you will reduce the mental overhead of anyone familiar with Python when dealing with your code (including your future self).
Pull out a minimalist main().
Create a class with instance methods to get the max number in a file and return a list of values (rather than printing them).
Print/save the return value in main() or a dedicated function. For scriptability the output should be as simple as possible, with no "fluff" like headers, and predictable, such as always integers with no surrounding punctuation.
I don't think you need to use .__str__() when formatting - Python knows it needs to convert to strings.
Use a context manager for opening files: with open(file, mode) as file_pointer.
Use variable names which are immediately understandable (see previous point).
Accumulating text into variables before printing/saving them wastes memory (very little in your case, but even so). Shift the bytes as quickly as possible. This way you'll also remove the need for intermediate variables, and can see the result of long-running processes as soon as any part of them is done.
I'm not very familiar with numpy, but it looks like you're reading the whole file before starting to process it. Treating files as streams instead will improve the speed and especially memory use when dealing with large files.