大家好，感觉好久没发博客了，今天也分享下自己的劳动成果吧！这是一个基于爬取租房信息的爬虫，代码比较简洁大方，如果您刚学习爬虫的话，不妨参考下哦，当然这对于大牛而言也没什么大不了的！代码中使用了多元表达式，如果您看不懂，欢迎留言！另外如果您有更好的爬取方式，欢迎分享！


#coding:utf-8

import requests,time

from bs4 import BeautifulSoup

url = [r'http://gz.xiaozhu.com/search-duanzufang-p{}-0/'.format(str(i)) for i in range(1,13+1)]

#urle = r'http://gz.xiaozhu.com/search-duanzufang-p1-0/'

headers = {

'Cookie':'abtest_ABTest4SearchDate=b; gr_user_id=85e9a01a-a0e4-4626-b3fa-bbebc1e43a8c; OZ_1U_2283=vid=v81756d34bb73d.0&ctime=1477924862&ltime=1477924861; OZ_1Y_2283=erefer=-&eurl=http%3A//m.xiaozhu.com/search.html%3Fcityid%3D16%26city%3D%2525E5%2525B9%2525BF%2525E5%2525B7%25259E%26offset%3D1%26step%3D15%26st%3D2016-10-31%26et%3D2016-11-01%26&etime=1477924563&ctime=1477924862&ltime=1477924861&compid=2283; xzuuid=aeacf51c; _gat_UA-33763849-7=1; __utmt=1; OZ_1U_2282=vid=v81732ffe11205.0&ctime=1477926800&ltime=1477926758; OZ_1Y_2282=erefer=https%3A//www.google.com.hk/&eurl=http%3A//www.xiaozhu.com/&etime=1477915390&ctime=1477926800&ltime=1477926758&compid=2282; _ga=GA1.2.1377836010.1477915392; __utma=29082403.1377836010.1477915392.1477915401.1477921654.2; __utmb=29082403.29.10.1477921654; __utmc=29082403; __utmz=29082403.1477915401.1.1.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=(not%20provided); startDate=2016-10-31; endDate=2016-11-01; gr_session_id_59a81cc7d8c04307ba183d331c373ef6=11901107-c72c-46d7-af6c-a78cc7f8bc82',

'User-Agent':'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36',

}

def Details_page(urlss):

web_data = requests.get(urlss)

soup = BeautifulSoup(web_data.text,'lxml')

title = soup.select('body > div.wrap.clearfix.con_bg > div.con_l > div.pho_info > h4 > em')

adders = soup.select('body > div.wrap.clearfix.con_bg > div.con_l > div.pho_info > p > span')

price = soup.select('#pricePart > div.day_l')

img = soup.select('#curBigImage')

hum_img = soup.select('#floatRightBox > div.js_box.clearfix > div.member_pic > a > img')

name = soup.select('#floatRightBox > div.js_box.clearfix > div.w_240 > h6 > a')

sexy = soup.select('#floatRightBox > div.js_box.clearfix > div.w_240 > h6 > span') #get class

for titles,adderss,prices,names,sexys,hum_imgs,imgs in zip(title,adders,price,name,sexy,hum_img,img):

print('标题：' + titles.get_text().strip())

print('地址：' + adderss.get_text().strip())

print('价格：'+ prices.get_text().strip() + ' 元/晚')

print('房东昵称：' + names.get_text().strip())

print('房东性别：' + ('空' if sexys.get('class')[0]== ''else ('男' if sexys.get('class')[0] == 'member_boy_ico' else '女') ))

print('主图链接地址：' + imgs.get('src'))

print('房东头像链接地址：' + hum_imgs.get('src').strip())

DownloadImage_File(hum_imgs.get('src').strip(),names.get_text().strip())


def channel(urls):

web_data = requests.get(urls,headers=headers)

time.sleep(2)

soup = BeautifulSoup(web_data.text,'lxml')

link = soup.select('#page_list > ul > li > a')

for i in link:

Details_page(i.get('href'))


def DownloadImage_File(img_Url,name):

Load_img = requests.get(img_Url, stream=True)

with open('D:/python工程/四周/01-02/img/'+ name + '.jpg', 'wb') as df:

for chunk in Load_img.iter_content(chunk_size=1024):

df.write(chunk)

df.flush()

for get_url in url:




channel(get_url)

此版本仍然作为预览版发布，当中也有不少bug，功能请自行尝试，暂时阉割掉腾讯视频，下个版本更新后修复！芒果TV播放电视剧可能会出现错误情况，请手动点击电视剧某集即可解决！如需播放中切换频道，应先点击暂停再进行切换，否则会反应很慢！

软件下载地址：http://d.nrfly.com/v/down.php?u=493077fe96df55650034ec2e406ab50c.undefined.zip

这是一只天气爬虫，本程序未调用天气网API，纯通过模拟浏览器登陆进行实时抓取天气讯息，目前已经实现全国各大城市的天气查询功能，因才刚开始学习爬虫，对正则与bs4还不熟悉，所以做起来好痛苦，如果大家有更方便、更高效的编写方式，欢迎提出建议哦！
如需获取全国各地的城市编号文件，请前往：http://bbs.fishc.com/forum.php?mod=viewthread&tid=74390&page=1&extra=#pid2622513 获取，不便之处请谅解！

代码如下：

#coding:utf-8
import requests,re,gzip
from bs4 import BeautifulSoup
import locale
import time
def searh(arg): #读取文件内容
    dict = {}
    with open('weatherdb.gd','r') as df:
        line = df.readlines()
        for i in line:
            if i !='\n':
                tem = i.strip().split('=')
                dict[tem[1]]=tem[0]
    if arg in dict:
        post_up(dict[arg])
    else:
        print('抱歉，没有找到您所在的城市，或者请确认您输入的城市正确！')
def post_up(arg):#通过识别字典的value传值给主域名进行精确的地址搜寻
    weather_url = 'http://www.weather.com.cn/weather/%s.shtml'%arg
    s = requests.session()
    herads = {
                 'Accept': 'text / html, application / xhtml + xml, application / xml;q = 0.9, image / webp, * / *;q = 0.8',
                 'Accept - Language':'zh - CN, zh;q = 0.8, zh - TW;q = 0.6',
                 'User - Agent': 'Mozilla / 5.0(Windows NT 10.0;WOW64) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 51.02704.103Safari / 537.36',
                'Accept-Encoding': 'gzip, deflate, sdch'
    }
    def ungzip(arg): #此函数用于解压经gzip压缩的网页
        try:
            print('尝试解压中.....')
            gzip.decompress(arg)
            gzip.open(arg)
            print('解压完毕！')
        except:
            print('未经压缩，无需解压')
        return arg
    data = s.get(weather_url, headers=herads)
    data.encoding='utf-8'
    sup_weather(data)
