Python中的函数接口与面向对象的三要素

一、Python中的函数

1.函数定义

格式：def 函数名(形式参数列表):
函数体
示例：

# 定义了 x  y 相加的函数
def add(x, y):return x + y

2.函数调用

格式：函数名(实际参数)

question: 实际参数与形式参数的关系？
answer: 形式参数是实际参数的一份临时拷贝

3.函数参数

①缺省参数：给形式参数一个默认值,当形式参数没有被传递的时候,会默认使用缺省值.

示例：

# 自我介绍函数
def info(name, age=18):print("my name is {}, age is {}".format(name, age))info("小白")
info("李雷",5)"""
运行结果：
my name is 小白, age is 18
my name is 李雷, age is 5
注意: 缺省值 必须从右往左一次填写.
"""

②不定长参数

* :将多余的参数打包成元组使用
** : 将键值对儿类型元素打包成字典

示例：

# 自我介绍函数
def show(name, age, *hobby, **family):   # *将多余的参数打包成元组  **将参数打包成字典使用print("my name is ", name)print("age is ", age)print("hobby :", hobby)print("family :", family)show("妮妮", 5, "超真实办家家酒", )
print("-----------------------------------")
show("野原新之助", 5, "动感超人", "娜娜子", "风间彻", father="野原广志", mother="野原美呀")

4.局部变量与全局变量

局部变量: 函数内部定义的变量
全局变量: 函数外部定义的变量

在函数内部修改全局变量的值：global var

示例：

money = 10def set_money():global money # 声明使用全局变量的moneymoney = 20set_money()
print(money)  # 20

5.函数的返回值

python 语言中支持一个函数返回多个值.

格式：def 函数名():
函数体
return value1, value2, value

示例：

def operation(x, y):add = x + ysub = x - ymul = x * ydiv = x / yreturn add, sub, mul, div
add, sub, mul, div = operation(10, 20)
print(add)  # 30
print(sub)  # -10
print(mul)  # 200
print(div)  # 0.5

6.递归函数

定义：在运行过程中,函数调用函数本身. 递归是把大问题分解成一个一个的小问题.

要求：需要有结束条件,且每递归一次都要向结束条件靠近.

使用原则：能想得到,并且不会对时间,空间造成太大的影响的时候就是用递归. 想不到就不用.

示例：

# 实现一个阶乘的计算.def factorial(n):if n == 1:return 1return n * factorial(n - 1)ret = factorial(1500)
print(ret)

7.匿名函数

定义：函数本身没有名字,是一些轻量级的函数类别的 C语言中的回调函数.

格式：lambda 形式参数列表: 函数体

示例：

# 定义两个数相加的匿名函数
sum = lambda x, y: x + y
print(sum(10, 20))  # 30

应用：排序（匿名函数指定比较方法）

stus = [{"name": "zhangsan", "age": 18},{"name": "lisi", "age": 19},{"name": "wangwu", "age": 17}
]
stus.sort(key = lambda x : x["name"])
print(stus)
#结果：[{'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}]

8.列表推导式

定义：列表推导式，就是指的轻量级循环创建列表

示例：

# 输出100个0
l1 = [0 for x in range(1, 101, 1)]
print(l1)

二、Python中的IO接口

1.打开文件 open

格式：open(文件路径, 访问模式)

2.关闭文件 close()

file = open("./hello.txt", "w")
file.close()

3.with 上下文管理器

格式：with open(文件路径，访问方式) as f：
code

特点：无需手动关闭文件。程序会自动关闭文件

示例：

# with 上下文管理器  # 当前路径不是程序所在的路径 ， 是执行程序的路径
with open("hello.txt", "w") as f:f.write("hello world")

4.read / write

read: 读取文件内容
write : 向文件写入内容

示例：

with open("hello.txt", "w+") as f:f.write("hello world")f.seek(0)help(f.seek)ret = f.read()print("ret = ", ret)

三、面向对象

1.面向对象与面向过程

面向过程：强调的是过程，所有的事情全部都是自己完成. 典型：C 语言.

