01计算任意文件夹的思路解析、02利用内置函数实现自制int函数myint、03面对对象编程思想...

1计算任意文件夹的思路解#### 计算任意文件编程

# 第一步：计算的是对象
# 通过思考发现我们需要定义一个我们要计算的文件的路径
# pathvar = "/mnt/hgfs/gongxiang_16/day17/ceshi100"
# 大致知道要计算这个目录下边的ceshi100
# 第二步：大体思路理清楚
# 第三部：验证逻辑，运行结果

# 写一个程序的思路可以理解为我该怎么去使用它下手，通过本案例可以知道
# 需要定义一个函数，然后通过函数计算出结果然后，返回结果，然后打印出来
# 第一步大致可能下出下面的结果
# def 计算所有文件大小():
def getallsize("传入的文件的路径"):
    pass

file_count = getallsize("传入的文件夹路径")
print(file_count)
# 第二步写出 
def getallsize(pathvar):
    # 查看文件夹内容
    lst = os.path.listdir(pathvar)
    # 列表中的内容就是文件里面的内容，现在不确定里面是目录还是文件
    # 如果是目录的话，还需要继续的处理，如果是文件可以直接计算出文件的大小
    # 此时得出我们需要一个循环判断是否是文件还是目录进而做出相应的处理
    for i in lst:
        # 查看下列表中的文件或者目录
        print(i)
        # 对文件就行组成新的路径，就行os.path.isdir()判断
        path_new = os.path.join(pathvar, i)
        if os.path.isdir(path_new):
            # 由于判断isdir这个函数的参数是完整的参数，列表中得到的参数只是文件里面的内容(文件或者目录于是)
            # 于是需要构造一个把每一个列表中的文件或者目录组成新的路径
            # path_new = os.path.join(pathvar, i)
            pass
        elif os.path.isfile():
            pass

# 第三步 
def getallsize(pathvar):

    lst = os.path.listdir(pathvar)
    for i in lst:
        print(i)
        path_new = os.path.join(pathvar, i)
        if os.path.isdir(path_new):
            # 对是目录的情况详细处理
            size += getallsize(path_new)# 使用递归的方式就行把数据读取出来


        elif os.path.isfile(path_new):
            # 对是文件的情况就行处理
            # 获取文件的大小只需要getsize()即可
            size += os.path.getsize(path_new)

    return size

file_count = getallsize(pathvar)
print(file_count)

总结：1.分析题的意思，结合所学知识
     2.写出整体框架，可以从要怎么去使用定义的这个函数或者说是对象入手。
　　　3.再次完善每一个部分的内容。

 

2利用内置函数实现自制int函数myint

## 利用内置函数实现自制的int函数myint
# 分析：由于要创建一个类，那么我们调用对象的时候，出现对应的值，那么立马想到__call__
# __call__ 的意思就是当把对象当函数调用并输出的时候会用到内置方法__calll__方法
# 大白话就是说，把对象当做函数使用

# 假如写好了，我们怎么去使用呢？
# myint = MyInt()
# res = my("1222000")
# print(res)

import math
class MyInt():
    #第三步写出专门处理字符串的函数
    def stoi(self, n, sign=1):
        # 传入函数的n是去掉了符号了之后的字符串
        # 分析：特殊情况00000000
                # 一般情况 00000001
                # 去掉左边的0
        res = n.lstrip("0")
        if res == '':
            return 0
            # 把字符串转化为数字的函数exvl,然后乘以符号位sign
        return eval(res) * sign

    # 函数stio()
    # 第一步写出大体的框架
    # 把def __call__(self, n):下面的内容当做函数来写就对了
    def __call__(self, n):
        # n为对象传进来的参数n, (实际就是把对象当做函数执行，怎么执行？的代码区，def __call__x下为函数的内容)
        if isinstance(n, int):
            return n
        elif isinstance(n, bool):
            if n == true:
                return 1
            return 0
        elif isinstance(n, float):
            # 利用math 中的floor(正数向下取整)和ceil(负数向上取整)来得到同等效果的整型转换的数值
            if n >0:
                return math.floor(n)
            return math.ceil(n)
            # 第二步对框架中的细节部分就行细化
        elif isinstance(n, str):
            # 如果传入的字符串是带有'+'.'-'
            if (n[0] == '+' or n[0] == '-') and n[1:].isdecimal():
                # 经过这步的处理的话，可以把字符中带有"+"和"-"的字符串符号提取出来，
                # '+'可以当做 1
                # '-'可以当做-1
                # n[1:] 剩余的是没有处理的传进来的字符串，这样我们可以调用类里面的函数stoi()来处理
                # 最后的处理的结果乘以sign 就是最后的结果 
                # 利用函数stoi 处理剩余的字符串(传入参数n,sign(符号位))
                #
                if n[0] == '+':
                    sign = 1
                elif n[0] == "-":
                    sign = -1
                return self.stoi(n[1:], sign)
            elif n.isdecimal():
                # 能走到这一步的话，那么字符串一定都是纯数字类型的
                return self.stoi(n)

            else:
                # 满足是字符串都是但是"sdjsad0000"
                print("对不起,老哥，这个我算不了！")
        else:
            # "排除的是不满足任意一种条件的数据"
            print("对不起,老哥，这个我算不了！")





myint = MyInt()
print(myint(False))
print(myint(5))
print(myint(-5.5))
print(myint("+000000000222"))
print(myint("-000000000000"))
print(myint("-00000000000000022"))
print(myint("000000000000"))

运行结果：

总结：
第一步：可以怎么使用去开始考虑
第二步：写出大体的框架
第三步：细化到要用的例子

 

3面对对象编程思想

 

1把对象理解为工厂产生出来的产品，
类的方法可以理解为：工厂里面生产产品需要的机械和
类属性的话可以理解为：工厂的某些特征

2.在类内部是可以访问私有成员的：通过方法调用
即是在工厂内部可以调用一些专门的服务(包装、加工)：通过内部人员实现（机械）

3.对象：类实例化之后的，可以调用类中的方法和属性
可以理解为工厂生产的产品，可以享受参观和调用工厂公有机械（方法和属性）
但是对象不能调用类里的一些私有属性和方法。
可以理解为产品卖出去之后，也不能调用工厂私有的的东西(属性或者方法)

4.对象可以动态的添加属性和方法。相当于产品卖出去之后，任意的改造，都和工厂没有关系。
5.类可以动态的添加属性和方法。
6.对象访问类的公有方法和属性，封装性中的，有个方法就是绑定到类，即是系统自发的传入一个参数self，那么我们在工厂内部，即是在类的内部，需要选择接受对象的参数self(默认),这样的结果之后，可以理解为机械生产什么型号的产品，类的方法中需要的参数就是
def __init__(self, name, count)
其中__init__中的参数即是我们要制作对象出来的时候给赋予的参数。
那么，在类的方法中，除了参数self，其余的参数就是我们对象调用类中某个方法需要达到什么样子的效果，需要传入的参数。
注意：不要理解方法中的参数中的self.参数就是类的对象的属性，其实真正对象的属性已经在init写出并初始化。

 

转载于:https://www.cnblogs.com/longerandergou/p/10914639.html