July 31-day14-Python面向?qū)ο?/h2>

yield關(guān)鍵字和生成器

  1. 生成器：a.可以看成是一個可以存儲多個數(shù)據(jù)的容器。需要里的數(shù)據(jù)的時候就生成一個，里面的數(shù)據(jù)只能從前往后一個一個的生成.
    不能跳躍，也不能從后往前。生成的數(shù)據(jù)，不能再生成了
    b.獲取生成器里面的數(shù)據(jù)，需要使用_next_（）方法
    c.只要函數(shù)聲明中有yield關(guān)鍵字,函數(shù)就不再是一個單純的函數(shù)，而變成一個生成器

  2. 和列表比較：列表存數(shù)據(jù)，數(shù)據(jù)必須是實實在在存在的數(shù)據(jù)，一個數(shù)據(jù)會占一定的內(nèi)存空間。
    生成器存數(shù)據(jù)，存的是產(chǎn)生數(shù)據(jù)的算法，沒有數(shù)據(jù)去占內(nèi)存空間

def xu_lie(n):
    pre_1 = 1
    pre_2 = 1
    for x in range(1,n+1):
        if x== 1 or x==2:
            current = 1
            yield current
            # print(current)
            continue
        current = pre_1+pre_2
        pre_1,pre_2=pre_2,current
        # print(current)
        yield current

if __name__ == '__main__':

    x = (i for i in range(10))

    print(x)
    print(x.__next__())   #生成0
    print(x.__next__())    #生成1
    print('===')
    print(x.__next__())     #生成2
    number = 0

    xulie = xu_lie(10)
    print(xulie,type(xulie))
    print(xulie.__next__())
    print(xulie.__next__())
    print(xulie.__next__())
    print(xulie.__next__())
    print(xulie.__next__())
    for x in xulie:
        print('*',x)
結(jié)果：
<generator object <genexpr> at 0x02810750>
0
1
===
2
<generator object xu_lie at 0x02810870> <class 'generator'>
1
1
2
3
5
* 8
* 13
* 21
* 34
* 55

什么是面向?qū)ο?/h2>

  1. 什么是類：對擁有相同屬性和功能的對象的封裝
    類是抽象
    類中相同的屬性的值是不能確定的

  2. 什么是對象：對象就是類的實例
    對象是具體
    對象的屬性是確定的
    如果說人是一個類，那么我就是人的一個對象
    如果電腦是一個類，我桌上的這臺電腦就是一個對象
    如果說杯子是一個類型，我桌上這個透明的水杯就是一個對象

  3. 面向?qū)ο缶幊?br> 面向過程編程：一步一步的寫代碼實現(xiàn)功能 --> 工具：邏輯和算法
    函數(shù)式編程：面對問題考慮有沒有擁有某種功能函數(shù) --> 工具：函數(shù)
    面向?qū)ο缶幊蹋好鎸栴}考慮有沒有相應(yīng)的對象來解決這個問題 --> 工具：類和對象

類的聲明

  1. 類的聲明：
    class 類名（父類）：
    屬性
    方法
  • class：python中聲明類的關(guān)鍵字
  • 類名：標識符，類名的首字母大寫，駝峰式命名
  • （）：類要繼承自其他的類，需要寫括號，括號里面是父類的名字?？梢允÷?/li>
  • 屬性：對象屬性和類的字段 --- 保存數(shù)據(jù)
  • 方法：實質(zhì)就是聲明在類中的函數(shù) --- 實現(xiàn)功能
class Person:
    """類的說明：人類"""

    #聲明兩個對象方法，需要使用對象來調(diào)用
    """
    對象方法默認都有一個參數(shù)self，在調(diào)用方法的時候，這個參數(shù)不用傳參（系統(tǒng)會自動給self傳參）
    誰來調(diào)用這個方法，self就是誰
    """
    def eat(self):
        print('=',self)
        print('在吃飯')
    def sleep(self):
        print('在睡覺，(～﹃～)~zZ')

if __name__ == '__main__':
    # 2.聲明對象
    p1 = Person()
    print(p1)

    # 一個類可以有多個對象
    p2 = Person()
    print(p2)
    #對象可以調(diào)用對象方法
    p1.eat()
    p1.sleep()
    p2.eat()
    p2.sleep()
  1. 聲明對象：
    通過類的構(gòu)造方法去創(chuàng)建對象（名字和類名同名的方法就是構(gòu)造方法）
    對象名= 類名（）
  • 類對象可以通過點語法使用類中聲明的對象的方法和屬性
  • 對象.方法名（）
  • 對象.屬性名

對象的屬性

  1. 對象屬性的聲明
  • class 類名：
    def init(self):
    self.屬性名 = 初值
    self.屬性名2 = 初值2
