Python 2.7 五种标准数据类型的使用

Python 2.7一共有五种标准数据类型：

• Numbers（数字），包含整数，浮点数，复数等
• String （字符串）
• List （列表）
• Tuple（元组）
• Dictionary（字典），类似于Java中的Map

1 - Number类型

在Python 2.7中，数字类型可以划分为以下几种：

• int类型，即有符号整型
• long类型，即长整型，大小没有上限。
• float类型，即浮点数
• complex类型，即复数类型，由实部和虚部组成。

1.1 - int/long 类型

对于int来说，32位环境下范围介于$[-2^{31},2^{31}-1]$，64位环境下范围介于$[-2^{63},2^{63}-1]$
可以通过print sys.maxsize查看当前环境的int最大值。
对于long来说，其范围无穷大。

1.1.2 - 强制类型转换

int函数
可通过函数int(x, [,base])将x转换为int类型，base为可选参数，表示数字的进制，可选值为 $[2,36]$ 之间的整数。int()也可以无参调用，其默认返回值为0。

• 若传入参数x，则参数x可以为int、long、float、字符串类型，也可以是对象，但是对象需要实现__int__(self)方法。
• 需要注意的是，若传入的是浮点数，那么不会进行四舍五入计算，而是直接将小数点后的数字截掉，例如：

  print int(1.7)  # 输出1
  print int(1.2)  # 输出1
  

long函数
可通过函数long(x, [,base])将x转换为long类型，参数要求类似于int，这里就不赘述了。

1.1.3 - 基本计算

int和long支持以下运算符：

• +，相加，print 5 + 6输出11
• -，相减，print 5 - 6输出-1
• /，相除，注意两个整型数字相除输出的数字也是整型，例如print 10 / 6输出1
• *，相乘，print 5 * 6输出30
• **，求指数，print 2 ** 4等同于 $2^4$，输出16
• %，求模
• 位运算符，包含&、|、^、~、<<、>>
• +=、-=、*=、/=、**=、%=等运算符

1.2 - float类型

float类型类似于Java中的double类型，即双精度浮点类型。
最大可以表示约1.8e308的数字，或inf。

1.2.1 - 强制类型转换

可通过函数float(x)将x转换为浮点数，参数x可以为int、long、float、字符串类型，无参调用返回的结果为0.0。
如果需要得到inf，可以通过float('inf')得到。

1.2.2 - 基本计算

除位运算以外，可以使用int和long所支持的运算符。

1.3 - Complex类型

Complex类型即数学中的复数，包含实数部分和虚数部分。
可通过complex(real [,imag ])函数创建一个复数，real为实数部分，imag为虚数部分。

复数在Python中支持四则运算，即+、-、*、/、**运算符

2 - String类型

String类型为字符串类型，可以直接通过双引号或者单引号创建字符串，也可以通过三个双引号或者单引号创建多行字符串。

str = "hello world"
str = 'hello world'
str = """
hello world
"""
str = '''
hello world
'''

Python不支持类似于Java的char单字符类型。

2.1 - 访问字符串内容的方法

可以采用方括号来访问字符串中的字符或者子字符串：

str = '0123456789'
print str[2]      # 第2个字符，即2
print str[1:5]    # 第1到第4个字符，即1234
print str[1:]     # 第1到最后一个字符，123456789
print str[-2]     # 倒数第二个字符，即8

2.2 - 运算符

• +：拼接字符串

  a = '012345'
  b = '6789'
  print a + b
  

  输出0123456789
• *：拼接n次原字符串

  a = '012345'
  print a * 3
  

  输出012345012345012345
• in：判断某个字符串是否是该字符串的连续子串

  a = '0123456789'
  print '345' in a
  

  输出True
• not in：和in相反。
• r或R：原始字符串，忽略转义符

  print '0123\t4567'
  print R'0123\t4567'
  

  输出0123 4567和0123\t4567
• %：字符串格式化，类似于Java中的String.format，例如：

  print "My name is %s and age is %d" % ('Li', 21)
  

2.3 - 常用方法

3 - 列表类型

列表类型类似于Java中的ArrayList，按照顺序存储元素。
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可，例如

lst = [1, 'string', 2.3, complex(1, 2)]
lst = [2, 3, 4, 6]

3.1 - 元素的访问

类似于字符串，可以通过中括号来访问元素：

lst = [2, 3, 4, 'five', 6]
print lst[2]
print lst[2:4]
print lst[2:]
print lst[-1]

输出内容：

4
[4, 'five']
[4, 'five', 6]
6

也可以使用for语句遍历列表：

lst = [2, 3, 4, 'five']
for x in lst:
	print x

输出：

2
3
4
five

也可以通过in操作符来判断某个元素是否在列表中：

lst = [2, 3, 4, 'five']
print 3 in lst

输出True。

3.2 - 元素的添加与删除

可以通过append函数向列表添加元素。

lst = [2, 3, 4, 'five']
lst.append(6)
lst.append('seven')
print lst

输出[2, 3, 4, 'five', 6, 'seven']
也可以通过+运算符来拼接两个列表为一个列表

