python类模块_python模块-类

#!/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>

# <__main__.bar object at> 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