参考菜鸟教程
https://www.runoob.com/python/python-object.html
各种超参数的介绍
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员:类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
局部变量:定义在方法中的变量,只作用于当前实例的类。
实例变量:在类的声明中,属性是用变量来表示的。这种变量就称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的。
继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
实例化:创建一个类的实例,类的具体对象。
方法:类中定义的函数。
对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。
类的格式
创建类
使用 class 语句来创建一个新类,class 之后为类的名称并以冒号结尾:
class ClassName:
‘类的帮助信息’ #类文档字符串
class_suite #类体
实例
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Employee:
'所有员工的基类'
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print "Total Employee %d" % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
创建实例对象
实例化类其他编程语言中一般用关键字 new,但是在 Python 中并没有这个关键字,类的实例化类似函数调用方式。
以下使用类的名称 Employee 来实例化,并通过 init 方法接收参数。
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
用创建的对象去调用类中的方法
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount
结果
Name : Zara ,Salary: 2000
Name : Manni ,Salary: 5000
Total Employee 2
python内置属性
Python内置类属性
dict : 类的属性(包含一个字典,由类的数据属性组成)
doc :类的文档字符串
name: 类名
module: 类定义所在的模块(类的全名是’main.className’,如果类位于一个导入模块mymod中,那么className.module 等于 mymod)
bases : 类的所有父类构成元素(包含了一个由所有父类组成的元组)
print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__
结果
Employee.doc: 所有员工的基类
Employee.name: Employee
Employee.module: main
Employee.bases: ()
Employee.dict: {‘module’: ‘main’, ‘displayCount’: <function displayCount at 0x10a939c80>, ‘empCount’: 0, ‘displayEmployee’: <function displayEmployee at 0x10a93caa0>, ‘doc’: ‘\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb’, ‘init’: <function init at 0x10a939578>}
销毁对象
del pt1
del pt2
del pt3
下面是面向对象三大方法
类的继承
class Parent: # 定义父类
parentAttr = 100
def __init__(self):
print "调用父类构造函数"
def parentMethod(self):
print '调用父类方法'
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print "父类属性 :", Parent.parentAttr
class Child(Parent): # 定义子类
def __init__(self):
print "调用子类构造方法"
def childMethod(self):
print '调用子类方法'
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法 - 设置属性值
c.getAttr() # 再次调用父类的方法 - 获取属性值
以上代码执行结果如下:
调用子类构造方法
调用子类方法
调用父类方法
父类属性 : 200
方法重写
class Parent: # 定义父类
def myMethod(self):
print '调用父类方法'
class Child(Parent): # 定义子类
def myMethod(self):
print '调用子类方法'
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
执行以上代码输出结果如下:
调用子类方法
#多重继承就是括号中多几个父类
class sample(speaker,student):
类的私有属性
__private_attrs:两个下划线开头,声明该属性为私有,不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类的内部,使用 def 关键字来定义一个方法,与一般函数定义不同,类方法必须包含参数 self,且为第一个参数,self 代表的是类的实例。
self 的名字并不是规定死的,也可以使用 this,但是最好还是按照约定是用 self。
类的私有方法
__private_method:两个下划线开头,声明该方法为私有方法,只能在类的内部调用 ,不能在类的外部调用。self.__private_methods。
类的私有属性实例如下:
实例(Python 3.0+)
#!/usr/bin/python3
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print (self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount) # 报错,实例不能访问私有变量
执行以上程序输出结果为:
1
2
2
Traceback (most recent call last):
File "test.py", line 16, in <module>
print (counter.__secretCount) # 报错,实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'
类的私有方法实例如下:
实例(Python 3.0+)
#!/usr/bin/python3
class Site:
def __init__(self, name, url):
self.name = name # public
self.__url = url # private
def who(self):
print('name : ', self.name)
print('url : ', self.__url)
def __foo(self): # 私有方法
print('这是私有方法')
def foo(self): # 公共方法
print('这是公共方法')
self.__foo()
x = Site('菜鸟教程', 'www.runoob.com')
x.who() # 正常输出
x.foo() # 正常输出
x.__foo() # 报错
类的专有方法:
init : 构造函数,在生成对象时调用
del : 析构函数,释放对象时使用
repr : 打印,转换
setitem : 按照索引赋值
getitem: 按照索引获取值
len: 获得长度
cmp: 比较运算
call: 函数调用
add: 加运算
sub: 减运算
mul: 乘运算
truediv: 除运算
mod: 求余运算
pow: 乘方
Python3 中类的静态方法、普通方法、类方法
静态方法: 用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法,类的静态方法可以没有参数,可以直接使用类名调用。
普通方法: 默认有个self参数,且只能被对象调用。
类方法: 默认有个 cls 参数,可以被类和对象调用,需要加上 @classmethod 装饰器。
class Classname:
@staticmethod
def fun():
print('静态方法')
@classmethod
def a(cls):
print('类方法')
# 普通方法
def b(self):
print('普通方法')
笑死我了这个图
我直接照搬了
封装
与Java不同,Python的访问控制相对简单,没有public,private,protected等属性
但是如果你必须实现数据隐藏,也是可以的,具体方法就是在变量名前加双下划线。如**privatedata=0**,定义私有方法则是在方法名称前加上**下划线。但即使对于隐藏的数据,也是有一定的方法可以访问的。方法就是__className__attrName。**
【封装原则】
-
将不需要对外提供的内容都隐藏起来;
-
把属性都隐藏,提供公共方法对其访问。
这段参考
https://www.jianshu.com/p/2aeee1ed59ec
# Python中的类的概念和其他语言相比没什么不同
# 比较特殊的是protected和private在Python中是没有明确限制的
# 一个惯例是用单下划线开头的表示protected,用双下划线开头的表示private
# Python中定义一个类
class class1:
"""Class A""" # 类定义中紧跟着类名字下一行的字符串叫做docstring,
# 可以写一些用于描述类的介绍,如果有定义则通过“类名.__doc__”访问
print('class1')
# 构造函数,用关键字“__init__”
# 在实例化对象时,构造函数被自动调用,一般用于初始化变量
# self:在类中的方法,第一个参数必须是self
def __init__(self,name,job):
print('I am __init__ in class1')
print('My name is '+ name+' My job is '+job)
# 定义属性,一定要用self.属性名
self.myname=name
self.myjob=job
# 定义类中的方法:
def myfunc(self,funcName):
print('I an in class1.myfunc')
print(funcName)
# 在实例化类时传入参数给构造函数
a=class1("keloli","student")
print(a.myname)
a.myfunc("func1")
# 输出
class1
I am __init__ in class1
My name is keloli My job is student
keloli
I an in class1.myfunc
func1
# 类的继承与重载
# 继承:把某一个或多个类(基类)的特征拿过来
# 重载:在子类(派生类)中多继承来的特征重新定义
# 单继承:父亲可以说话,小儿子继承了父亲,但是减弱了父亲的说话能力
# 父亲类(基类)
class father():
def speak(self):
print("father speak")
# 大儿子类(单继承父亲类)
class son1(father):
pass
s1=son1()
s1.speak()
# 多继承:父亲可以说话,母亲可以写字,
# 女儿继承了父亲和母亲,还可以听
# 母亲类(基类)
class mother():
def write(self):
print('mother write')
# 女儿类(多继承父亲和母亲)
class daughter(father,mother):
def listen(self):
print('daughter listen')
dau=daughter()
dau.speak()
dau.write()
dau.listen()
# 重载
# 小儿子类重载父亲类,减弱了父亲的说话能力
class son2(father):
def speak(self):
print('son2 speak')
s2=son2()
s2.speak()
# 输出
father speak
father speak
mother write
daughter listen
son2 speak