面向对象的编程

（从11.18开始的笔记）

一.模块和包

1.概念

A. 模块：一个.py文件就是一个模块；

B.包：类似于一个文件夹，可以管理和保持很多模块；

        注意：真正的包是： _init_.py

        通过包或模块，我们就可以项目化的管理软件；

 2.python中模块的导入问题

import xxx                           #直接导入需要的模块和包；

import xxx.xxx.xxx.xx         #如果存在多层，可以这样层层导入；

import xxx as alias             #通过别名，简化导入的模块名称

from xx import xxx             #python提供的一种导入；

from xx import xxx as a     #python提供的一种导入，可以别名；

注意：在python中，我们如果遇到比较复杂的命令，可以使用别名方式，将其简化；

3.模块分类（根据创建者存在三种分类）

A.观法内置模块                #python主目录下的lib

B.自定义模块                   #存在项目中

C.第三方                          #需要下载python主目录下的/lib/site-packages;

二.常见内置模块： 

A.随机模块 ---- random

        random.random                     #

        random.choices                    #

        random.choice                      #

        random.randint                      #

        random.randrange                 #

        random.uniform                     #

        random.shuffle                      #随机打乱顺序

B.数学模块  ---- math

        三角函数相关的

        ceil ----- 向上取整

        floor ----- 向下取整

        degrees ---- 弧度转角度

        radians ----- 角度转弧度

        factorial  -----  求阶乘；

        abs -----  整数求绝对值；

        fabs  -----  小数求绝对值；

C.python中的垃圾回收

        setrerecursionlimit：递归

三.main函数的作用和使用

A.javascript、python、PHP等编程语言；若数据类型编程语言是脚本语言，是解释型编程语言，所以这些编程语言往往没有main，即便是有，也不知道程序的入口，但是有特殊作用；

B.main函数是用来写测试代码的，该代码无法被导入到其他模块中；

四.模块分类

1.掌握两个全局函数：help，dir

2.sys模块：sys模块这个模块主要使用是用来调整和修改python文件[xxx.py]    

3.uuid模块

        获取一个128位（比特）的永不重复的数字，当然我们使用的时候会转换为32个字符串；

        格式：import uuid

                   uuid.uuid4().hex

4.时间模块

        A.python中跟时间相关的模块非常多；

        B.在计算机中时间是非常特殊的东西，为了方便时间的显示，一般是字符串格式。当然时间在计算机中是对象，为了比较时间，时间又可以表示成数字；（时间戳）

        时间戳：距离1970年的毫秒；

        C.time和datetime

5.hash加密模块  ----  主要用于数据校验！

        加密分为可逆加密和不可逆加密，对称加密 和非对称加密！

        hash加密特点：不可逆的加密！

        A.单向性：只能由明文转向为密文；

        B.唯一性：只要明文一致，得到的密文也是一定的；

        可逆加密：明文与密文可来回转换；

        对称加密：加密和解密是使用一个相同的秘钥！  -----  常用的是DES

        （把文件压缩后，可设置密码；接收人只有把密码输入正确才可以看到内容！）

        不对称加密：加密和解密是使用不同的秘钥！本质上也是一对秘钥；  ------    RSA

        

---

hashlib 和 hmac：通过避免基于内容的短路行为来防止定时分析,使得它适合处理密码 

hashlib：会对明文进行对称加密和hash加密；常见的可以做密码加密等功能；

 md5.hexdigest （Message-Digest ）：是一个计算哈希值的方法,它将输入的数据(通常是字符串)转换为固定长度的哈希值；常用来做数据校验！

格式：以sha3_256举例！

第一步：导入hashlib函数

第二步：创建对象；选择要使用的哈希校验码：我选用的是sha3_256.

        注意：在使用哈希校验码的时候，要记得encode编码！

第三步：可以使用hexdigest来计算哈希值！

这里放一个网址，是md5在线解密破解：md5在线解密破解,md5解密加密​​​​​​

平时很重要的密码就不要这样子，需要使用update。

update：将任意长度的消息作为输入，输出固定长度的哈希值；通常为128位；也就是在原来的密码后面拼接；

五.I/O流

1.什么是I/O流？

        输入输出流   -------   input output stream

 IO流分为在广义上和狭义上的不同：

        在广义上：是指计算机中数据的流动；

        在狭义上：内存cpu和磁盘之间的数据流动；

2.IO流分类：（站在cpu或内存的角度来看）

        A.基于数据流动方向：                        -----  输入流

     （数据存在存储里面的，将它输出！） -----  输出流（例如：将数据存入电脑中）

       

        B.数据的格式： ------  字节流

                                  ------  字符流（readline和readlines针对于字符流来说）（大多用于文本）

字节数据最后会加一个b

readlines是以【】返回的；

