Python学习笔记

1.python是脚本语言，脚本语言是电脑编程语言，开发者藉以编写出让电脑听命行事的程序。以简单的方式快速完成某些复杂的事情通常是创造脚本语言的重要原则。
2.IDLE是一个Python Shell，是一个通过键入文本与程序交互的途径。
3.在字符串中嵌入一个双引号：（1）利用反斜杠（\）对双引号转义 'Let\'s go !'（2）用单引号引起这个字符串 print('i "love" you') 
也可以用反斜杠对自身进行转义 str='C:\\now' 使用print()进行打印就会出现C:\now
4.快捷键Tab代表一个缩进，缩进类似于其他语言的()，使用要谨慎 缩进对Python的代码很重要
5.内置函数input：temp=input("***")  作用为首先打印***，并且要求用户输入，将输入值返回给temp
  内置函数int： guess=int(temp)  作用为将temp转为整型后赋值给guess
  内置函数len： len（变量） 计算变量的长度并返回
  内置函数list   生成一个列表  list(range(5))   [0,1,2，3,4]
7.Alt+p/n 调用上/下次输入的语句
8.BIF：Built-in functions 内置函数
9.通过dir(__builtins__) 可以调出所有的函数（小写的）
10.help(内置函数名) 获取帮助
11.区分大小写，只有当标识符已经赋值后才能在代码中使用，未赋值的标识符直接使用会导致运行时错误
12.Python不允许if条件中赋值
13.输入1到100之间的数（if 1<=num<=100）
14.Pathon不是把值存储在变量中，更像是把名字贴在值的上边
15.变量名可以包括字母、数字、下划线，但变量名不能以数字开头
16.原始字符串的使用非常简单，只需要在字符串前加一个英文字母r即可   str=r'C:\now'
17.如果希望得到长字符串，就需要三重引号字符串
18.type()获得关于类型的信息  isinstance(变量，数据类型)符合返回True 不符合返回False
19.while后边的条件只有以下内容会被看做假（注意冒号括号里边啥都没有，连空格都不要有）：False None 0 "" '' () [] {}
20.s为字符串
      s.isalnum() 所有字符都是数字或者字母，为真返回True，否则返回False
      s.isalpha() 所有字符都是字母，为真返回True，否则返回False
      s.isdigit() 所有字符都是数字，为真返回True，否则返回False
      s,islower() 所有字符都是小写，为真返回True，否则返回False
      s.isupper() 所有字符都是大写，为真返回True，否则返回False
      s.istitle() 所有字符都是首字母大写，为真返回True，否则返回False
      s.isspace() 所有字符都是空白字符，为真返回True，否则返回False
21.运算符：a+=3(a=a+3)  
           除法（/）返回浮点型  除法（//）类比于其他语言的除法返回整型   
           %（取余）  
           **（幂  3**2=9） 幂比左侧的一元运算符低 比右侧的一元运算符高
           比较运算符比逻辑运算符优先级高
           非零的数值都解释为True
           a<b<c  = ((a<b)and(b<c))
22.elif ：相当于C语言中的else if)
23.Pyhon可以有效避免“悬挂else”（强制使用缩进，在C语言中else为就近的if对应的）
24.三元操作符：small = x if x<y else y (条件为真把x赋值给small，否则将y赋值给small)
25.断言（assert）：当这个关键字后边的条件为假的时候，程序自动崩溃并抛出AssertionError的异常。一般来说可以用它在程序中置入检查点，当需要确保程序中的某个条件一定为真才能让程序正常工作。
26.for循环：
     for 目标 in 表达式： 
        循环体
    range():   range([start,] stop[, step=1])     []括起来的参数为可选参数，非必要参数
         step=1表示第三个参数的默认值为1
         这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列
27.成员资格运算符：in  用于检查一个值是否在序列中，如果在序列中返回True，否则返回False（列表中列表的元素不能进行判断，可以通过以下方式进行检验）
                          list5 = [123,['小甲鱼','牡丹'],456]
                              '小甲鱼' in list5[1]      True
                          list5[1][1] = '牡丹'(可以通过这种方式进行检索)       
                   not in  用于检查一个值是否在序列中，如果不在序列中返回True，否则返回False
28.列表名.append： 向列表添加元素（只能添加一个）
   列表名.extend：  以一个列表来扩展一个列表
   列表名.insert：  列表名.insert(int,str)   int为想加入的位置（从0开始计数）
   列表名[int]    获取列表相应位置的元素
   列表名.remove[str]： 删除相应元素
   列表名.count(str):   计算该元素在列表中出现的次数
   列表名.index(str,int1,int2)   找出该元素在范围之内的位置（如果不输入范围，则找出的是第一个出现的位置）
   列表名.reverse（）    将列表中元素位置颠倒，并返还给原列表
   列表名.sort（reverse）    将列表中元素按照一定顺序进行排序（默认为从小到大排序） (默认reverse=false，若改为True，则会按照从大到小的顺序排序)
   del 列表名.[int]:   删除相应位置的元素  del 列表名 删除整个列表
   列表名.pop(int)    删除第int个元素并返还给你
   列表分片（slice）：列表名[start:end]  又分出一个列表（不包含结束的位置元素），元列表不改变 列表名[:] 提取所有元素  列表名[start:end:int1]  int1为步长 步长可以为负，即向左走
29.列表比较：从第0个元素开始比较，一旦分出大小，后面的不在影响，和字符串ASCII类似
   列表拼接（+）：+号两边类型必须一致，如果想只添加一个用append或insert方法
   *： 复制了列表中的元素
