谈“对象“

# 创建的语法
class Studnet:
    native_pace = '吉林' # 类属性 
    # 初始化方法 这个self赋值时候不用写，赋值name和age即可，self默认带
    def __init__(self,name,age): # 将局部变量的值赋值给实体属性，self.name称为实例属性
        self.name = name
        self.age = age
    # 实例方法
    # self 为这个方法名，name,age的为实例属性
    def eat(self): # 这个self这里必写，self单词可以变，但程序员习惯self
        print('学生在吃饭')
# 在类外定义的称为函数，类之内称为方法
    # 类方法
    @classmethod
    def cm(cls):
        print('类方法')
    # 静态方法中不能写self，注意
    @staticmethod
    def sm():
        print('静态方法')
# 类之外定义的称为函数，在类之内定义的称为方法
def drink():
    print('喝水')

Stu1 = Student('张三',20)Student.eat(stu1)

stu1 = Studnet('张三',20)
stu2 = Studnet('李四',30)
print(id(stu1)) # 和stu2不同
print(id(stu2))
print('--------为stu2动态绑定性别属性-----------')
stu2.gender = '女'  # 这点和java不一样，java没有成员变量(属性-字段)，是不能指定的
# Student中没有 gender属性 能动态绑定性别 ,只属于stu2自己
print(stu2.gender) # 女
def show():
    print('定义在类之外的，称函数')
stu1.show = show()
stu1.show # 定义在类之外的，称函数
stu2.show # 报错 没有胃stu2动态绑定show方法,在对象上之后函数就称为方法了

classStudent:def__init__(self,name,age):self.name = nameself.__age = agedefshow(self):       print(self.name,self.__age)stu = Student('张三',20)# 在类外部使用name、ageprint(stu.name) # 张三# print(stu.__age) # 报错print(dir(stu)) # dir()可以查看类的所有属性和方法 ，里面找到一个_Student__ageprint(stu._Student__age) # 这样也能访问，但是不建议这种访问方式​classStudent2:def__init__(self,age):self.set_age(age)defget_age(self):returnself.__age # 不希望在外面使用，所以加上两个__defset_age(self,age):if0<=age<=120:self.__age = ageelse:self.__age = 18stu1 = Student2(150)stu2 = Student2(30)print(stu1.get_age()) # 18print(stu2.get_age()) # 30

classPerson(object): #object默认不写也行def__init__(self,name,age):self.name = nameself.age = agedefinfo(self):        print('姓名：{0},年龄{1}'.format(self.name,self.age))# 定义子类classStudent(Person):def__init__(self,name,age,score):super().__init__(name,age)self.score = scoredefinfo(self):super.info()# 还想用父类的info()可以super.        print(self.score)# 重写# 测试stu = Student('Haha',20,'1001')stu.info() # 从父类中继承的方法 ，重写后就是Student的方法了

classStudent:def__init__(self,name,age):self.name=nameself.age=agedef__str__(self):return'我的名字是{0},今年{1}岁'.format(self.name,self.age)​stu=Student('Haha',20)print(stu) # 我的名字是Haha,今年{20}岁  默认调用_str_()这样的方法

classAnimal:def eat(self):        print('eating...')classDog(Animal):    def eat(self):        print('dog gnawing...')​def fun(obj):    obj.eat()fun(Animal()) # eating...fun(Dog()) #  # dong gnawing

classA:def__init__(self,name,age):            self.name = name            self.age = agex = A('Jack',18)print(x.__dict__) #{'name': 'Jack', 'age': 18}print(x.__class__) # <class '__main__.A'> 所属的类classB(A):passprint(B.__base__) # <class '__main__.A'> # 类的基类,如果多继承，谁在前输出谁print(B.__bases__) # (<class '__main__.A'>,) 输出其父类类型的元素print(B.__mro__) # 继承层次结果 B继承A继承object (<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)print(A.__subclasses__())#子类列表  [<class '__main__.B'>]​a = 20b = 100c = a + bd = a.__add__(b) #等同于+print(c)print(d)classStudent:def__init__(self,name):        self.name = namedef__add__(self, other):# 必须在这里写，stu1.__add_(stu2)这样也报错return self.name + other.namedef__len__(self):# 必须写在这里才能计算长度return len(self.name)stu1 = Student('张三')stu2 = Student('李四')s = stu1 + stu2 # 写了__add__方法才能加，否则报错print(s) # 张三李四lst = [1,2,3,4,5]print(len(lst)) # 5print(lst.__len__()) # 5print(stu1.__len__()) # 2

classCPU:passclassDisk:passclassComputer:def__init__(self,cpu,disk):       self.cpu = cpu       self.disk = diskcpu1 = CPU()cpu2 = cpu1 # 这个是赋值操作print(cpu1,cpu2) # 内存地址一样# <__main__.CPU object at 0x000001A54423FF40> <__main__.CPU object at 0x000001A54423FF40>print('----------------------')disk = Disk() # 创建一个硬盘computer = Computer(cpu1,disk) # 创建一个计算机类的对象# 浅拷贝import copycomputer2 = copy.copy(computer)print(disk)# # <__main__.Disk object at 0x000001E1026AF3D0>print(computer,computer.cpu,computer.disk)# computer2和computer内存地址不同，子对象的内存地址是相同的-Disk和CPU# <__main__.Computer object at 0x000001A543EF4850> <__main__.CPU object at 0x000001A54423FF40> <__main__.Disk object at 0x000001A54423F3D0>print(computer2,computer2.cpu,computer2.disk)# <__main__.Computer object at 0x000001A5442928F0> <__main__.CPU object at 0x000001A54423FF40> <__main__.Disk object at 0x000001A54423F3D0>print('---------------------------')# 深拷贝computer3 = copy.deepcopy(computer)print(computer,computer.cpu,computer.disk)print(computer3,computer.cpu,computer3.disk)# 打印的内存地址各不同，computer、cpu、disk都拷贝了一份，内存地址变化了# <__main__.Computer object at 0x00000265D67B3E80> <__main__.CPU object at 0x00000265D67B3FD0> <__main__.Disk object at 0x00000265D67B3EB0># <__main__.C