3.python处理IO流：

        A.python提供了应该全局函数open函数，（该函数也在os模块中存在），底层就是c语言的fopen函数

        B.处理流和节点流一块使用,在节点流的基础上,再套接一层,套接在节点流上的就是处理流

4.小练习：

创建一个文本，然后将它输出到控制台上：

A.打开控制台，cd到当前目录（以我的举例！），然后并切换到python模式

B.打开我们创建的文件：

C.在我们创建的文件里面写入内容，并保存！---一定要保存，不然读取不到！

E.然后我创建的这个文件是只能读的，不能写！所以当我f.writable写入的时候，是不行的：

注意：

        f.read() = f.read(-1)两者都是一样的，都指的是读取一个文件的所有内容

        当我们使用完文件之后，我们最后要关闭文件！因为1.我们要保证最后一次刷新的内容会存在文件里面！2.操作系统的文件访问权限是有限的！当你访问的时候，别人是不能访问的！

        f.close()     ----   关闭文件；

        f.closed()   ----   判断一下是否关闭；

5.常用的函数

A. f.seek(0):   将文件中的读写位置移动到文件的开头。它实际上是一个措施,旨在将文件当前位置重置为文件开头(即0)。这样,我们可以从文件的开头重新开始读写;

B. f.readline():从文件中读取一整行字符串(包括末尾的换行’\n’)

C.f.readlines():用于读取文件中的所有行并将它们作为一个字符串列表返回。每一行都是列表中的一个元素,行尾的换行符也会包含在元素中

6.输出流：msg = “··········”

A.新建了一个b.txt文件：

B.写入一个msg信息：

注意：写入信息的时候要关闭b.txt文件！他会告诉你存了几个字符：

C.关闭b.txt文件之后，刷新一下，再打开文件就会有信息！

7.字节流 ---- 适应于任何数据

8.with语法

      在with语法中，可以不用自己关闭文件 ，它会自动关闭文件！

9.序列化

     对象序列化：将抽象的对象通过相关技术转换为可以存储或者传输的字符或者字节；

     对象序反列化：将序列化后的字符或者字节通过相关的技术转换为可以抽象的对象；

     对象持久化：将抽象的对象存储下来；

     对象反持久化：存储的对象数据还原成对象；

