类变量就是静态变量，所有方法（对象）要用到同一个属性是，将其定义成类变量

# class Fruits:
#     discount=0.8   # 类变量， 静态变量
#     # 当所有变量都共用到一个属性时，定义成类变量
#     def __init__(self,name,price):
#         self.name=name
#         self.price=price
#         self.pri=self.price * Fruits.discount
#         print(self.pri)
#
# apple=Fruits('苹果',5)

练习，求圆的周长和面积

正解：这样后面半径修改，周长、面积也会发生变化

# from math import pi
# class Circle:
#     def __init__(self,r):
#         self.r=r
#     def leng(self):
#         self.len=2*pi*self.r
#         print('周长', self.len)
#     def s(self):
#         self.area=pi*self.r**2
#         print('面积',self.area)
#
# c1=Circle(3)
# c1.leng()
# c1.s()
# c1.r=5  # 修改半径
# c1.leng()

坑：这样写，当修改了半径后，周长、面积没有改变。因为只在c1=Circle(3)时调用了init方法，后面修改，没有发生改变

# from math import pi
# class Circle:
#     def __init__(self,r):
#         self.r=r
#         self.len=2*pi*self.r
#         self.area=pi*self.r**2
#         print('周长', self.len)
#         print('面积',self.area)
# 
# c1=Circle(3)
# c1.r=5
# print(c1.len)

总结:
    类名作用:
        1.类名可以调类中的变量Fruits.discount
        2.类名可以实例化创建一个对象Fruits()
        3.调用一个方法,类名.方法名(对象)

    对象名作用:
        查看对象的属性 对象名.属性
        调用对象的方法 对象名.方法名()

类和对象,实例和实例化?
    什么是类? Person Dog  Fruits
    什么是对象? banana  dog1 zhangsan
    什么是实例? 对象就是实例,对象就是实例的另外一种称呼
    什么是实例化? 实例化是一个动词,类创造实例的过程叫做实例化
        对象=类名() # 实例化

# class A:
#     静态变量='值'
#     def __init__(self,属性):
#         self.属性=属性
#     def show(self):  #实例方法
#         print('展示所有的属性')
#
# a=A('参数')  # 对象a

#全家的钱放在一起

# class Person:
#     sum=0   # 目前全家工资总和
#     def __init__(self):
#         self.salary=1000
#
# father=Person()
# mother=Person()
# # print(mother.sum)  #通过对象指针拿到sum
# # print(mother.salary) # salary 就在对象空间里

#实现全家的钱加在一起
# Person.sum+=father.salary
# Person.sum+=mother.salary
# print('Person.sum',Person.sum)
# print('father.sum',father.sum)
# print('mother.sum',mother.sum)

#练习
#写一个类，统计一共实例化多少个变量

#方法1
# class Person:
#     count=0
#     def __init__(self):
#         self.num=1
#
# lisir=Person()
# gonsir=Person()
# Person.count+=lisir.num
# Person.count+=gonsir.num
# print('Person.count',Person.count)
# print('lisir.count',lisir.count)
# print('gonsir.count',gonsir.count)


#方法2——老师
# class Person:
#     count=0
#     def __init__(self):
#         Person.count+=1
#
# lisir=Person()
# gonsir=Person()
# print('Person.count',Person.count)
# print('lisir.count',lisir.count)
# print('gonsir.count',gonsir.count)

# class A:
#     num=0
#     def __init__(self):
#         self.num+=1
#
# a1=A()
# a2=A()
# a3=A()
# print(A.num)  # 0
# print(a1.num)  #  1
# print(a2.num) #  1
# print(a3.num)  # 1


# class A:
#     lst=[]
#     def __init__(self):
#         self.lst.append(1)  # 并没有对lst赋值，用对象修改静态变量（类变量），只有用到了赋值，才相当于在自己的对象空间中新建
#
# a1=A()
# a2=A()
# a3=A()
# print(A.lst)   # [1,1,1]
# print(a1.lst)  # [1,1,1]
# print(a2.lst)  # [1,1,1]
# print(a3.lst)  # [1,1,1]



# class A:
#     lst=[0,1]
#     def __init__(self):
#         self.lst[0]+=1   # 确实时重新赋值了，赋值给lst第一个元素，并没有对列表进行重新赋值
#
# a1=A()
# a2=A()
# a3=A()
# print(A.lst)   # [3,1]
# print(a1.lst)  # [3,1]
# print(a2.lst)  # [3,1]
# print(a3.lst)  # [3,1]

# 总结：
#     操作静态变量时，如果时查看，用类或对象都可以
#     如果是修改，用类名去修改，永远不会错
#     不要在对象空间中创建一个和类变量同名的实例变量

# __dict__方法,查看类和对象空间中存储了什么

# class Student:
#     age=18
#     def __init__(self,id,name,sex,tel):
#         self.id=id
#         self.name=name
#         self.sex=sex
#         self.tel=tel
#
#
#     def choose_course(self):
#         print('选择课程')
#
#     def show_score(self):
#         print('查看分数')
#
# print(Student.__dict__)
# lw=Student(1,'老王','男',13274582657)
# print(lw.__dict__)