标签：__ name Python self 面向对象 print age def

面向对象

编程范式

面向对象指的是一种编程范式；

编程范式：可以理解为一种编程方式，编程规范，编程模式

面向过程

面向过程编程：是一种以过程为核心的编程，主要是在解决一个问题的时候，将这个问题拆分成一个个小步骤完成并且拼接起来的就是面向过程。

面向对象

面向对象编程（object oriented programming ，简称OOP）：是一种以对象为核心的编程，面向对象在解决问题的时候是思考如何设计这个事情。

类和对象

在代码里面实行一个对象是通过类进行产生的；
类就相当于生活中的一个类别，一个比较抽象的概念。
对象就是一个通过类产生的一个拥有属性以及行为的实体，是对应类里面的一个个体
<先有类，再有对象>

函数是一系列的指令，完成特定的功能。变量是描述事物特征的东西，姑且叫信息。
类就是将变量信息和函数指令结合到一起的东西。变量表达类的特征（属性），函数表示类的功能（方法）。
对象是类的特例。犹如动物和人的关系。

类的定义

python中如何定义一个函数

# 定义
def 函数名(形参):
    函数体
# 调用
函数名(实参)

def func_1(name):
    return f'{name}是个超人'

print(func_1('伤心超人'))

python中定义类的语法：

class 类名:
   代码

类目的定义：使用驼峰式命名（大驼峰，每个单词的首字母大写）

定义类之后，执行代码，类里面的代码也会一起执行

定义再类中的变量称之为属性

class People:
    '''
    我是类文档
    就相当于类的说明书
    '''
    # 类属性  （所有对象共有的）
    height = 1.73
    weight = 200
    
# 实例化类
xs = People()
print(xs.weight)
# print(People.__dict__)

mj = People()
# 创建对象独有的属性,如果属性存在,则是修改属性值的操作
# 对象名.属性名 = 属性值
mj.weight = 90
mj.weight = 85
print(mj.weight)
# 使用对象.__dict__得到的是对象的属性
print(mj.__dict__)

# 修改类属性
# 类名.属性名 = 属性值
People.weight = 170
print(xs.weight)

# 动态的增加类属性
People.age = 20
print(xs.age)

--init--

class Animal:
    '''动物类'''
    # 初始化方法
    def __init__(self , name , age):
        # 属性
        self.age = age
        self.name = name
        
cat = Animal('da' , 1)
print(cat.name)
print(cat.age)

dog = Animal('xi',1.5)
print(dog.name)

self

class Animal:
    '''动物类'''

    # 初始化方法
    def __init__(self , name , age):
        # 属性
        self.age = age
        self.name = name

    def sleep(self):
        print(f'{self.name}睡觉')

cat = Animal('da' , 1)
dog = Animal('xi',1.5)
dog.sleep()
# print(cat.name)
# print(cat.age)
# print(dog.name)

封装

面向对象的三大特性：封装、继承、多态

封装：把功能代码，数据封装到某一个地方，需要的时候进行调用，提过程序的安全性。即把属性以及方法放到类中，通过类对象的操作或者调用。
通过封装，可以将一些不想给用户看到的功能进行隐藏，用户只能访问公开的功能，可以提高数据的安全性，也对后期的维护降低成本。
封装的好处：便于分工，便于复用，可扩展性强。

class People:
    '''人类'''
	height = 1.73
    weight = 200
    # 初始化方法
    def __init__(self , name , age , weight , job):
        self.name = name
        self.age = age
        self.weight = weight
        self.job = job

    def eat(self):
        print(f'{self.name}食べる')
        self.weight += 2

    def drink(self):
        print(f'{self.name} 飲みましょう。')
        self.weight += 0.5

    def run(self):
        print(f'{self.name} gogogo')
        self.weight -= 0.5

属性查找

在实例化属性中不同的对象，调用的属性不会产生影响互不干扰
对象寻找对应的属性，先从自身的实例属性开始查找，如果没有再从类属性查找。
不同的对象之间的实例属性是互不相通，都是独有的，两者无法相互访问

