day_5

对象和类

• 一个学生，一张桌子，一个圆都是对象
• 对象是类的一个实例，你可以创建多个对象，创建类的一个实例过程被称为实例化，
• 在Python中对象就是实例，而实例就是对象

 

定义类

class ClassName:

do something

• class 类的表示与def 一样
• 类名最好使用驼峰式
• 在Python2中类是需要继承基类object的，在Python中默认继承，可写可不写
• 可以将普通代码理解为皮肤，而函数可以理解为内衣，那么类可以理解为外套

In [34]:

 

 

 

 

 

# 类必须初始化,是用self,初始化自身.

# 类里面所有的函数中的第一个变量不再是参数,而是一个印记.

# 在类中,如果有参数需要多次使用,那么就可以将其设置为共享参数

class Joker:

    def __init__(self,num1,num2):

        print('我初始化了')

        # 参数共享

        self.num1 = num1

        self.num2 = num2

        print(self.num1,self.num2)

    def SUM(self,name):

        print(name)

        return self.num1 + self.num2

    def cheng(self):

        return self.num1 * self.num2

 

 

In [35]:

 

 

 

 

 

huwang = Joker(num1=1,num2=2) # () 代表直接走初始化函数

 

 

 

我初始化了
1 2

In [36]:

 

 

 

 

 

huwang.SUM(name='JJJ')

 

 

 

JJJ

Out[36]:

3

In [33]:

 

 

 

 

 

huwang.cheng()

 

 

Out[33]:

2

 

定义一个不含初始化init的简单类

class ClassName:

joker = “Home”

def func():
    print('Worker')

• 尽量少使用

 

定义一个标准类

• init 代表初始化，可以初始化任何动作
• 此时类调用要使用()，其中（）可以理解为开始初始化
• 初始化内的元素，类中其他的函数可以共享

 

• Circle 和 className_ 的第一个区别有 init 这个函数
• 。。。。 第二个区别，类中的每一个函数都有self的这个“参数”

 

何为self？

• self 是指向对象本身的参数
• self 只是一个命名规则，其实可以改变的，但是我们约定俗成的是self，也便于理解
• 使用了self就可以访问类中定义的成员

 

使用类 Cirlcle

 

类的传参

• class ClassName:

    def __init__(self, para1,para2...)：
  
        self.para1 = para1
  
        self.para2 = para2

 

EP:

• A：定义一个类，类中含有两个功能：
  • 1、产生3个随机数，获取最大值
  • 2、产生3个随机数，获取最小值
• B：定义一个类，（类中函数的嵌套使用）
  • 1、第一个函数的功能为：输入一个数字
  • 2、第二个函数的功能为：使用第一个函数中得到的数字进行平方处理
  • 3、第三个函数的功能为：得到平方处理后的数字 - 原来输入的数字，并打印结果

In [83]:

 

 

 

 

 

class Joker2:

    """

    Implement Login Class.

    """

    def __init__(self):

        """

        Initialization class

        Arguments:

        ---------

            name: xxx

            None.

        Returns:

        --------

            None.

        """

        self.account = '123'

        self.password = '123'

    def Account(self):

        """

        Input Account value

        Arguments:

        ---------

            None.

        Returns:

        --------

            None.

        """

        self.acc = input('请输入账号:>>')

    def Password(self):

        """

        Input Password value

        Arguments:

        ---------

            None.

        Returns:

        --------

            None.

        """

        self.passwor = input('请输入密码:>>')

    def Check(self):

        """

        Check account and password

        Note:

        ----

            we need "and" connect.

            if account and password is right, then login OK.

            else: running Veriy func.

        """

        if self.acc == self.account and self.passwor == self.password:

            print('Success')

        else:

            # running Verify !

            self.Verify()

    def Verify(self):

        """

        Verify ....

        """

        Verify_Var = 123

        print('验证码是:',Verify_Var)

        while 1:

            User_Verify = eval(input('请输入验证码:>>'))

            if User_Verify == Verify_Var:

                print('Failed')

                break

    def Start(self):

        """

        Start definelogistics.

        """

        self.Account()

        self.Password()

        self.Check()

 

 

In [84]:

 

 

 

 

 

# 创建类的一个实例

a = Joker2()

 

 

In [82]:

 

 

 

 

 

a.Start()

 

 

 

请输入账号:>>123
请输入密码:>>1
验证码是: 123
请输入验证码:>>1
请输入验证码:>>1
请输入验证码:>>123
Failed

 

类的继承

• 类的单继承

• 类的多继承

• 继承标识

  class SonClass(FatherClass):

        def __init__(self):
  
            FatherClass.__init__(self)

In [110]:

 

 

 

 

 

a = 100

a = 1000

a

 

 

Out[110]:

1000

 

