开发者

Python全栈之面向对象基础

目录
  • 1. 面向对象oop了解
  • 2. 对象的相关操作
    • 小提示:
  • 3. 类的相关操作
    • 4. 类对象的删除操作
      • 小提示:
    • 5. 小练习
      • 小提示:
      • 答案:
    • 总结

      1. 面向对象oop了解

      # ### oop 面向对象的程序开发
      # (1) 类的定义
      # 1
      class Car:
      	pass
      # 2 推荐
      class Car():
      	pass
      # 3.
      class Car(object):
      	pass
      	
      # (2)类的实例化
      class Car():
      	pass
      obj = Car()
      print(obj)
      # (3)类的基本结构
      """
      类中两样东西:
      	(1)成员属性
      	(2)成员方法
      """
      class Car():
      	# 成员属性
      	color = "白色"
      	# 成员方法
      	def didi():
      		print("小车会嚓嚓的叫")
      
      # 语法上不报错,但是严禁使用,破坏了类中的结构,不要裸露的把判断和循环直接写在类中,而是用方法包起来
      class Car():
      	if 5 ==5 :
      		print(11223344)
      # (4)类的命名
      """类的命名 : 推荐使用大驼峰命名法,每个单词的首字母都要大写"""
      """
      mycar => MyCar
      zhangbaozhang => ZhangBaoZhang
      """
      

      2. 对象的相关操作

      # ### 面向对象的封装 - 对象的操作
      """
      封装:
      	1.私有 : 在类内可以互相访问,在类外不能访问
      	2.公有 : 在类内或者类外都可以访问
      类中成员:
      	1.成员属性
      	2.成员方法
      绑定方法:
      	1.绑定到对象 : 当对象去调用类中成员方法时,系统会默认把该对象当成参数传递给该方法
      	2.绑定到类   : 当对象或者类去调用类中成员方法时,系统会默认把该类当成参数传递给该方法
      使用方式:
      	对象.成员属性
      	对象.成员方法
      """
      class MyCar():
      	# 公有属性
      	logo = "布加迪威龙"
      	# 私有属性
      	__price = "2000万"
      	# 公有方法
      	def run(self):
      		print("百公里油耗300L,logo={} , price={}".format(self.logo, self.__price))
      	# 私有方法
      	def __info(self):
      		print("车主信息保密,据说是某个房地产大佬的儿子")
      # 实例化对象(类的实例化)
      obj = MyCar()
      # (1)实例化的对象访问成员属性和方法
      # 公有
      print(obj.logo)
      obj.run()
      # 私有 (私有成员无法在类外访问,类内可以)
      # obj.__price error
      # obj.run()
      # obj.__info() error
      
      #(2)实例化的对象动态添加公有成员属性
      obj.color = "尿黄色"
      obj.logo = "五菱宏光" 
      print(obj.color)
      print(obj.logo)
      # __dict__ 获取类对象的内部成员
      print(obj.__dict__)
      print(MyCar.__dict__)
      #(3)实例化的对象动态添加公有成员方法
      # 1.无参方法
      def dahuangfeng():
      	print("请加我大黄蜂")
      obj.dahuangfeng = dahuan编程客栈gfeng
      obj.dahuangfeng()
      # 2.有参方法
      # 基本版
      def qingtianzhu(name):
      	print("请叫我一柱擎天么,{}".format(name))
      obj.qingtianzhu = qingtianzhu
      obj.qingtianzhu("擎天柱")
      # 升级版
      def qingtianzhu(obj,name):
      	print("请叫我一柱擎天么,{},我的颜色是{}".format(name,obj.color))
      obj.qingtianzhu = qingtianzhu
      obj.qingtianzhu(obj,"擎天柱")
      # 究极版
      """如果要创建绑定方法,参数的顺序,self对象本身要放到第一位."""
      def qingtianzhu(obj,name):
      	print("请叫我一柱擎天么,{},我的颜色是{}".format(name,obj.color))
      import types
      # 创建绑定方法,系统自动把该对象当成参数传递给方法;
      # types.MethodType(方法,对象) => 绑定方法   
      res = types.MethodType(qingtianzhu,obj)
      print(res)
      obj.qingtianzhu = types.MethodType(qingtianzhu,obj)
      obj.qingtianzhu("擎天柱")
      # 3.lambda表达式
      obj.weizhentian = lambda : print("我是威震天")
      obj.weizhentian()
      

      小提示:

      类对象在调用方法,如果方法是类外的(自定义的方法),那么不会自动传参的(不会把类对象传到方法里面)
      self是用来接收对象这参数(self只是一个名字而已,无所谓,习惯用self)
      

      Python全栈之面向对象基础

      3. 类的相关操作

      # ### 面向对象的封装 - 类的操作
      """
      使用方式:
      	类.成员属性
      	类.成员方法
      """MIuwYdx
      class MyCar():
      	# 公有成员属性
      	platenum = "京A7758BB"
      	# 私有成员属性
      	__earning = "月收入6000"
      	# 公有成员方法
      	def car_info():
      		print("牌照信息可以公开")
      		print("<======>")
      		MyCar.__money_info()
      	# 私有成员方法
      	def __money_info():
      		print( "收入信息保密" , MyCar.__earning )
      
      # (1)定义的类访问公有成员属性和方法
      print(MyMIuwYdxCar.platenum)
      MyCar.car_info()
      # MyCar.__money_info() error
      # (2)定义的类动态添加公有成员属性
      MyCar.oil = "1000L"
      print(MyCar.oil)
      print(MyCar.__dict__)
      # (3)定义的类动态添加公有成员方法
      # 1.无参方法
      def car_light():
      	print("我是造车灯的方法")
      MyCar.car_light = car_light
      MyCar.car_light()
      # 2.有参方法
      def car_engine(name):
      	print("我是造{}发动机的方法".format(name))
      MyCar.car_engine = car_engine
      MyCar.car_engine("三缸发动机")
      # 3.lambda表达式
      MyCar.luntai = lambda : print("我是造轮胎的方法")
      MyCar.luntai()
      
      # 对比 对象和类之间的不同
      """
      1.类中的无参方法默认只能类来调用,对象无法调取
      2.对象可以调用类中的成员,反过来,类不能调用对象中的成员
      3.每创建一个对象都会在内存中占用一份空间,对象之间是彼此独立的;
      """
      obj = MyCar()
      # obj.car_info() error
      MyCar.car_info()
      
      obj.price = "10万"
      print(MyCar.price)
      

      4. 类对象的删除操作

      # ### 1.如何在类外访问私有成员
      class Plane():
      	# 公有成员
      	captian = "赵沈阳"
      	# 私有成员
      	__air_sister = "3名空姐"
      	# 公有绑定方法
      	def fly(self):
      		print("飞机要非要平流层,才能减少震动",self.__air_sister)
      	# 私有绑定方法
      	def __age(self):
      		print("空姐年龄保密")
      	# 公有无参方法
      	def fly2():
      		print("航天飞机飞到天空层,翱翔太空")
      	# 私有无参方法
      	def __earn():
      		print("机长的收入保密")
      	def pub_get1(self):
      		print(self.__air_sister)
      		self.__age()
      	def pub_get2():
      		print(Plane.__air_sister)
      		Plane.__earn()
      # 实例化对象
      obj = Plane()
      # 方法一.访问私有成员 (不推荐)
      # python私有化: 采取了改名策略 =>  _类名 + __air_sister
      # print(obj.__air_sister)
      print(obj._Plane__air_sister)
      print(Plane.__dict__)
      """
      {'__module__': '__main__', 'captian': '赵沈阳', 
      '_Plane__air_sister': '3名空姐', 
      'fly': <function Plane.fly at 0x7f2774616158>, '_Plane__age': <function Plane.__age at 0x7f27746161e0>, 'fly2': <function Plane.fly2 at 0x7f2774616268>, '_Plane__earn': <function Plane.__earn at 0x7f27746162f0>, '__dict__': <attribute '__dict__' of 'Plane' objects>, '__weakref__': <attribute '__weakref__' of 'Plane' objects>, '__doc__': None}
      """
      # 方法二.访问私有成员 (使用类中的公有方法,间接访问私有成员) (推荐)
      obj = Plane()
      obj.pub_get1()
      Plane.pub_get2()
      # ### 2.使用类对象删除相应的成员
      """
      1.对象可以访问类中的公有成员,但是无权修改或者删除该类中的成员
      2.对象在访问成员时,优先访问该对象自己的成员,如果没有在访问类的,类如果也没有直接报错;
      """
      # 删除对象成员属性
      obj.captian = "赵世超"
      del obj.captian
      print(obj.captian)
      # 删除对象成员方法
      obj.basketball = lambda : print("我的私人飞机可以在天上打篮球")
      print(o编程客栈bj.__dict__)
      obj.basketball()
      del obj.basketball
      print(obj.__dict__)
      # obj.basketball() error
      # 删除类中成员属性
      del Plane.captian
      print(Plane.__dict__)
      # Plane.captian
      # print(obj.captian) error
      # 删除类中成员方法
      del Plane.fly2
      # Plane.fly2() error
      # 注意: 对象无法调无参方法!! 返回来,类可以调用对象的绑定方法么? 可以!!
      Plane.fly(obj)
      

      小提示:

      如果在类外添加公有方法
      def  __abc():
          print(1)
       在类外定义的方法__abc()只是简单的函数名字而已,之后在类里面定义
      的时候,__abc()才是私有方法。
      删除或创建私有的方法,要在类外去操作 
      对象在调用属性的时候,先看自己有没有,然后在看类中的属性
      class Plane():
          def fly1(self):
              print("飞机要起飞")
         def fly2(self):
             print("飞机真的要起飞了",self.captian)
         def fly3():
              print("飞机不起飞")编程客栈
      Plane.fly1(1) 类可以调用有参的方法,随便穿个值进去即可
      Plane.fly2(1) 这样的话就报错,Plane.fly2(obj) 把对象传进去就可以出结果
      如果说对象调用类中无参的方法是不会成功的
      

      5. 小练习

      1.请定义一个交通工具(Vehicle)的类,其中有:
      属性:速度(公有speed), 车的类型(私有type)
      方法:速度(公有setSpeed),加速(私有speedUp),减速(私有speedDown)
      让公有setSpeed调用私有speedUp和私有speedDown
      2.用类改写:猜数字游戏:
      一个类有两个成员num和guess,
      num有一个初值100。
      定义一个方法guess,
      调用guess,如果大了则提示大了,小了则提示小了。等于则提示猜测成功。
      3.创建一个圆Circle类。
      为该类提供一个变量r表示半径
      方法一返回圆的面积,方法二返回圆的周长;
      

      小提示:

      如果在类内的话,都是用对象调用方法或变量(self.speed、self.eat()),如果不是类的话,可以直接调变量和方法
      r = 3 归属于circle这个类
      self.r = r 归属于self这个对象
      

      答案:

      """
      1.请定义一个交通工具(Vehicle)的类,其中有:
      属性:速度(公有speed), 车的类型(私有type)
      方法:速度(公有setSpeed),加速(私有speedUp),减速(私有speedDown)
      让公有setSpeed调用私有speedUp和私有speedDown
      """
      class Vehicle():
      	speed = "百公里1小时"
      	__type = "拖拉机小蹦蹦"
      	def setSpeed(self):
      		self.__speedUp()
      		self.__speedDown()
      	def __speedUp(self):
      		print("我是加速方法,速度{}".format(self.speed))
      	def __speedDown(self):
      		print("我是减速方法,小车的类型是{}".format(Vehicle.__type))
      obj = Vehicle()
      obj.setSpeed()
      """
      2.用类改写:猜数字游戏:
      一个类有两个成员num和guess,
      num有一个初值100。
      定义一个方法guess,
      调用guess,如果大了则提示大了,小了则提示小了。等于则提示猜测成功。
      """
      import re
      class GuessGame():
      	num = 100
      	def guess(self):
      		while True:
      			n = input("请输入要猜测的数字")
      			obj = re.search(r"^\d+$",n)
      			# print(obj)
      			if obj:
      				n = int(obj.group())
      				if n > self.num:
      					print("大了..")
      				elif n < self.num:
      					print("小了..")
      				elif n == self.num:
      					print("ok~ bingo")
      					break
      			else:
      				print("输入的内容不正确")
      # obj = GuessGame()
      # obj.guess()
      """
      3.创建一个圆Circle类。
      为该类提供一个变量r表示半径
      方法一返回圆的面积,方法二返回圆的周长;
      """
      import math
      class Circle():
      	r = 3
      	def area(self):
      		return math.pi * self.r ** 2
      	def perimeter(self):
      		return 2 * math.pi * self.r
      obj = Circle()
      res1 = obj.area()
      res2 = obj.perimeter()
      print(res1,res2)
      # 方法二 (推荐)
      import math
      class Circle():
      	def __init__(self,r):
      		self.r = r	
      	def area(self):
      		return math.pi * self.r ** 2
      	def perimeter(self):
      		return 2 * math.pi * self.r
      obj = Circle(4)
      res1 = obj.area()
      res2 = obj.perimeter()
      print(res1,res2)
      

      总结

      本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

      0

      上一篇:

      下一篇:

      精彩评论

      暂无评论...
      验证码 换一张
      取 消

      最新开发

      开发排行榜