一: 类的定义

# 语法
class 类名:
pass
对象=类名() # 范例
class Person:
contry = '中国' def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex def eat(self):
print('%s正在吃饭'%self.name) wangys=Person('wangys',18,'男')
print(wangys.name)
print(wangys.age)
print(wangys.sex)

二  类成员

  • 变量(字段)
  • 方法
  • 属性

2.1  变量

变量又可以称之为字段,有实例变量(字段),类变量(静态字段)两大类,同时每大类又有私有变量

2.1.1 实例变量

class Persion:

    def __init__(self,name,age):
self.name = name # 实例变量
self.age = age # 实例变量 def info(self):
print(self.name,self.age) wangys = Persion('wangys',18)
print(wangys.name,wangys.age) #对象在外部调用实例变量
wangys.info() # 对象通过方法在内部调用实例变量

2.1.2 实例的私有变量

class Persion:

    def __init__(self,name,age):
self.name = name # 实例变量
self.__age = age # 实例的私有变量 def info(self):
print(self.name,self.__age) wangys = Persion('wangys',18)
print(wangys.name,wangys.__age) # 在外部直接调用会报错
wangys.info() # 可以在类内部通过方法调用私有变量

2.1.3 类变量

class Persion:
country = 'China' # 类变量(静态字段) def __init__(self,name,age):
self.name = name # 实例变量
self.age = age # 实例变量 wangys = Persion('wangys',18)
print(wangys.name,wangys.age) # 实例变量由实例进行调用
print(Persion.country) # 类变量(静态字段)推荐使用类直接调用

2.1.4 类私有变量

class Persion:
__country = 'China' # 类私有变量 def __init__(self,name,age):
self.name = name # 实例变量
self.age = age # 实例变量
def info(self):
print(Persion.__country) wangys = Persion('wangys',18)
print(wangys.name,wangys.age) # 实例调用实例变量
print(Persion.__country) # 外部调用类私有变量报错
print(wangys.info()) # 内部调用类的私有变量可以正常调用

2.3 方法

2.3.1  实例方法

class Persion:
def __init__(self,name,age):
self.name = name
self.age = age def info(self): # 实例方法,调用了封装的实例变量
print(self.name,self.age) wangys = Persion('wangys',18)
wangys.info()

2.3.2   静态方法

class Person:

    def __init__(self,name,age):
self.name = name
self.age = age def info(self): # 实例方法
print(self.name,self.age) @staticmethod
def func(a,b): # 静态方法(没有调用封装在对象种的字段)
return a+b wangys = Person('wangys',18)
Person.func(1,2) # 静态方法通过类调用即可
print(ret)

2.3.3  类方法

class Persion:
def __init__(self,name,age):
self.name = name
self.age = age def info(self): # 实例方法
print(self.name,self.age) @staticmethod
def func(a,b): # 静态方法
return a + b @classmethod
def func1(cls,c,d): # 类方法
return c + d ret = Persion.func1(1,2)
print(ret)

2.4 属性

当一个方法只需要封装在self的参数,并且功能更像一个属性,而非方法,例如圆的面积,这个面积更像是园的属性

class  Circle:
def __init__(self,r):
self.r = r def area(self): # 定义一个求面积的方法
return 3.14*self.r*self.r c1 = Circle(1)
print(c1.area()) # 查看面积时需要加上小括号,像方法,而不是这个园的属性 class Circle:
def __init__(self,r):
self.r = r
@property
def area(self): # 定义属性
return 3.14*self.r*self.r c1 = Circle(1)
print(c1.area) # 直接用点调用即可,更像时园的属性,而非方法

命名空间

class Course:
language = 'Chinese'
def __init__(self,teacher,name,period,price):
self.teacher = teacher
self.name = name
self.period = period
self.price = price print(Course.language)
python = Course('wangys','python','6 months',20000)
print(python.language)

静态属性

  • 类的属性和方法可以被类调用,也可以被对象调用
  • 类的静态属性当使用类进行修改时,使用字典的方式修改时不允许的,但可以通过 类名.属性=。。。 进行修改
  • 通过

类的静态属性可以被类调用,也可以被对象调用

