【Python学习】python学习手册--第四章 Python对象类型

Python程序可以分解为四大部分：

1. 程序由模块构成
2. 模块包含语句
3. 语句包含表达式
4. 表达式建立并处理对象

为什么要使用内置对象

• 内置对象使程序更容易编写。对于一些简单的任务，内置对象就能表示问题领域的所有结构。
• 内置对象是扩展的组件。对于复杂的任务，仍然需要内置对象。比如自己编写的类，往往也是建立在内置对象的基础上。
• 内置对象比定制的数据结构更有效率。Python的内置类型已经由c语言实现数据结构算法，所以在速度方面更有效率。
• 内置对象是语言标准的一部分。内置对象在语言内部都是标准的，一致的。

Python核心数据类型

数字

Python中的数字类型可以存储各类数据，包括整数（int型，无小数部分），浮点数（含有小数部分）以及其它少见的数据类型（比如复数，有理分数以及集合等等）。
Python的数字类型也支持基本的数学运算: + 、-、 * 、 / 、 **(乘方)

>>> 2**3
8
>>> 2*3
6
>>> 2+3
5
>>> 2-3
-1
>>> 

python还有一些数字工具包，比如math、random，需要导入后使用。

>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(4)
2.0
>>> math.sqrt(64)
8.0
>>> import random
>>> random.random()
0.36742454542268776
>>> random.random()
0.6723045899548151
>>> random.random()
0.23553798252588476
>>> 

在数字类型上，Python还有第三方的开源扩展工具，可以方便的表示向量，矩阵等数学上常见的数字类型。

字符串

字符串是用来记录文本信息的。在Python中，字符串是一种序列（一个包含其它对象的有序集合，与后面介绍的列表类似，严格意义上，字符串是单个字符的有序队列），也就是说字符串是包含了从左至右的顺序，且其中的原始可以根据它们相对应的位置进行存储和读取。

序列操作

按照有序索引对字符进行读取。

>>> strtest="StayFocus" 
>>> strtest[0]
'S'
>>> strtest[1]
't'
>>> strtest[2]
'a'
>>> strtest[3]="O"                           #字符串具有不可变性，不能单独对字符串中的某个字符进行更替
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> strtest="StayFoolish"                    # 但是你可以通过变量重新复制，达到修改（覆盖）字符串的效果
>>> strtest
'StayFoolish'
>>>  

也可以倒序来提取字符串中的字符：

>>> strtest="StayFoolish"
>>> strtest[-1]
'h'
>>> strtest[-2]
's'
>>> strtest[-3]
'i'

Python中的字符串可以使用分片（序列都是支持分片(slice)）：

>>> strtest[0:3]
'Sta'
>>> strtest[0:-3]
'StayFool'
>>> 

序列支持使用加号合并，乘号多次复制：

>>> "stayFocus"+"stayFoolish"
'stayFocusstayFoolish'
>>> 
>>> strtest+"helloPython"
'StayFoolishhelloPython'
>>> strtest*8
'StayFoolishStayFoolishStayFoolishStayFoolishStayFoolishStayFoolishStayFoolishStayFoolish'
>>> 

字符串中常用的操作

>>> strtest
'StayFoolish'
>>> strtest.find('F')
4
>>> strtest.upper()
'STAYFOOLISH'
>>> strtest.lower()
'stayfoolish'
>>> strtest.replace('F'," a,b,c,d,")              #虽然有些方法有改变字符串的意思
'Stay a,b,c,d,oolish'
>>> strtest                              #但是变量本身的字符串并没有改变，replace方法只是返回了新的字符串对象
'StayFoolish'
>>> strtest=strtest.replace('F'," a,b,c,d,")     #通过这种重新赋值（覆盖）的方式来改变字符串
>>> strtest                                      #注意：以前旧的字符串将会被遗弃
'Stay a,b,c,d,oolish'
>>> strtest.split(',')
['Stay a', 'b', 'c', 'd', 'oolish']
>>> 

注意：以上字符串的方法都是返回了一个新的对象，并没有在原来的字符串上修改。如果没有进行任何赋值（将原来的变量进行覆盖），原来变量中的字符串并未改变。

字符串还支持一种格式化的高级替代操作，这种操作经常用于打印具有某些定制格式的字符串：

>>> "Stay {0} and {1}".format("foolish","focus") 
'Stay foolish and focus'
>>> 

还有其它很多方法都不在这里一一列举，可以通过之前写到的dir函数查看字符串中所有的属性和方法，然后通过help方法来获取帮助。

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> help(str.rfind)
Help on method_descriptor:

