python实现学生信息管理系统

## 编码格式介绍

- 常见的字符编码格式

  - python的解释器使用的是Unicode（内存）

  - .py文件在磁盘上使用UTF-8存储（外存）

    -  `ASCII` ：7位表示一个字符，最高位为0，只能表示128个字符
    -  `ISO8859-1` ：8位表示1个字符，能表示256个字符，兼容 `ASCII` 
    -  `Unicode` ：定长编码，2个字节表示一个字符
    -  `UTF-8` ：变长编码，1-4个字节表示1个字符，英文1个字节，汉字3个字节
    -  `GB2312` 、 `GBK` 、 `GB18030` ： 兼容ISO8859-1，英文1个字节，汉字2个字节
	
	

    ```mermaid
    graph LR
    A(ASCII)--> B(ISO8859-1)
    B --> D(GB2312)
    B --> E(UTF-8)
    B --不兼容--> C(Unicode)
    subgraph "兼容ISO8859-1，英文1个字节，汉字2个字节"
    D --> F(GBK) --> G(GB18030)
    end
    E -.- |UTF-8是Unicode的实现| C
    ```




## 文件的读写原理

- 文件的读写俗称“IO操作”

- 文件读写操作流程

- 操作原理

  ```mermaid
  graph TB
  A(python操作文件)--> B(打开或新建文件) --> C("读、写文件") --> D(关闭资源)
  subgraph 系统
  E(.py文件)-->F(解释器)-->G(OS)
  end
  G--操作-->H(硬盘)
  ```




## 文件读写操作

- 内置函数 `open()` 创建文件对象，语法规则 `file = open( filename [,mode,encoding] )` 

  ```python
  file = open('a.txt', 'r')
  print(file.readlines())  # 把读取的文件放到列表中
  file.close()
  ```

- 常用的文件打开模式，按文件中数据的组织形成，文件分为以下两大类

  - 文本文件：存储的是普通的“字符”文本，默认为unicode字符集，可以使用记事本打开

    ```python
    file = open('b.txt', 'w')
    print(file.write('python'))
    file.close()
    
    file = open('b.txt', 'a')
    print(file.write('python'))
    file.close()
    ```

    

  - 二进制文件：把数据内容用“字节”进行存储，无法用记事本打开，必须使用专用的软件打开，举例：mp3音频文件，jpg图片文件，.doc文档等

    ```python
    src_file = open('logo.png', 'rb')
    target_file = open('copylogo.png', 'wb')
    target_file.write(src_file.read())
    target_file.close()
    src_file.close()
    ```

    

  | 打开模式 | 描述                                                         |
  | :------: | ------------------------------------------------------------ |
  |    r     | 以只读模式打开文件，文件的指针将会放在文件的开头             |
  |    w     | 以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头 |
  |    a     | 以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加内容，文件指针在原文件末尾 |
  |    b     | 以二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb或者wb |
  |    +     | 以读写方式打开文件，不能单独使用，需要与其他模式一起使用，a+ |

  
  



## 文件对象常用的方法

- 文件对象的常用方法

  | 方法名                | 说明                                                         |
  | --------------------- | ------------------------------------------------------------ |
  | read([size])          | 从文件中读取size个字节或字符的内容返回。若省略[size]，则读取到文件末尾，即一次读取文件所有内容 |
  | readline()            | 从文本文件中读取一行内容                                     |
  | readlines()           | 从文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回 |
  | write(str)            | 将字符串str内容写入文件                                      |
  | writelines(s_list)    | 将字符串列表s_list写入文本文件，不添加换行符                 |
  | seek(offset[,whence]) | 把文件指针移动到新的位置，offset表示相对于whence的位置：<br />offset：为正往结束方向移动，为负往开始方向移动<br />whence不同的值代表不同含义：<br />0：从文件头开始计算（默认值）<br />1：从当前位置开始计算<br />2：从文件尾开始计算 |
  | tell()                | 返回文件指针的当前位置                                       |
  | flush()               | 把缓冲区的内容写入文件，但不关闭文件                         |
  | close()               | 把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源   |

  ```python
  file = open('a.txt', 'r')
  print(file.read(2))  # 读取两个字符
  print(file.readline())  # 读取一行
  print(file.readlines())  # 列表方式输出
  file.close()
  
  file = open('c.txt', 'a')
  lst = ['java', 'go', 'python']
  file.writelines(lst)  # 把列表内容追加到c.txt文件
  file.close()
  
  file = open('a.txt', 'r')
  file.seek(2)  # 跳过2个字节
  print(file.read())
  file.close()
  
  file = open('c.txt', 'r')
  file.seek(2)
  print(file.read())
  print(file.tell())  # 返回文件指针的当前位置
  file.close()
  
  file = open('d.txt', 'a')
  file.write('hello')
  file.flush()  # flush不关闭文件，后面还可以继续使用这个文件
  file.write('world')
  file.close()
  ```



  

