[基础]1、对象类型介绍

python对象概述
一切皆为对象，包括数字，字符串、函数等等。
python的核心数据类型
python的内置对象类型
1.、数字        例如：123， 3.23， 99L， 3+4j, Decimal
2、字符串     例如：'spam', "guido's"
3、列表         例如：[1,3,4,5], [1,[2,'three'],4]
4、字典         例如：{'food':'spam','taste':'yum'}
5、元组         例如：(1,'spam',4,'U')
6、文件         例如：myfile=open('eggg.txt','r')
7、其他类型  例如： 集合、类型、None、布尔型

数字
python的核心对象的设置包括常规的类型：整数、浮点数（小数）等
python的数字支持一般的数学运算。
常见数据操作符：
       +（加）、-（减）、*（乘）、**（乘方）、/（除）、%（求余）、//（取整）
常用的数学模块：
       math模块包括了作为函数的更高级的数学工具。
       random模块可以生成随机数也可以从python列表中选择。
例子：
>>> 123+23
146
>>> 200-40
160
>>> 4*5
20
>>> 5/2
2
>>> 68%3
2
>>> 2**3
8
>>> 2**8
256
>>> 90//7
12
>>> 90/7
12
>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(121)
11.0
>>> math.sqrt(99)
9.9498743710662
>>> import random
>>> random.random()
0.4107205858311871
>>> random.random()
0.2178325217029341
>>> random.choice([2,4,6,3,7,8,5])
4
>>> random.choice([2,4,6,3,7,8,5])
7
>>> random.choice([2,4,6,3,7,8,5])
6

字符串
字符串是由单个字符组成的字符串序列。
内置函数：字符串提供了很多内置函数。
len , 获取字符串的长度。
>>> s="span"
>>> len(s)
4


索引：通过索引操作得到其各个元素。从第一个字符开始的索引为0，反向索引的是从最后一个开始为-1。
>>> s[1]
'p'
>>> s[-1]
'n'

截取字符串：提取字符串的某一部分。范围是左闭右开区间索引
>>> s[1:3]
'pa'
>>> s[1:-1]
'pa'
>>> s[1:]
'pan'
>>> s[:-2]
'sp'
字符串的不可变性：
      字符串在python中具有不可变性（在其创建后值不能改变）。例如，你不能通过对其某一位置的进行赋值而不改变字符串对象。s[0]='z'（这是错误的操作），但是可以通过建立一个新的字符串对象并以同一个变量名对其进行赋值。
例如：
>>> s="span"
>>> id(s)
37339304L
>>> s[0]='z'
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    s[0]='z'
TypeError: 'str' object does not support item assignment
>>> s
'span'
>>> s='z'+s[1:]
>>> s
'zpan'
>>> id(s)
38006176L
可以看到修改前后的s对象已经不是同一个对象了。
类型特定的方法：
       常见的字符串独有的方法（对象函数）
       s.find(str):查找子字符串在字符串中的位置，找不到返回-1
       s.replace(str1,str2):将字符串中的str1字符串替换成str2字符串，返回新的字符串对象
       s.split(str):将字符串按str作为分隔符拆分为列表
       s.upper():将字符串全部转为大写
       s.lower():将字符串权威转为小写
       s.isalapha():测试字符串的内容，若为字符，返回true.否则返回false
       s.rstrip():去除字符串后的空格
例如：
>>> s.find("a")
2
>>> s.find("k")
-1
>>> s.replace('z',"wa")
'wapan'
>>> array=s.split("a")
>>> type(array)
<type 'list'>
>>> array
['zp', 'n']
>>> s="span"
>>> id(s)
37339304L
>>> s=s.upper()
>>> id(s)
41980152L
>>> s
'SPAN'
>>> s=s.lower()
>>> id(s)
41980112L
>>> s
'span'
>>> s.isalpha()
True
>>> s="123"
>>> s.isalpha()
False
>>> s="abc123"
>>> s.isalpha()
False
>>> s="hello world\n"
>>> s
'hello world\n'
>>> s.rstrip()
'hello world'

查看帮助：
       通过调用内置函数dir(str)，显示字符串对象的所有属性（包含方法名称）。但是dir函数只显示方法名称。如需查询详细作用，可以将字符串传递给help(str.index)函数
        例如：
>>> s="span"
>>> dir(s)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

