Python-ArcGIS-高级指南-全-

Python ArcGIS 高级指南（全）

原文：annas-archive.org/md5/e61cac739b71cb09061c8d98a9a3e45b

译者：飞龙

协议：CC BY-NC-SA 4.0

第一章：Python for ArcGIS Pro：使用 ArcGIS Python 模块、ArcGIS Pro Notebooks、Jupyter Notebooks 和 pandas 自动化制图和数据分析

欢迎来到 Packt 早期访问版。我们为你提供了这本书的独家预览，提前了解内容。这本书的写作可能需要几个月的时间，但我们的作者今天就有前沿的信息与您分享。早期访问版通过提供章节草稿让你了解最新的进展。章节内容现在可能还不完全成熟，但我们的作者会随着时间的推移进行更新。新版本发布时，你将收到通知。

本书尚在开发中，更多章节仍待编写，这意味着你有机会对内容提出意见。我们希望出版能够为你和其他读者提供有用信息的书籍，因此我们会定期向你发送问卷。所有反馈都非常重要，请坦诚地分享你的想法和意见。我们的编辑将对书中的文本进行加工，因此我们希望你能对技术部分以及作为读者的体验提供意见。我们还将定期更新作者根据你反馈所做的章节修改。

你可以随时阅读本书，或者从头到尾跟随阅读；《早期访问版》旨在灵活使用。我们希望你能享受了解 Packt 图书编写过程的乐趣。通过贡献你的想法加入新主题的探索，并看到它们在书中变成现实。

  1. 第一章：GIS Python 入门

  2. 第二章：ArcPy 基础

  3. 第四章：使用游标访问数据

  4. 第三章：ArcGIS Python API 简介

  5. 第五章：发布到 ArcGIS Online

  6. 第八章：使用 Pandas 进行矢量分析

  7. 第六章：ArcToolbox 脚本工具

  8. 第九章：使用 pandas 进行栅格分析

  9. 第七章：自动化地图制作

  10. 第十章：使用 SciPy 进行地理空间数据科学

  11. 第十一章：案例研究：ArcGIS Pro 数据管理

  12. 第十二章：案例研究：高级地图制作

  13. 第十三章：案例研究：互动数据科学 Web 地图

第二章：Python：入门

编程与计算机是人类最有意义同时也是最令人沮丧的努力之一。

这些回报可以以金钱的形式表现出来，正如我们今天看到的高科技薪资。但我认为，掌握编程最有意义的部分是把自己打造成一个能够轻松执行简单和复杂应用程序以及分析的计算机高手，能编写可重复使用的代码。

挫折会时有发生，但这是一件好事：你，像我以及无数人在你之前的人，将从每个错误中学习（或许当个吹毛求疵的人有帮助，但我自己并不是这样，所以不能确定）。你将通过本书中的每一个练习不断成长和学习，通过提问和密切关注，你可以避免一些常见问题。

无论你是 ArcGIS 专家还是新手，寻求拓展你的技能：恭喜你，你来对地方了。在本书中，你将学习如何利用一种看似简单的编程语言——Python，来提升你现有的 GIS 专业知识（或兴趣）并放大其潜力。

计算机编程是一个庞大的领域，当然无法在一章中完全概述。在这一章中，我将解释阅读、编写和运行 Python 脚本所必需的基本知识。我们将把 ArcGIS 工具放到后面的章节，专注于 Python：它的起源、现状、如何使用它，最重要的是，Python 是什么，它又不是什么。

我们将涵盖以下主题：

  • Python 基础

  • 计算机编程基础

  • 安装和导入模块

  • 编写和执行脚本

Python：独具一格

Python 编程语言的创造者 Guido Van Rossum 在 1980 年代末期对计算机编程的现状感到沮丧。当时的编程语言过于复杂，同时在格式要求上也过于宽松。这导致了大量的代码库和复杂的脚本，代码质量差且很少有文档记录。

仅仅运行一个简单的程序可能需要很长时间，因为代码需要进行类型检查（确保变量正确定义并分配给正确的数据类型）和编译（将文本文件中的高级代码转换为 CPU 能够理解的汇编语言或机器代码）。

作为一名荷兰程序员，他在 ABC 编程语言的专业工作中学到了很多关于语言设计的知识，完成该项目后，他决定将自己对 ABC 及其他语言局限性的看法转化为一种兴趣。

范·罗苏姆拥有阿姆斯特丹大学数学与计算机科学的硕士学位，他的兴趣偏向计算机，但他也热爱英国喜剧系列《Monty Python》。因此，他将自己的热情结合在一起，创造了 Python 语言，现在它被广泛应用于各种编程解决方案。如今，Python 无处不在，遍及互联网、家电、汽车等多个领域。由于其普及性和简洁性，它已被 GIS 软件生态系统采纳为标准编程工具。

为什么 Python 与众不同

由于范·罗苏姆在 1980 年代对计算机语言的广泛经验，他具备了创造一种解决许多语言缺陷的语言的能力。他从许多其他语言中借鉴了他欣赏的特性，并加入了一些自己的创新。以下是 Python 为改进其他语言所构建的一些特性：

问题 改进 Python 特性
内存溢出 内建内存管理 垃圾回收和内存管理
慢编译时间 单行测试，动态类型 Python 解释器
不清晰的错误信息 显示指示错误行和受影响代码的消息 错误追踪
意大利面式代码 清晰的导入和模块化 导入
不清晰的代码格式和间距使代码不可读 缩进规则和减少括号 强制空白
太多方式做同一件事 应该只有一种方式：Pythonic 的方式 Python 之禅

Python 版本

Python 的最初版本于 1991 年由范·罗苏姆发布，Python 1.0 及其后续版本，最终被广泛流行的 Python 2.x 所取代。发布时，特别注意确保版本 2.0 及之后版本与 Python 1.x 向后兼容。然而，对于新的 Python 3.0 及之后的版本，与 Python 1 和 Python 2 的向后兼容性被打破。

这一变化导致 Python 生态系统出现分歧。一些公司选择坚持使用 Python 2.x，这意味着旧版本的“退休”日期从 2015 年延长到 2020 年 4 月。现在，随着“退休”日期的到来，Python 软件基金会（PSF）不再对 Python 2.x 进行任何积极开发。Python 3.x 的开发仍在继续，并将由 PSF 监督，持续到未来。

范·罗苏姆曾担任 PSF（Python Software Foundation）终身慈善独裁者，直到 2018 年辞去该职务。

了解更多关于 Python 的历史：docs.python.org/3/faq/general.html

图 1：Python 3 与 Python 2 的分歧

ArcGIS Python 版本

自 ArcMap 9.x 版本以来，Python 已经集成到 ArcGIS 软件套件中。然而，ArcGIS Desktop 和 ArcGIS Pro 现在都依赖于不同版本的 Python。

ArcGIS Desktop：Python 2.x

ArcGIS Desktop（或 ArcMap）版本 9.0 及以上自带 Python 2.x。ArcGIS 的安装程序会自动安装 Python 2.x，并将arcpy模块（最初是arcgisscripting）添加到 Python 路径变量中，使其可以用于脚本编写。

ArcMap、ArcCatalog、ArcGIS Engine 和 ArcGIS Server 都依赖于安装 ArcGIS Desktop 或 Enterprise 软件时随附的 arcpy 和 Python 2.x 版本。

ArcGIS Pro：Python 3.x

ArcGIS Pro 是在宣布停用 Python 2.0 后设计的，它与 Python 2.x 生态系统脱钩，改为随附 Python 3.x。

与arcpy不同，ArcGIS Pro 使用 ArcGIS API for Python。

管理两个版本

ArcGIS Desktop 的停用时间已延长至 2025 年 3 月，这意味着尽管 Python 软件基金会已正式停止对 Python 2.7 的支持，Esri 仍将在此日期之前将 Python 2.7 包含在内。

因此，我们将学习使用虚拟环境来管理版本，并且你将了解控制 Python 脚本执行版本的 PATH 和 PYTHONPATH 环境变量。

图片来源：media.geeksforgeeks.org/wp-content/uploads/20190502023317/TIMELINE.jpg

什么是 Python？

简而言之，Python 是一个应用程序：python.exe。该应用程序本身也是一个可执行文件，这意味着它可以独立运行来解释代码，或者可以从其他应用程序中调用来运行自定义脚本。这种标准的互操作性是它被包括在 ArcGIS Pro 等应用程序中的原因之一。安装 ArcGIS 时，Python 也会随之安装在您的计算机上，并带有一系列支持文件和文件夹。

Python 包含大量的标准库工具或“模块”。这些包括对互联网请求、高级数学、CSV 读写、JSON 序列化等的支持，以及 Python 核心中包含的许多其他模块。尽管这些工具非常强大，但 Python 也被设计为可扩展的，这意味着可以轻松地将第三方模块添加到 Python 安装中。ArcGIS Python 模块就是扩展 Python 能力的一个很好的例子。还有成千上万的其他模块，涵盖了几乎所有类型的编程需求，质量各异。

Python 是用编程语言 C 编写的。为了各种技术原因，Python 有一些用其他语言编写的变体，但大多数 Python 实现都是建立在 C 之上的。这意味着 Python 通常通过构建在 C 代码之上的模块来扩展，通常是为了提高速度。一个 Python 代码“层”或“包装器”被放置在 C 代码之上，使其能够与普通的 Python 包兼容，从而获得 Python 的简洁性和预编译 C 代码带来的处理速度提升。NumPy 和 SciPy 就是这种模块的例子，并且它们随 ArcGIS 安装的 Python 一同提供。

Python 是免费的开源软件，这也是它被打包到许多其他软件应用程序中用于自动化目的的原因之一。Python 也可以单独安装，通过 Python 软件基金会提供的免费安装程序。

在互联网上查看 Python 软件基金会：www.python.org/psf

从 PSF 直接下载 Python 版本：www.python.org/downloads/

它安装在哪里？

在 Windows 机器上，Python 默认不包含——它必须与 ArcGIS 一起安装，或者通过 Python 软件基金会的安装程序单独安装。运行 ArcGIS 安装程序后，你将在 C:\ drive 下看到一个文件夹。你可以设置自定义位置或使用默认位置。

Python 解释器

当你通过双击 python.exe 启动它时（下面将介绍多种其他运行可执行文件的方法），它将启动所谓的 Python 解释器。

这是一个有用的接口，允许你一次输入一行代码进行测试和确认。输入完一行后，按 Enter/Return 键，代码将被执行。这个工具帮助你在同一个环境中学习编码和测试代码。

启动解释器

双击文件夹中的 python.exe 或从开始菜单启动 Python（命令行），将启动解释器，允许执行单行命令：

Python 3 非常相似：

什么是 Python 脚本？

python.exe 可执行文件不仅是一个可以运行代码的程序，还可以执行 Python 脚本。这些脚本是可以由任何文本编辑软件编辑的简单文本文件。Python 脚本的文件扩展名为 .py。

当“运行”一个 Python 脚本时，它会作为第一个命令行参数传递给 Python 可执行文件（python.exe）。此程序将从上到下读取并执行代码，只要它是有效的 Python 代码并且没有错误。如果遇到错误，脚本将停止并返回错误信息。如果没有错误，除非你添加了“print”语句来在脚本运行时从主循环返回消息，否则不会返回任何内容。

在这个例子中，脚本通过“传递”脚本作为参数给可执行文件（python.exe）执行，且明确使用完整的文件夹路径调用 python.exe 文件，以避免路径问题：

C:\Projects>C:\PythonArcGIS\ArcGIS10.5\python.exe chapter1.py

在这个例子中，脚本通过“传递”脚本作为参数给可执行文件执行，并可选择接受脚本本身在运行前的可选参数：

C:\Projects>C:\PythonArcGIS\ArcGIS10.5\python.exe chapter1.py arg1 arg2

包含的版本

Python 附带了两个版本的 python.exe 文件。为了澄清，它们是相同版本的 Python，但每个文件的角色不同。python.exe 是主文件，另一个版本是 pythonw.exe。双击 pythonw.exe 不会启动解释器，这与正常的 python.exe 不同。pythonw.exe 没有解释器，它的作用是以比 python.exe 更“安静”的方式执行脚本。要启动解释器，请使用 python.exe。

如何调用可执行文件

访问 Python “可执行文件” (python.exe) 以运行 Python 解释器或运行自定义 Python 脚本。启动 Python 可执行文件有许多不同的方法：

  • 双击 python.exe

    • 启动 Python 解释器

  • 打开 IDLE，随附的集成开发环境（IDE）

    • 在 Windows 中的 ArcGIS 文件夹内，你应该能在开始菜单找到它。

  • 打开 CMD 终端并键入“python”

    • 只有当 Python 可执行文件位于 PATH 环境变量中时才有效

  • 使用第三方 IDE，如 PyCharm

    • 每个 PyCharm 项目可以有自己的虚拟环境，因此也有自己的可执行文件，或者它可以使用 Esri 在安装 ArcGIS 时安装的那个。

    • 有很多 IDE，但我推荐 PyCharm，原因有很多。

  • 使用 Jupyter Notebook，本书中将对此进行详细讨论。

    • 这需要安装 Jupyter，而 Jupyter 并不包含在标准 Python 安装包中。

  • 在 ArcGIS Desktop 或 ArcGIS Pro 内部

    • 有一些菜单按钮可以让你在 ArcMap、ArcCatalog 或 ArcGIS Pro 内部启动 Python 解释器窗口。

    • 一行一行地运行代码，或通过右键菜单中的加载脚本命令运行代码。

IDLE 开发环境

随附的 IDE，称为 IDLE，是一个有用的环境，标准配置每个 Python 实例时都会包含它。IDLE 对于 Python 解释器很有用，但也因为你可以通过从文件菜单打开新脚本，然后使用脚本的运行菜单来轻松创建和执行脚本。

Path 环境变量

在 Windows 上，有一个系统环境变量被称为 Windows Path 环境变量。这个变量对机器上安装的所有应用程序可用。其他程序将其用于不同的目的，但对 Python 来说，它用于查找所有可用的 Python 可执行文件和模块。

理解这一点很重要，因为你有可能在电脑上安装多个 Python 版本，或者只安装一次 ArcGIS Desktop 或 ArcGIS Pro 后便会出现多个版本。

如果在 CMD 窗口中使用 "python script.py" 命令运行脚本（将脚本作为参数传递给 Python），并且脚本中包含导入语句，那么有三件事必须发生。

首先，Windows 会在 Path 中查找名为 python.exe 的可执行文件。如果找到了，它会确认脚本是否有效。如果有效，Python 会运行该脚本，并且会检查 Path 环境变量，以查找允许导入所有模块的路径。

所以，Python 可执行文件不能仅通过名称运行（而不是文件位置），直到python.exe被添加到 Path 中。以下是如何编辑 Path 变量：

打开控制面板中的高级系统设置：

定位并双击 Path 变量（或者在选中时按编辑）：

在界面中为 Path 环境变量添加新的一行。如果你有多个版本的 Python，并且没有使用虚拟环境，确保按正确的顺序排列 Path 中的文件夹，这样当你在 CMD 窗口中输入“python”时，会调用正确版本的 Python：

如果你没有权限编辑 Path 变量，仍然可以通过使用可执行文件的完整路径来在命令行中运行 Python：C:\ArcGIS10.8\Python\python.exe script.py

操作系统和 Python 系统模块

需要首先提到两个内置的模块（代码库）。os模块和sys模块，也称为操作系统模块（os）和 Python 系统模块（sys），分别用于控制 Windows 系统操作和 Python 系统操作。

OS 模块

os模块用于许多操作，包括文件夹路径操作，如创建文件夹、删除文件夹、检查文件夹或文件是否存在，或者使用操作系统关联的应用程序来执行文件扩展名相关的文件。获取当前目录、复制文件等操作也可以通过这个模块实现。

在这个例子中，一个字符串被传递给os.path.exists方法，该方法返回布尔值。如果返回 False，表示文件夹不存在，然后使用os.mkdir方法创建该文件夹：

import os
folderpath = "C:\Test_folder"
if not os.path.exists(folderpath):
   os.mkdir(folderpath)

了解 os 模块的更多信息，请访问：www.geeksforgeeks.org/os-module-python-examples/

sys 模块接受参数

sys 模块允许你在脚本运行时接受参数，也就是说，在脚本执行时。可以通过使用sys.argv方法来实现，该方法是一个列表，包含了在执行脚本时传递给 Python 的所有参数。

If a name variable is using the sys module to accept parameters, here is what the script looks like:
import sys
name = sys.argv[1]
print(name)

系统路径

sys 模块包含 Python 路径或系统路径（这里的系统指的是 Python）。这是一个列表，Python 用它来在访问 Windows 路径后查找可导入的模块。如果你无法像上面解释的那样编辑 Windows 路径（通常是由于权限问题），你可以在运行时通过系统路径修改 Python 路径。

sys.path列表是 Python 内置的sys模块的一部分：

了解更多关于 sys 模块的信息，请访问：www.geeksforgeeks.org/python-sys-module/

编程基础

计算机编程在不同语言的实现方式上各不相同，但这些语言在其内部逻辑如何工作的方面有显著的相似之处。这些编程基础适用于所有编程语言，具体的代码实现以 Python 为例。

关键概念
变量 分配给 Python 任何数据类型对象的名称。变量名必须以字母开头。推荐使用下划线。 
x=0
y=1
xy = x+y
xy_str = str(xy)

|

迭代 For 循环用于遍历可迭代数据对象（例如列表）。While 循环用于在满足条件之前不断循环。 
for item in datalist:
    print(item)