## with语句（上下文管理器）

- with语句可以自动管理上下文资源，不论什么原因跳出with块，都能确保文件正确的关闭，以此来达到释放资源的目的

- 一个类对象实现了 `__enter__()` 方法和 `__exit__()` 方法，该类对象遵守了上下文管理协议，这个类的实例对象就称为 **上下文管理器** ，离开运行时上下文，自动调用上下文管理器的特殊方法 `__exit__()` 

  ```python
  with open('a.txt', 'r') as file:  # with后和as前的内容 open('a.txt', 'r') 称为上下文表达式，结果为上下文管理器
      print(file.read())
  
  '''
  MyContentMgr实现了特殊方法 __enter__() 和 __exit__() 称为该类对象遵守了上下文管理协议，这个类的实例对象就称为 上下文管理器
  MyContentMgr()  # 创建实例对象
  '''
  class MyContentMgr(object):
      def __enter__(self):
          print('enter方法被调用执行了')
          return self
  
      def __exit__(self, exc_type, exc_val, exc_tb):
          print('exit方法被调用执行了')
  
      def show(self):
          print('show方法被调用执行了')
  
  with MyContentMgr() as file:  # 相当于file=MyContentMgr()
      file.show()
  
      
  with open('logo.png', 'rb') as src_file:  # 使用with拷贝图片
      with open('copylogo.png', 'wb') as target_file:
          target_file.write(src_file.read())
  ```

  



## 目录操作

-  `os` 模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样

-  `os模块` 与 `os.path模块` 用于对目录或文件进行操作

  ```python
  import os
  os.system('notepad.exe')  # 打开记事本，可以调用系统的应用程序，退出程序后才可以继续执行后面代码
  os.startfile('C:\\Windows\\system32\\notepad.exe')  # 直接调用可执行文件，不等待程序退出继续执行
  ```
  

  - `os模块` 操作目录相关函数


    | 函数                            | 说明                           |
    | ------------------------------- | ------------------------------ |
    | getcwd()                        | 返回当前的工作目录             |
    | listdir(path)                   | 返回指定路径下的文件和目录信息 |
    | mkdir(path[,mode])              | 创建目录                       |
    | makedirs(path1/path2...[,mode]) | 创建多级目录                   |
    | rmdir(path)                     | 删除目录                       |
    | removedirs(path1/path2...)      | 删除多级目录                   |
    | chdir(path)                     | 将path设置为当前工作目录       |

    ```python
    import os
    print(os.getcwd())
    lst = os.listdir('test')
    print(lst)
    # os.mkdir('newdir')
    # os.makedirs('A/B/C')
    # os.rmdir('newdir')
    # os.removedirs('A/B/C')
    os.chdir('D:\code')```

  - `os.path` 模块操作目录相关函数

    | 函数            | 说明                                                        |
    | --------------- | ----------------------------------------------------------- |
    | abspath(path)   | 用于获取文件或目录的绝对路径                                |
    | exists(path)    | 用于判断文件或目录是否存在，如果存在返回True，否则返回False |
    | join(path,name) | 将目录与目录或者文件名拼接起来                              |
    | splitext()      | 分离文件名和扩展名                                          |
    | basename(path)  | 从一个目录中提取文件名                                      |
    | dirname(path)   | 从一个路径中提取文件路径，不包括文件名                      |
    | isdir(path)     | 用于判断是否为路径                                          |

    ```python
    import os.path
    print(os.path.abspath('logo.png'))
    print(os.path.exists('logo.png'), os.path.exists('logo.ico'))
    print(os.path.join('D:\\code', 'logo.png'))
    print(os.path.split('D:\\code\\logo.png'))  # 分离目录和文件
    print(os.path.splitext('logo.png'))
    print(os.path.basename('D:\\code\\logo.png'))
    print(os.path.dirname('D:\\code\\logo.png'))
    print(os.path.isdir('D:\\code\\logo.png'))
    
    # 列出指定目录下的所有py文件
    import os
    path = os.getcwd()
    lst = os.listdir(path)
    for filename in lst:
        if filename.endswith('.py'):
            print(filename)
    
    # os.walk(path) 可以遍历指定目录下的所有文件和目录
    import os
    path = os.getcwd()
    lst_files = os.walk(path)
    for dirpath, dirname, filename in lst_files:
        '''print(dirpath)
        print(dirname)
        print(filename)
        print('--------------------------')'''
        for dir in dirname:
            print(os.path.join(dirpath, dir))
        print('---------------------------')
        for file in filename:
            print(os.path.join(dirpath, file))
        print('---------------------------')
    ```





