数值类型
整数类型 int
Python 3 之后，整数类型为 int ，不在区分整型与长整型，（Python2.x 中分别是 int 和 long 类型）整数的长度不在受限。我觉得这个特性实在方便，少去了其它语言处理溢出的步骤，记得以前学C语言的时候做ACM题的大数相乘废了不少力。
# 不存在溢出问题，舒服
>>> 55555555555555555555555 * 66666666666666666666666666666666666666
3703703703703703703703666666666666666629629629629629629629630L
#直接写下数值，默认十进制
>>> 23
23
#前面加0b，二进制
>>> 0b101010
42
#前面加0o，八进制
>>> 0o15
13
#前面加0x，十六进制
>>> 0x2F
47
>>>
如果想将字符串、浮点数、布尔值等类型装换为整数则使用强制转换函数 int() ,使用函数 oct()、hex() 将十进制返回对应进制的字符串。
浮点类型 float
想知道某个数据的类型使用 type() 函数：
>>> type(3.14159)
#可以用科学计数法表示浮点类型
>>> 1.234e-10
1.234e-10
>>> type(1.234e-10)
如果用个浮点字符串如'1.2345'，想要将其转换为int类型，不能直接用int()函数，要先用float()函数转换为float，再转为int：
>>> int(1.2345)
1
# 这样会报错
>>> int('1.2345')
Traceback (most recent call last):
File "", line 1, in
ValueError: invalid literal for int() with base 10: '1.2345'
>>> int(float('1.2345'))
1
布尔类型
布尔类型只有两个值：True和False. 0为False，非0值都为True。将None、False、0、0.0、0j、''、()、[]、{} 等传给bool(),都会返回False，其他的为True。
复数
Python支持复数直接表示法，使用A+Bj的形式，是complex类的实例，可以直接运算：
>>> 1 + 2j + 2 + 3j
(3+5j)
>>> 10 + 3j + 2 + 3j
(12+6j)
>>>
字符串类型
Python中使用' '或" "来括住字符标明是一个字符串：
>>> 'study python'
'study python'
>>> 'study "python"'
'study "python"'
# Python 自动将'\'视为'\\'
>>> 'c:\windows'
'c:\\windows'
''为转义字符，需要注意特殊情况(这里\t相当与Tab)：
>>> print('c:\tindows')
c: indows
>>> print('c:\\tindows')
c:\tindows
>>> print('c:\\\tindows')
c:\ indows
>>> print('c:\\\\tindows')
c:\\tindows
可以看到这种写法有些不便，可以使用原生字符串Raw_String来表示，在字符串面前加上 r 就行：
>>> print(r'c:\\tindows')
c:\\tindows
想让字符串包含换行缩进等格式时，使用三重引号'''或"""：
>>> '''This is a
... examplr'''
'This is a\nexamplr'
>>> print('''This is a
... example''')
This is a
example
可以使用str()类将数值转换为字符串，使用ord()函数可以返回一个字符的Unicode编码，使用chr()函数则可以将Unicode编码转成一个字符:
>>> str(21.321)
'21.321'
>>> ord('一')
19968
>>> chr(19968)
'一'
格式化字符串
当指定多个字符串给print()函数时，默认的分隔符是空格，如果想要指定其他的字符，可以多指定一个sep参数：
>>> name = 'JYH'
>>> print('hello', name)
hello JYH
>>> print('hello', name, sep = ', ')
hello, JYH
>>> print('hello', name, end = '')
hello JYH>>>
print()函数中默认输出换行，它有一个参数end，在指定的字符串输出后，end指定的字符才会被输出，可以用这个参数来控制是否换行。
可以像C语言一样的在print中用'%'来控制格式，直接看案例：
>>> '你好 %s' % 'JYH'
'你好 JYH'
>>> '%d + %f = %.3f' % (2, 3.14159, 2 + 3.14159)
'2 + 3.141590 = 5.142'
>>> '%5d + %5f = %2.3f' % (2, 3.14159, 2 + 3.14159)
' 2 + 3.141590 = 5.142'
旧的格式化麻烦且可读性不是很好，好在后面有了新的格式化方法：
>>> '{} / {} = {}'.format(5, 7, 5/7)
'5 / 7 = 0.7142857142857143'
>>> '{1} / {0} = {2}'.format(7, 5, 5/7)
'5 / 7 = 0.7142857142857143'
>>> '{a} / {b} = {result}'.format(a = 5, b = 7, result = 5/7)
'5 / 7 = 0.7142857142857143'
占位符变成了{}，可以用索引或者名称来指定参数，也可以指定数字的宽度与小数点位数以及补齐字符：
>>> '{1:d} / {0:d} = {2:.2f}'.format(7, 5, 5/7)
'5 / 7 = 0.71'
>>> '{1:5d} / {0:10d} = {2:10.2f}'.format(7, 5, 5/7)
' 5 / 7 = 0.71'
#"<"用来左对齐，"^"前面的字符为补齐字符
>>> '{1:>5d} / {0:<10d} = {2:0^10.2f}'.format(7, 5, 5/7)
' 5 / 7 = 0000.71000'
format()函数用很多用法，可以像使用索引一样获取列表的值、使用键名称获取字典的值还有引用模块中的名称以及格式化单个值：
>>> array = ['a', 'b', 'c']
>>> 'array has {a[0]}, {a[1]}, {a[2]}'.format(a = array)
'array has a, b, c'
>>> user = {'name' : 'JYH', 'eamil' : '[email protected]'}
>>> 'The name of user is {user[name]}'.format(user = user)
'The name of user is JYH'
>>> import sys
>>> 'My system is {mac.platform}'.format(mac = sys)
'My system is darwin'
>>> format(1.234, '0^10.2f')
'0001.23000'
可以用len()函数获取字符串的长度，实用encode()方法可将字符串转为指定编码，用decode()方法解码，使用 in 来检测某字符是否在字符串中：
>>> str = '字符串'
>>> len(str)
3
>>> str.encode('UTF-8')
b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'
>>> str.encode('UTF-8').decode('UTF-8')
'字符串'
>>> '符' in str
True
无论是Python2 还是 Python3 字符串一旦创建都是不可便变动的 immutable ，无法修改它的内容，不像OC还有mutableString。
群集类型
列表 list
list，就相当于数组，有序，内容长度可变动，使用[]表示，每个元素用逗号','分开，下面展示了列表的一些常用方法：
>>> list = [1, 2, 3, 4]
# remove() 删除指定的元素值， del 删除索引位置的值
>>> list.remove(2)
>>> list
[1, 3, 4]
>>> del list[0]
>>> list
[3, 4]
>>> list.extend([1 , 2])
>>> list
[3, 4, 1, 2]
>>> list.pop()
2
>>> list
[3, 4, 1]
>>> list.append(2)
>>> list
[3, 4, 1, 2]
>>> list.sort()
>>> list
[1, 2, 3, 4]
>>> list.reverse()
>>> list
[4, 3, 2, 1]
>>> 2 in list
True
可以从可迭代对象（如字符串、集合、元组）用 list() 直接创建一个列表：
>>> list('abcde')
['a', 'b', 'c', 'd', 'e']
>>> list({'a', 'b', 'c', 'c', 'b'})
['a', 'b', 'c']
>>> list((1,2,3,4))
[1, 2, 3, 4]
集合 set
集合的内容无序且不重复，使用{}包裹元素，使用逗号','分割，如果有重复的元素会被自动剔除。创建空集合必须使用set();，不能使用{},这会创建一个空字典：
>>> shop = set()
>>> shop.add('water')
>>> shop.add('cake')
>>> shop
{'water', 'cake'}
>>> shop.remove('water')
>>> 'water' in shop
False
由于集合中的元素不能重复，所以并非所有元素都能加入集合中，只有可哈希hashable的对象能放进去，至于什么是可哈希看这里可哈希(hashable)与不可哈希(unhashable)，还可以从其他可迭代的对象中创建集合：
>>> set('fsafa')
{'s', 'a', 'f'}
>>> set([1,2,3,4])
{1, 2, 3, 4}
>>> set((1,2,3,4))
{1, 2, 3, 4}
字典 dict
字典用来存储键值对，创建字典时，键不能重复，必须是 hashable ：
>>> user = {'name' : 'JYH', 'pwd' : 1234}
>>> user['pwd']
1234
>>> user['emial'] = '[email protected]'
>>> user
{'name': 'JYH', 'pwd': 1234, 'emial': '[email protected]'}
#其他创建字典的方式
>>> user2 = dict(name = 'HJY', pwd = 5678, email = '[email protected]')
>>> user2
{'name': 'HJY', 'pwd': 5678, 'email': '[email protected]'}
>>> user3 = dict([('name', '三十六'), ('pwd', 123321)])
>>> user3
{'name': '三十六', 'pwd': 123321}
>>> user2.fromkeys(['name', 'pwd'], 'hahaha')
{'name': 'hahaha', 'pwd': 'hahaha'}
常用方法
#方法 #描述
-------------------------------------------------------------------------------------------------
D.clear() #移除D中的所有项
D.copy() #返回D的副本
D.fromkeys(seq[],val]) #返回从seq中获得的键和被设置为val的值的字典。可做类方法调用
D.get(key[],default]) #如果D[key]存在，将其返回；否则返回给定的默认值None
D.has_key(key) #检查D是否有给定键key
D.items() #返回表示D项的(键，值)对列表
D.iteritems() #从D.items()返回的(键，值)对中返回一个可迭代的对象
D.iterkeys() #从D的键中返回一个可迭代对象
D.itervalues() #从D的值中返回一个可迭代对象
D.keys() #返回D键的列表
D.pop(key[],d]) #移除并且返回对应给定键key或给定的默认值D的值
D.popitem() #从D中移除任意一项，并将其作为(键，值)对返回
D.setdefault(key[],default]) #如果D[key]存在则将其返回；否则返回默认值None
D.update(other) #将other中的每一项加入到D中。
D.values() #返回D中值的列表
元组 tuple
元组跟列表一样，都是有序结构，但不同的是，元组一旦创建之后无法变动，所以它是hashable 。创建元组只需要在某个值后面加一个逗号','即可：
>>> 1,
(1,)
>>> 1, 2, 3,
(1, 2, 3)
>>> 1, 'a', True
(1, 'a', True)
>>> (1, 2, 3)
(1, 2, 3)
创建元组时，最后一个逗号可以省略(只包含一个元素的除外)，通常加上（）更直观的看出这是一个元组。
元组的作用：
可以返回一组相关的值，不用自己定义类型；可以当做不能修改的参数传递给函数，因为元组无法修改，如果函数中试图修改数据，那么就会报错，使得程序更加严谨，而且元组所占用的内存较小。
元组其他用法：
#拆解(unpack)
>>> a = (1, 'a', True)
>>> num, str, bool = a
>>> num
1
>>> bool
True
#python3 新特性
>>> a, *b , c = (1,2,3,4,5)
>>> a
1
>>> b
[2, 3, 4]
>>> c
5
#交换两个变量的值，不像其它语言需要中间变量
>>> a = 1
>>> b = 2
>>> a, b = b, a
>>> a
2
>>> b
1