数据类型：
变量可以处理不同类型的值，基本的类型是数和字符串。使用变量时只需要给它们赋一个值。不需要声明或定义数据类型。
Python3 中有六个标准的数据类型：
Number（数字），String（字符串），List（列表），Tuple（元组），Sets（集合），Dictionary（字典）
1. 布尔值bool
布尔值类型: True，False
布尔运算类型: 与and、或or、非not
False： None，""，{}，()，[]， 0
a = True print a and 'a=T' or 'a=F' #计算结果不是布尔类型，而是字符串 'a=T'。因为Python的False只有几种，其他数值和非空字符串都看成 True，所以，计算结果是 'a=T'，继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'，
2. 字符串
1）定义
是由零个或多个字符组成的有限串行。一般记为s=a[1]a[2]...a[n]。（一般引号引起来）
2） 基本操作
str.index() # 索引字符 str[N] # 索引，可为负值 str[n:m] # 切片，可为负值 len() # 求序列长度 str1 + str2 # 加法：“+”连接字符串连接2个序列 str1 * n # 乘法：“*” 重复序列元素，就是重复那个字符串的含义。 in # 判断元素是否存在于序列中 max() # 返回最大值--ASCII编码 min() #返回最小值--ASCII编码 cmp(str1,str2) #比较2个序列值是否相同，首先将字符串中的符号转化为对应编码的数字，然后比较。如果返回的数值小于零，说明第一个小于第二个，等于0，则两个相等，大于0，第一个大于第二个。
3）扩展操作
● 字符串的拆分和拼接
str2 = str1.split("sep") #将字符串根据某个sep（分割符）分割成多个字符串组成的列表，默认为空格。 str2 = "sep".join(interable) #将序列中的元素以指定的字符sep连接生成一个新的字符串。列表、元组和字符串都是序列。
● 默认去掉字符串空格：原来的值没有变化，而是新返回了一个结果。也可以指定去除内容（序列或者字符），或者指定内容的子序列
S.strip() #去掉字符串的左右空格、 、 ，也可以指定去除内容（序列或者字符），或者指定内容的子序列 S.lstrip() #去掉字符串的左边空格、 、 ， 也可以指定去除内容（序列或者字符），或者指定内容的子序列 S.rstrip() #去掉字符串的右边空格、 、 ，也可以指定去除内容（序列或者字符），或者指定内容的子序列
str = '12a2b12c212' print(str.strip('12')) #a2b12c 删除头尾的1和2 print(str.lstrip('12')) #a2b12c212 删除开头的1和2 print(str.rstrip('12')) #12a2b12c 删除结尾的1和2
● 字符大小写的转换：用来实现各种类型的大小写转化
S.upper() #将S中的字母转换为大写 S.lower() #将S中的字母转换为小写 S.casefood #将S中的字母转换为小写，更强大 S.swapcase() #将S中的字母的大小写全转换 S.title() #将S中字符串中所有的单词转换成首字母都是大写 S.capitalize() #首字母大写 S.isupper() #S中的字母是否全是大写 S.islower() #S中的字母是否全是小写 S.istitle() #S中字符串中所有的单词拼写首字母是否为大写，且其他字母为小写
● 字符串填充/宽度设置
S.center(width[, fillchar]) #设置S的宽度，字符串内容在中间，以第二个参数为填充字符，填充字符只能指定一个，可不填，默认为空格 S.ljust(width[, fillchar]) #指定宽度和填充字符，内容放左边，右边填充指定字符，默认填充字符为空格 S.rjust(width[, fillchar]) #指定宽度和填充字符，内容放右边，左边填充指定字符，默认填充字符为空格 S.zfill(width) #指定宽度，不可指定字符，内容放右边，左边填充0
● 字符串分割
S.partition(sep) # 从左边起，找到第一个指定的字符sep，将左右两边进行切割，分割为3份。第二份为指定字符sep S.rpartition(sep) # 从右边起，找到第一个指定的字符sep，将左右两边进行切割，分割为3份。第二份为指定字符sep S.split(sep=None, maxsplit=-1) # 从左边起，找到所有指定的字符sep，将左右两边抽离，分割为n份。指定maxsplit=1则只找一个，左右两边分割一次，匹配的sep不会出现。 S.lstrip([chars]) # 从右边起，找到所有指定的字符sep，将左右两边抽离，分割为n份。指定maxsplit=1则只找一个，左右两边分割一次，匹配的sep不会出现。 S.splitlines([keepends]) #只能以 符号分割，如果（）内为True，保留换行符，为False为不保留换行符。
● 字符串内容替换
S.maketrans(self, *args, **kwargs) #给定替换规则（“m”，“n”）e.g. x=S.maketrans("abc","123") S.translate(table) #按照给给定的替换规则进行替换，类似翻译。e.g. y = S.translate(x) ,if S=abcda, print(y)为123d1 S.replace(old, new[, count]) #字符串替换，把old 替换成new，默认全体替换，可指定替换个数，即替换前面n个数
● 字符串内容判断
S.isalnum() # 判断字符串是否只包含数字和字母，是返回True，包含其他的字符返回False S.isalpha() # 判断字符串是否只包含字母，是返回True，包含其他的字符返回False S.isdecimal() # 判断是否为数字 S.isdigit() # 判断是否为数字，对特殊数字也适用。例如② S.isnumeric() # 判断是否都是数字，对中文数字也适用。最牛 S.isidentifier() # 判断是否为标识符 S.isprintable() # 判断是否存在不可显示的字符，如 、 S.isspace() # 判断是否都是空格 S.endswith(suffix[, start[, end]]) #判断字符串是否以指定字符为结尾，可指定范围 S.startswith(prefix[, start[, end]]) #判断字符串是否以指定字符为开头，可指定范围
● 字符串其它魔法
S.count(sub[, start[, end]]) #计算指定子序列在字符串的个数，可指定计算范围 S.expandtabs(tabsize=8) #把字符串中的 tab 符号(' ')转为空格，tabsize用来断句，默认8个字符，即以8个字符为一个断句标准，不足以空格补全。 S.find(sub [,start [,end]]) #查找给定子序列的第一个位置，返回索引值，可指定范围，未找到时返回-1 S.format(*args, **kwargs) #格式化，将字符串中的占位符替换成指定值 S.format_map({*args： m, **kwargs： n}) #格式化，将字符串中的占位符替换成指定值,必须提供键值对 S.index(sub [,start [,end]]) #查找给定子序列的第一个位置，返回索引值，可指定范围，未找到时返回出错
4） 格式化字符串
待续。。。
3. 列表
1） 定义
在python中，用方括号 [ ] 表示一个list。在方括号里面，可以是int，也可以是str类型的数据，甚至也能够是True/False这种布尔值，或者嵌套一个列表。list中的元素是任意类型的。
2） 判断
bool()是一个布尔函数，作用就是来判断一个对象是“真”还是“空”（假）。如果list中什么也没有，就是空的，用bool()函数来判断，得到False，从而显示它是空的。
3） 生成
生成list：range（）函数和for循环的引用 # e.g. print [ x * y for x, y in zip(range(1,100,2),range(2,101,2))]
4） 修改
这种修改，不是复制一个新的，而是在原地进行修改。内存地址不变。其存储为链式存储。
5）切片和索引
list和str两种类型的数据，有共同的地方，它们都属于序列（都是一些对象按照某个次序排列起来，这就是序列的最大特征）。
索引都是从左边开始编。第一个是0，然后依次增加1。此外，还有一种编号方式，对于list，既然Python支持L[-1]取倒数第一个元素就是从右边开始，右边第一个可以编号为-1，然后向左依次是：-2,-3,...，依次类推下来。这对字符串、列表等各种序列类型都是用。
序列的切片，左边的数字一定要小于右边的数字。不包括右边的数据。切片结果为新的list。 同样支持倒数切片取倒数。切片操作还可以指定第三个参数：第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。
list[:] #复制出了一个新list。 list[::-1] #反转，不是在“原地”把原来的值倒过来，而是新生成了一个值，那个值跟原来的值相比，是倒过来了。等同于list(reversed(list0)) list[1:3] = [x, y] #切片赋值
6） 基本操作
len(L) # 求列表长度 e.g. lst = [1,2,3] len(lst) = 3 L[i]=() # 替换第i个元素 e.g. lst[2]=(4) = [1,2,4] L1+ L2 # 连接2个序列，连接列表 e.g. alst = [5, 6] lst + alst = [1, 2, 3, 4, 5, 6] L*n # 重复序列元 素“*” 字符串中的“乘法”，就是重复那个列表的含义。blst = st * 2 = [1,2,3,1,2,3] x in list # 判断元素是否存在于序列中 e.g. x in lst : False L.append(object) # 即将新的元素x追加到list的尾部，等效于：a[len(a):]=[x] e.g. lst.append("like") = [1,2,3,like] cmp(L1,L2) # 比较2个序列值 e.g.cmp(lst,alst) == False L.extend(iterable) # append是整建制地追加，extend是个体化扩编。 # e.g. lst.append(["qiwsir","github"]) = [1, 2, 3, ['qiwsir', 'github']]; lst2.extend(["qiwsir","github"]) = [1, 2, 3, 'qiwsir', 'github'] L.count(value) # 计算元素个数 e.g.deblst.count(2) = 2 L.index(value, [start, [stop]]) # 获得索引位置 e.g.lst.index(2) = 1 L.insert(index, object) # L.insert(i,x) 在i位置插入元素x e.g. lst.insert(2,"x") = [1,2,x,3] del L[n:m] # 删除元素
L.remove(value) # 移除元素 lst.remove(1) = [2,x,3] L.pop([index]) # 移除索引值位置的元素，L.pop([i]) e.g. list.pop([1]) = [1,x,3] L.reverse() # 列表反转 e.g. lst.reverse () = [3,2,1] L.sort(key=None, reverse=False) # lst.sort(reverse=True) = [3,2,1] L.sort(cmp=None, key=None, reverse=False) -- stable sort IN PLACE; cmp(x, y) -> -1, 0, 1 # lst = ["python","java","c","pascal","basic"]; lst.sort(key=len) =['c', 'java', 'basic', 'python', 'pascal'] L.clear() # 清空列表，参数为空：None 表示 remove all items from L L.copy() # 拷贝列表，浅拷贝
7） list和str转化
str.split() # S.split([sep [,maxsplit]]) -> list of strings 这个内置函数实现的是将str转化为list。其中str=""是分隔符。返回字符串S中的单词列表，使用sep作为分隔符字符串。 如果给出maxsplit，则最多可以完成maxsplit拆分。 如果未指定sep或无，则空格字符串为分隔符，并从结果中删除空字符串。 "[sep]".join(list) or list（str） # 字符串转换成列表
4. 元组
1）特点
用圆括号()括起来的，其中的元素之间用逗号隔开。（都是英文半角）元组只有一个元素的时候（特别是数或者字符串），记得添加“,”才是元组
* 元组中的元素类型是任意的python数据。
* tuple是一种序列类型的数据，这点上跟list/str类似。它的特点就是其中的元素不能更改，这点上跟list不同，倒是跟str类似；它的元素又可以是任何类型的数据，这点上跟list相同，但不同于str。元素不能被增加或删除。tuple指向的list，list可变，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，“可变”是指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！要创建一个内容也不变的tuple，那就必须保证tuple的每一个元素本身也不能变。即一级元素不可变。
* 如果一个元组中只有一个元素的时候，应该在该元素后面加一个半角的英文逗号：因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义。
2） 索引和切片
可以正常使用 t[0]，t[-1]等索引方式访问元素，但是不能赋值成别的元素。
3） tuple使用的情景:
A. Tuple 比 list 操作速度快。如果您定义了一个值的常量集，并且唯一要用它做的是不断地遍历它，请使用 tuple 代替 list。
B. 如果对不需要修改的数据进行 “写保护”，可以使代码更安全。使用 tuple 而不是 list 如同拥有一个隐含的 assert 语句，说明这一数据是常量。如果必须要改变这些值，则需要执行 tuple 到 list 的转换 (需要使用一个特殊的函数)。
C. Tuples 可以在 dictionary（字典，后面要讲述） 中被用做 key，但是 list 不行。Dictionary key 必须是不可变的。Tuple 本身是不可改变的，但是如果您有一个 list 的 tuple，那就认为是可变的了，用做 dictionary key 就是不安全的。只有字符串、整数或其它对 dictionary 安全的 tuple 才可以用作 dictionary key。
D. Tuples 可以用在字符串格式化中。
4） 列表和元组：用list()和tuple()能够实现两者的转化
5） 基本用法
T.count(value) #计算某个值的出现个数 T.index(value, [start, [stop]]) #返回索引位置
5. 字典
1） 特点
* 查找速度快：无论dict有10个元素还是10万个元素，* 查找速度都一样。而list的查找速度随着元素增加而逐渐下降。不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。由于dict是按 key 查找，所以，在一个dict中，key不能重复。
* 存储的key-value序对是没有顺序，无序
* 作为 key 的元素必须不可变：Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。
* 可遍历：for
2） 创建
* 花括号 {} 表示, key: value,最后一个 key: value 的逗号可以省略。
* 在字典中的“键”，必须是不可变的数据类型；“值”可以是任意数据类型。列表可以修改，所以列表是可变的；字符串和元组都不行，所以它们是不可变的。字典可以原地修改，即它是可变的。列表，字典不能作为key。布尔值True=1， False=0，当与其他key值重复的时候，会出现冲突，其可以当成key的。
* 直接创建：
a. 创建一个空的dict，这个空dict，可以在以后向里面加东西用。
mydict = {}
b. 创建有内容的dict。
person = {"name":"qiwsir","site":"qiwsir.github.io"}
"name":"qiwsir"：键值对。前面的name叫做键（key），后面的qiwsir是前面的键所对应的值(value)。在一个dict中，键是唯一的，不能重复。值则是对应于键，值可以重复。键值之间用(:)英文的冒号，每一对键值之间用英文的逗号(,)隔开。
* 利用元组建构字典
name = (["first","Google"],["second","Yahoo"]) website = dict(name) #website = {'second': 'Yahoo', 'first': 'Google'} ad = dict(name = "qiwsir", age = 42) #ad = {'age': 42, 'name': 'qiwsir'}
* 使用fromkeys，这种方法是重新建立一个dict。
website = {}.fromkeys(("third","forth"),"facebook") #website = {'forth': 'facebook', 'third': 'facebook'}
3） 访问dict的值
dict数据类型是以键值对的形式存储数据的，所以，只要知道键，就能得到值。这本质上就是一种映射关系。通过字典的“键”找到相应的“值”。通过“键”能够增加dict中的“值”，通过“键”能够改变dict中的“值”，通过“键”也能够访问dict中的“值”。字典没有索引。
person = {'name2': 'qiwsir', 'name': 'qiwsir', 'language': 'python', 'site': 'qiwsir.github.io'}
person['name'] #'qiwsir'
person['language'] #'python'
4）基本操作
len(d) # 返回字典(d)中的键值对的数量 d[key] # 返回字典(d)中的键(key)的值 d[key]=value # 将值(value)赋给字典(d)中的键(key) del d[key] # 删除字典(d)的键(key)项（将该键值对删除） key in d # 检查字典(d)中是否含有键为key的项
5）要避免 KeyError 的两个办法：
key in d
先判断一下 key 是否存在，用 in 操作符：
dict.get()
使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None。
6） 其他操作
D.clear() #Remove all items from D D.copy() #浅拷贝 D.get(k[,d]) #-> D[k] 获取key的value值，获取不到返回None D.items() #D.iteritems(...) D.keys() #获取字典的key集合 D.values() #D. itervalues() D.pop(k[,d]) #删除指定键的键值对。 D.popitem() #随机删除字典的键值对。 D.setdefault(k[,d]) #设置键值对，若存在不设置，获取当前的key对应得值，不存在的话，添加。 D.update([E, ]**F) #更新键值对。存在的覆盖，不存在的更新上去。e.g. dic.update({'k1':'111','k2':'123'}) or dic.update({k1=111,k2=123}) dict.fromkeys(*args, **kwargs) #根据序列创建字典，指定的值统一。参数只能两个，静态方法 e.g. v=dict.fromkeys(["k1",123]，123); v={"k1":123, 123:123}
6. 集合set
1）定义
由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key。即列表，字典不可以，数字，字符串，元组可以。
2）特点
不同的集合间用来做关系运算，无需纠结于集合中单个值.list和dict的杂合。set拥有类似dict的特点:可以用{}花括号来定义；其中的元素没有序列，也就是是非序列类型的数据；而且，set中的元素不可重复,这就类似dict的键。
3）创建
用set()来创建集合，即创建的集合可变。
s2 = set([123,"google","face","book","facebook","book"]) #set(['facebook', 123, 'google', 'book', 'face'])
使用{}的方式创建集合，但无法创建含有list/dict元素的set。这种方式不提倡使用，因为在某些情况下，python搞不清楚是字典还是集合。创建的集合可变。
>>> s3 = {"facebook",[1,2,'a'],{"name":"python","lang":"english"},123}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>> s3 = {"facebook",[1,2],123}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
集合另一个创建方法是用frozenset()，hashable类型，不能在原处修改。即创建的集合不可变。
f_set = frozenset("qiwsir") # frozenset(['q', 'i', 's', 'r', 'w']) f_set.add("python") #报错，不能修改，则无此方法 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'frozenset' object has no attribute 'add' a_set = set("github") #对比看一看，这是一个可以原处修改的set, set(['b', 'g', 'i', 'h', 'u', 't']) a_set.add("python") #set(['b', 'g', 'i', 'h', 'python', 'u', 't'])
4) 关系运算
in #属于 not in #不属于 A==B # A等于B，即两个集合的元素完全一样或使用A!=B A<B #A是B的子集，或者反过来，B是否是A的超集。即A的元素也都是B的元素，但是B的元素比A的元素数量多。判断集合A是否是集合B的子集，可以使用A<B，返回true则是子集，否则不是。另外，还可以使用函数A.issubset(B)判断。 A<=B A>B A>=B A|B. #A、B的并集，即A、B所有元素。可以使用的符号是“|”，是一个半角状态写的竖线，输入方法是在英文状态下，按下"shift"加上右方括号右边的那个键。找找吧。表达式是A | B.也可使用函数A.union(B)，得到的结果就是两个集合并集，注意，这个结果是新生成的一个对象，不是将结合A扩充。 A|=B #合集 A & B #交集，A、B的交集，即A、B所有的元素：A & B 或A.intersection(B) A&=B A - B #A相对B的差（补），即A相对B不同的部分元素： A - B或A.difference(B) ^,^= #对称差分 (A-B)|(B-A) # A、B的对称差集：（A-B）| （B-A）或A.symmetric_difference(B)
5） 其他操作
S.add(self, *args, **kwargs) #添加元素 S.clear(self, *args, **kwargs): #清空元素 S0=S.copy(self, *args, **kwargs): #拷贝集合 S.pop(self, *args, **kwargs): #随机删除一个元素 S.remove(self, *args, **kwargs): #删除某个指定元素，如果元素不存在，会报错。 e.g. S.remove('sb') S.discard(self, *args, **kwargs): # 与remove功能相同，删除元素不存在时不会抛出异常 S.union(self, *args, **kwargs): # 求并集，相当于s1Us2 S.difference(self, *args, **kwargs): #求差集，相当于s1-s2 S.difference_update(self, *args, **kwargs): #求完交集求补集，相当于s1=s1-（s1&s2） S.intersection(self, *args, **kwargs): #求交集，相当于s1&s2 e.g. s1.intersection(s2) S.intersection_update(self, *args, **kwargs): # 求交集之后将结果赋值给S，相当于s1=s1&s2 S.symmetric_difference(self, *args, **kwargs): # 求交叉集的补集，相当于s1^s2 ((s1-(s1&s2))U((s2-(s1&s2)) S.symmetric_difference_update(self, *args, **kwargs): #求交叉集的补集,并赋值给S。相当于：s1=((s1-(s1&s2))U((s2-(s1&s2)) S.update(self, *args, **kwargs): #把新的可迭代的值更新到S S.isdisjoint(self, *args, **kwargs): # 判断是否有交集 S.issubset(self, *args, **kwargs): # 判断s1是否包含于s2，即s1是否为s2的子集，相当于s1<=s2 S.issuperset(self, *args, **kwargs): #判断s2是否包含于s1，即s2是否为s1的子集，相当于s1>=s2
《参考文献》
https://www.cnblogs.com/wupeiqi/articles/5433893.html
http://www.cnblogs.com/linhaifeng/articles/5935801.html
http://www.cnblogs.com/wupeiqi/articles/5444685.html
https://www.cnblogs.com/nulige/p/6102645.html
http://www.cnblogs.com/alexzp/p/3377921.html