可以通过del关键字来删除列表中的元素：

lst = [2, 3, 4, 'five', 6, 'seven']
del lst[3]
print lst

输出[2, 3, 4, 6, 'seven']

3.3 - 其它列表操作符

• 获取列表长度可以使用len：

  lst = [2, 3, 4, 'five', 6, 'seven']
  print len(lst)
  

  输出6

• 拼接两个列表的元素为一个列表可以直接使用+：

  l1 = [1, 2, 3]
  l2 = [4, 5, 6]
  l = l1 + l2
  print l
  

  输出[1, 2, 3, 4, 5, 6]

• 重复拼接一个列表的元素，可以使用*：

  l = [1, 2, 3]
  print l * 3
  

  输出[1, 2, 3, 1, 2, 3, 1, 2, 3]

• 判断某个元素是否在列表中，可以使用in，例如判断3是否在列表中：

  l = [1, 2, 3]
  print 3 in l
  

  输出True

• 可以使用max、min函数获取一个列表的最大值和最小值：

  l = [1, 2, 3]
  print str(max(l)) + " " + str(min(l))
  

  输出3 1

3.4 - 常用方法

• list.append(obj)：在列表末尾添加新的对象，例如

  l = [1, 2, 3]
  l.append(4)
  print l
  

  输出[1, 2, 3, 4]
• list.count(obj)：统计某个元素在列表中出现的次数，例如

  l = [1, 1, 2, 3]
  print l.count(1)
  

  输出2
• list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

  l = [1, 2, 3]
  l.extend([4, 5, 6])
  print l
  

  输出[1, 2, 3, 4, 5, 6]，这里和+拼接不同，extend不会生成一个新的列表
• list.index(obj)：从列表中找出某个值第一个匹配项的索引位置

  l = [1, 2, 2, 3]
  print l.index(2)
  

  输出1
• list.insert(index, obj)：将对象插入列表，第一个参数为插入的下标，第二个参数为元素

  l = [1, 2, 4]
  l.insert(2, 3)
  print l
  

  输出[1, 2, 3, 4]
• list.remove(obj)：移除列表中某个值的第一个匹配项
• list.reverse()：反转列表元素

  l = [1, 2, 3]
  l.reverse()
  print l
  

  输出[3, 2, 1]
• list.sort(cmp=None, key=None, reverse=False)：对原列表进行排序，有三种参数：cmp可以指定排序方法，key用来提供进行排序的元素，reverse表示是否是降序排序。

4 - 元组

元组和列表类似，有序存放元素，区别在于元组的元素一旦确定不可修改，类似于一个不可修改元素的数组。
元组的创建可以使用括号：

t = ()          #创建空元组
t = (1,)        #创建
t = (1, 2, 3)

元素的访问规则、截取和列表类似，不赘述了。

元组的内置函数有：

• cmp(tuple1, tuple2)：比较两个元组元素。
• len(tuple)：计算元组元素个数。
• max(tuple)：返回元组中元素最大值。
• min(tuple)：返回元组中元素最小值。
• tuple(seq)：将列表转换为元组，也可以利用list将元组转换为列表

5 - 字典

字典类似于Java中的Map，用来保存多个键值对，键不可重复，并且属于不可修改的类型，例如列表就不允许作为键。
可以通过花括号来创建字典，每个键值对之间用逗号隔开，使用冒号区分键和值：

m = {'apple': 1, 'banana': 10}

5.1 - 元素的增删改查

可以使用中括号来访问值：

print m['apple']   # 输出1

如果尝试访问一个不存在的键，会抛出异常。

如果需要删除一个键，可以使用del语句：

del m['apple']

如果要删除字典中所有的元素，可以使用clear方法：

m.clear()

修改某个键值对的值，或者添加元素可以直接用=赋值：

m['apple'] = 20
m['word'] = 10
print m

输出{'word': 10, 'apple': 20, 'banana': 10}

5.2 - 内置方法

• dict.clear()：删除字典内所有元素
• dict.copy()：创建一个新字典，并复制原字典的引用到新字典
• dict.fromkeys(seq[, val])：创建一个新字典，序列seq中元素做字典的键，val为字典所有键对应的初始值
• dict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值
• dict.has_key(key)：判断该字典是否存在key
• dict.items()：返回一个列表，包含所有的键值对（以元组的方式）

  m = {'apple': 1, 'banana': 10}
  print m.items()
  

  结果为[('apple', 1), ('banana', 10)]
• dict.keys()：以列表返回一个字典所有的键

  m = {'apple': 1, 'banana': 10}
  print m.keys()
  

  结果为['apple', 'banana']
• dict.setdefault(key, default=None)：如果key不存在于字典中，将会添加键值对(key, default)
• dict.update(dict2)：把字典dict2的键值对复制到dict里
• dict.values()：返回字典中的所有值，以列表的形式

  m = {'apple': 1, 'banana': 10}
  print m.values()
  

  输出[1, 10]
• pop(key[,default])：删除字典key所对应的值，返回值为被删除的值。如果字典不存在key，返回default值。
• popitem()：返回并删除字典中的最后一对键和值。