1.函数

1.1函数的语法

def 函数名（参数列表）:
    函数体

1.2例子

def max(a,b):
   if a>b:
       return a
   else:
       return b
   
print(max(3,5))

1.2参数

1.2.1参数传递

不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
实例：

def change(a):
    a+=5
    print("函数内的对象：",end='')
    print(id(a))

a=3
print("刚开始：",end='')
print(a,end='  对象a:')
print(id(a))
change(a)
print("函数调用后：",end='')
print(a,end='  对象a:')
print(id(a))

运行结果：

刚开始：3  对象a:1592290400
函数内的对象：1592290560
函数调用后：3  对象a:1592290400

可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

实例：

def change(a):
    a.append([4,5,6])
    print("函数内的对象：",end='')
    print(id(a))

a=[1,2,3]
print("刚开始：",end='')
print(a,end='  对象a:')
print(id(a))
change(a)
print("函数调用后：",end='')
print(a,end='  对象a:')
print(id(a))

运行结果：

刚开始：[1, 2, 3]  对象a:1522837328968
函数内的对象：1522837328968
函数调用后：[1, 2, 3, [4, 5, 6]]  对象a:1522837328968

1.2.2正式参数类型

必需参数
必需2数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=18, name="7个七" )

默认参数
调用函数时，如果没有传递参数，则会使用默认参数

def printinfo( name, age = 18 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=20, name="7个七" )
print ("------------------------")
printinfo( name="7个七" )

不定长参数
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

加了两个星号 ** 的参数会以字典的形式导入

def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

2.面向对象

1.对象–类的实例化

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

2.类的方法

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

class test:
    def prt(self):
        print(self)
        print(self.__class__)
        
a=test()
a.prt()
b=test()
b.prt()

运行结果：

<__main__.test object at 0x0000022389595898>
<class '__main__.test'>
<__main__.test object at 0x000002238965B978>
<class '__main__.test'>

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的

3.构造方法

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

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('runoob',10,30)
p.speak()

4.继承

4.1单继承

class dog:
    type='狗'
    food='狗粮'
    def __init__(self,type,food):
        self.type=type
        self.food=food
        
    def eat(self):
        print("%s爱吃%s"%(self.type,self.food))
    def sleep(self):
        print("%s正在睡觉"%(self.type))
#继承
class selfdog(dog):
    def __init__(self,name,type,food):
        dog.__init__(self, type, food)
        self.name=name
    def eat(self):
        print("%s%s爱吃%s"%(self.name,self.type,self.food))
    def sleep(self):
        print("%s%s正在睡觉"%(self.name,self.type))
        
sd=selfdog("小黄","狗","狗粮")
sd.eat()
sd.sleep()

4.2多继承

补充：对于python而言，类的属性的可见度只有两种，public和private。类的私有属性便是在前面加上“__”标识符，而公共属性则不必。

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()   #方法名同，默认调用的是在括号中排前地父类的方法

5方法重写

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

5运算符重载

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(2,10)
v2 = Vector(5,-2)
print (v1 + v2)