PYTHON开发--面向对象基础入门

Python中通过使用类(class)和对象(object)来实现面向对象（object-oriented programming，简称OOP
）的编程。 面向对象编程的最主要目的是提高程序的重复使用性，这和函数的目的相类似。

假设我养了一只小鸡，叫summer。它是个对象，属于鸟类。

比如说我们要实现这个简单的功能
小明，10岁，男，喝酒
小明，10岁，男，吸烟
小明，10岁，男，游戏 老王，50岁，男，喝酒
老王，50岁，男，吸烟
老王，50岁，男，游戏
我们往往在使用函数式编程的时候回这样写
def foo(name,age,sex,content):
print(name,age,sex,cntent)
foo()这里面赋值就行

1 class bar:
2 def foo(self，name,age,sex,content):
3 print(name,age,sex,content)
4 obj = bar()
5 obj.foo(小明，10岁，男，喝酒)
6 obj.foo(小明，10岁，男，吸烟)
7 obj.foo(小明，10岁，男，游戏)
8 obj.foo(老王，10岁，男，喝酒)
9 obj.foo(老王，10岁，男，吸烟)
10 obj.foo(老王，10岁，男，游戏)

class s: #类名
def add(self,a,b,c): #函数
print(a+b+c)
return a
obj = s() #中间人，对象
obj.add(1,2,3)
ret = (obj.add(1,2,3))
print(ret) 结果为： # 注意这里面最后又return 最后返回的就是return的值6
6
1

class bar:
def foo(self,arg):
print(self,arg)
obj = bar()
print(obj)
obj.foo(11111111111)
结果显示为：

你会发现self 和obj是一样的，self是调用方法的对象（中间人）

但是能不能再中间人里面存东西也就是self.name = "sang"这样行不行，其实 是可以的，上面的例子我们是通过中间人也就是对象先去访问类，我们也可以在对象中存东西，再去执行方法再看一个例子

class bar:
def __init__(self):
print("helo world")
def foo(self):
print("")
z = bar()
print(z)
z.foo()
结果为：

class Bar:
def __init__(self,n1,n2,n3,n4,n5,n6):
self.nam1=n1
self.nam2=n2
self.nam3=n3
self.nam4=n4
self.nam5=n5
self.nam6=n6
def foo(self):
print(self.nam1,self.nam2,self.nam3,self.nam4,self.nam5,self.nam6)
z = Bar(1,2,3,4,5,6)
print(z.nam1)
z.foo()
结果为：

class bar:
def __init__(self,n,a,s):
self.name = n
self.age = a
self.sex = s
def foo(self,content):
print(self.name,self.age,self.sex,content)
obj = bar("小明"，10，"男")
这样是不是就更加简便了，这就是面向对象的特点

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。所以，在使用面向对象的封装特性时，需要注意：
将内容封装到某处
从某处调用被封装的内容

1 class person:
2 def __init__(self,name,age):
3 self.n = name
4 self.a = age
5 def show(self):
6 print("%s-%s" %(self.n,self.a))
7 zhangsan = person("张三",22)
8 zhangsan.show()
9 wangwu = person("王五",55)
10 wangwu.show()
结果为：

代码

继承，面向对象中的继承和现实生活中的继承相同，即：儿子可以继承父亲的内容。

class father: #父类，基类
def f1(self): #fi()中的self时形参，代指obj,self是用于调用方法的调用者
print("f1.aaa")
def f2(self):
print("f2.vvv")
class son(father): #子类，派生类，他们的关系是一一对应的，
def f3(self):
print("f3.ccc")
def f2(self): #重写，防止继承父类中的方法
print("son.f2") #son中的f2表示不继承父类中f2，但是如果没有son中的f2,则表示全部继承父类中的，不想继承就在son自己中定义一个
11 obj = son()

obj.f3()
obj.f1()
obj.f2()

结果为：

同时呢，父亲还可以有一个父类，这时候son还可以继承父亲的父类，

但是如果我们既想执行自己得f2又想执行父类的f2该怎么办？