eg：去网上搜索一个自己喜欢的电脑，喜欢mac pro 16寸 i9 16 1TB 1.8万，去中关村购买电脑, 无法分辨真伪。随便找一个购买导购推荐一款 macOS 1万砍价30分钟成交9999。回家之后一大堆问题。

面向对象：强调的是结果，将事情委托给擅长做这件事情的人来完成. 典型：python C++ java

eg：我表哥是电脑天才，把买电脑这件事情委托给我表哥.

2.类与对象

类: 具有相似内部状态和运动规律的实体的集合(或统称为抽象)

解释: 抽象的概念. 相似的属性(一组数据) 和相似的行为 (函数)

注：一类物体的统称 , 泛指.

对象: 类的具体实例化. 可以看得到摸得着,可以直接使用.

注：一个具体的事务. 特指.

eg：植物: 类，竹子: 类，汽车: 类，奔驰汽车: 类，苹果: 类，红苹果: 类，狗 : 类，金毛: 类

小明家哪条掉了毛的狗: 对象

类与对象的关系：类是创建对象的模板.

3.类的构成

类是由三部分构成:

类名 : 都是大驼峰命名
属性 : 一组数据
方法 : 动作行为. 一般使用函数表示.

eg：设计一个狗类
类名: Dog
属性: 毛发颜色. 品种. 眼睛年龄性别
方法: call run eat 拆家捣乱挑衅

4.类的抽象

拥有相同(或者类似)属性和行为的对象都可以抽像出一个类

eg：坦克发射了3个炮弹. 击落了2架飞机

类名: 坦克
属性: 型号
方法: 发射炮弹

类别: 炮弹
属性: 飞行速度
方法: 击落飞机

类别: 飞机
属性: 飞行. 速度
方法: 被击落

5.面向对象的三要素

封装：封装就是事物抽象为类，把对外接口暴露，将实现和内部数据隐藏。

继承：继承是指可以使用现有类的所有功能。继承的过程，就是从一般到特殊的过程。

子类：通过继承创建的新类称为“子类”或“派生类”。
父类：被继承的类称为“基类”、“子类”或“超类”。

多态：多态性是指允许将父对象设置成为和一个或更多子对象相等的技术。

解释：赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

四、类的封装

1.定义类

①经典类

格式：class 类名:
类主体

示例：

# 僵尸的经典类
class Zombie:# 通过函数定义类的行为def speak(self):print("i am comming ~~~ !")

②新式类

格式：class 类名(object):
类主体

其中：object: python当中最顶级的父类 . 类似于女娲娘娘
self : 对象本身.

示例：

class Zombie(object):def speak(self):print("i am comming~~!")

2.创建对象

类是创建对象的模板; 通过 对象名 = 类名() 创建对象.

注: 一个类是可以创建出无数个对象的.

示例：

class Zombie(object):def speak(s  0elf):print("i am comming~~!")# 创建了一个舞王僵尸对象
dance_zombie = Zombie()
# 对象调用实例方法
dance_zombie.speak()

3.对象添加属性

方法: . 语法

格式: 对象名. 属性 = value

①在类的外部设置属性

示例：

class Zombie(object):def speak(s  0elf):print("i am comming~~!")# 创建了一个舞王僵尸对象
dance_zombie = Zombie()
# 对象调用实例方法
dance_zombie.speak()dance_zombie.name = "舞王僵尸"
dance_zombie.ornaments = "墨镜"
dance_zombie.hp = 200
dance_zombie.speed = 50print("name : {},ornaments : {}, hp : {}, speed: {}".format(dance_zombie.name, dance_zombie.ornaments,dance_zombie.hp, dance_zombie.speed ))

②在类的内部通过self 方式设置属性

示例：

 class Zombie(object):def speak(self):print("self : ", self)print("i am comming~~!")def set_info(self, name,  ornaments, hp, speed):self.name = nameself.ornaments = ornamentsself.hp = hpself.speed = speed# 创建了一个铁桶僵尸对象
