1 类型
在python中，一切都是对象，每个对象都有一个类型。
检查对象类型的常用方式。
<type> = type(<el>)或<el>.__class__：
这两行代码都是获取对象的类型。type(<el>)会返回<el>的类型，而<el>.__class__会返回类类型。这两种方法都可以用来确定一个对象的类型。
例如，如果我们有一个字符串"Hello, world!"，我们可以这样获取它的类型：
s \= "Hello, world!"
print(type(s)) \# 输出：<class 'str'>
print(s.\_\_class\_\_) \# 输出：<class 'str'>
这两行代码都会输出<class 'str'>，表示s是一个字符串类型。
<bool> = isinstance(<el>, <type>)或issubclass(type(<el>), <type>)：
这两行代码都是检查一个对象是否是特定类型或其子类型的实例。isinstance(<el>, <type>)会检查<el>是否是<type>或其子类型的实例，而issubclass(type(<el>), <type>)会检查<el>的类型是否是<type>或其子类型。
例如，如果我们有一个列表[1, 2, 3, 4]，我们可以这样检查它是否是列表类型或其子类型的实例：
lst \= \[1, 2, 3, 4\]
print(isinstance(lst, list)) \# 输出：True
print(issubclass(type(lst), list)) \# 输出：True
2 类型
列表的切片（slicing）操作：
-
from_inclusive（包含）是切片开始的索引，如果省略，默认为 0。 -
to_exclusive（不包含）是切片结束的索引，如果省略，默认为列表的长度。 -
step是切片的步长，如果省略，默认为 1。
例子：
my\_list \= \[0, 1, 2, 3, 4, 5, 6, 7, 8, 9\]
\# 获取索引为 2 到 5（不包含）的元素
sub\_list \= my\_list\[2:5\]
print(sub\_list) \# 输出：\[2, 3, 4\]
\# 获取索引为 2 到 8（不包含）的元素，步长为 2
sub\_list \= my\_list\[2:8:2\]
print(sub\_list) \# 输出：\[2, 4, 6\]
向列表添加元素
<list>.append(<el>)：这个方法将一个元素 <el> 添加到 <list> 的末尾。这个元素可以是任何类型的数据，包括另一个列表.
例子：
my\_list \= \[1, 2, 3\]
my\_list.append(4)
print(my\_list)
\# 输出：\[1, 2, 3, 4\]
<list>.extend(<collection>)：这个方法将一个集合 <collection> 中的所有元素添加到 <list> 的末尾。这个集合可以是任何可迭代的对象，例如另一个列表、一个元组、一个字典等。
例子：
my\_list \= \[1, 2, 3\]
my\_list.extend(\[4, 5, 6\])
print(my\_list)
\# 输出：\[1, 2, 3, 4, 5, 6\]
用于排序和反转列表的4种方法
1.<list>.sort()：这个方法会对 <list> 进行升序排序。这会直接修改原始列表，而不是创建一个新的列表。例如：
my\_list \= \[3, 1, 4, 1, 5, 9\]
my\_list.sort()
print(my\_list)
\# 输出：\[1, 1, 3, 4, 5, 9\]
2.<list>.reverse()：这个方法会将 <list> 中的元素顺序反转。这会直接修改原始列表，而不是创建一个新的列表。例如：
my\_list \= \[1, 2, 3, 4, 5\]
my\_list.reverse()
print(my\_list)
\# 输出：\[5, 4, 3, 2, 1\]
3.<list> = sorted(<collection>)：sorted() 函数会返回一个新的列表，这个列表包含 <collection> 中的所有元素，并且这些元素已经按升序排序。例如：
my\_list \= \[3, 1, 4, 1, 5, 9\]
sorted\_list \= sorted(my\_list)
print(sorted\_list)
\# 输出：\[1, 1, 3, 4, 5, 9\]
\# 例子2
\# 按照经纬度对过滤后的要素进行排序
filtered\_features.sort(key=lambda x: (x\['geometry'\]\['coordinates'\]\[0\]\[0\], x\['geometry'\]\['coordinates'\]\[0\]\[1\]))
4.<iter> = reversed(<list>)：reversed() 函数会返回一个迭代器，这个迭代器会按逆序生成 <list> 中的元素。例如：
my\_list \= \[1, 2, 3, 4, 5\]
reversed\_iter \= reversed(my\_list)
for i in reversed\_iter:
print(i, end\=' ')
\# 输出：5 4 3 2 1
一些常用的列表语法糖
"语法糖"是一个编程术语，指的是一种编程语法，它并没有增加任何新的功能，但是可以使代码更易读、更易写。这种语法提供了一种更方便、更清晰的方式来表达一种已经存在的编程结构或操作。
-
sum_of_elements = sum(<collection>)这段代码将计算集合（列表、元组等）中所有元素的总和。
例子：
numbers \= \[1, 2, 3, 4, 5\] sum\_of\_elements \= sum(numbers) print(sum\_of\_elements) \# 输出：15 -
elementwise_sum = [sum(pair) for pair in zip(list_a, list_b)]这段代码将两个列表中的对应元素相加。
例子：
list\_a \= \[1, 2, 3\] list\_b \= \[4, 5, 6\] elementwise\_sum \= \[sum(pair) for pair in zip(list\_a, list\_b)\] print(elementwise\_sum) \# 输出：\[5, 7, 9\] -
sorted_by_second = sorted(<collection>, key=lambda el: el[1])这段代码将根据集合中每个元素的第二个值进行排序。
例子：
pairs \= \[(2, 3), (1, 2), (4, 1)\] sorted\_by\_second \= sorted(pairs, key\=lambda el: el\[1\]) print(sorted\_by\_second) \# 输出：\[(4, 1), (1, 2), (2, 3)\] -
sorted_by_both = sorted(<collection>, key=lambda el: (el[1], el[0]))这段代码将根据集合中每个元素的第二个值和第一个值进行排序。
例子：
pairs \= \[(2, 3), (1, 2), (4, 1), (3, 2)\] sorted\_by\_both \= sorted(pairs, key\=lambda el: (el\[1\], el\[0\])) print(sorted\_by\_both) \# 输出：\[(4, 1), (1, 2), (3, 2), (2, 3)\] -
flatter_list = list(itertools.chain.from_iterable(<list>))这段代码将一个嵌套的列表（列表的列表）扁平化为一个单一的列表。
例子：
import itertools nested\_list \= \[\[1, 2, 3\], \[4, 5, 6\], \[7, 8, 9\]\] flatter\_list \= list(itertools.chain.from\_iterable(nested\_list)) print(flatter\_list) \# 输出：\[1, 2, 3, 4, 5, 6, 7, 8, 9\] -
product_of_elems = functools.reduce(lambda out, el: out * el, <collection>)这段代码将计算集合中所有元素的乘积。
例子：
import functools numbers \= \[1, 2, 3, 4, 5\] product\_of\_elems \= functools.reduce(lambda out, el: out \* el, numbers) print(product\_of\_elems) \# 输出：120 -
list_of_chars = list(<str>)这段代码将一个字符串转换为一个字符列表。
例子：
my\_string \= "Hello" list\_of\_chars \= list(my\_string) print(list\_of\_chars) \# 输出：\['H', 'e', 'l', 'l', 'o'\]
列表的增删查改
.insert(, )
这个方法会在指定的索引位置插入元素，并将剩余的元素向右移动。
例子：
numbers \= \[1, 2, 3, 4, 5\]
numbers.insert(2, 999)
print(numbers) \# 输出：\[1, 2, 999, 3, 4, 5\]
= .pop([])
这个方法会删除并返回指定索引位置的元素，如果没有指定索引，则默认删除并返回列表的最后一个元素。
例子：
numbers \= \[1, 2, 3, 4, 5\]
last\_element \= numbers.pop()
print(last\_element) \# 输出：5
print(numbers)
\# 输出：\[1, 2, 3, 4\]
= .count()
这个方法会返回指定元素在列表中的出现次数。这个方法也适用于字符串。
例子：
numbers \= \[1, 2, 3, 2, 2, 4, 5\]
count\_of\_2 \= numbers.count(2)
print(count\_of\_2) \# 输出：3
= .index()
这个方法会返回指定元素在列表中第一次出现的索引位置。如果元素不存在，则会抛出 ValueError。
例子：
numbers \= \[1, 2, 3, 2, 2, 4, 5\]
index\_of\_3 \= numbers.index(3)
print(index\_of\_3) \# 输出：2
.remove()
这个方法会删除列表中第一次出现的指定元素。如果元素不存在，则会抛出 ValueError。
例子：
numbers \= \[1, 2, 3, 2, 2, 4, 5\]
numbers.remove(2)
print(numbers)
\# 输出：\[1, 3, 2, 2, 4, 5\]
.clear()
这个方法会删除列表中的所有元素。这个方法也适用于字典和集合。
例子：
numbers \= \[1, 2, 3, 4, 5\]
numbers.clear()
print(numbers) \# 输出：\[\]
3 字典
获取字典信息的方式
-
<view> = <dict>.keys()这个方法返回一个反映字典键的动态视图。如果字典改变，视图也会改变。
例子：
student \= {'name': 'John', 'age': 15, 'grade': 'A'} keys \= student.keys() print(keys) \# 输出：dict\_keys(\['name', 'age', 'grade'\]) -
<view> = <dict>.values()这个方法返回一个反映字典值的动态视图。如果字典改变，视图也会改变。
例子：
student \= {'name': 'Han Meimei', 'age': 18, 'grade': 'A'} values \= student.values() print(values) \# 输出：dict\_values(\['Han Meimei', 18, 'A'\]) -
<view> = <dict>.items()这个方法返回一个反映字典键值对的动态视图。每个键值对被表示为一个元组。如果字典改变，视图也会改变。
例子：
student \= {'name': 'Li Ming', 'age': 15, 'grade': 'A'} items \= student.items() print(items) \# 输出：dict\_items(\[('name', 'Li Ming'), ('age', 15), ('grade', 'A')\])
获取或设置字典的值
-
value = <dict>.get(key, default=None)这个方法用于获取字典中给定键的值。如果键不存在，那么返回默认值，如果没有指定默认值，则返回None。
例子：
student \= {'name': 'John', 'age': 15} value \= student.get('grade', 'A') print(value) \# 输出：'A' -
value = <dict>.setdefault(key, default=None)这个方法用于获取字典中给定键的值。如果键不存在，那么将默认值写入字典，并返回默认值，如果没有指定默认值，则写入并返回None。
例子：
student \= {'name': 'John', 'age': 15} value \= student.setdefault('grade', 'A') print(value) \# 输出：'A' print(student) \# 输出：{'name': 'John', 'age': 15, 'grade': 'A'} -
<dict> = collections.defaultdict(<type>)这个方法返回一个默认字典，如果请求的键不存在，那么返回给定类型的默认值。
<type>应该是一个无参数的函数，用于生成默认值。例子：
from collections import defaultdict count \= defaultdict(int) for letter in 'hello': count\[letter\] += 1 print(count) \# 输出：defaultdict(<class 'int'>, {'h': 1, 'e': 1, 'l': 2, 'o': 1}) -
<dict> = collections.defaultdict(lambda: 1)这个方法也返回一个默认字典，但是这次我们使用一个lambda函数来生成默认值，这个lambda函数总是返回1。
例子：
from collections import defaultdict count \= defaultdict(lambda: 1) for letter in 'hello': count\[letter\] += 1 print(count) \# 输出：defaultdict(<function <lambda> at 0x7f8c0c3d2f70>, {'h': 2, 'e': 2, 'l': 3, 'o
创建字典的方法
-
<dict> = dict(<collection>)这个方法用于从键值对的集合创建一个字典。集合可以是一个列表的列表，也可以是一个元组的列表，只要每个内部列表或元组包含两个元素。
例子：
pairs \= \[('name', 'John'), ('age', 15), ('grade', 'A')\] student \= dict(pairs) print(student) \# 输出：{'name': 'John', 'age': 15, 'grade': 'A'} -
<dict> = dict(zip(keys, values))这个方法用于从两个集合创建一个字典，一个集合作为键，另一个集合作为值。这两个集合的长度必须相等。
例子：
keys \= \['name', 'age', 'grade'\] values \= \['John', 15, 'A'\] student \= dict(zip(keys, values)) print(student) \# 输出：{'name': 'John', 'age': 15, 'grade': 'A'} -
<dict> = dict.fromkeys(keys [, value])这个方法用于从键的集合创建一个字典。所有的键都有相同的值，如果没有指定值，则默认为None。
例子：
keys \= \['name', 'age', 'grade'\] student \= dict.fromkeys(keys, 'unknown') print(student) \# 输出：{'name': 'unknown', 'age': 'unknown', 'grade': 'unknown'}
对字典进行修改、查询和过滤
-
<dict>.update(<dict>)这个方法用于添加新的键值对到字典中。如果新的字典中的键在原字典中已经存在，那么它会替换原字典中的键值对。
例子：
student \= {'name': 'John', 'age': 15} student.update({'grade': 'A', 'age': 16}) print(student) \# 输出：{'name': 'John', 'age': 16, 'grade': 'A'} -
value = <dict>.pop(key)这个方法用于移除字典中的一个键值对，并返回该键对应的值。如果键不存在，那么会抛出
KeyError。例子：
student \= {'name': 'John', 'age': 15, 'grade': 'A'} age \= student.pop('age') print(age) \# 输出：15 print(student) \# 输出：{'name': 'John', 'grade': 'A'} -
{k for k, v in <dict>.items() if v == value}这是一个字典推导式，用于获取所有值等于给定值的键。结果是一个集合。
例子：
student \= {'name': 'John', 'age': 15, 'grade': 'A', 'level': 'A'} keys \= {k for k, v in student.items() if v \== 'A'} print(keys) \# 输出：{'grade', 'level'} -
{k: v for k, v in <dict>.items() if k in keys}这也是一个字典推导式，用于根据给定的键集合过滤字典。结果是一个新的字典。
例子：
student \= {'name': 'John', 'age': 15, 'grade': 'A', 'level': 'A'} keys \= \['name', 'grade'\] filtered\_student \= {k: v for k, v in student.items() if k in keys} print(filtered\_student) \# 输出：{'name': 'John', 'grade': 'A'}
4 集合
对于一些代码中的循环部分，集合特别好用，值得学习。
================================
集合是一个无序的元素集，每个元素唯一，不可重复。
s \= set() \# 创建一个空集合
print(s) \# 输出：set()
这里需要注意的是，尽管在Python中 {} 用于创建空字典，但如果在 {} 中放入一些用逗号分隔的值，Python会创建一个集合，而不是字典。例如：
s \= {1, 2, 3} \# 创建一个包含三个元素的集合
print(s) \# 输出：{1, 2, 3}
但如果想创建一个空集合，那必须使用 set()，而不能使用 {}，因为 {} 在Python中表示一个空的字典：
d \= {} \# 创建一个空字典，而不是集合
print(d) \# 输出：{}
1.<set> = <set>.union(<coll.>) 或 <set> | <set>：这两种操作都是用来获取两个集合的并集。并集意味着获取所有在两个集合中出现的元素，重复的元素只会出现一次。
例如：
set1 \= {1, 2, 3}
set2 \= {3, 4, 5}
set3 \= set1.union(set2)
\# 或者
set3 \= set1 | set2
print(set3) \# 输出：{1, 2, 3, 4, 5}
2.<set> = <set>.intersection(<coll.>) 或 <set> & <set>：这两种操作都是用来获取两个集合的交集。交集意味着获取在两个集合中都出现的元素。
例如：
set1 \= {1, 2, 3}
set2 \= {3, 4, 5}
set3 \= set1.intersection(set2)
\# 或者
set3 \= set1 & set2
print(set3) \# 输出：{3}
3. = .difference(<coll.>)或 - `：这两种操作都是用来获取两个集合的差集。差集意味着获取在第一个集合中出现，但不在第二个集合中出现的元素。
例如：
set1 \= {1, 2, 3}
set2 \= {3, 4, 5}
set3 \= set1.difference(set2)
\# 或者
set3 \= set1 \- set2
print(set3) \# 输出：{1, 2}
4.<set> = <set>.symmetric_difference(<coll.>) 或 <set> ^ <set>：这两种操作都是用来获取两个集合的对称差集。对称差集意味着获取只在一个集合中出现的元素。
例如：
set1 \= {1, 2, 3}
set2 \= {3, 4, 5}
set3 \= set1.symmetric\_difference(set2)
\# 或者
set3 \= set1 ^ set2
print(set3) \# 输出：{1, 2, 4, 5}
5.<bool> = <set>.issubset(<coll.>) 或 <set> <= <set>：这两种操作都是用来检查一个集合是否是另一个集合的子集。子集意味着第一个集合中的所有元素都出现在第二个集合中。
例如：
set1 \= {1, 2}
set2 \= {1, 2, 3, 4, 5}
is\_subset \= set1.issubset(set2)
\# 或者
is\_subset \= set1 <= set2
print(is\_subset) \# 输出：True
6.<bool> = <set>.issuperset(<coll.>) 或 <set> >= <set>：这两种操作都是用来检查一个集合是否是另一个集合的超集。超集意味着第二个集合中的所有元素都出现在第一个集合中。
例如：
set1 \= {1, 2, 3, 4, 5}
set2 \= {1, 2}
is\_superset \= set1.issuperset(set2)
\# 或者
is\_superset \= set1 \>= set2
print(is\_superset) \# 输出：True
5 元组
元组是一个不可变的列表。
如何定义一个元组
-
定义一个空的元组：
empty\_tuple \= ()这将创建一个没有元素的元组。
-
定义一个只有一个元素的元组：
single\_element\_tuple \= (1,)注意，如果你省略了末尾的逗号，Python会将其解释为一个数值，而不是一个元组。例如，
(1)在Python中表示的是数值1，而不是一个包含1的元组。 -
定义一个有多个元素的元组：
multi\_element\_tuple \= (1, 2, 3)这将创建一个包含三个元素的元组。你可以添加任意数量的元素到元组中，只要它们被逗号分隔开。
注意，元组是不可变的，这意味着一旦你创建了一个元组，就不能修改它的内容。这包括添加新的元素，删除已有的元素，或者改变元素的顺序。
6 字符串
字符串
不可变的字符序列。
移除字符串两端的字符
strip()是Python中的一个字符串方法，用于移除字符串两端的字符。
1.<str> = <str>.strip()：这个方法会移除字符串两端的所有空白字符（包括空格、换行\n、制表符\t等）。
例如：
s \= " Hello, LiMing! "
s \= s.strip()
print(s) \# 输出："Hello, LiMing!"
2.<str> = <str>.strip('<chars>')：这个方法会移除字符串两端的指定字符。如果你传入一个字符串参数，它会移除所有在这个字符串中出现的字符。此外，还有lstrip()和rstrip()方法，分别用于移除字符串左端（前端）和右端（后端）的字符。
例如：
s \= "www.remotesensing.com"
s \= s.strip("w.com")
print(s) \# 输出："remotesensing"
字符串的分割和连接
1.<list> = <str>.split()：这个方法会根据一个或多个空白字符（包括空格、换行\n、制表符\t等）来分割字符串，并返回一个包含分割后的子字符串的列表。
例如：
s \= "Hello, world! How are you?"
lst \= s.split()
print(lst) \# 输出：\['Hello,', 'world!', 'How', 'are', 'you?'\]
2.<list> = <str>.split(sep=None, maxsplit=-1)：这个方法会根据sep参数指定的字符来分割字符串。maxsplit参数指定了分割的最大次数。如果sep为None，则默认根据空白字符分割；如果maxsplit为-1，则表示没有分割次数的限制。
例如：
s \= "apple,banana,cherry,dates"
lst \= s.split(sep\=",", maxsplit\=2)
print(lst) \# 输出：\['apple', 'banana', 'cherry,dates'\]
3.<list> = <str>.splitlines(keepends=False)：这个方法会根据换行符来分割字符串，并返回一个包含分割后的子字符串的列表。keepends参数指定是否保留换行符。
例如：
s \= "Hello\\nworld!\\nHow\\nare\\nyou?"
lst \= s.splitlines()
print(lst) \# 输出：\['Hello', 'world!', 'How', 'are', 'you?'\]
4.<str> = <str>.join(<coll_of_strings>)：这个方法会使用指定的字符串作为分隔符，将一个字符串的集合（如列表或元组）连接成一个新的字符串。
例如：
lst \= \['Hello', 'world!', 'How', 'are', 'you?'\]
s \= " ".join(lst)
print(s) \# 输出："Hello world! How are you?"
字符串方法和操作符
1.<bool> = <sub_str> in <str>：这个操作会检查字符串是否包含子字符串，如果包含则返回True，否则返回False。
例如：
s \= "Hello, world!"
print("world" in s) \# 输出：True
print("goodbye" in s) \# 输出：False
2.<bool> = <str>.startswith(<sub_str>)：这个方法会检查字符串是否以子字符串开头，如果是则返回True，否则返回False。你还可以传入一个字符串的元组，来检查字符串是否以元组中的任何一个字符串开头。
例如：
s \= "Hello, world!"
print(s.startswith("Hello")) \# 输出：True
print(s.startswith(("world", "goodbye"))) \# 输出：False
3.<int> = <str>.find(<sub_str>)：这个方法会返回子字符串首次出现的位置的索引，如果字符串中不包含子字符串，则返回-1。
例如：
s \= "Hello, world!"
print(s.find("world")) \# 输出：7
print(s.find("goodbye")) \# 输出：-1
4.<int> = <str>.index(<sub_str>)：这个方法和find()方法类似，都是返回子字符串首次出现的位置的索引，但是如果字符串中不包含子字符串，index()方法会抛出一个ValueError异常。
例如：
s \= "Hello, world!"
print(s.index("world")) \# 输出：7
\# print(s.index("goodbye")) # 这行代码会抛出 ValueError: substring not found
修改字符串的大小写
<str> = <str>.lower()：这个方法会将字符串中的所有大写字符转换为小写，并返回新的字符串。
类似的方法还有upper()（将所有字符转换为大写）、capitalize()（将第一个字符转换为大写，其余字符转换为小写）和title()（将每个单词的第一个字符转换为大写，其余字符转换为小写）。
例如：
s \= "Hello, WORLD!"
print(s.lower()) \# 输出："hello, world!"
print(s.upper()) \# 输出："HELLO, WORLD!"
print(s.capitalize()) \# 输出："Hello, world!"
print(s.title()) \# 输出："Hello, World!"
替换字符串中的子字符串
<str> = <str>.replace(old, new [, count])：这个方法会将字符串中的old子字符串替换为new子字符串，并返回新的字符串。count参数指定了替换的最大次数，如果省略count参数，或者count为负数，则替换所有的old子字符串。
例如：
s \= "Hello, world! world!"
print(s.replace("world", "everyone")) \# 输出："Hello, everyone! everyone!"
print(s.replace("world", "everyone", 1)) \# 输出："Hello, everyone! world!"
转换Unicode字符和对应的整数编码
1.<str> = chr(<int>)：这个函数会返回对应整数编码的Unicode字符。
例如：
print(chr(65)) \# 输出："A"
print(chr(20013)) \# 输出："中"
2.<int> = ord(<str>)：这个函数会返回对应Unicode字符的整数编码。注意，这个函数只接受单个字符作为参数。
例如：
print(ord("A")) \# 输出：65
print(ord("中")) \# 输出：20013
字符串属性方法
1.<bool> = <str>.isdecimal()：这个方法检查字符串是否只包含十进制数字。这包括从0到9的所有数字，以及其他语言中的数字，例如印地语的[०-९]和阿拉伯语的[٠-٩]。如果字符串为空或包含非十进制数字的字符，该方法返回False。
例如：
print("12345".isdecimal()) \# 输出：True
print("12345.67".isdecimal()) \# 输出：False
print("१२३४५".isdecimal()) \# 输出：True
2.<bool> = <str>.isdigit()：这个方法检查字符串是否只包含数字字符。这包括十进制数字、上标和下标数字（例如²和³）、以及其他语言中的数字。如果字符串为空或包含非数字的字符，该方法返回False。
例如：
print("12345".isdigit()) \# 输出：True
print("12345.67".isdigit()) \# 输出：False
print("²³".isdigit()) \# 输出：True
3.<bool> = <str>.isnumeric()：这个方法检查字符串是否只包含数字字符。这包括十进制数字、上标和下标数字、分数（例如¼、½和¾）以及其他语言中的数字，例如中文数字（零、一、二等）。如果字符串为空或包含非数字的字符，该方法返回False。
例如：
print("12345".isnumeric()) \# 输出：True
print("12345.67".isnumeric()) \# 输出：False
print("½".isnumeric()) \# 输出：True
print("一二三".isnumeric()) \# 输出：True
4. = .isalnum()`：这个方法检查字符串是否只包含字母和数字。这包括拉丁字母（A-Z和a-z）、数字以及其他语言中的字母和数字。如果字符串为空或包含非字母或非数字的字符，该方法返回False。
例如：
print("abc123".isalnum()) \# 输出：True
print("abc 123".isalnum()) \# 输出：False
5.<bool> = <str>.isprintable()：这个方法检查字符串是否只包含可打印的字符。这包括字母、数字、标点符号、空格以及其他可打印的字符。如果字符串包含控制字符或其他非打印字符，该方法返回False。
例如：
print("Hello, world!".isprintable()) \# 输出：True
print("Hello,\\nworld!".isprintable()) \# 输出：False
6.<bool> = <str>.isspace()：这个方法检查字符串是否只包含空白字符。这包括空格、制表符、换行符、回车符、换页符以及其他空白字符。如果字符串为空或包含非空白字符，该方法返回False。
例如：
print(" \\t\\n".isspace()) \# 输出：True
print(" \\t\\na".isspace()) \# 输出：False
7 range函数
range()函数在Python中用于生成一个不可变的整数序列。这是一个内置函数，可以接受一到三个参数。以下是具体的用法：
-
range(stop): 创建一个从0开始，到stop（不包括）结束的整数序列。例如：for i in range(5): print(i)输出将是：
0 1 2 3 4 -
range(start, stop): 创建一个从start（包括）开始，到stop（不包括）结束的整数序列。例如：for i in range(2, 5): print(i)输出将是：
2 3 4 -
range(start, stop, step): 创建一个从start（包括）开始，到stop（不包括）结束，步长为step的整数序列。例如：for i in range(2, 10, 2): print(i)输出将是：
2 4 6 8
8 Enumerate 枚举
===
enumerate()函数是Python的内置函数，用于在遍历一个集合（例如列表、元组或字符串）时获取元素以及其索引。它返回一个枚举对象，其中包含索引和值的元组。这个函数非常有用，因为它允许你在遍历一个集合时同时获取索引和值，而不需要手动处理索引。
enumerate()函数可以接受两个参数：
-
<collection>：需要遍历的集合。 -
i_start（可选）：索引的起始值，默认为0。
以下是一个简单的例子：
English \= \['LiMing', 'HanMeimei', 'ZhangSan'\]
for i, name in enumerate(English):
print(f"Index: {i}, English: {name}")
输出将是：
Index: 0, English: LiMing
Index: 1, English: HanMeimei
Index: 2, English: ZhangSan
9 Iterator 迭代器
===
iter()和next()是Python中的内置函数，用于创建和操作迭代器。迭代器是一个可以记住遍历的位置的对象，它从集合的第一个元素开始访问，直到所有元素被访问完结束。
-
iter(collection): 这个函数返回一个迭代器对象，可以遍历collection中的所有元素。如果collection已经是一个迭代器，那么iter()会返回未修改的迭代器。例如：
my\_list \= \[1, 2, 3, 4\] my\_iter \= iter(my\_list) print(next(my\_iter)) \# 输出：1 print(next(my\_iter)) \# 输出：2 -
iter(function, to_exclusive): 这个函数返回一个迭代器，该迭代器会连续调用function，直到返回值等于to_exclusive为止。例如：
import random my\_iter \= iter(lambda: random.randint(0, 5), 2) for num in my\_iter: print(num)这个例子会打印出一系列随机数，直到2被打印出来为止。
-
next(iter, default): 这个函数返回迭代器iter的下一个元素。如果迭代器已经耗尽（即没有更多的元素可以返回），那么它会引发StopIteration异常。如果提供了default参数，那么在迭代器耗尽时会返回default，而不是引发异常。例如：
my\_list \= \[1, 2, 3, 4\] my\_iter \= iter(my\_list) print(next(my\_iter, 'No more elements')) \# 输出：1 print(next(my\_iter, 'No more elements')) \# 输出：2 print(next(my\_iter, 'No more elements')) \# 输出：3 print(next(my\_iter, 'No more elements')) \# 输出：4 print(next(my\_iter, 'No more elements')) \# 输出：No more elements -
list(iter): 这个函数返回一个列表，其中包含迭代器iter的所有元素。例如：
my\_iter \= iter(\[1, 2, 3, 4\]) my\_list \= list(my\_iter) print(my\_list) \# 输出：\[1, 2, 3, 4\]
10 generator生成器
===
使用yield语句来生成值，每次调用next()时都会返回下一个值。
以下是如何使用这个生成器的例子：
def count(start, step):
while True:
yield start
start += step
counter \= count(10, 2)
print(next(counter)) \# 输出：10
print(next(counter)) \# 输出：12
print(next(counter)) \# 输出：14
每次调用next(counter)时，生成器都会返回序列中的下一个值，并更新内部的状态，以便下次调用时能返回正确的值。
11 Regex正则表达式
正则表达式，值得好好去学，在字符串操作方面经常用得到，也很好用。
1.re.sub(pattern, repl, string, count=0, flags=0)
在字符串中查找与正则表达式模式匹配的所有子串，并用新的字符串替换它们。
示例：
import re
text \= "apple apple apple orange"
new\_text \= re.sub(r'apple', 'banana', text)
print(new\_text) \# 输出: banana banana banana orange
2.re.findall(pattern, string, flags=0)
在字符串中查找所有与正则表达式模式匹配的子串，并返回一个列表。
示例：
import re
text \= "apple apple apple orange"
matches \= re.findall(r'apple', text)
print(matches) \# 输出: \['apple', 'apple', 'apple'\]
3.re.split(pattern, string, maxsplit=0, flags=0)
通过正则表达式模式指定的分隔符来分割字符串。返回分割后的子串列表。
示例：
import re
text \= "apple,banana,orange"
split\_text \= re.split(r',', text)
print(split\_text) \# 输出: \['apple', 'banana', 'orange'\]
\# 如果要保留分隔符，则需要后处理或使用其他方法
4.re.search(pattern, string, flags=0)
在字符串中查找与正则表达式模式匹配的第一个位置，并返回一个相应的匹配对象。如果没有找到匹配项，则返回None。
示例：
import re
text \= "apple apple apple orange"
match \= re.search(r'orange', text)
if match:
print(match.group())
\# 输出: orange
5.re.match(pattern, string, flags=0)
从字符串的开头开始匹配正则表达式模式。如果模式在字符串的起始位置匹配，则返回一个相应的匹配对象。否则，返回None。
示例：
import re
text \= "apple apple apple orange"
match \= re.match(r'apple', text)
if match:
print(match.group()) \# 输出: apple
match \= re.match(r'orange', text)
if not match:
print("No match at the beginning.")
\# 输出: No match at the beginning.
6.re.finditer(pattern, string, flags=0)
在字符串中查找所有与正则表达式模式匹配的子串，并返回一个迭代器，产生匹配对象。
示例：
import re
text \= "apple apple apple orange"
matches \= re.finditer(r'apple', text)
for match in matches:
print(match.group())
\# 输出: apple 三次
Match
关于re模块中Match对象的一些常见方法和它们的使用示例。这些方法和属性用于获取匹配的信息，比如整个匹配的内容、分组内容、匹配的开始和结束索引等。
1.Match.group()
返回整个匹配的子串。group(0)也返回同样的结果，因为0是默认的组号。
示例：
import re
match \= re.search(r'(\\d+)-(\\d+)', 'abc123-456def')
if match:
print(match.group())
\# 输出: '123-456'
print(match.group(0))
\# 输出: '123-456' (与group()相同)
2.Match.group(n)
返回第n个括号中匹配到的内容。如果正则表达式中没有定义任何括号，则group(1)会引发IndexError。
示例：
import re
match \= re.search(r'(\\d+)-(\\d+)', 'abc123-456def')
if match:
print(match.group(1))
\# 输出: '123'
print(match.group(2))
\# 输出: '456'
3.Match.groups()
返回一个包含所有括号中匹配到的内容的元组。如果没有括号，则返回一个空元组。
示例：
import re
match \= re.search(r'(\\d+)-(\\d+)', 'abc123-456def')
if match:
print(match.groups())
\# 输出: ('123', '456')
4.Match.start()
返回匹配子串在原始字符串中的起始索引。
示例：
import re
match \= re.search(r'\\d+', 'abc123def')
if match:
print(match.start())
\# 输出: 3，因为'123'是从索引3开始的
5.Match.end()
返回匹配子串在原始字符串中的结束索引（不包括该索引处的字符）。
示例：
import re
match \= re.search(r'\\d+', 'abc123def')
if match:
print(match.end())
\# 输出: 6，因为'123'在索引6处结束
\# 但索引6处的字符'd'不是匹配的一部分
特殊字符类的等价表示
-
\d等同于[0-9]，它匹配任何单个数字字符。 -
\w等同于[a-zA-Z0-9_]，它匹配任何单个字母数字字符（无论是大写还是小写）或下划线。 -
\s匹配任何空白字符，包括空格、制表符、换行符、回车符、换页符和垂直制表符。它等同于字符类[ \t\n\r\f\v]。
12 格式问题
===
字符串格式化方法
1.f-string（格式化字符串字面值）
从Python 3.6开始，可以使用f-string来格式化字符串。这种方法的优点是它简洁易读，并且支持在字符串内部直接执行表达式。
el\_1 \= 'hello'
el\_2 \= 'world'
str\_value \= f'{el\_1}, {el\_2}' \# 结果是 'hello, world'
2.str.format() 方法:
str.format() 方法允许您使用花括号 {} 作为占位符，并通过位置参数或关键字参数来填充这些占位符。
使用位置参数：
el\_1 \= 'hello'
el\_2 \= 'world'
str\_value \= '{}, {}'.format(el\_1, el\_2) \# 结果是 'hello, world'
使用关键字参数（命名参数）:
el\_1 \= 'hello'
el\_2 \= 'world'
str\_value \= '{0}, {a}'.format(el\_1, a\=el\_2) \# 结果是 'hello, world'
这里，{0} 表示第一个位置参数，而 {a} 表示名为 a 的关键字参数。
3.% 运算符:
% 运算符是Python中较老的字符串格式化方法，现在通常被认为是不如 str.format() 或 f-string 的方法。但是，在某些情况下，特别是当与旧代码兼容时，它仍然很有用。
el\_1 \= 'hello'
el\_2 \= 'world'
str\_value \= '%s, %s' % (el\_1, el\_2) \# 结果是 'hello, world'
在选择使用哪种方法时，通常推荐使用 f-string，因为它简洁、易读，并且功能强大。然而，在需要向后兼容旧代码或特定库/框架的情况下，可能需要使用 str.format() 或 % 运算符。
13 Numbers
数字类型
-
整数（
<int>）:整数可以从浮点数、字符串或布尔值转换得到。int\_from\_float \= int(3.14) \# 结果是 3 int\_from\_str \= int('123') \# 结果是 123 int\_from\_bool \= int(True) \# 结果是 1，因为True等价于1，False等价于0 int\_from\_floor \= math.floor(3.14) \# 结果是 3，使用math模块的floor函数 -
浮点数（
<float>）:浮点数可以从整数、字符串或布尔值转换得到。另外，浮点数也可以由整数和指数（e±）表示。float\_from\_int \= float(123) \# 结果是 123.0 float\_from\_str \= float('3.14') \# 结果是 3.14 float\_from\_bool \= float(False) \# 结果是 0.0 float\_from\_exp \= 1.23e4 \# 结果是 12300.0 -
复数（
<complex>）:复数可以由实部和虚部（imag）组成，也可以由整数或浮点数与j（虚数单位）结合表示。complex\_from\_zero \= complex(0, 0) \# 结果是 0j complex\_from\_ints \= complex(3, 4) \# 结果是 (3+4j) complex\_from\_floats \= complex(3.0, 4.0) \# 结果是 (3+4j) complex\_from\_str \= complex('3+4j') \# 结果是 (3+4j) -
分数（
<Fraction>）:分数来自fractions模块，可以由分子和分母组成。from fractions import Fraction fraction\_from\_zero \= Fraction(0, 1) \# 结果是 0 fraction\_from\_nums \= Fraction(3, 4) \# 结果是 3/4 \# 也可以使用Fraction的命名参数 fraction\_from\_kwargs \= Fraction(numerator\=3, denominator\=4) \# 结果是 3/4 -
十进制数（
<Decimal>）:十进制数来自decimal模块，常用于需要精确控制浮点数运算的场合。可以从字符串或整数转换。from decimal import Decimal decimal\_from\_str \= Decimal('3.14') \# 结果是 Decimal('3.14') decimal\_from\_int \= Decimal(123) \# 结果是 Decimal('123') \# 使用tuple表示的方法较少见，通常不这么用 \# decimal\_from\_tuple = Decimal((1, (1, 2, 3), -2)) # 这表示 1.123
数学计算的几个内置函数
-
pow(<num>, <num>)或<number> \** <number>这两个表达式都是用于计算幂的。
pow是一个函数，接受两个参数（基数和指数），并返回基数的指数次幂。<number> ** <number>是幂运算符的语法。示例：
result \= pow(2, 3) \# 相当于 2 \*\* 3 print(result) \# 输出 8 -
abs(<num>)abs函数用于计算一个数的绝对值。它接受一个数字（整数或浮点数）作为参数，并返回其绝对值。对于复数，abs返回的是复数的模（magnitude）。示例：
result \= abs(\-5) \# 绝对值 print(result) \# 输出 5 result\_complex \= abs(3+4j) \# 复数的模 print(result\_complex) \# 输出 5.0 -
round(<num> [, ±ndigits])round函数用于四舍五入浮点数。它接受两个参数：要四舍五入的数字和一个可选的位数参数。如果提供了位数参数，它会将数字四舍五入到指定的小数位数。如果位数参数是负数，则会将数字四舍五入到指定的十的整数幂的倍数。示例：
result \= round(3.14159, 2) \# 保留两位小数 print(result) \# 输出 3.14 result\_negative\_digits \= round(126, \-1) \# 四舍五入到最近的十的倍数 print(result\_negative\_digits) \# 输出 130
14 math模块
在科学计算领域，会用到math模块
常量
-
e: 自然对数的底数（约等于2.71828）。 -
pi: 圆周率（约等于3.14159）。 -
inf: 表示正无穷大的浮点数。 -
nan: 表示“不是一个数字”（Not a Number）的特殊浮点数值。
函数
-
isinf(x): 检查x是否为正无穷大或负无穷大。 -
isnan(x): 检查x是否为“不是一个数字”（NaN）。
注意：<el> == nan 总是返回False，因为NaN是一个特殊的值，与任何其他值（包括它自身）都不相等。为了检查一个数是否是NaN，应该使用isnan(x)函数。
-
sin(x),cos(x),tan(x): 分别计算正弦、余弦和正切值。这些函数默认接受弧度作为输入。 -
asin(x),acos(x),atan(x): 分别是sin,cos,tan的反函数，也称为反正弦、反余弦和反正切。这些函数返回弧度值。
另外：math模块还提供了degrees(x)和radians(x)函数，用于在度数和弧度之间进行转换。
-
log(x[, base]): 计算x的自然对数（以e为底），如果提供了base参数，则计算以base为底的对数。 -
log10(x): 计算x的以10为底的对数。 -
log2(x): 计算x的以2为底的对数。
示例
from math import e, pi, inf, nan, isinf, isnan, sin, cos, tan, asin, acos, atan, log, log10, log2
\# 常量示例
print(e) \# 输出自然对数的底数
print(pi) \# 输出圆周率
\# 函数示例
print(isinf(inf)) \# 输出True，因为inf是正无穷大
print(isnan(nan)) \# 输出True，因为nan是“不是一个数字”的特殊值
\# 三角函数示例
print(sin(pi / 2)) \# 输出1.0，因为sin(90度)等于1（转换为弧度后）
print(cos(0)) \# 输出1.0，因为cos(0度)等于1
print(tan(pi / 4)) \# 输出1.0，因为tan(45度)等于1（转换为弧度后）
\# 反三角函数示例
print(asin(1)) \# 输出1.5707963267948966（弧度），相当于90度
print(acos(0)) \# 输出1.5707963267948966（弧度），相当于90度
print(atan(1)) \# 输出0.7853981633974483（弧度），相当于45度
\# 对数函数示例
print(log(e)) \# 输出1.0，因为ln(e)等于1
print(log10(100)) \# 输出2.0，因为log10(100)等于2
print(log2(8)) \# 输出3.0，因为log2(8)等于3
print(log(100, 10)) \# 输出2.0，计算以10为底100的对数
15 random模块
常常用于生成随机数
random()
random()函数返回一个在[0.0, 1.0)范围内的随机浮点数。也就是说，它包括0.0但不包括1.0。
示例：
from random import random
random\_float \= random()
print(random\_float) \# 输出类似 0.3456789
randint(a, b)
randint(a, b)函数返回一个在[a, b]范围内的随机整数，包括a和b。
示例：
from random import randint
random\_int \= randint(1, 10) \# 生成1到10之间的随机整数
print(random\_int) \# 输出可能是 1, 2, ..., 10 中的任意一个
choice(seq)
choice(seq)函数从非空序列（例如列表、元组或字符串）中随机选择一个元素并返回。
示例：
from random import choice
sequence \= \[1, 2, 3, 4, 5\]
random\_element \= choice(sequence)
print(random\_element) \# 输出可能是 1, 2, 3, 4, 5 中的任意一个
其他提到的函数
-
shuffle(list)：将列表的元素随机打乱。 -
gauss(mu, sigma)：返回一个具有指定平均值（mu）和标准差（sigma）的正态分布随机数。 -
triangular(low, high, mode)：返回一个在[low, high]范围内的随机浮点数，其分布是三角形分布，其中mode是众数（即最常见的值）。 -
seed(a=None, version=2)：为随机数生成器设置种子。如果提供了a，则使用它作为种子；否则，使用系统时间。设置种子可以确保随机数生成器的输出是可重复的。
16 内置函数
Lambda
没有参数的lambda函数
square\_of\_five = lambda: 5 \*\* 2 # 返回一个固定值 25
print(square\_of\_five()) # 输出: 25
带有参数的lambda函数
add\_two\_numbers = lambda x, y: x + y # 接收两个参数并返回它们的和
print(add\_two\_numbers(3, 4)) # 输出: 7
推导式
\# 列表推导：创建一个包含1到10的列表
list\_comp = \[i+1 for i in range(10)\] # 结果: \[1, 2, ..., 10\]
\# 生成器表达式：创建一个生成器，它生成6到9的数字
gen\_expr = (i for i in range(10) if i > 5) # 结果: 类似iter(\[6, 7, 8, 9\])，但它是生成器
\# 集合推导：创建一个包含5到14的集合（注意集合中元素唯一）
set\_comp = {i+5 for i in range(10)} # 结果: {5, 6, ..., 14}，但重复的元素只会出现一次
\# 字典推导：创建一个字典，其中键是0到9，值是键的两倍
dict\_comp = {i: i\*2 for i in range(10)}
Map, Filter, Reduce
from functools import reduce
\# 使用map函数将range(10)中的每个元素加1
\# 结果类似于 iter(\[1, 2, ..., 10\])
mapped\_iter \= map(lambda x: x + 1, range(10))
\# 使用filter函数过滤出range(10)中大于5的元素
\# 结果类似于 iter(\[6, 7, 8, 9\])
filtered\_iter \= filter(lambda x: x \> 5, range(10))
\# 使用reduce函数将range(10)中的元素累加
\# 结果是 45
reduced\_obj \= reduce(lambda out, x: out + x, range(10))
Any, All
collection \= \[0, 1, False, True, '', 'hello'\]
\# 使用any()函数检查集合中是否有任何元素为True（在布尔上下文中）
is\_any\_true \= any(collection) \# 相当于检查是否有任何元素的bool值为True
print(is\_any\_true) \# 输出: True，因为集合中包含True和非空字符串'hello'
\# 使用all()函数检查集合中的所有元素是否都为True（在布尔上下文中）
are\_all\_true \= all(collection) \# 相当于检查所有元素的bool值是否都为True
print(are\_all\_true) \# 输出: False，因为集合中包含0、False和空字符串''，它们的bool值都是False
三元操作符（条件操作符）
简单的例子
x \= 10
y \= 20
max\_value \= x if x \> y else y
print(max\_value)
\# 输出会是 20，因为 x 不大于 y
用传统的 if-else 语句，这段代码会是这样的：
x \= 10
y \= 20
if x \> y:
max\_value \= x
else:
max\_value \= y
print(max\_value) \# 输出会是 20
条件表达式提供了一种更简洁、更紧凑的方式来执行这种简单的条件判断和赋值。
17 导入语句
1.导入一个模块：
如果你有一个名为 my_function.py 的文件，并且它包含了一些数学函数，你可以这样导入它：
import my\_function
但是，如果模块名称与内置模块相同，应该重命名该模块或避免使用相同的名称。
2.导入一个包：
一个包是一个包含多个模块的目录，并且该目录有一个名为 __init__.py 的特殊文件（该文件可以为空）。例如，假设有一个名为 my_package 的包，并且它有一个 __init__.py 文件和一个名为 utils.py 的模块。要导入整个包（但通常我们不会这样做，除非包中有一些在 __init__.py 中定义的函数或变量），可以这样做：
import my\_package
但更常见的是，从包中导入特定的模块或函数/变量。
3.从包中导入一个模块：
假设你想从 my_package 包中导入 utils.py 模块，可以这样做：
from my\_package import utils
之后，可以使用 utils 模块中的函数或变量，但需要使用 utils. 前缀。
4.从包中的模块导入特定的函数或变量：
可以直接从模块中导入特定的函数或变量，而不是整个模块。例如，如果 utils.py 中有一个名为 my_function 的函数，可以这样导入它：
from my\_package.utils import my\_function
之后，可以直接使用 my_function() 而无需任何前缀。
另外，如果想从模块中导入所有的内容（这通常不是一个好的做法，因为它可能导致命名空间污染），可以使用 * 符号：
from my\_package.utils import \*
18 类
我不知道你有没有对象，但我知道python肯定是有对象的
===================================
面向对象语言的核心：类。
类具有可继承的特性，也是这样的特性解决了第二次软件危机。
面向对象的方法将代码组织成模块化的类和对象，使得代码更加清晰、易于维护和扩展。
class Person:
def \_\_init\_\_(self, name):
self.name \= name
class Employee(Person):
def \_\_init\_\_(self, name, staff\_num):
super().\_\_init\_\_(name)
self.staff\_num \= staff\_num
Person类：
-
这是一个基本类，表示一个人。
-
它有一个构造方法（
__init__），接受一个参数name，并将其赋值给实例属性self.name。
Employee类：
-
这是一个继承自
Person类的子类，表示一个雇员。 -
它有自己的构造方法（
__init__），接受两个参数：name和staff_num。 -
使用
super()函数调用父类Person的构造方法，并将name传递给父类的构造方法，以初始化从父类继承的属性self.name。 -
另外，它还初始化了自己的实例属性
self.staff_num。
举例说明
python复制代码p = Person("Alice")
print(p.name) # 输出: Alice
e = Employee("Bob", "E123")
print(e.name) # 输出: Bob
print(e.staff\_num) # 输出: E123
需要在实际中去使用才能深刻理解什么是类，什么是面向对象。
多重继承：
类还可以多重继承，模板如下：
class A: pass
class B: pass
class C(A, B): pass
19 open函数
数据写入到文本中
with open(filename, mode='w', encoding='utf-8') as file:
file.write(text)
模式mode
-
'r'- 读取（默认）。 -
'w'- 写入（截断）。 -
'x'- 如果文件已经存在，则写入或失败。 -
'a'- 附加。 -
'w+'- 读取和写入（截断）。 -
'r+'- 从头开始阅读和写作。 -
'a+'- 从末尾开始读、写。 -
'b'- 二进制模式
20 命令行参数
**经常用于交互获取用户输入的参数
**
方法一：内置函数input
xx = input(prompt=None)
从命令行获取输入的字符串。
在与用户交互时使用。
方法二：官方标准库sys
import sys
scripts\_path = sys.argv\[0\]
arguments = sys.argv\[1:\]
方法三：官方标准库argparse
import argparse \# 1、导入argpase包
def parse\_args():
\# 2、创建参数对象
parse \= argparse.ArgumentParser(description\='xxx')
\# 3、往参数对象添加参数
parse.add\_argument('radius', type\=int, help\='Radius')
\# 4、解析参数对象获得解析对象
parse.add\_argument('height', type\=int, help\='height')
args \= parse.parse\_args()
return args
if \_\_name\_\_ \== '\_\_main\_\_':
args \= parse\_args()
\# 5、使用解析对象.参数获取使用命令行参数
print(cal\_vol(args.radius, args.height))
由于篇幅关系，以上还有很多方面没写，只写了20个基础点。大家可以在学习python多去网上查阅资料，多看看别人是怎么写的，多学习优秀代码怎么设计的。
😝除了上面分享，我也给大家整理了Python学习籽料。Python+pycharm安装包，如果有需要的话，可以V扫描下方二维码联系领取哦~
学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
