命名空间

今日内容

作业回顾

 1  # sys.argv练习
 2  # 写一个python脚本,在cmd里执行
 3  # python xxx.py 用户名 密码 cp 文件路径 目的地址
 4  # python xxx.py alex sb cp D:python_22day221.内容回顾.py D:python_22day21
 5  # python xxx.py alex sb rm D:python_22day22
 6  # python xxx.py alex sb rename D:python_22day22  D:python_22day23
 7  8  # import sys,shutil,os
 9  # if sys.argv[1] == 'alex' and sys.argv[2] == 'sb':
10  #     print('登录成功!')
11  #     if sys.argv[3] == 'cp':
12  #         shutil.copytree(sys.argv[4],sys.argv[5])
13  #     elif sys.argv[3] == 'rm':
14  #         shutil.rmtree(sys.argv[4],ignore_errors=True)
15  #     elif sys.argv[3] == 'rename':
16  #         os.rename(sys.argv[4],sys.argv[5])

优化:1)判断脚本命令的长度,最少5位;具体的操作再判断下命令长度

   2)判断路径是否存在

   3)判断是文件夹还是文件,根据类型有两种分别对文件夹以及文件的操作

 1  # 定义一个圆形类,半径是这个圆形的属性,实例化一个半径为5的圆形,一个半径为10的圆形
 2  # 完成方法
 3          # 计算圆形面积
 4          # 计算圆形周长
 5          
 6  # class Round:
 7  #     def __init__(self,redius):
 8  #         self.redius = redius
 9  #     def area(self):
10  #         s = 3.1415926*self.redius**2
11  #         print(f'半径为{self.redius}的圆的面积为{s}')
12  #     def girth(self):
13  #         l = 2*3.1415926*self.redius
14  #         print(f'半径为{self.redius}的圆的周长为{l}')
15 16  # R10 = Round(10)
17  # print(R10.__dict__)
18  # R5 = Round(5)
19  # print(R5.__dict__)
20  # R10.area()
21  # R10.girth()
22  # R5.area()
23  # R5.girth()

优化:1)from math import pi如何取用π值

   2)不把周长和面积放到__init__,因为若改变半径不会改变周长与面积,所以要放到方法中

 
 1 # 定义一个用户类,用户名和密码是这个类的属性,实例化两个用户,分别有不同的用户名和密码
 2          # 登陆成功之后才创建用户对象
 3          # 设计一个方法 修改密码        
 4  5  # class User:
 6  #     def __init__(self,username,pwd):
 7  #         self.username = username
 8  #         self.pwd = pwd
 9  #     def login(self,):
10  #         name1 = input('用户名:').strip()
11  #         pwd1 = int(input('密码:').strip())
12  #         if name1 == self.username and pwd1 == self.pwd:
13  #             print('登录成功')
14  #             name2 = input('请输入用户名:').strip()
15  #             pwd2 = int(input('请输入密码:').strip())
16  #             global 中白
17  #             中白 = User(name2,pwd2)
18  #             print('注册成功!')
19  #         else:print('用户名或密码错误')
20  #     def revise(self):
21  #         pwd1 = int(input('请输入原密码:').strip())
22  #         if pwd1 == self.pwd:
23  #             print('请修改密码')
24  #             flag = True
25  #             while flag:
26  #                 pwd2 = int(input('请输入新密码:').strip())
27  #                 pwd3 = int(input('请确认新密码:').strip())
28  #                 if pwd2==pwd3:flag=False
29  #                 else:print('两次输入不一致请重新输入!')
30  #                 self.pwd = pwd2
31  #             print('修改成功!')
32  # 小白 = User('小白',123)
33  # 大白 = User('大白',321)
34  # 大白.login()
35  # print(中白.__dict__)
36  # import time
37  # time.sleep(2)
38  # 中白.revise()
39  # print(中白.__dict__)

优化:1)从文件中去匹配密码账号

   2)改变时把文件中的也改变

   3)活用if,例如登录系统返回一个bool值,用if ret:来判断是否执行下面语句

 1  # 使用walk来计算文件夹的总大小
 2  # import os
 3  # g = os.walk('D:python_22')
 4  # size = 0
 5  # for i in g :
 6  #     path,dir_lst,name_lst = i
 7  #     for name in name_lst:
 8  #         abs_path = os.path.join(path,name)
 9  #         size += os.path.getsize(abs_path)
10  # print(size)

新知识

python中一切皆对象,对象的类型就是类

1. 命名空间问题

  1. 类中的变量与对象中的变量

    1. 类中的变量是静态变量

    2. 对象中的变量只属于对象本身,每个对象有属于自己的空间来存储对象的变量

    3. 当使用对象名去调用某一个属性的时候会优先在自己的空间中寻找,找不到再去对应的类中寻找

    4. 如果自己没有就引用类的,如果类也没有就报错

    5. 对于类来说,类中的变量所有的对象都是可以读取的,并且读取的是同一份变量

  2. 类的命名空间:

    • 静态变量

    • 绑定方法

  3. 类中静态变量的用处

    1. 如果一个变量,是所有的对象共享的值,那么这个变量应该被定义成静态变量

    2. 所有和静态变量相关的增删改查都应该使用类名来处理,而不应该使用对象名直接修改静态变量

  4. 对象引用变量顺序

    对象会先在自己的内存空间中寻找变量的值,在没有的时候,因为对象中会有一个类指针指向类,就会再从类中去取值,调用方法时,先在自己空间寻找再去类的内存空间中调用函数,将生成结果保存到对象的内存空间中

 1  # class A:
 2  #     Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
 3  #     def __init__(self,name,age):  # 绑定方法 存储在类的命名空间里的
 4  #         self.name = name
 5  #         self.age = age
 6  #     def func1(self):
 7  #         print(self)
 8  #     def func2(self):pass
 9  #     def func3(self):pass
10  #     def func4(self):pass
11  #     def func5(self):pass
12 13  # a.func() == A.func(a) # 默认的

2.组合

  1. 什么是组合?

    一个类的对象是另外一个类对象的属性(类的嵌套)

 1  # 学生类
 2      # 姓名 性别 年龄 学号 班级 手机号
 3  # 班级信息
 4      # 班级名字
 5      # 开班时间
 6      # 当前讲师
 7  # class Student:
 8  #     def __init__(self,name,sex,age,number,clas,phone):
 9  #         self.name = name
10  #         self.sex = sex
11  #         self.age = age
12  #         self.number = number
13  #         self.clas = clas
14  #         self.phone = phone
15  # class Clas:
16  #     def __init__(self,cname,begint,teacher):
17  #         self.cname = cname
18  #         self.begint = begint
19  #         self.teacher = teacher
20 21  # 查看的是大壮的班级的开班日期是多少
22  # 查看的是雪飞的班级的开班日期是多少
23  # py22 = Clas('python全栈22期','2019-4-26','小白')
24  # py23 = Clas('python全栈23期','2019-5-28','宝元')
25  # 大壮 = Student('大壮','male',18,27,py23,13812012012)
26  # 雪飞 = Student('雪飞','male',18,17,py22,13812012013)
27  # print(大壮.clas,py23)
28  # print(py23.begint)
29  # print(大壮.clas.begint)

如上,学生类的班级属性是个班级类。

原文地址:https://www.cnblogs.com/zhangxiangning/p/10235076.html