python中的类

1、如何创建一个类：

class是关键字，表示类
类创建的语法：
class 类名称:
…… 变量 ……
…… 方法 ……
说明：Python类中定义的函数称之为方法
有了类就可以通过类来创建一个对象（创建对象的过程也称之为：类实例化过程。）。
对象创建的语法：对象标识符 = 类名称（）
说明：对象使用访问操作符 “.”对类的方法进行调用访问。对象标识符.方法名称（）。

	class person():
	    #类的成员方法
	    def greeting(self):
	        print('hello')
	obj1=person()
	obj1.greeting()#

2、类中的方法

Python3面向对象的概念中，关于类的方法一共有四种：
实例方法 （ instanceMethod ）- 使用频次最多
类方法（classMethod）- 根据需求适度
静态方法（staticMethod）- 根据需求适度
普通方法（ordinaryMethod）- 使用频次很少
这四种方法的区别：定义语法格式上；对各种类型变量的访问权限上。

2.1 实例方法 instanceMethod

实例方法是属于实例对象的，但也可以使用类直接调用。但两者调用的方式有区别（传递参数个数上面）。
实例方法在定义中，第一个参数必须为 self （当然参数名称也可以随意定义，但是 self 是python默认的规定最好不修改）
实例方法定义的语法规范：
def 方法名称 (self [, arg1[, arg2, …[, argN]]]):
第一个参数 self 代表 调用该方法的实例对象，在使用实例对象调用方法的时候 可以忽略第一个参数，只需传递满足在实例方法定义过程中的 n-1 个后续参数数量即可。
而类调用时，需要传递与定义数量匹配的n个参数，第一个 self 只当做一个参数变量名称而已。

	#创建一个名为ClassName的类
	class ClassName():
		#类的成员方法
	    def instanceMethod(self,name,age):
	        print('姓名：{}'.format(name),end='')
	        print('年龄：{}'.format(age))
	#使用ClassName创建一个实例对象
    instanceObj=ClassName()
    #使用实例对象调用方法的时候可以忽略第一个参数。
    instanceObj.instanceMethod('张三',18)#姓名：张三年龄：18
    #类调用时，需要传递与定义数量匹配的n个参数，第一个 self 只当做一个参数变量名称而已。
    ClassName.instanceMethod(0,'李四',19)#姓名：李四年龄：19

2.1.1 特殊的类实例方法 —— 构造方法 __init__

构造方法是类成员方法中特殊的一种方法，其方法名称为 __init__( )。
该方法无需对象通过访问操作符调用，在类实例化对象的过程中自动调用。
构造方法的作用有两个：为对象创建内存空间，实例对象的实例变量参数初始化
语法：
class 类名称:
# 类的构造方法
def _init_(self，参数列表 ):
……方法体……

	#创建一个类
	class Person():
	    def __init__(self):
	        print('Persion的构造方法')
	#构造方法在对象创建时就执行
   	obj1=Person()#Persion的构造方法

2.1.2 特殊的类实例方法2 —— 实例对象输出 __str__

当我们使用 print() 函数输出使用类创建好的实例对象的时候，默认输出的是当前实例对象的十六进制内存地址。但只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据。__str__方法需要返回一个字符串，当做这个对象的描写。

	#创建一个类
	class Person():
    def __str__(self):
        return '这是一个__str__方法'
	obj1=Person()#Persion的构造方法
    print(obj1)
    #这是一个__str__方法
    #若没写__str__方法则输出前实例对象的十六进制内存地址<__main__.Person object at 0x0000021DE50DB4C0>

2.2 实例变量（成员属性）

与实例方法 遥相呼应 的是实例变量。实例变量属于类创建的实例对象的，这些属性是所有实例对象都拥有的。只不过每个实例对象的属性值各异。
实例变量 均在构造方法__init__( )中声明并初始化。
语法： self.实例变量名称 = 值 # self 代表当前创建的实例对象
类中的实例方法均可以访问实例变量。

2.2.1 实例变量的创建及初始化

一般在创建构造方法的时候，充分利用构造方法为类实例变量（成员属性）初始化的这一典型作用。

	class Person():
	    def __init__(self,name,age):
	        #在构造方法中创建实例变量并初始化
	        #self是对类创建对象的引用，代表当前对象
	        self.name=name
	        self.age=age
	if __name__ == "__main__":
	    #通过构造方法传参调用方式，实现对当前类实例对象中的实例变量初始化
	    obj1=Person('张三',18)

2.2.1 类的实例变量的两种输出方式

方式一：通过实例对象实现对类创建的对象实例变量进行输出 。
方式二：通过定义类的实例方法实现对类创建的对象实例变量进行输出。

#方式一：
	if __name__ == "__main__":
	    obj1=Person('张三',18)
    	print('姓名：%s 年龄：%d' %(obj1.name,obj1.age))#姓名：张三 年龄：18
