模块使用
模块是Python组织代码的基本方式
一个Python脚本可以单独运行,也可以导入到另一个脚本中运行,当脚本被导入运行时,我们将其称为模块(module)
所有的.py文件都可以作为一个模块导入
模块名称与脚本的文件名相同,例如我们编写了一个名为hello.py的脚本,则可以在另一个脚本中用import hello语句来导入它
包(模块的集合):
Python的模块可以按照目录组织为包
创建一个包的步骤:
-创建一个名字为包名的目录
-在该目录下创建一个__init__.py文件
-根据需要,在该目录下存放脚本文件或已编译的扩展及子包
-import pack.m1,pack.m2,pack.m3
编写一个脚本(block.py),统计一个文件的行数,单词数,字符数:
#!/usr/bin/python
def wordCount(s):
chars = len(s)
words = len(s.split())
# lines = len(s.split('\n'))
lines = s.count('\n')
print lines,words,chars
s = open('/etc/passwd').read()
wordCount(s)
新建一个block2.py文件,只写入一句import block,执行block2.py文件,结果和执行block.py文件一致
模块是一个可导入的python脚本文件
包是一些按目录组织的模块和子包,目录下有__init__.py文件,此文件可存放包的信息
导入模块和包的语法:
--import,import as(取别名,如:from day02.block import wordCount as wc)
--from...import... 如:from day02 import block(import day02.block),
如果想直接使用函数 from 包名.模块名 import 函数名/类名
面向对象介绍
面向过程和面向对象编程:
--面向过程编程:函数式编程,C程序等(shell)
--面向对象编程:C++,Java,Python等,主要思想是:封装,继承,多态
类和对象:
-类:是对事物的抽象,比如:人类,球类
-对象:是类的一个实例,如:足球,篮球
实例说明:球类可以对球的特征和行为进行抽象,然后可以实例化一个真实的球实体出来
类定义:
类把需要的变量和函数组合成一起,这种包含称为“封装”
class A(object):
类的结构:
class 类名:
成员变量 - 属性
成员函数 - 方法
#!/usr/bin/python
class People(object):
color = 'yellow'
def think(self): #类的方法中至少有一个参数self,表示类自己(有其他参数的话继续添加在后面)
self.color = "black"
print "I am a %s" % self.color
print "I am a thinker"
ren = People() #实例化(创建对象),将类赋值给变量
print ren.color #使用对象.属性进行访问
ren.think() #对象.方法进行调用
类的属性
类的属性又可以叫做成员变量
类的方法又可以叫做成员函数
对象的创建:
创建对象的过程称之为实例化,当一个对象被创建后,包含三个方面的特性:对象句柄,属性和方法
句柄用于区分不同的对象
对象的属性和方法与类中的成员变量和成员函数对应
obj = MyClass()//创建类的一个实例(对象),通过对象来调用方法和属性
类的属性按使用范围分为公有属性和私有属性,类的属性范围取决于属性的名称
公有属性:在类中和类外都能调用的属性
私有属性:不能在类外及被类以外的函数调用,定义方式:以“__”双下划线开始的成员变量就是私有属性
可以通过instance._classname__attribute方式访问(如:instance._People__age),一般仅作测试用
内置属性:由系统在定义类的时候默认添加的,由前后双下划线构成,__dict__,__module__
类的方法
方法的定义和函数一样,但是需要self作为第一个参数
类方法为:
-公有方法:在类中和类外都能调用的方法
#!/usr/bin/python
class People(object):
color = 'yellow'
__age = 30
def think(self):
self.color = "black"
print "I am a %s" % self.color
print "I am a thinker"
print self.__age
def test(self):
self.think()
ren = People()
ren.test()
-私有方法:不能被类的外部调用,在方法前面加上“__”双下划线就是私有方法
#!/usr/bin/python
class People(object):
color = 'yellow'
__age = 30
def __talk(self):
print "I am talking with Tom"
def test(self):
self.__talk()
ren = People()
ren.test()
-类方法:被
classmethod()函数处理过的函数,能被类所调用,也能被对象所调用(是继承的关系),(
需要哪些东西才加载哪些东西,动态的,类方法占用资源很少)
#!/usr/bin/python
class People(object):
color = 'yellow'
__age = 30
def __talk(self):
print "I am talking with Tom"
def test(self):
print "Testing..."
cm = classmethod(test)
People.cm()
-静态方法:相当于“全局函数”,可以被类直接调用,可以被所有实例化对象共享,通过staticmethod()定义,
静态方法没有“self”参数(
会将类中所有的东西都加载到内存,占用资源较多,但是速度比动态方法更快
)
因为没有self参数,所以访问内中其他成员的时候,可以通过类直接访问,如People.color
#!/usr/bin/python
class People(object):
color = 'yellow'
__age = 30
def __talk(self):
print "I am talking with Tom"
def test():
print "Testing..."
sm = staticmethod(test)
People.sm()
装饰器(只对其下一个方法起作用):
-@classmethod
-@staticmethod
#!/usr/bin/python
class People(object):
@classmethod
def test(self):
print "This is class method"
@staticmethod
def test1():
print "This is static method"
People.test()
People.test1()
self参数:
用于区分函数和类的方法(必须有一个self),self参数表示执行对象本身
类的内置方法
内部类:在类的内部定义的类,主要目的是为了更好的抽象现实世界
例子:汽车是一个类,汽车的底盘、轮胎也可以抽象为类,将其定义到汽车类中,则形成内部类,更好的描述汽车类,因为底盘、轮胎是汽车的一部分
内部类的实例化方法:
-1.直接使用外部类调用内部类
object_name = outclass_name.inclass_name()
#!/usr/bin/python
class People(object):
class Chinese(object):
print "I am chinese"
ren = People.Chinese()
-2.先对外部类进行实例化,然后再实例化内部类
out_name = outclass_name()
in_name = out_name.inclass_name()
in_name.method()
#!/usr/bin/python
class People(object):
class Chinese(object):
print "I am chinese"
ren = People()
chin = ren.Chinese()
__str__(self)
#!/usr/bin/python
class People(object):
color = 'yellow'
__age = 30
def __str__(self):
return "This is People class"
ren = People()
print ren
构造函数和析构函数:
-构造函数:用于初始化类的内部状态,Python提供的构造函数是__init__()
__init__()方法是可选的,如果不提供,Python会给出一个默认的__init__方法
#!/usr/bin/python
class People(object):
color = 'yellow'
__age = 30
def __init__(self,c = 'red'):
self.color = c
ren = People() #括号中没有传值,便使用默认值red,如果有值则使用传的值
print ren.color #red
print People.color #yellow
-析构函数:用于释放对象占用的资源,Python提供的析构函数是__del__()
__del__()也是可选的,如果不提供,Python会在后台提供默认的析构函数
#!/usr/bin/python
class People(object):
color = 'yellow'
__age = 30
def __init__(self,c = 'red'):
self.color = c
self.think()
self.fd = open('/etc/hosts')
def think(self):
self.color = "black"
print "I am a %s" % self.color
print "I am a thinker"
print self.__age
def __del__(self): #del在脚本最后才执行
print "del ..."
self.fd.close()
ren = People()
print ren.color
print People.color
print "main end"
Python垃圾回收机制:gc模块的collect()可以一次性收集所有待处理的对象(gc.collect)
类的继承
继承是面向对象的重要特性之一
继承关系:继承是相对两个类而言的父子关系,子类继承了父类的所有公有属性和方法
继承实现了代码
继承可以重用已经存在的数据和行为,减少代码的重复编写。Python在类名后使用一对括号来表示继承关系,括号中的类即为父类
class Myclass(ParentClass)
#!/usr/bin/python
class People(object):
color = 'yellow'
def think(self):
print "I am a %s" % self.color
print "I am a thinker"
class Chinese(People):
pass
cn = Chinese()
print cn.color
cn.think()
如果父类定义了__init__方法,子类必须显式调用父类的__init__方法:ParentClass.__init__(self,[args...])
如果子类需要扩展父类的行为,可以添加__init__方法的参数
#!/usr/bin/python
class People(object): #传统的定义风格可以省略(object)
color = 'yellow'
def __init__(self,c):
self.dwell = 'Earth'
def think(self):
print "I am a %s" % self.color
print "I am a thinker"
class Chinese(People):
def __init__(self):
People.__init__(self,'red') #本行代码还可以使用super函数,super(Chinese,self).__init__('red')
pass
cn = Chinese()
print cn.color
多重继承:Python支持多重继承,即一个类可以继承多个父类
语法:class class_name(Parent_c1,Parent_c2...)
注意:当父类中出现多个自定义的__init__方法时,多重继承只执行第一个类的__init__方法,其他不执行
#!/usr/bin/python
class
People(object):
color = 'yellow'
def __init__(self):
self.dwell = 'Earth'
def think(self):
print "I am a %s" % self.color
print "My home is %s" % self.dwell
class
Martian(object):
color = 'red'
def __init__(self):
self.dwell = 'Martian'
class Chinese(People,Martian): #默认调用第一个父类(People)的__init__构造函数,如果想要使用其他的便需要进行显式调用
#def __init__(self):
#Martian.__init__(self) #显式调用
pass
cn = Chinese()
cn.think()
类的属性总结
#!/usr/bin/python
#coding:utf8
var6 = '全局变量 var6'
class MyClass(object):
var1 = '类属性,类的公有属性 var1'
__var2 = '类的私有属性 __var2'
def func1(self):
self.var3 = '对象的公有属性 var3'
sesslf.__var = '对象的私有属性 __var4'
var5 = '函数的局部变量'
def func2(self):
print self.var1 #可以访问
print self.__var2 #可以访问
print self.var3 #不能访问,除非先执行一次mc.func1()
print self.__var4 #不能访问,除非先执行一次mc.func1()
print self.var5 #不能访问
print var6 #可以访问
mc = MyClass()
print mc.var1 #可以访问,公有属性
print mc.__var2 #不能访问,私有属性
print mc._MyClass__var2 #仅供测试访问使用
mc.func1()
print mc.var3 #没有执行mc.func1()之前无法访问
print mc.__var4 #不能访问,私有属性
print mc.var5 #不能访问,函数的局部变量
print MyClass.var1 #可以访问
print MyClass.__var2 #不能访问
print MyClass.var3 #不能访问
mc.func2()
类的方法总结
#!/usr/bin/python
#coding:utf8
class MyClass(object):
name = "Test"
def __init__(self): #内置方法
self.func1()
self.__func2()
self.classFun()
self.staticFun()
def func1(self):
print self.name,
print "我是公有方法"
def __func2(self):
print self.name,
print "我是私有方法"
def classFun(self):
print self.name,
print "我是类方法"
def staticFunc(self):
print self.name,
print "我是静态方法"
mc = MyClass()
#mc.func1() #可以调用
#mc.__fun2() #不能调用(可以在类内部调用)
#MyClass.classFun() #不能调用(可以在方法上边加上一个装饰器@classmethod)
#MyClass.staticFun() #不能调用(可以在方法上面加上一个装饰器@staticmethod,并且将self.name改为MyClass.name,通过类名进行调用,同时将括号中的self参数去掉)