class Course:
language = 'Chinese'
def __init__(self,teacher,name,period,price):
self.teacher = teacher
self.name = name
self.period = period
self.price = price print(Course.language) # 类调用
python = Course('wangys','python','6 months',20000)
print(python.language) # 对象调用 # 不论是类调用还是对象调用,都是可以的

类的静态属性当通过类进行修改的时候,只能通过 类命.属性的方式进行修改

class Course:    # 定义了一个课程类
language = 'chinese' # 有一个语言静态属性
def __init__(self,teacher,name,period,price): # ————init__方法有老师,课程名称,周期,价格等
self.teacher = teacher
self.name = name
self.period = period
self.price = price Course.language = 'EN' # 通过类名.属性方式修改
print(Course.language)
# EN Course.__dict__['language'] = 'chinese' # 通过字典的方式修改不允许
print(Course.language)
# TypeError: 'mappingproxy' object does not support item assignment

类可以直接修改静态属性,修改后,对象与类都共享修改

class Course:
language = 'Chinese'
def __init__(self,teacher,name,period,price):
self.teacher = teacher
self.name = name
self.period = period
self.price = price python = Course('wangys','python','6 months',20000)
linux = Course('wc','linux','6 months',20000)
print(Course.language) # 类可以调用
print(python.language) # 对象可以调用
print(linux.language) # 对象可以调用
Course.language = 'english' # 类修改静态属性
print(Course.language) # 可以看到已经修改
print(python.language) # 对象共享修改
print(linux.language) # 对象共享修改 Chinese
Chinese
Chinese
english
english
english

通过对象进行静态属性修改,实际上是在对象的 命名空间里增加了一个变量,并没有改变类命名空间的静态属性,当然其他对象对该静态属性也没有改变、、

class Course:
language = 'chinese'
def __init__(self,teacher,name,period,price):
self.teacher = teacher
self.name = name
self.period = period
self.price = price
def func(self):
return self.price python = Course('eval','python','6 months',20000)
linux = Course('wangys','linux','7 months',10000)
print(Course.language)
print(python.language)
print(linux.language) python.language = 'english' # 对象修改静态属性
print(python.language) # 对象的命名空间里有了该名称
print(linux.language) # 其他对象并没有改变
print(Course.language) # 类也一样

# 结论 对于类的不可变的数据类型静态属性,使用类进行操作

# 对于类的可变数据类型静态属性,修改时共享的,重新赋值是独立的

class Course:
language = ['chinese']
def __init__(self,name,period,price):
self.name = name
self.period = period
self.price = price def func(self):
pass python = Course('python','6 months',20000)
linux = Course('linux','6 months',20000) python.language[0] = 'English' # 对象对可变数据类型进行修改
print(python.language) # 对象读取的是修改后的值
print(Course.language) # 类读取的是修改后的值
print(linux.language) # 其他对象读取的也是修改后的值
python.language=['Chinses'] # 对象重新赋值
print(python.language) # 读取的是修改后的值
print(Course.language) # 读取的原来的值
print(linux.language) # 读取的是原来的值 ['English']
['English']
['English']
['Chinses']
['English']
['English'] # 如果是修改,会先找到该列表,然后做修改,因为是类静态属性,所以找到的是类的静态属性,然后做的是对类列表的修改,都生效,如果是赋值,会在对象的命名空间重新生成一个对象属性,故该的是对象属性,而不是类的属性,所以类和其他对象没有影响

例子:记录实例化次数

class  Foo:
count = 0 def __init__(self):
Foo.count +=1 f1 = Foo()
print(f1.count) f2 = Foo()
print(f1.count)

# 1
# 2

绑定方法

def  func():
pass class Foo:
def func(self):
pass
f1 = Foo()
print(func)
print(Foo.func)
print(f1.func) <function func at 0x000001A9AEA37048>
<function Foo.func at 0x000001A9B071E1E0>
<bound method Foo.func of <__main__.Foo object at 0x000001A9B071D1D0>> # 绑定方法 # 对象在调用类的方法是,实际上是将self的值传递给方法,两者发生了绑定关系

类的组合

  • 组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合
  • 当类之间有显著不同,并且较小的类是较大的类所需要的组件时,用组合比较好

人狗大战(人使用武器攻击)

