Programming ArcGIS with Python Cookbook, Second Edition

To start the IDLE development environment for Python, you can navigate to Start | All Programs | ArcGIS | Python 2.7 | IDLE. Please note that the version of Python installed with ArcGIS will differ depending upon the ArcGIS version that you have installed. For example, ArcGIS 10.3 uses Python 2.7, whereas ArcGIS 10.0 uses version 2.6 of Python.

A Python shell window similar to this screenshot will be displayed:

The Python shell window is used for output and error messages generated by scripts. A common mistake for beginners is to assume that the geoprocessing scripts will be written in this shell window. This is not the case. You will need to create a separate code window to hold your scripts.

Although the shell window isn't used to write entire scripts, it can be used to interactively write code and get immediate feedback. ArcGIS has a built-in Python shell window that you can use in a similar way. We'll examine the ArcGIS Python window in the next chapter.

Your scripts will be written in IDLE inside a separate window known as the Python script window. To create a new code window, navigate to File | New Window from the IDLE shell window. A window similar to this will be displayed:

Your Python scripts will be written inside this new code window. Each script will need to be saved to a local or network drive. By default, scripts are saved with a .py file extension to signify that it is a Python script.

Existing Python script files can be opened by selecting File | Open from the IDLE shell window. Additionally, a Python script can be opened from Windows Explorer by right-clicking on the file and selecting Edit with IDLE, which brings up a new shell window along with the script loaded in the Python script editor. You can see an example of this in the following screenshot:

In this instance, we have loaded the ListFeatureClasses.py script with IDLE. The code is loaded inside the script window:

Now that the code window is open, you can begin writing or editing code. You can also perform some basic script debugging with the IDLE interface. Debugging is the process of identifying and fixing errors in your code.

Once you've written a geoprocessing script in the IDLE code window or opened an existing script, you can execute the code from the interface. IDLE does provide functionality that allows you to check the syntax of your code before running the script. In the code window, navigate to Run | Check Module to perform a syntax check of your code.

Any syntax errors will be displayed in the shell window. If there aren't any syntax errors, you should just see the prompt in the shell window. While the IDLE interface can be used to check for syntax errors, it doesn't provide a way to check for logical errors in your code nor does it provide more advanced debugging tools found in other development environments, such as PyScripter or Wingware.

Once you're satisfied that no syntax errors exist in your code, you can run the script. Navigate to Run | Run Module to execute the script:

Any error messages will be written to the shell window along with the output from the print statements and system-generated messages. The print statement simply outputs text to the shell window. It is often used to update the status of a running script or to debug the code.

The ArcGIS Python window is an embedded, interactive Python window in ArcGIS for Desktop 10.x. It is newer and ideal for testing small blocks of code, learning Python basics, building quick and easy workflows, and executing geoprocessing tools. For new programmers, the ArcGIS Python window is a great place to start!

The ArcGIS Python window has a number of capabilities in addition to being the location to write your code. You can save the content of the window to a Python script file on a disk or load an existing Python script into the window. The window can be either pinned or floating. While floating, the window can be expanded or contracted as you wish. The window can also be pinned to various parts of the ArcGIS display. You can also format the font and text colors displayed in the window by right-clicking on the window and selecting Format.

The Python window can be opened by clicking on the Python window button on the Standard ArcGIS for Desktop toolbar, as seen in the screenshot. This is a floating window, so you can resize as needed and also dock it at various places on the ArcMap interface:

The Python window is essentially a shell window that allows you to type in statements one line at a time, just after the >>> line input characters. On the right-hand side of the divider, you will find a help window.

You can load an existing script by right-clicking inside the Python window and selecting Load… from the menu. You can also format the font and text colors displayed in the window by right-clicking on the window and selecting Format. You will be provided with White and Black themes; you can select fonts and colors individually:

Click on the Set Black Theme button to see an example. If you spend a lot of time writing code, you may find that darker themes are easier on your eyes:

The ArcGIS Python window also provides code-completion functionalities that make your life as a programmer much easier. You can try this functionality by opening the ArcGIS Python Window and typing arcpy followed by a dot on the first line. ArcPy is a module-oriented package, which means that you access the properties and methods of an object using a dot notation. Notice that a drop-down list of available items is provided. These are the tools, functions, classes, and extensions that are available for this particular object. All objects have their own associated items, so the list of items presented will differ depending on the object that you have currently selected:

