from collections import namedtuple  #模块的导入，后面的将不再强调

Ponit = namedtuple('Ponit',['x','y','z'])

p = Ponit(1,2,5)

print(p.x)

print(p.y)

print(p.z)

# 双向队列

from collections import deque

deq = deque()

deq.append(12) #从右追加

deq.append(11)

deq.append(15)

print(deq)

deq.appendleft(10)  #从左追加

deq.appendleft(16)

print(deq)

deq.pop()  #从右取值

deq.pop()

print(deq)

deq.popleft()  #从左取值

deq.popleft()

print(deq)

deq.popleft()

# deq.popleft()  #取完后继续取会报错

print(deq)

from collections import Counter

c = Counter('abcdeabcdabcaba')

print(c)

print(c['a'])

from collections import Counter

#计数器的更新增加和减少

c = Counter('which')

print(c)

c.update('witch')

print(c)

c.update('watch')

print(c)

c.subtract('where')

print(c)

#键的删除

del c["h"]

print(c)

#返回一个迭代器

print(list(c.elements()))

#返回一个有序字典

print(c.most_common())  

#浅拷贝

c2 = c.copy()

print(c2)

#清空

c.clear()

print(c)

from collections import OrderedDict

d = dict([('a', 1),('b', 2),('c', 3)])

print(d)

o_d = OrderedDict([('a', 1), ('b', 2), ('c', 3)])

print(o_d)

od = OrderedDict()

od['z'] = 10

od['x'] = 10

od['y'] = 30

print(od)

print(od.keys())

x = {"k1":[],"k2":[]}

y = [11,22,33,44,55,66,77,88,99,90]

for i in y :

    if i > 66 :

        x["k1"].append(i)

    if i < 66:

        x["k2"].append(i)

print(x)

from collections import defaultdict

x = defaultdict(list)

y = [11, 22, 33,44,55,66,77,88,99,90]

for i in  y :

    if i > 66 :

        x['k1'].append(i)

    else :

        x['k2'].append(i)

print(x)

import re

ret = re.findall('a', 'eva egon yuan')

 # 返回所有满足匹配条件的结果,放在列表里

print(ret) #结果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()

print(ret) #结果 : 'a'

# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以

# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

ret = re.match('a', 'abc').group()  # 同search,不过尽在字符串开始处进行匹配

print(ret)

#结果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割

print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H'，参数1表示只替换1个

print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H'，返回元组(替换的结果,替换了多少次)

print(ret)

obj = re.compile('\d{3}')  #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字

ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串

print(ret.group())  #结果 ： 123

import re

ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器

print(ret)  # <callable_iterator object at 0x10195f940>

print(next(ret).group())  #查看第一个结果

print(next(ret).group())  #查看第二个结果

print([i.group() for i in ret])  #查看剩余的左右结果

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']

#在匹配部分加上（）之后所切出的结果是不同的，

#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，

#这个在某些需要保留匹配部分的使用过程是非常重要的。

while True:

    phone_number = input('please input your phone number ： ')

    if len(phone_number) == 11 \

            and phone_number.isdigit()\

            and (phone_number.startswith('') \

            or phone_number.startswith('') \

            or phone_number.startswith('') \

            or phone_number.startswith('') \

            or phone_number.startswith('')):

        print('是合法的手机号码')

    else:

        print('不是合法的手机号码')

import re

phone_number = input('please input your phone number ： ')

if re.match('^(13|14|15|17|18)[0-9]{9}$',phone_number):

        print('是合法的手机号码')

else:

        print('不是合法的手机号码')

不管以后你是不是去做python开发，只要你是一个程序员就应该了解正则表达式的基本使用。如果未来你要在爬虫领域发展，你就更应该好好学习这方面的知识。

但是你要知道，re模块本质上和正则表达式没有一毛钱的关系。re模块和正则表达式的关系 类似于 time模块（明天学习但是前面用过多次你应该有所了解）和时间的关系

你没有学习python之前，也不知道有一个time模块，但是你已经认识时间了 12:30就表示中午十二点半。

时间有自己的格式，年月日时分秒，12个月，365天......已经成为了一种规则。你也早就牢记于心了。time模块只不过是python提供给我们的可以方便我们操作时间的一个工具而已

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+","1-2*(60+(-40.35/5)-(-4*3))")

print(ret) #['1', '2', '60', '40', '35', '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']

import requests

import re

import json

def getPage(url):

    response=requests.get(url)

    return response.text