## 知识点总结

```mermaid
graph LR
A(编码格式)--> B(内存为Unicode)
A --> C(.py文件为utf-8)
D(目录操作) --> E(os模块)
D --> F(os.path模块)
G(文件操作) --> H(写)
G --> I(读)
G --> J(打开模式)
H --> K("writelines()")
H --> L("write()")
I --> M("read()")
I --> N("readline()")
I --> O("readlines()")
J --> P(只读r)
J --> Q(只写w)
J --> R(追加a)
J --> S(二进制b)
```

python入门到精通第十五章

## 什么叫模块

- 模块英文为Modules，一个模块中可以包含N多个函数，在python中一个扩展名为 `.py` 的文件就是一个模块

- 使用模块的好处

  - 方便其他程序和脚本的导入并使用
  - 避免函数名和变量名冲突
  - 提高代码的可维护性
  - 提高代码的可重用性



  ```python
  def fun(): #一个模块可以包含N多个函数
      pass
  def fun2():
      pass
  
  class Student: #可以包含N多个类
      native_place='吉林' # 类属性
      def eat(self,name,age):
          self.name=name
          self.age=age
      @classmethod
      def cm(cls):
          pass
      @staticmethod
      def sm():
          pass
  
  a=10 #可以包含N多个语句
  b=20
  print(a+b)
  ```

  



## 自定义模块

- 创建模块：新建一个 `.py` 文件，名称尽量不要与python自带的标准模块名称相同。

- 导入整个模块： `import 模块名称 [as 别名]` ，导入模块里的指定内容： `from 模块名称 import 函数/变量/类` 。

  ```python
  import math #第一种导入整个模块，关于数学运算的模块
  print(id(math))
  print(type(math))
  print(math)
  print(math.pi) #输出的是圆周率
  print(dir(math)) #查看都有哪些属性和方法
  print(math.pow(2,3),type(math.pow(2,3))) #计算的是2的3次方
  print(math.ceil(9.001))
  print(math.floor(9.999))
  
  
  from math import pi #第二种导入的方式
  print(pi)
  
  #新建一个 calc.py 的文件，自定义模块
  # def add(a,b):
  #     return a+b
  # def div(a,b):
  #     return a/b
  
  import calc #导入自定义模块
  print(calc.div(2,10))
  print(calc.add(2,3))
  ```

  



## 以主程序的形式运行

