python学习笔记二

一、Pickle

在机器学习中，我们常常需要把训练好的模型存储起来，这样在进行决策时直接将模型读出，而不需要重新训练模型，这样就大大节约了时间。Python提供的pickle模块就很好地解决了这个问题，它可以序列化对象并保存到磁盘中，并在需要的时候读取出来，任何对象都可以执行序列化操作。

二、文件对象的方法：

文件对象的方法：(f是文件路径)

f.read()    #读取文件

f.close()    #关闭打开的文件

f.readline()    #从文件中读取单独的一行，f.readline()如果返回一个空字符串，说明已经读取到最后一行。

f.readlines()    #返回该文件中包含的所有行。

f.write()    #将string写入到文件中，返回写入的字符数。

f.tell()    #返回文件对象当前所处的位置，它是从文件开头开始计算起的字节数。

f.seek()    #如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数 。from_what 值为默认为0，即文件开头 。

seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符 。

seek(x,1) ： 表示从当前位置往后移动x个字符 。

seek(-x,2) ：  表示从文件的结尾往前移动x个字符 。

三、Python面向对象---->类对象：

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

方法：类中定义的函数。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

局部变量：定义在方法中的变量，只作用于当前实例的类。

实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

实例化：创建一个类的实例，类的具体对象。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用 。

当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。

#创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象
class MyClass:

    i=123456
    def f(self):
        return'hello world...'

#实例化类
x=MyClass()

print("MyClass 类的属性 i 为",x.i)    #访问类的属性
print("MyClass 类的方法 f 输出为：",x.f())    #访问类的方法

#类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用
#类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法

class Comples:
    def __init__(self,realpart,imagpart):    # __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上
        self.r=realpart
        self.i=imagpart

#实例化类 Complex，对应的 __init__() 方法就会被调用
x=Complex(3.0,-4.5)
print(x.r,x.i)

#类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
#从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。
class Test:
    def prt(self):
        print(self)
        print(self.__class__)

t=Test()
t.prt()

四、Python面向对象---->类的方法：

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

class people:
    #定义基本属性
    name=''
    age=0
    #定义私有属性，私有属性在类外部无法直接进行访问
    __weight=0
　　#定义构造方法：
    def __init__(self,n,a,w):
        self.name=n
        self.age=a
        self.__weight=w
    def speak(self):
        print("%s 说: 我 %d 岁。"%(self.name,self.age))

#实例化类
p=people('yuangungun',10,30)
p.speak()

五、Python面向对象---->继承：

#定义类：
class people:
    #定义基本属性
    name=''
    age=0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight=0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name=n
        self.age=a
        self.__weight=w
    def speak(self):
        print("%s 说: 我 %d 岁。"%(self.name,self.age))

#单继承示例
class student(people):
    grade=''
    def __init__(self,n,a,w,g):
        #调用父类的构造
        people.__init__(self,n,a,w)
        self.grade=g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s=student("yuangungun",10,60,3)
s.speak()

六、Python面向对象---->多继承：

#类定义：
class people:
　　#定义基本属性：
    name=''
    age=0
　　#定义私有属性：
    __weight=0
　　#定义构造方法：
    def __init__(self,n,a,w):
        self.name=n
        self.age=a
        self.__weight=w
    
    def speak(self):
        print("%s 说: 我 %d 岁。"%(self.name,self.age))

#单继承：
class student(people):
    grade=''
    def __init__(self,n,a,w,g):
　　#调用父类的构造函数：
        people.__init__(self,n,a,w)
        self.grade=g
　　#覆写父类的方法：
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

#多重继承的准备 
class speaker():
    name=''
    topic=''
    def __init__(self,n,t):
        self.name=n
        self.topic=t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

#多重继承
class sample(speaker,student):
    a=''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g,)
        speaker.__init__(self,n,t)


test=sample('yuangungun',25,80,4,'Python')
test.speak()

七、Python面向对象---->方法重写：

#定义父类
class Parent:
    def myMethod(self):
        print('调用父类方法！')

#定义子类
class Child(Parent):
    def myMethod(self):
        print('调用子类方法！')

#子类实例
p=Child()
#子类调用重写方法
p.myMethod()
#用子类对象调用父类已被覆盖的方法
super(Child,p).myMethod()     #super() 函数是用于调用父类(超类)的一个方法

八、Python面向对象---->类的私有属性：

class JustCounter:
    __secretcount=0    #私有变量
    publicCount=0    #公开变量

    def count(self):
        self.__secretcount+=1
        self.publicCount+=1
        print(self.__secretcount)

counter=JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter.__secretcount)      # 报错，实例不能访问私有变量

九、Python面向对象---->类的私有方法：

class Site:
    def __init__(self,name,url):
        self.name=name
        self.__url=url

    def who(self):
        print("name:",self.name)
        print('url:',self.__url)

    def __foo(self):
        print('这是私有方法！')

    def foo(self):
        print('这是公共方法！')
        self.__foo()

x=Site("圆滚滚","yuangungun")
x.who()
x.foo()
x.__foo()

十、Python面向对象---->运算符重载：

class Vector:
    def __init__(self,a,b):
        self.a=a
        self.b=b

    def __str__(self):
        return "Vector (%d,%d)" %(self.a,self.b)

    def __add__(self,other):
        return Vector(self.a+other.a , self.b+other.b)


v1=Vector(5,10)
v2=Vertor(2,-6)
print(v1+v2)

 

：