day13 总结 - 类和对象

作者: Gary134 | 来源:发表于2018-11-24 17:25 被阅读0次

01.recode

一.json数据

1.json数据：a.只有一个数据 b.数据类型是json支持的类型

2.json数据转python
json.load(文件对象）
json.loads(字符串)

3.python数据转json
json.dump(数据，文件对象)
json.dumps(数据) - 字符串

import json
json.dumps('abc')   # -> '"abc"'
json.dumps([1, 2, 'aaa'])   # -> '[1, 2, "aaa"]

二.异常捕获

try - except - 捕获所有异常
try - except 异常类型 - 捕获指定一个异常
try - except （异常类型1，异常类型2，...） - 捕获多个指定异常
try - except 异常类型1 - except 异常类型2 - 捕获多个指定异常

try - except - finally - 不管try后面的代码有没有异常，异常是否能够捕获到，都会执行

三.抛出异常

raise 异常类型 - 让程序主动报错
异常类型 - 必须是Exception的子类

02.编程思想

1编程思想：
1.1 面向过程编程 - 逻辑、算法
遇到问题，考虑直接把逻辑思维转换成代码，解决问题

1.2 函数式编程 - 函数
遇到问题，考虑是否有一个这种功能的函数

1.3 面向对象编程 - 类和对象
遇到问题，就考虑是否有一个对象能够帮助解决问题

2.类和对象

1.定义
类：就是拥有相同属性和相同功能的对象的集合（类是抽象的）
对象：类的实例（对象是具体的）

2.从生活的角度考虑类的对象

03.类的声明

类：就是拥有相同属性和相同功能的对象的集合（类是抽象的）
对象：类的实例（对象是具体的）

1.类的声明

语法：
class 类名（父类列表）：
类的内容

说明：
class - 声明类的关键字
类名 - 标识符，不能是关键字（要求！）；
采用驼峰式命名，并且首字母要大写
见名知义
（父类列表） - 继承语法；可以省略，省略的时候相当于（object)
类的内容 - 主要包含属性和方法

补：驼峰式命名：名字由多个单词组成，通过单词首字母大写来区分不同的单词

studentName
userName

方法：声明在类中的函数就是方法

2.属性和方法

类中的属性 - 指的是在类中声明的变量；分为类的字段和对象属性
类中的方法 - 指的是在类中声明的函数；分为对象方法，类方法和静态方法

# 声明了一个Person类
class Person:
    """人类"""
    # 类的属性
    num1 = 23   # 类的字段

    # 类的方法
    def eat(self):
        print('人在吃饭！')

# Person是类(类就是类型)
print(Person)

3.创建对象

类名() --> 创建类对应的对象

# 创建Person类的对象xiao_ming
xiao_ming = Person()
print(xiao_ming)

04.对象方法

1.什么是对象方法

直接声明在类中，并且自带一个self的参数的函数

2.对象方法的调用 - 通过对象调用对象方法

对象.对象方法（）

