python核心编程（四）— python对象

客官°小女子只卖身不卖艺 2022-07-13 00:46 267阅读 0赞

## Python 对象 ##

### Python 对象 ###

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

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

1.  身份:
    
    每一个对象都有一个唯一的身份标识自己,任何对象的身份可以使用内建函数 id()来得到。
2.  类型
    
    对象的类型决定了该对象可以保存什么类型的值,可以进行什么样的操作,以及遵循什么样的规则。您可以用内建函数 type()查看 Python 对象的类型。
3.  值
    
    对象表示的数据项

### 标准类型 ###

1.  数字(分为几个子类型,其中有三个是整型)
2.  整型
3.  布尔型
4.  长整型
5.  浮点型
6.  复数型
7.  字符串
8.  列表
9.  元组
10. 字典

### 其他内建类型 ###

1.  类型
2.  Null 对象 (None)
3.  文件
4.  集合/固定集合
5.  函数/方法
6.  模块
7.  类

### 类型对象和 type 类型对象 ###

所有类型对象的类型都是 type,它也是所有 Python 类型的根和所有 Python 标准类的默认元类(metaclass)。

### None, Python 的 Null 对象 ###

Python有一个特殊的类型,被称作 Null 对象或者 NoneType,它只有一个值,那就是 None。 它不支持任何运算也没有任何内建方法。

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

### 内部类型 ###

1.  代码
2.  帧
3.  跟踪记录
4.  切片
5.  省略
6.  Xrange

#### 代码对象 ####

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

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

#### 帧对象 ####

帧对象表示 Python 的执行栈帧。帧对象包含 Python 解释器在运行时所需要知道的所有信息。它的属性包括指向上一帧的链接,正在被执行的代码对象(参见上文),本地及全局名字空 间字典以及当前指令等。

#### 跟踪记录 对象 ####

当异常发生时,一个包含针对异常的栈跟踪信息的跟踪记录对象被创建。

#### 切片对象 ####

扩展的切片语法允许对不同的索引切片操作,包括步进切片, 多维切片,及省略切片。多维切片语法是 `sequence[start1 : end1, start2 : end2]`, 或使用省略号,`sequence[...,start1 : end1 ]`. 切片对象也可以由内建函数 slice()来生成。步进切片允许利用第三个切片元素进行步进切片,它的语法为 `sequence[起始索引 : 结束索引 : 步进值]`。

#### 省略对象 ####

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

#### XRange 对象 ####

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

### 标准类型运算符 ###

1.  对象值的比较
2.  对象身份比较
3.  布尔类型
    
    标准类型布尔运算符
    
    <table> 
     <thead> 
      <tr> 
       <th>运算符</th> 
       <th>功能</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>not expr</td> 
       <td>expr 的逻辑非 (否)</td> 
      </tr> 
      <tr> 
       <td>expr1 and expr2</td> 
       <td>expr1 和 expr2 的逻辑与</td> 
      </tr> 
      <tr> 
       <td>expr1 or expr2</td> 
       <td>expr1 和 expr2 的逻辑或</td> 
      </tr> 
     </tbody> 
    </table>

### 标准类型内建函数 ###

标准类型内建函数

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>cmp(obj1, obj2)</td> 
   <td>比较 obj1 和 obj2, 根据比较结果返回整数 i: <br>i &lt; 0 if obj1 &lt; obj2<br>i &gt; 0 if obj1 &gt; obj2<br>i == 0 if obj1 == obj2</td> 
  </tr> 
  <tr> 
   <td>repr(obj) 或 <code>obj</code></td> 
   <td>返回一个对象的字符串表示</td> 
  </tr> 
  <tr> 
   <td>str(obj)</td> 
   <td>返回对象适合可读性好的字符串表示</td> 
  </tr> 
  <tr> 
   <td>type(obj)</td> 
   <td>得到一个对象的类型,并返回相应的 type 对象</td> 
  </tr> 
 </tbody> 
</table>

### 标准类型的分类 ###

#### 存储模型 ####

