Python_03-数据类型

1.1   数据类型

基本数据类型：字符串，整数，浮点数，布尔型

集合类型：列表（list), 元组（tuple), 字典（dictionary或hash)

列表（list）的定义：

aList = [23] 或者 bList = [1,2,3]

print bList[1]

List常用操作：append, del, + ,*, len(list)

[0] * 5

 

列表对象支持的方法

append(x)

count(x) ：X在List中的个数

extend(L)

index(x)

insert(i,x)

pop(x)

remove(x)

reverse()

sort()

 

例子:     list.append(x)#将元素x加入list列表

           list.sort()   对列表list进行排序

 

元组（tuple）的定义：

aTuple = (1, 3, 5)

print aTuple

 

元组可以用方括号括起下标做索引

元组一旦创建就不能改变

列表大部分操作同样适用于元组

1.2   序列

1.2.1   sequence 序列

sequence(序列)是一组有顺序的元素的集合

(严格的说，是对象的集合，但鉴于我们还没有引入“对象”概念，暂时说元素)

序列可以包含一个或多个元素，也可以没有任何元素。

我们之前所说的基本数据类型，都可以作为序列的元素。

元素还可以是另一个序列，以及我们以后要介绍的其他对象。

序列有两种：tuple（定值表；也有翻译为元组）和 list (表)

>>>s1 = (2, 1.3, 'love', 5.6, 9, 12, False)         # s1是一个tuple

>>>s2 = [True, 5, 'smile']                    # s2是一个list

>>>print s1,type(s1)

>>>print s2,type(s2)

>>> s1 = (2, 1.3, 'love', 5.6, 9, 12, False)

>>> s1[0]

2

>>> type(s1[0])

<type 'int'>

>>> s1[2]

'love'

>>> type(s1[2])

<type 'str'>

>>> s1[3]

5.6

>>> type(s1[3])

<type 'float'>

 

tuple和list的主要区别在于，一旦建立，tuple的各个元素不可再变更，而list的各个元素可以再变更。

一个序列作为另一个序列的元素

>>>s3 = [1,[3,4,5]]

空序列

>>>s4 = []

 

1.2.2   元素的引用

>>>s3 = [1,[3,4,5]]

序列元素的下标从0开始：

>>>print s1[0]

>>>print s2[2]

>>>print s3[1][2]

由于list的元素可变更，你可以对list的某个元素赋值：

>>>s2[1] = 3.0

>>>print s2

如果你对tuple做这样的操作，会得到错误提示。

所以，可以看到，序列的引用通过s[<int>]实现， int为下标

1.2.3   其他引用方式

范围引用：基本样式[下限:上限:步长]

>>>print s1[:5]             # 从开始到下标4 （下标5的元素不包括在内）

>>>print s1[2:]             # 从下标2到最后

>>>print s1[0:5:2]          # 从下标0到下标4 (下标5不包括在内)，每隔2取一个元素（下标为0，2，4的元素）

>>>print s1[2:0:-1]         # 从下标2到下标1

从上面可以看到，在范围引用的时候，如果写明上限，那么这个上限本身不包括在内。

1.2.4   尾部元素引用

>>>print s1[-1]             # 序列最后一个元素

>>>print s1[-3]             # 序列倒数第三个元素

同样，如果s1[0:-1], 那么最后一个元素不会被引用（再一次，不包括上限元素本身）

1.2.5   字符串是元组

字符串是一种特殊的元素，因此可以执行元组的相关操作。

 

>>>str = 'abcdef'

>>>print str[2:4]

总结

tuple元素不可变，list元素可变

序列的引用 s[2], s[1:8:2]

字符串是一种tuple

1.3   列表（list）

主要介绍了Python3的list列表用法, 这是Python3数据类型中非常常见的应用,

通常来说Python中任何值都是一个对象，因此任何类型（int、str、list…）都是一个类。而类就必然有它的方法或属性，我们要记下这么多类的所有方法显然是不可能的，对此本文介绍两个小技巧：

dir() ：内置函数，用来查询一个类或者对象所有属性，比如>>> dir(list)。

help() ：内置函数，用来查询具体的说明文档，比如>>> help(int)。

列表时对象的有序集合。列表的内容可以修改，列表的长度可变。

列表的定义：

     <列表名称>[<列表项>]

其中多个列表项用逗号隔开，它们的类型可以相同，也可以不同，还可以是其列表。例如

date=[2011, 2, 9, 9, 54]

day=['sun','mon','tue','wed','thi','fri','sat']

today=[2011,2,9,"wed"]

data=[date,day]

均是合法的列表。 使用时，通过

<列表名>[索引号]

的形式应用，索引号从0开始，即0是第1项的索引号。例如date[0]的值是2011，day[1]得到“mon”，data[1][3]的到“wed”。下列程序：

