- 模块
- 对于项目来说,程序文件不会出现在一个文件里面,所以需要将很多功能相似的函数进行分组,分别放到不同的文件中,而且对于每一个文件的大致功能使用文件名称来进行区别,通常来说每一个
*.py文件就是一个模块; -
- 模块用于提高代码的可维护性
-
- 可以提高代码的可复用度;
-
- 可以引用其他的模块,包括内置模块
[Python提供的]以及第三方模块以及自定义模块;
- 可以引用其他的模块,包括内置模块
-
- 可以避免函数名和变量名的冲突
- sys模块
sys:主要是用户获取命令行参数的列表
import sys
print(sys.argv)
for i in sys.argv:
print(i)
name = sys.argv[1]
age = sys.argv[2]
hoby = sys.argv[3]
print(name, age, hoby)
-
输出的结果
-
自动查找所需模块所需路径的列表
import sys
print(sys.argv)
for i in sys.argv:
print(i)
name = sys.argv[1]
age = sys.argv[2]
hoby = sys.argv[3]
print(name, age, hoby)
print(sys.path)
- 查看结果
- 模块引入的方式
- 系统模块
import module name [1,module name2, module name1]
- 自定义模块,一个模块只会被引入一次,防止模块被多次引入;
import module name //模块名和文件名在同一个目录,否则就需要放在指定的目录里面;
- 使用自定义模块的格式
//导入的一种方式
import hello
hello.sayhello() //模块名.方法[函数/变量]
//另一种引入的方式 引入模块的一种方法 从模块中导入某个指定的方法
from hello import tomorrow[,name1, name2]
tomorrow() //这里不需要加函数名
- 对于
from ... import ...这种导入方式是存在弊端的,如果在当前定义和模块里面的同名函数,就会导致模块里面的函数被覆盖
from hello import tomorrow
def tomorrow():
print("tomorrow is a good day")
tomorrow()
- 对于第一种方式就不存在上面的问题
import hello
def tomorrow():
print("tomorrow is a good day")
hello.tomorrow()
tomorrow()
//最后一种导入方式 用于将一个模块中所有的方法变量都进行导入
from hello import *
-
和第二种一样存在同样的弊端,不建议使用这种方式
-
关于
__name__属性:模块表示的是一个可执行的*.py,如果不希望模块在被引入的过程中被执行,可以用__name__属性,来使程序仅仅调用模块中的一部分; -
每一个模块都存在一个
__name__属性,当其值为__main__,表示执行模块本身
def man():
pass
if __name__ == "__main__":
man()
else:
def sayhello():
print("hello python")
def today():
print("today is new day")
def tomorrow():
print("hello")
-
如果模块当做可执行文件执行的时候,
__name__的值,就是__main__,如果当做模块不希望执行的时候,__name__的值是不确定的 -
输出指定年月的日历
import calendar
print(calendar.month(2018, 6))
June 2018
Mo Tu We Th Fr Sa Su
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30
- 返回某一个年的日历
print(calendar.calendar(2018))
2018
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 7 1 2 3 4 1 2 3 4
8 9 10 11 12 13 14 5 6 7 8 9 10 11 5 6 7 8 9 10 11
15 16 17 18 19 20 21 12 13 14 15 16 17 18 12 13 14 15 16 17 18
22 23 24 25 26 27 28 19 20 21 22 23 24 25 19 20 21 22 23 24 25
29 30 31 26 27 28 26 27 28 29 30 31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 1 2 3 4 5 6 1 2 3
2 3 4 5 6 7 8 7 8 9 10 11 12 13 4 5 6 7 8 9 10
9 10 11 12 13 14 15 14 15 16 17 18 19 20 11 12 13 14 15 16 17
16 17 18 19 20 21 22 21 22 23 24 25 26 27 18 19 20 21 22 23 24
23 24 25 26 27 28 29 28 29 30 31 25 26 27 28 29 30
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 1 2 3 4 5 1 2
2 3 4 5 6 7 8 6 7 8 9 10 11 12 3 4 5 6 7 8 9
9 10 11 12 13 14 15 13 14 15 16 17 18 19 10 11 12 13 14 15 16
16 17 18 19 20 21 22 20 21 22 23 24 25 26 17 18 19 20 21 22 23
23 24 25 26 27 28 29 27 28 29 30 31 24 25 26 27 28 29 30
30 31
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 7 1 2 3 4 1 2
8 9 10 11 12 13 14 5 6 7 8 9 10 11 3 4 5 6 7 8 9
15 16 17 18 19 20 21 12 13 14 15 16 17 18 10 11 12 13 14 15 16
22 23 24 25 26 27 28 19 20 21 22 23 24 25 17 18 19 20 21 22 23
29 30 31 26 27 28 29 30 24 25 26 27 28 29 30
31
- 判断闰年
print(calendar.isleap(2000))
True
- 用于返回某个月的
weekday的第一天以及这个月的天数
print(calendar.month(2018, 6))
print(calendar.monthrange(2018,6))
June 2018
Mo Tu We Th Fr Sa Su
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30
(4, 30)
- 返回某个月,以每一周为元素的列表
print(calendar.month(2018, 6))
print(calendar.monthcalendar(2018,6))
June 2018
Mo Tu We Th Fr Sa Su
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30
[[0, 0, 0, 0, 1, 2, 3], [4, 5, 6, 7, 8, 9, 10], [11, 12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23, 24], [25, 26, 27, 28, 29, 30, 0]]
- 递归遍历目录处理邮箱格式的文件
- 代码如下
import os
import collections
def formatFile(path):
recvPath = "/root/temp/mailfile"
with open(path,"r") as file:
while True:
lineinfo = file.readline()
#print(lineinfo)
if len(lineinfo) < 5:
break
mailStr = lineinfo.split("----")[0]
print(mailStr)
fileType = mailStr.split("@")[1].split(".")[0]
dirStr = os.path.join(recvPath, fileType)
if not os.path.exists(dirStr):
os.mkdir(dirStr)
filePath = os.path.join(dirStr,fileType + ".txt")
with open(filePath, "a") as filew:
filew.write(mailStr + "\n")
def mailprocess(path):
stack = []
stack.append(path)
while len(stack) != 0:
dirPath = stack.pop()
fileList = os.listdir(dirPath)
for fileName in fileList:
filePath = os.path.join(dirPath, fileName)
if os.path.isdir(filePath):
stack.append(filePath)
else:
formatFile(filePath)
path = "/root/temp/mail"
mailprocess(path)
- 第三方模块的安装
- 首先确定
pip是否安装
pip -v
- 然后通过命令安装
from PIL import Image
picturepath = "/root/PycharmProjects/test/123.jpg"
im = Image.open(picturepath)
print(im.format, im.size, im.mode)
im.thumbnail((640, 400))
im.save("new.jpg", "JPEG")
-
面向过程
-
自上而下执行,逐步求精
-
程序结构通常是若干个模块,各个模块之间的关系尽量简单,功能上相对独立;
-
每一个模块内部都是由顺序,选择和循环三种基本结构;
-
模块的具体使用方法是使用子程序;
-
程序流程在写程序时,就已经决定;
-
面向对象
-
将数据和对于数据操作的方法放在一起,作为一个相互依赖的整体,成为对象
-
将同类对象抽取出共性,形成类;
-
对于类中的大多数数据,只能够使用本类的方法进行处理;
-
类通过一个简单的外部接口与外界发生关系,对象和对象通过消息进行通信;
-
程序的流程在用户的使用过程中决定;
-
面向过程和面向对象
-
面向过程强调的是功能行为以及解决问题需要的步骤;
-
面向对象:将功能封装成对象,强调了具备了那些功能的对象,关注与解决问题需要那些对象;
-
面向对象是基于面向过程的;
-
面向对象的特点:
- 可以将复杂的问题简单化;
- 符合思考的习惯
- 可以根据实际的需求来采用各种对象,如果对象不存在,就创建所需要的对象;
-
类和对象的关系:
- 对象表示对象实际存在的个体;
- 类是对于事物特性的一种抽象;
-
类的定义
-
定义类其实就是在定义类中成员的成员变量和成员方法;
-
类的设计:类名,属性,行为;
-
object:表示基类,超类,表示的是所有类的父类,一般没有合适的父类就使用object;
class Person(object): #表示基类,超类,表示的是所有类的父类,一般没有合适的父类就使用`object`;
# 定义属性,本质上就是定义变量
name = ""
age = 0
height = 0
weight = 0 //这里定义的就是默认的值,如果创建对象不赋值,使用这里
# 定义方法(定义函数):方法的参数必须是以self当做第一个参数,self表示的含义就是类的实例
def run(self):
print("run")
def eat(self, food):
print("eat" + food)
- 使用类来实例化对象
格式 对象名 = 类名(参数列表) 没有参数时,()不能够省略
xixi = Person()
print(xixi)
<__main__.Person object at 0x7fdaf1613780> //返回值得到的是一个内存地址
- 使用同一个类实例化的对象是不同的对象地址也是不一样的
xixi = Person()
print(xixi)
print(type(xixi))
print(id(xixi))
js = Person()
print(js)
print(type(js))
print(id(js))
-
对象一般是存储在堆区,变量一般是在栈区的;
-
访问对象的属性和方法
格式: 对象名.属性名
赋值: 对象名.属性名 =
xixi.name = "hello"
xixi.age = 16
xixi.height = 180
print(xixi.name, xixi.age, xixi.height)
- 对于对象来说,如果不进行赋值,就不会使用默认的值;
- 访问方法:
格式:对象名.方法名(参数列表)
xixi.eat("apple")
- 使用上面的方法创建的对象都是一样的,这里希望每个对象创建出来都是不一样的,需要借助于构造函数来完成
- 构造函数
__init__():在使用类创建对象的时候,自动调用,如果不显示的写出构造函数,默认也是存在一个默认的空的构造函数;
xixi.name = "hello"
xixi.age = 16
xixi.height = 180
print(xixi.name, xixi.age, xixi.height)
xixi.eat("apple")
- 创建对象时的执行结果
- 所以这里可以借助于构造函数来传递参数,完成每个对象的初始化
class Person(object):
def run(self):
print("run")
def eat(self, food):
print("eat " + food)
def __init__(self, name, age, height, weight): //属性定义
self.name = name
self.age = age
self.height = height
self.weight = weight
print("__init__")
xixi = Person("hello", 19, 180, 66)
print(xixi.name, xixi.age, xixi.height, xixi.weight)
hello
19
180
66
__init__
self的含义:self代表的是类的实例,而不是类;- 哪个对象调用方法,该方法中的
self就代表哪个对象; self.__class__:代表的是类名;
class Person(object):
name = ""
age = 0
height = 0
weight = 0
def run(self):
print("run")
def eat(self, food):
print("eat " + food)
def say(self):
print("my name is %s,and i am %d years old" %(self.name, self.age))
print(self.__class__)
def __init__(self, name, age, height, weight):
self.name = name
self.age = age
self.height = height
self.weight = weight
print("__init__")
xixi = Person("hello", 19, 180, 66)
#print(xixi.name, xixi.age, xixi.height, xixi.weight)
xixi.say()
js = Person("js", 20, 150, 60)
js.say()
__init__
my name is hello,and i am 19 years old
<class '__main__.Person'>
__init__
my name is js,and i am 20 years old
<class '__main__.Person'>
self不是关键字,可以换,但是不建议换;- 析构函数
- 在对象释放时,自动调用;
- 释放对象:
- 程序结束时,对象自动释放;
- 使用
del删除变量时,程序自动释放; - 对于自定义的函数,在函数调用完成之后,就会自动释放;
- 对象释放之后,无法再次使用;
析构函数: __del__()
lass Person(object):
def run(self):
print("run")
def eat(self, food):
print("eat " + food)
def say(self):
print("my name is %s,and i am %d years old" %(self.name, self.age))
print(self.__class__)
def __init__(self, name, age, height, weight):
self.name = name
self.age = age
self.height = height
self.weight = weight
print("__init__")
def __del__(self):
print("xigou funcation")
xixi = Person("hello", 19, 180, 66)
#print(xixi.name, xixi.age, xixi.height, xixi.weight)
xixi.say()
del xixi
js = Person("js", 20, 150, 60)
js.say()
del js
- 重写函数
- 将函数重新定义,并且重写一遍,
- 重写函数包括
__str__();- 使用重写函数可以输出对象里面所有的属性值,方便在进行输出控制;
- 在调用
print打印对象时,会自动调用,是一个描述对象的方法;
- 以及以及
__repr__():- 这个是给机器使用的,在Python解释器中直接使用对象名称时,调用的方法,在函数调用时,如果不存在
__str__(),也会使用__repr__()
- 这个是给机器使用的,在Python解释器中直接使用对象名称时,调用的方法,在函数调用时,如果不存在
def __str__(self):
return "%s %d %d %d" % (self.name, self.age, self.height, self.weight)
hello 19 180 66
xigou funcation
- 访问限制
- 限制对象访问类里面的某些属性,这些属性可能是类里面使用的,需要在属性前
__属性名,在Python中,如果在属性前加两个__,属性就变为private; - 类似于
__name__的变量属于特殊变量,但是不是私有变量,外部是可以直接访问的; - 类似于
_name_这样的外部变量也是可以进行访问的,按照约定的规则,是不能够访问这种类型的变量的;
def __init__(self, name, age, height, weight, money):
self.name = name
self.age = age
self.height = height
self.weight = weight
self.__money = money
print("__init__")
print(xixi.__money)
Traceback (most recent call last):
File "/root/PycharmProjects/test/person.py", line 27, in <module>
print(xixi.__money)
AttributeError: 'Person' object has no attribute '__money'
- 如果访问私有属性,就会出错;对于下面这种情况,是因为动态语言的特性,支持动态添加属性;
xixi.__money = 10
print(xixi.__money)
- 内部是可以使用这个变量的
def run(self):
print("run")
print(self.__money)
def __init__(self, name, age, height, weight, money):
self.name = name
self.age = age
self.height = height
self.weight = weight
self.__money = money
print("__init__")
xixi.run()
- 类可以通过定义方法向对象提高修改私有变量的方法
def setMoney(self, money):
if money < 0 :
money = 0
self.__money = money
def getMoney(self):
return self.__money
- 不能够直接访问
xix._money是因为Python把__money改为了_Person__money,可以通过后面这个变量来进行访问
xixi._Person__money = 30 //并且也直接修改了私有变量的值
xixi.run()
- 但是是不建议这样进行使用的,对于不同版本的解释器,解释出来的结果是不一样的;
- 小程序
class bulletBox(object):
def __init__(self, count):
self.bulletCount = count
class gun(object):
def __init__(self, bulletBox):
self.bulletBox = bulletBox
def shoot(self):
if self.bulletBox.bulletCount == 0:
print("no bellit")
else:
self.bulletBox.bulletCount -= 1
print("left is %d" %(self.bulletBox.bulletCount))
class person(object):
def __init__(self, gun):
self.gun = gun
def fire(self):
self.gun.shoot()
def loadBullet(self, count):
self.gun.bulletBox.bulletCount += count
bulletBox = bulletBox(5)
gun = gun(bulletBox)
per = person(gun)
per.fire()
per.fire()
per.fire()
per.loadBullet(3)
per.fire()
扫一扫
1722
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
