Python基础入门5

11.模块

#模块：可以简单的理解为一个python文件。
'''
分类
1.内置模块：安装python环境后直接可以使用的模块
2.自定义模块：项目需求自己封装提炼的模块
3.第三方模块：别人写好的具有某些特殊功能的模块
导入方式
1.使用import 模块名 导入
2.from 模块名 import 模块中方法
3.import 模块名 as 别名
'''
#内置模块
import math
import random
import time
import datetime
import os#文件或文件夹操作

num=9.12
print(math.ceil(num))#向上取整
list=[1,5,6,9]
print(random.choice(list))#随机取列表一个元素
print(time.strftime("%Y-%m-%d %H:%M:%S"))#格式化显示时间
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))#格式化输出当前时间
print(os.listdir(r"D:/"))#查看指定目录下的文件或文件夹
print(os.curdir)#获取当前目录
print(os.getcwd())#获取当前路径
'''
os模块中其他方法:
mkdir()创建文件夹
makedirs（）递归式创建文件夹
rmdir（）删除文件夹
rename（）重命名文件夹或文件
path.getsize()获取文件大小
path.exists判断文件是否存在返回布尔值
path.isfile判断是否是文件
path.isdir判断是否是文件夹
'''
#自定义模块
'''
其实和内置模块道理相同，只不过自己根据需求自定义
导入和使用和内置模块一样
'''
#第三方模块
'''
安装别人解决特定问题的模块，后再导入使用
安装通过pip工具或者pycharm编辑器进行安装
在 终端-本地 中  
pip -V查看pip版本
pip list 查看当环境中安装的所有扩展
pip install 模块名    安装第三方模块
pip install 模块名 -i http。。。。。   设置临时镜像，并下载
pip config set global.index-url http.... 设置永久镜像
pip uninstall 模块名 卸载模块

通过pycharm编辑器
文件-设置-项目-pycharm解释器
点击加号即可安装扩展模块，减号卸载
'''

12.面向对象

#面向对象
'''
class 类名：
    类体（属性和方法）
'''
class A():
    name='123'
    def b(self):
        print("456")

a=A()
print(a.name)
a.b()
#构造函数
class Student():
    def __init__(self,name,age):
        self.name=name
        self.age=age
'''构造函数的触发机制是：当对象创建完毕后，给对象属性赋值时，自动触发'''

stu=Student('xiaoming',18)
stu1=Student('xiaocong',18)
print(stu.name)
print(stu1.name)

#面向对象析构函数
class Demo():
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def run(self):
        print('跑')

    def __def__(self):
        print('析构函数的触发机制是：当对象销毁的时候，自动出发....')

demo1=Demo('123',18)
demo1.run()
print(demo1.name)
print(demo1.age)

#类属性和对象属性
'''
类属性：写在类里的属性
对象属性：写在构造函数中里的属性
一般用类名对类属性的访问和修改
一般用对象名完成对对象属性的访问和修改
'''
#类方法和静态方法
class Animal():

    name = '动物'   #类属性


    def __init__(self,sex,name):#构造函数：设置对象的属性
        self.sex=sex
        self.name=name


    def eat (self):    #对象的方法
        print('吃饭的方法')
    '''
    类方法：
    1.通过@classmethod 装饰器修饰的方法就是类方法
    2.类方法可以通过类名或者对象名调，一般用类名调用
    3.类方法当中没有self，在类方法中不可以使用其他对象的方法和属性
    4.类方法中一般会有一个参数cls表示当前类，cls（class简写）只是一个变量名而已
    5.cls表示当前类
    '''

    @classmethod    #定义类方法
    def run(cls):
        print('我是类方法')

# 静态方法
    @staticmethod  # 静态方法
    def drink():
        print('静态方法')
'''
1.通过@staticmethod装饰器修饰的方法是静态方法
2.通过类名或者对象名调用静态方法，一般用类名调用
3.在静态方法中没有cls这个形式参数，在静态方法中一般不推荐其他的方法（对象的方法\类方法\静态方法）
4.静态方法一般是一个单独的方法，只是写在类里
'''


animal = Animal('公','小狗')#创建对象
animal.eat()#通过对象调用对象的方法
Animal.run()#通过类调用类方法（推荐）
animal.run()#通过对象调用类方法（不推荐）
Animal.drink()#通过类名调用静态方法（推荐）

