python面向对象

一.time&datetime&hashlib模块应用

1time时间模块

代码演示：

import time
#1.获取当前时间对应的时间戳，使用浮点型表示,单位:秒【掌握】
t1 = time.time()
print(t1)

#2.休眠,参数的单位为秒,可以为浮点数【掌握】
print("hello1")
time.sleep(2)  
print("hello2")

2.datetime日期模块【掌握】

是对time模块的封装，比time模块更加全面

 

'''
import datetime  

获取当前的日期对象，包含时间的
dt_now = datetime.datetime.now()

根据指定的日期、时间生成一个日期对象
dt_ziding = datetime.datetime()

dt.strftime()  将日期对象转化为指定的格式
dt.date()   获取日期对象中的日期
dt.time()   获取日期对象中的时间
dt.timestamp()  获取日期对象的时间戳
dt.hour\minute\second  获取小时、分钟、秒

根据一个时间戳，转化为指定的日期对象
datetime.datetime.fromtimestamp()

生成一个差值对象，可以和日期对象直接进行相加减
datetime.timedelta()

参数有，days,hours,minutes,seconds
'''

'''
# %y 两位数的年份表示（00-99）
# %Y 四位数的年份表示（000-9999）
# %m 月份（01-12）
# %d 月内中的一天（0-31）
# %H 24小时制小时数（0-23）
# %I 12小时制小时数（01-12）
# %M 分钟数（00-59）
# %S 秒（00-59）
# %a 本地简化星期名称
# %A 本地完整星期名称
# %b 本地简化的月份名称
# %B 本地完整的月份名称
# %c 本地相应的日期表示和时间表示
# %j 年内的一天（001-366）
# %p 本地A.M.或P.M.的等价符
# %U 一年中的星期数（00-53）星期天为星期的开始
# %w 星期（0-6），星期天为星期的开始
# %W 一年中的星期数（00-53）星期一为星期的开始
# %x 本地相应的日期表示
# %X 本地相应的时间表示
# %% %号本身
'''

代码演示：

import  datetime

#1.获取当前时间
d1 = datetime.datetime.now()
print(d1)  #2018-05-29 11:20:51.432757

#2.获取指定的时间，通过元组形式
d2 = datetime.datetime(2015,10,1,10,23,23,1234)
print(d2)

#3.将时间格式化
d3 = d1.strftime("%Y.%m.%d")
print(d3)

#4.将时间字符串转换为datetime实体
d4 = datetime.datetime.strptime(d3,"%Y.%m.%d")
print(d4)

#5.直接进行加减运算
date1 = datetime.datetime(2015,10,1,10,23,23,0)
print(date1)

date2 = datetime.datetime(2015,10,4,10,23,23,0)
date3 = date2 - date1
print(date3)  #3 days, 0:00:00

print(date3.days)
print(date3.seconds)

3.加密模块

#加密模块
import hashlib
'''
    md5加密:不可逆的加密算法(只能加密不能解密)  明文和密文一一对应  加盐(随机的字符串 或者字符)
    非对称加密算法:(公钥和私钥)  通常情况下:公钥用来加密  私钥用来解密   比如:RSA加密
    对称加密算法: 加密和解密使用同一个密钥    比如:DES和AES
'''
m = hashlib.md5()
m.update('123456'.encode())   #byte类型
print(m.hexdigest())
#e10adc3949ba59abbe56e057f20f883e

该可以按照下面的方式去写:
mpsw=hashlib.md5(b'123456').hexdigest()#给123456加密，转为16进制

对中文加密:
data = "你好"
hashlib.md5(data.encode(encoding="UTF-8")).hexdigest()

二、面向对象思想

1.面向对象思想设计

基于哲学观点：万物皆对象, 一切皆对象

举例说明：

案例一：我想吃大盘鸡

面向过程 面向对象

1.自己去买菜 1.委托一个人帮忙买菜

2.自己择菜 2.委托一个人帮忙择菜

3.自己做菜 3.委托一个人厨师做菜

4.自己吃 4.自己吃

案例二：小明是一个电脑小白，想要配置一台电脑

面向过程 面向对象

1.小明补充电脑知识 1.委托一个懂电脑的人买零件

2.小明去买零件 2.委托一个人组装

3.小明把零件运回来 3.小明打开玩游戏

