8.16 学习笔记

# 斐波那契
# def fib(x):
#     if x==1 or x ==2:
#         return  1
#
#     return fib(x-1)+fib(x-2)
import re
# ret= re.findall('avvvv','adnsadjkalsjdklasjdlaksjdsad')
# print(ret)  #不要用group
#没匹配上则空
# ret=re.match('avvvv','adnsadjkalsjdklasjdlaksjdsad')
# print(ret.group())
# #没匹配上则报错
# ret=re.search('avvvv','duasoudlkasjdljasdia;klskmdas')
# print(ret.group())
# #没匹配上则报错
# ret=re.split('ab','abcdaba')  #分开的目标在两端自动加空  ‘’
# print(ret)
# ret=re.sub('cd','h','jinycdsdadcd')
# print(ret)
# ret=re.subn('cd','h','jinycdsdadcd')
# print(ret)   #返回替换后结果和次数
# obj=re.compile('\d{3}')   #数字加量词
# ret=obj.search('duasoudwqe3123123lkasjdljasdia;klskmdas')
# print(ret.group())   #匹配不到就报错
# ret=re.finditer('\d', 'ds3sy4784a')
# print(ret)                      #<callable_iterator object at 0x000001721CB32F28>
# print(next(ret).group())        #3
# print(next(ret).group())        #4
# print(next(ret).group())        #7
# print(next(ret).group())        #8
# for i in ret:
#     print(i.group())
# ret = re.search('^[1-9](\d{14})(\d{2}[0-9x])?$','110105199912122277')
# print(ret.group())
# print(ret.group(1))
# print(ret.group(2))
#正则笔记：[0-9a-fA-F]可行
# . 除了换行符的所有
# \w 匹配字母数字下划线 word   （大写代表非） a|b or
# \s 任意空白符 space  \d 数字 digit *$开始和结尾
# ()  匹配括号内表达式，一个组  【。。。】匹配字符组中的字符
# 【……。。。】匹配除了字符组字符的所有字符
# #量词 *0-无穷次 +1-无穷 ？0-1次 {n,m}重复n到m次
# ？在最后变为惰性匹配，[\d]任何一个数字 [\d]+ 匹配任意个数字
# #转义和r'\d'  匹配正常的转义字符
#1 findall的优先级查询：
# import re
# ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
# print(ret)  # ['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
# # 默认只返回组内的，叫优先级，在组内（）的一开始（？）即可
# ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
# print(ret)  # ['www.oldboy.com']
# ret=re.split("\d+","eva3egon4yuan")
# print(ret) #结果 ： ['eva', 'egon', 'yuan']
#
# ret=re.split("(\d+)","eva3egon4yuan")
# print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）之后所切出的结果是不同的，
#************没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，**************
#这个在某些需要保留匹配部分的使用过程是非常重要的。

#爬虫例子
'''
import re
from urllib.request import urlopen

def getPage(url):
    response = urlopen(url)
    return response.read().decode('utf-8')    #打开url 读取 decode

def parsePage(s):
    ret = re.findall(
        '<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?<span class="title">(?P<title>.*?)</span>'
       '.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)评价</span>',s,re.S)
    return ret

def main(num):
    url = 'https://movie.douban.com/top250?start=%s&filter=' % num
    response_html = getPage(url)
    ret = parsePage(response_html)
    print(ret)

count = 0
for i in range(10):   # 10页  #每行25个词条
    main(count)
    count += 25
'''

# url从网页上把代码搞下来
# bytes decode ——> utf-8 网页内容就是我的待匹配字符串
# ret = re.findall(正则，带匹配的字符串)  #ret是所有匹配到的内容组成的列表
# .*?abc 一直取遇到abc就停

# re模块
# import re
# re.findall('\d','awir17948jsdc',re.S)   #使用了flags
# 返回值：列表 列表中是所有匹配到的项
# flags有很多可选值：
#
# re.I(IGNORECASE)忽略大小写，括号内是完整的写法
# re.M(MULTILINE)多行模式，改变^和$的行为
# re.S(DOTALL)点可以匹配任意字符，包括换行符
# re.L(LOCALE)做本地化识别的匹配，表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境，不推荐使用
# re.U(UNICODE) 使用\w \W \s \S \d \D使用取决于unicode定义的字符属性。在python3中默认使用该flag
# re.X(VERBOSE)冗长模式，该模式下pattern字符串可以是多行的，忽略空白字符，并可以添加注释

# ret = search('\d(\w)+','awir17948jsdc'）
# ret = search('\d(?P<name>\w)+','awir17948jsdc'）  #为分组命名
# 找整个字符串，遇到匹配上的就返回，遇不到就None
# 如果有返回值ret.group()就可以取到值
# 取分组中的内容 ： ret.group(1)   /  ret.group('name')

# match
# 从头开始匹配，匹配上了就返回，匹配不上就是None
# 如果匹配上了 .group取值

# 分割 split
# 替换 sub 和 subn
# finditer 返回迭代器
# compile 编译 ：正则表达式很长且要多次使用

import re

# ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
# #还可以在分组中利用?<name>的形式给分组起名字
# #获取的匹配结果可以直接用group('名字')拿到对应的值
# print(ret.group('tag_name'))   #结果 ：h1
# print(ret.group())             #结果 ：<h1>hello</h1>

# ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
# #如果不给组起名字，也可以用\序号来找到对应的组，表示要找的内容和前面的组内容一致
# #获取的匹配结果可以直接用group(序号)拿到对应的值
# print(ret.group(1))
# print(ret.group())  #结果 ：<h1>hello</h1>
#匹配整数和小数
import re