#方式二：	
	class Person():
	    def __init__(self,name,age):
	        #在构造方法中创建实例变量并初始化
	        #self 是对类创建对象的引用，代表当前对象
	        self.name=name
	        self.age=age
	    def show(self):#通过定义类的实例方法实现对类创建的对象实例变量进行输出
        	print('姓名：%s 年龄：%d' %(obj1.name,obj1.age))
    if __name__ == "__main__":
	    obj1=Person('张三',18)
    	obj1.show()#姓名：张三 年龄：18

3、类方法与类变量

类方法是属于类本身的，但也可以使用对象实例调用。但两者调用的方式有区别（传递参数个数上面）。类方法在定义中，第一个参数必须为 cls（当然参数名称也可以随意定义，但是 cls 是python默认的规定最好不修改）
类方法定义的语法规范：
@classmethod
def 方法名称 (cls [, arg1[, arg2, …[, argN]]]) :

3.1 类方法的调用

第一个参数 cls 代表 当前的类，在使用类直接调用方法的时候 忽略第一个参数，只需传递满足在实例方法定义过程中的 n-1 个后续参数数量即可。而类的对象实例调用时，同样需要传递与定义数量匹配的n-1个参数。

class ClassName():
	 @classmethod #classmethod 修饰符对应的函数不需要实例化，不需要self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
    def classMethod(cls,arg1):
        print('-->{}'.format(cls))
        print('-->{}'.format(arg1))
if __name__ == "__main__":
    inshtance=ClassName()
    ClassName.classMethod('class...')
    inshtance.classMethod('instance...')
'''
输出：
--><class '__main__.ClassName'>
-->class...
--><class '__main__.ClassName'>
-->instance...
'''

3.2 类变量的定义及访问操作

类变量 与 类方法 可以成对使用，同样类方法也可访问操作实例变量。
**类变量 声明在类中，类中的各种类型方法（除了普通方法之外）**均可以访问。
类方法中也可操作实例变量但只能进行赋值操作

class ClassName():
     
    # 定义一个类变量
    classVariable = 'I am a class Variable.'
     
    # 类的构造方法
    def __init__(self):
        # 定义一个类实例变量
        self.instanceVariable = 'I am a instance variable.'
        pass
    pass
 
    # 定义一个类方法
    @classmethod
    def classMethod(cls, parameter):
        print('\nI am class method, I can visit class variable and instance variable.')
 
        # 访问类变量
        print('I am class method, I can modifying the class variable')
        classVariable = parameter + ': class variable had updated.'
        print(classVariable)
 
        # 访问实例变量
        print('I am class method, I can modifying the instance variable')
        cls.instanceVariable = parameter + ': instance variable had updated.'
        print(cls.instanceVariable + '\n')
        pass

if __name__ == "__main__":

    inshtance=ClassName()
    ClassName.classMethod('class...')
    inshtance.classMethod('instance...')

4、静态方法

静态方法是属于类本身的，但也可以使用对象实例调用。但两者调用的方式有区别（传递参数个数上面）。没有 cls 和 self 参数限制的方法我们称之为静态方法。
静态方法定义的语法规范：
@staticmethod #使用装饰器方式定义，告知Pyhton解析器该方法为类方法，解析器优化该方法的执行效率。
def 方法名称 ([, arg1[, arg2, …[, argN]]]) :

4.1静态方法的调用

1、静态方法是 类中的方法，不需要被实例
​ 2、可以使用【类名.静态方法名()】的形式调用，同时也可以使用实例对象调用
​ 3、切记：静态方法没有self 和 cls这样的参数限制

# 创建一个类
class ClassName():
     
    # 定义一个类变量
    classVariable = 'I am a class Variable.'
     
    # 类的构造方法
    def __init__(self):
        # 定义一个类实例变量
        self.instanceVariable = 'I am a instance variable.'
        pass
    pass
 
    # 定义一个静态方法
    @staticmethod
    def staticMethod(arg1):
        print('\nI am static method, I can visit class variable and instance variable.')
        print('>> {0}'.format(arg1))
        # 访问类变量
        print('I am static method, I can modifying the class variable')
        classVariable = arg1 + ': class variable had updated.'
        print(classVariable)
 
        # 访问实例变量
        print('I am static method, I can modifying the instance variable')
        instanceVariable = arg1 + ': instance variable had updated.'
        print(instanceVariable + '\n')
        pass
 
 
# 脚本程序入口
if __name__ == '__main__':
    # 使用Person类创建一个对象1
    instance = ClassName()
    # 通过类实例访问classMethod()
    instance.staticMethod('static method is calling by instance……')
    # 通过类名称直接访问classMethod()
    ClassName.staticMethod('static method is calling by class……')