标签：exp 没有 count 移动 rom 抽象 派生 __next__ 选择
dict:
类中: 所有的静态属性和方法
对象: 所有的对象的属性
class Foo:
count = 0
def __init__(self):
self.count += 1
f1 = Foo()
f2 = Foo()
print(Foo.count)
print(f1.count)
print(f2.count)
"静态属性: 类的属性，所有的对象共享这个变量"
"对象名 去修改类的静态属性"
"在对象的空间中又创建了一个属性，而不能修改类中属性的值"
"操作静态属性，应该用类名操作""统计对象创建个数" 面试题
class Foo:
count = 0
def __init__(self):
Foo.count += 1
f1 = Foo()
f2 = Foo()
f1.count += 1
print(Foo.count)
"创建对象改变属性值"
class A:
l = []
def __init__(self,n):
self.l.append(n)
a = A("a")
b = A("b")
c = A("c")
print(A.l)
print(a.l)
print(b.l)
class Foo:
count = [0]
f1 = Foo()
f1.count[0] += 1
print(f1.count[0])
print(Foo.count[0])
f1.count = [2]
print(f1.count)
print(Foo.count)只要对象的某个属性被直接赋值，那么一定是对象的命名空间发生变化。
只要是静态变量用类名操作
代码冗余时，继承可以优化，简化代码 继承特点
先抽象，后继承
父类/超类/基类
子类/派生类
继承与重用 继承特点
父类中的所有属性和方法都可以被子类使用了
继承与派生
子类在父类的基础上又新创建了自己需要的方法和属性
父类有的子类没有 - 子类对象直接调用就会直接执行父类的方法
父类有的子类也有 - 子类对象调用直接执行子类中的方法，想在子类中使用父类的名字:
当子类当中有要被调用的方法的时候，子类的对象会直接选择子类中的方法，变量，父类中的方法不会被自动执行
如果我们既想要执行子类的方法，也想要执行父类的方法，那么需要在子类的方法中调用父类的方法
super().__init__() 调用父类不用传self
Animals.__init__()"当self 去调用某个方法的时候不要看self在哪个类里，要看self到底是谁"
class Foo:
def __init__(self):
self.func()
def func(self):
print("in Foo")
class Son(Foo):
def func(self):
print("in Son")
s1 = Son()>>规范的编程模式 继承特点
> 抽象类
> 多人开发，复杂的需求，后期的扩展
> 需要一种手段来帮助我们，通过继承创建模板。来要求继承的类也必须实现。
> 报错手段实现类的规范性
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self):pass抽象类是一个规范，他基本不会实现什么具体的功能，抽象类是不能被实例化的。
在这个类创建的时候指定metaclass=ABCMeta
在你希望子类继承的方法上加上一个@abstractmethod装饰器
语法
class Parent1:pass
class Parent2:pass
class Son(Parent1,Parent2):pass
print(Son.__bases__)子类只能实现父类的一部分，就不能直接继承。不符合逻辑
需要分门别类的去将多个方法放在多个类中，再由子类多继承这些类
接口类
新式类和经典类之间的区别
广度优先
继承object
mro方法
super不是单纯的找父类，而是遵循mro顺序
py3都是新式类
所有的新式类都有默认的父类，object。
继承了object的类就是新式类，没有继承就是经典。
多继承的顺序
钻石继承??
其他方式遍历父类寻找东西会重复。没有必要的步骤
走过的路不能重复，所有的点都要走到
广度优先，当我没有办法必须往前走，当我能够有其他方式走优先横着走。
在新式类中所有的多继承关系寻找方法的顺序 都遵循广度优先
D.mro() 类的继承顺序，广度优先查找顺序都给你
super
super不是单纯的找父类，而是遵循mro顺序的,B的super找C
class D(B,C):
def func(self):
super().func()
print("D")
print(D.func())
输出:A,C,B,D深度优先
不提供mro方法，和super
不主动继承object
python 面向对象的解释型语言
genexpr
class A():
def f(self):
pass
a = A()
print(type(a.f))
print(type(A.f))
-------------
"输出"
<class "method">
<class "function">
-------------"查看Iterator与Iterable差别"
print(set(dir([1,2].__iter__()))-set(dir([1,2])))
--------------
"输出"
{"__length_hint__", "__next__", "__setstate__"}
--------------"执行代码"
code = ""
import os
print(os.path.abspath("."))
exec(code,{"print:print},)"打印进度条"
import time
for i in range(0,101,2):
time.sleep(0.1)
char_num = i//2 #打印多少个‘*‘
per_str = "\r%s%% : %s\n" % (i, "*" * char_num) if i == 100 else "\r%s%% : %s"%(i,"*"*char_num)
print(per_str,end="", flush=True)
#小越越 ： \r 可以把光标移动到行首但不换行"返回元素的值"
"改变元素id值不变"
ret = bytearray(‘alex‘,encoding=‘utf-8‘)
print(id(ret))
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))标签：exp 没有 count 移动 rom 抽象 派生 __next__ 选择
原文地址：https://www.cnblogs.com/yonghuierming/p/9551458.html
