xml地图|网站地图|网站标签 [设为首页] [加入收藏]
变量类型,探索逻辑事务
分类:编程

一、什么是TransactionScope?

  TransactionScope即范围事务(类似数据库中的事务),保证事务声明范围内的一切数据修改操作状态一致性,要么全部成功,要么全部失败回滚.

  MSDN:如果在事务范围内未不发生任何异常 (即之间的初始化 TransactionScope 对象并调用其 Dispose 方法),则范围所参与的事务可以继续,否则参与到其中的事务将回滚。
      当应用程序完成所有工作时它想要在事务中执行,应调用 Complete 方法一次,以通知该事务管理器是可接受(此时事务并未提交),即可提交事务,未能调用此方法中止事务。
      调用 Dispose 方法将标记事务范围的末尾。 在调用此方法之后所发生的异常不会影响事务。

引言

 

二、TransactionScope有什么用?

  假如现在有一个需求:实现一个下单功能,主要业务包含扣减商品库存、扣减用户账户余额、生成订单记录以及记录日志。为了保证数据一致性我们通常的做法就是在数据库建一个下订单的事务,然后程序调用事务传入相应的参数即可。那么问题来了,如果用户的账户数据跟订单数据分别处于不同的数据库,就没法在同一个数据库事务里完成所有任务,也就没法保证数据的一致性。
  最近由于业务的变更公司改用MySQL数据库,处理数据变更时习惯性先写事务,写的时候发现现有数据库中一个事务都没有,于是去问java组,不使用事务怎么保证数据的一致性?得到的答复是:事务是什么鬼,spring帮我们解决所有问题...。立马就懵逼了,.net中没听说有Spring啊(据说有类似的框架),虽然可以考虑使用仓储加工作单元来解决,但是感觉好麻烦的样子,后来寻找解决方案时发现了TransactionScope。

本周初步认识了库,并学习了Python中各种类型的变量和常用操作。并完成了较为完善的用户与商家购物界面设计。

一 isinstance(obj,cls)和issubclass(sub,super)

  isinstance(obj,cls)检查是否obj是否是类 cls 的对象

1 class Foo(object):
2     pass
3  
4 obj = Foo()
5  
6 isinstance(obj, Foo)

  issubclass(sub, super)检查sub类是否是 super 类的派生类

class Foo(object):
    pass

class Bar(Foo):
    pass

issubclass(Bar, Foo)

 

二、反射

2 python面向对象中的反射:通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射)

四个可以实现自省的函数

def getattr(object , name, defalut=None) :

判断object中有没有一个name字符串对应的方法或属性

 

def getattr(object, name, default=None): # known special case of getattr
    """
    getattr(object, name[, default]) -> value

    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
    When a default argument is given, it is returned when the attribute doesn't
    exist; without it, an exception is raised in that case.
    """
    pass

def setattr(x,y, v):

def setattr(x, y, v): # real signature unknown; restored from __doc__
    """
    Sets the named attribute on the given object to the specified value.

    setattr(x, 'y', v) is equivalent to ``x.y = v''
    """
    pass

def delattr(x,y):

 

def delattr(x, y): # real signature unknown; restored from __doc__
    """
    Deletes the named attribute from the given object.

    delattr(x, 'y') is equivalent to ``del x.y''
    """
    pass

 

实践案例

class BlackMedium:
    feature='Ugly'
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr

    def sell_house(self):
        print('%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼' %self.name)
    def rent_house(self):
        print('%s 黑中介租房子啦,傻逼才租呢' %self.name)

b1=BlackMedium('万成置地','回龙观天露园')

#检测是否含有某属性
print(hasattr(b1,'name'))
print(hasattr(b1,'sell_house'))

#获取属性
n=getattr(b1,'name')
print(n)
func=getattr(b1,'rent_house')
func()

# getattr(b1,'aaaaaaaa') #报错
print(getattr(b1,'aaaaaaaa','不存在啊'))  

#设置属性
setattr(b1,'sb',True)
setattr(b1,'show_name',lambda self:self.name+'sb')#给Blackhouser添加SB属性
print(b1.__dict__)
print(b1.show_name(b1))

#删除属性
delattr(b1,'addr')
delattr(b1,'show_name') 
delattr(b1,'show_name111')#不存在,则报错

print(b1.__dict__)

类也是对象
class Foo(object):

    staticField = "old boy"

    def __init__(self):
        self.name = 'wupeiqi'

    def func(self):
        return 'func'

    @staticmethod
    def bar():
        return 'bar'