def sup_weather(arg): #主函数，解析网页并输出
    soup = BeautifulSoup(arg.text, "html.parser")
    fand = soup.find_all('div', class_="c7d")
    fand = BeautifulSoup(str(fand),"html.parser")
    feng = fand.find_all(id="hidden_title")
    fengxiang = fand.find_all('em')
    if str(fengxiang[0])[-57:-56] == '=':
        fengxiangs = str(fengxiang[0])[-55:-52]
    else:
        fengxiangs = str(fengxiang[0])[-57:-52]
    re_find = r'value="(.*)"'
    feng = re.findall(re_find,str(feng))
    see = soup.find_all('li')
    day = see[5]
    fengli = day.find_all('i')
    weathers = day.p.string
    fenglis = fengli[1].string
    data = str(see[12:30])
    data = BeautifulSoup(data,"html.parser")
    title_zishu = data.find_all('em')
    text_zizhu = data.find_all(('span'))
    cent_zishu = data.find_all('p')
    title = []
    text = []
    cent = []
    for i in range(0,10):
        if title_zishu[i].string != None:
            title.append(title_zishu[i].string)
        if '天空' not in text_zizhu[i].string:
            text.append(text_zizhu[i].string)
        cent.append(cent_zishu[i].string)
    locale.setlocale(locale.LC_CTYPE, 'chinese') #定义时间
    now = time.strftime("%Y年%m月%d日",time.localtime(time.time()))
    print('%s(今天)：%s的本日天气为:%s\n录得室外最高温度为：%s℃ 摄氏度，最低为：%s℃摄氏度\n风力：%s（%s）'% (now,send,weathers,str(feng)[-9:-7],str(feng)[-6:-4],fenglis,fengxiangs))
    print('以下是今天各项指数以及建议：')
    print('%s:(%s)建议：%s' %(title[0],text[0],cent[0]))
    print('%s:(%s)建议：%s' % (title[1], text[1], cent[1]))
    print('%s:(%s)建议：%s' % (title[2], text[2], cent[2]))
    print('%s:(%s)建议：%s' % (title[3], text[3], cent[3]))
    print('%s:(%s)建议：%s' % (title[4], text[4], cent[4]))
    print('%s:(%s)建议：%s' % (title[5], text[5], cent[5]))
print('欢迎使用全国天气查询服务！')
send = input('请输入您要查询的城市名称（精确到（市/县/直辖区）范围内）：')
searh(send)

貌似好久来博客囖，最近很忙，忙着学习、忙着工作、忙着吃饭.....O(∩_∩)O哈哈~忙够了，还是继续写小程序练手吧！今天带来的是一个检测密码深度的脚本，它有3个评定级别，当输入的密码低于8位时，程序会自动判定密码为弱密码，大于8位且低于16位数且密码包含了字母+数字 或者密码大于8低于16且密码包含数字或字母+特殊字符，则判定为中等级别同时给密码打印出2个星，如果密码超过16个字符且包含了数字、字母、特殊字符，则密码深度为高，并同时打印出3个星，注：本程序未调用正则等高级语法实现，所以看上去似乎比较笨重，几乎都是通过if.....else实现，感兴趣的朋友可以自己修改成您的方案，比如可以实现判断非空，因为用户可能会很调皮的直接不输入内容就想测试，如果此时有个文明的非空报错，看起来也会很不错！好啦，那么下面就该贴上代码啦！



__author__ = 'acer'
#coding: utf-8
tem = r'''~!@#$%^&*()_=-/,.?<>;:[]{}|\\'''
def Ad_pass(ps,flog):
if (len(ps) <= 8) :
flog = '低☆☆☆'
print('您的密码安全系数较：%s\n请以以下方式提升您的密码安全级别：'%flog)
print(' 1.密码必须由数字、字母及特殊字符三种组合')
print(' 2.密码只能由字母开头')
print(' 3.密码长度不能低于8位')
print("当前的密码长度为：%d" % len(ps))
else:
for i in tem:
if i in ps:
if len(ps) <= 16 or (len(ps) <= 16 and ps.isalnum() == False):
flog = '中★★☆'
print('您的密码安全系数较：%s\n请以以下方式提升您的密码安全级别：' % flog)
print(' 1.密码必须由数字、字母及特殊字符三种组合')
print(' 2.密码只能由字母开头')
print(' 3.密码长度不能低于8位')
print("当前的密码长度为：%d"%len(ps))
break
elif (len(ps) > 16) and (ps.isalnum() == False):
flog = '高★★★'
print('您的密码安全系数较：%s\n请以以下方式提升您的密码安全级别：' % flog)
print('请继续保持！')
print("当前的密码长度为：%d" % len(ps))
break
else:
if len(ps) <= 16 or (len(ps) <= 16 and ps.isalnum() == False):
flog = '中★★☆'
print('您的密码安全系数较：%s\n请以以下方式提升您的密码安全级别：' % flog)
print(' 1.密码必须由数字、字母及特殊字符三种组合')
print(' 2.密码只能由字母开头')
print(' 3.密码长度不能低于8位')
print("当前的密码长度为：%d" % len(ps))
break
while True:
tab_inp = input('请输入需要检查的密码组合：')
Ad_pass(tab_inp, True)
choose = input('按Q退出本程序，否则请按回车键继续：').upper()
if choose == 'Q':
break

   经过多日的实战，总算实现了模糊搜寻功能，开发的阶段也即将进入高潮，虽说当中感觉挺累的，但回过头来看看今天的成果，觉得一切都值得的，其实编程无非用来用去就那么几个函数，用多了自然就熟悉了，想要成就一身本事，光靠看是不够滴，还是得多动手！那么接下来就来讲解下本次更新的内容吧！

   继上次更新完登录环节那部分后，我再次进行了调整，将登录部分完完全全的阉割到函数里面，可以看到，我的主程序启动后，仅仅只用了几行代码，因为真正运作的是背后的函数，这些函数经过无数遍的修改，至今尚有不足之处，可谓是bug连连，那么本次更新的是模糊查询，因为才刚刚学python不久，还没接触数据库，所以我以文本形式将数据写入，然后当用户调用时只需输入要查找的信息的其中一个字符，即可立即显示出来，而此查找的操作得益于re模块，调用了findall函数进行模糊查询，只要找到的内容与用户输入的有关便会将其加入到result里，而为了使打印的效果看起来不那么的僵硬，我还调用了控制台专用的表格函数pylsy，打印出来的效果虽说不是什么高大上，但看起来还是蛮不错的啦，pylsy需要通过pip安装，可以直接在终端输入pip install pylsy,别跟我说你连这个都不知道....

