python面向对象-day01-面向对象的思想

面向对象的思想

1. 核心思想:
面向对象,是一种编程思想. 强调的是实现任何功能, 找一个对象来帮我们完成, 只需要关注完成
功能的结果.
2. 区分面向对象和面向过程
   面向过程: 注重的是步骤
   面向对象: 注重的是对象和完成功能的结果, 不用关注步骤 ,简化开发, 实现代码的重用.
3. 面向对象的特点和特征
特点:
1. 符合人们思考习惯
2. 将程序原从执行者转换成指挥者
3. 将复杂的事情简单化

特征: 封装,继承,多态

万物皆对象.

类的使用语法

1. 概念
在面向对象的概念中有两个重要的概念: 类 对象
并且:
    对象 由 类创建得到

2. 类的概念
类可以简单理解为 创建对象的模具.

类概念: 类 是用于对同一类事物 共有的特征和功能的 描述(抽象)

3. 语法:
中文描述女朋友类:
    外在特征: 性别,脸型,身高,体重
    内在功能: 做饭,洗衣服,花钱

类描述事物:
    外在特征:  属性 (在类中的变量) ---> 存储数据,方便后面使用
    内在功能:  方法 (在类中的函数) ---> 封装重复代码块

语法:
    class 类名:
        # 属性
        # 方法
        def 方法名1(self):
            #方法体
            pass
        def 方法名2(self):
            #方法体
            pass
    备注:
        a. 通过关键字 class 声明一个类
        b. 每一个类 取一个类名(标识符), 建议类名采用大驼峰命名
        c. 方法定义到类名的下面,缩进的里面. 方法的定义和函数差不多, 只是
        第一个形参用self占位.

4. 创建对象
对象: 实实在在的一个事物(实体) 被称为对象
对象: 由类(抽象)创建得到的, 这个过程被 实例 化

语法:
    变量名 = 类名()  # 创建对象(实例化对象)

备注:
    1, 真正创建对象的代码: 类名(), 但是 往往需要使用一个变量存储 创建的对象
    2, 使用对象 通过 对象的 "变量名" 使用对象
    3, 每次创建的对象的 地址是不一样的(每次创建的都是新对象)

设计一个类: 手机类
特征(属性):
功能(方法): 打电话,发短信,上网,看电影

class Phone:
    # 方法
    def call(self):
        print("打电话~~")

    def sendMsg(self):
        print("发短信~~")

    def surfInternet(self):
        print("上网~~")

    def movie(self):
        print("看电影~~")
print(id(Phone))

# 创建对象
iphone6 = Phone()
iphone7 = Phone()

# 使用对象
print(iphone6)
print(iphone7)

# 使用对象上的方法
iphone6.call()
iphone6.call()  
iphone6.sendMsg()  
iphone6.surfInternet()  

对象上属性的操作

1. 前提: 先创建对象
对象变量=类名()  # 没有类就自己定义一个类

2. 使用对象(就是使用对象上的属性和方法)
对象.成员

3. 使用对象上的属性
a. 添加属性
    对象.属性名 = 值  # 属性名 类似于变量名 存储数据
b. 查看属性
    print(对象.属性名)
c. 修改属性
    对象.属性名 = 新值
d. 删除属性
    del 对象.属性名
e. 判断是否有某个属性(attribute)
    hasattr(对象,属性名) ---> bool

4. 对象上方法的使用
对象.方法名()

定义类

class Phone:
	def call(self):
		print("打电话~")

	def sendMsg(self):
		print("发短信~")
#1. 前提: 先创建对象
iphone6 = Phone()

# 2. 操作对象上的属性
# 添加属性
iphone6.color = "土豪金"
iphone6.size = "6寸"  # 尺寸
iphone6.price = 2000  # 价格
# 查看
print(iphone6.color)
print(iphone6.size)
print(iphone6.price)
# 修改属性
iphone6.color = "白色"
print(iphone6.color)
# 删除属性
del iphone6.size
# print(iphone6.size) # 'Phone' object has no attribute 'size' 手机对象没有属性 size
# 判断
print(hasattr(iphone6, "size")) # 实参 实际的数据
print(hasattr(iphone6, "price"))


# 对象上方法的调用
iphone6.call()
iphone6.call()
iphone6.sendMsg()

