Python:输入输出，注释，运算符，变量，数字类型，序列，条件和循环控制，函数，迭代器与生成器，异常处理

输入函数input()和raw_input()
>>> a = input()

>>> c = raw_input()

>>> type(c)

输出函数print()


注释

　　行内注释用#，在一行的#之后被认为是注释。

　　多行注释用一对三个引号（"""或'''都行，在Python中单引号和双引号没有区别）将注释内容引起来。

运算符

　　/：除运算，结果为浮点数（Python3为浮点数，Python2为整数（商））

　　//：模运算（在2.7中/和//都是模运算），得到两数相除的商

　　**：幂运算

　　*：乘运算，可以在序列中用这个符号定义序列，如lst = [3] * 4，lst为[3, 3, 3, 3]，不限于列表，字符串和元组等也可以使用

　　%：结果为两数相处的余数

　　+=、-=、*=等：Python中可以使用+=、-=等运算，但是不可以使用“i++”这种运算方式

　　>=或<=：大于（小于）或等于，Python中可以这样使用：if a <= xxx <= b: pass

　　位运算符：&（位与），|（位或），^（位异或：当两个对应的二进位不同时，结果为1），~（位取反：对数据的每个二进制位取反,即把1变为0,把0变为1），<<或>>（左移位或右移位）

　　注：

divmod(a, b)：返回a除以b的商和余数的元组(参数a和b不限于整数)


变量
变量类型：Python中的变量在声明时不需要指定其类型，它会根据你的赋值自动判断，其实变量本身是没有类型的，类型指的是这个变量引用的对象的类型；在某些编程规范中，有一种约定是变量名中不要加类型说明，比如：a_int = 3, b_list = [1, 2, 4], c_obj = C()。因为Python是动态语言，它的变量的类型是随时可变的。
变量删除：删除变量使用del，删除某个变量“del var”，删除多个变量“del var1, var2, var3”，对于变量的赋值和删除，变量只是对它的引用，删除时并不能直接删除其引用的的对象，删除的是这个变量本身。
垃圾回收：Python中的每个对象都有一个引用计数，当其引用计数为0时，即没有其他对象引用它了，Python回收机制就会回收它。其实由于Python中的垃圾回收机制，你并不能真正删除任何东西，由Python自动判断它“没有人用了”才会删除它。
变量赋值：多个变量赋同一个值，可以这样：a = b = c = 'python'；多个变量同时赋值，可以这样：a, b, c = 1, 2, 3； 对于变量值的交换，Python不需要中间变量，直接交换即可：var1, var2 = var2, var1。
global：作用域为整个文件的变量为全局变量，在函数中如果想要修改全局变量的值，则需要使用关键字global声明此变量为全局变量。
nonlocal：Python2中没有这个关键字，Python3中才有，如果想要修改外层非全局作用域中的变量时，需要使用关键字nonlocal声明此变量为局部变量。
　　注：当前版本的Python的关键字，使用keyword模块的kwlist查看即可。


数字类型
int：有符号整数（如果超出范围会自动转换为长整数）。

　　long：长整数（其范围取决于用户的虚拟内存），Python3中已没有此类型，只有int类型了。

　　float：浮点数，即小数。

　　complex：复数（虚数在数字末尾加字母j表示），比如：3+2j或complex(3, 2)。

　　bool：布尔值（1代表True，0代表False，True+False的结果为1），另外True和False在Python2中并不是关键字，在Python3中才列入了关键字。

序列
元组：是一个有序的不可变的序列，用括号()表示，其中的元素用逗号分隔：

字符串：字符串可以看成是由单一数据类型（字符）组成的不用逗号表示的元组，从序列的角度来看它们其实是一样的；
不可变：元组和其元素是不可变的，但是元素可以是可变类型，比如list，这个点可能有点绕，可以自己练习下加深理解；
有序：元组中的元素是有顺序的，可用下标或分片等方法对其进行读取的操作；
空元组和单元素元组：当元组中只有一个元素时，一定要加上逗号，不然Python不会将其当做元组处理的，只会当做一个普通的括号来处理，
当然，空元组可以直接使用()表示；
新元组：可以使用“+”对多个元组相加，返回一个新的元组；使用下标截取也会返回新的元组。
2、列表：是一个有序的可变的序列，使用中括号[]表示，元素之间用逗号分隔：

可变：列表本身和其中的元素都是可以进行“增删改查”的（如果元素类型允许）；
元素类型：一个列表的每个元素的数据类型可以不同，可以是任意数据类型；
有序：列表的元素之间是有顺序的，可用下标或分片等方法对其进行读或改的操作；
新列表：两个列表相加“+”会返回一个新的列表，包含两个列表的所有元素，并保有原有的顺序；对列表进行切片截取，返回的也是一个新的列表。
切片：切片使用形如list_[start:stop:step]的语句，start和stop表示下标，正数的下标表示正序（从左到右，起始数为0），负数的下标表示反序
（从右到左，起始数为-1），step为大于0的正整数时表示正序的切片步长，step为小于0的负整数时表示反序的切片步长；step一般不常用，默认为1，
当没有指明对应的start/stop时，默认为正序或反序的起始或结束下标。
3、集合：是一个无序的可变的序列，可以用大括号{}表示（元素用逗号隔开），也可以用set()定义：

无序：因为是无序的，不能用下标进行读取等操作；
集合运算：它和数学上的集合概念相同，不可以有相同的元素，元素无序，可以进行交集、并集和差集运算；
可变和不可变：每个元素都可以是不同的不可变类型，但集合本身是可变的。
4、字典：是一个无序的可变的序列，使用大括号{}表示，字典的元素使用键值对（key: value）表示，元素之间用逗号分隔:

新建字典：新建一个字典有几种特别的方法，比如：dict([('a', 'b'), (11, 22), (33, 'cc')])，{i: 'python %s' % i for i in range(3)}，
以及dict(a='aaa', b='bbb', c='ccc')（这种方式的key只能以参数名的形式定义，最后会自动转换成对应的字符串）；
可变：可以对字典进行“增删改查”操作；
key和value：字典中的元素（键值对）都是独立的，所有的key和value可以是不同数据类型，但是key必须是不可变的类型（不可以是列表等可变的类型），
且字典中每一个key都是唯一的，value则可以是任意数据类型；
无序：字典的元素（键值对）是无序的，不可用下标等有序序列的方法对其进行操作，只能通过元素的key来确定某一个元素（key是唯一的，value可以不唯一）。
注：

1、应用类型：列表，集合和字典属于可变类型，无论在什么地方对它的操作都是基于它本身的，所以需要小心使用，比如将一个列表传入函数后
（对于函数来说就是一个参数），如果函数有对它进行了修改操作，那么执行函数后，这个列表也就改变了，如果需要使用它的，但又不想影响到它本身
，可以使用深度拷贝（即copy模块的deepcopy()方法复制一个它拷贝）。

>>> ch = 'hello python!'
>>> ch[4]
'o'
>>> ch[:4]
'hell'
>>> ch[4:]
'o python!'

tup = (3, 'aa', {'a': 'b'})

>>> #列表
>>> lst = []
>>> lst = lst + [3, 'a', {'hello': 'python!'}]
>>> lst
[3, 'a', {'hello': 'python!'}]
>>> lst[:2]
[3, 'a']
>>> lst[2:]
[{'hello': 'python!'}]

>>> # 集合
>>> se = set([1, 2, 3])
>>> se
{1, 2, 3}
>>> se1 = set((2, 3, 3, 5, 6))
>>> se1
{2, 3, 5, 6}
>>> se & se1 #交集
{2, 3}
>>> se | se1 #并集
{1, 2, 3, 5, 6}
>>> se - se1 #差集
>>> #字典
>>> dct = {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
>>> dct[1] = [1, 2, 3, 4]
>>> dct
{1: [1, 2, 3, 4], 2: 'b', 3: 'c', 4: 'd'}
>>> dct[0] = 'hello'
>>> dct
{0: 'hello', 1: [1, 2, 3, 4], 2: 'b', 3: 'c', 4: 'd'}

条件和循环控制

if条件控制：基本结构为：if-elif-else，if和elif后面跟一个布尔表达式，若值为真，则执行对应子语句块，若值为假，则跳过此条件块。
while循环控制：while后面跟一个布尔表达式，若值为真，则执行其中的语句块，执行完后再一次判断布尔表达式的值和执行语句块，然后无限重复判断和执行，直到布尔表达式的值为假。可以使用continue结束本层循环的本次循环，而使用break则结束本层的整个循环。
for循环：for用于遍历一个可迭代对象，使用continue可以结束本层循环的本次循环，而使用break则结束本层的整个循环。
for和while的else：当for或while正常执行完后接着执行else中的内容，当for或while循环中使用break终止跳出循环后就不会执行else中的内容了。
简单语句组：if、while和for语句中的语句块如果只有一条简单的语句，这时候条件判断和字句块可以写在一行，比如：if a > 1: print(a)。

曾经缩进

>>> for i in range(5):  # break中断循环后就不会执行else中的内容了
    if i % 2 == 1:
        break
    print(i)
else:
    print('end')


函数

函数定义：Python中函数以def定义，用于实现某种功能，若是某段代码被多处使用，不妨将它定义成一个函数，或是它用于实现特定的功能，也可以将它定义成一个函数。
函数调用：一个函数func()，func为函数名，是这个函数引用（指向函数的地址）；而加上括号func()则表示执行这个函数。
函数作用域：在函数中定义的变量为局部变量，在函数体外不可引用它。
参数默认值：在定义函数时可以为参数指定默认值，比如func(a=0)，当没有传入该参数时，就会使用默认值，传参时如果没有指定参数名，则会按函数定义的顺序给参数赋值。
动态参数：使用*（元组）和**（字典）来定义函数的动态参数，动态参数有一个特别的写法“*args”和“**kwargs”，这两个写法合在一起就表示所有参数（“万能”的参数表示法），比如func(*var_tuple, **var_dict)，*var_tuple会将传进来的参数以元组的形式存在var_tuple中，**var_dict会将以特定形式传进来的参数以字典的形式存在var_dict中。
函数加载：在文件中函数不会被运行，Python只是去加载它，除非它被引用执行；
文件加载：Python文件有一个系统变量为“__name__”，默认值为当前文件名，但是被当作主文件执行的文件默认值为“__main__”，所以可以使用"if '__name' == '__main__':"作为文件的执行入口。
函数返回值：若是这个函数没有使用return指定这个函数的返回值，那么这个函数的返回值默认为None。
匿名函数：使用lambda来创建一个简单的匿名函数，语法为：lambda [arg1 [,arg2,.....argn]]: expression。lambda的主体只是一个简单的表达式，而不是复杂的代码块，函数返回的是表达式的值。
注：

参数传值：如果定义函数时既有普通参数，也有指定默认值的参数，那么普通参数必须在前面。
参数默认值：建议不要定义为可变类型，因为本质上说，参数也是函数的变量，如果是可变类型，那么多次调用后这个默认值可能就不再是你定义的初始值了，最直观的表现就是两次相同的调用，却返回了不同的值。
作用域：Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，

def func(a1,a2):
...     print(a1)
...     print(a2)


def func1(*args1,**args2):
...     print(args1)
...     print(args2)
...     print(args1[2])
...     print(args2['name'])
...
>>> res=func1(1,2,3,name='san',age=17)
(1, 2, 3)
{'age': 17, 'name': 'san'}
3
san


>>> def func2(a1,lst=[]):
...     lst.append(a1)
...     return lst
...
>>> list=func2(200,[])
>>> list
[200]


迭代器与生成器

异常处理
try...except...else...如果try语句中没有异常发生就会继续执行else中的语句，如果发生了异常就不会去执行else中的语句了。
try:
    # 此处为可能会发生异常错误的代码，如果发生异常将会抛出异常
    pass
except ValueError as e:
    # 捕捉指定的异常ValueError，并取别名为e
    # 如果捕捉到指定的异常（如ValueError），就会在进入这里进行处理
    pass
except (TypeError, NameError):
    # 可以一次指定捕获多个异常，多个异常一元组形式指定即可
    pass
except:
    # 没有指定异常时，表示捕捉所有异常
    # 如果抛出的异常在前面所有指定的异常都没有捕捉到，那么就会进入这里，
    pass
finally:
    # 无论是否发生异常都会执行此处代码
    pass

打印异常信息：可以使用trackback模块的format_exc()函数打印异常信息
抛出异常：使用“raise MyError”来抛出异常，并在except捕获这个异常
自定义异常：自定义的异常类，需要直接或间接继承Exception类，且一般以Error作为后缀