rfind(...)
    S.rfind(sub[, start[, end]]) -> int

    Return the highest index in S where substring sub is found,
    such that sub is contained within S[start:end].  Optional
    arguments start and end are interpreted as in slice notation.

    Return -1 on failure.

>>> 

其它编码方式

Python的字符串允许用单引号或双引号指示（它们都表示相同的东西），还允许：

• 三引号来包括多行字符串，在三引号内的字符串，每行会自动添加换行符。
• r”string”，在字符串前加上字母r，表示原始字符(raw)，引号中的字符会去掉反斜线转义机制（“\n”会原原本本的打印出来，而不会转义成为换行符）。

匹配模式

使用匹配模式，需要导入re模块，匹配模式是比较高级的字符处理模块，支持正则表达，拥有很多编辑模式来满足编程需求。

列表

Python中的列表跟字符串有一些类似，也是一种序列，支持一系列序列操作（比如索引，切片，合并等等）但是与字符串不同的是，它可以在自身变量上改变大小和内容。

>>> List=["a",'b','c','d','e']
>>> List
['a', 'b', 'c', 'd', 'e']
>>> List[0]
'a'
>>> List[0]='a1'                        #可以直接修改列表中的内容
>>> List
['a1', 'b', 'c', 'd', 'e']
>>> List+[1,2,3]                        #列表中各个元素可以是任意类型或任意类型的嵌套
['a1', 'b', 'c', 'd', 'e', 1, 2, 3]
>>> List[1:-1]
['b', 'c', 'd']
>>> 

序列常规操作

>>> List=List+[1,2,3,4,5,6,7]
>>> List
['a1', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 6, 7]
>>> List.append('00')                                 #将新元素添加到列表的最后端
>>> List
['a1', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 6, 7, '00']
>>> List.append(00)  
>>> List
['a1', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 6, 7, '00', 0]
>>> List.pop(-1)                                      #取出检索对应的元素，列表中不再含有该元素
0
>>> List
['a1', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 6, 7, '00']
>>> 

• 列表的大小虽然不确定，但是Python对于列表越界的检查还是很严格的，当引用了一个越界的索引，Python会报错
• 列表可以嵌套，列表中的元素也可以是列表，这样操作起来就很像数学中的矩阵了。
• 列表解析表达式。

>>> M=[[1,2,3],[4,5,6],[7,8,9]]
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> c2=[row[1] for row in M ]
>>> c2
[2, 5, 8]
>>> 

从上面这段代码看出，列表解析是通过对序列中的每一项运行一个表达式来创建一个新列表的方法。列表解析有处理速度上的优势。它们也能够在Python的任何的序列类型中发挥作用。

字典

Python中的字典与以上两种数据类型就有所不同：字典不是序列，而是一种映射(mapping)，字典可靠的顺序关系，也没有可靠的相对位置，它是通过“键”来存储的，是简单的“键：值”对。字典是Python核心对象集合中，唯一一种映射类型。它像列表那样，具有可变性。
字典的映射关系对应现实中的关系是很有用的：

>>> dicttest={'name':'Baymax','Age':999,'Address':'China'}        #用大括号{}来声明字典类型
>>> dicttest
{'name': 'Baymax', 'Address': 'China', 'Age': 999}
>>> dicttest={'name':'Baymax','Age':999,'Address':'China'}
>>> dicttest
{'name': 'Baymax', 'Address': 'China', 'Age': 999}
>>> dicttest['name']                                              #通过“键”来获取“值”
'Baymax'
>>> dicttest['Age'] 
999
>>> 

字典也可以进行嵌套操作，“键”所对应的“值”可以是列表，或者其它数据类型或对象。
如果真要对字典中的元素强调某种顺序的时候，这时可以取出字典中的所有键值，将键值排序，按照键值来取对应的值：

>>> dicttest={'a':1,'b':2,'c':3,'d':4}
>>> dicttest                           # 这里看出没有顺序
{'b': 2, 'c': 3, 'a': 1, 'd': 4}
>>> key_sort=list(dicttest.keys()).sort()
>>> key_sort
>>> list(dicttest.keys())     
['b', 'c', 'a', 'd']
>>> keys=list(dicttest.keys())         #将key值转化为列表
>>> keys.sort()                        #并对key值组成的列表进行排序
>>> keys
['a', 'b', 'c', 'd']
>>> for i in keys:                     #然后再输出相应的值
...   print(i, dicttest[i]) 
... 
a 1
b 2
c 3
d 4
>>> 

也可以使用sorted内置函数一步完成：

