大厂卖8800都买不到的Python资料，竟然能够白嫖到？这还不看看？

前言

大家好 我是你们的笨蛋程序员灰南。一直立志成长为牛逼程序员的我，
在最近学习发展的时候也遇到了很多问题。最近在学python，但由于接触时间不是很长。经过向五湖四海的广大大神程序员取经之后。
多方取证之后，我才总结出来了这篇我自认为很牛的Python自动化的部分解析和梗概

这里也是给大伙准备了一些极其给力的资料 如果有需要的伙伴可以进群领取CSDN资料

---

一、 Python对象

Python使用对象模型来存储数据。构造任何类型的值都是一个对象。尽管 Python通常当成一种“面向对象的编程语言”，但你完全能够写出不使用任何类和实例的实用脚本。

不过Python的对象语法和架构鼓励我们使用这些特性，下面让我们仔细研究一下Python对象。

所有的Python对像都拥有三个特性:身份，类型和值。

身份：

每一个对象都有一个唯一的身份标识自己,任何对象的身份可以使用内建函数id()来得到。这个值可以被认为是该对象的内存地址。您极少会用到这个值，也不用太关心它究竟是什么。

类型：

对象的类型决定了该对象可以保存什么类型的值，可以进行什么样的操作，以及遵循什么样的规则。您可以用内建函数type()查看Python对象的类型。

因为在Python 中类型也是对象(还记得我们提到 Python是面向对象的这句话吗?)，所以 type()返回的是对象而不是简单的字符串。

如果对象支持更新操作，那么它的值就可以改变，否则它的值也是只读的。对象的值是否可以更改被称为对象的可改变性(mutability)，我们会在后面讨论这个问题。只要一个对象还没有被销毁,这些特性就一直存在。

值：

对象表示的数据项

上面三个特性在对象创建的时候就被赋值，除了值之外，其它两个特性都是只读的。对于新风格的类型和类，对象的类型也是可以改变的，不过对于初学者并不推荐这样做。

如果对象支持更新操作，那么它的值就可以改变，否则它的值也是只读的。对象的值是否可以更改被称为对象的可改变性(mutability)，我们会在后面的小节中讨论这个问题。只要一个对象还没有被销毁,这些特性就一直存在。

Python有一系列的基本（内建)数据类型，必要时也可以创建自定义类型来满足你的应用程序的需求。绝大多数应用程序通常使用标准类型，对特定的数据存储则通过创建和实例化类来实现。

1.对象属性

某些Python对象有属性、值或相关联的可执行代码，比如方法(method )。

Python用点(.)标记法来访问属性。属性包括相应对象的名字等等。最常用的属性是函数和方法，不过有一些Python类型也有数据属性。含有数据属性的对象包括(但不限于):类、类实例、模块、复数和文件。

2.标准类型

• 数字（分为几个子类型，其中有三个是整型）
• 整型
• 布尔型
• 长整型
• 浮点型
• 复数型
• 字符串
• 列表
• 元组
• 字典

在本文中，我们把标准类型也称作“基本数据类型”，因为这些类型是 Python 内建的基本数据类型。

2.其他内建类型

• 类型
• Null对象（None）
• 文件
• 集合/固定集合
• 函数/方法
• 模块
• 类
  这些是当你做Python开发时可能会用到的一些数据类型。我们在这里讨论Type和 None类型的使用，除此之外的其他类型将在其他章节中讨论。

3.类型对象和 type类型对象

在本章我们要讨论所有的Python类型，虽然看上去把类型本身也当成对象有点特别，我们还是要在这里提一提。你一定还记得，对象的一系列固有行为和特性（比如支持哪些运算，具有哪些方法）必须事先定义好。从这个角度看，类型正是保存这些信息的最佳位置。描述一种类型所需要的信息不可能用一个字符串来搞定，所以类型不能是一个简单的字符串，这些信息不能也不应该和数据保存在一起，所以我们将类型定义成对象。

下面我们来正式介绍内建函数type()。通过调用type()函数你能够得到特定对象的类型信息:

type(42)<type 'int’>

我们仔细研究一下这个例子，请注意看type函数有趣的返回值。我们得到一个简洁的输出结果<type ‘int’>。不过你应当意识到它并不是一个简简单单的告诉你42是个整数这样的字符串。
您看到的<type ‘int’>实际上是一个类型对象，碰巧它输出了一个字符串来告诉你它是个int型对象。