>>> help(s.count)
Help on built-in function count:

count(...)
    S.count(sub[, start[, end]]) -> int
  
    Return the number of non-overlapping occurrences of substring sub in
    string S[start:end].  Optional arguments start and end are interpreted
    as in slice notation.

编写字符串的其他方法：
       python允许字符串以单引号或双引号引起来作为字符串表示。但这种写法不能直接按键盘换行，换行必须用斜线\转义。如果想输入多行表示一个字符串的还有一种表示形式，就是用连续三个引号（单引号或双引号）做开始和结束，中间就可以输入多行内容的字符串。


模式匹配（正则表达式匹配）
        python中有一个名为re的模块，该模块提供模式匹配的方法可以对一个字符串进行格式匹配检查。匹配的任意字符保存在group，可能通过group和groups方法查看匹配到保存内容。
例如：
>>> import re

>>> match=re.match('hello[\t]*(.*)world', "hello   tests world")

>>> match.group(1)
'   tests '
>>> match.groups()
('   tests ',)
>>> match=re.match("/(.*)/(.*)/(.*)", "/urs/aaa/bbb")
>>> match.groups()
('urs', 'aaa', 'bbb')

序列
       列表是序列中的一种，列表是一个存放任意类型对象的有序集合（同一个列表可以存放不同类型的对象），它没有固定大小，。其大小是可变的。列表支持所有对字符串中的序列操作。例如可以对列表进行索引和截取字符串操作。
>>> list=[123,"span",1.23]
>>> len(list)
3
>>> list[0]
123
>>> list[:-1]
[123, 'span']
>>> list+[4,5,"ss"]
[123, 'span', 1.23, 4, 5, 'ss']
>>> list
[123, 'span', 1.23]

列表类型特定的操作：
    python列表与其他语言的数组有些类似，就是没有固定类型的约束。另外列表可以按照需要增加、插入或减少，也可以进行排序和反转。
例如：
>>> list
[897, 'span', 1.21]
>>> list.append("NI")
>>> list
[897, 'span', 1.21, 'NI']
>>> list.pop(2)
1.21
>>> list
[897, 'span', 'NI']
>>> M=["bb","aa","cc"]
>>> M.sort()
>>> M
['aa', 'bb', 'cc']
>>> M.reverse()
>>> M
['cc', 'bb', 'aa']
列表边界检查
    python列表没有固定大小。但仍不允许引用不存在的元素（超出边界范围）。
>>> M
['cc', 'bb', 'aa']
>>> M[99]
Traceback (most recent call last):
  File "<pyshell#111>", line 1, in <module>
    M[99]
IndexError: list index out of range
>>> M[99]=12
Traceback (most recent call last):
  File "<pyshell#112>", line 1, in <module>
    M[99]=12
IndexError: list assignment index out of range

嵌套列表
    python核心数据类型的一个优秀特性就是它们支持任意的嵌套。能够以任意的组合对其进行嵌套。并可以多深层次的嵌套都可以。实际场景可以做到三维思维的矩阵。
例如：
>>> M=[[1,2,3],[4,5,6],[7,8,9]]
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> M[1]
[4, 5, 6]
>>> M[1][1]
5
>>> M[0][2]
3

列表解析：
    在处理序列的操作和列表的方法中，python还包括了一个更高级的操作，称为列表解析表达式，从而提供了一种处理像矩阵这样强大的工具。
例如：
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> cols=[row[1] for row in M]
>>> cols
[2, 5, 8]
>>> cols=[row[2] for row in M]
>>> cols
[3, 6, 9]
>>> cols=[row[1]for row in M if row[1]%2==0]
>>> cols
[2, 8]
>>> diag=[M[i][i] for i in[0,1,2]]
>>> diag
[1, 5, 9]
>>> doubles=[c*2 for c in "spam"]
>>> doubles
['ss', 'pp', 'aa', 'mm']

字典类型
    python中的字典不是序列，是一种映射，是通过”键“映射值的一种对象，字典也是python核心对象集合中唯一的一种映射类型，也具有可变性。