class Person:
    """人類"""
    """
    init方法是系統(tǒng)自帶的一個方法，這個方法不能直接調(diào)用，通過類創(chuàng)建對象的時候系統(tǒng)會自動調(diào)用這個方法
    init方法的作用是對對象的屬性進行初始化
    通過構(gòu)造方法創(chuàng)建對象的時候，一定要保證，init方法中除了self以外，其他的每個參數(shù)都必須有值
    
    """
    def __init__(self,name1='',age1=0,sex1='man'):
        # 在這個地方聲明對象的屬性
        # print('***')
        # print(name1)
        # print(age1)
        # 在init方法中聲明對象的屬性
        """
        name、age和sex就是Person這個類的對象屬性。類的對象屬性，需要通過對象來使用
        """
        self.name = name1
        self.age = age1
        self.sex = sex1

if __name__ == '__main__':
    # 注意：構(gòu)造方法中的參數(shù)，實質(zhì)是傳給init方法的參數(shù)的
    p1 = Person('dalao',18)
    # 通過對象使用對象屬性
    print(p1.name,p1.age,p1.sex)

    p2 = Person('羅昊',30)
    print(p2.sex,p2.name)

    # 創(chuàng)建對象的時候不給屬性賦值

    p3 = Person(age1=10)
    print(p3.age)
結(jié)果：
dalao 18 man
man 羅昊
10

對象屬性的增刪改查

class Dog:
    """狗類"""
    def __init__(self, age=0, color='yellow'):
        self.age = age
        self.color = color

if __name__ == '__main__':

    dog1 = Dog(3,'black')

    # 1.查（獲取屬性）
    """
    方法一：對象.屬性（如果屬性不存在，會報錯）
    方法二：對象.__getattribute__(屬性名) 和 getattr(對象,屬性名，默認值)
    
    """
    print(dog1.age,dog1.color)
    print(dog1.__getattribute__('age'))
    print(getattr(dog1,'age'))
    # 如果設(shè)置了default的值，那么當屬性不存在的時候不會報錯，并且返回默認值
    print(getattr(dog1, 'abc','無名氏'))
    # 2.改（修改屬性的值）
    """
    方法一： 對象.屬性 = 新值
    方法二： 對象.__setattr__(屬性名，新值) 和 setattr（對象，屬性名新值）
    """
    dog1.age = 4
    print(dog1.age)

    dog1.__setattr__('color','blue')
    print(dog1.color)

    setattr(dog1,'color','writa')
    print(dog1.color)
    # 3.增加
    """
    方法一： 對象.屬性 = 值（屬性不存在）
    注意：屬性是添加給對象的，而不是類的
    方法二： 對象.__setattr__(屬性名，新值) 和 setattr（對象，屬性名新值）
   
    """
    dog1.name = '土狗'
    print(dog1.name)

    dog1.__setattr__('type','哈士奇')
    print(dog1.type)

    setattr(dog1, 'sex', '公')
    print(dog1.sex)
    # 4.刪（刪除對象的屬性）
    """
    方法一： del 對象.屬性
    注意：刪除屬性也是刪的具體某個對象的屬性。不會影響這個類的其他對象
    方法二： delattr(對象,屬性名)
    """
    del dog1.age
    # print(dog1.age)  報錯：AttributeError: 'Dog' object has no attribute 'age'

    delattr(dog1,'color')
    # print(dog1.color)
結(jié)果：
3 black
3
3
無名氏
4
blue
writa
土狗
哈士奇
公

練習(xí)：

  • 聲明一個學(xué)生類，擁有屬性：姓名、性別、年齡。方法：學(xué)習(xí)
  1. 聲明學(xué)生類的對象，聲明的時候就給姓名、性別和年齡賦值
  2. 通過三種方式分別獲取姓名、性別和年齡，并且打印
  3. 給學(xué)生對象添加一個屬性，電話
  4. 修改學(xué)生年齡
  5. 刪除學(xué)生的性別
class Student:
    def __init__(self, name='小王', sex='男', age='15'):
        self.name = name
        self.sex = sex
        self.age = age

    def study(self):
        print( '%s正在學(xué)習(xí)'% self.name)

student1 = Student()

print(student1.name,student1.sex,student1.age)
print(student1.__getattribute__('name'))
print(student1.__getattribute__('sex'))
print(student1.__getattribute__('age'))
getattr(student1,'name')
getattr(student1,'sex')
getattr(student1,'age')

student1.tel = 110
print(student1.tel)
student1.__setattr__('id',1805001)
setattr(student1,'hobby','football')

student1.age = 20
print(student1.age)

del student1.sex
# print(student1.sex)
student1.study()
結(jié)果：
小王 男 15
小王
男
15
110
20
小王正在學(xué)習(xí)

_slots_和_str_用法