4.小明组装

5.小明打开玩游戏

2.面向过程和面向对象的区别

2.1面向过程

在生活案例中：

​ 一种看待问题的思维方式，在解决问题的时候，侧重于问题是怎样一步一步解决的，然后亲力亲为的去解决

在程序中：

​ 代码从上往下依次执行

​ 各个模块之间的关系尽可能的独立的，当import的时候，加载的顺序也是从上往下依次加载

​ 每个模块中的语句结构：顺序，分支，循环

2.2面向对象

在生活案例中：

​ 一种看待问题的思维方式，侧重于找到一个具有特殊功能的个体，然后委托这个个体帮忙完成某件事情，这个个体就被称为对象

​ 好处：可以将复杂的问题简单化，将程序员从执行者变成了指挥者

在程序中：

​ 根据不同的需求执行代码【代码执行顺序不一定】

​ 程序的流程完全由需求决定【对象】

​ 思想：如果对象存在，则直接使用；如果对象不存在，则创建对象

注意：面向对象只是一种思想，并不是一门编程语言

Python是一门面向对象的编程语言，类和对象是 面向对象的核心

示例： 小狗吃食（闻一闻smell、舔一舔lick、咬一咬bite）
      分别采用面向过程和面向对象来分析

面向过程 :  先闻一闻, 然后再舔一舔, 最后再咬一咬 (注重过程) 
面向对象 :  小狗是一个对象, 它可以闻一闻食物, 可以舔一舔食物, 可以咬一咬食物.      (不注重过程, 注重对象)

三、类和对象【掌握】

1.类和对象的概念

类：多个具有特殊功能的个体的集合 例如: 人类 狗 猫

对象：在一个类中，一个具有特殊功能的个体，能够帮忙解决某件特定的事情，也被称为实例【instance】

比如: 孙钰昊 孙钰昊家的中秋猫 陈冰杰家的狼青

两者之间的关系：类用于描述某一类对象的共同特征，而对象是类的具体的存在

思考问题：先有类还是先有对象？

【在程序中使用的时候，一般是先定义类，然后创建对象】

举例：

​ 类 对象

​ 人 王麻子, 李四, 赵四。。

​ 快递 韵达，中通，圆通。。

SupreHero 蝙蝠侠，蜘蛛侠，美国队长。。

帮忙理解:类其实也是一种数据类型，只不过一般情况下是自定义的，所以可以将类认为是自定义的数据类型，用法和整型，str，list等基本是相同的【定义变量，传参】

2.类的定义

语法：

class 类名( ):

​ 类体

说明：

​ a.Python中使用class关键字定义类

​ b.类名只要是一个合法的标识符即可，但是要求：遵循大驼峰命名法则【首单词的首字母大写，不同单词之间首字母大写】

​ c.通过缩进区分类体

​ d.类体一般包含两部分内容：属性和方法

代码演示：

#定义类   类主要有属性和方法组成
class Dog():
    #类的属性 (一般情况下以变量的形式存在)
    name = "旺财"
    color = "黑色"
    height = 0.8

    #类的方法  (一般使用函数表示)
    def wang(self):
        print(self.name,"汪汪")

    def eat(self):
        print(self.name,"吃肉,吃骨头")

#对象
labuladuo = Dog()
labuladuo.eat()
labuladuo.wang()

三、类中的方法和变量【掌握】

1.类中的方法和变量的定义

类中的方法和变量是为了描述事物的行为和特征

类中定义的方法被称为成员方法

类中定义的变量被称为成员变量，也被称为属性 [os.name]

成员变量：类具有的特征

成员方法：类具有的行为

类存在的意义：拥有相同特征和行为的对象可以抽取出来一个类，类的存在是为了创建一个具体的对象

代码演示：

#定义类
#1.事物的名称：类名
class Person():
    #2.事物的特征：成员变量、属性
    name = ""
    age = 0
    height = 0.0

    #3.事物的行为：成员方法【函数】
    #注意：类中的成员方法区别于普通方法：参数部分一定包含self(名字可以不是self,但是一般使用self)，而且最好self出现在参数列表的第一个
    #调用函数的时候，self不需要被传参
    #除此之外，成员方法的用法和普通方法的使用完全相同，也可以设置默认参数或者关键字参数，不定长参数

    #注意：self：自己，代表类的实例【对象】
    #此处的self可以是任意的标识符，只不过为了结合其他编程的使用，习惯上使用self
    def eat(self,food):
        print("eating",food)
    def run(self):
        print("running")