那么接下来的几天，我会继续完成：1，将用户搜寻返回后的相关信息高亮展示，2，继续完善修改用户、自定义增加用户，删除用户等功能。3.因为这个项目纯粹为了练手，所以难免会后期添加或扩展新的功能，但我都会一一列于本博客，4.如果可以，我将会把所有的用户信息进行加密处理，也就是说用户打开、增加用户都将通过加密/解密的操作，当然这一系列操作都由后台完成。5.将（或）提供扩展支持，读取大量用户数据，如果您有一个很大的数据文件，那么你可以将内容导入到程序中进行解析。

大话就先说到这吧，那么下次再见啦！大家有更好的思路或者学习的方式欢迎留言交谈！也希望大家留下你们宝贵的意见。

#coding: utf-8
__author__ = 'Naruto'
import re
from pylsy import pylsytable
def rigster(flog): #用于注册\登录时输入账号密码，参数flog用于判断登录或注册n为登录y为注册
us = input("请输入您的账号：")
ps = input("请输入您的密码：")
check_acount(us,ps,flog) #将参数传给check_acount
def check_acount(arg,pw,flog): #判断用户是否存在或写入配置
num = 0 #用于增量，配置文件第一行用于标识信息，从第二行才开始遍历内容
account = "用户：%s 密码：%s" % (arg, pw) #将用户密码赋于account
dict={} #用于接收切割后的用户信息
with open('Eycheck.conf', 'a+') as df: #加载本地配置文件，并以读写形式追加
df.seek(0) #将文本指针指向0，表示从头开始遍历
line = df.readlines() #遍历文件内容并赋值给line
if line != '': #非空执行下面的代码
for i in line: #通过for循环将line的变量分别赋值给 i
num+=1 #增量
if num >=2: #从第二行开始遍历
user,psd =i.strip('\n').split() #将文本分割为 用户名：admin 密码：admin 的形式
dict[user[3:]]=psd[3:] #通过分片截取冒号以后的字符，也就是账号密码的值，并以key:value形式写入到字典中
for k,v in dict.items(): #用for循环分别将字典的键值写入到k,v
if arg == k and pw == dict[k]: #通过传入的参数(即用户信息)与字典的键值进行动态配对
if flog == "n": #判断登录或注册，n为登录
print("登录成功！")
return True
elif flog =="y": #判断登录或注册，y为注册
print("该用户已存在于数据库中，请直接登录！")
rigster("n")
elif arg ==k and pw != dict[k]:
if flog == "n": #判断登录或注册，n为登录
print("您输入的账号与密码不符")
rigster('n')
elif flog == "y": #判断登录或注册，y为注册
print("该用户名已被占用，请更换！")
rigster('y')
if arg not in dict: #通过上面的配对后都没有找到的情况下进行非操作，如为登录状态则返回该用户不存在，反之则将新用户写入到配置文本
if flog == 'n': #判断登录或注册，n为登录
print("该用户不存在，请重新输入！")
elif flog == 'y': #判断登录或注册，y为注册
df.write('\n' + account) # 如用户名不存在字典中则创建并返回成功！
print('账户创建完毕')
else: #当配置文件为空时写入配置信息
df.write('#===========这里是系统配置文件，请勿随意修改===========#\n' + account)
print("配置与用户信息写入完毕")
def start(): #加载启动的函数
choose = input("是否初次使用本系统？ y|n:")
if choose == 'y':
rigster('y')
elif choose == 'n':
rigster('n')
def choose_Box(arg): #用于查询并显示用户信息
attributes = ['姓名', '年龄', '性别', '联系方式']
table = pylsytable(attributes)
tem = []
tem2 = []
tem3 = []
tem4 = []
if arg == 'A':
UserName = input("请输入您要查询的用户名字，（直接输入您要查找的信息的首写字母即可）：")
with open("information.dat", 'a+') as df:
df.seek(0)
line = df.read()
tofind = re.escape(UserName)
result = re.findall('.*' + tofind + '.*',line)
for line in result:
name, age, sex, cons = line.strip('\n').split()
tem.append(name[3:])
tem2.append(age[3:])
tem3.append(sex[3:])
tem4.append(cons[5:])
table.add_data('姓名', tem)
table.add_data('年龄', tem2)
table.add_data('性别', tem3)
table.add_data('联系方式', tem4)
print(table)

#=============================================主程序启动=================================================#
if __name__== "__main__": #判断是否为主文件执行
start()
print("欢迎使用Eyinfo个人信息查询系统，文明使用，请勿将他人信息公开")
choose = input("接下来你是想（A.查询用户 B.修改用户信息 C.添加用户信息 D.删除用户信息：）")
if choose == 'A':
choose_Box('A')
elif choose == 'B':
choose_Box('B')
elif choose == 'C':
choose_Box('C')
elif choose == 'D':
choose_Box('D')
else:
print("对不起，您的输入有误，请重新输入！")

时隔了几天，我终于实现了注册与登录这部分的功能，实现过程我都一一标上了注解，虽然看上去这里的代码并不多，但其实我已经写了几天啦，在经过不断反复的调试后终于实现了一函两用，这也应验了编程界的一句话：“没有做不到只有想不到”，这些方法虽看上去简单，但其实真正实践起来时并没有想象中的容易呢，或许可能是我的智商低吧，逻辑一直转不过弯，如果大家有更好的方式，也欢迎大家一起来交流！

#coding: utf-8
__author__ = 'Naruto'
def rigster(flog): #用于注册\登录时输入账号密码，参数flog用于判断登录或注册n为登录y为注册
us = input("请输入您的账号：")
ps = input("请输入您的密码：")
check_acount(us,ps,flog) #将参数传给check_acount
def check_acount(arg,pw,flog): #判断用户是否存在或写入配置
num = 0 #用于增量，配置文件第一行用于标识信息，从第二行才开始遍历内容
account = "用户：%s 密码：%s" % (arg, pw) #将用户密码赋于account
dict={} #用于接收切割后的用户信息
with open('Eycheck.conf', 'a+') as df: #加载本地配置文件，并以读写形式追加
df.seek(0) #将文本指针指向0，表示从头开始遍历
line = df.readlines() #遍历文件内容并赋值给line
if line != '': #非空执行下面的代码
for i in line: #通过for循环将line的变量分别赋值给 i
num+=1 #增量
if num >=2: #从第二行开始遍历
user,psd =i.strip('\n').split() #将文本分割为 用户名：admin 密码：admin 的形式
dict[user[3:]]=psd[3:] #通过分片截取冒号以后的字符，也就是账号密码的值，并以key:value形式写入到字典中
for k,v in dict.items(): #用for循环分别将字典的键值写入到k,v
if arg == k and pw == dict[k]: #通过传入的参数(即用户信息)与字典的键值进行动态配对
if flog == "n": #判断登录或注册，n为登录
print("登录成功！")
return True
elif flog =="y": #判断登录或注册，y为注册
print("该用户已存在于数据库中，请直接登录！")
rigster("n")
elif arg ==k and pw != dict[k]:
if flog == "n": #判断登录或注册，n为登录
print("您输入的账号与密码不符")
rigster('n')
elif flog == "y": #判断登录或注册，y为注册
print("该用户名已被占用，请更换！")
rigster('y')
if arg not in dict: #通过上面的配对后都没有找到的情况下进行非操作，如为登录状态则返回该用户不存在，反之则将新用户写入到配置文本
if flog == 'n': #判断登录或注册，n为登录
print("该用户不存在，请重新输入！")
elif flog == 'y': #判断登录或注册，y为注册
df.write('\n' + account) # 如用户名不存在字典中则创建并返回成功！
print('账户创建完毕')
else: #当配置文件为空时写入配置信息
df.write('#===========这里是系统配置文件，请勿随意修改===========#\n' + account)
print("配置与用户信息写入完毕")
def start(): #加载启动的函数
choose = input("是否初次使用本系统？ y|n:")
if choose == 'y':
rigster('y')
elif choose == 'n':
rigster('n')
#=============================================主程序启动=================================================#
if __name__== "__main__": #判断是否为主文件执行
start()

