Day12 面向对象基础

01.迭代器和生成器

02.认识面向对象

03.类的声明

04.对象的属性

05.对象属性的增删改查

06.slots魔法

07.类中的方法

---

01.迭代器和生成器

生成器：
a.可以看成一个可以存储多个数据的容器，需要里面的数据的时候，就生成一个数据，里面的数据只能从前往后一个一个生成，不能跳跃，也不能从后往前，而且生成后的数据，也不能再生成
b,获取生成器里面的数据，需要使用next()方法
c.只要函数声明中有yield关键字，函数就不再是一个单纯的函数，而变成一个生成器

• 和列表比较：列表存数据，数据必须是实实在在存在的数据，一个数据会占一定的内存空间
  生成器存数据，存的是产生数据的算法，没有数据去占内存空间

x = (i for i in range(10))
# x 就是一个生成器,用来生成数据
print(x.__next__())
print(x.__next__())

print('====')
print(x.__next__())



# 1,1,2,3,5,8,13,21
def xu_lie(n):
pre_1 = 1
pre_2 = 1
for x in range(1,n+1):
    if x == 1 or x == 2:
        current = 1
        yield current
        continue
    current = pre_1 + pre_2
    pre_1,pre_2 = pre_2,current
    yield current

xulie = xu_lie(10)
print(xulie.__next__())
print(xulie.__next__())
print(xulie.__next__())

02.认识面向对象

1.什么是类：对拥有相同属性和功能的对象的封装
类是抽象
类中相同的属性的值是不能确定的

2.什么是对象：对象就是类的实例
对象是具体
对象的属性是确定的

3.面向对象编程
面向过程编程：一步一步的写代码实现功能-->工具：逻辑和算法
函数式编程：面对问题考虑有没有拥有某种功能的函数-->工具：函数
面想对象编程：面对问题考虑有没有相应的对象来解决这个问题-->工具：类和对象

03.类的声明

类的声明：
class 类名(父类)：
    属性
    方法

• class：python中声明类的关键字
• 类名：标识符，类名的首字母大写，驼峰式命名
• {}：类如果继承至其他的类，需要写括号，括号里面是父类的名字，可以省略
• 属性：对象属性和类的字段 ---> 保存数据
• 方法：实质就是声明在类中的函数 --->实现功能

1.声明类Person

class Person:
'''类的说明：人类'''

# 声明两个对象方法，需要使用对象来调用
# 对象方法默认都有一个参数self，在调用方法的时候，这个参数不用传参（系统自动给self传参）
# 谁调用这个方法，self就是谁
def eat(self):
    print('在吃饭')

def sleep(self):
    print('在睡觉')

'''
声明对象：
通过类的构造方法去创建对象(名字和类名同名的方法就是构造方法，自动生成的)
对象名 = 类名()

类对象可以通过点语法使用类中声明的对象的方法和属性
对象.方法名()
对象.属性名()
'''


# 2.声明对象
p1 = Person()
print(p1)

# 一个类可以有多个对象
p2 = Person()
print(p2)

# 对象可以调用对象方法
p1.eat()
p2.eat()
p1.sleep()
p2.sleep()

04.对象的属性

class 类名：
def __init__(self):
    self.属性名 = 初值
    self.属性名2 = 初值

class Person:
# a.init方法是系统自带的方法，这个方法不能直接调用，而是通过类创建对象的时候系统会自动调用这个方法
# b.init方法的作用是对对象的属性进行初始化
# c.通过构造方法创建对象的时候，一定要保证，init方法中除了self以外，其他的每个参数都必须有值
def __init__(self,name1,age1):
    #在这个地方声明对象的属性
    print('====')
    print(name1)
    # 在init方法中声明对象的属性
    '''
    name、age、sex就是Person这个类的对象属性。累的对象属性，需要通过对象来使用
    '''
    self.name = name1
    self.age = age1
    self.sex = '男'




# 注意：构造方法中的参数，实质是传给init方法的参数的
p1 = Person('zk',18)
# 通过对象使用对象属性
print(p1.name,p1.age,p1.sex)

p2 = Person('TQ',18)
print(p2.name,p2.age,p2.sex)

# 创建对象时不给属性赋值
# p3 = Person()
#
# p4 = Person('qqq')
#
# p5 = Person(sex='男')

05.对象属性的增删改查

class Dog:
'''狗类'''
def __init__(self, age=0, color='yellow'):
    self.age = age
    self.color = color



dog1 = Dog(3,'white')

# 1.查(获取属性)
'''方法一：对象.属性(如果属性不存在，会报错)'''
print(dog1.age,dog1.color)
'''方法二：对象.__getattribute__(属性名)和getattr(对象名，属性，默认值)
'''
print(dog1.__getattribute__('age'))
print(getattr(dog1,'age'))

# 如果设置了default的值，那么当属性不存在的时候不会报错，并且返回默认值
print(getattr(dog1,'abc','无名氏'))