def parsePage(s):

    com=re.compile('<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>',re.S)

    ret=com.finditer(s)

    for i in ret:

        yield {

            "id":i.group("id"),

            "title":i.group("title"),

            "rating_num":i.group("rating_num"),

            "comment_num":i.group("comment_num"),

        }

def main(num):

    url='https://movie.douban.com/top250?start=%s&filter='%num

    response_html=getPage(url)

    ret=parsePage(response_html)

    print(ret)

    f=open("move_info7","a",encoding="utf8")

    for obj in ret:

        print(obj)

        data=json.dumps(obj,ensure_ascii=False)

        f.write(data+"\n")

if __name__ == '__main__':

    count=0

    for i in range(10):

        main(count)

        count+=25

import re

def func() :

    """简单输入判断"""

    while True :

        msg = input("请输入需要计算的表达式(q:退出)：").strip()

        if msg == "q" :  # 退出程序

            print("bye-bye")

            exit()

        elif len(msg) == 0 :  #输入空

            continue

        return msg.replace(" ","")  #去空格

def multiply_divide(msg):

    """

    乘除运算

    :param msg: 表达式

    :return: 返回计算结果

    """

    l = '\d+\.*\d*[\*\/]+[\+\-]?\d+\.*\d*'

    ret = re.search(l, msg)  # 匹配乘除号

    if not ret :  # 乘除号不存在，返回输入的表达式

        return msg

    calculate = re.search(l, msg).group()  # 匹配乘除号

    if '*' in calculate :  # 当可以用乘号分割，证明有乘法运算

        a,b = calculate.split('*')  # 以乘号作为分割符

        value = float(a) * float(b)  # 计算乘法

    else :

        a,b = calculate.split('/')  # 用除号分割

        if float(b) == 0 :  # 如果分母为0，则退出计算

            print("被除数为0！")

            exit()

        value = float(a) / float(b)  # 计算除法

    # 获取第一个匹配到的乘除计算结果value，将value放回原表达式

    a,b = re.split(l, msg, 1)  # 分割表达式

    msg = "{}{}{}".format(a,value,b)  # 将计算结果替换会表达式

    return multiply_divide(msg)  # 递归表达式

def add_subtract(msg):

    """

    加减运算

    :param msg: 表达式

    :return: 返回计算结果

    """

    l = '\d+\.*\d*[\+\-]{1}\d+\.*\d*'

    msg = msg.replace('+-', '-')  # 替换表达式里的所有'+-'

    msg = msg.replace('--', '+')

    msg = msg.replace('-+', '-')

    msg = msg.replace('++', '+')

    ret = re.search(l, msg)  # 匹配加减号

    if not ret :  # 如果不存在加减号，则证明表达式已计算完成，返回最终结果

        return msg

    ret = re.search(l, msg).group()

    if len(ret.split('+')) > 1 :  # 以加号分割成功，有加法计算

        a,b = ret.split('+')

        value = float(a) + float(b)  # 计算加法

    elif ret.startswith('-') :  # 如果是已'-'开头则需要单独计算

        a,b, part3 = ret.split('-')

        value = -float(b) - float(part3)  # 计算以负数开头的减法

    else:

        a,b = ret.split('-')

        value = float(a) - float(b)  # 计算减法

    a,b = re.split(l, msg, 1)  # 分割表达式

    msg = "{}{}{}".format(a,value,b)  # 将计算后的结果替换回表达式，生成下一个表达式

    return add_subtract(msg)  # 递归运算表达式

def del_bracket(msg):

    """

    小括号去除运算

    :param msg: 表达式

    :return: 返回计算结果

    """

    l = r'\([^()]+\)'

    if not re.search(l, msg) :  # 判断小括号，如果不存在小括号，直接调用乘除，加减计算

        ret1 = multiply_divide(msg)

        ret2 = add_subtract(ret1)

        return ret2  # 返回最终计算结果

    calculate = re.search(l, msg).group()  # 如果有小括号，匹配出优先级最高的小括号

    calculate = calculate.strip('[\(\)]')  # 剔除小括号

    ret1 = multiply_divide(calculate)  # 计算乘除

    ret2 = add_subtract(ret1)  # 计算加减

    a,b = re.split(l,msg,1)  # 将小括号计算结果替换回表达式

    msg = "{}{}{}".format(a,ret2,b)  # 生成新的表达式

    return del_bracket(msg)  # 递归去小括号

def get() :

    while True :

        msg = func()  # 获取到的表达式

        ret = del_bracket(msg)  # 用函数计算后得出的结果

        ret = float(ret)

        print("表达式计算结果：%s" % ret)

get()

#1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )

#此题有多种写法按个人理解