记得上个月给自己托付了2个任务，一个是编写一个购物车系统，另一个则是本次的个人资料查询系统，由于懒惰的关系，迟迟未能动手，今天心血来潮，便开始着手这个项目了，当然说了是个查询的系统，我追求的是完美，所以是不可能在一天内完成的，在博客中大家可以一同见证我开发这个项目的全过程，如果可以我希望能给大家带来帮助，同时我也很乐意与志同道合的朋友一起交流与学习，如果您也有兴趣，不妨一起研究探讨，将项目做得更完美，虽然这个系统仅仅只是一个作业，但对于我而言无疑就是一块冲向成功的垫脚石。
下面来介绍下这个系统的详细运作流程吧！
和购物车一样，这个查询系统也有登录的一环，但与购物车不一样的是，这次为了精简代码，我决定把反复要求用户输入账户密码的操作封装到了一个函数内，而check_aconut则用于判断用户名是否存在，存在则要求直接登录，否则将用户信息写入到配置文件Eycheck.conf里，当用户启动程序后，系统调用register函数当用户输入完账号密码后将按照选择的choose进行反馈，登录成功后将会调用到check_info函数进行个人信息查询，check_info函数主要实现模糊遍历、数据将以字典形式存储于Ey_information.ini中，当用户输入关键字后，函数会字典寻找与关键字相符的数据并以红色标明后展示给用户。（待续....）


#coding: utf-8
__author__ = 'Naruto'
def register(): #注册/登陆
us = raw_input("请输入您的账号：")
pad = raw_input("请输入您的密码：")
check_acount(us, pad)
def check_acount(arg,pw): #判断用户是否存在或写入配置
account = "用户：%s 密码：%s" % (arg, pw)
num = 0
with open('Eycheck.conf', 'a+') as df:
for i in df:
num += 1
if num == 2:
user, paw = i.strip('\n').split()
if user == arg[9:] and paw == pw[9:]:
return 'Error_Exist'
elif arg[9:] == '' and paw[9:] == '':
df.write('===========这里是系统配置文件，请勿随意修改===========\n' + account)
else:
df.write('\n' + account)


if __name__== "__main__":
while True:
choose = raw_input("是否初次使用本系统？ y|n:")
if choose == 'y':
df = register()
if df == 'Error_Exist':
print "您的账户已存在数据库中，请直接登陆！"
break
else:
print "账户创建完毕."
break

elif choose == 'n':
bf = register()
if bf == 'Error_Exist':
print "系统登陆成功."
break
else:
print "您的账号或密码不符，请重新输入！"
break

else:
print "您的输入有误，请重新输入！"

注：本文仅供参，以上源代码仅仅是本人的开发思路，值得探讨的是，登录函数的调用，我暂时未能找到调用的方式现在使用的调用方式无疑是错误的，不知什么原因程序只走到for i in df处就直接跳转至check_acount(arg,pad)了下面的代码并未执行导致判断写入的语句失效，如您有更好的方法或建议，欢迎与我交流！

经过反反复复的修改，最后我还是post了一个未完成的作品，当中的逻辑真的乱得一塌糊涂


下面就来简单介绍下它的结构吧，当购物车程序启动后系统会询问用户是否为第一次使用，


如果为第一次使用则要求用户注册，否则将直接进入登录流程，用户的信息保存在login.ini


这个配置文件当中，登录时系统会通过分片截取方式捕获文件里的内容是否与用户输入的


相同，不同则要求重新输入，成功登录后系统会要求用户充值钱包，钱包充值函调用了非


数字判断，只要用户输入的内容不是数字就会要求重新输入，充值完毕后将进入商城，用


户可以选择性购买商品，购买完毕后选择Q进入购物车结算.....


好吧，购物车还未完成，当中的逻辑实在是太乱了，我需要重新整理思路再次重写，当然


我也很期待有大神可以给点建议，因为这个购物车全是凭自己所掌握的知识开发的，未曾


参阅过任何文档、源码，作为一个自学的菜鸡，我还有很多知识需要普及，如果您也喜欢


python，欢迎一起交流，本购物车程序将会不断完善下去，我也会不断地发布新的文章


与大家一起分享学习的心得，也希望能从中把自己的知识水平提升到更高的级别！



# ===============以下为源码===============#