- 在每个模块的定义中都包括一个记录模块名称的变量 `__name__` ，程序可以检查该变量，以确定他们在哪个模块中执行。如果一个模块不是被导入到其他程序中执行，那么它可能在解释器的顶级模块中执行。顶级模块的 `__name__` 变量的值为 `__main__` ，示例： `if __name__ == '__main__' : pass` 

  ```python
  # calc.py 文件
  def add(a,b):
      return a+b
  
  if __name__ == '__main__':
      print(add(10,20)) #只有当点击运行 calc 时，才会执行运算，被其他模块引用后不会被执行
  
  # main.py 文件
  import calc
  print(calc.add(100,50)) #引用calc模块，只计算当前程序的计算，calc就不是主程序了
  ```

  



## python中的包

- 包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下，作用： 代码规范和避免模块名称冲突。

- 包与目录的区别

  - 包含 `__init__.py` 文件的目录成为包
  - 目录里通常不包含 `__init__.py` 文件

- 包的导入： `import 包名.模块名` 

  ```python
  #package1包下面有 module_A.py 和 module_B.py 两个模块
  #在 main.py 的模块中导入 package1 包
  import package1.module_A as ma # ma是package1.module_A这个模块的别名
  print(ma.a)
  
  #使用import方式进行导入时，只能导入包名或者模块名
  import package1
  import calc
  
  #使用 from...import 可以导入包，模块，函数，变量等
  from package1 import module_A
  from package1.module_A import a
  ```



| 模块名   | 描述                                                         |
| -------- | ------------------------------------------------------------ |
| sys      | 与python解释器及其环境操作相关的标准库                       |
| time     | 提供与时间相关的各种函数的标准库                             |
| os       | 提供了访问操作系统服务功能的标准库                           |
| calendar | 提供与日期相关的各种函数的标准库                             |
| urllib   | 用于读取来自网上（服务器）的数据标准库                       |
| json     | 用于使用json序列化和饭序列化对象                             |
| re       | 用于在字符串中执行正则表达式匹配和替换                       |
| math     | 提供标准算数运算函数的标准库                                 |
| decimal  | 用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算 |
| logging  | 提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能   |

```python
import sys
import time
import urllib.request
import math
print(sys.getsizeof(24)) #获取对象占用的内存大小
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))
print(time.time()) #输出的时间戳
print(time.localtime(time.time())) #转成本地时间
print(urllib.request.urlopen('http://www.baidu.com').read()) #可以爬取网站
print(math.pi) #输出圆周率
```





## 第三方模块的安装及使用

- 第三方模块安装： `pip install 模块名` ，使用： `import 模块名` 。

  ```python
  #先安装第三方模块，在命令行窗口执行 pip install schedule
  import schedule
  import time
  def job():
      print('打印一句话')
  schedule.every(3).seconds.do(job) #每3秒执行一下job函数，可以做一个定时任务
  while True:
      schedule.run_pending()
      time.sleep(1) #休眠1秒
  ```

python入门到精通第十四章

## 封装

**面向对象的三大特征**

- 封装：提高程序的安全性
  - 将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。无需关心方法内部的具体实现细节，从而隔离了复杂难度。
  - 在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个“`_`”。
- 继承：提高代码的复用性。
- 多态：提高程序的可扩展性和可维护性。



```python
class Car: # 封装
    def __init__(self,brand):
        self.brand=brand
    def start(self):
        print('汽车已启动')

car=Car('宝马X5')
car.start()
print(car.brand)

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age # 年龄不希望在类的外面使用，所以前面加了两个_
    def show(self):
        print(self.name,self.__age) # 可以在类的内部使用__age
stu=Student('张三',23)
stu.show()
print(stu.name)
print(dir(stu)) # 列出对象的所有属性及方法
print(stu._Student__age) # 在类的外部可以通过 _Student__age 进行访问
```





## 继承

如果一个类没有继承任何类，则默认继承 `object` ，python 支持多继承，定义子类时，必须在其构造函数中调用父类的构造函数，语法格式 `class 子类名( 父类1,父类2... )` 。