import math # 导入数学模块 每一个模块都有id、type以及它的值组成print(id(math))print(type(math))print(math)print(math.pi) # 3.141592653589793#2051647076960#<class 'module'>#<module 'math' (built-in)>print(dir(math))from math import piprint(pi) # 这是能直接输出的print(pow(2,3)) # 如果不导入math，只导入from math import pi 是不能使用的

# 开发时间：2023/2/11defadd(a,b):return a+bif __name__ == '__main__':   print(add(10,20)) # 只有当运行这个calc2的时候才会执行这个主程序语句，可防止其它程序调用此类运行这个

import pageage1.module_A as ma# 现在就可以使用pageage1.module_A的内容了(别名叫ma)

import sysimport timeimport urllib.requestimport math# getsizeof是获取占用字节数print(sys.getsizeof(20)) # 28print(sys.getsizeof(21)) # 28print(sys.getsizeof(True)) # 28print(sys.getsizeof(False)) # 24print(time.time()) # 对应秒数 1676127718.0125294print(time.localtime(time.time())) # 将秒转成本地时间time.struct_time(tm_year=2023, tm_mon=2, tm_mday=11, tm_hour=23, tm_min=1, tm_sec=58, tm_wday=5, tm_yday=42, tm_isdst=0)print(urllib.request.urlopen('http://ww.baidu.com').read())print(math.pi)

file = open('a.txt','r') # 读，中括号是可选，写不写都行print(file.readlines()) # readlines读取的是一个列表file.close()

file = open('a.txt','r')file = seek(2) # a.txt有中国两字。一个字占取2字节(gbk)，从国开始读（如果在pyCharm中写的txt,可能就是utf-8了，不是2字节）print(file.read()) # 国# tellprint(file.tell()) # 会把当前所有内容打印出，指向最后一个位置。如seek(2)跳过了2，如果打印hello的话只会出现llo

# open('logo.png','rb') with之后as之前为上下文表达式，结果为上下文管理器-->同时创建一个运行时上下文-->自动调用_enter_()方法，并将返回值赋值给src_filewith open('logo.png','rb') as src_file:# as src_file:可选项上下文管理器对象的引用[可选项]src_file.read() # with语句体# 离开运行时上下文，自动调用上下文管理器的特殊方法_exit_()

withopen('a.txt','r') asfile:    print(file.read()) # 不用再手动close关闭了，因为离开with语句时会自动释放资源

# 开发时间：2023/2/12# MyContentMgr实现了特殊方法__enter__(),__exit__()称为该类对象遵守了上下文管理器协议，该类对象的实例对象，称为上下文管理器classMyContentMgr(object):def__enter__(self):       print('enter方法被调用执行了')return selfdef__exit__(self, exc_type, exc_val, exc_tb):       print('exit方法被调用执行了')# print('show方法被调用执行了',1/0) 即使产生异常也会调用exit方法，称为自动关闭资源defshow(self):# 实例Method       print('show方法被调用执行了')​# MyContentMgr这个类遵守上下文管理协议，它的对象就称为上下文管理器，把这个对象赋给file去存储# 相当于file = MyContentMgr()，这时候就可以通过file调用它的方法# with里面的所有缩进都称为with语句体with MyContentMgr() as file:# 这个with语句体执行之后就会自动跳出上下文管理器，调用exit方法   file.show()  # exit方法被调用执行了

import os# 调用记事本# os.system('notepad.exe')# 直接调用可执行文件# os.startfile('C:\\Users\\79382\\AppData\\Local\\Google\\Chrome\\Application\\chrome.exe')

import os.pathprint(os.path.abspath('demo13.py')) # F:\pythonProject1\venv\Scripts\demo13.pyprint(os.path.exists('demo13.py')) # Falseprint(os.path.join('E:\\Python','demo13.py')) # E:\Python\demo13.pyprint(os.path.split('E:\\vipython\\chap15\\demo13.py')) # ('E:\\vipython\\chap15', 'demo13.py')print(os.path.splitext('demo13.py')) # ('demo13', '.py')print(os.path.basename('E:\\vippython\\chap15\\demo13.py')) # demo13.pyprint(os.path.dirname('E:\\vippython\\chap15\\demo13.py')) # E:\vippython\chap15print(os.path.isdir('E:\\vippython\\chap15\\demo13.py')) # False 因为demo13.py是文件

import ospath = os.getcwd() # 获取当前目录下的所有文件lst = os.listdir(path)for filename in lst: # 获取所有以py结尾的文件if filename.endswith('.py'):       print(filename)

import ospath = os.getcwd()# os.walk()可以遍历指定目录下所有的文件lst_files = os.walk(path)print(lst_files) # 获取的是一个对象# 这个迭代器对象返回来的是一个元组for dirpath,dirname,filename in lst_files:'''      print(dirpath)      print(dirname)      print(filename)      print('------------')  '''for dir in dirname:       print(os.path.join(dirpath,dir))for file in filename:       print(os.path.join(dirpath),file)   print('------------------------------')