# 2.改(修改属性的值)
'''
方法一：对象.属性 = 新值
'''
dog1.age = 4
print(dog1.age)

'''方法二：对象.__setattr__(属性名，新值)和setattr(对象，属性名，新值)'''
dog1.__setattr__('color','black')
print(dog1.color)

setattr(dog1,'color','blue')
print(dog1.color)

# 3.增
'''
对象.属性 = 值(属性不存在，就添加)
注意：属性是添加给对象的，而不是类的
'''
dog1.name = '大黄'
print(dog1.name)



# 4.删(删除对象的属性)
'''
方法一：del 对象.属性
删除属性也是删的具体某个对象的属性，不会影响这个类的其他对象
'''
# del dog1.age
# print(dog1.age)  报错：AttributeError: 'Dog' object has no attribute 'age'

'''方法二：'''
# dog1.__delattr__('age')
# print('dog1.age')
#
# delattr(dog1,'color')
# print(dog1.color)

'''
练习：声明一个学生类，拥有属性：姓名、性别、年龄。方法：学习
1.声明学生类的对象，声明的时候就给姓名、性别和年龄赋值
2.通过三种方式分别获取姓名、性别和年龄，并且打印
3.给学生对象添加一个属性，电话
4.修改学生的年龄
5.删除学生的性别
'''
class Student:
def __init__(self,name='',sex='',age=0):
    self.name = name
    self.sex = sex
    self.age = age

def study(self):
    print('%s在学习' % self.name)

stu1 = Student('小明','男',20)
print(stu1.name)
print(stu1.__getattribute__('sex'))
print(getattr(stu1,'age'))

stu1.study()

stu1.tel = '1234567'
print(stu1.tel)

stu1.age = 18

del stu1.sex

06.slots魔法

class Person:
__slots__ = ('name','age')  #约束类中的对象的属性
def __init__(self,name='',age=0):
    self.name = name
    self.age = age

# 自定义对象的打印格式
def __str__(self):
    return self.name+','+ str(self.age)

if __name__ == '__main__':
p1 = Person('小王',20)
# p1.sex = '男'
print(p1)

07.类中的方法

属性：对象的属性（属性），类的属性(类的字段)
对象属性：属于对象的，不同对象对应的值可能不一样(对象属性，通过对象来使用)
类的字段：声明在类里面，函数外面。类的属性属于类(类的字段，通过类来使用)

方法：
对象方法（方法）、类方法、静态函数
对象方法：自带一个self参数，一般要通过对象去调用
类方法：1.使用@classmethod修饰
2.自带一个cls参数，这个参数不用传参，谁来调用这个方法，cls就指向谁
3.类方法要通过类来调用
静态方法：1.使用@staticmethod修饰
2.没有默认参数
3.静态方法通过类来调用

怎么选择对象方法、类方法、静态方法？

• if 如果实现函数的功能需要使用对象的属性，就声明成对象方法

• elif 如果实现函数的功能需要使用类的字段或者调用类的方法，就声明成类方法

• else 如果实现函数功能既不需要对象的属性，也不需要类的字段，就声明成静态方法

class Person:
# number是类字段
number = 61

def __init__(self,name='',age=0):
    # name和age是对象和属性
    self.name = name
    self.age = age

# eat方法是对象方法
def eat(self,food):
    print('%s在吃%s' % (self.name,food))

# hurt_earth就是一个类方法
@classmethod
def hurt_earth(cls):
    # cls指向的是调用这个方法的类，cls可以当成类来使用
    pt = cls('张三')  #可以使用cls创建对象
    print(pt.name)

    print(cls.number)  #可以使用cls使用类的字段
    print('人类破坏环境！')

#protect_eart是一个静态类方法
@staticmethod
def protect_earth():
    print('人类保护地球！')


# 1.类的字段要用类来使用
print(Person.number)

# 2.对象的属性要通过对象来使用
p1 = Person('小明')
print(p1.name,p1.age)

# 3.对象方法用对象调用
p1.eat('面条')

p2 = Person('小红')
p2.eat('火锅')

# 4.类方法通过类来调用
Person.hurt_earth()

# 5.静态方法
Person.protect_earth()


'''
练习：
1.写一个班级类，属性：班级名、学生
功能：添加学生，查找学生

2.写一个类：封装所有和数学运算相关的功能
'''

class Student:
'''学生类'''
def __init__(self,name='',age=0):
    self.name = name
    self.age = age

def __str__(self):
    return 'name:%s' 'age:%d' % (self.name,self.age)
class Class:
def __init__(self,name='',students=[]):
    self.class_name = name
    self.students = students

def add_student(self):
    name = input('name:')
    age = input('age:')
    # 根据输入的信息创建学生对象
    stu = Student(name,int(age))
    # 添加学生
    self.students.append(stu)


# 创建班级类对象
cls1 = Class('py1805',[])
cls1.add_student()
print(cls1.students[0])