代码格式：{键:值，键:值}.
特点：
1、字典的元素存储是没有顺序的，需要通过键去取值，不能通过位置。
2、字典的某个元素的值可以动态改变，字典的地址位置是不会改变的。
3、可以创建空的字典。
4、字典可以嵌套
5、知道字典的某个元素对应的类型后，可以使用该类型的方法进行操作。
例如：
初始化字典：
>>> d={'food': 'spam', 'apple': 'juce', 'count': 2}
>>> d
{'food': 'spam', 'count': 2, 'apple': 'juce'}  #没有按初始顺序显示
>>> d["food"]  # 取某个键的值
'spam'
>>> id(d)
45737368L
>>> d["count"]+=1  #修改键的值
>>> d["count"]
3
>>> id(d)
45737368L
>>> d
{'food': 'spam', 'count': 3, 'apple': 'juce'}
创建空的字典，添加数据
>>> d={}
>>> d["name"]='Bob'
>>> d["age"]=40
>>> d
{'age': 40, 'name': 'Bob'}

嵌套字典
python中的字典可以嵌套，
eg.编写一个嵌套字典
>>> rec={"name":{"first":"Bob","last":"Smith"},"job":["dev","mgr"],"age":45.5}

查看字典中的一个元素，这个元素也是一个字典
>>> rec["name"]
{'last': 'Smith', 'first': 'Bob'}
查询字典元素中的字典元素
>>> rec["name"]["first"]
'Bob'
查看字典元素中的列表元素
>>> rec["job"]
['dev', 'mgr']
>>> rec["job"][-1]
'mgr'
对字典元素中的列表进行添加元素操作
>>> rec["job"].append("janitor")
>>> rec
{'age': 45.5, 'job': ['dev', 'mgr', 'janitor'], 'name': {'last': 'Smith', 'first': 'Bob'}}
>>> rec["job"]
['dev', 'mgr', 'janitor']

查看字典中某个元素类型可以使用的方法。
>>> dir(rec["job"])
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

字典的排序
    字典不是序列，没有顺序，若要排序的话，最简单的方法就是通过字典的keys()收集键的列表，并使用列表的排序方法进行循环显示。例如：
方法一：1、通过keys()获取键的列表，2、对列表使用sort()进行排序，3、通过for循环键的列表，在取字典中对应的值。
>>> d={"a":1,"b":2,"c":3}
>>> d
{'a': 1, 'c': 3, 'b': 2}
>>> keys=d.keys()
>>> keys
['a', 'c', 'b']
>>> keys.sort()
>>> keys
['a', 'b', 'c']
>>> for key in keys:
print key,"=>",d[key]
 
a => 1
b => 2
c => 3
方法二：使用 python中的内置的函数sorted可以一步完成字典的排序。原理：sorted方法是对字典的键排序的。
>>> d
{'a': 1, 'c': 3, 'b': 2}
>>> for key in sorted(d):
print key,"=>",d[key]

a => 1
b => 2
c => 3
>>> d
{'a': 1, 'c': 3, 'b': 2}
>>> sorted(d)           #sorted方法是对字典的键排序的。
['a', 'b', 'c']

迭代和优化
    for循环是通用的迭代方式。
通过列表解析表达式的方式添加元素
>>> squares=[x**2 for x in [1,2,4,8]]
>>> squares
[1, 4, 16, 64]
通过for循环，使用手动增加的方式添加元素。
>>> squares=[]
>>> for x in [1,2,4,8]:
squares.append(x**2)
>>> squares
[1, 4, 16, 64]
上述两种方法中，使用列表解析运行会比手动循环添加元素快2倍以上。
在python中的一个主要的编码原则：首先为了简单和可读性去编码。在程序运行后，并证明了确实有必要考虑性能后，再进行优化。

判断键值是否存在
    若键不在字典中，取的时候会报错，通常通过has_key()方法判断，然后在做处理。
>>> d
{'a': 1, 'c': 3, 'b': 2}
>>> d['f']
Traceback (most recent call last):
  File "<pyshell#213>", line 1, in <module>
    d['f']
KeyError: 'f'
>>> d.has_key('f')
False
>>> d.has_key('a')
True
>>> if not d.has_key("e"):
print "d字典中不存在e"

d字典中不存在e

元组
    元组对象基本上就像一个不可改变的列表。就像列表一样，元组是序列，但是它具有不可变性。元组是一旦创建后就不能改变，也就是，元组是不可变的序列。
    元组在实际中通常并不像列表这样使用频繁，但是它的关键在于不可变性。元组可以提供一种完整性的约束，这是它的主要特点。
