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

  1.  class Person(object):
  2.      def __init__(self, name, age, sex, nationality):
  3.          self.name = name
  4.          self.age = age
  5.          self.sex = sex
  6.          self.nationality = nationality
  7.  
  8.      def say(self):
  9.          print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
  10.  
  11.      def __getattr__(self, item):
  12.          print("当实例获取属性不存在的时候会执行__getattr__方法")
  13.  
  14.      def __getattribute__(self, item):
  15.          print("实例获取属性，不管实例dict属性字典里又没有都会执行__getattribute__方法")
  16.  
  17.  class Chinese(Person):
  18.          pass
  19.  
  20.  if __name__ == "__main__":
  21.      p1 = Person("里斯", 78, '男', "美国")
  22.      # p1 实例是否是Person类的一个实例
  23.      print(isinstance(p1, Person))
  24.      # issubclass(sub, super)检查sub类是否是 super 类的派生类
  25.      print(issubclass(Chinese, Person))

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

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

反射

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

  1. 　　hasattr(obj,"属性"):# obj.属性是否存在
    　　getattr(obj,"属性"):# 获取 obj.属性 如果不存在就报错
    　　getattr(obj,"属性","默认值"):# 获取 obj.属性 如果不存在不会报错，并且返回默认的
    　　setattr(obj,"属性"):# 设置属性
    　　delattr(obj,"属性"):# 删除属性
  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  
  6.  class Person(object):
  7.      name = "hah"
  8.  
  9.      def __init__(self, name, age, sex, nationality):
  10.          self.name = name
  11.          self.age = age
  12.          self._sex = sex
  13.          self.__nationality = nationality
  14.  
  15.      def say(self):
  16.          print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s" % (self.name, self.age, self._sex, self.__nationality))
  17.  
  18.  class Chinese(Person):
  19.      pass
  20.  
  21.  if __name__ == "__main__":
  22.      print("\r\n ==============对象的反射============ \r\n")
  23.      p1 = Person("张三", 18, '男', "中国")
  24.      p1.say()
  25.      # 获取 p1 对象里name的值
  26.      print(getattr(p1, "name"))
  27.  
  28.      # 判断p1对象里又没有addr属性
  29.      print(hasattr(p1, "addr"))
  30.  
  31.      # 设置p1 对象addrs属性并且赋值
  32.      setattr(p1, "addrs", "四川达州")
  33.      print(getattr(p1, "addrs"))
  34.  
  35.      # 删除p1对象addrs属性
  36.      delattr(p1, "addrs")
  37.      print(hasattr(p1, "addrs"))
  38.  
  39.      print("\r\n ==============类的反射（类本质上也是对象）============ \r\n")
  40.      print(hasattr(Person, "addrs"))
  41.      print(getattr(Person, "name", "没有这个属性"))
  42.      setattr(Person, "addrs", "类地址")
  43.      print(getattr(Person, "addrs"))
  44.      delattr(Person, "name")
  45.      print(hasattr(Person, "name"))

  1. importlib---动态导入模块
  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  
  6.  from Python基础.myImport import chufa
  7.  import importlib
  8.  
  9.  if __name__ == "__main__":
  10.      # 第一种导入调用
  11.      # print(chufa(1000,50))
  12.  
  13.      # 第二种：动态导入模块
  14.      # m1 = __import__("myImport")
  15.      # print(m1)
  16.      # # 调用模块里的方法
  17.      # print(m1.chufa(10,2))
  18.  
  19.      # # 第三中：动态导入模块
  20.      # m2 = importlib.import_module("myImport")
  21.      # print(m2)
  22.      # print(m2.chufa(4,2))
  23.      m3 = importlib.import_module("modular.sendMsg")
  24.      print(m3)
  25.      print(m3.SendMsage())

