[Python3基础] 模块和函数、参数、异常、面向对象编程（类的方法、继承）

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数的创建

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

• 函数内容以冒号 : 起始，并且缩进。

• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

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

函数的调用

#无参
def hello() :
    "可以写函数功能的介绍"
    print("Hello World!")
#有参   
def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
#函数的调用
print(max(a, b))
hello()

参数

• 必需参数：必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
a='sb'
printme(a)

• 关键字参数:关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
  使用关键字参数允许函数调用时参数的顺序与声明时不一致

#可写函数说明
def printme( str,a ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme( a = "s",str = "hahah")

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

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="tom" )
print ("------------------------")
printinfo( name="bob" )

• 不定长参数:声明时不会命名
  加了 * 的参数会以元组(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)

lambda表达式（匿名函数）

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

格式：

lambda [arg1 [,arg2,.....argn]]:expression

例子：

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

import语句

import module1[, module2[,... moduleN]

创建一个模块（即创建一个文件，里面包含了写好的函数）

# Filename: support.py
 
def print_func( par ):
    print ("Hello : ", par)
    return

导入模块

# Filename: test.py
 
# 导入模块
import support
 
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")

这样就可以使用其他模块里面的函数了！

from…import语句

导入这个模块的一部分函数

from modname import name1[, name2[, ... nameN]]

异常捕获

语法格式1：

try:
    无异常时执行的代码
except （异常类型1,异常类型2...) :
    有异常时执行的代码
except （异常类型1,异常类型2...) :
    有异常时执行的代码

语法格式2：

try:
    无异常时执行的代码
except （异常类型1,异常类型2...) :
    有异常时执行的代码
except （异常类型1,异常类型2...) :
    有异常时执行的代码
else ：
    无异常时执行的代码

语法格式3：

try:
    无异常时执行的代码
except （异常类型1,异常类型2...) :
    有异常时执行的代码
except （异常类型1,异常类型2...) :
    有异常时执行的代码
else :
    无异常时执行的代码
finally :
    有无异常都会执行的代码

举例：

def disvision(a,b):
    num = a // b
    return num
try:
    numa = int(input("请输入被除数："))
    numb = int(input("请输入除数："))
    endnum = disvision(numa,numb)
    print(endnum)
except ZeroDivisionError:
    print("除数不能为0")
except ValueError:
    print("请输入正常的整数")
else:
    print("一切正常")
finally:
    print("一直都在")

异常抛出：raise [Exception [, args [, traceback]]]

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

面向对象编程

类的定义格式：

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

类的对象：

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

类的属性和方法：

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。
类的私有方法定义和属性一样，调用也一样
如果想让类名直接调用方法，就在方法上面加一个装饰器@classsmethod，或者是加@staticmethod声明为静态方法（函数），这时候里面就不用加self了
装饰器就是在函数代码不变的情况下，增加一些其他功能（在代码运行期间动态增加功能的方式叫做装饰器）

@classmethod
def run(self):
    print("running")
# 相当于这么调用的
run = classmethod(run)

类的属性分为公有属性（类中和类外都可以调用）和私有属性（在类外不能直接调用，可以由类的方法调用，也可以由实例化对象._类名__属性名这样调用）
以双下划线开始的成员变量为私有属性，否则为公有属性
内置属性：前后由两个下划线组成，默认添加的，例如：构造函数

#类定义
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('bob',10,30)
p.speak()

单继承格式：

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

举例：

#类定义
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()
print(s.__weight)

多继承格式：

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

注意：需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，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))
 
#另一个类，多重继承之前的准备
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()   #方法名同，默认调用的是在括号中排前地父类的方法

方法重写：

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