#私有属性和私有方法
class Man():
    def __init__(self,name,age,sex,height):#构造函数
        self.name=name
        self.age=age
        self.sex=sex
        self.__height=height#属性前加俩下划线就是私有属性

    def say(self):#方法
        print('说话的方法')

    #定义一个方法，提供给外部访问私有属性，一般有条件条件满足后可访问
    def sayHeight(self,manname):
        if manname == '小明':
            print(self.__height)
        else:
            print('无法访问')

    def __study(self):#私有方法前边加__
        print('私有方法')

    def saystudy(self,studyname):#在类的内部可以调用私有方法，一般会设定条件
        if studyname =='小明':
            self.__study()
        else:
            print('无法访问')

man= Man('小明','18','男',178)
print(man.name)#通过对想访问属性（共有属性）
man.say()#通过对象访问方法（共有方法）
# print(man.height)#私有属性不能再外部直接访问
man.sayHeight('小明')#通过公开的对外的方法传入满足条件访问私有属性
man.saystudy('小明')#通过公开的对外的方法传入满足条件访问私有方法

#get和set访问和设置私有方法与属性
'''
get和set是自己定义的函数，不是系统的函数
为了和面向对象封装的概念相吻合，一般对外公开的方法设置为getXXX和setXXX
'''
class  demo7():
    def __init__(self,name,age):#构造函数
        self.name=name
        self.__age=age

    def run(self):#方法
        print('普通的方法')

    #通过get函数访问私有属性，命名规则get+私有属性名字首字母大写
    def getAge(self):
        print(self.__age)
    #通过set设置私有属性，命名规则同get(因为私有属性无法直接访问所以设置更不行）
    def setAge(self,age):
        self.__age=age

demo = demo7('小明',18)
demo.run()
demo.getAge()#在类的外部通过访问get函数访问私有属性
demo.setAge(20)#在类的外部通过访问set函数设置私有属性
demo.getAge()

#使用装饰器访问和设置私有属性
class Demo8():
    def __init__(self,name,age):
        self.name=name
        self.__age=age

    def run(self):
        print('普通方法')

    @property#使用@property装饰器访问私有属性等价于 getAge（）
    def age(self):
        print(self.__age)

    #使用装饰器设置私有属性等价于setage（），语法@+私有属性名+setter
    def age(self,age):
        self.__age=age

demo8=Demo8('小刚',19)
demo8.age#通过装饰器访问类的私有属性

#面向对象的继承
'''
面向对象的三大特性：封装 ，继承 ，多态
继承：如果两个或者两个以上的类有相同的属性和方法，
我们可以抽取出一个类来，再抽取的类中申明公共的部分
被抽取的类叫做父类，两个或两个以上的类叫子类
'''
#单继承（只有一个父类）
'''
1.在python中object是所有类的父类，无明显父类则默认父类为object
2.使用继承可以简化代码，提高代码复用性
'''
print('-----------------------------')
class Person(object):#父类（object可以不写）
    def say(self):
        print('父类的方法')

class Boy(Person):#子类,只需将父类写在小括号中即可实习继承
    def eat(self):
        print('我是子类的方法')

boy=Boy()
boy.say()#调用父类方法

#包含构造函数的继承
class Demo9(object):
    def __init__(self,name,age):
        self.name=name
        self.__age=age

    def eat(self):
        print('共有方法')

class Demo10(Demo9):
    def __init__(self,name,age,tail):
        #第一种方式
        Animal.__init__(self,name,age)#表示子类继承父类的属性
        self.tail=tail#子类定义自己的属性

class Demo11(Demo9):
    def __init__(self,name,age,tail):
        #第二种方式
        super(Demo11,self).__init__(name,age)
        self.tail=tail

#多继承（一个子类可以继承多个父类）
'''
语法
class 子类名（父类1，父类2.。。。。）:
    类体
注
可以继承非私有属性和非私有方法，私有不能继承
'''
#多态：一个事物的多种体现形式，函数的重写就是多态的一种体现
#在python中多态指的是父类的引用指向子类的对象
'''
比如各个不同的子类（同一个父类）调用相同名字的方法，
调用的都是自己的方法，这种一种简单的多态的体现

'''