03 . 函数定义与调用 & Python类与对象

一、Python函数定义与调用

1.Python函数的概念

函数：是组织好的、可重复使用的，用来实现单一or相关联概念的代码段。函数能提高应用的模块性，代码的复用性。如print()、range()函数，也可以自定义函数。

2.Python函数的定义&调用

案例：定义一个函数Max_num()，用来比较两个数字的大小，然后将数值大的数字返回。

1）函数代码块以def关键字开头，厚街函数标识符名称和圆括号()
2）圆括号之间可以用于定义参数
3）函数内容以冒号起始，并且缩进
4）return[表达式]选择性地返回一个值给调用方，不带表达式的return相当于返回None

#定义一个带参数的函数，实现获取最大值
def Max_num(a,b):
    if a > b:
        return a
    elif a < b:
        return b
    else:
        return a
#调用函数
result = Max_num(22,10)
#输出调用的结果
print(result)

3.方法参数的个数及调用

def fun_args1(a1):  # 方法包含1个参数；实现输出该参数
    print("args is %s" %a1)
def fun_args2(a1,a2):
    print("args is %s and %s" %(a1,a2))
def fun_var_args(*a):
    for value in a:
        print("args:",value)
fun_args1("Python")
# fun_args1()   # 报错，提示需要传递1个参数
# fun_args1("abc","111")    # 报错，提示只要1个参数，而传递了2个参数
fun_args2(1,2)
# fun_args2(1)  # 报错，提示需要2个参数，只传递了1个参数
# 可以传递任意个数的参数
fun_var_args("aaa")
fun_var_args("aaa","bbb")
fun_var_args("aaa","bbb","ccc")
fun_var_args()

执行结果：

4.参数设定方法

• 顺序传入：调用函数时传参，实参与形参顺序对应一致
• 关键词传入：调用函数时在参数中指定关键词（给某个参数赋值）
• 默认参数：定义方法时提前设置好参数
• 不定长参数：传入的参数个数不受限制

# 不定长参数可封装成一个元组形式
def add(*args):
    sum=0
    for i in args:
        sum=sum+i
    return sum
# 调用函数
a=add(1,2)
b=add(1,2,3,4,5,6)
print(a,b)

二、Python类与对象

1.类与对象

对象：现实世界中万物皆对象，是事物存在的实体，即类的具体表现 类：类是对象的抽象集合，如人类、汽车、动物、水果这些都是一个抽象的类别

【举例】水果（类）——苹果、葡萄、桃子（对象）

人（类）
属性：地域、肤色、国家...
功能：走路、思考、饮食、繁衍...
具体对象：中国人、美国人...

学生（类）
属性：姓名、学号、城市、年龄...
功能：听、说、读、写...
具体对象：Jack童鞋、Harry童鞋...

2.面向对象编程

OOP（Object Oriented Programming），是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数（方法）。
面向对象的设计思想来源于自然界，类（class）是一种抽象概念，比如我们定义的Student类，是指学生这个概念；而实例（Instance）则是作为个体的Student对象。
面向对象-三大特性：封装、继承、多态。

3.Python类与对象

1）创建一个类

class 类名(object):
    类体

① class：是定义类的关键词
② 类名：通常是大写开头的单词（如：Student）
③ (object)：表示该类是从object类继承下来的；若未明确的继承类，则默认就是继承object类，这是所有类最终都会继承的类，即基类。

2）对属性初始化

类可以起到模板的作用，可在创建实例对象的时候，把一些我们认为必须绑定的属性强制填写进去。
【案例】通过定义一个特殊的__init__方法，比如在创建Student实例的时候，就把name,city等属性绑上去：
（PS：此处init前后的符号分别都是2个下划线组成，不是只有1个下划线）

# 创建一个类
class Student():
    # 初始化方法
    def __init__(self,name,city):
        self.name = name    # 实例变量(属性)
        self.city = city
        print("My name is %s and come from %s" %(name,city))

① __init__方法的第一个参数永远是self，表示创建的实例本身。因此在__init__方法内部，可把各种属性绑定到self，self就指向所创建的实例本身。
② 有个__init__方法，在创建实例的时候，就不能传入空的参数，必须传入与__init__方法匹配的参数，但self参数不需要单独传入，Python解释器默认会把实例变量传进去。

3）定义不同的方法

类的方法除了第一个参数是self之外，其他和普通函数一样

# 创建一个Student类
class Student():
    type="学生"   # 类变量
# 初始化方法
    def __init__(self,name,city):   # self表示当前对象
        self.name = name  # 实例变量(属性)
        self.city = city
        print("My name is %s and come from %s" %(name,city))
# 普通方法：talk()方法
    def talk(self):
        print("Hi, girls and boys !")
# 普通方法：write()方法
    def write(self,year):
        print(year,self.name,"学习Python")
# 实例化对象；当前对象为：stu
# 隐式传递了self，相当于传递的是3个参数
stu=Student("Caddy","Chongqing")
print(stu.city)
stu.city="Shanghai" # 修改属性
print(stu.city)
# 调用方法
stu.talk()
stu.write(2019)