date=[2011, 2, 9, 9, 54]

day=['sun','mon','tue','wed','thi','fri','sat']

today=[2011,2,9,"wed"]

data=[date,day]

print(date[0])

print(day[1])

print(data[1][3])

的运行结果为：

2011

mon

wed

 

列表可以整体输出，如print(data)

列表的其他运算见表1-2。

表1-2列表的运算

运算格式/举例	说明/结果
L1=[]	空列表
L2=[ 2011, 2, 9, 19, 54]	5项，整数列表，索引号0-4
L3= ['sun',['mon','tue','wed']]	嵌套的列表
L2[i],L3[i][j]	索引,L2[1]的值为2，L3[1][1]的值为'tue'
L2[i:j]	分片，取i到j-1的项
Len(L2)	求列表的长度
L1+L2	合并
L2*3	重复,L2重复3次
for x in L2	循环,x取L2中的每个成员执行循环体
19 in L2	19是否是L2的成员
L2.append(4)	增加4作为其成员，即增加一项
L2.sort()	排序,L2结果变为[2, 9, 19, 54, 2011]
L2.index(9)	得到9在列表中的索引号，结果为2
L2.reverse()	逆序，L2的结果为[2011, 54, 19, 9, 2]
del L2[k]	删除索引号为k的项
L2[i:j]=[]	删除i到j-1的项
L2[i]=1	修改索引号为i的项的值
L2[i:j]=[4,5,6]	修改i到j-1的项的值，如果项数多，则自动插入
L4=range(5,20,3)	生成整数列表L4实际为[5,8,11,14,17]

 

 

1.3.1   列表的方法

list.append(x)

在列表的尾部添加一个项，等价于 a[len(a):] = [x]。

list.extend(L)

将给定的列表L接到当前列表后面，等价于a[len(a):] = L。

list.insert(i, x)

在给定的位置 i 前插入项，例如：a.insert(0, x) 会在列表的头部插入，而 a.insert(len(a), x) 则等价于 a.append(x)。

list.remove(x)

移除列表中第一个值为 x 的项，没有的话会产生一个错误。

list.pop([i])

删除列表给定位置的项，并返回它。如果没指定索引，a.pop()移除并返回列表最后一项。（方括号表示可选）

list.clear()
删除列表中的所有项，相当于 del a[:]。

list.index(x)
返回列表中第一个值为 x 的项的索引。如果没有匹配的项, 则产生一个错误。

list.count(x)
返回列表中 x 出现的次数。

list.sort()
就地完成列表排序。

list.reverse()
就地完成列表项的翻转。

list.copy()
返回列表的一个浅拷贝，相当于a[:]。

 

1.3.2   列表当栈

List的方法使得其可以很方便地作为一个栈来使用。我们知道，栈的特点是最后进入的元素最先出来（即后入先出），用append()方法进行压栈，用不指定索引的pop()方法进行出栈。

示例代码如下：

stack = []

for x in range(1,6):

    stack.append(x)  # 入栈

    print('push', x, ' ')

    print(stack)

 

print('Now stack is', stack)

 

while len(stack)>0:

    print('pop', stack.pop(), ' ') # 出栈

    print(stack)

1.3.3   列表当队列

列表还可以当作队列来使用，队列的特性是第一个加入的元素第一个取出来（即先入先出）。然而，把列表当队列使用效率并不高，因为从列表的尾部添加和弹出元素是很快的，而在列表的开头插入或弹出是比较慢的（因为所有元素都得移动一个位置）。

要实现一个队列, 使用标准库的collections.deque，它被设计成在两端添加和弹出都很快。

示例代码如下：

from collections import deque

queue = deque()    # 创建空队列

for x in range(1,6):

    queue.append(x)  # 入队

    print('push', x, ' ')

    print(list(queue))

 

print('Now queue is', list(queue))

 

while len(queue)>0:

    print('pop', queue.popleft(), ' ') # 出队

    print(list(queue))

1.3.4   列表推导式

列表推导式提供了从序列创建列表的简单途径。

通常程序会对序列的每一个元素做些操作，并以其结果作为新列表的元素，或者根据指定的条件来创建子序列。

列表推导式的结构是：在一个方括号里，首先是一个表达式，随后是一个 for 子句，然后是零个或更多的 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。

示例代码如下：

squares =[x**2forx inrange(10)] # 推导式

print(squares)

# 输出是[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

pairs =[(x, y) forx in[1,2,3] fory in[3,1,4] ifx!=y] # 推导式

print(pairs)

# 输出是[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

1.3.5   列表嵌套

Python中并没有二维数组的概念，但我们可以通过列表嵌套达到同样的目的。

mat = [

   [1, 2, 3],

   [4, 5, 6],

   [7, 8, 9]

   ]

