python成长之路（二）面向对象与编程基础

夯实基础

python3是一门面向对象的语言，在python中创建一个类和对象是很容易的。

面向对象技术简介

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

方法：类中定义的函数。

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

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

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

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

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

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

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

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法
Python中的类在尽量不增加语法规则的情况下提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
对象可以包含任意数量和类型的数据。

类定义

语法格式如下：

class Classname:
       <statement-1>
       .
       .
       <statement-N>

类实例化后，可使用其属性。实际上，创建一个类后，可以通过类名访问其属性。

类对象

类对象支持两种操作：属性引用和实例化。
属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。类对象创建后，类命名空间中所有的命名都是有效属性名。

#!/usr/bin/python3
 
class MyClass:
    """一个简单的类实例"""
    i = 12345
    #类的方法（函数）
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

以上创建一个新的类实例并将该对象赋给局部变量x，x为空的对象。
执行后的输出结果为：

MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

类有一个名为_init_()的特殊方法（构造方法），专门用来定义一个类具有哪些属性的方法,就是无论系统是否调用，都会被执行。

def _init_(self):
      self.data = []           

其中self代表类的实例，而非类。
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，按照惯例它的名称是self。（p.s. 它不是python关键字！）

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()

以上实例结果：

<__main__.Test instance at 0x100771878>
__main__.Test

从而看出，“self”是代表类的实例，即当前对象的地址，而self.class指的类。

类的方法

在类的内部，使用“def”来定义一个方法，与一般函数不同，类方法必须包含参数self,且为第一个参数。

继承

实例如下

#!/usr/bin/python3
 
#类定义
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():
    topic = ''
    name = ''
    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("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

注意：此时如果将sample中的student与speaker互换并删除“python”，test.speak将输出“Tim 说: 我 25 岁了，我在读 4 年级”。

python还支持在子类改写父类的方法，例如：

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

super函数是用于超类的一个函数方法
结果输出为

调用子类方法
调用父类方法

子类继承父类构造函数说明：
情况一：子类需要自动调用父类的方法
子类不重写 __ init __ ,实例化子类时，会自动调用父类定义的__ init __。

情况二：子类不需要自动调用父类的方法
子类重写__ init ,这时就不会调用父类已经定义的 init .
**情况三：如果重写了__init 时，要继承父类的构造方法，可以使用 super 关键字**
super(子类，self).init(参数1，参数2，…)还有另一种经典写法
父类名称.init(self,参数1，参数2，…)

class Father(object):
    def __init__(self, name):
        self.name=name
        print ( "name: %s" %( self.name))
    def getName(self):
        return 'Father ' + self.name
 
class Son(Father):
    def __init__(self, name):
        super(Son, self).__init__(name)
        print ("hi")
        self.name =  name
    def getName(self):
        return 'Son '+self.name
 
if __name__=='__main__':
    son=Son('runoob')
    print ( son.getName() )

输出结果如下：

name: runoob
hi
Son runoob

类的专有方法

类的专有方法：

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

小试牛刀

实例一：
写一个斐波那契数列：即两个元素的总和确定了下一个数

#!/usr/bin/python3

a,b = 0,1
while b < 10 
   print(b)
   a,b = b,a+b    #先计算右边表达式，再赋值给左边

结果为

1
1
2
3
5
8

第一行为一个复合赋值：变量a和b同时得到新值0和1.最后一行再次使用了相同的方法，可以看到，右边的表达式会在赋值变动之前执行。执行顺序是从左到右的。

关键字end：可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符。

print(b, end=',')     #原程序的print(b)后加上end

条件控制与循环流程

条件控制

大体与C中if-else语句相似，但Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

注意：

1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在Python中没有switch – case语句

循环流程

while 判断条件（condition）:
    执行语句（statement）

• 无限循环

设置条件表达式永远不为false来实现无限循环，实例如下：

#!/usr/bin/python3

var = 1
while var == 1     #表达式永远为true
    name = int(input("输入一个数字："))
    print("你输入的数字是："，num)
print("Good bye!")

输出如下：

输入一个数字  :5
你输入的数字是:  5
输入一个数字  :

• while循环使用else语句

在while…else在条件语句为false时执行else的语句块
格式如下：

while<expr>:
     <statement(s)>
else:
    <additoinal_statement(s)>

• for 循环语句

for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
实例如下：

sites = ["chair", "pants","shoe","desk"]
for site in sites:
    if site == "shoe":
        print("AJ")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
#print("完成循环!")          疑问：当加入此句会报错invalid syntax

输出如下：

循环数据 chair
循环数据 pants
AJ

• range（）函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列。

可结合range()和len()函数以遍历一个序列的索引

a = ['Google', 'Baidu', 'Bytedance', 'Taobao', 'QQ']
>>> for i in range(len(a)):
...     print(i, a[i])

输出结果：
0 Google
1 Baidu
2 Bytedance
3 Taobao
4 QQ

• break 和 continue 语句及循环中的 else 子句

break语句可以跳出for和while的循环体。如果你从for或while循环中终止，任何对应的循环else块将不再执行。
continue语句被用来告诉python跳过当前循环块中的剩余语句，然后继续下一轮循环

实例：
while使用break

n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
print('循环结束。')

输出如下

4
3
循环结束

while中使用continue

n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
print('循环结束。')

输出如下：

4
3
1
0
循环结束

迭代器与生成器

迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能向前不会后退。
两个基本语句：iter()和next()。
字符串，列表或元组对象都可用于创建迭代器：