x=0
while x < 1:
    x+=1

|

条件语句 If/Elif/Else 语句用于判断一个对象是否满足某个条件。 
list_var = [1,’1’,1.0]
for item in list_var:
  if type(item) == type(0):
    print(‘Integer’)
  elif type(item) == type(‘a’):
    print(‘String’)
  else:
    print(‘Float’)

|

从零开始的索引 数据容器通过从 0 开始的索引来访问。索引通过方括号[]传递给列表或元组。字符串字符也可以使用相同的模式访问。 
list_var = [‘s’,’m’,’t’]
m_var = list_var[0]

name_var = “logan”
g_var = name_var[0]

|

数据类型 字符串用于文本。整数用于整数。浮动数用于浮动点数字。数据容器，如列表、元组和字典，广泛用于组织数据。 
Str_var = “string”
int_var = 4
float_var = 5.7
list_var = [45,43,24]
tuple_var = (87.’a’,34)
dict_var = {‘key’:’value’}

|

代码注释 在代码中使用注释是受到鼓励的。注释有助于向其他读者和自己解释你的思路。注释通过使用“#”符号创建。注释可以单独占一行，也可以添加在语句的末尾，因为#符号后面的内容会被忽略。 
# This is a comment
x = 0 #also a comment

|

错误 Python 内置了许多类型的错误信息。错误追踪会显示受影响的代码行和错误类型。它并不完美。 
>>> str_var = 'red"
  File "<stdin>", line 1
    str_var = 'red"
                  ^
SyntaxError: EOL while scanning string literal

|

计数器/枚举器 使用变量跟踪 for 循环或 while 循环执行的次数是一个好主意。一些语言（包括 Python）具有一些内置的枚举功能。计数器在增加后会重新赋值给自己。在 Python 中，快捷方式“x += y”与“x = x + y”是等价的。 
counter = 0
list_var = [34,54,23,54]
for item in list_var:
    print(item, counter)
    counter += 1

|

变量

变量用于将对象分配给标签或标识符。它们用于跟踪数据片段、组织数据在脚本中的流动，并帮助程序员阅读脚本。

variable = 1 # a variable assignment

我建议（由我）使用描述性的变量，既不太长也不太短。当变量名太短时，阅读时可能会产生混淆。当变量名太长时，写起来可能会令人困惑。在变量中使用下划线分隔单词是一种常见的做法。

赋值与等于（值比较）

在 Python 中，变量通过等号“=”赋值给对象。这意味着还有另一种方法可以检查一个值是否等于另一个值：使用双等号“==”。

variable = 1 # a variable assignment
variable == 1 # a comparison (that is True)
变量格式化规则

变量必须以字母开头，不能以数字或其他符号开头，否则会发生语法错误。不过，数字和下划线可以用在变量名中。

>>> 2var = 34
  File "<stdin>", line 1
    2var = 34
     ^
SyntaxError: invalid syntax
>>> two_var = 34
>>> two_var
34

阅读更多关于变量的内容：realpython.com/python-variables/

迭代

计算机编程的核心是迭代：递归地执行相同的操作、分析、函数调用或你所编写脚本要处理的任何任务。计算机擅长这种类型的任务：它们可以快速遍历数据集，在数据集中的每个数据项上执行你认为必要的操作。

for 循环

“for 循环”是一种迭代实现方式，当提供数据列表时，它会对列表中的每个成员执行某个操作。

在这个例子中，一个整数列表被赋值给变量名 data_list。然后，使用格式“for {var} in {iterable}”构建一个 for 循环，其中 {var} 是一个变量名，它会被分配给列表中的每个对象，随着循环的进行，逐一处理。一个常见的约定是使用“item”，但它可以是任何有效的变量：

data_list = [45,56,34,12,2]
for item in data_list:
    print (item * 2)
90
112
68
24
4

while 循环

“while 循环”是一种迭代实现方式，直到满足特定条件时才会停止。while 循环可能会很危险，因为如果条件永远不满足，它会导致脚本进入无限循环。

在这个例子中，while 循环将执行（除了将 1 加到 x 上直到它达到 100，达到阈值时 while 循环结束）。

x = 0
while x < 100:
    x = x + 1   #same as x += 1

阅读更多关于循环的内容：www.geeksforgeeks.org/loops-in-python/

计数器和枚举器

在 for 循环或 while 循环中的迭代通常需要使用计数器（也称为枚举器）来跟踪循环的迭代次数。

for 循环可以通过将迭代器传递给 enumerate 函数并在项目变量前面使用一个计数变量（可以是任何有效的变量名，但 count 是一个逻辑选择）来使用该函数。计数变量会跟踪循环，从索引零开始：

>>> data_list = ['a','b','c','d','e']
>>> for count,item in enumerate(data_list):
...     print(count, item)
... 
0 a
1 b
2 c
3 d
4 e

在 Python 中，快捷方式“x += y”用于增加 x 的值，同时保持相同的变量名，这与“x = x + y”是等效的：

>>> x = 0
>>> while x <100:
...    x = x + 1
>>> x
100
>>> x = 0
>>> while x <100:
...    x += 1
>>> x
100

条件语句

if 语句、elif 语句（即 else if 的缩写）和 else 语句用于创建条件，用来评估数据对象。if 语句可以单独使用（elif 和 else 是可选的），通过声明 if 关键字，然后写出数据必须满足的条件：

list_var = [1,’1’,1.0]
for item in list_var:
  if type(item) == type(0):
    print(‘Integer’)
  elif type(item) == type(‘a’):
    print(‘String’)
  else:
    print(‘Float’)

阅读更多关于条件语句的内容：realpython.com/python-conditional-statements/

if 与 else

If 语句通常特定于一个条件，而 Else 语句作为“兜底”语句，确保任何通过 If 语句的数据都有某种方式被处理，即使它不满足 If 语句的条件。Elif 语句依赖于 If 语句的存在，并且也是条件特定的，不是兜底语句。

列表位置（或者为什么程序员从 0 开始计数）

迭代发生在包含数据的列表上。在列表中，这些数据通过列表顺序或位置来区分。列表中的项目是通过项目索引来获取的，即数据在列表中的（当前）位置。

从零开始的索引

在 Python 中，与大多数计算机编程语言一样，列表中的第一个项位于索引 0，而不是索引 1。

这对初学者来说有点混淆，但这是编程的标准。检索从 0 开始的列表中的项比从 1 开始的列表更高效，且这种标准在 C 语言及其前身中形成，这也意味着 Python（用 C 编写）使用零索引。

使用索引位置提取数据

这是从列表中检索数据的基本格式。这个字符串列表有一个顺序，其中字符串“Bill”是第二个元素，意味着它位于索引 1。要将这个字符串赋值给变量，我们将索引传递给方括号：

names = [“Silas”, “Bill”, ”Dara”]
name_bill = names[1]
使用反向索引位置提取数据

这是从列表中提取数据的第二种格式。可以反向使用列表顺序，意味着索引从列表的最后一个成员开始，向后计数。使用负数来表示，从 -1 开始，这是列表最后一个成员的索引，-2 是倒数第二个成员的索引，依此类推。这意味着在使用反向索引位置时，“Bill”字符串位于索引 -2，因此必须将 -2 传递给列表的方括号：

names = [“Silas”, “Bill”, ”Dara”]
name_bill = names[-2]

在这里阅读更多关于索引的内容：realpython.com/lessons/indexing-and-slicing/

数据类型

变量的数据类型决定了它的行为。例如，字符 5 可以是整数类型（5）、浮点类型（5.0）或字符串类型（“5”）。每种版本的 5 都有不同的可用工具，比如字符串的 replace 方法，可以将字符串中的字符替换为其他字符。

关键数据类型
数据类型 Python 数据类型对象
文本数据以字符串数据类型存储 str
数字数据以整数、浮点数或复数类型存储 int , float , complex
序列数据（列表或数组）可以存储为列表或元组。Range 是一种特殊的生成器 list , tuple , range
映射或键值对数据类型也被称为字典类型 dict
集合是一种包含唯一、不变对象的数据类型 set , frozenset
布尔值是 True 或 False，1 或 0 bool
二进制数据类型用于以二进制模式访问数据文件。 bytes， bytearray， memoryview

检查数据类型

要检查 Python 变量的数据类型，请使用type()函数：

>>> x = 0
>>> type(x)
<class ‘int’>

字符串

所有文本数据在 Python 中都表示为 String 数据类型。这些称为字符串。常见的存储为字符串的数据包括姓名、地址，甚至整篇博客文章。

字符串也可以在代码中进行模板化，以允许“填空”的字符串，直到脚本运行时才设定。字符串技术上是不可变的，但可以使用 Python 内置的字符串工具和独立的 String 模块进行操作。

关键概念
引号 单引号或双引号都可以用来表示字符串，只要开头和结尾的引号一致。三重引号用于多行字符串。在字符串内部的引号可以使用与开头和结尾不同的引号表示。
字符串相加 字符串可以“相加”在一起形成更大的字符串。字符串也可以通过一个整数“乘法”来重复字符串 X 次。
字符串格式化 可以在代码中使用字符串模板或占位符，并在运行时用所需的数据填充。
字符串操作 可以使用内置功能对字符串进行操作。可以替换或定位字符。可以分割或连接字符串。
引号

字符串必须被引号包围。在 Python 中，这些引号可以是单引号或双引号，但必须一致。如果单引号用于开始字符串，那么单引号也必须用于结束字符串：

>>> string_var = 'the red fox"
  File "<stdin>", line 1
    string_var = 'the red fox"
                             ^
SyntaxError: EOL while scanning string literal
>>> string_var = 'the red fox'
>>> string_var
'the red fox'
多行字符串

多行字符串通过在字符串开头和结尾分别配对三个单引号或双引号来创建。

在这个例子中，变量string_var是一个多行字符串（“\n”是一个代表新行的 Python 字符）：

>>> string_var = """the red fox chased the
... dog across the yard"""
>>> string_var
'the red fox chased the\ndog across the yard'
字符串相加（及更多）

字符串可以“相加”在一起，创建一个新的字符串。这个过程允许你从小字符串构建字符串，这对于填充数据文件中的其他字段组成的新字段或其他任务非常有用。

在这个例子中，字符串“forest”被赋值给string_var。然后，另一个字符串被添加到 string_var 中，创建一个更长的字符串。

>>> string_var = "forest"
>>> string_var += " path" #same as string_var = string_var+ “ path”
>>> string_var
'forest path'
字符串格式化

代码中的字符串经常使用“占位符”来表示稍后将填充的数据。这被称为字符串格式化，并且有多种方式可以使用 Python 执行字符串格式化。

关键概念
格式化函数 所有字符串都有一个内置的函数叫做 format，允许传入参数。它接受所有数据类型，并根据模板格式化字符串。
字符串字面量 对于 Python 3.6+，有一个新的工具叫做字符串字面量，它允许你直接在字符串中插入变量。在字符串前面加上一个“f”。
数据类型字符串操作符 一个较旧但仍然有用的工具是字符串操作符，它们在字符串中作为占位符，用于表示特定的数据类型（可以是字符串、浮动点数或整数）。

字符串格式化函数

这种格式化方法是 Python 3 推荐的形式（在 Python 2.7 中也可用）。它允许你将变量传递给format函数（该函数内建于所有字符串中），并让它们填充字符串中的占位符。任何数据类型都可以传递给format函数。

在这个例子中，字符串模板通过format字符串函数填充了其他变量中的详细信息。占位符按照变量列出的顺序进行填充，因此它们必须按照正确的顺序排列。大括号是占位符，format函数将接受参数并填充字符串：

>>> year = 1980
>>> day = "Monday"
>>> month = "Feb"
>>> template = "It was a cold {} in {} {}"
>>> template.format(day, month, year)
'It was a cold Monday in Feb 1980'

在这个例子中，占位符已命名，并以关键字参数的格式传递给format函数。参数是命名的，因此在format函数中不需要按照顺序排列：

>>> template = 'It was a cold {day} in {month} {year}'
>>> template.format(month=month,year=year,day=day)
'It was a cold Monday in Feb 1980'

在这个例子中，占位符是按编号排列的，这使得重复字符串变得更容易：

>>> template = "{0},{0} oh no,{1} gotta go"
>>> template.format("Louie", "Me")
'Louie,Louie oh no,Me gotta go'
字符串字面量

Python 3.6（及更高版本）新增了一种字符串格式化方法，称为格式化字符串字面量。通过在字符串前加上“f”，占位符变量可以通过变量来填充，而无需使用format函数。

在这个例子中，变量直接格式化到字符串字面量中，字符串前加上“f”以表示它是一个字符串字面量：

>>> year = 1980
>>> day = "Monday"
>>> month = "Feb"
>>> str_lit = f"It was a cold {day} in {month} {year}"
>>> str_lit
'It was a cold Monday in Feb 1980'

了解更多关于字符串格式化的信息，请访问：realpython.com/python-string-formatting/

字符串操作

字符串操作是常见的，许多工具已内建于字符串数据类型中。它们允许你替换字符串中的字符或查找字符在字符串中的索引位置。

find 和 index 是类似的方法，但 find 可以用于条件语句。如果字符串中找不到字符，find 将返回-1，而 index 将返回错误。

join 方法用于将一个字符串数据列表连接在一起。split 方法是其反向操作：它根据提供的字符或默认的空格将一个字符串分割成一个列表。

方法 示例
join 
string_list = [‘101 N Main St’,’Eureka’,’Illinois 60133’]
address = ‘, ’.join(string_list)

|

replace 
address = ‘101 N Main St’.replace(“St”,”Street”)

|

find, rfind 
str_var = ‘rare’
str_index = str_var.find(‘a’) #index 1
str_index = str_var.find(‘r’) #index 0
str_index = str_var.rfind(‘r’) #index 2

|

upper, lower, title 
name = “Laura”
name_upper = name.upper()
name_lower = name.lower()
name_title = name_lower.title()

|

index, rindex 
str_var = ‘rare’
str_index = str_var.index(‘a’) #index 1
str_index = str_var.index(‘r’) #index 0
str_index = str_var.rindex(‘r’) #index 2
str_var.index(‘t’) #this will cause an error

|

split 
latitude,longitude = “45.123,-95.321”.split(“,”)
address_split = ‘101 N Main St’.split()

|

字符串索引

字符串索引类似于列表索引，如上所述。可以通过将需要的字符的索引传递给字符串并用方括号括起来，从字符串中选择单个字符或字符组。

在这个例子中，字符串“readiness”中的“d”是通过将索引[3]传递给字符串旁的方括号来访问的：

>>> str_var = "readiness"
>>> d_var = str_var[3]
>>> d_var 
'd'

通过传递起始和结束索引，可以选择一组字符，其中结束索引是你不想包含的第一个字符的索引：

>>> str_var = "readiness"
>>> din_var = str_var[3:6]. #index 6 is e
>>> din_var
'din'
>>> dine_var = str_var[3:7]. #index 7 is s
>>> dine_var
'dine'

整数

整数数据类型表示整数。它可以用于执行加法、减法、乘法和除法（但有一个需要注意的例外，见下文）。

>>> int_var = 50
>>> int_var * 5
250
>>> int_var / 5
10.0
>>> int_var ** 2
2500
将字符串转换为整数

要将字符串（或浮点数）转换为整数，请使用int函数：

>>> x = '0'
>>> y = int(x)
>>> y
0
>>> type(y)
<type 'int'>
>>> type(x)
<type 'str'>
Python 2 中的整数运算问题

Python 2 中一个著名且有意为之的设计问题是整数除法问题。这意味着，使用整数进行除法运算时，结果通常会是没有余数的（通常是）不希望看到的结果。建议在进行除法操作前将整数转换为浮点数。

这是该问题的一个示例：

Python 2.7.16 (default, Dec 21 2020, 23:00:36) 
>>> 5/3
1

这个问题在 Python 3 中已被修复：

Python 3.8.2 (default, Apr  8 2021, 23:19:18) 
>>> 5/3
1.6666666666666667

了解更多关于 Python 中整数的内容，请访问：realpython.com/python-numbers/

浮动数字

在 Python 中，浮点数用于表示实数，作为 64 位双精度值。有时使用二进制系统表示基于十进制的数字可能有些奇怪，所以需要留意，但通常它们会按预期工作。

>>> x = 5.0
>>> x * 5
25.0
>>> x ** 5
3125.0
>>> x/2.3
2.173913043478261
将字符串转换为浮点数

要将字符串（或整数）转换为浮点数，请使用float函数：

>>> x = '5'
>>> y = float(x)
>>> type(y)
<type 'float'>

了解更多关于 Python 中浮点数的信息，请访问：www.geeksforgeeks.org/python-float-type-and-its-methods

数据类型之间的转换

在 Python 中，数据类型之间的转换是可能的，使用标准库中的内置函数。首先，type函数对查找对象的数据类型很有帮助。一旦确定了数据类型，数据对象可以从整数（int函数）转换为字符串（str函数）再到浮点数（float函数），只要该字符在该数据类型中是有效的。

在这些示例中，使用int、str和float函数将字符从字符串转换为整数、浮点数再转换回字符串：

>>> str_var = "5"
>>> int_var = int(str_var)
>>> int_var
5
>>> float_var = float(int_var)
>>> float_var
5.0
>>> str_var = str(float_var)
>>> type(str_var)
'<class 'str'>'

数据结构或容器

数据结构，也称为数据容器和数据集合，是可以按可检索顺序存储任何数据项的特殊数据类型，这些数据项可以是任何数据类型（包括其他数据容器）。数据容器用于通过索引（在元组或列表中）或键值对（在字典中）组织数据项。