30.正常下标： 0  1  2  3  4  5
   负数下标：-6 -5 -4 -3 -2 -1
31.元组内元素是不可改变的，不允许随意的插入和删除元素的，通过（）进行输入，允许切片操作 有小括号的不一定为元组，没有小括号的也不一定不是元组，所以‘,’才是关键
   通过切片操作对元组进行修改，删除
        temp=('小甲鱼','黑夜','米兔','小布丁')
        temp=temp[:2]+('怡景',)+temp[2:]
   del temp  可以删除整个元组
   +  *  >  <  in   and or not  都可以在元组中操作
32.Python开始next()方法改为_next_()
33.字符串的内置方法：见附件 
34.字符串的格式化
    "{0} love {1}.{2}".format("I","love","com")  {0}这一类的位置参数
    "{a} love {b}.{c}".format(a="I",b="love",c="com")   {a}这一类为关键字参数
    如果混合使用，位置参数必须在关键字参数之前
    如果想打印{}，用{{}}进行转义
    {00:.1f}   在替换域中 : 表示格式化符号中的开始  .1 表示四舍五入保留一位小数  f表示打印定点数（类似于浮点数）
    %c   格式化字符及其ASCII码
           '%c %c %c' % (97,98,99) (当有多个字符时，用元组装，否则易报错)    
           'a b c'
    %s   格式化字符串
           '%s' % 'I love FishC.com'
           'I love FishC.com'
    %d   格式化整数
           '%d + %d = %d' % (4,5,4+5)
           '4 + 5 = 9'
    %o   格式化无符号八进制数
           '%o' % 10
           '12'
    %x   格式化无符号十六进制数
           '%o' % 10
           'a'
    %X   格式化无符号十六进制数（大写）
           '%o' % 10
           'A'
    %f   格式化定点数，可指定小数点后的精度
           '%f' % 27.658
           '27.658000'
    %e   用科学计数法格式化定点数
           '%e' % 27.658
           '2.765800e+01'
    %E   作用同%e，用科学计数法格式化定点数
           '%E' % 27.658
           '2.765800E+01'
    %g   根据值的大小决定使用%f或%e
    %G   作用同%g，根据值的大小决定使用%f或%E
  格式化操作辅助命令
     m.n    m是显示的最小总宽度，n是小数点后的位数(宽度不够再前面加空格补全宽度)
           '%5.1f' % 27.658
           ' 27.7'
     -      用于左对齐
     +      在正数前面显示（+），在负数前面显示（-）
     #      在八进制数前面显示零（'0o'）,在十六进制数前面显示'0x'或'0X'
              '%#o' % 10
              '0o12'
     0      显示的数字前面填充'0'取代空格 
35.字符换转义字符含义
     \'     单引号
     \"     双引号
     \a     发出系统响铃声
     \b     退格符
     \n     换行符
     \t     横向制表符（TAB）
     \v     纵向制表符
     \r     回车符
     \f     换页符
     \o     八进制数代表的字符
     \x     十六进制数代表的字符
     \0     表示一个空字符
     \\     反斜杠
36.列表、元组和字符串的共同点
      都可以通过引索得到每一个元素
      默认索引值总是从0开始的
      可以通过分片的方法得到一个范围内的元素的集合
      有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
37.list（）  把一个可迭代对象转换为列表
   tuple([iterable]) 把一个可迭代对象转换为元组
   str(obj)   把obj对象转换为字符串
   len(obj)   返回obj的长度
   max/min（）    若为字符，则返回ASCII码最大(最小)对应的字符（要求数据类型必须统一）
   sum(iterable[,start=0])     返回序列iterable和可选参数start的总和
   stored()    从小到大排序进行
   reversed（） 通过list（reversed（numbers））  将numbers中元素倒置
   enumerate()  通过list（enumerate（numbers））  将列表元素变为元组，并在元组里每一元素前加上了索引值
   zip（）      返回由各个元素序列组成的元组
                a=[1,2,3,4,5,6,7,8]
                b=[4,5,6,7,8]
                list(zip(a,b))
                  [(1,4),(2,5),(3,6),(4,7),(5,8)]
38.形参和实参：函数定义过程中的变量叫做形参，调用函数时传进的变量叫做实参
39.函数文档：在函数定义的最开有部分，用不记名字符串表示
     通过   函数名.__doc__  来调用函数文档（系统的特殊属性都是__开始__结束的）
     ''为函数文档   #之后的为注释
40.关键字参数
    def say(name,words):
    print(name+'说了'+words)
   
    在调用时 say(words='吃屎',name='他')（存在关键字参数时就不按照正常顺序进行索引匹配）
41.默认参数：定义默认值的参数
    def say(name='他',words='吃屎'):
    print(name+'说了'+words)
   在调用时若为对参数进行赋值，则返回的调用默认参数的结果，若调用时给出了新的参数，则返回新参数输入的结果
42.收集参数：（若后面还有其他类型参数，在调用时需要使用关键字参数进行调用，否则会被默认为收集参数）
     def test(*params):
      print('参数的长度是：',len(params));
        print('第二个参数是：',params[1]);


     test(1,'小甲鱼',2,3,4.52,6)
43.函数：有返回值（动态的确定返回值类型）
   过程：是简单、特殊并且没有返回值的（python只有函数，没有过程）