<table> 
 <thead> 
  <tr> 
   <th>分类</th> 
   <th>Python 类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>标量/原子类型</td> 
   <td>数值(所有的数值类型),字符串(全部是文字)</td> 
  </tr> 
  <tr> 
   <td>容器类型</td> 
   <td>列表、元组、字典</td> 
  </tr> 
 </tbody> 
</table>

#### 更新模型 ####

<table> 
 <thead> 
  <tr> 
   <th>分类</th> 
   <th>Python 类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>可变类型</td> 
   <td>列表, 字典</td> 
  </tr> 
  <tr> 
   <td>不可变类型</td> 
   <td>数字、字符串、元组</td> 
  </tr> 
 </tbody> 
</table>

#### 访问模型 ####

<table> 
 <thead> 
  <tr> 
   <th>分类</th> 
   <th>Python 类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>直接访问</td> 
   <td>数字</td> 
  </tr> 
  <tr> 
   <td>顺序访问</td> 
   <td>字符串、列表、元组</td> 
  </tr> 
  <tr> 
   <td>映射访问</td> 
   <td>字典</td> 
  </tr> 
 </tbody> 
</table>

#### 总结：标准类型分类 ####

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>存储模型</th> 
   <th>更新模型</th> 
   <th>访问模型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>数字</td> 
   <td>Scalar</td> 
   <td>不可更改</td> 
   <td>直接访问</td> 
  </tr> 
  <tr> 
   <td>字符串</td> 
   <td>Scalar</td> 
   <td>不可更改</td> 
   <td>顺序访问</td> 
  </tr> 
  <tr> 
   <td>列表</td> 
   <td>Container</td> 
   <td>可更改</td> 
   <td>顺序访问</td> 
  </tr> 
  <tr> 
   <td>元组</td> 
   <td>Container</td> 
   <td>不可更改</td> 
   <td>顺序访问</td> 
  </tr> 
  <tr> 
   <td>字典</td> 
   <td>Container</td> 
   <td>可更改</td> 
   <td>映射访问</td> 
  </tr> 
 </tbody> 
</table>

### 不支持的类型 ###

1.  char 或 byte
2.  指针

## Python 中的数字 ##

数字提供了标量贮存和直接访问。它是不可更改类型,也就是说变更数字的值会生成新的对象。  
Python 支持多种数字类型:整型、长整型、布尔型、双精度浮点型、十进制浮点型和复数。

### 复数 ###

复数对象拥有数据属性, 分别为该复数的实部和虚部。复数还拥有 conjugate 方法, 调用它可以返回该复数的共轭复数对象。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>num.real</td> 
   <td>该复数的实部</td> 
  </tr> 
  <tr> 
   <td>num.imag</td> 
   <td>该复数的虚部</td> 
  </tr> 
  <tr> 
   <td>num.conjugate()</td> 
   <td>返回该复数的共轭复数</td> 
  </tr> 
 </tbody> 
</table>

### 运算符 ###

流程图阐释了强制转换的规则。数字类型之间的转换是自动进行的,程序员无须 自己编码处理类型转换。不过在确实需要明确指定对某种数据类型进行特殊类型转换的场合, Python 供了 coerce() 内建函数来帮助你实现这种转换。

![运算符][SouthEast]

### 幂运算 ###

注:\*\* 运算符优先级高于单目运算符

### \*位运算符(只适用于整数) ###

Python 整数支持标准位运算:取反(~),按位 与(&), 或(|) 及 异或(^) 及左移(<<)和右 移(>>)。

### 数值工厂函数总结 ###