3.self(当前对象）

通过对象调用对象方法的时候，对象方法中的第一个参数self不用传参，
系统会自动将当前对象传给self

哪个对象在调用的，self就指向谁。

注意:当前类的对象能做的事情，self都能做

class Person:
    """人类"""
    def __init__(self):
        self.name = ''

    # 声明了一个对象方法sleep
    def sleep(self, a):
        print('self:', self)
        print("睡觉！", a)
        self.run()

    def run(self):
        print('跑')

# 创建Person的对象p1
p1 = Person()
print('p1:', p1)
p1.sleep(10)

p1: <main.Person object at 0x021631B0>
self: <main.Person object at 0x021631B0>
睡觉！ 10
跑

05.init方法和构造方法

0.魔法方法

python类中，用开头并且是结尾的方法，就是魔法方法。
魔法方法不需要主动调用，都会自动调用。

1.init方法

a.是对象方法
b.不需要自己调用，会被自动调用
c.专门用来对对象进行初始化的

2.构造方法

概念：函数名和类名一样的函数，就是构造方法
当我们创建类的时候，系统会自动创建这个类的构造方法，用来创建对象
当我们通过构造方法创建对象的时候，系统会自动调用init方法来对创建好的对象进行初始化

注意：当init方法中除了self以外如果需要别的参数，那么这些参数是通过构造方法来传参的
只要调用了构造方法，就会产生新的对象。（想要对象，调用构造方法）

class Person:
    def __init__(self, name):
        print("init方法", name)

# def Person(*args, **kwargs):
    # 在堆中开辟空间创建对象
    # 对象.__init__()
   #  return 对象

p1 = Person('小明')
p2 = Person('小花')

init方法小明
init方法小花

06.对象属性

1.什么是对象属性

a.声明在init方法中
b.self.属性名 = 值
c.通过对象使用：对象.属性
d.

语法：
self.变量名 = 值

说明：变量名就是属性名，这个变量就是对象属性

2.什么样的属性应该声明成对象属性

如果属性的值会因为对象不同而不一样，那这样的属性就应该声明成对象属性。
反之就声明成类的字段

# 情况一：所有的对象属性创建的时候都是用一个固定的默认值
class Person:
    def __init__(self):
        # 这儿的name和age就是Person类的对象属性
        self.name = '张三'
        self.age = 0

# 创建对象
p1 = Person()

# 使用对象属性
print(p1.name)
p1.name = '李四'
print(p1.name)

张三
李四

# 情况二：创建对象的时候，决定对象属性的值
class Person:
    def __init__(self, name,age=1):
        self.name = name
        self.age = age


p1 = Person('小明')
p2 = Person('小龙', 10)
print(p1.name, p2.age)
print(p2.name, p1.age)
# 修改对象属性
p1.name = '老王'
print(p1.name, p1.age)

小明 10
小龙 1
老王 1

# practice：声明一个矩形类
class Rect():
    def __init__(self, length, width):
        self.length = length
        self.width = width

    # 一个对象方法需不需要除了self以外的其他参数，
    # 看实现这个函数的功能需不需要除了类的属性以外的其他数据
    def area(self):
        return self.length * self.width

    def perimeter(self):
        return 2 * (self.length + self.width)

r1 = Rect(10, 20)
print(r1.area())
print(r1.perimeter())

r2 = Rect(3, 5)
print(r2.area())
print(r2.perimeter())

200
60
15
16

# practice2：声明一个Point类，拥有属性x坐标和y坐标。
# 功能：求两个点之间的距离。

class Ponit():
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def distance(self, other):
        return ((self.x - other.x)**2 + (self.y - other.y)**2) ** 0.5


p1 = Ponit(3, 12)
p2 = Ponit(6, 6)
# 求p1到p2的距离
print(p1.distance(p2))

6.708203932499369

07.对象属性的增删改查

class Dog:
    def __init__(self, name, color, type=None):
        self.name = name
        self.color = color
        self.type = type


dog1 = Dog('旺财', '黄色', '二哈')
dog2 = Dog('才才', '黑色', '土狗')

1.查(获取对象属性的值)

获取指定对象指定属性的值
a.对象.属性 - 属性不存在的时候会报错
b.getattr(对象, 属性名, 默认值) - 属性不存在的时候，如果设置了默认值，程序不崩溃，而是返回默认值

print(dog1.name)
# print(dog1.name1)  # AttributeError: 'Dog' object has no attribute 'name1'

print(getattr(dog1, 'color'))
print(getattr(dog1, 'name1', None))

旺财
黄色
None

2.增、改

a.对象.属性 = 值
b.setattr(对象, 属性名, 值)

注意：属性存在的时候，对应的功能是修改属性的值。当属性不存在的时候是添加属性

dog1.name = '大黄'    # 修改
print(dog1.name)

dog1.sex = '公'    # 添加
print(dog1.sex)

setattr(dog1, 'name', '热狗')  # 修改
print(dog1.name)

setattr(dog1, 'name2', '肉狗')  # 添加
print(dog1.name2)

大黄
公
热狗
肉狗

3.删除

a. del 对象.属性
b. delattr(对象, 属性名)

del dog1.name
# print(dog1.name)    # AttributeError: 'Dog' object has no attribute 'name'

delattr(dog1, 'color')
# print(dog1.color)  # AttributeError: 'Dog' object has no attribute 'color'

注意： 对象属性的增删改查，都是针对指定的那一个对象，不会影响其他对象

4.slots魔法

slots是用来约束当前这个类有哪些对象属性

class Student:
    # Student类的对象只能有name,study_id,age和sex属性
    __slots__ = ('name', 'study_id', 'age', 'sex')

    def __init__(self, name, age):
        self.name = name
        self.study_id = '001'
        self.age = age
        # self.sex = ''


stu1 = Student('夏明', 18)
# stu1.neme = '小明'
stu1.sex = '男'

08.类的字段和内置类属性

1.类的字段

a.直接声明在类里面，函数的外面的变量就是类的字段
b.类的字段需要通过类来使用：类.字段 - (不管是在类里面还是类的外面都一样)

不会因为对象不同而不一样的数据就声明成类的字段

class Person:
    # 声明了一个字段number
    number = 61

    def show_number(self):
        print('人类的数量：%d' % Person.number)


print(Person.number)
Person().show_number()

61
人类的数量：61

2.内置类属性

内置属性就是声明类的时候，类中已经声明好的属性(包含类的字段和对象的属性)

class Dog:
    """说明文档:狗类"""
    # 类的字段
    type = '犬科'

    # 对象属性
    def __init__(self, name='', age=0, color=''):
        self.name = name
        self.age = age
        self.color = color

    # 对象方法
    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

    # 类方法
    @classmethod
    def shout(cls):
        print('汪汪汪~~~~')

    # 静态方法
    @staticmethod
    def bite():
        print('狗咬人！！！')


dog1 = Dog('小黑', 3, '黑色')

a.name

类.name - 获取类的名字(字符串)

class_name = Person.__name__
print(class_name, type(class_name))

# with open(Person.__name__+'.json', 'w') as f:
#     pass

Person <class 'str'>

b.class

对象.class - 获取对象对应的类(结果是一个类，原来类能做的事情它都可以做)

aa = dog1.__class__

d1 = Dog()
d2 = aa()
print(d1, d2)

print(Dog.type)
print(aa.type)

print(dog1.__class__.__name__)   # 获取对象对应的类的名字

<main.Dog object at 0x00603A70> <main.Dog object at 0x00603AB0>
犬科
犬科
Dog

c.dict

(了解)类.dict - 获取当前类的所有的类的字段及其对对应的值
(重点)对象.dict - 将当前对象所有的对象属性及其值转换成字典,key是属性名,value是属性的值

print(Dog.__dict__)
print(dog1.__dict__)

{'module': 'main', 'doc': '说明文档:狗类', 'type': '犬科', 'init': <function Dog.init at 0x006054F8>, 'eat': <function Dog.eat at 0x006054B0>, 'shout': <classmethod object at 0x0048C370>, 'bite': <staticmethod object at 0x006039F0>, 'dict': <attribute 'dict' of 'Dog' objects>, 'weakref': <attribute 'weakref' of 'Dog' objects>}

{'name': '小黑', 'age': 3, 'color': '黑色'}

d.bases

类.bases - 获取当前类的父类(以元祖的形式返回，元祖中的元素就是类的父类)

print(Dog.__bases__)

(<class 'object'>,)

e.module

类.module - 获取当前类所在的模块的模块名

print(Dog.__module__)
print(int.__module__)

main
builtins

f.doc

类.doc - 获取类的说明文档

print(Dog.__doc__)
print(int.__doc__)

说明文档:狗类

int(x=0) -> integer
int(x, base=10) -> integer
int(x=0) -> integer
int(x, base=10) -> integer
Convert a number or string to an integer, or return 0 if no arguments
are given. If x is a number, return x.int(). For floating point
numbers, this truncates towards zero.
If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance representing an integer literal in the
given base. The literal can be preceded by '+' or '-' and be surrounded
by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
Base 0 means to interpret the base from the string as an integer literal.

int('0b100', base=0)
4