# 以前版本的写法
class Person():
    pass
新版本的写法
增加了参数object, object表示对象的意思
也就是说说有的类的父类都是object
即所有的对象都是面向对象的
class Person(object):
    pass

class Water(object):
    type = 'power'
xlwater = Water()
print(xlwater.type)
# 类的文档字符串
print(xlwater.__doc__)
# 类所在的模块
print(Water.__module__)
# 类的所有父类构成的元素
print(Water.__bases__)
# 类的属性
print(xlwater.__dict__)
# 类的名字
print(Water.__name__)

1. 面向对象的含义
    所有的数据都是面向对象的
    这是一种编程的思维模式

2. 类的定义
    定义类也叫做类的封装
    表示将一组相同或者类似的数据使用一个对象
    来统一进行设定,我们需要使用关键字class来定义
    例如:
        旧版本中:
            class Person():
                pass
        新版本中:
            class Person(object):
                pass
    注意:要有冒号表示结束

3. 类的属性和实例化属性
    声明一个类之后我们可以设置一个默认属性
    也可以不设置默认属性
    3.1 类的属性的设置
    我们可以设置一个变量作为类的属性
    这样的所有的实例化的对象都会具备这个属性
    3.2 类的实例化属性
    我们需要将实例化对象的属性和对象进行绑定
    往往使用__init__来进行声明
    例如:
        class Preson(object):
            def __init__(self, name):
                self.name = name
        a = Person('test')
        这个时候Person表示一个类
        a 表示对Person进行的实例化
        name是Person的属性
    3.3 属性的方法
        getattr(obj, name[default])
            访问对象的属性
        hasattr(obj, name)
            判断对象是否存在属性
        setattr(obj, name, value)
            设置属性和其属性值
        delattr(obj, name)
            删除对象的属性和属性值

    类的属性的增加和删除
    类的属性是可以在实例化之后动态增加的
    同时也可以删除
    例如:
        class Person(object):       ---> object表示继承的父类
            country = 'china'       ---> 默认的属性
        a = Preson()                ---> 对Preson进行实例化
        a.country                   ---> 访问属性
        a.name = '喜羊羊'           ---> 增加属性
        del a.country               ---> 删除属性
    3.4
        class Person(object):
            a = 1               # 公有变量
            _b = 10             # 特殊变量
            __c = 100           # 私有变量
            def add(self):
                print(self.a + 1)
                print(self._b + 1)
                print(self.__c + 1)

        tom = Person()
        tom.add()
        print(tom.a)
        print(tom._b)
        # print(tom.__c)        # 会报错
    私有变量:使用__(两个下划线) 表示私有变量
        私有变量是无法从外部实例化的对象获取的
        但是可以被类的内部的方法所获取
    特所变量:使用_(一个下划线) 表示特殊变量
        特殊变量可以通过类提供的接口进行访问,
        但是所有使用_开头的名称都不会被访问。
    公有变量:可以被实例化对象访问
        也可以被类中的方法访问,提供的接口也可以被访问

    # 例子一
    # 我们可以使用 del 来自动的回收类对象
    # del 并不需要手动调用,当进行实例化对象的时候就会自动调用
    # 通过以下的例子我们发现,类对象指向的都是一个位置
    # 但是实例化对象指的是不同的位置
    class Person(object):
        def __init__(self, name):
            self.name = name
        def __del__(self):
            print('实例化对象:%s' % self.name, id(self))
            print('python解释器回收%s对象' % self.name)
            print('类对象的位置', id(Person))
    sys = Person('sys')
    hm = Person('hm')

    # 例子二:先执行,后调用
    class Test(object):
        def __del__(self):
            print('over...')
    a = Test()
    print('---')
    print('---')
    print('---')

4. 类的方法
    4.1 常规的设定函数
        def eat(self)
            print('eatting...')
        参数必须是self,且不能省略参数
    4.2 使用@classmethod 方法来创建类函数
        @classmethod
        def eat(cls)        ---> 参数变成cls
            print('eatting...')
    4.3 使用@staticmethod方法来创建类函数
        @staticmethod
        def eat()           ---> 不需要使用参数
            print('eatting...')
    4.4 区别
        @classmethod:必须使用参数cls,但是不需要做实例化对象了
        @staticmethod:不需要任何参数,不需要做实例化对象
        普通函数:必须使用参数self,且必须实例化对象

5. 类的特性
    5.1 封装:将一类对象进行设定就叫封装,现在我们来定义类,就是在做类的封装
    5.2 继承:子类可以继承父类的公有属性和公有方法
        多重继承:一个子类可以继承多个父类
                一个父类也可以被多个子类继承
    5.3 多态:一种接口,多种实现
            是指一个类实例的相同方法在不同情形下有不同表现形式,多态机制使具有不同内部结构的对象可以共享相同的外部接口

作业

# test01:
# 请使用函数将昨天的作业进行以下的修改
# 删除日期为偶数的文件

# 引入OS模块和datetime模块
import os
import datetime

# 获取之前十天日期
def cc(day=0):
    a = datetime.datetime.now()
    a = a - datetime.timedelta(days=day)
    a = a.strftime('%Y-%m-%d')
    return a

# 创建目录及文件结构
list = ['python', 'app', 'nginx', 'ios', 'tomcat', 'apache']
os.chdir(r'D:\ ')
os.mkdir('logs')
os.chdir('logs')
c = os.getcwd()
for i in list:
    os.chdir(c)
    os.mkdir(i)
    d = os.path.join(c, i)
    os.chdir(d)
    for j in range(10):
        w = open(i + cc(j) + '.txt', 'w+')
        w.close()
# 获取目录文件结构
for i in list:
    os.chdir(c)
    d = os.path.join(c, i)
    os.chdir(d)
    s = os.listdir()
    # 用切割和合并的方式获取日期并强制类型转换  (如:20190101)
    for j in range(len(s)):
        rqi = int(''.join(s[j].split(i)[1].split('.')[0].split('-')))
        # 判断如果日期除以2的商为0,那么就是偶数,然后将删除当前偶数日期的文件
        if rqi % 2 == 0:
            os.remove(s[j])
Last modification:August 10th, 2020 at 11:03 pm
如果觉得我的文章对你有用,请随意赞赏