类

目录

• 什么是类?
• 什么是类2)?
  • 类的插图1)
• 类的查找顺序
• 如何修改类的属性
• 统计统计类实例化的次数(类和对象直接属性的关系 )
• 对象的绑定方法
• 双下init的使用
• 双下init的终极使用方法
  • 总结
• 总结

面向对象编程介绍

1.面向过程编程的核心是过程二字, 过程值得是解决问题的步骤, 先干什么再干什么最后干什么

2.面向对象编程的核心是对象二字, 对象是特征与技能的结合体

类与对象

# 实例化:类名加括号就是实例化>>>类名()
类的意思：种类，分类，类别
现实生活中，有一系列相同类别的对象(张三,李四..)>>人类)(边牧,金毛...)>>>犬类),归为类
程序中,先有类,才有对象
	class Person:		# 类名尽量使用大驼峰
    name = 'junjie'
    def run(self):
      pass
    Person = Person() # 对象(由类实例化得到的,类名())
    

什么是类?

"""
造一个张三：有体重身高，还有睡觉技能（特征与技能的结合体：属性和方法）
"""
# 定义一个类
# 类 Person
class Person():
    # 特征(属性)
    height = 180
    weight = 90
    # sleeph函数 就是方法 特征 self先不用管
    def sleep(self):
        print('睡觉技能')

# 定义一个对象
# 对象 zhangsan
zhangsan = Person()

# 使用对象
print(zhangsan.weight)
print(zhangsan.height)
zhangsan.sleep()
"""
90
180
睡觉技能
"""
# 仅为举例

什么是类2)?

# 定义一个学生类(学习属性,选课技能)，实例化得到一个学生对象
class Student():
  school = 'oldboy'
  def choose_course(self):
    print('选课技能')
    
 stu = Student() # 类的实例化,得到对象
类名.__dict__
# __dict__ 是类的名称空间
# print(Student.__dict__)  双__ 开头暂时不用关注,写在类中的属性和方法，都在Stedent中
"""
/usr/local/bin/python3.6 /Users/macintoshhd/Desktop/python/面向对象/main.py
{'__module__': '__main__', 'school': 'oldboy', 'choose_course': <function Student.choose_course at 0x7fb73c1c56a8>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
"""
print(Student.school) # oldboy
print(stu.school) # oldboy
"""
如果对象stu.school的名称空间中没有属性,去类的名称空间中寻找
"""
下面插图

类的插图1)

类的查找顺序

class Student():
    # 属性
    school = 'oldboy'

    # 方法
    def choose_course(self):
        # 那个对象来调用,self就是哪个对象
        # print(self)
        print('选课技能')


stu = Student()  # 类的实例化,得到对象
stu1 = Student()
# 模拟s1去了北大
stu.school = '北大'

# 对象的名称空间中有属性，优先使用自身的，没有再去类寻找属性
# print(Student.school) # oldboy
# print(stu.school) # 北大
# print(stu1.school) # oldboy

# 对象调用方法，使用的是类中定义的方法
# 类中定义的方法是绑定给对象,对象来使用
# .choose_course() 就是使用方法

stu.choose_course() # 选课技能
stu1.choose_course() # 选课技能
# 对象属性的查找顺序，对象自己>>>类>>>报错
# 对象方法的查找顺序，所有对象都用类的方法>>>方法有self参数，通过self参数区分是那个对象调用的
类名.__dict__
对象.__dict__
print(stu.__dict__) # {'school': '北大'}
print(stu1.__dict__) # {} stu1的名称空间中没有属性
# 类中的属性应该写对象共有的属性,如果是对象自己的，需要放到对象自己的名称空间
stu.name = 'junjie'
stu.age = 10
print(stu.__dict__)

如何修改类的属性

 class Student():
    # 属性
    school = 'oldboy'
   # 方法
    def choose_course(self):
      # 那个对象来调用,self就是哪个对象
      # print(self)
      print('选课技能')

s1 = Student()
s1.school = '北大'  # 只能修改对象自己的名称空间，改不到类的属性
Student.school = '清华'
stu1 = Student()
stu2 = Student()
print(stu1.school) # 清华
print(stu2.school) # 清华

统计统计类实例化的次数(类和对象直接属性的关系 )

class Student():
    count = 0


s1 = Student()  # 实例化一次 数字+1
Student.count += 1
s2 = Student()
Student.count += 1  # 实例化一次 数字+1