class Person():
    # __slots__的功能：就是約束類中的對象的屬性。
    __slots__ = ('name','age','sex','id')
    def __init__(self,name='',age=0):
        self.name = name
        self.age = age

    # 自定義對象的打印格式
    """
    id（）：是python的內(nèi)置函數(shù)，功能是獲取變量的地址
    """
    def __str__(self):
        return self.name+','+str(self.age)

if __name__ == '__main__':
    p1 = Person('小王',20)
    # p1.name = '老王'
    p1.sex = 'woman'
    print(p1)
結(jié)果：
小王,20

類中的方法

  • 屬性：對象的屬性（屬性）、類的屬性（類的字段）

  • 對象屬性：屬于對象的，不同對象對應(yīng)的值可能不一樣(對象屬性，通過對象來使用)

  • 類的字段：聲明在類里面，函數(shù)外面。類的屬性屬于類()

  • 方法：對象方法（方法）、類方法、靜態(tài)方法

  • 對象方法：自帶一個self參數(shù)，一般要通過對象去調(diào)用

  • 類方法：

  1. 使用@classmethod修飾
    2. 自帶一個cls參數(shù)，并且這個參數(shù)不用傳參，誰來調(diào)用這個方法，cls就指向誰
    3. 類方法要通過類來調(diào)用

  • 靜態(tài)方法：
    1.使用@staticmethod修飾
    2.沒有默認參數(shù)
    3.靜態(tài)方法要通過類來調(diào)用

  • 怎么選擇用對象方法、類方法、靜態(tài)方法？
    if 如果實現(xiàn)函數(shù)的功能需要使用對象的屬性，就聲明成對象方法；
    elif 如果實現(xiàn)函數(shù)的功能需要使用類的字段或者調(diào)用類的方法，就聲明成類方法
    elif 如果實現(xiàn)函數(shù)的功能既不需要對象的屬性也不需要類的字段，就聲明成靜態(tài)方法

class Person:
    # number是類字段
    number = 0

    def __init__(self,name='',age= 0):
        # name和age是對象屬性
        self.name = name
        self.age = age
    # eat1方法是對象方法
    def eat1(self,food):
        print('%s在吃%s' %(self.name, food))

    # hurt_earth 就是一個類方法
    @classmethod
    def hurt_earth(cls):
        # cls指向的是調(diào)用這個方法的類，cls可以當成類來使用
        pt = cls('李四')  #可以使用cls創(chuàng)建對象
        print(pt.name)
        print(cls.number)  #可以通過cls使用類的字段

        print('人類破壞環(huán)境..')

    @staticmethod
    def protect_earth():
        print('人類保護地球')
if __name__ == '__main__':
    # 類的字段要用類來使用
    print(Person.number)

    # 對象的屬性要通過對象來使用
    p1 = Person('小明')
    # 對象方法用對象調(diào)用
    p1.eat1('方便面')
    print(p1.name,p1.age)
    p2 = Person('小網(wǎng)')
    p2.eat1('串串')

    # 類方法通過類來調(diào)用
    Person.hurt_earth()
    # 靜態(tài)方法通過類來調(diào)用
    Person.protect_earth()

結(jié)果：
0
小明在吃方便面
小明 0
小網(wǎng)在吃串串
李四
0
人類破壞環(huán)境..
人類保護地球

練習(xí)：

1.寫一個班級類，屬性：班級名、學(xué)生；功能：添加學(xué)生

class Student:
    """學(xué)生類"""
    def __init__(self,name='',age=0):
        self.name = name
        self.age = age

    def __str__(self):
        return 'name:%s age:%d'%(self.name,self.age)

class Class:
    """班級類"""
    def __init__(self,name='',students=[]):
        self.class_name = name
        self.students = students

    def add_student(self):
        name = input('name:')
        age = input('age:')
        # 根據(jù)輸入的信息創(chuàng)建學(xué)生對象
        stu = Student(name,int(age))

        self.students.append(stu)

cls1 = Class('py1805',[])
cls1.add_student()
print(cls1.students)

結(jié)果：
name:孝利
age:23
name:孝利 age:23

面向?qū)ο缶毩?xí)

1.聲明一個電腦類：
屬性：品牌、顏色、內(nèi)存大小
方法：打游戲、寫代碼、看視頻
a.創(chuàng)建電腦類的對象，然后通過對象點的方式獲取、修改、添加和刪除它的屬性
b.通過attr相關(guān)方法去獲取、修改、添加和刪除它的屬性

class Computer:
    def __init__(self,brand='聯(lián)想',color='black',memory='64G'):
        self.brand = brand
        self.color = color
        self.memory = memory
    def game(self):
        print('可以打游戲')

    def write_code(self):
        print('可以寫代碼')

    def movie(self):
        print('可以看電影')
