01.recode

一.json數(shù)據(jù)

1.json數(shù)據(jù)：a.只有一個(gè)數(shù)據(jù) b.數(shù)據(jù)類型是json支持的類型

2.json數(shù)據(jù)轉(zhuǎn)python
json.load(文件對象）
json.loads(字符串)

3.python數(shù)據(jù)轉(zhuǎn)json
json.dump(數(shù)據(jù)，文件對象)
json.dumps(數(shù)據(jù)) - 字符串

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

二.異常捕獲

try - except - 捕獲所有異常
try - except 異常類型 - 捕獲指定一個(gè)異常
try - except （異常類型1，異常類型2，...） - 捕獲多個(gè)指定異常
try - except 異常類型1 - except 異常類型2 - 捕獲多個(gè)指定異常

try - except - finally - 不管try后面的代碼有沒有異常，異常是否能夠捕獲到，都會執(zhí)行

三.拋出異常

raise 異常類型 - 讓程序主動報(bào)錯
異常類型 - 必須是Exception的子類

02.編程思想

1編程思想：
1.1 面向過程編程 - 邏輯、算法
遇到問題，考慮直接把邏輯思維轉(zhuǎn)換成代碼，解決問題

1.2 函數(shù)式編程 - 函數(shù)
遇到問題，考慮是否有一個(gè)這種功能的函數(shù)

1.3 面向?qū)ο缶幊?- 類和對象
遇到問題，就考慮是否有一個(gè)對象能夠幫助解決問題

2.類和對象

1.定義
類：就是擁有相同屬性和相同功能的對象的集合（類是抽象的）
對象：類的實(shí)例（對象是具體的）

2.從生活的角度考慮類的對象

03.類的聲明

類：就是擁有相同屬性和相同功能的對象的集合（類是抽象的）
對象：類的實(shí)例（對象是具體的）

1.類的聲明

語法：
class 類名（父類列表）：
類的內(nèi)容

說明：
class - 聲明類的關(guān)鍵字
類名 - 標(biāo)識符，不能是關(guān)鍵字（要求！）；
采用駝峰式命名，并且首字母要大寫
見名知義
（父類列表） - 繼承語法；可以省略，省略的時(shí)候相當(dāng)于（object)
類的內(nèi)容 - 主要包含屬性和方法

補(bǔ)：駝峰式命名：名字由多個(gè)單詞組成，通過單詞首字母大寫來區(qū)分不同的單詞

studentName
userName

方法：聲明在類中的函數(shù)就是方法

2.屬性和方法

類中的屬性 - 指的是在類中聲明的變量；分為類的字段和對象屬性
類中的方法 - 指的是在類中聲明的函數(shù)；分為對象方法，類方法和靜態(tài)方法

# 聲明了一個(gè)Person類
class Person:
    """人類"""
    # 類的屬性
    num1 = 23   # 類的字段

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

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

3.創(chuàng)建對象

類名() --> 創(chuàng)建類對應(yīng)的對象

# 創(chuàng)建Person類的對象xiao_ming
xiao_ming = Person()
print(xiao_ming)

04.對象方法

1.什么是對象方法

直接聲明在類中，并且自帶一個(gè)self的參數(shù)的函數(shù)

2.對象方法的調(diào)用 - 通過對象調(diào)用對象方法

對象.對象方法（）

3.self(當(dāng)前對象）

通過對象調(diào)用對象方法的時(shí)候，對象方法中的第一個(gè)參數(shù)self不用傳參，
系統(tǒng)會自動將當(dāng)前對象傳給self

哪個(gè)對象在調(diào)用的，self就指向誰。

注意:當(dāng)前類的對象能做的事情，self都能做

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

    # 聲明了一個(gè)對象方法sleep
    def sleep(self, a):
        print('self:', self)
        print("睡覺！", a)
        self.run()

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

# 創(chuàng)建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方法和構(gòu)造方法

0.魔法方法

python類中，用開頭并且是結(jié)尾的方法，就是魔法方法。
魔法方法不需要主動調(diào)用，都會自動調(diào)用。

1.init方法

a.是對象方法
b.不需要自己調(diào)用，會被自動調(diào)用
c.專門用來對對象進(jìn)行初始化的

2.構(gòu)造方法

概念：函數(shù)名和類名一樣的函數(shù)，就是構(gòu)造方法
當(dāng)我們創(chuàng)建類的時(shí)候，系統(tǒng)會自動創(chuàng)建這個(gè)類的構(gòu)造方法，用來創(chuàng)建對象
當(dāng)我們通過構(gòu)造方法創(chuàng)建對象的時(shí)候，系統(tǒng)會自動調(diào)用init方法來對創(chuàng)建好的對象進(jìn)行初始化

注意：當(dāng)init方法中除了self以外如果需要別的參數(shù)，那么這些參數(shù)是通過構(gòu)造方法來傳參的
只要調(diào)用了構(gòu)造方法，就會產(chǎn)生新的對象。（想要對象，調(diào)用構(gòu)造方法）

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

# def Person(*args, **kwargs):
    # 在堆中開辟空間創(chuàng)建對象
    # 對象.__init__()
   #  return 對象

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

init方法 小明
init方法 小花

06.對象屬性

1.什么是對象屬性

a.聲明在init方法中
b.self.屬性名 = 值
c.通過對象使用： 對象.屬性
d.

語法：
self.變量名 = 值

說明：變量名就是屬性名，這個(gè)變量就是對象屬性

2.什么樣的屬性應(yīng)該聲明成對象屬性

如果屬性的值會因?yàn)閷ο蟛煌灰粯?，那這樣的屬性就應(yīng)該聲明成對象屬性。
反之就聲明成類的字段