__setattr__,__delattr__,__getattr__

  1. __getattr__:不存在的时候出发
  2. __setattr__:设置属性的值的时候出发
  3. __delattr__:删除属性的时候出发
  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  
  6.  """
  7.  __getattr__:不存在的时候出发
  8.  __setattr__:设置属性的值的时候出发
  9.  __delattr__:删除属性的时候出发
  10.  
  11.  """
  12.  
  13.  class Person(object):
  14.      def __init__(self, name, age, sex, nationality):
  15.          self.name = name
  16.          self.age = age
  17.          self.sex = sex
  18.          self.nationality = nationality
  19.  
  20.      def say(self):
  21.          print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
  22.  
  23.      def __getattr__(self, item):
  24.          print("执行了__getattr__")
  25.  
  26.      def __setattr__(self, key, value):
  27.          print("执行了__setattr__")
  28.          # 实际上就是操作属性字典
  29.          self.__dict__[key] = value
  30.  
  31.      def __delattr__(self, item):
  32.          print("执行了__delattr__")
  33.          self.__dict__.pop(item)
  34.  
  35.  class Chinese(Person):
  36.      pass
  37.  
  38.  class American(Person):
  39.      pass
  40.  
  41.  class Korean(Person):
  42.      pass
  43.  
  44.  class Japanese(Person):
  45.      pass
  46.  
  47.  if __name__ == "__main__":
  48.      pass
  49.      # # 因为在类中重写了设置属性的方法，然而代码里并没有正在设置上，所以调用say会报错
  50.      # p1 = Person("张三",18,'男',"中国")
  51.      # p1.say()
  52.  
  53.      # 修改后在执行
  54.      p1 = Person("张三", 18, '男', "中国")
  55.      p1.say()
  56.      del p1.name
  57.      print(hasattr(p1, "name"))　

__getattr__例子：

  1.   # -*- coding: utf-8 -*-
  2.  
  3.   # 声明字符编码
  4.   # coding:utf-8
  5.  
  6.   import time
  7.  
  8.   class FileHelper(object):
  9.       def __init__(self, filepath, model="r", encoding='utf-8'):
  10.           self.file = open(filepath, mode=model, encoding=encoding)
  11.  
  12.       def __getattr__(self, item):
  13.           # item 是字符串类型
  14.           # 通过getattr()获取 self.file 中的方法
  15.           return getattr(self.file, item)
  16.  
  17.       def write(self, line):
  18.           # 在每次写入的内容前面加上时间
  19.           t = time.strftime("%Y-%m-%d %X")
  20.           self.file.write('%s %s' % (t, line + "\r\n"))
  21.  
  22.   if __name__ == "__main__":
  23.       f1 = FileHelper("../files/Log/logger.log", 'w', encoding='utf-8')
  24.       f1.write("锄禾日当午")
  25.       f1.write("汗滴禾下土")
  26.       f1.write("谁知盘中餐")
  27.       f1.write("粒粒皆辛苦")
  28.  
  29.       f1 = FileHelper("../files/Log/logger.log", 'r', encoding='utf-8')
  30.       # f1.read() 首先在f1实例中的__dict__数据字典中去找read方法，如果没有就去FileHelper类中的__dict__数据字典中找，如果还是没有
  31.       # 就报错，如果在FileHelper中重写的__getattr__方法，就执行该方法。所以在该方法中通过self.file属性中去找，self.file就是系统的open对象。
  32.       content = f1.read()
  33.       print(content)

__setitem__,__getitem,__delitem__　

  1.  class Chinese(Person):
  2.  
  3.      def __getitem__(self, item):
  4.          print("执行了__getitem__")
  5.  
  6.      def __setitem__(self, key, value):
  7.          print("执行了__setitem__")
  8.  
  9.      def __delitem__(self, key):
  10.          print("执行了__delitem__")
  11.      c1 = Chinese("李四",14,"女","中国")
  12.      c1["addrs"] = "四川成都"
  13.      c1['addrs']
  14.      del c1["addrs"]

__getattribute__

  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  
  6.  class Person(object):
  7.      def __init__(self, name, age, sex, nationality):
  8.          self.name = name
  9.          self.age = age
  10.          self.sex = sex
  11.          self.nationality = nationality
  12.  
  13.      def say(self):
  14.          print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
  15.  
  16.      def __getattr__(self, item):
  17.          print("当实例获取属性不存在的时候会执行__getattr__方法")
  18.  
  19.      def __getattribute__(self, item):
  20.          print("实例获取属性，不管实例dict属性字典里又没有都会执行__getattribute__方法")
  21.  
  22.  if __name__ == "__main__":
  23.      p1 = Person("里斯", 78, '男', "美国")
  24.      # p1 实例是否是Person类的一个实例
  25.      print(isinstance(p1, Person))
  26.      # issubclass(sub, super)检查sub类是否是 super 类的派生类
  27.      print(issubclass(Chinese, Person))
  28.  
  29.      # getattribute方法
  30.      # addrs不存在与p1的dict属性字典里，所以会执行getattr方法
  31.      p1.addrs
  32.      p1.name
  33.      """
  34.      当实例中同时具有__getattr__和__getattribute__方法时候，都只会执行__getattribute__方法，如果__getattribute__方法里有
  35.      抛出AttributeError异常，就会出发 __getattr__方法。
  36.  
  37.      """

