Python基础之系统常用模块

一. 系统模块

UTC：国际标准时间, 格林尼治天文时间，UTC+8

时间戳：指定时间距离1970.1.1 00:00:00的秒数

time：时间

datetime:日期

calendar：万年历

os：系统，文件和文件夹

2.1time时间模块

代码演示：

import time

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

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

2.2datetime日期模块【掌握】

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

'''
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
'''

代码演示：

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)

二、面向对象思想

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 MyClass():
    #类的实现
    #类体
    #print("hello")   #一般不会这么书写
    pass

#注意：在同一个py文件中可以同时定义多个类，但是，为了提高代码的可读性，结合模块的使用，最好是一个文件一个类
class MyClass1():
    pass

3.类的设计【类体的实现】

三要素：

​ 事物名称【类名】：举例：人

​ 事物的特征【变量】：名词，举例：姓名，年龄。。。。

​ 事物的行为【函数/方法】：动词，举例：吃，跑。。。。

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

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

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

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

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

成员变量：类具有的特征

成员方法：类具有的行为

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

代码演示：

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

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

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

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

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

已知类，通过类创建对象

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

语法：变量名 = 值

​ 对象名 = 类名()

代码演示：

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

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

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


#对象的创建
p1 = Person()
print(p1)

p2 = Person()
print(p2)

#p1和p2被称为对象，变量名，引用，指向了真正的对象
#p1和p2在栈空间中开辟了空间，真正的对象的被存储在堆空间中

#通过对象调用类中的成员方法和访问类中的成员变量
#1.访问属性
#语法：对象.属性名
#赋值：对象.属性 = 值
per = Person()
print(per.name)
per.name = "小姐姐"
print(per.name)
per.age = 18
print(per.age)
per.height = 1.70
print(per.height)

#2.调用方法
#语法：对象.函数名(参数列表)
#注意：self不需要被传参，传参的时候注意区分参数的类型【默认参数，不定长参数，关键字参数】
per.run()
print("per的地址：",id(per))
"""
self的地址： 2687721120880
per的地址： 2687721120880
"""
per.eat("apple")

person = Person()
person.name = "张三"
person.age = 20
print(person.name,person.age)
person.run()
person.eat("")

#结论：类中的成员变量和成员方法随着对象的出现而出现

总结：

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

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

3.内存中的对象

per = Person()

说明：

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

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

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

4.动态绑定属性和限制绑定

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

代码演示：

#1.类的定义
class MyClass():
    #2.成员变量
    """
    num1 = 0
    num2 = 10
    """
    #限制属性
    #注意：被限制的属性的名称通过字符串的方式出现在元组的元素中
    __slots__ = ("num1","num2")

    #3.成员方法
    def fun1(self):
        print("fun1")
    def fun2(self,num):
        print(num)

#4.创建对象
my = MyClass()
#5.访问类中的成员变量
my.num1 = 11
my.num2 = 22
print(my.num1,my.num2)

#6.调用类中的成员方法
my.fun1()
my.fun2(30)

#成员变量随着对象的出现而出现的
#属性的动态绑定【Python是一门动态语言】
my.n = 100
print(my.n)

my1 = MyClass()
#print(my1.n)

5.综合案例一

代码演示：

practiceDemo01.py文件【测试模块】

"""
需求：使用面向对象的思想描述下面这个情景
开学了，王老师让小明，小花，小丽分别做自我介绍
需要介绍姓名，年龄，爱好，来一段才艺展示
"""
"""
分析：
老师类
    特性：姓名
    行为：让学生做自我介绍

学生类
    特征：姓名，年龄，爱好
    行为：一段才艺展示
"""
#导入
"""
import  practice01.teacher
import  practice01.student
"""
from practice01.teacher import  Teacher
from practice01.student import Student

#1.创建一个老师的对象
wang = Teacher()
wang.name = "王老师"

#2.创建一个学生的对象
xiaohua = Student()
xiaohua.name = "小花"
xiaohua.age = 18
xiaohua.hobby = "唱歌"

#3.让老师执行自己的行为
wang.letStudentIntroduce(wang.name,xiaohua)   #stu = xiaohua

xiaoli = Student()
xiaoli.name = "小丽"
xiaoli.age = 20
xiaoli.hobby = "跳舞"
wang.letStudentIntroduce(wang.name,xiaoli)

xiaoming = Student()
xiaoming.name = "小明"
xiaoming.age = 25
xiaoming.hobby = "吹牛逼"
wang.letStudentIntroduce(wang.name,xiaoming)

teacher.py文件【实体类】

#老师类
class Teacher():
    #特征：成员变量
    name = ""

    #行为：成员方法
    def letStudentIntroduce(self,name,stu):
        #老师发出指令
        print(name + "让" + stu.name + "做自我介绍")

        #执行指令
        stu.introduce(stu.name,stu.age,stu.hobby)

        #不同的学生展示不同的才艺
        if stu.name == "小花":
            stu.singSong()
        elif stu.name == "小丽":
            stu.dance()
        else:
            stu.lie()

