python之基础篇（五）——数据类型

防伪码：忘情公子著

  前面四篇我们已经讲了许多概念方面的东西，从此篇开始，我们将真正开始学习python。

  在上一篇中，我们已经说过Python有哪些核心数据类型，接下来我们将一一细说这些数据类型。

python数据类型之数字类型

  python使用5种数字类型：布尔型、整型、长整型、浮点型和复数，所有数字类型均为不可变对象。

  math模块是python中专门用来实现高级算术运算的模块。

  数字支持以下操作：

    +：加法

    -：减法

    *：乘法

    /：除法

    //：截断除法

    **：乘方

    %：取模

    -=：一元减法

    +=：一元加法

    *=：一元乘法

    /=：一元除法

  数字支持以下比较运算：

    <<：左移，右边补0

    >>：右移，左边补0

    &：按位与

    |：按位或

    ^：按位异或（位相同则为0，不同则为1）

      1 ^ 0 值为1

      1 ^ 1 值为0

    ~：按位求反

python数据类型之序列类型

  序列表示索引为非负整数的有序对象集合，包括字符串、列表和元组。

  字符串是字符类型，字符串也属于序列类型，同样支持迭代。

  列表和元组是任意python对象的序列。

  字符和元组属于不可变序列，而列表则支持插入、删除和替换元素。

  所有序列都支持迭代。

python序列类型之字符类型

  指定字符串字面量：把文本放入单引号、双引号或三引号中。

  在python2.0系列当中，字符串字面量（str）对应于8位字符（8bit数据）或面向字节的数据，因此无法完全支持国际字符集（Unicode）。

  在python2系列中，如果想用Unicode进行编码，则必须在定义字符串时在其之前加上一个u来表示，如u'abc'，而python3系统则不用加u，python3可以自动在类型之间转换，而且已经支持Unicode编码。

  python2系列提供两种字符串对象类型：

    字节字符串：字节（8bit数据）序列；

    Unicode字符串：Unicode字符（16bit）序列

  python可以使用32bit整数保存Unicode字符，但此为可选特性。

  文档字符串：若模块、类或函数的第一条语句是一个字符串的话，该字符串就成为文档字符串，可以使用__doc__属性来引用。

    文档字符串在代码段中，要与其它语句的缩进保持一致。

适用于字符串的操作与方法：

  s.captitalize()：首字符变大写

  s.index(sub [, start [, end]])：找到指定字符串sub首次出现的位置，否则报错

  s.join(t)：使用s作为分隔符连接序列t中的字符串

  s.lower()：转换为小写形式

  s.replace(old, new [, maxreplace])：替换一个字符串

  s.split([sep [, maxsplit]])：使用sep作为分隔符对一个字符串进行划分，maxsplit是划分的最大次数

  s.strip([chars])：删掉chars开头和结尾的空白或字符

  s.upper()：将一个字符串转换为大写形式

python序列类型之列表

  列表是一种容器类型：

    可以包含任意对象的有序集合，通过索引进行访问其中的元素，是一种可变对象，其长度可变

    支持异构和任意嵌套

    支持在原处修改：

      修改指定的索引元素

        l1[2] = 'abc'

      修改指定的分片

        l1[1:3] = []

      删除语句

        del l1[2]

        del l1[1:]

        或使用del函数

        del(l1[2])

        del(l1[1:])

适用于列表的操作与方法：

  list(s)可将任意可迭代类型转换为列表，而如果s已经是一个列表，则该函数构造的新列表是s的一个浅复制

  list(s)：将s转换为一个列表

  s.append(x)：将一个新元素x追加到s末尾

  s.extend(t)：将一个新元素t追加到s末尾

  s.count(x)：计算s中x的出现次数

  s.index(x, [, start [, stop]])：当s[i] == x.start时返回最小的i，可选参数stop用于指定搜索的起始和结束索引

  s.insert(i,x)：在索引i处插入x

  s.pop([i])：返回元素i并从列表中移除它。如果省略i，则返回列表中最后一个元素并从列表中移除它

  s.remove(x)：搜索x并从s中移除它

  s.reverse()：颠倒s中的所有元素的顺序

  s.sort([key [, reverse]])：对s中的所有元素进行排序。key是一个键函数。reverse是一个标志，表明以倒序对列表进行排序。key和reverse应该始终以关键字参数的形式指定

  list1 + list2：合并两个列表，返回一个新的列表，不会修改原列表

  list1 * N：把list1重复N次，返回一个新列表

  in：成员关系判断字符，用法：object in container

  not in：成员关系判断字符，用法：object not in container

  浅复制与深复制的区别？

  浅复制：浅复制时，复制者与被复制者在内存中实际上是同一个对象引用

In [1]: list1 = [1,2,3]