self是什么

1. self的概念
a. 通过对象 调用对象上的方法, python解释器自动将调用方法的那个对象作为方法的第一个
参数传递给方法
b. 所以我们定义方法的时候第一个参数必须写self占位, 用于接收自动传入的对象
c. self到底是什么?  哪个对象调用我,self就是那个对象

2. 目的: 方便我们在方法中使用对象上的属性(数据)

定义一个类: 学生类
定义一个方法: 跑步的方法

class Student:
    # 方法
    def run(self): # self 谁调用我,我就是谁
        # print(id(self))
        print(f"{self.name}跑步锻炼身体~~~")

# 创建俩学生对象,添加属性
zhangfei = Student()
zhangfei.name = "张飞"
zhangfei.age = 18
zhangfei.run()
# print(id(zhangfei))

lisi = Student()
lisi.name = "李四"
lisi.age = 19
lisi.run()
# print(id(lisi))

“”"

初始化方法的使用

1. 初始化方法__init__()概念
a. 初始化方法也是在类中定义的一个方法, 第一个参数也是self
b. 特殊性
    1. 名字固定 __init__
    2. 调用时机: 创建对象的时候自动调用
c. 作用: 在初始化方法中 通过self绑定(添加)初始属性
        self.属性名 = 值

2. 具体语法:
class 类名:
    def __init__(self,形参1,形参2):
        self.属性1 = 形参1
        self.属性2 = 形参2

# 创建对象的时候传递给 __init__方法实参
类名(实参1,实参2)
类名(形参1=实参1,形参2=实参2)

定义一个类: 学生类
定义一个方法: 跑步的方法

class Student:
    def __init__(self, name, age):
        print("初始化方法,自动调用")
        self.name = name
        self.age = age

    # 方法
    def run(self):  # self 谁调用我,我就是谁
        print(f"{self.name}跑步锻炼身体~~~")


# 创建学生对象,添加属性
zhangfei = Student("张飞", 18)
# 初始化就自带了属性
# print(zhangfei.name)
# print(zhangfei.age)
zhangfei.run()
# 创建李四对象
lisi = Student(age=19, name="李四")
lisi.run()

__str__方法的使用

1. 说明
a. 默认通过print(对象) 输出的对象的描述信息 仅仅是对象的地址
b. 我们可以在类中 定义一个方法 __str__(self)
    特殊:
        1. 打印对象的时候自动调用
        2. 在__str__() 方法中返回对象的自定义的描述信息

class Student:
    def __init__(self,name,age):
        """初始化方法,绑定初始属性"""
        self.name = name
        self.age = age
        
    def run(self):
        print(f"{self.name},今年{self.age},在跑步锻炼身体~~")
        
    # 定义 __str__方法
    def __str__(self): # TypeError: __str__ returned non-string (type NoneType)
        return f"<学生{self.name}对象,内存地址{id(self)}>"  # hex(id(self))
        
# 创建对象
zhangfei = Student(name="张飞",age=18)
#zhangfei.run()
print(zhangfei)

lisi = Student(name="李四",age=18)
print(lisi)

总结

1. 编程思想
   核心思想: 找个对象帮我实现功能,关注实现功能的结果

   三个特征: 封装,继承,多态

   特点:
   1. 符合人们思考习惯
   2. 将程序员从执行者转换成指挥者
   3. 将复杂的事情简单化(代码简单, 不考虑具体如何实现)

2. 面向对象的语法
   类:

    class 类名:  # 类名采用大驼峰
    	def __init__(self,形参1,形参2):
            # 绑定初始属性, 创建对象的时候自动执行
            self.属性名1 = 形参1
            self.属性名2 = 形参2
            
        # 方法
        def 方法名(self,形参1...):
            # 方法体
            pass
    
    	# __str__
        def __str__(self):
            # 返回对象的定义描述信息
            return "字符串的描述信息"

对象:
对象变量=类名(实参1,实参2)
对象变量=类名(形参1=实参1,形参2=实参2)
使用对象
属性:
对象.属性名 # 查看
对象.属性名 = 值 # 添加
对象.旧属性名 = 新值 # 修改
del 对象.属性名 # 删除

方法:
    对象.方法名([实参]) # 实参从形参的第二个参数开始传递