标签：ali argv 关系 组织结构 格式 问题 static length 引入
#人类 class Ren: def __init__(self,name): self.name = name self.xue = 100 self.qiang = None def __str__(self): return self.name + "剩余血量为:" + str(self.xue) def anzidan(self,danjia,zidan): danjia.baocunzidan(zidan) def andanjia(self,qiang,danjia): qiang.lianjiedanjia(danjia) def naqiang(self,qiang): self.qiang = qiang def kaiqiang(self,diren): self.qiang.she(diren) def diaoxue(self,shashangli): self.xue -= shashangli #弹夹类 class Danjia: def __init__(self, rongliang): self.rongliang = rongliang self.rongnaList = [] def __str__(self): return "弹夹当前的子弹数量为:" + str(len(self.rongnaList)) + "/" + str(self.rongliang) def baocunzidan(self,zidan): if len(self.rongnaList) < self.rongliang: self.rongnaList.append(zidan) def chuzidan(self): #判断当前弹夹中是否还有子弹 if len(self.rongnaList) > 0: #获取最后压入到单间中的子弹 zidan = self.rongnaList[-1] self.rongnaList.pop() return zidan else: return None #子弹类 class Zidan: def __init__(self,shashangli): self.shashangli = shashangli def shanghai(self,diren): diren.diaoxue(self.shashangli) #枪类 class Qiang: def __init__(self): self.danjia = None def __str__(self): if self.danjia: return "枪当前有弹夹" else: return "枪没有弹夹" def lianjiedanjia(self,danjia): if not self.danjia: self.danjia = danjia def she(self,diren): zidan = self.danjia.chuzidan() if zidan: zidan.shanghai(diren) else: print("没有子弹了，放了空枪....") #创建一个人对象 laowang = Ren("老王") #创建一个弹夹 danjia = Danjia(20) print(danjia) #循环的方式创建一颗子弹，然后让老王把这颗子弹压入到弹夹中 i=0 while i<5: zidan = Zidan(5) laowang.anzidan(danjia,zidan) i+=1 #测试一下，安装完子弹后，弹夹中的信息 print(danjia) #创建一个枪对象 qiang = Qiang() print(qiang) #让老王，把弹夹连接到枪中 laowang.andanjia(qiang,danjia) print(qiang) #创建一个敌人 diren = Ren("敌人") print(diren) #让老王拿起枪 laowang.naqiang(qiang) #老王开枪射敌人 laowang.kaiqiang(diren) print(diren) print(danjia) laowang.kaiqiang(diren) print(diren) print(danjia)
如果有一个对象，当需要对其进行修改属性时，有2种方法
为了更好的保存属性安全，即不能随意修改，一般的处理方式为
class People(object): def __init__(self, name): self.__name = name def getName(self): return self.__name def setName(self, newName): if len(newName) >= 5: self.__name = newName else: print("error:名字长度需要大于或者等于5") xiaoming = People("dongGe") print(xiaoming.__name)
class People(object): def __init__(self, name): self.__name = name def getName(self): return self.__name def setName(self, newName): if len(newName) >= 5: self.__name = newName else: print("error:名字长度需要大于或者等于5") xiaoming = People("dongGe") xiaoming.setName("wanger") print(xiaoming.getName()) xiaoming.setName("lisi") print(xiaoming.getName())
__del__()方法创建对象后，python解释器默认调用__init__()方法；
当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法
import time class Animal(object): # 初始化方法 # 创建完对象后会自动被调用 def __init__(self, name): print(‘__init__方法被调用‘) self.__name = name # 析构方法 # 当对象被删除时，会自动被调用 def __del__(self): print("__del__方法被调用") print("%s对象马上被干掉了..."%self.__name) # 创建对象 dog = Animal("哈皮狗") # 删除对象 del dog cat = Animal("波斯猫") cat2 = cat cat3 = cat print("---马上 删除cat对象") del cat print("---马上 删除cat2对象") del cat2 print("---马上 删除cat3对象") del cat3 print("程序2秒钟后结束") time.sleep(2)
结果:
在现实生活中，继承一般指的是子女继承父辈的财产，如下图
在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物；同理，波斯猫和巴厘猫都继承自猫，而沙皮狗和斑点狗都继承足够，如下如所示：
# 定义一个父类，如下: class Cat(object): def __init__(self, name, color="白色"): self.name = name self.color = color def run(self): print("%s--在跑"%self.name) # 定义一个子类，继承Cat类如下: class Bosi(Cat): def setNewName(self, newName): self.name = newName def eat(self): print("%s--在吃"%self.name) bs = Bosi("印度猫") print(‘bs的名字为:%s‘%bs.name) print(‘bs的颜色为:%s‘%bs.color) bs.eat() bs.setNewName(‘波斯‘) bs.run()
运行结果:
说明：
__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法class Animal(object): def __init__(self, name=‘动物‘, color=‘白色‘): self.__name = name self.color = color def __test(self): print(self.__name) print(self.color) def test(self): print(self.__name) print(self.color) class Dog(Animal): def dogTest1(self): #print(self.__name) #不能访问到父类的私有属性 print(self.color) def dogTest2(self): #self.__test() #不能访问父类中的私有方法 self.test() A = Animal() #print(A.__name) #程序出现异常，不能访问私有属性 print(A.color) #A.__test() #程序出现异常，不能访问私有方法 A.test() print("------分割线-----") D = Dog(name = "小花狗", color = "黄色") D.dogTest1() D.dogTest2()
从图中能够看出，所谓多继承，即子类有多个父类，并且具有它们的特征
Python中多继承的格式如下:
# 定义一个父类 class A: def printA(self): print(‘----A----‘) # 定义一个父类 class B: def printB(self): print(‘----B----‘) # 定义一个子类，继承自A、B class C(A,B): def printC(self): print(‘----C----‘) obj_C = C() obj_C.printA() obj_C.printB()
运行结果:
----A---- ----B----
如果在上面的多继承例子中，如果父类A和父类B中，有一个同名的方法，那么通过子类去调用的时候，调用哪个？
#coding=utf-8 class base(object): def test(self): print(‘----base test----‘) class A(base): def test(self): print(‘----A test----‘) # 定义一个父类 class B(base): def test(self): print(‘----B test----‘) # 定义一个子类，继承自A、B class C(A,B): pass obj_C = C() obj_C.test() print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法
#coding=utf-8 class Cat(object): def sayHello(self): print("halou-----1") class Bosi(Cat): def sayHello(self): print("halou-----2") bosi = Bosi() bosi.sayHello()
#coding=utf-8 class Cat(object): def __init__(self,name): self.name = name self.color = ‘yellow‘ class Bosi(Cat): def __init__(self,name): # 调用父类的__init__方法1(python2) #Cat.__init__(self,name) # 调用父类的__init__方法2 #super(Bosi,self).__init__(name) # 调用父类的__init__方法3 super().__init__(name) def getName(self): return self.name bosi = Bosi(‘xiaohua‘) print(bosi.name) print(bosi.color)
多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态
class F1(object): def show(self): print ‘F1.show‘ class S1(F1): def show(self): print ‘S1.show‘ class S2(F1): def show(self): print ‘S2.show‘ # 由于在Java或C#中定义函数参数时，必须指定参数的类型 # 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类 # 而实际传入的参数是：S1对象和S2对象 def Func(F1 obj): """Func函数需要接收一个F1类型或者F1子类的类型""" print obj.show() s1_obj = S1() Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show s2_obj = S2() Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show
class F1(object): def show(self): print ‘F1.show‘ class S1(F1): def show(self): print ‘S1.show‘ class S2(F1): def show(self): print ‘S2.show‘ def Func(obj): print obj.show() s1_obj = S1() Func(s1_obj) s2_obj = S2() Func(s2_obj)
在了解了类基本的东西之后，下面看一下python中这几个概念的区别
先来谈一下类属性和实例属性
在前面的例子中我们接触到的就是实例属性（对象属性），顾名思义，类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本，这个和C++中类的静态成员变量有点类似。对于公有的类属性，在类外可以通过类对象和实例对象访问
class People(object): name = ‘Tom‘ #公有的类属性 __age = 12 #私有的类属性 p = People() print(p.name) #正确 print(People.name) #正确 print(p.__age) #错误，不能在类外通过实例对象访问私有的类属性 print(People.__age) #错误，不能在类外通过类对象访问私有的类属性
class People(object): address = ‘山东‘ #类属性 def __init__(self): self.name = ‘xiaowang‘ #实例属性 self.age = 20 #实例属性 p = People() p.age =12 #实例属性 print(p.address) #正确 print(p.name) #正确 print(p.age) #正确 print(People.address) #正确 print(People.name) #错误 print(People.age) #错误
class People(object): country = ‘china‘ #类属性 print(People.country) p = People() print(p.country) p.country = ‘japan‘ print(p.country) #实例属性会屏蔽掉同名的类属性 print(People.country) del p.country #删除实例属性 print(p.country)
类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以‘cls‘作为第一个参数的名字，就最好用‘cls‘了），能够通过实例对象和类对象去访问。
class People(object): country = ‘china‘ #类方法，用classmethod来进行修饰 @classmethod def getCountry(cls): return cls.country p = People() print p.getCountry() #可以用过实例对象引用 print People.getCountry() #可以通过类对象引用
类方法还有一个用途就是可以对类属性进行修改：
class People(object): country = ‘china‘ #类方法，用classmethod来进行修饰 @classmethod def getCountry(cls): return cls.country @classmethod def setCountry(cls,country): cls.country = country p = People() print p.getCountry() #可以用过实例对象引用 print People.getCountry() #可以通过类对象引用 p.setCountry(‘japan‘) print p.getCountry() print People.getCountry()
结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变
需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数
class People(object): country = ‘china‘ @staticmethod #静态方法 def getCountry(): return People.country print People.getCountry()
从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用
# 定义车类 class Car(object): # 定义车的方法 def move(self): print("---车在移动---") def stop(self): print("---停车---") # 定义一个销售车的店类 class CarStore(object): def order(self): self.car = Car() #找一辆车 self.car.move() self.car.stop()
上面的4s店，只能销售那一种类型的车
如果这个是个销售北京现代品牌的车，比如伊兰特、索纳塔等，该怎样做呢？
# 定义伊兰特车类 class YilanteCar(object): # 定义车的方法 def move(self): print("---车在移动---") def stop(self): print("---停车---") # 定义索纳塔车类 class SuonataCar(object): # 定义车的方法 def move(self): print("---车在移动---") def stop(self): print("---停车---") # 定义一个销售北京现代车的店类 class CarStore(object): def order(self, typeName): #根据客户的不同要求，生成不同的类型的车 if typeName == "伊兰特": car = YilanteCar() elif typeName == "索纳塔": car = SuonataCar() return car
这样做，不太好，因为当北京现代又生产一种新类型的车时，又得在CarStore类中修改，有没有好的解决办法呢？
# 定义伊兰特车类 class YilanteCar(object): # 定义车的方法 def move(self): print("---车在移动---") def stop(self): print("---停车---") # 定义索纳塔车类 class SuonataCar(object): # 定义车的方法 def move(self): print("---车在移动---") def stop(self): print("---停车---") # 用来生成具体的对象 def createCar(typeName): if typeName == "伊兰特": car = YilanteCar() elif typeName == "索纳塔": car = SuonataCar() return car # 定义一个销售北京现代车的店类 class CarStore(object): def order(self, typeName): # 让工厂根据类型，生产一辆汽车 car = createCar(typeName) return car
# 定义伊兰特车类 class YilanteCar(object): # 定义车的方法 def move(self): print("---车在移动---") def stop(self): print("---停车---") # 定义索纳塔车类 class SuonataCar(object): # 定义车的方法 def move(self): print("---车在移动---") def stop(self): print("---停车---") # 定义一个生产汽车的工厂，让其根据具体的订单生产车 class CarFactory(object): def createCar(self,typeName): if typeName == "伊兰特": car = YilanteCar() elif typeName == "索纳塔": car = SuonataCar() return car # 定义一个销售北京现代车的店类 class CarStore(object): def __init__(self): #设置4s店的指定生产汽车的工厂 self.carFactory = CarFactory() def order(self, typeName): # 让工厂根据类型，生产一辆汽车 car = self.carFactory.createCar(typeName) return car
咋一看来，好像只是把生产环节重新创建了一个类，这确实比较像是一种编程习惯，此种解决方式被称作简单工厂模式
工厂函数、工厂类对具体的生成环节进行了封装，这样有利于代码的后需扩展，即把功能划分的更具体，4s店只负责销售，汽车厂只负责制造
当买车时，有很多种品牌可以选择，比如北京现代、别克、凯迪拉克、特斯拉等，那么此时该怎样进行设计呢？
# 定义一个基本的4S店类 class CarStore(object): #仅仅是定义了有这个方法，并没有实现，具体功能，这个需要在子类中实现 def createCar(self, typeName): pass def order(self, typeName): # 让工厂根据类型，生产一辆汽车 self.car = self.createCar(typeName) self.car.move() self.car.stop() # 定义一个北京现代4S店类 class XiandaiCarStore(CarStore): def createCar(self, typeName): self.carFactory = CarFactory() return self.carFactory.createCar(typeName) # 定义伊兰特车类 class YilanteCar(object): # 定义车的方法 def move(self): print("---车在移动---") def stop(self): print("---停车---") # 定义索纳塔车类 class SuonataCar(object): # 定义车的方法 def move(self): print("---车在移动---") def stop(self): print("---停车---") # 定义一个生产汽车的工厂，让其根据具体得订单生产车 class CarFactory(object): def createCar(self,typeName): self.typeName = typeName if self.typeName == "伊兰特": self.car = YilanteCar() elif self.typeName == "索纳塔": self.car = SuonataCar() return self.car suonata = XiandaiCarStore() suonata.order("索纳塔")
工厂方法模式的定义定义了一个创建对象的
接口(可以理解为函数)，但由子类决定要实例化的类是哪一个，工厂方法模式让类的实例化推迟到子类，抽象的CarStore提供了一个创建对象的方法createCar，也叫作工厂方法。子类真正实现这个createCar方法创建出具体产品。 创建者类不需要直到实际创建的产品是哪一个，选择了使用了哪个子类，自然也就决定了实际创建的产品是什么。
__new__方法__new__和__init__的作用class A(object): def __init__(self): print("这是 init 方法") def __new__(cls): print("这是 new 方法") return object.__new__(cls) A()
__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值
我们可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节
举个常见的单例模式例子，我们日常使用的电脑上都有一个回收站，在整个操作系统中，回收站只能有一个实例，整个系统都使用这个唯一的实例，而且回收站自行提供自己的实例。因此回收站是单例模式的应用。
确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。
# 实例化一个单例 class Singleton(object): __instance = None def __new__(cls, age, name): #如果类数字能够__instance没有或者没有赋值 #那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时 #能够知道之前已经创建过对象了，这样就保证了只有1个对象 if not cls.__instance: cls.__instance = object.__new__(cls) return cls.__instance a = Singleton(18, "dongGe") b = Singleton(8, "dongGe") print(id(a)) print(id(b)) a.age = 19 #给a指向的对象添加一个属性 print(b.age)#获取b指向的对象的age属性
运行结果：
In [12]: class Singleton(object): ...: __instance = None ...: ...: def __new__(cls, age, name): ...: if not cls.__instance: ...: cls.__instance = object.__new__(cls) ...: return cls.__instance ...: ...: a = Singleton(18, "dongGe") ...: b = Singleton(8, "dongGe") ...: ...: print(id(a)) ...: print(id(b)) ...: ...: a.age = 19 ...: print(b.age) ...: 4391023224 4391023224 19
# 实例化一个单例 class Singleton(object): __instance = None __first_init = False def __new__(cls, age, name): if not cls.__instance: cls.__instance = object.__new__(cls) return cls.__instance def __init__(self, age, name): if not self.__first_init: self.age = age self.name = name Singleton.__first_init = True a = Singleton(18, "dongGe") b = Singleton(8, "dongGe") print(id(a)) print(id(b)) print(a.age) print(b.age) a.age = 19 print(b.age)
运行结果:
看如下示例:
print ‘-----test--1---‘ open(‘123.txt‘,‘r‘) print ‘-----test--2---‘
运行结果:
说明:
打开一个不存在的文件123.txt，当找不到123.txt 文件时，就会抛出给我们一个IOError类型的错误，No such file or directory：123.txt （没有123.txt这样的文件或目录）
异常:
当Python检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"
看如下示例:
try: print(‘-----test--1---‘) open(‘123.txt‘,‘r‘) print(‘-----test--2---‘) except IOError: pass
运行结果:
说明:
小总结:
看如下示例:
try: print num except IOError: print(‘产生错误了‘)
运行结果如下:
想一想:
上例程序，已经使用except来捕获异常了，为什么还会看到错误的信息提示？
答:
except捕获的错误类型是IOError，而此时程序产生的异常为 NameError ，所以except没有生效
修改后的代码为:
try: print num except NameError: print(‘产生错误了‘)
运行结果如下:
#coding=utf-8 try: print(‘-----test--1---‘) open(‘123.txt‘,‘r‘) # 如果123.txt文件不存在，那么会产生 IOError 异常 print(‘-----test--2---‘) print(num)# 如果num变量没有定义，那么会产生 NameError 异常 except (IOError,NameError): #如果想通过一次except捕获到多个异常可以用一个元组的方式 # errorMsg里会保存捕获到的错误信息 print(errorMsg)
咱们应该对else并不陌生，在if中，它的作用是当条件不满足时执行的实行；同样在try...except...中也是如此，即如果没有捕获到异常，那么就执行else中的事情
try: num = 100 print num except NameError as errorMsg: print(‘产生错误了:%s‘%errorMsg) else: print(‘没有捕获到异常，真高兴‘)
运行结果如下:
try...finally...语句用来表达这样的情况：
在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用finally。 比如文件关闭，释放锁，把数据库连接返还给连接池等
demo:
import time try: f = open(‘test.txt‘) try: while True: content = f.readline() if len(content) == 0: break time.sleep(2) print(content) except: #如果在读取文件的过程中，产生了异常，那么就会捕获到 #比如 按下了 ctrl+c pass finally: f.close() print(‘关闭文件‘) except: print("没有这个文件")
说明:
test.txt文件中每一行数据打印，但是我有意在每打印一行之前用time.sleep方法暂停2秒钟。这样做的原因是让程序运行得慢一些。在程序运行的时候，按Ctrl+c中断（取消）程序。
我们可以观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍然被执行，把文件关闭。
import time try: f = open(‘test.txt‘) try: while True: content = f.readline() if len(content) == 0: break time.sleep(2) print(content) finally: f.close() print(‘关闭文件‘) except: print("没有这个文件")
运行结果:
In [26]: import time ...: try: ...: f = open(‘test.txt‘) ...: try: ...: while True: ...: content = f.readline() ...: if len(content) == 0: ...: break ...: time.sleep(2) ...: print(content) ...: finally: ...: f.close() ...: print(‘关闭文件‘) ...: except: ...: print("没有这个文件") ...: finally: ...: print("最后的finally") ...: xxxxxxx--->这是test.txt文件中读取到信息 ^C关闭文件 没有这个文件 最后的finally
def test1(): print("----test1-1----") print(num) print("----test1-2----") def test2(): print("----test2-1----") test1() print("----test2-2----") def test3(): try: print("----test3-1----") test1() print("----test3-2----") except Exception as result: print("捕获到了异常，信息是:%s"%result) print("----test3-2----") test3() print("------华丽的分割线-----") test2()
运行结果:
总结：
你可以用raise语句来引发一个异常。异常/错误对象必须有一个名字，且它们应是Error或Exception类的子类
下面是一个引发异常的例子:
class ShortInputException(Exception): ‘‘‘自定义的异常类‘‘‘ def __init__(self, length, atleast): #super().__init__() self.length = length self.atleast = atleast def main(): try: s = input(‘请输入 --> ‘) if len(s) < 3: # raise引发一个你定义的异常 raise ShortInputException(len(s), 3) except ShortInputException as result:#x这个变量被绑定到了错误的实例 print(‘ShortInputException: 输入的长度是 %d,长度至少应是 %d‘% (result.length, result.atleast)) else: print(‘没有异常发生.‘) main()
运行结果如下:
#super().__init__()的说明
这一行代码，可以调用也可以不调用，建议调用，因为
__init__方法往往是用来对创建完的对象进行初始化工作，如果在子类中重写了父类的__init__方法，即意味着父类中的很多初始化工作没有做，这样就不保证程序的稳定了，所以在以后的开发中，如果重写了父类的__init__方法，最好是先调用父类的这个方法，然后再添加自己的功能
class Test(object): def __init__(self, switch): self.switch = switch #开关 def calc(self, a, b): try: return a/b except Exception as result: if self.switch: print("捕获开启，已经捕获到了异常，信息如下:") print(result) else: #重新抛出这个异常，此时就不会被这个异常处理给捕获到，从而触发默认的异常处理 raise a = Test(True) a.calc(11,0) print("----------------------华丽的分割线----------------") a.switch = False a.calc(11,0)
运行结果:
有过C语言编程经验的朋友都知道在C语言中如果要引用sqrt函数，必须用语句#include <math.h>引入math.h这个头文件，否则是无法正常进行调用的。
那么在Python中，如果要引用一些其他的函数，该怎么处理呢？
在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似，比如在Python中要调用sqrt函数，必须用import关键字引入math这个模块，下面就来了解一下Python中的模块。
说的通俗点：模块就好比是工具包，要想使用这个工具包中的工具(就好比函数)，就需要导入这个模块
在Python中用关键字import来引入某个模块，比如要引用模块math，就可以在文件最开始的地方用import math来引入。
形如:
import module1,mudule2...
当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。
在调用math模块中的函数时，必须这样引用：
模块名.函数名
想一想:
为什么必须加上模块名调用呢？
答:
因为可能存在这样一种情况：在多个模块中含有相同名称的函数，此时如果只是通过函数名来调用，解释器无法知道到底要调用哪个函数。所以如果像上述这样引入模块的时候，调用函数必须加上模块名
import math #这样会报错 print sqrt(2) #这样才能正确输出结果 print math.sqrt(2)
有时候我们只需要用到模块中的某个函数，只需要引入该函数即可，此时可以用下面方法实现：
from 模块名 import 函数名1,函数名2....
不仅可以引入函数，还可以引入一些全局变量、类等
注意:
通过这种方式引入的时候，调用函数时只能给出函数名，不能给出模块名，但是当两个模块中含有相同名称函数的时候，后面一次引入会覆盖前一次引入。也就是说假如模块A中有函数function( )，在模块B中也有函数function( )，如果引入A中的function在先、B中的function在后，那么当调用function函数的时候，是去执行模块B中的function函数。
如果想一次性引入math中所有的东西，还可以通过from math import *来实现
Python的from语句让你从模块中导入一个指定的部分到当前命名空间中
语法如下：
from modname import name1[, name2[, ... nameN]]
例如，要导入模块fib的fibonacci函数，使用如下语句：
from fib import fibonacci
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *
In [1]: import time as tt In [2]: time.sleep(1) --------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-2-07a34f5b1e42> in <module>() ----> 1 time.sleep(1) NameError: name ‘time‘ is not defined In [3]: In [3]: In [3]: tt.sleep(1) In [4]: In [4]: In [4]: from time import sleep as sp In [5]: sleep(1) --------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-5-82e5c2913b44> in <module>() ----> 1 sleep(1) NameError: name ‘sleep‘ is not defined In [6]: In [6]: In [6]: sp(1) In [7]:
当你导入一个模块，Python解析器对模块位置的搜索顺序是：
在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字。
比如有这样一个文件test.py，在test.py中定义了函数add
test.py
def add(a,b): return a+b
那么在其他文件中就可以先import test，然后通过test.add(a,b)来调用了，当然也可以通过from test import add来引入
main.py
import test result = test.add(11,22) print(result)
在实际开中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，例如：
test.py
def add(a,b): return a+b # 用来进行测试 ret = add(12,22) print(‘int test.py file,,,,12+22=%d‘%ret)
如果此时，在其他py文件中引入了此文件的话，想想看，测试的那段代码是否也会执行呢！
main.py
import test result = test.add(11,22) print(result)
运行现象：
至此，可发现test.py中的测试代码，应该是单独执行test.py文件时才应该执行的，不应该是其他的文件中引用而执行
为了解决这个问题，python在执行一个文件时有个变量__name__
__all____all__
__all__
__init__.py文件
__init__.py文件中写入
__init__.py 文件，那么这个文件夹就称之为包__init__.py文件有什么用 __init__.py 控制着包的导入行为
__init__.py为空仅仅是把这个包导入，不会导入包中的模块
__all__ 在__init__.py文件中，定义一个__all__变量，它控制着 from 包名 import *时导入的模块
__init__.py文件中编写内容可以在这个文件中编写语句，当导入时，这些语句就会被执行
__init__.py文件
假定我们的包的例子有如下的目录结构：
Phone/
__init__.py
common_util.py
Voicedta/
__init__.py
Pots.py
Isdn.py
Fax/
__init__.py
G3.py
Mobile/
__init__.py
Analog.py
igital.py
Pager/
__init__.py
Numeric.py
Phone 是最顶层的包，Voicedta 等是它的子包。 我们可以这样导入子包：
import Phone.Mobile.Analog Phone.Mobile.Analog.dial()
你也可使用 from-import 实现不同需求的导入
第一种方法是只导入顶层的子包，然后使用属性/点操作符向下引用子包树：
from Phone import Mobile Mobile.Analog.dial(‘555-1212‘)
此外，我们可以还引用更多的子包：
from Phone.Mobile import Analog Analog.dial(‘555-1212‘)
事实上，你可以一直沿子包的树状结构导入：
from Phone.Mobile.Analog import dial dial(‘555-1212‘)
在我们上边的目录结构中，我们可以发现很多的 __init__.py 文件。这些是初始化模块，from-import 语句导入子包时需要用到它。 如果没有用到，他们可以是空文件。
包同样支持 from-import all 语句：
from package.module import *
然而，这样的语句会导入哪些文件取决于操作系统的文件系统。所以我们在__init__.py 中加入 __all__变量。该变量包含执行这样的语句时应该导入的模块的名字。它由一个模块名字符串列表组成.。
1.mymodule目录结构体如下：
. ├── setup.py ├── suba │ ├── aa.py │ ├── bb.py │ └── __init__.py └── subb ├── cc.py ├── dd.py └── __init__.py
2.编辑setup.py文件
py_modules需指明所需包含的py文件
from distutils.core import setup setup(name="dongGe", version="1.0", description="dongGe‘s module", author="dongGe", py_modules=[‘suba.aa‘, ‘suba.bb‘, ‘subb.cc‘, ‘subb.dd‘])
3.构建模块
python setup.py build
构建后目录结构
. ├── build │ └── lib.linux-i686-2.7 │ ├── suba │ │ ├── aa.py │ │ ├── bb.py │ │ └── __init__.py │ └── subb │ ├── cc.py │ ├── dd.py │ └── __init__.py ├── setup.py ├── suba │ ├── aa.py │ ├── bb.py │ └── __init__.py └── subb ├── cc.py ├── dd.py └── __init__.py
4.生成发布压缩包
python setup.py sdist
打
. ├── build │ └── lib.linux-i686-2.7 │ ├── suba │ │ ├── aa.py │ │ ├── bb.py │ │ └── __init__.py │ └── subb │ ├── cc.py │ ├── dd.py │ └── __init__.py ├── dist │ └── dongGe-1.0.tar.gz ├── MANIFEST ├── setup.py ├── suba │ ├── aa.py │ ├── bb.py │ └── __init__.py └── subb ├── cc.py ├── dd.py └── __init__.py
python setup.py install注意：
python setup.py install --prefix=安装路径在程序中，使用from import 即可完成对安装的模块使用
from 模块名 import 模块名或者*
import sys print(sys.argv)
运行结果:
所谓的列表推导式，就是指的轻量级循环创建列表
生成一个[[1,2,3],[4,5,6]....]的列表最大值在100以内
请写出一段 Python 代码实现分组一个 list 里面的元素,比如 [1,2,3,...100]变成 [[1,2,3],[4,5,6]....]
标签：ali argv 关系 组织结构 格式 问题 static length 引入
原文地址：https://www.cnblogs.com/alexzhang92/p/9347622.html
