python 对象使用

python对象使用

  1. 存储

    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
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    python的数据都保存在内存中,如果断电,内存中数据就会消失.另一方面,python程序运行结束,那么分配给这个程序的内存空间也会清空.为了长期持续存储,python将数据存储在磁盘中.磁盘以文件为单位来存储数据.对于计算机来说,数据本质就是有序的二进制序列,如果以字节为单位,也就是每8位二进制序列为单位,8位的二进制序列正好对应ASCII编码中的一个字符.python借助文本对象来读写文件.

    例如:
    f = open('test.txt','r')
    content = f.read(10)
    content = f.readline()
    content = f.readlines()
    f.close

    f = open('test.txt','w')
    f.write('I like apple\n')
    f.close

    文件操作常常和上下文管理器一起使用,上下文管理器用于规定某个对象的使用范围:一旦进入或者离开该使用范围,则会有特殊的操作被调用.
    例如:
    with open('test.txt','w') as f:
    f.write('hello world !')

    上下文管理器有隶属于它的程序块,当隶属于程序块执行结束时,上下文管理器就会自动关闭文件
    在使用上下文管理器语法时,python会在进入程序块前调用文件对象__enter__()方法,在结束程序块时调用文件对象__exit__()方法.

    自定义上下文管理器:
    class Vow(object):
    def __init__(self,text):
    self.text = text
    def __enter__(self):
    self.text = "I say: " + self.text
    return self
    def __exit__(self,exc_type,exc_value,traceback):
    self.text = self.text + "!"

    with Vow("I am fine") as MyVow:
    print(MyVow.text)

    print(MyVow.text)


    我们能把文本存于文件,但python中最常见的是对象,当程序结束或计算机关机时,这些存在于内存的对象会消失.利用pickle可以将对象保存下来,再存储到磁盘里的文件
    对象存储步骤:
    第一步,我们将对象在内存中的数据直接抓取出来,转换成一个有序的文本,即序列化
    第二步,将文本存入文件
    等到需要时,我们从文件中读出文本,再放入内存,就可以获得原有对象
    例如:
    import pickle
    class Bird(object):
    have_feather = True
    reproduction = 'egg'

    summer = Bird() #创建对象

    方式一:
    pickle_str = pickle.dumps(summer) #序列化对象,将对象转化为字符串形式
    with open('text.pkl','wb') as f: #将内容写入到文件
    f.write(pickle_str)

    方式二:
    with open('text.pkl','wb') as f:
    pickle.dumps(summer,f)

    对象读取步骤:
    第一步,从文件中读取文本
    第二步,将字符串形式的文本转换为对象(注意:在读取对象时,程序中必须已经定义过类)
    例如:
    import pickle
    class Bird(object):
    have_feather = True
    reproduction = 'egg'
    with open('text.pkl','r') as f:
    summer = pickle.loads(f)
    print(summer.reproduction)
  2. 时间

    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
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    python通过编程来管理时间和日期

    //time包
    例如:
    import time
    print(time.time()) #挂钟时间,单位是秒

    //测试程序运行时间
    import time
    start = time.clock()
    for i in range(1000):
    print(i**2)
    end = time.clock()
    print(end - start)
    注意: clock()在不同计算机上返回值会有所不同,unix系统上,返回的是处理器时间,windows则是挂钟时间

    //sleep()让程序休眠
    import time
    print('start')
    sleep(10)
    print('end')

    //struct_time对象
    import time
    st = time.gmtime() 返回struct_time的UTC时间
    st = time.localtime() 返回struct_time的当地时间
    s = time.mktime(st) 将struct_time转换为挂钟时间

    //datetime包
    datetime由data和time两部分组成:date是指年月日构成的日期,time是指时分秒毫秒构成的一天24小时具体时间
    datetime模块下面有两类: datetime.data和datetime.time类,你也可以调用datetime.datetime类
    例如:
    import datetime
    print(datetime.datetime(2017,6,2,10,5))

    a = datetime.datetime(2017,6,1,10,5)
    b = datetime.datetime(2017,7,10,10,5)
    c = datetime.timedelta(seconds = 600)
    d = datetime.timedelta(weeks = 3)
    print(a + c)
    print(b - d)
    print(a > b)

    //日期格式
    对于包含时间信息的字符串来说,我们可以借助datetime包,把它转换成datetime类的对象
    例如:
    from datetime import datetime
    str = 'output-2017-06-02-101400.txt'
    format = "output-%Y-%m-%d-%H%M%S.txt"
    t = datetime.strptime(str,format)
    print(t)

    将一个datetime对象转换为特定格式的字符串:
    from datetime import datetime
    format = "%Y-%m-%d %H%M%S"
    t = datetime(2017,6,2,10,15)
    print(t.strftime(format))
  3. 正则

    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
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    正则表达式的主要功能是从字符串中通过特定的模式,搜索希望找到的内容
    python中使用re来处理正则表达式
    例如:
    import re
    m = re.search("[0-9]","abcd4ef")
    print(m.group(0))

    正则搜索方法:
    m = re.search(pattern,string) #搜索整个字符串,直到发现符合的字符串为止
    m = re.match(pattern,string) #从头开始检查字符串是否符合正则表达式,字符串第一个字符必须符合正则

    正则搜索字符并替换:
    str = re.sub(pattern,replacement,string)

    常用正则:
    re.split() #根据正则表达式分割字符串,并将所有字符串放在一个list表中返回
    re.findall() #根据正则搜索字符串,将所有符合条件的子字符串放在一个list表中返回

    正则表达式:
    * . 任意一个字符
    * a|b 字符a或b
    * [abc] a或b或c一个字符
    * [0-4] 0-4范围内的一个字符
    * [a-f] a-f范围内的一个字符
    * [^m] 非m的一个字符
    * \s 一个空格
    * \S 一个非空格
    * \d 一个数字,等价于[0-9]
    * \D 一个非数字,等价于[^0-9]
    * \w 数字或字母,等价于[0-9a-zA-Z]
    * \W 非数字或字母,等价于[^0-9a-zA-Z]

    正则表示重复符号:
    * * 重复超过0次或更多次
    * + 重复1次或超过1次
    * ? 重复0次或1次
    * {m} 重复m次
    * {m,n} 重复m到n次

    正则位置相关符号:
    * ^ 字符串的起始位置
    * $ 字符串的结尾位置

    正则进一步提取
    * () 用括号()圈起来的正则是表达式的一部分,称为群.一个正则中可以有多个群
    例如:
    import re
    m = re.search("output_(\d{4})","output_2017.txt")
    print(m.group(1))

    m = re.search("output_(?P<year>\d{4})","output_2017.txt")
    print(m.group("year"))
  4. python http通信

    1
    2
    3
    4
    5
    6
    7
    8
    9
    python标准库中的http.client包可用于发出HTTP请求
    例如:
    import http.client
    conn = http.client.HTTPConnection('www.baidu.com')
    conn.request("GET","/")
    respone = conn.getresponse()
    print(response.status,response.reason)
    content = response.read()
    print(content)