s1.count += 1

# 类的名称空间count已经固定是2
print(Student.count) # 2
# s1 从类中取到两次count 再到自己的名称空间中产生count+=1 
print(s1.count) # 3

对象的绑定方法

# 函数：普通函数def定义的函数,调用有几个参数就需要传几个参数
# 方法：绑定给某个对象，方法有特殊之处：绑定给谁，谁来调用，谁来调用就会自动把谁传过来，传给self

class Student():
    # 属性
    school = 'oldboy'

    # 方法
    def choose_course(self):  # 定义再类的内部的函数，就是绑定给对象的方法
        # 哪个对象来调用,self就是哪个对象
        # print(self.name) # 通过self来区分，那个对象调用了自己的绑定方法
        print('%s这个人选课技能' % self.name)


s1 = Student()
# print(s1.__dict__) # {}
s1.name = 'xjj'
s1.choose_course()  # xjj这个人选课技能
# print(s1.__dict__)

s2 = Student()
s2.name = 'hnn'
s2.choose_course()  # hnn这个人选课技能

# 类可不可以调用方法? 可以调用,类来调用方法,方法就是一个普通函数
s1 = Student()
s1.name = 'junjie'
Student.choose_course(s1)
# 类可以调用对象的绑定方法，但是需要手动把对象传进来，有几个参数就传几个参数

双下init的使用

# 对象再实例化时，赋初始值(这里是给对象的属性)

class Student:
  def choose_course(self):
    print('选课')

# 之前的方法
stu1 = Student()
stu1.name = 'junjie'
stu1.age = 18

# 新方法
class Student:
  def __init__(self):
    self.name = 'junjie'
    self.age = 18
  def choose_course(self):
    print('选课')
    
stu2 = Student()
print(stu2.age) # 18
print(stu2.name) # junjie
# 但是
stu3 = Student()
print(stu3.name) # junjie
# 这样的写法固定死了所以__init__的终极使用方法

双下init的终极使用方法

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

    def choose_course(self):
        print('选课')

# 这种初始化方式会触发类的__init__的执行，并把参数传入
stu1 = Student(name='junjie',age=18) 
print(stu1.__dict__) # {'name': 'junjie', 'age': 18}
print(stu1.name) # junjie
print(stu1.age) # 18
stu2 = Student(name='jun',age=28)
print(stu2.name) # jun

总结

# 对象在实例化的时候，赋初值（给对象一些属性）


# class Student:
#     def choose_course(self):
#         print('选课')

# 之前的方案
# student1=Student()
# student1.name='lqz'
# student1.age=19


# 新方法
# class Student:
#     def __init__(self):
#         self.name='lqz'
#         self.age=19
#
#     def choose_course(self):
#         print('选课')
#
#
# student1 = Student()  # 只要是类实例化得到对象，就会自动触发__init__的执行
# print(student1.age)
# print(student1.name)
#
# student2 = Student()
# print(student2.name)


# __init__的终极使用
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def choose_course(self):
        print('选课')


# student=Student(name='lqz',age=19)  # 这种初始化方式会触发类的__init__的执行，并把参数传入
# print(student.name)
# egon=Student(name='egon',age=20)
# print(egon.name)


# 按位置传
# lqz=Student(20,'liuqingzheng')
lqz=Student('liuqingzheng',20)
print(lqz.name)

总结

# 类与对象
class 类名:
  pass
对象 = 类名()
字典，列表，数字...其实都是一些类的对象
# 对象的属性查找
"""
对象，属性---->先从对象自己的名称空间中找---->类的名称空间找----->报错
类中定义的属性，对象只能使用，不能修改
对象如果修改，改的是自己名称空间
"""
# 对象的绑定方法
"""
定义在类内部的函数，就是对象的绑定方法，对象来调用，会自动把对象传入(self)
类也可以来调用,类来调用,就是普通函数,有几个参数就要传几个参数

什么叫函数? 什么叫方法?
函数就是def 定义的函数,有几个参数就传入几个参数
方法是绑定给对象使用，由对象调用，特殊之处会把对象本身传入
"""
class Student:
  def choose_course(self):
    print(self)
s = Student
s.choose_course() # choose_course 就是方法
Student.choose_course() # 普通函数 就几个参数就传几个参数

# __init__的使用
初始化方法，类加括号实例化得到对象是，会触发它的执行
可以再初始化方法中，给对象赋初值