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))

-------------
"输出"


-------------

"查看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))

第1月5周2天