python学习笔记
1、基础知识
数据类型：integer(int) string (str) float (浮点数) long list dictionary tuple set boolean
变量=定义的变量可以不确定变量类型，只有使用的时候，才会确定变量类型（java 不同）
命名规范：1、不能使用数字开头，2、不能过长（一般可以根据内存长度确定，所以无限制） 3、不能包含除——之外的特殊字符
4、应该有意义（方便阅读） 5、用下划线分割多个单词的命名（可读性，不强制） 6、一般变量名全部小写，作为常量使用时，才全部大写
7、避免使用小写的l和大写 的o（可读性要求，不强制）
运算符：
支持加法、减法、乘法、除法、取反、绝对值、求幂（math方法有其他运算）
运算的优先级（按照数学元算进行）
逻辑
1、if else 真假的判断：integer 如果值为0，float值为0.0 long的值为0，string的值为"",list的值为[]，dictionary的值为｛｝，tuple的值为()则为False,其余为真
2、循环 for while
range()函数，生成数字。range(10)-----生成 [0,1,2,3,4,5,6,7,8,9]
range(1,4)--- 生成[1,2,3]
range(1,6,2)--生成[1,3,5]
for 循环 for i in range(3):
语句：
遍历列表 for cat in cats:
语句：
继续执行下一个遍历 continue 退出循环 break ；
for语句在执行完遍历之后。变量的值为最后一次遍历的值。
while 条件：
语句
无限循环需要在合适的位置设置break语句，不然，程序会一直执行下去；
3、顺序--------
字符串的使用
1、打印：print 语句会自动换行，如果不想换行，则在print语句结束时，输入","就不会换行了
2、string的方法 len()---自符串长度函数 str.upper-------把所有字母转换成大写；str.lower----全部小写
str.capitalize() 字符串首字母大写，其余小写 str.title()----首字母以及每个空格或者标点符号后的字母转换成大写，其他字母小写
str.is_alpha()-------------检查字符串是否全部有字母组成，str.is_digit()------检查字符串是否全部有数字组成
str.strip() 去掉字符串中开头或者结尾的某个值（没有参数则为空格，有参数则为该参数）
相同的方法---str.rstrip()---删除末尾的某个值 str.lstrip()------删除开头的某个值
字符串 的加法和乘法 支持，不支持除法和减法
str.count("x")---查找字符串中某个字符出现的次数
str.find("x")-----查找字符串中某个字符第一次出现的位置（没有该字符则返回-1）
str.replace("x","x1")---------用x1代替字符串中出现的所有的x
type(x)-----查看x的数据类型
获取输入和处理输出
获取输入：input()-------- 用于收集信息，用户输入的任何内容都将按照实际内容保存，比如输入5，则为int，
输入5.0 ，则保存为浮点数，输入"你好"，则保存为string型,不能保存没有用""括住的字符串
raw_input()----收集任何非数字的信息，例如输入5 则保存为str（"5"）;
密码的输入使用getpass模块 f=getpass() 会自动隐藏输入
使用format()函数或者%来格式化输出 例子
print("你好，s%",%())
print("你好｛｝,你多大了".format("李敏"))
list（列表）
含义：一系列事务的组合
1、创建列表 list=[]（空列表）
2、列表的第一项编号是0，及list[0]
方法：len（list）
list.count("value")列表中某个值的出现次数
list.index("value")列表中某个值的在泪飙中第一次出现的索引位置，如果没有该列表，则返回错误；
value in list ：某个值是否在列表中
以下方法会改变列表的内容：
list.append("value")：添加某个值到列表末尾
list.extend(list1):添加某个list到另一个list的末尾 支持"+"加法,列表支持乘法：list*n
list[index]='value'：修改某个值
list.remove("value"):删除某个值，其他项向前移动一位,没有则报错
list.insert(index,"value"):在指定位置添加一个列表项--该方法效率较低
list.reverse()--反转列表
list.sort()----按照字母顺序或者按照数字升序排列列表 https://www.cnblogs.com/sunny3312/archive/2017/01/07/6260472.html
list1==list2 :比较列表，如果完全相同，则为True，如果不完全相同则为False
切片操作：
[start:end:step]--start 其实索引，从0开始，-1结束 end ---结束索引 step---步长，为正，从左向右取值，为负，反向取值
切片的结果不包含结束索引的值
如下变种：[::]====默认所有
[:]===省略全部，所有值
[:3]===省略起始位置索引以及步长。取从开始到第三个的值
[::-1]===步长为1，从右向左取值。可以认为是反转原列表
list()函数====可以把tuple()或者list转换成list 实例：list((1,2))====[1,2];list([1,2])====[1,2]
函数：
创建函数：格式：def function_name(parameter1,parameter2):
code
code
return==================该语句是调用函数后会返回的值，如果缺少，返回值为null
函数的调用 ：function_name(); 如果直接输入函数的名称，实际得到的是函数的内存地址
函数可以设置别名，比如 abs函数可以设置为a=abs,a(-1)=>>>1;
参数的类别：默认参数====调用函数时可以不用传值的参数，默认参数必须在必选参数之后，不然函数不知道默认值是哪个参数的；
默认参数有多个时，调用函数会按照函数定义的顺序进行，也可以根据参数名=值 来进行判断
需要注意的一点：默认参数必须指向不变对象！不然会出现默认值改变的现象
可变参数====参数数量不固定，定义格式 def function_name(*params):
语句；
实例：
def calc(*number):
sum=0
for n in number:
sum=sum+n;
return sum
print calc(1) #>>>>1
print calc(1,3,4)#>>>>8
list=[1,2,3,4]
#print calc(list) >>>>unsupported operand type(s) for +: 'int' and 'list'
print calc(*list) #>>>>10
print calc(list[0],list[1],list[2],list[3]) #>>>>10
tuple=(2,3,4,5)
#print calc(tuple) #>>>>unsupported operand type(s) for +: 'int' and 'tuple'
print calc(*tuple) # >>>14
关键字参数====可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。
而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
定义格式：def person(name, age, **kw):
语句：
调用：person("Name","age"，city="北京")；
或者person("Name"，"age",**dict)====dict={"city":"beijing","grade"}
**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，
注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra
命名关键字参数==对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。
至于到底传入了哪些，就需要在函数内部通过kw检查。
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
实例：
def person(name, age, *, city, job):
print(name, age, city, job)
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
命名关键字参数必须传入参数名，这和位置参数不同。
如果没有传入参数名，调用将报错：TypeError: person() takes 2 positional arguments but 4 were given
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
实例：
def person(name, age, *args, city, job):
print(name, age, args, city, job)
使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。
如果缺少*，Python解释器将无法识别位置参数和命名关键字参数
参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
函数定义中，如果没有return则调用函数时，会返回NOne。
实例：
def product(*args):
sum=1
if len(args)>0:
for arg in args:
sum=sum*arg
return sum
else:
return ("请输入至少一个参数")
print(product(1,3,4))
print (product(*(2,3,4)))
print(product(4))
print(product())
高阶函数：
1、变量可以指向函数====例子：f=abs>>>>f(-10)=>>>10
2、函数名可以是变量 ===例子 abs=10>>>>abs(-10)>>>>typeError: 把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数而是指向一个整数10
定义：一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数；函数式编程就是指这种高度抽象的编程范式。
内建高阶函数：
1、map()====map()函数接收两个参数，一个是函数，一个是Iterable，
map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
实例：def f(x):
return x*x
list=[1,2,3,4,5,6]
list2=map(f,list) #f指的是函数对象本身，如果使用f(x),则会报错：x 未定义；
print list2
2、reduce()====reduce()函数把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，
reduce把结果继续和序列的下一个元素做累积计算；例如 加法和累乘；
实例：def chr2int(s):
return {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}[s]
def fn(x,y):
return 10*x+y
def str2int(s):
return reduce(fn,map(chr2int,s))
print (str2int("13456"))#>>>>13456(int类型的)
3、filter()=====filter()函数也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，
然后根据返回值是True还是False决定保留还是丢弃该元素。过滤函数。
实例：def not_empty(s):
return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))=====和filter(not_empty,['A',"",'B',None,'C',' '])没有区别
#注释布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
#filter()函数返回的是一个Iterator,所以需要使用list（）函数（是一个转换函数，而不是list[]）
完成计算并获取结果；https://www.cnblogs.com/spiritman/p/5158331.html迭代器的使用及特点。http://blog.csdn.net/u012671171/article/details/42169843 yield的讲解；
4、sorted()=====sorted()函数接受一个序列和key函数，返回按照规则的排序;
sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序;
ey指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序.如果反转，只要reverse=True 即可；
sorted()也是一个高阶函数。用sorted()排序的关键在于实现一个映射函数。
实例：>>> sorted([36, 5, -12, 9, -21], key=abs)
>>>[5, 9, -12, -21, 36]
异常处理：
第一种异常逻辑
try：
语句
except 错误名：
语句
except 错误名：
语句
else:
语句
流程：先执行 try 语句，如果出现了异常，则判断异常的类型，执行相应的except （不再执行else语句了），如果没有则抛出异常，停止执行程序，如果没有异常，
则执行else语句；
在except的错误语句中，需要把范围小的放在前面，范围大的放在后面，才会有效果，不然，后面的错误类型一直不会执行到；
变种：except可以不带错误名，只有语句，或者错误名可以是多个（Exception1[, Exception2[,...ExceptionN]]]）均可
第二种异常逻辑：
try:
语句
finally：
语句
不管try语句是否执行，都会执行finally语句
实例：
def f():
try:
print 1
return 1
except:
return 2
else:
print 3
return 3
finally:
print 0
#return 0
执行结果：结果为 1 0 1
说明try里面运行完之后return，阻挡了else的执行，但是并没有影响finally的执行。
借用Vamer文章的两句话：
“如果try中没有异常，那么except部分将跳过，执行else中的语句，但是如果try中有return，则结束运行。
finally是无论是否有异常，最后都要做的一些事情。”
这里补充一句，在含有return的情况下，并不会阻碍finally的执行。
第三种处理方式：
使用raise 触发异常