# 定义了一个Dog类,有名字,攻击力,血量,种类,并且有咬的技能(方法)
class Dog:
def __init__(self,name,aggr,hp,kind):
self.name = name
self.aggr = aggr
self.hp = hp
self.kind = kind
def bite(self,person):
person.hp -= self.aggr # 定义了一个人的类,有名字,攻击力,血量,性别,金钱,有攻击技能,有获取武器的技能
class Person:
def __init__(self,name,aggr,hp,sex):
self.name = name
self.aggr = aggr
self.hp = hp
self.sex = sex
self.money = 0 def attack(self,dog):
dog.hp -= self.aggr def get_weapon(self,weapon):
if self.money > weapon.price: # 得到武器之前先判断人是否有钱买整个武器
self.money -= weapon.price # 得到武器后人的钱减去武器的价钱
self.weapon = weapon # 给人类加了一个weapon属性
self.aggr += weapon.aggr # 人的攻击力加上武器的攻击力
else:
print('余额不足') # 如果钱不够,则报错 # 定义了一个武器类,有名称,攻击力,耐久度,价钱,还有大招hand18
class Weapon:
def __init__(self,name,aggr,njd,price):
self.name = name
self.aggr = aggr
self.njd = njd
self.price = price def hand18(self,dog):
if self.njd >0: # 使用大招有限度
dog.hp -= self.aggr *2 # 血量直接减去武器攻击力的两倍
self.njd -=1 # 耐久度减去1 w = Weapon('打狗棒',100,3,998) # 实例化一个打狗棒武器
alex = Person('alex',0.5,100,'male') # 实例化一个alex人对象
jin = Dog('金老板',100,500,'teddy') # 实例化一个狗对象
alex.money =1000 # 人的金钱增加,可以买武器
alex.get_weapon(w) # alex获得武器
alex.attack(jin) # 攻击狗对象
alex.weapon.hand18(jin) # 使用武器大招攻击
print(jin.hp)

圆环周长及面积

class Circle:

    role = '圆形'

    def __init__(self,radius):
self.radius = radius def perimeter(self):
return 3.14*2*self.radius def area(self):
return 3.14*(self.radius**2) c1 = Circle(1)
c2 = Circle(2)
print(c1.perimeter() + c2.perimeter())
print(c2.area() - c1.area()) class Ring(): name = '圆环' def __init__(self,inner_circle_radius,outer_circle_radius):
self.inner_circle_radius = inner_circle_radius
self.outer_circle_radius = outer_circle_radius
self.inner_circle = Circle(inner_circle_radius)
self.outer_circle = Circle(outer_circle_radius) def perimeter(self):
return self.inner_circle.perimeter() + self.outer_circle.perimeter() def area(self):
return self.outer_circle.area() - self.inner_circle.area() r1 = Ring(1,2)
print(r1.perimeter())
print(r1.area())

教授有生日,有教授课程

教授一个类,生日一个类,课程一个类,教授可以有生日,可以教授课程

class Brith_date:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day class Course:
def __init__(self,course_name,course_period,course_price):
self.course_name = course_name
self.course_period = course_period
self.course_price = course_price class Teacher:
def __init__(self,name,age,brith,course):
self.name = name
self.age = age
self.brith = brith
self.course = course
def teaching(self):
print('teaching') t1 = Teacher('wangys',18,Brith_date('2000','10','19'),Course('Python','6 months',20000))
print(t1.course.course_name)
print(t1.brith.year)

