标签：return pre 用法 int 初始化 core 定制 架构师 obj
面向对象介绍
‘‘‘
面向过程：
核心是"过程"二字
过程的终极奥义就是将程序流程化
过程是"流水线"，用来分步骤解决问题的
面向对象：
核心是"对象"二字
对象的终极奥义就是将程序"整合"
对象是"容器"，用来盛放数据与功能的
类也是"容器"，该容器用来存放同类对象共有的数据与功能
python这门语言到底提供了什么语法来允许我们将数据与功能很好地整合好一起呢？？？
‘‘‘
# 程序=数据+功能
# 学生的容器=学生的数据+学生的功能
# 课程的容器=课程的数据+课程的功能
# 粉扑、眼影、各种颜料=》原材料=》数据
# 眉笔、小刷子 =》工具 =》功能
# 学生的功能
# def tell_stu_info(stu_obj):
# print(‘学生信息：名字：%s 年龄：%s 性别：%s‘ %(
# stu_obj[‘stu_name‘],
# stu_obj[‘stu_age‘],
# stu_obj[‘stu_gender‘]
# ))
# def set_info(stu_obj,x,y,z):
# stu_obj[‘stu_name‘]=x
# stu_obj[‘stu_age‘]=y
# stu_obj[‘stu_gender‘]=z
# stu_obj={
# ‘stu_school‘:‘oldboy‘,
# ‘stu_name‘:‘egon‘,
# ‘stu_age‘:18,
# ‘stu_gender‘:‘male‘,
# ‘tell_stu_info‘: tell_stu_info,
# ‘set_info‘:set_info
# }
# stu1_obj={
# ‘stu_school‘:‘oldboy‘,
# ‘stu_name‘:‘lili‘,
# ‘stu_age‘:19,
# ‘stu_gender‘:‘female‘,
# ‘tell_stu_info‘: tell_stu_info,
# ‘set_info‘:set_info
# }
# 课程的数据
# course_name=‘python‘
# course_period=‘6mons‘
# course_score=10
# 课程的功能
# def tell_coure_info():
# print(‘课程信息：名字：%s 周期：%s 学分：%s‘ %(course_name,course_period,course_score))
面向对象编程
# 一：先定义类
# 类是对象相似数据与功能的集合体
# 所以类体中最常见的是变量与函数的定义，但是类体其实是可以包含任意其他代码的
# 注意：类体代码是在类定义阶段就会立即执行，会产生类的名称空间
# class Student:
# # 1、变量的定义
# stu_school=‘oldboy‘
#
# # 2、功能的定义
# def tell_stu_info(stu_obj):
# print(‘学生信息：名字：%s 年龄：%s 性别：%s‘ %(
# stu_obj[‘stu_name‘],
# stu_obj[‘stu_age‘],
# stu_obj[‘stu_gender‘]
# ))
#
# def set_info(stu_obj,x,y,z):
# stu_obj[‘stu_name‘]=x
# stu_obj[‘stu_age‘]=y
# stu_obj[‘stu_gender‘]=z
# print(‘========>‘)
# print(Student.__dict__)
# 属性访问的语法
# 1、访问数据属性
# print(Student.stu_school) # Student.__dict__[‘stu_school‘]
# 2、访问函数属性
# print(Student.set_info) # Student.__dict__[‘set_info‘]
# Student.x=1111 #Student.__dict__[‘x]=111
# print(Student.__dict__)
# 二：再调用类产生对象
# stu1_obj=Student()
# stu2_obj=Student()
# stu3_obj=Student()
# print(stu1_obj.__dict__)
# print(stu2_obj.__dict__)
# print(stu3_obj.__dict__)
# 为对象定制自己独有的属性
# 问题1：代码重复
# 问题2：属性的查找顺序
# stu1_obj.stu_name=‘egon‘ # stu1_obj.__dict__[‘stu_name‘]=‘egon‘
# stu1_obj.stu_age=18 # stu1_obj.__dict__[‘stu_age‘]=18
# stu1_obj.stu_gender=‘male‘ # stu1_obj.__dict__[‘stu_gender‘]=‘male‘
# # print(stu1_obj.__dict__)
#
# stu2_obj.stu_name=‘lili‘
# stu2_obj.stu_age=19
# stu2_obj.stu_gender=‘female‘
# # print(stu2_obj.__dict__)
#
# stu3_obj.stu_name=‘jack‘
# stu3_obj.stu_age=20
# stu3_obj.stu_gender=‘male‘
# # print(stu2_obj.__dict__)
# 解决问题一：
# 解决方案一：
# def init(obj,x,y,z):
# obj.stu_name=x
# obj.stu_age=y
# obj.stu_gender=z
#
# init(stu1_obj,‘egon‘,18,‘male‘)
# init(stu2_obj,‘lili‘,19,‘female‘)
# init(stu2_obj,‘jack‘,20,‘male‘)
# 解决方案二：
# 一：先定义类
# class Student:
# # 1、变量的定义
# stu_school=‘oldboy‘
#
# # 空对象,‘egon‘,18,‘male‘
# def __init__(obj,x,y,z):
# obj.stu_name=x # 空对象.stu_name=‘egon‘
# obj.stu_age=y # 空对象.stu_age=18
# obj.stu_gender=z # 空对象.stu_gender=‘male‘
# # return None
#
# # 2、功能的定义
# def tell_stu_info(stu_obj):
# print(‘学生信息：名字：%s 年龄：%s 性别：%s‘ %(
# stu_obj[‘stu_name‘],
# stu_obj[‘stu_age‘],
# stu_obj[‘stu_gender‘]
# ))
#
# def set_info(stu_obj,x,y,z):
# stu_obj[‘stu_name‘]=x
# stu_obj[‘stu_age‘]=y
# stu_obj[‘stu_gender‘]=z
#
# # print(‘========>‘)
# 二：再调用类产生对象
# 调用类的过程又称之为实例化，发生了三件事
# 1、先产生一个空对象
# 2、python会自动调用类中的__init__方法然将空对象已经调用类时括号内传入的参数一同传给__init__方法
# 3、返回初始完的对象
# stu1_obj=Student(‘egon‘,18,‘male‘) # Student.__init__(空对象,‘egon‘,18,‘male‘)
# stu2_obj=Student(‘lili‘,19,‘female‘)
# stu3_obj=Student(‘jack‘,20,‘male‘)
# print(stu1_obj.__dict__)
# print(stu2_obj.__dict__)
# print(stu3_obj.__dict__)
# 总结__init__方法
# 1、会在调用类时自动触发执行，用来为对象初始化自己独有的数据
# 2、__init__内应该存放是为对象初始化属性的功能，但是是可以存放任意其他代码，想要在
# 类调用时就立刻执行的代码都可以放到该方法内
# 3、__init__方法必须返回None
属性查找
# class Student:
# # 1、变量的定义
# stu_school=‘oldboy‘
# count=0
#
# # 空对象,‘egon‘,18,‘male‘
# def __init__(self,x,y,z):
# Student.count += 1
#
# self.stu_name=x # 空对象.stu_name=‘egon‘
# self.stu_age=y # 空对象.stu_age=18
# self.stu_gender=z # 空对象.stu_gender=‘male‘
# # return None
#
# # 2、功能的定义
# def tell_stu_info(self):
# print(‘学生信息：名字：%s 年龄：%s 性别：%s‘ %(
# self.stu_name,
# self.stu_age,
# self.stu_gender
# ))
#
# def set_info(self,x,y,z):
# self.stu_name=x
# self.stu_age=y
# self.stu_gender=z
#
# def choose(self,x):
# print(‘正在选课‘)
# self.course=x
#
# stu1_obj=Student(‘egon‘,18,‘male‘) # Student.__init__(空对象,‘egon‘,18,‘male‘)
# stu2_obj=Student(‘lili‘,19,‘female‘)
# stu3_obj=Student(‘jack‘,20,‘male‘)
# print(stu1_obj.count)
# print(stu2_obj.count)
# print(stu3_obj.count)
# 类中存放的是对象共有的数据与功能
# 一：类可以访问：
# 1、类的数据属性
# print(Student.stu_school)
# 2、类的函数属性
# print(Student.tell_stu_info)
# print(Student.set_info)
# 二：但其实类中的东西是给对象用的
# 1、类的数据属性是共享给所有对象用的，大家访问的地址都一样
# print(id(Student.stu_school))
# print(id(stu1_obj.stu_school))
# print(id(stu2_obj.stu_school))
# print(id(stu3_obj.stu_school))
# Student.stu_school=‘OLDBOY‘
# stu1_obj.stu_school=‘OLDBOY‘
# print(stu1_obj.stu_school)
# print(Student.stu_school)
# print(stu2_obj.stu_school)
# print(stu3_obj.stu_school)
# 2、类中定义的函数主要是给对象使用的，而且是绑定给对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法，内存地址各不相同
# 类调用自己的函数属性必须严格按照函数的用法来
# print(Student.tell_stu_info)
# print(Student.set_info)
# Student.tell_stu_info(stu1_obj)
# Student.tell_stu_info(stu2_obj)
# Student.tell_stu_info(stu3_obj)
# Student.set_info(stu1_obj,‘EGON‘,19,‘MALE‘)
# Student.tell_stu_info(stu1_obj)
# 绑定方法的特殊之处在于：谁来调用绑定方法就会将谁当做第一个参数自动传入
# print(Student.tell_stu_info)
# print(stu1_obj.tell_stu_info)
# print(stu2_obj.tell_stu_info)
# print(stu3_obj.tell_stu_info)
# stu1_obj.tell_stu_info() #tell_stu_info(stu1_obj)
# stu2_obj.tell_stu_info() #tell_stu_info(stu2_obj)
# stu3_obj.tell_stu_info() #tell_stu_info(stu3_obj)
#
# stu1_obj.choose(‘python全栈开发‘)
# print(stu1_obj.course)
#
# stu2_obj.choose(‘linux运维‘)
# print(stu2_obj.course)
#
# stu3_obj.choose(‘高级架构师‘)
# print(stu3_obj.course)
# l1=[‘aa‘,‘bb‘,‘cc‘] # l=list([1,2,3])
# l2=[111,222,333] # l=list([1,2,3])
# print(l1.append)
# print(list.append)
# l1.append(‘dd‘)
# l2.append(‘dd‘)
# print(l1)
# print(l2)
# list.append(l1,‘dd‘)
# list.append(l2,‘dd‘)
# print(l1)
# print(l2)
标签：return pre 用法 int 初始化 core 定制 架构师 obj
原文地址：https://www.cnblogs.com/0B0S/p/12654238.html
