""" 面向过程 和 面向对象(oop:object oriented programming) 的基本概念 面向过程：---侧重于怎么做？ 1.把完成某一个需求的 所有步骤 从头到尾 逐步实现 2.根据开发要求，将某些功能独立的代码封装成一个又一个函数 3.最后完成的代码，就是顺序的调用不同的函数 特点： 1.注重步骤与过程，不注重职责分工 2.如果需求复杂，代码会变得很复杂 3.开发复杂项目，没有固定的套路，开发难度很大 面向对象：--谁来做? 相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法 1.在完成某一个需求前，首先确定职责--要做的事(方法) 2.根据职责确定不同的对象，在对象内部封装不同的方法(多个) 3.最后完成代码，就是顺序的让不同的对象调用不同的方法 特点： 1.注重对象和职责，不同的对象承担不同的职责 2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供的固定套路 3.需要在面向过程的基础上，再学习一些面向对象的语法 面向对象有两个核心的概念 类：是一群具有相同特征或行为的事物的一个统称，类是抽象的，不能直接使用 对象：由类创造出来的具体存在 在开发中，应该先有类再有对象 类和对象的关系 类是模板，对象是根据这个模板创建出来的 类只需要有一个，对象可以有多个(一张图纸可以造出多个飞机) 类：属性(信息)和方法(你能完成的动作) 1.类名 2.属性 3.方法 1.类名 这类事物的名字，满足大驼峰命名法 大驼峰命名法： 1.每一个单词的首字母大写 2.单词与单词之间没有下划线 2.属性 这个类创建出的对象有什么样的特征 3.方法 这个类创建出的对象有什么样的行为 类名的确定 名词提炼法分析整个业务流程，出现的名词，通常就是找到的类 属性和方法的确定 对 对象的特征描述，通常可以定义成属性 对象具有的行为(动词)，通常可以定义为方法 提示：需求中没有涉及的属性或方法在设计类时，不需要考虑 """陟彼崔嵬，我马虺隤。有谁来对上联或下联?
此代码由一叶知秋网-知秋君整理""" 练习1： 需求： 小明今年18岁，身高1.75，每天早上要跑步，会去吃东西 小美今年17岁，身高1.65 小美不跑步，小美喜欢吃东西 Person name age height run() eat() 练习2： 一只黄颜色的狗狗叫大黄 看见生人旺旺叫 看见家人摇尾巴 Dog name color shout() shake() """ # 小猫爱吃鱼 小猫要喝水 # Cat eat drink class Cat: def eat(self): print('%s爱吃鱼' %self.name) def drink(self): print('小猫要喝水') # 创建猫对象 # tom = Cat() # tom.name = 'Tom' # print(tom) # addr = id(tom) #print(addr) # %x：打印格式为十六进制 # print('%x' %(addr)) # # %d:打印格式为十进制 # print('%d' %(addr)) # tom.drink() # tom.eat()
""" 初始化方法 创建对象时 1.为对象在内存中分配空间--创建对象 2.调用初始化方法位对象的属性设置初始化值--初始化方法（--init--） """ class Cat(): # 初始化方法的参数，创建类时，必须给足 def __init__(self, name): print('初始化方法') self.name = name # 使用类创建一个对象时，会调用初始化方法 cat = Cat('lala') print(cat.__init__) dog = Cat('dog') print(dog.name)
此代码由一叶知秋网-知秋君整理""" __str__ __del__ """ class Cat: def __init__(self, name): self.name = name print('%s coming' % (self.name)) # 对象名将不返回内存地址，返回改字符串 def __str__(self): # 必须放回一个字符串 return '我是 %s' % self.name # 释放内存时自动执行的方法 def __del__(self): print(('%s leaving' % (self.name))) # tom = Cat('tom') print(tom) del tom print('*' * 40) 小练习 "" 需求 1.房子有户型，总面积和家具名称列表 新房子没有任何的家具 2.家具有名字和占地面积，其中 床：占地4平米 衣柜：占地2平米 餐具：占地1.5平米 3.将以上三件家具添加到房子中 4.打印房子时，要输出：户型，总面积，剩余面积，家具名称列表 """ class house: def __init__(self, houseType, houseArea): self.houseType = houseType self.area = houseArea self.fire_area = houseArea self.fitment = [] def __str__(self): return '户型：%s\n总面积:%s平米\n剩余面积:%s平米\n家具：%s' % (self.houseType, self.area, self.fire_area, ','.join(self.fitment)) def add_fitment(self, fitmentname): if fitmentname.area < self.fire_area: self.fitment.append(fitmentname.name) self.fire_area -= fitmentname.area else: print('%s的占地%s平米太大了，房子剩余面积%s平米太小了' % (fitmentname.name, fitmentname.area, self.fire_area)) class fitment: def __init__(self, name, area): self.name = name self.area = area def __str__(self): return '%s占地%s平米' % (self.name, self.area) bed = fitment('架子床', 4) bureau = fitment('折叠衣柜', 2) cutlery = fitment('餐桌', 1.5) # print(bed) # print(bureau) # print(cutlery) xiaoming_house = house('两室一厅', 100) xiaoming_house.add_fitment(bed) xiaoming_house.add_fitment(cutlery) print(xiaoming_house)
python中class的继承
""" 继承: 实现代码的重用，相同的代码不需要重复的写 """ # 定义父类 class Animal: def eat(self): print('吃~~~~') def drink(self): print('喝') def run(self): print('跑') def sleep(self): print('睡') # 子类继承父类 class Cat(Animal): def call(self): print('喵～') # 创建一个猫对象，可以直接调用继承父类的方法属性，还有自己的方法。 fentiao = Cat() fentiao.eat() fentiao.drink() fentiao.run() fentiao.sleep()
class Animal: def eat(self): print('吃~~~~') def drink(self): print('喝') """ 继承具有传递性 """ class Cat(Animal): def call(self): print('喵～') class Tom(Cat): def speak(self): print('我可以说日语') kt = Tom() kt.speak() # 子类可以继承父类的所有属性和方法 kt.call() # 继承有传递性，包括父类继承的所有属性和方法 kt.eat() kt.drink() 
""" 当父类方法实现不能满足子类的需求时？可以对方法进行重写 1.覆盖父类的方法 2.对父类方法进行扩展 """ class Animal: def eat(self): print('吃~~~~') def drink(self): print('喝') def run(self): print('跑') def sleep(self): print('睡') class Cat(Animal): def call(self): print('喵～') class Tom(Cat): def speak(self): print('我可以说日语') def call(self): print('这是我写的方法') kt = Tom() # 如果子类中，重写了父类的方法 # 在运行中，只会调用在子类中重写的方法而不会调用父类的方法 kt.call() 
""" 子类重写方法，并调用父类的方法 """ class Tom(Cat): def speak(self): print('我可以说日语') def call(self): # 1.针对子类特有的需求，编写代码 print('子类的方法') # 2.调用原本在父类中封装的方法 # Cat.call(self) super().call()kt = Tom() kt.call()
""" 1.子类可以同时继承多个父类 2.如果方法或属性名称相同时，默认继承成首个参数父类的方法或属性 """ class A: def test(self): print('A----test方法') def demo(self): print('A-----demo方法') class B: def test(self): print('B----test方法') def demo(self): print('B-----demo方法') # 同时继承B和A，但是默认B的方法生效 class C(B, A): pass c = C() c.test() c.demo()
""" 新式类和旧式(经典)类： object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看 新式类：以object为基类的类，推荐使用 经典类：不以object为基类的类，不推荐使用 在python3.X中定义的类时，如果没有指定父类，会默认使用object作为基类--python3.x中定义的类都是新式类 在python2.x中定义类时，如果没有指定父类，则不会以object作为基类 为保证编写的代码能够同时在python2.x和python3.x运行 今后在定义类时，如果没有父类，建议统一继承自object """class cat: pass print(dir(cat))
""" 多态(以封装和继承为前提)，不同的子类对象调用相同的方法，产生不同的执行结果 人类 work(self) 程序员 设计师 """ class Dog(object): def __init__(self, name): self.name = name def game(self): print('%s 蹦蹦跳跳的玩～' % (self.name)) class Gaofei(Dog): # 父类方法不能满足子类的方法，重写game方法 def game(self): print('%s 和米老鼠一起玩～' % (self.name)) class Person(object): def __init__(self, name): self.name = name def game_with_dog(self, dog): print('%s 和 %s 玩～' % (self.name, dog.name)) dog.game() # 1.创建一个狗对象 wangcai = Gaofei('高飞') # 2.创建一个人对象 xiaoming = Person('小明') # 3.让小明和狗玩 xiaoming.game_with_dog(wangcai)
""" 一切皆对象 类是一个特殊的对象---类对象 在程序运行的时候，类对象(创建实例对象的模板)在内存中只有 一份，通过它可以创建出和很多个对象实例 除了封装实例的属性和方法外，类对象还可以拥有自己的属性和方法 1.类属性 2.类方法 通过 类名. 的方式可以直接访问类的属性 类属性：就是给类对象定义的属性 通常用来记录与这个类相关的特征 类属性不会用于记录对象特征 """ """ 定义一个工具类，每个工具都有自己的名字 需要知道使用这个类，创建了多少个工具对象 """ class Tool(object): # 1.使用赋值语句定义类属性，记录所有工具的数量 count = 0 def __init__(self, name): self.name = name # 让类属性 +1 Tool.count += 1 # 创建工具对象 tool1 = Tool('斧头') # tool2 = Tool('榔头') # tool3 = Tool('起子') # 输出工具对象的总数 # 类名.属性名 来获取 print(Tool.count)
""" 类方法 类属性就是针对类对象定义的 使用赋值语句在class关键字下可以定义类属性 类属性用于记录于这个类相关的特性 类方法就是针对类对象定义的方法 在类方法内部就可以直接访问类属性或者调用其他类方法 """ class Toy(object): # 1.使用赋值语句定义类属性，记录所有工具的数量 count = 0 def __init__(self,name): self.name = name # 让类属性 +1 Toy.count += 1 @classmethod def show_toy_count(cls): print('玩具对象的数量 %d' %(cls.count)) # 创建玩具对象 toy1 = Toy('乐高') toy2 = Toy('泰迪熊') # 调用类方法 Toy.show_toy_count() 
""" 静态方法 在开发的时候，如果需要在类中封装一个方法，这个方法 即不需要访问实例属性或者调用实例方法 也不需要访问类属性或者调用类方法 这个时候，我们就可以把这个方法封装成一个静态方法 """ class Cat(object): @staticmethod def call(): print('喵～') # 通过 类名. 调用静态方法 Cat.call() # 不需要创建对象，直接就可以使用
""" 私有属性和私有方法 应用场景及定义方式 应用场景 在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用， 而不希望在外部被访问到 私有属性 就是 对象 不希望公开的 属性 私有方法 就是 对象 不希望公开的 方法 定义方法 在定义属性或方法时，在属性名或者方法名前增加两个下划线， 定义的就是私有属性或方法 """ class Women(object): def __init__(self, name): self.name = name self.__age = 18 def __secrte(self): print('%s 的年龄是 %d' % (self.name, self.__age)) lily = Women('lily') print(lily.name) # 私有属性,外界不能直接访问 print(lily.__age) # 私有方法,外界不能直接访问 # lily.secrte()
python中的异常处理方式
""" 异常: 程序在运行的时候，如果python解释器遇到一个错误，会停止程序的执行， 并且提示一些错误的信息，这就是异常 我们在程序开发的时候，很难将所有的特殊情况都处理，通过异常捕获可以针对 突发事件做集中处理，从而保证程序的健壮性和稳定性 在程序开发中，如果对某些代码的执行不能确定(程序语法完全正确) 可以增加try来捕获异常 try: 尝试执行的代码 except 错误类型1： 针对错误类型1，对应的代码处理 except 错误类型2： 针对错误类型2，对应的代码处理 """ try: # 不能确定正确执行的代码 num = int(input('请输入一个整数:')) print('lala') except: print('请输入一个整数') print('#' * 50) 
""" 1.提示用户输入一个整数 2.使用8除以用户输入的整数并输出 """ try: # 提示用户输入一个整数 num = int(input('请输入一个整数:')) # 使用8除以用户输入的整数并输出 result = 8 / num print(result) except ZeroDivisionError: print('0不能做除数') except ValueError: print('输入的不是数字') except Exception as result: print('未知错误 %s' % (result)) finally: # 无论是否有异常,都会执行的代码 print('~~~~~~~~~~~~~~~~~~~~~')
