python学习之第七天

知识点目录
1.面向对象和面向过程的语言分别有哪些
2.面向对象的特点
3.面向过程的特点
4.OO.OOP.OOP.OOD的含义
5.什么是类
6.什么是对象
7.object的含义
8.声明类的关键字是哪个
9.self的含义
10.类和对象的关系
11.构造函数的特点以及函数名是什么
12.析构函数的特点以及函数名是什么
13.新式类和经典类的区别是什么
14.什么是魔术方法
15.常用的魔术方法(至少知道5个)
16.python中的私有性怎么表示(_和__来区分)
17.如何动态添加属性
18.如何安全的声明属性?(基本格式说出来)
19.继承的特点
20.如何重写父类方法
21.通过super()调用父类方法
22.哪些属性和方法可以被继承
23.综合练习

1.面向对象和面向过程的语言分别有哪些

面向过程 -C语言
面向对象 -python Java PHP C++ JS

2.面向对象的特点

1.继承
继承是实现软件复用的重要手段,实现继承的类被称为子类，被继承的类被称为父类。父类和子类的关系，是一种一般和特殊的关系。
2.封装
封装是面向对象的三大特征之一，它指的是将对象的状态信息隐藏在对象的内部，不允许外部程序直接访问对象的内部信息，只能通过该类所提供的方法来实现对内部信息的操作和访问
3.多态
相同类型的变量，调用同一方法是呈现出多种不同的行为特征，即为多态。

3.面向过程的特点

面向过程是一种以过程为中心的编程思想，其原理就是将问题分解成一个一个详细的步骤，然后通过函数实现每一个步骤，并依次调用
1.根据业务逻辑从上往下写代码
2.容易被初学者接受

4.OO.OOP.OOP.OOD的含义

OO=ObjectOriented = 面向对象
OOP= Programming =面向过程编程
OOA= Analyse=面向对象分析
OOD=Design = 面向对象设计

5.什么是类

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例

6.什么是对象

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

7.object的含义

所有类本质上都来自于object

object 超级父类/超类/基类

8.声明类的关键字是哪个

class

9.self的含义

self 当前类的对象

10.类和对象的关系

# 对象跟类的关系
# 1.对象是类的实例
# 2.类是对象的模板(封装)

class People(object):
name = ""
age = 0
sex = True
def eat(self):
print('人类会吃饭!')
def sleep(self):
print('开始睡觉')

# 创建对象(实例化对象)的格式
# 对象名 = 类名(初始化参数)
# 对象如何调属性? 打点
# 对象如何调方法? 打点
zhang_san = People()
zhang_san.name ="张三"
zhang_san.age = 20
zhang_san.sex = '男'

zhang_san.eat()
zhang_san.sleep()

11.构造函数的特点以及函数名是什么

class Student(object):
stu_num = 0
stu_phone = ''
stu_class = ''
# 类中的__init__就叫构造函数
#主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值
# 一般用于初始化对象的属性
def __init__(self, your_num, your_class):
# print('初始化学生属性')
self.stu_num = your_num
self.stu_class= your_class

12.析构函数的特点以及函数名是什么

# 析构函数,由系统自动调用且不能加参数
# 当对象即将被销毁的时候调用
# 当它之前加上死循环时不会执行析构函数
# python自带内存管理机制gc = GarbageCollection = 垃圾回收
# 如果系统检测到该对象无人使用时则自动进行销毁,会调用析构函数
# 手动进行销毁用del 也会调用析构函数
# 如del stu1
# def __del__(self):
#     print("调用了析构函数")

13.新式类和经典类的区别是什么

# 新式类和经典类的区别
# 1.写法不一样
# 2.新式类更符合OOP编程思想,统一了python中的类型机制
# 3.在多继承中,新式类采用了广度优先搜索,经典采用了深度优先搜索

# 经典类
class People:
pass

# 新式类
class Student(object):
pass

14.什么是魔术方法