2.类中方法和属性的使用

2.1创建对象【实例化对象】

已知类，通过类创建对象

对象的创建过程被对象的实例化过程

语法：变量名 = 值

​ 对象名 = 类名()

代码演示：

class Person():
    #类属性
       name = "社会我强哥"
       age = 38
       love = "打豆豆,造娃,撸代码,抠脚丫"
   
       #类中的方法
   #self详解:
       '''
           1.self不是关键字,只是一般取名用它
           2.self参数一般作为方法中的第一个参数,不能省略
           3.self的作用是:调用类中的其他属性和方法
           4.self指向当前对象:哪个对象调用了类中的方法,那self就表示哪个对象
       '''
       def dance(self):
           #self调用了类中的name属性
           print(self.name,"你看过强哥跳桑巴吗?")
           #self调用了类中的sing方法
           self.sing()
           #查看self的内存地址
       print("定义的类中获取self内存:",id(self))

    def sing(self):
        print("听强哥唱:我的眼里只有你")
        print("类中的self内存:",id(self))
#创建对象
zhaoqiang = Person()
zhaoqiang.dance()
print("具体对象获取内存:",id(zhaoqiang))
xiaoqiang = Person()
xiaoqiang.sing()
print("xiaoqiang获取内存:",id(xiaoqiang))

总结：

​ 访问变量采用：对象名.属性名

​ 访问方法采用：对象名.方法名(参数列表)

3.内存中的对象

per = Person()

说明：

a.程序中定义的Person类型的变量per实际上是一个变量名，它被存放在栈内存中，他指向实际的Person对象，而真正的Person对象则存放于堆内存中

b.类中的成员变量随着对象的出现而出现，随着对象的消失而消失

c.每个对象的成员变量会在堆空间中开辟一份自己的空间，相互之间互不影响

四、构造函数和析构函数

1.构造函数【掌握】

采用上面的方式创建对象【直接给成员变量赋值】，很多的类一般倾向于创建成有初始状态的
__init__:构造函数【作用：创建对象，给对象的成员变量赋初始值】
构造函数：构造器
调用的时机：当一个对象被创建的时候，第一个被自动调用的函数
per = Person()

语法：
    def __init__(self,args1,args2....)
        函数体
说明：
    a.之前的写法中并没有显式的定义__init__函数，说明系统默认提供了一个无参的构造函数
    b.args1,args2...一般设置的形参列表和成员变量有关

代码演示：

class GirlFriend():
    '''
           #类属性 (不推荐)
           name = "林志玲"
       age = 43
       '''
   
       #构造函数  __init__(self,arg1,arg2....)
   '''
           __init__(self,arg1,arg2....)构造函数:作用创建对象的时候,给对象赋初始值
           构造函数也叫做构造器
        调用的时机:当一个对象创建的时候,第一个被自动调用的函数
                    ling = GirlFriend()
        说明:
           1.之前的写法中没有显示的定义一个__init__构造函数,说明系统已经提供了一个无参的构造函数
            2.arg1,arg2....一般设置的形参列表和创建对象的时候的成员变量有关
    '''
       #构造函数
       def __init__(self,name,age):
           #对象属性
           self.name = name
           self.age = age
           print("构造函数的触发时机是:当创建对象的时候自动触发")
       #类方法
       def say(self):
           print(self.name,"卡哇伊")
       def sing(self):
       print(self.name,"唱歌给谁听")


    #析构函数  __del__
        '''
            触发时机:当对象被销毁的时候,自动触发的函数.比如删除对象 del
            使用场景:清理工作.  比如删除数据库  删除文件等操作 
        '''
       def __del__(self):
           print("析构函数被调用了")

   ling = GirlFriend("林志玲",42)
   bing = GirlFriend("范冰冰",40)
   
   ling.say()
   bing.sing()
print(ling,bing)

#删除对象
del ling

2.析构函数

与构造函数正好相反，当对象被销毁的时候自动调用的函数，被称为析构函数
__del__:
​
删除变量：   del  变量名，此时可以触发析构函数的调用
​
使用情景：清理工作，比如关闭数据库，关闭文件等