1.編程思想

• 1.編程思想

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

2.函數(shù)式編程 - 函數(shù)
遇到問題，直接考慮是否有一個這種功能的函數(shù)

3.面向?qū)ο缶幊?- 類和對象
遇到問題，就考慮是否有一個對象能夠幫我解決這個問題

• 2.類和對象

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

2.從生活的角度來看對象
如果電腦是一個類，每一臺具體的電腦就是一個對象
如果學(xué)生是一個類，每一名具體的學(xué)生就是一個對象

2.類的聲明

1.類的聲明
語法：
class 類名(父類列表):
類的內(nèi)容

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

駝峰式命名：名字有多個單詞組成通過單詞首字母大寫來區(qū)分不同的單詞
studentName,userName...
方法：聲明在類中的函數(shù)就是方法

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

class Person:
    """人類"""
    # 屬性
    num = 61

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


print(Person)

3.創(chuàng)建對象
類名（） - 創(chuàng)建類對應(yīng)的對象

• 創(chuàng)建Person類的對象xiao_ming

xiao_ming = Person()
print(xiao_ming)

3.對象方法

1.什么是對象方法
直接聲明在類中，并且自帶self的參數(shù)

2.對象方法的調(diào)用 - 通過對象調(diào)用對象方法
對象.對象方法()
（可以通過類來調(diào)用對象方法，但是需要給self傳參，一般不用）

3.self(當(dāng)前對象)
對象方法的第一個參數(shù)self不用傳參，系統(tǒng)會自動的將當(dāng)前對象傳給self
哪個對象調(diào)用的，self就是誰。當(dāng)前對象能做的self都能做

class Person:
    """人類"""

    # 聲明了一個對象方法
    def sleep(self, a):
        # self = p1, a = 10
        print('睡覺', a, self)
        self.run()

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


p1 = Person()
p1.sleep(10)
print(p1)

4.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ò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 run(self):
        print('跑')
"""
def Person(*args, **kwargs):
    在堆中開辟空間創(chuàng)建對象
    對象.__init__()
    return 對象
"""
p1 = Person('小明')
p1.run()

• 模擬構(gòu)造方法和init方法

def __init__(a, b):
    print('自己實(shí)現(xiàn)：', a, b)


def Func1(*args, **kwargs):
    print('創(chuàng)建對象')
    __init__(*args)
    print('返回對象')


Func1(10, 20)

5.對象屬性

1.什么是對象屬性
a.聲明在__ init __方法中
b.self.屬性名 = 值
c.通過對象來使用： 對象.屬性

語法：
self.變量名 = 值
說明：變量名就是屬性名，這個變量就是對象屬性

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

• 情況一：所有的對象屬性創(chuàng)建的時(shí)候都使用一個固定的屬性

class Person:
    def __init__(self):
        # 這里的name和age就是Person類的對象屬性
        self.name = ''
        self.age = 18


# 創(chuàng)建對象
p1 = Person()
p1.name = '張三'
print(p1.name, p1.age)

p2 = Person()
p2.name = '小紅'
print(p2.name, p1.name)

• 情況二：創(chuàng)建對象的時(shí)候，決定對象屬性的值

class Person:
    def __init__(self, name, age=0):
        # 這里的name和age就是Person類的對象屬性
        self.name = name
        self.age = age


p3 = Person('李四', 20)
print(p3.name, p3.age)
# 修改對象屬性的值
p3.age = 18
print(p3.age)

• 練習(xí)：聲明一個矩形類

class Rect:
    def __init__(self, length, width):
        self.angie1 = '90°'
        self.angie2 = '90°'
        self.angie3 = '90°'
        self.angie4 = '90°'
        self.sidenum = 4
        self.length = length
        self.width = width
    # 一個對象方法需不需要除了self以外的其他參數(shù)，
    # 看實(shí)現(xiàn)這個函數(shù)的功能需不需要除了屬性外的其他數(shù)據(jù)
    def area(self):
        area = self.length * self.width
        return '面積是%.2f' % area

    def peri(self):
        peri = (self.length + self.width) * 2
        return '周長是%.2f' % peri


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

• 練習(xí)：聲明一個Point類，擁有屬性x坐標(biāo)和y坐標(biāo)。求兩個點(diǎn)之間的距離

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance(self, other):
        distance = ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5
        return '兩點(diǎn)之間的距離是%.2f' % distance


d1 = Point(1, 2)
d2 = Point(-5, 6)
print(d1.distance(d2))

6.對象屬性的增刪改查

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


dog1 = Dog('旺財(cái)', '黃色', '二哈')

• 1.查（獲取對象屬性的值）

a.對象.屬性名 (如果屬性不存在會報(bào)錯)
b.getattr(對象, 屬性名, 默認(rèn)值) （如果屬性不存在,給個默認(rèn)值不會報(bào)錯,返回默認(rèn)值）

print(dog1.name)
print(getattr(dog1, 'color', '黑色'))

• 2.增、改
  """
  a.對象.屬性 = 值 - 當(dāng)屬性存在，修改；不存在，添加
  b.setattr(對象, 屬性名, 值)

dog1.name = '小白'
setattr(dog1, 'name', '大黃')

• 3.刪除

a.del 對象.屬性
b.delattr(對象, 屬性名)

del dog1.name
delattr(dog1, 'color')

注意：對象屬性的增刪改查,都是針對指定的那一個對象

• 4.__ slots __魔法

__ slots __是用來約束當(dāng)前這個類有哪些對象屬性
如果給類的slots賦了值，那么這個類的對象的dict屬性就不能用了

class Student:
    __slots__ = ('name', 'id', 'age')

    def __init__(self, name, age):
        self.name = name
        self.id = '001'
        self.age = age


stu1 = Student('小明', 18)
# stu1.neme = '小紅'

7.類的字段和內(nèi)置類屬性

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

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

class Person:
    # 聲明了一個字段number
    number = 61

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


print(Person.number)

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('小黑', 6, '黑色')

• a.__ name __

類.__ name __ - 獲取類的名字(字符串)

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

• b.__class __

對象.__ class __ - 獲取對象對應(yīng)的類(結(jié)果是一個類，原來類能做的他都能做)

a = dog1.__class__
print(Dog.__class__)
print(dog1.__class__)
d1 = Dog()
d2 = a()
print(d1, d2)

print(Dog.type)
print(a.type)

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

• c.__ dict __

（了解）類.__ dict __ - 獲取當(dāng)前類的所有類的字段及其對應(yīng)的值，以字典的形式返回
（重點(diǎn)）對象.__ dict __ - 將當(dāng)前所有的對象屬性及其值轉(zhuǎn)換成字典，key是屬性名,value是屬性的值

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

• d. __ bases __

類.__base __ - 獲取當(dāng)前類的父類(以元組的形式返回，元組中的元素就是類的父類)

print(Dog.__bases__)

• e.__ module __

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

print(Dog.__module__)

• f.__doc __

類.__ doc __ - 獲取當(dāng)前類的說明文檔

print(Dog.__doc__)