python学习5

- file
a.文件访问

open()将会返回一个file对象，基本语法：

open(filename,mode)

filename:是一个包含了访问的文件名称的路径字符串

mode:决定了打开文件的模式：只读，写入，追加等，默认文件访问模式为只读®

不同模式打开文件的列表：

r：以只读的方式打开文件，文件的指针将会放在文件的开头，为默认模式

rb：以二进制格式打开一个文件用于只读，文件指针会在文件的开头

r+：打开一个文件用于读写，文件指针将会在文件的开头

rb+：以二进制格式打开一个文件用于读写，文件指针会放在文件的开头

w：打开一个文件用于写入，如果该文件已存在则将会覆盖文件，如果不存在则创建新文件

wb：以二进制打开一个文件用于写入

w+：打开一个文件用于读写

wb+：以二进制格式打开一个文件用于读写，如果文件存在则覆盖，如果不存在则创建新文件

a：打开一个文件用于追加内容，如果文件已存在，文件指针会放在文件的结尾，如果不存在则创建新文件进行写入

ab：以二进制格式打开一个文件用于追加写入

a+：打开一个文件用于读写，如果该文件已存在，文件指针会放在结尾，文件打开时会是追加模式，该文件不存在则创建新文件

ab+：以二进制格式打开一个文件用于追加
b.文件对象操作方法
1,open() 打开文件

2,read()读取文件

readline()读取整行，包括“\n”字符

readlines()读取文件，最后把文件每行内容作为一个字符串放在一个list中

  注意:read系列函数的参数可以控制读取的字节数量

3,write()写文件，要传入一个字符串的参数

writelines()写文件，要传入一个列表

4,close() 关闭文件，关闭后不再进行读写操作

flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。

next(文件) 返回文件的下一行数据，从第一行数据开始

5,seek( )用于移动指定位置

  参数 offset—开始偏移量，也就是代表需要移动的字节数

      Whence---可选，默认值为 0。给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起

  注意:如果偏移是2的时候，偏移量的数必须要为复数

tell()返回文件当前位置

6，案例中要用到的标签库和一些关键字

1, Importcodecs 默认编码Unicode，这样会省去一些转换编码的事情

2, with用法,不需要用fd.close()关闭文件

with codecs.open(‘3.txt’,‘rb’) as fd:

    print fd.read()

• os模块

  os.sep:取代操作系统特定的路径分隔符

  os.name:指示你正在使用的工作平台。比如对于Windows，它是’nt’，而对于Linux/Unix 用户，它是’posix’。

  os.getcwd:得到当前工作目录，即当前python脚本工作的目录路径。

  os.getenv()和os.putenv:分别用来读取和设置环境变量

  os.listdir():返回指定目录下的所有文件和目录名

  os.remove(file):删除一个文件

  os.stat（file）:获得文件属性

  os.chmod(file):修改文件权限和时间戳

  os.mkdir(name):创建目录

  os.rmdir(name):删除目录

  os.removedirs（r“c：\python”）:删除多个目录

  os.system():运行shell命令

  os.exit():终止当前进程

  os.linesep:给出当前平台的行终止符。例如，Windows使用’\r\n’，Linux使用’\n’而Mac使 用’\r’

  os.path.split():返回一个路径的目录名和文件名

  os.path.isfile()和os.path.isdir()分别检验给出的路径是一个目录还是文件

  os.path.existe():检验给出的路径是否真的存在

  os.listdir(dirname):列出dirname下的目录和文件

  os.getcwd():获得当前工作目录

  os.curdir:返回当前目录（’.’）

  os.chdir(dirname):改变工作目录到dirname

  os.path.isdir(name):判断name是不是目录，不是目录就返回false

  os.path.isfile(name):判断name这个文件是否存在，不存在返回false

  os.path.exists(name):判断是否存在文件或目录name

  os.path.getsize(name):或得文件大小，如果name是目录返回0L

  os.path.abspath(name):获得绝对路径

  os.path.isabs():判断是否为绝对路径

  os.path.normpath(path):规范path字符串形式

  os.path.split(name):分割文件名与目录（事实上，如果你完全使用目录，它也会将最后一个目录作为文件名而分离，同时它不会判断文件或目录是否存在）

  os.path.splitext():分离文件名和扩展名

  os.path.join(path,name):连接目录与文件名或目录

  os.path.basename(path):返回文件名

  os.path.dirname(path):返回文件路径

• datetime模块
  datatime模块重新封装了time模块，提供更多接口，提供的类有：date,time,datetime,timedelta,tzinfo。

1、date类
datetime.date(year, month, day)

静态方法和字段

date.max、date.min：date对象所能表示的最大、最小日期；
date.resolution：date对象表示日期的最小单位。这里是天。
date.today()：返回一个表示当前本地日期的date对象；
date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；