In [2]: list2 = list1

In [3]: print list1
[1, 2, 3]

In [4]: print list2
[1, 2, 3]

In [5]: id(list1)
Out[5]: 140347116298112

In [6]: id(list2)
Out[6]: 140347116298112

  深复制：深复制时，复制者与被复制者在内存中是两个不同的对象引用

In [7]: list1 = [1,2,3]

In [8]: list2 = list1[:]

In [9]: print list1
[1, 2, 3]

In [10]: print list2
[1, 2, 3]

In [11]: id(list1)
Out[11]: 140347117118024

In [12]: id(list2)
Out[12]: 140347117098696

  也可以通过copy模块的deepcopy方法来实现深复制

In [13]: import copy

In [14]: list3 = copy.deepcopy(list1)

In [15]: print list1
[1, 2, 3]

In [16]: print list3
[1, 2, 3]

In [17]: id(list1)
Out[17]: 140347117118024

In [18]: id(list3)
Out[18]: 140347117091008

python序列类型之元组

  元组是一种容器类型，但是其是不可变对象。表达式符号是()

  可以包含任意对象的有序集合，通过索引访问其中的元素，是一种不可变对象，长度固定

  支持异构和任意嵌套

  支持索引、切片、成员关系判断、合并、重复

  元组的常见操作有以下这些：

    ()：定义空元组

    (1,)：定义一个元素的元组

    (1,2,3)：定义元组

    tuple1 + tuple2：全并两个元组，生成一个新元组，不会修改原元组

    tuple1 * N：把tuple1重复N次，返回一个新元组

    in：成员关系判断字符，用法：object in container

    not in：成员关系判断字符，用法：object not in container

  在不引起语法冲突的前提下，元组定义时、使用时允许省略()。一般而言，仅当元组作为字符传给函数调用以及当元组出现在print语句的特殊情况时，()是必要的。

  元组本身不可变，但当元组内嵌套了可变类型的元素，那么此类元素的修改不会返回新元组

    例如当元组中包含列表时，可以对元组中列表的元素进行修改，但是不会返回一个新的元组，元组本身并未改变

In [19]: a = (1,2,3,['a','b','d','e'])

In [20]: type(a)
Out[20]: tuple

In [21]: id(a)
Out[21]: 140347105497608

In [22]: a[3][2] = 5

In [23]: print a
(1, 2, 3, ['a', 'b', 5, 'e'])

In [24]: id(a)
Out[24]: 140347105497608

适用于所有序列的操作和方法：

  s + r：连接

  s * n：制作s的n个副本，n为整数

  value1,value2...valuen = s：变量解包

  s[i]：索引运算符，返回一个序列的元素i

  s[i:j]：切片运算符，返回一个切片

  s[i:j:stride]：扩展切片运算符，返回一个扩展切片

    对于切片运算，切片后的结果会生成为新对象

  x in s，x not in s：从属关系

  for x in s：迭代

  len(s)：返回s中的元素个数

  min(s)：返回s中的最小值

  max(s)：返回s中的最大值

    min(s)和max(s)只适用于能够对元素排序的序列

  sum(s [, initial])：只适用于数字序列，返回s中各项的和

  all(s)：检查s中的所有项是否为True

  any(s)：检查s中的任意项是否为True

适用于可变序列的操作：

  s[i] = v  项目赋值

  s[i:j] = t  切片赋值

  s[i:j:stride] = t  扩展切片赋值

  del s[i]  项目剔除

  del s[i:j]  切片剔除

  del s[i:j:stride]  扩展切片剔除

适用于列表的方法：

  list(s)可将任意可迭代类型转换为列表，而如果s已经是一个列表，则该函数构造的新列表是s的一个浅复制

  list(s)：将s转换为一个列表

  s.append(x)：将一个新元素x追加到s末尾

  s.extend(t)：将一个新元素t追加到s末尾

  s.count(x)：计算s中x的出现次数

  s.index(x, [, start [, stop]])：当s[i] == x.start时返回最小的i，可选参数stop用于指定搜索的起始和结束索引

  s.insert(i,x)：在索引i处插入x

  s.pop([i])：返回元素i并从列表中移除它。如果省略i，则返回列表中最后一个元素并从列表中移除它

  s.remove(x)：搜索x并从s中移除它

  s.reverse()：颠倒s中的所有元素的顺序

  s.sort([key [, reverse]])：对s中的所有元素进行排序。key是一个键函数。reverse是一个标志，表明以倒序对列表进行排序。key和reverse应该始终以关键字参数的形式指定

python数据类型之字典：dict

  字典在其它编程语言中又称作关联数组或散列表。

  在python中，字典属于可变类型的容器，其长度可变，与列表不同的地方在于它的元素是无序的，只能通过键来实现元素存取。

  序列类型的键只能是数字下标，而字典的键可以是任意可hash类型，不过一般使用字符串当作其键

  支持异构和任意嵌套