```python
class Person(object): # Person继承object类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

class Student(Person): # Student 继承 Person 类
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no

class Teacher(Person): # Teacher 继承 Person 类
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear=teachofyear

stu=Student('张三',23,'1001')
teacher=Teacher('李四',31,10)

stu.info()
teacher.info()

class inherit(Student,Teacher): # 多继承，inherit 同时继承了 Student和Teacher类
    pass
```





## 方法重写

- 如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写；子类重写后的方法中可以通过 `super().xxx()` 调用父类中被重写的方法。

  ```python
  class Person(object): # Person继承object类
      def __init__(self,name,age):
          self.name=name
          self.age=age
      def info(self):
          print('姓名：{0}，年龄：{1}'.format(self.name,self.age))
  
  class Student(Person): # 定义的子类 Student 继承 Person 类
      def __init__(self,name,age,score):
          super().__init__(name,age)
          self.score=score
      def info(self):
          super().info()
          print('分数：{0}'.format(self.score))
  
  stu=Student('张三',23,'1001')
  stu.info()
  ```

  



## object类

- **object** 类是所有类的父类，因此素有类都有 **object** 类的属性和方法，内置函数 `dir()` 可以查看指定对象所有的属性； **object** 有一个 `__str__()` 方法，用于返回一个对于“对象的描述”，对应于内置函数 `str()` 经常用于 `print()` 方法，帮我们查看对象的信息，所以我们经常会对 `__str__()` 进行重写。

  ```python
  class Student:
      def __init__(self,name,age):
          self.name=name
          self.age=age
      def __str__(self):
          return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)
  
  stu=Student('张三',21)
  print(dir(stu))
  print(stu) # 默认会调用 __str__() 这样的方法
  print(type(stu))
  ```

  



## 多态

- 多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法。

  ```python
  class Animal(object):
      def eat(self):
          print('动物要吃东西')
  class Dog(Animal):
      def eat(self):
          print('狗吃肉')
  class Cat(Animal):
      def eat(self):
          print('猫吃鱼')
  
  class Person():
      def eat(self):
          print('人吃五谷杂粮')
  
  # def fun(animal): # 定义一个函数
  #     animal.eat()
  def fun(animal):
      animal.eat()
  
  
  # 调用函数
  fun(Cat())
  fun(Dog())
  fun(Animal())
  print('--------------')
  fun(Person())
  ```

- 静态语言和动态语言关于多态的区别

  - 静态语言实现多态的三个必要条件： `继承` 、 `方法重写` 、 `父类引用指向子类对象` 。
  - 动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来像鸭子、游泳起来像鸭子，那么这只鸟可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为。





## 特殊方法和特殊属性

  <table>
      <tr>
          <td></td>
          <td>名称</td>
          <td>特殊方法</td>
      </tr>
      <tr>
          <td>特殊属性</td>
          <td>__dict__</td>
          <td>获得类对象或实例对象所绑定的所有属性和方法的字典</td>
      </tr>
  	<tr>
          <td rowspan="5">特殊方法</td>
      </tr>
  	<tr>
          <td>__len__()</td>
          <td>通过重写__len__()方法，让内置函数len()的参数可以是自定义类型</td>
      </tr>
      <tr>
          <td>__add__()</td>
          <td>通过重写__add__()方法，可以使用自定义对象具有“+”功能</td>
      </tr>
      <tr>
          <td>__new__()</td>
          <td>用于创建对象</td>
      </tr>
      <tr>
          <td>__init__()</td>
          <td>对创建的对象进行初始化</td>      
      </tr>
  </table>




- 特殊属性

  ```python
  class A:
      pass
  class B:
      pass
  class C(A,B):
      def __init__(self,name,age):
          self.name=name
          self.age=age
  class D(A):
      pass
  
  # 创建C类的对象
  x=C('tom',17)
  print(x.__dict__) # 实例对象的属性字典
  print(C.__dict__) # 类对象可以查看到属性和方法
  
  print(x.__class__) # <class '__main__.C'> 输出了对象所属的类
  print(C.__bases__) # C类的父类类型的元素
  print(C.__base__) # 类的基类
  print(C.__mro__) # 查看类的层次结构
  print(A.__subclasses__()) # 子类的列表
  ```