总结

  1. 　　obj点的方式操作属性时候出发
    　　__getattr__:不存在的时候出发
    　　__setattr__:设置属性的值的时候出发
    　　__delattr__:删除属性的时候出发
  2.  
  3. 　　obj['属性']的的方式操作属性的时候出发
    　　__getitem__:不存在的时候出发
    　　__setitem__:设置属性的值的时候出发
    　　__delitem__:删除属性的时候出发
    　　
    　　def __get__():
       　　 pass
    　　def __set__():
        　　pass
    　　def __del__():
       　　 pass
  4.  
  5. 　　描述的就是一个新式类，这个类至少实现上述三个方法中的一个
  1. 改变对象的字符串显示__str__,__repr__
  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  
  6.  # 改变对象的字符串显示__str__,__repr__
  7.  
  8.  class Person(object):
  9.      def __init__(self, name, age, sex, nationality):
  10.          self.name = name
  11.          self.age = age
  12.          self.sex = sex
  13.          self.nationality = nationality
  14.  
  15.      def say(self):
  16.          print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
  17.  
  18.      def __str__(self):
  19.          return '重写str方法，默认就返回我啦！！！'
  20.  
  21.      def __repr__(self):
  22.          return '通过解释器执行后返回的'
  23.  
  24.  if __name__ == "__main__":
  25.      # 实例中没有__str__函数，打印实例 地址，加了之后，打印重写后返回的内容。
  26.      p1 = Person("小村伊朗", 78, '妖', '小岛')
  27.      print(p1)

__next__和__iter__实现迭代器协议

高效的求斐波拉契数列方法

  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  
  6.  class FeiBoLa(object):
  7.      def __init__(self):
  8.          self.__a = 1
  9.          self.__b = 1
  10.  
  11.      def __iter__(self):
  12.          return self
  13.  
  14.      def __next__(self):
  15.          self.__a, self.__b = self.__b, self.__a + self.__b
  16.          return self.__a
  17.  
  18.  if __name__ == "__main__":
  19.      f = FeiBoLa()
  20.      print(f.__next__())
  21.      print(f.__next__())
  22.      print(f.__next__())
  23.      print(f.__next__())
  24.      print(f.__next__())

__enter__和__exit__组成with语法

  1. with MyOpen('a.txt') as f:
  2.          print(f)
  3.          print('执行代码块')
  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  """
  6.  
  7.  案例：
  8.  with MyOpen('a.txt','r',encoding='utf-8') as f:
  9.      pass
  10.  
  11.  __enter__(): MyOpen('a.txt','r',encoding='utf-8') 会触发 MyOpen类中的__enter__方法
  12.  __exit__():执行完代码块中的代码后出发 __exit__方法。
  13.  
  14.  """
  15.  
  16.  class MyOpen(object):
  17.      def __init__(self, path, model='r', encoding='utf-8'):
  18.          self.path = path
  19.          self.model = model
  20.          self.encoding = encoding
  21.  
  22.      def __enter__(self):
  23.          print('执行了enter方法.....')
  24.  
  25.      def __exit__(self, exc_type, exc_val, exc_tb):
  26.          # 如果发生异常 对应三个值的说明
  27.          # exc_type：异常类, exc_val：异常值, exc_tb：异常追踪信息
  28.          print('执行了exit方法......')
  29.          print(exc_type)
  30.          print(exc_val)
  31.          print(exc_tb)
  32.          return False
  33.  
  34.  if __name__ == "__main__":
  35.      with MyOpen('a.txt') as f:
  36.          print(f)
  37.          print('执行代码块')

