截止6-24 面向对象完成

变量名起的不好
变量名起的不好
变量名起的不好
变量名起的不好

=============================

# # 对于中文

# # str 编码方式：unicode

# # bytes 编码方式 utf-8 gbk等

# # str 表现形式 s = “abc”

# # 编码方式 01010101 unicode

# # bytes 表现形式 s = b"abc"

# # 编码方式 00101010 utf-8 gbk等

# # s1 = ‘abc’

# # s2 = b’abs’

# # print(s1, type(s1))

# # print(s2, type(s2))

# # abc <class ‘str’>

# # b’abs’ <class ‘bytes’>

# # 对于英文

# # str 编码方式：unicode

# # bytes 编码方式 utf-8 gbk等

# # str 表现形式 s = “中”

# # 编码方式 01010101 unicode

# # bytes 表现形式 s = b"x\e91\e91\e01\e21\e31\e32"

# # 编码方式 00101010 utf-8 gbk等

# # s1 = ‘中’

# # s2 = b’中’

# # print(s1, type(s1))

# # print(s2, type(s2))

# # SyntaxError: bytes can only contain ASCII literal characters.

# # py3的bytes中文表现不出来

# # ===============

# # str转化bytes

# s1 = ‘中’

# s2 = s1.encode(“gbk”)

# print(s1, type(s1))

# print(s2, type(s2))

# # 中 <class ‘str’>

# # b’\xe4\xb8\xad’ <class ‘bytes’>

# # 转化后就可以传输和储存

class Employ(object):

raiseamount = 1.04

employ_num = 0

def init(self, name, salary):

self.name = name

self.salary = salary

Employ.employ_num += 1

def infosummary(self):

print(“name:%s, salary:%s” % (self.name, self.salary))

def raisesalary(self):

print(“涨工资了”)

self.salary = self.salary * self.riseamount

@classmethod

def aet_raiseamount(cls, arg):

cls.raiseamount = arg

e1 = Employ(“cm”, 666)

print(Employ.raiseamount)

print(e1.raiseamount)

e1.aet_raiseamount(10)

print(Employ.raiseamount)

print(e1.raiseamount)

e2 = Employ(“fe”, 32)

print(e2.raiseamount)

class Animal():

def init(self, name, aggr, hp):

self.name = name

self.aggr = aggr

self.hp = hp

def eat(self):

self.hp += 100

print(‘Animal中吃药’)

class Dog(Animal):

def init(self, name, aggr, hp, kind):

# Animal.init(self, name, aggr, hp)

# 等价于：super()方法

super().init(name, aggr, hp)

self.kind = kind #派生属性

def bite(self, person): # 使用派生方法

person.hp -= self.aggr

def eat(self):

print(‘Dog类中吃药’)

class Person(Animal):

def init(self, name, aggr, hp, sex, money):

Animal.init(self, name, aggr, hp)

self.money = money

d1 =Dog(“cc”, 122, 333, “dog”)

d1.eat()

print(d1.hp) -> 433

print(d1.name)

print(d1.aggr)

print(d1.kind)

cc

122

dog

p1 = Person(“cm”, 40000, 90000, “nv”, “+oo”)

print(p1.name)

print(p1.aggr)

print(p1.hp)

print(p1.money)

40000

90000

+oo

p1.eat()

print(p1.hp) -> 90100

使用派生方法

d1.bite(p1)

print(p1.hp) - >89878

父类中没有的属性 在子类中出现 叫派生属性

父类中没有的方法 在子类中出现 叫派生方法

只要是子类的对象调用 子类中有的 用子类的 子类没有的去父类里面查找

print(d1.hp) -> 333

d1.eat()

print(d1.hp) -> 433

super()方法在单继承中

d1.eat() Dog类中吃药

super(Dog, d1).eat() Animal中吃药

上面看出 super() 调用的eat直接调用了父类的方法

==============================================================

==============================================================

==============================================================

==============================================================

==============================================================

==============================================================

==============================================================

==============================================================

==============================================================

多继承 # 多继承 # 多继承 # 多继承 # 多继承 # 多继承

class A:

def func(self):

print(“A”)

class B:

def func(self):

print(“B”)

class C:

def func(self):

print(“C”)

class D(A, B, C):

def func(self):

print(“D”)

print(D.mro())

==============================================================

==============================================================

==============================================================

==============================================================

==============================================================

==============================================================

==============================================================

==============================================================

==============================================================

封装

class Person:

__key = 123 # 私有静态属性

def init(self, name, password):

self.name = name

self.__password = password # 私有属性

def get_psw(self):

print(self.__password)

def __personff(self): # 私有方法

print(“这是私有方法”)

def ues_person(self): # 打印类中的私有属性

print(self.__key)

print(self.__password)

self.__personff()

p1 = Person(“cm”, “262626”)

p1.ues_person()

print(p1.dict)

->{‘name’: ‘cm’, ‘_Person__password’: ‘262626’}

上面的password在内存中储存为_Person__password

只有在类内部定义 __属性名 这样的类型时，系统才会自动带上 _类名

在类外定义的就不会加 如：

p1.__high = 1.9

print(p1.dict)

-> {‘name’: ‘cm’, ‘_Person__password’: ‘262626’, ‘__high’: 1.9

定义的__high在内存中仍然为__high

print(p1.__password) -> err

print(p1._Person__password) _类名__属性名

-> 262626

p1.get_psw()

-> 262626

=======================================

面向对象的一些内置函数

class Circle:

def init(self, r):

self.r = r

def perimeter(self):

return self.r * 2 * 3.14

def area(self):

return self.r ** 2 * 3.14

c1 = Circle(3)

print(c1.perimeter())

print(c1.area())

18.84

28.26

将上面的 perimeter() area() 从方法伪装成属性

class Circle:

def init(self, r):

self.r = r

@property

def perimeter(self):

return self.r * 2 * 3.14

@property

def area(self):

return self.r ** 2 * 3.14

c1 = Circle(3)

print(c1.perimeter)

print(c1.area)

18.84

28.26

=======================================

反射 # 反射 # 反射 # 反射 # 反射

=====================================

class Circle:

def init(self, r):

self.r = r

@property

def perimeter(self):

return self.r * 2 * 3.14

@property

def area(self):

return self.r ** 2 * 3.14

def del(self):

print(“释放内存”)

c1 = Circle(3)

# del c1

# print(c1.area)

t = 0

while t < 12:

t += 1

# print(t)

===================================

class Circle:

def init(self, r):

self.r = r

def str(self):

return ‘卧槽泥马’

def print_property(self):# property

print(self.r)

c1 = Circle(3)

c1.print_property()

print(c1)

卧槽泥马