- Simple calculations
- Python built-in functions
- Using code blocks
- Code samples–math
- Calculate fields using logic with Python
- Calculate fields using logic with VBScript
- Code samples—geometry
- Geometry unit conversions
- Code samples—dates
- Code samples—strings
- Accumulative and sequential calculations
- Random values
- Calculating null values

Entering values with the keyboard is not the only way you can edit values in a table. In some cases, you might want to perform a mathematical calculation to set a field value for a single record or even all records. You can perform simple as well as advanced calculations on all or selected records. In addition, you can calculate area, length, perimeter, and other geometric properties on fields in attribute tables. The sections below include examples of using the field calculator. Calculations can be performed using either Python or VBScript.

Python is the recommended scripting language for ArcGIS. Use Python if you want access to geoprocessing functionality, including feature geometry. The adoption of Python as the scripting language for ArcGIS provides many opportunities for performing calculations.

Use **VBScript** if you have VBA or VBScript
experience and are comfortable with the scripting syntax. Saved
.cal files from previous versions of ArcGIS may work or
require minimal modifications. If you have VBA code from past releases that use ArcObjects, you will need to modify your calculations.

## Simple calculations

### Simple string examples

Strings are supported by a series of Python string functions, including capitalize, rstrip, and replace.

Capitalize the first character of the string in the field CITY_NAME.

```
!CITY_NAME!.capitalize()
```

Strip any white space from the end of the string in the field CITY_NAME.

```
!CITY_NAME!.rstrip()
```

Replace any occurrences of "california" with "California" found in the field STATE_NAME.

```
!STATE_NAME!.replace("california", "California")
```

Characters in a string field can be accessed by indexing and slicing in Python. Indexing fetches characters at an index position; slicing fetches a group of characters.

Example | Explanation | Result |
---|---|---|

!fieldname![0] | The first character. | "a" |

!fieldname![-2] | The second to last character. | "e" |

!fieldname![1:4] | The second, third, and fourth characters. | "bcd" |

Python also supports string formatting using the str.format() method.

Combine FieldA and FieldB separated by a colon.

```
"{}:{}".format(!FieldA!, !FieldB!)
```

#### VBScript string functions

Strings are supported by a series of VBScript string functions, including Left, InStr, and Chr. Below are some VBScript examples for commonly used string functions in the Field Calculator.

Left function: Return a Variant (String) containing a specified number of characters from the left side of a string.

```
MyStr = Left([MyField], 1)
```

Right function: Returns a Variant (String) containing a specified number of characters from the right side of a string.

```
MyStr = Right([MyField], 1)
```

Mid function: Returns a Variant (String) containing a specified number of characters from a string.

```
MyString = "Mid Function Demo" 'Create text string
FirstWord = Mid(MyString, 1, 3) ' Returns "Mid"
LastWord = Mid(MyString, 14, 4) 'Returns "Demo"
MidWords = Mid(MyString, 5) 'Returns "Function Demo"
```

InStr function: Returns a Variant (Long) specifying the position of the first occurrence of one string within another.

```
MyPosition = InStr([address], " ")
```

Replace function: Returns a string in which a specified substring has been replaced with another substring a specified number of times.

```
NewString = Replace([comments], "#", "!")
```

Chr function: Returns a String containing the character associated with the specified character code.

```
' Replace a carriage return character with an exclamation
NewString = Replace([comments], chr(13), "!")
```

& operator: Used to force string concatenation of two expressions.

```
MyStr = [MyField1] & " " & [MyField2]
```

### Simple math examples

Python provides tools for processing numbers. Python also supports a number of numeric and mathematical functions, including math, cmath, decimal, random, itertools, functools, and operator.

Operator | Explanation | Example | Result |
---|---|---|---|

x + y | x plus y | 1.5 + 2.5 | 4.0 |

x - y | x minus y | 3.3 - 2.2 | 1.1 |

x * y | x times y | 2.0 * 2.2 | 4.4 |

x / y | x divided by y | 4.0 / 1.25 | 3.2 |

x // y | x divided by y ( | 4.0 / 1.25 | 3.0 |

x % y | x modulo y | 8 % 3 | 2 |

-x | negative expression of x | x = 5 -x | -5 |

+x | x is unchanged | x = 5 +x | 5 |

x ** y | x raised to the power of y | 2 ** 3 | 8 |

Multiplication

```
!Rank! * 2
```

Calculate volume of a sphere given a radius field.

```
4 / 3 * math.pi * !Radius! ** 3
```

When performing field calculations with a Python expression, Python math rules are in effect. For example, dividing two integer values will always produce an integer output (3 / 2 = 1). To get decimal output