date.max、date.min：date对象所能表示的最大、最小日期；
date.resolution：date对象表示日期的最小单位。这里是天。
date.today()：返回一个表示当前本地日期的date对象；
date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；

方法和属性

d1 = date(2011,06,03)#date对象
d1.year、date.month、date.day：年、月、日；
d1.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
d1.timetuple()：返回日期对应的time.struct_time对象；
d1.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
d1.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
d1.isocalendar()：返回格式如(year，month，day)的元组；
d1.isoformat()：返回格式如'YYYY-MM-DD’的字符串；
d1.strftime(fmt)：和time模块format相同。

2、time类
datetime.time(hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] )

静态方法和字段

time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)， time.max = time(23, 59, 59, 999999)；
time.resolution：时间的最小单位，这里是1微秒；
 

3、datetime类
datetime相当于date和time结合起来。
datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )

静态方法和字段

datetime.today()：返回一个表示当前本地时间的datetime对象；
datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
datetime.utcnow()：返回一个当前utc时间的datetime对象；#格林威治时间
datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息；
datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；
datetime.combine(date, time)：根据date和time，创建一个datetime对象；
datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；

方法和属性

dt=datetime.now()#datetime对象
dt.year、month、day、hour、minute、second、microsecond、tzinfo：
dt.date()：获取date对象；
dt.time()：获取time对象；
dt. replace ([ year[ , month[ , day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] ] ] ])：
dt. timetuple ()
dt. utctimetuple ()
dt. toordinal ()
dt. weekday ()
dt. isocalendar ()
dt. isoformat ([ sep] )
dt. ctime ()：返回一个日期时间的C格式字符串，等效于time.ctime(time.mktime(dt.timetuple()))；
dt. strftime (format)

4.timedelta类，时间加减
使用timedelta可以很方便的在日期上做天days，小时hour，分钟，秒，毫秒，微妙的时间计算，如果要计算月份则需要另外的办法。

#coding:utf-8
from  datetime import *

dt = datetime.now()
#日期减一天
dt1 = dt + timedelta(days=-1)#昨天
dt2 = dt - timedelta(days=1)#昨天
dt3 = dt + timedelta(days=1)#明天
delta_obj = dt3-dt
print type(delta_obj),delta_obj#<type 'datetime.timedelta'> 1 day, 0:00:00
print delta_obj.days ,delta_obj.total_seconds()#1 86400.0

5、tzinfo时区类

#! /usr/bin/python
# coding=utf-8

from datetime import datetime, tzinfo,timedelta

"""
tzinfo是关于时区信息的类
tzinfo是一个抽象类，所以不能直接被实例化
"""
class UTC(tzinfo):
    """UTC"""
    def __init__(self,offset = 0):
        self._offset = offset

    def utcoffset(self, dt):
        return timedelta(hours=self._offset)

    def tzname(self, dt):
        return "UTC +%s" % self._offset

    def dst(self, dt):
        return timedelta(hours=self._offset)

#北京时间
beijing = datetime(2011,11,11,0,0,0,tzinfo = UTC(8))
print "beijing time:",beijing
#曼谷时间
bangkok = datetime(2011,11,11,0,0,0,tzinfo = UTC(7))
print "bangkok time",bangkok
#北京时间转成曼谷时间
print "beijing-time to bangkok-time:",beijing.astimezone(UTC(7))

#计算时间差时也会考虑时区的问题
timespan = beijing - bangkok
print "时差:",timespan

#Output==================
# beijing time: 2011-11-11 00:00:00+08:00
# bangkok time 2011-11-11 00:00:00+07:00
# beijing-time to bangkok-time: 2011-11-10 23:00:00+07:00
# 时差: -1 day, 23:00:00

- 类和对象
感谢此位博主的分享，对我有很大的帮助
类 是对一群具有相同特征 或者行为的事物的一个统称。是抽象的，不能直接使用。
因此类的主要作用是表示某些特征和行为，在Python中
特征被称为属性
行为被称为方法
理解类和对象的关系
类好比制造飞机的图纸，对象好比飞机实例。需要注意的是类中有的属性和方法，在对象中也有，并且不能多也不能少
1. Python类的定义

	class 类名： #大驼峰命名发
	def 方法1（self ，参数列表）
	　　pass
	def 方法2（self ，参数列表）
　　	pass