#coding: utf-8
__author__ = 'By Naruto'
from prettytable import PrettyTable
import sys,os
import getpass,time
# ===============主要函数===============#
def register(us,ps): #register函数
while True:
new_pasd_again = raw_input("请再次输入您要创建的密码：")
if new_pasd_again <> ps:
print '您两次输入的密码不符，请重新输入！'
else:
break
account = "用户：%s 密码：%s"%(us,ps)
with open('login.ini','a+') as df:
if df == '':
df.write('===========这里是系统配置文件，请勿随意修改===========\n'+ account)
print "信息保存成功 ,请登录您的账户！"
print '请重新登录您的账户！'
else:
df.write('\n'+ account)
print "信息保存成功,请登录您的账户！"
print '请重新登录您的账户！'
def login(us,ps): #到文件判断用户输入的账号密码是否正确函数
num = 0
with open('login.ini','r')as f:
for i in f:
num+=1
if num ==2:
user, psd = i.strip('\n').split()
if us == user[9:] and ps ==psd[9:]:
return 'Y'
else:
return 'N'
def login2(usd,psb): #登录函数
user_name = raw_input("请输入您的用户名：")
user_pasd = raw_input("请输入您的密码：")
rs = login(user_name,user_pasd)
if rs =='Y':
return 'True'
else:
return 'Felse'
def bank_money(num): #钱包充值函数
if num.isdigit():
return True
else:
return False
def shop_stoye(**arg): #商品展示函数
nu = ['A.', 'B.', 'C.','Q']
shop = ['mp3===》300RMB','mp4===》500RMB','iphone===》3000RMB','到购物车结算']
for k,v in enumerate(shop):
print nu[k],v
def Choose_shop(arg): #选择商品或进入购物车
if arg == 'A':
return 300
elif arg == 'B':
return 500
elif arg == 'C':
return 3000
elif arg =='Q':
return 'go'
else:
return 'Error'
# ===============主函数启动===============#
if __name__ == "__main__":
us_up = ""
psd_up = ''
i = 2
flog = True
while i >= 0: #进入购物车只有3次机会，选择y执行注册函数，n则直接执行登录
ask_question = raw_input("您是第一次使用本购物车系统吗？ y|n:")
if ask_question == 'y':
new_name = raw_input("请输入您要注册的用户名：")
new_pasd = raw_input("请输入您要注册的密码：")
register(new_name, new_pasd)
login2(us_up, psd_up)
bank_money()
elif ask_question == 'n':
while flog == True:
bs = login2(us_up, psd_up)
if bs == 'True': #登录完毕后系统会要求用户输入充值金额
print '首次使用请先充值钱包！'
while True:
bank_Money = raw_input("请输入您要充值的金额：")
temp = bank_money(bank_Money)
if temp == True: #充值完毕后方可展示商品
print '充值完毕，您当前余额为：%s RMB' % int(bank_Money)
print '欢迎光临幕尼贺锡城，我们目前有以下商品正在出售！'
shop_stoye()
bankmoney1 = {}
while True:
choose = raw_input('请选择您要购买的商品：')
chose = Choose_shop(choose)
if chose == 300:
bankmoney1['mp3'] = 300
print 'MP3已成功加入购物车.'
continue
elif chose == 500:
bankmoney1['mp4'] = 500
print 'MP4已成功加入购物车.'
continue
elif chose == 3000:
bankmoney1['ipone'] = 3000
print 'iphone已成功加入购物车.'
continue
elif chose == 'go':
break
elif chose == 'Error':
print '您的输入有误，请重新输入！'
print ("您目前在本购物车添加了以下商品：") #选择Q后会进入购物车，并打印显示商品总价与当前余额
abc = 0
for key in bankmoney1:
print "品名：%s 价格%s" % (key, bankmoney1[key])
abc += bankmoney1[key]
print "总计：%d元，您的钱包有%d元" % (int(abc), int(bank_Money))
sum = raw_input('您要现在结账吗？ y|n:')
bank_sum = 0
if sum == 'y':
bank_sum = int(bank_Money) - int(abc)
print '结算完毕，您的账户还剩%s元。'%bank_sum

elif sum == 'n':
continue
else:
print '请输入正确的金额！'
flog = False
else:
print "登录失败，您输入的账号或密码错误！"
else:
print "抱歉，您的输入有误，请输入 (y|n)您还有%s次机会。"%i
i -= 1
sys.exit()

#coding: utf-8__author__ = 'By Naruto'from prettytable import PrettyTable
import sys,os
import getpass,time
#register函数def register(us,ps):
    while True:
        new_pasd_again = raw_input("请再次输入您要创建的密码：")
        if new_pasd_again <> ps:
            print '您两次输入的密码不符，请重新输入！'        else:
            break    account = "用户：%s 密码：%s"%(us,ps)
    with open('login.ini','a+') as df:
        if df == '':
            df.write('===========这里是系统配置文件，请勿随意修改===========\n'+ account)
            print "信息保存成功,请登录您的账户！"            print '请重新登录您的账户！'        else:
            df.write('\n'+ account)
            print "信息保存成功,请登录您的账户！"            print '请重新登录您的账户！'def login(us,ps):
    num = 0    with open('login.ini','r')as f:
        for i in f:
            num+=1            if num ==2:
                user, psd = i.strip('\n').split()
                if us == user[9:] and ps ==psd[9:]:
                    return 'Y'                else:
                    return 'N'def login2(usd,psb):
    user_name = raw_input("请输入您的用户名：")
    user_pasd = raw_input("请输入您的密码：")
    rs = login(user_name,user_pasd)
    if rs =='Y':
        return 'True'    else:
        return 'Felse'def bank_money(num):
    bank_Money_num = 0    while True:
        if num.isdigit():
            num=int(num)
            return num
            break        else:
            print '请输入正确的金额'def shop_stoye(**arg):
    nu = ['A.', 'B.', 'C.']
    shop = ['mp3===》300RMB','mp4===》500RMB','iphone===》3000RMB']
    for k,v in enumerate(shop):
        print  nu[k],v
def Choose_shop(arg):
    if arg == 'A':
        return 300    elif arg == 'B':
        return 500    elif arg == 'C':
        return 3000    elif arg =='Q':
        return 'go'    else:
        print '程序发生未知的错误，正在结束本程序，欢迎再次使用，谢谢！'
# ==================================主程序启动========================================#
if __name__ == "__main__":
    us_up = ""    psd_up = ''    ask_question = raw_input("您是第一次使用本购物车系统吗？ y|n:")
    if ask_question == 'y':
        new_name = raw_input("请输入您要注册的用户名：")
        new_pasd = raw_input("请输入您要注册的密码：")
        register(new_name,new_pasd)
        login2(us_up,psd_up)
        bank_money()
    elif ask_question =='n':
        while True:
            bs = login2(us_up, psd_up)
            if bs == 'True':
                print '首次使用请先充值钱包！'                bank_Money = raw_input("请输入您要充值的金额：")
                temp = bank_money(bank_Money)
                print '充值完毕，您当前余额为：%d RMB' % temp
                print '欢迎光临幕尼贺锡城，我们目前有以下商品正在出售！'                shop_stoye()
                break            else:
                print '您输入的账号或与当前密码不符，请重新输入！'else:
    print "抱歉，系统已崩溃，请重新启动程序，为您带来的不便还望海涵。"while True:
    choose = raw_input('请选择您要购买的商品：')
    chose = Choose_shop(choose)
    bankmoney1 = []
    if chose == 300:
        bankmoney1.append('300')
        print 'MP3已成功加入购物车.'        continue    elif chose == 500:
        bankmoney1.append('500')
        print 'MP4已成功加入购物车.'        continue    elif chose==3000:
        bankmoney1.append('3000')
        print 'iphone已成功加入购物车.'        continue    elif chose == 'go':
        break

