<jupyter_start><jupyter_text>对象和类- 一个学生，一张桌子，一个圆都是对象- 对象是类的一个实例，你可以创建多个对象，创建类的一个实例过程被称为实例化，- 在Python中对象就是实例，而实例就是对象  定义类class ClassName:    do something    - class 类的表示与def 一样- 类名最好使用驼峰式- 在Python2中类是需要继承基类object的，在Python中默认继承，可写可不写- 可以将普通代码理解为皮肤，而函数可以理解为内衣，那么类可以理解为外套  定义一个不含初始化__init__的简单类class ClassName:    joker = “Home”        def func():        print('Worker')    - 尽量少使用<jupyter_code>class ClassName:
    yk = 'home'
ClassName.yk  ## == ClassName().yk
class ClassName_:
    yk = 'home'
    def func():
        print('Worker')
ClassName_.func() ## ClassName_().func()  不能运行，代码错误  只有内中的函数可使用这种形式（函数参数是self）<jupyter_output>Worker<jupyter_text>定义一个标准类- __init__ 代表初始化，可以初始化任何动作- 此时类调用要使用()，其中（）可以理解为开始初始化- 初始化内的元素，类中其他的函数可以共享![](../Photo/85.png)<jupyter_code>import math
class Circle:
    def __init__(self,radius = 1):#初始化，一般在这个初始化内，放入参数
        '''
        因为在类中，可能有多个函数都需要使用这个参数，所以一定要将这个参数变成通用型
        '''
        self.radius = radius
    def getPerimeter(self):#这里的self代表这个函数是这个类中的
        return 2 * self.radius * self.radius * math.pi
    def getArea(self):
        return self.radius * self.radius * math.pi
    def setRadius(self,radius):#自己的一个参数radius
        self.radius = radius
Circle(radius=100).getPerimeter()
class class_jiou:
    def  __init__(self,shu =1 ):
        self.shu = shu
    def fun_jiou(self):
        if self.shu % 2 == 0:
            print(self.shu,' 偶数')
        else:
            print(self.shu,' 奇数')    
    def fun_su(self):
        if self.shu == 2:
             print(self.shu,'  素数')
        for i in range(2,self.shu):
            if self.shu % i == 0:
                print(self.shu,'  不是素数')
                break
            if i == self.shu - 1:
                print(self.shu,'  素数')
    def fun_chengfabiao(self):
        for i in range(1,10):
            for j in range(1,i+1):
                print(j,'*',i,'=',i * j,end = ' ')
            print('')
class_jiou(3).fun_su()
class class_he:
    def __init__(self,num):
        self.num = num
    def fun_zijia(self):
        self.num += 1
        return self.num
    def fun_cheng(self):
        self.num *= self.num
        return self.num
num = class_he(0)
for i in range(100):
    num.fun_zijia()
ji = num.fun_cheng()
print(ji)<jupyter_output>10000<jupyter_text>何为self？- self 是指向对象本身的参数- self 只是一个命名规则，其实可以改变的，但是我们约定俗成的是self，也便于理解- 使用了self就可以访问类中定义的成员  使用类 Cirlcle  类的传参- class ClassName:            def __init__(self, para1,para2...)：                        self.para1 = para1                        self.para2 = para2  EP:- A：定义一个类，类中含有两个功能：    - 1、计算随机数的最大值    - 2、计算随机数的最小值- B：定义一个类，（类中函数的嵌套使用）    - 1、第一个函数的功能为：输入一个数字    - 2、第二个函数的功能为：使用第一个函数中得到的数字进行平方处理    - 3、第三个函数的功能为：得到平方处理后的数字 - 原来输入的数字，并打印结果  类的继承- 类的单继承- 类的多继承- 继承标识>  class SonClass(FatherClass):                        def __init__(self):                            FatherClass.__init__(self)<jupyter_code>class class_chuangcan:
    def __init__(self):
        self.num = 123
