[LNT] Python 3 support: Update `<>` and `None` comparisons

[hubert.reinterpretcast]

Summary

Replaces comparisons using !=, <>, and == against None with the corresponding version of is not None and is None.

Replaces <> with !=.

As requested by reviewers, add spaces around operators on lines touched.

[thopre]

I haven't put a comment for all occurences of the issues I pointed. Please make a scan through the patch for the whitespaces and isinstance suggestions.

lnt/external/stats/pstat.py

133 ↗

(On Diff #220041)

I think a more pythonic change would be:

if !isinstance(source, (list, tuple))

Similarly below.

222 ↗

(On Diff #220041)

This should be a straight isinstance. While the more complex case with several types are not caught by futurize, that one is changed as expected by futurize. I would recommend you to give it a try.

293 ↗

(On Diff #220041)

I'm quite new to Python but I believe for comparison against None it is more usual to do "is None" or "is not None".

lnt/external/stats/stats.py

515 ↗

(On Diff #220041)

Please add whitespace around operator while you are at it.

lnt/server/reporting/runs.py

126 ↗

(On Diff #220041)

I am not sure it is safe in this specific case to do this. With the old syntax if you passed a tuple with 3 parameters the function would behave as you would expect it (by doing tuple unpacking first) while with the new code I think it'll give an error.

Futurize gave me instead (except for the variable naming):

lambda bucket_entry: -abs(bucket_entry[1].pct_delta)

If you've checked that the function is always called as expected then the change you propose is fine (and better).

lnt/server/ui/views.py

833 ↗

(On Diff #220041)

As above.

[thopre]

BTW given the size of this patch it might be worth splitting into smaller bits (eg. the type changes, the lambda one and the <> one).

[hubert.reinterpretcast]

In D67535#1669129, @thopre wrote:

BTW given the size of this patch it might be worth splitting into smaller bits (eg. the type changes, the lambda one and the <> one).

I'll split out the lambda and raise changes first.
Then it looks like:

• Updating the type-related comparisons.
• Changing the remaining <> cases.
• Changing the remaining type references (if any).

lnt/external/stats/pstat.py

133 ↗

(On Diff #220041)

I'll look into updating to use isinstance.

293 ↗

(On Diff #220041)

Okay. Will do.

lnt/server/reporting/runs.py

126 ↗

(On Diff #220041)

The problem you describe is likely. Will fix.

lnt/server/ui/views.py

833 ↗

(On Diff #220041)

Will fix.

[cmatthews]

lnt/external/stats/pstat.py

293 ↗

(On Diff #220041)

space between each list elements.

[hubert.reinterpretcast]

Split out changes for lambdas (D67582), raise (D67581), type-related comparisons (D67587), and the remaining type references (also D67587). Will update this patch to cover the remaining <> cases.

lnt/external/stats/pstat.py

133 ↗

(On Diff #220041)

Changed in D67587.

222 ↗

(On Diff #220041)

Changed in D67587.

293 ↗

(On Diff #220041)

Changed in D67587.

lnt/server/reporting/runs.py

126 ↗

(On Diff #220041)

Fixed in D67582.

lnt/server/ui/views.py

833 ↗

(On Diff #220041)

Fixed in D67582.

[hubert.reinterpretcast]

Reduce patch to updating <> and None comparisons

• Replaces comparisons using !=, <>, and == against None with the corresponding version of is not None and is None.
• Replaces <> with !=.
• As requested by reviewers, add spaces around operators on lines touched.

[hubert.reinterpretcast]

• Rebase on updated version of D67587

[thopre]

LGTM. Thanks for doing this.

lnt/trunk/lnt/external/stats/pstat.py

def collmean (inlist):
          for item in inlist:
              s = s + item
          return s/float(len(inlist))
 
      if not isinstance(keepcols, (list, tuple)):
          keepcols = [keepcols]
      if not isinstance(collapsecols, (list, tuple)):
          collapsecols = [collapsecols]
-     if cfcn == None:
+     if cfcn is None:
          cfcn = collmean
      if keepcols == []:
          means = [0]*len(collapsecols)
          for i in range(len(collapsecols)):
              avgcol = colex(listoflists,collapsecols[i])
              means[i] = cfcn(avgcol)
              if fcn1:
                  try:
else:
          newlist = []
          if not isinstance(keepcols, (list, tuple)):  keepcols = [keepcols]
          for item in uniques:
              if not isinstance(item, (list, tuple)):  item =[item]
              tmprows = linexand(listoflists,keepcols,item)
              for col in collapsecols:
                  avgcol = colex(tmprows,col)
                  item.append(cfcn(avgcol))
-                 if fcn1 <> None:
+                 if fcn1 is not None:
                      try:
                          test = fcn1(avgcol)
                      except:
                          test = 'N/A'
                      item.append(test)
-                 if fcn2 <> None:
+                 if fcn2 is not None:
                      try:
                          test = fcn2(avgcol)
                      except:
                          test = 'N/A'
                      item.append(test)
                  newlist.append(item)
          return newlist
 

 Changes the values in a list to a new set of values (useful when
 you need to recode data from (e.g.) strings to numbers.  cols defaults
 to None (meaning all columns are recoded).
 
 Usage:   recode (inlist,listmap,cols=None)  cols=recode cols, listmap=2D list
 Returns: inlist with the appropriate values replaced with new ones
 """
     lst = copy.deepcopy(inlist)
-    if cols != None:
+    if cols is not None:
         if not isinstance(cols, (list, tuple)):
             cols = [cols]
         for col in cols:
             for row in range(len(lst)):
                 try:
                     idx = colex(listmap,0).index(lst[row][col])
                     lst[row][col] = listmap[idx][1]
                 except ValueError:
"""
     def acollmean (inarray):
         return N.sum(N.ravel(inarray))
 
     if not isinstance(keepcols, (list, tuple, N.ndarray)):
         keepcols = [keepcols]
     if not isinstance(collapsecols, (list, tuple, N.ndarray)):
         collapsecols = [collapsecols]
 
-    if cfcn == None:
+    if cfcn is None:
         cfcn = acollmean
     if keepcols == []:
         avgcol = acolex(a,collapsecols)
         means = N.sum(avgcol)/float(len(avgcol))
-        if fcn1<>None:
+        if fcn1 is not None:
             try:
                 test = fcn1(avgcol)
             except:
                 test = N.array(['N/A']*len(means))
             means = aabut(means,test)
-        if fcn2<>None:
+        if fcn2 is not None:
             try:
                 test = fcn2(avgcol)
             except:
                 test = N.array(['N/A']*len(means))
             means = aabut(means,test)
         return means
     else:
         if not isinstance(keepcols, (list, tuple, N.ndarray)):
             keepcols = [keepcols]
         values = colex(a,keepcols)   # so that "item" can be appended (below)
         uniques = unique(values)  # get a LIST, so .sort keeps rows intact
         uniques.sort()
         newlist = []
         for item in uniques:
             if not isinstance(item, (list, tuple, N.ndarray)):
                 item =[item]
             tmprows = alinexand(a,keepcols,item)
             for col in collapsecols:
                 avgcol = acolex(tmprows,col)
                 item.append(acollmean(avgcol))
-                if fcn1<>None:
+                if fcn1 is not None:
                     try:
                         test = fcn1(avgcol)
                     except:
                         test = 'N/A'
                     item.append(test)
-                if fcn2<>None:
+                if fcn2 is not None:
                     try:
                         test = fcn2(avgcol)
                     except:
                         test = 'N/A'
                     item.append(test)
                 newlist.append(item)
         try:
             new_a = N.array(newlist)

lnt/trunk/lnt/external/stats/stats.py

 of the histogram binning, and (iii) the bin width (the last 2 are not
 necessarily integers).  Default number of bins is 10.  If no sequence object
 is given for defaultreallimits, the routine picks (usually non-pretty) bins
 spanning all the numbers in the inlist.
 
 Usage:   lhistogram (inlist, numbins=10, defaultreallimits=None,suppressoutput=0)
 Returns: list of bin values, lowerreallimit, binsize, extrapoints
 """
-    if (defaultreallimits <> None):
+    if (defaultreallimits is not None):
         if not isinstance(defaultreallimits, (list, tuple)) or len(defaultreallimits) == 1: # only one limit given, assumed to be lower one & upper is calc'd
             lowerreallimit = defaultreallimits
             upperreallimit = 1.000001 * max(inlist)
         else: # assume both limits given
             lowerreallimit = defaultreallimits[0]
             upperreallimit = defaultreallimits[1]
         binsize = (upperreallimit-lowerreallimit)/float(numbins)
     else:     # no limits given for histogram, both must be calc'd
for j in range(k):
             t1 = (n[j]-1.5)*n[j]*(nargs[j][i]-m[j])**2
             t2 = 0.5*v[j]*(n[j]-1.0)
             t3 = (n[j]-1.0)*(n[j]-2.0)
             nargs[j][i] = (t1-t2) / float(t3)
     check = 1
     for j in range(k):
         if v[j] - mean(nargs[j]) > TINY:
             check = 0
-    if check <> 1:
+    if check != 1:
         raise ValueError, 'Problem in obrientransform.'
     else:
         return nargs
 
 
 def lsamplevar (inlist):
     """
 Returns the variance of the values in the passed list using

 Calculates a Pearson correlation coefficient and the associated
 probability value.  Taken from Heiman's Basic Statistics for the Behav.
 Sci (2nd), p.195.
 
 Usage:   lpearsonr(x,y)      where x and y are equal-length lists
 Returns: Pearson's r value, two-tailed p-value
 """
     TINY = 1.0e-30
-    if len(x) <> len(y):
+    if len(x) != len(y):
         raise ValueError, 'Input values not paired in pearsonr.  Aborting.'
     n = len(x)
     x = map(float,x)
     y = map(float,y)
     xmean = mean(x)
     ymean = mean(y)
     r_num = n*(summult(x,y)) - sum(x)*sum(y)
     r_den = math.sqrt((n*ss(x) - square_of_sums(x))*(n*ss(y)-square_of_sums(y)))
def lspearmanr(x,y):
     """
 Calculates a Spearman rank-order correlation coefficient.  Taken
 from Heiman's Basic Statistics for the Behav. Sci (1st), p.192.
 
 Usage:   lspearmanr(x,y)      where x and y are equal-length lists
 Returns: Spearman's r, two-tailed p-value
 """
     TINY = 1e-30
-    if len(x) <> len(y):
+    if len(x) != len(y):
         raise ValueError, 'Input values not paired in spearmanr.  Aborting.'
     n = len(x)
     rankx = rankdata(x)
     ranky = rankdata(y)
     dsq = sumdiffsquared(rankx,ranky)
     rs = 1 - 6*dsq / float(n*(n**2-1))
     t = rs * math.sqrt((n-2) / ((rs+1.0)*(1.0-rs)))
     df = n-2
     probrs = betai(0.5*df,0.5,df/(df+t*t))  # t already a float
 # probability values for rs are from part 2 of the spearman function in
 # Numerical Recipies, p.510.  They are close to tables, but not exact. (?)
     return rs, probrs
 
 
 def lpointbiserialr(x,y):
     """
 Calculates a point-biserial correlation coefficient and the associated
 probability value.  Taken from Heiman's Basic Statistics for the Behav.
 Sci (1st), p.194.
 
 Usage:   lpointbiserialr(x,y)      where x,y are equal-length lists
 Returns: Point-biserial r, two-tailed p-value
 """
     TINY = 1e-30
-    if len(x) <> len(y):
+    if len(x) != len(y):
         raise ValueError, 'INPUT VALUES NOT PAIRED IN pointbiserialr.  ABORTING.'
     data = pstat.abut(x,y)
     categories = pstat.unique(x)
-    if len(categories) <> 2:
+    if len(categories) != 2:
         raise ValueError, "Exactly 2 categories required for pointbiserialr()."
     else:   # there are 2 categories, continue
         codemap = pstat.abut(categories,range(2))
         recoded = pstat.recode(data,codemap,0)
         x = pstat.linexand(data,0,categories[0])
         y = pstat.linexand(data,0,categories[1])
         xmean = mean(pstat.colex(x,1))
         ymean = mean(pstat.colex(y,1))

 def llinregress(x,y):
     """
 Calculates a regression line on x,y pairs.  
 
 Usage:   llinregress(x,y)      x,y are equal-length lists of x-y coordinates
 Returns: slope, intercept, r, two-tailed prob, sterr-of-estimate
 """
     TINY = 1.0e-20
-    if len(x) <> len(y):
+    if len(x) != len(y):
         raise ValueError, 'Input values not paired in linregress.  Aborting.'
     n = len(x)
     x = map(float,x)
     y = map(float,y)
     xmean = mean(x)
     ymean = mean(y)
     r_num = float(n*(summult(x,y)) - sum(x)*sum(y))
     r_den = math.sqrt((n*ss(x) - square_of_sums(x))*(n*ss(y)-square_of_sums(y)))
"""
     x = mean(a)
     v = var(a)
     n = len(a)
     df = n-1
     svar = ((n-1)*v)/float(df)
     t = (x-popmean)/math.sqrt(svar*(1.0/n))
     prob = betai(0.5*df,0.5,float(df)/(df+t*t))
 
-    if printit <> 0:
+    if printit != 0:
         statname = 'Single-sample T-test.'
         outputpairedstats(printit,writemode,
                           'Population','--',popmean,0,0,0,
                           name,n,x,v,min(a),max(a),
                           statname,t,prob)
     return t,prob
 
 
"""
     v2 = stdev(b)**2
     n1 = len(a)
     n2 = len(b)
     df = n1+n2-2
     svar = ((n1-1)*v1+(n2-1)*v2)/float(df)
     t = (x1-x2)/math.sqrt(svar*(1.0/n1 + 1.0/n2))
     prob = betai(0.5*df,0.5,df/(df+t*t))
 
-    if printit <> 0:
+    if printit != 0:
         statname = 'Independent samples T-test.'
         outputpairedstats(printit,writemode,
                           name1,n1,x1,v1,min(a),max(a),
                           name2,n2,x2,v2,min(b),max(b),
                           statname,t,prob)
     return t,prob
 
 
 def lttest_rel (a,b,printit=0,name1='Sample1',name2='Sample2',writemode='a'):
     """
 Calculates the t-obtained T-test on TWO RELATED samples of scores,
 a and b.  From Numerical Recipies, p.483.  If printit=1, results are
 printed to the screen.  If printit='filename', the results are output to
 'filename' using the given writemode (default=append).  Returns t-value,
 and prob.
 
 Usage:   lttest_rel(a,b,printit=0,name1='Sample1',name2='Sample2',writemode='a')
 Returns: t-value, two-tailed prob
 """
-    if len(a)<>len(b):
+    if len(a) != len(b):
         raise ValueError, 'Unequal length lists in ttest_rel.'
     x1 = mean(a)
     x2 = mean(b)
     v1 = var(a)
     v2 = var(b)
     n = len(a)
     cov = 0
     for i in range(len(a)):
         cov = cov + (a[i]-x1) * (b[i]-x2)
     df = n-1
     cov = cov / float(df)
     sd = math.sqrt((v1+v2 - 2.0*cov)/float(n))
     t = (x1-x2)/sd
     prob = betai(0.5*df,0.5,df/(df+t*t))
 
-    if printit <> 0:
+    if printit != 0:
         statname = 'Related samples T-test.'
         outputpairedstats(printit,writemode,
                           name1,n,x1,v1,min(a),max(a),
                           name2,n,x2,v2,min(b),max(b),
                           statname,t,prob)
     return t, prob
 
 
 def lchisquare(f_obs,f_exp=None):
     """
 Calculates a one-way chi square for list of observed frequencies and returns
 the result.  If no expected frequencies are given, the total N is assumed to
 be equally distributed across all groups.
 
 Usage:   lchisquare(f_obs, f_exp=None)   f_obs = list of observed cell freq.
 Returns: chisquare-statistic, associated p-value
 """
     k = len(f_obs)                 # number of groups
-    if f_exp == None:
+    if f_exp is None:
         f_exp = [sum(f_obs)/float(k)] * len(f_obs) # create k bins with = freq.
     chisq = 0
     for i in range(len(f_obs)):
         chisq = chisq + (f_obs[i]-f_exp[i])**2 / float(f_exp[i])
     return chisq, chisqprob(chisq, k-1)
 
 
 def lks_2samp (data1,data2):

 def lwilcoxont(x,y):
     """
 Calculates the Wilcoxon T-test for related samples and returns the
 result.  A non-parametric T-test.
 
 Usage:   lwilcoxont(x,y)
 Returns: a t-statistic, two-tail probability estimate
 """
-    if len(x) <> len(y):
+    if len(x) != len(y):
         raise ValueError, 'Unequal N in wilcoxont.  Aborting.'
     d=[]
     for i in range(len(x)):
         diff = x[i] - y[i]
-        if diff <> 0:
+        if diff != 0:
             d.append(diff)
     count = len(d)
     absd = map(abs,d)
     absranked = rankdata(absd)
     r_plus = 0.0
     r_minus = 0.0
     for i in range(len(absd)):
         if d[i] < 0:

 def lsummult (list1,list2):
     """
 Multiplies elements in list1 and list2, element by element, and
 returns the sum of all resulting multiplications.  Must provide equal
 length lists.
 
 Usage:   lsummult(list1,list2)
 """
-    if len(list1) <> len(list2):
+    if len(list1) != len(list2):
         raise ValueError, "Lists not equal length in summult."
     s = 0
     for item1,item2 in pstat.abut(list1,list2):
         s = s + item1*item2
     return s
 
 
 def lsumdiffsquared(x,y):
"""
     n = len(inlist)
     svec, ivec = shellsort(inlist)
     sumranks = 0
     dupcount = 0
     newlist = [0]*n
     for i in range(n):
         sumranks = sumranks + i
         dupcount = dupcount + 1
-        if i==n-1 or svec[i] <> svec[i+1]:
+        if i == n - 1 or svec[i] != svec[i + 1]:
             averank = sumranks / float(dupcount) + 1
             for j in range(i-dupcount+1,i+1):
                 newlist[ivec[j]] = averank
             sumranks = 0
             dupcount = 0
     return newlist
 
 

 if dimension is a sequence, it collapses over all specified dimensions.  If
 keepdims is set to 1, the resulting array will have as many dimensions as
 inarray, with only 1 'level' per dim that was collapsed over.
 
 Usage:   ageometricmean(inarray,dimension=None,keepdims=0)
 Returns: geometric mean computed over dim(s) listed in dimension
 """
     inarray = N.array(inarray,N.float_)
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(inarray)
         size = len(inarray)
         mult = N.power(inarray,1.0/size)
         mult = N.multiply.reduce(mult)
     elif isinstance(dimension, (int, float)):
         size = inarray.shape[dimension]
         mult = N.power(inarray,1.0/size)
         mult = N.multiply.reduce(mult,dimension)

 if dimension is a sequence, it collapses over all specified dimensions.  If
 keepdims is set to 1, the resulting array will have as many dimensions as
 inarray, with only 1 'level' per dim that was collapsed over.
 
 Usage:   aharmonicmean(inarray,dimension=None,keepdims=0)
 Returns: harmonic mean computed over dim(s) in dimension
 """
     inarray = inarray.astype(N.float_)
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(inarray)
         size = len(inarray)
         s = N.add.reduce(1.0 / inarray)
     elif isinstance(dimension, (int, float)):
         size = float(inarray.shape[dimension])
         s = N.add.reduce(1.0/inarray, dimension)
         if keepdims == 1:
             shp = list(inarray.shape)
else: # must be a SEQUENCE of dims to average over
             size = len(N.ravel(inarray))
             s = asum(1.0 / inarray)
             if keepdims == 1:
                 s = N.reshape([s],N.ones(len(inarray.shape)))
         else:
             idx[0] = -1
             loopcap = N.array(tinarray.shape[0:len(nondims)]) -1
             s = N.zeros(loopcap+1,N.float_)
-            while incr(idx,loopcap) <> -1:
+            while incr(idx, loopcap) != -1:
                 s[idx] = asum(1.0/tinarray[idx])
             size = N.multiply.reduce(N.take(inarray.shape,dims))
             if keepdims == 1:
                 shp = list(inarray.shape)
                 for dim in dims:
                     shp[dim] = 1
                 s = N.reshape(s,shp)
     return size / s

 keepdims is set to 1, the resulting array will have as many dimensions as
 inarray, with only 1 'level' per dim that was collapsed over.
 
 Usage:   amean(inarray,dimension=None,keepdims=0)
 Returns: arithematic mean calculated over dim(s) in dimension
 """
     if inarray.dtype in [N.int_, N.short,N.ubyte]:
         inarray = inarray.astype(N.float_)
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(inarray)
         sum = N.add.reduce(inarray)
         denom = float(len(inarray))
     elif isinstance(dimension, (int, float)):
         sum = asum(inarray,dimension)
         denom = float(inarray.shape[dimension])
         if keepdims == 1:
             shp = list(inarray.shape)

 Returns the 'middle' score of the passed array.  If there is an even
 number of scores, the mean of the 2 middle scores is returned.  Can function
 with 1D arrays, or on the FIRST dimension of 2D arrays (i.e., dimension can
 be None, to pre-flatten the array, or else dimension must equal 0).
 
 Usage:   amedianscore(inarray,dimension=None)
 Returns: 'middle' score of the array, or the mean of the 2 middle scores
 """
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(inarray)
         dimension = 0
     inarray = N.sort(inarray,dimension)
     if inarray.shape[dimension] % 2 == 0:   # if even number of elements
         indx = inarray.shape[dimension]/2   # integer division correct
         median = N.asarray(inarray[indx]+inarray[indx-1]) / 2.0
     else:
         indx = inarray.shape[dimension] / 2 # integer division correct

 If there is more than one such score, ONLY THE FIRST is returned.
 The bin-count for the modal values is also returned.  Operates on whole
 array (dimension=None), or on a given dimension.
 
 Usage:   amode(a, dimension=None)
 Returns: array of bin-counts for mode(s), array of corresponding modal values
 """
 
-    if dimension == None:
+    if dimension is None:
         a = N.ravel(a)
         dimension = 0
     scores = pstat.aunique(N.ravel(a))       # get ALL unique values
     testshape = list(a.shape)
     testshape[dimension] = 1
     oldmostfreq = N.zeros(testshape)
     oldcounts = N.zeros(testshape)
     for score in scores:

 in the sequence, or the value of limits itself, can be set to None.  The
 inclusive list/tuple determines whether the lower and upper limiting bounds
 (respectively) are open/exclusive (0) or closed/inclusive (1).
 
 Usage:   atmean(a,limits=None,inclusive=(1,1))
 """
      if a.dtype in [N.int_, N.short,N.ubyte]:
          a = a.astype(N.float_)
-     if limits == None:
+     if limits is None:
          return mean(a)
      assert isinstance(limits, (list, tuple, N.ndarray)), "Wrong type for limits in atmean"
      if inclusive[0]:         lowerfcn = N.greater_equal
      else:               lowerfcn = N.greater
      if inclusive[1]:         upperfcn = N.less_equal
      else:               upperfcn = N.less
      if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
          raise ValueError, "No array values within given limits (atmean)."
-     elif limits[0]==None and limits[1]<>None:
+     elif limits[0] is None and limits[1] is not None:
          mask = upperfcn(a,limits[1])
-     elif limits[0]<>None and limits[1]==None:
+     elif limits[0] is not None and limits[1] is None:
          mask = lowerfcn(a,limits[0])
-     elif limits[0]<>None and limits[1]<>None:
+     elif limits[0] is not None and limits[1] is not None:
          mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])
      s = float(N.add.reduce(N.ravel(a*mask)))
      n = float(N.add.reduce(N.ravel(mask)))
      return s/n
 
 
  def atvar(a,limits=None,inclusive=(1,1)):
      """
 Returns the sample variance of values in an array, (i.e., using N-1),
 ignoring values strictly outside the sequence passed to 'limits'.  
 Note: either limit in the sequence, or the value of limits itself,
 can be set to None.  The inclusive list/tuple determines whether the lower
 and upper limiting bounds (respectively) are open/exclusive (0) or
 closed/inclusive (1). ASSUMES A FLAT ARRAY (OR ELSE PREFLATTENS).
 
 Usage:   atvar(a,limits=None,inclusive=(1,1))
 """
      a = a.astype(N.float_)
-     if limits == None or limits == [None,None]:
+     if limits is None or limits == [None, None]:
          return avar(a)
      assert isinstance(limits, (list, tuple, N.ndarray)), "Wrong type for limits in atvar"
      if inclusive[0]:    lowerfcn = N.greater_equal
      else:               lowerfcn = N.greater
      if inclusive[1]:    upperfcn = N.less_equal
      else:               upperfcn = N.less
      if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
          raise ValueError, "No array values within given limits (atvar)."
-     elif limits[0]==None and limits[1]<>None:
+     elif limits[0] is None and limits[1] is not None:
          mask = upperfcn(a,limits[1])
-     elif limits[0]<>None and limits[1]==None:
+     elif limits[0] is not None and limits[1] is None:
          mask = lowerfcn(a,limits[0])
-     elif limits[0]<>None and limits[1]<>None:
+     elif limits[0] is not None and limits[1] is not None:
          mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])
 
      a = N.compress(mask,a)  # squish out excluded values
      return avar(a)
 
 
  def atmin(a,lowerlimit=None,dimension=None,inclusive=1):
      """
 Returns the minimum value of a, along dimension, including only values less
 than (or equal to, if inclusive=1) lowerlimit.  If the limit is set to None,
 all values in the array are used.
 
 Usage:   atmin(a,lowerlimit=None,dimension=None,inclusive=1)
 """
      if inclusive:         lowerfcn = N.greater
      else:               lowerfcn = N.greater_equal
-     if dimension == None:
+     if dimension is None:
          a = N.ravel(a)
          dimension = 0
-     if lowerlimit == None:
+     if lowerlimit is None:
          lowerlimit = N.minimum.reduce(N.ravel(a))-11
      biggest = N.maximum.reduce(N.ravel(a))
      ta = N.where(lowerfcn(a,lowerlimit),a,biggest)
      return N.minimum.reduce(ta,dimension)
 
 
  def atmax(a,upperlimit,dimension=None,inclusive=1):
      """
 Returns the maximum value of a, along dimension, including only values greater
 than (or equal to, if inclusive=1) upperlimit.  If the limit is set to None,
 a limit larger than the max value in the array is used.
 
 Usage:   atmax(a,upperlimit,dimension=None,inclusive=1)
 """
      if inclusive:         upperfcn = N.less
      else:               upperfcn = N.less_equal
-     if dimension == None:
+     if dimension is None:
          a = N.ravel(a)
          dimension = 0
-     if upperlimit == None:
+     if upperlimit is None:
          upperlimit = N.maximum.reduce(N.ravel(a))+1
      smallest = N.minimum.reduce(N.ravel(a))
      ta = N.where(upperfcn(a,upperlimit),a,smallest)
      return N.maximum.reduce(ta,dimension)
 
 
  def atstdev(a,limits=None,inclusive=(1,1)):
      """

 the sequence passed to 'limits'.   Note: either limit in the sequence,
 or the value of limits itself, can be set to None.  The inclusive list/tuple
 determines whether the lower and upper limiting bounds (respectively) are
 open/exclusive (0) or closed/inclusive (1).
 
 Usage:   atsem(a,limits=None,inclusive=(1,1))
 """
      sd = tstdev(a,limits,inclusive)
-     if limits == None or limits == [None,None]:
+     if limits is None or limits == [None, None]:
          n = float(len(N.ravel(a)))
          limits = [min(a)-1, max(a)+1]
      assert isinstance(limits, (list, tuple, N.ndarray)), "Wrong type for limits in atsem"
      if inclusive[0]:         lowerfcn = N.greater_equal
      else:               lowerfcn = N.greater
      if inclusive[1]:         upperfcn = N.less_equal
      else:               upperfcn = N.less
      if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
          raise ValueError, "No array values within given limits (atsem)."
-     elif limits[0]==None and limits[1]<>None:
+     elif limits[0] is None and limits[1] is not None:
          mask = upperfcn(a,limits[1])
-     elif limits[0]<>None and limits[1]==None:
+     elif limits[0] is not None and limits[1] is None:
          mask = lowerfcn(a,limits[0])
-     elif limits[0]<>None and limits[1]<>None:
+     elif limits[0] is not None and limits[1] is not None:
          mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])
      term1 = N.add.reduce(N.ravel(a*a*mask))
      n = float(N.add.reduce(N.ravel(mask)))
      return sd/math.sqrt(n)
 
 
 #####################################
 ############  AMOMENTS  #############
 #####################################
 
  def amoment(a,moment=1,dimension=None):
     """
 Calculates the nth moment about the mean for a sample (defaults to the
 1st moment).  Generally used to calculate coefficients of skewness and
 kurtosis.  Dimension can equal None (ravel array first), an integer
 (the dimension over which to operate), or a sequence (operate over
 multiple dimensions).
 
 Usage:   amoment(a,moment=1,dimension=None)
 Returns: appropriate moment along given dimension
 """
-    if dimension == None:
+    if dimension is None:
         a = N.ravel(a)
         dimension = 0
     if moment == 1:
         return 0.0
     else:
         mn = amean(a,dimension,1)  # 1=keepdims
         s = N.power((a-mn),moment)
         return amean(s,dimension)

 dimension over which to operate), or a sequence (operate over multiple
 dimensions).
 
 Usage:   askew(a, dimension=None)
 Returns: skew of vals in a along dimension, returning ZERO where all vals equal
 """
     denom = N.power(amoment(a,2,dimension),1.5)
     zero = N.equal(denom,0)
-    if isinstance(denom, N.ndarray) and asum(zero) <> 0:
+    if isinstance(denom, N.ndarray) and asum(zero) != 0:
         print("Number of zeros in askew: ", asum(zero))
     denom = denom + zero  # prevent divide-by-zero
     return N.where(zero, 0, amoment(a,3,dimension)/denom)
 
 
  def akurtosis(a,dimension=None):
     """
 Returns the kurtosis of a distribution (normal ==> 3.0; >3 means
 heavier in the tails, and usually more peaked).  Use akurtosistest()
 to see if it's close enough.  Dimension can equal None (ravel array
 first), an integer (the dimension over which to operate), or a
 sequence (operate over multiple dimensions).
 
 Usage:   akurtosis(a,dimension=None)
 Returns: kurtosis of values in a along dimension, and ZERO where all vals equal
 """
     denom = N.power(amoment(a,2,dimension),2)
     zero = N.equal(denom,0)
-    if isinstance(denom, N.ndarray) and asum(zero) <> 0:
+    if isinstance(denom, N.ndarray) and asum(zero) != 0:
         print("Number of zeros in akurtosis: ", asum(zero))
     denom = denom + zero  # prevent divide-by-zero
     return N.where(zero,0,amoment(a,4,dimension)/denom)
 
 
  def adescribe(inarray,dimension=None):
      """
 Returns several descriptive statistics of the passed array.  Dimension
 can equal None (ravel array first), an integer (the dimension over
 which to operate), or a sequence (operate over multiple dimensions).
 
 Usage:   adescribe(inarray,dimension=None)
 Returns: n, (min,max), mean, standard deviation, skew, kurtosis
 """
-     if dimension == None:
+     if dimension is None:
          inarray = N.ravel(inarray)
          dimension = 0
      n = inarray.shape[dimension]
      mm = (N.minimum.reduce(inarray),N.maximum.reduce(inarray))
      m = amean(inarray,dimension)
      sd = astdev(inarray,dimension)
      skew = askew(inarray,dimension)
      kurt = akurtosis(inarray,dimension)

 Tests whether the skew is significantly different from a normal
 distribution.  Dimension can equal None (ravel array first), an
 integer (the dimension over which to operate), or a sequence (operate
 over multiple dimensions).
 
 Usage:   askewtest(a,dimension=None)
 Returns: z-score and 2-tail z-probability
 """
-    if dimension == None:
+    if dimension is None:
         a = N.ravel(a)
         dimension = 0
     b2 = askew(a,dimension)
     n = float(a.shape[dimension])
     y = b2 * N.sqrt(((n+1)*(n+3)) / (6.0*(n-2)) )
     beta2 = ( 3.0*(n*n+27*n-70)*(n+1)*(n+3) ) / ( (n-2.0)*(n+5)*(n+7)*(n+9) )
     W2 = -1 + N.sqrt(2*(beta2-1))
     delta = 1/N.sqrt(N.log(N.sqrt(W2)))
     alpha = N.sqrt(2/(W2-1))
     y = N.where(y==0,1,y)
     Z = delta*N.log(y/alpha + N.sqrt((y/alpha)**2+1))
     return Z, (1.0-zprob(Z))*2
 
 
  def akurtosistest(a,dimension=None):
     """
 Tests whether a dataset has normal kurtosis (i.e.,
 kurtosis=3(n-1)/(n+1)) Valid only for n>20.  Dimension can equal None
 (ravel array first), an integer (the dimension over which to operate),
 or a sequence (operate over multiple dimensions).
 
 Usage:   akurtosistest(a,dimension=None)
 Returns: z-score and 2-tail z-probability, returns 0 for bad pixels
 """
-    if dimension == None:
+    if dimension is None:
         a = N.ravel(a)
         dimension = 0
     n = float(a.shape[dimension])
     if n<20:
         print("akurtosistest only valid for n>=20 ... continuing anyway, n=", n)
     b2 = akurtosis(a,dimension)
     E = 3.0*(n-1) /(n+1)
     varb2 = 24.0*n*(n-2)*(n-3) / ((n+1)*(n+1)*(n+3)*(n+5))

 Tests whether skew and/OR kurtosis of dataset differs from normal
 curve.  Can operate over multiple dimensions.  Dimension can equal
 None (ravel array first), an integer (the dimension over which to
 operate), or a sequence (operate over multiple dimensions).
 
 Usage:   anormaltest(a,dimension=None)
 Returns: z-score and 2-tail probability
 """
-    if dimension == None:
+    if dimension is None:
         a = N.ravel(a)
         dimension = 0
     s,p = askewtest(a,dimension)
     k,p = akurtosistest(a,dimension)
     k2 = N.power(s,2) + N.power(k,2)
     return k2, achisqprob(k2,2)
 
 

 can be None (the routine picks bins spanning all the numbers in the
 inarray) or a 2-sequence (lowerlimit, upperlimit).  Returns all of the
 following: array of bin values, lowerreallimit, binsize, extrapoints.
 
 Usage:   ahistogram(inarray,numbins=10,defaultlimits=None,printextras=1)
 Returns: (array of bin counts, bin-minimum, min-width, #-points-outside-range)
 """
     inarray = N.ravel(inarray)               # flatten any >1D arrays
-    if (defaultlimits <> None):
+    if (defaultlimits is not None):
         lowerreallimit = defaultlimits[0]
         upperreallimit = defaultlimits[1]
         binsize = (upperreallimit-lowerreallimit) / float(numbins)
     else:
         Min = N.minimum.reduce(inarray)
         Max = N.maximum.reduce(inarray)
         estbinwidth = float(Max - Min)/float(numbins) + 1e-6
         binsize = (Max-Min+estbinwidth)/float(numbins)
for j in range(k):
             t1 = (n[j]-1.5)*n[j]*(nargs[j][i]-m[j])**2
             t2 = 0.5*v[j]*(n[j]-1.0)
             t3 = (n[j]-1.0)*(n[j]-2.0)
             nargs[j][i] = (t1-t2) / float(t3)
     check = 1
     for j in range(k):
         if v[j] - mean(nargs[j]) > TINY:
             check = 0
-    if check <> 1:
+    if check != 1:
         raise ValueError, 'Lack of convergence in obrientransform.'
     else:
         return N.array(nargs)
 
 
  def asamplevar (inarray,dimension=None,keepdims=0):
     """
 Returns the sample standard deviation of the values in the passed
 array (i.e., using N).  Dimension can equal None (ravel array first),
 an integer (the dimension over which to operate), or a sequence
 (operate over multiple dimensions).  Set keepdims=1 to return an array
 with the same number of dimensions as inarray.
 
 Usage:   asamplevar(inarray,dimension=None,keepdims=0)
 """
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(inarray)
         dimension = 0
     if dimension == 1:
         mn = amean(inarray,dimension)[:,N.NewAxis]
     else:
         mn = amean(inarray,dimension,keepdims=1)
     deviations = inarray - mn 
     if isinstance(dimension, list):

 Returns the estimated covariance of the values in the passed
 array (i.e., N-1).  Dimension can equal None (ravel array first), an
 integer (the dimension over which to operate), or a sequence (operate
 over multiple dimensions).  Set keepdims=1 to return an array with the
 same number of dimensions as inarray.
 
 Usage:   acov(x,y,dimension=None,keepdims=0)
 """
-    if dimension == None:
+    if dimension is None:
         x = N.ravel(x)
         y = N.ravel(y)
         dimension = 0
     xmn = amean(x,dimension,1)  # keepdims
     xdeviations = x - xmn
     ymn = amean(y,dimension,1)  # keepdims
     ydeviations = y - ymn
     if isinstance(dimension, list):

 Returns the estimated population variance of the values in the passed
 array (i.e., N-1).  Dimension can equal None (ravel array first), an
 integer (the dimension over which to operate), or a sequence (operate
 over multiple dimensions).  Set keepdims=1 to return an array with the
 same number of dimensions as inarray.
 
 Usage:   avar(inarray,dimension=None,keepdims=0)
 """
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(inarray)
         dimension = 0
     mn = amean(inarray,dimension,1)
     deviations = inarray - mn
     if isinstance(dimension, list):
         n = 1
         for d in dimension:
             n = n*inarray.shape[d]

 Returns the estimated population standard error of the values in the
 passed array (i.e., N-1).  Dimension can equal None (ravel array
 first), an integer (the dimension over which to operate), or a
 sequence (operate over multiple dimensions).  Set keepdims=1 to return
 an array with the same number of dimensions as inarray.
 
 Usage:   asterr(inarray,dimension=None,keepdims=0)
 """
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(inarray)
         dimension = 0
     return astdev(inarray,dimension,keepdims) / float(N.sqrt(inarray.shape[dimension]))
 
 
  def asem (inarray, dimension=None, keepdims=0):
     """
 Returns the standard error of the mean (i.e., using N) of the values
 in the passed array.  Dimension can equal None (ravel array first), an
 integer (the dimension over which to operate), or a sequence (operate
 over multiple dimensions).  Set keepdims=1 to return an array with the
 same number of dimensions as inarray.
 
 Usage:   asem(inarray,dimension=None, keepdims=0)
 """
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(inarray)
         dimension = 0
     if isinstance(dimension, list):
         n = 1
         for d in dimension:
             n = n*inarray.shape[d]
     else:
         n = inarray.shape[dimension]
def athreshold(a,threshmin=None,threshmax=None,newval=0):
     """
 Like Numeric.clip() except that values <threshmid or >threshmax are replaced
 by newval instead of by threshmin/threshmax (respectively).
 
 Usage:   athreshold(a,threshmin=None,threshmax=None,newval=0)
 Returns: a, with values <threshmin or >threshmax replaced with newval
 """
     mask = N.zeros(a.shape)
-    if threshmin <> None:
+    if threshmin is not None:
         mask = mask + N.where(a<threshmin,1,0)
-    if threshmax <> None:
+    if threshmax is not None:
         mask = mask + N.where(a>threshmax,1,0)
     mask = N.clip(mask,0,1)
     return N.where(mask,newval,a)
 
 
  def atrimboth (a,proportiontocut):
     """
 Slices off the passed proportion of items from BOTH ends of the passed

 
  def acovariance(X):
     """
 Computes the covariance matrix of a matrix X.  Requires a 2D matrix input.
 
 Usage:   acovariance(X)
 Returns: covariance matrix of X
 """
-    if len(X.shape) <> 2:
+    if len(X.shape) != 2:
         raise TypeError, "acovariance requires 2D matrices"
     n = X.shape[0]
     mX = amean(X,0)
     return N.dot(N.transpose(X),X) / float(n) - N.multiply.outer(mX,mX)
 
 
  def acorrelation(X):
     """

 Sci (1st), p.194.
 
 Usage:   apointbiserialr(x,y)      where x,y are equal length arrays
 Returns: Point-biserial r, two-tailed p-value
 """
     TINY = 1e-30
     categories = pstat.aunique(x)
     data = pstat.aabut(x,y)
-    if len(categories) <> 2:
+    if len(categories) != 2:
         raise ValueError, "Exactly 2 categories required (in x) for pointbiserialr()."
     else:   # there are 2 categories, continue
         codemap = pstat.aabut(categories,N.arange(2))
         recoded = pstat.arecode(data,codemap,0)
         x = pstat.alinexand(data,0,categories[0])
         y = pstat.alinexand(data,0,categories[1])
         xmean = amean(pstat.acolex(x,1))
         ymean = amean(pstat.acolex(y,1))
"""
     x = amean(a)
     v = avar(a)
     n = len(a)
     df = n-1
     svar = ((n-1)*v) / float(df)
     t = (x-popmean)/math.sqrt(svar*(1.0/n))
     prob = abetai(0.5*df,0.5,df/(df+t*t))
 
-    if printit <> 0:
+    if printit != 0:
         statname = 'Single-sample T-test.'
         outputpairedstats(printit,writemode,
                           'Population','--',popmean,0,0,0,
                           name,n,x,v,N.minimum.reduce(N.ravel(a)),
                           N.maximum.reduce(N.ravel(a)),
                           statname,t,prob)
     return t,prob
 
 
  def attest_ind (a, b, dimension=None, printit=0, name1='Samp1', name2='Samp2',writemode='a'):
     """
 Calculates the t-obtained T-test on TWO INDEPENDENT samples of scores
 a, and b.  From Numerical Recipies, p.483.  If printit=1, results are
 printed to the screen.  If printit='filename', the results are output
 to 'filename' using the given writemode (default=append).  Dimension
 can equal None (ravel array first), or an integer (the dimension over
 which to operate on a and b).
 
 Usage:   attest_ind (a,b,dimension=None,printit=0,
                      Name1='Samp1',Name2='Samp2',writemode='a')
 Returns: t-value, two-tailed p-value
 """
-    if dimension == None:
+    if dimension is None:
         a = N.ravel(a)
         b = N.ravel(b)
         dimension = 0
     x1 = amean(a,dimension)
     x2 = amean(b,dimension)
     v1 = avar(a,dimension)
     v2 = avar(b,dimension)
     n1 = a.shape[dimension]
     n2 = b.shape[dimension]
     df = n1+n2-2
     svar = ((n1-1)*v1+(n2-1)*v2) / float(df)
     zerodivproblem = N.equal(svar,0)
     svar = N.where(zerodivproblem,1,svar)  # avoid zero-division in 1st place
     t = (x1-x2)/N.sqrt(svar*(1.0/n1 + 1.0/n2))  # N-D COMPUTATION HERE!!!!!!
     t = N.where(zerodivproblem,1.0,t)     # replace NaN/wrong t-values with 1.0
     probs = abetai(0.5*df,0.5,float(df)/(df+t*t))
 
     if isinstance(t, N.ndarray):
         probs = N.reshape(probs,t.shape)
     if probs.shape == (1,):
         probs = probs[0]
         
-    if printit <> 0:
+    if printit != 0:
         if isinstance(t, N.ndarray):
             t = t[0]
         if isinstance(probs, N.ndarray):
             probs = probs[0]
         statname = 'Independent samples T-test.'
         outputpairedstats(printit,writemode,
                           name1,n1,x1,v1,N.minimum.reduce(N.ravel(a)),
                           N.maximum.reduce(N.ravel(a)),

 to 'filename' using the given writemode (default=append).  Dimension
 can equal None (ravel array first), or an integer (the dimension over
 which to operate on a and b).
 
 Usage:   attest_rel(a,b,dimension=None,printit=0,
                     name1='Samp1',name2='Samp2',writemode='a')
 Returns: t-value, two-tailed p-value
 """
-    if dimension == None:
+    if dimension is None:
         a = N.ravel(a)
         b = N.ravel(b)
         dimension = 0
-    if len(a)<>len(b):
+    if len(a) != len(b):
         raise ValueError, 'Unequal length arrays.'
     x1 = amean(a,dimension)
     x2 = amean(b,dimension)
     v1 = avar(a,dimension)
     v2 = avar(b,dimension)
     n = a.shape[dimension]
     df = float(n-1)
     d = (a-b).astype('d')
 
     denom = N.sqrt((n*N.add.reduce(d*d,dimension) - N.add.reduce(d,dimension)**2) /df)
     zerodivproblem = N.equal(denom,0)
     denom = N.where(zerodivproblem,1,denom)  # avoid zero-division in 1st place
     t = N.add.reduce(d,dimension) / denom      # N-D COMPUTATION HERE!!!!!!
     t = N.where(zerodivproblem,1.0,t)     # replace NaN/wrong t-values with 1.0
     probs = abetai(0.5*df,0.5,float(df)/(df+t*t))
     if isinstance(t, N.ndarray):
         probs = N.reshape(probs,t.shape)
     if probs.shape == (1,):
         probs = probs[0]
 
-    if printit <> 0:
+    if printit != 0:
         statname = 'Related samples T-test.'
         outputpairedstats(printit,writemode,
                           name1,n,x1,v1,N.minimum.reduce(N.ravel(a)),
                           N.maximum.reduce(N.ravel(a)),
                           name2,n,x2,v2,N.minimum.reduce(N.ravel(b)),
                           N.maximum.reduce(N.ravel(b)),
                           statname,t,probs)
         return
     return t, probs
 
 
  def achisquare(f_obs,f_exp=None):
     """
 Calculates a one-way chi square for array of observed frequencies and returns
 the result.  If no expected frequencies are given, the total N is assumed to
 be equally distributed across all groups.
 @@@NOT RIGHT??
 
 Usage:   achisquare(f_obs, f_exp=None)   f_obs = array of observed cell freq.
 Returns: chisquare-statistic, associated p-value
 """
 
     k = len(f_obs)
-    if f_exp == None:
+    if f_exp is None:
         f_exp = N.array([sum(f_obs)/float(k)] * len(f_obs),N.float_)
     f_exp = f_exp.astype(N.float_)
     chisq = N.add.reduce((f_obs-f_exp)**2 / f_exp)
     return chisq, achisqprob(chisq, k-1)
 
 
  def aks_2samp (data1,data2):
     """

  def awilcoxont(x,y):
     """
 Calculates the Wilcoxon T-test for related samples and returns the
 result.  A non-parametric T-test.
 
 Usage:   awilcoxont(x,y)     where x,y are equal-length arrays for 2 conditions
 Returns: t-statistic, two-tailed p-value
 """
-    if len(x) <> len(y):
+    if len(x) != len(y):
         raise ValueError, 'Unequal N in awilcoxont.  Aborting.'
     d = x-y
     d = N.compress(N.not_equal(d,0),d) # Keep all non-zero differences
     count = len(d)
     absd = abs(d)
     absranked = arankdata(absd)
     r_plus = 0.0
     r_minus = 0.0
if (df > 2):
             e = N.zeros(probs.shape,N.float_)
         else:
             e = N.log(N.sqrt(N.pi)) *N.ones(probs.shape,N.float_)
         c = N.log(a)
         mask = N.zeros(probs.shape)
         a_big = N.greater(a,BIG)
         a_big_frozen = -1 *N.ones(probs.shape,N.float_)
         totalelements = N.multiply.reduce(N.array(probs.shape))
-        while asum(mask)<>totalelements:
+        while asum(mask) != totalelements:
             e = N.log(z) + e
             s = s + ex(c*z-a-e)
             z = z + 1.0
 #            print z, e, s
             newmask = N.greater(z,chisq)
             a_big_frozen = N.where(newmask*N.equal(mask,0)*a_big, s, a_big_frozen)
             mask = N.clip(newmask+mask,0,1)
         if even:
             z = N.ones(probs.shape,N.float_)
             e = N.ones(probs.shape,N.float_)
         else:
             z = 0.5 *N.ones(probs.shape,N.float_)
             e = 1.0 / N.sqrt(N.pi) / N.sqrt(a) * N.ones(probs.shape,N.float_)
         c = 0.0
         mask = N.zeros(probs.shape)
         a_notbig_frozen = -1 *N.ones(probs.shape,N.float_)
-        while asum(mask)<>totalelements:
+        while asum(mask) != totalelements:
             e = e * (a/z.astype(N.float_))
             c = c + e
             z = z + 1.0
 #            print '#2', z, e, c, s, c*y+s2
             newmask = N.greater(z,chisq)
             a_notbig_frozen = N.where(newmask*N.equal(mask,0)*(1-a_big),
                                       c*y+s2, a_notbig_frozen)
             mask = N.clip(newmask+mask,0,1)
for i in range(ITMAX+1):
         am = ap/bpp
         bm = bp/bpp
         az = app/bpp
         bz = 1.0
         newmask = N.less(abs(az-aold),EPS*abs(az))
         frozen = N.where(newmask*N.equal(mask,0), az, frozen)
         mask = N.clip(mask+newmask,0,1)
     noconverge = asum(N.equal(frozen,-1))
-    if noconverge <> 0 and verbose:
+    if noconverge != 0 and verbose:
         print('a or b too big, or ITMAX too small in Betacf for ', noconverge, ' elements')
     if arrayflag:
         return frozen
     else:
         return frozen[0]
 
 
  def agammln(xx):

 function of a.  The continued fraction formulation is implemented
 here, using the betacf function.  (Adapted from: Numerical Recipies in
 C.)  Can handle multiple dimensions.
 
 Usage:   abetai(a,b,x,verbose=1)
 """
     TINY = 1e-15
     if isinstance(a, N.ndarray):
-        if asum(N.less(x,0)+N.greater(x,1)) <> 0:
+        if asum(N.less(x, 0) + N.greater(x, 1)) != 0:
             raise ValueError, 'Bad x in abetai'
     x = N.where(N.equal(x,0),TINY,x)
     x = N.where(N.equal(x,1.0),1-TINY,x)
 
     bt = N.where(N.equal(x,0)+N.equal(x,1), 0, -1)
     exponents = ( gammln(a+b)-gammln(a)-gammln(b)+a*N.log(x)+b*
                   N.log(1.0-x) )
     # 746 (below) is the MAX POSSIBLE BEFORE OVERFLOW

 from:
     Peterson et al. Statistical limitations in functional neuroimaging
     I. Non-inferential methods and statistical models.  Phil Trans Royal Soc
     Lond B 354: 1239-1260.
 
 Usage:   aglm(data,para)
 Returns: statistic, p-value ???
 """
-    if len(para) <> len(data):
+    if len(para) != len(data):
         print("data and para must be same length in aglm")
         return
     n = len(para)
     p = pstat.aunique(para)
     x = N.zeros((n,len(p)))  # design matrix
     for l in range(len(p)):
         x[:,l] = N.equal(para,p[l])
     b = N.dot(N.dot(LA.inv(N.dot(N.transpose(x),x)),  # i.e., b=inv(X'X)X'Y

 dimensions).  If keepdims=1, the resulting array will have as many
 dimensions as the input array.
 
 Usage:   asum(a, dimension=None, keepdims=0)
 Returns: array summed along 'dimension'(s), same _number_ of dims if keepdims=1
 """
      if isinstance(a, N.ndarray) and a.dtype in [N.int_, N.short, N.ubyte]:
          a = a.astype(N.float_)
-     if dimension == None:
+     if dimension is None:
          s = N.sum(N.ravel(a))
      elif isinstance(dimension, (int, float)):
          s = N.add.reduce(a, dimension)
          if keepdims == 1:
              shp = list(a.shape)
              shp[dimension] = 1
              s = N.reshape(s,shp)
      else: # must be a SEQUENCE of dims to sum over
def acumsum (a,dimension=None):
     """
 Returns an array consisting of the cumulative sum of the items in the
 passed array.  Dimension can equal None (ravel array first), an
 integer (the dimension over which to operate), or a sequence (operate
 over multiple dimensions, but this last one just barely makes sense).
 
 Usage:   acumsum(a,dimension=None)
 """
-    if dimension == None:
+    if dimension is None:
         a = N.ravel(a)
         dimension = 0
     if isinstance(dimension, (list, tuple, N.ndarray)):
         dimension = list(dimension)
         dimension.sort()
         dimension.reverse()
         for d in dimension:
             a = N.add.accumulate(a,d)

 the array.  Dimension can equal None (ravel array first), an integer
 (the dimension over which to operate), or a sequence (operate over
 multiple dimensions).  Set keepdims=1 to maintain the original number
 of dimensions.
 
 Usage:   ass(inarray, dimension=None, keepdims=0)
 Returns: sum-along-'dimension' for (inarray*inarray)
 """
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(inarray)
         dimension = 0
     return asum(inarray*inarray,dimension,keepdims)
 
 
  def asummult (array1,array2,dimension=None,keepdims=0):
     """
 Multiplies elements in array1 and array2, element by element, and
 returns the sum (along 'dimension') of all resulting multiplications.
 Dimension can equal None (ravel array first), an integer (the
 dimension over which to operate), or a sequence (operate over multiple
 dimensions).  A trivial function, but included for completeness.
 
 Usage:   asummult(array1,array2,dimension=None,keepdims=0)
 """
-    if dimension == None:
+    if dimension is None:
         array1 = N.ravel(array1)
         array2 = N.ravel(array2)
         dimension = 0
     return asum(array1*array2,dimension,keepdims)
 
 
  def asquare_of_sums(inarray, dimension=None, keepdims=0):
     """
 Adds the values in the passed array, squares that sum, and returns the
 result.  Dimension can equal None (ravel array first), an integer (the
 dimension over which to operate), or a sequence (operate over multiple
 dimensions).  If keepdims=1, the returned array will have the same
 NUMBER of dimensions as the original.
 
 Usage:   asquare_of_sums(inarray, dimension=None, keepdims=0)
 Returns: the square of the sum over dim(s) in dimension
 """
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(inarray)
         dimension = 0
     s = asum(inarray,dimension,keepdims)
     if isinstance(s, N.ndarray):
         return s.astype(N.float_)*s
     else:
         return float(s)*s
 
 
  def asumdiffsquared(a,b, dimension=None, keepdims=0):
     """
 Takes pairwise differences of the values in arrays a and b, squares
 these differences, and returns the sum of these squares.  Dimension
 can equal None (ravel array first), an integer (the dimension over
 which to operate), or a sequence (operate over multiple dimensions).
 keepdims=1 means the return shape = len(a.shape) = len(b.shape)
 
 Usage:   asumdiffsquared(a,b)
 Returns: sum[ravel(a-b)**2]
 """
-    if dimension == None:
+    if dimension is None:
         inarray = N.ravel(a)
         dimension = 0
     return asum((a-b)**2,dimension,keepdims)
 
 
  def ashellsort(inarray):
     """
 Shellsort algorithm.  Sorts a 1D-array.
"""
     n = len(inarray)
     svec, ivec = ashellsort(inarray)
     sumranks = 0
     dupcount = 0
     newarray = N.zeros(n,N.float_)
     for i in range(n):
         sumranks = sumranks + i
         dupcount = dupcount + 1
-        if i==n-1 or svec[i] <> svec[i+1]:
+        if i == n - 1 or svec[i] != svec[i + 1]:
             averank = sumranks / float(dupcount) + 1
             for j in range(i-dupcount+1,i+1):
                 newarray[ivec[j]] = averank
             sumranks = 0
             dupcount = 0
     return newarray
 
 

lnt/trunk/lnt/server/ui/filters.py

def filter_filesize(value):
     for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']:
         if abs(value) < 1024.0:
             return "%3.2f %sB" % (value, unit)
         value /= 1024.0
     return "%.2f%sB" % (value, 'Yi')
 
 
 def filter_print_value(value, field_unit, field_unit_abbrev, default = '-'):
-    if value == None:
+    if value is None:
         return default
 
     if field_unit == 'bytes' and field_unit_abbrev == 'B':
         return filter_filesize(value)
     else:
         return '%.3f' % value
 
 
 def register(env):
     for name, object in globals().items():
         if name.startswith('filter_'):
             env.filters[name[7:]] = object

lnt/trunk/tests/server/db/ImportV4TestSuiteInstance.py

 print sample_a_0
 print sample_a_1
 print sample_b
 assert sample_a_0.compile_time == 0.019
 assert sample_a_0.compile_status == lnt.testing.PASS
 assert sample_a_0.execution_time == 0.3
 assert sample_a_0.execution_status == lnt.testing.PASS
 assert sample_a_1.compile_time == 0.0189
-assert sample_a_1.compile_status == None
+assert sample_a_1.compile_status is None
 assert sample_a_1.execution_time == 0.29
-assert sample_a_1.execution_status == None
+assert sample_a_1.execution_status is None
 assert sample_b.compile_time == 0.022
 assert sample_b.compile_status == lnt.testing.PASS
 assert sample_b.execution_time == 0.32
 assert sample_b.execution_status == lnt.testing.PASS