Python的类

目录

属性和方法

1.共有属性

2.私有属性（__）

公有方法和私有方法（__）

特殊方法：

1. __init__()

2. >>print obj

函数的属性：

类的多态和继承

多态：

继承：

方法的重载

重载运算符

把类当成模块

---

属性和方法

• 1.共有属性

• 2.私有属性（__）

class Human:
    name = 'ren'
    gender = 'male'
    age = '25'
    __money = 8000


zhangsan = Human()
zhangsan.name = 'zhangsan'
print(zhangsan.name) # zhangsan

print(zhangsan.__money) # error
 

公有方法和私有方法（__）

class Human:
    name = 'ren'
    gender = 'male'
    age = '25'
    __money = 8000

    def say(self):
        print("my name is %s i have %d"(self.name, self.__money))

    def __lie(self):
        print('i have 3000')

zhangsan = Human()
zhangsan.name = 'zhangsan'
print(zhangsan.name) # zhangsan

print(zhangsan.__money) # error

zhangsan.say() #right
zhangsan.__lie() #error

私有方法可以在内部进行调用

    def say(self):
        print("my name is %s i have %d"(self.name, self.__money))
        self.__lie()

    def __lie(self):
        print('i have 3000')


zhangsan.say()

特殊方法：

1. __init__()

__init__() #构造函数，生成对象时调用


### 初始化对象########
def __init__(self, name, gender, age):
    self.name = name
    self.gender = gender
    self.age = age

2. >>print obj

__str__()

def __str__(self):
    msg = 'hi ! I am the object of Human!!'
    return msg

print(Human.name) 
print(Human.__money) # error

print(zhangsan) # hi ! I am the object of Human!!


class Human:
'''
    111111
'''
   ....


# 内置属性
print(Human.__doc__) # 111111

函数的属性：

class Myclass():
    var1 = '类属性，静态属性'
    __var2 = '类的私有属性'
    def __init__(self):
        self.var2 = 'var2 是实例的属性'
        self.__var3 = '实例的私有属性'
        var4 = '简单变量，非属性，作用域只在函数体内'

类的多态和继承

多态：

同一个方法在不同类中的不同功能

class Triangle
    def __init__(self,width,height):
        self.width = width
        self.height = height
    def getArea(self)
        area = self.width * self.height / 2
        return area


class Square
    def __init__(self,size):
        self.size= size

    def getArea(self)
        area = self.size* self.size
        return area


a = Triangle(5,5)
a.getArea()

b = Square(5)
b.getArea()

继承：

父类-子类、派生类

class Father:
    money = 1000000
    __mone = 1000000
    
    def drive(self):
        print('I can drive a car1')

    
class Mother:
    mm = 100000

class Son(Father, Mother): ## 相同的方法只能继承第一个
    pass
    def pay(self):
        print(self.__money) # error

tom = Father()
print(tom.money)
tom.drive()

jerry = Son()
jerry.money
jerry.drive()

方法的重载

 重载方法

class Father:
    money = 1000000
    __mone = 1000000
    
    def drive(self):
        print('I can drive a car1')

    
class Mother:
    mm = 100000

class Son(Father, Mother): ## 相同的方法只能继承第一个
    def pay(self):
        print(self.__money) # error
        Father.drive(self) # car1

    def drive(self):
        print('I can drive a Tank!')


tom = Father()
print(tom.money)
tom.drive()

jerry = Son()
jerry.money
jerry.drive() ## Tank! 重载

多参数传入函数的冗余处理

# 多参数传入函数

def machine(x=5, y = 'nnn')
    pass


l = [5,'gg']
machine(*l) # 传列表

d = ['x':5,'y':'bohe']
machine(**d) # 传字典

##传的过多过少，冗余处理


def machine(x=5, y = 'nnn'， *arg) #arg接受多余的值（元组）
    pass
# 上诉不能接受指定的值 如machine(x=5, y = 'nnn'， z= 'a')



def machine(x=5, y = 'nnn'， *arg, **kv) #arg接受多余的值（元组）,kv接受指定值（字典）
    pass

重载运算符

定义一个类

类的对象是一个列表

对象可以进行加减乘除，其中每个元素分别运算

l = [1,2,3]
l + 10 ## error

class MyList:
    __mylist = []
    def __init__(self,*args)
        for arg in args:
            self.__mylist.append(arg)
        
    def __add__(self,x): ## 自带的方法，重写一下, help()看一看到内置的方法
        for i in range(0, len(self._mylist))
            self.__mylist[i] = self.__mylist[i] + x
        return self.__mylist

    def __sub__(self,x):
        pass

    def __mul__(self,x):
        pass

    def __div__(self,x):
        pass
    def __mod__(self):
        pass

    def __len__(self):
        pass

    def show(self):
        print(self.__mylist)


l =  MyList(1,2,3,4,5)

l + 10 # [11,12,13,14,15]
l.show()

把类当成模块

import ...