class class_panduan(class_chuangcan):#告诉python  子类马上要继承父类
    def __init__(self):
        class_chuangcan.__init__(self)#告诉父类，子类继承父类
    def fun_jiou(self):
        if self.num % 2 == 0:
            print(self.num,' 偶数')
        else:
            print(self.num,' 奇数')        
A = class_panduan()
A.fun_jiou()<jupyter_output>123  奇数<jupyter_text>私有数据域(私有变量，或者私有函数)- 在Python中 变量名或者函数名使用双下划线代表私有  \__Joker,   def \__Joker():- 私有数据域不可继承- 私有数据域强制继承   \__dir__() ![](../Photo/87.png)  EP:![](../Photo/88.png)![](../Photo/89.png)![](../Photo/90.png)  类的其他- 类的封装    - 实际上就是将一类功能放在一起，方便未来进行管理- 类的继承（上面已经讲过）- 类的多态    - 包括装饰器：将放在以后处理高级类中教    - 装饰器的好处：当许多类中的函数需要使用同一个功能的时候，那么使用装饰器就会方便许多    - 装饰器是有固定的写法        - 其包括普通装饰器与带参装饰器  Homewor UML类图可以不用画 UML 实际上就是一个思维图- 1![](../Photo/91.png)<jupyter_code>class Rectangle:
    def __init__(self,width,height):
        self.width = width
        self.height = height
    def getArea(self):
        return self.width * self.height
    def getPerimeter(self):
        return (self.width + self.height) * 2
    def getwh(self):
        print('这个矩阵的宽',self.width,'长',self.height,end = ' ')
A = Rectangle(4,40)
B = Rectangle(3.5,35.7)
A.getwh()
print('面积',A.getArea(),'周长',A.getPerimeter())
B.getwh()
print('面积',round(B.getArea(),2),'周长',B.getPerimeter())<jupyter_output>这个矩阵的宽 4 长 40 面积 160 周长 88
这个矩阵的宽 3.5 长 35.7 面积 124.95 周长 78.4<jupyter_text>- 2![](../Photo/92.png)<jupyter_code>class Account:
    def __init__(self,Id = 0,balance = 100,annualInterestRate = 0):
        self.__Id = Id
        self.__balance = balance
        self.__annualInterestRate = annualInterestRate
    def getMonthlyInterestRate(self):
        return self.__annualInterestRate / 12 / 100
    def getMonthlyInterest(self):
        return self.__balance * (self.__annualInterestRate / 12 / 100)
    def withdraw(self,num):
        self.__balance -= num
    def deposit(self,num):
        self.__balance += num
    def pri(self):
        print('id = ',self.__Id,'balance = ',self.__balance,end = ' ')
A = Account(1122,20000,4.5)
A.withdraw(2500)
A.deposit(3000)
A.pri()
print('MonthlyInterestRate = ',A.getMonthlyInterestRate(),'getMonthlyInterest = ',A.getMonthlyInterest())<jupyter_output>id =  1122 balance =  20500 MonthlyInterestRate =  0.00375 getMonthlyInterest =  76.875<jupyter_text>- 3![](../Photo/93.png)<jupyter_code>class Fan():
    def __init__(self,speed = 1,radius = 5,color = 'blue',on = False):
        self.__speed = speed
        self.__on = on
        self.__radius = radius
        self.__color = color
    def fun_speed(self):
        if self.__speed == 1:
            print('SLOW',self.__radius,self.__color,self.__on)
        elif self.__speed == 2:
            print('MEDIUM',self.__radius,self.__color,self.__on) 
        else:
             print('FAST',self.__radius,self.__color,self.__on)  
