Python学习之路：一些BIF+魔法方法+模块

一、类和对象中的一些BIF

①issubclass(class, classinfo) 第一个class是第二个classinfo的子类则返回True，一个类被认为是自身的子类，后面的classinfo可以是一个元组，只要里面有一个是class的父类则返回True

②isinstance(object，classinfo) 前面的object是一个实例对象，如果一个实例对象属于后面一个classinfo或一个classinfo元组的话返回True

③hasattr(object, ‘name’) 测定一个实例对象object里面是否有指定的属性name,注意nameu要用引号，如果有则返回True

④getattr(object,’name’,default) 返回对象object对应的属性name值，如果属性不存在，若已设置default的值则返回其值，否则会抛出异常

⑤setattr(object,’name’,value) 设置对象object指定属性name的值value，若归属性不存在，则会创建一个属性并给它赋值为value

⑥delattr(object,’name’) 删除对象中指定的属性，如果属性不存在则抛出异常

⑦property(fget=None，fset=None，fdel=None，doc=None) 通过属性设置属性，前三个参数传入已设置好的属性 (获取，设置，删除 )属性

class A:
def __init__(self,x=666):
self.x=x
def getX(self):
return self.x
def setX(self,value):
self.x=value
def delX(self):
del self.x
y=property(getX,setX,delX)
b=A()
print(b.getX())
print(b.y)   #直接获取属性值
b.x=888      #直接设置属性值，未调用setX函数
print(b.y)
del b.y  #y属性已删除

666
666
888

魔法方法

一、构造与析构

构造函数 ：__init_(self,变量名)

_new__(cls,变量名) 为对象实例化后调用的第一个方法，cls（类）后面若有参数会全部传给init方法，需要返回一个实例对象，当一个类继承了一个不可变类型且需要修改的时候，修改new方法，

class A(str):
def __new__(cls,s):
s=s.upper()
return str.__new__(cls,s)
a=A("I love you")
print(a)

析构函数：_del_(self) 当创建一个实例对象，所有该实例对象的引用包括该实例对象都被del（即删除）后，自动调用del方法

二、描述符

描述符就是将某种特殊类型的类的实例指派给另一个类的属性

_get_(self,instance,owner) 访问的时候被调用—用于访问属性，它返回属性的值

_set_(self,instance,value) 赋值的时候被调用– -将属性分配在操作中调用，不返回任何内容

[b]_delete_[/b](self,instance) 删除属性的的时候被调用–控制删除操作，不返回任何内容

三、容器类型的定义

①如果定制不可变容器，只需定义_len__()和_getitem()方法

②如果定制不可变容器，除定义上述两种方法外，还需定义__setitem_()和__delitem_()方法

_len_(self)定义当被len()调用时的行为（返回容器中元素的个数）

_getitem_(self,key)定义·获取容器中指定元素的行为，相当self[key]

_setitem_(self,key,value)定义设置容器中指定元素的行为，相当于self[key]=value

_delitem_(self,key) 定义删除容器中指定元素的行为，相当于del self[key]

实例：定义一个不可变列表，要求记录列表中每个元素的被访问的次数

class List1:
def __init__(self,*args):   #args表示不知道用户输入几个
self.list1=[x for x in args]  #map()表示用户输入的值组成一个列表
self.count={}.fromkeys(range(len(self.list1)),0)      #fromkeys（）初始化一个字典，例子中，前者为列表的下标也为字典的key值，后者为访问次数，初始化为0

def __len__(self):
return len(self.list1)

def __getitem__(self,n):
self.count
+=1       #每访问一次键值次数加1
return self.list1

>>> L=List1(1,2,3,4,5,6)
>>> L[1]
2
>>> L[3]
4
>>> L[1]
2
>>> L.count
{0: 0, 1: 2, 2: 0, 3: 1, 4: 0, 5: 0}

四、迭代器

①iter(): -__iter_(self)

②next(): -_next_(self)

iter(),next()用法：

>>> string="ILoveYou"
>>> it=iter(string)
>>>
>>> next(it)
'I'
>>> next(it)
'L'
>>> next(it)
'o'
>>> next(it)
'v'
>>> next(it)
'e'
>>> next(it)
'Y'
>>> next(it)
'o'
>>> next(it)
'u'
>>> next(it)    #超出范围抛出异常
Traceback (most recent call last):
File "<pyshell#100>", line 1, in <module>
next(it)
StopIteration

