1.面向对象设计的一条基本原则是计算机程序由多个能够起到子程序作用的单元或对象组合而成，使得编程像堆积木一样。面向对象程序设计的一个关键性观念是将数据以及数据的操作封装在一起，组成一个相互依存、不可分割的整体，即对象。对于相同类型的对象进行分类、抽象后，得出共同的特质而形成了类，面向对象程序设计的关键就是如何合理地定义和组织这些类以及类之间的关系。
2.python对象的概念很广泛，Python中的一切对象都可以称为对象，除了数字、字符串、列表、元组、字典、集合、range对象、zip对象等等，函数也是对象，类也是对象。
创建类时用变量形式表示的对象属性称为数据成语，用函数形式表示的对象行为称为成员方法。成员属性和成员方法统称为类的成语。
3.定义了类之后，可以用来实例化对象，并通过"对象名.成员"的方式来访问其中的数据成员或成员方法
4.python提供了一个关键字‘pass’,类似于空语句，可以用在类和函数的定义中或者选择结构中。当暂时没有确定如何实习功能，或者为以后的软件升级预留空间，或者其它类型功能时，可以使用该关键字来“占位”。
5.类的所有实例方法都必须至少有一个名为self的参数，并且必须是方法的第一个形参（如果有 多个形参的话），self参数代表将来要创建的对象本身。在类的实例方法中访问实例属性时需要以self为前缀，但在外部通过对象名调用对象方法时并不需要传递这个参数，如果在外部通过类名调用对象方法则需要显式为self参数传值。
在类中定义实例方法时将第一个参数定义为“self”只是一个习惯，而实际上类的实例方法中第一个参数的名字是可以变化的，而不必使用“self”这个名字。尽管如此，建议编写代码时仍以self作为方法的第一个参数名字。
6.属于实例的数据成员一般是指在构造函数__init__()中定义的，定义，定义和使用必须以self作为前缀；属于类的数据成员是在类中所有方法之外定义的。在主程序中（或类的外部），实例属性属于实例（对象），只能通过对象名访问；而类属性属于类，可以通过类名或对象名访问。
7.在python中比较特殊的是，可以动态地为类和对象增加成语，这一点和很多面向对象程序设计语言不同的，也是python动态类型特点的一种重要体现。
>>> class Car:
price = 100000 #定义类属性
def __init__(self,c):
self.color = c #定义实例属性
>>> car1 = Car('Red') #实例化对象
>>> car2 = Car('Blue')
>>> print(car1.color,Car.price) #查看实例属性和类属性的值
Red 100000
>>> Car.price = 110000 #修改类属性
>>> Car.name ="QQ" #动态增类属性
>>> car1.color = "Yellow" #修改实例属性
>>> print(car2.color.Car.price,Car.name)
Traceback (most recent call last):
File "<pyshell#278>", line 1, in <module>
print(car2.color.Car.price,Car.name)
AttributeError: 'str' object has no attribute 'Car'
>>> print(car1.color,Car.price,Car.name)
Yellow 110000 QQ
>>> print(car2.color,Car.price,Car.name)
Blue 110000 QQ
>>>
>>> import types
>>> def setSpeed(self,s):
self.speed=s
>>> car1.setSpeed = types.MethodType(setSpeed,car1) #动态增加成员方法
>>> car1.setSpeed(50)
>>> print(car1.speed)
50
8.python类型的动态性使得我们可以动态为自定义及其对象增加新的属性和行为，俗称混入机制，这在大型项目开发中会非常分方便和实用。
>>> import types
>>> class Person(object):
def __init__(self,name):
assert isinstance(name,str),'naee must be string'
self.name = name
>>> def sing(self):
print(self.name+'can sing')
>>> def walk(self):
print(self.name+'can walk')
>>> def eat(self):
print(self.name+'can eat')
>>> zhang = Person('zhang')
>>> zhang.sing()
Traceback (most recent call last):
File "<pyshell#306>", line 1, in <module>
zhang.sing() #用户不具有该行为
AttributeError: 'Person' object has no attribute 'sing'
>>> zhang.sing = types.MethodType(sing,zhang）#动态的增加一个新行为
SyntaxError: invalid character in identifier
>>> zhang.sing = types.MethodType(sing,zhang)
>>> zhang.sing()
zhangcan sing
>>> zhang.walk()
Traceback (most recent call last):
File "<pyshell#310>", line 1, in <module>
zhang.walk()
AttributeError: 'Person' object has no attribute 'walk'
>>> zhang.walk = types.MethodType(walk,zhang)
>>> zhang.walk()
zhangcan walk
>>> del zhang.walk #删除用户行为
>>> zhang.walk()
Traceback (most recent call last):
File "<pyshell#314>", line 1, in <module>
zhang.walk()
AttributeError: 'Person' object has no attribute 'walk'
9.在Python中函数和方法是有区别的，方法一般指与特定实例绑定的函数，通过对象调用方法时，对象本身将作为第一个参数传递过去，普通函数不具备这个特点。
>> class Demo:
pass
>>> t = Demo()
>>> def test(self,v):
self.value = v
>>> t.test = test
>>> t.test #普通函数
<function test at 0x0000018867AC7A60>
>>> t.test(t,3) #必须为self参数传值
>>> t.test = types.MethodType(test,t)
>>> t.test #绑定的方法
<bound method test of <__main__.Demo object at 0x0000018867AC46D8>>
>>> t.test(5) #不需要为self参数传值
10.python并没有对私有成员提供严格的访问保护机制。在定义类的成员时，如果成员名以两个下划线“__”开头则表示是私有成员。私有成员在类的外部不能直接访问，需要通过调用对象的公有成员方法来访问，也可以通过python支持的特殊方式来访问。公有成员既可以在类的内部进行访问，也可以在外部程序中进行使用。
>>> class A:
def __init__(self,v1=0,v2=0):
self._v1 = v1
self.__v2 = v2
def setV(self,v1,v2):
self._v1 =v1
self.__v2 = v2
def show(self):
print(self,_v1)
print(self.__v2)
>>> a =A()
>>> a._v1
0
>>> a.__v2
Traceback (most recent call last):
File "<pyshell#372>", line 1, in <module>
a.__v2
AttributeError: 'A' object has no attribute '__v2'
>>> a._A__v2
0
11.在IDLE环境中，在对象或类名后面加上一个圆点‘.’,稍等一秒钟则会自动列出其所有的公开成员，模块也具有同样的方法。如果在圆点“.”后面再加一个下划线，则会列出该对象、类或模块的所有成员，也包括私有成员。
12.在Python中，以下划线开头的变量名和方法名有着特殊的含义，尤其是在类的定义中。用下划线作为变量名和方法名前缀和后缀来表示类的特殊成员。
_xxxx:受保护成员，不能用‘from module import ’导入；
xxx:系统定义的特殊成员；
__xxx:私有成员，只有类对象自己能访问，子类对象不能直接访问到这个成员，但在对象外部可以通过“对象名.类名_xxx”这样的特殊方式来访问。需要注意的是python中不存在严格意义上的私有成员。
12.在idle交互模式下，一个下划线“”表示解释器中最后一次显示的内容或最后一次语句正确执行的输出结果。
>>> 3+5
8
>>> 8+8
16
>>> _*2
32
>>> _/4
8.0
>>> _//2
4.0
13.在程序中，可以使用一个下划线表示不关心该变量的值。
>>> for _ in range(5):
print(3,end=' ')
3 3 3 3 3
>>> a,_ = divmod(60,18)
>>> a
3
>>> apple = Fruit()
>>> apple.price
1
>>> app.price=2
Traceback (most recent call last):
File "<pyshell#397>", line 1, in <module>
app.price=2
NameError: name 'app' is not defined
>>> apple.price #显示对象公开数据成员的值
1
>>> apple.price = 2 #修改对象公开数据成员的值
>>> apple.price
2
>>> print(apple.price,apple._Fruit__color)#显示对象私有成员的值
2 red
>>> apple._Fruit__color = 'blue'#修改对象私有成员的值
>>> print(apple.price,apple._Fruit__color)
2 blue
>>> print(apple._color)#不能直接访问对象的私有数据成员
Traceback (most recent call last):
File "<pyshell#404>", line 1, in <module>
print(apple._color)
AttributeError: 'Fruit' object has no attribute '_color'
>>>
14.在类定义的方法粗略分为四大类：公有方法、私有方、静态方法和类方法。
公有方法、私有方法都属于对象，私有方法的名字以两个下划线“__”开始，每个对象都有自己的公有方法和私有方法，在这两类方法中可以访问属于类和对象的成员。
公有方法通过对象名直接调用，私有方法不能通过对象名直接调用，只能在属于对象的方法中通过self调用或在外部通过Python支持的特殊方式进行调用。
如果通过类名来调用属于对象的公有方法，需要显式为该方法的self参数传递一个对象名，用来明确指定访问哪个对象的数据成员。
静态方法和类方法都可以通过类名和对象名调用，但不能直接访问属于对象的成员，只能访问属于类的成员。
静态方法可以没有参数。
一般将cls作为类方法的第一个参数名称，但也可以使用其它名字作为参数，并且在调用类方法时不需要该参数传递值。
>>> class Root:
__total = 0
def __init__(self,v): #构造方法
self.__value = v
Root.__total += 1
def show(self): #普通实例方法
print('self.__value:',self.__value)
print('Root.__total:',Root.__total)
@classmethod #修饰器，声明类方法
def classShowTotal(cls):#类方法
print(cls.__total)
@staticmethod #修饰器 声明静态方法
def staticShowTotal():#静态方法
print(Root.__total)
>>> r =Root(3)
>>> r.classShowTotal() #通过对象来调用类方法
1
>>> r.staticShowTotal() #通过对象来调用静态方法
1
>>> r.show()
self.__value: 3
Root.__total: 1
>>> rr = Root(5)
>>> Root.classShowTotal()#通过类名调用类方法
2
>>> Root.staticShowTotal() #通过类名调用静态方法
2
>>> Root.show() #试图通过类名直接调用实例方法，失败
Traceback (most recent call last):
File "<pyshell#32>", line 1, in <module>
Root.show()
TypeError: show() missing 1 required positional argument: 'self'
>>> Root.show(r) #但是可以通过这种方法来调用方法并访问实例成员
self.__value: 3
Root.__total: 2
>>> Root.show(rr)#通过类名调用实例方法时self参数显式传递对象名
self.__value: 5
Root.__total: 2
15.类种普通数据成员和私有数据成员的区别：
>>> class Test:
def show(self):
print(self.value)
print(self.__v)
>>> t =Test()
>>> t.show()
Traceback (most recent call last):
File "<pyshell#42>", line 1, in <module>
t.show()
File "<pyshell#40>", line 3, in show
print(self.value)
AttributeError: 'Test' object has no attribute 'value'
>>> t.value =3 #添加新的数据成员
>>> t.show()
3
Traceback (most recent call last):
File "<pyshell#44>", line 1, in <module>
t.show()
File "<pyshell#40>", line 4, in show
print(self.__v)
AttributeError: 'Test' object has no attribute '_Test__v'
>>> t.__v =5
>>> t.show()
3
Traceback (most recent call last):
File "<pyshell#46>", line 1, in <module>
t.show()
File "<pyshell#40>", line 4, in show
print(self.__v)
AttributeError: 'Test' object has no attribute '_Test__v'
>>> t._Test__v=5 #添加私有数据成员
>>> t.show()
3
5
16.只读属性
class Test():
def __init__(self,value):
self.__value = value
@property
def value(self): #只读，无法修改和删除
return self.__value
>>> t = Test(3)
>>> t,value
Traceback (most recent call last):
File "<pyshell#57>", line 1, in <module>
t,value
NameError: name 'value' is not defined
>>> t.value
3
>>> t,value = 5#只读属性不允许修改值
Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
t,value = 5
TypeError: 'int' object is not iterable
>>> t.v = 5 #动态增加新成员
>>> t.v
5
>>> del t.v #动态删除成员
>>> del t.value #试图删除对象属性，失败
Traceback (most recent call last):
File "<pyshell#63>", line 1, in <module>
del t.value
AttributeError: can't delete attribute
>>> t.value
3
>>>
17.可读可写可删除属性
class Test:
def __init__(self,value):
self.__value = value
def __get(self):
return self.__value
def __set(self,v):
self.__value = v
def __del(self):
del self.__value
value = property(__get,__set,__del)
def show(self):
print(self.__value)
>>> t =Test(3)
>>> t.show()
3
>>> t.value
3
>>> t.value = 5
>>> t.show()
5
>>> del t.value #删除属性
>>> t.value#对应的私有数据成员已删除
Traceback (most recent call last):
File "<pyshell#20>", line 1, in <module>
t.value
File "<pyshell#13>", line 5, in __get
return self.__value
AttributeError: 'Test' object has no attribute '_Test__value'
>>> t.show()
Traceback (most recent call last):
File "<pyshell#21>", line 1, in <module>
t.show()
File "<pyshell#13>", line 12, in show
print(self.__value)
AttributeError: 'Test' object has no attribute '_Test__value'
>>> t.value = 1 #为对象动态增加属性和对应的私有数据成员
>>> t.show()
1
>>> t.value
1
>>>
今天暂缓一下，看一下数据分析的内容。
1.列表和数组的区别，列表中数据可以多样化。数组要求数据类型相同。
2.Numpy 是一个开源的Python科学计算基础库，提供了一个强大的N维数组对象ndarray，具有广播功能函数，整合了C/C++
/Fortran代码的工具，提供线性代数、傅里叶变换、随机数生成等功能。
3.N维数组对象：ndarray 数组对象可以去掉元素间运算所需的循环，使一维向量更像单个数据。
.ndim 秩，即轴的数量或纬度的数量
.shape 对象的尺度，对于矩阵，n行m列
.size ndarray对象元素的个数，相当于.shape中nm的值
.dtype ndarry 对象的元素类型。
.itemsize ndarry 对象中每个元素的大小，以字节为单位。
4.ndarray的元素类型：bool 布尔类型，True 或False；intc 与c语言中的int类型一致；intp 用于索引的整数，与c语言中的ssize_t一致。int8 字节长度的整数 取值[-128,127] ;int16 16位长度的整数，取值【-32768，32767】；int32 32位长度的整数，无符号整数类型浮点数类型，复数类型
4.ndarray数组的创建
从python中的列表、元组等类型创建ndarray数组 x= np.array(list/tuple); x = np.array(list/tuple,dtype = np.float32)当np.array()不指定dtype时,Numpy将根据数据情况关联一个dtype类型，
使用numpy中的函数创建ndarray数组，如arrange，ones，zeros等。还可以从字节流（raw bytes）中创建数组。
x = np.array(list/tuple)
x = np.array(list/tuple,dtype = np.float32),dtype可以指定数据类型，不指定的将根据数据类型自动确定。
np.arange(n) 类似range函数，返回ndarray类型，元素从0到n-1；
np.ones(shape) 根据shape生成1个全1数组，shape是元组类型；
np.zeros(shape) 根据shape生成一个数组，每个元素都是val。
np.eye(n) 创建一个正方的nn的单位矩阵，对角线位1，其余为0.
np.linspace() 根据起止数据等间距地填充数据，形成数组；
np.concatenate()将两个或多个数组合并成一个新的数组。
5.对数组的维度和数据类型的变换。
.reshape(shape) 不改变数组元素，返回一个shape形状的数组，原数组不改变。
.resize(shape) 与reshape（）功能一致，但修改原数组。
.swapaxes(ax1,ax2) 将数组n个维度中的两个维度进行调换。
.flatten（） 对数组进行降维，返回折叠后的一位数组，原数组不变。
数组类型的变换：new_a = a.astype(new_type)
ndarray 数组向列表的转换：ls = a.tolist()
6.ndarray 数组的运算：
np.abs(),np.fabs(),np.sqrt(),np.square()
np.log(x).np.log10(),np.log2()
np.ceil() np.floor();
np.rint（）四舍五入；np.modf()将整数和小数部分分开
numpy二元函数运算，±*/** np.maxmun(x,y)
np.mod(x,y) np.copysign(x,y) ><+=！=
7.读csv文件
np.savetxt(frame,array,fmt = ‘%.18e’,delimiter=None)
frame:文件、字符串或产生器，可以是gz或bz2的压缩文件；arry 存入文件的数组；fmt 写入文件的格式，例如“%d %.2f%.18e”;
np.load(frame,dtype,delimiter = None,unpack = False),dtype为数据类型，upck默认为false，如过为true，读入属性将分别写入不同变量。
8.对多维变量存取：
a.tofile(frame,sep=’’,format =’%s’)
np.fromfile(frame,dtype = flaot,count = -1,sep=’’)
dtype 读取数据的类型，count读入元素的个数，-1表示读入整个文件。
缺点：需要额外写一个文件说明存取数组的维度信息。
9.Numpy的便捷文件存取
np.save(fname,array) 或np.savez(fname,array)
frame 文件名，以.npy为扩展名，压缩扩展名为.npz
array ；数组变量
10.Numpy 的随机函数子库
rand randn randint seed(s) 0-1 均匀分布 n正态分布 整数 区间范围
>>> a = np.random.rand(3,4,5)
>>>
>>> a
array([[[0.23765557, 0.36649346, 0.70045883, 0.41009289, 0.76629848],
[0.34552465, 0.97641305, 0.91096502, 0.09435248, 0.73101356],
[0.46610143, 0.88955784, 0.48143552, 0.72787876, 0.23570576],
[0.45144982, 0.63313632, 0.37384284, 0.25788377, 0.0341047 ]],
[[0.09109581, 0.56304725, 0.27191195, 0.52245713, 0.83288139],
[0.56233959, 0.16161125, 0.28196578, 0.68968082, 0.29982289],
[0.25350569, 0.52952347, 0.32402623, 0.38398131, 0.44546931],
[0.41958415, 0.25337374, 0.98909639, 0.08072454, 0.00354332]],
[[0.60281286, 0.73057806, 0.01895487, 0.1759737 , 0.84409951],
[0.97960905, 0.4659815 , 0.05871244, 0.81239668, 0.88167103],
[0.48653991, 0.22823176, 0.50153414, 0.05225988, 0.58820932],
[0.864764 , 0.71883582, 0.72423452, 0.88726707, 0.45418993]]])
>>> b = np.random.rand(3,4)
>>> b
array([[0.96795453, 0.44029296, 0.48909726, 0.30126388],
[0.40615896, 0.29533075, 0.65807984, 0.56878269],
[0.69178749, 0.76793946, 0.04380486, 0.11241911]])
b = np.random.randint(100,200,(3,4))
>>> b
array([[155, 173, 188, 192],
[175, 177, 174, 106],
[156, 144, 154, 199]])
>>> np.random.seed(1)
>>> np.random.randint(10,20,(2,3))
array([[15, 18, 19],
[15, 10, 10]])
>>> np.random.seed(1)
>>> np.random.randint(10,20,(2,3))
array([[15, 18, 19],
[15, 10, 10]])
>>>
shuffle 根据数组的第1轴进行随排列，改变数组x；
permutation（a) 根据数组a的第1轴产生一个新的乱序数组，不改变数组x‘
choice（a[,size,replace,p])从一维数组以概率p抽取元素，形成size大小新数组replace表示是否可以重用元素，默认为false）
np.random.choice(b,(3,2),replace=False)
array([[188, 100],
[157, 181],
[101, 108]])
>>> np.random.choice(b,(3,4),p=b/np.sum(b))
array([[100, 108, 188, 157],
[188, 113, 188, 100],
[188, 157, 160, 113]])
uniform(low,hize,size) 产生均匀分布的数组，low起始值，high结束值，size形状
normal（loc，scale，size） 产生具有正态分布的数组，loc均值，scale 标准差，size形状）
poisson（lam,size) 产生具有泊松分布的数组，lam随机事件发生率，size形状。
11.numpy的统计函数
sum（a,axis)
mean(a,axis)
average(a,axis,weight = none)weight是权重
std(a,axis)
var(a,axis) 方差，axis表示轴的方向；
min(a) max(a)
argmin(a) argmax(a) 根据shape返回的一维的坐标
unravel_index(index,shape）根据shape将一维下标index转换为多维下标；
ptp(a) 计算数组中a元素最大值与最小值的差
median（a) 计算a中元素的中位数。
a = np.arange(15).reshape((3,5))
>>> a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
>>> np.sum(a)
105
>>> np.sum(a,axis=0)
array([15, 18, 21, 24, 27])
>>> np.sum(a,axis=(0,1))
105
>>> np.sum(a,axis=1)
array([10, 35, 60])
>>> np.argmax(a)
14
>>> np.unravel_index(np.argmax(a),a.shape)
(2, 4)
>>> np.median(a)
7.0
12.np.random的梯度函数，np.gradient(f) 计算数组f中元素的梯度，当f为多维时，返回每个纬度梯度。
c = np.random.randint(0,50,(3,5))
>>> c
array([[40, 12, 16, 4, 5],
[ 6, 13, 39, 9, 20],
[29, 12, 30, 36, 1]])
>>> np.gradient(c)
[array([[-34. , 1. , 23. , 5. , 15. ],
[ -5.5, 0. , 7. , 16. , -2. ],
[ 23. , -1. , -9. , 27. , -19. ]]), #最外层梯度
array([[-28. , -12. , -4. , -5.5, 1. ],
[ 7. , 16.5, -2. , -9.5, 11. ],
[-17. , 0.5, 12. , -14.5, -35. ]])]
>>>
153
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