案例：

  1. 　　描述符类装饰器给类动态添加属性
  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  
  6.  # 类属性描述
  7.  class AttrDesc:
  8.  
  9.      def __init__(self, attr_name, attr_type):
  10.          self.attr_name = attr_name
  11.          self.attr_type = attr_type
  12.  
  13.      def __get__(self, instance, owner):
  14.          return instance.__dict__[self.attr_name]
  15.  
  16.      def __set__(self, instance, value):
  17.          if not isinstance(value, self.attr_type):
  18.              raise TypeError("%s值的类型不是:%s" % (self.attr_name, self.attr_type))
  19.          instance.__dict__[self.attr_name] = value
  20.  
  21.      def __delete__(self, instance):
  22.          return instance.__dict__.pop(self.attr_name)
  23.  
  24.  # 限制类属性类型装饰器
  25.  def add_attr(**kwargs):
  26.      def add(obj):
  27.          for key, val in kwargs.items():
  28.              setattr(obj, key, AttrDesc(key, val))
  29.  
  30.          return obj
  31.  
  32.      return add
  33.  
  34.  @add_attr(height=float, weigt=float, name=str)
  35.  class Person(object):
  36.      def __init__(self, name, age, sex, nationality):
  37.          self.name = name
  38.          self.age = age
  39.          self.sex = sex
  40.          self.nationality = nationality
  41.  
  42.      def say(self):
  43.          print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
  44.  
  45.  if __name__ == "__main__":
  46.      p1 = Person('小明', 12, '男', '中国')
  47.      p1.height = 2.19
  48.      print(Person.__dict__)

案例：自定义property

　　    可以让一个方法 看起来像一个属性，使用的时候对象点出来即可

  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  
  6.  class LazyPropery:
  7.      def __init__(self, func):
  8.          self.func = func
  9.  
  10.      def __get__(self, instance, owner):
  11.          print(instance)
  12.          print(owner)
  13.          if instance is None:
  14.              return self
  15.          return self.func(instance)
  16.  
  17.  class Person(object):
  18.      def __init__(self, name, age, sex, nationality):
  19.          self.name = name
  20.          self.age = age
  21.          self.sex = sex
  22.          self.nationality = nationality
  23.  
  24.      # 标记上@property 变为静态属性，这样就可以通过实例名点方法名调用。
  25.      @property
  26.      def say(self):
  27.          print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
  28.  
  29.  class Chinese(Person):
  30.  
  31.      @LazyPropery
  32.      def run(self):
  33.          print('run')
  34.          return '我是%s' % self.name
  35.  
  36.  if __name__ == "__main__":
  37.      print("\r\n======系统内置property=====\r\n")
  38.      p1 = Person('王二小', 12, '女', '中国')
  39.      p1.say
  40.      print("\r\n======自定义的property=====\r\n")
  41.      c1 = Chinese('王二', 15, '女', '中国')
  42.      print(c1.run)

