12.python 模块使用，面向对象介绍

一.简介

　　模块是一个保存了Python代码的文件。模块能定义函数，类和变量。模块里也能包含可执行的代码

　　模块分为三种：

• 自定义模块
• 内置标准模块
• 开源模块（第三方）

自定义模块：

　　

模块导入

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename  
from module.xx.xx import *

导入自定义模块时注意路径，查看库文件sys.path,sys.path.append('路径')添加自定义路径

二.内置模块

time模块

 

time模块提供各类操做时间的函数

说明：通常有两种表示时间的方式:
       1.时间戳的方式(相对于1970.1.1 00:00:00以秒计算的偏移量),时间戳是唯一的
       2.以数组的形式表示即(struct_time),共有九个元素，分别表示，同一个时间戳的struct_time会由于时区不一样而不一样

The tuple items are:
  year (including century, e.g. 1998)
  month (1-12)
  day (1-31)
  hours (0-23)
  minutes (0-59)
  seconds (0-59)
  weekday (0-6, Monday is 0)
  Julian day (day in the year, 1-366)
  DST (Daylight Savings Time) flag (-1, 0 or 1)

•  函数

time() -- 返回时间戳
sleep() -- 延迟运行单位为s
gmtime() -- 转换时间戳为时间元组（时间对象）
localtime() -- 转换时间戳为本地时间对象
asctime() -- 将时间对象转换为字符串
ctime() -- 将时间戳转换为字符串
mktime() -- 将本地时间转换为时间戳
strftime() -- 将时间对象转换为规范性字符串
经常使用的格式代码：

%Y Year with century as a decimal number.
%m Month as a decimal number [01,12].
%d Day of the month as a decimal number [01,31].
%H Hour (24-hour clock) as a decimal number [00,23].
%M Minute as a decimal number [00,59].
%S Second as a decimal number [00,61].
%z Time zone offset from UTC.
%a Locale's abbreviated weekday name.
%A Locale's full weekday name.
%b Locale's abbreviated month name.
%B Locale's full month name.
%c Locale's appropriate date and time representation.
%I Hour (12-hour clock) as a decimal number [01,12].
%p Locale's equivalent of either AM or PM.

strptime() -- 将时间字符串根据指定的格式化符转换成数组形式的时间
经常使用格式代码：
   同strftime

• 举例

  View Code

2.datetime模块

定义的类有：　
datetime.date　　　　--表示日期的类。经常使用的属性有year, month, day
datetime.time　　　　--表示时间的类。经常使用的属性有hour, minute, second, microsecond

datetime.datetime　　--表示日期时间
datetime.timedelta　  --表示时间间隔，即两个时间点之间的长度

• date类

date类表示日期，构造函数以下 ：

datetime.date(year, month, day);

year (1-9999)

month (1-12)

day (1-31)

date.today()　　--返回一个表示当前本地日期的date对象

date.fromtimestamp(timestamp) --根据给定的时间戮，返回一个date对象

 

  View Code

 

　　　　date.year() 　　--取给定时间的年

　　　　date.month()　　--取时间对象的月

　　　　date.day()　　--取给定时间的日

date.replace()　　--生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性

date.timetuple()　　--返回日期对应的time.struct_time对象

date.weekday()　　--返回weekday,Monday == 0 ... Sunday == 6

date.isoweekday() --返回weekday,Monday == 1 ... Sunday == 7

date.ctime()　　　　--返回给定时间的字符串格式

1 2 3 4 5 6

import  datetime from  dateutil.relativedelta  import  relativedelta # 获取当前时间的前一个月 datetime.datetime.now()  -  relativedelta(months = + 1 ) # 获取当天的前一个月 datetime.date.today()  -  relativedelta(months = + 1 )

  View Code

• time 类

time类表示时间，由时、分、秒以及微秒组成

time.min（)　　--最小表示时间

time.max()　　--最大表示时间

time.resolution()　　--微秒

 

  View Code

 

• datetime类

datetime是date与time的结合体，包括date与time的全部信息

datetime.max()　　--最大值

datetime.min()　　--最小值

datetime.resolution() --datetime最小单位

datetime.today()　　--返回一个表示当前本地时间

datetime.fromtimestamp()　　--根据给定的时间戮，返回一个datetime对象

