1.面向对象的介绍
# -*- coding: utf-8 -*-
"""
面向对象:
关键点是将程序整合
对象是容器，用来存放数据与功能
类 也是容器，该容器用来存放同类对象共有的数据与功能
"""
# 学生的容器 = 学生的数据 + 学生的功能
# 课程的容器 = 课程的功能 + 课程的数据
2.实现面向对象编程
- 注意: 类体代码是在定义阶段就会立即执行，会产生类的名称空间
# -*- coding: utf-8 -*-
# 一、先定义类(推荐使用驼峰体)
# 类是对象类似于数据与功能的集合体
# 类当中通常包含的是变量和函数，但是类当中其实可以写任意其他代码
# 注意: 类体代码是在定义阶段就会立即执行，会产生类的名称空间
class Students:
# 1)变量的定义
stu_schools = 'world'
# 2)功能的定义
def set_info(stu_obj, x, y, z):
stu_obj['stu_name'] = x
stu_obj['stu_age'] = y
stu_obj['stu_gender'] = z
# print('====>')
# Students.__dict__ 下面存放的字典
# print(Students.__dict__)
# print(Students.__dict__['set_info'])
# 类专门的取值的语法
# 属性访问的语法
# 1)访问数据属性
# print(Students.stu_schools) # 本质上是 Students.__dict__['set_info']
# 2)访问函数属性
# print(Students.set_info)
# 添加 本质上是操作字典
# Students.x = 111 # Students.__dict__['x'] = 111
# 二、调用类产生对象
# 对象
# stu1_obj = Students()
# stu2_obj = Students()
# stu3_obj = Students()
# 底层是在操作字典
# 代码重复
# 属性的查找顺序
# stu1_obj.stu_name = 'carter' # stu1_obj.__dict__['stu_name'] = 'carter'
# 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 = 'carter' # stu1_obj.__dict__['stu_name'] = 'carter'
# stu2_obj.stu_age = 18 # stu1_obj.__dict__['stu_age'] = 18
# stu2_obj.stu_gender = 'male' # stu1_obj.__dict__['stu_gender'] = 'male'
# print(stu2_obj.__dict__)
# stu3_obj.stu_name = 'carter' # stu1_obj.__dict__['stu_name'] = 'carter'
# stu3_obj.stu_age = 18 # stu1_obj.__dict__['stu_age'] = 18
# stu3_obj.stu_gender = 'male' # stu1_obj.__dict__['stu_gender'] = 'male'
# print(stu3_obj.__dict__)
# 解决代码重复问题 使用函数
# 方案一
# def init(obj, x, y, z):
# obj.stu_name = x
# obj.stu_age = y
# obj.stu_gender = z
#
#
# init(stu1_obj, 'carter', 18, 'male')
# init(stu2_obj, 'jack', 20, 'male')
# init(stu3_obj, 'mary', 21, 'female')
# 方案二
# 先定义类
class Student:
# 1)变量的定义
stu_schools = 'world'
# 在类调用阶段运行
# 空对象，('carter', 18, 'male')
def __init__(obj, x, y, z):
obj.stu_name = x # 空对象.stu_name = 'carter'
obj.stu_age = y # 空对象.stu_age = 18
obj.stu_gender = z # 空对象.stu_gender = 'male'
# 2)功能的定义
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('carter', 18, 'male')
stu2_obj = Student('jack', 20, 'male')
stu3_obj = Student('mary', 21, 'female')
print(stu1_obj.__dict__)
# 总结 __init__方法
# 1.会在调用类时自动触发执行，用来为对象初始化自己独有的数据
# 2.__init__应该存放对象初始化属性的功能，但是也是可以存放其他的
# 代码的，可以存放想要在类调用时立刻执行的代码
# 3.init方法返回None
3.属性查找
# -*- coding: utf-8 -*-
class Student:
# 1)变量的定义
stu_schools = 'world'
# 在类调用阶段运行
# 空对象，('carter', 18, 'male')
def __init__(self, x, y, z):
self.stu_name = x # 空对象.stu_name = 'carter'
self.stu_age = y # 空对象.stu_age = 18
self.stu_gender = z # 空对象.stu_gender = 'male'
# 2)功能的定义
def set_info(self, x, y, z):
self.stu_name = x
self.stu_age = y
self.stu_gender = z
def func(self):
print('hello world')
# print('====>')
stu1_obj = Student('carter', 18, 'male')
stu2_obj = Student('jack', 20, 'male')
stu3_obj = Student('mary', 21, 'female')
print(stu1_obj.__dict__)
# 类中存放的对象共有数据与功能的
# 一、类可以访问
# 1.类的数据属性 共享给所有数据
# print(Student.stu_schools)
# 2.类的函数属性
# print(Student.set_info)
# 二、类中的东西是给对象用的
# 1.类的数据属性是共享给所有对象用的，大家访问的地址都一样
# print(stu1_obj.stu_name)
# print(stu1_obj.stu_age)
# print(stu1_obj.stu_gender)
# print(stu1_obj.stu_schools)
# 2、类的函数属性是绑定给对象使用的
# 绑定方法的特殊之处在于：谁调用绑定方法就会将谁当作第一个参数自动传入
# print(Student.set_info)
# 严格按照函数的规则来用
# Student.set_info(stu1_obj, 'carter', 20, 'male')
# 绑定方法的特殊之处在于：谁调用绑定方法就会将谁当作第一个参数自动传入
# 其他严格按照函数的规则使用
# 在类中新定一个函数一定要传入一个参数用来接收绑定方法传入的参数 self
# stu1_obj.set_info('carter', 20, 'male')
# set_info(stu1_obj, 'carter', 20, 'male')
# -*- coding: utf-8 -*-
# 面向过程
def add_user():
pass
def del_user():
pass
def modify_user():
pass
def query_user():
pass
def show_all():
pass
def start():
while True:
print("""---------------------------
名片管理系统 V1.0
1:添加名片
2:删除名片
3:修改名片
4:查询名片
5:显示所有名片
6:退出系统
---------------------------""")
operator = input('请输入要进行的操作(数字)')
if operator == '1':
add_user()
elif operator == '2':
del_user()
elif operator == '3':
modify_user()
elif operator == '4':
query_user()
elif operator == '5':
show_all()
elif operator == '6':
pass
else:
print('输入有误,请重新输入......')
if __name__ == '__main__':
start()
4.面向对象的基本语法
# -*- coding: utf-8 -*-
# 类和对象
# 小明今年18 岁，身高 1.75，每天早上跑完步，会去 吃 东西
# 小美今年17 岁，身高 1.65，小美不跑步，小美喜欢 吃 东西
# 1.定义类(驼峰命名) 使用class来定义一个类
# class 类名
# class<类名>:
# class<类名>(object):
class Students: # 类中要关注这个类有哪些属性和行为
def __init__(self, name, age, height):
# __init__方法中以参数的形式定义特征，称之为属性
self.name = name
self.age = age
self.height = height
# 行为定义为函数
def run(self):
print('正在跑步')
def eat(self):
print('正在吃饭')
# Students() -> 自动调用init方法
# 使用Students 类创建两个示例对象 s1, s2(都有属性和方法)
s1 = Students('小明', 18, 1.83)
s2 = Students('小美', 19, 1.63)
s1.run()
s1.eat()
s2.run()
5.self的介绍
# -*- coding: utf-8 -*-
class Student(object):
# 这个属性直接定义再类里面，是一个元组，用来规定对象可以存在的属性
# 如果不添加会报错
__slots__ = ('name', 'age', 'city')
def __init__(self, name, age):
self.name = name
self.age = age
def say_hello(self):
print('hello', self.name)
# Student('张三', 18) 具体做了什么？
# 1.调用 __init__ 方法用来申请内存空间
# 2.自动调用__init__方法传入参数，将self指向创建好的内存空间，填充数据
# 谁调用 self 谁就是 self
s1 = Student('张三', 18)
print(s1.name)
s1.say_hello()
print(s1.name)
# print(s1.heigiht) # AttributeError: 'Student' object has no attribute 'heigiht'
# 没有这个属性
# 动态属性
# 直接用等号给一个属性赋值
# 如果这个属性以前不存在，会给对象添加一个新的属性
# 如果存在，会修改这这个属性的值
s1.city = '上海' # 给对象添加这个属性对应的值
print(s1.city)
6.魔法方法
# -*- coding: utf-8 -*-
# 魔法方法也称之为魔术方法
# 在类里面的一些特殊方法
# 特点如下
# 1.不需要手动调用，会在合适的时机自动调用
# 2.都是以__开头，__结尾的方法
# 3.方法名字都是系统规定好的，在合适的时机自己调用
class Person(object):
def __init__(self, name, age):
# 在创建对象时候，会自动调用这个方法
print('__init__方法被调用了')
self.name = name
self.age = age
def __del__(self):
# 在对象被销毁的时候会自动调用这个方法
print('__del__方法被调用了')
def __repr__(self):
# 自动调用 并返回 hello
return 'hello'
# 可读性比较好
def __str__(self):
return '姓名{},年龄{}'.format(self.name, self.age)
def __call__(self, *args, **kwargs):
print('call方法被调用了')
p = Person('carter', 19)
# del p 手动删除
print(p)
# 如果不做任何修改，直接打印一个模块名.类型，内存地址
# <__main__.Person object at 0x000002A74CBA8640>
# 当打印一个对象的时候，会调用对象的 __str__ 或者 __repr__方法
# 如果两个方法都写了， 调用 __str__
# __repr__一般不被调用
# 对象名() 调用__call__方法
p() # 'Person' object is not callable
7.运算符相关的魔法方法
# -*- coding: utf-8 -*-
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
p1 = Person('张三', 19)
p2 = Person('张三', 19)
# p1 p2 不是同一个对象
# 比较两个对象是否是同一个对象 比较内存地址是否相同
# 身份运算符 is 比较两个对象是否是同一个对象
# == 会调用对象的__eq__方法,获取这个方法的比较结果
print(p1 is p2) # False
num1 = [1, 2, 3]
num2 = [1, 2, 3]
print(num1 is num2) # False
扫一扫
4845
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
