Day_Python_模块、面向对象和类

一、时间模块

# 时间戳：指定时间距离1970年1月1日0点的总秒数
# UTC:国际标准时间
# time模块
import time
print(time.time())     # 当前时间的时间戳
# 1596508500.797607

# 休眠，会阻塞程序
time.sleep(0.2)  # 睡眠2秒

# datetime 模块
import datetime

# 创建日前对象
d = datetime.datetime.utcnow()  # 当前时间  2020-08-04 02:41:34.375285
d = datetime.datetime(year=2030, month=1, day=1)

# 日前对象属性和方法
print(d.year, d.month, d.day)    # 日前：年月日
print(d.hour, d.minute, d.second)  # 时间：时分秒
print(d.date(), d.time())


print(d.strftime('%Y{}%m{}%d{}').format('年','月','日'))
# ===> 2020年08月04日
print(d.timestamp())   # 时间戳

# 时间戳 => 日前对象： 了解
print(datetime.datetime.fromtimestamp(2596509841))

# 时间差
d2 = datetime.timedelta(days=7, hours=10)
print(d + d2)   # 7天10时后的日前
print(d - d2)   # 7天10时前的日前

二、加密模块

import hashlib
# md5加密：没有解密算法，不可逆，明文和密文一一对应
# RSA加密：非对称加密，私钥和公钥
# DES， AES加密：对称加密，需要使用key进行加密/解密

m = hashlib.md5()
m.update('123456'.encode())  # 32位的16进制
print(m.hexdigest())

三、面向对象

# 面向对象：类，对象  ==> Python, Java, PHP, C#....
#   特点：
#       侧重解决问题中涉及到的对象
#   使用类封装
#
#   面向过程：c语言
#   特点：
#       侧重解决问题的过程（步骤）
#   使用函数封装


# 封装
# 函数 => 类（封装了函数和变量）=> 模块（python文件）=>包（文件夹）

#    类         对象（具体存在的一个事物）
#    人             我，这个人
#    猫             我家的那一只猫
#   电脑            我的这一台电脑
#   联想电脑        我家的那一台联想电脑

# 类：用来创建任意多个对象
# 类是对象的抽象
# 对象是类的具体

# 小狗食狗粮（闻一闻smell、舔一舔lick、咬一咬bite）
# 面向过程：使用函数封装每个功能，然后再按顺序调用
def smell():
    print("闻一闻")
def lick():
    print("舔一舔")
def bite():
    print('咬一咬')
smell()
lick()
bite()

# 面向对象：创建类将功能封装，然后再通过类的对象调用功能
# 类
class Dog:
    name = '旺财'
    def smell(self):
        print(self.name, "闻一闻")
    def lick(self):
        print(self.name, "舔一舔")
    def bite(self):
        print(self.name, '咬一咬')


# 创建对象
dog = Dog()
dog.smell()
dog.lick()
dog.bite()

四、类和对象

1、类和对象的区别：

类：多个具有特殊功能的个体的集合

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

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

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

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

举例：

​ 类 对象

​ 人 王麻子，李四. 赵四。。

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

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

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

2.类的定义

语法：

class 类名( ):

​ 类体

说明：

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

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

​ c.通过缩进区分类体

​ d.类体一般包含两部分内容：对类的特征的描述、对类的行为的描述

# 类和对象
# 类：泛指，指的是同一系列的事物
# 对象：特指，是一个具体存在的实例

# 创建类
#   属性：变量，特征，静态的
#   方法：函数，行为/功能，动态的

class Person:
    # 属性
    name = "小明"
    age = 10

    # 方法
    # self：1、不是关键字，只是一个形参，一般建议取名为self
    #       2、指向当前类的对象, p调用eat时，self==p，p2调用eat时，self==p2
    def eat(self):
        print('self：', self, id(self))
        print("食饭")

# 创建对象/实例
p = Person()
print(p.name, p.age)
p.eat()
print('P:', p, id(p))

p2 = Person()
p2.eat()
print('p2:', p2, id(p2))

五、对象属性和类属性

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

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

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

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

成员变量：类具有的特征

成员方法：类具有的行为

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

# 类

class Pig:
    # 类属性：类变量
    name = '佩奇'
    likes = ['食', '睡']

    # 初始化函数/构造函数：
    # 1.在对象创建时自动被调用
    # 2.在这个函数中可以初始化属性
    def __init__(self, name1, age1):
        # 对象属性：成员变量
        self.name1 = name1
        self.age = age1
        # 如果出现与类属性同名的对象属性，使用对象调用时， 会优先使用对象属性
        self.name = '超人强'

    def eat(self):
        print(self.name1, self.age, "食饭")

# 对象
p1 = Pig('佩奇', 3)
# p1.eat()

p2 = Pig('乔治', 2)
# p2.eat()
print('+' * 100)

# 类属性的调用
print(p1.name)  # 对象，类属性
print(Pig.name)  # 类，类属性，推荐

# 对象属性的调用
print(p1.name1)  # 对象，对象属性
# print(Pig.name1)   # 类，对象属性，错误，不能调用

print("=" * 100)
# 修改对象属性
p1.name1 = '八戒'
print(p1.name1)

# 修改类属性
# Pig.name = "猪猪侠"
# p1.name = "猪猪侠"   # 对象不能修改类属性
# print(Pig.name, p1.name)    # 佩奇 猪猪侠

print(Pig.name)  # 佩奇
print(p1.name)  # 超人强

# 类属性是所有Pig对象共享的
p1 = Pig('佩奇', 3)
p2 = Pig('乔治', 2)

print(p1.likes)  # ['食', '睡']
print(p2.likes)  # ['食', '睡']

p1.likes.append('游泳')
print(p1.likes)  # ['食', '睡', '游泳']
print(p2.likes)  # ['食', '睡', '游泳']

# 对象属性是独立的，不会被其他对象干扰
p1 = Pig('佩奇', 3)
p2 = Pig('乔治', 2)

六、构造函数和析构函数

构造函数：采用上面的方式创建对象【直接给成员变量赋值】，很多的类一般倾向于创建成有初始状态的
init:构造函数【作用：创建对象，给对象的成员变量赋初始值】
构造函数：构造器
调用的时机：当一个对象被创建的时候，第一个被自动调用的函数
per = Person()
语法：
def init(self,args1,args2…)
函数体
说明：
a.之前的写法中并没有显式的定义__init__函数，说明系统默认提供了一个无参的构造函数
b.args1,args2…一般设置的形参列表和成员变量有关

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

限制属性__slots__变量的作用：限制一个类中的成员变量【程序在运行的过程中，就不能随意的动态绑定属性】
语法：slots = (属性的名称)

# 构造函数/析构函数
#   1、在对象创建时自动被调用
#   2、在这个函数中可以初始化属性

# 析构函数
#   在对象销毁时会自动调用


class Ipad:

    # 限制属性
    __slots__ = ('price','size', 'color')

    # 构造函数
    def __init__(self, price, size, color):
        self.price = price
        self.size = size
        self.color = color

    # 析构函数
    def __del__(self):
        print("析构函数调用了")

# 对象
ipad_mini = Ipad(3000, 9.7, '土豪金')
print(ipad_mini.price, ipad_mini.size, ipad_mini.color)

del ipad_mini
print("end")