datetime.year()　　--取年

datetime.month()　　--取月

datetime.day()　　--取日期

datetime.replace()　　--替换时间

datetime.strptime()　　--将字符串转换成日期格式

datetime.time()　　--取给定日期时间的时间　　

  View Code

 

3.sys模块

   用于提供对解释器相关的访问及维护，并有很强的交互功能

经常使用函数：

sys.argv --传参，第一个参数为脚本名称即argv[0]

sys.path --模块搜索路径

sys.moudule --加载模块字典

sys.stdin　　--标准输入

sys.stdout　　--标准输出

sys.stderr　　--错误输出

sys.platform --返回系统平台名称

sys.version　　--查看python版本

sys.maxsize　　--最大的Int值

举例:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#传参
import sys

print(sys.argv[0])
print(sys.argv[1])
print(sys.argv[2])


##运行
python argv.py argv0 argv1
argv.py
argv0
argv1

 

  View Code

#sys.exit()系统返回值 

>>> import sys
>>> sys.exit(0)

C:\>echo %ERRORLEVEL%
0

#windows查看系统返回值命令
echo %ERRORLEVEL%
#linux查看系统返回值命令
echo $?

  View Code

  View Code

4.pickle模块

　　pickle，用于python特有的类型 和 python的数据类型间进行转换

 pickle模块提供了四个功能：dumps、dump、loads、load

Functions:

    dump(object, file)
    dumps(object) -> string
    load(file) -> object
    loads(string) -> object

pickle.dumps(obj)--把任意对象序列化成一个str，而后，把这个str写入文件
pickle.loads(string)　　--反序列化出对象
pickle.dump(obj,file)　　--直接把对象序列化后写入文件
pickle.load(file)　　--从文件中反序列化出对象

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pickle
accounts = {
    1000: {
        'name':'USERA',
        'email': 'lijie3721@126.com',
        'passwd': 'abc123',
        'balance': 15000,
        'phone': 13651054608,
        'bank_acc':{
            'ICBC':14324234,
            'CBC' : 235234,
            'ABC' : 35235423
        }
    },
    1001: {
        'name': 'USERB',
        'email': 'caixin@126.com',
        'passwd': 'abc145323',
        'balance': -15000,
        'phone': 1345635345,
        'bank_acc': {
            'ICBC': 4334343,
        }
    },
}
#把字典类型写入到文件中
f = open('accounts.db','wb')
f.write(pickle.dumps(accounts))
f.close()

#2，反序列出对象并修改其内容，并将修改内容从新写入文件
file_name = "accounts.db"
f = open(file_name,'rb')
account_dic = pickle.loads(f.read())
f.close()

account_dic[1000]['balance'] -= 500
f = open(file_name,'wb')
f.write(pickle.dumps(account_dic))
f.close()


#3,反序列化对象并查看其内容

f = open('accounts.db','rb')
acountdb = pickle.loads(f.read())
print(acountdb)

dic = {
    'k1': [1,2],
    'k2': [3,4]
}
#1.将对象写入文件
f = open('test','wb')
pickle.dump(dic,f)
f.close()
#2.将文件中内容反序列化，并读出
f = open('test','rb')
dic2 = pickle.load(f)
print(dic2)
f.close()

 

5.os模块

做用：

　　用于提供系统级别的操做

函数：　

 1 os.getcwd()                 获取当前工做目录，即当前python脚本工做的目录路径
 2 os.chdir("dirname")         改变当前脚本工做目录；至关于shell下cd
 3 os.curdir                   返回当前目录: ('.')
 4 os.pardir                   获取当前目录的父目录字符串名：('..')
 5 os.makedirs('dir1/dir2')    可生成多层递归目录
 6 os.removedirs('dirname1')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
 7 os.mkdir('dirname')         生成单级目录；至关于shell中mkdir dirname
 8 os.rmdir('dirname')         删除单级空目录，若目录不为空则没法删除，报错；至关于shell中rmdir dirname
 9 os.listdir('dirname')       列出指定目录下的全部文件和子目录，包括隐藏文件，并以列表方式打印