student.py文件【实体类】

#学生类
class Student():
    #特征：成员变量
    name = ""
    age = 0
    hobby = ""

    #行为：成员方法
    def introduce(self,name,age,hobby):
        print("大家好，我是%s，今年%d,爱好%s"%(name,age,hobby))

    #唱歌
    def singSong(self):
        print("娘子~啊哈")

    #跳舞
    def dance(self):
        print("广场舞")

    #吹牛逼
    def lie(self):
        print("我家可穷了，就养了几百头牛")

四、构造函数和析构函数

1.构造函数【掌握】

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

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

代码演示：

#1.构造函数被调用的时机
class Check():
    num1 = 0
    str1 = ""

    #构造函数
    def __init__(self):
        print("jfahj")

    def show(self):
        print("show")
#注意：当创建对象的时候，默认调用了系统提供的无参的构造函数
c = Check()
c.show()

#2.给构造函数添加参数
class Check1():
    name = ""
    age = 0
    """
    def __init__(self,n,a):
        print("fajkgak")
    """
    #注意2：当使用构造函数的时候，可以使用无参的，也可以使用有参的，在Python中的解决办法：设置不定长参数
    #注意3：Python中，一个类中只能有一个构造函数
    def __init__(self, *n):
        print("fajkgak")


#注意1：当手动头添加了有参的构造函数之后，系统将不再提供无参的构造函数
c1 = Check1()
c11 = Check1("fsiugh")

#3.有参构造函数的使用
class Check2():
    name = ""
    age = 0

    #构造函数的形参列表：和成员变量有关
    def __init__(self,n,a):
       print(n,a)
       name = n
       age = a

#注意1：当手动头添加了有参的构造函数之后，系统将不再提供无参的构造函数
c2 = Check2("zhangsan",10)
print(c2.name,c2.age)   #0


#4.self的使用
class Check3():
    name = ""
    age = 0

    #构造函数的形参列表：和成员变量有关
    def __init__(self,n,a):
       print(n,a)
       #self的使用：通过self来区分成员变量和局部变量,所以self.name代表name是一个全局变量【成员变量】
       self.name = n
       self.age = a

c3 = Check3("zhangsan",10)
print(c3.name,c3.age)  #10

#5.使用self之后，可以省略成员变量的定义【掌握】
#self只是一个标识符，可以替换成任意的标识符
class Check4():

    #构造函数的形参列表：和成员变量有关
    def __init__(self,name,age):
       print(name,age)
       #self的使用：通过self来区分成员变量和局部变量,所以self.name代表name是一个全局变量【成员变量】
       self.name = name
       self.age = age

    def show(self):
        print("showing")

c4 = Check4("lisi",20)
print(c4.name,c4.age)
c4.show()

2.析构函数

与构造函数正好相反，当对象被销毁的时候自动调用的函数，被称为析构函数
__del__:

删除变量：   del  变量名，此时可以触发析构函数的调用

使用情景：清理工作，比如关闭数据库，关闭文件等

代码演示：

import  time

class Pig():
    def __init__(self,name,age):
        self.name  = name
        self.age = age
        print("构造函数被执行")


    def show(self):
        print("show")

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


#析构函数被调用的时机：1：当程序运行完成的时候    2：使用del删除变量
p = Pig("abc",10)

del p

#注意：对象释放以后就不能再访问了【相当于根本未创建过这个对象】
#print(p.age)

time.sleep(5)

#在函数里定义的对象，会在函数结束时自动释放，这样可以用来减少内存空间的浪费
#其实就是作用域的问题
def func():
    per2 = Person("aa", 1, 1, 1)

func()

3.综合案例二

practiceDemo02.py文件【测试模块】

"""
需求：富二代王思聪开着豪车，很自豪的向他的新女友炫耀

富二代类
特征：姓名
行为：开车，炫耀

汽车类
特征：品牌，颜色
行为：奔驰
"""
#测试模块
from  practice02.car import Car
from practice02.richMan import RichMan

#1.创建一个富二代的对象
wang = RichMan("王思聪")

#2.创建一个汽车的对象
c = Car("玛莎拉蒂","闷骚红")
c.run()

#3.让富二代执行自己的行为
wang.driveCar(c)
wang.showCar(c)

richMan.py文件【实体类】

class RichMan():
    #构造函数
    def __init__(self,name):
        self.name = name

    #成员函数
    def driveCar(self,car):
        print("富二代%s开着他的豪车%s"%(self.name,car.brand))
    def showCar(self,car):
        print(car.brand,car.color)

car.py文件【实体类】

class Car():
    #构造函数
    def __init__(self,brand,color):
        self.brand = brand
        self.color = color

    #成员函数
    def run(self):
        print("%s在马路上奔驰"%(self.brand))