用迭代器实现斐波那契数列：

class Fibs:
def __init__(self,n=10):
self.a=0
self.b=1
self.n=n

def __iter__(self):
return self

def __next__(self):
self.a,self.b=self.b,self.a+self.b
if self.b>self.n:       #如果斐波那契数超过某个值抛出异常
raise StopIteration
else:
return self.b

>>> fibs=Fibs()
>>> for each in fibs:
print(each)

五、生成器

一个函数内出现 yield 语句这个函数就被定义为生成器，yield 语句相当于普通函数的return 但它会返回yield 后对应的返回值，且函数执行暂停在当前位置，下次调用next语句继续执行。（生成器是一个特殊的迭代器，用next（）函数调用，for循环会自动调用next函数，探测StopIteration结束）

def fibs():
a=0
b=1
for x in range(10):
a,b=b,a+b
yield b

>>> t=fibs()
>>> for each in t:
print(each)

1
2
3
5
8
13
21
34
55
89

或者

>>> t=fibs()
>>> next(t)
1
>>> next(t)
2
>>> next(t)
3
>>> next(t)
5
>>> next(t)
8
>>> next(t)
13
next(t)

>>> next(t)
21
>>> next(t)
34
>>> next(t)
55
>>> next(t)
89
>>>
>>> next(t)
Traceback (most recent call last):
File "<pyshell#120>", line 1, in <module>
next(t)
StopIteration

列表推导式：

>>> a=[x for x in range(100) if not(x%2) and not(x%3)]
>>> a
[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

字典推导式：

>>> b={x: x+1 for x in range(10) if x%2}
>>> b
{1: 2, 3: 4, 5: 6, 7: 8, 9: 10}

集合推导式：

>>> c={x for x in [1,2,3,4,5,5,4,3,2,1]}
>>> c
{1, 2, 3, 4, 5}

生成器推导式：

>>> G=(x for x in range(0,10) if not(x%2))
>>> G
<generator object <genexpr> at 0x0000000002B58570>
>>> next(G)
0
>>> next(G)
2
>>> next(G)
4
>>> next(G)
6
>>> next(G)
8
>>> next(G)
Traceback (most recent call last):
File "<pyshell#134>", line 1, in <module>
next(G)
StopIteration

生成器作为函数的参数，函数可直接作用于生成器中全部元素

>>> sum(x for x in range(0,10) if not(x%2))
20

六、模块

①创建模块：将已写好的模块保存在安装python的目录下

②导入模块：法一: import 模块名

法二: from 模块名 import 函数名

法三: import 模块名 as 新名（最好使用）

def Hi():
print ("I Love You")

>>> import hello as H
>>> H.Hi()
I Love You

七、_name_==’_main_‘、搜索路径和包

①_name__==’__main_’ ：在已写好的模块中需要在模块中写上测试语句，在测试语句前加上 if _name_==’_main_’ 则在导入模块后不会执行模块内的测试语句

#模块
def calc(n):
return n**2

def test():
print(%calc(2))

if __name__=='__main__': #必加条件
test()               #测试语句

#含if条件
>>> import hello
>>> hello.calc(4)
16

不含if条件
>>> import hello
4         #会先输出测试例子
>>> hello.calc(4)
16
>>>

②搜索路径

路径是一个列表

>>> import sys
>>> sys.path
['', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\Lib\\idlelib', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\python36.zip', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\DLLs', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\lib', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\lib\\site-packages']

导入模块时Python会从以上列表中的路径搜索模块所在位置，若找到模块则导入，若未找到则导入失败。site-packages文件夹设置用来存放模块

可以自定义添加搜索路径 语句为：sys.path.append(‘路径’)

对于要实现不同的方法，把模块分门别类的存放在不同的文件夹下，把路径添加进去

③包（package）：把方法放在同一个文件夹内，便于调用

创建一个包：（1）创建一个文件夹，用于存放相关的模块，文件夹的名字即是包的名字；

（2）在文件夹必须中创建一个[b]_init_[/b].py的模块文件，内容可以为空，（来告诉Python把这个文件夹当做一个包）

（3）将相关的模块放入文件夹中

包的导
a0fe
入：import 包名 . 模块名（其他导入方法跟模块导入相同）