10 os.remove()                 删除一个文件
11 os.rename("oldname","new")  重命名文件/目录
12 os.stat('path/filename')    获取文件/目录信息
13 os.sep                      操做系统特定的路径分隔符，win下为"\\",Linux下为"/"
14 os.linesep                  当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
15 os.pathsep                  用于分割文件路径的字符串
16 os.name                     字符串指示当前使用平台。win->'nt'; Linux->'posix'
17 os.system("bash command")   运行shell命令，直接显示
18 os.environ                  获取系统环境变量
19 os.path.abspath(path)       返回path规范化的绝对路径
20 os.path.split(path)         将path分割成目录和文件名二元组返回
21 os.path.dirname(path)       返回path的目录。其实就是os.path.split(path)的第一个元素
22 os.path.basename(path)      返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
23 os.path.exists(path)        若是path存在，返回True；若是path不存在，返回False
24 os.path.isabs(path)         若是path是绝对路径，返回True
25 os.path.isfile(path)        若是path是一个存在的文件，返回True。不然返回False
26 os.path.isdir(path)         若是path是一个存在的目录，则返回True。不然返回False
27 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径以前的参数将被忽略
28 os.path.getatime(path)      返回path所指向的文件或者目录的最后存取时间
29 os.path.getmtime(path)      返回path所指向的文件或者目录的最后修改时间

6.hashlib模块

　　做用：

　　用于加密相关的操做，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法　

  View Code

　　加密算法缺陷，即：经过撞库能够反解。因此，有必要对加密算法中添加自定义key再来作加密

  View Code

　　7.random

　　做用：

　　生成随机变量

import random
 
print(random.random())
print(random.randint(1, 2))
print(random.randrange(1, 10))

import random
checkcode = ''
for i in range(4):
    current = random.randrange(0,4)
    if current != i:
        temp = chr(random.randint(65,90))
    else:
        temp = random.randint(0,9)
    checkcode += str(temp)
print checkcode

 

 

参考连接

https://i.cnblogs.com/EditPosts.aspx?opt=1

 

python 面向对象（进阶篇）

 

成员

类的成员能够分为三大类：字段、方法和属性

注：全部成员中，只有普通字段的内容保存对象中，即：根据此类建立了多少对象，在内存中就有多少个普通字段。而其余的成员，则都是保存在类中，即：不管对象的多少，在内存中只建立一份。

1、字段

字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不一样，

• 普通字段属于对象
• 静态字段属于类

  字段的定义和使用

由上述代码能够看出【普通字段须要经过对象来访问】【静态字段经过类访问】，在使用上能够看出普通字段和静态字段的归属是不一样的。其在内容的存储方式相似以下图：

由上图但是：

• 静态字段在内存中只保存一份
• 普通字段在每一个对象中都要保存一份

应用场景： 经过类建立对象时，若是每一个对象都具备相同的字段，那么就使用静态字段

2、方法

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不一样。

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

  方法的定义和使用

相同点：对于全部的方法而言，均属于类（非对象）中，因此，在内存中也只保存一份。

不一样点：方法调用者不一样、调用方法时自动传入的参数不一样。

3、属性　　

若是你已经了解Python类中的方法，那么属性就很是简单了，由于Python中的属性实际上是普通方法的变种。

对于属性，有如下三个知识点：

• 属性的基本使用
• 属性的两种定义方式

一、属性的基本使用

  属性的定义和使用

由属性的定义和调用要注意一下几点：

• 定义时，在普通方法的基础上添加 @property 装饰器；
• 定义时，属性仅有一个self参数
• 调用时，无需括号
             方法：foo_obj.func()
             属性：foo_obj.prop

注意：属性存在乎义是：访问属性时能够制造出和访问字段彻底相同的假象

        属性由方法变种而来，若是Python中没有属性，方法彻底能够代替其功能。

实例：对于主机列表页面，每次请求不可能把数据库中的全部内容都显示到页面上，而是经过分页的功能局部显示，因此在向数据库中请求数据时就要显示的指定获取从第m条到第n条的全部数据（即：limit m,n），这个分页的功能包括：

• 根据用户请求的当前页和总数据条数计算出 m 和 n
• 根据m 和 n 去数据库中请求数据 

  View Code

从上述可见，Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回。

二、属性的两种定义方式

属性的定义有两种方式：

• 装饰器 即：在方法上应用装饰器
• 静态字段 即：在类中定义值为property对象的静态字段

装饰器方式：在类的普通方法上应用@property装饰器

