python笔记5 接口类抽象类 封装 反射 设计模式 模块 :random随机数 josn shelve持久化存储
接口类抽象类
接口类:接口类就是制定一个规则,让其他人按照我的规则去写程序.
#!/usr/bin/env python
from abc import ABCMeta,abstractmethod #针对新手强制规定类的格式,不统一格式就报错
class payment(metaclass=ABCMeta): #类的模板,新加入的类必须沿用这个类的模型
@abstractmethod
def pay(self,money):
pass
class qqpay:
def pay(self, money):
print('QQ支付了%s元' % money) class alipay:
def pay(self, money):
print('阿里支付了%s元' % (money)) class wechat:
def pay(self, money):
print('微信支付了%s元' % (money))
def pay(fs,money): #统一支付方式的函数
fs.pay(money)
a1 = qqpay() #定义类的单个对象
a2 = alipay()
a3 = wechat()
pay(a1,) #支付的方式被统一
封装
类的三大特性:继承,封装,多态(python默认支持)
类的结构:
class A:
country = 'china' # 静态变量(属性,字段)
__name__ = 'wk' # 私有静态变量 def func(self): # 动态普通方法
pass def __init__(self): # 特殊方法,双下方法
pass def __func(self, age): # 私有方法
self.__age = age #私有对象属性 @property #属性
def f1(self):
pass @classmethod # 类方法
def f2(cls):
pass @staticmethod # 静态方法
def f3():
pass
私有
私有成员有: 私有变量,私有对象属性,私有方法
class A:
__name = 'wk' #私有变量 def __aa(self, age): #私有方法
self.__age = age #私有对象属性
私有变量(私有变量和私有对象属性一样)
class A:
country = 'china'
__name = 'wk' def __init__(self, name, xingbie):
self.name = name
self.__xingb = xingbie def aa(self):
print(self.__name) #私有变量类外不能访问(print(bb.__name)报错),只能在本类内使用,子类继承父类一样不能调用父类私有变量
bb = A('',)
bb.aa()
wk
私有变量不是真实的找不到,而是变量名__name变成了_A__name,用_A__name就能找到私有变量
class A:
country = 'china'
__name = 'wk' def __init__(self, name, xingbie):
self.name = name
self.__xingb = xingbie def aa(self):
print(self.__name) class B(A):
def ee(self):
print(self.__name) bb = A('',)
print(bb._A__name) #私有变量前边加_A就能调用 wk
类方法
@classmethod 用于改变类里的静态属性 ,(对象无法改变类的静态属性)
class A:
country = 'china' def fun(self):
pass def __init__(self, name):
self.name = name @classmethod #使用classmethod类方法,cls就是类A
def fun2(cls):
print(cls)
cls.xixi = 321 #cls.xixi = A.xixi
A.fun2() #调用fun2
print(A)
c = A('wk')
print(c.xixi) #对象c就能使用类里的方法
<class '__main__.A'>
<class '__main__.A'>
记录有多少个对象使用了A类
class A:
num = def fun(self):
pass def __init__(self,): #有对象生成就自动执行__init__方法:
A.fun2() #自动执行__init__方法会调用fun2方法. @classmethod
def fun2(cls):
cls.num += 1 #fun2方法使类的静态属性num自增1 c = A()
b = A()
d = A()
a = A()
print(c.num) #打印num静态属性就知道有几个A类的对象
静态方法
静态方法:就是一个不依赖类及对象的普通函数
为什么要用静态方法而不在类外边用普通函数?
为了保证代码的一致性
@staticmethod
class A:
num = def fun(self):
pass def __init__(self,):
A.fun2() @staticmethod #静态方法,和在类外边的普通函数一样
def fun2():
print() A.fun2()
类属性
@property
property是将方法伪装成一个属性,虽然在代码层面上没有提升,但是他会让你的代码看起来更合理一些
class A:
def __init__(self,name, weight, heigh):
self.name = name
self.weight = weight
self.heigh = heigh
@property #类属性可将函数名变为变量名
def bmi(self):
return self.weight / self.heigh **
wk = A('wk',,1.85)
print(wk.bmi) #打印时 bmi函数不加()直接返回的的就是对应return的值 18.991964937910883
class A:
def __init__(self, name):
self.name = name @property #将a当做变量使用
def a(self):
print() @a.setter #当给a改值时执行这里
def a(self, value):
print(value)
print() @a.deleter #当删除a值时执行这里
def a(self):
print()
c = A('wk')
c.a
c.a =
del c.a
苹果折扣练习 :苹果原始价是8元1斤打7折 球苹果折扣多少钱一斤和重新定价苹果后的折扣价
class A:
def __init__(self,name,jiage,zhekou):
self.name = name
self.jiage = jiage
self.zhekou = zhekou @property
def pg(self):
return '%s是%s元' %(self.name, self.jiage*self.zhekou)
@pg.setter
def pg(self, xinjia):
self.jiage = xinjia a = A('苹果', , 0.8) print(a.pg )
a.pg =
print(a.pg) 苹果是6.4元
苹果是5.6000000000000005元
反射
isinstance() 判断 一个对象是不是此类或此类的子孙类生成的对象
class A:
pass
class B(A): #A是B的父类
pass
c = B()
print(isinstance(c, B)) #c 是不是B生成的对象
print(isinstance(c, A)) #c 是不是A生成的对象 True
True
issubclass()一个类是否是令一个类的子类或子孙类
class A:
pass
class B(A):
pass
c = B()
print(issubclass(B, A)) #B是否是A的子类 True
反射方法
反射就是:通过 字符串 去操作对象(实例化对象 类, 模块)。 可以通过input交互输入的方式调用类以及对象
hasattr() 查看是否存在
getattr() 查看
setattr() 增加
delattr() 删除
对实例化对象的示例
class A:
def __init__(self,name,age):
self.name = name
self.age = age b = A('wk', ) #对象b
print(hasattr(b, 'name')) #判断对象b的变量name是否存在
print(getattr(b, 'name')) #查看 对象b的变量name的值
setattr(b,'xingbie', '男') #增加对象b的变量
print(b.xingbie)
delattr(b, 'name') #删除对象b的变量
print(b.__dict__) True
wk
男
{'age': , 'xingbie': '男'}
对类:
class A:
name = 'cc' def __init__(self, name, age):
self.name = name
self.age = age print(hasattr(A, 'name')) #判断A类的 变量name是否存在
print(getattr(A, 'name')) #取A类 变量name的值
setattr(A, 'xingbie', '男') #增加A类变量xingbie 并赋值男
print(A.xingbie)
delattr(A, 'name') #删除A类变量name
print(A.__dict__)
用input方式调用类的变量
class A:
name = 'wk' def __init__(self, name, age):
self.name = name
self.age = age cc = input('>>>>')
print(getattr(A, cc)) >>>>name
wk
对其他模块进行操作
模块aaa
#!/usr/bin/env python
n1 = 'wk' def func():
print() class A:
name = 'aaa' def func2(self):
print('xxxxxx')
import aaa
print(getattr(aaa, 'n1'))
aa = getattr(aaa, 'func')
aa()
bb = getattr(aaa, 'A')
print(bb.name)
cc = getattr(aaa.A, 'name')
print(cc)
getattr(aaa.A, 'func2')() wk aaa
aaa
xxxxxx
__str__
如果一个类中定义了__str__方法,那么在打印对象时,默认输出该方法的返回值(默认执行该方法).
class A :
def __init__(self):
pass
def __str__(self):
return ''
a = A()
print(a) 打印对象则打印__str__()的返回值, 654
__repr__
在repr对象时返回repr的返回值
class A:
name = 'wk' def __init__(self):
pass def __repr__(self):
return '' a = A()
print(repr(a)) 654
__call__
对象加()触发__call__方法
class A:
name = 'wk' def __init__(self):
pass def __call__(self, *args, **kwarge):
print(args) a = A()
a('wk', 'xx', 123) #对象加括号触发__call__方法,可以传参 ('wk', 'xx', 123)
__item__
对一个对象进行类似于字典的操作,就会触发__item__系列的某个方法.
item系列:包括__setitem__,__getitem__,__delitem__,
getitem
class A:
def __init__(self, name):
self.name = name def __getitem__(self, item):
print('执行了 此方法')
print(item) f = A('wk')
f['name'] #对象名这样写即触发getitem
class A:
def __init__(self, name):
self.name = name def __getitem__(self, item):
print('执行了 此方法')
print(item)
return self.__dict__[item] #可以将对象当字典调用 根据静态变量名找到对象对应的值 f = A('wk')
print(f['name']) 执行了 此方法
name
wk
setitem
class A:
def __init__(self, name):
self.name = name
def __setitem__(self, key, value):
self.key = value
self.value = key f = A('wk')
f['k'] = 123 #对象名这样写触发setitem
print(f.__dict__) {'name': 'wk', 'key': 123, 'value': 'k'}
deltiem
class A:
def __init__(self, name):
self.name = name
def __delitem__(self, key):
print('执行了删除key')
return self.__dict__.pop(key) f = A('wk')
del f['name'] #对象名这样写触发delitem
print(f.__dict__) 执行了删除key
{}
设计模式
单例模式:让一个类的实例化对象有且只有一个.
class A:
__instance = None def __new__(cls, *args, **kwargs):
if cls.__instance is None: #第一次进入
obj = object.__new__(cls) #借助object创建一个对象 obj
cls.__instance = obj #将第一次创建的对象赋值给了__instance
return cls.__instance #第二次进入 if cla.__instance 不为空,直接return 第一次的对象 rea = A()
rea1 = A()
rea2 = A()
print(rea, rea1, rea2) <__main__.A object at 0x0000027569695278> <__main__.A object at 0x0000027569695278> <__main__.A object at 0x0000027569695278>
模块
模块就是py文件
1.内置模块 time os random shelve re 等等
2.拓展模块.大神写的. beautifulsoup iteat
3.自定义米快
序列化模块 : json, pickle,shelve
序列化 将重要的数据转化成可以传输,并且得到后能够反解出来(就是一隔特殊的字符串,能用于网络传输).
json: 适用于所有语言.
python json
dict object
list,tuple array
str string
int,float number
True true
False false
None null
json里的dumps,loads和dump和load 解析和反解,dumps和loads用于网络传输,dump和load用于文件写入
import json dic = {'name': '马冬梅', 'age': 25, 'sex': '女'}
ret = json.dumps(dic) #将dic序列化为json
print(ret, type(ret))
ret1 = json.dumps(dic, ensure_ascii=False) #将dic序列化为人能看懂的json
print(ret1, type(ret))
rett = json.loads(ret) #将序列化的json反解出来
print(rett)
import json
f = open('json', 'w')
dic = {'k1': 1, 'k2': 2, 'k3': 3}
json.dump(dic,f,ensure_ascii=False) #将一个字典传入到一个写入的文件句柄
f.close()
json与普通字符串的区别
import json dic = {'name': '马冬梅', 'age': , 'sex': '女'}
ret = json.dumps(dic, ensure_ascii=False)
print(dic)
print(ret) {'name': '马冬梅', 'age': , 'sex': '女'} #普通字符串的是单引号
{"name": "马冬梅", "age": , "sex": "女"} #json字符串的是双引号
pickle 只用于Python语言之间的传输,包含所有Python支持的所有数据类型 和json用法基本一致
dumps和loads 传输用法
import pickle dic = {'name': '马冬梅', 'age': , 'sex': '女'}
ret = pickle.dumps(dic) #与json用法基本一致
set = pickle.loads(ret)
print(ret)
print(set) b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\t\x00\x00\x00\xe9\xa9\xac\xe5\x86\xac\xe6\xa2\x85q\x02X\x03\x00\x00\x00ageq\x03K\x19X\x03\x00\x00\x00sexq\x04X\x03\x00\x00\x00\xe5\xa5\xb3q\x05u.'
{'name': '马冬梅', 'age': , 'sex': '女'}
dump和load 文件写入用法 (这个不仅可以写常规的数据,还可以将对象写入,)
import pickle
class A:
name = 'wk'
def func(self):
print(666)
ww = A()
f = open("cc",'wb')
pickle.dump(ww,f) f = open('cc','rb')
ret = pickle.load(f)
print(ret.name)
ret.func()
f.close() wk
666
random随机模块
import random print(random.random()) # 随机大于0且小于1之间的小数
print(random.uniform(1, 3)) # 随机指定范围之间的小数
print(random.randint(1, 5)) # 随机指定范围之间的整数
print(random.randrange(1, 10, 2)) # 随机指定范围之间的奇数
print(random.choice([1, 23, [4, 5]])) # 随机选择一个返回,返回1或23或[4,5]
print(random.sample([1, 23, [4, 5], 'wk'], 2)) # 随机选择两个组成一个列表返回 item = [1, 3, 5, 7, 9]
random.shuffle(item) #打乱顺序
print(item)
0.24827130573087497
1.3810108843857392
4
5
[4, 5]
[1, 23]
[3, 7, 1, 5, 9]
利用random模块写一个生成随机数的函数
import random def suij():
code = ''
for i in range(5):
num = str(random.randint(0, 9)) # 0-9的数字
zim = chr(random.randint(97, 122)) # A-Z的大写字母
ZIM = chr(random.randint(65, 90)) # a-z的小写字母
add = random.choice([num, zim, ZIM]) # 随机选取其中一个
code += add # 每次加1循环5次
return code print(suij()) 82TqP
shelve 持久化存储
import shelve
s = shelve.open('ccc') #打开一个持久化存储文件
s['name'] = 'wk' #将数据以键值的形式存入到文件里
print(s['name'])
s.close() #在其它脚本里使用
import shelve
s = shelve.open('jay')
print(s['name'])
最新文章
- dedecms 后台栏目添加图片
- 我理解的Sitecore开发流程
- Oracle 存储过程 split 代码实现
- 谈谈javascript放在哪里更合适
- C#继承基本控件实现自定义控件
- Codeforces Round #115 A. Robot Bicorn Attack 暴力
- HTTP DNS小结
- Leetcode 解题 Longest Substring without repeating charcater python
- Android学习笔记--服务(Service)
- vb.NET基础总结
- 17.1.2.1 Advantages and Disadvantages of Statement-Based and Row-Based Replication
- OpenCV HaarTraining代码解析(二)cvCreateMTStumpClassifier(建立决策树)
- 分享一个C#自定义事件的实际应用
- pandas 对数据帧DataFrame中数据的索引及切片操作
- WIN7远程桌面连接--“发生身份验证错误。要求的函数不受支持”
- 如何打开.lxe文件
- JDBC学习笔记之SQLException介绍
- win7 java环境变量配置
- Elasticsearch5.5.2安装和启动遇到哪些问题
- Windows下Python安装: requires numpy+mkl 和ImportError: cannot import name NUMPY_MKL