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 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

时间: 2024-11-09 04:46:17

python模块-类的相关文章

python-学习笔记之-Day5 双层装饰器 字符串格式化 python模块 递归 生成器 迭代器 序列化

1.双层装饰器 #!/usr/bin/env python # -*- coding: utf-8 -*- # author:zml LOGIN_INFO = False IS_ADMIN = False   def check_log(func): def inner(): res = func() if LOGIN_INFO: print('验证成功!') return res else: print('验证失败!') return inner   def check_admin(func)

Python 八、Python模块

一.python文件概述 1.python模块概述 可以将代码量较大的程序分割成多个有组织的.彼此独立但又能互相交互的代码片段,这些自我包含的有组织的代码段就是模块 模块在物理形势上表现为以.py结尾的代码文件 一个文件被看作一个独立的模块,一个模块也可以被看作是一个文件 模块的文件名就是模块的名字加上扩展名(.py) 每个模块都有自己的名称空间 python允许导入其它模块以实现代码重用,从而也实现了将独立的代码文件组织成更大的程序系统 python中,模块也是对象 在一个模块的顶层定义的所有

python 学习第五天,python模块

一,Python的模块导入 1,在写python的模块导入之前,先来讲一些Python中的概念性的问题 (1)模块:用来从逻辑上组织Python代码(变量,函数,类,逻辑:实现一个功能),本质是.py结尾的python文件(文件名:test.py,对应的模块名:test) (2)包:用来从逻辑上组织模块的,本质就是一个目录(必须带有一个__init__.py文件) 2,导入的方法 (1)import module_name导入某个模块 (2)import module_name,module2_

python Class(类) and Object Oriented(面向)

Python类与面向对象    程序=指令+数据 (或算法+数据结构).代码可以选择以指令为核心或以数据为核心进行编写.    两种范型        (1)以指令为核心:围绕"正在发生什么"进行编写(面向过程编程:程序具有一系列线性步骤:主体思想是代码作用于数据)以指令为中心,程序员的主要工作在于设计算法.        (2)以数据为核心:围绕"将影响谁"进行编写(面向对象编程<oop>:围绕数据及为数据严格定义的接口来组织程序,用数据控制对代码的访

Python学习日志之Python模块

Python入门学习笔记之Python模块 Python模块: 一.认识Python模块 1.什么是模块 函数是可以实现一项或多项功能的一段程序.我们的模块是函数功能的扩展,模块是可以实现一项或多项功能的程序块.从定义可以看出:函数是一段程序,模块是一项程序块,也就是说函数,模块都是用来实现功能的,但是模块范围要广,在模块里可以重用多个函数 2.如何导入模块 在Python程序中如果要使用某个模块,不能直接使用某个模块的功能.在模块使用之前,我们需要先导入指定模块,只要导入模块后我们才能使用 >

dive into python:模块的导入和搜索文件路径的配置

1.Python中导入模块:import sys:相当于Java中的导入包.类. 比如,我们导入sys模块,使用:import sys; 2.Python中调用函数的时候,会从默认配置的库文件夹中(sys.path)搜索你所调用的模块.这个库文件的目录配置,如下: sys.path用来配置Python模块搜索路径.它是一个List(列表),打印默认sys.path的内容: Python 3.3.5 (v3.3.5:62cf4e77f785, Mar  9 2014, 10:37:12) [MSC

Python 的类的下划线命名有什么不同?

1,以一个下划线开头的命名 ,如_getFile2,以两个下划线开头的命名 ,如__filename3,以两个下划线开头和结尾的命名,如 __init__()4,其它这些命名有什么不同吗 首先是单下划线开头,这个被常用于模块中,在一个模块中以单下划线开头的变量和函数被默认当作内部函数,如果使用 from a_module import * 导入时,这部分变量和函数不会被导入.不过值得注意的是,如果使用 import a_module 这样导入模块,仍然可以用 a_module._some_var

Python学习笔记-打包发布Python模块或程序,安装包

Python模块.扩展和应用程序可以按以下几种形式进行打包和发布: python setup.py获取帮助的方式 python setup.py --help python setup.py --help-commands 所有可以使用的命令,如build,install python setup.py COMMAND --help 获取特定命令的帮助 python setup.py COMMAND --help-formats 获取特定命令支持使用的格式 打包 1.压缩文件(使用distuti

Python/模块与包之包

Python/模块与包之包 1. 包是一种通过使用模块名 来组织Python模块名称空间的方式,一个类似于目录并存有__init__.py文件的被称为包 包的本质就是一个包含__init__.py文件的目录.包A和包B下有同名模块也不会冲突,如A.a与B.a来自俩个命名空间 无论是import形式还是from...import形式,凡是在导入语句中(而不是在使用时)遇到带点的,都要第一时间提高警觉:这是关于包才有的导入语法 包 通常包总是一个目录,可以使用import导入包,或者from + i