上一篇文章:（2018-03-21）0003.Python基础入门班_第3课、容器以及容器的访问使用
关于本人
个人信息:微博
写作区:个人博客、、开源中国、豆瓣、掘金、CSDN
代码管理区:码云、GitHub、GitBook、Python_NoteBook(这个仅仅限于自己的本地搭建)
我的网络制作书籍:Python3Book(基于廖雪峰的Python教程编写成书)、
july_Oneline(基于七月在线培训机构的教程编写成书)、LineCode刷题总结__GitBookEditor网络书籍
推荐网站
1.第三方库__scipy
2.第三方库__sklearn（安装之前需要安装，numpy、scipy）
3.什么是ML
4.什么是测试集
5.sklearn的作用
推荐软件
无
推荐书籍
无
第4课 面向对象基础
一、类和对象
百度维基
类和对象（class）是两种以计算机为载体的计算机语言的合称。
对象是对客观事物的抽象，类是对对象的抽象。类是一种抽象的数据类型。
它们的关系是，对象是类的实例，类是对象的模板。
对象是通过new className产生的，用来调用类的方法;类的构造方法 。
自身理解
人类 是 类
我们每个人 都是对象。
是通过人类演化而成的一个个对象
代码展示
#一、类和对象
print('一、类和对象')
class Foo:
# 这里我们可以创建一个类级别的变量
# 它不会随着由此类创建的变量而变化
name = 'lyh'
def bar(self): # 第一参数的指向
print('Bar')
def hello(self,name):
print('you are %s' %self.name)
print('i am %s'%name)
print('\n')
pass
# 根据Foo创建的对象
obj = Foo()
obj2 = Foo()
print(obj)
obj.bar()
obj.hello('lyh')
obj2.hello('h')
print('!end!\n')
控制台打印
一、类和对象
<__main__.Foo object at 0x013D7CB0>
Bar
you are lyh
i am lyh
you are lyh
i am h
!end!
二、构造函数
百度维基
构造函数：是一种特殊的方法。
只要用来在创建对象时 初始化对象，即为对象成员变量赋初始值
自身理解
自己创建一些函数
代码展示
#二、构造函数
'构造函数：是一种特殊的方法。只要用来在创建对象时 初始化对象，即为对象成员变量赋初始值'
print('二、构造函数')
class Foo:
name = 'l'
def __init__(self): #这就是构造函数，它的职责是在模型创建的初期，就完成一些动作
# 简单的说就是，自定义的初始化步骤:
# 同样，他需要self来指代本身这个class
self.name = 'll'
def __init__(self,name2): #你可以在这里附加上一些参数
# 这些参数僵尸你创建一个Foo类时的必要条件
self.name = name2
def hello(self,name):
print('you are %s' %self.name)
print('i am %s'%name)
# obj = Foo()
obj.hello('a')
obj2 = Foo('lll')
obj.hello('b')
print('!end!\n')
控制台打印
二、构造函数
you are lyh
i am a
you are lyh
i am b
!end!
三、访问限制
自身理解
能不能访问
代码展示
#三、访问限制
'''
变量 是否能给外界访问
如果不能 怎么在创建类的时候设置
在变量的前面添加两个__
'''
print('三、访问限制')
class Stundet:
def __init__(self,name,age):
# 外界能访问的变量
# self.name = name
# self.age = age
# 外界不能访问的变量
self.__name = name # AttributeError: 'Stundet' object has no attribute 'name'
self.__age = age
def detail(self):
print(self.__name)
print(self.__age)
Lyh = Stundet('Lyh',12)
Lyh.age = 20
Lyh.detail()
print('!end!\n')
控制台打印
三、访问限制
Lyh
12
!end!
四、Getter + Setter
getter 和 setter的作用
setter方法，是对象引用调用setter方法，并传入参数。
getter方法，对象调用getter方法，获取对象属性的值。
自身理解
get 获取对象属性值
set 设置对象属性值
代码展示
#四、Getter + Setter
'''
如何确保安全，又能被外部修改变量
'''
print('四、Getter + Setter')
class Student(object): # (object)，表示该类是从哪个类继承下来的
def get_name(self):
return self.__name
def get_age(self):
return self.__age
def set_age(self):
self.__age = age
print('!end!\n')
控制台打印
四、Getter + Setter
!end!
五、Python的面向对象三大特性、python的经典类和新类(现在基本都是用新类)
封装、继承、多态的基本知识
自身理解
封装:将一些东西收藏起来
继承:子继承父业
多态:很多钟表示状态
代码展示
#五、Python的面向对象三大特性
'''
封装：指的是把内容封装到某个地方，用于日后调用
其实就是使用构造方法将内容封装到对象中，
然后通过对象直接 或者self间接获取被封装的内容
继承：儿子继承父亲
爸爸有的儿子都有
多态：
Python可以多类继承
'''
print('五、Python的面向对象三大特性')
#1.封装
class Student(object):
def __init__(self,name,age):
self.name = name
self.age = age
def detail(self):
print(self.name)
print(self.age)
obj1 = Student('lyh',12)
print(obj1.name) # 直接调用obj1对象的name属性
print(obj1.age) # 直接调用obj1对象的age属性
obj1.detail() #自我调用
print('!~~~!\n')
#2.继承
class PrimaryStudent(Student): #因为是继承于学生类，所以我们卸载括号内
# 这里我们可以不写构造函数，于是我们就是直接引用Student的构造函数
def lol(self) : # 我们有一些新的独有方法，会被叠加起来
print('开打开打')
class CollegeStudent(Student):
#改写父类的构造函数
def __init__(self,name,age,gf):
#于是爸爸的init会被直接 overwrite（重写掉）
self.name = name
self.age = age
self.gf = gf
def gf_detail(self):
print(self.gf)
''''''
obj1 = PrimaryStudent('小了',3)
obj1.lol() #独有方法
obj1.detail() #继承与爸爸的方法
print('!~~~!\n')
obj2 = CollegeStudent('李',22,'H')
obj2.detail()
obj2.gf_detail()
print('!~~~!\n')
# Python可以多类继承
class D:
def bar(self):
print('D.bar')
class C(D):
def bar(self):
print('C.bar')
class B(D):
pass
class A(B,C): # A 继承两个 爸爸 B、C
pass
a = A()
# -- 经典类
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B没用，
# 则继续去D类中找，如果D没有，则继续去C类中找，如果还是没有找到则报错
# 顺序 A -> B -> D -> C # 注意 这是之前python2.2的经典类顺序
# ** 新类(python3.x)
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B没用，
# 则继续去C类中找，如果C没有，则继续去D类中找，如果还是没有找到则报错
# 顺序 A -> B -> C -> D # 注意 这是新类顺序
a.bar()
# 多态
'''
python 不支持多态并且也用不到多态，多态的概念是应用于java 和 C#这一类强类型语言
，而python 是 鸭子类型
'''
class F1:
pass
# 假设 ，S1是我们的正统类，它继承与根正苗红的F1，
class S1(F1):
def show(self):
print('S1.show')
# S2是路人甲
class S2:
def show(self):
print('S2.show')
def Func(obj):
obj.show()
s1_obj = S1()
s2_obj = S2()
Func(s1_obj)
Func(s2_obj)
print('!end!\n')
控制台打印
五、Python的面向对象三大特性
lyh
12
lyh
12
!~~~!
开打开打
小了
3
!~~~!
李
22
H
!~~~!
C.bar
S1.show
S2.show
!end!
六、获取对象信息(dir()的作用、实例对象和类对象、模块和包)
自身理解
获取人、事物的信息
代码展示
#六、获取对象信息
print('六、获取对象信息')
print(type(123))
print(type('str'))
print(type(None))
print(type(abs))
print('用语句进行获取对象信息')
# 用语句进行获取对象信息
print(type(123) == type(456))
print(type('123') == type('456'))
print(type('123') == type(456))
print(type('123') == type(str))
print(type([]) == type(list))
print('isinstance')
# isinstance : 可以告诉我们，一个对象是不是某种类型（包含继承关系）
class A:
pass
class B(A):
pass
class C(B):
pass
k = A()
g = B()
y = C()
print(isinstance(y,C))
print(isinstance(y,B))
print('## 使用dir()')
## 使用dir()
'''
如果要获取一个对象的所有属性和方法，可以使用dir()函数，
它会返回一个包含字符串的list
比如，获取一个str对象的所有属性和方法
'''
print(dir('ABC'))
print('ABC'.__len__())
# dir()
'''
配合
getattr(),
setattr(),
hasattr() 有没有这个属性
'''
class MyObject:
def __init__(self):
self.x = 9
def power(self):
return self.x * self.x
obj = MyObject()
print(hasattr(obj,'x')) # 有没有x这个属性
print(hasattr(obj,'power')) # 有没有power这个属性
print(hasattr(obj,'y')) # 有没有y这个属性
print(setattr(obj,'y',19)) # 设置y这个属性
print(getattr(obj,'y')) # 获取y这个属性
fn = getattr(obj,'power') # 获取属性'power'并赋值到变量Fn里面
print(fn()) # 调用 fn() 相当于调用 obj.fn()
# 实例属性 和 类属性
'''
类创建的实例 可以任意绑定属性
给实例 绑定属性的方法是通过 实例变量，或者通过self变量
'''
class Student(object):
name = 'Student' # 类属性
def __init__(self,name):
self.name = name # 实例属性
s = Student('boy')
s.score = 90
print(s.name)
class Student(object):
name = 'Student' # 类属性
s = Student() # 创建实例s
print(s.name) # 打印name属性,因为实例并没有name属性，所以会执行查找class的name属性
print(Student.name) # 打印类的name属性
s.name = 'LYH' #给实例绑定name属性
print(s.name) # 由于 实例属性优先级比类属性高，因此，他会屏蔽类的name属性
print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问
del s.name # 删除实例的name属性
print('123'+s.name) # 再次调用s.name 由于实例的name属性没有找到，类的name属性就显示出来了
print('## 模块 和 包')
## 模块 和 包
'''
python的程序 由 包(package)、模块(module) 和函数组成。
包是 由 一系列模块组成的集合。
模块是处理某一类问题的函数 和 类的集合。
包 就是一个完成特定任务的工具。python提供了许多有用的工具包，如字符串处理、
图形用户接口、web应用、图形图像处理等。
这些自带的工具包和模块安装在python的安装目录下的Lib子目录中
'''
# 包
'''
包将有联系的模块组织在一起，有效避免模块名称冲突问题，让应用组织结构更加清晰。
一个普通的python应用程序的目录结构：
app/
__init__.py
a/
__init__.py
a.py
b/
__init__.py
b.py
app是最顶层的包，a和b是它的子包，可以这样导入
from app.a import a
from app.b.b import test
a.test()
test()
'''
# 模块
'''
在python中一个文件可以被看成一个独立模块，而包对应着文件夹。模块把python代码
分成一些有组织的代码段，通过导入的方式实现代码重用
import sys
print(sys.path)
'''
import sys
print(sys.path)
# 导入模块
# import module1
#使用from-import语句导入模块的属性
# 单行导入
# from module import name1
#多行导入
# from module import name1,name2,name3
# from module import * # 导入所有
# 自定义导入模块名称
# from A import B as BoyFunc
print('!end!\n')
控制台打印
六、获取对象信息
用语句进行获取对象信息
True
True
False
False
False
isinstance
True
True
## 使用dir()
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
3
True
True
False
None
19
81
boy
Student
Student
LYH
Student
123Student
## 模块 和 包
['C:\\Users\\Hasee\\Desktop\\Python_七月在线\\01-Python课程___Python基础入门班\\Code\\第4课 面向对象基础', 'C:\\Users\\Hasee\\AppData\\Local\\Programs\\Python\\Python35-32\\python35.zip', 'C:\\Users\\Hasee\\AppData\\Local\\Programs\\Python\\Python35-32\\DLLs', 'C:\\Users\\Hasee\\AppData\\Local\\Programs\\Python\\Python35-32\\lib', 'C:\\Users\\Hasee\\AppData\\Local\\Programs\\Python\\Python35-32', 'C:\\Users\\Hasee\\AppData\\Local\\Programs\\Python\\Python35-32\\lib\\site-packages']
!end!
七、实战
自身理解
将学习的东西 用在战场上。
代码展示
print('七、实战')
#七、实战
'''
下载 sklearn 包
http://scikit-learn.org/stable/install.html
iris(鸢尾花)
http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_iris.html
在ML里面
基本都会 X 判断 Y 的问题
X 基本就是
Y 基本就是
ML:
机器学习[1] (Machine Learning)，是研究计算机怎样模拟或实现人类的学习行为，
以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。
它是人工智能的核心，是使计算机具有智能的根本途径，
其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。
'''
from sklearn import svm,datasets
# datasets数据库、svm:upport Vector Machine 分类器（支持向量机）
'''
最好把 dataset 写成一个文件
'''
class Dataset:
# 我们创建一个dataset的类，这个类会帮我们下载相关的数据集
# 并给我们分类好x,y
def __init__(self,name):
# 告诉类,我们需要那个数据集
# 我们有两个选择,一个是'iris',一个是'digits'
self.name = name
def download_data(self): # 1、下载数据
# 从sklearn的自带集中下载我们制定的数据集
if self.name =='iris':
# 这里是sklearn自带的数据集下载方法，更多信息可以参考官网
self.download_data = datasets.load_iris()
elif self.name == 'digits':
self.download_data = datasets.load_digits()
else:
# 如果不是我们预想的两个数据集,则报错
print('DataSet Error : No Named datasets')
def generate_xy(self): # 2、创造x,y
# 通过这个过程 来把我们的数据集 分为原始数据 以及他们的label
# 我们先把数据下载下来
self.download_data() # 传接download_data参数
x = self.download_data.data # data 是 x
y = self.download_data.target # target 是 y
print('\n Original data looks like this :\n',x)
print('\n Labels looks Like this:\n',y)
return x,y
def get_train_test_set(self,ratio): # 3、数据分成训练、测试集
# 这里,我们把所有的数据分成训练集 和 测试集
# 一个参数要求我们告知，我们以多收的比例来分割训练和测试集
# 首先，我们把XY给generate出来
x,y = self.generate_xy()
# 有个比例，我们首先得知道 一共有多少的数据
n_samples = len(x)
#于是我们知道,有多少应该是训练集，多少应该是测试集
n_train = n_samples * ratio
# 好了，接下来 我们分割数据
X_train = x[:n_train] # X训练集
y_train = y[:n_train] # Y训练集
X_test = x[n_train:] # X测试集
y_test = y[n_train:] # Y测试集
# 好，我们得到了所有想要的玩意儿
return X_train,y_train,X_test,y_test
# === 我们的dataset类创造完毕===
# 使用digits 数据集
data = Dataset('digits')
# 接着,我们可以用0.7 的分割率 把 xy给分割出来
X_train,y_train,X_test,y_test = data.get_train_test_set(0.7)
'''
同样，我们也不一定需要自己创造类，我们可以引用第三方库里的类，
比如这里，我们用SVM作为我们的分类器，去训练我们的算法
我们就直接建造一个object，使他成为SVM类
'''
clf = svm.SVC()
'''
这里clf是classifier的简称，SVC指的是SVM的classification版本。
因为我们的数据集都是分类问题，所以我们使用SVC()
接下来，我们fit我们的数据(也就是训练我们的数据)
显然，做fit的时候，我们只可以使用训练集
'''
clf.fit(X_train,y_train)
print(clf.fit(X_train, y_train))
# 拿出数据进行测试
test_point =X_test[12]
y_true = y_test[12]
# clf.predict(test_point) # 看clf给出的预测是什么
print(clf.predict(test_point.reshape(1,-1))) # 输出 [7]
print(y_true) # 打印 7
'''
正确！
那么这样，你们已经学会如何训练数据集并作出新的预测了。
把所有的测试集都导入clf，让他pridict，并看看跟真实的label相差多少。
'''
print('!end!\n')
控制台打印
七、实战
Original data looks like this :
[[ 0. 0. 5. ..., 0. 0. 0.]
[ 0. 0. 0. ..., 10. 0. 0.]
[ 0. 0. 0. ..., 16. 9. 0.]
...,
[ 0. 0. 1. ..., 6. 0. 0.]
[ 0. 0. 2. ..., 12. 0. 0.]
[ 0. 0. 10. ..., 12. 1. 0.]]
Labels looks Like this:
[0 1 2 ..., 8 9 8]
C:\Users\Hasee\Desktop\Python_七月在线\01-Python课程___Python基础入门班\Code\第4课 面向对象基础\面向对象基础.py:442: VisibleDeprecationWarning: using a non-integer number instead of an integer will result in an error in the future
X_train = x[:n_train] # X训练集
C:\Users\Hasee\Desktop\Python_七月在线\01-Python课程___Python基础入门班\Code\第4课 面向对象基础\面向对象基础.py:443: VisibleDeprecationWarning: using a non-integer number instead of an integer will result in an error in the future
y_train = y[:n_train] # Y训练集
C:\Users\Hasee\Desktop\Python_七月在线\01-Python课程___Python基础入门班\Code\第4课 面向对象基础\面向对象基础.py:444: VisibleDeprecationWarning: using a non-integer number instead of an integer will result in an error in the future
X_test = x[n_train:] # X测试集
C:\Users\Hasee\Desktop\Python_七月在线\01-Python课程___Python基础入门班\Code\第4课 面向对象基础\面向对象基础.py:445: VisibleDeprecationWarning: using a non-integer number instead of an integer will result in an error in the future
y_test = y[n_train:] # Y测试集
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',
max_iter=-1, probability=False, random_state=None, shrinking=True,
tol=0.001, verbose=False)
[7]
7
!end!
代码:74nf
明天将会更新→0005.Python基础入门班_第5课、文件访问与函数式编程入门
代码都是上传百度云