IDE的全称是:Inergrated Devement Enviroment----集成开发环境 

 #!/usr/bin/env python 这一行能够引导程序找到Python解释其，也就是说，不管这个文件保存在什么地方，这个程序都能执行，而不用指定Python的安装路径 

 #coding: utf-8    采用utf-8的编码格式 

 type()可以找到对象的类型，譬如在交互式环境编译type(x),会弹出x的类型 

 在py3中双引号""  与单引号''在打印句子时可以用上但要注意 `` 这个是在ESC键的下面 稍后解释 

 用 + 号拼接起来的两个对象必须是用一种类型，两个数字，则是求和；两个字符串，则是相连，对于list与tuple也是如此 

 如果对int与str比较好奇，可以在交互模式中使用help(int) 

 补充：repr()是一个函数，其实就是反引号的替代品，它能够把结果字符串转化为合法的Python表达式。repr()例如 

 >>> a=250 

 >>> b='you' 

 >>> c=b+repr(a) 

 >>> c 

 'you250' 

 首先明确repr()与``是一致的，repr是函数，str是一种对象类型，具体的区别还在翻译中。。。。。（尴尬） 


 当一个字符串的转义比较多时，可以用 r'  ' 这样来解决，原始字符串就不要转义了。 

 input()函数的返回值是str类型 

 特别提醒的是，print的返回值默认是以 \n 结尾的，所以每个输出语句后自动换行 

 字符串的索引<str>.[] 索引0表示第一个位置，而索引-1表示最后一个位置 


 id()找到变量存储的内存地址，变量相当于一个标签，这个函数我们可以来检验那些对象的方法，看看它们是否改变了内存地址，从而得知是返回一个新生成，还是在原来基础上修改 

 内建函数：built-in-Function 

 对象有类型，变量无类型---非常重要的一句话 

 字符串的伪复制 

 >>> lang='i love you' 

 >>> c=lang[:] 

 >>> c 

 'i love you' 

 >>> id(c) 

 2528756230896 

 >>> id(lang) 

 2528756230896 

 所有序列具有如下基本操作： 

 len()  返回序列长度 

 in 判断元素是否存在与序列中 

 +  连接两个序列 

 *  重复序列元素 

 max() 返回最大值 

 min() 返回最小值 

 cmp(str1，str2) 比较两个序列是否相等 str1<str2  则返回-1； str1=str2 则返回0；str1>str2 则返回1； 

 比较大小的实质是根据其编码 

 ord()是一个内建函数，能后返回某个字符（注意是一个字符，不是多个字符组成的串）的对应ASCII值（十进制） 

 chr()恰好相反，根据整数值得到相应字符 

 字符串的方法split()默认为空格分割，可以根据某个字符分割， 

 方法strip() 去掉字符串左右两端空格 

 lstrip()去掉字符串左边的空格 

 rstrip()去掉字符串右边的空格 

 将列表（这种列表的每个元素必须是字符串元素）拼接为一个总字符串，并且用某个符号连接 

 >>> a=['1','2','3'] 

 >>> ''.join(a) 

 '123' 

 str.split()将str分割为list存储，第一个参数是分割标识，第二个是分割次数 

 >>> kk='i love you forever' 

 >>> kk.split(' ',1) 

 ['i', 'love you forever'] 

 >>> kk.split(' ',2) 

 ['i', 'love', 'you forever'] 

 字符串的格式化，可以用到占位符%s 或 %d 等根据它的不同对象填充来改变，还可以使用<str>.format()的格式化方法，此外还有一种叫做字典格式化，如： 



 对于序列的切片，左边的数字一定要小于右边，不然就返回一个空~~~~ 

 list的反转： 

 >>> alst=[1,2,3,4,5,6] 

 >>> alst[::-1] 

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

 >>> alst 

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

 实际上的alst并没有发生改变，所以是伪反转~~ 

 >>> list(reversed(alst)) 

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

 对于reversed函数，它可以返回一个可以迭代的对象。 

 >>> list(reversed('abcd')) 

 ['d', 'c', 'b', 'a'] 

 而list.reverse()不返回值，不能实现对列表的反响迭代，原地反过来，不会另外生成一个新的列表 

 旗下还有sort函数，对列表进行排序 

 L.sort(cmp=None,key=None,reverse=False)自带3个默认参数 

 >>> a=[1,3,2,4] 

 >>> a.sort() 

 >>> a 

 [1, 2, 3, 4] 

 >>> a.sort(reverse=True) 

 >>> a 

 [4, 3, 2, 1] 

 注意它的从大到小 和 从小到大 

 以及它的key，按照某个关键字排序。 

 >>> lang=['python','java','c','pascal','basic'] 

 >>> lang.sort(key=len) 

 >>> lang 

 ['c', 'java', 'basic', 'python', 'pascal'] 

 列表的append(x)函数，是在原列表进行操作，不会生成新的列表，把x当做整体加到list的尾部 

 对于extend()函数，有点+的感觉，功能更多一点，同样的也是在原列表操作 

 说的专业点：append是整建制地追加，当成整体，extend是个体化扩编，打散为单个。 

 >>> la=[1,2,3] 

 >>> b='abc' 

 >>> la.extend(b) 

 >>> la 

 [1, 2, 3, 'a', 'b', 'c'] 

 对于list的插入：insert()函数，如果插入的位置超出了了最大索引值，则自动将所要插入的元素放到列表的尾部 

 对于list的删除：首先remove()函数，只删除第一次出现的元素，参数就是要删除的元素，后面出现的不管 

 其次是pop()函数，参数为索引编号，默认为尾部，然后返回编号对应的元素，最后删除。 

 以及del list[x] 可以删除索引为x的元素 

 这3个都在原列表上操作。 

 判断一个对象是否为可迭代的（有多种方式） 

 -----------貌似这里出问题了，我用str在hasattr()的检测结果是True，，不应该啊 

 ---------------------------------------------------------------------------------------------- 

 2017.04.19 

 内建函数hasattr()判断一个对象是否为可迭代的， 

 >>> kk='abc' 

 >>> hasattr(kk,'__iter__')注意双下划线 

 True 

 说明了字符串是可迭代的对象 

 原因是把_iter_写成了__iter__，很尴尬啊 

 严重怀疑跟老齐学Python写错了 

 此外我们可以用dir()查找对象是否含有_iter_的方法 

 因为在dir(str)里找到了__iter__方法 

 然后就是extend()提供的不是iterable类型对象，如果提供字符串的话 

 >>> lst=[1,2,3] 

 >>> lst.extend(kk) 

 >>> lst 

 [1, 2, 3, 'a', 'b', 'c'] 

 会将字符串分解为单个字符，然后这些字符组成列表再extend入lst 

 而如果提供整数类型， 

 >>> a=7 

 >>> hasattr(a,'__iter__') 

 False 

 >>>lst.extend(a) 

 报错。。。。。 

 原地修改的特点同时也对应着它们没有返回值 

 list的count方法：其作用是数一数某个元素在list中出现多少次： 

 >>> lst.count(1) 

 1 

 >>> lst.count(10) 

 0 

 >>> lst.count('a') 

 1 

 list的index方法：返回list中元素的下标索引，且当元素多次出现时，取第一次出现的下标索引， 

 当元素未出现，则报错。 

 字典格式化，如： 

 >>> temp='i love %(lang)s my number is %(number)d' 

 >>> my={'lang':'python','number':9527} 

 >>> temp%my 

 'i love python my number is 9527' 

 关于字典copy的一些事： 

 >>> x={'name':'qiwsir','lang':['python','java','c']} 

 >>> y=x.copy() 

 >>> y 

 {'name': 'qiwsir', 'lang': ['python', 'java', 'c']} 

 >>> id(x) 

 2351855576192 

 >>> id(y) 

 2351855576120 

 >>> y['lang'].remove('c') 

 >>> y 

 {'name': 'qiwsir', 'lang': ['python', 'java']} 

 >>> x 

 {'name': 'qiwsir', 'lang': ['python', 'java']} 

 通过id知道x和y不是同一内存，但修改了y而x也变，注意修改的值是列表。 

 >>> y['name']=9527 

 >>> y 

 {'name': 9527, 'lang': ['python', 'java']} 

 >>> x 

 {'name': 'qiwsir', 'lang': ['python', 'java']} 

 注意修改的值是字符串。 

 在Python中，对象比较复杂（非基本数据）的话， 如列表，在复制过程中 

 就不新建窝了，直接引用下原来的窝，copy()实现了浅拷贝 

 相对应的还有深拷贝：不过要导入一个模块 

 >>> import copy 

 >>> z=copy.deepcopy(x) 

 >>> z 

 {'name': 'qiwsir', 'lang': ['python', 'java']} 

 单一的修改x或者z都不会像之前一样由于引用使得改变。 

 字典方法中clear： 

 可用help(dict.clear)查看使用说明 

 del是语句形式的，删除对象，使得完全消失 

 字典方法get和setdefault： 

 get可以寻找参数key是否在字典key中，可以设定当参数key不存在时，有返回值 

 setfault也可以寻找判断，而且当参数key不在时，设定返回值作为值， 

 如果不设定返回值，那么默认的值为None，然后将这组键-值写入字典 

 方法：item/itertims,key/iterkeys,value/itervalues 

 用help()查看使用帮助 

 集合：有的可变，有的不可变，元素无次序，不可重复 

 >>> s1=set('qiwsir') 

 >>> s1 

 {'s', 'r', 'i', 'w', 'q'} 

 >>> s2 

 {'qiwsir'} 

 >>> type(s2) 

 <class 'set'> 

 不提倡使用用{ }的方法来创建set，因为这样无法创建含有列表或者字典类型对象元素的集合 

 hashable 可哈希 即为不可变。 

 对于字典的键必须是hashable 

 创建一个不能原地修改的集合：frozenset()类型为——可哈希 

 集合运算： 

 元素与集合的关系：属于，不属于    用in 

 集合与集合的关系： 

 集合是否相等： 

 >>> a=set('1,2,3') 

 >>> b=set('a,b,c') 

 >>> a 

 {'3', '2', ',', '1'} 

 >>> b 

 {'a', 'b', ',', 'c'} 

 >>> a==b 

 False 

 >>> a!=b 

 True 

 集合子集与超集 

 a<b返回True则是子集，否则不是 

 还可以使用a.issubset(b)判断a是否为b的子集，返回True则是子集 

 集合并集： a|b   或者使用a.union(b) 

 注意这个结果是新生成的一个对象，不是将结合a扩充 

 集合交集： a&b   或者a.intersection(b) 

 集合差集： a-b   或者a.difference(b) 表示将集合a中的集合b元素剔除 

 集合对称差集： a.symmetric_difference(b) 

 相当于将a-b和b-a取并集