01-面向对象编程

----编程思想

✈ 1、面向过程编程 --> 算法，逻辑（数学逻辑）
✈ 2、函数式编程 --> 函数
✈ 3、面向对象编程 --> 类和对象（生活）

***********************类的声明**********************

1.什么是类

类是拥有相同属性和相同功能的对象的集合
对象 - 就是类的实列（具体的）

从生活的角度来看类和对象

如果说人是一个类，uzi就是一个对象

如果说电脑是一个类，我桌上的这台电脑就是一个对象

如果说水杯是一个类，具体的某个水杯就是这个类的对象

如果车是一个类，汽车、自行车、摩托车等这些是这个类的子类，具体的某一辆车才是对象

2. 类的声明

格式：
class 类名（父类列表）
类的说明文档
类的内容

说明：

class -> python中类的关键字
类名 -> 标识符，不能是关键字；类名使用驼峰式命名，并且首字母大写；见名知义

驼峰式命名：如果一个名字由多个单词组成，第一个单词首字母小写，后面每个单词首字母大写
userName

PEP8命名规范：如果一个名字由多个单词组成，所有字母小写，多个单词之间由下划线隔开
user_name

（父类列表） -> 继承语法，让声明的类继承括号的父类。这个结果可以省略，让当前类基类:object

：-> 固定结构
类的说明文档 -> 注释，对类进行说明

类的内容 -> 包含属性(变量)和方法（函数）

方法：就是声明在类中的函数

"""

声明Person类，吃饭和睡觉

class Person:
    """人类"""
    def eat(self):
        print('吃饭')
    def sleep(self):
        print('睡觉')

"""

3.对象的声明

格式：
对象名 = 类名()

对象名 -> 变量名
类名 -> 必须是声明过的类
"""

声明了Person类的对象p1

p1 = Person()
p2 = Person()

**************************对象方法***********************

1.

类的内容包含属性和方法，方法分为对象方法、类方法和静态方法

对象方法：直接声明在类中的函数就是对象方法。对象方法都有一个默认参数self，通过对象来调用

对象方法调用：对象.方法名()。调用对象方法的时候，不需要给默认值self传参。
系统会自动将当前对象传递给self

self：谁调用当前的对象方法，self就指向谁.self就是当前类的对象，类的对象能做的事情，self都能做

"""
class Person:
    """人类"""

    # 对象方法eat
    def eat(self):
        print('self:',self)
        print('吃饭')

# 声明对象
p1 = Person()
print('p1:',p1)
p1.eat()

*********************构造方法和init方法****************

1.构造方法

构造方法就是函数名和类名一样的方法，作用是用来创建对象的。
声明类的时候，系统会自动为这个类创建对应构造方法

创建对象的过程：调用构造方法在内存中开辟空间创建对象，并且会自动调用init方法去对这个对象进行初始化
最后将创建好的地址返回

2.init方法

对象方法

不需要手动调用，创建完对象后，会被自动调用

class Dog:
    """狗类"""
    def __init__(self):
        print(self)
        print('init方法')

dog1 = Dog()
print(dog1)

dog2 = Dog()

"""

3.带其他参数的init方法

init 方法的参数要通过构造方法来传。（构造方法的实参，会传递给init方法的形参）

"""
class Person:

    def __init__(self, name='', age=0):
        print(name, age)

p1 = Person('uzi', 90)
p2 = Person('uzi')
p3 = Person(age=99)

***********************对象的属性************************

类的内容包含属性和方法，属性又分为对象属性和类的字段

属性：用来在类中去保存数据的变量。

对象属性：属性的值会因为对象不同而不同，这种属性就需要声明成对象属性，例如：人的名字，人的年龄等
对象属性要通过对象来使用

1.对象属性的声明（重点！！！）

a.必须声明在init方法中

b.声明的格式：self.属性名 = 初值

2.使用对象属性：对象.属性

"""

声明一个人类，要求有名字，年龄和性别属性

class Person():
    def __init__(self):
        self.name = 'uzi'
        self.age = 19
        self.sex = '男'
p1 = Person()
print(p1.name)     # uzi

p2 = Person()
print(p2.name)      # uzi

声明人类，有名字，年龄，性别三个属性。要求创建不同的时候就可以直接确定不同属性值

class Person2():
    def __init__(self, name1, age1, sex1):
        self.name = name1
        self.age = age1
        self.sex = sex1

p1 = Person2('uzi', 25, '男')
print(p1.name)          # uzi

p2 = Person2('xiaohu', 15, '男')
print(p2.name)         # xiaohu

*******************对象属性的增删改查*****************

class Student:
    def __init__(self, name1='', age1=0, stu_id1='001'):
        self.name = name1
        self.age = age1
        self.stu_id = stu_id1

stu1 = Student('小虎')

1.查（获取对象属性的值）

"""

方法1：对象.属性 --> 获取指定属性值，属性不存在会报错

print(stu1.name)
#print(stu1.name2)       # AttributeError: 'Student' object has no attribute 'name2'

