cnblogs 分享 static orien 河北 字段 c89 version upd
- #!/usr/bin/env python
- # encoding: utf-8
- """
- @version: python3.6
- @file: object_oriented.py
- @time: 2017/11/3 21:18
- """
- ‘‘‘定义类并执行类中的方法:
- class 类名:
- def 方法名(self,arg):
- print(arg)
- 中间对象 = 类名()#类的实例化
- 中间人.方法名(1)#此处的 1 指的是上面的arg‘‘‘
- #
- ‘‘‘
- class bar:
- def paper(self,a):
- #a=‘had been accepted‘
- # print(a)
- return a
- object=bar()
- ret = object.paper(‘paper‘)
- print(ret)
- ‘‘‘
- class bar:
- def foo(self,arg):
- print(self,self.name,self.age,self.sex,arg)
- z = bar()
- print(z)
- z.name = ‘alex‘
- z.age = ‘23‘
- z.sex = ‘male‘
- z.foo(999)
- # <__main__.bar object at 0x000001C89E2DBD68>
- # <__main__.bar object at 0x000001C89E2DBD68> alex 23 male 999表明了 self表示类的实例
- ‘‘‘
- ‘‘‘
- #self代指调用方法的对象,也是类的实例化(中间人)
- class person:
- def __init__(self,name,age):#构造方法 由python自己调用 初始化操作 作用1。创建类对象,2.通过对象执行类中的一个特殊方法
- #构造方法的特性是 类名() 自动执行构造方法
- self.name = name
- self.age = age
- def show(self):#需要人为调用
- print(‘%s-%s‘ %(self.name,self.age))
- lihuan = person(‘liuhuan‘,18)
- zhaojin = person(‘zhaojin‘,20)
- lihuan.show()
- ‘‘‘
- #
- ‘‘‘
- #继承
- class F:
- def f1(self):
- print(‘F.f1‘)
- def f2(self):
- print(‘F.f2‘)
- class s(F):
- def s1(self):
- print(‘s.s1‘)
- def f2(self):
- print(‘s.f2‘)#由于子类中由f2这一方法 所以不会继承父类的f2;若想将父类的f2输出,有两种方法 如下:
- #super(s, self).f2()#方法一:执行父类中的f2方法
- #F.f2(self)#方法二:执行父类中的f2方法
- obj = s()
- obj.s1()#s1中的self是形参,此时代指obj
- obj.f1()#self永远指调用方法的调用者
- obj.f2()
- ‘‘‘
- class province:
- country = ‘中国‘#静态字段,属于类
- def __init__(self,name):
- #普通字段,属于对象
- self.name =name
- henan = province(‘河南‘)
- hebei = province(‘河北‘)
- print(province.country)
- print(hebei.name)
- ‘‘‘
- #
- ‘‘‘
- class foo:
- def bar(self):
- print(‘bar‘)
- @staticmethod#静态方法 关键字
- def sta():
- print(‘sta‘)
- @staticmethod
- def sta1(a1,a2):
- print(a1,a2)
- @classmethod#类方法
- def rew(cls):
- print(cls)
- print(‘sdfsadf‘)
- @property #属性关键字 以普通方法来定义,但执行时却以类的方式执行
- def per(self):
- print(213)
- foo.sta()
- foo.sta1(1,2)
- obj = foo()
- obj.bar()
- foo.rew()
- obj = foo()
- obj.per
- ‘‘‘
- ‘‘‘
- class Pergination:
- def __init__(self,current_page):
- try:
- p =int(current_page)
- except Exception as e :
- p =1
- self.page = p
- @property
- def start(self):
- val = (self.page-1)*10
- return val
- @property
- def end(self):
- val=self.page*10
- return val
- li=[]
- for i in range(1000):
- li.append(i)
- while True:
- p = input(‘请输入要查看的页码:‘)#每页显示10条
- obj =Pergination(p)
- print(li[obj.start:obj.end])
- ‘‘‘‘‘‘
1、如何创建类
class 类名:
pass
2、创建方法
构造方法,__init__(self,arg)
obj = 类(‘a1‘)
普通方法
obj = 类(‘xxx’)
obj.普通方法名()
3、面向对象三大特性之一:封装
class Bar:
def __init__(self, n,a):
self.name = n
self.age = a
self.xue = ‘o‘
b1 = Bar(‘alex‘, 123)
b2 = Bar(‘eric‘, 456)
4、适用场景:
如果多个函数中有一些相同参数时,转换成面向对象
class DataBaseHelper:
def __init__(self, ip, port, username, pwd):
self.ip = ip
self.port = port
self.username = username
self.pwd = pwd
def add(self,content):
# 利用self中封装的用户名、密码等 链接数据
print(‘content‘)
# 关闭数据链接
def delete(self,content):
# 利用self中封装的用户名、密码等 链接数据
print(‘content‘)
# 关闭数据链接
def update(self,content):
# 利用self中封装的用户名、密码等 链接数据
print(‘content‘)
# 关闭数据链接
def get(self,content):
# 利用self中封装的用户名、密码等 链接数据
print(‘content‘)
# 关闭数据链接
s1 = DataBaseHelper(‘1.1.1.1‘,3306, ‘alex‘, ‘sb‘)
5、面向对象三大特性之二:继承
1、继承
class 父类:
pass
class 子类(父类):
pass
2、重写
防止执行父类中的方法
3、self永远是执行改方法的调用者
4、
super(子类, self).父类中的方法(...)
父类名.父类中的方法(self,...)
5、Python中支持多继承
a. 左侧优先
b. 一条道走到黑
c. 同一个根时,根最后执行
6、面向对象三大特性之三:多态
====> 原生多态
# Java
string v = ‘alex‘
def func(string arg):
print(arg)
func(‘alex‘)
func(123)
# Python
v = ‘alex‘
def func(arg):
print(arg)
func(1)
func(‘alex‘)
==================================================================
练习:
class Person:
def __init__(self,n,a,g,f):
self.name = n
self.age =a
self.gender =g
self.fight = f
role_list = []
y_n = input(‘是否创建角色?‘)
if y_n == ‘y‘:
name = input(‘请输入名称:‘)
age = input(‘请输入名称:‘)
...
role_list.append(Person(....))
# role_list,1,2
======================================================= 面向对象中高级 ========================================================
class Foo:
def __init__(self, name):
# 普通字段
self.name = name
# 普通方法
def show(self):
print(self.name)
obj = Foo(‘alex‘)
obj.name
obj.show()
类成员:
# 字段
- 普通字段,保存在对象中,执行只能通过对象访问
- 静态字段,保存在类中, 执行 可以通过对象访问 也可以通过类访问
# 方法
- 普通方法,保存在类中,由对象来调用,self=》对象
- 静态方法,保存在类中,由类直接调用
- 类方法,保存在类中,由类直接调用,cls=》当前类
########应用场景:
如果对象中需要保存一些值,执行某功能时,需要使用对象中的值->普通方法
不需要任何对象中的值,静态方法
# 属性,特性
- 不伦不类
中国的所有省份,用面向对象知识表示?
class Province:
# 静态字段,属于类
country = ‘中国‘
def __init__(self, name):
# 普通字段,属于对象
self.name = name
henan = Province(‘河南‘)
henan.name
henan.name = "河南南"
#hebei = Province(‘河北‘)
# Province.country
python模块-类
来源: http://www.bubuko.com/infodetail-2380763.html