python学习笔记

今日内容概要

• 面向对象前戏
• 编程思想
• 类与对象的概念
• 类与对象的创建
• 对象的实例化方法(独有数据)

今日内容详细

面向对象前戏

案例: 人狗大战

'''推导步骤1: 直接手写字典模拟一个个人和狗'''

person1 = {  # 使用字典模拟人
    'name': 'jason',
    'p_type': '猛男',
    'attack_val': 800,
    'life_val': 2000
}
person2 = {  # 使用字典模拟人
    'name': '慢男',
    'p_type': '闷骚',
    'attack_val': 100,
    'life_val': 1200
}
dog1 = {  # 使用字典模拟狗
    'name': '小黑狗',
    'd_type': '泰迪',
    'attack_val': 50,
    'life_val': 800
}
dog2 = {  # 使用字典模拟狗
    'name': '小舔狗',
    'd_type': '比特',
    'attack_val': 800,
    'life_val': 8000
}

"""推导步骤2: 由于定义人和狗的字典基本不变 但是在很多地方又需要反复使用 所以封装成函数"""

def get_person(name, gender, age, p_type, attack_val, life_val):
    """
    专用用于产生用户字典(创造人)
    :param name: 姓名
    :param gender: 性别
    :param age: 年龄
    :param d_type: 类型
    :param attack_val:攻击力
    :param life_val: 生命值
    :return: 人的字典(人)
    """
    person_obj = {
        'name': name,
        'gender': gender,
        'age': age,
        'p_type': p_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return person_obj
p1 = get_person('jason', 'male', 18, '猛男', 8000, 80000)
p2 = get_person('kevin', 'female', 28, '淑女', 10, 80)

def get_dog(name, d_type, attack_val, life_val):
    """
    专门用于产生狗字典(狗)
    :param name: 狗的名字
    :param d_type: 狗的类型
    :param attack_val: 狗的攻击力
    :param life_val: 狗的生命值
    :return: 狗的字典(狗)
    """
    dog_obj = {
        'name': name,
        'd_type': d_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return dog_obj
d1 = get_dog('小黄狗','中华田园犬',800, 5000)
d2 = get_dog('小奶狗','哈士奇',100, 200)

"""推导步骤3: 让人和狗具备攻击的能力 本质其实就是定义两个函数供人和狗调用"""

def person_attack(person_obj, dog_obj):
    """
    专用提供给人调用 攻击狗
    :param person_obj: 传人数据(字典)
    :param dog_obj: 传狗数据(字典)
    """
    print('即将被攻击的狗:%s 当前血量:%s' % (dog_obj.get('name'), dog_obj.get('life_val')))  # 先展示当前狗的状态
dog_obj['life_val'] -= person_obj.get('attack_val')  # 人锤狗 直接用狗的生命值减去人的攻击力
print('人:%s 锤了 狗:%s 狗掉血:%s 剩余血量:%s' % (person_obj.get('name'), dog_obj.get('name'), person_obj.get('attack_val'), dog_obj.get('life_val')))

def dog_attack(dog_obj, person_obj):
    """
    专用提供给狗调用 攻击人
    :param dog_obj: 传狗数据(字典)
    :param person_obj: 传人数据(字典)
    """
    print('即将被攻击的人:%s 当前血量:%s' % (person_obj.get('name'), person_obj.get('life_val')))  # 先展示当前人的状态
person_obj['life_val'] -= dog_obj.get('attack_val')  # 狗咬人 直接用人的生命值减去狗的攻击力
print('狗:%s 咬了 人:%s 人掉血:%s 剩余血量:%s' % (dog_obj.get('name'), person_obj.get('name'), dog_obj.get('attack_val'), person_obj.get('life_val')))

# 调用产生人和狗的函数
p1 = get_person('jason', 'male', 18, '猛男', 8000, 90000)
p2 = get_person('kevin', 'female', 28, '淑女', 10, 200)
d1 = get_dog('小黄狗', '恶霸犬', 800, 8000)
d2 = get_dog('小黑狗', '巴哥犬', 200, 500)
# 调用攻击彼此的函数
person_attack(p1, d1)
dog_attack(d2, p2)


# 代码优化
有一个问题：人和狗攻击的函数，可以被任意调用
人可以调用狗攻击的功能，狗也可以调用人攻击的功能

"""推导步骤4: 人和狗攻击乱套"""
person_attack(d2, p1)
dog_attack(p2, d1)

"""推导步骤5: 人跟人攻击狗的函数绑定 狗跟狗攻击人的函数绑定
我们定义的函数默认情况下都是可以被任意调用的 但是现在我们想实现定义的函数只有特定的东西才可以调用
"""

def get_person(name, gender, age, p_type, attack_val, life_val):
    """
    专用用于产生用户字典(创造人)
    :param name: 姓名
    :param gender: 性别
    :param age: 年龄
    :param d_type: 类型
    :param attack_val:攻击力
    :param life_val: 生命值
    :return: 人的字典(人)
    """
    def person_attack(person_obj, dog_obj):
        """
        专用提供给人调用 攻击狗
        :param person_obj: 传人数据(字典)
        :param dog_obj: 传狗数据(字典)
        """
        print('即将被攻击的狗:%s 当前血量:%s' % (dog_obj.get('name'), dog_obj.get('life_val')))  # 先展示当前狗的状态
        dog_obj['life_val'] -= person_obj.get('attack_val')  # 人锤狗 直接用狗的生命值减去人的攻击力
        print('人:%s 锤了 狗:%s 狗掉血:%s 剩余血量:%s' % (
            person_obj.get('name'), dog_obj.get('name'), person_obj.get('attack_val'), dog_obj.get('life_val')))
    person_obj = {
        'name': name,
        'gender': gender,
        'age': age,
        'p_type': p_type,
        'attack_val': attack_val,
        'life_val': life_val,
        'person_attack': person_attack
    }
    return person_obj

def get_dog(name, d_type, attack_val, life_val):
    """
    专门用于产生狗字典(狗)
    :param name: 狗的名字
    :param d_type: 狗的类型
    :param attack_val: 狗的攻击力
    :param life_val: 狗的生命值
    :return: 狗的字典(狗)
    """
    def dog_attack(dog_obj, person_obj):
        """
        专用提供给狗调用 攻击人
        :param dog_obj: 传狗数据(字典)
        :param person_obj: 传人数据(字典)
        """
        print('即将被攻击的人:%s 当前血量:%s' % (person_obj.get('name'), person_obj.get('life_val')))  # 先展示当前人的状态
        person_obj['life_val'] -= dog_obj.get('attack_val')  # 狗咬人 直接用人的生命值减去狗的攻击力
        print('狗:%s 咬了 人:%s 人掉血:%s 剩余血量:%s' % (
            dog_obj.get('name'), person_obj.get('name'), dog_obj.get('attack_val'), person_obj.get('life_val')))
    dog_obj = {
        'name': name,
        'd_type': d_type,
        'attack_val': attack_val,
        'life_val': life_val,
        'dog_attack': dog_attack
    }
    return dog_obj
d1 = get_dog('小黄狗', '恶霸犬', 800, 8000)
p1 = get_person('jason', 'male', 18, '猛男', 8000, 90000)
p1.get('person_attack')(p1, d1)  # 即将被攻击的狗:小黄狗 当前血量:8000 人:jason 锤了 狗:小黄狗 狗掉血:8000 剩余血量:0

# 总结

将人的数据跟人的功能绑定到一起
	只有人可以调用人的功能
将狗的数据跟狗的功能绑定到一起
	只有狗可以调用狗的功能
我们将数据与功能绑定到一起的操作起名为:'面向对象编程'
 
本质:将特定的数据与特定的功能绑定到一起 将来只能彼此相互使用

编程思想

	面向过程	面向对象
区别	事物比较简单，可以用线性思维去解决	事务比较复杂，使用简单的线性思维无法解决
相当于	相当于让你给出一个问题的具体解决方案	当于让你创造出一些事物之后不用你管

共同点: 面向过程和面向对象都是解决实际问题的一种思维方式

二者相辅相成，并不是对立的

解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的关系，

方便我们分析整个系统：具体到微观操作，仍然使用面向过程方式来处理

面向过程编程
	截止昨天 我们所编写的代码都是面向过程编程
	过程其实就是流程 面向过程编程其实就是在执行一系列的流程
	eg:	注册功能   登录功能   冻结账户  ...
    就是按照指定的步骤依次执行 最终就可以得到想要的结果
    
面向对象编程
	核心就是'对象'二字
    	对象其实就是一个容器 里面将数据和功能绑定到了一起
	eg: 游戏人物 ...
    只负责创造出该人物以及该人物具备的功能 至于后续战绩如何无人知晓

类与对象的概念

• 1.类:多个对象相同的数据和功能的结合体

  数据被称为属性

  功能被称为方法

• 2.对象:数据与功能的结合体

  对象是由类创建出来的一个具体的存在，可以直接使用。

  由哪一个类创建出来的对象，就拥有在哪一个类中定义的属性和方法。

  在程序开发中，应该先有类，再有对象。

类主要用于记录多个对象相同的数据和功能

对象则用于记录多个对象不同的数据和功能

ps:在面向对象编程中 类仅仅是用于节省代码 对象才是核心

类与对象的创建

在程序开发中，要设计一个类，通常需要满足以下三个要素：

1.类名：这类事物的名字，满足大驼峰命名法

2.属性：这类事物具有什么样的特征

3.方法：这类事物具有什么样的行为

• 大驼峰命名法：CapWords

每一个单词的首字母大写，单词与单词之间没有下划线

• 类名的确定

名词提炼法，分析整个业务流程出现的名词，通常就是要找到的类。

• 属性和方法的确定

对对象的特征描述，通常可以定义为属性。

对象具有的行为（动词），通常可以定义为方法。

提示：需求中没有涉及的属性或者方法在设计类时，不需要考虑

在现实生活中理论是应该先有一个个的个体(对象)再有一个个的群体(类)
在编程世界中必须要先有类才能产生对象

创建类的完整语法
class People:
    # 学生对象公共的数据
    # 学生对象公共的方法
    
1.class是定义类的关键字
2.People是类的名字
	类名的命名跟变量名一致 并且推荐首字母大写(为了更好的区分)
3.类体代码
	公共的数据\公共的方法
ps:类体代码在类定义阶段就会执行!!!
    

# 查看名称空间的方法
print(Student.__dict__)  # 使用该方法查看名称空间 可以看成是一个字典
print(Student.__dict__['school'])  # 使用字典的取值方式获取名字
print(Student.__dict__.get('choice_course'))  # 使用字典的取值方式获取名字
'''在面向对象编程中 想要获取名称空间中的名字 可以采用句点符'''
print(Student.school)
print(Student.choice_course)
'''类实例化产生对象>>>: 类名加括号'''
stu1 = Student()
stu2 = Student()
print(stu1.school)
print(stu2.school)
print(stu1)  # <__main__.Student object at 0x000001D923B04A60>
print(stu2)  # <__main__.Student object at 0x0000025E8A48F130>
print(stu1.__dict__, stu2.__dict__)  # {} {}
print(stu1.school)
print(stu2.school)
print(stu1.choice_course)
print(stu2.choice_course)
Student.school = '北京大学'  # 修改school键对应的值
print(stu1.school)
print(stu2.school)
"""
我们习惯将类或者对象句点符后面的东西称为属性名或者方法名
"""

对象的实例化方法(独有数据)

# 学生类
class Student:
    # 学生对象的公共数据
    school = '清华大学'
    
    # 学生对象的公共方法
    def choice_course(self):
        print('正在选课')
        
 '''推导思路1: 直接利用__dict__方法朝字典添加键值对'''

obj1 = Student()
obj1.__dict__['name'] = 'jason'  # 等价于 obj1.name = 'jason'
obj1.__dict__['age'] = 18  # 等价于 obj1.age = 18
obj1.__dict__['gender'] = 'male'  # ...
print(obj1.name)
print(obj1.age)
print(obj1.gender)
print(obj1.school)
obj2 = Student()
obj2.__dict__['name'] = 'kevin'
obj2.__dict__['age'] = 28
obj2.__dict__['gender'] = 'female'
print(obj2.name)
print(obj2.age)
print(obj2.gender)
print(obj2.school)

'''推导思路2: 将添加独有数据的代码封装成函数'''

def init(obj,name,age,gender):
    obj.__dict__['name'] = name
    obj.__dict__['age'] = age
    obj.__dict__['gender'] = gender
stu1 = Student()
stu2 = Student()
init(stu1,'jason',18,'male')
init(stu2, 'kevin',28,'female')
print(stu1.__dict__)  # {'name': 'jason', 'age': 18, 'gender': 'male'}
print(stu2.__dict__)  # {'name': 'kevin', 'age': 28, 'gender': 'female'}

'''推导思路3: init函数是专用给学生对象创建独有的数据 其他对象不能调用>>>:面向对象思想   将数据和功能整合到一起
将函数封装到学生类中 这样只有学生类产生的对象才有资格访问
'''

class Student:
    """
    1.先产生一个空对象
    2.自动调用类里面的__init__方法 将产生的空对象当成第一个参数传入
    3.将产生的对象返回出去
    """
    def __init__(self, name, age, gender):
        self.name = name  # obj.__dict__['name'] = name
        self.age = age  # obj.__dict__['age'] = age
        self.gender = gender  # obj.__dict__['gender'] = gender
        # 左右两边的名字虽然一样 但是意思不一样 左边的其实是字典的键 右边的其实是实参

    # 学生对象公共的数据
    school = '清华大学'

    # 学生对象公共的方法
    def choice_course(self):
        print('正在选课')

# stu1 = Student()
# print(stu1.__dict__)
# Student.__init__(stu1, 'jason', 18, 'male')
# print(stu1.__dict__)
# print(stu1.name)

stu1 = Student('jason', 18, 'male')
print(stu1.__dict__)  # {'name': 'jason', 'age': 18, 'gender': 'male'}
stu2 = Student('kevin', 28, 'female')
print(stu2.__dict__)  # {'name': 'kevin', 'age': 28, 'gender': 'female'}