- One of the numbers in the operation must be a decimal value: 3.0/2 = 1.5.
- Use the float function to
explicitly convert the value to a float:
`float(3)/2 = 1.5`

`float(!Population!) / !Area!`

## Python built-in functions

Python has a number of built-in functions that are available to use, including max, min, round, and sum.

Calculate the maximum value for each record from a list of fields.

```
max([!field1!, !field2!, !field3!])
```

Calculate the sum for each record from a list of fields.

```
sum([!field1!, !field2!, !field3!])
```

## Using code blocks

With Python expressions and the Code Block parameter, you can

- Use any Python function in the expression.
- Access geoprocessing functions and objects.
- Access properties of feature geometry.
- Access the new random value operator.
- Reclassify values using if-then-else logic.
- Use other geoprocessing tools.

How the code block is used is determined by the Expression Type. The Calculate Field tool supports PYTHON, PYTHON_9.3, and VB as expression types.

Expression Type | Code Block |
---|---|

PYTHON_9.3 | Supports Python functionality. The code block is expressed using Python functions (def). Geometry properties are expressed using geoprocessing objects, such as Point objects, where appropriate. |

PYTHON | Same as PYTHON_9.3, but returns strings instead of geometry objects. |

VB | Calculations are performed using VBScript. |

Python functions are defined using the def keyword followed by the name of the function and the function’s input arguments. A Python function can be written to accept any number of input arguments (including none at all). Values are returned from the function using a return statement. The function name is your choice (don't use spaces or leading numbers).

## Code samples–math

Round a field's value to two decimal places.

```
Expression:
round(!area!, 2)
Expression Type:
PYTHON_9.3
```

Use the math module to help convert meters to feet. The conversion is raised to the power of 2 and multiplied by the area.

```
Expression:
MetersToFeet((float(!shape.area!)))
Expression Type:
PYTHON_9.3
Code Block:
import math
def MetersToFeet(area):
return math.pow(3.2808, 2) * area
```

## Calculate fields using logic with Python

Classify based on field values.

```
Expression:
Reclass(!WELL_YIELD!)
Expression Type:
PYTHON_9.3
Code Block:
def Reclass(WellYield):
if (WellYield >= 0 and WellYield <= 10):
return 1
elif (WellYield > 10 and WellYield <= 20):
return 2
elif (WellYield > 20 and WellYield <= 30):
return 3
elif (WellYield > 30):
return 4
```

## Calculate fields using logic with VBScript

Conditionally executes a group of statements, depending on the value of an expression.

```
Expression:
density
Expression Type:
VB
Code Block:
Dim density
If [POP90_SQMI] < 100 Then
density = "low"
elseif [POP90_SQMI] < 300 Then
density = "medium"
else
density = "high"
end if
```

## Code samples—geometry

Calculate the area of a feature.

```
Expression:
!shape.area!
Expression Type:
PYTHON_9.3
```

Calculate the maximum X-coordinate of a feature.

```
Expression:
!shape.extent.XMax!
Expression Type:
PYTHON_9.3
```

Calculate the vertex count of a feature.

```
Expression:
MySub(!shape!)
Expression Type:
PYTHON_9.3
Code Block:
def MySub(feat):
partnum = 0
# Count the number of points in the current multipart feature
partcount = feat.partCount
pntcount = 0
# Enter while loop for each part in the feature (if a singlepart
# feature this will occur only once)
#
while partnum < partcount:
part = feat.getPart(partnum)
pnt = part.next()
# Enter while loop for each vertex
#
while pnt:
pntcount += 1
pnt = part.next()
# If pnt is null, either the part is finished or there
# is an interior ring
#
if not pnt:
pnt = part.next()
partnum += 1
return pntcount
```

For a point feature class, shift the x coordinate of each point by 100.

```
Expression:
shiftXCoordinate(!SHAPE!)
Expression Type:
PYTHON_9.3
Code Block:
def shiftXCoordinate(shape):
shiftValue = 100
point = shape.getPart(0)
point.X += shiftValue
return point
```

## Geometry unit conversions

Area and length properties of the geometry field can be modified with unit types expressed with an @ sign.

- Areal unit of measure keywords:
- ACRES | ARES | HECTARES | SQUARECENTIMETERS | SQUAREDECIMETERS | SQUAREINCHES | SQUAREFEET | SQUAREKILOMETERS | SQUAREMETERS | SQUAREMILES | SQUAREMILLIMETERS | SQUAREYARDS | SQUAREMAPUNITS | UNKNOWN

- Linear unit of measure keywords:
- CENTIMETERS | DECIMALDEGREES | DECIMETERS | FEET | INCHES | KILOMETERS | METERS | MILES | MILLIMETERS | NAUTICALMILES | POINTS | UNKNOWN | YARDS

Calculate a feature's length in yards.

```
Expression:
!shape.length@yards!
Expression Type:
PYTHON_9.3
```

Calculate a feature's area in acres.

```
Expression:
!shape.area@acres!
Expression Type:
PYTHON_9.3
```

Geodesic area and length can also be calculated using geodesicArea and geodesicLength properties with @ followed by a unit of measure keyword.

Calculate a feature's geodesic length in yards.

```
Expression:
!shape.geodesicLength@yards!
Expression Type:
PYTHON_9.3
```

Calculate a feature's geodesic area in acres.

```
Expression:
!shape.geodesicArea@acres!
Expression Type:
PYTHON_9.3
```

## Code samples—dates

Calculate the current date.

```
Expression:
time.strftime("%d/%m/%Y")
Expression Type:
PYTHON_9.3
```

Calculate the current date and time.

```
Expression:
datetime.datetime.now()
Expression Type:
PYTHON_9.3
```

Calculate the date to be December 31st 2000.

```
Expression:
datetime.datetime(2000, 12, 31)
Expression Type:
PYTHON_9.3
```

Calculate the number of days between the current date and the value in a field.

```
Expression:
(datetime.datetime.now() - arcpy.time.ParseDateTimeString(!field1!)).days
Expression Type:
PYTHON_9.3
```

Calculate a date by adding 100 days to the date value in a field.

```
Expression:
arcpy.time.ParseDateTimeString(!field1!) + datetime.timedelta(days=100)
Expression Type:
PYTHON_9.3
```

Calculate the day of the week (for example Sunday) for a date value in a field.

```
Expression:
arcpy.time.ParseDateTimeString(!field1!).strftime('%A')
Expression Type:
PYTHON_9.3
```

## Code samples—strings

Return the three rightmost characters.

```
Expression:
!SUB_REGION![-3:]
Expression Type:
PYTHON_9.3
```

Replace any cases of an uppercase "P" with a lowercase "p".

```
Expression:
!STATE_NAME!.replace("P","p")
Expression Type:
PYTHON_9.3
```

Concatenate two fields with a space separator.

```
Expression:
!SUB_REGION! + " " + !STATE_ABBR!
Expression Type:
PYTHON_9.3
```

### Convert to proper case

The following examples show different ways to convert words so that each word has the first character capitalized and the rest of the letters in lowercase.

```
Expression:
' '.join([i.capitalize() for i in !STATE_NAME!.split(' ')])
Expression Type:
PYTHON_9.3
```

```
Expression:
!STATE_NAME!.title()
Expression Type:
PYTHON_9.3
```

### Regular expressions

Python's re module provides regular expression matching operations that can be used to perform complex pattern matching and replacement rules for strings.

Replace 'St' or 'St.' starting a new word at the end of the string with the word 'Street'.

```
Expression:
update_street(!ADDRESS!)
Expression Type:
PYTHON_9.3
Code Block:
import re
def update_street(street_name):
return re.sub(r"""\b(St|St.)\Z""",
'Street',
street_name)
```

## Accumulative and sequential calculations

Calculate a sequential ID or number based on an interval.

```
Expression:
autoIncrement()
Expression Type:
PYTHON_9.3
Code Block:
rec=0
def autoIncrement():
global rec
pStart = 1 #adjust start value, if req'd
pInterval = 1 #adjust interval value, if req'd
if (rec == 0):
rec = pStart
else:
rec = rec + pInterval
return rec
```

Calculate the accumulative value of a numeric field.

```
Expression:
accumulate(!FieldA!)
Expression Type:
PYTHON_9.3
Code Block:
total = 0
def accumulate(increment):
global total
if total:
total += increment
else:
total = increment
return total
```

Calculate the percentage increase of a numeric field.

```
Expression:
percentIncrease(float(!FieldA!))
Expression Type:
PYTHON_9.3
Code Block:
lastValue = 0
def percentIncrease(newValue):
global lastValue
if lastValue:
percentage = ((newValue - lastValue) / lastValue) * 100
else:
percentage = 0
lastValue = newValue
return percentage
```

## Random values

Use the numpy site package to calculate random float values between 0.0 and 1.0.

```
Expression:
getRandomValue()
Expression Type:
PYTHON_9.3
Code Block:
import numpy
def getRandomValue():
return numpy.random.random()
```

## Calculating null values

Using a Python expression, null values can be calculated using a Python None.

Use a Python None to calculate null values.

```
Expression:
"None"
Expression Type:
PYTHON_9.3
```