方法2：getattr(对象， 属性名， 默认值) --> 获取指定属性的值，如果设置的默认值当属性不存在的时候不会保存，

并且将默认值作为结果（如果没有设置默认值属性不存在还是会报错）

print(getattr(stu1, 'name'))
print(getattr(stu1, 'name2','小狗'))

方法3：对象.getattribute(属性名) -> 获取指定属性值.属性不存在会报错

print(stu1.__getattribute__('stu_id'))

2.增（给对象添加属性）

注意：给对象添加属性，只能添加到当前对象中。不会影响当前的其他对象

方法1：对象.属性 = 值（属性不存在的时候增加，存在的就是修改）

方法2：setattr(对象， 属性名， 属性值)

方法3：对象.setattr(属性名，属性值)

# 添加
stu1.sex = '男'
print(stu1.sex)
# 修改
stu1.name = '胡歌'
print(stu1.name)
# 修改
setattr(stu1, 'name', '吉吉')
print(stu1.name)
# 添加
setattr(stu1, 'name2', '老猫')
print(stu1.name2)

3.删（删除对象属性）

"""
注意：删除只删除当前对象的属性，对其他对象没有影响
方法1：del 对象.属性

方法2：delattr(对象，属性名)

方法3：对象.--delattr--(属性名)

del stu1.age
# print(stu1.age)

print(stu1.sex)
delattr(stu1,'sex')
# print(stu1.sex)

stu1.__delattr__('name')

*********************对象的所有**************************

""""""
import copy
"""
python中所有的数据都是对象，所有的变量存储的都是对象的地址
"""
num = int(10)
print(num.bit_length())

class Student:
def init(self,name, age, score):
self.name = name
self.age = age
self.score = score

# 定制当前类的打印格式，函数的返回值必须是字符串
def __str__(self):
    return str(self.__dict__)

1.将对象给别的变量赋值

stu1 = Student('xiaohu', 19, 88)
stu2 = stu1 # 赋对象地址
stu3 = copy.copy(stu1) # 产生新的对象，将新的地址赋值

stu1.name = 'zhangsan'
print(stu2.name)

2.将对象作为列表的元素

students = [Student('小虎', 22, 90), stu3, Student('网吧', 33, 99)]

找到列表students中成绩最好的学生的名字

max1 = students[0].score
name = students[0].name
for stu in students:
if stu.score > max1:
max1 = stu.score
name = stu.name
print(name, max1)

对列表中的学生按年龄从小到大排序

students.sort(key=lambda item:item.age)
for stu in students:
print(stu)

max1 = max(students, key=lambda item: item.score)
print('max:',max1)

1.根据姓名查找指定学生的信息。2.根据姓名修改指定的学生的年龄。

def yy():
name = input('请输入查找学生的姓名：')
for stu in students:
if stu.name == name:
print(stu)
xg_age = int(input('请输入修改学生年龄：'))
stu.age = xg_age

        print(stu)

yy()

*******************slots魔法属性************************

属性：对象属性，类的字段

类的字段：声明在类里面，函数外面的变量就是类的字段。使用的时候要通过类来使用：类.

2.slots: 用来约束当前类的对象的属性有哪些

"""

class Dog:
    # num就是类的字段
    num = 10
    __slots__ = ('color', 'name', 'type')

    def __init__(self, color, name, type):
        self.color = color
        self.name = name
        self.type = type
        print(Dog.name)

Dog.num = 100
print(Dog.num)

dog1 = Dog('黄色', '大黄', '土狗')

# dog1.neme = '厂长'
# print(dog1.name)

*******************内置类属性****************************

class Person:
    """人类"""
    # 类的字段
    num = 66

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    # 对象方法
    def run(self):
        print('%s在跑' % self.name)

    def __str__(self):
        return '{'+self.__class__.__module__+'.'+self.__class__.__name__+\
        'object at' + hex(id(self))+'>>'


p1 = Person('uzi', 18, '男')

# 1.__name__
"""
类.__name__ --> 获取当前类的名字
"""
print(Person.__name__, type(Person.__name__))

# 2.__doc__
"""
类.__doc__ --> 获取当前类的文档
"""
print(Person.__doc__)
print(int.__doc__)
print(dict.__doc__)


# 3.__class__
"""
对象.__class__ -> 获取对象的类
"""
my_class = p1.__class__
p2 = Person('uzi', 33, '男')
p2 = my_class('uzi', 33, '男')
print(p2.name)

print(Person.num)
print(my_class.num)

# 4.__dict__
"""
类.__dict__ --> 获取当前类的所有类的字段和其对应的值，以字典的形式返回（了解）
对象.__dict__ --> 获取当前对象所有的属性和其对应的值，以字典的形式返回

"""
print(Person.__dict__)
print(p1.__dict__)

# 5.__module__
"""
类.__module__ -> 获取当前类所在的模块
"""
print(Person.__module__)

# 6.__bases__
"""
类.__bases__ --> 获取当前类的父类，返回的是一个元祖，元祖的元素是类
"""
print(Person.__bases__)