#coding: utf-8
'''''''''
#抽象编程之函数的使用，抽象的函数可以帮我们大大的增加工作效率。
def hello (name): #def用于定义函数的键值，本实例定义了一个名为hello的函数，只有一个name的参数，调用时只需使用：hello()即可
return 'Hello,%s str'%name
print hello('naruto').title()
#这是一个用于计算斐波那契数列的函数实例
def fibss(number):
abc=[0,1]
for i in range(number-2):
abc.append(abc[-2] + abc[-1])
return abc
temp = int(raw_input("请输入您要计算的数："))
print fibss(temp)


#回味数学之圆的面积、周长、球的表面积与体积的计算，圆的面积公式为：S=πr²或S=π×(d/2)²，圆的周长公式为：L = 2×π×r，球的表面积公式为：4πr^2.球的体积公式为：V球=(4/3)πr^3.
import sys #导入系统sys模块库，用于调用退出函数
def Area(area): #定义计算面积的函数
print "根据您输入的半径推算出圆的面积约为：%s" % float(3.1416 * (area*area))

def Lunch(lunch):#定义计算周长的函数
print "根据您输入的半径推算出圆的周长约为：%s" % float(2*3.1416*lunch)
def Ball(ball):
print "根据您输入的半径推算出球的表面积约为：%s,球的体积约为：%s" % (float(4*3.1416*(ball*ball)),float(4*3.1416*(ball*ball*ball)/3))

while True:#外围循环用于控制choose的输入，等于Q、A则进入内嵌循环中，否则将报错或退出。
choose = raw_input("您是想要（Q：计算面积、A：计算周长、V:计算球的表面积与体积、E：退出）：")
while choose == 'Q' or choose == 'A' or choose == 'V':
sum = raw_input("请输入您要计算圆体的半径：")
if choose == 'Q':
Area(int(sum))#调用面积的函数并将sum的值传给area，进行打印输出
break
elif choose == 'V':
Ball(float(sum))
break
else:
Lunch(float(sum))#调用周长的函数并将sum的值传给lunch，进行打印输出
break
if choose == 'E':
print "感谢您的使用，再见！"
sys.exit()
if choose <> 'Q' and choose <> 'A' and choose <> 'V': #如果用户输入的字符是choose以外的字符，将提示用户重新输入！
print "对不起，您的输入有误，请重新输入！"

#回味数学之圆的面积、周长、球的表面积与体积的计算的精简版
def Area(area): #定义计算的函数
print "根据您输入的半径推算出圆的面积约为：%s，圆的周长约为：%s" % (float(3.1416 * (area * area)),float(2 * 3.1416 * area))
print "根据您输入的半径推算出球的表面积约为：%s,球的体积约为：%s" % (float(4 * 3.1416 * (area * area)), float(4 * 3.1416 * (area * area * area) / 3))
sum = raw_input('请输入您要计算圆体的半径：')
Area(float(sum))
'''''''''''

柔軟的小兔子或許不懂時尚，但卻在主人巧手打扮下以各種服裝照風靡網路！PuiPui 是隻在網路上掀起時尚風暴的小兔子，並不是因為牠瘋狂啃咬了哪位設計師的下一季單品，而是牠的時尚穿搭，已經讓許多自詡走在潮流尖端的人類甘拜下風～～

在牠的主人（應該稱作事業夥伴）Mumitan 的鼎力協助之下，定居於日本東京的模特兔 PuiPui 穿著精緻鮮明的迷你服飾，包括：駕駛帽、披風、和服與皇冠等，拍攝下一張張專業的服裝型錄照。

設計對白：請問你有先預約面談嗎？

大部分，牠的角色扮演靈感，來自於文學人物或知名人士，例如傳奇偵探福爾摩斯或英國皇家衛兵等，名模兔 PuiPui 都能將其可愛風格毫無違和地帶入原先沉穩的角色當中。

Mumitan 是這位名模兔的最佳造型師與幕後推手，她對細節的挑剔是無話可說的，看看牠身上的小小鈕釦、蝴蝶結與三件式衣服，都擁有難以置信的縫製工藝。PuiPui 的敬業態度，是事業夥伴 Mumitan 的最佳回報。

設計對白：這是我的王國！跪下！

由于现在的插头款式都不尽相同，尤其是3C产品，一款一个样，变压器越做越大，方向性也各有不同，往往让插座变得相当拥挤、甚至有你就没有我的互斥状况，国外一名大学生研发了甜甜圈状的插座，将以往最令人困扰的空间问题可以获得有效纾解，重点是，还不会有安全疑虑喔！





这是我们常见的状况，稍微大一点的变压器就很容易像这样打架，得重新帮大家调整位置，充个电像是在做脑力激荡。



MOGIC Power Donut&Bagel 将长条型的插座圈成圆型，除了解放空间的好处，它还能同时支援四种规格的插头，完全不需要再多一个转接头。





MOGIC Power Donut&Bagel 有两种规格，左边是MOGIC Power Donut，五个插座都是美规；右边则是国际通用的MOGIC Power Bagel，除了插孔通用之外，内部有6.3A 的安全保险丝以及备用保险丝，可以保护产品避免毁坏。


两个2A USB，iPad也能用，可快速充电。本身的电源线是伸缩性，总长92公分，需要多少就拉多少出来，让空间更干净。 MOGIC Power Donut&Bagel还有一个重点诉求，就是外出行动时的便携性，尤其是出国旅行或出差，所以它除了基本的Type A和B插孔之外，还可以加购旅行用的MA1万国插头配件，去调整配合当地规格。

有容乃大的MOGIC Power Donut&Bagel 可以让五个电子产品充电、却又小巧依人地能够窝进你胸前的小口袋， 似乎又让充电的行为更加方便了，如果你也为它心动​​，可以考虑去预购看看喔～～

有.设计uDesign目前有针对MOGIC Power Donut & Bagel | 圆阵型插座做独家集资预购的优惠方案！

#coding: utf-8

