python基础入门（四）——python类与对象，内置函数__init__，类的继承，私有属性和方法，python迭代器

python中的类与对象

对象是由它的属性和方法组成。
属性来描述对象的性质。
方法说明这个对象的功能。
一些基本术语

1. 类(class)：用来描述具有相同属性和方法的对象的集合，它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
2. 方法(method)：类中定义的函数。
3. 类变量(class variable)：类变量在整个实例化的对象中是公用的。类变量定义在类中存在函数体之外。类变量通常不作为实例变量使用。
4. 数据成员(data member)：类变量或者实例变量用于处理类及其实例对象的相关数据。
5. 方法重载(method overloading)：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖(override)，也称为方法的重载。
6. 局部变量(local variable):定义在方法中的变量，只作用于当前实例的类。
7. 实例变量(instance variable)：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
8. 继承(inheritance)：一个派生类(derived class )继承基类(base class)的属性和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个dog(狗)类型的对象派生自Animal (动物)类，这是模拟“是一个(is-a)”关系(如dog是一个animal)。
9. 实例化(instantiation)：创建一个类的实例，类的具体对象。
10. 对象(object)：通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。
    python程序设计语言是一种面向对象的程序设计语言。

python类和对象的创建

类就像是对象构造器

class CatClass:
    name='big orange',
    color='orange',
    weight=15
    def voice(self):
        return 'miaomiaomiao'
cat1=CatClass()
print('the name of the catclass is:',cat1.name)
print('the weight of the catclass is:',cat1.weight)
print('the voice of the catclass is:',cat1.voice())

输出：
the name of the catclass is: (‘big orange’,)
the weight of the catclass is: 15
the voice of the catclass is: miaomiaomiao

python内置函数：__init__

在所有的python类中都有一个名为__init__()的函数，而且当每一个类被初始化，该函数都会自动执行。
在类中声明一个方法，每个方法都有一个名为self的参数。

要真正理解Python的类，您就不得不首先理解Python的内置函数__init__。
在所有的Python类中都有一个名为__init__()的函数，而且每当一个类被初始化，该函数都会自动执行。
当对象被创建时，Python自动使用这个__init__()函数为对象属性赋值，或做一些其他的必需的操作。
在一个类中声明一个方法，与定义一个普通的函数几乎没有什么差别，只是有一个例外那就是每一个方法都有一个名为self的参数，而且它是第一个参数。Python会自动将self参数添加到你所定义的方法的参数列表中；而且在调用方法时你不必包括这个self参数。
每次使用某个类创建一个对象时，该类中的__init__函数都会被自动的调用。

class Cat:
    def __init__(self,name,weight,color):
        self.name=name
        self.weight=weight
        self.color=color
cat1=Cat('big orange',12,'orange')
cat2=Cat('little black',11,'black')
print(cat1.name)
print(cat2.color)

输出：
big orange
black

python对象的方法

与变量不同的是，一个对象除了可以包含值（属性）之外，还可以包含方法（相当于函数），方法就是一个对象可以做的事情。

class Cat:
    def __init__(self,name,weight,color):
        self.name=name
        self.weight=weight
        self.color=color
    def bark(self):
        print('miaomiaomiao')
    def dream(self):
        print('I have so much food')
cat1=Cat('big orange',12,'orange')
cat2=Cat('little black',11,'black')
print(cat1.name)
print(cat2.color)
cat1.dream()
cat2.bark()

输出：
big orange
black
I have so much food
miaomiaomiao

python对象的self参数

self参数是类的当前实例（对象）的一个引用，即self参数代表的是实例而不是类。类的方法与普通函数只有一个区别——它们必须有一个额外的第一个参数，而这个参数的名称习惯上使用self (不是必须使用self)。
参数self是类的当前实例的一个引用，在所定义的方法中可以将它当作当前对象来使用。这给编程带来了很大的方便。
尽管一般都使用self这个名字，但是这并不是强制的要求。可以改成别的名字。

class Cat:
    def __init__(d,name,weight,color):
        d.name=name
        d.weight=weight
        d.color=color
    def bark(d):
        print('miaomiaomiao')
    def dream(d):
        print('I have so much food')
cat1=Cat('big orange',12,'orange')
cat2=Cat('little black',11,'black')
print(cat1.name)
print(cat2.color)
cat1.dream()
cat2.bark()

输出：
big orange
black
I have so much food
miaomiaomiao