4）生成类的实例对象，进行调用方法

要调用方法，只需要在实例变量上直接调用

# 生成类的实例对象（传入初始化方法中的参数，不包括self）
stu = Student('Jack','Beijing')
# 通过实例变量调用talk()方法
stu.talk()

备注：

1）实例化对象时，默认会调用初始化方法init()
2）实例化对象时，隐式传递了self
3）self在初始化方法中表示当前对象，即实例化的对象
4）在初始化方法中 self.name=name，等号左边self后的name为定义的实例变量，等号右边的name为传入的参数值（该值可修改为其他名称）

三、面向对象三大特性：封装、继承、多态

1.类的封装

对类中的属性进行封装，变为私有属性，常规情况只能在类的内访问；对类中的方法进行封装，变为私有方法。从外部访问私有属性or私有方法时，需要进行相关的验证。
私有方式：在属性名or方法名之前加上2个下划线__

# 创建银行卡的类：Card类
class Card():
    # 初始化方法
    def __init__(self,num,pwd,bal):
        self.num=num    # 卡号
        self.pwd=pwd    # 密码
        self.__bal=bal  # 余额（私有属性，只能在类的内部被访问）

    def deposit(self):
        print("存款")
    def getBal(self,inputNum,inputPwd):
        # 安全验证
        if inputNum==self.num and inputPwd==self.pwd:
            return self.__bal
        else:
            return "输入错误"
# 实例化对象；当前对象：card
card=Card("1001","111",100) # 开卡
bal=card.getBal("1001","111")   # 通过验证获取余额
# bal=card._Card__bal   # 绕过验证直接获取私有属性的值
print(bal)

PS：
以上利用非常规方式，可以绕过安全验证而直接获取到敏感数据，如：`实例化的对象.类名_私有属性名`，故不建议使用Python应用在安全级别要求高的应用程序中

2.类的继承

类的继承，会继承父类的属性、方法，对父类属性和方法进行调用

class Animal(object):   # Animal类继承object类
    def __init__(self,color):
        self.color=color
    def eat(self):
        print("动物在吃草")
    def run(self):
        print("动物在奔跑")
class Cat(Animal):  # Cat类继承Animal类
    pass
# 实例化对象时，默认调用父类的__init__()方法，故需要传入初始化方法的参数
cat=Cat("grey")
print(cat.color)    # 调用继承的属性
cat.eat()   # 调用继承的方法
cat.run()

父类与子类调用优先级：
① 实例化对象时，优先调取子类中的初始化方法，若子类没有该方法，再到其父类中寻找初始化方法
② 调用同名方法时，先在子类中寻找，若未找到，再到父类中寻找

class Animal(object):   # Animal类继承object类
    def __init__(self,color):
        self.color=color
    def eat(self):
        print("动物在吃草")
    def run(self):
        print("动物在奔跑")
class Cat(Animal):  # Cat类继承Animal类
    pass
class Pig(Animal):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def eat(self):
        print("小猪在吃菜")
# 实例化对象时，优先调取子类中的初始化方法，若子类没有该方法，再到其父类中寻找初始化方法
pig=Pig("PQ",2)
pig.eat()   # 调用同名方法时，先在子类中寻找，若无，再到父类中寻找
pig.run()

在子类中调用父类的初始化方法：
在子类初始化方法中写上 super(子类名,self).__init__(父类初始化方法的参数)，其中super表示父类

class Animal(object):   # Animal类继承object类
    def __init__(self,color):
        self.color=color
    def eat(self):
        print("动物在吃草")
    def run(self):
        print("动物在奔跑")
class Cat(Animal):  # Cat类继承Animal类
    pass
class Pig(Animal):
    def __init__(self,name,age,color):
        super(Pig,self).__init__(color) # 在子类中调用父类的初始化方法;super为父类
        self.name=name
        self.age=age
    def eat(self):
        print("小猪在吃菜")
pig=Pig("PQ",2,"grey")
print(pig.color)

3.类的多态

一个类/对象拥有多种形态，当不同的类中都有相同名称的方法时，每个对象可分别调用归属各自的同名方法

class Animal(object):   # Animal类继承object类
    def __init__(self,color):
        self.color=color
    def eat(self):
        print("动物在吃草")
    def run(self):
        print("动物在奔跑")
class Cat(Animal):  # Cat类继承Animal类
    def eat(self):
        print("小猫在吃鱼")
class Pig(Animal):
    def __init__(self,name,age,color):
        super(Pig,self).__init__(color) # 在子类中调用父类的初始化方法;super为父类
        self.name=name
        self.age=age
    def eat(self):
        print("小猪在吃菜")
# 多态：每个对象分别调用各自的同名方法
def feed(obj):
    obj.eat()
animal=Animal("white")
cat=Cat("yellow")
pig=Pig("小猪",2,"grey")
feed(animal)
feed(cat)
feed(pig)

2人點贊

Selenium+Python

作者：Fighting_001
链接：https://www.jianshu.com/p/bb8d467030e7
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。