# 情況一：所有的對象屬性創(chuàng)建的時(shí)候都是用一個(gè)固定的默認(rèn)值
class Person:
    def __init__(self):
        # 這兒的name和age就是Person類的對象屬性
        self.name = '張三'
        self.age = 0

# 創(chuàng)建對象
p1 = Person()

# 使用對象屬性
print(p1.name)
p1.name = '李四'
print(p1.name)

張三
李四

# 情況二：創(chuàng)建對象的時(shí)候，決定對象屬性的值
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：聲明一個(gè)矩形類
class Rect():
    def __init__(self, length, width):
        self.length = length
        self.width = width

    # 一個(gè)對象方法需不需要除了self以外的其他參數(shù)，
    # 看實(shí)現(xiàn)這個(gè)函數(shù)的功能需不需要除了類的屬性以外的其他數(shù)據(jù)
    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：聲明一個(gè)Point類，擁有屬性x坐標(biāo)和y坐標(biāo)。
# 功能：求兩個(gè)點(diǎn)之間的距離。

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('旺財(cái)', '黃色', '二哈')
dog2 = Dog('才才', '黑色', '土狗')

1.查(獲取對象屬性的值)

獲取指定對象指定屬性的值
a.對象.屬性 - 屬性不存在的時(shí)候會報(bào)錯
b.getattr(對象, 屬性名, 默認(rèn)值) - 屬性不存在的時(shí)候，如果設(shè)置了默認(rèn)值，程序不崩潰，而是返回默認(rèn)值

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

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

旺財(cái)
黃色
None

2.增、改

a.對象.屬性 = 值
b.setattr(對象, 屬性名, 值)

注意：屬性存在的時(shí)候，對應(yīng)的功能是修改屬性的值。當(dāng)屬性不存在的時(shí)候是添加屬性

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'

注意： 對象屬性的增刪改查，都是針對指定的那一個(gè)對象，不會影響其他對象

4.slots魔法

slots是用來約束當(dāng)前這個(gè)類有哪些對象屬性

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.類的字段和內(nèi)置類屬性

1.類的字段

a.直接聲明在類里面，函數(shù)的外面的變量就是類的字段
b.類的字段需要通過類來使用： 類.字段 - (不管是在類里面還是類的外面都一樣)

不會因?yàn)閷ο蟛煌灰粯拥臄?shù)據(jù)就聲明成類的字段

class Person:
    # 聲明了一個(gè)字段number
    number = 61

    def show_number(self):
        print('人類的數(shù)量：%d' % Person.number)


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

61
人類的數(shù)量：61

2.內(nèi)置類屬性

內(nèi)置屬性就是聲明類的時(shí)候，類中已經(jīng)聲明好的屬性(包含類的字段和對象的屬性)

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('汪汪汪~~~~')

    # 靜態(tài)方法
    @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 - 獲取對象對應(yīng)的類(結(jié)果是一個(gè)類，原來類能做的事情它都可以做)

aa = dog1.__class__

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

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

print(dog1.__class__.__name__)   # 獲取對象對應(yīng)的類的名字

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

c.dict

(了解)類.dict - 獲取當(dāng)前類的所有的類的字段及其對對應(yīng)的值
(重點(diǎn))對象.dict - 將當(dāng)前對象所有的對象屬性及其值轉(zhuǎn)換成字典,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 - 獲取當(dāng)前類的父類(以元祖的形式返回，元祖中的元素就是類的父類)

print(Dog.__bases__)

(<class 'object'>,)

e.module

類.module - 獲取當(dāng)前類所在的模塊的模塊名

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