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就表示这个递归结束了。

你可能感兴趣的:(python)