day14-类和对象1
2018-10-17 本文已影响0人
_桑心人
1.面向对象编程
1.面向过程编程 --> 算法、逻辑（数学逻辑）
2.函数式编程 ---> 函数
3.面向对象编程 ---> 类和对象（生活）
代码示例
# 1.面向过程
n = 100
for x in range(n+1):
sum += x
# 2.函数式编程
def add():
pass
value = input('数字')
if value == '1':
"""函数"""
add()
# 3.面向对象
class Studeng_Manager:
def add(self):
pass
value = input('数字')
if value == '1':
"""函数"""
Studeng_Manager.add()
2.类的声明
1.什么是类和对象
类是拥有相同属性和相同功能的对象的集合
对象就是类的实例（类都是抽象的、具体的）
从生活的角度来看类和对象
如果说人是一个类，余婷就是一个对象
如果说电脑是一个类，我桌上的这台电脑就是一个对象
如果水杯是一个类，具体的某一个水杯才是这个类的对象
如果车是一个类，汽车、自行车等这些是这个类的子类，具体的某一辆车才是对象
2.类的声明
格式：
class 类名（父类列表）：
类的说明文档
类的内容
说明：
class -> python中声明类的关键字
类名 -> 标识符，不能是关键字，类名使用驼峰式命名，并且首字母必须大写:见名知义
驼峰式命名：如果一个名字由多个单词组成，第一个单词首字母小写，后面每个单词首字母大写
userName
PEP8命名规范：如果一个名字由多个单词组成，所有字母小写，多个单词用下划线隔开
user_name
（父类列表） -> 继承语法，让声明的类继承括号中的父类，这个结构可以省略，
让当前类python的基类：object
: -> 固定结构
类的说明文档 —> 注释，对类进行说明
类的内容 --> 包含属性（数据）和方法（函数）
方法：声明在类中的函数
代码示例
# 声明人这个类，都可以吃饭和睡觉
class Person:
"""人类"""
def eat(self):
print('吃饭')
def sleep(self):
print('睡觉')
3.对象的声明
对象名= 类名（）
对象名 -> 变量名
类名 -> 必须是声明过的类
代码示例
# 声明了Person()
p1 = Person()
p2 = Person()
3.对象方法
1.
类的内容包含属性和方法，方法分为内对象方法、类方法和静态方法
对象方法：直接声明在类中的函数就是对象方法。对象方法都有一个参数self，通过对象来调用
对象调用：对象.方法名().调用对象的方法的时候，不要给默认参数self传参。
系统会自动将当前对象传递给self。
self:调用当前的对象方法，self就指向谁.self就是当前类的对象，类的对象能做的事情，self都能做
代码示例
class Person:
# 对象的方法eat
def eat(self, name):
print('self:', self)
print('吃饭！')
self.sleep()
def sleep(self):
print('s_self:', self)
print('睡觉')
p1 = Person()
print('p1:', p1)
p1.eat('小明')
p2 = Person()
print('p2:', p2)
p2.eat('小红')
运行结果
p1: <__main__.Person object at 0x000001E717428470>
self: <__main__.Person object at 0x000001E717428470>
吃饭！
s_self: <__main__.Person object at 0x000001E717428470>
睡觉
p2: <__main__.Person object at 0x000001E7174284E0>
self: <__main__.Person object at 0x000001E7174284E0>
吃饭！
s_self: <__main__.Person object at 0x000001E7174284E0>
睡觉
4.构造方法和init方法
1.构造方法
构造方法就是函数名和类名一样的方法，作用就是用来创建对象的。声明类的时候，系统会自动为这个类
创建对应的构造方法
创建对象的过程：调用构造方法在内存中开辟空间创建对象没并且会自动调用__init__方法去对这个对象
进行初始化,最后将创建好的对象的地址返回
2.__init__方法
对象方法
不需要手动调用，创建完对象后，会被自动调用
代码示例
class Dog:
"""类"""
def __init__(self):
print(self)
print('init方法')
dog1 = Dog()
print(dog1)
运行结果
class Dog:
"""类"""
def __init__(self):
print(self)
print('init方法')
dog1 = Dog()
print(dog1)
运行结果
<__main__.Dog object at 0x000001B38EA88438>
init方法
<__main__.Dog object at 0x000001B38EA88438>
3.带其他参数的init方法
__init__方法的参数要通过构造方法来传。构造方法的实参，会传给init方法的形参
代码示例
class Person:
def __init__(self, name='火', age=''):
print(name, age)
p1 = Person('小明', 45)
p2 = Person(age=89)
p3 = Person('小红')
运行结果
小明 45
火 89
小红
5.对象的属性
类的内容包含属性和方法，属性又分为对象属性和类的字段
属性：用来在类中保存数据的变量。
对象属性：属性的值会因为对象不同 而不同，这种属性就需要声明成对象属性，例如：人的名字、年龄等
对象属性要通过对象来使用
1.怎么声明对象属性（重点）
a.必须声明在__init__方法中
b.声明格式：self.属性名 = 初值
2.使用对象属性：对象.属性
3.创建对象的时候可以给对象属性赋值3.创建对象的时候可以给对象属性赋值
代码示例
class Person:
def __init__(self, name, age=0, sex='grile'):
self.name = name
self.age = age
self.sex = sex
p1 = Person('小明', 45, '男')
print(p1.name)
p2 = Person('小❀')
print(p2.name, p2.age, p2.sex)
运行结果
小明
小❀ 0 grile
6.对象属性的增删改查
1.查（获取对象属性的值）
方法一：对象.属性 --> 获取指定属性的值,属性不存在会报错
方法二:getattr(对象，'属性名'，默认值) 若属性名不存在，则返回默认值（若没有设置默认值。会报错）
方法三：对象.__getattribute__('属性名'） -> 获取指定属性值
代码示例
class Student:
def __init__(self, name='', age=0, study_id='001'):
self.name = name
self.age = age
self.study_id = study_id
stu1 = Student('小明')
stu2 = Student('小红')
print(stu1.name)
print(getattr(stu1, 'name'))
print(getattr(stu1, 'name', '张三'))
print(getattr(stu1, 'name1', '张三'))
print(stu1.__getattribute__('age'))
运行结果
小明
小明
小明
张三
0
2.增/改（给对象添加属性）
注意：给对象添加属性和只能添加到当前对象中，不会影响当前类的其他对象
方法一：对象.属性 = 值（属性不存在是增加，存在是修改）
方法二：setattr(对象，'属性名'，属性值)
方法三：对象.__setattr__('属性名'，属性值)
代码示例
stu1.sex = '男'
stu1.age = 2
print(stu1.sex)
print(stu1.age)
setattr(stu1, 'name', '李四')
print(stu1.name)
setattr(stu1, 'name2', '王腾')
print(stu1.name2)
运行结果
0
男
2
李四
王腾
3.删除（删除对象属性）
注意：删除只删除当前对象的属性，对当前类的其他对象没有影响
方法一：del 对象.属性
方法二：delattr(对象，'属性名')
方法三：对象.__delattr__('属性名')
代码示例
del stu1.name2
delattr(stu1, 'sex')
7.对象的使用
python中所有的数据都是对象，所有的变量存储的都是对象的地址
代码示例
import copy
class Student:
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
# 定制当前类对象的打印格式，函数返回必须以字符串返回
def __str__(self):
# return str(self.__dict__)
return str(self.__dict__)
# 1.将对象给别的变量赋值
stu1 = Student('xiaohu', 18, 90)
stu2 = stu1 # 赋对象地址
stu3 = copy.copy(stu1) # 产生新的对象，将新的地址赋值
stu1.name = '张三'
print(stu2.name)
print(stu3.name)
# 2.将对象作为列表的元素
students = [Student('小郭', 23, 98), Student('香锅', 18, 69), stu3]
# 找到列表students中成绩最好的学生的名字
max1 = students[0].score
name = students[0].name
for stu in students:
if stu.score > max1:
max1 = stu.score
name = stu.name
print(name, max1)
# 对列表中的学生从小到大排序
students.sort(key=lambda item: item.age)
# students.sort(key=lambda item: getattr(item, 'age'))
for stu in students:
print(stu)
max1 = max(students, key=lambda item: item.score)
print(max1)
# 根据姓名查找指定学生的信息，根据姓名修改指定学生的年龄
name = input('请输入学生的名字：')
for stu in students:
if stu.name == name:
print(stu)
运行结果
张三
xiaohu
小郭 98
{'name': '香锅', 'age': 18, 'score': 69}
{'name': 'xiaohu', 'age': 18, 'score': 90}
{'name': '小郭', 'age': 23, 'score': 98}
{'name': '小郭', 'age': 23, 'score': 98}
请输入学生的名字：香锅
{'name': '香锅', 'age': 18, 'score': 69}
8.slots魔法
1.类的字段
属性:对象属性，类的字段
类的字段：声明在类里面，函数外面的变量就是类的字段。使用的时候要用类来使用：类.字段
2.__slots__ 用来约束当前的对象的属性与那些
代码示例
class Dog:
# 类的字段
num = 10
__slots__ = ('color', 'name', 'type', 'sex')
def __init__(self, color, name, type):
self.color = color
self.name = name
self.type = type
self.sex = '公的'
print(Dog.num)
print(Dog.num)
dog1 = Dog('黄色', '大黄', '土狗')
运行结果
10
10
9.内置类属性
代码示例
class Person():
"""人类"""
# 类的字段
num = 61
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def run(self):
print('%s在跑' % self.name)
def __str__(self):
return '{' + self.__class__.__module__ + '.' +self.__class__.__name__ + \
'object at ' + hex(id(self)) + '}'
p1 = Person('小明', 18, '男')
# 1.__name__
"""
类.__name__ --> 获取当前类的名字
"""
print(Person.__name__)
# 2.__doc__
"""
类.__doc__ --> 获取类的说明文档
"""
print(Person.__doc__)
# 3.__class__
"""
对象.__class__ -> 获取对象的类
"""
print(Person.__class__)
my_class = p1.__class__
print(my_class('小花', 65, '女'))
p2 = my_class('小花', 65, '女')
print(p2.name)
# 4.__dict__
"""
类.__dict__ --> 获取当前类所有类的字段和对应的值，以字典返回（了解）
对象.__dict__ --> 获取当前对象所有的属性和其对应的值，以字典的形式返回
"""
print(Person.__dict__)
print(p1.__dict__)
# 5.
# 类.__module__ --> 获取当前类所在的模块
print(Person.__module__)
# 6.__bases__
"""
类.__bases__ -> 获取当前类的父类，返回的是一个元组，元组的元素是一个类
"""
print(Person.__bases__)
print(p1)
运行结果
Person
人类
<class 'type'>
{__main__.Personobject at 0x207886284a8}
小花
{'__module__': '__main__', '__doc__': '人类', 'num': 61, '__init__': <function Person.__init__ at 0x0000020788624D90>, 'run': <function Person.run at 0x000002078862B268>, '__str__': <function Person.__str__ at 0x000002078862B2F0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
{'name': '小明', 'age': 18, 'sex': '男'}
__main__
(<class 'object'>,)
{__main__.Personobject at 0x20788628438}