私有变量,不可继承,不可在外部调用,但是可以在内部使用.

In [32]:

 

 

 

 

 

class A:

    def __init__(self):

        self.__a = 'a'

    def a_(self):

        print('aa')

        print(self.__a)

 

 

In [35]:

 

 

 

 

 

def b():

    a()

def a():

    print('hahah')

b()

 

 

 

hahah

 

_ _ -- + = / \ { } [] ! ~ !@ # $ % ^ & * ( ) < > ……

 

私有数据域(私有变量，或者私有函数)

• 在Python中 变量名或者函数名使用双下划线代表私有 __Joker, def __Joker():
• 私有数据域不可继承
• 私有数据域强制继承 __dir__()

 

 

EP:

 

类的其他

• 类的封装
  • 实际上就是将一类功能放在一起，方便未来进行管理
• 类的继承（上面已经讲过）
• 类的多态
  • 包括装饰器：将放在以后处理高级类中教
  • 装饰器的好处：当许多类中的函数需要使用同一个功能的时候，那么使用装饰器就会方便许多
  • 装饰器是有固定的写法
    • 其包括普通装饰器与带参装饰器

 

Homewor

UML类图可以不用画

UML 实际上就是一个思维图

• 1

In [14]:

 

 

 

 

 

class Rectangle:

    def __init__(self,width,heightd):

        self.width = width 

        self.heightd = heightd 

    def getArea(self):

        return self.width * self.heightd

    def getPerimeter(self):

        return (self.width + self.heightd) * 2

    def print(self):

        area = self.getArea()

        perimeter = self.getPerimeter()

        a = self.width

        b = self.heightd

        print('这个矩形长为:%.2f,宽为:%.2f,面积为:%.2f,周长为:%.2f'%(a,b,area,perimeter))

​

Rectangle(4,40).print()

Rectangle(3.5,35.7).print()

 

 

 

这个矩形长为:4.00,宽为:40.00,面积为:160.00,周长为:88.00
这个矩形长为:3.50,宽为:35.70,面积为:124.95,周长为:78.40

 

• 2

In [13]:

 

 

 

 

 

class Account:

    def __init__(self,id=0 ,balance=100,annuna=0):

        self.id=id

        self.balance=balance

        self.annuna=annuna

        print('id:%s'%self.id)

        print('金额:%s'%self.balance)

​

    def withdraw(self,qu):

        self.shenx=self.balance-qu

    def deposit(self,cun):        

        self.yu=self.shenx+cun

​

    def getMonthlyInterestRate(self):

        self.lil=(self.annuna/12)/100

        print('月利率:%s'%self.annuna)

    def getMonthlyInterest(self):

        self.lix=self.yu*self.lil

        print('月利息:%s'%self.lix) 

re = Account(1122,20000,1.5)

re.withdraw(2500)

re.deposit(3000)

re.getMonthlyInterestRate()

re.getMonthlyInterest()

 

 

 

id:1122
金额:20000
月利率:1.5
月利息:25.625

 

• 3

In [15]:

 

 

 

 

 

class Fun:

    def __init__ (self,speed,on,radius,color):

        self._speed = speed

        self._on = on

        self._radius = radius

        self._color = color

        print('风的速度————%s' %self._speed)

        print('状态————%s' %self._on)

        print('风扇半径————%s' %self._radius)

        print('颜色————%s' %self._color)

self = Fun('最大','on',10,'yellow')

class Fun1:

    def __init__ (self,speed1,on1,radius1,color1):

        self._speed1 = speed1

        self._on1 = on1

        self._radius1 = radius1

        self._color1 = color1

        print('风的速度————%s' %self._speed1)

        print('状态————%s' %self._on1)

        print('风扇半径————%s' %self._radius1)

        print('颜色————%s' %self._color1)

self = Fun1('中等','off',5,'blue')

 

 

 

风的速度————最大
状态————on
风扇半径————10
颜色————yellow
风的速度————中等
状态————off
风扇半径————5
颜色————blue

 

• 4

In [16]:

 

 

 

 

 

import math

class RegularPolygon:

    def __init__(self,n,side,x,y):

        self.n=n

        self.side=side

        self.x=x

        self.y=y

    def getArea(self):

        return (self.n*self.side**2)/4*math.tan(3.14/self.n)

    def getPerimeter(self):

        return self.n*self.side

if __name__ == "__main__":

    n,side,x,y=map(float,input('n,side,x,y:>>').split(','))

    re=RegularPolygon(n,side,x,y)

    print(n,side,x,y,re.getArea(),re.getPerimeter())

 

 

 

n,side,x,y:>>3,1,0,0
3.0 1.0 0.0 0.0 1.2974469150673424 3.0

 

• 5

In [19]:

 

 

 

 

 