　工厂模式案例：

  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  '''
  6.  在父类中定义，在子类中实现 ========工厂模式
  7.  '''
  8.  
  9.  # 店铺类
  10.  class Store(object):
  11.      def select_car(self):
  12.          pass
  13.  
  14.      def Order(self, car_type):
  15.          return self.select_car(car_type)
  16.  
  17.  # 宝马4S店
  18.  class BMStore(Store):
  19.      def select_car(self, car_type):
  20.          return BMFactory().select_car_by_type(car_type)
  21.  
  22.  # 桑塔纳4S店
  23.  class STNStore(Store):
  24.      def select_car(self, car_type):
  25.          return STNFactory().select_car_by_type(car_type)
  26.  
  27.  # 雪佛兰4S店
  28.  class XFLStore(Store):
  29.      def select_car(self, car_type):
  30.          return XFLFactory().select_car_by_type(car_type)
  31.  
  32.  # 宝马工厂
  33.  class BMFactory(object):
  34.      def select_car_by_type(self, car_type):
  35.          if car_type == "宝马X": return BaoMaX()
  36.          if car_type == "宝马XX": return BaoMaXX()
  37.          if car_type == "宝马XXX": return BaoMaXXX()
  38.  
  39.  # 桑塔纳工厂
  40.  class STNFactory(object):
  41.      def select_car_by_type(self, car_type):
  42.          if car_type == "桑塔纳Q": return SangTaNaQ()
  43.          if car_type == "桑塔纳QQ": return SangTaNaQQ()
  44.  
  45.  # 雪佛兰工厂
  46.  class XFLFactory(object):
  47.      def select_car_by_type(self, car_type):
  48.          if car_type == "雪佛兰T": return XueFuLanT()
  49.          if car_type == "雪佛兰TT": return XueFuLanTT()
  50.  
  51.  # 整个车类
  52.  class Car(object):
  53.      def move(self):
  54.          print("车在移动......")
  55.  
  56.      def music(self):
  57.          print("车里再放音乐....")
  58.  
  59.      def stop(self):
  60.          print("车停下了.......")
  61.  
  62.  # 宝马车类
  63.  class BaoMa(Car):
  64.      pass
  65.  
  66.  class BaoMaX(BaoMa):
  67.      pass
  68.  
  69.  class BaoMaXX(BaoMa):
  70.      pass
  71.  
  72.  class BaoMaXXX(BaoMa):
  73.      pass
  74.  
  75.  # 桑塔纳车类
  76.  class SangTaNa(Car):
  77.      pass
  78.  
  79.  class SangTaNaQ(SangTaNa):
  80.      pass
  81.  
  82.  class SangTaNaQQ(SangTaNa):
  83.      pass
  84.  
  85.  # 雪佛兰车类
  86.  class XueFuLan(Car):
  87.      pass
  88.  
  89.  class XueFuLanT(XueFuLan):
  90.      pass
  91.  
  92.  class XueFuLanTT(XueFuLan):
  93.      pass
  94.  
  95.  stor = BMStore()
  96.  s = stor.Order("宝马XX")
  97.  s.move()
  98.  s.music()
  99.  s.stop()
  1. 简单工厂模式案例：
  1.  # -*- coding: utf-8 -*-
  2.  
  3.  # 声明字符编码
  4.  # coding:utf-8
  5.  
  6.  #<region 简单工厂模式>
  7.  
  8.  # 店铺类
  9.  class CarStore(object):
  10.      def __init__(self):
  11.          self.factory = Factory()
  12.      def Order(self,car_type):
  13.          return self.factory.select_car_by_type(car_type)
  14.  
  15.  # # 店铺类
  16.  # class CarStore(object):
  17.  #     def Order(self,car_type):
  18.  #         return select_car_by_type(car_type)
  19.  
  20.  class Factory(object):
  21.      def select_car_by_type(self,car_type):
  22.          if car_type =="宝马":return BaoMa()
  23.          if car_type == "桑塔纳":return SangTaNa()
  24.          if car_type == "雪佛兰":return XueFuLan()
  25.  
  26.  # # 函数（达到了解耦性）
  27.  # def select_car_by_type(car_type):
  28.  #     if car_type =="宝马":return BaoMa()
  29.  #     if car_type == "桑塔纳":return SangTaNa()
  30.  #     if car_type == "雪佛兰":return XueFuLan()
  31.  
  32.  # 整个车类
  33.  class Car(object):
  34.      def move(self):
  35.          print("车在移动......")
  36.      def music(self):
  37.          print("车里再放音乐....")
  38.      def stop(self):
  39.          print("车停下了.......")
  40.  
  41.  # 宝马车类
  42.  class BaoMa(Car):
  43.      pass
  44.  # 桑塔纳车类
  45.  class SangTaNa(Car):
  46.      pass
  47.  # 雪佛兰车类
  48.  class XueFuLan(Car):
  49.      pass
  50.  
  51.  stor = CarStore()
  52.  s = stor.Order("宝马")
  53.  s.move()
  54.  s.music()
  55.  s.stop()
  56.  
  57.  #<endregion>

