1.recode

1.json数据：a.只能有一个数据，并且这个数据必须是json支持的类型的数据

2.json支持的数据类型：

• 1.数字类型
• 2.字符串（双引号引起来的）
• 3.布尔
• 4.数组
• 5.字典
• 6.特殊值

3.json与python数据的转换

json.load(文件对象) - 将json文件里面的数据转换成python数据
json.loads（字符串）- 将json数据转换成python数据
json.dump（文件对象）- 将python文件里面的数据转换成json数据
json.dumps（字符串）- 将python数据转换成json数据

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

二.异常捕获

try: - except:捕获所有异常
try: - except 异常类型: 捕获指定异常
try: - except （异常类型1，异常类型2）： 捕获多个指定异常，做出相同反应
try：- except 异常类型1：- except 异常类型2： 捕获多个异常，做出不同反应

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

三.抛出异常

raise 异常类型
异常类型必须是一个类，并且这个类是exception的子类

---

2.编程思想

1.编程思想：

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

• 2.函数式编程 - 函数
  遇到问题，考虑是否有这样一种功能的函数

• 3.面向对象编程 - 类和对象
  遇到问题，就考虑是否有一个对象能够帮我解决这个问题

2.类和对象

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

• 2.从生活的角度来考虑类和对象
  如果"人"是一个类，"曾宇"就是一个对象，"李龙"也是一个对象
  如果"骚猪儿"是一个类，"曾宇"就是一个对象

---

3.类的声明

1.类的声明

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

• 说明：

• class - 声明类的关键字

• 类名 - 标识符，不能是关键字（驼峰式命名），并且类名首字母要大写
  （父类列表） - 继承语句；（可以省略），省略的时候相当于（objct）

• 类的内容 - 主要包含：类的属性和方法

补：驼峰式命名：如果名字由多个单词组成，通过单词首字母大写，来区分不同的单词
补：声明在类里面的函数就叫方法

2.属性和方法

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

class Person:
    """人类"""
    #=======属性======
    num = 61 #类的字段
    #=======方法======
    def eat(self):
        print("人在吃饭")

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

3.创建对象
语法：
类名() - 创建一个类对应的对象

#创建一个Person类的对象xiao_ming
xiao_ming =Person()
print(xiao_ming) #<__main__.Person object at 0x0000000002498A58>

---

4.对象方法

1.什么是对象方法

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

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

对象.对象方法（）

3.self（当前对象）

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

注意：当前类的对象能做的时候，self都能做，必须是通过对象调用才有用

# 声明Person类
class Person:
    """人类"""
    #声明了一个对象方法sleep
    def sleep(self):
        print("睡觉")
        self.run()
    def run(self):
        print("跑")
#创建一个Person类的对象i
i =Person()
i.sleep()

---

5.init方法和构造方法

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

1. __ init __ 方法：

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

2.构造方法

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

注意：当init方法中除了self以外，如果需要别的参数，那么这些参数是通过构造方法来传的参

class Person:
    #声明一个对象方法
    def __init__(self):
        print("init方法")

p1 =Person()

def __func2__(a,b):
    print("__func2__方法",a,b)
def func1(*args,**kwargs):
    print("创建对象")
    __func2__(*args,**kwargs)
    print("返回对象")
func1(50,b=30)

---

6.对象属性

1.什么是对象属性

• a.声明在 __ init__方法中
• b.self.属性名 = 值
• c.通过对象来使用： 对象.属性
• d.不同的对象，对象属性的值可能会不一样

• 语法：
  self.属性名 = 值

• 说明：
  这个属性就是对象属性

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

#创建对象
p1 =Person()
#使用对象属性
p1.name ="滴滴滴"
print(p1.name)
#情况二.

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

p2 = Person("曾宇")
p3 =Person("是帅逼")
print(p2.name,p3.name)
#修改对象属性的值
p2.name = "龙少爷"
print(p2.name,p3.name)

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

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

#练习：声明一个矩形类

class JuXing:
    def __init__(self,long,wide):
        self.chang =long
        self.kuan = wide
    #一个对象方法需不需要除了self以外的其他参数，看实现这个函数的功能
    # 需不需要出了对象属性以外的其他数据
    def area(self):
        #self = p1
        return self.chang*p1.kuan

p1 =JuXing(20,10)
print("面积：",p1.area())

#练习：声明一个point类，拥有属性x坐标和y坐标，拥有的功能是求两点之间的距离
class Point:
    def __init__(self,x,y):
        self.x_coor =x
        self.y_coor =y
    def distance(self,x1,y1):
        return ((self.x_coor-x1)**2+(self.y_coor-y1)**2)**0.5

r1 =Point(10,20)
print("距离：",r1.distance(10,30))

#最佳方法：
class Point:
    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

r1 =Point(10,0)
r2 =Point(0,0)
print(r1.distance(r2))

---

7.对象属性的增删改查

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

dog1 =Dog("旺财","黄色","二哈")

#1.查（获取对象属性的值）
"""
a.对象.属性名 -属性不存在时会报错
b.getattr(对象,属性名,默认值) -给了默认值之后，如果属性不存在的时候会返回默认值

"""
print(dog1.name) #"旺财"
# print(dog1.name1) #AttributeError: 'Dog' object has no attribute 'name1'
print(getattr(dog1,"name"))#"旺财"
# print(getattr(dog1,"nam1",None)) #None

try:
    print(dog1.name1)
except AttributeError:
    print(None) #None

#2.增、改
"""
a.对象.属性 = 值 （属性存在时是修改，属性不存在时是添加）
b.setattr(对象，属性名，值)

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

dog1 =Dog("旺财","黄色","二哈")
dog1.aaa =20
print(dog1.aaa) #20 添加
dog1.name ="才才"
print(dog1.name) #才才  修改

#3.删
"""
del 对象.属性 - 将指定对象的指定属性删除

delattr(对象，属性名)

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

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

# 4.__slots__ 魔法
"""
是用来约束当前这个类有哪些对象属性

"""
class Student:
    #Student类的对象只能有name，id，age属性
    __slots__ =("name","id","age")
    def __init__(self,name,age):
        self.name=name
        self.id ="001"
        self.age=age

stu1 =Student("小明",18)
stu1.name = "小花"

---

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

1.类的字段

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

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

class Person:
    #声明一个类的字段
    number =61
    def show_number(self):
        print("人的数量%s"%Person.number)


Person.number =20
print(Person.number)

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("小黑",10,"黄色")
# a.__name__
"""
类.__name__ - 获取类的名字（字符串）

"""
print(Person.__name__,type(Person.__name__)) #Person <class 'str'>

# b.__class__
"""
对象.__class__ -获取对象对应的类(结果是一个类，原来类能做的事情它都能做)

"""
a =dog1.__class__
print(a.__name__) #Dog <class"str">
print(Dog.type)#犬科
print(a.type) #犬科


#c.__dict__ (返回的是字典)
"""
类.__dict__ -  获取当前类的所有的类的字段及其对应的值
(重点)对象.__dict__ - 将当前对象所有的属性及其值转换成字典，key是属性名，value是属性的值 

"""
print(dog1.__dict__)
#d.__base__（返回的是元组，元素就是父类）
"""
类.__basa__ 获取当前类的父类

"""
print(Dog.__bases__) #(<class 'object'>,)

#e.__module__
"""
类.__module__ - 获取当前类所在的模块的模块名

"""
print(Dog.__module__)  #__main__

#f.__doc__
"""
类.__doc__ - 获取类的说明文档

"""
print(Dog.__doc__) #说明文档：狗类