注意：不改变只针对于存储的一级对象而言。对象里面的值是可以改变的，例如对象是列表等。
>>> T=(1,2,3,4)
>>> len(T)
4
>>> T+(4,5)
(1, 2, 3, 4, 4, 5)
>>> T[1]
2
>>> T[0]=3
Traceback (most recent call last):
  File "<pyshell#226>", line 1, in <module>
    T[0]=3
TypeError: 'tuple' object does not support item assignment

文件类型
    文件对象是python操作文件的主要接口，只需要通过内置的open函数创建一个文件对象，以字符串的形式传递一个文件名称及一个处理模式（'w','r'）的字符串。
>>> f=open("data.txt","w")
>>> f.write("hello\n")
>>> f.write("world 张三\n")
>>> f.close()
上述代码就会在程序的安装目录文件夹下创建一个文本文件。
读取一个已经存在的文件， 可以按行、按字节读取。
>>> f=open("data.txt")
>>> f
<open file 'data.txt', mode 'r' at 0x0000000002BDEED0>
>>> bytes=f.read()
>>> bytes
'hello\nworld \xd5\xc5\xc8\xfd\n'
>>> print bytes
hello
world 张三
>>> bytes.split()         #默认拆分符是换行、空格
['hello', 'world', '\xd5\xc5\xc8\xfd']
>>> bytes.split(" ")
['hello\nworld', '\xd5\xc5\xc8\xfd\n']
>>> bytes.split("\n")
['hello', 'world \xd5\xc5\xc8\xfd', '']


集合
    python中的集合是通过内置函数set()创建出来的对象，是一个容器，支持一般数学集合操作。
>>> x=set("span")
>>> y=set(['h','a','m'])
>>> x,y
(set(['a', 'p', 's', 'n']), set(['a', 'h', 'm']))
>>> x&y         #交集
set(['a'])
>>> x|y           #并集
set(['a', 'p', 's', 'h', 'm', 'n'])
>>> x-y           #差集
set(['p', 's', 'n'])
>>> y-x           #差集
set(['h', 'm'])

decimal
    python中的decimal是pythone2.4引入的十进制数（固定精度浮点数）。
>>> import decimal
>>> d=decimal.Decimal(0.00001)
>>> d+3
Decimal('3.000010000000000000000818031')
>>> d+2
Decimal('2.000010000000000000000818031')
>>> d+=6
>>> d
Decimal('6.000010000000000000000818031')

布尔类型
    从python2.3开始，加入了该类型，布尔类型只有两个值True和False（实际上对象的是整数1和0）
>>> 1>2,2>1
(False, True)
>>> bool("abc")
True
>>> bool(None)  #特殊的None类型，表示为空的意思
False

None
    python中的有一个特殊的类型，被称为null对象或者NoneType, 它只有一个值，就是None。它不支持任何运算也没有任何内建方法，没有什么有用的属性，它的布尔总是False
>>> x=None
>>> x
>>> print x
None
>>> L=[None]*5   #复制5个
>>> L
[None, None, None, None, None]
>>> type(L)
<type 'list'>
>>> type(L[0])   #查看None的类型
<type 'NoneType'> 
>>> type(type(L))
<type 'type'>

类型检查
    在python中至少有3种方法可以检查对象的类型。
第一种：通过简单类型比较
>>> L
[None, None, None, None, None]
>>> if type(L)==type([]):
print "yes"

yes
第二种：通过默认类型判断
>>> if type(L)==list:
print "yes"
   
yes
第三种：判断实例是否属于某个类型
>>> if isinstance(L,list):
print "yes"

yes

类型分类
    在了解了python中核心类型后，根据其所属的类别共享操作，分类如下。
对象类型     分类    是否可变
数字             数值 否
字符串         序列    否
列表             序列    是
字典             队列    是
元组              序列    否
文件 扩展      N/A

列表、字典和元组可以存储任何种类的类型（不同类型的可以同时存储）
列表、字典和元组可以任意嵌套
列表和字典可以动态地扩大和缩小
例子：
>>> L=["abc",[(1,2),([3],4)],5]
>>> L[1]
[(1, 2), ([3], 4)]
>>> L[1][1]
([3], 4)
>>> L[1][1][0]
[3]
>>> L[1][1][0][0]
3

类型的层次划分