day7--面向对象
复习
logging ：日志
1、通过函数去控制
2、logger对象
re ：正则
time&datetime 时间
时间戳:记录一个时间节点
格式化时间：给人看的
结构化时间：计算机计算
os：和操作系统交互
sys：和python解释器交互
hashlib：摘要算法模块
1、文件的一致性校验
2、用户的加密认证
3、不可逆性、撞库和加盐
json/pickle/shelve
1、为什么要序列化：数据存储、网络传输
2、json：通用的序列化格式、支持的数据类型有限
3、pickle：只能python程序使用、游戏
4、shelve:把数据当成一个字典操作、操作简单
configpaser
1、特殊格式的配置文件
random 随机数
1、验证码
# subprocess : 多进程
# xml：tomcat的配置文件
面向对象
#游戏工作
#人狗大战
#人 、 狗
#人角色：攻击力 生命值 名字 等级
#狗角色：攻击力 生命值 名字 品种
def person(attack,life_value,name,level):
def atk(dog_d):
print('%s 打了 %s' % (name, dog_d['name']))
dog_d['life_value'] -= attack
person_dic = {'attack':attack,
'life_value':life_value,
'name':name,
'level':level,
'atk':atk}
return person_dic
def dog(attack,life_value,name,level):
def bite(person_d):
print('%s 咬了 %s' % (name, person_d['name']))
person_d['life_value'] -=attack
dog_dic = {'attack':attack,
'life_value':life_value,
'name':name,
'level':level,
'bite':bite}
return dog_dic
alex = person(100,1000,'alex',2)
alex2 = person(1001,10000,'alex2',2)
egg = dog(200,2000,'egon',10)
alex['atk'](egg)
print(egg['life_value'])
# 面向对象编程
# 对象 - 角色
# alex
# egg
# 类 ：具有相同属性和方法的一类事物就是类
# person
# dog
# 对象和类的关系
# 对象是一个实实在在存在的事物，是独一无二的
# 类 是一个抽象的大致规范了一类事物的范围
#
初识面向对象和类
#def
#面向过程编程
#固定的目的 固定的结果
#从头到尾把要执行的步骤堆积出来就好了
#面向对象编程
#有一个抽象的过程
#上帝视角：结果不能预测
'''
class Person:
rol = '人' #数据属性、静态属性
country = '中国'
def attack(self): #函数属性、动态属性、方法
pass
# person 类 Person也是类名
print(callable(Person))
print(Person()) #对象
#一个类名加上括号就会返回一个对象
print(Person.rol) #.属性名
Person.rol = '人类' #修改属性的值
print(Person.__dict__) #不可以平时直接用的
#类也有一个属于自己的名称空间：静态属性和动态属性
print(Person.attack)
# print(Person.attack()) 报错：没有self参数
'''
#类的定义
# class 类名:
# 静态属性 = '值'
# def 方法(self):
# pass
#
# 对象 = 类名()
# 对象.静态属性
# 对象.方法 #可以调用不能执行
class Person:
rol = '人' #数据属性、静态属性、类属性
country = '中国'
def __init__(self,name,age,life_value): #初始化方法
# self.__dict__['name'] = name
self.name = name #属性、对象属性
self.theage = age
self.life_value = life_value
self.aggr = 200
def attack(self): #函数属性、动态属性、方法
#self只是一个形式参数，可以叫其他名字，但正常没人会这样
#self是水性杨花，那个对象调这个方法，self就是那个对象
print('attack方法被%s执行了'%self.name)
# alex = Person('alex',38,2000) #alex 对象
# print(alex.name)
# print(alex.theage)
# print(alex.life_value)
#类加上括号的过程： #实例化
#1.先创建了一个对象 self = {}
#2.才执行初始化方法__init__,同时把创建的对象扔到了__init__参数里
# Person.rol
# alex.name = 'alex' #给alex对象创建一个属性
# print(alex.name) #查看alex的name属性
# alex.name = 'Alexander' #修改alex的name属性
# print(alex.name) #查看alex的name属性
# print(alex.__dict__['name'])
# alex.__dict__['name'] = 'alex' #对象可以使用dict来修改属性的值
# print(alex.name)
# alex.age = 38
# print(alex.age)
# print(alex.__dict__)
# egg = Person()
# egg.name = 'egon'
# print(egg.name)
# print(alex.name)
#类 对象(实例) 实例化
#类是我们自己抽象出来的
#实例化 对象 = 类名()
#类经过实例化就产生了对象/实例
# alex = Person('alex',38,2000) #alex 对象
# egg = Person('egon',18,1000) #alex 对象
#真正使用方法的不是类而是对象
# Person.attack(alex)
# Person.attack(egg)
# alex.attack() #==Person.attack(alex)
# egg.attack() #==Person.attack(egg)
#类：静态属性 动态属性
#类可以调用静态属性
#类可以查看动态属性 却必须要带上具体的对象参数才能调用动态属性
#对象：可以拥有自己的对象属性，并且可以调用类中的方法
# 对象可以调用类的方法么
class Person:
rol = '人' #数据属性、静态属性、类属性
country = '中国'
def __init__(self,name,age,life_value): #初始化方法
# self.__dict__['name'] = name
self.name = name #属性、对象属性
self.theage = age
self.life_value = life_value
def attack(self): #函数属性、动态属性、方法
#self只是一个形式参数，可以叫其他名字，但正常没人会这样
#self是水性杨花，那个对象调这个方法，self就是那个对象
print('attack方法被%s执行了'%self.name)
# egg = Person('egon',18,1000)
# alex = Person('alex',38,2000)
# print(alex.rol)
# print(alex.country)
# egg.aggr = 200
# alex.country = '印度'
# print(alex.country)
# print(egg.country)
#类有属于自己的命名空间
#对象也是
#类不可以调用对象的属性
#但是对象在寻找属性的时候，是先找自己名称空间的，找不到就找类名称空间里的
class Dog:
def __init__(self,name,type):
self.name = name
self.dog_type = type
self.life_value = 2000
def bite(self,name):
print('%s咬了%s'%(self.name,name))
旺财 = Dog('旺财','土狗')
#使用init去进行属性的初识化
#1.规范所有的对象都拥有一些基础的属性
#2.方便
# print(旺财.name)
# print(旺财.dog_type)
# print(旺财.life_value)
# 旺财.bite('alex') #Dog.bite(旺财,'alex')
#__init__再讲
#再讲类中的方法
#练习
#创建一个类,实例化对象，需要做一个计数器，这个类每实例化一次，计数器加一
#所有的对象共享这个计数个数
# class Dog:
# counter = 0
# def __init__(self,name,type):
# self.name = name
# self.dog_type = type
# self.life_value = 2000
# Dog.counter += 1
#
# 史努比 = Dog('史努比','大白狗')
# 史努比2 = Dog('史努比','大白狗')
# print(史努比.counter)
# print(史努比2.counter)
#练习2
#创建一个圆形类
#有一个属性：圆的半径
#提供两个方法：计算圆面积 、计算圆周长
from math import pi
class Circle:
def __init__(self,r):
self.r = r
def area(self):
return self.r**2*pi
def perimeter(self):
return 2*pi*self.r
c1 = Circle(5)
print(c1.area())
print(c1.perimeter())
c2 = Circle(20)
print(c2.area())
print(c2.perimeter())
# 在终端输出如下信息
#
# 小明，10岁，男，上山去砍柴
# 小明，10岁，男，开车去东北
# 小明，10岁，男，最爱大保健
# 老李，90岁，男，上山去砍柴
# 老李，90岁，男，开车去东北
# 老李，90岁，男，最爱大保健
#两个人物 --》 人类
#姓名 年龄 性别 ---》属性
#行为 --> 方法
class Person:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def shangshan(self):
print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.sex))
xiaoming = Person('小明',10,'男')
old_li = Person('老李',90,'男')
xiaoming.shangshan()
old_li.shangshan()
#面向过程和面向对象编程
#思路1 从只关心某一个对象变成抽象规范了一类对象
#思路2 当多个函数都需要传递同样的多个参数的时候，考虑面向对象的思想
#面向对象作业
#1.正方形类
面向对象之间的交互
#人狗大战
class Dog:
def __init__(self,name,type,aggr):
self.name = name
self.dog_type = type
self.aggr = aggr
self.life_value = 2000
def bite(self,person_obj): #self==egg,person_obj=alex
#属性的变化
print('%s咬了%s'%(self.name,person_obj.name))
person_obj.life_value -= self.aggr
class Person:
rol = '人' #数据属性、静态属性、类属性
country = '中国'
def __init__(self,name,age,life_value): #初始化方法
self.name = name #属性、对象属性
self.theage = age
self.life_value = life_value
self.aggr = 1
def attack(self,dog_obj): #函数属性、动态属性、方法
print('%s攻击了%s'%(self.name,dog_obj.name))
dog_obj.life_value -= self.aggr
alex = Person('alex',38,500)
egg = Dog('egon','二哈',20)
print(alex.life_value)
egg.bite(alex) #Dog.bite(egg,alex)
print(alex.life_value)
print(egg.life_value)
alex.attack(egg)
print(egg.life_value)
#类的定义
#对象
#实例化
#交互
组合
#组合 —— 面向对象的一种功能
#什么有什么的关系
#每个人都有生日,生日是由年月日组成
class Birthday:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
class Person:
def __init__(self,name):
self.name = name
# self.birthday = birth
alex_birth = Birthday(1968,1,1)
print(alex_birth.year)
alex = Person('alex')
alex.birth = alex_birth #Birthday类的对象是Alex的birth属性
print(alex.birth.year)
#组合 - 两个类之间的事儿
#描述的是一种所属关系
#组合例二：
#人狗大战
#人
#武器：伤害、属性
class Weapon:
def __init__(self,aggr,name,money):
self.aggr = aggr
self.name = name
self.money = money
def kill(self,dog_obj):
print('%s武器暴击%s,伤害%s'%(self.name,dog_obj.name,self.aggr))
dog_obj.life_value -= self.aggr
class Dog:
def __init__(self, name, type, aggr):
self.name = name
self.dog_type = type
self.aggr = aggr
self.life_value = 2000
def bite(self, person_obj): # self==egg,person_obj=alex
# 属性的变化
print('%s咬了%s' % (self.name, person_obj.name))
person_obj.life_value -= self.aggr
class Person:
rol = '人' # 数据属性、静态属性、类属性
country = '中国'
def __init__(self, name, age, life_value): # 初始化方法
self.name = name # 属性、对象属性
self.theage = age
self.life_value = life_value
self.aggr = 1
def attack(self, dog_obj): # 函数属性、动态属性、方法
print('%s攻击了%s' % (self.name, dog_obj.name))
dog_obj.life_value -= self.aggr
alex = Person('alex', 38, 500)
egg = Dog('egon', '二哈', 20)
alex.money = 2000
knife = Weapon(200,'杀猪刀',1900)
if alex.money > knife.money:
alex.money -= knife.money
alex.weapon = knife
print(egg.life_value)
alex.weapon.kill(egg)
print(egg.life_value)
#
继承
#继承 —— 面向对象的三大特性之一
#想产生继承关系，必然是两个类以上
#继承表达的是一种 什么 是 什么的关系
# class Animal:
# def __init__(self,name,aggr,life_value):
# self.name = name
# self.aggr = aggr
# self.life_value = life_value
#
# def func(self):
# print(self.name)
#
# class Foo:
# def func(self):
# print(self.name)
#
# class Dog(Animal,Foo):
# def __init__(self,name,aggr,life_value,type):
# #Animal.__init__(self,name,aggr,life_value)
# super().__init__(name,aggr,life_value)
# self.dogtype = type #派生属性
#
# def bite(self):
# #派生方法
# Animal.func(self)
# super().func()
#
# class Person(Animal):
# def __init__(self,name,aggr,life_value,money):
# Animal.__init__(self,name,aggr,life_value)
# self.money = money
#
# def attack(self):pass
# egg = Dog('egon',100,2000,'金毛')
# egg.bite()
# alex = Person('alex',100,2000,2000)
# # print(egg.__dict__)
# print(alex.__dict__)
# alex.func()
#Dog继承了Animal
#父类 ：Animal
#子类 ：Dog
#一个类可以有多个子类
#子类调用方法；先调自己的，自己没有就调用父类的
#写继承的过程：是先抽象，后继承
#派生：父类没有的属性和方法在子类中就是派生出来的
#多继承
#一个类可以拥有多个父类
# class A:
# pass
#
# class B:
# pass
#
# class C(A,B):
# pass
#
# print(A.__base__)
#object 类祖宗
#如果一个类有指定的父类，那么他的父类就是被指定的那个
#如果一个类没有指定的父类，那么他的父类就是object
#凡是继承了object类的类都是新式类
#python3里所有的类都是新式类
#新式类调用父类的方法：
# 指名道姓:父类名.方法名(self,aggr1...)； ---->经典类
# super关键字:super().方法名(aggr1,...) ----> 只适用于新式类
#教授类
#属性 年龄 姓名
#行为 讲课 写专利
#教师类：
#属性 年龄 姓名
#行为 讲课
#教授是教师
#教师是父类/基类
#教授是子类
# class Teacher:
# def __init__(self,name,age,salary):
# self.name = name
# self.age = age
# self.salary = salary
#
# def teach(self):
# print('%s正在讲课'%self.name)
#
# class Professor(Teacher):
# def print_write(self):
# print('%s正在写专利'%self.name)
#
# egon = Professor('egon',18,20000)
# print(egon.__dict__)
# print(egon.salary)
# egon.teach()
# egon.print_write()
#
# class Teacher:
# def __init__(self,name,age,salary):
# self.name = name
# self.age = age
# self.salary = salary
# self.teach()
#
# def teach(self):
# print('%s正在讲课'%self.name)
#
# class Professor(Teacher):
# def print_write(self):
# print('%s正在写专利'%self.name)
#
# def teach(self):
# # super().teach()
# print('教授%s正在讲课'%self.name)
#
# egon = Professor('egon',18,20000)
# egon.teach()
# print(egon.__dict__)
# print(egon.salary)
# egon.teach()
# egon.print_write()
#新式类多继承, 执行父类的方法是 广度优先
class A:
def func(self):
print('A')
class B(A):pass
# def func(self):
# print('B')
class C(A):
def func(self):
print('C')
class D(B):pass
# def func(self):
# print('D')
class E(C):
def func(self):
print('E')
class F(D,E):pass
# def func(self):
# print('F')
# f = F()
# f.func()
# 广度优先
print(F.mro())
#经典类和新式类的区别
#1、关于基类 ： 新式类默认继承object
#2、关于在子类中执行父类的方法:新式类有super，经典类只能用指名道姓
#3、关于多继承：新式类 广度优先（mro），经典类：深度优先
#在py3没有经典类；在py2里经典类和新式类共存
#关于继承：
#子类继承父类
#子类的对象调用方法，优先在子类中找，如果子类中有，就执行子类中的
# 如果子类中没有，就执行父类的
#多个父类以广度优先为准
#关注self到底是哪个类的实例化
