原 python学习2019/4/29

类变量与实例变量的区别

实例方法一般用来操作实例变量，
但是也可以用来操作类变量
class Student():
sum=0
name=’’
age = 0

def __init__(self,name,age):  #构造函数
    self.name=name
    self.age=age
    self.__class__.sum +=1
    print('当前班级学生总数为' + str(self.__class__.sum))

def do_homework(self):
    print('homework')

#class Printer():
#def print_file(self):
#print('name: '+ self.name)
#print('age: '+ str(self.age))

student1=Student(‘子路’,18)
student2=Student(‘王子’,8)
#student1.do_homework()
#print(student1.name)
#print(student2.age)
print(Student.sum)

如何定义一个类方法

@classmethod
def plus_sum(cls):
pass

@classmethod
def plus_sum(cls):
cls.sum += 1
print(cls.sum)

调用类方法
Student.plus_sum()
通过对象调用类方法
student.1.puls_sum()
都可以调用。
但是建议不要通过对象调用类方法。

静态方法

@staticmethod
def add(x,y):
print(‘这是一个静态方法’)

实例方法一般用self指代参数
类方法一般用cls指代参数
静态方法不强制传入指代参数
调用静态方法
student1.add(1,2)
通过类调用静态方法
Student.add(1,2)

可以在内部调用类方法
@staticmethod
def add(x,y):
print(Student.sum)

基本上静态方法与类方法是相同的
但是静态方法与类的关联性非常弱
一般来说只有在这个方法非常纯粹的情况下才会使用静态方法

成员的可见性

类是有内外之分的

内部调用方法
def do_homework(self):
self.do_english_homework()
print(‘homework’)
def do_english_homework(self):
print(‘english’)

外部调用方法
student1.do_homework()

def init(self,name,age): #构造函数
self.name=name
self.age=age
self.score=0
# self.class.sum +=1
# print(‘当前班级学生总数为’ + str(self.class.sum))

def marking(self, score):
    if score<0:
        score=0
        return '不能给别人负分.'
    self.score=score
    print(self.name+'同学本次考试的分数为:'+str(self.score))

result = student1.marking(-1)
print(result)

不要直接在外部给内部方法赋值
如果需要赋值建议在方法处赋值
因为你可以在方法内对对象进行一个判断
保证赋值的一个范围，以保护赋值对象的安全性

公开的成员和私有的成员

public，private
默认公开的方法
方法前加__marking
__双下划线就是私有的方法
init__后面也加双下划线的话就又变成公开的方法
一般这样使用的是python默认的方法
实例变量也是如此__双下划线
但是实例变量加双下划线还是可以调取
是因为用动态变量的方式又添加了一个实例变量
而不是调用的原来的实例变量
所以，你硬要调用私有变量还是可以用__dict
查到私有变量的值从而调用
但是，尽量不要使用这种方法调用，破坏类的原始定义

面向对象的三大特性

1。继承性
class student 是一个类
student 比如是属于class human类目里，那么
这个就是继承性。
注意，写类的时候尽量一个模块写一个类。好区分。

class Human():
sum = 0
def init(self,name,age): #构造函数
self.name=name
self.age=age
def get_name(self):
print(self.name)

from p4 import Human 一般用import 写法导入父类的模块

class Student(Human): （内的类是括号外的父类，括号外是子类）
def do_homework(self):
print(‘english homework’)

子类继承父类的变量

（python，一个子类可以有多个父类，但是首先要用好单继承，再想多继承）
from p4 import Human

class Student(Human):
def init(self,school,name,age):
self.school = school
# Human.init(self,name,age) 调用父类方法的两种写法
super(Student,self).init(name,age) 一般建议用super来调用父类方法
他不止可以调用构造函数
还可以调用实例方法
————————————————————————————————————

from p4 import Human

class Student(Human):
def init(self,school,name,age):
self.school = school
# Human.init(self,name,age)
super(Student,self).init(name,age)

# sum=0
# def __init__(self):  #构造函数
#     self.__score=0
#     self.__class__.sum +=1

def do_homework(self):
    print('english homework')

student1=Student(‘非正常人研究中心’,‘子路’,18)
student2=Student(‘美丽高中’,‘小云’,15)

student1.do_homework()
print(student1.school)
print(student1.name)
print(student1.age)
#print(get_name)

——————————————————————————————

class Human():
sum = 0
def init(self,name,age): #构造函数
self.name=name
self.age=age
def get_name(self):
print(self.name)

def do_homework(self):
    print('这是一个父类')

在子类方法与父类方法同名的情况下，默认调用子类的方法。

class Human():
sum = 0
def init(self,name,age): #构造函数
self.name=name
self.age=age
def get_name(self):
print(self.name)

def do_homework(self):
    print('这是一个父类')

——————————————————————————
from p4 import Human

class Student(Human):
def init(self,school,name,age):
self.school = school
# Human.init(self,name,age)
super(Student,self).init(name,age)

# sum=0
# def __init__(self):  #构造函数
#     self.__score=0
#     self.__class__.sum +=1

def do_homework(self):
    super(Student,self).do_homework()
    print('english homework')

student1=Student(‘非正常人研究中心’,‘子路’,18)
student2=Student(‘美丽高中’,‘小云’,15)

student1.do_homework()
print(student1.school)
print(student1.name)
print(student1.age)
#print(get_name)

2。封装性
类属于一种封装，是从模拟世界的角度，
把一些变量，方法，用特征和行为表现出来
封装性又多种表示方法
3.多态性