Fan(3,10,'yellow',True).fun_speed()
Fan(2,5).fun_speed()<jupyter_output>FAST 10 yellow True
MEDIUM 5 blue False<jupyter_text>- 4![](../Photo/94.png)![](../Photo/95.png)<jupyter_code>import math
class RegularPolygin:
    def __init__(self,n =3,side = 1,x = 0,y = 0):
        self.__n = n
        self.__side = side 
        self.__x = x
        self.__y = y
    def getPerimeter(self):
        return self.__n * self.__side
    def getArea(self):
        return (self.__n * self.__side ** 2) / (4 * math.tan (math.pi / self.__n))
A = RegularPolygin()
print('周长 = ',A.getPerimeter(),'面积 = ',round(A.getArea(),3))
B = RegularPolygin(6,4)
print('周长 = ',B.getPerimeter(),'面积 = ',round(B.getArea(),3))
C = RegularPolygin(10,4,5.6,7.8)
print('周长 = ',C.getPerimeter(),'面积 = ',round(C.getArea(),3))<jupyter_output>周长 =  3 面积 =  0.433
周长 =  24 面积 =  41.569
周长 =  40 面积 =  123.107<jupyter_text>- 5![](../Photo/96.png)<jupyter_code>class LinearEquation:
    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 isSolvable(self):
        if self.__a * self.__d - self.__b * self.__c == 0:
            return False
        else:
            return True
    def getX(self):
        return (self.__e * self.__d - self.__b * self.__f) / (self.__a * self.__d - self.__b * self.__c)
    def getY(self):
        return (self.__a * self.__f - self.__e * self.__c) / (self.__a * self.__d - self.__b * self.__c)
A = LinearEquation(1,1,1,-1,2,0)
if A.isSolvable:
    print('x = ',A.getX(),'y = ',A.getY())
else:
    print('这个方程式无解')<jupyter_output>x =  1.0 y =  1.0<jupyter_text>- 6![](../Photo/97.png)<jupyter_code>class LinearEquation:  
    def __init__(self,x1,y1,x2,y2,x3,y3,x4,y4):
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2
        self.x3 = x3
        self.y3 = y3
        self.x4 = x4
        self.y4 = y4
    def findPoint(self):
        k1 = (self.y2 - self.y1) / (self.x2 - self.x1)
        b1 = self.y1 - k1 * self.x1
        if (x4-x3)==0:
            k2=None
            b2=0
        else:
            k2=(self.y4 - self.y3) / (self.x4 - self.x3)
            b2=self.y3 - self.x3 * k2
        if k2==None:
            x = self.x3
        else:
            x = ( b2 - b1) / (k1 - k2)
        y =  k1* x + b1
        print('The intersecting point is :(',x,y,')')
x1,y1,x2,y2 = eval(input('Enter the endpoints of the first line segment:'))
x3,y3,x4,y4 = eval(input('Enter the endpoints of the second line segment:'))
LinearEquation(x1,y1,x2,y2,x3,y3,x4,y4).findPoint()<jupyter_output>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 )<jupyter_text>- 7![](../Photo/98.png) - 8 进阶- 定义一个子类，一个父类    - 父类产生随机数    - 子类一直判定该随机数是奇数还是偶数        - 该例子实际上就是一个粗浅的分布式<jupyter_code>import random
class farther:
    def __init__(self):
        self.num = random.randint(1,100)
class son(farther):
    def __init__(self):
        farther.__init__(self)
    def fun_jiou(self):
        if self.num % 2 == 0:
            print(self.num,'是偶数')
        else:
            print(self.num,'是奇数')
A = son()
A.fun_jiou()<jupyter_output>49 是奇数
{'fraction_non_alphanumeric': 0.148189168235685, 'fraction_numerical': 0.03588437257725108, 'mean_word_length': 2.569169960474308, 'pattern_counts': {'":': 0, '<': 31, '<?xml version=': 0, '>': 32, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '11154', 'license': 'Apache-2.0', 'n_tokens_mistral': 4138, 'n_tokens_neox': 4093, 'n_words': 630, 'path': '7.23.ipynb', 'repo_name': 's1u9m9m0e1r/fzh', 'size': '9029'}