# 魔术方法=MagicMethod
# 在类中形如__xxx__的方法就被称为魔术方法,因为这类方法都有特殊功能
# 常用的魔术方法有哪些?
# __str__  __unicode__  自己补充4个

class Student(object):
name = ""

def study(self):
print("正在学习")
# py3中 自定义打印对象时显示的内容
def __str__(self):
return f"当前对象的姓名为{self.name}"
# py2中 自定义打印对象时显示的内容
def __unicode__(self):
return f"当前对象的姓名为{self.name}"
stu1 = Student()
stu1.name = '张三'
stu1.study()
print(stu1)

15.python中常用的魔术方法(至少知道5个)

# py3中 自定义打印对象时显示的内容
def __str__(self):
return f"当前对象的姓名为{self.name}"
# py2中 自定义打印对象时显示的内容
def __unicode__(self):
return f"当前对象的姓名为{self.name}"

变量前后有双下划线
str
unicode
add(self, other) 实现一个加法

sub(self, other) 实现一个减法

mul(self, other) 实现一个乘法

int(self) 转换成整型

long(self) 转换成长整型

float(self) 转换成浮点型

complex(self) 转换成 复数型

16.python中的私有性怎么表示(_和__来区分)

# 为了保证属性安全
# 1.需要为每个属性创建两个方法get/set
# 2.应该把属性设置为私有属性(为了防止用户打点调属性)(在属性前加__变私有)
# python 中没有真正意义的私有,只是通过属性前加_或者__来区分
# 但是我们可以通过下面这两种方式强制修改访问
# 1._属性名   obj._属性名=值
# 2. __属性名  obj._类名__属性名=值

17.如何动态添加属性

#python 动态属性添加(仅对当前对象有用)
# 如给stu1添加个属性phone并赋予初值
# stu1.phone = 1008611

18.如何安全的声明属性?(基本格式说出来)

# 属性装饰器的作用
# 把set/get方法 变成相当于属性 对象打点调用这个属性

# 对于变量的访问和设置，我们可以使用get、set方法
class Student(object):
def __init__(self,name=""):
self.__name = name

def set_name(self,name):
self.__name = name

def get_name(self):
return self.__name

# 修改名字格式为
stu = Student()
stu.set_name("张三")

# 使用装饰器的写法
class Student(object):
def __init__(self,name=""):
self.__name = name

@property
def get_name(self):
return self.__name
@get_name.setter
def set_name(self,name):
self.__name = name
# 修改名字格式为
stu1 = Student()
stu1.set_name="张三"

# 这是个创建类的标准写法
class Student(object):
count = 0

# 构造函数
def __init__(self, name="", age=0, *args, **kwargs):
# 动态添加属性
self.__name = name
self.__age = age

@property  # 属性装饰器
def name(self): # get方法
return self.__name

@name.setter
def sname(self, new_name):# set方法
self.__name = new_name

@property
def age(self):
return self.__age

@age.setter
def age(self,new_age):
if not isinstance(new_age,int):
raise TypeError("类型不正确")
self.__age=new_age
stu1 = Student()
stu1.sname="张三"
print(stu1.name)

19.继承的特点

# calss 子类(父类):
#   pass
# 继承特点:
# 1.子类拥有父类的属性和方法
# 2.子类可以拥有自己的属性和方法
# 3.子类可以重写父类的方法
# self和super特点
# super:当前类的父类的对象
# self:当前类的对象

20.如何重写父类方法

看最后一个练习中

21.通过super()调用父类方法

super().父类的方法名

22.哪些属性和方法可以被继承

# 单继承:当前类只有一个父类

# 单继承第一个特点:子类可以拥有父类的所有属性和方法

# 什么时候用继承?
# 如果该类的属性和方法用得到,但是不够完善
# 则可以通过继承给该类扩展属性和功能

class A(object):
name = "张三"
_age = 0
__address = "河南郑州"

def hello(self):
pass

def _eat(self):
pass

def __sleep(self):
pass

class B(A):
pass