9.python官方提供的两个持久化模块

        pickle 、 json 、shelve

        A. pickle  

                pickle.dump(ls,open("c.txt","bw")                #返回该对象序列后的字节数据

                pickle.loads(字节数据)                                #反序列化

               

10.python如何私有化属性或方法：

        A.正常命名的方法

        B.双下划线的属性或者方法（魔法属性或者方法：double line method/attribute）

                __doc__   

                __int__

                __eq__

                __init__

        C.前面加一个下划线的属性或者方法 ---- 这样的定义无法使用from xxx import *这种方式导入到其他模块中；

                _name

                _age

                _nickname

        D.封装

                __（两个横线）属性名称或者方法名称

六.定义类和创建对象

#定义一个类
class User:
   
    #python中，类定义属性，要用这个初始化方法
    def __init__(self):
        self.name = "小辣椒"
        self.age = 18
        self.gender = "女"
        self.tel = "1008611"

    def speak(self):
        print(f"我的名字是{self.name}")

    def talk(self):
        print(f"我的年龄是{self.age}")

u=User()
print(u)
print(u.name, u.age, u.gender, u.tel)
u.speak()
u.talk()

 如果if __name__ == '__main__' 所在.py文件是被直接运行的，则该语句下代码块被运行，如果所在文件作为模块被导入到其他的python脚本中运行的，则该语句下代码块不被运行。

七.面向对象

1.面向对象的三大特征：

        封装        继承        多态（核心）

封装：

           A.类会将类成员封装在类内部；

           B.类的属性，私有化（加两个下划线__），不让外界访问，如果外界徐娅访问，则需要提供对应的公开方法的方式；为了保证安全；

第一种：（两个下划线）

lass User(object):

    def __init__(self, name, age, password, nickname):
        #在name前面加两个横线，对name进行封装；
        # 也就是说在类的外部是不能访问到的；
        self.__name = name
        self.age = age
        self. password = password
        self.nickname= nickname

    def login(self, name, password):
        if name == self.__name and password == self.password:
            print("登陆成功！")
        else:
            print("登陆失败！！")
if __name__ == '__main__':
    u1 = User("张三", 18, "147258", "小辣椒")
    u1.name = "xiaojinfeng"
    u1.login("xiaojinfeng", "147258")
  

第二种：增加了一个a的变量！

class User(object):

    def __init__(self, name, age, password, nickname):
        #在name前面加两个横线，对name进行封装；
        # 也就是说在类的外部是不能访问到的；
        self.__name = name
        self.age = age
        self. password = password
        self.nickname= nickname

    def login(self, name, password):
        if name == self.__name and password == self.password:
            print("登陆成功！")
        else:
            print("登陆失败！！")

    #这里是可以拿到name的，因为name封装在这里是没有效果的！
    def get_name(self):
        return self.__name
#传一个属性进去，便于后续修改name
    def set_name(self, name):
        self.__name = name
#在这里加一个property全局函数二次封装，来获得name和修改name
    a = property(get_name, set_name)
if __name__ == '__main__':
    u1 = User("张三", 18, "147258", "小辣椒")
#打印name
    print(u1.a)
    #修改name
    u1.a = "里斯"
    print(u1.a)
    print(u1.get_name())

第三种：

                1.将get_name和set_name的名字改成一样；例如：name

                2.在get_name前面加上@property

                   在set_name前面加上@name.setter

class User(object):

    def __init__(self, name, age, password, nickname):
        #在name前面加两个横线，对name进行封装；
        # 也就是说在类的外部是不能访问到的；
        self.__name = name
        self.age = age
        self. password = password
        self.nickname= nickname

    def login(self, name, password):
        if name == self.__name and password == self.password:
            print("登陆成功！")
        else:
            print("登陆失败！！")

    @property
    def name(self):
        return self.__name
  # 传一个属性进去，便于后续修改name
    @name.setter
    def name(self, name):
        self.__name = name


if __name__ == '__main__':
    u1 = User("张三", 18, "147258", "小辣椒")
    # 打印name
    print(u1.name)
    # 修改name
    u1.name = "里斯"
    print(u1.name)

继承：

           在面向对象中，存在了类继承类的特征，这个就是我们说的继承；

           父类：（supper class）被继承的类，被称为父类，也被称为超类，基类；

           子类：继承父类的类，被称为子类；

python是多继承机制

方法重写(overwrite)：（方法覆盖(override)；）

                  在继承的关系中，如果子类继承父类中的某一个或者某些方法时，如果想要修改原有的方法，这需要重写该方法；

函数重载（overload）：两个或者两个以上函数，函数名称相同，参数类型或个数不同，从而在调用时，根据传递的参数类型或者个数，能正确调用该函数的这种现象；

装饰器：property

注意：python，JavaScript等弱数据类型编程语言，因为不强调

        （经典类和新式类）

        要记住super函数！

多态：

        事务的多种状态；

        特征：1.父类引用指向子类的实例；

                   2.

小知识点over-xxxxxx的笔记整理

overwrite，override，overload三者的区别：

   1.overload意为重载，override意为覆盖，overwrite意为重写；

   2.重载就是方法名必须一样，其他都可以不一样；重写可以发生在继承也可以发生在现实，是发生在不同的类里面；

2.异常处理：

       1.python用  try 和 catch  进行异常抓捕的处理；

       2. 针对异常，我们就对应的处理，这种方式叫异常处理；

       3. 异常：非正常现象，一般指的是软件运行时出现一些可控或者可处理的错误

       4. 注意：异常是一种错误，但是错误不一定是异常。致命性的错误，只能通过修改代码；异常是可以控制或者忽略；

        目的：保证软件的稳定性，加强软件的容错能力

        3.补充：for,while循环中的else ，for和while循环中,else用于循环正常结束,且循环体中没有break、return和异常抛出,则执行else语句块中的内容；

3.try 和 catch怎么处理多个异常

       ······  

4.finally

        A.finally中的代码一定要执行！

        B.和try配合使用，finally中的代码不管是都存在异常，都必须会执行！

        C.如果代码非常重要，必须要执行，建议放在finally中执行；

        D.return的级别比finally高；        

        E.finally中的return级别高于其他的return；

5.正则表达式（regular expression）

 1.python给正则表达式提供re模块；

 2.正则表达式：

        元字符：

                        .                                                       #除\n外，匹配任意字符；

                        \w （在python中）                          #匹配有效字符：大小写字母，数字，下划线或0-9，a-z,A-Z；中文也可以；

                        \d                                                     #匹配数字；

                        \s                                                     #匹配任意的空白符；

                       ^                                                        #以什么开始  ----- 从字符串开头开始匹配；

                       $                                                        #以什么结尾 ----- 也是针对于开始字符串来说；

                       [ ]                                                        #列举只能是中括号中的数字；

转义符：

        最佳实践：在python中，使用正则表达式字符串，建议在前面加上r"正则表达式"；

                       

重复‘位数问题：

                   *                                                       #0~多位

                   +                                                      #1~多位；

                   ?                                                      # 0 、1

                   {m}                                                  #m位

                   {m，}                                              #至少m位

                   {m，n}                                            #m到n

sub函数是用来替换的；

匹配一个标签的正则表达式：

        r"

|符号使用：

        注意：|表示或者的意思，也就是多个中选择一个；

                   单个符号可以使用，但是不建议使用！因为[]是同样的作用；

        因此，主要使用多个符号的匹配中，但是多个是一般要配合（）使用；