<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>import pygame
class Music:                    #定义类
    def play():
        pygame.mixer.init()
        print("播放音乐")
        track1=pygame.mixer.music.load("C:/Users/AmmmmMAN/Music/Aloha+Heja+He+-+Achim+Reichel.mp3")
        pygame.mixer.music.play()
Music.play()<jupyter_output>播放音乐2<jupyter_text>定义一个标准类- __init__ 代表初始化，可以初始化任何动作- 此时类调用要使用()，其中（）可以理解为开始初始化- 初始化内的元素，类中其他的函数可以共享![](../Photo/85.png)<jupyter_code>#第一种方法
class Study:
    def __init__(self):           #创建初始函数
        self.num=2
    def fun1(self):
        self.n=self.num ** 3    
        print(str(self.num)+'的三次方为',self.n)
    def fun2(self):
        self.m=self.num ** 2
        print(str(self.num)+'的二次方为',self.m)
    def fun3(self):
        self.fun1()
        self.fun2()
        print('差为',self.n-self.m)
A = Study()     #创建一个实例，A是初始完毕之后的结果
A.fun3()
#第二种方法
class Study:
    def __init__(self):           #创建初始函数
        self.num=2
    def fun1(self):
        self.n=self.num ** 3    
        print(str(self.num)+'的三次方为',self.n)
    def fun2(self):
        self.m=self.num ** 2
        print(str(self.num)+'的二次方为',self.m)
    def fun3(self):
        print('差为',self.n-self.m)
A = Study()     #创建一个实例，A是初始完毕之后的结果
A.fun1()
A.fun2()
A.fun3()
#第三种方法
class Study:
    def __init__(self):           #创建初始函数
        self.num=2
    def fun1(self):
        n=self.num ** 3  
        return n
    def fun2(self):
        m=self.num ** 2
        return m
    def fun3(self):
        n1=self.fun1()
        m1=self.fun2()
        print('差为',n1-m1)
Study().fun3()     #创建一个实例，A是初始完毕之后的结果<jupyter_output>差为 4<jupyter_text>- Circle 和 className_ 的第一个区别有 __init__ 这个函数- 。。。。   第二个区别，类中的每一个函数都有self的这个“参数”  何为self？- self 是指向对象本身的参数- self 只是一个命名规则，其实可以改变的，但是我们约定俗成的是self，也便于理解- 使用了self就可以访问类中定义的成员  使用类 Cirlcle  类的传参- class ClassName:            def __init__(self, para1,para2...)：                        self.para1 = para1                        self.para2 = para2<jupyter_code>class Study:
    def __init__(self,num1):           #创建初始函数,传参也在初始化函数中进行
        self.num=num1
    def fun1(self):
        self.n=self.num ** 3    
        print(str(self.num)+'的三次方为',self.n)
    def fun2(self):
        self.m=self.num ** 2
        print(str(self.num)+'的二次方为',self.m)
    def fun3(self):
        self.fun1()
        self.fun2()
        print('差为',self.n-self.m)
Study(num1=2).fun3()  #创建一个实例，A是初始完毕之后的结果<jupyter_output>2的三次方为 8
2的二次方为 4
差为 4<jupyter_text>EP:- A：定义一个类，类中含有两个功能：    - 1、计算随机数的最大值    - 2、计算随机数的最小值- B：定义一个类，（类中函数的嵌套使用）    - 1、第一个函数的功能为：输入一个数字    - 2、第二个函数的功能为：使用第一个函数中得到的数字进行平方处理    - 3、第三个函数的功能为：得到平方处理后的数字 - 原来输入的数字，并打印结果<jupyter_code>import random
class Random:
    def __init__(self,num1,num2):
        self.n=num1
        self.m=num2
        print('俩个数字分别为'+str(self.n)+'和'+str(self.m))
    def fun1(self):
        if self.n<self.m:
            print('最大值为'+str(self.m)+'最小值为'+str(self.n))
        else:
            print('最大值为'+str(self.n)+'，最小值为'+str(self.m))
