目录
[第二篇 实践篇](#第二篇 实践篇)
[1 python基础与遥感深度学习境配置](#1 python基础与遥感深度学习境配置)
[1.1.1.1 anconda安装](#1.1.1.1 anconda安装)
[1.1.1.2 pycharm安装](#1.1.1.2 pycharm安装)
[1.1.1.3 Python环境配置](#1.1.1.3 Python环境配置)
第二篇 实践篇
1 python基础与遥感深度学习境配置
这一小节将对Python语言的一些基础进行介绍，Python比较的熟悉的同学可以跳过。
1.1初识Python
1.1.1Python安装与环境配置
python的安装主要分为python独立安装和anconda附带安装两种，我个人比较推荐anconda附带安装，因为anconda提供了强大的第三方包的管理能力，配合pycharm写代码爽歪歪。
接下来我以anconda安装以及pycharm配置为例。
1.1.1.1 anconda安装
1、下载安装包
推荐使用通过清华镜像源下载，下载速度较快，链接如下，可根据date选择最新版本
https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/?C=M&O=D
2、安装anconda
推荐使用管理员权限运行安装，避免不必要的麻烦
点击Next
I agree 同意
两个选择，我在使用时影响不大，可选择默认选项all users，点击next
选择安装路径，如果C盘空间充足建议默认路径，next
默认选项即可，install，然后稍定几分钟。。。。
next，next然后完成了安装！！！
1.1.1.2 pycharm安装
1.下载安装包https://www.jetbrains.com/pycharm/download/?section=windows 下载社区版就基本够用
2.安装pycharm
找到你下载PyCharm的路径，双击.exe文件进行安装。
点击 Next 后，我们进行选择安装路径页面（尽量不要选择带中文和空格的目录）选择好路径后，点击 Next 进行下一步
进入 Installation Options（安装选项）页面，全部勾选上。点击 Next
进入 Choose Start Menu Folder 页面，直接点击 Install 进行安装
5.等待安装完成后出现下图界面，我们点击 Finish 完成。
3.汉化
File->Settings->Plugins（插件）在搜索栏中输入Chinese（Simplified)下载中文插件并安装重启PyCharm即出现汉化
1.1.1.3 Python环境配置
1.anconda环境配置
打开anconda，点击environment
新安装后的anconda只有一个base环境，如果新建环境点击create
给环境起一个名称，选择python的版本 ，填写好后点击create 稍定几分钟就创建好了
2、在虚拟环境中安装第三方库（界面化操作）
把左上方下拉框选为 not installed 在右上方搜索，如gdal、Scikit learn、numpy。pytorch等
然后勾选需要的库
点击apply 进行安装
3、虚拟环境的使用（pycharm内使用）
打开pycharm
新建项目，使用先前配置的解释器
使用conda环境，确定，就可使用。
1.1.2第一个python程序
1 新建python项目
文件->新建项目->新建一个文件夹"python-learn"->选择该文件夹->选择一个python环境->创建
新建之后，pycharm自动生产了一个简易模版
2 编写"Holle world"
在模版的基础上修改一下，删除一些注释
def print_hi(name):
print(f'Hi, {name}')
if __name__ == '__main__':
print_hi('Holle world')3 运行python代码
右键点击"运行'main'"，下方就会打印出Hi,Holle world的文本
1.2Python基础
1.2.1数据类型与变量
1 什么是数据类型
在计算机编程中，数据类型是指变量或表达式可以存储或处理的数据的种类。它定义了数据的特性、可操作性以及可能的值范围。常见的数据类型包括整数、浮点数、字符、字符串、布尔值等。
下面是Python中常见的数据类型及其常用方法：
- 整数 (int)：常用方法包括：
abs()（返回绝对值）、bin()（将整数转换为二进制字符串）、hex()（将整数转换为十六进制字符串）、int()（将字符串或浮点数转换为整数）等。 - 浮点数 (float)：常用方法包括：
abs()（返回绝对值）、round()（四舍五入取整）、is_integer()（判断是否为整数）等。 - 字符串 (str)：常用方法包括：
len()（返回字符串长度）、upper()（将字符串转换为大写）、lower()（将字符串转换为小写）、split()（将字符串拆分为列表）等。 - 列表 (list)：常用方法包括：
append()（将元素追加到列表末尾）、pop()（删除并返回列表中的最后一个元素）、insert()（在指定位置插入元素）、sort()（对列表进行排序）等。 - 元组 (tuple)：元组是不可变的，因此没有修改元素的特定方法。可以使用索引访问元素，也可以使用
len()获取元组的长度。 - 字典 (dict)：常用方法包括：
keys()（返回字典中的所有键）、values()（返回字典中的所有值）、get()（根据键获取值，可以设置默认值）等。 - 集合 (set)：常用方法包括：
add()（向集合中添加元素）、remove()（删除集合中的元素）、union()（返回两个集合的并集）、intersection()（返回两个集合的交集）等。 - 布尔值 (bool)：布尔值主要用于逻辑判断，常用于条件语句中。
此外，各个数据类型还有更多的内置方法和功能，可以根据具体需求查阅官方文档以获取详细信息。
2 什么是变量
在计算机编程中，变量是用于存储和表示数据的一种命名标识符。它可以将一个值或数据对象赋值给一个变量，以便在程序中进行处理、操作和引用。
在 Python 中，定义变量时不需要事先声明变量的类型，可以直接给变量赋值，解释器会根据赋的值自动推断变量的类型。变量名可以包含字母、数字和下划线，但不能以数字开头。
以下是一些关于变量的基本知识：
- 变量赋值：使用等号（=）将值赋给变量。例如：
x = 5，将数字 5 赋给变量 x。 - 变量命名规则：变量名只能包含字母、数字和下划线，但不能以数字开头。变量名区分大小写，例如，
myVar和myvar是不同的变量名。 - 变量类型：变量的类型由赋给它的值决定。变量可以随时更改其值和类型。
- 变量引用：变量本质上是一个指向存储值的内存地址的名称。多个变量可以引用相同的值。
- 动态类型：Python 是一种动态类型语言，允许在运行时更改变量的类型。
- 变量命名习惯：为了提高代码的可读性，建议使用具有描述性的变量名，使其易于理解变量的用途。
以下是一些使用变量的示例：
x = 10 # 将整数值 10 赋给变量 x
y = "Hello" # 将字符串值 "Hello" 赋给变量 y
z = [1, 2, 3] # 将列表 [1, 2, 3] 赋给变量 z
# 变量之间的运算和操作
a = x + 5 # x 和 5 相加，结果赋给变量 a
b = y + " World" # 字符串拼接，结果赋给变量 b
z.append(4) # 在列表 z 中添加一个元素 4
print(a) # 输出变量 a 的值
print(b) # 输出变量 b 的值
print(z) # 输出变量 z 的值通过使用变量，可以在程序中存储和操作数据，使代码更加灵活和可读。
1.2.1.1整数 (int)
以下是一些常用的整型方法和示例：
-
int()：将其他数据类型转换为整型。num1 = int(3.5)
num1 的值为 3
-
+、-、*、/：整型之间的基本算术运算。num2 = 5 + 2
num2 的值为 7
num3 = 9 - 4
num3 的值为 5
num4 = 3 * 4
num4 的值为 12
num5 = 10 / 2
num5 的值为 5.0
-
%：取模运算，返回两个数相除的余数。num6 = 10 % 3
num6 的值为 1
-
//：整数除法，返回两个数相除后的整数部分。num7 = 10 // 3
num7 的值为 3
-
**：幂运算，返回一个数的指数幂。num8 = 2 ** 3
num8 的值为 8
-
abs()：返回一个数的绝对值。num9 = abs(-5)
num9 的值为 5
1.2.1.2浮点数 (float)
以下是一些常用的浮点型方法和示例：
-
float()：将其他数据类型转换为浮点型。num1 = float(3)
num1 的值为 3.0
-
+、-、*、/：浮点型之间的基本算术运算。num2 = 3.5 + 2.1
num2 的值为 5.6
num3 = 8.9 - 4.3
num3 的值为 4.6
num4 = 2.5 * 4
num4 的值为 10.0
num5 = 9.0 / 2
num5 的值为 4.5
-
math.floor()：返回一个浮点数的向下取整值。import math
num6 = math.floor(3.7)
num6 的值为 3
-
math.ceil()：返回一个浮点数的向上取整值。import math
num7 = math.ceil(3.2)
num7 的值为 4
-
round()：返回一个浮点数的四舍五入值。num8 = round(2.9)
num8 的值为 3
num9 = round(3.1)
num9 的值为 3
-
math.sqrt()：返回一个浮点数的平方根值。import math
num10 = math.sqrt(9)
num10 的值为 3.0
1.2.1.3字符串 (str)
以下是一些常用的字符串方法和示例：
-
len()：返回一个字符串的长度（即字符数）。length 的值为 12
-
+：字符串拼接。str2 = 'Hello' + ' ' + 'World!'
str2 的值为 'Hello World!'
-
*：字符串复制。str3 = 'Hello' * 3
str3 的值为 'HelloHelloHello'
-
str.upper()：将字符串中的所有字符转换为大写字母。str4 = 'hello world!'
upper_str = str4.upper()upper_str 的值为 'HELLO WORLD!'
-
str.lower()：将字符串中的所有字符转换为小写字母。str5 = 'HELLO WORLD!'
lower_str = str5.lower()lower_str 的值为 'hello world!'
-
str.capitalize()：将字符串的第一个字符转换为大写字母，其他字符转换为小写字母。str6 = 'hello world!'
cap_str = str6.capitalize()cap_str 的值为 'Hello world!'
-
str.count()：返回一个字符串中某个子串出现的次数。str7 = 'Hello World!'
count = str7.count('l')count 的值为 3
-
str.replace()：替换字符串中的某个子串。str8 = 'hello world!'
new_str = str8.replace('world', 'python')new_str 的值为 'hello python!'
-
str.split()：将字符串按照指定分隔符拆分成列表。str9 = 'hello,world,python'
split_str = str9.split(',')split_str 的值为 ['hello', 'world', 'python']
1.2.1.4布尔值 (bool)
尔值数据类型表示逻辑上的真(True)或假(False)。以下是一些常用的布尔值方法和示例：
-
True和False：布尔字面值，分别代表真和假。bool1 = True
bool2 = False -
==、!=、>、<、>=、<=：比较运算符，用于比较两个值之间的关系，返回布尔值。num1 = 10
num2 = 5bool3 = num1 == num2
bool3 的值为 False
bool4 = num1 > num2
bool4 的值为 True
-
and、or、not：逻辑运算符，用于组合多个布尔表达式，返回布尔值。bool5 = True and False
bool5 的值为 False
bool6 = True or False
bool6 的值为 True
bool7 = not True
bool7 的值为 False
-
bool()：将其他数据类型转换为布尔值。bool8 = bool(0)
bool8 的值为 False
bool9 = bool(10)
bool9 的值为 True
布尔值常用于条件语句和逻辑判断中，用于控制程序的执行流程。
1.2.1.5列表 (list)
列表数据 list，可以存储多个值，支持添加、删除、修改等操作。以下是一些常用的列表方法和示例：
-
[]：列表字面值，用方括号括起来表示一个列表，元素之间用逗号隔开。list1 = [1, 2, 3, 'hello', True]
-
len()：返回一个列表的长度（即元素个数）。list2 = [1, 2, 3, 4, 5]
length = len(list2)length 的值为 5
-
+：列表拼接，将两个列表合并成一个新的列表。list3 = [1, 2, 3]
list4 = [4, 5, 6]
new_list = list3 + list4new_list 的值为 [1, 2, 3, 4, 5, 6]
-
*：列表复制，将列表中的元素重复多次。list5 = [1, 2, 3]
new_list = list5 * 3new_list 的值为 [1, 2, 3, 1, 2, 3, 1, 2, 3]
-
append()：在列表的末尾添加新的元素。list6 = [1, 2, 3]
list6.append(4)list6 的值为 [1, 2, 3, 4]
-
extend()：在列表的末尾添加多个元素，相当于将一个列表合并到另一个列表的末尾。list7 = [1, 2, 3]
list7.extend([4, 5, 6])list7 的值为 [1, 2, 3, 4, 5, 6]
-
insert()：在列表的指定位置插入一个新的元素。list8 = [1, 2, 3]
list8.insert(1, 'hello')list8 的值为 [1, 'hello', 2, 3]
-
remove()：从列表中删除第一个匹配的元素。list9 = [1, 2, 3, 4, 5]
list9.remove(3)list9 的值为 [1, 2, 4, 5]
-
pop()：从列表中删除并返回指定位置的元素。list10 = [1, 2, 3, 4, 5]
popped = list10.pop(2)popped 的值为 3，list10 的值为 [1, 2, 4, 5]
-
index()：返回列表中第一个匹配元素的索引值。list11 = [1, 2, 3, 4, 5]
index = list11.index(3)index 的值为 2
-
count()：返回列表中指定元素的出现次数。list12 = [1, 2, 3, 4, 3, 5, 3]
count = list12.count(3)count 的值为 3
-
sort()：对列表中的元素进行排序，默认为升序排序。list13 = [2, 5, 1, 3, 4]
list13.sort()list13 的值为 [1, 2, 3, 4, 5]
-
reverse()：将列表中的元素反转。list14 = [1, 2, 3, 4, 5]
list14.reverse()list14 的值为 [5, 4, 3, 2, 1]
-
copy()：复制一个列表，返回一个新的列表。list15 = [1, 2, 3]
new_list = list15.copy()new_list 的值为 [1, 2, 3]
-
clear()：清空列表中的所有元素。list16 = [1, 2, 3]
list16.clear()list16 的值为 []
-
slice：通过切片操作截取列表的一部分。list17 = [1, 2, 3, 4, 5]
sub_list = list17[1:4]sub_list 的值为 [2, 3, 4]
-
in和not in：判断一个元素是否存在于列表中。list18 = [1, 2, 3, 4, 5]
result1 = 3 in list18
result2 = 6 not in list18result1 的值为 True，result2 的值为 True
-
max()和min()：返回列表中的最大值和最小值。list19 = [1, 2, 3, 4, 5]
max_value = max(list19)
min_value = min(list19)max_value 的值为 5，min_value 的值为 1
-
sum()：计算列表中所有元素的总和。list20 = [1, 2, 3, 4, 5]
total = sum(list20)total 的值为 15
-
列表的索引和切片操作：使用索引和切片操作可以获取列表中的元素或子列表，也可以修改列表中的元素。
list21 = [1, 2, 3, 4, 5]
element_0 = list21[0]
sub_list = list21[1:4]
list21[2] = 6element_0 的值为 1，sub_list 的值为 [2, 3, 4]，list21 的值为 [1, 2, 6, 4, 5]
1.2.1.6元组 (tuple)
元组是一个有序、不可变的数据类型，用于存储多个元素。它使用圆括号 () 或 tuple() 构造。与列表类似，元组可以包含不同类型的元素，并且可以嵌套其他元组。
元组的特点是一旦创建后，其元素和长度都不能修改。这使得元组具有不可变性，适合用于表示不会改变的数据集，如一组坐标、数据库记录等。
以下是元组常用的方法和操作：
-
len()：返回元组中的元素数量。tuple1 = (1, 2, 3)
length = len(tuple1)length 的值为 3
-
索引和切片：使用索引访问元组中的元素，或使用切片操作访问子元组。
tuple2 = ("apple", "banana", "cherry")
element = tuple2[0]
sub_tuple = tuple2[1:3]element 的值为 "apple"，sub_tuple 的值为 ("banana", "cherry")
-
in和not in：判断元素是否存在于元组中。tuple3 = (1, 2, 3, 4, 5)
result1 = 3 in tuple3
result2 = 6 not in tuple3result1 的值为 True，result2 的值为 True
-
count()：统计元组中某个元素的出现次数。tuple4 = (1, 2, 2, 3, 2, 4, 5)
count = tuple4.count(2)count 的值为 3
-
index()：返回元素在元组中首次出现时的索引。tuple5 = (1, 2, 2, 3, 2, 4, 5)
index = tuple5.index(2)index 的值为 1
-
元组拆包：将元组的值赋给多个变量。
tuple6 = (1, 2, 3)
a, b, c = tuple6a 的值为 1，b 的值为 2，c 的值为 3
-
不可变性：元组的元素不可修改。
tuple7 = (1, 2, 3)
tuple7[1] = 4 # 会报错，元组不可修改
元组相对于列表而言，由于其不可变性，具有更高的内存效率，同时也可以用作字典的键。然而，在需要频繁修改或添加元素时，列表更为适合。
需要注意的是，当只有一个元素的时候，需要在元素后面加上逗号，以区分元组和普通括号的语法，例如 tuple8 = (1,)。
1.2.1.7集合（set)
集合是一个无序、可变的数据类型，用于存储唯一的元素。集合使用大括号 {} 或 set() 构造，元素之间使用逗号 , 分隔。和数学中的集合类似，集合中的元素是唯一且不可重复的。
以下是集合常用的方法和操作：
-
创建集合：通过大括号或
set()构造一个空集合或初始具有元素的集合。set1 = set()
set2 = {"apple", "banana", "cherry"} -
添加元素：使用
.add()方法向集合中添加一个元素，注意重复的元素会被忽略。set3 = {"apple", "banana"}
set3.add("cherry")set3 的值为 {"apple", "banana", "cherry"}，添加了一个新的元素
set3.add("apple")
set3 的值仍然为 {"apple", "banana", "cherry"}，忽略了重复的元素
-
删除元素：使用
.remove()或.discard()方法删除集合中的指定元素。如果元素不存在，.remove()会引发 KeyError，而.discard()不会抛出错误。set4 = {"apple", "banana", "cherry"}
set4.remove("banana")set4 的值为 {"apple", "cherry"}，删除了 "banana"
set4.discard("orange")
set4 的值仍然为 {"apple", "cherry"}，因为 "orange" 不存在，.discard() 不会引发错误
-
运算操作：集合支持多种集合操作，如并集、交集、差集和对称差集。
set5 = {"apple", "banana", "cherry"}
set6 = {"cherry", "orange", "pear"}union = set5.union(set6)
union 的值为 {"apple", "banana", "cherry", "orange", "pear"}，并集
intersection = set5.intersection(set6)
intersection 的值为 {"cherry"}，交集
difference = set5.difference(set6)
difference 的值为 {"apple", "banana"}，差集，属于 set5 但不属于 set6 的元素
symmetric_difference = set5.symmetric_difference(set6)
symmetric_difference 的值为 {"apple", "banana", "orange", "pear"}，对称差集，属于 set5 和 set6 中的元素但不重复的
-
.update()：使用另一个集合或可迭代对象中的元素更新当前集合。set7 = {1, 2, 3}
set8 = {3, 4, 5}set7.update(set8)
set7 的值为 {1, 2, 3, 4, 5}，将 set8 中的元素添加到 set7 中
set9 = {1, 2, 3}
set9.update([3, 4, 5])set9 的值为 {1, 2, 3, 4, 5}，将列表 [3, 4, 5] 中的元素添加到 set9 中
-
.copy()：复制一个集合的副本。set10 = {1, 2, 3}
set11 = set10.copy()set11 的值为 {1, 2, 3}，复制了 set10 的元素
集合是一种有用的数据类型，它可以帮助我们高效地进行去重、集合运算以及快速判断元素的存在性。需要注意的是，集合是无序的，元素的顺序是不确定的。
1.2.1.8字典 (dict)
字典是一种无序、可变的数据类型，用于存储键值对。它使用大括号 {} 或 dict() 构造，每个键值对使用冒号 : 分隔，键值对之间使用逗号 , 分隔。字典中的键必须是唯一的，而值可以是任何数据类型。
以下是字典常用的方法和操作：
-
创建字典：通过大括号或
dict()构造一个空字典或初始具有键值对的字典。dict1 = {}
dict2 = dict()dict3 = {"name": "Alice", "age": 25, "country": "USA"}
-
访问元素：通过键来访问字典中的值。
dict4 = {"name": "Bob", "age": 30, "country": "Canada"}
name = dict4["name"]name 的值为 "Bob"
-
添加或修改元素：通过键来添加新的键值对，或通过键来修改对应的值。
dict5 = {"name": "Alice", "age": 25, "country": "USA"}
dict5["occupation"] = "Engineer"
dict5 的值为 {"name": "Alice", "age": 25, "country": "USA", "occupation": "Engineer"}
dict5["age"] = 26
dict5 的值为 {"name": "Alice", "age": 26, "country": "USA", "occupation": "Engineer"}
-
删除元素：通过键来删除字典中的键值对。
dict6 = {"name": "Alice", "age": 25, "country": "USA"}
del dict6["age"]
dict6 的值为 {"name": "Alice", "country": "USA"}
-
.keys()、.values()和.items()：获取字典的键、值、键值对。dict7 = {"name": "Alice", "age": 25, "country": "USA"}
keys = dict7.keys()
keys 的值为 ["name", "age", "country"]
values = dict7.values()
values 的值为 ["Alice", 25, "USA"]
items = dict7.items()
items 的值为 [("name", "Alice"), ("age", 25), ("country", "USA")]
-
.get()：根据键获取对应的值，如果键不存在，则返回默认值。dict8 = {"name": "Bob", "age": 30, "country": "Canada"}
name = dict8.get("name")
name 的值为 "Bob"
gender = dict8.get("gender", "Unknown")
gender 的值为 "Unknown"，因为 "gender" 键不存在
-
.update()：用另一个字典中的键值对更新当前字典。dict9 = {"name": "Alice", "age": 25}
dict10 = {"country": "USA", "occupation": "Engineer"}dict9.update(dict10)
dict9 的值为 {"name": "Alice", "age": 25, "country": "USA", "occupation": "Engineer"}
字典是一种非常灵活且强大的数据结构，可用于存储和操作大量的关联数据。通过键值对的方式，使得数据的访问更加方便、快速。
1.2.2运算符与表达式
在 Python 中，运算符用于执行各种算术、逻辑和比较操作。而表达式是由运算符、操作数和函数调用组成的代码构造，用于计算结果。
以下是 Python 的常用运算符和表达式的介绍和示例：
1.算术运算符
-
-
+：加法运算，用于计算两个数的和。x = 5
y = 3
result = x + y # 结果为 8
-
-
-
-：减法运算，用于计算两个数的差。x = 5
y = 3
result = x - y # 结果为 2
-
-
-
*：乘法运算，用于计算两个数的积。x = 5
y = 3
result = x * y # 结果为 15
-
-
-
/：除法运算，用于计算两个数的商（浮点数除法）。x = 6
y = 2
result = x / y # 结果为 3.0
-
-
-
//：整数除法运算，用于计算两个数的商（整数除法）。x = 7
y = 2
result = x // y # 结果为 3
-
-
-
%：取模运算，用于计算两个数相除的余数。x = 7
y = 3
result = x % y # 结果为 1
-
-
-
**：幂运算，用于计算一个数的指数次幂。x = 2
y = 3
result = x ** y # 结果为 8
-
2.比较运算符
-
==：检查两个值是否相等。!=：检查两个值是否不相等。>：检查左值是否大于右值。<：检查左值是否小于右值。>=：检查左值是否大于等于右值。<=：检查左值是否小于等于右值。
这些比较运算符的结果是布尔值 True 或 False。例如：
x = 5
y = 3
result1 = x == y # 结果为 False
result2 = x < y # 结果为 False3.逻辑运算符
-
and：逻辑与运算，当所有操作数都为True时，结果为True。or：逻辑或运算，当任意一个操作数为True时，结果为True。not：逻辑非运算，对操作数取反。
这些逻辑运算符通常用于组合多个条件表达式。例如：
x = 5
y = 3
z = 7
result1 = x > y and x < z # 结果为 True
result2 = x > y or x > z # 结果为 True
result3 = not (x > y) # 结果为 False4.赋值运算符
-
=：简单赋值，将右侧的值赋给左侧的变量。+=：加法赋值，将右侧的值加到左侧的变量上。-=：减法赋值，将右侧的值减去左侧的变量。*=：乘法赋值，将右侧的值乘到左侧的变量上。/=：除法赋值，将右侧的值除到左侧的变量上。//=：整数除法赋值，将右侧的值整数除到左侧的变量上。%=：取模赋值，将右侧的值取模到左侧的变量上。**=：幂赋值，将左侧的变量自身做指数运算。
赋值运算符用于修改变量的值。例如：
x = 5
x += 3 # x 的值变为 85.成员运算符
-
in：检查某个值是否存在于序列（如字符串、列表或元组）中。not in：检查某个值是否不存在于序列中。
成员运算符返回布尔值。例如：
list1 = [1, 2, 3, 4, 5]
result1 = 3 in list1 # 结果为 True
result2 = 6 not in list1 # 结果为 True1.2.3选择结构与条件判断
在 Python 中，条件判断用于根据不同的条件执行不同的代码块。常见的条件判断语句有 if、elif 和 else。
以下是 Python 中条件判断的介绍和示例：
if condition1:
# 如果 condition1 为 True，则执行这里的代码块
statement1
elif condition2:
# 如果 condition1 为 False 而 condition2 为 True，则执行这里的代码块
statement2
else:
# 如果以上条件都为 False，则执行这里的代码块
statement3示例解析：
if后面的condition1是一个条件表达式，需返回布尔值True或False。如果condition1为 True，则执行if后的代码块statement1。- 如果
condition1不为 True，则继续判断elif后的condition2。如果condition2为 True，则执行elif后的代码块statement2。 - 如果以上所有条件都不为 True，则执行
else后的代码块statement3。
示例代码：
x = 5
if x > 10:
print("x 大于 10")
elif x > 5:
print("x 大于 5，但不大于 10")
else:
print("x 不大于 5")在这个例子中，我们判断了变量 x 的大小，并根据其值执行不同的代码块。根据变量 x 的值，输出结果为 "x 不大于 5"。
除了上述的基本条件判断，还有其他常用的条件判断方法：
1.多个条件的判断
-
and：当多个条件都为 True 时，才为 True。or：当多个条件中至少有一个为 True 时，为 True。
示例：
x = 5
y = 3
if x > 0 and y > 0:
print("x 和 y 都大于 0")2.判断值是否属于特定的范围
-
in：检查某个值是否存在于序列（如字符串、列表或元组）中。not in：检查某个值是否不存在于序列中。
示例：
fruit = "apple"
if fruit in ["apple", "banana", "orange"]:
print("这是一个水果")3. 复合条件判断
-
- 可以使用多个条件判断语句来实现更复杂的逻辑判断。
示例：
x = 5
y = 3
if x > 0:
if y > 0:
print("x 和 y 都大于 0")
else:
print("x 大于 0，但 y 不大于 0")
else:
print("x 不大于 0")1.2.4循环结构与循环体
在 Python 中，循环结构用于重复执行相同或类似的代码块。常见的循环结构有 for 循环和 while 循环。
以下是 Python 中循环结构的介绍和示例：
1.for****循环
for 循环用于遍历序列（如字符串、列表或元组）中的元素。循环体中的代码会依次对序列中的每个元素执行。
for element in sequence:
# 执行循环体中的代码，针对当前元素
statement示例：
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
print(fruit)输出结果为：
apple
banana
orange2. while****循环
while 循环根据一个条件判断执行代码块，只要条件为 True，循环会一直持续进行。
while condition:
# 执行循环体中的代码
statement示例：
count = 0
while count < 5:
print(count)
count += 1输出结果为：
0
1
2
3
4除了基本的 for 循环和 while 循环外，还有其他常用的循环控制方法：
3. break****语句：
break 语句用于立即终止循环，并跳出循环体。
示例：
numbers = [1, 2, 3, 4, 5]
for number in numbers:
if number == 3:
break
print(number)输出结果为：
1
24. continue****语句：
continue 语句用于跳过当前循环迭代，继续下一次循环迭代。
示例：
numbers = [1, 2, 3, 4, 5]
for number in numbers:
if number == 3:
continue
print(number)输出结果为：
1
2
4
5循环结构可以帮助我们重复执行代码块，依次处理元素或根据条件执行特定的操作。同时，循环控制语句（如 break、continue ）可以更灵活地控制循环的行为。
1.2.5数据的输入和输出
1.input()函数
input() 函数是 Python 内置的一个函数，用于从键盘读取用户的输入，并将其作为字符串类型返回。这个函数可以接受一个可选的提示字符串，该字符串将用于提示用户输入。
下面是 input() 函数的常用方法和示例：
基本使用：
input() 函数的最基本用法是直接调用该函数，然后等待用户输入：
x = input()
print(x)运行该程序后，当代码执行到 input() 函数时，程序将暂停执行，并等待用户输入。用户输入完成后，程序会读取用户输入的字符串，并将其赋值给变量 x，然后将 x 的值打印出来。
提示用户输入：
我们可以向 input() 函数传递一个字符串参数，该参数将用于提示用户输入。这个字符串通常是可选的。
name = input("请输入你的名字：")
print("你好，" + name + "！")在这个示例中，当代码执行到 input() 函数时，程序将暂停执行，并在控制台上输出 "请输入你的名字："，然后等待用户输入。用户输入完成后，程序将读取用户输入的字符串并将其赋值给变量 name，最后将 name 的值拼接成一句问候语。
转换输入的数据类型：
由于 input() 函数始终将用户输入的内容作为字符串返回，在需要使用其他类型的数据时，需要将其转换为相应的类型。常用的做法是使用 int() 和 float() 等内置函数进行强制类型转换。
age = input("请输入你的年龄：")
age = int(age)
print("你的出生年份是：" + str(2023 - age))在这个示例中，我们先通过 input() 函数获取用户输入的一个字符串，然后使用 int() 函数将其转换成整数类型，最后使用 str() 函数将计算后的字符串拼接成一句话输出。
2.print()函数
print() 函数是 Python 内置的一个函数，用于将指定的对象输出到标准输出设备（通常是控制台）。它可以接受多个参数，并以空格作为默认分隔符将它们打印出来。
下面是 print() 函数的常用方法和示例：
打印字符串：
print() 函数最常见的用法是直接传递一个字符串作为参数，它会将该字符串打印到控制台：
print("Hello, World!")运行该程序后，print() 函数将会在控制台上输出字符串 "Hello, World!"。
打印变量：
我们可以将变量作为参数传递给 print() 函数，它会打印出变量的值：
name = "Alice"
print("My name is", name)运行该程序后，print() 函数将会输出 "My name is Alice"，注意到 print() 函数会以空格作为默认分隔符将参数打印出来。
格式化输出：
print() 函数还支持使用格式化字符串对输出进行格式化，常用的是使用 % 运算符或者 .format() 方法：
score = 95
print("Your score is %d" % score)
age = 28
print("I am {} years old".format(age))上述的两个示例分别使用了 % 运算符和 .format() 方法来格式化输出，输出语句根据变量的值进行相应的替换。
控制换行：
默认情况下，每个 print() 函数调用会在输出的末尾添加一个换行符 \n，从而使下一个输出从新的一行开始。如果不希望换行，可以使用 end 参数来自定义结束字符：
print("Hello,", end=" ")
print("World!")这个示例中，我们将 end 参数设置为空格，使 "Hello," 和 "World!" 打印在同一行上。
1.2.6文件读写
Python 提供了一组用于进行文件读写操作的内置函数，可以方便地读取和写入文件中的数据。常用的文件读写方法包括：
-
打开文件：
使用open()函数可以打开一个文件，并返回一个文件对象。我们需要指定文件的路径和打开模式。file = open("example.txt", "r")
这个示例中，我们使用 "example.txt" 作为文件路径，并使用 "r" 作为打开模式，表示以只读模式打开文件。
- 读取文件内容：
在打开文件后，可以使用文件对象的read()和readlines()方法来读取文件中的内容。
-
-
read()方法用于将整个文件的内容作为一个字符串返回。content = file.read()
-
-
-
readlines()方法用于以列表的形式返回文件中的所有行。lines = file.readlines()
-
-
写入文件：
在打开文件后，可以使用文件对象的write()方法将数据写入文件。file.write("Hello, World!")
这个示例将字符串 "Hello, World!" 写入到文件中。
-
关闭文件：
在文件操作完成后，应该使用close()方法关闭文件，释放资源。file.close()
注意，使用 open() 打开文件后，必须在操作完成后显式调用 close() 方法来关闭文件。
除了上述常用的文件读写方法之外，还有其他一些常用方法，例如：
writelines()：以列表的形式将多行数据写入文件。seek()：用于移动文件指针到文件的指定位置。tell()：返回当前文件指针的位置。with语句：提供了一种更便捷的方式来自动管理文件的打开和关闭，不需要显式调用close()方法。
以下是一个完整的文件读写的例子：
# 打开文件
file = open("example.txt", "w")
# 写入数据
file.write("Hello, World!\n")
file.write("This is an example.")
# 关闭文件
file.close()
# 打开文件
file = open("example.txt", "r")
# 读取数据
content = file.read()
lines = file.readlines()
# 输出结果
print(content)
print(lines)
# 关闭文件
file.close()通过掌握这些方法，我们可以在 Python 程序中方便地读取和写入文件中的数据。同时，要记得在操作完成后显式关闭文件，以释放资源。
1.2.7函数
函数是一段封装了特定功能的可复用代码块。Python 中的函数可以帮助我们将程序组织成较小的模块，提高代码的可读性和可维护性。常用的函数方法包括：
-
定义函数：
使用def关键字可以定义一个函数，然后给函数起一个名称，并指定函数的参数和代码块。def greet(name):
print("Hello, " + name + "!")
在这个示例中，我们定义了一个名为 greet 的函数，它有一个参数 name。在函数体内，我们使用 print() 函数来打印出问候语，问候语中使用了参数 name 的值。
-
调用函数：
通过函数名称和传递给函数的实际参数值，可以调用函数并执行其中的代码块。greet("Alice")
这个示例中，我们调用了函数 greet，并将字符串 "Alice" 作为实际参数传递给函数。函数执行后，将会输出 "Hello, Alice!"。
-
返回值：
函数可以通过return语句返回一个值给调用者。调用函数时，可以将返回的值赋给一个变量。def add(a, b):
return a + bresult = add(3, 5)
print(result)
在这个示例中，我们定义了一个名为 add 的函数，它有两个参数 a 和 b，并返回它们的和。在函数调用时，我们将实际参数 3 和 5 传递给函数，并将返回值赋给变量 result。最后，将变量 result 的值打印出来。
-
默认参数：
在函数定义时，可以为参数指定默认值，这样在函数调用时，如果没有为参数提供实际值，将使用默认值来代替。def greet(name="World"):
print("Hello, " + name + "!")greet() # 输出 "Hello, World!"
greet("Alice") # 输出 "Hello, Alice!"
这个示例中，函数 greet 的参数 name 使用了默认值 "World"。当函数不带参数调用时，将使用默认值进行处理；而当函数传递了参数 "Alice" 时，将使用实际参数值。
-
可变数量的参数：
使用*args和**kwargs，可以定义接受可变数量参数的函数。*args用于接受任意数量的位置参数，而**kwargs用于接受任意数量的关键字参数。def print_values(*args, **kwargs):
for arg in args:
print(arg)
for key, value in kwargs.items():
print(key + " = " + value)print_values("apple", "banana", name="Alice", age="25")
在这个示例中，函数 print_values 接受任意数量的位置参数和关键字参数。在函数体内，我们使用 for 循环分别遍历位置参数和关键字参数，并将它们打印出来。
通过使用函数，我们可以将代码组织成可复用的块，提高代码的可读性和可维护性。同时，函数还支持默认参数、可变数量的参数等高级功能，使函数的使用更加灵活。
1.2.8类
类是一种面向对象编程的工具，它是一种抽象数据类型，用于描述具有共同属性和方法的对象。Python 中的类可以让我们更好地组织和管理代码，实现代码的重用性和扩展性。常用的类方法包括：
-
定义类：
使用class关键字可以定义一个类，并指定类的名称。class Person:
def init(self, name):
self.name = namedef greet(self): print("Hello, my name is " + self.name)
在这个示例中，我们定义了一个名为 Person 的类。类中有两个方法：__init__ 和 greet。__init__ 方法是一个特殊的方法，用于初始化对象的属性。greet 方法用于输出问候语，并使用对象的属性值。
-
创建对象：
通过类名和实际参数值，可以创建类的对象。person = Person("Alice")
在这个示例中，我们使用类名 Person 创建了一个名为 person 的对象。在创建对象时，可以向类的 __init__ 方法传递参数值。
-
访问属性：
通过对象名和属性名称，可以访问对象的属性。print(person.name)
这个示例中，我们通过对象名 person 和属性名称 name，访问了对象的属性。将会输出属性值 "Alice"。
-
调用方法：
通过对象名和方法名称，可以调用对象的方法。person.greet()
在这个示例中，我们通过对象名 person 和方法名称 greet，调用了对象的方法。将会输出问候语 "Hello, my name is Alice"。
-
继承：
类之间可以通过继承建立父类和子类的关系。子类可以继承父类的属性和方法，并可以根据需要进行扩展和重写。class Student(Person):
def init(self, name, student_id):
super().init(name)
self.student_id = student_iddef study(self): print("I'm studying.")student = Student("Bob", 12345)
student.greet()
student.study()
在这个示例中，我们定义了一个名为 Student 的子类，它继承自父类 Person。子类在初始化方法中使用 super() 函数调用父类的初始化方法，并扩展了一个新的方法 study。通过创建子类的对象，可以调用父类的方法和子类的方法。
通过使用类，我们可以将相关的属性和方法组织在一起，并实现代码的重用性和扩展性。同时，类还支持继承和方法重写等特性，使代码更加灵活和模块化。
1.3Python遥感深度学习境配置
Python遥感深度学习主要用到的Python库有：
- NumPy：虽然NumPy本身并不是专门针对遥感数据或深度学习的，但它提供了处理大型多维数组和矩阵的高效方法，是许多其他高级库的基础。
- Scikit-Image：这是一个专注于图像处理的库，适合用于图像的分割、色彩空间转换、形态学操作等基础处理操作。
- GDAL (Geospatial Data Abstraction Library)：GDAL 是一个开源的地理空间数据转换库，支持多种数据格式的读写，非常适合处理包括遥感图像在内的地理空间数据。
- Rasterio：这是一个基于 GDAL 的 Python 包，专门用来读写栅格数据集。它为读取遥感图像和元数据提供了更简洁的接口。
- OpenCV：OpenCV（Open Source Computer Vision Library）是一个强大的计算机视觉库，能够处理视频和图像，广泛应用于图像处理、特征检测等领域。
- SciPy：SciPy 是基于 NumPy 的科学计算库，提供了许多用于科学和技术计算的功能，包括用于优化、统计和信号处理等功能，这些功能在遥感数据处理中也非常有用。
- PyTorch：是最流行的深度学习库之一，它们提供了强大的框架来构建和训练深度学习模型。无论是卷积神经网络、循环神经网络还是更复杂的架构，这两个库都提供了全面的支持。
- GeoPandas：GeoPandas 是一个用于处理地理数据的开源Python库，它扩展了 pandas 库以支持空间操作。使用 GeoPandas 可以轻松地处理地理数据集上的空间信息。
当然除了以上库，还有一些工具库，可以自行安装。配置流程参考实践篇 1.1.1.3Python环境配置
注意：PyTorch安装有CPU和GPU两个版本，大家根据自己的电脑的情况安装，有独立显卡安装GPU版，没有安装CPU版，这个安装可以参考pytorch官网教程，使用命令行安装：https://pytorch.org/get-started/locally/
请见xy 用户：geedownload
或者xy 搜索 深度学习遥感地物分类-以建筑分割和多地物分割为例