py语法初步补充

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取并集