删除一个python对象

del cat1

python类的继承（创建父类和子类）

父类是被继承的类，也称之为基类。
子类是继承了另一个类的类，也被称为派生类。
要创建一个继承另一个类的功能的类，如果不添加新属性和方法，可以使用pass关键字

class rabbit(pet)：
pass

class Pet:
    def __init__(self,name,weight,color):
        self.name=name
        self.weight=weight
        self.color=color
    def bark(self):
        print('miaomiaomiao')
    def dream(self):
        print('I have so much food')
pet1=Pet('big orange',12,'orange')
pet2=Pet('little black',11,'black')
print(pet1.name)
print(pet2.color)
pet1.dream()
pet2.bark()

class Cat(Pet):
    pass
cat1=Cat('little',14,'white')
print(cat1.name)
cat1.dream()

输出：
big orange
black
I have so much food
miaomiaomiao
little
I have so much food

在子类中添加自己的__init__函数和属性

到目前为止，所创建的子类的所有属性和方法都是从父类那里继承而来的。如果子类所创建的新对象与父类有一些不同，可以为子类添加自己的__init__函数(即用这个函数代替pass关键字来完成，因为在使用现有类创建一个新对象时每次都会自动调用__init__函数。
当在子类中添加了它自己的__init__函数时，子类将不再继承父类的__init__函数了，因为子类的__init__函数覆盖了所继承的父类的__init__函数。如果要继续使用父类的__init__函数，可以使用调用父类__init__函数的语句，即在__init__函数之前冠以“父类名.”(如Pet._init)。

class Pet:
    def __init__(self,name,weight,color):
        self.name=name
        self.weight=weight
        self.color=color
    def bark(self):
        print('miaomiaomiao')
    def dream(self):
        print(self.name+' has a dream')
class Cat(Pet):
    def __init__(self,name,weight,color,age):
        Pet.__init__(self,name,weight,color)
        self.age=age
cat1=Cat('john',14,'white',2)
print(cat1.age)
cat1.dream()

输出：
2
john has a dream

在子类中添加自己的方法

如果在子类中添加的方法个父类中的方法（函数）他明天，那么从父类中继承的同名方法将被子类的方法所覆盖。
在Python程序设计语言中子类也被称为派生类，而父类也被称为基类，创建一个子类(派生类)的基本语法格式如下。

class 派生类名(基类名)：
<语句1>
<语句2>
...
<语句N>

class Pet:
    def __init__(self,name,weight,color):
        self.name=name
        self.weight=weight
        self.color=color
    def dream(self):
        print(self.name+' has a dream')
class Cat(Pet):
    def meow(self):
        print('hiahiahia')
cat1=Cat('peter',3,'red')
cat1.meow()

输出：
hiahiahia

在实际工作中，不少软件公司通常会将经常使用的父类(基类)存入某个模块，此时创建一个子类(派生类)的语法格式如下。

class 子类名(模块名·父类名)：
<语句1>
<语句2>
...
<语句N>

多继承以及方法的重载（重写）

语法格式：

class 派生类名(基类1,基类2,基类3,...)：
<语句1>
<语句2>
...
<语句N>

在以上语法格式中，需要注意圆括号中基类(父类)的顺序：如果在父类中有相同的方法名，而在子类使用时又没有指定，那么Python从左至右搜索——如果在子类中没有找到时，按照从左至右顺序在父类中寻找是否有所需的方法。
如果在父类中的方法无法满足需要，可以在子类中重写(重载)父类的方法(子类中的方法与父类中的方法同名)。

class Pet:
    def __init__(self,name,weight,color):
        self.name=name
        self.weight=weight
        self.color=color
    def dream(self):
        print(self.name+' has a dream')
class Cat(Pet):
    def dream(self):
        print('i am rich')
cat1=Cat('peter',3,'red')
cat1.dream()

输出：
i am rich

可能有这样的情况发生——虽然在子类中重写了一个方法，但是有时还是需要调用父类中的同名方法。这又该如何处理呢？那就是使用super函数调用父类(也叫超类)的方法。

super(Rabbit, rabbit1).sleep()

class Pet:
    def __init__(self,name,weight,color):
        self.name=name
        self.weight=weight
        self.color=color
    def dream(self):
        print(self.name+' has a dream')
class Cat(Pet):
    def dream(self):
        print('hiahiahia')
cat1=Cat('peter',3,'red')
cat1.dream()
super(Cat,cat1).dream()

输出：
hiahiahia
peter has a dream

super(Rabbit，rabbit1).sleep(调用的是在Pet父类中定义的方法sleep，而不是在子类Rabbit中定义的sleep方法。使用super函数调用父类(也叫超类)的方法的一般语法格式如下。

super(子类名，对象名).方法

类的私有属性和私有方法

在有些情况下，出于安全和保密的考虑，类中的某个或某些属性不希望在类的外部可以直接访问。此时，我们可以将这个或这些属性定义为私有属性。定义私有属性的办法很简单，只是在属性名前冠以两个下画线，如定义成私有属性__weight和__age。

class People:
    __weight=100
    name='jok'
    def fun(self):
        self.__weight +=12
        self.name
        print(self.__weight)
        print(self.name)
    def __dream(self):
        print('it is a bad dream')
people1=People()
people1.fun()
#people1.__dream()
people1.name
#people1.__weight

类外部不能调用私有属性和方法

与私有属性类似，类中的某个或某些方法不希望在类的外部可以直接访问。此时，我们可以将这个或这些方法定义为私有方法。定义私有方法的办法同样也很简单，只要在方法名前冠以两个下画线就可以了。

类的专用方法及运算符重载

除了之前已经使用过多次的__init__()方法之外,Python程序设计语言还提供了类的另外一些专用方法,这些专用方法如下。

__init__：构造函数,在生成对象时调用。
__del__：析构函数,在释放对象时使用。
__repr__：输出，转换。
__setitem__： 按照索引赋值。
__getitem__： 按照索引获取值。 
__len__：  获得长度。 
__cmp__： 比较运算。 
__call__：函数调用。 
__add__：加运算。
__sub__： 减运算。
__mul__： 乘运算。 
__truediv__： 除运算。 
__mod__：求余运算。
__pow__： 乘方。 

python程序代码的主要功能是重载运算符"+"，重载后的"+"运算符可以进行向量（三维数据）的加法运算。

class vector:
    def __init__(self,x,y):
        self.x=x
        self.y=y
    def __add__(self, other):
        return (self.x+other.x,self.y+other.y)
v1=vector(12,33)
v2=vector(45,62)
v=v1+v2
print(v)

输出：
(57, 95)

python的迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。迭代器是一个可以记住遍历位置的对象，包括一个可数数量的值。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束——进行迭代操作。迭代器只能前进而不能后退。
迭代器有两个基本的方法：iter和next。列表、元组、字典和集合对象都是可迭代对象。它们是可迭代的容器，因此在这些对象中已经包括了一个迭代器。所有的这些对象中都有两个用于迭代器的方法iter和next。

pets=('cat','dog','pig','dark')
p=iter(pets)
print(next(p))
print(next(p))
print(next(p))
print(next(p))

输出：
cat
dog
pig
dark

使用循环语句遍历python的可迭代对象

用for

pets=('cat','dog','pig','dark')
for p in pets:
    print(p)

输出：
cat
dog
pig
dark

用while
因为要处理产生的异常，导入sys模块

import sys
pets=('cat','dog','pig','dark')
p=iter(pets)
while True:
    try:
        print(next(p))
    except StopIteration:
        sys.exit()

输出：
cat
dog
pig
dark

创建一个迭代器

class Number:
    def __iter__(self):
        self.x=10
        return self
    def __next__(self):
        n=self.x
        self.x+=10
        return n
num=Number()
numiter=iter(num)
print(next(numiter))
print(next(numiter))
print(next(numiter))
print(next(numiter))
print(next(numiter))
print(next(numiter))

输出：
10
20
30
40
50
60

利用stopiteration异常结束迭代

防止无限循环

因为在以上的例子中使用了raise语句，所以这里简单地介绍一下raise语句。Python使用raise语句抛出一个指定的异常，raise唯一的一个参数就是指定的要被抛出的异常。它必须是一个异常的实例或者异常的类(也就是Exception的子类)。如果只想抛出一个异常，并不想去处理它，那么一个简单的raise语句就可以了。

class Number:
    def __iter__(self):
        self.x=10
        return self
    def __next__(self):
        if self.x<=100:
            n=self.x
            self.x+=10
            return n
        else:
            raise StopIteration
num=Number()
numiter=iter(num)
for i in numiter:
    print(i)

输出：
10
20
30
40
50
60
70
80
90
100