- 特殊方法

  `__add__()` 和 `__len__()` 特殊方法

  ```python
  a=20
  b=100
  c=a+b # 两个整数类型的对象的相加
  d=a.__add__(b)
  
  print(c)
  print(d)
  
  class Student:
      def __init__(self,name):
          self.name=name
      def __add__(self, other):
          return self.name+other.name # 可以实现2个对象的相加
      def __len__(self):
          return len(self.name) # 可以获取对象的长度
  
  stu1=Student('张三')
  stu2=Student('李四')
  
  s=stu1+stu2 # 实现了两个对象的加法运算（因为在 Student 类中，编写 __add__() 特殊方法）
  print(s)
  s=stu1.__add__(stu2)
  print(s)
  
  lst=[11,22,33,44]
  print(len(lst)) # len是内置函数的len
  print(lst.__len__()) # 和上面的结果一样
  print(len(stu1)) # 输出 stu1 的长度
  ```

  `__init__()` 和 `__new__()` 特殊方法

  ```python
  class Person(object):
      def __new__(cls, *args, **kwargs): # 创建对象的方法
          print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))
          obj=super().__new__(cls)
          print('创建的对象的id为：{0}'.format(id(obj)))
          return obj
      def __init__(self,name,age): # 初始化方法
          print('__init__被调用了，self的id值为：{0}'.format(id(self)))
          self.name=name
          self.age=age
  
  print('object这个类对象的id为：{0}'.format(id(object)))
  print('Person这个类对象的id为：{0}'.format(id(Person)))
  
  # 创建Person类的实例对象
  p1=Person('张三',18)
  print('p1这个Person类的实例对象的id为:{0}'.format(id(p1)))
  ```



类的浅拷贝与深拷贝

- 变量的赋值操作： 只是形成两个变量，实际上还是指向同一个对象。

  ```python
  class CPU:
      pass
  class Disk:
      pass
  class Computer:
      def __init__(self,cpu,disk):
          self.cpu=cpu
          self.disk=disk
  
  # （1）变量的赋值
  cpu1=CPU()
  cpu2=cpu1
  print(cpu1,id(cpu1))
  print(cpu2,id(cpu2)) # cup1和cpu2指向同一块内存地址
  ```

  

- 浅拷贝：python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象。

  ```python
  #（2）类的浅拷贝
  disk=Disk() #创建一个硬盘类的对象
  computer=Computer(cpu1,disk) #创建一个计算机类的对象
  
  #浅拷贝
  import copy
  print(disk)
  computer2=copy.copy(computer)
  print(computer,computer.cpu,computer.disk)
  print(computer2,computer2.cpu,computer2.disk) #浅拷贝 对象包含的子对象不会拷贝
  ```

  

- 深拷贝： 使用 `copy` 模块的 `deepcopy` 函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。

  ```python
  #深拷贝
  computer3=copy.deepcopy(computer)
  print(computer,computer.cpu,computer.disk)
  print(computer3,computer3.cpu,computer3.disk) #深拷贝的子对象也会拷贝一份
  ```

python入门到精通第十三章

## 两大编程思想

编程语言分为 **面向过程** 和 **面向对象** 两种

<table>
    <tr>
    	<td></td>
        <td>面向过程</td>
        <td>面向对象</td>
    </tr>
    <tr>
    	<td>区别</td>
    	<td>事务比较简单，可以用线性的思维去解决</td>
    	<td>事务比较复杂，使用简单的线性思维无法解决</td>
    </tr>
    <tr>
    	<td>共同点</td>
    	<td colspan="2">面向过程和面向对象都是解决实际问题的一种思维方式</td>
    </tr>
    <tr>
    	<td></td>
        <td colspan="2">二者相辅相成，并不是对立的<br/>解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间的复杂关系，方便我们分析整个系统：具体到微观操作，仍然使用面向过程方式来处理</td>
    </tr>
</table>



## 类和对象的创建