print getattr(Foo, 'staticField')
print getattr(Foo, 'func')
print getattr(Foo, 'bar')



#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sys


def s1():
    print 's1'


def s2():
    print 's2'


this_module = sys.modules[__name__]

hasattr(this_module, 's1')
getattr(this_module, 's2')

#!/usr/bin/env python
# -*- coding:utf-8 -*-

def test():
    print('from the test')

图片 1图片 2

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3  
 4 """
 5 程序目录:
 6     module_test.py
 7     index.py
 8  
 9 当前文件:
10     index.py
11 """
12 
13 import module_test as obj
14 
15 #obj.test()
16 
17 print(hasattr(obj,'test'))
18 
19 getattr(obj,'test')()

View Code

 

3 为什么用反射之反射的好处

 

好处一:实现可插拔机制

总之反射的好处是,可以事先定义好接口,接口只有在被完成后才会真正执行,这实现了即插即用,这其实是一种‘后期绑定’,什么意思?即你可以事先把主要的逻辑写好(只定义接口),然后后期再去实现接口的功能

 

class FtpClient:
    'ftp客户端,但是还么有实现具体的功能'
    def __init__(self,addr):
        print('正在连接服务器[%s]' %addr)
        self.addr=addr

#from module import FtpClient
f1=FtpClient('192.168.1.1')
if hasattr(f1,'get'):
    func_get=getattr(f1,'get')
    func_get()
else:
    print('---->不存在此方法')
    print('处理其他的逻辑')

动态导入模块

图片 3

 

 

三、TransactionScope怎么使用?

 1 try
 2 {
 3     using (TransactionScope scope = new TransactionScope())
 4     {
 5         //TODO:数据处理业务       
 6         scope.Complete();
 7     }
 8 }
 9 catch (Exception ex)
10 {
11     throw ex;
12 }

正文

三 __setattr__,__delattr__,__getattr__

class Foo:
    x=1
    def __init__(self,y):
        self.y=y

    def __getattr__(self, item):
        print('----> from getattr:你找的属性不存在')


    def __setattr__(self, key, value):
        print('----> from setattr')
        # self.key=value #这就无限递归了,你好好想想
        # self.__dict__[key]=value #应该使用它

    def __delattr__(self, item):
        print('----> from delattr')
        # del self.item #无限递归了
        self.__dict__.pop(item)

#__setattr__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)

#__delattr__删除属性的时候会触发
f1.__dict__['a']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)

#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx

 

四、问题探讨

模块:

四 二次加工标准类型(包装)

 

包装:python为大家提供了标准数据类型,以及丰富的内置方法,其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型,新增/改写方法,这就用到了我们刚学的继承/派生知识(其他的标准类型均可以通过下面的方式进行二次加工)

 

 

 

授权:授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。

 

实现授权的关键点就是覆盖__getattr__方法

 

 

import time
class FileHandle:
    def __init__(self,filename,mode='r',encoding='utf-8'):
        self.file=open(filename,mode,encoding=encoding)
    def write(self,line):
        t=time.strftime('%Y-%m-%d %T')
        self.file.write('%s %s' %(t,line))

    def __getattr__(self, item):
        return getattr(self.file,item)

f1=FileHandle('b.txt','w+')
f1.write('你好啊')
f1.seek(0)
print(f1.read())
f1.close()

 

 

描述符注意事项:

一 描述符本身应该定义成新式类,被代理的类也应该是新式类
二 必须把描述符定义成这个类的类属性,不能为定义到构造函数中
三 要严格遵循该优先级,优先级由高到底分别是
1.类属性
2.数据描述符
3.实例属性
4.非数据描述符
5.找不到的属性触发__getattr__()

其中

数据描述符、数据描述符:至少实现了__get__()和__set__()

非数据描述符、没有实现__set__()

 