bucket_zombie = Zombie()
# 对象调用实例方法
print("bucket_zombie :", bucket_zombie)
print("bucket_zombie.speak() :", end=" ")
bucket_zombie.speak()bucket_zombie.set_info("铁桶僵尸", "铁帽子", 500, 20)
print("name : {}, ornaments : {}, hp : {}, speed: {}".format(bucket_zombie.name,bucket_zombie.ornaments, bucket_zombie.hp, bucket_zombie.speed ))

4.魔法方法

①初始化方法 __init__：__init__ 不是创建对象. 当对象创建之后会自动调用 __init__ 方法, 去初始化对象的属性.

②回收资源方法 __del__：当删除对象的时候会自动调用 __del__的方法. 主要用来回收资源.

注：__del__不是删除对象, 是回收对象的资源.

③方便打印: __str__：__str__() 返回一个字符串. 当调用 print函数进行打印的时候, 会自动打印出 __str__() 的返回值字符串.

示例：

class Zombie(object):# 魔法方法def __init__(self, name=None,  ornaments=None, hp=0, speed=0):"""当创建对象以后,会自动调用 __init__方法"""self.name = nameself.ornaments = ornamentsself.hp = hpself.speed = speedself.file = open("./hello.txt", "w")def speak(self):print("i am comming~~!")def __str__(self):msg = "name : {},ornaments : {}, hp : {}, speed: {}".format(self.name, self.ornaments,self.hp, self.speed)return msgdef __del__(self):print("__del__() 开始回收资源")self.file.close()# 创建了一个铁桶僵尸对象
bucket_zombie = Zombie("铁桶僵尸", "铁帽子", 500, 20)# 打印铁桶僵尸信息
print(bucket_zombie)# 手动回收对象资源
del bucket_zombie

5.烤地瓜案例

类名 : SweetPotato
属性 : cookedLevel : 这是数字；0~3表示还是生的，超过3表示半生不熟，超过5表示已经烤好了，超过8表示已经烤成木炭了！（我们的地瓜开始时时生的）
cookedString : 这是字符串；描述地瓜的生熟程度
condiments : 这是地瓜的配料列表，比如番茄酱、芥末酱等
方法 : cook() : 把地瓜烤一段时间
addCondiments() : 给地瓜添加配料
__init__() : 设置默认的属性
__str__() : 让print的结果看起来更好一些

# 烤地瓜案例
class SweetPotato(object):# 定义属性def __init__(self):self.cookedLevel = 0self.cookedString = "生的"self.condiments = []def cook(self, time):self.cookedLevel += timeif 0 <= self.cookedLevel <= 3:passelif 3 < self.cookedLevel <= 5:self.cookedString = "半生不熟"elif 5 < self.cookedLevel <= 8:self.cookedString = "熟透了"else:self.cookedString = "成木炭了"def __str__(self):msg = self.cookedString + "的地瓜"if len(self.condiments) > 0:msg += "("for i  in self.condiments:msg += imsg += ")"return msgdef addCondiments(self, condiment):self.condiments.append(condiment)potato = SweetPotato()
potato.cook(5)
print(potato)
potato.cook(2)
print(potato)
potato.addCondiments("辣椒酱")
print(potato)

五、类的继承与多态

1.继承

继承是类与类之间的关系. 指的是子类继承父类的属性与方法.

格式： A : 父类基类 B: 子类派生类

class A(object):
          def __init__(self):
                        self.money = 10
        class B(A):
          pass

示例：通过一个小故事讲解单继承，多继承，隔代继承，子类调用与重写父类的方法