类是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质，不同的 **数据类型** 属于不同的 **类** 。int类之下包含相似的不同个例，这个个例专业属于就是 **实例** 或 **对象**。python中的一切皆对象。

```python
print(type(25)) # <class 'int'> 这些都属于int类，类里面的数值25，97，356这些称为对象或者实例
print(type(97)) # <class 'int'>
print(type(356)) # <class 'int'>
```



### 类的创建

类是由 **类属性** 、 **实例方法** 、 **静态方法** 、 **类方法** 组成。

```python
class Student: # Student为类的名称(类名)，由一个单词或多个单词组成，规范：每个单词的首字母大写，其余的小写，
    native_pace='北京' # 直接写在类里的变量，称为类属性。
    def __init__(self,name,age): # 初始化方法 也叫 构造方法
        self.name=name # self.name称为实例属性，进行了赋值操作，将局部变量的name的值赋值给实例属性
        self.age=age

    def info(self): # 实例方法 在类之外定义的称为函数，在类之内定义的称为方法
        print('我叫',self.name,'年龄是',self.age)
    @staticmethod # 静态方法
    def method(): # 在静态方法里不允许使用self
        print('我使用了@staticmethod修饰，所以我是静态方法')
    @classmethod # 类方法
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
print(id(Student)) # 类对象 这个是Student类的地址
print(type(Student))
print(Student)
```



### 对象的创建

对象的创建又称为类的实例化，有了实例，就可以调用类中的内容。语法是 `实例名=类名()`。

```python
# 上面已经创建好Student类，现在创建Student类的对象
stu1=Student('张三',23)
print(id(stu1)) # 实例对象 这个是Student类型的对象的地址
print(type(stu1))
print(stu1) # 输出对象值的时候，实际输出的是对象的十六进制的内存地址
stu1.info() # 第一种调用方式：对象名.方法名()
print(stu1.name) # 可以调用实例属性
print(stu1.age)
Student.info(stu1) # 第二种调用方式：类名.方法名(类的对象) 类的对象就是方法定义处的self
```



## 类属性、类方法与静态方法

- 类属性：类中方法外的变量称为属性，被该类的所有对象所共享。

  ```python
  print(Student.native_pace)
  stu1=Student('张三',29)
  stu2=Student('李四',23)
  print(stu1.native_pace)
  print(stu2.native_pace)
  Student.native_pace='天津' # native_pace属性是被stu1和stu2共享的
  print(stu1.native_pace)
  print(stu2.native_pace)
  ```

- 类方法：使用 `@calssmethod` 修饰的方法，使用类名直接访问的方法。

  ```python
  Student.cm()
  ```

- 静态方法：使用 `@staticmethod` 修饰的方法，使用类名直接访问的方法。

  ```python
  Student.method()
  ```

- Python是动态语言，在创建对象之后，可以动态地绑定属性和方法

  ```python
  class Student:
      def __init__(self,name,age): # name和age是所有Student类对象都可以使用的
          self.name=name
          self.age=age
      def eat(self):
          print(self.name+'在吃饭')
  stu1=Student('张三',23) # 创建Student类对象
  stu2=Student('李四',30)
  stu2.gender='男' # 给stu2动态绑定gender属性，只适用于当前绑定的属性
  print(stu1.name,stu1.age)
  print(stu2.name,stu2.age,stu2.gender)
  
  stu1.eat()
  stu2.eat()
  def show():
      print('定义类之外的称为函数')
  stu1.show=show() # 动态绑定方法
  stu1.show
  # stu2.show # 因为sut2没有绑定show方法，所以会报错
  ```

	面向过程	面向对象
区别	事务比较简单，可以用线性的思维去解决	事务比较复杂，使用简单的线性思维无法解决
共同点	面向过程和面向对象都是解决实际问题的一种思维方式
	二者相辅相成，并不是对立的解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间的复杂关系，方便我们分析整个系统：具体到微观操作，仍然使用面向过程方式来处理

需求分析

编码格式介绍

什么叫模块

封装

两大编程思想