if __name__ == '__main__':
    # 聲明一個對象
    com1 = Computer()
    # 修改對象品牌
    com1.brand = '華碩'
    print(com1.brand)
    setattr(com1,'brand','蘋果')
    print(com1.brand)
    # 獲取內(nèi)存大小
    print(com1.memory)
    print(getattr(com1,'memory'))
    # 添加對象屬性
    com1.screen_size = '15.7'
    print(com1.screen_size)
    setattr(com1, 'CPU', 'i7')
    print(com1.CPU)
    # 刪除對象屬性
    del com1.color
    delattr(com1,'screen_size')
結(jié)果：
華碩
蘋果
64G
64G
15.7
i7

2.聲明一個人的類和狗的類：
狗的屬性：名字、顏色、年齡 狗的方法：叫喚
人的屬性：名字、年齡、狗 人的方法：遛狗
a.創(chuàng)建人的對象小明，讓他擁有一條狗大黃，然后讓小明去遛大黃

class Dog:
    def __init__(self,name='',color='',age=''):
        self.name = name
        self.color = color
        self.age = age
    def bark(self):
        print('%s在叫喚'%self.name)

class Person:
    def __init__(self,name='',dog='',age=15):
        self.name = name
        self.age = age
        self.dog = dog
    def walk_the_dog(self):
        print('%s在溜著%s'%(self.name,self.dog))

if __name__ == '__main__':
    dog1 = Dog('大黃','yellow','5')
    p1 = Person('小明', dog1.name)
    p1.walk_the_dog()
    dog1.bark()
結(jié)果：
小明在溜著大黃
大黃在叫喚

3.聲明一個矩形類：
屬性：長、寬 方法：計算周長和面積
a.創(chuàng)建不同的矩形，并且打印其周長和面積

class Rectangle:
    def __init__(self,width,height):
        self.width = width
        self.height = height
    def perimeter(self):
        perimeter1 = (self.width+self.height)*2
        print('周長為%s'%perimeter1)
    def area(self):
        area1 = self.width*self.height
        print('面積為%s'%area1)
if __name__ == '__main__':
    r1 = Rectangle(10,20)
    r2 = Rectangle(5, 5)
    r1.perimeter()
    r1.area()
    r2.perimeter()
    r2.area()
結(jié)果：
周長為60
面積為200
周長為20
面積為25

4.創(chuàng)建一個學(xué)生類：
屬性：姓名，年齡，學(xué)號 方法：答到，展示學(xué)生信息
創(chuàng)建一個班級類：
屬性：學(xué)生，班級名 方法：添加學(xué)生，刪除學(xué)生，點名，根據(jù)姓名查看學(xué)生信息，展示班級的所有學(xué)生信息

5.寫一個類，封裝所有和數(shù)學(xué)運算相關(guān)的功能（包含常用功能和常用值，例如：pi,e等）

import math

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

    def pow(self):
        print('%s的%s次方是%d' %(self.x, self.y, (self.x**self.y)))
    def perimeter(self):
        perimeter1 = self.x*2*math.pi
        print('圓周長為%s'%perimeter1)
    def area(self):
        area1 = self.x*math.pi**2
        print('圓面積為%s'%area1)

if __name__ == '__main__':
    m1 = Function(2,4)
    m1.pow()
    m2 = Function(3)
    m2.perimeter()
    m2.area()
結(jié)果：
2的4次方是16
圓周長為18.84955592153876
圓面積為29.608813203268074
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • 1.ios高性能編程 (1).內(nèi)層 最小的內(nèi)層平均值和峰值(2).耗電量 高效的算法和數(shù)據(jù)結(jié)構(gòu)(3).初始化時...
    歐辰_OSR閱讀 30,214評論 8贊 265
  • Swift1> Swift和OC的區(qū)別1.1> Swift沒有地址/指針的概念1.2> 泛型1.3> 類型嚴謹 對...
    cosWriter閱讀 11,629評論 1贊 32
  • 國家電網(wǎng)公司企業(yè)標準（Q/GDW）- 面向?qū)ο蟮挠秒娦畔?shù)據(jù)交換協(xié)議 - 報批稿：20170802 前言： 排版 ...
    庭說閱讀 12,332評論 6贊 13
  • 執(zhí)我之手 去盛唐時的長安 采一支青蓮 去酒館里找那個醉漢 功名分我一半 罪責(zé)我也愿承擔(dān) 多年后 史書為你的回眸張貼...
    在那遙遠的地方o閱讀 270評論 2贊 2
  • 春分。太陽從象征迷惘、療愈、混同與合一的雙魚座離開。。。在之前的一個月，有很多事情開始轉(zhuǎn)了方向，一些離別，一些重逢...
    丁子然閱讀 214評論 0贊 0

友情鏈接更多精彩內(nèi)容