import random
Random(num1=random.randint(1,9),num2=random.randint(1,9)).fun1()  #创建一个实例，A是初始完毕之后的结果
#单类继承.........
class Study:    #创建类
    def __init__(self,num1,num2):
        self.n=num1
        self.m=num2
        self.res1=None
        self.res2=None
    def p2_p3(self):
        self.res1 = self.n ** 2
        self.res2 = self.m ** 3
class Jisuan(Study):        #创建类并继承父类
    def __init__(self,num1,num2):
        Study.__init__(self,num1,num2)       #继承父类的初始化函数
    def show(self):
        print(self.res1- self.res2)
A = Jisuan(2,2)
A.p2_p3()
A.show()
#多类继承........
class One: #创建类
    '''
    This is .......
    '''
    def __init__(self,num1):
        self.n=num1
        self.res1=None
    def p2(self):
        self.res1 = self.n ** 2
class Two: #创建类
    def __init__(self,num2):
        self.m=num2
        self.res2=None
    def p3(self):
        self.res2 = self.m ** 3
class Jisuan(One,Two):        #创建类并继承父类
    def __init__(self,num1,num2):    #定义自己类的初始化函数
        One.__init__(self,num1)       #继承父类的初始化函数
        Two.__init__(self,num2)
    def show(self):
        print(self.res1- self.res2)
A = Jisuan(2,2)
A.p2()
A.p3()
A.show()<jupyter_output>-4<jupyter_text>类的继承- 类的单继承- 类的多继承- 继承标识>  class SonClass(FatherClass):                        def __init__(self):                            FatherClass.__init__(self)  私有数据域(私有变量，或者私有函数)- 在Python中 变量名或者函数名使用双下划线代表私有  \__Joker,   def \__Joker():- 私有数据域不可继承- 私有数据域强制继承   \__dir__()<jupyter_code>import requests
import re
url = 'http://www.baidu.com'
response = requests.get(url)
response.encoding = 'utf8'
html = response.text
print(html)
res = re.search('name=tj_trvideo(.?)',html)
res.group(1)<jupyter_output><!DOCTYPE html>
<!--STATUS OK--><html> <head><meta http-equiv=content-type content=text/html;charset=utf-8><meta http-equiv=X-UA-Compatible content=IE=Edge><meta content=always name=referrer><link rel=stylesheet type=text/css href=http://s1.bdstatic.com/r/www/cache/bdorz/baidu.min.css><title>百度一下，你就知道</title></head> <body link=#0000cc> <div id=wrapper> <div id=head> <div class=head_wrapper> <div class=s_form> <div class=s_form_wrapper> <div id=lg> <img hidefocus=true src=//www.baidu.com/img/bd_logo1.png width=270 height=129> </div> <form id=form name=f action=//www.baidu.com/s class=fm> <input type=hidden name=bdorz_come value=1> <input type=hidden name=ie value=utf-8> <input type=hidden name=f value=8> <input type=hidden name=rsv_bp value=1> <input type=hidden name=rsv_idx value=1> <input type=hidden name=tn value=baidu><span class="bg s_ipt_wr"><input id=kw name=wd class=s_ipt value maxlength=255 autocomplete=off autofocus></span><span class="bg s_btn_wr"><input type=submit id=su va[...]<jupyter_text>![](../Photo/87.png)  EP:![](../Photo/88.png)![](../Photo/89.png)![](../Photo/90.png)  类的其他- 类的封装    - 实际上就是将一类功能放在一起，方便未来进行管理- 类的继承（上面已经讲过）- 类的多态    - 包括装饰器：将放在以后处理高级类中教    - 装饰器的好处：当许多类中的函数需要使用同一个功能的时候，那么使用装饰器就会方便许多    - 装饰器是有固定的写法        - 其包括普通装饰器与带参装饰器  Homewor UML类图可以不用画 UML 实际上就是一个思维图- 1![](../Photo/91.png)<jupyter_code>class Re:
    def __init__(self,weight=1,height=2):
        self.w = weight
        self.h = height    
    def getArea(self):
        self.res = self.w * self.h
        return self.res 
    def getPerimeter(self):
        self.res1 = (self.w + self.h)*2 
        return self.res1
    def show(self):
        area =self.getArea()
        per =self.getPerimeter()
        print('长为' + str(self.h)+'宽为' + str(self.w))
        print('面积为'+str(area))
        print('周长为'+str(per))

