python菜鸟日记2，,1.对于类之间的的子

python菜鸟日记2，,1.对于类之间的的子

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__属性）


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


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‘])
其实，并不是的，元组中有一个列表，其实元组中变的并不是元组的元素，而是元组中列表中的元素，列表中的元素是可以变的这个我们都知道，所以，上面的例子其实变的是列表中的元素

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是用空间来换取时间的一种方法。


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菜鸟日记2