'''''''''''
#循环与其他条件语句的使用
#关于import与print隐藏的更多信息
print 'name:',40 #用逗号输出,注：print输出的参数并不能像我们预期那样构成一个元组。
#if条件语句的使用
name = 'ABC'
if name == 'ABC':print 'is True' #if 就是所谓的如果，如果判断表达式成立则显示相关信息，否则则返回False。
#else,else是if的不成立方式，当if表达式不成立的时候，最终会选择else继续往下执行。
if name == 'Fa':print 'is True'
else:
print 'is Nothing.'
#elif,elif可作为if的多判断形式出现，多用于嵌套循环之中。
number = raw_input('please input the numbe：')
if number < 0 :print 'the number is smaile.'
elif number == 0:print 'Binggo,You have egg again.'
elif number > 0:print 'Your input number,than be zero.'
else:
print 'Your Enter is Error. '
#相等运算符
print 'abc' == 'abc' #is True，python中一个等号用于赋值，两个等号用于判断！
#同一运算符性质
x = y = [1,2,3]
z = [1,2,3]
print x == y #is True.看上去它和==是一样的，但实际并不一样。
x==z #is True.看上去它和==是一样的，但实际并不一样。
x is y #is True
x is z #is False.

#in,成员资格，使用in可以判断该元素是否存在于字符串之中。
name = raw_input('Please input your name:')
if 'J' in name:print 'Your name is true'
else:
print 'your name is False.'
#while循环的使用，以下实例是一个每个月提醒您缴房租的程序。
x = 1 #定义月数
while x < 100:
print '第(%s)个月，老板又到了交房租的时候啦！'% x
x+=1

#本实例是一个反复让用户输入数字的程序，只要用户输入的数少于之前输入的数字，程序就会提示用户该数字已经打印，请重新输入，直到打印完100为止。
temp = 1 #用于循环打印输出显示
sum = 1 #用于计算循环打印的次数
while sum < 100: #当sum小于100的时候执行以下代码
number = int(raw_input('请输入数字：')) # 让用户输入
if number < sum: #如果用户输入的数低于当前循环的次数则返回错误
print '对不起，您输入的（%s）已经打印过啦，请输入比（%s）大的数，想打印（%s）直接输入即可。'%(number,sum,sum)
else:
while sum <= number: #当循环次数小于用户输入的数的时候将一直循环增加到与用户输入的数相等。
print temp # 1
temp += 1
sum += 1
User_s = raw_input('您是想（Q.退出、Y.继续输入）：')#退出或继续
if User_s == 'Q':
break
print '程序已按要求打印完毕，感谢您的使用，再见。'

#for循环的使用，一般来说while已经可以满足任何条件为真的情况下重复执行一块代码区域，但对于集合与其他迭代对象，就需要使用for了。
wors =['this','is','a','new','page']
for line in wors: #将会得到循环输出每一个元素
print line
#for方法有个很实用的迭代对象函数，当我们想打印某个范围内的数字的时候，可以使用range参数。
print range(1,30)#将会返回[1,2,3,4,5....]它有点类似于分片，它默认包含下限0，不包含上限，当然我们可以只提供上限
for line in range(1,101):#会打印出1-100的数，比起使用while实现，for看起来会更加的整洁。
print line
#开发过程中，如果可以使用For循环就尽量不要使用While循环。

#这是一个循环遍历字典元素的实例
dict_d = {'a': 1,'b': 2,'c': 3,'y':9}
for k in dict_d: #会得到所有元素的key与value
print 'key:(%s)'% k,'value:(%s)'% dict_d[k]
#这两种方法都可以获得key与value
for k,v in dict_d.items(): #会得到所有元素的key与value
print 'key:(%s),value:(%s)'% (k,v)

#For循环实现并行迭代
name =['naruto','levon','jone']
ages = [20,18,19]
for i in range(len(name)): #同时打印姓名与年龄
print "(%s)今年(%s)岁."% (name[i],ages[i])

#zip函数，zip函数可以将两个序列压缩在一起，然后返回一个元组列表
name =['naruto','levon','jone']
ages = [20,18,19]
print zip(name,ages)#会返回[('naruto', 20), ('levon', 18), ('jone', 19)]
#接下来，我们使用for循环来解包元组：
for Name, age in zip(name,ages):
print "(%s)今年(%s)岁." % (Name, age)#同样，也能获得元组的key与value
#index索引迭代法，index可以获得当前指定序列的对象的索引位置，并替换该字符串
strings = ['naruto','levon','jone']

index = 0
for line in strings: #for循环遍历strings列表
if 'naruto' in line: #如果Naruto存在列表中则将当前位置赋值给index。
strings[index] = 'youtube'#修改当前位置的字符串实现字符串替换
print strings
index +=1
#也可以通过enumerate函数实现：
for index,string in enumerate(strings):
if 'naruto' in string:
strings[index] = 'youtube'
print strings

#翻转与排序迭代函数reversed与sorted与列表相似，但它可作用于任何序列或可迭代的对象上，不是原地修改对象，而是翻转或排序。
print sorted([5,4,3,2,1])#返回[1, 2, 3, 4, 5]
print list(reversed("hello world."))#返回['.', 'd', 'l', 'r', 'o', 'w', ' ', 'o', 'l', 'l', 'e', 'h']
#sorted方法返回的是列表，而reversed返回的则是可迭代的对象
'''''''''