A=Re()
A.show()
A=Re(4,40)
A.show()
A=Re(3.5,35.7)
A.show()<jupyter_output>长为35.7宽为3.5
面积为124.95000000000002
周长为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 getId(self):       #定义ID
        id_ = self.__id
        return id_ 
    def getBalance(self):   #定义余额
        bl = self.__balance
        return bl
    def getAn(self):      #定义年利率
        ann = self.__annualinterestRate
        return ann
    
    def getMonthlyInterestRate(self):         #定义月利率
        mir = self.__annualinterestRate / 1200
        return mir
    def getMonthlyInterest(self):       #定义月利息
        monthlyInterestRate = self.getMonthlyInterestRate()
        return self.__balance * monthlyInterestRate
    
    def withdraw(self, a):
        self.__balance -= a
    def deposit(self, b):
        self.__balance += b
account = Account(1122, 20000, 4.5)
account.withdraw(2500)
account.deposit(3000)
print('用户id为'+str(account.getId())+'账户余额'+str(account.getBalance()))
print('月利率为'+str(account.getMonthlyInterestRate()))
print('月利息为'+str(account.getMonthlyInterest()))<jupyter_output>用户id为1122账户余额20500
月利率为0.00375
月利息为76.875<jupyter_text>- 3![](../Photo/93.png)<jupyter_code>class Fan:
    def __init__(self, speed = 1, on = False, radius = 5, color = 'blue'):
        self.__speed = 'SLOW'
        if speed == 1:
            self.__speed = 'SLOW'
        elif speed == 2:
            self.__speed = 'MEDIUM'
        else:
            self.__speed = 'FAST'
        self.__on = on
        self.__radius = radius 
        self.__color = color
    def getSpeed(self):     #速度
        s = self.__speed
        return s
    def getOn(self):        #开关
        o = self.__on
        return o
    def getRadius(self):     #半径
        r = self.__radius
        return r
    def getColor(self):     #颜色
        c=self.__color 
        return c

F = Fan(3, True, 10, 'yellow')
print('速度为 ', F.getSpeed())
print('半径为 ', F.getRadius())
print('颜色为 ', F.getColor())
print('开关 ', F.getOn())
F = Fan(2, True, 5, 'blue')
print('速度为 ', F.getSpeed())
print('半径为 ', F.getRadius())
print('颜色为 ', F.getColor())
print('开关 ', F.getOn())<jupyter_output>速度为  MEDIUM
半径为  5
颜色为  blue
开关  True<jupyter_text>- 4![](../Photo/94.png)![](../Photo/95.png)<jupyter_code>import math
class RegularPolygon():
    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):
        round_ = self.__n*self.__side
        return round_
    def getArea(self):
        area = self.__n*(self.__side**2)/(4*math.tan(math.pi/self.__n))
        return area 
    def show(self):
        a =self.getArea()
        p =self.getPerimeter()
        print('它的周长为',p)
        print('它的面积为',a)