class Cat:
    # 类属性
    category = 'ねこ'
    age = 2
    # 初始化方法
    def __init__(self , name , category):
        # 实例属性
        self.name = name
        self.category = category

    def sleep(self):
        print(f'{self.name}睡觉')

mao1 = Cat('xiaopang' , '家猫')
mao1.age = 1
print(mao1.name)
print(mao1.category)

mao2 = Cat('dapang','流浪猫')
print(mao2.name)
print(mao2.age)	# 2
print(mao2.category)

属性隐藏

在类中定义一些数据或者功能不希望被外部访问到以及操作的时候，可以将数据以及功能进行隐藏。

在Python中没有绝对的隐藏，是可以通过一些方法对其进行访问的。

在类中的三种隐藏方法：

属性或者方法名前加上双下划线
使用property（）函数
@property 装饰的方法是获取属性值的方法， 被装饰的方法的名字会被作为属性名，方法名尽量跟隐藏的属性名一致
@属性名.setter 装饰的方法是设置属性值的方法
@属性名.deleter 装饰的方法是删除属性值的方法

属性或者方法名前加上双下划线

双下划线开头的属性，是对象的隐藏属性，隐藏属性可以在类内部进行访问

class People:

    def __init__(self , name , age):
        self.name = name
        self.__age = age    # 将age属性进行隐藏

    def __speak(self):
        print(f'我今年{self.__age}')

hh = People('haha', 24)
# print(hh.name)
# 获取对象属性
# print(hh.__dict__)
# 对象名称._类名__属性名
print(hh._People__age)
hh._People__speak()

使用property（）函数

property可以设置、获取，删除对象的某一个属性值，也可以限制用户对属性的设置与获取

# property 属性
# property(fget = None , fset = None , fdel = None , doc = None)
# fget = 是获取属性值的方法
# fset = 是设置属性值的方法
# fdel = 是删除属性值的方式

class People:

    def __init__(self , name , age):
        self.name = name
        self.__age = age    # 将age属性进行隐藏

    def speak(self):
        print(f'我今年{self.__age}')

    def get_age(self):
        print('===get=====')
        return self.__age

    def set_age(self , value):
        print('===set=====')
        self.__age = value

    def del_age(self):
        print('===del=====')
        del self.__age

    # 赋予对象属性权限 加上这句话，可以限制权限，而且对象进行操作很符合习惯
    age = property(fget=get_age , fset=set_age , fdel=del_age)

p2 = People('小小怪', 26)
print(p2.name)
# 获取对象属性
print(p2.__dict__)
# 对象名称._类名__属性名
print(p2._People__age)
# ac._People__speak() # 'People' object has no attribute '_People__speak'
# 因为本来就没有__speak，如果没有property，speak可以直接调用
print(p2.age)
p2.age = 22
print(p2.age)
del p2.age # 如果没有property，删除就得是p2.del_age，和习惯不同
print(p2.__dict__)

装饰器

class Student:
    def __init__(self):
        self.__name = '开心超人'

    @property  # grade = property(grade) 不清楚具体咋实现的，但是结果是 将函数的返回值 __name 赋给grade，也就是下变函数的名字，所以说为了让外边调用方便还是不要瞎起名
    def grade(self):
        return self.__name

    @grade.setter
    def grade(self , value):
        self.__name = value

    @grade.deleter
    def grade(self):
        del self.__name


p5 = Student()
print(p5.grade)
p5.grade = "花心超人"
print(p5.grade)
del p5.grade
# print(p5.grade)

继承

在python中是在多个类中的一种所属关系
被继承的类称为父类
接收的类称为子类
在继承中子类是默认继承父类中的属性以及方法
继承可以解决类与类之间的代码冗余。
在python3中都会默认继承object类，即object是python中所有类的父类（基类，超类）。

单继承

一个子类继承一个父类，子类默认继承父类中的所有方法，属性

class Father:

    def __init__(self , name):
        self.name = name
        self.clothes = '
标签：__,name,Python,self,面向对象,print,age,def	

From： https://www.cnblogs.com/fhy-blog/p/16631284.html

Python-——面向对象