recode
1.迭代器和生成器
迭代器,獲取數(shù)據(jù):next(迭代器),for循環(huán)遍歷;數(shù)據(jù)來源:轉(zhuǎn)換,生成器
生成器:就是迭代器,
"""
def 函數(shù)名():
yield 值
生成式:
(表達式 for 變量 in 序列 if 條件語句)
"""
# 補充:三目運算符
"""
C語言中的三目運算符:表達式?值1:zhi2 -- 判斷表達式的值是否為真,如果是整個運算的結(jié)果是值1,否則是值2
python的三目運算操作:值1 if 表達式 else 值2
"""
num = 10
result = '偶數(shù)' if num % 2 == 0 else '奇數(shù)'
print(result)
2.模塊
- 模塊就是py文件
- import 模塊名
- 倒入模塊中所有的內(nèi)容
from math import *
if __name__ == '__main__':
pass
`
包/庫就是文件夾
# 3.異常處理
```python
"""
try:
需要捕獲的異常的代碼段
except:
出現(xiàn)異常后對異常的處理代碼段
finally:
不管try后的代碼是否異常,異常是否被捕獲第都執(zhí)行代碼
"""
類和對象
1.什么是類,什么是對象
"""
1)官方定義:類就是擁有相同功能和相同屬性的對象的集合 -- 抽象
對象就是類的實例 -- 具體
2)生活角度看類和對象
如果人是類,余婷就是對象,駱昊也是對象
如果電腦是類,對象就是具體到一臺電腦,比如我桌子上的電腦
"""
2.類的聲明
"""
1)語法
class 類名:
類的內(nèi)容
2)說明
class - 固定寫法聲明類的關(guān)鍵字
類名 - 標識符,不能是關(guān)鍵字,
見名知意,才用駝峰式命名(通過單詞首字母大寫的方式來區(qū)分不同的單詞),首字母大寫
: - 固定寫法
類的內(nèi)容 - 主要包含:類的說明文檔,類的屬性(普通的變量),類的功能(函數(shù):寫在類里面也叫方法)
"""
3.對象怎么聲明
"""
對象 = 類() - 創(chuàng)建指定的類對應(yīng)的對象
"""
4.類中的方法
"""
1)什么是方法:聲明在類中的函數(shù)就叫方法
2)類中的方法有三種:對象方法,類方法,靜態(tài)方法
a.對象方法:直接聲明在類中的函數(shù)
有默認參數(shù)self,通過對象調(diào)用的時候這個參數(shù)不用傳參,因為系統(tǒng)會自動將當前對象傳遞給self
(self,當前對象 - 誰調(diào)用self就指向誰,當前類的對象嫩做的事情self都能做)
通過類的對象來調(diào)用: 對象.對象方法()
b.類方法: 聲明函數(shù)前加@classmethod
有默認參數(shù)cls,通過類調(diào)用的時候這個參數(shù)不用傳參
(cls,當前類 - 誰調(diào)用就指向誰)
通過類來調(diào)用:類.類方法
c.靜態(tài)方法: 聲明函數(shù)前加@staticmethod
沒有默認參數(shù)
通過類來調(diào)用:類.靜態(tài)方法
"""
# 聲明一個Person類
class Person:
"""說明文檔"""
# =======屬性=======
# =======方法=======
def eat(self, food):
# self = p1 food = '串串'
print(p1, self) # 打印 p1 和 self 的 內(nèi)存地址
print('吃'+food)
self.study('python')
def study(self, type1):
print('學習', type1)
# ==============類方法============
@classmethod
def destroy(cls):
tp = cls
print('人類破壞環(huán)境')
print('cls:', cls)
print('tp:', tp)
# ==============靜態(tài)方法============
@staticmethod
def beat_animal():
print('喜歡貓')
# 創(chuàng)建Person類的對象p1
p1 = Person()
p1.eat('串串')
p1.study('數(shù)學')
Person.destroy()
print(Person)
Person.beat_animal()
常識:
1.什么是init方法
init是類名默認繼承的一個魔法方法,用來初始化類; 本質(zhì)是對象方法,但是會不需要程序員自己調(diào)用,會被自動調(diào)用
通過類創(chuàng)建對象的時候(通過構(gòu)造方法創(chuàng)建對象),系統(tǒng)會自動調(diào)用類中的init方法,并且構(gòu)造方法中單實參會全部傳給init方法
創(chuàng)建對象的時候需不需要參數(shù),需要幾個參數(shù),看這個類的init方法
(了解)聲明類的時候系統(tǒng)會自動給我們創(chuàng)建一個函數(shù),這個函數(shù)的函數(shù)名和聲明的類的類名一樣,這個函數(shù)叫構(gòu)造方法.
函數(shù)中會先在內(nèi)存中開辟空間創(chuàng)建對象,然后用創(chuàng)建的對象去調(diào)用類的init方法,最后才將對象返回
class Person:
def __init__(self):
print('init方法')
p1 = Person() # 開辟
類的屬性
1.屬性
"""
類中的屬性分為:對象屬性和字段
1) 字段 : 直接聲明在類中的變量就是字段 ; 字段要通過'類.字段'的方式來使用;
當屬性的值不會因為對象不同而不同,這種屬性就可以聲明成類的字段
2)對象屬性 : 必須聲明在__init__方法中以'self.屬性 = 值'的形式聲明;
通過對象要通過'對象.屬性'的方式來使用
當屬性的值會因為對象不同而不同,使用對象屬性
"""
class Dog:
"""狗"""
# =========字段=========
numbers = 10
# =======對象屬性=======
def __init__(self, name1, color1='黑色', gender1='公'):
self.name = name1
self.color = color1
self.gender = gender1
self.age = 0
print(Dog.numbers)
dog1 = Dog('黃狗')
print(dog1.age, dog1.color, dog1.gender)
# 寫一個矩形類,有屬性:長和寬 方法:求面積,求周長
class Rectangle:
def __init__(self, long: int, width: int):
self.long = long
self.width = width
def rect(self):
s = self.long*self.width
l = (self.long+self.width)*2
return s, l
p2 = Rectangle(2, 2)
print(p2.rect())
# 聲明一個學生類,擁有屬性:名字,電話.年齡,學號.擁有功能:學習(打印XX在學XX),打游戲
class Student:
def __init__(self, names, telephone, ages, numbers):
self.name = names
self.tpl =telephone
self.age = ages
self.num = numbers
def study(self, subject='英語'):
print(self.name+'在學'+subject)
p1 = Student('王子', 123, 12, '001')
p1.study('數(shù)學')
2.聲明類的時候方法的選擇
"""
1.對象方法:實現(xiàn)函數(shù)功能需要用到對象屬性的時候,就使用對用方法
2.類方法:實現(xiàn)函數(shù)功能不需要對象屬性,但是需要類的相關(guān)的操作,就使用類方法
3.靜態(tài)方法:實現(xiàn)函數(shù)的功能既不需要對象屬性,也不需要類相關(guān)的操作,就使用靜態(tài)方法
"""
對象屬性相關(guān)
python中的對象屬性支持增,刪,改,查
!!!注意:對象屬性的增刪改查只針對單個對象
class Dog:
def __init__(self, name):
self.name = name
self.age = 0
dog1 = Dog('大黃')
dog2 = Dog('才才')
1.查
"""
a.對象.屬性 - 獲取指定屬性對應(yīng)的值,如果屬性不存在會報錯
b.getattr(對象, 屬性名, 默認值) - 獲取指定對象指定屬性對應(yīng)的值;
當屬性不存在有默認值的時候不報錯,返回默認值.沒有默認值的時候報錯
"""
print(dog1.name)
print(getattr(dog1, 'name2', 100))
2.增,改
"""
a.對象.屬性 = 值 - 當屬性不存在就添加屬性,當屬性存在修改屬性的值
b.setattr(對象,屬性名,值) - 當屬性不存在就添加屬性,當屬性存在修改屬性的值
"""
# a.
dog1.gender = '公'
print(dog1.gender)
dog1.name = '貝貝'
print(dog1.name)
# b.
setattr(dog1, 'category', '二哈')
a_name = 'color'
setattr(dog1, a_name, '白色')
print(dog1.category, dog1.color)
3.刪除
"""
a.del 對象.屬性
b.delattr(對象,屬性名)
"""
del dog1.name
# print(dog1.name) #AttributeError:
delattr(dog1, 'age')
# print(dog1.'age') #AttributeError:
Day14_recode
1.類的聲明
類是擁有相同屬性和相同功能的對象的集合
"""
class 類名:
類的內(nèi)容
"""
2.創(chuàng)建對象
對象 = 類()
3.(重點!)類中的內(nèi)容:對象方法.類方法,靜態(tài)方法;字段,對象屬性
"""
1)方法 - 怎么聲明,特點,怎么調(diào)用,什么時候用
對象方法:直接聲明在類中的函數(shù);
有默認參數(shù)self;
通過對象調(diào)用;
實現(xiàn)功能需要用到對象屬性的時候
類方法:聲明前加@classmethod;
有默認參數(shù)cls;
通過類調(diào)用;
實現(xiàn)函數(shù)功能在不需要對象屬性,需要類相關(guān)操作的時候
靜態(tài)方法:聲明前加@staticmethod,
沒有默認參數(shù),和普通函數(shù)差不多;
通過類調(diào)用;
既不需要對象屬性,也不需要對象操作
2)屬性 - 怎么聲明,怎么使用,什么時候用
字段:聲明在類里面,函數(shù)外面;
通過類來使用
不會因為對象不同而不同的屬性聲明成字段
對象屬性:以'self.屬性 = 值'的形式聲明在__init__方法中;
通過對象使用
會因為對象不同而不同的屬性聲明成字段
"""
4.對象屬性的增刪改查
"""
1)查
對象.屬性 - 沒對應(yīng)屬性會報錯
getattr(對象,屬性,默認值) - 當沒有對應(yīng)屬性的時候返回默認值
2)增改
對象.屬性 = 值
setattr(對象,屬性,值)
3)刪
del 對象.屬性
delattr(對象,屬性)
"""
內(nèi)置類屬性
1.內(nèi)置類屬性
創(chuàng)建類的時候,系統(tǒng)默認為我們添加的類的屬性
class Person:
"""人類"""
# 類的字段
number = 61
# 對象屬性
def __init__(self, name, age=0, gender='女'):
self.name = name
self.age = age
self.gender = gender
def object_func(self):
print('對象方法:'+self.name)
@classmethod
def class_func(cls):
print('類方法:', cls.number)
@staticmethod
def static_func():
print('靜態(tài)方法:')
# 系統(tǒng)自帶的魔法方法,可以定制當前類的對象的打印內(nèi)容.實現(xiàn)這個函數(shù)的時候要求有一個字符串類型的返回值
# 影響單獨打印對象的效果
def __str__(self):
# return str(self.__dict__)[1:-1]
return 'abc'
# 對象作為元素的時候的打印效果
def __repr__(self):
return str(self.__dict__)
# return '132'
p1 = Person('小明', 18, '男')
p2 = Person('小花', 19, '女')
# 1.__name__ 字段
"""
類.__name__ - 獲取類的名字
"""
print(Person)
print(Person.__name__, type(Person.__name__))
# 2.__doc__ 字段
"""
類.__doc__ - 獲取類的說明文檔
"""
print(Person.__doc__)
# 3.__class__ 對象屬性
"""
對象.__class__ - 獲取對象對應(yīng)的類(你這個對象是那個類的對象)
"""
print(p1.__class__)
# 4.__dict__ 字段和對象屬性都可以
"""
類.__dict__ - 獲取類中所有的字段和對應(yīng)的值以字典返回
對象.__dict__ - 獲取對象中所有的對象屬性和對應(yīng)的值以字典返回
"""
print(Person.__dict__)
print(p1.__dict__)
# 5.__module__ 字段
"""
類.__module__ - 獲取指定類聲明在那個模塊中,返回模塊名(獲取所在模塊的__name__的屬性的值)
"""
print(Person.__module__)
# 6.__bases__ 字段
"""
lei.__bases__ - 返回當前類所有的父類
"""
print(Person.__bases__)
print('p1', p1)
print([p1, p2, Person('小紅')])
2.slots魔法
**與dict沖突使用時注意
"""
可以通過給__slots__字段賦值約束當前類有那些對象屬性,只約束增加不約束刪除
當在類中給__slots__賦值后,當前類的對象的__dict__屬性無效
"""
class Dog:
__slots__ = ('name', 'age')
def __init__(self, name, age=0):
self.name = name
self.age = age
dog = Dog('大黃')
# dog.name1 = '小白'
# print(dog.__dict__)
屬性保護和私有化
"""
1.高級語言
在很多的高級面對對象語音中,會將屬性和方法分為
a.公開的(在類的外部可以使用),
b.私有的(只能在類的內(nèi)部使用,不能被繼承),
c.受保護(只能在類的內(nèi)部使用,可以被繼承)
2.python
python中類的內(nèi)容本質(zhì)上全部都是公開的.私有和公開都只是約到
1)私有化 - a.內(nèi)容只能在類的內(nèi)部使用,不能在外面使用.(效果)
b.在類中的方法名或者屬性名前加'__'那么對于的屬性和方法就會變成私有的(怎么私有化)
c.當聲明類的時候在名字前加'__',內(nèi)部會在這個基礎(chǔ)上下再加'_類名' (私有化的本質(zhì))
2)屬性保護 - 可通過在對象屬性名前'_',吧這個屬性標記成受保護類型;為了告訴別人這個屬性在使用的時候,
不要直接用,而是通過getter和setter來使用 (怎么保護)
a.getter - 獲取對象屬性值之前想要干點別的事情,那么就給這個屬性添加getter
第一步:在對應(yīng)的屬性名前加'_'
第二步:在@property聲明一個函數(shù),這個函數(shù)沒有參數(shù),有一個返回值,并且函數(shù)名是屬性名去掉'_'
第三步:獲取屬性值的時候,通過對象.屬性名去掉下劃線去獲取屬性的值
b.setter - 給屬性賦值前干點別的事情,就給這個屬性添加setter.(想要添加setter必須先有g(shù)etter)
第一步:在對應(yīng)的屬性名前加'_'
第二步:在@getter名.setter后面聲明一個函數(shù),這個函數(shù)需要一個參數(shù),沒有返回值,并且函數(shù)名是屬性去掉'_'
第三步:給屬性賦值的時候,,通過'對象.屬性名去掉下劃線 = 值'去賦值
3.拋出異常:
a.語法
raise 異常類型
b.說明:
raise - 關(guān)鍵字
異常類型 - 可以是系統(tǒng)提供的異常類型,也可以是自定義的異常類型(必須繼承Exception)
4.自定義異常類型:寫一個類繼承Exception,然后重寫str方法來自定義錯誤信息.
"""
class WeekValueError(Exception):
def __str__(self):
return '星期的值只能是1-7的整數(shù)'
class AgeError(Exception):
def __str__(self):
return '年齡要求是整數(shù)并且只能在0-150之間'
# raise WeekValueError
# =============保護=============
class Person1:
def __init__(self):
self._age = 0
self._week = 6
@property
def week(self):
weeks = ['周一', '周二', '周三', '周四', '周五', '周六', '周日']
return weeks[self._week-1]
@week.setter
def week(self, x):
if not isinstance(x, int):
raise ValueError
elif not 1 <= x <= 7:
raise ValueError
self._week = x
@property
def age(self):
if self._age < 18:
return str(self._age)+'歲', '未成年'
else:
return str(self._age)+'歲', '成年'
@age.setter
def age(self, x):
if not isinstance(x, int):
raise AgeError
elif not 150 >= x >= 0:
raise AgeError
self._age = x
p1 = Person1()
p1.age = 16
print(p1.age)
# p1.age = 'abc'
print(p1.week)
p1.week = 4 # 本質(zhì)是在調(diào)用setter
print(p1.week) # 本質(zhì)實在調(diào)用getter
# 練習:給age屬性添加getter和 setter,獲取年齡的時候拿到年齡值,和這個年齡對應(yīng)的階段;
# 給age賦值的時候,必須是整數(shù),并且范圍在0-150.如果不滿女主要求求報錯AgeError,并且定義提示信息
# =============私有化===========
class Person:
def __init__(self, name, age=0):
self.name = name
self.__age = age
def message(self):
print(self.__age)
p = Person('小明')
print(p.name)
# print(p.__age)
p.message()
繼承
1.什么是繼承:讓子類直接擁有父類的所有的屬性和方法
父類 - 被繼承中,子類 - 繼承者
python所有的類都是直接或者間接繼承object
2.怎么繼承
"""
class 子類(父類列表):
類的內(nèi)容
"""
3.子類添加內(nèi)容
1)字段和方法,直接添加
2)對象屬性的添加