R = RegularPolygon()
R.show()
R = RegularPolygon(6,4)
R.show()
R = RegularPolygon(10,4,5.6,7.8)
R.show()<jupyter_output>它的周长为 40
它的面积为 123.10734148701015<jupyter_text>- 5![](../Photo/96.png)<jupyter_code>class LinuarEq():
    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 getA(self):
        A = self.__a
        return A
    def getA(self):
        B = self.__b
        return B
    def getA(self):
        C = self.__c
        return C
    def getA(self):
        D = self.__d
        return D
    def getA(self):
        E = self.__e
        return E
    def getA(self):
        F = self.__f
        return F
    def isSolvable():
        if self.__a*self.__d != self.__b*self.__c :
            return True
        else:
            return False
    def getX(self):
        x=(self.__e*self.__d - self.__b*self.__f)/(self.__a * self.__d - self.__b * self.__c)
        return x
    def getY(self):
        y=(self.__a*self.__f - self.__e*self.__c)/(self.__a * self.__d - self.__b * self.__c)
        return y

L =LinuarEq( a = eval(input('请输入a:')),b = eval(input('请输入b:')),c = eval(input('请输入c:')),d = eval(input('请输入d:')),e = eval(input('请输入e:')),f = eval(input('请输入f:')))
if LinuarEq.isSolvable== True :
    print('这个方程式的解为'+str(L.getX+str(L.getY)
else:
    print('这个方程式无解')<jupyter_output>a:1
b:2
c:3
d:4
e:5
f:6
这个方程式无解<jupyter_text>- 6![](../Photo/97.png)<jupyter_code>class LinEq():
    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 K_o(self):
        k1 = (self.__y2-self.__y1)/(self.__x2-self.__x1)
        return k1
    def b_o(self):
        b1=(self.__y2-self.__y1)/((self.__x2-self.__x1)*(self.__y2-self.__y1)/(self.__x2-self.__x1))
        return b1
    def K_t(self):
        k2 = (self.__y4-self.__y3)/(self.__x4-self.__x3)
        return k2
    def b_t(self):
        b2=(self.__y4-self.__y3)/((self.__x4-self.__x3)*(self.__y4-self.__y3)/(self.__x4-self.__x3))
        return b2
    def X_jd(self):
        x = (((self.__y4-self.__y3)/((self.__x4-self.__x3)*(self.__y4-self.__y3)/(self.__x4-self.__x3)))-((self.__y2-self.__y1)/((self.__x2-self.__x1)*(self.__y2-self.__y1)/(self.__x2-self.__x1)))) / (((self.__y2-self.__y1)/(self.__x2-self.__x1))-((self.__y4-self.__y3)/(self.__x4-self.__x3)))
        return x
    def Y_jd(self):
        y = ((((self.__y4-self.__y3)/((self.__x4-self.__x3)*(self.__y4-self.__y3)/(self.__x4-self.__x3)))-((self.__y2-self.__y1)/((self.__x2-self.__x1)*(self.__y2-self.__y1)/(self.__x2-self.__x1)))) / (((self.__y2-self.__y1)/(self.__x2-self.__x1))-((self.__y4-self.__y3)/(self.__x4-self.__x3)))) * ((self.__y2-self.__y1)/(self.__x2-self.__x1)) + (self.__y2-self.__y1)/((self.__x2-self.__x1)*(self.__y2-self.__y1)/(self.__x2-self.__x1))
        return y
    def show(self):
        xx= self.X_jd()
        yy = self.Y_jd()
L=LinEq(2.0,2.0,0,0,0,2.0,2.0,0)
L.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.16407947842285003, 'fraction_numerical': 0.03399565352375039, 'mean_word_length': 2.65014164305949, 'pattern_counts': {'":': 0, '<': 68, '<?xml version=': 0, '>': 67, 'https://': 0, 'lorem ipsum': 0, 'www.': 4, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '11', 'dir': 'jupyter-structured-clean-dedup', 'id': '125422', 'license': 'Apache-2.0', 'n_tokens_mistral': 5856, 'n_tokens_neox': 5862, 'n_words': 804, 'path': '9.17.ipynb', 'repo_name': 'Thatiswjg/test', 'size': '12884'}