Pthon面向对象之基础的更多相关文章

  1. Python 面向对象编程基础

    Python 面向对象编程基础 虽然Pthon是解释性语言,但是Pthon可以进行面向对象开发,小到 脚本程序,大到3D游戏,Python都可以做到. 一类: 语法: class 类名: 类属性,方法 ...

  2. Pthon面向对象-补充知识

    Pthon面向对象-补充知识 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.tracemalloc 标准库tracemalloc,可以统计内存使用情况,通过下面的案例可以看出内 ...

  3. 第二章 Matlab面向对象编程基础

    DeepLab是一款基于Matlab面向对象编程的深度学习工具箱,所以了解Matlab面向对象编程的特点是必要的.笔者在做Matlab面向对象编程的时候发现无论是互联网上还是书店里卖的各式Matlab ...

  4. [.net 面向对象编程基础] (1) 开篇

    [.net 面向对象编程基础] (1)开篇 使用.net进行面向对象编程也有好长一段时间了,整天都忙于赶项目,完成项目任务之中.最近偶有闲暇,看了项目组中的同学写的代码,感慨颇深.感觉除了定义个类,就 ...

  5. [Java入门笔记] 面向对象编程基础(二):方法详解

    什么是方法? 简介 在上一篇的blog中,我们知道了方法是类中的一个组成部分,是类或对象的行为特征的抽象. 无论是从语法和功能上来看,方法都有点类似与函数.但是,方法与传统的函数还是有着不同之处: 在 ...

  6. [.net 面向对象编程基础] (2) 关于面向对象编程

    [.net 面向对象编程基础]  (2)  关于面向对象编程 首先是,面向对象编程英文 Object-Oriented Programming 简称 OOP 通俗来说,就是 针对对象编程的意思 那么问 ...

  7. [.net 面向对象编程基础] (3) 基础中的基础——数据类型

    [.net 面向对象编程基础] (3) 基础中的基础——数据类型 关于数据类型,这是基础中的基础. 基础..基础..基础.基本功必须要扎实. 首先,从使用电脑开始,再到编程,电脑要存储数据,就要按类型 ...

  8. [.net 面向对象编程基础] (4) 基础中的基础——数据类型转换

    [.net面向对象编程基础] (4)基础中的基础——数据类型转换 1.为什么要进行数据转换? 首先,为什么要进行数据转换,拿值类型例子说明一下, 比如:我们要把23角零钱,换成2.30元,就需要把整形 ...

  9. [.net 面向对象编程基础] (5) 基础中的基础——变量和常量

    [.net面向对象编程基础]  (5) 基础中的基础——变量和常量 1.常量:在编译时其值能够确定,并且程序运行过程中值不发生变化的量. 通俗来说,就是定义一个不能改变值的量.既然不能变动值,那就必须 ...

随机推荐

  1. Python学习笔记-条件语句

    学习代码如下 flag=False name = raw_input("请输入:"); if name == '羊爸爸': flag=True print 'Welcome Hom ...

  2. Web从入门到放弃<1>

    HTML大法: <01> <!DOCTYPE html> <html lang="en"> <head> <meta char ...

  3. 【转】【Linux】Linux下统计当前文件夹下的文件个数、目录个数

    [转][Linux]Linux下统计当前文件夹下的文件个数.目录个数 统计当前文件夹下文件的个数,包括子文件夹里的 ls -lR|grep "^-"|wc -l 统计文件夹下目录的 ...

  4. 卷积神经网络(matlab实现)

    卷积神经网络是看matlab 的一个toolbox入的门: https://github.com/rasmusbergpalm/DeepLearnToolbox 还有一篇原理推导文献,全是公式: ht ...

  5. linux shell中 if else for循环以及大于、小于、等于逻辑表达式的历程

    作者:邓聪聪 比如比较字符串.判断文件是否存在及是否可读等,通常用"[]"来表示条件测试. 注意:这里的空格很重要.要确保方括号的空格.笔者就曾因为空格缺少或位置不对,而浪费好多宝 ...

  6. linux 查看nginx如何启动

    执行命令: ps -A | grep nginx如果返回结果的话,说明有nginx在运行,服务已经启动

  7. linux软件安装、rpm操作命令、本地yum配置(有什么用)

    1.yum是什么? yum的全称是yellow dog updater,modified,是一个shell前端软件包管理器;基于RPM包管理,能够从指定的服务器下载RPM包并自动安装,可以自动处理依赖 ...

  8. JS打开新的窗口

    一.使用JS打开新窗口 1. 超链接<a href="http://www.wumz.me" title="Mauger`s Blog">Welco ...

  9. Weblogic12c 单节点安装

    第一节weblogic12c 的安装   WebLogic除了包括WebLogic Server服务器之外,还包括一些围绕WebLogic的产品,习惯上我们说的WebLogic是指WebLogic S ...

  10. Confluence 6 配置文件和key

    找到配置文件 缓存的配置文件是存储在 <confluence-home>/shared-home/config/cache-settings-overrides.properties 中的 ...