>>> sorted(dicttest)
['a', 'b', 'c', 'd']
>>> for i in sorted(dicttest):
...   print(i, dicttest[i])
... 
a 1
b 2
c 3
d 4
>>> 

当调用字典中不存在的键值，就会发生错误。

>>> dicttest
{'b': 2, 'c': 3, 'a': 1, 'd': 4}
>>> dicttest['z']                      # 字典中没有键值'z'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'z'
>>> 'z' in dicttest                     # 利用键值判断，是否存在键值'z'
False
>>> if 'z' in dicttest:
...   print('key missing')    
... 
>>> if 'z' not in dicttest:   
...   print('key missing')
... 
key missing
>>> if not 'z' in dicttest:
...   print('key missing') 
... 
key missing
>>> dicttest.get('z',0)            #也可以用字典中的get方法，当键值不存在时会默认返回零值
0
>>> 

元组

元组对象（tuple）基本上就是不能改变的列表，像列表一样，元组也是序列，但是它如字符串一样有不可变性。

>>> T=(1,2,3,4,5,6,7,9,8,7,6,5)       #与列表不同，元组由（）括号声明 
>>> T
(1, 2, 3, 4, 5, 6, 7, 9, 8, 7, 6, 5)
>>> T+(88,99)                          # 加号结合成为新的元组
(1, 2, 3, 4, 5, 6, 7, 9, 8, 7, 6, 5, 88, 99)
>>> T
(1, 2, 3, 4, 5, 6, 7, 9, 8, 7, 6, 5)
>>> T[0]=0                          # 元组具有不可变性，不能像列表一样修改其中某个值
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> 

一些元组的其它方法：

>>> T.index(7)             #返回从左到右第一个为7的元素的索引
6
>>> T.count(7)             # 元组中出现元素7的次数
2
>>> 

为什么使用元组

与列表相比，元组的操作很少。我们使用元组时，最主要的就是应用它的不可变性，这在编程过程中，可以增加各个模块之间的约束性。

文件

文件对象是python与外界计算机沟通的主要接口。

>>> file = open('filedata.txt','w')
>>> file.write('Hello Python, 123456\n')
21                                              #这里执行write写入数据，返回的是写入文件的字节数。
>>> file.close()

当Python需要对文件读取时，返回的都是字符串类型，读取之后再做其它处理。

>>> fileread=open('filedata.txt')
>>> txt=fileread.read()
>>> txt
'Hello Python, 123456\n'
>>> print(txt)                 #print函数会将\n转义成为换行符
Hello Python, 123456

>>> txt.split(',')
['Hello Python', ' 123456\n']
>>> number=txt.split(',')[1].rstrip()
>>> number
' 123456'
>>> number.lstrip()
'123456'
>>> number=number.lstrip()               #去掉多余的空格
>>> int(number)
123456                                   #转化成为整型数字
>>> 

其它核心类型

集合

集合很像只有键的字典，这些键值不会有对应的值，这些键值不会重复：

>>> s={1,2,3,4,5,6}
>>> s
{1, 2, 3, 4, 5, 6}
>>> s={1,2,3,4,5,6,1,2,3}
>>> s
{1, 2, 3, 4, 5, 6}

集合的一些操作：

>>> s={1,2,3,4,5,6,1,2,3}
>>> s
{1, 2, 3, 4, 5, 6}
>>> s1={4,5,6,7,8}
>>> s-s1                  #s集合中有的，而s1中没有的
{1, 2, 3}
>>> s1-s                  
{8, 7}
>>> s|s1                  #并集
{1, 2, 3, 4, 5, 6, 7, 8}
>>> s & s1                #交集
{4, 5, 6}
>>> 

分数

>>> from fractions import Fraction
>>> f1 = Fraction(1,3)      #表示分数三分之一
>>> f2 = Fraction(1,2)
>>> f1+f2
Fraction(5, 6)                   #相加为六分之五
>>> f2+3
Fraction(7, 2)
>>> 

布尔值以及占位符对象None

>>> 1 < 2
True
>>> 3 < 1
False
>>> N=(None,None,None)
>>> len(N)
3
>>> N
(None, None, None)
>>> 

总结

Python中的数据都是对象，它们有自己的方法，自己的属性。如果有需要还可以自己定义自己需要的对象。Python本身就支持面向对象，上面介绍的核心数据类型都是属于对象。如果之前接触过OOP，那么学习起来将会轻松许多。

---

不可变性的对象类型：数字，字符串，元组。
序列类型的对象类型：字符串，列表，元组。
映射类型的对象类型：字典。