Day 14 python学习笔记

面向对象

---

对象对应着现实中具体的事物
生活中=========程序中
设计表格--------------设计类
打印表格---------------创建对象
填写表格---------------对象属性赋值

面向对象编程

使用对象进行编程

设计一个类，基于类去创建对象，并使用对象完成具体的操作

类定义

class ClassName:      #class  类名 ：
       xxx
或者:
class ClassName(object):
       xxx

类的构成

类的名称        人名字

类的属性        身高体重

类的行为        行为、功能

类对象

对象：   类名（）

类对象支持两种操作：属性引用和实例化

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
print(x.i)
print(x.f)
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())


结果：
12345
>
MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self（也可以改成任意名称）

简单来说：

self（类的实例）：指向当前调用的实例对象，python解释器会自动传递参数

实例属性： 类的实例.方法 （例：self.uname）

例：
class MyClass:
    def set_name(self, name, age):   #self传的是x（类的实例）
        self.uname = name        #self.uname即为实例属性
        self.age = age
x = MyClass()
x.MyClass(zhangsan,21)   #表面的使用
x.MyClass(x，zhangsan,21)   #内部的使用，会自动将将类的实例（避免发生混乱）

类的成员方法

写在类中的函数成为类的成员方法，必须包含形参self，self.name调用类的属性，传参是可以进行忽略

魔术方法

python的内置方法各自有各自的特殊功能，这些内置方法我们称之为：魔术方法

例：__init__ , __str__  , __del__

构造方法

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，age,title等属性绑上去：

_ _ init _ _

注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去

例1：

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

例2：

class Student:
    name=None
    age=None
    tel=None
    def __init__(self,name,age,tel):
        self.name=name
        self.age=age
        self.tel=tel
        print(f"{self.name} {self.age} {self.tel}")

stu1=Student("openlab",11,13024920) #可以在创建时进行传参

结果：
openlab 11 13024920

例3：

class Student:
    name=None
    age=None
    tel=None
    def __init__(self,name,age,tel):
        self.name=name
        self.age=age
        self.tel=tel
        print(f"{self.name} {self.age} {self.tel}")
    def __str__(self):
        return f"Student类对象，name={self.name},age={self.age}"
stu1=Student("openlab",11,13024920)
print(stu1)


结果：
openlab 11 13024920
Student类对象，name=openlab,age=11

例4

class Student:
    name=None
    age=None

    def __init__(self,name,age):
        self.name=name
        self.age=age
        print(f"{self.name}{self.age}")
    def __lt__(self, other):
        return  self.agestu2) 

结果：
zs12
zs15
False

私有化

类的私有属性

__private_attrs：（private：私有的  attrs:属性）两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

实例：

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0  # 公开变量

    def __count(self):  #私有方法
        self.__secretCount += 1  # 私有属性
        self.publicCount += 1
        print(self.__secretCount)
        print(self.publicCount)


counter = JustCounter()
print(counter.__secretCount)  # 报错，实例不能访问私有变量

结果：
Traceback (most recent call last):
  File "D:\pycharm\10.py", line 33, in 
    print(counter.__secretCount)  # 报错，实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0  # 公开变量

    def __count(self):
        self.__secretCount += 1  # 私有属性
        self.publicCount += 1
        print(self.__secretCount)
        print(self.publicCount)


counter = JustCounter()
counter.count()    #私有话方法不可以访问

结果：
Traceback (most recent call last):
  File "D:\pycharm\10.py", line 30, in 
    counter.count()
AttributeError: 'JustCounter' object has no attribute 'count'

Python中的私有，事实上是不存在的，只是对私有的属性或者方法进行重名，将__属性 改名为  __类名__属性

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0  # 公开变量

    def __count(self):  #私有方法
        self.__secretCount += 1  # 私有属性
        self.publicCount += 1
        print(self.__secretCount)
        print(self.publicCount)


counter.count = 1  #因为它是重新创建一个属性并赋值，所以不会报错
print(counter._JustCounter__count)
print(counter._JustCounter__secretCount)  # 这样才可以访问


结果：
>
0