# 类外访问属性
# 1)常规属性对象可以直接打点使用
# 2)单下划线属性,打点调用不提示,但是可以正常使用
# 3)双下划线属性,打点调用不提示,且不能强制使用
# 可以通过  对象._类名__属性
# 类外访问方法
# 1)常规方法对象可以直接打点使用
# 2)单下划线方法,打点调用不提示,但是可以正常使用
# 3)双下划线方法,打点调用不提示,且不能强制使用
# 可以通过  对象._类名__方法

# 子类重写父类属性
# 1)常规属性会直接覆盖
# 2)单下划线属性会直接覆盖
# 3)双下划线属性不能覆盖
# 子类重写父类方法
# 1)常规方法会直接覆盖
# 2)单下划线方法会直接覆盖
# 3)双下划线方法不能覆盖

# 总结:双下划线属性和方法表示为私有(要求只能在类内使用,类外不能用)
# 但是,python限制没那么严格,可以通过上面访问属性和方法第3步这种方式强制使用(不推荐)

a = A()
print(a.name, a._age, a._A__address)

# 子类能够使用父类的哪些属性?
# 1.常规属性
# 2.单下划线属性    子类对象._属性
# 3.双下划线属性   子类对象._父类__属性名
# 子类能够使用父类的哪些方法?
# 1.常规方法
# 2.单下划线方法   子类对象._方法
# 3.双下划线方法  子类对象._父类__方法
b = B()
print(b.name, b._age, b._A__address)

# 如果子类访问一个自己没有的属性和方法,会怎么样?
# 1)先在本类中查找是否拥有该属性和方法
# 2)如果没有,查找父类中是否拥有该属性/方法
# 3)如果没有,继续向上查找
# 4)如果最后还是没有,则报错
print(b.phone)

# python明确规定,_和__属性和方法,类外理论上可以用,实际上做项目时代码中最好不要用

23.综合练习

# 综合练习
# 1. 创建People类和Student类。其中Student继承自People，People继承自Object
# 2. People中包含name,age等普通属性,_sex等单下划线属性,__address等双下划线属性
# 3. 在构造函数中进行初始化，想想哪些属性需要写set和get方法
# 4. People类拥有eat方法和sleep方法，调用时请输出 "People, ***,**岁在睡觉/吃饭"
# 创建p1对象，初始值为 张三,20,男,河南郑州
# p1调用eat和sleep方法，看输出什么

# 5. Student类包含stu_num, _stu_class, __stu_grade三个属性
# 在构造函数中进行相关初始化

# 6. Student类包含study,sleep方法
#     Student类重写父类sleep方法，当调用的时候输出 "People, ***,**岁在睡觉/吃饭" 和 "Student, ***级***号在学习"
# 7. 创建s1对象，初始值为李四,18,男，河南信阳
# 8. s1调用eat方法，看输出什么
# 9. s1调用sleep方法，看输出什么

class People(object):
def __init__(self, name='', age=0, sex="", address=""):
self.name = name
self.age = age
self._sex = sex
self.__address = address

@property
def get_adress(self):
return self.__address

@get_adress.setter
def set_adress(self, address):
self.__address = address

def eat(self):
print(f"People,{self.name} ,{self.age}岁在吃饭")

def sleep(self):
print(f"People, {self.name} ,{self.age}岁在睡觉")

p1 = People("张三", 20, "男", "河南郑州")
p1.eat()
p1.sleep()

class Student(People):
def __init__(self, name="", age=0, sex="", address="", stu_num=1003, stu_class="3班", stu_grade="三年级"):
super().__init__(name, age, sex, address)
self.stu_num = stu_num
self._stu_class = stu_class
self.__stu_grade = stu_grade

@property
def get_stu_grade(self):
return self.__stu_grade

@get_stu_grade.setter
def set_stu_grade(self, stu_grade):
self.__stu_grade = stu_grade

def study(self):
pass

def sleep(self):
super().sleep()
print(f"Student, {self.__stu_grade}{self._stu_class}级{self.stu_num}号在学习")

s1 = Student("李四", 18, "男", "河南信阳")
s1.eat()
s1.sleep()