#coding: utf-8
"""""""""
#字典：当索引不好用时.....
#以下是示例
name = ['naruto','Levon','Airx','Jone']
number = ['3314','2236','5567','6456']
print number[name.index('Levon')]
#字典的创建
phonebook = {'naruto':'13314','Levon':'2236','Airx':'5567','Jone':'6456'}
#dict函数的使用
a = dict(phonebook)
print a['naruto']

#字典示例程序
#这是一个简单的数据库，字典使用人名字作为key，而每个人用另一个字典来表示，其中phone与addr分别表示他们的电话号码与地址。
peoplle = {
'Aire':{
'phone':'110',
'addr':'Lijun street 29'

},
'Jone':{
'phone':'999',
'addr':'Yushan street 39'

},
'serry': {
'phone':'120',
'addr':'Lie street 80'


}
}
#电话号码与地址使用的描述性标签，打印时使用
labels = {
'phone':'phone_number',
'addr':'addrss'
}
name = raw_input('please input your name:')
#询问用户是查号码还是查地址
request = raw_input('Are you want find the name(Q) or find the phone number(A): ')
#使用正确的key
if request == 'Q':
key = 'phone'
elif request == 'A':
key = 'addr'
#如果名字存在于key中，将会得到打印。否则则返回False
if name in peoplle :
print "%s's %s is %s." % (name,labels[key],peoplle[name][key])


#格式化字典%s
phonebook = {'naruto':'13314','Levon':'2236','Airx':'5567','Jone':'6456'}
print "Airx's phone number is %(Airx)s." % phonebook

#比较常见的字典格式化方法常用于HTML中，另外string.Template类也是非常有用的。
temp = '''''''''<html>
<head><title>%(title)s</title></head>
<body>
<h1>%(title)s</h1>
<p>%(text)s</p>
</body>'''''''''

data = {'title':'My Home Page','text':'Welcome to my home page!'}
print temp % data
#clear方法，clear方法用于清除字典中所有的项，类似于list.sort，无返回值或返回None。
phonebook = {'naruto':'13314','Levon':'2236','Airx':'5567','Jone':'6456'}
print phonebook
phonebook = phonebook.clear()
print phonebook
#实例2
x = {}
y = x
x['key'] = 'Value'
print y
x = {}
print y
#实例3
x = {}
y = x
x['key'] = 'Value'
print y
x.clear()
print y

#copy方法，copy可以浅复制出一个具有相同key、value的功能，因值本身是相同的所以并不是副本。
name = {'naruto':'27','Levon':'90','Airx':'80','Jone':'10','abc':['niube','bar','bz']}
user = name.copy()
user['naruto']='Mini'
user['abc'].remove('bz')
print user
print name
#deepcopy方法，deepcopy即所谓的深复制，可复制包含的所有值，通过from引用、
from copy import deepcopy
d = {}
d['name'] = ['admin','sb']
c = d.copy()
dc = deepcopy(d)
d['name'].append('av')
print c
print dc
#fromkeys方法，fromkeys用于特定的键创建新的字典，每个字典都有相应的值，默认为Nane,可以自定义默认值。
d = {}
print d.fromkeys(['name','age'],'(unkown)')

#get方法，get方法是个更宽松访问字典的方法，如试图访问的字典不存在时不会返回错误。
#示例
d = {}
#print d['abc']会返回一个错误
print d.get('name')#返回Nane，可以自定义返回值，例如将Nane改成：print d.get('name','N/A'),当然，如果值存在get也会返回。
#实例 - 本实例与上面的相似,本实例使用get()方法实现。
peoplle = {
'Aire':{
'phone':'110',
'addr':'Lijun street 29'

},
'Jone':{
'phone':'999',
'addr':'Yushan street 39'

},
'serry': {
'phone':'120',
'addr':'Lie street 80'


}
}
phone_book = {
'phone':'phone_number',
'addr':'address'
}
name = raw_input('Please input your name:')
#询问查找号码还是查找地址
request = raw_input('Are you want find the phone number(Q) or find the adders(A):')
#使用正确的key
key = request
if request == 'Q':
key ='phone'
if request == 'A':
key = 'addr'
#使用get提供默认值
person = peoplle.get(name, {})
result = person.get(key,'not available')#如果request = Q，则会匹配peoplle中的phone的值，A则则匹配地址，否则返回‘not available’
lable = phone_book.get(key,key)#key与值将匹配到phone_book的字典中。
print "%s's %s is %s." % (name,lable,result)

#has_key方法，has_key可用于检测字典中是否含有指定的key，表达式：a.has_key(k)相当于k in d.
d = {}
d.has_key('Jone')#return is False.
d['name'] = 'Jone'#return is True
#items与iteritems，items将字典所有的项以列表形式返回，而iteritems则返回一个对象生成器，而不是列表。
d = {'title':'Google web site','url':'https://www.google.com','spam':0}
print d.items()
#iteritems
b = d.iteritems()
print b #会生成一个迭代对象生成器：<dictionary-itemiterator object at 0x029CFB70>
print list(b)#list方法会将迭代对象转换成一个列表形式打印。
#pop，pop会获得用户指定的值，然后将键值从字典中移除。
d = {'b':1,'x':2}
print d.pop('x')
print d


#popitem方法，popitem类似list.pop，后者会弹出最后一个元素，不同的是popitem会随机弹出一键值。
d = {'title':'Google web site','url':'https://www.google.com','spam':0}
print d.popitem()
#setdefault方法与get类似，除能获得给予key所关联的值外，还可以在字典中不含有给定的key的情况下设定相项。
d = {}
d.setdefault('name','N/A')#用setdefailt创建了个key为name，vlue：N/A的键值。
print d
d['name'] = 'Jone'#给name赋值
d.setdefault('name')
print d #如果值存在则返回则，否则将返回默认值，如果不设定默认值则显示None。

#update方法可以利用一个字典项更新另一个字典
d = {'title':'Google web site','url':'https://www.google.com','changed':'Mar 16 17:25 Apr 2016'}
b = {'title':'Google ABCPP site'}
d.update(b)
print d
#vlues和itervlues，vlues以列表形式返回字典中的值，而后者后者返回的是一个迭代对象，不同的是后者可以包含重复的元素。
d = {}
d[1] =1
d[2]=2
d[3]=3
d[4]=4
d[5]=5
print d.values()
a = d.itervalues()
print list(a)
"""""""""

#Join 方法，Join方法是非常重要的字符串方法，它是split方法的逆向方法，用于连接序列中的元素
set = ['1','2','3','4','5']#用于连接字符串。
sep = '+'
sep.join(set)
dirs = '','usr','bin','env'
'/'.join(dirs)
print 'C:' + '\\'.join(dirs)
#C:\usr\bin\env

# lower方法，lower方法返回字符串的小写字母版。另外此方法还具有忽略大小写功能，模糊搜索将用到。
'Hello World.'.lower()
#这是一个实例，如果用户输入的字符串中含有text里的元素则返回真,注：’本方法仅对小写有效。‘
name = raw_input('输入一个字符:')
text = ['And','bnc','Unic','hello']
if name.lower() in text:
print "That's the True"
else:
print "That's the Noting."

#title 方法，title方法可将字符串转换为标题，即所有单词首写字母大写，其他小写。
"that's a example".title()

#这是一个实例，当用户输入字符后将自动转换成标题形式。
tx = raw_input('请输入标题：')
print tx.title()

#类似title方法的还有另一种实现方式：
import string
print string.capwords("that's a example")

#replace方法，replace方法可用于替换字符串中的字符。
print "This 's the new example.".replace('example','string')

#这是一个实例，用户可以自定义替换字符串中的内容。
show = "This's the new example."
print show
inp = raw_input('请输入您想要替换的字符:')
tr = raw_input('您想要将%s替换成什么呢？:'%(inp))
print "这是替换后的效果：" + show.replace(inp,tr)

#split方法，split是一个非常重要的字符串方法，它是join的逆向方法，常用于字符分割。
print '1+2+3+4+5'.split('+')
print 'C:/User/acer/Desktop'.split('/')
print "This's the New Day.".split()
#这是一个实例，用户可以自定义切割字符串中的内容。
show = "This's + the + New + Example,But,The + Example + is + only + for + you"
print show
inp = raw_input('您想要如何分割文本呢？:')
print show.split('%s'% (inp))
'''''''''''
'''''''''''
#strip方法，strip会去除两侧（不包含内部）空格的字符
print " This's is the New Example.but,the Example is only for you. ".strip()
#这是一个实例，用户可以自定义替换字符中的内容、切割文本、去除多余的空格以及内容添加，本实例将以while循环遍历实现。
show = " This's +is +the +New+Example.but+the+example+is+only+for+you. "
print show
while True:
inp = raw_input('您是想（Q.切割文本/T.替换内容/D.去空/A.添加内容）:')
if inp == 'Q':
cut = raw_input('您想以哪种方式进行分割呢？:')
print show.split(cut)
break
elif inp == 'T':
cut = raw_input('您想要替换哪部分内容呢？：')
put = raw_input('您想将%s替换成什么呢？：'% cut)
print show.replace(cut,put)
break
elif inp == 'D':
print show.strip()
break
elif inp == 'A':
cut = raw_input('请输入您要往字符串中添加的内容:')
print show.join(cut)
break
else:
print '您的输入有误，请重新输入！'