格式：def 函数名(形式参数列表):
函数体
示例：
# 定义了 x y 相加的函数
def add(x, y):
return x + y
2.函数调用
格式：函数名(实际参数)
question: 实际参数与形式参数的关系？
answer: 形式参数是实际参数的一份临时拷贝
①缺省参数：给形式参数一个默认值,当形式参数没有被传递的时候,会默认使用缺省值.
示例：
# 自我介绍函数
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 = 10
def set_money():
global money # 声明使用全局变量的money
money = 20
set_money()
print(money) # 20
5.函数的返回值
python 语言中支持一个函数返回多个值.
格式 ：def 函数名():
函数体
return value1, value2, value
示例：
def operation(x, y):
add = x + y
sub = x - y
mul = x * y
div = x / y
return 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 1
return 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 拆家 捣乱 挑衅
拥有相同(或者类似)属性和行为的对象都可以抽像出一个类
eg：坦克发射了3个炮弹. 击落了2架飞机
类名: 坦克
属性: 型号
方法: 发射炮弹
类别: 炮弹
属性: 飞行速度
方法: 击落飞机
类别: 飞机
属性: 飞行. 速度
方法: 被击落
封装：封装就是事物抽象为类，把对外接口暴露，将实现和内部数据隐藏。
继承：继承是指可以使用现有类的所有功能。继承的过程，就是从一般到特殊的过程。
子类：通过继承创建的新类称为“子类”或“派生类”。
父类：被继承的类称为“基类”、“子类”或“超类”。
多态：多态性是指允许将父对象设置成为和一个或更多子对象相等的技术。
解释：赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。
四、类的封装 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 = 50
print("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 = name
self.ornaments = ornaments
self.hp = hp
self.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 = name
self.ornaments = ornaments
self.hp = hp
self.speed = speed
self.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 msg
def __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 = 0
self.cookedString = "生的"
self.condiments = []
def cook(self, time):
self.cookedLevel += time
if 0 <= self.cookedLevel <= 3:
pass
elif 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 += i
msg += ")"
return msg
def 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 = 1000
def 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 -= 10
def show(self):
print("money : ", self.__money)
class GrandSon(Student):
pass
cat = Student()
cat.smoke()
cat.drunk()
# 调用顺序属性
print(Student.__mro__)
# (, , , )
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 = "女"
# 通过装饰器的方法定义类方法
@classmethod
def sing(cls):
pass
4.单例模式
定义：只能创建出一个对象的类称为单例
原理：创建出的对象共用一个地址
示例：
class Single(object):
# 定义类属性. 记录有没有创建过对象
__instance = None
def __new__(cls, *args, **kwargs):
"""
object.__new__(): 创建一个对象. 并且把这个对象的地址返回.
"""
if cls.__instance is None:
# 如果判断成功, 说明没有创建过对象
cls.__instance = object.__new__(cls)
return cls. __instance
def __init__(self):
print("this is self")
s1 = Single()
print("--------------------")
s2 = Single