现在你该问自己了，那么类型对象的类型是什么?来，我们试验一下:

type(type(42))
<type ‘type’>

没错，所有类型对象的类型都是type，它也是所有Python类型的根和所有Python标准类的默认元类(metaclass)。你现在有点搞不明白，没关系，随着我们逐步深入的学习类和类型，你就会慢慢理解。

随着Python 2.2中类型和类的统一，类型对象在面向对象编程和日常对象使用中扮演着更加重要的角色。从现在起，类就是类型，实例是对应类型的对象。

4.None，Python的Null对象

Python有一个特殊的类型,被称作Null对象或者NoneType,它只有一个值,那就是None。

它不支持任何运算也没有任何内建方法。如果非常熟悉C语言，和 None类型最接近的C类型就是void，None类型的值和C的NULL值非常相似（其他类似的对象和值包括Perl 的undef和Java 的void类型与null值)。

None没有什么有用的属性，它的布尔值总是False。

核心笔记:布尔值
所有标准对象均可用于布尔测试，同类型的对象之间可以比较大小。每个对象天生具有布尔True或False值。空对象、值为零的任何数字或者Null对象None的布尔值都是False。
下列对象的布尔值是False。

• None
• False（布尔类型）
• 所有的值为零的数：
• 0（整型）
• （浮点型）
• OL（长整型）
• 0.0
• 0.0j（复数）
• ‘’ ‘’（空字符串）
• []（空列表）
• ()（空元组）
• {}（空字典）

值不是上面列出来的任何值的对象的布尔值都是True,例如non-empty、non-zero等等。