1、准备工作

 1 //数据库访问对象
 2 public class Studuent
 3 {
 4     public static IList<StudentModel> GetList()
 5     {
 6         //不允许脏读
 7         string sql = "SELECT Id,Name,CreateTime FROM Student ORDER BY Id DESC;";
 8         DataTable dt = SQLHelper.ExecuteDataTable(CommandType.Text, sql);
 9         return dt.ToModel<StudentModel>();
10     }
11 
12     public static bool Add(string name)
13     {
14         SqlParameter[] parms = { new SqlParameter("@Name", SqlDbType.NVarChar, 32) { Value = name } };
15         string sql = "INSERT INTO Student (Name) VALUES (@Name)";
16         return SQLHelper.ExecuteNonQuery(CommandType.Text, sql, parms) > 0;
17     }
18 
19     public static void Clear()
20     {
21         SQLHelper.ExecuteNonQuery("DELETE Student");
22     }
23 }

 1 //公共方法,输出学生列表
 2 static void PrintStudent()
 3 {
 4     IList<StudentModel> list = Studuent.GetList();
 5     foreach (var item in list)
 6     {
 7         Console.WriteLine("{0}t{1}t{2}", Thread.CurrentThread.ManagedThreadId, item.Name, item.CreateTime);
 8     }
 9     Console.WriteLine();
10 }

  Python有标准库和第三方库。第三方库需要安装才能使用。大量的库可以帮助我们更容易的完成复杂的操作。一般情况下,标准库被保存在了‘lib/’目录下,第三方库被保存在了‘lib/site-packages’目录下。导入一个库非常简单,例子:

2、事务什么时候提交? 图片 4

最初我以为在执行Complete后即刻提交,但根据输出结果可以看出,Complete方法执行两秒之后事务依旧没有提交。因为不允许脏读的原因,主线程会在事务对Student表操作完成后才可查询完成,但学生列表是在scope调用dispose方法之后输出,MSDN介绍说dispose确定事务范围末尾,因此猜测事务是在调用dispose时被提交。

import os

3、异常是怎么导致数据不被提交?

图片 5

图片 6

对比两幅图可以看出,异常在Complete之后发生并不会影响事务的提交,事务未提交是因为发生异常导致Complete未被执行。之前看过一篇文章说,如果TransactionScope范围中没有调用Complete会导致程序异常,我想他肯定是开玩笑的...

  每种模块都有很多操作,一般情况是用模块名.操作名完成某些操作,例子:

4、嵌套事务

os.system('dir')#读取目录下的文件列表,但不保存

图片 7

图片 8

 

变量类型:

  整型(int),Python 3.X中整型只有int型,而在Python 2.X中整型分为int,和long,变量的类型不需定义,与Matlab中类似,但类型不可随意更改。查看变量类型,例子:

x = 3
type(x)

  其他类型与C++中类似,所以不再赘述。

  虚数型,在Python中j表示虚数。

  比特型(bytes),Python 2.X中比特型与字符型没有区别,而在Python 3.X中存在不同,它们可以互相转换,例子:

x = '我爱中国'
y = x.encode()#转换为比特型
print(y)
z = y.decode())#转换为字符型
print(z)

  在日常使用Python中,字典与列表是最常使用的变量。下面将详细介绍字典与列表的使用方法。

列表:

  列表的定义,例子:

province = ['Beijin','Hebei','Shanghai','Henan']

  列表的切片与Matlab有相似之处,但有着巨大不同,Python的:后的数字是切片位置的后一位。所以,在Python中[1:2]=[1],例子:

province = ['Beijin','Hebei','Shanghai','Henan']
print(province[0:2])#切片(顾头不顾尾)

  Python还可以从右数来完成切片,例子:

province = ['Beijin','Hebei','Shanghai','Henan']
print(province[-1])#从右数
print(province[-2:])#最后的值省略

   列表的增加有两种方式,一种是最后追加,还有一种是某处插入。例子:

province = ['Beijin','Hebei','Shanghai','Henan']
province.append('Shannxi')#最后追加
province.insert(1,'Xinjiang')#某处插入

  列表的修改十分简单,例子:

province = ['Beijin','Hebei','Shanghai','Henan']
province[1] = 'Beijing'#改变某处

  列表的删除有很多方法,del是Python中通用的删除方法,此外还有删除某个与删除某处参数的方法,例子:

province = ['Beijin','Hebei','Shanghai','Henan']
del province[2]#删除某处
province.remove('Beijing')#删除某个
province.pop()#删除最后一个(默认),或括号中的位置

  此外,Python还为列表提供了许多功能。Python中可以轻松查询某个参数的位置和个数,例子:

本文由澳门新葡亰手机版发布于编程,转载请注明出处:变量类型,探索逻辑事务

上一篇:自兴人工智能,中文词云代码调试 下一篇:urlretrieve函数解析,3永久激活
猜你喜欢
热门排行
精彩图文