# ret=re.findall(r"\d+\.\d+|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")  #匹配到小数：\d+\.\d  .前为转义字符，与r一起回归本意
# print(ret) #['1', '2', '60', '', '5', '4', '3']
# ret.remove('')
# print(ret) #['1', '2', '60', '5', '4', '3']
# ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
# print(ret) #['1', '-2', '60', '', '5', '-4', '3']
# ret.remove("")
# print(ret) #['1', '-2', '60', '5', '-4', '3']

# 首先得到一个字符串
# 去空格
# 没有空格的字符串
# 先算最里层括号里的 ： 找括号 ，且括号里没有其他括号
# 得到了一个没有括号的表达式 ：只有加减乘除 从左到右先找到第一个乘除法   —— 重复
# 所有的乘除法都做完了
# 计算加减  —— 加减法
# 只有一个数了 就可以结束了
# python中的数据类型：#列表、元祖
# #字典
# #集合、frozenset
# #字符串
# #堆栈 : 先进后出
# #队列 ：先进先出 FIFO

# from collections  import namedtuple   #命名式的元祖
# point=namedtuple('point',['x','y','z'])
# p1=point(1,2,3)       # point(x=1, y=2, z=3)
# print(p1)
# card=namedtuple('card',['type','number'])
# c1=card('red',5)
# print(c1)          #card(type='red', number=5)
#队列
# import queue
# q=queue.Queue()    #queue,Queue() 不能少
# q.put([1,2,3,9])
# q.put('gggdsf')
# q.put('ahusgdja')
# print(q.qsize())   #3
# print(q.get())  #[1,2,3,9]
# print(q.get())   #gggdsf
# print(q.get())    #ahusgdja
# print(q.qsize())   #0
#deque 双向可插入队列
# from collections import deque
# q = deque(['a', 'b', 'c'])
# q.append('y')
# q.appendleft('s')
# # q.pop()  #从右（后删除一个）
# q.popleft()   #从最前删除一个
# q.insert(2,'q')   #在2号位加入q
# print(q) #deque(['a', 'b', 'q', 'c', 'y'])
#有序字典
# from collections import OrderedDict     #O D 大写
# od=OrderedDict([('c',32),('b',122),('a',311)])
# print(od)  #顺序在定义的时候就确定了，首先一层函数执行外壳（），一层字典外壳【】，最后各个键值对之间用不变的（）分开，逗号分隔
# print(od['a'])  #311
# for i in od:    #c,b,a,与值无关，只认一开始的确定顺序
#     print(i)
#defaultdict
from collections import defaultdict
# values = [11, 22, 33,44,55,66,77,88,99,90]
# my_dict = defaultdict(list)
# for value in  values:
#     if value>66:
#         my_dict['k1'].append(value)
#     else:
#         my_dict['k2'].append(value)
# print(my_dict['k1'])

# defaultdict字典解决方法 以上 default_factory 接收一个工厂函数作为参数, 例如int str list set等.
#missing(key)方法, 在调用一个不存的key的时候, defaultdict会调用__missing__,
# 返回一个根据default_factory参数的默认值, 所以不会返回Keyerror.
#使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：
# from collections import defaultdict
# dd = defaultdict(lambda: 'N/A')
# dd['key1'] = 'abc'
# print(dd['key1'])  #abc
# print(dd['key2'])  #N/a
# #counter
# import collections
# c = collections.Counter('djasui ')  # 创建一个空的Counter类
# print(c) #Counter({'d': 1, 'j': 1, 'a': 1, 's': 1, 'u': 1, 'i': 1, ' ': 1})
#time模块
import time
# %y 两位数的年份表示（00-99）
# %Y 四位数的年份表示（000-9999）
# %m 月份（01-12）
# %d 月内中的一天（0-31）
# %H 24小时制小时数（0-23）
# %I 12小时制小时数（01-12）
# %M 分钟数（00=59）
# %S 秒（00-59）
# %a 本地简化星期名称
# %A 本地完整星期
# %b 本地简化月
# %B 完整月
# %c 日期和时期
# %j 一年内的第几天
# %p 本地A.M.或P.M.的等价符
# %U 一年中的星期数（00-53）星期天为星期的开始
# %w 星期（0-6），星期天为星期的开始
# %W 一年中的星期数（00-53）星期一为星期的开始
# %x 本地相应的日期表示
# %X 本地相应的时间表示*************************
# %Z 当前时区的名称

#时间戳
# print(time.time()) #1534428115.7940974
# #时间字符串
# print(time.strftime("%Y-%m-%d %X")) # 2018-08-16 22:02:26
# print(time.strftime("%Y-%m-%d %H-%M-%S")) # 2018-08-16 22-02-26
# print(time.strftime(r'%y/%m/%d   %H.%M.%S')) #18/08/16  22.07.11 时间用%x或者三个都要大写 小y只有年份后两位
# #时间元组:localtime将一个时间戳转换为当前时区的struct_time
# print(time.localtime())
# #time.struct_time(tm_year=2018, tm_mon=8, tm_mday=16, tm_hour=22, tm_min=3, tm_sec=58, tm_wday=3, tm_yday=228, tm_isdst=0)
# st=time.localtime()
# print(st)  #默认返回的为时间元祖
# print(st.tm_year) #2018 只选择显示年份
# print(st.tm_mon)  #8
import time
# 时间戳和结构化时间
# t = time.time()
# print(t)
# print(time.localtime(3000000000))
# print(time.gmtime(t))

# print(time.mktime(time.localtime()))

# print(time.strptime('2000-12.31','%Y-%m.%d'))
# print(time.strftime('%m/%d/%Y %H:%M:%S',time.localtime(3000000000)))

# print(time.asctime())
#时间戳-->结构化时间
print(time.gmtime(1500000000))  #从1970到现在的时间以默认方式输出
#结构化时间-->时间戳　
tmtuple=time.localtime(1500000000)
print(time.mktime(tmtuple))