This is an auto-filtering list, so as you begin typing the name of the tool, function, class, or extension, the list will be filtered according to what you have typed:

You can choose to have the Python window auto-complete the text for you by selecting an item from the list using your mouse or by using the arrow keys to highlight your choice, and then using the Tab key to enter the command. This autocompletion feature makes you a faster, more efficient programmer. Not only is it easy to use, but it also dramatically cuts down the number of typos in your code.

Python scripts should follow a common structure. It is a commonly accepted practice that the beginning of each script should serve as documentation, detailing the script name, author, and a general description of the processing provided by the script. This introductory documentation will help you and other programmers in the future to quickly scan the details and purpose of a script. This documentation is accomplished in Python through the use of comments. Comments are lines of code that you add to your script that serve as a documentation of what functionality the script provides. These lines of code begin with a single pound sign (#) or a double pound sign (##), and are followed by whatever text you need to document the code. The Python interpreter does not execute these lines of code. They are simply used to document your code. In the next screenshot, the commented lines of code are displayed with a single pound sign that prefixes the line of code. You should also strive to include comments throughout your script to describe important sections of your script. This will be useful to you (or another programmer) when the time comes to update your scripts:

Although Python includes many built-in functions, you will frequently need to access specific bundles of functionality, which are stored in external modules. For instance, the Math module stores specific functions related to processing numeric values and the R module provides statistical analysis functions. We haven't discussed the topic of functions yet, but basically functions are a named block of code that execute when called. Modules are imported through the use of the import statement. When writing geoprocessing scripts with ArcGIS, you will always need to import the arcpy module, which is the Python package that is used to access GIS tools and functions provided by ArcGIS. The import statements will be the first lines of code (not including comments) in your scripts. The following line of code imports the arcpy and os modules. The Python os module provides a way of interfacing with the underlying operating system:

import arcpy
import os

At a high level, you can think of a variable as an area in your computer's memory that is reserved to store values while the script is running. Variables that you define in Python are given a name and a value. The values assigned to variables can then be accessed by different areas of your script as needed, simply by referring to the variable name. For example, you might create a variable that contains a feature class name, which is then used by the Buffer tool to create a new output dataset. To create a variable, simply give it a name followed by the assignment operator, which is just an equals sign (=), and then a value:

fcParcels = "Parcels"
fcStreets = "Streets"

The following table illustrates the variable name and value assigned to the variable using the preceding code example:

There are certain naming rules that you must follow when creating variables, including the following:

There are a few dozen Python keywords that must be avoided, including class, if, for, while, and others. These keywords are typically highlighted in a different font color from other Python statements.

Here are some examples of legal variable names in Python:

These are some examples of illegal variable names in Python:

Python is a case-sensitive language, so pay particular attention to the capitalization and naming of variables in your scripts. Case-sensitivity issues are probably the most common source of errors for new Python programmers, so always consider this as a possibility when you encounter errors in your code. Let's look at an example. The following is a list of three variables; note that although each variable name is the same, the casing is different, resulting in three distinct variables:

If you print these variables, you will get the following output:

print(mapsize)
>>> 22x34

print(MapSize)
>>> 8x11  #output from print statement

print(Mapsize)
>>>36x48  #output from print statement

Python variable names need to be consistent throughout the script. The best practice is to use camel casing, wherein the first word of a variable name is all lowercase and then each successive word begins with an uppercase letter. This concept is illustrated in the following example with the fieldOwnerName variable name. The first word (field) is all lowercase followed by an uppercase letter for the second word (Owner) and third word (Name):

fieldOwnerName

In Python, variables are dynamically typed. Dynamic typing means that you can define a variable and assign data to it without specifically defining that a variable name will contain a specific type of data. Commonly used data types that can be assigned to variables include the following:

We will discuss each of these data types in greater detail in the coming sections.

For instance, in C#, you would need to define a variable's name and type before using it. This is not necessary in Python. To use a variable, simply give it a name and value, and you can begin using it right away. Python does the work behind the scenes to figure out what type of data is being held in the variable.

In the following C# code example, we've created a new variable called aTouchdown, which is defined as an integer variable, meaning that it can contain only integer data. We then assign the 6 value to the variable:

int aTouchdown;
aTouchdown = 6;

In Python, this variable can be created and assigned data through dynamic typing. The Python interpreter is tasked with dynamically figuring out what type of data is assigned to the variable:

aTouchdown = 6

There may be times when you know that your script will need a variable, but don't necessarily know ahead of time what data will be assigned to the variable. In these cases, you could simply define a variable without assigning data to it. Here, you will find a code example that depicts creating a variable without assigning data:

aVariable = ''
aVariable = NULL

Data that is assigned to the variable can also be changed while the script is running.

Variables can hold many different kinds of data, including primitive data types, such as strings and numbers, along with more complex data, such as lists, dictionaries, and even objects. We're going to examine the different types of data that can be assigned to a variable along with various functions that are provided by Python to manipulate the data.

Python has a number of built-in data types. The first built-in type that we will discuss is the string data type. We've already seen several examples of string variables, but these types of variables can be manipulated in a lot of ways, so let's take a closer look at this data type.

Strings

Strings are ordered collections of characters that store and represent text-based information. This is a rather dry way of saying that string variables hold text. String variables are surrounded by single or double quotes when being assigned to a variable. Examples could include a name, feature class name, a Where clause, or anything else that can be encoded as text.

String manipulation

Strings can be manipulated in a number of ways in Python. String concatenation is one of the more commonly used functions and is simple to accomplish. The + operator is used with string variables on either side of the operator to produce a new string variable that ties the two string variables together:

shpStreets = "c:\\GISData\\Streets" + ".shp"
print(shpStreets)

Running this code example produces the following result:

>>>c:\GISData\Streets.shp

String equality can be tested using Python's == operator, which is simply two equals signs placed together. Don't confuse the equality operator with the assignment operator, which is a single equals sign. The equality operator tests two variables for equality, while the assignment operator assigns a value to a variable:

firstName = "Eric"
lastName = "Pimpler"
firstName == lastName

Running this code example produces the following result because the firstName and lastName variables are not equal:

>>>False

Strings can be tested for containment using the in operator, which returns True if the first operand is contained in the second:

fcName = "Floodplain.shp"
print(".shp" in fcName)
>>>True

I have briefly mentioned that strings are an ordered collection of characters. What does this mean? It simply means that we can access individual characters or a series of characters from the string and that the order of the characters will remain the same until we change them. Some collections, such as a dictionary, do not maintain a set order. In Python, this is referred to as indexing in the case of accessing an individual character, and slicing in the case of accessing a series of characters.

Characters in a string are obtained by providing the numeric offset contained within square brackets after a string. For example, you could obtain the first string character in the fc variable by using the fc[0] syntax. Python is a zero-based language, meaning the first item in a list is 0. Negative offsets can be used to search backwards from the end of a string. In this case, the last character in a string is stored at the -1 index. Indexing always creates a new variable to hold the character:

fc = "Floodplain.shp"
print(fc[0])
>>>'F'
print(fc[10])
>>>'.'
print(fc[13])
>>>'p'

The following image illustrates how strings are an ordered collection of characters with the first character occupying the 0 position, the second character occupying the 1 position, and each successive character occupying the next index number:

While string indexing allows you to obtain a single character from a string variable, string slicing enables you to extract a contiguous sequence of strings. The format and syntax is similar to indexing, but with the addition of a second offset, which is used to tell Python which characters to return.

The following code example provides an example of string slicing. The theString variable has been assigned a value of Floodplain.shp. To obtain a sliced variable with the contents of Flood, you would use the theString[0:5] syntax:

theString = "Floodplain.shp"
print(theString[0:5])
>>>Flood

Note

Python slicing returns the characters beginning with the first offset up to, but not including, the second offset. This can be particularly confusing for new Python programmers and is a common source of errors. In our example, the returned variable will contain the Flood characters. The first character, which occupies the 0 position, is F. The last character returned is the 4 index, which corresponds to the d character. Notice the 5 index number is not included since Python slicing only returns characters up to, but not including, the second offset

Either of the offsets can be left off. This, in effect, creates a wild card. In the case of theString[1:], you are telling Python to return all characters starting from the second character to the end of the string. In the second case, theString[:-1], you are telling Python to start at character zero and return all characters except the last.

Python is an excellent language to manipulate strings and there are many additional functions that you can use to process this type of data. Most of these are beyond the scope of this text, but in general, all the following string manipulation functions are available:

• String length

• Casing functions for conversion to upper and lowercase

• The removal of leading and trailing whitespace

• Finding a character within a string

• The replacement of text

• Splitting into a list of words based on a delimiter

• Formatting

Your Python geoprocessing scripts for ArcGIS will often need to reference the location of a dataset on your computer or, perhaps, a shared server. References to these datasets will often consist of paths stored in a variable. In Python, pathnames are a special case that deserve some extra mention. The backslash character in Python is a reserved escape character and a line continuation character, thus there is a need to define paths using two back slashes, a single forward slash, or a regular single backslash prefixed with r. These pathnames are always stored as strings in Python. You'll see an example of this in the following section.

The example for an illegal path reference is as follows:

fcParcels = "c:\Data\Parcels.shp"

The example for legal path references are as follows:

fcParcels = "c:/Data/Parcels.shp"
fcParcels = "c:\\Data\\Parcels.shp"
fcParcels = r"c:\Data\Parcels.shp"

import math

Lists

A third built-in data type provided by Python is lists. A list is an ordered collection of elements that can hold any type of data supported by Python as well as being able to hold multiple data types at the same time. This could be numbers, strings, other lists, dictionaries, or objects. So, for instance, a list variable could hold numeric and string data at the same time. Lists are zero-based, with the first element in the list occupying the 0 position. This is illustrated here:

Each successive object in the list is incremented by one. Additionally, lists have the special capability of dynamically growing and shrinking.

Lists are created by assigning a series of values enclosed by brackets. To pull a value from a list, simply use an integer value in brackets along with the variable name. The following code example provides an illustration of this:

fcList = ["Hydrants", "Water Mains", "Valves", "Wells"]
fc = fcList[0] ##first item in the list - Hydrants
print(fc)
>>>Hydrants
fc = fcList[3]  ##fourth item in the list - Wells
print(fc)
>>>Wells

You can add a new item to an existing list by using the append() method, as seen in this code example:

fcList.append("Sewer Pipes")
print(fcList)
>> Hydrants, Water Mains, Valves, Wells, Sewer Pipes

You can also use slicing with lists to return multiple values. To slice a list, you can provide two offset values separated by a colon, as seen in the following code example. The first offset indicates the starting index number and the second indicates the stopping point. The second index number will not be returned. Slicing a list always returns a new list:

fcList = ["Hydrants", "Water Mains", "Valves", "Wells"]
fc = fcList[0:2] ##get the first two items – Hydrants, Water Mains

Lists are dynamic in nature, meaning that you can add and remove items from an existing list as well as change the existing contents. This is all done without the need to create a new copy of the list. Changing values in a list can be accomplished either through indexing or slicing. Indexing allows you to change a single value, while slicing allows you to change multiple list items.

Lists have a number of methods that allow you to manipulate the values that are part of the list. You can sort the contents of the list in either an ascending or descending order through the use of the sort() method. Items can be added to a list with the append() method, which adds an object to the end of the list, and with the insert() method, which inserts an object at a position within the list. Items can be removed from a list with the remove() method, which removes the first occurrence of a value from the list, or the pop() method, which removes and returns the object at the end of the list. The contents of the list can also be reversed with the reverse() method.

fcTuples = ("Hydrants", "Water Mains", "Valves", "Wells")

fcTuples = ("Hydrants", "Water Mains", "Valves", "Wells")
print(fcTuples[1])
>>>Water Mains

Dictionaries

Dictionaries are a second type of collection object in Python. They are similar to lists, except that dictionaries are an unordered collection of objects. Instead of fetching objects from the collection through the use of an offset, items in a dictionary are stored and fetched by a key. Each key in a dictionary has an associated value, as seen here:

Similar to lists, dictionaries can grow and shrink in place through the use of methods on dictionary. In the following code example, you will learn to create and populate a dictionary and see how values can be accessed through the use of a key. Dictionaries are created with the use of curly braces. Inside these braces, each key is followed by a colon and then a value is associated with the key. These key/value pairs are separated by commas:

##create the dictionary
dictLayers = {'Roads': 0, 'Airports': 1, 'Rail': 2}

##access the dictionary by key
print(dictLayers['Airports'])
>>>1
print(dictLayers['Rail'])
>>>2

Basic dictionary operations include getting the number of items in a dictionary, acquiring a value using a key, determining if the key exists, converting the keys to a list, and getting a list of values. The dictionary objects can be changed, expanded, and shrunk in place. What this means is that Python does not have to create a new dictionary object to hold the altered version of the dictionary. Assigning values to a dictionary key can be accomplished by stating the key value in brackets and setting it equal to some value.

Tip

Unlike lists, dictionaries can't be sliced due to the fact that their contents are unordered. Should you have the need to iterate over all the values in a dictionary, simply use the keys() method, which returns a collection of all the keys in the dictionary and can then be used individually to set or get their value.

Classes and objects are a fundamental concept in object-oriented programming. While Python is more of a procedural language, it also supports object-oriented programming. In object-oriented programming, classes are used to create object instances. You can think of classes as blueprints for the creation of one or more objects. Each object instance has the same properties and methods, but the data contained in an object can and usually will differ. Objects are complex data types in Python composed of properties and methods, and can be assigned to variables just like any other data type. Properties contain data associated with an object, while methods are actions that an object can perform.

These concepts are best illustrated with an example. In ArcPy, the extent class is a rectangle specified by providing the coordinate of the lower-left corner and the coordinate of the upper-right corner in map units. The extent class contains a number of properties and methods. Properties include XMin, XMax, YMin, YMax, spatialReference, and others. The minimum and maximum of x and y properties provide the coordinates for the extent rectangle. The spatialReference property holds a reference to a spatialReference object for extent. Object instances of the extent class can be used both to set and get the values of these properties through dot notation. An example of this is seen in the following code example:

# get the extent of the county boundary
ext = row[0].extent
# print out the bounding coordinates and spatial reference
print("XMin: " + str(ext.XMin))
print("XMax: " + str(ext.XMax))
print("YMin: " + str(ext.YMin))
print("YMax: " + str(ext.YMax))
print("Spatial Reference: " + ext.spatialReference.name)

Running this script yields the following output:

XMin: 2977896.74002
XMax: 3230651.20622
YMin: 9981999.27708
YMax:10200100.7854
Spatial Reference: NAD_1983_StatePlane_Texas_Central_FIPS_4203_Feet

The extent class also has a number of methods, which are actions that an object can perform. In the case of this particular object, most of the methods are related to performing some sort of geometric test between the extent object and another geometry. Examples include contains(), crosses(), disjoint(), equals(), overlaps(), touches(), and within().

One additional object-oriented concept that you need to understand is dot notation. Dot notation provides a way of accessing the properties and methods of an object. It is used to indicate that a property or method belongs to a particular class.

The syntax for using dot notation includes an object instance followed by a dot and then the property or method. The syntax is the same regardless of whether you're accessing a property or a method. A parenthesis and zero or more parameters at the end of the word following the dot indicates that a method is being accessed. Here are a couple of examples to better illustrate this concept:

Property: extent.XMin
Method: extent.touches()

Each line of code that you write with Python is known as a statement. There are many different kinds of statements, including those that create and assign data to variables, decision support statements that branch your code based on a test, looping statements that execute a code block multiple times, and others. There are various rules that your code will need to follow as you create the statements that are part of your script. You've already encountered one type of statement: variable creation and assignment.

if fcName == 'Roads':
  arcpy.Buffer_analysis(fc, "c:\\temp\\roads.shp", 100)
elif fcName == 'Rail':
  arcpy.Buffer_analysis(fc, "c:\\temp\\rail.shp", 50)
else:
  print("Can't buffer this layer")

x = 10
while x < 100:
     print(x)
     x = x + 10

dictLayers = {"Roads":"Line","Rail":"Line","Parks":"Polygon"}
for key in dictLayers:
  print(dictLayers[key])

import arcpy
import sys

inFeatureClass = arcpy.GetParameterAsText(0)
outFeatureClass = arcpy.GetParameterAsText(1)

try:
  # If the output feature class exists, raise an error
  
  if arcpy.Exists(inFeatureClass):
    raise overwriteError(outFeatureClass)
  else:
    # Additional processing steps
    print("Additional processing steps")

except overwriteError as e:
  # Use message ID 12, and provide the output feature class
  #  to complete the message.
  
  arcpy.AddIDMessage("Error", 12, str(e))

import arcpy

try:
  if arcpy.CheckExtension("3D") == "Available":
    arcpy.CheckOutExtension("3D")
  else:
    # Raise a custom exception
    raise LicenseError
  
  arcpy.env.workspace = "D:/GrosMorne"
  arcpy.HillShade_3d("WesternBrook", "westbrook_hill", 300)
  arcpy.Aspect_3d("WesternBrook", "westbrook_aspect")

except LicenseError:
  print("3D Analyst license is unavailable")
except:
  print(arcpy.GetMessages(2))
finally:
  # Check in the 3D Analyst extension
  arcpy.CheckInExtension("3D")

import arcpy

fc = "c:/data/city.gdb/streets"

# For each row print the Object ID field, and use the SHAPE@AREA
# token to access geometry properties

with arcpy.da.SearchCursor(fc, ("OID@", "SHAPE@AREA")) as cursor:
  for row in cursor:
    print("Feature {0} has an area of {1}".format(row[0], row[1]))

try:
  if <statement1>:
    <statement2>
    <statement3>
  <statement4> <………..>
except:
  <statement>
  <………..>
except:
  <statement>
  <…………>

You will often find it necessary to retrieve or write information to files on your computer. Python has a built-in object type that provides a way to access files for many tasks. We're only going to cover a small subset of the file manipulation functionality provided, but we'll touch on the most commonly used functions, including opening and closing files, and reading and writing data to a file.

Python's open() function creates a file object, which serves as a link to a file residing on your computer. You must call the open() function on a file before reading and/or writing data to a file. The first parameter for the open() function is a path to the file you'd like to open. The second parameter corresponds to a mode, which is typically read (r), write (w), or append (a). A value of r indicates that you'd like to open the file for read-only operations, while a value of w indicates you'd like to open the file for write operations. In the event that you open a file that already exists for write operations, this will overwrite any data currently in the file, so you must be careful with the write mode. The append mode (a) will open a file for write operations, but instead of overwriting any existing data, it will append the new data to the end of the file. The following code example shows the use of the open() function to open a text file in a read-only mode:

with open('Wildfires.txt','r') as f:

Notice that we have also used the with keyword to open the file, ensuring that the file resource will be cleaned up after the code that uses it has finished executing.

After a file has been opened, data can be read from it in a number of ways and using various methods. The most typical scenario would be to read data one line at a time from a file through the readline() method. The readline() function can be used to read the file one line at a time into a string variable. You would need to create a looping mechanism in your Python code to read the entire file line by line. If you would prefer to read the entire file into a variable, you can use the read() method, which will read the file up to the End Of File (EOF) marker. You can also use the readlines() method to read the entire contents of a file, separating each line into individual strings, until the EOF is found.

In the following code example, we have opened a text file called Wildfires.txt in the read-only mode and used the readlines() method on the file to read its entire contents into a variable called lstFires, which is a Python list containing each line of the file as a separate string value in the list. In this case, the Wildfire.txt file is a comma-delimited text file containing the latitude and longitude of the fire along with the confidence values for each fire. We then loop through each line of text in lstFires and use the split() function to extract the values based on a comma as the delimiter, including the latitude, longitude, and confidence values. The latitude and longitude values are used to create a new Point object, which is then inserted into the feature class using an insert cursor:

import arcpy, os
try:
 
  arcpy.env.workspace = "C:/data/WildlandFires.mdb"
  # open the file to read
  with open('Wildfires.txt','r') as f:   #open the file

    lstFires = f.readlines() #read the file into a list
    cur = arcpy.InsertCursor("FireIncidents")
  
    for fire in lstFires: #loop through each line
      if 'Latitude' in fire: #skip the header
        continue
      vals = fire.split(",") #split the values based on comma
      latitude = float(vals[0]) #get latitude
      longitude = float(vals[1]) #get longitude
      confid = int(vals[2]) #get confidence value
      #create new Point and set values
      pnt = arcpy.Point(longitude,latitude) 
      feat = cur.newRow()
      feat.shape = pnt
      feat.setValue("CONFIDENCEVALUE", confid)
      cur.insertRow(feat) #insert the row into featureclass
except:
    print(arcpy.GetMessages()) #print out any errors
finally:
  del cur
  f.close()

Just as is the case with reading files, there are a number of methods that you can use to write data to a file. The write() function is probably the easiest to use and takes a single string argument and writes it to a file. The writelines() function can be used to write the contents of a list structure to a file. In the following code example, we have created a list structure called fcList, which contains a list of feature classes. We can write this list to a file using the writelines() method:

outfile = open('c:\\temp\\data.txt','w')
fcList = ["Streams", "Roads", "Counties"]
outfile.writelines(fcList)