"""
故事情节：(1). 煎饼果子老师傅在煎饼果子界摸爬滚打几十年，拥有一身精湛的煎饼果子技术，并总结了一套"古法煎饼果子配方"。(2). 可是老师傅年迈已久，在嗝屁之前希望把自己的配方传承下去，于是老师傅把配方传给他的徒弟大猫...  <单继承>(3). 大猫掌握了师傅的配方，可以制作古法煎饼果子。但是大猫是个爱学习的好孩子，他希望学到更多的煎饼果子的做法，于是通过百度搜索，找到了一家煎饼果子培训学校。（多继承）(4). 大猫掌握了 师傅的配方 和 学校的配方，通过研究，大猫在两个配方的基础上，创建了一种全新的煎饼果子配方，称之为 "猫氏煎饼果子配方"。（子类重写父类同名属性和方法）(5) 大猫的新配方大受欢迎，但是有些顾客希望也能吃到古法配方和 现代配方 的煎饼果子...（子类调用父类的同名属性和方法）(6) 大猫的煎饼果子店非常红火，终于有一天，他成了世界首富！！但是他也老了，所以他希望把 师傅的配方 和 学校的配方 以及自己的配方 继续传承下去...（隔代继承）
"""class Master(object):# 添加属性def __init__(self):self.technology = "古法煎饼果子配方"def make_cake(self):print("根据 <%s> 制作一份煎饼果子." % self.technology)def drunk(self):print("喝酒我只喝二锅头")class School(object):# 添加属性def __init__(self):self.technology = "东方牌煎饼果子配方"def make_cake(self):print("根据 <%s> 制作一份煎饼果子." % self.technology)def smoke(self):print("抽烟我只抽华子.")class Student(School, Master ):def __init__(self):self.technology = "猫氏煎饼果子配方"# 私有属性. 私有属性不可以被继承 , 私有属性只能在类的内部使用,不可以在类的外部使用self.__money = 1000def make_cake(self):self.__init__()print("根据 <%s> 制作一份煎饼果子." % self.technology)# 子类调用父类的同名方法def make_old_cake(self):# 父类名.方法Master.__init__(self)Master.make_cake(self)def make_new_cake(self):School.__init__(self)School.make_cake(self)def build(self):self.__money -= 10def show(self):print("money : ", self.__money)class GrandSon(Student):passcat = Student()
cat.smoke()
cat.drunk()# 调用顺序属性
print(Student.__mro__)
# (<class '__main__.Student'>, <class '__main__.Master'>, <class '__main__.School'>, <class 'object'>)cat.make_cake()
cat.make_old_cake()
cat.make_new_cake()fish = GrandSon()
fish.make_new_cake()
fish.make_old_cake()
fish.make_cake()fish.show()
fish.build()
fish.show()

2.多态

定义：函数调用的多种形态. 类与类之间的关系. 同一个函数在传递不同对象的时候,变现出来的效果不一致.

鸭子模型：虽然我想要一只"鸭子"，但是你给了我一只鸟。但是只要这只鸟走路像鸭子，叫起来像鸭子，游泳也像鸭子，我就认为这是鸭子。

注：python 是一个弱类型语言 (函数参数无需类型要求).只要你传递过来的参数,有指定的功能就可以了. 无需去关系类型.

示例：

# 多态是类与类之间的关系
class Animal(object):def call(self):print("this is animal call")class Dog(Animal):def call(self):print("汪汪汪")class Cat(Animal):def call(self):print("喵喵喵")def info(obj):obj.call()dog = Dog()
cat = Cat()info(dog)
info(cat)

3.类属性与类方法

类属性 : 修饰类本身的属性.

类方法: 修饰类的方法（通过装饰器定义）

应用：直接在类的内部定义一组数据

示例：

class Girl(object):# 添加数据限制模板sex = "女"# 通过装饰器的方法定义类方法@classmethoddef sing(cls):pass

4.单例模式

定义：只能创建出一个对象的类称为单例

原理：创建出的对象共用一个地址

示例：

class Single(object):# 定义类属性. 记录有没有创建过对象__instance = Nonedef __new__(cls, *args, **kwargs):"""object.__new__(): 创建一个对象. 并且把这个对象的地址返回."""if cls.__instance is None:# 如果判断成功, 说明没有创建过对象cls.__instance = object.__new__(cls)return cls. __instancedef __init__(self):print("this is self")s1 = Single()
print("--------------------")
s2 = Single