Python学习笔记【第十一篇】：Python面向对象高级的更多相关文章

  1. Python 学习笔记（十一）Python语句（三）

    While 循环语句 用于循环执行程序,即在某条件下,循环执行某段程序,以处理需要重复处理的相同任务. 语法: while 判断条件: 执行语句…… 执行语句可以是单个语句或语句块.判断条件可以是任何 ...

  2. Python 学习笔记（十一）Python语句（二）

    For 循环语句 基础知识 for循环可以遍历任何序列的项目,如一个列表或者一个字符串. 语法: for 循环规则: do sth >>> for i in "python ...

  3. Python 学习笔记（十一）Python语句（一）

    运算符和条件语句 算术运算符 运算符 描述 实例 + 加 - 两个对象相加 a + b 输出结果 30 - 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -10 * 乘 - 两个数相乘 ...

  4. Python学习笔记（十一）

    Python学习笔记(十一): 生成器,迭代器回顾 模块 作业-计算器 1. 生成器,迭代器回顾 1. 列表生成式:[x for x in range(10)] 2. 生成器 (generator o ...

  5. Python学习笔记之基础篇（-）python介绍与安装

    Python学习笔记之基础篇(-)初识python Python的理念:崇尚优美.清晰.简单,是一个优秀并广泛使用的语言. python的历史: 1989年,为了打发圣诞节假期,作者Guido开始写P ...

  6. openresty 学习笔记番外篇:python的一些扩展库

    openresty 学习笔记番外篇:python的一些扩展库 要写一个可以使用的python程序还需要比如日志输出,读取配置文件,作为守护进程运行等 读取配置文件 使用自带的ConfigParser模 ...

  7. openresty 学习笔记番外篇:python访问RabbitMQ消息队列

    openresty 学习笔记番外篇:python访问RabbitMQ消息队列 python使用pika扩展库操作RabbitMQ的流程梳理. 客户端连接到消息队列服务器,打开一个channel. 客户 ...

  8. Python 学习笔记（基础篇）

    背景:今年开始搞 Data science ,学了 python 小半年,但一直没时间整理整理.这篇文章很基础,就是根据廖雪峰的 python 教程 整理了一下基础知识,再加上自己的一些拓展,方便自己 ...

  9. Python学习笔记——基础语法篇

    一.Python初识(IDE环境及基本语法,Spyder快捷方式) Python是一种解释型.面向对象.动态数据类型的高级程序设计语言,没有编译过程,可移植,可嵌入,可扩展. IDE 1.检查Pyth ...

  10. python学习笔记：安装boost python库以及使用boost.python库封装

    学习是一个累积的过程.在这个过程中,我们不仅要学习新的知识,还需要将以前学到的知识进行回顾总结. 前面讲述了Python使用ctypes直接调用动态库和使用Python的C语言API封装C函数, C+ ...

随机推荐

  1. ubuntu 环境下 安装虚拟环境

    sudo pip3 install virtualenv 安装虚拟环境 sudo pip3 instal virtualenvwrapper #安装虚拟环境扩展包 编辑home目录下面的.bashrc ...

  2. DynamoDB

    https://boto3.amazonaws.com/v1/documentation/api/latest/guide/dynamodb.html Creating a  New  Table I ...

  3. centos7 使用kubeadm 快速部署 kubernetes 国内源

    前言 搭建kubernetes时看文档以及资料走了很多弯路,so 整理了最后成功安装的过程已做记录.网上的搭建文章总是少一些步骤,想本人这样的小白总是部署不成功(^_^). 准备两台或两台以上的虚拟机 ...

  4. spring 装配机制

    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w ...

  5. 在Centos7下搭建Socks5代理服务器

    在Centos7下搭建Socks5代理服务器 http://blog.51cto.com/quliren/2052776   采用socks协议的代理服务器就是SOCKS服务器,是一种通用的代理服务器 ...

  6. monkey命令解析

  7. 图解Go select语句原理

    Go 的select语句是一种仅能用于channl发送和接收消息的专用语句,此语句运行期间是阻塞的:当select中没有case语句的时候,会阻塞当前的groutine.所以,有人也会说select是 ...

  8. Markdown 尝试

    目录 简介 参数模型 vs. 非参数模型 创新点 at the modeling level at the training procedure 模型结构 attention kernel Full ...

  9. 【NIFI】 Apache NiFI 使用技巧

    本章介绍NIFI组件的使用. 主要有:Nginx反向代理NIFI,配置SSLContextService Nginx反向代理NIFI 使用nginx反向代理NIFI配置如下 upstream nifi ...

  10. pip install cv2报错

    pip install cv2 安装cv2报错: Could not find a version that satisfies the requirement cv2 (from versions: ...