44.局部变量（Local Variable）:在函数里定义的参数、变量，出了函数都是无效的
   全局变量（Global Variable）：在函数外定义的参数、变量，拥有更大的作用域（在函数内部对全局变量进行修改时，python会重新建立一个局部变量，变量名和原来的一致）（尽量少使用全局变量）
45.global关键字：若想在函数内部对全局变量进行修改，需要提前使用关键字global对全局变量定义一下
46.内嵌函数（内部函数）：只有在外部函数被调用时，才能调用它所包含的内层函数，否则内层函数不会被调用（在使用嵌套函数时要注意的问题就是作用域的问题）
47.闭包：如果在一个内部函数里，对在外部作用域的变量进行引用，这个内部函数就是一个闭包（在嵌套的函数中，如果希望在内部函数修改外部函数的局部变量，可以使用nonlocal关键字）
48.lambda语句：lambda 原函数的参数：原函数的返回值
lambda x : 2*x+1              g = lambda x,y : x + y
g = lambda x : 2*x+1          g(3,4)
g(5)                          7
        11
   Python写一些执行脚本时，使用lambda就可以省下定义函数过程，不需要专门定义一个函数然后再写调用，使用lambda就可以使得代码更加精简
     使用lambda不需要考虑命名的问题
     简化代码的可读性
49.filter():过滤器   
     filter(function or None, iterable)(iterable为可迭代的数据)：如果第一个参数为函数，将第二个可迭代数据里的每一个元素作为函数的参数进行计算，把返回为True的值筛选出来，并成一个列表；如果第一个参数为None，则将第二个可迭代数据为True的值筛选出来
list(filter(None, [1, 0, False, True]))
[1, True]
def odd(x):
return x % 2
temp = range(10)
        list(filter(odd,temp))
[1,3,5,7,9] 
50.map():映射
    map():将序列中每一个元素作为函数的参数进行运算加工，直到可迭代数列的每一个元素都加工完毕，返回所有加工后的元素，构成一个新数列