咱们知道Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 若是类继object，那么该类是新式类 ）
经典类，具备一种@property装饰器（如上一步实例）

# ############### 定义 ############### class Goods: @property def price(self): return "wupeiqi" # ############### 调用 ############### obj = Goods() result = obj.price # 自动执行 @property 修饰的 price 方法，并获取方法的返回值

新式类，具备三种@property装饰器

# ############### 定义 ############### class Goods(object): @property def price(self): print '@property' @price.setter def price(self, value): print '@price.setter' @price.deleter def price(self): print '@price.deleter' # ############### 调用 ############### obj = Goods() obj.price # 自动执行 @property 修饰的 price 方法，并获取方法的返回值  obj.price = 123 # 自动执行 @price.setter 修饰的 price 方法，并将 123 赋值给方法的参数 del obj.price # 自动执行 @price.deleter 修饰的 price 方法

 

注：经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
      新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法

因为新式类中具备三种访问方式，咱们能够根据他们几个属性的访问特色，分别将三个方法定义为对同一个属性：获取、修改、删除

class Goods(object): def __init__(self): # 原价 self.original_price = 100 # 折扣 self.discount = 0.8 @property def price(self): # 实际价格 = 原价 * 折扣 new_price = self.original_price * self.discount return new_price @price.setter def price(self, value): self.original_price = value @price.deltter def price(self, value): del self.original_price obj = Goods() obj.price # 获取商品价格 obj.price = 200 # 修改商品原价 del obj.price # 删除商品原价

静态字段方式，建立值为property对象的静态字段

当使用静态字段的方式建立属性时，经典类和新式类无区别

class Foo:

    def get_bar(self):
        return 'wupeiqi' BAR = property(get_bar) obj = Foo() reuslt = obj.BAR # 自动调用get_bar方法，并获取方法的返回值 print reuslt

property的构造方法中有个四个参数

• 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
• 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
• 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
• 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息

  View Code

 因为静态字段方式建立属性具备三种访问方式，咱们能够根据他们几个属性的访问特色，分别将三个方法定义为对同一个属性：获取、修改、删除

  实例

 注意：Python WEB框架 Django 的视图中 request.POST 就是使用的静态字段的方式建立的属性

  Django源码

因此，定义属性共有两种方式，分别是【装饰器】和【静态字段】，而【装饰器】方式针对经典类和新式类又有所不一样。

类成员的修饰符

类的全部成员在上一步骤中已经作了详细的介绍，对于每个类的成员而言都有两种形式：

• 公有成员，在任何地方都能访问
• 私有成员，只有在类的内部才能方法

私有成员和公有成员的定义不一样：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）

1 2 3 4 5

class  C:        def  __init__( self ):          self .name  =  '公有字段'          self .__foo  =  "私有字段"

私有成员和公有成员的访问限制不一样：

静态字段

• 公有静态字段：类能够访问；类内部能够访问；派生类中能够访问
• 私有静态字段：仅类内部能够访问；

  公有静态字段

  私有静态字段

普通字段

• 公有普通字段：对象能够访问；类内部能够访问；派生类中能够访问
• 私有普通字段：仅类内部能够访问；

ps：若是想要强制访问私有字段，能够经过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。

  公有字段

  私有字段

方法、属性的访问于上述方式类似，即：私有成员只能在类内部使用

ps：非要访问私有属性的话，能够经过 对象._类__属性名

类的特殊成员

上文介绍了Python的类成员以及成员修饰符，从而了解到类中有字段、方法和属性三大类成员，而且成员名前若是有两个下划线，则表示该成员是私有成员，私有成员只能由类内部调用。不管人或事物每每都有不按套路出牌的状况，Python的类成员也是如此，存在着一些具备特殊含义的成员，详情以下：

1. __doc__

　　表示类的描述信息

  View Code

2. __module__ 和  __class__ 

　　__module__ 表示当前操做的对象在那个模块

　　__class__     表示当前操做的对象的类是什么

  lib/aa.py

  index.py

3. __init__

　　构造方法，经过类建立对象时，自动触发执行。

  View Code

4. __del__

　　析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法通常无须定义，由于Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，由于此工做都是交给Python解释器来执行，因此，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

  View Code

5. __call__

　　对象后面加括号，触发执行。