<table> 
 <thead> 
  <tr> 
   <th>类(工厂函数)</th> 
   <th>操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>bool(obj) b</td> 
   <td>返回obj对象的布尔值,也就是 obj.<strong>nonzero</strong>()方法的返回值</td> 
  </tr> 
  <tr> 
   <td>int(obj, base=10)</td> 
   <td>返回一个字符串或数值对象的整数表示, 类似string.atoi();从Python 1.6起, 引入了可选的进制参数。</td> 
  </tr> 
  <tr> 
   <td>long(obj, base=10)</td> 
   <td>返回一个字符或数据对象的长整数表示,类似string.atol(), 从Python1.6起, 引入了可选的进制参数</td> 
  </tr> 
  <tr> 
   <td>float(obj)</td> 
   <td>返回一个字符串或数据对象的浮点数表示,类似string.atof()</td> 
  </tr> 
  <tr> 
   <td>complex(str) or complex(real,imag=0.0)</td> 
   <td>返回一个字符串的复数表示,或者根据给定的实数(及一个可选的虚数部分)生成一个复数对象。</td> 
  </tr> 
 </tbody> 
</table>

### 功能函数 ###

Python 有五个运算内建函数用于数值运算: abs(), coerce(), divmod(), pow(), pow() 和 round()。

1.  abs()返回给定参数的绝对值。
2.  函数 coerce()仅回一个包含类型转换完 毕的两个数值元素的元组。
3.  divmod()内建函数把除法和取余运算结合起来, 返回一个包含商和余数的元组。
4.  函数 pow() 和双星号 (\*\*) 运算符都可以进行指数运算。不过二者的区别并不仅仅在于一个是运算符,一个是内建函数。
5.  内建函数 round()用于对浮点数进行四舍五入运算。它有一个可选的小数位数参数。如果不供小数位参数,它返回与第一个参数最接近的整数(但仍然是浮点类型)。第二个参数告诉 round 函数将结果精确到小数点后指定位数。

### 仅用于整数的函数 ###

1.  进制转换函数
    
    Python还提供了两个内建函数来返回字符串表示的8进制和16进制整数。它们分别是 oct() 和 hex()。它们都接受一个整数(任意进制的)对象,并返回一个对应值的字符串对象。
2.  ASCII 转换函数
    
    函数 chr()接受一个单字节整数值,返回一个字符串,其值为对应的字符。函数 ord()则相反,它接受一个字符,返回其对应的整数值。

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hex(num)</td> 
   <td>将数字转换成十六进制数并以字符串形式返回</td> 
  </tr> 
  <tr> 
   <td>oct(num)</td> 
   <td>将数字转换成八进制数并以字符串形式返回</td> 
  </tr> 
  <tr> 
   <td>chr(num)</td> 
   <td>将ASCII值的数字转换成ASCII字符,范围只能是0 &lt;= num &lt;= 255。</td> 
  </tr> 
  <tr> 
   <td>ord(chr)</td> 
   <td>接受一个 ASCII 或 Unicode 字符(长度为1的字符串),返回相应的ASCII或Unicode值。</td> 
  </tr> 
  <tr> 
   <td>unichr(num)</td> 
   <td>接受Unicode码值,返回 其对应的Unicode字符。所接受的码值范围依赖于你的Python是构建于UCS‐2还是UCS‐4。</td> 
  </tr> 
 </tbody> 
</table>

### 其他数字类型 ###

#### 布尔“数” ####

尽管布尔值看上去是“True”和“False, 但是事实上是整型的子类,对应与整数的 1 和 0。

1.  有两个永不改变的值 True 或 False。
2.  布尔型是整型的子类,但是不能再被继承而生成它的子类。
3.  没有**nonzero**()方法的对象的默认值是True。
4.  对于值为零的任何数字或空集(空列表、空元组和空字典等)在Python中的布尔值都是 False。
5.  在数学运算中,Boolean 值的 True 和 False 分别对应于 1 和 0。
6.  以前返回整数的大部分标准库函数和内建布尔型函数现在返回布尔型。
7.  True和False现在都不是关键字,但是在Python将来的版本中会是。

--------------------

参考资料：  
Python核心编程  
备注：  
转载请注明出处：[http://blog.csdn.net/wsyw126/article/details/53709449][http_blog.csdn.net_wsyw126_article_details_53709449]  
作者：WSYW126

[SouthEast]: /images/20220713/91b9390790f54c36beb79772964d9a03.png
[http_blog.csdn.net_wsyw126_article_details_53709449]: http://blog.csdn.net/wsyw126/article/details/53709449