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

  • 0
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值