用户创建的类实例如果定义了nonzero(nonzero())或length (len()）且值为0，那么它们的布尔值就是False。

5. 内部类型

• 代码
• 帧
• 跟踪记录
• 切片
  省略
  Xrange

我们在这里简要介绍一下这些内部类型，一般的程序员通常不会直接和这些对象打交道。不过为了这一章的完整性，我们还是在这里介绍一下它们。请参阅源代码或者Python 的内部文档和在线文档获得更详尽的信息。

你如果对异常感到迷惑的话，可以告诉你它们是用类来实现的，在老版本的Python中，异常是用字符串来实现的。

6.代码对象

代码对象是编译过的Python源代码片段，它是可执行对象。通过调用内建函数compile()可以得到代码对象。代码对象可以被exec命令或eval()内建函数来执行。

代码对象本身不包含任何执行环境信息，它是用户自定义函数的核心，在被执行时动态获得上下文。(事实上代码对象是函数的一个属性)一个函数除了有代码对象属性以外，还有一些其它函数必须的属性，包括函数名，文档字符串，默认参数，及全局命名空间等等。

7.帧对象

帧对象表示 Python的执行栈帧。
帧对象包含Python解释器在运行时所需要知道的所有信息。

它的属性包括指向上一帧的链接，正在被执行的代码对象，本地及全局名字空间字典以及当前指令等。每次函数调用产生一个新的帧，每一个帧对象都会相应创建一个C栈帧。

用到帧对象的一个地方是跟踪记录对象。

8. 跟踪记录 对象

当你的代码出错时，Python就会引发一个异常。如果异常未被捕获和处理，解释器就会退出脚本运行，显示类似下面的诊断信息:

Traceback (innermost last):
File “stdin>”， line N?, in ???
ErrorName: error reason

当异常发生时，一个包含针对异常的栈跟踪信息的跟踪记录对象被创建。如果一个异常有自己的处理程序，处理程序就可以访问这个跟踪记录对象。

9.切片对象

当使用Python扩展的切片语法时，就会创建切片对象。

扩展的切片语法允许对不同的索引切片操作，包括步进切片，多维切片，及省略切片。多维切片语法是sequence[startl : endl,start2 : end2]，或使用省略号，sequence[… . , startl : endl ].

切片对象也可以由内建函数slice()来生成。步进切片允许利用第三个切片元素进行步进切片，它的语法为sequence[起始索引∶结束索引︰步进值]。

Python 很早就支持扩展步进切片语法了，但直到Python2.3以前都必须依靠CAPI或Jython才能工作。下面是几个步进切片的例子:
当使用Python扩展的切片语法时，就会创建切片对象。扩展的切片语法允许对不同的索引切片操作，包括步进切片，多维切片，及省略切片。多维切片语法是sequence[startl : endl,start2 : end2]，或使用省略号，sequence[… . , startl : endl ].切片对象也可以由内建函数slice()来生成。步进切片允许利用第三个切片元素进行步进切片，它的语法为sequence[起始索引∶结束索引︰步进值]。Python 很早就支持扩展步进切片语法了，但直到Python2.3以前都必须依靠CAPI或Jython才能工作。下面是几个步进切片的例子:

foostr = ‘abede’
foostr[::-1]‘edcba’
foostr[::-2]
‘eca’

foolist = [123, 'xba '，342.23， 'abc’]>>>foolist[::-1]
[ 'abe '，342.23， 'xba '， 123]

10.省略对象

省略对象用于扩展切片语法中，起记号作用。这个对象在切片语法中表示省略号。类似Null对象None，省略对象有一个唯一的名字Ellipsis，它的布尔值始终为True.

11.XRange对象

调用内建函数 xrange()会生成一个Xrange对象，xrange()是内建函数range()的兄弟版本，用于需要节省内存使用或range()无法完成的超大数据集场合。

标准类型运算符

1.对象值的比较

比较运算符用来判断同类型对象是否相等，所有的内建类型均支持比较运算，比较运算返回布尔值 True或False。
如果你正在使用的是早于 Python2.3的版本，因为这些版本还没有布尔类型，所以会看到比较结果为整型值1（代表True）或0(代表False)。

注意，实际进行的比较运算因类型而异。换言之，数字类型根据数值的大小和符号比较，字符串按照字符序列值进行比较，等等。

注意，实际进行的比较运算因类型而异。换言之，数字类型根据数值的大小和符号比较，字符串按照字符序列值进行比较，等等。

2 == 2
True

2.46<= 8.33True
5+4j >= 2-3jTrue
'abe’ == 'xyz’False
'abc’> 'xyz’False
'abc’< 'xyz’True
[3, ‘abc’] == ['abc '，3]False
[3， ‘abc’] == [3, ‘abc’]True
不同于很多其它语言，多个比较操作可以在同一行上进行，求值顺序为从左到右。

3<4< 7# same as ( 3< 4 ) and ( 4< 7)
True

4 > 3 == 3 # same as ( 4 > 3 ) and ( 3 == 3 )True
4 < 3 < 5 != 2 < 7False

• 表 标准类型值比较运算符
  exprl < expr2 exprl 小于expr2
  exprl > expr2 exprl 大于expr2
  exprl <= expr2 expr1 小于等于expr2
  exprl >= expr2 expr1 大于等于expr2
  expr1 == expr2 expr1 等于expr2
  expr1 != expr2 expr1不等于expr2 (C风格)
  exprl <expr2 expr1不等于expr2(ABC/Pascal风格)

注:未来很有可能不再支持〈>运算符，建议您一直使用!=运算符。

我们会注意到比较操作是针对对象的值进行的，也就是说比较的是对象的数值而不是对象本身。在后面的部分我们会研究对象身份的比较。

---

2.对象身份比较

作为对值比较的补充，Python也支持对象本身的比较。

对象可以被赋值到另一个变量（通过引用)。因为每个变量都指向同一个(共享的）数据对象，只要任何一个引用发生改变，该对象的其它引用也会随之改变。

为了方便大家理解，最好先别考虑变量的值，而是将变量名看作对象的一个链接。让我们来看以下三个例子:

例1:fool和foo2指向相同的对象

foo1 = foo2 = 4.3

当你从值的观点看这条语句时，它表现的只是一个多重赋值，将4.3这个值赋给了fool和foo2这两个变量。

这当然是对的，不过它还有另一层含义。

事实是一个值为4.3的数字对象被创建，然后这个对象的引用被赋值给fool和foo2，结果就是fool和 foo2指向同一个对象。图4—1演示了一个对象两个引用。

这个例子非常类似上一个，一个值为4.3的数值对象被创建，然后赋给一个变量，当执行foo2 = fool时，foo2被指向fool所指向的同一个对象，这是因为 Python 通过传递引用来处理对象。
foo2就成为原始值4.3的一个新的引用。这样fool和foo2就都指向了同一个对象。

foo1 = 4.3
foo2 = 1.3 + 3.0

这个例子有所不同。

首先一个数字对象被创建，然后赋值给fool.然后第二个数值对象被创建并赋值给foo2．尽管两个对象保存的是同样大小的值，但事实上系统中保存的都是两个独立的对象，其中 fool是第一个对象的引用，foo2则是第二个对象的引用。

演示给我们这里有两个不同的对象，尽管这两个对象有同样大小的数值。我们为什么在示意图中使用盒子?没错，对象就象一个装着内容的盒子。当一个对象被赋值到一个变量，就象在这个盒子上贴了一个标签，表示创建了一个引用。

每当这个对象有了一个新的引用，就会在盒子上新贴一张标签。当一个引用被销毁时，这个标签就会被撕掉。当所有的标签都被撕掉时，这个盒子就会被回收。

那么，Python是怎么知道这个盒子有多少个标签呢?

每个对象都天生具有一个计数器，记录它自己的引用次数。这个数目表示有多少个变量指向该对象。这也就是我们在提到的引用计数.Python提供了is和is not运算符来测试两个变量是否指向同一个对象。象下面这样执行一个测试

a is b
这个表达式等价于下面的表达式id(a) == id(b)

对象身份比较运算符拥有同样的优先级，表列出了这些运算符。

在下面这个例子里，我们创建了一个变量，然后将第二个变量指向同一个对象。

a =- [ 5, ‘hat’, -9.3]
b = a
a is bTrue
a is not bFalse

b = 2.5e-5>>> b
2.5e-005>>>a
[5， ‘hat’, -9.3]>>a is b
False

a is not b
True

is与not标识符都是Python关键字

核心提示:实践
在上面的例子中，您会注意到我们使用的是浮点数而不是整数。

为什么这样?整数对象和字符串对象是不可变对象，所以Python 会很高效的缓存它们。这会造成我们认为Python应该创建新对象时，它却没有创建新对象的假象。看下面的例子:

a = 1

id(a)
8402824

b = 1id(b)
8402824

c = 1.0
id©8651220
d = 1.0>
id(d)
8651204

在上面的例子中,a和 b 指向了相同的整数对象，但是c和d并没有指向相同的浮点数对象。如果我们是纯粹主义者，我们会希望a 与b 能和c 与d一样，因为我们本意就是为了创建两个整数对象，而不是像b = a 这样的结果。

Python仅缓存简单整数，因为它认为在 Python应用程序中这些小整数会经常被用到。当我们在写作本书的时候，Python缓存的整数范围是(-1，100)，不过这个范围是会改变的，所以请不要在你的应用程序使用这个特性。

Python 2.3中决定，在预定义缓存字符串表之外的字符串，如果不再有任何引用指向它，那这个字符串将不会被缓存。也就是说，被缓存的字符串将不会象以前那样永生不灭，对象回收器一样可以回收不再被使用的字符串。从 Python 1.5起提供的用于缓存字符的内建函数intern() 也已经不再推荐使用，即将被废弃。

3.布尔类型

布尔逻辑运算符and,or 和 not都是Python关键字，这些运算符的优先级按从高到低的顺序列于表4.3. not运算符拥有最高优先级，只比所有比较运算符低一级。and和 or运算符则相应的再低一级。

表 标准类型布尔运算符

前面我们提到过Python支持一个表达式进行多种比较操作，其实这个表达式本质上是由多个隐式的and 连接起来的多个表达式。

3 <4 <7#same as "( 3 < 4 ) and ( 4< 7)”True

4.标准类型内建函数

除了这些运算符我们刚才也看到，Python提供了一些内建函数用于这些基本对象类型：
cmp（），repr（），str（）type（），和等同于repr（）函数的单反引号（’’）运算符。

5.type

我们现在来正式介绍type()。在 Python2.2以前，type()是内建函数。不过从那时起，它变成了一个“工厂函数”。在本章的后面部分我们会讨论工厂函数，现在你仍然可以将type()仅仅当成一个内建函数来看。type() 的用法如下:

type (object)

type()接受一个对象做为参数，并返回它的类型。它的返回值是一个类型对象。

type (4)#int type
<type ‘int’>

type (’ Hello World ! ') # string type
<type ‘string’>

type (type(4)) #type type
<type ‘type’>

在上面的例子里，我们通过内建函数type()得到了一个整数和一个字符串的类型;为了确认一下类型本身也是类型，我们对type()的返回值再次调用type().一注意type()有趣的输出，它看上去不象一个典型的Python数据类型，比如一个整数或一个字符串，一些东西被一个大于号和一个小号包裹着。

这种语法是为了告诉你它是一个对象。每个对象都可以实现一个可打印的字符串表示。

不过并不总是这样，对那些不容易显示的对象来说，Python 会以一个相对标准的格式表示这个对象,格式通常是这种形式:<object_something_or_another>，以这种形式显示的对象通常会提供对象类别，对象id或位置，或者其它合适的信息。

6.cmp（）

内建函数cmp()用于比较两个对象objl和 obj2，如果objl小于obj2，则返回一个负整数，如果objl大于obj2则返回一个正整数，如果objl等于obj2，则返回0。

它的行为非常类似于C语言的strcmp()函数。比较是在对象之间进行的，不管是标准类型对象还是用户自定义对象。如果是用户自定义对象， cmp()会调用该类的特殊方法_cmp_()。

会详细介绍类的这些特殊方法。下面是几个使用cmp()内建函数的对数值和字符串对象进行比较的例子。

a, b = -4, 12>
cmp (a, b)
-1

cmp(b, a)1
b = —4>>>cmp(a, b)

a, b = 'abc '， ‘xyz’>
cmp (a, b)
-23

cmp(b, a)
23

b = ‘abc’

cmp(a, b)
0
在后面我们会研究cmp（）用于其它对象的比较操作。

7.str（）和repr（）（及 ’ '运算符）

内建函数str() 和repr()或反引号运算符(~`）可以方便的以字符串的方式获取对象的内容、类型、数值属性等信息。

str()函数得到的字符串可读性好，而repr()函数得到的字符串通常可以用来重新获得该对象，通常情况下obj == eval(repr(obj)）这个等式是成立的。

两个函数接受一个对象做为其参数，返回适当的字符串。在下面的例子里，我们会随机取一些Python对象来查看他们的字符串表示。

str(4.53-2j)
’(4.53-2j)’

str(1)'1’

str (2e10)
’20000000000.o’>>>

str([0, 5，9，9])’
[0，5，9，9]’

repr([0，5，9，9])
’[0，5，9，9]’

¹`’[0，5，9，9]’

尽管str(), repr()和`运算在特性和功能方面都非常相似，事实上repr()和``做的是完全一样的事情，它们返回的是一个对象的“官方”字符串表示，也就是说绝大多数情况下可以通过求值运算(使用eval()内建函数)重新得到该对象，但 str()则有所不同。

str()致力于生成一个对象的可读性好的字符串表示，它的返回结果通常无法用于eval()求值，但很适合用于 print语句输出。需要再次提醒一下的是，并不是所有repr()返回的字符串都能够用eval()内建函数得到原来的对象:

eval ( type(type)))File “”， line 1eval ( type (type)))
SyntaxError: invalid syntax

也就是说 repr()输出对Python 比较友好，而str()的输出对人比较友好。虽然如此，很多情况下这三者的输出仍然都是完全一样的。

核心笔记:为什么我们有了repr()还需要^^`?

在Python学习过程中，你偶尔会遇到某个运算符和某个函数是做同样一件事情。之所以如此是因为某些场合函数会比运算符更适合使用。
举个例子，当处理类似函数这样的可执行对象或根据不同的数据项调用不同的函数处理时，函数就比运算符用起来方便。另一个例子就是双星号()乘方运算和pow()内建函数，x林y 和pow(x, y)执行的都是x的y次方。**

8.type（）和isinstance（）

Python不支持方法或函数重载，因此你必须自己保证调用的就是你想要的函数或对象。幸运的是，我们前面提到的type()内建函数可以帮助你确认这一点。

一个名字里究竟保存的是什么?相当多，尤其是这是一个类型的名字时。确认接收到的类型对象的身份有很多时候都是很有用的。

为了达到此目的，Python提供了一个内建函数 type(). type()返回任意Python对象对象的类型，而不局限于标准类型。让我们通过交互式解释器来看几个使用type()内建函数返回多种对象类型的例子:

Python不支持方法或函数重载，因此你必须自己保证调用的就是你想要的函数或对象。(参阅Python常见问答4.75节)。幸运的是，我们前面4.3.1小节提到的type()内建函数可以帮助你确认这一点。一个名字里究竟保存的是什么?相当多，尤其是这是一个类型的名字时。确认接收到的类型对象的身份有很多时候都是很有用的。为了达到此目的，Python提供了一个内建函数 type(). type()返回任意Python对象对象的类型，而不局限于标准类型。让我们通过交互式解释器来看几个使用type()内建函数返回多种对象类型的例子:

type(’’)
<type ‘str’>>>>

s = ‘xyz’>>>type (s)<type ‘str’>>>>
type (100)Ktype ‘int’>>>>type(O+0j)Ktype ‘complex’>>type (OL)Ktype ‘long’>>>>type (0.0)<type ‘float’>>>>
type([])<type ‘list’>>>>type(())

<type ‘tuple’>

type (l})<type ‘dict’>>

type (type)
<type ‘type’>>>>
class Foo: pass #new-style class
…

foo = Foo()
class Bar (object): pass#new-style class…
bar = Bar (>>>

type(Foo)<type ‘classobj’>>>>type(foo)<type ‘instance’>>>type (Bar)<type ‘type’>>>>type(bar)
<class ‘main.Bar’>

Python2.2统一了类型和类，如果你使用的是低于Python2.2的解释器，你可能看到不一样的输出结果。

除了内建函数type()，还有一个有用的内建函数叫isinstance()．
我们会面向对象编程正式研究这个函数，不过在这里我们还是要简要介绍一下你如何利用它来确认一个对象的类型。

举例

在其中们提供了一段脚本来演示在运行时环境使用isinstance()和 type()函数。随后我们讨论type()的使用以及怎么将这个例子移植为改用isinstance()。

运行typechk.py，我们会得到以下输出:

-69 is a number of type: int
9999999999999999999999 is a number of type:
long98.6 is a number of type: float
(-5.2+1.9j) is a number of type: comple
xxxx is not a number at all ! !

检查类型(typechk.py)

函数displayNumType()接受一个数值参数，它使用内建函数type()来确认数值的类型(或不是一个数值类型)。

1 # !/usr/bin/env python2
3def displayNumType (num) :4 print num, 'is '，
5 if isinstance (num,(int,long,float,complex) ) :6 print 'a number of type: ', type (num)._name__7 else:
8 print 'not a number at all ! !’9
10 displayNumType (-69)
11 displayNumType(9999999999999999999999L)12 displayNumType(98.6)
13 displayNumType(-5.2+1.9j)14 displayNumType ( ‘xxx’)

例子进阶
原始
这个完成功能的函数与本书的第一版中的例子已经大不相同：

def displayNumetype（num）：
例子进阶
print num, "is ",
if type (num) == type(O) :print ‘an integer’
elif type (num) -= type (OL) :print ‘a long’
elif type (num) == type(0.0):print ‘a float’
elif type (num) == type(O+0j):print ‘a complex number’
else:
print 'not a number at all ! !’

由于 Python奉行简单但是比较慢的方式，所以我们必须这么做，看一眼我们原来的条件表达式:
if type (num) == type(0). . .

减少函数调用的次数
如果我们仔细研究一下我们的代码，会看到我们调用了两次 type()。

要知道每次调用函数都会付出性能代价，如果我们能减少函数的调用次数，就会提高程序的性能。

利用在本章我们前面提到的 types模块，我们还有另一种比较对象类型的方法，那就是将检测得到的类型与一个已知类型进行比较。如果这样，我们就可以直接使用type对象而不用每次计算出这个对象来。那么我们现在修改一下代码，改为只调用一次type()函数:

import types
if type (num) == types.IntType… .

---

对象值比较 VS对象身份比较

在这一章的前面部分我们讨论了对象的值比较和身份比较，如果你了解其中的关键点,你就会发现我们的代码在性能上还不是最优的.在运行时期,只有一个类型对象来表示整数类型.也就是说, type(0), type(42), type(-100）都是同一个对象:<type ‘int’>(types.IntType 也是这个对象)

最后！

今天的文章就到这里结束啦，希望看完以后能对有一些不大不小的帮助。如果喜欢的可以点赞收藏关注，如果不行的话，那也得行（我们IT人不能说不行）球球大伙辽

如果大家感兴趣的话，可以学习交流讨论的,咱可以一起加油，可以点击这里，咱们一起进步

---

1. 0， 5，9， 9 ↩︎