list(map(lambda x : x * 2, range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
51.当程序陷入死循环，用Ctrl+c 强制停止
52.递归：有调用函数自身的行为和一个正确的返回条件
53.三引号字符串不赋值的情况下，通常当做跨行注释使用
54.迭代：是重复反馈过程的活动，其目的是为了接近并到达所需的目标或结果。每一次对过程的重复被称为一次“迭代”，而每一次迭代得到的结果会被用来作为下一次迭代的初始值
55.斐波那契数列的迭代实现：1,1,2,3,5,8,13,21,34,55,89,144
56.字典是映射类型： 字典名={ key : value }（也可以通过列表和元组实现，只要有对应关系即可，或用关键字参数实现对应关系）
dict1={'李宁':'一切皆有可能','耐克':'Just do it','阿迪达斯':'Impossible is nothing','鱼C工作室':'让编程改变世界'}
        print('鱼C工作室的口号是：',dict1['鱼C工作室'])
57.dict1.fromkeys(s[,v])   创建并返回一个新的字典 s为字典的键值，v为value（若v不提供，则是默认的None）函数是将v赋给所有的s，而不存在对应赋值
   dict1.keys()    返回键值
   dict1.value()   返回value
   dict1.items()   返回项（以元组的形式）
   dict1.get(keys,str) 返回keys对应的value，若对应的键值不在字典中，则返回str，可默认没有str
   dict1.clear()   清空字典（dict1={}）
   dict1.copy()    浅拷贝（拷贝之后id地址一样）
   dict1.pop(key)  在字典中弹出对应的项
   dict1.popitem() 在字典中随机弹出一个项
   dict1.setdefault(key)   作用和get（）类似，但如果对应键值不存在，则会自动添加key，对应的value为None
   dict1.update(dict2)     用字典dict2来填充（更新）dict1
   dict1[temp1]=input('请输入用户联系电话：')#可以这样直接修改键值对应的值dict1[temp1]=input('请输入用户联系电话：')dict1[temp1]=input('请输入用户联系电话：'
58.当试图检查一个键值是否在字典中，可以用成员资格操作符（in  not in）来检查   31 in dict1
（Python调用内部的散列函数，将键（Key）作为参数进行转换，得到一个唯一的地址，然后将值（Value）存放到该地址中，对于Python来说，键（Key）必须是可哈希的，也就是可以通过散列函数计算出唯一地址的，因此变量、列表、字典、集合这些可变的都不能作为键（Key）使用）
59.集合(set)：用大括号括起一堆数字，之间不存在映射关系（集合几乎所有的作用就是确保里边包含的元素的唯一性，集合跟字典的存储方式是一样的，利用哈希函数计算，相同的元素得到的哈希值（存放地址）是相同的，所以在集合中所有相同的元素都会覆盖掉）
集合里的元素都具有唯一性，重复的数据会被删掉
集合里的元素是无序的，所以不支持索引
        可以用成员资格操作符（in  not in）来检查
        set1.add()
        set1.remove()
        frozenset()  定义了不可改变的集合，不能进行修改
60.文件：open(file,mode='r')（Windows在路径名中既可以接受斜线（/）也可以接受反斜线（\），不过如果使用反斜线作为路径名的分隔符的话，要注意使用双反斜线进行转义）（open()函数默认的打开方式是'rt'，即可读、文本的模式打开）
'r'    以只读方式打开文件（默认）
'w'    以写入的方式打开文件，会覆盖已存在的文件
  'x'    如果文件已存在，使用此模式打开将会引发异常
'a'    以写入模式打开，如果文件存在，则会在末尾追加写入
'b'    以二进制模式打开文件
't'    以文本模式打开（默认）
'+'    可读写模式（可添加到其他模式中使用）
'U'    通用换行符支持
61.文件对象方法（可以通过 list(f) 将一个文件对象（f）中的数据存放进列表中）
f.close()             关闭文件
f.read(size=-1)         从文件读取size个字符，当为给定size或给定负值时，读取剩余的所有字符，然后作为字符串返回
f.readline([size=-1])            从文件中读取并返回一行（包括行结束符），如果有size有定义则返回size个字符
f.write(str)            将字符串str写入文件
f.writelines(seq)       向文件写入字符串序列seq，seq应该是一个返回字符串的可迭代对象
f.seek(offset,from)     在文件中移动文件指针，从from（0代表文件起始位置，1代表当前位置，2代表文件末尾）偏移offset个字节
f.tell()                返回当前在文件中的位置
     文件只有在调用f.close()之后才会更新
62.模块：包含所有你定义的函数和变量的文件（后缀为.py），模块可以被别的程序引入，以使用该模块中的函数等功能
在试图调用randint()函数之前，需要先调用模块即：
import random
secret = random.randint(1,10)
     OS：（Operating System）:操作系统，由于操作系统底层对于文件系统的访问工作原理是不一样的，因此可能就要针对不用的系统来考虑使用哪些文件系统模块
63.绝对路径=盘名：\\+相对路径
64.挂载点：c盘、d盘等
65.pickle模块（存放、pickling）：可以把所有python的对象转化为二进制的形式进行存放（当要保存列表、字典、集合甚至是类这样复杂的数据类型）
   unpickle（读取）：从二进制的形式转化为对象的过程
import pickle
my_list = [1,2,'小甲鱼',['another list']]
pickle_file = open('my_list.pkl','wb')#文件名'my_list'可以重新取名，.pkl只是为了提醒，可以为任意后缀名  'wb'为‘写入’的形式
pickle.dump(my_list,pickle_file)#将my_list放入到pick_file中
pickle_file.close()


pickle_file = open('my_list.pkl','rb')#'rb'为‘读取’的形式
my_list2 = pickle.load(pickle_file)#用load方式进行读取
print(my_list2)
66.try:
检测范围
   except Exceptiong[as reason]:
出现异常（Exception）后的处理代码
   
   try:
    f = open('文件.txt')#当文件.txt不存在时，系统不会报错
    print(f.read())
        f.close()
   except OSError:#FileNotFoundError异常属于OSError异常
        print('文件出错！')


   -->文件出错！
================================================================
   try:
    f = open('文件.txt')#当文件.txt不存在时，系统不会报错
    print(f.read())
        f.close()
   except OSError as reason:
        print('文件出错！\n错误的原因是：'+str(reason))


   -->文件出错！
      错误的原因是：[Errno 2] No such file or directory: '文件.txt'
=======================================================================
   try:
        sum = 1 + '1'
    f = open('文件.txt')#当文件.txt不存在时，系统不会报错
    print(f.read())
        f.close()
   except OSError as reason:
        print('文件出错！\n错误的原因是：'+str(reason))
   except TypeError as reason:
        print('类型出错！\n错误的原因是：'+str(reason))
   -->类型出错！
      错误的原因是：unsupported operand type(s) for +: 'int' and 'str' (因为首先遇到类型出错，所以直接抛出异常，程序不会再继续执行)（当抛出的异常不属于OSError异常和TypeError异常时，程序会正常报错）（当后面不加 as reason 时，系统遇到错误便不再报错，而是执行出现异常（Exception）后的处理代码，但并不推荐这种方式）(因为它会隐藏所有程序员并未想到并且未做好准备处理的错误)
==========================================================================
也可以用
   try:
        sum = 1 + '1'
    f = open('文件.txt')#当文件.txt不存在时，系统不会报错
    print(f.read())
        f.close()
   except (OSError, TypeError):
        print('文件出错!')
============================================================================
   try:
检测范围
   except Exceptiong[as reason]:
出现异常（Exception）后的处理代码
   finally:
        无论如何都会被执行的代码


   try:
    f = open('文件.txt','w')#当文件.txt不存在时，系统不会报错
    print(f.write('文件'))
        sum = 1 + '1'
   except (OSError, TypeError):
        print('文件出错!')
   finally:
        f.close()#这样即使在后面的语句出错，也会将更改后的文件写入到硬盘中
67.可以通过raise语句引发异常
raise ZeroDivisionError('除数为零的异常')#会抛出一个除零的异常，后面的str对异常进行解释
68.丰富的else语句
        if 条件:
代码
else：
代码
==============================================================================================================
      只有在while语句和for语句循环结束之后才会执行，如果中间有break则会跳出循环，else中的语句不会执行
def showMaxFactor(num):
count = num // 2
while count > 1:
if num % count == 0:
print('%d最大的约数是%d' % (num, count))
break
count -= 1
else:
print('%d是素数！' % num)
num = int(input('请输入一个数：'))
showMaxFaxtor(num)
===============================================================================================================
     当try语句中，没有抛出任何异常时，才会执行else语句中的内容，当抛出异常时就不执行
try:
int('abc')
except ValueError as reason:
print('出错了！'+str(reason))
else:
print('没有任何异常！')
69.简洁的with语句
try:
f=open('data.txt','w') 
for each_line in f:
print(each_line)
except OSError as reason:
print('出错了：'+str(reason))
finally:
f.close()#但是如果没有data.txt文件，则不会打开，所以最后这个close()会报错


try:
with open('data.txt','w') as f:#使用with语句，就会关注文件是否被用到，如果用到了，就会自动调用close()语句
for each_line in f:
print(each_line)
except OSError as reason:
print('出错了：'+str(reason))
    wwith语句处理多个项目的时候，可以用逗号隔开写成一条语句
with A() as a, B() as b:
suite
70.列表的排序方法叫list.sort()，sorted()是BIF
71.Python认为在内部函数的x是局部变量的时候，外部函数的x就被屏蔽了起来，在python3之前没有直接的解决方法，只能间接地通过容器类型来存放，因为容器类型不是放在栈里，所以不会被屏蔽。在python3之后，如果希望在内部函数里可以修改外部函数里的局部变量的值，可以通过关键字nonlocal：
def my_fun1():
x=5
def my_fun2():
nonlocal x
x*=x
return x
return my_fun2()
my_fun1()
72.对象 = 属性 + 方法 （类名约定以大写字母开头）
    对象封装了属性和方法
    封装：对外部隐藏对象的工作细节
    继承：子类自动共享父类之间数据和方法的机制 class MyList(list)  #继承了list
    多态：不同对象对同一方法响应不同的行动
class A:
def fun(self):
print('我是小A...')
class B:
def fun(self):
print('我是小B...')
a=A()
b=B()
a.fun()


--> 我是小A...

b.fun()


--> 我是小B...
73.OOA:面向对象分析
   OOD:面向对象设计
   OOP:面向对象编程
74.self：由同一个类可以生成无数的对象，当一个对象的方法被调用的时候，对象会将自身作为第一个参数传给self参数（类似于this）
clss Ball:#在类的定义时，要将self作为第一个参数写入
def setName(self,name):
self.name = name
def kick(self):
print('我叫%s' % self.name)


a = Ball()
a.setName('球A')
b = Ball()
b.setName('球B')


a.kick()
-->我叫球A


b.kick()
-->我叫球B
75._init_(self)#只要实例化一个对象的时候，这个方法就会在对象被创建的时候被调用
class Ball:
def _init_(self,name):
self.name = name
def kick(self):
print('我叫%s' % self.name)


b=Ball('球B')
b.kick()
-->我叫球B
76.公有和私有（name mangling 名字改变，名字重整）：在Python中定义私有变量只需要在变量名或函数名前加上“_”两个下划线，那么这个函数或变量就会为私有的了
class Person:
__name = '小甲鱼'


p = Person()
p.__name()#会报错，私有变量或者函数只能从内部进行调用，在外部被隐藏了


class Person:
__name = '小甲鱼'
def getName(self):
return self.__name


p = Person()
p.getName()

-->'小甲鱼'
    实际上，Pyhton只是将“__变量名”改为“_类名_变量名”
p._Person_name
-->'小甲鱼'
77.如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法和属性
78.class Fish:
def __init__(self):
self.x=r.randint(0,10)
self.y=r.randint(0,10)
   class Shark(Fish):
def __init(self):
self.hungry=True
    由于子类继承父类，对__init__函数进行了重写，所以子类的初始化坐标不存在
    (1)调用未绑定的父类方法：对上面的子类代码进行修改
   class Shark(Fish):
def __init(self):
Fish.__init__(self)#此时调用了父类的方法，但self为子类的实例对象，所以称为未绑定的父类方法，它给的是子类的实例对象，相当于Fish.__init__(shark)
self.hungry=True
    (2)使用super函数：
   class Shark(Fish):
def __init(self):
super().__init__()#不用给定基类的名字，会自动找出基类对应的方法，当需要修改时，只需要修改继承的父类就可以了
self.hungry=True
79.多重继承：同时继承多个父类的属性和方法（但是很容易代码混乱）
class Base1:
def fool(self):
print('我是Base1')
class Base2:
def foo2(self):
print('我是Base2')
class C(Base1,Base2):
pass


c=C()
c.foo1()
c.foo2()


多重继承容易导致钻石继承问题，即实例化D类后可能发现A被前后进了两次，为解决这个问题，python使用了“方法解析顺序（MRO）”，还用了C3算法
MRO顺序：在避免同一类被调用多次的前提下，使用广度优先和从左到右的原则去寻找需要的属性和方法，在继承体系中，C3算法确保同一个类只会被搜寻一次。可以通过使用（类名.__mro__获得MRO顺序）（当然直接使用super函数也可以解决这一类问题）
80.组合：把几个不是有继承关系的类放到一起
class Turtle:
def __init__(self,x):
self.num=x
class Fish:
def __init__(self,x):
self.num=x
class Pool:
def __init__(self,x,y):
self.turtle=Turtle(x)
self.fish=Fish(y)

def print_num(self):
print("水池里共有王八%d只，小鱼%d条" % （self.turtle.num,self.fish.num）)
89.Mixin:将多个类中的功能单元进行组合利用的方式。Mixin并不作为任何类的基类，也不关心与什么类一起使用，而是在运行时动态的同其他零散的类一起组合使用
    好处：可以在不修改任何源代码的情况下，对已有的类进行扩展
 可以保证组件的划分
 可以根据需要，使用已有的功能进行组合，来实现“新”类
 很好的避免了类继承的局限性，因为新的业务需要可能就需要创建新的子类
__bases__:给类A添加类B的特性
class A:
def get_a(self):
print 'a'
class B:0.0
def get_b(self):
print 'b'
A.__bases__+=(B,)
a.get_b()
因此多继承也可以以这种方式实现：
C.__bases__+=(A,B,)
90.类，类对象和实例对象（如果属性的名字和方法相同，会将方法覆盖掉）（不要试图在一个类里边定义出所有能想到的特性和方法，应该利用继承和组合机制来进行扩展）（用不同的词性命名，如属性名用名词，方法名用动词）
91.绑定：（Python严格要求方法需要有实例才能被调用）
92.类相关的BIF
issubclass(class,classinfo) 如果class为classinfo的子类，则返回True（非严格检查，即自身会被认为是自身的子类）（classinfo可以是类对象组成的元组，只要class与其中任何一个候选类的子类，则会返回True）
isinstance（object,classinfo） 检查一个实类对象是否属于一个类的（classinfo可以是类对象组成的元组）（如果第一个参数不是对象，则永远返回False）（如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常）
hasattr（object,name） 测试对象里是否有指定的属性（object为对象，name为属性名（需要用字符串形式表示））
getattr(object,name[,default]) 返回对象指定属性值，若属性不存在，则会打印default参数（default被设置的情况）,否则会抛异常AttributeError
setattr(object,name,value)  会设置对象中指定属性的值，若属性不存在，则会新建一个新的属性，并赋值（name要以字符串形式进行输入）
delattr(object,name) 会删除对象中指定属性，若属性不存在，则会抛异常AttributeError

property(fget=None, fset=None, fde1=None, doc=None)  设置一个属性，作用是设置定义好的属性将x传入写好的方法


class C:
def __int__(self,size=10):
self.size=size
def getSize(self):
return self.size
def setSize(self,value):
self.size=value
def delSize(self):
del self.size
x=property(getSize, setSize, delSize)


c1=C
c1,getSize()
-->10

c1.x
-->10
c1.x=18
c1.x
-->18


c1.size
-->18

c1.getSize()
-->18


del c1.x
c1.size
-->AttributeError: 'C' object has no attribute 'size'
93.修饰符：可以抽离出大量函数中与函数功能本身无关的雷同的代码并继续重用（为已经存在的对象添加额外的功能）
import time
 
def timeslong(func):
    def call():
        start = time.clock()
        print("It's time starting ! ")
        func()
        print("It's time ending ! ")
        end = time.clock()
        return "It's used : %s ." % (end - start)
    return call


@timeslong
def f():
    y = 0
    for i in range(10):
        y = y + i + 1
        print(y)
    return y


print(f())#（这样就不用在函数内部在进行嵌入函数了，通过@timeslong对其进行修饰达到目的）


class timeslong(object):
def __init__(self,func):
    self.f = func
def __call__(self):
    start = time.clock()
    print("It's time starting ! ")
    self.f()
    print("It's time ending ! ")
    end = time.clock()
    return "It's used : %s ." % (end - start)


@timeslong
def f():
    y = 0
    for i in range(10):
        y = y + i + 1
        print(y)
    return y


print(f())#（可以通过类进行使用，共享该类）
    内置的修饰符有三个，分别是staticmethod、classmethod和property，作用分别是把类中定义的实例方法变成静态方法、类方法和雷属性。由于模块里可以定义函数，所以静态方法和类方法的用处并不是太多。


class Hello(object):
def __init__:
        ...
 
@classmethod
def print_hello(cls):
print("Hello")#（classmethod修饰之后，print_hello()就变成了类方法，可以直接通过Hello.print_hello()调用，而无需绑定实例对象了）
94.魔法方法：（总是被双下划线包围，例如__init__）（魔法方法是面向对象的Python的一切，魔法方法的“魔力”体现在它们总能够在适当的时候被自动调用）
__init__(self[, ...])(相当于其他编程语言的构造方法，类在实例化对象的时候首先会被调用的方法)
    当继承一个不可变类型的时候，又需要对其修改的时候，调用__new__(cls[, ...])
class CapStr(str):#将输入的字符串全都变成大写
def __new__(cls,string):
string = string.upper()
return str.__new__(cls,string)#由于继承的类是str（字符串）（不可修改的类），所以在实例化之前需要对其进行重写
__del__(self)#当对象将要被销毁的时候，该方法就会被自动的调用（当对象生成之后，所有对它的引用都被del之后，才会启动垃圾回收机制，才会自动调用__del__()）


class New_int(int):
def __add__(self,other):#（定义加法的行为，当程序中出现'+'的时候，自动调用该方法）
return int.__sub__(self,other)
def __sub__(self,other):
return int.__add__(self,other)


a=New_int(3)
b=New_int(5)
a+b
--> -2
95.__radd__(self,other)  定义加法的行为，当左操作数不支持相应的操作时被调用。
class Nint(int0:
def __radd__(self,other):
return int.__sub__(self,other)


a = Nint(5)
b = Nint(3)
a + b   #由于a存在add（）方法，所以不会调用__radd__()方法，所以正常执行 5+3
--> 8
1 + b   #由于1不存在add()方法，即左操作数不支持相应的操作，所以b会调用__radd__()方
--> 2   #法，当b.__radd__()被调用时，b为self，1为other
96.__str__():
class A():
def __str__(self):
return '小甲鱼是帅哥'


a = A()
print(a)


-->小甲鱼是帅哥  #当被打印需要字符串输出的时候方法被调用
    __repr__():
class B():
def __repr__(self):
return '小甲鱼是帅哥'


b = B():
b


-->小甲鱼是帅哥
97.__getattr__(self, name)    定义当用户试图获取一个不存在的属性时的行为
   __getattrbute__(self, name)   定义当该类的属性被访问时的行为
   __setattr__(self, name, value)   定义当一个属性被设置时的行为
   __delattr__(self, name)    定义当一个属性被删除时的行为


class C:
def __getattribute__(self, name):
print('getattribute')
return super().__getattribute__(name)
def __getattr__(self, namae):
print('setattr')
def __setattr__(self, name, value):
print('setattr')
super().__setattr__(name, value)
def __delattr__(self, name):
print('delattr')
super().__delattr__(name)


c = C()
c.x
--> getattribute
--> getattr

c.x = 1
--> setattr


c.x
--> getattribute
--> 1
 
del c.x
--> delattr
98.__dict__(特殊属性)：以字典的形式显示出当前对象的所有属性和对应的值
99.描述符：是将某种特殊类型的类的实例指派给另一个类的属性
特殊类型指至少实现以下三个方法中的一个：
__get__(self, instance, owner)      用于访问属性，它返回属性的值
__set__(self, instance, value)      将在属性分配操作中调用，不返回任何内容
__delete__(self, instance)          控制删除操作，不返回任何内容 

class MyDecriptor:
def __get__(self, instance, owner):
print('getting...', self, instance, owner)
def __set__(self, instance, value):
print('setting...', self, instance, value)
def __delete__(self, instance):
print('deleting...', self, instance)

class Test:
x = MyDecriptor()   #（MyDecriptor是实现了三个特殊类型的方法的类，实例化将其指派给Test类中的属性值x，所以MyDecriptor()为x的描述符）


test = Test()  
test.x  #(当访问属性时，__get__()被调用，self为描述符类MyDecriptor本身的实例，instance为拥有者的类的实例test，owner为拥有者本身Test)
--> getting... <__main__.MyDecriptor object at 0x000001F3B6BCBCC0> <__main__.Test object at 0x000001F3B6B26DA0> <class '__main__.Test'>


test
--> <__main__.Test object at 0x000001F3B6B26DA0>

Test
--> <class '__main__.Test'>


test.x = 'X-men'
--> setting... <__main__.MyDecriptor object at 0x000001F3B6BCBCC0> <__main__.Test object at 0x000001F3B6B26DA0> X-men
del test.x
--> deleting... <__main__.MyDecriptor object at 0x000001F3B6BCBCC0> <__main__.Test object at 0x000001F3B6B26DA0>
100.property() 实际上就是一个描述符类
class Myproperty：
def __init__(self, fget = None, fset = None, fdel = None):
self.fget = fget
self.fset = fset
self.fdel = fdel

def __get__(self, instance, owner):
return self.fget(instance)


def __set__(self, instance, owner):
self.fset(instance, value) 


def __delete__ (self, instance):
self.fdel(self, instance):
101.协议（Protocols）与其他编程语言中的借口很相似，规定了哪些方法必须要定义，在Python中，协议更像是一种指南
102.容器类型的协议：
    如果说你希望定制的容器是不可变的话，只需要定义__len__()和__getitem__()方法
    如果希望定制的容器是可变的话，除了__len__()和__getitem__()方法，还需要定义__setitem__()和__delitem__()两个方法
103.iter() 和 next()                        __iter__()  和  __next__()
string = 'Fish'                     class Fibs:
def __init__(self):
it = iter(string)                       self.a = 0
self.b = 1
next(it) def __iter__(self):
--> 'F' return self


next(it) def __next__(self):
--> 'i' self.a = self.b
self.b = self.a + self.b
next(it) return self.a
--> 's'


next(it)
--> 'h'


next(it)
--> 会抛出StopIteration的异常
class Fibs:
def __init__(self, n):#通过给定一个参数n，可以限制范围，防止其无限迭代下去
self.a = 0
self.b = 1
self.n = n
def __iter__(self):
return self


def __next__(self):
self.a = self.b
self.b = self.a + self.b
if self.a > self.n:
raise StopIteration
return self.a
104.生成器：（协同程序是指可以运行的独立函数调用，函数可以暂停或者挂起，并在需要的时候从程序离开的地方继续活着重新开始）（一旦函数里有yield语句，则这个函数就被定义为生成器，函数会暂停在yield语句处，并返回后面的参数，下一次执行在下个yield语句）（for循环会自动的调用next（）方法和探测StopIteration结束））
>>> def myGen():
print('生成器被执行！')
yield 1
yield 2



>>> myG = myGen()
>>> next(myG)
生成器被执行！
1
>>> next(myG)
2
>>> next(myG)
Traceback (most recent call last):
  File "<pyshell#73>", line 1, in <module>
    next(myG)
StopIteration
105. 容器 -> 数据的封装
     函数 -> 语句的封装
     类   -> 方法和属性的封装
     模块 -> 模块就是程序
106.导入模块：
第一种：import 模块名
第二种：from 模块名 import 函数名
第三种：import 模块名 as 新名字
107.if __name__ == '__main__'（如果在主程序中使用__name__变量，得到的是__main__，如果是模块中使用__name__变量，得到的就是模块的名字）（如果此时__name__变量的值为模块名，证明该模块被导入，就不用调用测试函数了）


def c2f(cel):
    fah = cel * 1.8 + 32
    return fah


def f2c(fah):
    cel = (fah - 32) / 1.8
    return cel


def test():
    print('测试：0摄氏度 = %.2f华氏度' % c2f(0));
    print('测试：0华氏度 = %.2f华氏度' % f2c(0));


if __name__ == '__main__':#如果此时的__name__变量为__main__,证明该模块为主函数，则测试函数需要被调用
    test()                #如果此时的__name__变量为函数名（tc）,证明该模块被调用，则测试函数不会被调用


108.搜索路径（C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\lib\\site-packages）（这个文件夹是用来存放模块的）
     可以通过（import sys    sys.path.append('路径')）进行添加路径
109.包（package）：
（1）创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字
（2）在文件夹中创建一个__init__.py的模块文件，内容可以为空
（3）导入包的模块，通过   包名.模块名  就可以进行导入
110.PEP是Python Enhancement Proposals的缩写，翻译过来就是Python增强建议书的意思。它是用来规范与定义Pyhton的各种加强与延伸功能的技术规格、好让Python开发社区能有共同遵循的依据。每个PEP都有一个唯一的编号，这个编号一旦给定了就不会在改变。
111.快速掌握一个模块的用法：
（1）import timeit # 调用模块名
（2）timeit.__doc__ # 可以查看这个模块的简介  可以通过print(timeit.__doc__)将其打印出来，方便阅读
（3）dir(timeit) #可以知道模块定义了哪些变量、函数和类
（4）timeit.__all__ #可以过滤出模块可以供外界调用的所有信息（不是所有的模块都有__all__属性）（如果有__all__属性，可以通过 from timeit import* 将其导入到命名空间，只有__all__属性里的名字才会被导入）
（5）timeit.__file__  # 可以指明该模块源代码所在的位置
112.论一只爬虫的自我修养.Python如何访问互联网：
URL的一般格式为（带方括号[]的为可选项）：
protocol://hostname[:port]/path/[:parameters][?query]#fragment
URL由三部分组成：
第一部分是协议：http, https, ftp, file, ed2k...
第二部分是存放资源的服务器的域名系统或IP地址（有时候要包含端口号，各种传输协议都有默认的端口号，如http的默认端口为80）
第三部分是资源的具体地址，如目录或文件名等
import urllib.request
response = urllib.request.urlopen('heet://www.baidu.com') #从服务器上获取网页的过程
htm1 = response.read()
htm1 = htm1.decode('utf-8')#网页是utf-8的解码形式
print(htm1)
113.在客户端和服务器之间进行请求响应的时候，两种最常用的方法（GET、POST）
GET：是指从服务器请求获得数据
POST：是向指定服务器提交被处理的数据
114.修改headers进行隐藏代码：
通过Request的headers参数修改
通过Request.add_header()方法修改
115.代理：将需要访问的网址传给代理，代理帮忙访问，将看到的内容全部传回
（1）参数是一个字典{'类型' : '代理ip:端口号'}
proxy_support = urllib.request.ProxyHandler({})
（2）定制、创建一个oppener()
oppener = urllib.request.build_opener(proxy_support)
（3.1）安装oppener
urllib.request.install_opener(opener)
（3.2）调用opener（不想替换掉默认的opener，只是临时调用）
opener.open(url)
116.正则表达式：
search()方法用于在字符串中搜索正则表达式模式第一次出现的位置(第一个参数正则表达式模式，也就是搜索规则，需要使用r+str)（起始位置从零开始，如果没有搜索到则什么都不会返回）
(.)代表通配符，可以匹配除了换行符以外的任意字符（通过\. 可以匹配（.））（元字符：字符本身代表其他含义，有其他能力的字符。\可以剥夺元字符的特殊能力）（\可以使普通字符拥有特殊能力（\d  可以匹配任何数字））
[]可以创建字符类：只要匹配字符类中的任意字符，都属于匹配（在字符类中加-代表范围，a-z代表所有的小写字母）[^5]（会匹配除了‘5’之外的任何字符）
{int}代表{}前面的字符重复的次数，{int1, int2}}表示重复次数的范围
r'[01]\d\d|2[0-4]\d'|25[0-5]，代表匹配的数字在0-255之间（由于匹配的是字符串，所以当百位数字是0或者1的时候，十位和个位可以任取，以此类推）
findall()找到所有匹配的字符串，将其打包成列表返回
如果需要重复的使用某个正则表达式，那么可以先将正则表达式编译成模式对象，可以使用re.compile()方法进行编译
>>> p = re.compile(r'[A-Z]')
>>> p.findall('I love FishC.com')
['I', 'F', 'C']
117.match() 判断一个正则表达式是否从开始处匹配一个字符串
    search() 遍历字符串，找到正则表达式匹配的第一个位置
    findall() 遍历字符串，找到正则表达式所匹配的所有位置，并以列表的形式返回
    finditer() 遍历字符串，找到正则表达式匹配的所有位置，并以迭代器的形式返回
118.匹配对象包含的属性：
group() 返回匹配的字符串
start() 返回匹配的开始位置
end()   返回匹配的结束位置
span()  返回一个元组表示匹配位置（开始，结束）
119.对于比较复杂的内容，正则表达式通常使用分组的方式分别对不同的内容进行匹配，使用()表示的子组我们还可以对它进行按层次索引，序号0表示第一个分组（这个是默认分组，一直存在的，所以不传入参数相当于默认值0）子组的索引值是从左到右进行编号，子组也允许嵌套，因此可以通过从左往右来统计左括号(来确定子组的序号,
>>> p = re,compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'
     group()方法可以一次传入多个子组的序号：
>>>m.group(2,1,2)
('b', 'abc', 'b')
     还可以通过groups()方法一次性返回所有的子组匹配的字符串
>>>m.groups()
('abc', 'b')