Python中，能够直接处理的数据类型有以下几种：
整数
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
字符串
字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。当然单引号‘和双引号"本身也是字符，如果字符串中有单引号'或双引号"则按照如下的方法处理
字符串的方法
name.capitalize() 首字母大写 name.casefold() 大写全部变小写 name.center(50,"-") 输出 '---------------------Alex Li----------------------' name.count('lex') 统计 lex出现次数 name.encode() 将字符串编码成bytes格式 name.endswith("Li") 判断字符串是否以 Li结尾 "Alex Li".expandtabs(10) 输出'Alex Li'， 将 转换成多长的空格 name.find('A') 查找A,找到返回其索引， 找不到返回-1 format : >>> msg = "my name is {}, and age is {}" >>> msg.format("alex",22) 'my name is alex, and age is 22' >>> msg = "my name is {1}, and age is {0}" >>> msg.format("alex",22) 'my name is 22, and age is alex' >>> msg = "my name is {name}, and age is {age}" >>> msg.format(age=22,name="ale") 'my name is ale, and age is 22' format_map >>> msg.format_map({'name':'alex','age':22}) 'my name is alex, and age is 22' msg.index('a') 返回a所在字符串的索引 '9aA'.isalnum() True '9'.isdigit() 是否整数 name.isnumeric name.isprintable name.isspace name.istitle name.isupper "|".join(['alex','jack','rain']) 'alex|jack|rain' maketrans >>> intab = "aeiou" #This is the string having actual characters. >>> outtab = "12345" #This is the string having corresponding mapping character >>> trantab = str.maketrans(intab, outtab) >>> >>> str = "this is string example....wow!!!" >>> str.translate(trantab) 'th3s 3s str3ng 2x1mpl2....w4w!!!' msg.partition('is') 输出 ('my name ', 'is', ' {name}, and age is {age}') >>> "alex li, chinese name is lijie".replace("li","LI",1) 'alex LI, chinese name is lijie' msg.swapcase 大小写互换 >>> msg.zfill(40) '00000my name is {name}, and age is {age}' >>> n4.ljust(40,"-") 'Hello 2orld-----------------------------' >>> n4.rjust(40,"-") '-----------------------------Hello 2orld' >>> b="ddefdsdff_哈哈" >>> b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则 True
布尔值
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。
变量
变量即在程序运行过程中它的值是允许改变的量
变量的作用：代指内存里某个地址中保存的内容
变量定义的规则：
- 变量名只能是 字母、数字或下划线的任意组合
- 变量名的第一个字符不能是数字
- 以下关键字不能声明为变量名
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
变量不仅可以是数字，还可以是任意数据类型
变量的赋值
#!/usr/bin/env python
# -*- coding: utf-8 -*-
name = "sunny" # name是字符串
age=24 # age是整数
这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言
常量
所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：
PI = 3.14159265359
list
list是一种有序的集合，可以随时添加和删除其中的元素
创建一个列表
list1=[1, 2, 3, 4, 5 ]
查看列表
list1
列表元素的个数
len(list1)
用索引来访问list中每一个位置的元素，记得索引是从0开始的
>>> list1[0]
1
>>> list1[-1]
5
查找列表中值为3元素的索引
list1.index(3)
在列表末尾添加新的元素
list.append(8)
插入元素到指定位置
list1.insert(2,'hehe')
移除列表中的一个元素（默认最后一个元素),并且返回该元素的值
list1.pop()
list1.pop(2)
删除指定元素
list1.remove(3)
替换元素
list1[0]=4
排序
list1.sort()
反转
list1.reverse()
统计某个元素在列表中出现的次数
list1.count('hehe')
在列表末尾追加另一个列表
list1.extend(list2)
返回列表元素最大值
max(list1)
返回列表元素最小值
min(list1)
切片
list1[0:5]
判断某个值是否在列表中
if 5 in list1: print("true")
删除列表
del list1
tuple
tuple和list非常类似，但是tuple一旦初始化就不能修改
创建一个元组
tup1 = (1, 2, 3, 4, 5 )
只有1个元素的tuple定义时必须加一个逗号,
tup2= (1,)
将元组转为列表
list2=list(tup1)
将列表转为元组
tup2=tuple(list2)
删除元组
del tup1
dict
使用键-值（key-value）存储，具有极快的查找速度 。dict是无序的 key是唯一的
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} #生成一个字典
>>> d['Michael'] #通过key查询对应的值
95
>>> d['Adam'] = 67 #向字典中插入新值
>>> d['Adam']
67
>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88 #多次对一个key放入value，后面的值会把前面的值冲掉
>>> d['Jack']
88
>>>d['Thomas'] #key不存在，dict就会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Thomas'
>>> 'Thomas' in d #通过in判断key是否存在
False
>>>d.get('Thomas') #如果key不存在，可以返回None，并不会报错
>>> d.pop('Bob') #删除一个key，用pop(key)方法，对应的value也会从dict中删除
75
循环打印
#方法1 这种速度快，大数据用这种
for i in dic:
print i,dic[i]
#方法2
for k,v in dic.items():
print k,v
dic.items()
取key
dic.keys()
['key2', 'key1']
取值
dic.values()
['sxl1', 'sxl']
随机删，慎重使用
dic.popitem()
如果没有这个key，就设置一个默认的值
dic.setdefault('name','sun')
将2个字典聚合，如果有重复数据将被覆盖
dic.update(a)
清空字典
dic.clear()
删除字典
del dic
浅复制，将字典复制一份
b=dic.copy()
set
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key
>>> s = set([1, 2, 3]) >>> s {1, 2, 3} 注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。 重复元素在set中自动被过滤： >>> s = set([1, 1, 2, 2, 3, 3]) >>> s {1, 2, 3} 通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果： >>> s.add(4) >>> s {1, 2, 3, 4} >>> s.add(4) >>> s {1, 2, 3, 4} 通过remove(key)方法可以删除元素： >>> s.remove(4) >>> s {1, 2, 3} set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作： >>> s1 = set([1, 2, 3]) >>> s2 = set([2, 3, 4]) >>> s1 & s2 {2, 3} >>> s1 | s2 {1, 2, 3, 4} set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。
difference 差异比较
l1 = ['1','2','3','4'] l2 = ['4','5','6'] s1 = set(l1) #传入一个集合 s2 = s1.difference(*l2) print(s1) 原集合并未改变 print(s2) # 最终返回一个新的集合， # 这个属性是通过对象本身与传入的元素进行对比，只要对象本身没有与传入元素相同的元素，则返回这个元素，最终组合成新的元素集合
difference_update 差异更新
l1 = ['1','2','3','4','6']
l2 = ['4','5','6']
s1 = set(l1)
s2 = s1.difference_update(*l2)
print(s1)
print(s2)
#通过观察返回结果可知，这个方法是直接更新对象本身，就存在相同的元素剔除，并不会返回剔除元素，剔除规则，对象本身与传入元素对比，如果对象本身的元素在传入的元素里面，则删除这个元素
#{'3', '1', '2'}
#None
discard 删除一个元素
l1 = ['1','2','3','4','6']
l2 = ['4','5','6']
s1 = set(l1)
print(s1)
s2 = s1.discard('1')
print(s1)
print(s2)
#通过传入一个元素，对象本身则将这个元素删除，如果对象本身不存在这个元素则没有任何变化，也没有错误信息，该操作是直接操作对象本身，且没有返回值
#{'3', '2', '6', '4', '1'}
#{'3', '2', '6', '4'}
#None
intersection 取交集元素集合
l1 = ['1','2','3','4','6']
l2 = ['4','5','6']
s1 = set(l1)
s2 = set(l2)
print(s1)
s3 = s1.intersection(s2)
print(s1)
print(s2)
print(s3)
#{'1', '2', '4', '3', '6'} 第一次原始集合
#{'1', '2', '4', '3', '6'} 集合s1和s2进行交集判断后的输出结果，并没有改变对象本身
#{'4', '5', '6'} s2的集合也并未发生改变
#{'4', '6'} 通过交集比较，返回了一个新的元素集合，返回的是s1和s2共同拥有的元素集合
intersection_update 交集更新
l1 = ['1','2','3','4','6']
l2 = ['4','5','6']
s1 = set(l1)
s2 = set(l2)
print(s1)
s3 = s1.intersection_update(s2)
print(s1)
print(s3)
#通过输出结果可以看出，s1是直接更新了自己，把与传入的集合，与集合里面不相同的元素删除，且没有返回值
#{'6', '3', '4', '1', '2'}
#{'6', '4'}
#None
isdisjoint 判断是非没有交集
l1 = ['1','12']
l2 = ['4','6']
s1 = set(l1)
s2 = set(l2)
print(s1)
s3 = s1.isdisjoint(s2)
print(s1)
print(s3)
#{'12', '1'}
#{'12', '1'}
#True
#当两个集合之间没有任何交集时，则返回True
issubset 是否是子集
l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
print(s1.issubset(s2)) # 输出为False说明s1不是s2的子集
print(s1.issubset(s3)) # 输出false说明 s1不是 s3的子集
print(s3.issubset(s1)) # 输出true，说明s3是s1的子集
issuperset 是否父集
l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
print(s1.issuperset(s3)) #输出True,说明s1是s3的父集
print(s3.issuperset(s1)) #输出false，说明s3不是s1的父集
pop 随机删除元素
l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.pop()
print(s1) #对象本身被随机删除一个元素
print(s4) # 随机删除的元素会返回被随机删除的元素
remove 移除指定元素
l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.remove('12')
print(s1) #直接移除指定元素，并更新对象本身，如果指定元素不存在，则抛出异常
print(s4) # 该属性没有返回值
symmetric_difference 差集对比
l1 = ['1','12','13']
l2 = ['4','6','1']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.symmetric_difference(s2)
print(s1) #该方法并不会更新对象本身的值
print(s4) #该对象返回一个新的集合，传入的元素与对象本身比较，如果传入的元素里面有的元素，而对象本身没有，则添加到对象本身的集合内，最终返回一个新的集合
symmetric_difference_update 差集更新
l1 = ['1','12','13']
l2 = ['4','6','1']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.symmetric_difference_update(s2)
print(s1) #直接扩展对象本身与传入集合的没有交集的元素
print(s4) #该方法没有返回值
union 返回新集合
#效果与差异更新类似，只是这个是返回一个新的集合，而差异更新是更新对象本身，不返回新集合
l1 = ['1','12','13']
l2 = ['4','6','1']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
s4 = s1.union(s2)
print(s1) #对象本身没有变化
print(s4) #将对象本身与传入的集合元素比较，把所有的元素重现组合成一个新的集合返回
update 更新集合
dic1 ={'k1':'v1','k2':'v2'}
dic2 ={'k1':'vv','k2':'v2','k3':'v3'}
s1 = set(dic1)
print(s1)
s2 = s1.update(dic2)
print(s1) #将会对集合本身进行扩展，如果对象本身不存在这个传入的元素，则添加到对象本身的元素集合
s = set([3,5,9,10]) #创建一个数值集合 t = set("Hello") #创建一个唯一字符的集合 a = t | s # t 和 s的并集 b = t & s # t 和 s的交集 c = t – s # 求差集（项在t中，但不在s中） d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中） 基本操作： t.add('x') # 添加一项 s.update([10,37,42]) # 在s中添加多项 使用remove()可以删除一项： t.remove('H') len(s) set 的长度 x in s 测试 x 是否是 s 的成员 x not in s 测试 x 是否不是 s 的成员 s.issubset(t) s <= t 测试是否 s 中的每一个元素都在 t 中 s.issuperset(t) s >= t 测试是否 t 中的每一个元素都在 s 中 s.union(t) s | t 返回一个新的 set 包含 s 和 t 中的每一个元素 s.intersection(t) s & t 返回一个新的 set 包含 s 和 t 中的公共元素 s.difference(t) s - t 返回一个新的 set 包含 s 中有但是 t 中没有的元素 s.symmetric_difference(t) s ^ t 返回一个新的 set 包含 s 和 t 中不重复的元素 s.copy() 返回 set “s”的一个浅复制
有序字典(orderedDict )
import collections mydic = collections.OrderedDict(name='zcy',age='25',job='IT') print(mydic) print(mydic.keys()) print(mydic.values()) mydic.update(name='hello') mydic.update(time='2016') print(mydic) #OrderedDict([('age', '25'), ('name', 'zcy'), ('job', 'IT')]) #odict_keys(['age', 'name', 'job']) #odict_values(['25', 'zcy', 'IT']) #OrderedDict([('age', '25'), ('name', 'hello'), ('job', 'IT'), ('time', '2016')])
默认字典(defaultdict)
import collections mydic = collections.defaultdict(list) print(mydic) mydic['k1'] print(mydic) print(mydic.keys()) print(mydic.values()) #默认值为一个列表类型 newdic={} newdic.setdefault('k1',list) newdic['k1'] print(newdic) print(newdic['k1']) print(newdic.values()) #defaultdict(<class 'list'>, {}) #defaultdict(<class 'list'>, {'k1': []}) #dict_keys(['k1']) #dict_values([[]]) #{'k1': <class 'list'>} #<class 'list'> #dict_values([<class 'list'>])
可命名元组(namedtuple)
import collections Point = collections.namedtuple('Point',['x','y','z']) #创建一个类,类名为Point myPoint = Point(11,22,33) print(myPoint) print(myPoint.x) #直接通过命名元素去访问元组对应的元素, print(myPoint[0]) #等同于上面这种方式,但是没有上面这种方式可读性强 print(myPoint.y) print(myPoint.z) #Point(x=11, y=22, z=33) #11 #11 #22 #33
双向队列(deque)
import collections newqueue = collections.deque(['a','b','c']) print(newqueue) newqueue.append(['d1','d2']) #追加一个元素到队列 print(newqueue) newqueue.appendleft('a1') #追加一个元素到队列左侧 newqueue.appendleft('a2') #追加一个元素到队列左侧 print(newqueue) newc = newqueue.count('a') #对队列某个元素进行计数 print(newc) newqueue.extend(['e','f','g']) #扩展队列元素 print(newqueue) newqueue.extendleft(['a11','a22','a33']) #从左侧开始扩展队列 print(newqueue) newqueue.insert(2,'aa22') #插入到下标2的位置 print(newqueue) newqueue.reverse() #顺序反转 print(newqueue) newqueue.rotate(4) #将队列末尾4个元素反转到队列左侧 print(newqueue) #deque(['a', 'b', 'c']) #deque(['a', 'b', 'c', ['d1', 'd2']]) #deque(['a2', 'a1', 'a', 'b', 'c', ['d1', 'd2']]) #1 #deque(['a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g']) #deque(['a33', 'a22', 'a11', 'a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g']) #deque(['a33', 'a22', 'aa22', 'a11', 'a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g']) #deque(['g', 'f', 'e', ['d1', 'd2'], 'c', 'b', 'a', 'a1', 'a2', 'a11', 'aa22', 'a22', 'a33']) #deque(['a11', 'aa22', 'a22', 'a33', 'g', 'f', 'e', ['d1', 'd2'], 'c', 'b', 'a', 'a1', 'a2'])
单项队列
#单向队列是FIFO工作模式 import queue newqueue = queue.Queue(2) #设置队列长度为2,也就是队列里只有两个任务 newqueue.put(['1','2']) # 放入一个任务 newqueue.put(2) # 放入第二个任务 isempty = newqueue.empty() #判断队列是否空 isfull = newqueue.full() # 判断队列是否满了 get1 = newqueue.get() #获取第一个任务 get2 = newqueue.get() #获取第二个任务 print(get1) print(get2) isfull2 = newqueue.full() #判断队列是否满了,因为已经把任务取出来了,所以这时队列应该是没有满 isempty2 = newqueue.empty() #判断队列是否为空 print(isfull) print(isfull2) print(isempty) print(isempty2) #['1', '2'] #2 #True #False #False #True queue 单向队列