2. Python类的结构
Class 类名: 成员变量（属性） 成员函数（方法）
3. 类的创建

	class MyClass():
   	 def fun(self): # self 是必须的
       	 print('I am fuction")

4. 类的属性
类由属性和方法组成，类的属性是对数据的封装，类的方法则是对类的行为的封装。类的属性按使用范围分为公有属性和私有属性，类的属性范围取决于属性的名称。
公有属性：类中和类外都可以调用的属性
私有属性：不能被类以外的函数调用，只能通过类的内部方法调用。（其实也可以通过instance.classname__attribute方式访问，但只用于调试程序）。定义方式：以"–"双下划线开始的成员变量就是私有属性，否则是共有属性。
内置属性：由系统在定义类的时候默认添加的，由前后两个下划线构成__dict_,module

#!/usr/bin/python
#coding:utf-8

name ='Jock' # 定义全局变量
class Ren(object): # 定义类，class Ren或者class Ren()都可以
    name = '人' # 定义公有属性
    __money = '我有十块钱' # 定义私有属性

    def run(self): # 定义方法（函数），必须要有一个形参，通常用self
        print('跑步')
        print(name) # 调用全局变量name='Jock'
        print(self.name) # 调用类属性name='人'

    def say(self):
        lie = "我很欣赏你" # 定义局部变量，注意这个不是类的公有属性
        print(self.__money) # 内部调用私有属性
        print(lie) # 调用局部变量

if __name__ == '__main__': # 直接调用则执行，被调用则不执行 
    zhangsan = Ren() # 实例化类，创建对象
    print(zhangsan.name) # 调用类的公有属性name='人’
    zhangsan.name='张三' # 对实例zhangsan的name属性重新赋值为'张三'
    print(zhangsan.name) # 输出>>>张三
    zhangsan.run() # 调用成员函数fun()
    zhangsan.say() # 调用成员函数say()
    print(zhangsan._Ren__money) # 另外一种访问私有属性的方式，仅在测试时使用
    print('#'*50)
    print(Ren.__dict__) # 调用内置属性'__dict__'

5. 类的方法
和函数定义一样，但需要self作为第一个参数。
类的方法也分为：公有方法和私有方法。
公有方法：只有实例化之后才能被调用。
私有方法：不能被外部的类和方法调用，私有方法的定义和私有属性定义都是一样的，在方法前面加上’__'双下划线就可以了；
类方法：被classmethod()函数处理过的函数，能被类所直接调用，也能被对象所调用（是继承关系）
静态方法：相当于"全局函数"，可以被类直接调用，可以被所有实例化对象共享，通过staticmethod()定义静态方法没有"self"语句；
self参数：用于区分函数和类的方法（必须有一个self)，self参数表示指向对象本身。

#!/usr/bin/python
#coding:utf-8

class Name():
    name = 'Jock'
    __money = '我有十块钱' # 定义私有属性
    __age = 24 # 定义私有属性

    def fun1(self): # 定义公有方法
        print(self.name)
        print('我是公有方法')
        #__fun2() # 直接调用__fun2会报错，提示NameError: name '_Name__fun2' is not defined
        self.__fun2() # 调用私有方法

    def __fun2(self): # 定义私有方法，只能在类定义里面被调用
        print(self.name)
        print('我是私有方法')

    def get(self,x): # 获取私有属性的值
        if x == 'money':
            return self.__money
        else:
            return self.__age

    def set(self,x): # 改变私有属性
        self.__age = x
    

    @classmethod # 装饰器，声明下面这个函数是动态方法，可以直接被类调用,这种方法最好
    def classFun(self): # 定义动态方法
        print(self.name)
        print('我是类方法')
    # 另外一种解决办法，使用classmethod()函数
    # classNewFun = classmethod(classFun)

    @staticmethod # 装饰器，声明下面这个函数是静态方法，可以直接被类调用，这种方法最好
    def staticFun(): # 不能有self，定义静态方法
        print(Name.name) # 需要通过Name.name调用类的name属性
        print('我是静态方法')
    # 另一种解决办法，使用staticmethod()函数
    # staticNewFun = staticmethod(staticFun)
"""
二者实际原理
动态方法是动态加载内部的属性和方法，现加载，节省空间，不过执行速度不如静态方法
静态方法是在执行前先加载静态方法的所有属性和方法，然后再执行，执行速度快，不过占用空间多
一般大数据才需要考虑资源空间效率问题
"""
print('#'*80)
tan = Name()
tan.fun1()
print('#'*80)
# Name.fun1 # 报错，因为公有方法必须实例化调用才行。类本身无法直接调用类自身的公有方法 
Name.classFun()
print('#'*80)
Name.staticFun()
print('#'*80)
print(tan.get('age')) 获取类的私有属性
print('#'*80)
tan.set(20) # 设置类的私有属性
print(tan._Name__age) # 测试，访问私有属性

- 对象
对象：是类的一个实例，比如：大卡车。类是把对象抽象化，对象是把类实例化。这个有点像哲学上上的个体和整体。当然个体还可以继续细分，这种就是一种分而治之和分类思想。

1. 对象的创建
   创建对象的过程称之为实例化；当一个对象被创建后，包含三个方面的特性：对象的句柄、属性、方法。
   1）句柄用于区分不同对象；
   2）对象对象的属性和方法与类中的成员变量和成员函数对应。
   注：还有继承、多态、析构函数、构造函数没有总结进去。