字典支持的操作与方法：

  {}：定义一个空字典

  {key1:value1,key2:value2,...}：定义字典

  {'x':32,'y':[1,2,3]}：定义一个异构字典

  d1 = dict(name='tom',age=42,gender='n')：用dict定义一个字典

  d1= dict(zip('xyz','123'))：用dict结合zip定义一个字典，此字典d1的结果为{'x':1,'y':2,'z':3}

  d2 = d1.copy()：字典复制

  d.get(key)：若key在字典d中存在，则返回key的值，否则返回空值

  d[key]：若key在字典d中存在，则返回key的值，否则抛出异常

  d.items()：把字典d中的键值对返回成元组列表。将字典转换成元组列表

  d.has_key(key)：判断字典d中是否存在key

  d.keys()：返回字典d中的键列表

  d.values()：返回字典d中的值列表

  d.pop(key)：弹出指定的key

  d.popitem()：随机弹出键值映射

  d1.update(d2)：将字典d2合并到字典d1中，合并时若有键相同，则覆盖原字典中对应的键

  d.iteritems()：以键值对做为条目进行迭代，返回一个迭代器对象

  d.iterkeys()：以键做条目进行迭代，返回一个迭代器对象

  d.itervalues()：以值做条目进行迭代，返回一个迭代器对象

  d.viewitems()：返回类似集合风格的字典，以键值对的元组形式显示字典构造。返回的结果类似dict.items([(key,value),(key,value),(key,value)...])

  d.viewkeys()：返回类似集合风格的key列表。返回的结果类似dict.keys([key1,key2,key3....])

  d.viewvalues()：返回类似集合风格的value列表。返回的结果类似dict.values([value1,value2,value3....])

python数据类型之集合：set

  集合就是指一大堆的不重复的元素放到一起，是一组无序排列的可hash的值。

  支持集合关系测试：

    并集

    交集

    差集

  支持成员关系测试：

    in

    not in

  支持迭代、异构

  不支持索引、元素获取、切片

  集合的类型：

    set()：可变对象

    frozenset()：不可变对象

  集合没有特定语法格式，可以通过以下方法创建：

  1.通过工厂函数（set()、frozenset()）创建

  2.通过{}创建，如s1 = {1,2,3,4,5,6}

集合类型支持的方法和操作：

  s1 = set([1,2,3])：定义一个set集合。其参数必须是一个可迭代对象，可以是字符串、列表等

  len(s)：返回s中的项目数

  max(s)：返回s中的最大元素

  min(s)：返回s中的最小元素

  s.copy()：制作s的一份副本

  s.difference(t)：求差集。返回所有在s中，但不在t中的项目

  s.intersection(t)：求交集。返回所有同时在s和t中的项目

  s.isdisjoint(t)：如果s和t没有相同项，则返回True

  s.issubset(t)：如果s是t的一个子集，则返回True

  s.issuperset(t)：如果s是t的一个超集，则返回True

  s.symmetric_difference(t)：求对称差集。返回所有在s或t中，但又不同时在这两个集合中的项

  s.uNIOn(t)：求并集。返回所有在s或t中的项

  s.pop()：随机弹出一个项目

  s.add(i)：在s集合中添加一个元素i

  s | t：求s和t的并集

  s & t：求s和t的交集

  s - t：求差集

  s ^ t：求对称差集

容器、类型、对象的相关概念：

  列表、元组、字典字面量可以在不使用续行符的情况下直接分布在多行上。最后一个元素后面允许使用一个逗号，但是没有元素时不允许使用逗号。

  所有对象都有引用技术，为对象分配一个新名称（用一个变量名引用它）或者将一个对象放进一个容器中时，都会导致对象引用技术增加。

  当对象引用技术为0时，就会由垃圾回收器回收此对象。使用del语句执行删除操作或者某次引用的修改超出当前对象的作用域时，对象的引用技术就会减少。

  可以使用sys模块的getrefcount()函数来查看对象的引用技术：

In [28]: import sys

In [29]: a = 'black'

In [30]: sys.getrefcount(a)
Out[30]: 3

  列表和字典都支持两种类型的复制操作：浅复制和深复制。深复制可使用copy模块中的deepcopy()实现。

  python中的所有对象都是"第一类的"。第一类就意味着，使用标识符命名的所有对象，都具有相同状态。因此，能够命名的所有对象，都可以当作数据直接处理。

  序列表示索引为非负整数的有序对象集合，包括字符串、列表和元组。所有序列都支持迭代。

    字符串是字符的序列；

    列表和元组是任意python对象的序列