精华内容
下载资源
问答
  • 对象持久 持久方式 文本文件存储–扁平文件 scores = [88,99,77,55] def write_scores(): with open('data_list.txt','w',encoding = 'utf8') as f: f.write(str(scores)) print('文件写入完成...') def...

    Python基础学习笔记DAY10

    对象持久化

    1. 持久化方式
    • 文本文件存储–扁平文件
    scores = [88,99,77,55]
    def write_scores():
       with open('data_list.txt','w',encoding = 'utf8') as f:
           f.write(str(scores))
       print('文件写入完成...')
    
    def read_scores():
       with open('data_list.txt','r',encoding = 'utf8') as f:
           lst = eval(f.read())
    
    if __name__ =='__main__':
       write_scores()
    
    • pickle
    import pickle
    person = {'name : 'Tom', 'age': 20}
    s = pickle.dumps(person)
    p = pickle.loads(s)
    //dumps 对象到字符串
    //loads 字符串到对象
    
    
    //序列化对象到二进制文件
    pickle.dump(person, open('pickle_db','wb'))
    p = pickle.load(open('pickle_db','rb'))
    

    ps: pickle不便于把多个对象存储在一个文件里

    • shelve(更适用于自定义的类)
    import shelve
    scores = [99,88,77]
    student = {'name':'Mike', 'age':20}
    
    db = shelve.open('shelve_student') //创建为二进制
    
    db['s'] = student
    db['scores'] = scores
    len(db)  //2
    temp_student = db['s']
    type(temp_student)
    
    del db['scores'] 
    
    class Student:
        def __init__(self,name,age):
            self.name = name
            self.age = age
            
        def__str__(self):
            return self.name
    
    def write_shelve():
        s =Student('Tom', 20)
        db = shelve.open('shelve_student_db')
        db['s'] = s
        db.close()
    
    def read_shelve():
        db = shelve.open('shelve_student_db')
        st = db['s']
        db.close()
    
    if __name__ =='__main__':
        read_shelve()
        read_shelve()
    
    • 数据库
    • ORM

    字符串本质

    (1)数据类型

    1. str 字符串
    2. bytes 字节
    3. bytearray 字节数组

    (2)字符编码架构

    1. 字符集:赋值一个编码到某个字符,以便在内存中表示
    2. 编码encoding:转换字符到原始字节形式
    3. 解码decoding:依据编码名称转换原始字节到字符的过程

    (3)字符串存储

    1. 编码只作用域文件错处或中间媒介转换时
    2. 内存中总是存储解码以后的文本

    (4)字符编码

    1. ASCII: 存储在一个Byte 0-127
      ord(‘A’);chr(104)
    2. latin-1: 存储在一个Byte 128-255
    3. utf-16: 2Byte存储字符(另加2Byte作为标识)
    4. utf-32:4Byte
    5. utf-8:可变字节:
      0-127使单字节
      128-2047双字节存储
      >2047 3Byte
      (每Byte使用128-255)
      utf-8优点:保持最大限度的兼容性的同时,减少存储字节大小

    (5)字符和编码间的转换

    • str.encode(‘编码’) 将特定字符编码
    s1 = 'ABCD'
    s1.encode('ASCII')
    
    s2 = '优品课堂'
    s1.encode('UTF-8')
    
    str.decode('编码') //将字符编码解码为字符文本
    b1 = b'\xe4\xbc\x98\xe5\x93\x81\xe8\xaf\xbe\xe5\xa0\x82'
    b1.decode('utf-8')
    
    //不指定编码方式,默认以utf-8
    s1.encode()
    
    //如何获知系统默认的是哪种编码方式:
    //方法1
    s2.encode //输入后系统会显示提示
    //方法2
    import sys
    sys.getdefaultencoding()
    
    //ps:文件操作是按照gbk的形式写的
    

    (6)字符串和字节的类型转换

    //字符串获取字节的方法(字节不能原位改变)
    //方法1:通过encode方法:
    s = abc
    s.encode()
    
    //方法2:通过bytes函数:
    bytes('abc','ascii')
    bytes([87,65,89,97])  //只能在0-255
    
    //方法3:b = b'abc'
    

    (7)字符串字节的读取和编码的读取

    open('data.txt','rb').read()
    open('data.txt','rb').read()
    

    (8)bytearray(可原位改变)

    ba = bytearray(s1,'utf8')   //bytearray(b'abc')
    ba[0] = 98    //bytearray(b'bbc')
    ba.append(93) //append的数要在256之内 
    ba +b'c!'
    
    //转化为字符串
    ba.decode()
    

    (9)BOM处理

    open('data.txt','r',encoding='utf8').read()
    //额外存储字节顺序标记/ufeff
    
    open('data.txt','r',encoding='utf8-sig').read()
    //忽略标记
    
    open('data3.txt','r',encoding='utf8-sig').write('123')
    //加入字节顺序标记
    
    展开全文
  • 这两者区别在于对内存的占用,开发过程中,主要解决的问题就是内存的...2.实例化对象,实实在在的占用内存空间。 格式: 对象名 = new 类();“类()”是一个构造函数,依据个人所需进行有参或无参的实例。 ...

    这两者区别在于对内存的占用,开发过程中,主要解决的问题就是内存的使用和释放。

            1.声明对象,给编译器发一个通知预留一定空间,而没有占用实际内存。

        格式:  类  对象名;
           2.实例化对象,实实在在的占用内存空间。
        格式: 对象名 = new 类();“类()”是一个构造函数,依据个人所需进行有参或无参的实例化。
     

    展开全文
  • 面向对象的方法是以对象为核心来构造软件框架的。 结构方法是按功能分解的规律组织软件系统结构的。 二、 应对需求变更能力的不同。 面向对象的方法与生俱来很强的应对需求变更能力。能从容应对客户的需求变更...
    一、系统的构造内容不同。
    面向对象的方法是以对象为核心来构造软件框架的。
    结构化方法是按功能分解的规律组织软件系统结构的。
    二、 应对需求变更能力的不同。
    面向对象的方法与生俱来很强的应对需求变更能力。能从容应对客户的需求变更。
    对结构化方法来说,它的先天缺陷是需求变更很难,一旦要需求变更,意味着以前一切的工作都是徒劳的。
    三、管理维护的难易程度不同
    面向对象方法对管理信息系统的维护很简单。
    结构化方法对管理信息系统的维护很困难。
    四、思维模式不同
    面向对象方法的思维模式是:关注“责任”,把责任转移。关注要解决的问题可以归纳或划分为哪些责任,归纳每个对象应该负有的责任,然后通过消息传递,让他们各自承担起自己的责任就行了。通过对象自身的行为改变其内部状态(所谓封装的概念)。
    结构化方法的思维模式是:只关注要解决的问题的本身,不关注应由“谁”来完成。主要是通过外部力量改变数据状态。
    五、强调的重点不同
    面向对象方法强调对象交互。对象是一等公民,我们主要关注的是对象如何通过向彼此发送消息,支配行为,改变状态。
    结构化方法强调过程序列。过程是一等公民,我们首先要知道做事情的一连串过程,一个过程就是一个改变实体状态的操作序列。
    总之,结构化的方法是在传统的编程语言环境下诞生的,用这种方法构建的系统结构使得开发人员在面对用户需求频繁变更的开发环境时,吃尽了苦头。
    相比之下,面向对象的语言和方法,使开发人员如释重负。首先,面向对象编程方法带来了高效、可靠、易维护、易扩充的效果。其次,运用面向对象的思维模式来认识和理解系统的构成,更接近于人们对客观世界的认知习惯。最重要的是,运用面向对象的方法构建的设计方案能够灵活自如地应对用户的需求变更,而这种变更对使用结构化方法构建的系统往往是一种致命的挑战。因此,面向对象的方法逐渐发展成为主流软件工程方法。
    展开全文
  • 面向对象本质

    2020-02-15 22:19:41
    面向过程将解决问题的步骤写在函数里面,让计算机有步骤的按顺序解决问题,在大型的软件工程开发中这样的过程会造成维护困难,因为在软件开发中需求的改动是常见的事,例如AB两人同时开发一个软...

    Author JYBlog

    Email jcAuthor@163.com

    本博客GitHub开源(jcNaruto/JYBlog),

    JYBlog每周五,周三公众号等多平台同步更新,欢迎讨论交流~

    #.补充

    面向过程在开发中也可以使用结构体等操作来实现高内聚低耦合,也可以写出遵循开闭原则的代码,抽象的看面向对象,有点像形而上的编程思维,也是编程范式之一,也就是在编写动态迭代的软件工程中面向对象的编程思维会提高工程可扩展性,维护性,甚至降低工作量,高手使用面向过程一样也可以写出扩展性,可维护性很好的代码(工作量会大些,但可能会带来性能或其他方面的收获),再者映射到具体的面向对象的语言,例如Java语言实现了面向对象的编程思维,使得开发者更加方便的接触面向对象思维。

    1.概述

    面向过程将解决问题的步骤写在函数里面,让计算机有步骤的按顺序解决问题,在大型的软件工程开发中这样的过程化会造成维护困难,因为在软件开发中需求的改动是常见的事,例如AB两人同时开发一个软件,要旋转三个图形,正方形,三角形,圆形,A采用面向过程开发,B采用面向对象开发

    //A开发
    rotate(shapeName){
        //旋转
    }
    
    //B开发
    class Square{
        ....
        public void rotate(){
            //旋转
        }
    }
    class Triangle{
        ....
        public void rotate(){
            //旋转
        }
    }
    class Round{
        ....
        public void rotate(){
            //旋转
        }
    }
    

    此时你会发现面向过程的优越性,代码量要少的多,但是现在需求改变,要添加一个六边形,且六边形的旋转方式与之前三个不一致

    //A开发新增的需求
    rotate(shapeName){
        if(hexagon){
            //六边形旋转
        }else{
           //旋转 
        }
    }
    

    面向过程在需求动态改变的时候要修改已测试过的代码,也就是随着需求的每次更改都要重新测试,十分耗费资源

    例如互联网中产品的迭代伴随着一生,比如某产品到现在还要因为迭代而测试多余的代码会使得整个项目变得异常臃肿缓慢

    //B开发新增的需求
    .....
    class Hexagon{
         ....
        public void rotate(){
            //旋转
        }
    }
    

    面向对象只需要在增加一个类就行了,此时面向对象的优越性就体现出来,可以不修改已近测试过的代码,需求是会不停的更改的,每改一次就只需要测试新增的类即可

    也就是说在软件工程动态的迭代的过程中,面向对象的优越性体现出来,但是此时还存在一个问题,面向对象的代码量比面向过程要高的多,为了解决这个问题可以使用面向对象的继承特性,同时为了降低程序的耦合性和提高代码的内聚性面向对象中还有封装以及提高了程序可扩展性的多态。

    2.封装(Encapsulation)

    class Student{
        public int age;
    }
    
    class Teacher{
        
        public void score(){
            Student student = new Student();
     		student.age = -99;//不安全       
        }
    }
    

    以上就是不封装的结果,完全脱离实际业务情况,并且student的age filed暴露给了所有的其他对象,为了解决此种情况,一般推荐将你的实例变量标记为private,然后对每个filed提供唯一的public的setter(设置),getter(获取)方法,强制其他的对象在设置或者获取该field时一定要经过对应的setter,getter方法,并且在setter或者getter方法内部你还可以根据业务需求进行一定的逻辑判断

    class Student{
        private int age;
        
        public void setAge(int age){
        	if(age > 105 || age <0){
                thorw new RuntimeException("age invalid");//在set方法内做业务逻辑校验
        	}
            this.age = age;
        }
        
        public int getAge(){
            return age;
        }
    }
    
    class Teacher{
        
        public void score(){
            Student student = new Student();
     		student.setAge(12);     
        }
    }
    

    注意

    1. getter,setter方法的命名是有规范的(规范就是最好遵守,不遵守也可以,但是可能会付出高昂的代价,软件工程中可能就是要自己造所有的轮子),xxx getPropertyName(), void setPropertyName(xxx propertyName),如果是filed 是boolean类型get方法命名为 boolean isPropertyName(),并且有getter和setter方法的filed可以称之为属性
    2. 实际的开发中,很少会在setter和getter方法做校验,因此有人便提出可以省略去getter和setter直接将filed设置为public,这是错误的观点,因为即使这两个方法只是直接返回或者设置了filed的值,但还是为field提供了统一访问路径,假如某一天新需求是要对某个参数做校验,直接在setter方法中设置即可,但是如果直接外暴filed的public属性,无数的xxx.field很难在进行校验。也就是说getter,setter方法提高了程序的内聚性降低了模块的耦合性,即使没有校验逻辑也要加上。如果一个class的所有属性对应了setter,getter方法,则该class可以称之为Java bean,多用于传输数据。
    3. 一般敏感数据或者外部不不必感知的复杂逻辑方法也要使用private封装,以降低耦合度,降低使用成本。

    3.继承(Inheritance)

    回到之前开发图形旋转的例子,多个类中有重复的rotate方法,此时就可以抽取一个父类,父类中具有那个rotate方法,子类通过extends就可以继承父类,然后具有那个rotate方法,但是六边形的旋转方式不一样,这时就可以通过@Override来重新实现自己的rotate方法。

    注意:

    1. 继承表面上看是代码复用技术使模块具备复用性同时也在子父类之间构建了某种协议,但普通类继承和抽象类继承和interface implements配合在一起使用,可以用来设计出规范性,复用性很强的类架构。

    2. 今后如果在更改被抽取的代码的话,只需更改这一处即可,并且只需要重新编译父类即可。

    3. java 单继承,因为要避免多继承的致命方块问题,但是采用了接口来弥补了单继承的不足。

    4. super表示父类,super.filedName访问父类filed,super()为调用父类构造方法,任何类的构造方法第一行都是这个,如果没有编译器会自动加上。

    5. 继承有一个局限就是子类无法访问父类的private 字段或者方法,改成protected,使其可以让子类或者子子类访问。

    6. Object是Java中的总父类,是对万事万物的抽象

    7. 区分组合和继承,组合就是将引用类型变量作为field,is 用继承,has用组合,通过李氏替换原则判断是否满足is关系,既任何父类出现的地方对应的子类都能够出现,成功编译运行。

    8. final修饰class和修饰方法对继承的影响。

    9. 可以将子类向上转型为父类,称为向上转型,也可以将父类转为子类,但可能会报错,因为子类扩展的方法父类没有,向下转型的时候可以用instanceof做判断运算符左边的实例是否为右边的类型或者为右边的子类

      class Person{
          public int age;
          public String name;
          
          public void say(){
              System.out.println(age + "=====" + name);
          }
      }
      
      class Student extends Person{
          public int score;
          
          @Override
          public void say(){
              System.out.println(age + "=====" + name + "=======" + score);
          }
      }
      
      public class InheritTest {
      	public static void main(String[] args){
              Person upStudent = new Student();//向上转型,ok
              Student downStudent1 = new Person();//向下转型,ClassCastException
              
              if(upStudent instanceof Student){//instanceof 运算符,可以判断左边的实例是否为右边的类型或者为右边的子类   
                  Student downStudent2 = (Student)upStudent;//此时向下转型成功
              }
              
              //调用的是Person还是Student的say方法
              upStudent.say();
              //实际上调用的是Student的方法,这就是多态
      	}
      }
      

      继承的使用成本十分低,但是这带来一个负面问题,滥用继承,出现方法污染和方法爆炸,方法污染是指父类具备的功能传给子类,但是子类不具备该功能,方法爆炸是指某个子类方法过多,不宜与代码编写和调式,因此谨慎使用继承,避免滥用

    4. 多态(Polymorphic)

    子类向上转型之后,子类同时也覆写了对应的方法,此时调用的是子类中的方法,但是变量的标识符确实父类类型的,因此得出结论Java的实例方法调用是基于运行时的实际类型的动态调用,而不是申明的变量类型,这就是多态。其含义就是运行期动态的决定调用的是子类的方法还是父类的方法。

    多态强大的功能允许不修改父类代码和业务逻辑代码,就通过扩展子类来实现功能的扩展。

    举个栗子

    不同学院的保研排名计算方式不一致,各个学院有各个学院的算法

    class Push{
        public int[] scores;
        
        public void getFinalScore(){
            System.out.println(scores*0.1 + scores*0.4 + scores*0.5);
        }
    }
    
    class MathStudent extends Push{
        @Override
         public void getFinalScore(){
            System.out.println(scores*0.9 + scores*0 + scores*0.1);
        }
    }
    
    class CSStudent extends Push{
        @Override
         public void getFinalScore(){
            System.out.println(scores*0.3 + scores*0.4 + scores*0.3);
        }
    }
    
    public class Caculator{
        public void getFinalScores(Push[] pushs){
            for(Push push : pushs){//利用多态,getFinalScores只和Push父类相关,当要新增某个学院的学生时只需要,新增子类并实现其getFinalScore方法即可,并将其实例传入,其他的代码都不需要修改
    			push.getFinalScore();
            }
        }
    }
    

    类似的interface和实现类的之间也可以实现多态

    多态使模块在复用的基础上具备了更强的可扩展性

    注:重载和多态没有任何的关系,重载根本没有覆盖任何方法,并且重载在编译时期已经可以确定要调用的方法,谈不上动态!!!

    5. 总结

    面向对象三大特性

    1. 封装,提高程序内聚,降低耦合,降低程序维护使用成本。
    2. 继承,使模块间可以复用,少写代码,是多态的基础,同时在子父类之间产生了一种协议。
    3. 多态,使模块在复用的基础上具备了更强的可扩展性。

    6.面向对象与抽象

    1. 面向对象就是通过对象把现实世界映射到计算机模型的一种编程方法,是抽象思维的一种体现。

    2. 抽象是计算机科学中及其重要的一种思维。

    ​ 2.1 抛弃细节,直接使用现成的api(指令集是CPU的抽象,编程时并不需要了解CPU底层的集成电路细节,直接使用指令集即可,大大降低了计算机的使用成本)。

    ​ 2.2 面向对象中抽象分为归纳演绎,归纳:从具体到本质,个性到共性,演绎:从本质到具体,共性到个性。

    7.致谢

    1. 码出高效Java开发手册 杨冠宝(孤尽) 高海慧(鸣莎)
    2. HeadFirst Java Bert Bates Kathy Sierra
    展开全文
  • http://blog.csdn.net/wojiushiwo987/article/details/7251740面向对象方法论与结构方法论的本质区别【转】 一、系统的构造内容不同。 面向对象的方法是以对象为核心来构造软件框架的。 结构方法是按功能分解...
  • 在.NET环境下,万物皆对象,在HttpRuntime收到请求之后,立即将通过HttpWorkerRequest传递的参数进行分析和分解,创建方便用于网站应用程序处理用的对象,其中主要涉及到两个对象类型:HttpRequest类型和...
  • 创建对象及this的本质

    2020-12-13 16:23:43
    this的本质就是“创建好的对象的地址”!!!由于在构造方法调用前,对象已创建。因此,在构造方法中可以使用this代表“当前对象” this最常的用法 在程序中产生二义性之处,应使用this来指明当前对象,this总是...
  • **对象创建的过程和this的本质:** 使用new关键字调用构造器时,构造器也确实返回该类的对象,但这个对象并不是完全由构造器负责创建。 创建一个对象分为如下四步: 1、分配对象空间,并将对象成员变量初始化为0...
  • 文章目录 单元测试 常用断言方法 类与测试装置 对象持久 使用格式文本 pickle应用 shelve应用 字符串本质 正则表达式 特殊符号与字符 系统工具 单元测试 import unittest def add(a,b): return a+b class Mytest...
  • spring注入,本质其实就是实例化对象后赋值给接口的引用,在其他类要调用接口时,他不需要考虑实现类,直接和接口打交道,就是通过A d=new a(),但是对象都是由spring实例,所以spring注入,就是将实例化对象给接口...
  • * this的本质对象创建过程的四步 * @author 110 * *创建一个对象分为如下四步: *1:分配对象空间,并将对象成员变量初始化为0或空。 *2:执行属性值的显示初始 *3:执行构造方法 *4:返回对象的地址给相关变量...
  • 序列本质

    2019-10-08 14:13:17
    序列是把内存中易丢失的数据结构或对象状态转换成另一种可存储(存储到磁盘),可在网络间传输的状态的数据,然后可以在以后某一时刻再恢复到序列之前的数据状态! 序列化本质也是数据形式的转化!一种形式...
  • 1、什么是序列和反序列Serialization(序列)是一种将对象以一连串的字节描述的过程;反序列deserialization是一种将这些字节重建成一个对象的过程。   2、什么情况下需要序列 a)当你想把的内存中的...
  • 模块更深,封装性强 更容易实现复杂的业务逻辑 更容易维护、复用、扩展 面向对象的特征: 封装性:对象是属性和行为的结合体 多态性:同一消息被不同对象接收后,会产生不同的效果 继承性:子类型可继承父类的...
  • 如果你需要把对象的... java序列本质:就是把对java对象转换为字节序列的过程。  java反序列本质:把字节序列恢复为java对象的过程。  接下来用一个例子把一个java对象存成文件然后转换成java对象并...
  • oleVariant序列化对象

    2019-01-08 05:20:36
    midas支持使用OLEVARIANT序列化对象,最新的DATASNAP支持使用OLEVARAINT和JSON来序列化对象。 下面的代码演示OLEVARINAT序列TPARAMS, TPARAMETERS对象。OLEVARIANT本质上是一个BYTE数组。   还原TPARAMS对象 ...
  • JAVA创建对象的过程和this的本质 创建一个对象分为四步: 1、分配对象空间,并将对象成员变量初始化为0或空 2、执行属性值的显式初始 3、执行构造方法 4、返回对象的地址给相关的变量 public class F...
  • this 1.分配一个对象空间,并将对象成员变量初始化为0或空 2.执行属性值的显示初始 3.执行构造方法 4.返回对象地址给相关变量
  • 抽象原则是一切系统科学方法都必须遵循的基本原则它注重把握系统的本质内容而忽略与系统当前目标无关的内容它是一种基本的认知过程和思维方式 (2)分解原则 分解原则是结构方法中最基本的原则它是一种先总体后...
  • _x: 单前置下划线,私有属性或方法,from somemodule import *禁止导入,类对象和子类可以访问 __xx:双前置下划线,避免与子类中的属性命名冲突,无法在外部直接访问(名字重整所以访问不到) xx:双前后下划线,用户...
  • 我们都知道Python中,一切皆对象,比如创建的变量、列表、元组、字典等都是对象对象本质上就是一个“存储数据的内存块”。 有时我们需要将“内存块的数据”保存到硬盘上,或者通过网络传输到其他计算机上。这时就...
  • 用const修饰类的对象,那么该对象不允许修改其属性值,同时也只能调用该对象的常函数,该对象又称常对象。 C++中写单例模式需要将默认构造函数、默认拷贝构造函数设置为私有,并设置私有的静态指针 然后再设置...
  • 序列的原本意图是希望对一个Java对象作一下“变换”,变成字节序列,这样一来方便持久存储到磁盘,避免程序运行结束后对象就从内存里消失,另外变换成字节序列也更便于网络运输和传播,所以概念上很好理解: ...
  • 数据在网络上的传输形式都是二进制字节流,序列本质就是把对象转化成字节码,来进行网络传输。 1 只有实现了serializable接口和externalizable接口的类拥有被序列的权限。 2 如果此类可以实现序列,那么此类...
  • 执行属性值的显式初始。 执行构造方法。 返回对象的地址给相关的变量。 有关于this的用法 this不能用于statis方法中。 statis修饰的成员变量和方法从属于类而不是对象。普通变量和方法从属于对象。 静态...
  • 1.分配对象空间 并将对象成员变量初始 为 数字默认0 或者 引用默认空 Boolean默认false 2. 属性值的显试初始 3. 执行构造方法 //执行构造方法时 对象已经创建好并且初始了 构造方法只是进一步初始 4. 返回...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,879
精华内容 1,951
关键字:

本质对象化