print(mat)

print(type(mat))

print(mat[1])

mat[2]=[0,0,0]

print(mat)

同样，我们可以使用推导式生成嵌套的列表：

mat = [[1,2,3], [4,5,6], [7,8,9]]

new_mat = [ [row[i] for row in mat] for i in [0,1,2] ] # 嵌套

print(new_mat)

# 输出[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

 

附：del语句

del语句可以通过给定索引（而不是值）来删除列表中的项，它与返回一个值的pop()方法不同。del语句也可以移除列表中的切片，或者清除整个列表：

lst =[1,2,3,4,5,6,7,8,9]

dellst[2] # 删除指定索引项

print(lst)

dellst[2:5] # 删除切片

print(lst)

dellst[:]  # 删除整个列表

print(lst)

del也可以用于删除变量实体：

dellst

在删除变量实体之后引用 lst 的话会产生错误。

 

1.4   元组（tuple）

元组和列表十分类似，只不过元组和字符串一样是不可变的，即不能修改元组。元组通过圆括号中用逗号分割的项目定义。当一组数据，只使用，不修改时使用元组。元组的使用与列表相同，只是不能修改、删除、增加其元素。例如：

# use of tuple

# filename: tuple.py

garden=("Bird of Paradise" ,"rose" ,"tulip", "lotus","olive", "Sunflower")

print ('Number of flowers in the garden is', len(garden))

i=2;

print('flower',i,'is',garden[i-1])

new_garden = ('Phlox', 'Peach Blossom', garden)

i=1;

print('flower',i,'is',garden[i-1])

运行结果如下:

C:Python31>python tuple.py

Number of flowers in the garden is 6

flower 2 is rose

flower 1 is Bird of Paradise

 

元组的运算见表1-3

表1-3元组的运算

运算格式/举例	说明/结果
T1()	空元组
T2=(2011,)	有一项的元组
T3=(2011, 2, 9, 19, 54)	5项，整数元组，索引号0-4
T4= ('sun',('mon','tue','wed'))	嵌套的元组
T3[i],T4[i][j]	索引,T3[1]的值为2，T4[1][1]的值为'tue'
T3[i:j]	分片，取i到j-1的项
Len(T3)	求元组的长度
T3+T4	合并
T3*3	重复,T3重复3次
for x in T3	循环,x取T3中的每个成员执行循环体
19 in T3	19是否是L2的成员

注意：元组与列表的最大不同：一是定义时用一对圆括号，二是内容不能修改。

 

1.5   字典（dict）

字典是python中唯一内置映射数据类型。

通过指定的键从字典访问值，即 [key,value]模式

字典为容器，内建len函数可以将字典当作单一参数使用，返回字典对象中项目（键／值对）的数目。

   字典是无序的对象的集合，通过键进行操作。类似于通讯录，通过姓名来查找电话、地址等信息，则姓名就是键。一定要没有同名的人。

字典的定义为：

<字典名>={键1:值2,键2:值2,键3:值3,…}

其中，键1，键2，键3不相同，值可以是任何类型的数据，可以是列表或元组。注意，字典定义中使用的是大括号，项通过逗号隔开，每个项有键部分和值部分，键和值之间用冒号隔开。只可使用简单的对象作为键,而且不能改变，但可以用不可变或可变的对象作为字典的值。

 

在Python2.2以及后面版本，D中的k运算符检测是否对象k是字典D中的键。如果是返回True如果不是返回False。相似的，

字典D中的值与相关的键k被索引表示为：D[k]。索引字典没有的键会引起意外。例如：

 

d = { 'x':42, 'y':3.14, 'z':7 }

d['x']                           # 42

d['z']                           # 7

d['a']                           # raises exception

1.5.1   赋值

D[newkey]= value 该操作加载键和值到字典里新的项目中。

1.5.2   删除

语法：

del D[k]中的del语句，删除字典中拥有键k的项目。

如果k不是字典D中的键，del D[k]就会引起意外。

1.5.3   字典的使用例子

a = {'a': 'aa', 'b': 'bb'}

a['c']='cc'

a.has_key('a') #判断字典中是否存在此值

a['a']='uu'

a

a['a']=3

del a['a'] #删除键值

a

len(a)

示例：

>>> d={'d':[3,4],1:[7],'ab':['ab','cd','ef']}

>>> d['d']

[3, 4]

>>> d[1]

[7]

>>> d['ab']

['ab', 'cd', 'ef']

>>> print(d)

{1: [7], 'd': [3, 4], 'ab': ['ab', 'cd', 'ef']}

>>> del d[1]; print(d)

{'d': [3, 4], 'ab': ['ab', 'cd', 'ef']}

1.5.4   字典的常用方法

has_key(x)

keys()

