数据类型：
变量能够处理不一样类型的值，基本的类型是数和字符串。使用变量时只须要给它们赋一个值。不须要声明或定义数据类型。
Python3 中有六个标准的数据类型：
Number（数字），String（字符串），List（列表），Tuple（元组），Sets（集合），Dictionary（字典）html
1. 布尔值bool
布尔值类型: True，False
布尔运算类型: 与and、或or、非notjava
False： None，""，{}，()，[]， 0python
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]。（通常引号引发来）git
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）扩展操做
● 字符串的拆分和拼接github
str2 = str1.split("sep") #将字符串根据某个sep（分割符）分割成多个字符串组成的列表，默认为空格。 str2 = "sep".join(interable) #将序列中的元素以指定的字符sep链接生成一个新的字符串。列表、元组和字符串都是序列。
● 默认去掉字符串空格：原来的值没有变化，而是新返回了一个结果。也能够指定去除内容（序列或者字符），或者指定内容的子序列web
S.strip() #去掉字符串的左右空格、\t、\n，也能够指定去除内容（序列或者字符），或者指定内容的子序列 S.lstrip() #去掉字符串的左边空格、\t、\n， 也能够指定去除内容（序列或者字符），或者指定内容的子序列 S.rstrip() #去掉字符串的右边空格、\t、\n，也能够指定去除内容（序列或者字符），或者指定内容的子序列
str = '12a2b12c212' print(str.strip('12')) #a2b12c 删除头尾的1和2 print(str.lstrip('12')) #a2b12c212 删除开头的1和2 print(str.rstrip('12')) #12a2b12c 删除结尾的1和2
● 字符大小写的转换：用来实现各类类型的大小写转化api
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
● 字符串分割app
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]) #只能以\n符号分割，若是（）内为True，保留换行符，为False为不保留换行符。
● 字符串内容替换ide
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() # 判断是否存在不可显示的字符，如\t、\n S.isspace() # 判断是否都是空格 S.endswith(suffix[, start[, end]]) #判断字符串是否以指定字符为结尾，可指定范围 S.startswith(prefix[, start[, end]]) #判断字符串是否以指定字符为开头，可指定范围
● 字符串其它魔法
S.count(sub[, start[, end]]) #计算指定子序列在字符串的个数，可指定计算范围 S.expandtabs(tabsize=8) #把字符串中的 tab 符号('\t')转为空格，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