Python面向对象

面向对象术语：类、方法、类变量、数据成员、方法重写、局部变量、实例变量、继承、对象
Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

函数

函数定义

def 函数体(参数列表)：
    函数体
    
例：
def area(width, height):
    return width * height

调用：
area(5, 6)

函数参数

#必需参数
def call(number):
    startCall(number)
call('10010')

#关键字参数，函数调用时确定参数名
def info(name, age):
    print('name:' + name + 'age:' + age)
info(age = 22, name = 'daibi')

#默认参数
def info(name, age=24):
    print('name:' + name + 'age:' + age)
info('zhangsan',32) or info('zhangsan')

#不定长参数
#加了*号的参数会以元组的形式导入
def info(name, *vartuple):
    print(name + str(vartuple))
info('lisi', 54, 33.2)   ->  'lisi'(54,33.2)

#加了2个**号的参数会以字典的形式导入
def info(name, **vardic):
    print(name + str(vardic))
info('lisi', 54, 33.2)   ->  'lisi'{54,33.2}

变量作用域

#方法内部变量不会影响到方法外的变量
num = 5
def fun():
	num = 6
	print(num, end=" ")
fun()
print(num, end=" ") 
打印结果：6 5

#全局变量,global
num = 5
def fun():
	global num
   num = 6
	print(num, end=" ")
fun()
print(num, end=" ") 
打印结果：6 6

# nonlocal关键字声明
def outer():
    num = 10
    def inner():
        nonlocal num  
        num = 100
        print(num)
    inner()
    print(num)
outer()

a = 10
def test():
    a = a + 1
    print(a)
test()
#上面的代码会报错，是因为a是局部变量，还没有定义不能修改
Traceback (most recent call last):
  File "C:\Users\username\test.py", line 5, in <module>
    test()
  File "C:\Users\username\test.py", line 3, in test
    a = a + 1
UnboundLocalError: local variable 'a' referenced before assignment

类及类对象

#定义类
class MyClass:
    i = 123
    def fun(self):
        return 'python world'

#实例化
x = MyClass()
print('类属性i:', x.i)
print('类方法：', x.fun())

#__init__()方法
类都会有一个__init__()构造方法，该方法在类实例化的时候自动调用，该方法可以有参数
class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart

x = Complex(2.0, 3.0)
self代表类的实例，类的方法与普通的函数的区别是多一个额外的self参数

继承

class DerivedClassName(modname.BaseClassName1):

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，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('ken',10,60,3)
s.speak()
结果：ken 说: 我 10 岁了，我在读 3 年级

#多重继承
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()   #方法名同，默认调用的是在括号中排前地父类的方法
结果：我叫 Tim，我是一个演说家，我演讲的主题是 Python

方法重写

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

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

# 子类实例
c = Child()
# 子类调用重写方法       
c.myMethod()
#用子类对象调用父类已被覆盖的方法  
super(Child,c).myMethod()

私有变量及方法

#私有变量，以两个下划线__开头，不能在类的外部使用和访问
#私有方法，以两个下划线__开头，不能在类的外部调用
class Counter:
    __count = 0
    num = 4
    def count(self):
        self.__count = 3
        self.num += 1
        print(self.__count)
    def __countNum(self):
        print('私有方法')

x = Counter()
print(x.__count)  #报AttributeError: 'Counter' object has no attribute '__count'
print(x.num)      ->  4
x.count()         ->  3
print(x.__countNum()) #报错