class F1():
def a1(self):
print('F1.a')class F2():
def a1(self):
print('F2.a')class S(F1,F2):
passobj = S()
obj.a()
结果为：F1.a #哪个父类在前面就执行哪一个父类中的

class Base:
def a(self):
print('Base.a')
class F0(Base):
def a1(self):
print('F0.a')
class F1(F0):
def a1(self):
print('F1.a')
class F2(Base):
def a1(self):
print('F2.a')
class S(F1,F2):
pass
obj = S()
obj.a()
结果为： Base.a 你会发现现在左边找，一直往上找，再找右边，但是如果F1和F2的共同的根中有，
F2中也有，它会先找F2，最后才去找根，
总结：

# class BaseHandler():
# pass
# class RequestHandler(BaseHandler):
# def serve_forever(self):
# print("RequestHandler.serve_forever")
# self.process_request()#self 就是obj
# def process_request(self):
# print("RequestHandler.process_request")
#
# class Minx:
# def process_request(self):
#

print("RequestHandler.serve_forever")

# class son(Minx,RequestHandler): # pass # obj = son() # obj.serve_forever()
结果为：

print("RequestHandler.serve_forever")

print("RequestHandler.serve_forever") 此时 ，obj是son的对象，它会返回到原点再从左开始找。

import socketserver
obj = socketserver.ThreadingTCPServer(1,2)#创建对象，init
obj.serve_forever()

# Java
string v = 'alex'
def func(string arg):
print(arg) #在Java中是需要声明类型的
func('alex')
func(123) # Python
v = 'alex'
def func(arg):
print(arg)
func(1)
func('alex')

类成员：
# 字段
- 普通字段，保存在对象中，执行只能通过对象访问
- 静态字段，保存在类中， 执行 可以通过对象访问 也可以通过类访问 # 方法
- 普通方法，保存在类中，由对象来调用，self=》对象
- 静态方法，保存在类中，由类直接调用
- 类方法，保存在类中，由类直接调用，cls=》当前类 ########应用场景：
如果对象中需要保存一些值，执行某功能时，需要使用对象中的值－＞普通方法
不需要任何对象中的值，静态方法 # 属性，特性
- 不伦不类

class Foo:
def __init__(self, name):
# 普通字段
self.name = name
# 普通方法
def show(self):
print(self.name)
obj = Foo('alex')
obj.name #字段直接去调用
obj.show() #方法加上（）才行

class province:
#静态字段属于类
country = "中国"
def __init__(self,name):
#普通字段，属于对象
self.name = name
# henan = province("河南")
# hebei = province("河北")
print(province.country)
henan = province("河南")
print(henan.name)
结果为：

alex
中国
河南

class foo:
def bar(self):
print("you are good")#普通方法
@staticmethod#静态方法保存在类中，由类直接调用
def sta():
print("")
@staticmethod #静态装饰器
def stat(a1,a2):
print(a1,a2)
@classmethod
def classmd(cls):
#cls 是类名
print(cls)
print("classmd") obj = foo()
obj.bar()
foo.sta()
foo.stat(2,3)
foo.classmd()
结果是：

class foo:
def __init__(self):
self.name = "a"
def bar(self):
print("bar")
@property
def perr(self0):
print("")
return 1 #obj.per = 123
@perr.setter
def perr(self,val):
print(val)
@perr.deleter
def perr(self):
print(666)
obj = foo()
r = obj.perr
#print(r)
obj.perr = 123
del obj.perr
结果为： 其实他们就是一一对应的关系

123
123
666

class foo:
def f1(self):
return 123
per = property(fget=f1) 第一种 @property
def per(self):
return 123 第二种 其实这2种方法功能是一样的
obj = foo()
re = obj.per
obj.per
print(re)
所以呢，定义属性有2种方法，分别是装饰器和静态字段
per = property(fget = f1,fset = f2,fdel = f3,doc = "ajakjhs")
最多有三个参数，最后一个参数是介绍这个是干嘛的