class LinearEquation(object):   

    def __init__(self,a,b,c,d,e,f):

        self.__a=a

        self.__b=b

        self.__c=c

        self.__d=d

        self.__e=e

        self.__f=f           

    def set_a(self,a):

        self.__a=a

    def get_a(self):

        return self.__a

    def set_b(self,b):

        self.__b=b

    def get_b(self):

        return self.___b

    def set_c(self,c):

        self.__c=c

    def get_c(self):

        return self.__c

    def set_d(self,d):

        self.__d=d

    def get_d(self):

        return self.__d

    def set_e(self,e):

        self.__e=e

    def get_e(self):

        return self.__e

    def set_f(self,f):

        self.__f=f

    def get_f(self):

        return self.__f

    def isSolvable(self):

        if (self.__a*self.__d)-(self.__c*self.__b)!=0:

            return True

        else:

            return print('此方程无解')

    def getX(self):

        s=(self.__a*self.__d)-(self.__b*self.__c)

        x=(self.__e*self.__d)-(self.__b*self.__f)/s

        print('X的值为：%.2f'% x)

    def getY(self):

        s=(self.__a*self.__d)-(self.__b*self.__c)

        y=(self.__a*self.__f)-(self.__e*self.__c)/s

        print('Y的值为：%.2f'% y)

if __name__=="__main__":

    a=int(input('a的值是：'))

    b=int(input('b的值是：'))

    c=int(input('c的值是：'))

    d=int(input('d的值是：'))

    e=int(input('e的值是：'))

    f=int(input('f的值是：'))

    l=LinearEquation(a,b,c,d,e,f)

    l.isSolvable()

    l.getX()

    l.getY()

​

 

 

 

a的值是：2
b的值是：5
c的值是：7
d的值是：8
e的值是：10
f的值是：12
X的值为：83.16
Y的值为：27.68

 

• 6

In [17]:

 

 

 

 

 

​

class zuobao:

    def shur(self):

        import math      

        x1,y1,x2,y2=map(float,input('Enter the endpoints of the first line segment: ').split(','))

        x3,y3,x4,y4=map(float,input('Enter the endpoints of the second line segment: ').split(','))

        u1=(x4-x3)*(y1-y3)-(x1-x3)*(y4-y3)

        v1=(x4-x3)*(y2-y3)-(x2-x3)*(y4-y3)

        u=math.fabs(u1)

        v=math.fabs(v1)

​

        x5=(x1*v+x2*u)/(u+v)

        y5=(y1*v+y2*u)/(u+v)

        print('The intersecting point is(%.1f, %.1f)'%(x5,y5)) 

re=zuobao()

re.shur()

 

 

 

Enter the endpoints of the first line segment: 2.0,2.0,0,0
Enter the endpoints of the second line segment: 0,2.0,2.0,0
The intersecting point is(1.0, 1.0)

 

• 7

In [20]:

 

 

 

 

 

class LinearEquation(object):   

    def __init__(self,a,b,c,d,e,f):

        self.__a=a

        self.__b=b

        self.__c=c

        self.__d=d

        self.__e=e

        self.__f=f           

    def set_a(self,a):

        self.__a=a

    def get_a(self):

        return self.__a

    def set_b(self,b):

        self.__b=b

    def get_b(self):

        return self.___b

    def set_c(self,c):

        self.__c=c

    def get_c(self):

        return self.__c

    def set_d(self,d):

        self.__d=d

    def get_d(self):

        return self.__d

    def set_e(self,e):

        self.__e=e

    def get_e(self):

        return self.__e

    def set_f(self,f):

        self.__f=f

    def get_f(self):

        return self.__f

    def isSolvable(self):

        if (self.__a*self.__d)-(self.__c*self.__b)!=0:

            return True

        else:

            return print('此方程无解')

    def getX(self):

        s=(self.__a*self.__d)-(self.__b*self.__c)

        x=(self.__e*self.__d)-(self.__b*self.__f)/s

        print('X的值为：%.2f'% x)

    def getY(self):

        s=(self.__a*self.__d)-(self.__b*self.__c)

        y=(self.__a*self.__f)-(self.__e*self.__c)/s

        print('Y的值为：%.2f'% y)

if __name__=="__main__":

    a=int(input('a的值是：'))

    b=int(input('b的值是：'))

    c=int(input('c的值是：'))

    d=int(input('d的值是：'))

    e=int(input('e的值是：'))

    f=int(input('f的值是：'))

    l=LinearEquation(a,b,c,d,e,f)

    l.isSolvable()

    l.getX()

    l.getY()

 

 

 

a的值是：2
b的值是：5
c的值是：7
d的值是：8
e的值是：10
f的值是：12
X的值为：83.16
Y的值为：27.68