Python 基本数据类型

目录

 

数据类型

整数

浮点数

字符串

布尔值

空值

序列

sequence 序列

空序列

元素的引用

其他引用方式

尾部元素引用

字符串是元组

列表（list）

列表（list）的定义

列表的运算

列表的方法

列表当栈

列表当队列

列表推导式

列表嵌套

del语句

元组（tuple）

元组（tuple）的定义

元组的运算

字典（dict）

赋值

删除

字典的使用例子

字典的操作

字典的常用方法

Python 序列应用

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

序列类型的操作符

---

数据类型

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

整数

整数包括负整数和正整数，例如100,-200等。

整数也可以用十六进制表示，十六进制以0x为前缀，用0～9,a～f表示。

Example：

>>> a = 400

>>> a

400
-----------

>>> a = -300

>>> a

-300
---------

>>> a = 0x3827

>>> a

14375

浮点数

浮点数即小数。例如0.123等。科学记数法的浮点数可以写成例如2.125e-2的格式，该数即表示 2.125*10^(-2)。

Example：

>>> f = 0.123

>>> f

0.123
------------
>>> f = 2.125e-2

>>> f

0.02125
-------------

字符串

用单引号或者双引号包括，但不可混搭使用；支持转义；前缀r表示字符串内不转义；多个字符串拼接；'''...'''字符串跨行表示。

Example：

>>> print '1:first,second,third'   

1:first,second,third
-----------

>>> print '2:first,\nsecond,\nthird'

2:first,

second,

third
--------------

>>> print r'3:first,\nsecond,\nthird'

3:first,\nsecond,\nthird
----------

>>> print '4:first,'"second,"'third'

4:first,second,third
----------

>>> print '''''5:first,

... second,

... third'''


''5:first,

second,

third
------------

>>> print '''''6:first,

... second,

... third,''''fourth,'"fifth"


''6:first,

second,

third,fourth,fifth

布尔值

布尔值只有True和False两种。

布尔值支持and与运算、or或运算、not取反运算。

>>> boolean = False

>>> boolean

False
----------

>>> boolean = True

>>> boolean

True

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

>>> b1 = True

>>> b2 = False

>>> b1 and b2

False

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

>>> b1 or b2

True

--------
>>> not b1

False

空值

python中有一个特殊的数据类型，即空值即None。None并不是数学中的0。因为0是一个有具体意义的值，而None代表为空。

>>> none = None

>>> none

> type(none)

<type 'NoneType'>

序列

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)

(2, 1.3, 'love', 5.6, 9, 12, False) <type 'tuple'>


----------

>>>print s2,type(s2)

[True, 5, 'smile'] <type 'list'>

----------

>>> 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 = []

元素的引用

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

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

>>> print s1[0]

2

-----

>>> print s2[2]

smile

-----

>>> print s3[1][2]

5

-----

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

>>>s2[1] = 3.0

>>>print s2

[True, 3.0, 'smile']

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

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

其他引用方式

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

>>>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

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

尾部元素引用

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

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

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

字符串是元组

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

>>>str = 'abcdef'

>>>print str[2:4]

列表（list）

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

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

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

列表（list）的定义

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

列表的定义：

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

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

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.list.append(x)

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

>>> bList.append(1)

>>> print bList

[1, 2, 3, 1]

2.list.sort()

就地完成列表排序。

>>> b=bList.sort()

>>> bList

[1, 1, 2, 3]

3.count(x)

返回列表中 x 出现的次数。

>>> bList.count(1)

2

4.index(x)

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

>>> bList.index(1)

0

5.remove(x)

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

>>> bList

[1, 1, 2, 3, '5']

>>> bList.remove(3)

>>> bList

[1, 1, 2, '5']

6.insert(i,x)

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

>>> bList.insert(2,3)

>>> bList

[1, 1, 3, 2, '5']

7.list.extend(L)

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

>>> bList

[1, 1, 3, 2, '5', '5']

>>> bList.extend([4,5,6,7])

>>> bList

[1, 1, 3, 2, '5', '5', 4, 5, 6, 7]

8.list.pop([i])

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

>>> bList.pop(5)

'5'

9.list.reverse()

就地完成列表项的翻转。

>>> bList.reverse()

>>> bList

[7, 6, 5, 4, '5', 2, 3, 1, 1]

列表当栈

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)

运行结果：

 

 

列表当队列

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

要实现一个队列, 使用标准库的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))

运行结果：

列表推导式

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

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

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

示例代码如下

squares =[x**2 for x in range(10)] # 推导式

print(squares)

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

pairs =[(x, y) for x in[1,2,3] for y in[3,1,4] if x!=y] # 推导式

print(pairs)

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

列表嵌套

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

mat = [

   [1, 2, 3],

   [4, 5, 6],

   [7, 8, 9]

   ]

>>> print(mat)

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

>>> print(type(mat))

<type 'list'>

>>> print(mat[1])

[4, 5, 6]

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

>>> print(mat)

[[1, 2, 3], [4, 5, 6], [0, 0, 0]]

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

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]

>>> del lst[2] # 删除指定索引项

>>> print(lst)

[1, 2, 4, 5, 6, 7, 8, 9]

>>> del lst[2:5] # 删除切片

>>> print(lst)

[1, 2, 7, 8, 9]

>>> del lst[:]  # 删除整个列表

>>> print(lst)

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

del lst

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

元组（tuple）

元组（tuple）的定义

>>> aTuple = (1, 3, 5)

>>> print aTuple

(1, 3, 5)

元组可以用方括号括起下标做索引；元组一旦创建就不能改变；列表大部分操作同样适用于元组，只是不能修改、删除、增加其元素；元组通过圆括号中用逗号分割的项目定义。

例如：

# use of tuple

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])

运行结果如下:

元组的运算

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

字典（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

赋值

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

>>> d['q']=55

>>> d

{'y': 3.14, 'x': 42, 'z': 7, 'q': 55}

删除

语法：

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

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

>>> del d['q']

>>> d

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

字典的使用例子

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

>>> a['c']='cc'

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

True

>>> a['a']='uu'

>>> a

{'a': 'uu', 'c': 'cc', 'b': 'bb'}

>>> a['a']=3

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

>>> a

{'c': 'cc', 'b': 'bb'}

>>> len(a)

2

字典的操作

字典的常用方法

（1）has_key(x)：判断字典是否含有键为x的值

>>> a.has_key('a')

True

（2）items()：列出字典的所有对象

>>> a.items()

[('a', 'aa'), ('b', 'bb')]

（3）clear()：清除字典中的所有对象

>>> a.clear()

>>> a

{}

（4）copy()：完全复制

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

>>> b = a.copy()

>>> b

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

>>> a

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

（5）update(x)：更新词典键值为x的值

>>> b.update(a)

示例

例如：

# use of dictionaries

address1 = {'zhang': '[e-mail]',

             'wang': '[e-mail]',

             'lily': '[e-mail]',

             'sam': '[e-mail]'

          }

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

address2 = {'zhang': ['[e-mail]','shaanxi'],

             'wang': ['[e-mail]','beijing'],

             'lily': ['[e-mail]','shanghai'],

             'sam': ['[e-mail]','hubei']

          }

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

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

运行结果如下：

 

 

Python 序列应用

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

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

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

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

序列类型的操作符

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

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

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

>>> a in t1

False

（2）连接操作符（+）

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

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

示例：

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

>>> t1.extend(t2)

>>> t1

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

（3）重复操作符（*）

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

>>> t1 * 3

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

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

访问某一个数据元素：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）