values()

items()

clear()

copy()

update(x)

get(x[,y])

1.5.5   示例

例如：

# use of dictionaries

# filename: dict.py

 

address1 = {'zhang'   : 'larry@wall.org',

             'wang'     : 'wang@wall.org',

             'lily' : 'lily@ruby-lang.org',

             'sam'   : 'sam@hotmail.com'

          }

print ('mail of zhang',address1['zhang'])

 

address2 = {'zhang'   : ['larry@wall.org','shaanxi'],

             'wang'     : ['wang@wall.org','beijing'],

             'lily' : ['lily@ruby-lang.org','shanghai'],

             'sam'   : ['sam@hotmail.com','hubei']

          }

print ('mail of zhang',address2['lily'][0])

print ('province of zhang',address2['lily'][0])

运行结果如下：

C:Python31>python dict.py

mail of zhang larry@wall.org

mail of zhang lily@ruby-lang.org

province of zhang lily@ruby-lang.org

字典的操作见表1-4：

表1-4字典的运算

运算格式/举例	说明/结果
d1={}	空字典
d2={'class':'jianhuan','year':'2011'}	有两项的字典
d3={'xjtu':{'class':'huagong','year':'2011'}}	字典的嵌套
d2['class'], d3['xjtu']['class']	按键使用字典
d2.keys()	获得键的列表
d2.values()	获得值的列表
len(d2)	求字典的长度
d2['year']=2020	添加或改变字典的值
del d2['year']	删除键

 

 

 

 

1.6   Python 序列应用

序列：成员有序排列，并且可以通过下标漂移量访问一个（直接指定索引）或者几个成员（切片操作）。

包括字符串（普通字符串和unicode字符串）、列表和元组。其索引第一个元素从零向后递增（正索引），也可以从最后一个元素的-1索引向前递减（负索引）。

1.6.1   所有的标准类型操作符适用于序列

（值比较操作符，对象身份比较，逻辑操作符）。

1.6.2   序列类型的操作符

（1）成员关系操作符（in, not in）

判断一个元素是否属于一个序列，返回值为True/False。

（2）连接操作符（+）

将一个序列与另一个相同类型的序列做连接。

这个方法并不是最快最有效的，因为python要为每一个参加连接操作的字符串分配新的内存，包括新产生的字符串。对于字符串，推荐将子字符串放到一个列表或者可迭代对象中，调用join方法连接，节约内存。对于列表，推荐使用列表对象的extend()方法。

示例：

>>> t1=['ab','cd','ef']

>>> t2=[3,4,5]

>>> t1.extend(t2)

>>> t1

['ab', 'cd', 'ef', 3, 4, 5]

（３）重复操作符（*）

一个序列的多份拷贝，返回一个包含多份原对象拷贝的新对象。sequence*copies_int，注意copies_int必须为整型，不能为长整型。

（４）切片操作符（[],[:][::]）

访问某一个数据元素：sequence[index]。（len()函数可获得序列的长度）

例：print ('a','b','c')[1] （例子中没有先赋值直接访问一个序列的元素，当只对函数返回序列对象的某些元素感兴趣时非常有用）

访问多个元素：sequence[starting_index:ending_index]。（注意不包括结束索引，并且如果没有提供或者用None作索引值，则从第一个元素开始或者到最后一个元素结束）。对于这种形式，起始索引和结束索引可以为超过字符串长度的索引。

例：s[:-1] 从第一个元素到最后一个元素

s[:0] 返回''

扩展的步长索引：

例：s[::-1] 可以看作翻转操作，'abcd'操作后为'dcba'

例：

s='abcde'

for i in [None] + range(-1, -len(s),-1)

print s[:i]

（注意这里不能先用None生成列表，再用extend将range的输出加入列表，因为extend的输出为None）

1.6.3   序列常用的内建函数

（1）类型转换：实际上没有进行真正的类型转换，是将参数传入对象的内容浅拷贝到新生成的对象中。浅拷贝是指只拷贝对象的索引，不是重新建立对象，在python中，对象建立后就不能更改其身份和类型。

str()：用于对象的打印，对序列类型和其它类型都适用。

unicode()：功能与str()一样，只是输出为unicode编码。

list()：转换为列表；tuple()：转换为元组。这两个函数常用于列表和元组的互换。很少用于string类型。

basestring()：抽象工厂函数，是str和unicode的父类，不能被实例化和调用。

（2）内建函数：

参数只接收序列对象：len(seq)，reversed(seq)，sum(seq,start)。

参数可接收序列对象和可迭代对象：

enumerate(iter)

sorted(iter,func=None,key=None,reverse=False),

zip([it0,it1,...itN])

可接收参数列表：

max(iter,key=None)或者max(arg0,arg1,...,key=None)

min类同于max。