python自学class13——类的基础用法

1. 使用类可以实现数据封装，数据独立性重用
   class是类标识，后面是类名称

class namemoney:
    def __init__(self):  #__init__初始化  self自身
        print("create")
        self.name = "tmy"
        self.money = 100000
    def savemoney(self,num):
        print(self.name,"savemoney",num)
        self.money += num
    def packout(self,num):
        print(self.name,"packout",num)
        self.money -= num

tmy = namemoney()  #创建一个对象，namemoney(),调用init函数
print(type(tmy))   #类型就是对象namemoney
tmy.savemoney(100)   #调用内部函数方法
tmy.packout(1000)
print(tmy.money)   #调用类的属性
print(tmy.name)

2. 类实现重用

#类更深入的基础用法
class namemoney:
    def __init__(self,name,money):  #__init__初始化  self自身
        print("create")
        self.name = name
        self.money = money
    def savemoney(self,num):
        print(self.name,"savemoney",num)
        self.money += num
    def packout(self,num):
        print(self.name,"packout",num)
        self.money -= num
tmy = namemoney("tmy",100000)  #即需要传递参数
tmy.savemoney(1000)
print(tmy.money)

txm = namemoney("txm",100000)   #实现重用
txm.packout(1000)
print(txm.money)

#1.self本质是实例化以后的对象地址
#2.self可以调用类的属性和方法
#3.在类中，属性各自独立，方法是共享的，调用方法传递self，区别是谁调用了self

#类的一般形式
class lazy:
    name = "txm"   #属性-变量，self在内部可以调用属性也可以调用行为
    def sleep(self):  #行为-函数
        print(self.name,"sleep")  #引用属性需要加self
        self.go()   #self只能在类的内部，不能在外部
    def go(self):   #self用于区分谁调用的
        print("lazy,d")

txm = lazy()
print(txm.name)
txm.sleep()

tmm = lazy()
print(id(txm.name),id(tmm.name))   #属性
print(id(txm.go),id(tmm.go))  #行为，函数地址一样

4. 类的简单应用——构造函数

class namemoney:
    #a = 10
    #b = 100
    def __init__(self,x,y):   #__init__构造的时候调用
        print("构造了",id(self))
        self.a = x
        self.b = y
    def add(self):
        return self.a + self.b
    def __del__(self):    #__del__删除的时候调用
        print("删除了",id(self))


add1 = namemoney(10,100)  #构造函数，传递参数初始化
print(add1.add())

5. 类的简单应用——UI设计，tkinker基础用法（Tk()，title，geometry，mainloop）

import tkinter
class mywin:
    def __init__(self,text,height,width,x,y):
        self.mytk = tkinter.Tk()  # Tk是一个类,Tk()是构造函数
        self.mytk.title("hello")  # 调用类的行为
        self.height = height
        self.width = width
        self.x = x
        self.y = y
        lastr = "%dx%d+%d+%d"%(self.height,self.width,self.x,self.y)
        self.mytk.geometry(lastr)  # 设置窗口位置和大小,"x"是字母x
    def show(self):
        self.mytk.mainloop()  # 运行起来

win1 = mywin("hello1",300,400,0,0)
win1.show()
win2 = mywin("hello2",500,800,0,0)
win2.show()
win3 = mywin("hello3",600,700,0,0)
win3.show()
'''
mytk = tkinter.Tk()   #Tk是一个类,Tk()是构造函数
mytk.title("hello")   #调用类的行为
mytk.geometry("600x600+0+0")  #设置窗口位置和大小,"x"是字母x
mytk.mainloop()   #运行起来
'''

6. 对于一个类，也可以在外部动态增加它的属性，但需要注意的是，此时无法使用self

class tmm:
    pass
txm = tmm()
print(type(txm))
txm.name = "txm2"    #动态增加属性
print(txm.name)
txm.getup = lambda name:print(name,"lsp",txm.name)  #匿名函数,动态增加的方法
txm.getup("txm")

7. 类中运算符的重载，重载即对某一行为进行重新解释。
   同时需要注意深拷贝和浅拷贝的区别：对象赋值是浅拷贝共用地址，深拷贝会重开新地址，重新传参定义对象。
   #函数的参数，副本机制是浅拷贝
   #不能改变原来数据的地址
   #字符串，数字，当作参数，原来的数据不会改变
   #对象，list可以改变原来数据的地址变量内容

class complex:
    def __init__(self,x,y):
        self.x = x
        self.y = y
    def show(self):
        print(self.x,"+",self.y,"i")
    def __add__(self, other):   #重载的含义针对本类型，对于+号重新解释一种行为
        self.x += other.x
        self.y += other.y
c1 = complex(1,2)
c2 = complex(3,5)
c1.show()
c2.show()
c1+c2   #等价c1.__add__(c2)
c1.__add__(c2)
c1.show()
c2.show()
#对象的赋值是浅拷贝，共用地址
c2 = complex(c1.x,c1.y)   #深拷贝，重新传参定义对象

8. 类的简单封装，私有变量的定义

#私有变量
'''
class money:
    def __init__(self):
        self.money = 100
    def show(self):
        print(self.money)


tmymoney = money()
tmymoney.money = -1000  #python解释语言，变量存在，解释引用，不存在，解释动态绑定或者不可见
print(tmymoney.money)
tmymoney.show()
'''
class money:
    def __init__(self):
        self.__money = 100   #__表示是私有变量，不允许外面随便访问
    def show(self):
        print(self.__money)


tmymoney = money()
tmymoney.__money = -1000  #python解释语言，变量存在，解释引用，不存在，解释动态绑定
print(tmymoney.__money)
tmymoney.show()
#访问私有变量方法：_money__money,加一个_

9. 数据归并方法——使用类封装

class filegetlines:
    def __init__(self,filepath):
        self.filepath = filepath
        self.file = open(filepath,"rb")
        self.Lines = -1
    def readlines(self):
        i = 0
        while True:
            linestr = self.file.readline()
            if linestr:
                print(linestr)
                i+=1
            else:
                break
        self.lines = i
        return i

f1 = filegetlines(r"D:\Python代码\class13\9.数据归并.txt")
print(f1.readlines())

总结：了解了python面向对象编程的思想，了解简单的类的定义及应用