l 从数据容器中检索数据

要从数据容器中提取数据，可以使用方括号来传递索引（列表和元组）或键（字典）。如果有多个级别的数据容器（即一个容器包含另一个容器），首先使用第一个方括号中的索引或键来引用内部的数据容器，然后使用第二个方括号来访问容器中的数据。

数据容器 示例
元组 
tuple_var = (“blue”, 32,[5,7,2],’plod’,{‘name’:’magnus’})
plod_var = tuple_var[-2]
magnus_var = tuple_var[-1][‘name’]

|

列表 
list_var = [‘fast’,’times’,89,4.5,(3,8),{‘we’:’believe’}]
times_var = list_var[1]

|

字典 
dict_var = list_var[-1]
believe_var = list_var[-1][‘we’]

|

元组

元组是有序的列表，可以存放任何类型的数据，甚至是同一元组中不同类型的数据。元组是不可变的，这意味着它们不能被修改，并且一旦创建，数据不能添加或删除。元组有长度，可以使用内置的 len 函数获取元组的长度。

在 Python 中，元组是通过使用圆括号 () 或 tuple 函数来声明的。数据通过零基索引访问，方法是将索引传递给紧邻元组的方括号。

在这个例子中，一个元组被赋值给变量名 tuple_var，并通过索引访问数据：

>>> tuple_var = ("red",45,"left")
>>> type(tuple_var)
<class 'tuple'>
>>> ("red",45,"left")[0]
'red'
>>> tuple_var[0]
'red'

阅读更多关于元组的信息，点击这里：www.geeksforgeeks.org/python-tuples/

列表

列表（在其他编程语言中通常称为数组）是数据容器，可以存放任何类型的数据，甚至可以在同一个列表中存放不同类型的数据，这意味着它们不必只有一种数据类型。列表在创建后可以被修改。在 Python 中，可以通过使用方括号 [] 或 list 函数来声明列表。数据通过零基索引访问，方法是将索引传递给紧邻列表的方括号。

在这个例子中，一个列表被赋值给变量名 list_var，并通过索引访问数据：

>>> list_var = ["blue",42,"right"]
>>> type(list_var)
<class 'list'>
>>> ["blue",42,"right"][0]
'blue'
>>> list_var[0]
'blue'

阅读更多关于列表的信息，点击这里：www.geeksforgeeks.org/python-list/

在列表和元组之间转换

列表可以通过使用 tuple 函数复制到一个新的元组对象中。反过来，元组可以通过 list 函数复制到一个列表数据类型中。从技术上讲，这并没有转换原始数据项，而是创建了数据项在新数据类型中的副本。

在这个例子中，列表被复制到一个元组数据类型中，然后元组被复制到一个列表数据类型中。注意，每创建一个新数据类型，方括号会发生变化：

 >>> tuple_copy = tuple(list_var)
>>> tuple_copy
('blue', 42, 'right', 'ankle')
>>> list_copy = list(tuple_copy)
>>> list_copy
['blue', 42, 'right', 'ankle']
列表和元组的操作

列表和元组都可以通过 for 循环进行迭代。它们也可以被“切片”，从而创建列表或元组的一个子集，该子集将用于 for 循环或其他操作。

切片

对列表或元组进行切片会创建一个新的列表或元组。切片是通过将索引传递给列表或元组，方括号中用冒号分隔的方式创建的。第一个索引是起始索引，如果是索引 0（即原始列表的开始），可以忽略不写。第二个索引是你不想包含的第一个值的索引（如果是原始列表的其余部分，可以为空）。

In this example we see a tuple with three data items sliced to only include the first two items. The string “left” is at index 2 in the tuple, meaning that the last index in the slice will be 2\. The slice is assigned to variable name tuple_slice: 
>>> tuple_var = ("red",45,"left")
>>> tuple_slice = tuple_var[:2]
>>> tuple_slice
('red', 45)

在这个例子中，我们看到一个包含四个数据项的列表，通过切片操作仅包含最后两个项。第一个索引是我们想要的第一个数据项的索引（字符串 "right"）。最后一个索引为空：

>>> list_var = ["blue",42,"right","ankle"]
>>> list_slice = list_var[2:]
>>> list_slice
['right', 'ankle']
仅限列表的操作

列表可以通过 append 方法添加单个数据项，或者通过 extend 方法扩展（将一个列表或元组中的所有数据项添加到主列表）。列表顺序可以被反转或排序。内建函数允许计算列表的最大值或最小值，甚至是列表的总和（前提是列表中数据项的类型正确）。

集合

集合表示一组独特的对象。在 Python 中，集合是无序的，不允许重复，并且集合中的所有数据项必须是不可变的。

集合操作

集合特别适用于获取列表中所有不同的成员。它们不能通过索引访问（因为是无序的），但是可以进行迭代：