注：构造方法的执行是由建立对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

  View Code

6. __dict__

　　类或对象中的全部成员

上文中咱们知道：类的普通字段属于对象；类中的静态字段和方法等属于类，即：

  View Code

 7. __str__

　　若是一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

  View Code

八、__getitem__、__setitem__、__delitem__

用于索引操做，如字典。以上分别表示获取、设置、删除数据

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#!/usr/bin/env python # -*- coding:utf-8 -*-   class  Foo( object ):        def  __getitem__( self , key):          print  '__getitem__' ,key        def  __setitem__( self , key, value):          print  '__setitem__' ,key,value        def  __delitem__( self , key):          print  '__delitem__' ,key     obj  =  Foo()   result  =  obj[ 'k1' ]       # 自动触发执行 __getitem__ obj[ 'k2' ]  =  'wupeiqi'    # 自动触发执行 __setitem__ del  obj[ 'k1' ]            # 自动触发执行 __delitem__

九、__getslice__、__setslice__、__delslice__

 该三个方法用于分片操做，如：列表

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#!/usr/bin/env python # -*- coding:utf-8 -*-   class  Foo( object ):        def  __getslice__( self , i, j):          print  '__getslice__' ,i,j        def  __setslice__( self , i, j, sequence):          print  '__setslice__' ,i,j        def  __delslice__( self , i, j):          print  '__delslice__' ,i,j   obj  =  Foo()   obj[ - 1 : 1 ]                    # 自动触发执行 __getslice__ obj[ 0 : 1 ]  =  [ 11 , 22 , 33 , 44 ]     # 自动触发执行 __setslice__ del  obj[ 0 : 2 ]                 # 自动触发执行 __delslice__

10. __iter__ 

用于迭代器，之因此列表、字典、元组能够进行for循环，是由于类型内部定义了 __iter__ 

  第一步

  第二步

  第三步

以上步骤能够看出，for循环迭代的实际上是  iter([11,22,33,44]) ，因此执行流程能够变动为：

1 2 3 4 5 6 7

#!/usr/bin/env python # -*- coding:utf-8 -*-   obj  =  iter ([ 11 , 22 , 33 , 44 ])   for  i  in  obj:      print  i

  For循环语法内部

11. __new__ 和 __metaclass__

阅读如下代码：

1 2 3 4 5 6

class  Foo( object ):        def  __init__( self ):          pass   obj  =  Foo()    # obj是经过Foo类实例化的对象

上述代码中，obj 是经过 Foo 类实例化的对象，其实，不只 obj 是一个对象，Foo类自己也是一个对象，由于在Python中一切事物都是对象。

若是按照一切事物都是对象的理论：obj对象是经过执行Foo类的构造方法建立，那么Foo类对象应该也是经过执行某个类的 构造方法 建立。

1 2	print  type (obj)  # 输出：<class '__main__.Foo'>     表示，obj 对象由Foo类建立 print  type (Foo)  # 输出：<type 'type'>              表示，Foo类对象由 type 类建立

因此，obj对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是经过type类的构造方法建立。

那么，建立类就能够有两种方式：

a). 普通方式

1 2 3 4

class  Foo( object ):        def  func( self ):          print  'hello wupeiqi'

b).特殊方式（type类的构造函数）

1 2 3 4 5 6 7

def  func( self ):      print  'hello wupeiqi'   Foo  =  type ( 'Foo' ,( object ,), { 'func' : func}) #type第一个参数：类名 #type第二个参数：当前类的基类 #type第三个参数：类的成员

＝＝》 类 是由 type 类实例化产生

那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的建立类？类又是如何建立对象？

答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化建立，因此，咱们能够为 __metaclass__ 设置一个type类的派生类，从而查看 类 建立的过程。

class MyType(type): def __init__(self, what, bases=None, dict=None): super(MyType, self).__init__(what, bases, dict) def __call__(self, *args, **kwargs): obj = self.__new__(self, *args, **kwargs) self.__init__(obj) class Foo(object): __metaclass__ = MyType def __init__(self, name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls, *args, **kwargs) # 第一阶段：解释器从上到下执行代码建立Foo类 # 第二阶段：经过Foo类建立obj对象 obj = Foo()

 

 

 

参考连接 

https://www.cnblogs.com/wupeiqi/p/4766801.html