python基础（四）OOP 面向对象
OOP 面向对象
认知: 一切皆对象
小结:
类, 就是一个抽象, 虚拟的事物
对象, 就是真实的, 实例化的事物
关系:
类 就是对象的抽象化
对象 就是类的实例化
类
格式：
class 类名():
代码块
命名规范：
类名：
类名采用 大驼峰命名法(每个单词的首字母大写)
类名一般都是 名词
严格区分大小写
属性名：
由数字, 字母和下划线组成
不能以数字开头
方法名:
- 动词开头
属性名 和 方法名:
一律小写, 多个单词用 下划线 隔开
严格区分大小写
注意:
类一旦定义, 就会占据一个内存
类不实例化, 就不能正常使用
例如：
# 定义 飞机类
class Plane():# 属性(类有什么)# 属性就是平时的变量, 不过在类里面, 改名叫属性. 该属性专属于该类name = '波音777'age = 10# 方法(类会什么)# 方法就是平时的函数, 不过在类里面, 改名叫方法. 该方法专属于该类def fly(self):print('我会飞')def biu(self):print('没事射两下')
对象
单独的类只是抽象的, 只有实例化之后, 才能真正的使用
创建一个对象 (实例化)
对象名 = 类名()
使用属性
对象名.属性名
使用方法
对象名.方法名()
self
self : 当前对象
别名 : 伪对象
限制 : 只能在类内使用
注意 : self不是关键字, self用其他单词来代替, 并非固定词 ( 用self来表达, 习惯, 不成文的规定)
普通方法中, 必须带有self参数, 必须是第一个
小结：
在类内, 靠 self 使用属性/方法
在类外, 靠 对象 使用属性/方法
属性和方法 都是依托对象而存在的
代码示例：
class Plane():name = '波音777'age = 18def fly(self):print('I can fly')def test(self):print(self) # 就是 plane object, 就是对象 aprint(self.name)print(self.age)self.fly()a = Plane() # Plane() 返回一个对象
print(a) # 0x??????? 默认以十六进制 来表达内存地址
print(id(a)) # 以十进制 表达内存地址, 与十六进制 等价的
操作类
类内：
代码案例
class Plane():name = '波音777'age = 18def fly(self):print('I can Fly')def biu(self):print('射两下')def test(self):print(self.name)print(self.nickname)self.age = 50 # 类内修改属性print(self.age)self.desc = '666, 有钱自己造一个' # 类内新增属性print(self.desc)小结:
给属性赋值, 若属性已存在, 即为修改
若属性不存在, 即为新增
不推荐在类外 修改或新增属性(原因: OOP有封装性, 如果在类外修改或新增, 就违反了OOP的特性)
类外：
类外、类内修改/新增属性代码案例：
a = Plane()a.name = '中国歼击机' # 在类外, 修改属性
print(a.name)
a.nickname = '最牛逼的战斗机' # 在类外, 新增属性
print(a.nickname)a.test()print(a.age)
类的专属方法
普通方法,：不调用不会主动执行
专属方法,：触发指定条件, 就会自动执行
构造方法
(_ _ init _ _)
触发条件: 实例化类时
主要作用:
设置初始化属性
改变初始化属性
小结:
有了__ init__, 类才能变得更加通用
代码解析：
class Book():def __init__(self):print('准备要初始化Book类')a = Book()class Book():def __init__(self, name, author, price):self.name = name # 新增属性 name (书名)self.author = author # 新增属性auther (作者)self.price = price # 新增属性 price (单价)
析构方法
(_ _ del _ _)
触发条件: 当对象被销毁的时候
有以下几种销毁场景:
1) 当程序自然结束时
2) 当对象被删除时
3) 当对象被覆盖时
主要作用: 在销毁之前, 做一些遗嘱
代码解析
class Book():def __init__(self, name, author, price):self.name = name # 新增属性 name (书名)self.author = author # 新增属性 auther (作者)self.price = price # 新增属性 price (单价)def __del__(self):print('书快要被扔了, 当草纸擦擦屁股')a = Book('熊出没', '熊大', 20)
print(a.name)
print(a.author)
print(a.price)
oop 三大方法
封装性
定义：将属性和方法集中到一个类中, 形成一个不可分割的类，封装后, 类内的属性和方法, 有的公开, 有的私有
格式：
私有属性
__属性名 = 值
私有方法：
def __方法名(self):
pass
使用：
self.__属性名
self.__方法名()
限制: 只能在类内使用
小结:
默认属性和方法, 都是公开, 类内类外都可以访问
私有属性和方法, 只能在类内使用
继承性
定义：子类继承父类的一些东西
优点：提高代码的重用性，降低冗余率
格式：
class 子类(父类):
代码块
特性：
- 可以继承属性和方法 (不能继承私有属性和方法)
- 可以重写属性和方法
- 支持单继承, 连续继承, 多继承
重写：
- 可以重写属性 和 方法
- 如果已经重写了父级方法, 在后期发现还需要用到父级的方法. 那么通过 super().父级方法名() 来调用
- super() 可以调用父级的属性和方法
格式：super().方法名/属性名
代码案例：
class Gumu():name = '古墓派'def skill1(self):print('玉女心经')def skill2(self):print('御蜂之术')class Man(Gumu):name = '杨过' # 重写父级同名属性# 可以重写方法def skill1(self): # 这里仅仅是在Man类中 覆盖Gumu的skill1方法. (Gumu类的skill1本身不受影响)super().skill1() super().skill2()print('黯然销魂掌')print(super().name)print(super()) # super() 既代表Man类, 也代表Man对象a = Man()
print(a.name)
a.skill1()
单继承
即子继承父
代码案例：
class Father():name = '老王'def skill1(self):print('穿墙')class Son(Father):name = '小宋'a = Son()
print(a.name)
a.skill1()
连续继承
即儿子继承老子, 孙子继承儿子, 曾孙子继承孙子, 重孙子继承曾孙子 …
代码案例：
class Father():name = '老王'def skill1(self):print('穿墙')class Son(Father):money = 50000000def skill2(self):print('造钱') # 孙子 可以使用Son 和 Father的属性和方法
class Grandson(Son):pass# name = '小宋'# money = 5# def skill1(self):# print('透视')# def skill2(self):# print('花钱')a = Grandson()
print(a.name)
print(a.money)
a.skill1()
a.skill2()
注意：
/ – 大儿子 <-- 孙子
老子 <–
\ – 小儿子
孙子可以使用 大儿子和老子的属性和方法
孙子不能使用 小儿子的属性和方法
孙子 和 小儿子没有继承关系
继承顺序
查看多继承时, 是按照什么样的顺序来找属性和方法的
内置方法: mro
使用格式:
类名.——mro——
分析:
结果: 元组类
(从左向右 搜索法)在第一个类找到了, 就不去第二个类找，如果到了最后都找不到, 则 报错
多态性
定义：通过一个类, 传入不同的对象, 从而实现不同的效果
优点: 提高代码的灵活度
代码案例：
class usb():def run(self): # run 方法代表运行接入的设备passclass mouse(usb):def run(self):print('已连接鼠标')class keyboard(usb):def run(self):print('已连接键盘')class udisk(usb):def run(self):print('已连接U盘')# 准备在电脑上实现效果
class computer():def start(self, usb):usb.run() # 一开机, 就通过usb来调用run() 方法c = computer()
m = mouse()
k = keyboard()
u = udisk()c.start(m) # 电脑开机, 运行usb上的鼠标
c.start(k) # 电脑开机, 运行usb上的键盘
c.start(u)
分析:
这里准备了 3个usb设备, 如何体现代码的灵活度
这里computer类, 一旦开机(start), 就会usb下的run方法直接运行. (根本不管是什么usb设备, 只知道接入usb, 就要运行)
类属性和实例属性
定义:
通过类来访问的属性, 都叫做"类属性",别称"类变量"
通过对象来访问的属性, 都叫做"实例属性",别称"实例变量"
作用:
类属性: 资源共享
实例属性: 资源独享
代码案例：
class Person():name = '小龙'# 2. 访问
print(Person.name) # 类属性
a = Person()
b = Person()
print(a.name) # 实例属性# 3. 修改
Person.name = '神龙'
print(Person.name)
print(a.name)
print(b.name)a.name = '大龙'
print(Person.name)
print(a.name)Person.name = '火龙'
print(Person.name)
print(a.name)
print(b.name)分析:
通过类 来修改:
将会把Person类中的name 给修改掉.、
这会影响"所有"从 Person 实例化出去的对象 (拥有 专属的除外)
通过对象 来修改:
一旦将Person 实例化, 生成一个对象a. 对象a 会拥有**“独立的内存”**, 拥有Person类的所有属性和方法
- 只要不修改属性, 就会受到 Person的影响
- 一旦对象a 自己修改了属性, 那么这个属性是 专属于对象a. 将不再受到Person 的影响
类方法和实例方法
定义
类方法: 通过"类名"来访问的方法
实例方法: 通过"对象" 来访问的方法
格式
类方法格式:
@classmethod
def 方法名(cls):
代码块
注意:
- 在方法名上一行必须添加 @classmethod
- 第一个参数必须设为cls. 功能类似于self.
cls也不是关键字, 名字可以改
cls 代表当前类名
self 代表当前对象
小结:
类方法: 属于类
可以通过类 访问
可以通过对象 访问
只可以访问类属性
一个类占一个内存
实例方法: 属于对象
可以通过对象 访问
可以直接访问 实例属性
可以间接访问 类属性 和 类方法
一个对象占一个内存
静态方法
定义
不需要使用类属性, 也不需要使用实例属性, 即可定义为 静态方法
作用: 说明书, 更新内容, 协议展示 …
格式
@staticmethod
def 静态方法名():
代码块
注意: 不需要强制传入 self 或 cls
异常
定义
在程序执行过程中, 如果发生了错误, 那么程序会立马终止, 并提示一些错误信息, 这就是"异常"
其中, 这些错误信息, 这种行为"抛出异常"
我们程序员需要做的, 就是让产品不会抛出异常, 尽量给用户比较好的体验感
格式
格式1: 基本用法
try:
正在执行代码的区域a (捕获异常)
except:
处理异常的区域b (处理异常)
区域c
分析:
区域a 如果发生错误, 则立马进入区域b
区域a 如果没发生错误, 则等区域a 执行完, 然后进入区域c
在trye中, python一直在捕获 区域a 的异常, 一旦捕获成功, 则会执行区域b
注意:
无论上面是否有异常, 区域c 都会执行
格式2:
不同的错误, 报不同的信息
try:
代码块a
except 错误类型1:
代码块b
except 错误类型2:
代码块c
…
格式3:
不同的错误信息, 报相同的提示信息
try:
代码块a
except (错误类型1, 错误类型2, …):
代码块b
except (错误类型3, 错误类型4, …):
代码块c
格式4:
未知错误
try:
代码块a
except Exception as 变量:
代码块b
作用:
在实际开始种, 想要把所有可能发生的错误全部预测出来, 挺难的
此时,通过Exception 异常类 统一抛出异常. 例如: 404, 服务器繁忙…
格式5:
完整写法
try:
代码块a
except 错误类型1:
…
except 错误类型2:
…
except (错误类型3,错误类型4):
…
except (错误类型5,错误类型6):
…
except Exception as e:
…
else:
代码块b 没有异常时才会执行
finally:
代码块c 无论是否有异常, 都会执行
异常传递
场景
在实际开发中, 都是模块式开发, 每一个功能都是独立的，最终会在一个主程序中 集中进行调试.如果在调用模块时, 其中一个模块发生了错误, 那么try应该写哪里
解决方案: 把try写在主程序里面
主动抛出异常
场景
在之前学的Python中, 都是自动捕获异常, 也会自动报错.，在实际开发中, 有很多业务不满足条件时, 也会做异常处理, 此时需要主动抛出异常来处理
小结:
能够进入 处理异常区域的方式:
自动捕获异常
主动抛出异常
①准备异常
②抛出异常
代码解析：
def get_num():# 1) 提示用户 输入数字num = input('请输入数字: ')# 2) 判断是否为 数字if num.isdigit() == True:print('您输入的数字为: %s' % num)else:print('准备主动抛出异常')e = Exception('您输入的不是数字') # 准备异常raise e # 抛出异常try:get_num()
except Exception as e:print(e)专属方法–new–
触发条件: 创建实例时, 自动触发
功能: 创建一个对象
代码解析：
class test():def __new__():pass# a = test() #报错:说new方法需要0个参数,但是实际却送了1个数给new# 由此证明, new方法至少有一个形参# 正确方法
class test():def __new__(cls, *arg, **kwargs): print(cls)# 参数分析:# cls 接收一个test类# *arg 接收剩余的参数# **kwargs 接收剩余的关键字参数# # 这里的 *arg 和 **kwargs 主要是配合 __init__ 来使用的a = test() # 在实例化时, 第一个自动执行的方法是 new, 不是initprint(a) # 输出的是None, 没有得到对象# 特殊写法
class test(object):def __new__(cls, *arg, **kwargs):return super().__new__(cls) # 返回一个对象a = test()
print(a)# 平常写法
class test():pass
a = test()
print(a)
分析:
在"平常写法"中, 原生写法应该是 class test(object)
在python3中, 在定义类时, 默认自动将 object 填入类名( ) 的小括号中.
所以才有任何类都继承object类的说法
那么object里面有什么?
object 自带一个 new方法.
new 用于创建一个对象
在平常写法中, 只要不重写new方法, 那么在实例化时, 得到一个对象
在"特殊写法"中, 重写new 方法, 没有对象可以返回, 默认返回None
类方法和实例方法
定义
类方法: 通过"类名"来访问的方法
实例方法: 通过"对象" 来访问的方法
格式
类方法格式:
@classmethod
def 方法名(cls):
代码块
注意:
- 在方法名上一行必须添加 @classmethod
- 第一个参数必须设为cls. 功能类似于self.
cls也不是关键字, 名字可以改
cls 代表当前类名
self 代表当前对象
小结:
类方法: 属于类
可以通过类 访问
可以通过对象 访问
只可以访问类属性
一个类占一个内存
实例方法: 属于对象
可以通过对象 访问
可以直接访问 实例属性
可以间接访问 类属性 和 类方法
一个对象占一个内存
静态方法
定义
不需要使用类属性, 也不需要使用实例属性, 即可定义为 静态方法
作用: 说明书, 更新内容, 协议展示 …
格式
@staticmethod
def 静态方法名():
代码块
注意: 不需要强制传入 self 或 cls
异常
定义
在程序执行过程中, 如果发生了错误, 那么程序会立马终止, 并提示一些错误信息, 这就是"异常"
其中, 这些错误信息, 这种行为"抛出异常"
我们程序员需要做的, 就是让产品不会抛出异常, 尽量给用户比较好的体验感
格式
格式1: 基本用法
try:
正在执行代码的区域a (捕获异常)
except:
处理异常的区域b (处理异常)
区域c
分析:
区域a 如果发生错误, 则立马进入区域b
区域a 如果没发生错误, 则等区域a 执行完, 然后进入区域c
在trye中, python一直在捕获 区域a 的异常, 一旦捕获成功, 则会执行区域b
注意:
无论上面是否有异常, 区域c 都会执行
格式2:
不同的错误, 报不同的信息
try:
代码块a
except 错误类型1:
代码块b
except 错误类型2:
代码块c
…
格式3:
不同的错误信息, 报相同的提示信息
try:
代码块a
except (错误类型1, 错误类型2, …):
代码块b
except (错误类型3, 错误类型4, …):
代码块c
格式4:
未知错误
try:
代码块a
except Exception as 变量:
代码块b
作用:
在实际开始种, 想要把所有可能发生的错误全部预测出来, 挺难的
此时,通过Exception 异常类 统一抛出异常. 例如: 404, 服务器繁忙…
格式5:
完整写法
try:
代码块a
except 错误类型1:
…
except 错误类型2:
…
except (错误类型3,错误类型4):
…
except (错误类型5,错误类型6):
…
except Exception as e:
…
else:
代码块b 没有异常时才会执行
finally:
代码块c 无论是否有异常, 都会执行
异常传递
场景
在实际开发中, 都是模块式开发, 每一个功能都是独立的，最终会在一个主程序中 集中进行调试.如果在调用模块时, 其中一个模块发生了错误, 那么try应该写哪里
解决方案: 把try写在主程序里面
主动抛出异常
场景
在之前学的Python中, 都是自动捕获异常, 也会自动报错.，在实际开发中, 有很多业务不满足条件时, 也会做异常处理, 此时需要主动抛出异常来处理
小结:
能够进入 处理异常区域的方式:
自动捕获异常
主动抛出异常
①准备异常
②抛出异常
代码解析：
def get_num():# 1) 提示用户 输入数字num = input('请输入数字: ')# 2) 判断是否为 数字if num.isdigit() == True:print('您输入的数字为: %s' % num)else:print('准备主动抛出异常')e = Exception('您输入的不是数字') # 准备异常raise e # 抛出异常try:get_num()
except Exception as e:print(e)专属方法–new–
触发条件: 创建实例时, 自动触发
功能: 创建一个对象
代码解析：
class test():def __new__():pass# a = test() #报错:说new方法需要0个参数,但是实际却送了1个数给new# 由此证明, new方法至少有一个形参# 正确方法
class test():def __new__(cls, *arg, **kwargs): print(cls)# 参数分析:# cls 接收一个test类# *arg 接收剩余的参数# **kwargs 接收剩余的关键字参数# # 这里的 *arg 和 **kwargs 主要是配合 __init__ 来使用的a = test() # 在实例化时, 第一个自动执行的方法是 new, 不是initprint(a) # 输出的是None, 没有得到对象# 特殊写法
class test(object):def __new__(cls, *arg, **kwargs):return super().__new__(cls) # 返回一个对象a = test()
print(a)# 平常写法
class test():pass
a = test()
print(a)
分析:
在"平常写法"中, 原生写法应该是 class test(object)
在python3中, 在定义类时, 默认自动将 object 填入类名( ) 的小括号中.
所以才有任何类都继承object类的说法
那么object里面有什么?
object 自带一个 new方法.
new 用于创建一个对象
在平常写法中, 只要不重写new方法, 那么在实例化时, 得到一个对象
在"特殊写法"中, 重写new 方法, 没有对象可以返回, 默认返回None
单例模式
定义
第一次通过类 实例化时, 产生一个对象.
第二次及以后再次通过类 实例化时, 会直接获取第一次实例化得到的对象. 不会再创建新的对象
优势
由于只会产生一个对象, 所以内存得到节省(内存是同一个)
案例
显卡
音乐播放器
第一次听歌时, 需要先打开播放器, 点第一首歌.
当想要听第二首歌是, 需要再打开播放器吗???
显而易见, 不需要再打开播放器.
如果再打开播放器, 也可以听, 不过内存中, 也需要再多占一个内存
如果直接使用第一次听歌的播放器, 也能听第二首歌, 而且不需要再多占一个内存
单例模式 - 完整版
代码解析：
class Music(object):# 用于记录 第一个对象first = Noneis_init = Falsedef __new__(cls): if cls.first is None:cls.first = super().__new__(cls)#第一次获取object里面的对象return cls.first#返回first 第二次first就不是None 不获取之前object的对象 再次return first后面的对象就会一直不变def __init__(self):if Music.is_init == True:return None#第一次 is_init是false所以进下面，第一次进下面之后in_init变true由于类属性是共享的所以后面进来的就is_init是true直接return Noneprint('hello, 酷狗')Music.is_init = Truea = Music()
b = Music()
c = Music()
print(a)
print(b)
print(c)小结
初始化时, 会自动 执行 new 和 init (先new, 再init)
单例模式:
只有一个对象
只执行一次初始化
装饰器
装饰器本质是一个函数
作用
在不影响原有函数的基础上, 给函数扩展功能, 使用起来更强大
原生写法代码解析：
# 原始写法 (回顾知识: 闭包)
def wing(func):def angel():things = '天使翅膀'name = func() # name = 东北虎print('一个拥有 %s 的 %s ' % (things, name))return angeldef tiger():name = '东北虎'return namea = wing(tiger) # a 接收的就是 angel 函数
a()分析:
执行顺序:
1) 先调用 wing(tiger) 将tiger作为参数传给wing
2) 进入wing, 直接返回函数angel (此时没有调用angel)
3) 回到调用函数的地方, a = angel
4) a() ==> angel() 调用angel
5) 生成变量 things = 天使翅膀
6) name = func() ==> name = tiger() 调用tiger函数
7) 在tiger中, 生成变量name = 东北虎
8) 返回name 到angle中的 name=func()
9) name = func() => tiger() => 东北虎
10) 执行print, 执行输出
综上所述: 高阶函数 + 闭包函数 = 装饰器
装饰器写法代码解析：
def wing(func):def angel():things = '天使翅膀'name = func() # name = 东北虎print('一个拥有 %s 的 %s ' % (things, name))return angel@wing
def tiger():name = '东北虎'return nametiger()
分析:
仅仅是将 wing(tiger) 写在定义函数 tiger的上方. 代表用wing 来装饰tiger
python基础（四）OOP 面向对象相关推荐
- python基础四_01_面向对象
python基础四_01_面向对象编程 导读: 本文主要从what?why?how?三个方向理解面向对象编程的思想:仅供自己梳理. 一.什么是面向对象编程? 面向对象编程与面向过程编程是两种常见的编程 ...
- Python基础day09【面向对象(封装、继承、多态)、重写、私有权限】
视频.源码.课件.软件.笔记:超全面Python基础入门教程[十天课程]博客笔记汇总表[黑马程序员] Python基础day09[面向对象(封装.继承.多态).重写.私有权限] Python基础day ...
- Python基础入门_5面向对象基础
Python 基础入门前四篇: Python 基础入门–简介和环境配置 Python基础入门_2基础语法和变量类型 Python基础入门_3条件语句和迭代循环 Python基础入门_4函数 第五篇主要 ...
- python基础程序设计与面向对象程序设计_python基础——面向对象的程序设计
python基础--面向对象的程序设计 1 什么是面向对象的程序设计 面向过程的程序设计的核心是过程,过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西. 优 ...
- Python基础day08【面向对象(类、对象、属性)、魔方方法(init、str、del、repr)】
视频.源码.课件.软件.笔记:超全面Python基础入门教程[十天课程]博客笔记汇总表[黑马程序员] 目录 0.复习 1.类外部添加和获取对象属性 2.类内部操作属性 3.魔法方法 3.1.__i ...
- Python全栈开发-Python基础教程-07 面向对象初级
面向对象初级 一. 面向对象 面向对象编程(Object-oriented Programming,简称 OOP),是一种封装代码的方法.其实,在前面章节的学习中,我们已经接触了封装,比如说,将乱七八 ...
- Python基础学习，面向对象的基本概念
Python使用类(class)和对象(object),进行面向对象(object-oriented programming,简称OOP)的编程. 面向对象的最主要目的是提高程序的重复使用性.我们这么 ...
- python基础之数据类型-面向对象
人生苦短,Python當歌! 此篇博客是本人学习python过程中,总结的基础知识点,希望可以帮到有需要的朋友,如有不足或错误之处,希望评论指出,感谢大家!! 第一章 计算机基础 1.1 硬件 计 ...
- Python基础：16面向对象概述
1:在版本2.2 中,Python社区最终统一了类型(type)和类(class),新式类具备更多高级的OOP特性,扮演了一个经典类(旧式类)超集的角色,后者是Python 诞生时所创造的类对象. 2 ...
- Python基础学习(13)—面向对象2(特殊方法，分装及装饰器)
面向对象(2) 1.1 特殊方法(魔术方法) 1 特殊方法例如__init__的都是以__开头__结尾的方法, 特殊方法会在特定的时候自动调用,init会在对象创建以后立即执行并且init会对新创建的 ...
最新文章
- 我的个人博客搭建记录
- 成功解决AttributeError: ‘str‘ object has no attribute ‘decode‘
- Linux——主流发行版本
- 大数据WEB阶段（二十）更新丢失
- 【Python】处理UnicodeDecodeError: ‘gbk’ codec can’t decode byte 0xa2 in position…
- wpe使用方法（详细）（--新加秒10图）(10号继续可用）
- oracle 提示存在lob,Oracle数据库出现ORA-19566 LOB坏块的处理记录
- xp系统打开计算机硬盘分区,XP系统下怎么进行硬盘分区啊?
- poi 和jxl导出excel（2）
- Openstack1 云计算与虚拟化概念
- 洛阳最新打卡地--洛阳新都汇购物公园变样啦
- Android：开发中，代码被横线划掉是什么意思
- div盒模型宽高计算
- 银河麒麟下安装ftp服务
- 博弈论（初级）——数学知识（C++）
- C语言——PTA 埃尔米特多项式
- [网易IM通讯]推送小结
- 西门子S7-1200PLC堆栈程序 在使用西门子1200PLC时候发现，系统没有自带的堆栈功能块，不能实现数据的先进先出后进后出功能
- 考研英语 - word-list-34
- html5选择年月日 年月日时分 年月日时分秒