python菜鸟日记2

1. 对于类之间的的子类关系是可以传递的：比如C1是C2的子类，C2是C3的子类，那么C1也是C3的子类，任何类都可以看成是自身的子类，class类里面也可以嵌套一个class类


2. 在类中，要想在函数中引用类的属性（全局变量），就必须使用完整名称（类名.变量名），而对于在类体中的语句，想引用类的属性，就必须使用属性的简单名称
   例如： class c():
               x=55
               y=x+66                   --必须使用简单名称
               def b():
                  f=c.x**3              --必须使用完整名称
                  print(f)


3. 继承问题：由传统方法解析顺序，还有新型方法解析顺序
           例如：class base1:
                      def amethod(self):
                             print('base1')
                 class base2(base1):
                      pass
                 class base3:
                      def amethod(self):
                             print('base3')
                 class derived(base2,base3):
                             pass
                 aninstance=derived()
                 aninstance.amethod()             #打印base1
      首先继承关系是一个树形图，传统的顺序是：先找寻amethod（）函数，先derived类中找，再base2，再base1，再base3，直到找到为止，而新型的顺序是：先找寻amethod（）函数，先derived类中找，再base2，再base3，再base1，直到找到为止，（必须每个类里面都要包含一个__mro__属性）

3.1. 在继承中有一个原则就是子类可以覆盖父类，如果子类中的属性或者函数与父类同名，那么在子类中就会覆盖父类的属性或者函数,为什么会覆盖呢？原因就是上面所有的访问顺序，现访问子类再去父类，如果在子类中找到了就不会在去父类中找了

4. 在基于菱形的多重继承下，我们可以考虑使用super.super(aclass,obj)内置函数来确保每个祖先的方法（函数）只被调用一次，该类型将返回对象obj的一个特殊超对象，查找顺序是MRO，例如下面的例子：

 class a:

    def miss(self):
      print('a.miss')
    class b(a):
    def miss(self):
        print('b.miss')
        super(b,self).miss()     # a.miss(self)
        class c(a):
    def miss(self):
                 print('c.miss')
        super(c,self).miss()     # a.miss(self)
    class d(b,c):
    def miss(self):
        print('d.miss')
        super(d,self).miss()
        
a=d()
a.miss()
                                            结果是：    d.miss
b.miss
c.miss
a.miss


5. 看到类似C:\>是在Windows提供的命令行模式，看到>>>是在Python交互式环境下，python解释器就是用来执行你所输入的python代码的

6. Python中的除/，取整//，取余%        

      >>> 10/3

              3.3333333333333335
     >>> 10//3
              3
     >>> 10%3
              1


7. 对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符:
                   >>>ord('B')
    66
                   >>> ord('白')
                         30333
                    >>>chr(33333)
                         '舵'
                     >>> chr(22222)
                          '囎'


8. 可见，1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节

9. 多变量输出,%后面的变量要与前面的一一对应，顺序一样要一致

            例如：>>>print('这是%d%d的帐号他的存款额是%s，%s'%(a,b,c,d))

                        >>>这是555666的帐号他的存款额是aaa，bbb
  

10. 对于元组我们使用（）括号来进行定义的，他和列表很类似，但是他不能进行修改，a=（1），如果这样定义一个有一个元素的元组，这会产生奇异，即可以理解为数字1，带了个小括号，又可以理解为含有一个元素的元组，所以python规定，定义含有一个元素的元组的时候要在扩后里面加一个逗号，a=(1,)。
    然而下面这个列子中元组似乎是可变的：
                        
                        >>> t = ('x', 'y', ['p', 'q'])
                        >>> t[2][0] = 'p'
                        >>> t[2][1] = 'q'
                        >>> t

                           ('x', 'y', ['p', 'q'])

10.1.  其实，并不是的，元组中有一个列表，其实元组中变的并不是元组的元素，而是元组中列表中的元素，列表中的元素是可以变的这个我们都知道，所以，上面的例子其实变的是列表中的元素

  
11.在字典中，一个key对应一个value，如果多次对这个key赋值，那么后面的会冲掉前面的value，只保留最后一个value，想判断某个key是否有value与之对应，有两种方法
        ①，>>>key in dict_name        如果key在dict，则返回true，不在false
        ②，>>>dict_name.get(key)       调用get函数，确定key是否在字典中


12.和list比较，dict有以下几个特点：
       查找和插入的速度极快，不会随着key的增加而增加；
      需要占用大量的内存，内存浪费多。

      而list相反：

     查找和插入的时间随着元素的增加而增加；

     占用空间小，浪费内存很少。
     所以，dict是用空间来换取时间的一种方法。


12.1.dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象， 这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：


13. set和dict类似，也是一组key的集合，但不存储value,要创建一个set，需要提供一个list作为输入集合：  a=set([1,2,3,4,5,6])
                       >>> a = set([1, 2, 3,4,5,6])
                       >>> a

                          {1, 2, 3,4,5,6}      --注意花括号

 因为set是key的集合，所以具有集合的特点，无序性和不可重复性，当列表中有重复值时，会过滤掉重复值，因为是集合，所以可以进行交集和并集的运算，a & b（交集）；a | b(并集)

14. 函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：a=max 那么a就是max的别名，用法和max一样都是求最大值的


15. 函数是可以返回多个值的，当函数要返回多个值的时候，其实返回的是一个元组，在语法上，返回一个tuple可以省略括号，多个变量可以同时接收一个tuple，按位置赋给对应的值。
   例如： def a(c,d):
    f=c+d
    g=c/d
    h=c*d
    return f,g,h
x,y,z=a(6,3)
print(x,y,z)
print(a(6,3))
  
结果： 9 2.0 18
            (9, 2.0, 18)


16. 可变参数,由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来,当我们调用的时候需要先组装一个列表或者元组，但如果我们使用了可变参数，那么python在我们调用函数的时候就将我们传入的值自动组装成为一个元组 def function_name(*number): 调用传值的时候就直接function_name(1,2,3,....),而不用写成function_name([1,2,3,...])关键字参数，def function_name(**number),调用的时候：function(a=1,b=2,c=3....),关键字参数传进来的是一个字典，与上面的类似

17.默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

18.递归函数就是自己调用自己，在函数中遇到return就表示这个递归结束了。