>>> orig_list = ["blue","pink","yellow","red","blue","yellow" ]
>>> set_var = set(orig_list)
>>> set_var
{'pink', 'yellow', 'blue', 'red'}
>>> set_var[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object is not subscriptable
>>> for item in set_var:
...     print(item)
... 
pink
yellow
blue
red

字典

字典是键值对存储，意味着它们是使用无序的键值对来组织数据的数据容器。键被用作组织和检索的参考点。当通过方括号提供键时，会返回对应的值。

>>> dict_var = {"key":"value"}
>>> dict_var['key']
'value'
>>> dict_var = {"address":"123 Main St", "color":"blue"}
>>> dict_var["address"]
'123 Main St'
>>> dict_var["color"]
'blue'

在 Python 中阅读更多关于字典的内容：www.geeksforgeeks.org/python-dictionary/

键和值

键可以是任何不可变的数据类型（这意味着列表不能用作键，但字符串、整数、浮点数和元组可以用作键）。值可以是任何类型的数据，包括其他字典。

可以使用字典的 keys 函数将字典中的所有键作为列表进行访问。在 Python 2.x 中，这是一个列表；在 Python 3.x 中，这是一个生成器。

可以使用字典的 values 函数将字典中的所有值作为列表进行访问。在 Python 2.x 中，这是一个列表；在 Python 3.x 中，这是一个生成器。

函数

函数是由代码定义的子程序。当“调用”或运行时，函数会执行某些操作（如果写成这样的话，也可以什么都不做）。函数通常接受参数，且这些参数可以是必需的或可选的。

函数使得反复执行相同的操作变得容易，而无需反复编写相同的代码。这使得代码更加简洁、短小且智能。它们是一个好主意，应该经常使用。

在这里阅读更多关于函数的内容：realpython.com/defining-your-own-python-function/

def 关键字

函数使用 def 关键字定义，def 是“定义函数”的缩写。编写该关键字后，紧接着是函数名和圆括号 ()，其中可以定义期望的参数。

返回语句

函数允许通过 return 语句将数据从子程序返回到主循环。这些语句使得用户可以在函数中计算一个值或执行某些操作，然后将该值返回给主循环。

参数

参数或论据是函数期望的值，并由代码在运行时提供。

命名空间

在 Python 中，有一个叫做命名空间的概念。这些命名空间细分为两种类型：全局命名空间和局部命名空间。

脚本的主部分（函数外）中定义的所有变量都被认为是在全局命名空间中。在函数内部，变量有不同的“命名空间”，这意味着函数内部的变量位于局部 命名空间中，它们与主脚本中的全局变量不同。如果函数内的变量名与函数外的变量名相同，改变函数内的值（在局部命名空间中）不会影响函数外的变量（在全局命名空间中）。

函数示例

在这个示例中，定义了一个函数，每次调用时返回“hello world”。没有参数，但使用了return关键字：

def new_function():
    return "hello world"

在这个示例中，一个预期的参数在括号中定义。调用时，提供该值，函数会将局部命名空间中的值返回到主循环中的全局命名空间：

def accept_param(value):
    return value

在这个示例中，一个预期的参数有一个默认值，这意味着只有在函数使用非默认参数时才需要提供该参数：

def accept_param(value=12):
    return value
文档字符串

函数允许在定义行后添加一个字符串，用于声明该函数的用途，以便于文档化。

def accept_param(value=12):
    'this function accepts a parameter if different from default'
    return value

类

类是组织多个变量和函数的特殊代码块，它们将这些内容整合成一个具有自身方法和函数的对象。类使得创建可以引用相同内部数据列表和函数的代码工具变得容易。类内部的函数和变量可以相互通信，从而使得在类的某一部分定义的变量可以在另一部分中使用。

类使用“self”这一概念来允许类的不同部分进行通信。通过将 self 作为参数引入类中的每个函数，数据可以被调用。

类是通过“实例化”来创建类对象的。这意味着类定义有点像该类的工厂，当你需要其中一个类对象时，你调用类类型并传递正确的参数（如果需要）。

class Object():
    def __init__(self, name):
        'accepts a string'
        self.name = name
    def get_name(self):
        'return the name'
        return self.get_name

阅读更多关于类的信息：www.geeksforgeeks.org/python-classes-and-objects/

安装和导入模块

为了扩展内置标准 Python 库的功能，Python 被设计成可扩展的。第三方模块通常以某种格式从提供者（通常是 PyPI，即 Python 包索引，大部分模块都托管在此）下载，使用内置的pip程序或其他方法。像arcpy和 ArcGIS Python API 这样的模块就是很好的例子：它们扩展了 Python 的功能，使得可以控制 ArcGIS Desktop 或 Pro 中可用的工具。

使用 pip

为了简化 Python 模块的安装，现在 Python 附带了一个名为 pip 的程序。这个名字是一个递归首字母缩写，代表 Pip Installs Programs。它通过允许一行命令同时定位请求的模块并执行安装命令，简化了安装过程。

pip 连接到 Python 包索引（或 PyPI）。在这个仓库中存储了由其他开发者编写的成千上万的免费模块。值得检查模块的许可证，确认它是否允许你使用其代码。

pip 位于 Scripts 文件夹中，那里存放着许多可执行文件：

安装模块

我们将介绍

setup.py 文件

在 Python 2.x 及有时在 Python 3.x 中，一个模块通常会包含一个 “setup.py” 文件。这个文件不是由 pip 运行的，而是由 Python 本身运行。

通常，一个模块会有一个可下载的 zip 文件，该文件应复制到 /sites/packages 文件夹中。然后解压缩，并使用 Python 可执行文件运行 setup.py 文件，通过 install 命令进行安装：python setup.py install

在虚拟环境中安装

虚拟环境刚开始可能是一个有点奇怪的概念，但在 Python 编程中非常有用。因为如果你安装了 ArcGIS Desktop 和 ArcGIS Pro，可能会有两个不同的 Python 版本在你的电脑上，因此将这些版本放在虚拟环境中会非常方便。

核心思路是使用 Python 虚拟环境模块中的一个，创建你所需的 Python 版本副本，然后将其与机器上其他 Python 版本隔离。这避免了在调用模块时出现路径问题，允许你在同一台计算机上拥有多个版本的这些重要模块。

以下是一些 Python 虚拟环境模块：

名称 描述 示例虚拟环境创建
venv 内置于 Python 3.3+ python3 -m venv
virtualenv 必须单独安装。它非常有用，也是我个人最喜欢的。 
virtualenv namenv --python=python3.6

|

pyenv 用于隔离 Python 版本以进行测试。必须单独安装。 
pyenv install 3.7.7

|

Conda /Anaconda 在学术和科研环境中使用频繁。必须单独安装。 
conda create --name snakes python=3.9

|

了解更多关于虚拟环境的内容，请访问：towardsdatascience.com/python-environment-101-1d68bda3094d

导入模块

为了访问 Python 标准库中的大量模块，以及第三方模块，如 arcpy，我们需要能够在脚本（或解释器）中导入这些模块。

为此，你将使用导入语句。这些语句声明你将在脚本中使用的模块或子模块（模块的较小组成部分），只要这些模块在你安装的 Python 的/sites/packages文件夹中，或者在 PATH 中（就像arcpy在安装后一样）。

import csv
from datetime import timedelta
from arcpy import da.SearchCursor

导入模块的三种方式

有三种不同且相关的方式可以导入模块。这些模块，无论是来自标准库还是第三方库，在脚本中的导入方式都是相同的。

方法 1：导入整个模块

这是导入模块的最简单方式，通过导入它的顶级对象。其子方法通过点符号访问（例如csv.Reader，一个用于读取 CSV 文件的方法）：

import csv
reader = csv.Reader
方法 2：导入子模块

你可以使用“from X import Y”的格式，只导入你需要的模块或方法，而不是导入顶级对象：

from datetime import timedelta
from arcpy import da.SearchCursor
方法 3：导入所有子模块

你可以使用“from X import *”的格式导入所有模块或方法，而不是只导入一个子对象：

from datetime import *
from arcpy import *

阅读更多关于导入模块的内容：realpython.com/python-import/

导入自定义代码

模块不一定只是来自“第三方”：它们也可以来自你自己。通过使用特殊的__init__.py文件，你可以将普通文件夹转换为可导入的模块

__init__.py 文件

这个特殊的文件可以包含代码，但通常只是一个空文件，它告诉 Python 一个文件夹是一个可以导入到脚本中的模块。该文件本身只是一个带有.py扩展名的文本文件，名为__init__.py（两边各有两个下划线），并放置在文件夹内。只要包含__init__.py的文件夹位于脚本旁边或在 Python 路径中（例如在 site-packages 文件夹中），文件夹中的代码就可以被导入。

示例自定义模块

在此示例中，我们看到在名为example_module.py的脚本中的一些代码：

import csv
from datetime import timedelta
print('script imported')

创建一个名为mod_test的文件夹。将此脚本复制到该文件夹中。然后，创建一个名为__init__.py的空文本文件：

导入你的模块

在mod_test文件夹旁边创建一个新脚本，命名为“module_import.py”：

在脚本内，你将使用下面的格式从mod_test文件夹中的example_module脚本中导入“test_function”函数：

模块内的脚本可以通过点符号访问（例如mod_test.example_module）。在名为example_module.py的脚本中的函数和类可以通过名称进行导入。

因为模块与导入函数的脚本位于同一目录，所以这个导入语句会正常工作。但如果你移动了脚本，并且没有将模块复制到 Python 路径中的某个位置，那么这个导入就不会成功。

这是因为导入语句的工作方式是基于 Python 路径的。Python 会根据这个路径列表查找你请求的模块。默认情况下，第一个位置是本地文件夹，即包含你脚本的文件夹。下一个位置是 site-packages 文件夹。

site-packages 文件夹

大多数模块都安装在 Python 文件夹中的一个子文件夹内，这个文件夹叫做 site-packages 文件夹，它位于 */Lib/sites-packages。

要使你的模块可以导入，而无需将其与脚本放在同一目录下，请将模块文件夹放入 site-packages 文件夹。当你运行 "from mod_test.example_module import test_function" 时，它将定位到位于 site-packages 文件夹中的名为 mod_test 的模块。

编写脚本的基本风格建议

为了编写干净、可读的代码，建议遵循一些关于如何编写和组织代码的基本建议。Python 强制执行的主要规则是要求缩进，这旨在让代码更容易阅读和编写。

阅读更多关于 Python 代码风格的内容： realpython.com/python-pep8/

缩进

Python 代码有严格的缩进规则，所有 IDE 都会强制执行这些规则。这些规则尤其与函数和循环相关。

按照标准，函数声明或创建循环后使用 4 个空格。这只是一个标准，虽然可以使用一个空格，但当脚本变得庞大时，保持 4 个空格的缩进对于提高可读性非常有帮助。

强烈建议在缩进时不要混用制表符和空格。

阅读更多关于缩进的内容： www.python.org/dev/peps/pep-0008/ - 缩进

在顶部添加包含脚本细节的注释

这是一个可选但推荐的方式来开始你的脚本：在顶部写一个注释，包含你的名字、日期和脚本功能的简短说明。当其他人需要阅读你的代码时，这特别有用。

在脚本中添加更多注释，以确保你知道脚本中的每一部分发生了什么。

紧接着是导入语句

强烈建议但并非要求将导入语句放在脚本的顶部或靠近顶部。导入必须在调用模块对象之前发生，但导入语句可以放在任何地方。最好将它们放在顶部，这样阅读脚本的人可以很容易理解导入了哪些内容。

定义全局变量

在导入语句之后，定义脚本中需要用到的变量。有时需要在脚本的后面定义变量，但最好将重要的变量放在顶部。

定义函数

通过将函数定义放在全局变量下方，在阅读时更容易理解函数的作用。如果函数不在脚本中的已知位置，有时很难找到在脚本其他部分调用的函数。

包含print语句

内置函数print用于在脚本运行时将消息发送到命令窗口。将任何有效的数据传递给print语句，并用它来跟踪进度或在出现问题时进行调试。

>>> print("blueberry")
blueberry
>>> x = 0
>>> print(x)
0

阅读更多关于print语句的内容：realpython.com/python-print/

编写脚本的可执行部分

在导入模块和定义函数之后，脚本的下一部分是实际执行的地方。for循环运行，函数被调用，脚本完成执行。

确保添加大量注释，以帮助自己理解脚本中的操作，并添加print语句帮助在脚本运行时进行调试。

如果__name__ == '__main__'

在脚本的末尾，你常常会看到这一行，if __name__ == "__main__"。这意味着，如果脚本被直接执行，下面缩进的代码将会运行；但是如果脚本中的代码被另一个脚本导入，那么代码将不会执行，直到在第二个脚本中被调用。

阅读更多关于此的内容：www.geeksforgeeks.org/what-does-the-if-__name__-__main__-do/

小结

在本章中，我们快速而全面地概述了计算机编程和 Python 编程语言。我们回顾了计算机编程的基础，包括变量、迭代和条件语句。我们回顾了 Windows 的 Path 环境变量和 Python 系统路径。我们探讨了 Python 的数据类型，包括整数、字符串和浮点数，以及 Python 的数据容器，如列表、元组和字典。我们学习了脚本的一些基本代码结构，以及如何执行这些脚本。

在下一章，我们将讨论arcpy和 ArcGIS Python API 的基础知识。我们将学习如何导入这些模块并访问它们的方法和子模块。我们将开始执行 Python 代码，以自动化 ArcGIS Desktop 和 ArcGIS Pro。

第三章：ArcPy 基础

现在你已经理解了 Python 语法，可以开始使用 ArcPy 包。ArcPy 是 ArcGIS 提供的 Python 包，用于执行和自动化地理处理和制图任务。除了 ArcGIS 中提供的 地理处理 工具外，你还可以访问其他模块、函数和类。将这些组合在一起，你可以创建简化并自动化复杂分析和制图的工作流程和独立工具。

本章将涵盖：

  • 确保你的 Python 环境已为 ArcPy 配置

  • ArcPy 工具以及如何在 ArcGIS Pro 中使用它们

  • 在 ArcPy 中访问 环境设置

  • ArcPy 中的 函数

  • ArcPy 模块

检查你的 ArcPy 安装

ArcPy 包使你能够访问 ArcGIS Pro 的地理处理功能。Python 包包含多个模块、函数和类。一个包采用层次结构，并使用点表示法来访问模块和函数。

ArcPy 随 ArcGIS for Pro 和 ArcGIS Desktop 一起安装。从 ArcGIS 10.0 开始，ArcPy 就被用于在 ArcGIS 中编写 Python 脚本。它是官方的 ArcGIS 脚本语言，可用于自动化分析和制图工作流程。ArcGIS 桌面版使用 Python 2.7，当前版本为 2.7.18。ArcGIS Pro 使用的是新的 Python 版本 Python 3，当前最新版本是 Python 3.9.5。你可以通过前往 项目>Python>已安装的包 并查找 Python 来检查你安装的 Python 版本。

使用 ArcPy 包时，必须先导入。大多数脚本都以导入语句开始，以便访问包中的所有模块。要导入 ArcPy，可以使用以下代码行：

import arcpy

导入 ArcPy 可以访问所有的地理处理工具和所包含的模块。

一些模块包括：

  • Arcpy.sa（空间分析）

  • Arcpy.geocoding（地理编码）

  • Arcpy.na（网络分析）

  • Arcpy.da（数据访问）

  • Arcoy.mp（制图）

后续章节将深入探讨数据访问和制图模块。这两个模块都非常强大，可以自动化工作。

Python IDLE Shell for ArcGIS Pro 安装

由于 Python 和 ArcPy 是与 ArcGIS Pro 一起安装的，如果你使用的是 ArcGIS Pro 中安装的 Python 版本的 IDLE Shell，导入 ArcPy 时不会出现错误。如果你使用的是其他 Python 解释器，则需要进行配置，以使其找到 ArcPy 模块。大多数情况下，你会直接在 ArcGIS Pro 的 Python 窗口、ArcGIS Pro 中的 ArcGIS Notebook 或转化为脚本工具中编写脚本，因此使用 ArcGIS Pro 安装中附带的 Python IDLE 最为方便。

确保访问 ArcGIS Pro 安装附带的 Python IDLE 最简单的方法是创建一个快捷方式，因为安装时不会自动创建。

  • 查找运行 IDLE 的路径，对于典型的 ArcGIS Pro 安装，它通常在这里：C:\Program Files\ArcGIS\Pro\bin\Python\envs\arcgispro-py3\Lib\idlelib\idle.bat，双击 它将打开 IDLE：

  • 要创建快捷方式，右键点击 桌面 并 点击 新建 > 快捷方式，然后粘贴 idle.bat 文件的完整路径：

  • 点击 下一步，然后为你的快捷方式命名：

    我建议使用一个名称，这样你就能记住这是与 ArcGIS Pro 一起安装的 Python 环境。

  • 图标将是默认的快捷方式图标。

    .

    .

  • 要更改图标为标准的 Python IDLE 图标：

    • 右键点击 它

    • 点击 属性。

    • 在 快捷方式 标签中，点击 更改图标。

      你可能会收到一个警告，提示没有图标，需要从其他文件中选择一个图标。如果是这种情况，点击确定，这样你就可以导航到图标所在的位置。

    • 导航到 Python IDLE 所在位置，通常在此路径：C:\Program Files\ArcGIS\Pro\bin\Python\envs\arcgispro-py3\Lib\idlelib\Icons

  • 一个用于访问 ArcGIS Pro 安装的 IDLE 快捷方式现在已经安装在桌面上。这个安装是一个测试代码片段的地方，特别是在处理复杂脚本工具时，稍后的章节将对此进行详细探讨。

当你想要使用 IDLE 与 ArcGIS Pro 一起工作时，你需要使用这个版本，因为它与你安装的 ArcGIS Pro 相关联。

确保使用正确的 IDLE 的一种好方法是导入 arcpy。如果安装成功后显示三个尖括号 >>>，说明 IDLE 已正确设置。

如果没有显示，系统将会显示一个错误：

Python IDLE Shell

Python IDLE Shell 是尝试代码的好地方，因为它是交互式的，并且会立即显示代码结果：

IDLE Shell 还使用不同的颜色显示代码元素的解释。字符串用绿色显示，函数用紫色显示，循环和条件语句用橙色显示，结果用蓝色显示。

虽然从 IDLE Shell 获取即时结果很有用，但它并不适合用来保存代码。虽然可以在需要时将其复制出来，但更好的做法是将其写入脚本文件中以便保存。

要启动脚本文件，你需要在 IDLE Shell 的菜单栏上点击 文件>新建文件。这将打开一个新的窗口，这是一个名为 Untitled 的空 Python 脚本文件。与 IDLE Shell 不同，它没有命令提示符，并且菜单栏也有所不同。

你可以创建一个脚本文件。

  • 将之前在 IDLE 中编写的代码复制到脚本文件中。

  • 移除尖括号。

  • 修正缩进以匹配下面的格式。

  • 保存文件。

这个新文件 HelloLoop.py 有 .py 扩展名，表示它是一个 Python 文件。你可以通过点击 运行 > 运行模块 来运行它，并将结果发送到 Python IDLE Shell。

现在你已经了解了

  • 如何确保你的 Python 环境已设置为与 ArcPy 一起使用

  • 如何使用 IDLE Shell

  • 如何启动新的脚本文件

你现在已经准备好查看 ArcGIS Pro 中的 Python 窗口以及你能在其中做什么了。

ArcGIS Pro 中的 Python 窗口

不仅可以通过 IDLE 访问 ArcPy，还可以通过 ArcGIS Pro 中的 Python 窗口访问。

Python 窗口允许你直接在 ArcGIS Pro 中编写和运行代码，并查看你运行任何地理处理工具时的结果。在测试新代码时，这可以帮助你看到代码的执行情况和效果。你编写的代码可以复制或保存到大型脚本工具中。你将在后续章节中学习更多关于脚本工具的内容。现在，让我们看看 ArcGIS Pro 中的 Python 窗口，了解它有多强大。

一旦点击图标，Python 窗口会弹出，通常第一次它会固定在屏幕底部。

就像 ArcGIS Pro 中的所有窗口一样，Python 窗口可以固定在任何位置，或者可以自由浮动。你可以像处理任何 ArcGIS Pro 窗口一样，通过拖动和隐藏来将其移动到最适合你工作的地方。

窗口的顶部部分称为 转录内容，其中显示你之前编写的代码。底部标有 在此处输入 Python 代码 的部分称为 提示符，这是你输入代码的地方。当你第一次打开 Python 窗口时，转录内容是空的，因为你还没有编写任何代码。

尝试在 IDLE 中编写的一些代码，看看它在 Python 窗口中是如何工作的。就像在 IDLE 中一样，当你输入一行代码时，需要按 Enter。

  • 输入 x = 10 并按 Enter

  • 输入 y = 3 并按 Enter

  • 输入 x + y 并按 Enter

你可以看到这就像在 IDLE 中一样正常工作。这意味着所有标准的 Python 函数和工具在 Python 窗口中的运行方式与它们在 IDLE Shell 中的表现是一样的。

转录框可以随时通过右键点击转录框并选择清除转录内容来清空。这不会从内存中删除你的代码或变量。

  • 点击转录框并选择 清除转录内容。

  • 输入 x + y 并按 Enter

如你所见，x 和 y 的变量已经保存在内存中，即使清除了转录内容，它们仍然可用。即使你保存并关闭项目，再次打开时这些变量仍然可用。它们被保存在项目的内存中，因此可以在同一个项目中稍后再次使用。 这可能会很有用，但你将在后续章节中了解更好的方法来保存代码以便在同一项目和其他项目中重复使用。

就像在 IDLE Shell 中一样，Python 窗口能够理解你编写的多行连接代码。你可以通过在本章前面编写的 HelloLoop.py 脚本来看到这一点。

  • 输入 String = “Hello” 并按 Enter

  • 输入 i = 1 并按 Enter

  • 输入 while i < 5: 并按 Enter

    注意，提示窗口变大了，并且光标有了缩进。Python 窗口理解 while 语句开始了一个代码块，并且是多行构造的一部分。当你继续输入代码时，提示窗口会变大，以容纳需要的额外行数。if 语句也是多行构造的一部分，因此它也会像 while 语句一样增加额外的行并进行缩进。

  • 输入 if i == 1: 并按 Enter Enter

  • 输入 print(string) 并按 Enter

  • 输入 else: 并按 Enter

  • 输入 print(i) 并按 Enter

  • 输入 i+=1 并按 Enter

  • 按 Enter

当你编写多行代码并按下回车时，光标将移动到下一行。

如果你忘记了 i += 1 而导致死循环会发生什么？如何停止循环？

你可以点击 Python 窗口底部的 X 来停止执行。

或者在提示窗口中输入Ctrl+C来停止执行。

ArcPy 环境设置

  • ArcPy 环境设置允许你访问通用的地理处理设置，以及特定工具的地理处理设置。

  • 对于工具，它们作为参数，可以设置来改变工具的结果。

  • 有很多环境设置可以使用，但你会发现自己常用其中的一些。

你将看到最常见的一种情况，并学习如何设置它：arcpy.env.workspace。

使用环境类的工作空间属性，你可以检查并更改你的工作空间或临时工作空间

arcpy.env.workspace
arcpy.env.scratchWorkspace

你可以检查并设置你的 工作空间

  • 输入 arcpy.env.workspace 并按 Enter

返回的结果是你当前的工作空间。

现在你可以设置你的工作空间

  • 输入 arcpy.env.workspace = r"C:\PythonBook\Project_2\Project_2.gdb" 并按 Enter

你可以通过类似的方法检查你的临时工作空间

  • 输入 arcpy.env.workspace 并按 Enter

现在你可以设置你的临时工作空间

  • 输入 arcpy.env.scratchWorkspace = r”C:\PythonBook\Project_2\Project_2.gdb” 并按 Enter

设置你的临时工作空间和工作空间是一个好主意，因为它可以为你创建的数据提供一个默认存放位置。它也是你在使用下文将要探索的列表函数时所使用的工作空间。在示例中，你已经将工作空间和临时工作空间设置为地理数据库。你也可以将它们设置为文件夹、要素数据集或你想要的任何工作空间。

路径前面的 r 是什么意思？

注意输入位置的方式。它以字母 r 开头，后面跟着用双引号括起来的路径。字母 r 代表“原始字符串”，意思是 Python 会按原样读取引号中的内容。这一点很重要，因为在 Python 中，\ 字符是一个转义字符，用于插入字符串中通常不允许出现的字符。你已经看到过如何在查询中使用转义字符来在字符串中的引号内插入引号。不过在这里你不需要转义字符，因此有 3 种选择。

在引号前加上字母 r 来创建原始字符串。

将所有单个的 \ 替换为双 \。

将单个 \ 改为 \。

根据你运行的过程，可能还有许多其他环境设置对你有用。你在工具属性中找到的大多数设置都可以在环境设置中进行设置。例如，分析范围可以通过 arcpy.env.extent 设置，做栅格分析时的栅格快照可以通过 arcpy.env.snapRaster 设置。

重要的是要记住，一旦你设置了环境设置，它会保持不变，直到你修改它。在更高级的脚本工具中，你会修改它，或者在代码中设置并重置它。

ArcPy 工具 - 使用 ArcPy 进行地理处理

现在你已经掌握了 Python 窗口的基本用法，是时候了解如何使用地理处理工具了。

  • 你将学习如何在 Python 窗口中使用选择、缓冲、创建要素图层、按要素图层选择工具、添加字段和计算字段工具。

  • 最终结果将是一个包含公园周围 1,000 英尺范围内的公交车站的要素类。

要进行一些地理处理，你需要一些数据。确保你在 ArcGIS Pro 中打开了一个地图，并将你下载的 CPAD_2020b_Units.shp 数据添加进来。该数据来自加利福尼亚保护区数据库，展示了加利福尼亚州内的公园及其他保护区。有关该数据集的更多信息，请访问 www.calands.org/。

你将使用 Python 窗口选择奥克兰市的公园，进行 1,000 英尺的缓冲，选择缓冲区内的公交车站，并将它们写入新的要素类。

右键点击目录表，选择属性表，查看数据展示的内容。

  1. 你将使用 AGENCY_NAME 字段运行一个选择工具，创建一个仅包含奥克兰市保护区的新要素类。你将在 Python 窗口中通过输入以下内容来完成此操作：arcpy.Se。Python 窗口会显示一些自动完成选项，帮助你找到所需的工具。你将使用分析工具集中的选择工具，因此需要使用 Select() analysis。

  2. 选择工具后，你可以看到该工具期望的参数。将光标悬停在工具上，帮助窗口会弹出，显示工具的参数。选择工具需要以下必需参数：

    1. in_features

    2. out_features,

      • 以及以下可选参数

    3. where_clause。where_clause用大括号{}表示，因为它是可选的。

      • in_features是加粗的，因为它是当前工具希望输入的参数。将以下内容输入括号中以创建选择查询：“CPAD_2020b_Units”,”CPAD_2020b_units_Oakland”,’”AGNCY_NAME = \’Oakland, City of\’ 然后按Enter键！

    运行后，它将如下所示，你应该会有一个新的要素类，表示奥克兰的保护区。

    如何编写 where 子句查询以确保其有效？正确使用转义字符“\”

    反斜杠（\）是转义字符，在你需要使用多个单引号或双引号时非常必要。在此实例中，由于你正在对 shapefile 执行选择查询，所选属性字段需要使用双引号，而字符串值则需要使用单引号。整个 where 子句需要放在单引号或双引号内。因此，最简单的选项是将整个查询用单引号括起来，并在所选字符串周围使用转义字符。如果你想将整个 where 子句放在双引号中，它将如下所示：“/”AGNCY_NAME” = ‘Oakland, City of’”。这两种方式都能正常工作。

    如果你在 ArcGIS Pro 项目中工作，那么新文件将会保存在该项目的地理数据库中，因为这是默认的工作空间。如果你通过环境设置指定了工作空间，则将写入该工作空间。如果没有设置，它将存储在临时空间中，且不会写入磁盘。

    如果不想使用默认工作空间，如何指定不同的工作空间？

    若要指定不同的保存位置，需要在保存时写出完整路径。例如，要将 shapefile 写入MyProject文件夹，你可以写出如下命令：arcpy.analysis.Select(“CPAD_2020b_Units”,r”C:\PythonBook\MyProject\CPAD_2020b_Units_Oakland.shp”,’”AGNCY_Name” = \’Oakland, City of\’’)

  3. 现在你可以选择这些公园，并将它们缓冲 1000 英尺。缓冲工具位于分析 工具箱中，因此要调用它，只需输入arcpy.analysis.Buffer()。你可以通过将光标悬停在括号中查看缓冲工具的参数。它按以下顺序接受以下必需参数：

    1. in_features

    2. out_features

    3. buffer_distance_or_field

    以及以下可选参数，按此顺序排列：

    1. line_side

    2. line_end_type

    3. dissolve_option

    4. dissolve_field

    5. method

    你希望为公园设置 1,000 英尺的缓冲区，仅解散为UNIT_NAME、AGENCY_NAME和LABEL_NAME。为此，你将输入in_features、out_featuers、buffer_distance、dissolve_option和dissolve_field paramaters。其中，in_features、out_features和buffer_distance是前 3 个参数，但dissolve_option和dissolve_field是第 6 和第 7 个参数。为确保它们处于正确位置，你将在第 4 和第 5 个参数中输入一对单引号或双引号。这告诉函数这些可选参数为空，就像它们没有被输入一样；并允许你在它们之后输入参数。在括号内输入“CPAD_2020b_Units_Oakland”,”CPAD_2020b_Units_Oakland_1000ft”,”1000 FEET”, “”,””,”LIST”,[UNIT_NAME,”AGNCY_NAME”,”LABEL_NAME”]，然后按Enter键。

  4. 缓冲区应该已添加到你的地图中。你可以探索它们，看看它们的样子。当你准备好时，你现在要用创建要素图层工具制作公交车站要素类的要素图层。在括号内输入arcpy.management.MakeFeatureLayer()。你可以看到创建要素图层工具需要两个必填参数

    1. in_features

    2. out_layer以及以下可选参数

    3. where_clause

    4. workspace

    5. field_info

  5. 你将输入以下参数来制作所有公交车站的要素图层，只需在括号内输入以下内容。“UniqueStops_Summer21”,”AC_TransitStops_Summer21”，然后按Enter键。

  6. 要素图层应已添加到你的地图中。你可以探索它，看看它与 UniqueStops_Summer21 要素类相似。但由于它是要素图层，你可以使用按位置选择图层工具选择缓冲区内的所有公交车站。在括号内输入arcpy.management.SelectLayerByLocation()。你可以看到按位置选择图层工具有一个必填参数

    1. in_layer以及以下可选参数

    2. overlap_type

    3. select_features

    4. search_distance

    5. selection_type

    6. invert_spatial_relationship

  7. 你将输入以下参数来选择 1,000 英尺缓冲区内的公交车站，只需在括号内输入以下内容。“AC_TransitStops_Summer21”,”INTERSECT”,”CPAD_2020b_Units_Oakland_1000ft”，然后按Enter键。

  8. 你应该看到已选择的公交车站。你可以探索数据，看看是否符合你的预期。从这里，你可以将数据导出为表格、CSV 或要素类，或者仅用于地图显示。现在，你要将数据导出为要素类以备日后使用，当你探索数据访问模块并使用游标时。为此，你将使用复制要素工具。在括号内输入arcpy.management.CopyFeatures()。复制要素工具有两个必填参数

    1. in_features

    2. out_features以及一个可选参数

    3. config_keyword

  9. 你将输入以下参数到括号中，将选定的公交站点复制到新的要素类中：“AC_TransitStops_Summer21”, “AC_TransitStops_Within1000ft_OaklandPark”

你的结果要素类将在地图中显示，并写入当前工作空间。有关此数据的下一步将在第四章：数据访问与行中探索。在那里，你将学习如何在内存中完成此过程并将公园名称添加到公交站点。

内置 ArcPy 函数

ArcPy 有许多内置函数可以帮助进行地理处理。ArcPy 函数的写法与地理处理工具类似。当你编写代码创建一个选择要素类时，你写了 arcpy.analysis.select(in_features,out_features,{where_clause})。通过将输入要素、输出要素和查询条件放在括号中，你调用了这个函数并向其传递了这些参数。这就是函数的全部内容，你可以稍后通过传递不同的参数来调用它。

ArcPy 具有帮助环境设置、描述数据、许可、ArcGIS Online、栅格、列出数据等功能，还有针对特定模块（如空间分析或映射模块）的函数。在本节中，你将探索两个更常用的内置函数。

  • describe 函数

  • 列出函数

这些函数很常见，因为它们帮助你设置并完成迭代过程，比如在同一位置对不同的要素类进行相同的分析。

describe 函数

describe 函数将根据元素的类型返回不同的属性。describe 函数可以作用于多种元素，包括但不限于：shapefile、地理数据库、要素类、要素数据集、表格、LAS 文件、栅格数据和地图文档。

describe 函数返回一个包含所有属性的对象，因此你需要创建一个变量来保存这些属性，然后稍后调用它们。你可以在 CPAD 数据上尝试此操作。

  • 输入 desc = arcpy.Describe(r”C:\PythonBook\cpad_2020b\CPAD_2020b\CPAD_2020b_Units.shp 然后按 Enter 键

  • 看起来没有发生任何事情，但现在你可以使用该 desc 变量来获取有关 shapefile 的信息。你可以通过输入 desc.dataType 并按 Enter 键来查看数据类型。

  • 你还可以通过输入 desc.shapeType 并按 Enter 键来查看要素类的几何类型。

你可以看到，如果你不了解某个文件，你可以调用 describe 函数并使用其属性来查找文件的相关信息。

在上述示例中，你知道数据是一个 shapefile，你可以看到如果你在文件夹中搜索并且只想对 shapefile 执行分析时，这些信息是多么有用。

列出函数

列表函数非常强大，因为它们允许你创建一个工作空间中数据的列表，然后你可以遍历这些数据。对于这些示例，你将使用MyProject.gdb地理数据库中的数据。

列表函数获取你所在的当前工作空间，并将为该类型的列表函数创建一个所有数据集的列表。以下是一些列表函数：

  • ListDatasets

  • ListFeatureClasses

  • ListFields

  • ListFiles

  • ListIndexes

  • ListRasters

  • ListTables

  • ListVersions

  • ListWorkspace

ListDatasets、ListFeatureClasses、ListFiles、ListRasters、ListTables和ListWorkspaces需要在运行之前设置工作空间，因为它们只会在当前工作空间上运行。

  • 首先列出MyProject.gdb所在的工作空间。你需要首先将工作空间设置为地理数据库的所在位置。arcpy.env.workspace = r"C:\\PythonBook\\MyProject"并按下Enter键。

  • 接下来，将ListWorkspaces函数分配给一个名为wksp的变量，wksp = arcpy.ListWorkspaces()并按下Enter键。

    ListWorkspaces函数有两个可选参数，

    通配符 - 用于限制返回列表的值，只有匹配你输入的值时才会返回。

    工作空间类型 - 用于限制工作空间的类型。

  • 你可以通过输入wksp并按下Enter键来看它是什么样子。

  • 你可以看到它是创建新项目时，在 ArcGIS Pro 中标准的所有工作空间。它们在这个列表中有些难以阅读。因此，为了让它们更容易阅读，你可以遍历该列表，逐个打印出来。输入for w in wksp:并按Enter键，再输入print(w)并按Enter键，然后按下Enter键。

现在你可以真正看清楚你拥有什么了。

这很棒，因为你可以看到文件夹中所有的工作空间。但是你只想要文件夹中的地理数据库。这时，你可以使用参数。为此，你可以使用工作空间类型参数。工作空间参数接受以下字符串值：

  • 访问 - 个人地理数据库将被选中

  • 覆盖 - 覆盖工作空间将被选中

  • FileGDB - 文件地理数据库将被选中

  • 文件夹 - 将选择 shapefile 工作空间

  • SDE - 企业数据库将被选中

  • 所有 - 所有工作空间 - 这是默认设置

要仅选择文件地理数据库，你需要输入以下内容。

wksp = arcpy.ListWorkspaces("","FileGDB")

为什么会有一个“”后跟一个逗号？

第一个参数是通配符，输入“”将留空。不过需要有这个参数，因为函数会按书写顺序处理参数。如果你像这样写wksp = arpcy.ListWorkspaces("FileGDB")，函数仍然会运行。但是当你调用它时，你不会得到任何数据，因为没有名为“FileGDB”的工作空间。

你可以看到当调用wksp变量时，你现在只会得到一个值：MyProject.gdb。

虽然列表中只有一个值，但它仍然是一个列表，在 Python 中表现为列表。也就是说，如果 ArcPy 函数期望的是一个字符串而给它一个列表，它会失败。例如，你不能通过使用wksp变量将工作空间更新为该地理数据库位置。

列表的元素可以通过不同的方法设置为工作空间。如果你想将列表中的每个元素都设置为工作空间，可以按以下方式操作。

输入for w in wksp: 按下Enter

输入arcpy.env.workspace = w 按下Enter

输入print(arcpy.env.workspace) 按下Enter 按下Enter

如果你知道只有一个目标工作空间该怎么办？

在这个例子中，你只有一个项目在列表中，因此只会执行一次。在这种情况下，如果只有一个项目，你可以直接写w = wksp[0]

事实上，当你知道列表中只有一个项目时，你可以直接写以下代码来设置工作空间：arcpy.env.workspace = ListWorkspaces(“”,”FileGDB”)[0] 请小心使用这种表示法，如果你有多个工作空间，它将只会将工作空间设置为列表中的第一个。

现在工作空间已经设置为你的地理数据库，你可以使用 ListFeatureClasses 函数获取该地理数据库中所有要素类的列表，并将其赋值给一个变量。

你将编写代码获取要素类的列表，然后编写一个 for 循环遍历该列表，以便你可以轻松读取列表中有哪些要素类。

  • 输入fcs = arcpy.ListFeatureClasses() 按下Enter

  • 输入for fc in fcs: 按下Enter

  • 输入print(fc) 按下Enter 按下Enter

现在你有一个包含地理数据库中所有要素类的列表。这个列表可以进行迭代，得到单个要素类，你可以将其传递给其他 ArcPy 函数或地理处理工具。你可以使用上述的 Describe 函数来仅查找特定几何类型的要素类，确保分析只在该类型的要素类上进行。

你将从存储在变量 fcs 中的要素类列表开始，并像上面那样遍历它，之前你只是打印出了名称。然后，你将使用要素类的 ShapeType 属性来确定每个要素类的形状，并打印出相应的说明。

以下代码是你将在 Python 窗口中编写的内容。

for fc in fcs:
    desc = arcpy.Describe(fc)
    fcName = desc.name
    if desc.shapeType == "Polygon":
        print("Shape Type for " + fcName + " is " + desc.ShapeType)
    elif desc.shapeType == "Polyline":
        print("Shape Type for " + fcName + " is " + desc.ShapeType)
    elif desc.ShapeType == "Point":
        print("Shape Type for " + fcName + " is " + desc.ShapeType)
    else:
        print(fcName + " is not a Point, Line, or Polygon")

这是编写它的步骤。

  • 输入for fc in fcs: 按下Enter

  • 输入desc = arcpy.Describe(fc) 按下Enter

  • 输入fcName = desc.name 按下Enter

  • 输入if desc.shapeType == “Polygon”: 按下Enter

  • 输入print(“Shape Type for “ + fcName + “ is “ + desc.ShapeType) 按下Enter

  • 输入elif desc.ShapeType == “Polyline”: 按下Enter

  • 输入print(“Shape Type for “ + fcName + “ is “ + desc.ShapeType) 按下Enter

  • 输入elif desc.ShapeType == “Point”: 按下Enter

  • print(“Shape Type for “ + fcName + “ is “ + desc.ShapeType)并按Enter键

  • else:并按Enter键

  • print(fcName + “ is not a Point, Line, or Polygon”)并按Enter键，再按Enter键

for 循环会遍历每个要素类。对于该要素类，你会创建一个变量来保存该要素类的 Describe 属性。接着，你创建一个变量来保存该要素类的名称。然后，你编写 if/elif/else 语句来测试 Describe 对象的 ShapeType 属性。输出语句会像这样。

if/elif 语句可以简化吗？

是的，根据你的需求，它是可以的。但如果你不知道自己在寻找什么，有时候明确一些会更好。现在你已经写出了这段代码，可以保存它并复制粘贴某些部分。例如，如果你想对地理数据库中的点、线和多边形运行不同的地理处理工具，那么你现在已经有了示例的 if/elif 语句可以使用。

另一种选择列表函数中元素的方式是在将它们放入列表之前使用通配符参数。通配符限制了函数返回的内容。它不区分大小写，并使用来包含任意数量的字符，可以在前后使用。让我们看一下如何使用当前的地理数据库工作区的几个示例。

你可以选择所有的 CPAD 数据

  • 输入cpad_fcs = arcpy.ListFeatureClasses(“CPAD*”)并按Enter键

  • 使用 for 循环查看列表内容。输入for fc in cpad_fcs:并按Enter键

  • 输入print(fc)并按Enter键，再按Enter键

通配符正在查找以 CPAD 开头的任何要素类，*告诉它匹配 CPAD 后面的任何内容。你可以在结果中看到，你现在有了一个包含所有 CPAD 要素类的列表。

  • 可以在任意字符前、后或前后使用。

你可以通过写出如下代码仅选择 CPAD 单元和超单元

cpad_fcs_units = arcpy.ListFeatureClasses(“*Units”)

并通过 for 循环验证输出

for fc in cpad_fcs_units:
  print(fc)

通配符可以用于选择仅包含 2019 的普查要素类，可以通过写出如下代码

census_fcs = arcpy.ListFeatureClasses(“*2019*”)

并通过 for 循环验证输出

for fc in census_fcs:
  print(fc)

通配符是许多列表函数中的可选参数之一，可以与其他参数一起使用。ListFeatureClasses函数有一个用于要素类型和要素数据集的参数。要素类型参数可以用来选择特定的要素类型，包括但不限于：点、面、多段线。要素数据集可以用来指定要在地理数据库中搜索的要素数据集。如果未指定要素数据集，则ListFeatureClasses函数只会查找地理数据库中的独立要素类。

使用你的MyProjects.gdb，你可以看到如何结合通配符和要素类型参数来获取特定的要素类。

你可以通过输入以下代码来选择仅包含人口普查多边形要素类：

census_fc_poly = arcpy.ListFeatureClasses(“*2019*”, “Polygon”)

并通过输入变量来验证

census_fc_poly

注意，要素类是以列表的形式存储在 [] 中。要执行任何地理处理任务，你需要通过迭代列表并在 for 循环中执行任务，或者使用列表索引提取要素类，获取你需要的列表索引。

census_county = census_fc_poly[0]

注意，census_county 变量返回的是要素类的名称。只要你的工作空间仍然是地理数据库，你可以仅使用该名称来执行地理处理任务。但是，如果你重置了工作空间，ArcPy 将不知道在哪里找到具有该名称的要素类。因此，使用 os 库创建一个包含要素类完整路径的变量是一个良好的做法。在 IDLE 中工作时，要使用 os 库，它需要像 ArcPy 一样被导入。

  • 输入 import os 然后按 Enter

  • 现在你可以创建一个变量，包含人口普查要素类的完整路径。输入 gdb = wksp[0] 然后按 Enter

  • 输入 census_county_full = os.path.join(gdb,census_county) 然后按 Enter

现在，你已经在一个变量中得到了人口普查县 shapefile 的完整路径，可以在你编写的任何后续代码中使用该变量。

ArcPy 模块介绍

ArcPy 附带了一套模块，除了地理处理工具和函数。模块是包含额外 Python 定义和语句的文件，包括函数和变量等。它们有助于更逻辑地组织代码。

ArcPy 附带了以下模块：

  • 图表模块 (arcpy.charts)

  • 数据访问模块 (arcpy.da)

  • 地理编码模块 (arcpy.geocoding)

  • 图像分析模块 (arcpy.ia)

  • 映射模块 (arcpy.mp)

  • 元数据模块 (arcpy.metadata)

  • 网络分析模块 (arcpy.na 或 arcpy.nax)

  • 共享模块 (arcpy.sharing)

  • 空间分析模块 (arcpy.sa)

  • 工作流管理模块 (arpcy.wmx)

上述一些模块确实需要特定的许可才能使用其中的功能和工具。例如，网络分析模块和空间分析模块需要你拥有网络分析和空间分析扩展。你将在后面的章节中深入学习的两个模块——数据访问模块和映射模块则不需要。数据访问模块可以帮助你简化数据清理和分析过程。映射模块可以简化大量地图的制作，并使得创建数百张地图成为一个简单的过程。

空间分析模块

空间分析模块包含所有与空间分析扩展相关的地理处理工具。因为它使用了空间分析扩展，所以你需要导入该扩展。

from arcpy.sa import *

就像使用通配符一样，星号表示所有内容。你可以仅导入空间分析模块中的特定模块、类或函数，但大多数时候你将导入整个模块。

你将学习如何编写代码，在 Python 窗口中运行空间分析工具，使用来自 CalFire 的 FVEG 数据。数据可以在这里找到：frap.fire.ca.gov/mapping/gis-data/

  • 将fveg15_1数据加载到地图中

  • 右键点击它并选择符号系统

  • 点击下拉菜单中的Stretch，选择唯一值

  • 点击Field 1的下拉菜单并选择 WHR10Name。如果需要，可以调整颜色和色彩图案。同时也可以稍微浏览一下数据，看看显示了什么。这是加利福尼亚州整个州的土地覆盖数据。你将提取奥克兰市受保护区域的数据。

  • 输入from arcpy.sa import *并按下Enter

  • 如果你已经为奥克兰市的公园创建了要素类，可以跳过下一步

  • 输入arcpy.analysis.Select(“CPAD_2020b_Units”,r”C:\PythonBook\MyProject\MyProject.gdb\CPAD_2020b_Units_Oakland”,’”AGNCY_NAME” = \’Oakland, City of\’’)并按下Enter

  • 通过输入arcpy.CheckExtension(“Spatial”)并按下Enter检查是否有空间分析扩展可用。如果没有，它应返回‘Available’，如果没有，你需要启用你的空间分析许可证，或者如果是在共享许可证网络上，需要让其他人释放他们的许可证。

  • 一旦确认许可证可用，输入arcpy.CheckOutExtension(“Spatial”)并按下Enter。它应返回‘已签出’

  • 输入oaklandParksLandCover = ExtractByMask(“fveg15_1”,“CPAD_2020b_Units_Oakland”)并按下Enter

  • 输入oaklandParksLandCover.save(r”C:\MyProject\MyProject.gdb\OaklandParksLandCover”)并按下Enter

为什么需要保存栅格？是否可以用一行代码完成？

在 ArcPy 中使用空间分析扩展时，运行地理处理工具实际上是一个函数。该函数返回提取栅格。该栅格是在内存中创建的，如果你想保存它，必须使用返回栅格的保存属性。

这可以用一行代码完成。代码如下：oaklandParksLandCover_2 = ExtractByMask("fveg15_1","CPAD_2020b_Units_Oakland").save(r"C:\PythonBook\MyProject\MyProject.gdb\OakalndParksLandCover_2")

现在你拥有了这些数据，你可以使用 Con 工具找到公园中非城市区域的部分。

  • 首先为你的栅格命名，输入oaklandParksNonUrban =

  • 通过输入con(调用 Con 工具

  • 第一个参数是输入栅格，它是我们新创建的公园土地覆盖，输入oaklandParksLandCover,

  • 下一个参数是实际的栅格或常量，这是新栅格将获取的值。由于你希望保留不是城市的不同土地覆盖类型在新栅格中，所以这是同样的栅格，输入oaklandParksLandCover,

  • 下一个参数是可选的，它是虚假栅格或常数。这是新的栅格在城市区域中会得到的值。你希望它为无数据，这样新的栅格中的城市公园区域就会是空白，输入“”,

  • 最后一个参数是可选参数，它是一个 where 子句。它的写法就像运行选择工具的查询，输入“WHR10NAME <> ‘Urban’”)

  • 完整的代码应该如下所示oaklandParksNonUrban = Con(oaklandParksLandCover,oaklandParksLandCover,””,”WHRNAME <> ‘Urban’”)

  • 在目录中的新栅格上打开属性表。它只有一个值字段，没有其他属性。这是因为 con 工具仅提取真实栅格的值属性。可以通过做连接来解决这个问题。

  • Join Field 工具位于管理工具箱中，适用于栅格数据、要素类，并创建一个永久连接。输入arcpy.management.JoinField(

  • 第一个参数是输入图层，输入oaklandParksNonUrban,

  • 第二个参数是要连接的字段，输入VALUE,

  • 第三个参数是要连接的表，输入oaklandParksLandCover,

  • 第四个参数是从连接表中连接的字段，输入VALUE,

  • 最后一个参数是可选的，它是你想从连接表中加入到输入图层的字段列表。你可以使用列表来选择要连接的字段。如果留空，将连接所有字段。你将连接 WHR 字段，输入[“WHRNUM”,”WHRNAME”,”WHRTYPE”,”WHR10NUM”,”WHR10NAME”,”WHR13NUM”,”WHR13NAME”]

  • 完整的代码应该如下所示arcpy.management.JoinField(oaklandParksNonUrban,”VALUE”,oaklandParksLandCover,”VALUE”,[ [“WHRNUM”,”WHRNAME”,”WHRTYPE”,”WHR10NUM”,”WHR10NAME”,”WHR13NUM”,”WHR13NAME”])

  • 同样，必须保存以便存储。输入(oaklandParksNonUrban.save(r”C:\MyProject\MyProject.gdb\OaklandParksLandCover”)并按Enter

在接下来的章节中，你将学习如何使用搜索游标创建不同属性的列表，并遍历它们以创建多个栅格并进行进一步分析。

第四章：ArcGIS Python API

什么是 ArcGIS Python API？

ArcGIS Python API 是一个为 Web GIS 设计的 Python 包。它允许你直接处理托管在 ArcGIS Online 或 ArcGIS Enterprise 上的数据。之前你使用的是 ArcPy，虽然它非常适合桌面工作，但在处理托管数据时功能有限。ArcGIS Python API 提供了许多与 ArcPy 相同的功能，例如创建地图、地理编码、管理数据和地理处理，但它是在你的 ArcGIS Online 或 ArcGIS Enterprise 账户中进行的。除此之外，你还可以通过管理用户、组和项目来管理你组织的 Web GIS 数据。需要注意的是，虽然你将通过 ArcGIS Pro Notebooks 进行所有示例的操作，但你并不需要通过 ArcGIS Pro 来操作。你可以安装一个独立的环境，使用conda并通过 Jupyter Notebook 环境访问所有内容。本书不涉及这一点，因为它专注于在 ArcGIS Pro 中使用 Python。

ArcGIS Python API 类似于 ArcPy，它是一个 Python 包。它包含类、模块和函数。但它不仅仅是一个 Python 包：它还是一个应用程序编程接口（API）。API 是允许不同应用程序和软件相互通信的代码。它主要与 ArcGIS REST API 进行交互。这意味着你可以使用该模块向 ArcGIS Online 或 ArcGIS Enterprise 上托管的数据发出请求。这些数据可以是你自己组织中的数据，也可以是公开可用的数据。它是一个Python 风格的API，设计符合 Python 标准和最佳实践。作为一个 Python 风格的 API，它使 Python 程序员能够轻松使用 ArcGIS，而熟悉 Python 的 ArcGIS 用户可以自动化 Web GIS 任务。

该 API 已被组织成不同的模块供你使用。每个模块都有不同的功能和类型，以帮助你进行 GIS 工作。

模块：

  • arcgis.gis – 这是你将最常使用的模块。它允许进入 GIS，并提供创建、读取、更新和删除 GIS 用户、组或内容的功能。

  • arcgis.features – 该模块用于处理特征数据、特征图层、特征图层集合和特征集。它包含空间分析功能，用于处理特征数据。所有特征数据都是带有几何表示的数据。

  • arcgis.raster – 该模块用于处理栅格数据。它包含用于处理栅格和影像数据的类和函数。

  • arcgis.realtime – 该模块用于处理实时数据流。它用于处理流式数据，进行持续分析。它允许 Python 脚本订阅流式数据、广播更新或警报。

  • arcgis.network – 该模块用于完成网络分析。它用于网络图层，可用于查找最佳路线、最近设施、成本矩阵和服务区。

  • arcgis.schematics – 这个模块用于处理示意图。示意图是简化的网络。它用于解释示意图的结构和工作方式。

  • arcgis.geoanalytics – 这个模块用于对大数据集进行分布式分析，支持特征数据和表格数据。工具设计用于处理大数据和特征图层。

  • arcgis.geocoding – 这个模块用于地理编码和反向地理编码。它将地址创建为地理点，并在地图上可视化，或将其用作空间分析的输入数据。

  • arcgis.geometry – 这个模块用于处理几何类型。它包含接受几何类型作为输入和输出的函数，以及将几何图形转换为不同表示形式的函数。

  • arcgis.geoprocessing – 这个模块用于创建方法，以创建和共享地理处理工具。用户可以创建自己的地理处理工具并共享，此模块提供了一些可以协助创建工具的工具。

  • arcgis.geoenrichment – 这个模块提供有关某个地区或位置的数据。用户可以获取某个地区或指定距离内的人员和地点信息。它可以通过轻松提供人口统计数据来帮助模型。

  • arcpy.env – 这个模块用于创建一个共享环境，供不同模块使用。它存储当前活动的 GIS 和环境设置。

  • arcgis.mapping – 这个模块提供 GIS 数据的可视化功能。它包括 WebMap 和 WebScene，用于实现 2D 和 3D 可视化。

  • arcgis.widgets – 这个模块提供 GIS 数据的可视化功能。它包括 Jupyter Notebook MapView 小部件，帮助显示地图和图层。

  • arcgis.apps – 这个模块用于提供管理 ArcGIS 中可用的基于 Web 的应用程序的功能。

本章的重点将主要放在arcgis.gis模块上，用于管理组织中的数据，arcgis.features模块用于处理这些数据，以及arcgis.mapping模块用于可视化数据。

它做什么？为什么要使用它？

ArcGIS Python API 允许你在不进入 ArcGIS Online 的情况下访问 ArcGIS Online 中的数据。你可以管理你的 ArcGIS Online 或 ArcGIS Enterprise 组织、其用户和数据，通过 Jupyter Notebook 或 ArcGIS Pro Notebook 进行操作。通过在 Notebook 中执行此操作而非通过 ArcGIS Online 网页界面，你可以利用 Python 的完整功能，迭代数据并多次运行相同的过程，或安排任务执行。ArcGIS Python API 补充了 ArcPy，因为它允许你自动化组织的 Web GIS 流程。就像在 ArcGIS Pro 中使用 ArcPy 来自动化过程一样，当你需要在 ArcGIS Online 或 ArcGIS Enterprise 组织中自动化某个过程时，你可以使用 ArcGIS Python API

如何使用它？

ArcGIS API for Python 随 ArcGIS Pro 安装。如果您使用的是 ArcGIS Pro 2.5.x 或更高版本，conda 包应预先安装了 arcgis 包。默认的 conda 环境 arcgispro-py3，在 ArcPy 章节中已经看到，包含了 ArcGIS for Python API。如果需要升级包，可以通过Python Package Manager或Python Command Prompt来执行。如果只安装了默认的 Python 环境且没有创建新环境或克隆环境，则无法进行更新。

默认 Python 包安装

  • Python Package Manager 升级流程

    • 用空白项目打开 ArcGIS Pro

    • 选择项目选项卡

    • 选择Python菜单

    • 点击管理环境

    • 选择要更新的包（不能通过此方式更新默认安装）

    • 选择更新软件包

    • 从更新包列表中选择arcgis发布版

  • Python Command Prompt 升级流程

    • 在开始菜单的 ArcGIS 文件夹中，右键单击 Python Command Prompt

    • 激活要升级的环境

    • 输入conda upgrade -c esri arcgis

具有克隆环境的 Python Package Manager 以进行升级

一旦确认已安装了更新版本的arcgis包，可以测试是否正确安装。

  1. 转到项目>打开>计算机>打开另一个项目，然后导航到您下载的 Chapter5.aprx 文件并打开它。

  2. 在 Chapter5 文件夹上右键单击，然后选择新建>笔记本。将笔记本重命名为TestArcGISAPI

  3. 在单元格 1 中输入以下内容

    from arcgis.gis import GIS
gis = GIS()
map1 = gis.map("Oakland, California")
map1

  4. 点击运行以执行该单元格。您应该看到以下结果。

在 ArcGIS Pro Notebook 中创建的地图

让我们逐行查看代码，以了解其功能：

  1. from arcgis.gis import GIS 这从arcgis.gis模块导入 GIS

  2. gis = GIS() 这将以匿名用户身份连接到 ArcGIS Online。

  3. map1 = gis.map("加利福尼亚州奥克兰") 这将创建一个以加利福尼亚州奥克兰为中心的地图

  4. map1 这将地图打印到输出中，以便您可以查看创建的地图。

连接到 ArcGIS Online 或 ArcGIS Enterprise

有多种方法可以通过构建 GIS 对象连接到 ArcGIS Online 或 ArcGIS Enterprise。GIS 对象需要三个参数，全部都是可选的。

  1. url - 这是您的组织的 ArcGIS Online 或 ArcGIS Enterprise 的网址。如果没有给出，则默认为 ArcGIS Online (www.arcgis.com)

  2. 用户名 - 这是您的用户名，如果留空，则将以匿名方式登录

  3. 密码 - 这是您的密码，如果留空并指定了用户名，系统将提示您输入密码。

使用用户名但不输入密码登录 ArcGIS Online

使用这种设置，您可以共享您的笔记本，但不能共享您的登录凭据。

匿名用户

在之前的示例中，你以匿名用户连接到 ArcGIS Online 来测试你的 ArcGIS API for Python 安装。这使你能够查询和查看公开可用的数据。但它不允许你创建或修改内容，或执行分析。

内置用户

ArcGIS Online 和 ArcGIS Enterprise 配备了内置的身份存储。可以在单元格中输入以下代码实现：

gis = GIS(‘home’)

这将使用你当前登录 ArcGIS 时的凭证，将你的 Notebook 连接到 ArcGIS Online 账户。

ArcGIS Pro 连接

使用 ArcGIS Pro 的身份验证方案进行连接。可以在单元格中输入以下代码实现：

gis = GIS(‘pro)

这将使用你登录 ArcGIS Pro 时使用的凭证，将你的 Notebook 连接到 ArcGIS Online 门户。这类似于内置用户。不同之处在于，Pro 身份验证方案仅在本地安装并同时运行 ArcGIS Pro 时有效。

连接选项摘要
匿名用户 gis = GIS() 仅允许访问和查看公开可用的数据
内置用户 gis = GIS(‘home’) 使用当前登录账户连接到 ArcGIS Online，并允许根据用户分配完全访问该数据。
ArcGIS Pro gis = GIS(‘pro’) 当登录到 ArcGIS Pro 应用时，连接到活动的门户。这仅在 ArcGIS Pro 本地安装并同时运行时有效
凭证 gis = GIS({url}, username = ‘example’) 通过特定的用户名连接到一个网址，若留空，则默认连接到 arcgis.com，并且在运行时会提示输入密码，留空密码参数可保护你的凭证，方便分享

大多数时候，你将使用 gis = GIS(‘home’) 或 gis = GIS(‘pro’) 进行连接。在本书中，你将使用匿名连接或使用 gis = GIS(‘home’) 连接到你的组织。

使用 gis 模块管理你的 GIS

使用 gis 模块，你可以访问和管理文件夹、内容、组和用户。如果你有重复的任务和工作流，你可以将其自动化为脚本。在本节中，你将学习如何搜索数据、发布项目、将数据组织到文件夹中、访问和管理组、访问和管理用户、下载数据、删除数据和下载附件。

搜索数据

你可以使用 GIS 的内容属性来使用 search() 方法。这允许你在 GIS 中搜索并查找数据。search() 方法会根据提供的参数返回一个项目列表。search() 方法有多个可以使用的参数。通常，你将使用查询和项目类型参数。查询可以接受多种类型。在本节中，你将学习如何根据项目的标题或所有者进行查询。

在之前的示例中，你是连接到 ArcGIS Online 账户中的 GIS。对于搜索示例，你将以匿名方式连接，以了解如何搜索数据。你将搜索奥克兰的公开可用要素图层。

作为匿名用户搜索公共数据

  1. 转到项目>打开>计算机>打开另一个项目，然后导航到你下载的 Chapter5.aprx 并打开它。

  2. 右键点击 Chapter5 文件夹，选择新建>笔记本。将笔记本重命名为SearchForDataSample

  3. 你将通过匿名登录创建你的 GIS，并将导入一个显示模块，使返回的数据更容易查看。输入以下内容：

    from arcgis.gis import GIS
from IPython.display import display
gis = GIS()

    点击运行按钮以运行。

  4. 在下一个单元格中，你将搜索与奥克兰相关的要素图层，限制为仅显示 5 个项目，并展示结果。

    oaklandResults = gis.content.search(query="Oakland",item_type="Feature Layer",max_items=5)
for item in oaklandResults:
    print(item)
for result in oaklandResults:
    display(result)

    这两个 for 循环将以两种不同的方式返回数据细节。第一种方式是仅打印结果，第二种方式是使用显示模块来显示更多细节。点击运行按钮以运行。

搜索奥克兰数据的结果

结果仅显示与奥克兰相关的前五个要素图层。还有很多其他参数可以用来查找不同的数据。你可以应用以下任何或所有参数：

  • query – 这可以用来查询标题或所有者，并且可以使用通配符。

  • item_type – 这可以用来查询任何可以出现在 ArcGIS Online 门户中的项目类型。它可以找到 shapefile、要素图层、要素集合、csv 文件、表格、地图、Web 场景等。它还可以接受通配符。

  • sort_field – 这可以用来根据字段（如标题、所有者或浏览次数）对数据进行排序。

  • sort_order – 这可以与排序字段一起使用，进行升序或降序排序。

  • outside_org – 当登录到你的组织时，可以使用此项来搜索组织外部的数据。

你将测试一些参数，看看如何通过search()方法获得不同的结果。

首先，你将修改上次的搜索，查找标题中包含奥克兰的要素图层或集合，并按浏览次数进行排序。

  1. 现在你正在搜索标题中包含“奥克兰”的数据。你不需要在标题中使用通配符，因为这将搜索“奥克兰”一词。但它只会搜索“奥克兰”这个词，所以像“奥克兰县”这样的内容将不会被返回。你正在使用通配符来查询item_type，返回所有以“Feature”开头的类型。这将返回要素图层和要素集合。你还按浏览次数降序排序，以获取浏览量最多的项目，并且只返回 5 个项目。在同一个笔记本中输入以下内容：

    oaklandResults2 = gis.content.search(query="title:Oakland",item_type="Feature *",
                                     sort_field="numViews",sort_order="desc",max_items=5)
for item in oaklandResults2:
    print(item)
for result in oaklandResults2:
    display(result)

    点击运行按钮以运行。输出结果应该如下所示。

    使用不同搜索参数的奥克兰搜索查询结果

    您还可以按数据所有者搜索数据。您的查询参数结构如下：query=”owner:username” 这将仅返回所有者公开的数据。

  2. 您将从前一个单元格中获取两个数据集的所有者，并搜索他们拥有的所有要素数据类型。由于您不知道有多少种类型，并且不想打印所有数据，因此您只打印出返回的搜索结果列表的长度。在同一笔记本中的下一个单元格中输入以下内容

    oaklandResults3 = gis.content.search(query="owner:antievictionmapdev",item_type="Feature *")
print(len(oaklandResults3))

    点击运行按钮来运行并查看结果

    所有者查询的搜索结果

  3. 现在，您知道在下一个单元格中有 10 个要素层或要素集合，您可以输入以下内容。

    for result in oaklandResults3:
    display(result)

    点击运行以查看层显示。

从所有者查询中显示的层

您可以点击输出单元格中的层名称，浏览器会打开并显示您点击的项目的概览页面。

在连接到您的组织时搜索数据

在本节中，您已了解如何使用search()操作作为匿名用户搜索公共数据，以及如何搜索您组织中的数据。如您所见，根据您如何使用 ArcGIS API for Python，以及您使用的是 ArcGIS Online 还是 ArcGIS Enterprise，连接到您组织的方式会有所不同。由于在这些示例中您将连接到您的组织，因此将显示有限的图形，这些图形将取决于您在组织中拥有的数据。

要在您的组织中搜索数据，您将继续使用上面示例中的SearchForDataSample笔记本。

  1. 在下一个单元格中，您将使用在 ArcGIS Pro 中登录的帐户创建另一个连接到 ArcGIS Online，输入以下内容

    gis2 = GIS(‘home’)

    这将在 gis2 下创建一个 GIS，您可以用它来访问和管理您的 ArcGIS Online 中的内容和用户。如果您使用的是 ArcGIS Enterprise，则需要输入以下内容

    gis2 = GIS(“https://portal/domain.com/webadapter”,”username”,”password”)

    点击运行按钮来运行该单元格。

  2. 您可以通过输入以下内容查看您登录的用户的属性

    gis2.properties.user

    点击运行按钮来运行该单元格。结果将是一个数据字典，包含有关用户的所有信息。

    用户详细信息

  3. 所有这些都可以进一步访问并分配给变量（如果需要）。要访问姓氏，只需输入以下内容

    firstName = gis2.properties.user.firstName
firstName

    点击运行按钮。

    提取用户的姓名

  4. 在匿名登录时，搜索您的内容与此相同。唯一的区别是您正在搜索您组织中的数据。在下一个单元格中输入以下内容

    searchResults = gis2.content.search(query="*",item_type="Feature Layer")
for result in searchResults:
    display(result)

    点击运行按钮来运行该单元格。它将显示您组织中的所有要素层。

  5. 若要仅搜索您拥有的项目，请输入以下内容

    searchResults = gis2.content.search(query="owner:"+gis2.users.me.username,item_type="Feature Layer")
for result in searchResults:
    display(result)

    点击运行按钮来运行该单元格。

    search()方法中唯一需要的参数是查询。因为可以使用通配符，您可以通过只写query="*"来搜索所有内容。但请小心，如果您有很多图层，搜索可能会很慢。

  6. 当连接到您的组织时，您仍然可以通过将outside_org参数设置为True来搜索公开可用的数据。您可以通过编写以下代码，在gis2中找到相同的奥克兰数据集。

    oaklandResultsHome = gis2.content.search(query="title:Oakland",item_type="Feature *",
                                     sort_field="numViews",sort_order="desc",max_items=5,outside_org=True)
for result in oaklandResultsHome:
    display(result)

    点击Run按钮运行单元格。结果应该与匿名连接时相同。

在您的组织外部搜索的结果

在这一部分中，您已经学习了如何在匿名状态下以及连接到您的组织时搜索数据。现在您可以找到数据，接下来您将看到如何将数据添加到您的组织中，并如何组织这些数据。

发布数据

您发布到 ArcGIS Online 或 ArcGIS Enterprise 的大部分数据都是在 ArcGIS Pro 中完成的。当您发布单一地图或要素图层时，这非常有用且方便。如果您要发布一个包含纬度和经度字段的 csv，这就不太方便，因为您需要在 ArcGIS Pro 中显示坐标，然后再进行发布。使用 ArcGIS Python API，您可以将 csv 文件添加到您的组织，并通过几行代码进行发布。

从 csv 添加数据

要将数据添加到您的 GIS 中，您将使用add()方法。与search()方法类似，add()方法是 GIS 对象的content()属性的一部分。要使用add()方法，您需要创建要创建的项的属性数据字典。这些属性与您需要填写的项相同，以便从 ArcGIS Pro 中添加项目：标题、描述、标签。您还可以使用add()方法添加一个可选的缩略图。

首先打开 csv 文件AlamedaCountyFarmersMarket.csv，看看您将要添加的内容。它是一个基本的 csv 文件，包含市场名称、营业天数、营业时间、位置、城市、纬度和经度。目前，它只包含奥克兰和伯克利的农贸市场，而不包括整个阿拉米达县。稍后，您将把剩余的数据附加到您从这个 csv 数据创建的要素图层中。

农贸市场 CSV

  1. 右键点击Chapter3文件夹，选择新建>笔记本。将笔记本重命名为AddPublishData。

  2. 在第一个单元格中输入您的导入语句，并创建您的 GIS。您将创建一个与您在 ArcGIS Pro 中登录的 ArcGIS Online 账户相关联的 GIS。输入以下内容：

    from arcgis.gis import GIS
from IPython.display import display
gis = GIS(‘home’)

  3. 点击+按钮添加一个单元格。在这个单元格中，您将为csv创建一个变量。

    csvFM = r"C:\PythonBook\Chapter3\AlamedaCountyFarmersMarket.csv"

    如果您的 csv 文件保存在其他位置，请确保使用其正确位置。

  4. 点击+按钮添加一个单元格。在这个单元格中，您将创建csv属性的数据字典。您将为标题、描述和标签填写属性，作为键值对填入它们的值。输入以下内容：

    csvProperties = {
    "title":"Farmers Markets in Alameda County",
    "descrption":"Location, days, and hours of Farmers Markets in Alameda County",
    "tags":"Farmers Market, Alameda County, ArcGIS API for Python"
}

    如果你要添加缩略图，可以在此单元格中通过定义一个变量来指定缩略图的位置。

    thumbnail = r”PATH\TO\THUMBNAIL.png”

  5. 点击 + 按钮添加一个单元格。在这个单元格中，你将创建一个变量来保存正在添加的 csv 项。你需要使用内容模块中的 add 函数。传递的参数是属性字典和 csv 的路径。输入以下内容：

    addCsvFM = gis.content.add(item_properties=csvProperties,data=csvFM)

  6. 点击 + 按钮添加一个单元格。在这个单元格中，你将通过调用发布方法发布刚才添加的 csv 项。输入以下内容：

    farmersMarketFL = addCsvFM.publish()
farmersMarketFL

    通过将发布方法设置为一个变量，这个变量将包含要素图层。你可以调用该变量来显示要素图层的属性。

  7. 点击 + 按钮添加一个单元格。在这个单元格中，你将创建一个快速地图来可视化你的数据，以验证要素图层是否已创建。输入以下内容：

    map1 = gis.map("Oakland, California")
map1.add_layer(farmersMarketFL)
map1

  8. 点击 Cell>Run All 来运行所有单元格。输出的地图应该如下所示：

地图小部件显示农贸市场要素图层。

添加和发布摘要与提示

你已经了解了如何发布包含经度和纬度列的 csv 文件，用于点数据。这个过程可以通过使用循环将其转换为一个迭代过程来发布多个 csv 文件。你需要做的就是为每个 csv 编写一个属性数据字典。但是你的数据并不总是包含经度和纬度的点位 csv。以下是发布其他类型数据的一些技巧。

  • 在发布包含经纬度字段的 csv 时，确保它们的字段名称分别是 latitude 和 longitude。模块会查找这些字段名。如果没有找到，它将无法正确定位点。你可以通过可选的 publish_paramaters 字典在 publish() 方法中指定要使用的字段名称。为此，你需要创建以下字典：

    publishParam = {
    "locationType":"coordinates",
    "latitudeFieldName":"LatX",
    "longitudeFieldName":"LongY"
}
    • locationType 的值应为坐标，然后 latitudeFieldName 和 longitudeFieldName 分别是 csv 文件中对应字段的名称。

  • 没有经纬度但有地址的 csv 文件可以进行地理编码。要对 csv 中的数据进行地理编码，你仍然需要使用 publish_paramaters 字典。

    publishParam = {
    "locationType":"address",
    “addressTemplate”:”{address},{city},{state},{zip}”
}
    • locationType 字段设置为地址。然后，addressTemplate 字段设置为包含不同地址组件的字段。在这个示例中，有一个字段包含街道地址，一个字段包含城市，一个字段包含州，一个字段包含邮政编码。这个设置将取决于你在 csv 中的数据结构。

  • Shapefile 和文件地理数据库可以使用相同的方法进行添加和发布，但它们必须被压缩为 zip 文件。如果你有大量未压缩的 Shapefile 或文件地理数据库，可以通过自动化处理来压缩它们。

使用 ArcGIS API for Python 添加和发布数据对于快速将数据添加到你组织的 ArcGIS Online 或 ArcGIS Enterprise 账户中非常有用。你已经看到如何添加和发布 csv 文件。你已经看到这些 csv 文件在发布时可以使用 ArcGIS Online 地理编码器进行地理编码。在下一部分，你将看到如何将数据组织到文件夹中，创建小组并管理对小组的访问。

组织数据，管理小组和用户

在 ArcGIS Online 或 ArcGIS Enterprise 中组织你的数据非常重要。你希望能够找到你的数据。除了文件夹来存储数据外，你还可以创建小组来共享特定的数据。在大型组织中，这一点尤为重要，因为并非每个人都需要访问相同的数据。在本节中，你将看到如何创建文件夹并将数据移动到其中，创建小组并管理对小组的访问，以及创建和管理用户。

将数据组织到文件夹中

在添加数据或发布数据之后，首先要做的事情之一是找到一个文件夹将其放入其中。使用文件夹来组织数据是一个良好的实践。它不仅帮助你找到数据，还能帮助组织中的其他成员。你可以使用 ArcGIS API for Python 添加文件夹并移动数据。在下面的示例中，你将创建一个新文件夹并将上面的农贸市场数据移入其中。

  1. 右键点击Chapter3文件夹并选择新建>笔记本。将笔记本重命名为CreateFolderMoveData

  2. 在第一个单元格中输入你的导入语句并创建 GIS。你将创建一个已登录 ArcGIS Online 账户的 GIS，这个账户和你在 ArcGIS Pro 中登录的账户是同一个。

    from arcgis.gis import GIS
from IPython.display import display
gis = GIS(‘home’)

  3. 点击+按钮添加一个单元格。在这个单元格中，你将创建一个新文件夹。

    gis.content.create_folder(folder="AlamedaFarmersMarkets")

  4. 点击+按钮添加一个单元格。在这个单元格中，你将搜索需要移动的数据。

    alamedaFM = gis.content.search(query="title:Farmers Markets in Alameda County”)

  5. 记住，search()方法返回的是一个项的列表。为了确认你的列表中有什么，你将运行一个 for 循环来遍历该列表并显示数据。在上述相同的单元格中输入。

    alamedaFM = gis.content.search(query="title:Farmers Markets in Alameda County")
for item in alamedaFM:
    display(item)

  6. 点击单元格>全部运行来运行到目前为止的所有单元格。你的笔记本现在应该类似于这个样子。

    创建文件夹并查找数据以移动的输出。

  7. 点击+按钮添加一个单元格。在这个单元格中，你将把要素图层和 csv 文件移动到新的文件夹中。你将通过遍历搜索结果并使用move()方法来完成此操作。

    for item in alamedaFM:
    item.move(folder="AlamedaFarmersMarkets")
     print(item)

    点击运行按钮来运行这个单元格。你应该能看到类似以下的输出，确认你的数据已经被移动。如果你进入你的 ArcGIS Online，你会看到你现在有一个新文件夹，两个数据集也在其中。

移动数据到新文件夹的输出

创建文件夹并将数据移动到该文件夹的过程是 ArcGIS API for Python 可以帮助你组织数据的一个方法。在示例中，你能够通过名称找到所有数据集，并将它们移动到新创建的文件夹中。能够使用 ArcGIS API for Python 搜索 GIS 中的数据并将其移动到文件夹中是一个非常有价值的工具，能够节省你大量时间。

如果你需要将数据移回根目录，只需使用以下代码item.move(“\”)。

访问和管理组

组是你与其他用户共享数据的空间。通过它，你可以创建一个协作 GIS，允许其他用户访问你的数据和地图。使用 ArcGIS API for Python，你可以以编程方式创建和管理组，从而节省时间，同时促进团队内外更好的协作。在本节中，你将学习如何搜索组、查看组属性、创建新组，并通过分享数据到组以及添加或移除组内用户来管理组。

搜索组

搜索组与搜索数据非常相似。你可以在匿名登录时搜索公开的组，或者在登录到组织时搜索你所在组织内的组。你将首先匿名搜索组，然后访问你创建的组的属性。接着，你将搜索你所在组织内的组。

  1. 右键点击Chapter3文件夹，选择新建>笔记本。将笔记本重命名为SearchForGroups。

  2. 在第一个单元格中输入导入语句并创建你的 GIS。你将匿名创建 GIS。

    from arcgis.gis import GIS
from IPython.display import display
gis = GIS()

    点击运行按钮来执行。

  3. 在下一个单元格中，你将创建搜索并显示结果。就像功能图层一样，你将把数据搜索限制为前 5 条记录。你还将使用显示模块更好地展示组信息。输入以下代码。

    oaklandGroups = gis.groups.search('title:Oakland',max_groups=5)
for group in oaklandGroups:
    display(group)

    点击运行按钮来执行。你应该能看到如下图所示的结果。

    奥克兰组搜索的结果。

  4. 就像搜索项目一样，你也可以按所有者而不是标题搜索组。你将使用搜索结果中的一个组所有者。输入以下代码。

    oaklandGroups2 = gis.groups.search('owner:DebusB@oakgov.com_oakgov',max_groups=5)
for group in oaklandGroups2:
    display(group)

    点击运行按钮来执行。你应该能看到如下图所示的结果。

    按所有者搜索组的结果。

  5. 就像搜索项目一样，组搜索返回一个列表。要查看组的详细属性，你需要通过列表索引选择它。你将选择第一次搜索中的第一个组，查看其属性。输入以下代码。

    oaklandGroup1 = oaklandGroups[0]
oaklandGroup1

    点击运行按钮来执行。你应该能看到如下图所示的结果。

    从组列表中选择组的结果。

  6. 现在你可以看到小组的一些属性。你将使用 .format() 输出这些值，以便为输出的值添加一些上下文信息。

    print("Group Access is : {}".format(oaklandGroup1.access))
print("Group id is: {}".format(oaklandGroup1.id))
print("Group Tags are : {}".format(", ".join(oaklandGroup1.tags)))
print("Group is Invitation only: {}".format(oaklandGroup1.isInvitationOnly))

    点击 Run 按钮以运行。你应该看到如下图所示的结果

    小组属性的结果

    你可以访问小组的更多属性。完整的列表请参见这里：developers.arcgis.com/rest/users-groups-and-items/group-search.htm

  7. 要在组织内部搜索小组，你需要登录到你的 GIS。通过在下一个单元格中输入以下内容来创建一个新的 GIS。

    gis2 = GIS('home')

    点击 Run 按钮以运行

  8. 在下一个单元格中，你将运行一个搜索，查找所有你所在组织中你有权限访问的小组。

    myGroups = gis2.groups.search(query="*",max_groups=5)
for group in myGroups:
    display(group)

    点击 Run 按钮以运行。你应该最多看到 5 个小组。如果你不是 5 个小组的成员，你将只看到你所在的小组。如果你想查看你是所有小组的成员，可以去掉 max_groups=5

创建小组

现在你已经看过如何在组织中搜索小组，接下来你需要创建一个小组。你可以创建小组来公开分享数据，或者仅与小组成员分享。接下来你将学习如何创建一个公开共享数据的小组。你还将看到创建私人小组所需的参数以及如何更改设置。

  1. 右键点击 Chapter3 文件夹并选择 New>Notebook。将笔记本重命名为 CreateGroupMoveData

  2. 你将通过你当前登录 ArcGIS Pro 的用户登录到组织的 GIS，输入以下内容。

    from arcgis.gis import GIS
from IPython.display import display
gis = GIS("home")

    点击 Run 按钮以运行

  3. 在下一个单元格中，你将使用小组模块的 create 方法来创建小组。create 方法需要 5 个参数，参数解释见下表。输入以下内容：

    farmerMarketGroup = gis.groups.create(title="Alameda County Farmers Markets",
                                      tags="Alameda County, Farmers Market",
                                      description = "Group with data for Alameda County Farmers Markets.",
                                      access = "public",
                                      is_invitation_only = "False"
                                     )

    点击 Run 按钮以运行

你应该不会收到退出消息，但你已经创建了一个新的公共小组。要验证这一点，你可以进入你的 ArcGIS Online 账户并查看“Groups”部分。你也可以输入 farmerMarketGroup 并点击 Run 按钮来查看该小组。它应该看起来像下面这样。

新创建的小组。

为了创建小组，你使用了 5 个参数：标题、标签、描述、访问权限、is_invitation_only。这些是你在设置新小组时应使用的最基本的参数，它们为小组设置标题、标签、描述，并设置基本的访问权限。下面的表格列出了这些参数及其可能的值。

title 单引号或双引号之间的字符串，作为你小组的标题
tags 单引号或双引号之间的字符串，标签之间用逗号分隔。返回时，它是一个列表
description 单引号或双引号之间的字符串，作为你小组的描述
access 用单引号或双引号括起来的字符串，用于设置访问权限。访问权限的值可以是：org、private、public。Org 是指你的组织中的每个人都能看到的组。Private 是一个私密的组，只有被邀请的用户可以查看。Public 是一个公开的组，任何人都可以访问。
is_invitation_only 用单引号或双引号括起来的字符串，表示布尔值。当设置为 True 时，用户只能在被邀请后才能访问。当设置为 False 时，用户可以请求访问或被邀请。

你可以通过输入组的变量、点和相应的值来验证任何设置。要验证你刚创建的组的访问权限，可以在下一个单元格中输入以下内容

farmerMarketGroup.access

然后点击运行以执行。

你应该能看到以下输出。

验证组的访问权限。

要更改组的任何值，可以使用更新功能。更新功能采用与创建组时相同的所有参数。要更新以下内容的访问类型

farmerMarketGroup.update(access = "private")

然后点击运行以执行。

现在你已经创建了一个新组，并了解了如何更改该组的值。下一步是与组共享数据。

向组共享内容

一个空组没有什么用处。创建组的目的是共享数据，不管是公开共享还是与其他用户共享。在这一部分，你将看到如何与组共享数据。

  1. 你需要访问包含阿拉梅达县农贸市场的功能层。在上面同一个 Notebook 的下一个单元格中，你将使用search()方法来获取阿拉梅达县农贸市场的功能层。搜索方法返回一个列表，但你知道该列表中只有一个项，因此可以在搜索方法的末尾加上[0]，只返回列表中的第一个值。输入以下内容

    alamedaFM = gis.content.search(query="title:Farmers Markets in Alameda County")[0]
alamedaFM

    点击运行以执行。你应该能看到阿拉梅达县农贸市场功能层的显示

  2. 现在你可以通过输入以下内容来检查功能层的访问权限

    alamedaFM.access

    点击运行以执行。你应该能看到返回‘private’

  3. 现在你有了一个功能层，可以与组共享它。为了与组共享，你将使用share()方法，并使用两个参数来设置共享给组时的组织共享级别。org 参数可以设置为 True 或 False，当设置为 True 时，它将与整个组织共享该项；当设置为 False 时，它仅与该组共享。group 参数接受组的 id。由于你有一个保存该组的变量，你只需要通过使用 id 方法访问它的 id。输入以下内容

    alamedaFM.share(org=False,groups=farmerMarketGroup.id)

    点击运行以执行。你应该能看到以下结果

    向组共享项目的结果

  4. 你可以通过对任何项调用shared_with方法来检查其共享级别。要查看这一点，输入以下内容

    alamedaFM.shared_with

    点击运行以执行。你应该能看到以下结果

    shared_with 的结果

    结果是一个字典，其中包含有关每个用户、组织和组的值，表示该项目现在已与这些内容共享。

既然你已经向该组共享了一些数据，现在你需要添加或邀请用户加入该组。

向组添加、邀请和移除用户

添加、邀请和移除用户的代码类似。它们都对该组应用一种方法。该方法接受一个包含用户名的字符串列表作为参数。下表展示了使用我们示例中的农贸市场组的语法。

add_users farmerMarketGroup.add_users([“user1”,”user2”, . . .])
invite_users farmerMarketGroup.invite_users([“user1”,”user2”, . . .])
remove_users farmerMarketGroup.remove_users([“user1”,”user2”, . . .])

当执行上述任何代码时，输出将是一个字典，列出已添加、邀请或移除的用户及其详细信息。组的所有者不能被移除。

哪些用户可以属于某个组取决于你的组织类型。在某些情况下，组织不允许外部用户或公共用户成为组的成员。

现在你已经创建了一个组，向其共享了数据并添加或邀请了新的用户。接下来，你将看到如何管理用户。

管理用户

通过 Python 的 ArcGIS API 管理你组织中的用户可以节省时间，因为你可以创建并运行笔记本，以快速创建新用户、访问用户数据、重新分配用户内容和删除用户。第一步是理解 User 类，以了解你可以查看哪些关于用户的信息。

用户属性

为了更好地了解用户的属性，你将查看自己的账户并探索不同的用户属性。

  1. 右键点击Chapter3文件夹，选择新建>笔记本。将笔记本重命名为UserProperties

  2. 你将通过当前在 ArcGIS Pro 中登录的用户登录到你的组织的 GIS，输入以下内容：

    from arcgis.gis import GIS
from IPython.display import display
gis = GIS('home')

    点击运行以执行

  3. 在下一个单元中，你将通过使用 me 属性查看自己的账户。输入以下内容：

    me = gis.users.me
me

    点击运行以执行。你应该能看到返回的内容，其中包含你的用户信息。

    用户信息

  4. 你可以识别用户档案的许多不同方面。比如用户的名字和姓氏、电子邮件地址、最后一次访问账户的时间、他们是哪些组的成员以及他们使用的存储量等。你将提取并写出所有这些信息。你需要导入时间模块，将返回的时间转换为月/日/年格式。groups 属性返回一个数据字典。为了访问名称，你需要创建一个空列表，并通过数据字典迭代访问每个标题，并将其附加到组中，然后使用 join 函数将组的内容写入字符串。接下来，在下一个单元中输入以下内容：

    import time
firstName = me.firstName
lastName = me.lastName
email = me.email
accessedLast = time.localtime(me.lastLogin/1000)
groups = me.groups
myGroupsList =[]
for group in groups:
    groupName = group["title"]
    myGroupsList.append(groupName)
groupsName = ", ".join(myGroupsList)
storageAssigned = me.storageQuota
storageUsed = me.storageUsage
prctStorage = round((storageUsed/storageAssigned)*100,4)
print("First Name:           {0}".format(firstName))
print("Last Name:            {0}".format(lastName))
print("email:                {0}".format(email))
print("Last Accessed:        {0}/{1}/{2}".format(accessedLast[1],accessedLast[2],accessedLast[0]))
print("Groups:               {0}".format(groupsName))
print("Storage Assigned:     {0}.".format(storageAssigned))
print("Storage Used:         {0}.".format(storageUsed))
print("Percent Storage Used: {0}".format(prctStorage))

    点击运行来执行。你应该看到以下返回的内容，其中包含你的用户信息

返回的用户信息

另一个有用的返回项是可用积分。为此，你需要开启积分预算功能。在后续部分，你将深入了解作为管理员如何管理积分，并且你可以将这些代码添加到你上面的代码中，来查找可用积分。

用户搜索

你可以像搜索项目或组一样搜索用户。你可以设置查询条件，通过用户名查找用户，或者通过电子邮件地址查找用户。你将设置一个包含这两种搜索示例的笔记本，供你进一步在组织内搜索用户使用。

  1. 右键点击Chapter5文件夹并选择新建>笔记本。将笔记本重命名为SearchForUsers

  2. 你将通过你当前在 ArcGIS Pro 中登录的用户，登录到你组织的 GIS 中，输入以下内容

    from arcgis.gis import GIS
from IPython.display import display
gis = GIS('home')

    点击运行来执行

  3. 首先，你将通过用户名搜索用户。在代码中的{userNameSearch}部分，你将输入你的用户名。用户搜索与之前的所有搜索相似，它返回一个值的列表。因为你是在搜索特定的用户名，所以列表应该只有一个。为了确保，你将运行一个测试，打印出列表的长度。输入以下内容

    userNameSearch = gis.users.search(query="username:{userNameSearch}")
len(userNameSearch)

    点击运行来执行

    用户名搜索结果

  4. 要访问返回的用户，你需要使用列表索引提取第一个用户。然后显示这些结果。输入以下内容

    userNameSelect = userNameSearch[0]
userNameSelect

    点击运行来执行

    选择单个用户的结果

  5. 你也可以使用通配符*通过电子邮件进行搜索。这允许你搜索来自相同电子邮件提供商的所有电子邮件地址。代码与按用户名搜索时相同，只是查询部分有所不同。在这个示例中，你将在{@email.com}中输入你自己的电子邮件提供商。你再次需要查找返回给你的列表长度，然后再提取用户。接着在下一个单元格中输入以下内容。

    emailSearch = gis.users.search(query="email: *{@email.com}")
len(emailSearch)

    点击运行来执行

  6. 根据你所在组织中有多少人使用该电子邮件主机，你可能会有一个很大的用户列表。你可以使用for循环逐个遍历这些用户，并打印出来自上一个笔记本的用户信息。输入以下内容

    import time
for user in emailSearch:
    firstName = user.firstName
    lastName = user.lastName
    email = user.email
    accessedLast = time.localtime(user.lastLogin/1000)
    groups = user.groups
    myGroupsList =[]
    for group in groups:
        groupName = group["title"]
        myGroupsList.append(groupName)
    groupsName = ", ".join(myGroupsList)
    storageAssigned = user.storageQuota
    storageUsed = user.storageUsage
    prctStorage = round((storageUsed/storageAssigned)*100,4)
    print("--------------------------------------------")
    print("First Name:           {0}".format(firstName))
    print("Last Name:            {0}".format(lastName))
    print("email:                {0}".format(email))
    print("Last Accessed:        {0}/{1}/{2}".format(accessedLast[1],accessedLast[2],accessedLast[0]))
    print("Groups:               {0}".format(groupsName))
    print("Storage Assigned:     {0}.".format(storageAssigned))
    print("Storage Used:         {0}.".format(storageUsed))
    print("Percent Storage Used: {0}".format(prctStorage))

    点击运行来执行。它将打印出每个搜索结果中的用户信息，结果之间用-----------分隔。

用户搜索信息。

你已经学会了如何在组织内搜索用户并打印出用户信息。在接下来的部分，你将看到一些可以应用于用户的管理员权限。

管理你的 GIS

在本节中，你将探索如果你是管理员并且拥有管理员权限，你能做什么。有了管理员权限，你可以添加和移除用户、管理用户许可证和管理 ArcGIS Online 积分。在本节中，你将学习如何执行这些操作。

你必须拥有管理员权限才能执行以下操作。要添加用户，你必须为新用户提供凭证。

创建和删除用户

要在 ArcGIS Online 中创建新用户，你将使用 create() 方法。create() 方法需要以下参数：username、password、firstname、lastname、email、description、role、user_type 和 provider。

username 用户名的字符串值
password 密码的字符串值，用户可以在任何时候登录时更改此密码
firstname 用户的名字的字符串值
lastname 用户姓氏的字符串值
email 用户的电子邮件地址的字符串值
description 用户描述的字符串值
role 用户在组织中的角色的字符串值。ArcGIS Online 有三个选项，org_admin 是具有管理员权限的组织管理员，org_publisher 是可以发布 Web 图层和服务图层的发布者，org_user 是可以创建小组和内容并使用组织数据的普通用户
user_type 组织中用户类型的字符串值，viewer_UT 适用于需要查看与他们共享的数据的用户，他们不能创建或编辑数据；fieldworkerUT 适用于需要查看和编辑数据的用户，通常通过现场应用程序与数据互动；editor_UT 适用于需要查看和编辑与他们共享的数据的用户，他们不能创建或共享数据；creator_UT 适用于需要创建和共享内容（如 Web 地图和应用程序）的用户；GISProfessionalBasicUT 适用于具有所有创建者功能并能访问 ArcGIS Pro Basic 的用户；GISProfessionalStdUT 适用于具有所有创建者功能并能访问 ArcGIS Pro Standard 的用户；GISProfessionalAdvUT 适用于具有所有创建者功能并能访问 ArcGIS Pro Advanced 的用户
provider 提供者的字符串值，arcgis 代表 ArcGIS Online，enterprise 代表 ArcGIS Enterprise

使用此表格，你可以创建新的用户。

  1. 右键点击 Chapter5 文件夹并选择新建>笔记本。将笔记本重命名为 AdminsteringYourOrg

  2. 你将通过当前在 ArcGIS Pro 中登录的用户登录到你组织的 GIS，方法是输入以下内容

    from arcgis.gis import GIS
from IPython.display import display
gis = GIS('home')

    点击运行以执行

  3. 你将创建一个新的示例用户。你需要为其分配用户名、密码、名字、姓氏、电子邮件、描述、角色、用户类型和提供者。请键入以下内容

    newUser = gis.users.create(username = "newUser1",
                           password = "1234PleaseChange",
                           firstname = "New",
                           lastname = "User",
                           email = "newUser@company.com",
                           description  = "Creating a new user",
                           role = "org_publisher",
                           user_type = "GISProfessionalAdvUT",
                           provider = "arcgis"                          
                          )

    点击运行以执行。如果执行成功，你应该不会得到任何结果。

  4. 在下一个单元格中输入 newUser，然后点击运行以执行

  5. 删除用户时，首先要确保不会丢失任何数据。作为管理员，您可以将用户的数据重新分配给其他用户。第一步是找到该用户的所有数据。请回忆之前的内容，您可以根据所有者的用户名搜索内容。在下一个单元中输入以下内容：

    items = gis.content.search(query="owner: newUser1")

    点击运行以执行。

  6. 要将所有项目重新分配给新用户，您需要遍历项目列表，并调用reassign_to方法。reassign_to方法需要target_owner和target_folder参数。如果没有为target_folder指定名称，它将把项目放在根文件夹中。现在，您可以通过输入以下内容将所有数据从 newUser 重新分配给自己：

    for item in items:
    item.reassign_to(target_owner = "{yourUserName}")

    点击运行以执行。您应该不会得到任何输出。

  7. 现在，您可以删除该用户，因为他们的所有数据已经重新分配。在下一个单元中输入：

    newUser1.delete()

    点击运行以执行。您应该不会得到任何输出。

删除用户时，您可以重新分配该用户的所有项目。但您只能将其重新分配到根文件夹。为此，您需要写入newUser.delete(reassign_to ={userNameToAssignTo}”

您已经看到如何创建用户，以及在创建用户时可以分配的不同属性。您还看到了如何重新分配用户的数据并删除该用户。接下来，您将看到如何分配许可证并监控用户的积分。

分配许可证和积分

您可以通过笔记本管理用户许可证和积分。可以为用户分配许可证并撤销该许可证。您可以查看您组织中的可用积分，并通过信用预算管理这些积分。您将首先看到如何检查您组织中的应用程序，然后查看您组织中的许可证，并学习如何分配这些许可证。

  1. 继续在AdminsteringYourOrg笔记本中工作，通过查找您组织中所有授权的应用程序。您将创建一个变量来保存应用程序列表，然后使用循环逐行打印出每个应用程序。输入以下内容：

    license = gis.admin.license.all()
for l in license:
    print(l)

    点击运行以执行。您将看到您组织中已授权的应用程序。

  2. 在下一个单元中，您将使用 get 方法获取 ArcGIS Pro 应用程序的许可证，以便查看您拥有的具体许可证。输入以下内容：

    proLic = gis.admin.license.get("ArcGIS Pro")

    点击运行以执行。您应该不会得到任何输出。

  3. 现在，您拥有 Pro 应用程序许可证，可以查看您已授权的扩展名，以及是否已分配任何扩展名。您正在使用报告对象来获取一个表格，显示您拥有的许可证、已分配的数量以及剩余的数量。输入以下内容：

    proLic.report

    点击运行以执行。您应该会看到一个类似于下方的表格，只是显示的是您组织中的许可证。

    您组织中的 ArcGIS Pro 许可证

  4. 现在您已经知道可用的许可证，您可以分配一个。您使用分配方法，用户名和扩展名作为授权参数。为自己分配一个空间分析师许可证。

    proLic.assign(username = me.username,entitlements="spatialAnalystN")

    点击运行以执行。如果已分配，您的结果应该是True。

  5. 您可以检查用户分配了什么扩展名。您可以使用 user_entitlement 方法，将用户名作为参数传递。检查您分配给您的扩展名，输入以下内容，并在引号之间输入您的用户名。

    proLic.user_entitlement("{yourUserName}")

    单击 运行 以运行。结果是带有用户名、最后登录、连接和授予权利的列表的字典作为键值对。

    分配给用户的扩展

  6. 要撤销许可证，您可以在许可证对象上使用 revoke 方法。参数与 assign 相同，用户名和要撤销的扩展名。您可以使用 * 通配符来撤销所有许可证。撤销分配给您的所有许可证。

    proLic.revoke(username = me.username,entitlements="*")

    单击 运行 以运行。如果分配，则您的结果应为 真

  7. 要验证您没有许可证，请再次使用 user_entitlement 方法

    proLic.user_entitlement("{yourUserName}")

    单击 运行 以运行。结果是一个空字典。

  8. 您可以使用 credits 属性查看组织中可用的信用额度。输入以下内容

    gis.admin.credits.credits

    单击 运行 以运行。结果将是组织中信用点的数量。

  9. 您可以通过使用信用预算来管理每个用户的可用信用额度。通过在积分属性上使用 enable 方法打开信用预算。

    gis.admin.credits.enable()

    单击 运行 以运行。您的结果应为 真

  10. 现在，您可以使用分配方法为用户分配积分。分配方法以用户名和积分数作为其参数。为自己分配 10 个积分

    gis.admin.credits.allocate(username=me.username, credits=api_acc_credits)

    单击 运行 以运行。您的结果应为 真

    您还可以通过使用分配方法从用户那里删除积分。分配方法从用户那里删除所有积分。如果您想删除所有积分，则应键入以下内容 gis.admin.credits.deallocate(username='{username}')

  11. 当启用信用预算时，您可以检查每个用户的可用信用额度，因为他们分配了信用额度和可用信用额度属性。检查您可用的信用额度

    me.availableCredits

    单击 运行 以运行。结果将是您可用的信用额度数量。如果您使用单用户帐户，则无法向自己分配积分，因为您可以访问所有积分

摘要

在本节中，您已经看到如何在组织内外搜索内容。您现在可以创建新文件夹来组织您的内容。您可以创建组，并设置不同的共享级别以通过邀请用户到您的组来共享内容。使用管理设置，您可以创建具有不同角色和类型的新用户。您可以搜索现有用户并提取有关其角色和拥有的数据，他们是成员的组和使用的存储的信息。您可以为用户管理许可证和预算积分。总之，您有管理您的组织的内容和用户的工具和笔记本电脑。

第五章：反馈

发表您的意见！帮助我们的作者为像您一样的客户提供有用的信息。请填写我们的快速调查，给出您的反馈。我们很想了解您作为读者的更多体验。

请记住，早期访问章节是初稿，因此还没有经过编辑的最终润色。

posted @ 2025-07-16 12:31  绝不原创的飞龙  阅读(53)  评论(0)    收藏  举报