第二篇：数据类型、字符编码、文件处理

上一章复习：

1、安装python解释器
        python C:\test.py
        1 启动python解释器
        2 把文件内容读入内存
        3 解释执行

    2 变量
        age=18

        id:id(age)
        type:type(age)
        value:age

        is:比较id
        ==：比较value
        强调：id不同，value可以相同

    3 数据类型
        整形int
        浮点型float
        字符串str
        列表list
        字典dict

    4 用户与程序交互
        python3
            input：把任何输入的内容都存成字符串

        python2
            raw_input:把任何输入的内容都存成字符串
            input:必须输入一个明确的数据类型的值

    5 格式化输出
        %s：接收字符串和整型
        %d：只能接收整型

    6 基本运算符
        算数运算符
            + * ：字符串，列表
        比较运算符
        逻辑运算符
            and，or，not
        赋值运算
            x+=1
            x=y=z=1

            m=1
            n=2
            m,n=n,m

            a,b,c=[1,2,3]
        身份运算符：
            is，is not

    7 if判断
        if 条件1：
            pass
        elif 条件2：
            pass
        elif 条件3：
            pass
        else:
            pass

    8 while
        while 条件：
            pass

        while+break
        while+continue

1 数据类型与内置方法
2 字符编码
3 文件处理

View Code

数据类型：

一 引子

1 什么是数据？

　　x=10，10是我们要存储的数据

2 为何数据要分不同的类型

　　数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示

3 数据类型

　　数字（整形，长整形，浮点型，复数）

　　字符串

　　字节串：在介绍字符编码时介绍字节bytes类型

　　列表

　　元组

　　字典

　　集合

4 按照以下几个点展开数据类型的学习

#一：基本使用
1 用途

2 定义方式

3 常用操作+内置的方法

#二：该类型总结
1 存一个值or存多个值
    只能存一个值
    可以存多个值，值都可以是什么类型

2 有序or无序

3 可变or不可变
    ！！！可变：值变，id不变。可变==不可hash
    ！！！不可变：值变，id就变。不可变==可hash

二.数字

整数int与浮点型：

#整型int
　　作用：年纪，等级，身份证号，qq号等整型数字相关
　　定义：
　　　　age=10 #本质age=int(10)

#浮点型float
　　作用：薪资，身高，体重，体质参数等浮点数相关

    salary=3000.3 #本质salary=float(3000.3)

#二进制，十进制，八进制，十六进制 

View Code

整型int
# 1 用途：年龄，等级，qq号等

# 2 定义方式
# age=18 #age=int(18)


#二：该类型总结
# 1 存一个值or存多个值
#     只能存一个值

# 3 可变or不可变
#     ！！！不可变

#hash可哈希
# x=11
# print(id(x))
# x=12
# print(id(x))

View Code

其他数据类型（了解）

#长整形（了解）
    在python2中（python3中没有长整形的概念）：　　　　　　
    >>> num=2L
    >>> type(num)
    <type 'long'>

#复数（了解）　　
    >>> x=1-2j
    >>> x.real
    1.0
    >>> x.imag
    -2.0　　

View Code

三.字符串：

#用途：姓名，性别，住址等描述性的数据
#定义：‘’ ，“”，''' '''内定义的一串字符
#msg='hello world'

#优先掌握的操作：
1、按索引取值(正向取+反向取) ：只能取

msg='hello world'
print(msg[0],type(msg[0]))
print(msg[-1])

View Code

2、切片(顾头不顾尾，步长)

msg='hello world'
print(msg[0:3]) #>=0 <3
print(msg[0:7]) #>=0 <7
print(msg[0:7:1]) #>=0 <7
print(msg[0:7:2]) #hello w   #hlow
print(msg[:])
print(msg[5:1:-1])
print(msg[-1::-1])字符串倒过来

View Code

3、长度len

msg='hello world'
print(msg.__len__())
print(len(msg)) #msg.__len__() 

View Code

4、成员运算in和not in

msg='hello world'
print('llo' in msg)        #True
print('llo' not in msg)  #False

View Code

5、移除空白strip

password='    alex3714     '
print(password.strip())

password=input('>>: ').strip()

password='alex 3714     '
print(password.strip())
#去除左右空格，不可去除中间空格

View Code

6、切分split

user_info='root:x:0:0::/root:/bin/bash'
res=user_info.split(':')      #按照：切分
print(res[0])  

cmd='get /root/a/b/c/d.txt'
print(cmd.split())                #括号内不写按空格切分

file_path='C:\\a\\d.txt'
print(file_path.split('\\',1))   #指定切分一次

file_path='C:\\a\\d.txt'
print(file_path.rsplit('\\',1))  #从右往左切分（rsplit）

View Code

7、循环 （while,for）

#while循环，按照索引取值
msg='hel'
n=0
size=len(msg)
while n < size:
    print(msg[n])
    n+=1

#for循环，不依赖索引
msg='hel'
for i in msg:                   #i=l
    print(i)

for i in range(0,5,2): #0 2 4  #从0到5，步长2
    print(i)

msg='hel'
for i in range(len(msg)):        #0 1 2
    print(msg[i])          #range：模拟数字，从哪开始


for i in range(3):
    print(i)

View Code

该类型总结:

# 1 存一个值or存多个值
#     只能存一个值

# 2 有序

# 3 可变or不可变
#     ！！！不可变：值变，id就变。不可变==可hash

View Code

 需要掌握的操作:

#1、strip,lstrip,rstrip
#2、lower,upper
#3、startswith,endswith
#4、format的三种玩法
#5、split,rsplit
#6、join
#7、replace
#8、isdigit

#1、strip,lstrip,rstrip
# print("**alex****".strip('*'))
# print("**alex****".lstrip('*'))去左边的
# print("**alex****".rstrip('*'))去右边的 

#2、lower,upper
# print('ALeX'.lower())#全变小写
# print('aaa'.upper())全变大写

#3、startswith,endswith
# msg='alex is SB'
# print(msg.startswith('alex'))#判断以什么开头
# print(msg.startswith('a'))
# print(msg.endswith('SB'))判断以什么结尾

#4、format的三种玩法     #传值语句
# print('my name is %s my age is %s' %('alex',18))

# print('my name is {} my age is {}'.format('alex',18))
# print('my name is {} my age is {}'.format(18,'alex'))

# print('{0} {1} {0}'.format('alex',18))

## print('my name is {name} my age is {age}'.format(age=18,name='male'))


#5、split,rsplit
# info='root:x:0:0'
# l=info.split(':')   #把字符串切成列表
# print(l)
#6、join               #把一个列表以某一种分隔符合成字符串
# print(':'.join(l))

# l=[1,2,3]
# ' '.join(l) #报错：只有在列表内的元素全是字符串类型，才能用join拼接


#7、replace        #替换
# msg='alex say my name is alex ,alex have on tesla'
# msg=msg.replace('alex','SB',1 
# print(msg)


#8、isdigit        #判断字符串内包含的是不是数字
# age=input('>>: ').strip()
# # print(age.isdigit()) #age='123'  #只能输入数字 
# if age.isdigit():
#     age=int(age)
# else:
#     print('必须输入数字')

示例

了解:

#1、find,rfind,index,rindex,count
#2、center,ljust,rjust,zfill
#3、expandtabs
#4、captalize,swapcase,title
#5、is数字系列
#6、is其他

#1、find,rfind,index,rindex,count
#msg='hello world'
# print(msg.find('wo'))      #查找所在位置
# print(msg.find('SB'))      #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引

# print(msg.index('wo'))
# print(msg.index('SB')) #ValueError: substring not found  找不到会报错

# print(msg.count('l'))     #统计，顾头不顾尾,如果不指定范围则查找所有
# print(msg.count('SB'))  #没有返回值0


#2、center,ljust,rjust,zfill
# print('jianghao'.center(30,'*'))   #居中填充
# print('jianghao'.ljust(30,'*'))     #左对齐填充
# print('jianghao'.rjust(30,'*'))     #右对齐填充
# print('jianghao'.zfill(30))         #默认右对齐，默认用0填充


#3、expandtabs             #补充
#msg='hello world'
# print('hello\tworld'.expandtabs(10))

#4、captalize,swapcase,title
# print('i am jianghao'.capitalize())  #首字母大写
# print('i am jianghao'.title())        #每一个开头字母大写
# print('AbC'.swapcase())           #大小写翻转

#5、is数字系列
# num1=b'4' #bytes
# num2=u'4' #unicode,python3中无需加u就是unicode
# num3='壹' #中文数字
# num4='Ⅳ' #罗马数字

#isdigt:bytes,unicode
# print(num1.isdigit())  #True  #只能判断bytes,unicode 
# print(num2.isdigit())  #True
# print(num3.isdigit())  #False
# print(num4.isdigit())  #False

#isdecimal:uncicode
#bytes类型无isdecimal方法
# print(num2.isdecimal())  #True
# print(num3.isdecimal())  #False
# print(num4.isdecimal())  #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
# print(num2.isnumeric())  #True
# print(num3.isnumeric())  #True
# print(num4.isnumeric())  #True

#三者不能判断浮点数
num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())


'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

#6、is其他
# name='egon123'
# print(name.isalnum()) #字符串由字母或数字组成
# print(name.isalpha()) #字符串只由字母组成

# print('print1111'.isidentifier())  #字符串里包含关键字
# print('abcA'.islower())            #判断小写
# print(name.isupper())              #判断大写
# print(' '.isspace())               #判断空格
# print('Am Ia'.istitle())           #判断标题

示例

 四.列表:

#定义：[]内可以有多个任意类型的值，逗号分隔

#作用：多个装备，多个爱好，多门课程，多个女朋友等

#定义：[]内可以有多个任意类型的值，逗号分隔
# my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
# print(list('hello'))
# print(int('123'))
# print(str(123))

#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
# my_girl_friends=['alex','wupeiqi','yuanhao',4,5]

#2、切片(顾头不顾尾，步长)

#3、长度 len
# print(my_girl_friends.__len__())
# print(len(my_girl_friends))
#4、成员运算in和not in
# print('wupeiqi' in my_girl_friends)

#5、追加 .append
# my_girl_friends[5]=3 #IndexError: list assignment index out of range
# my_girl_friends.append(6)
# print(my_girl_friends)

#6、删除(del,.pop)
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
#单纯的删除
# del my_girl_friends[0]
# print(my_girl_friends)

# res=my_girl_friends.remove('yuanhao')
# print(my_girl_friends)
# print(res)
# print(my_girl_friends)

#删除并拿到结果:取走一个值
# res=my_girl_friends.pop(2)  #按照索引去删
# res=my_girl_friends.pop()  #默认末尾去删
# print(res)

# my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
# print(my_girl_friends.pop(0)) #'alex'
# print(my_girl_friends.pop(0)) #'wupeqi'
# print(my_girl_friends.pop(0)) #'yuanhao'
#7、循环 for
# my_girl_friends=['alex','wupeiqi','yuanhao',4,5]

# i=0
# while i < len(my_girl_friends):
#     print(my_girl_friends[i])
#     i+=1

# for item in my_girl_friends:
#     print(item)

# for i in range(10):
#     if i== 3:
#         break
#         # continue
#     print(i)
# else:
#     print('===>')

View Code

掌握的方法：

my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
# my_girl_friends.insert(1,'egon')  #插入
# print(my_girl_friends)

# my_girl_friends.clear()    #清空
# print(my_girl_friends)

# l=my_girl_friends.copy()     #复制
# print(l)

# print(my_girl_friends.count('yuanhao'))   #统计

# l=['egon1','egon2']
# my_girl_friends.extend(l)               #循环加值
# my_girl_friends.extend('hello')
# print(my_girl_friends)

# my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
# print(my_girl_friends.index('wupeiqi'))            #以列表形式查索引
# print(my_girl_friends.index('wupeiqissssss'))      
# my_girl_friends.reverse()                          #翻转
# my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
# my_girl_friends.reverse()
# print(my_girl_friends)                   #排序         


# l=[1,10,4,11,2,]
# l.sort(reverse=True)                   #反排序
# print(l)

# x='healloworld'
# y='he2'

# print(x > y)

# l=['egon','alex','wupei']
# l.sort()
# print(l)

示例

该类型总结：

# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意类型

# 2 有序

# 3 可变or不可变
#     ！！！可变：值变，id不变。可变==不可hash

View Code

 

五.元组：

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

优先掌握的操作：

#1、按索引取值(正向取+反向取)：只能取
#2、切片(顾头不顾尾，步长)
# age=(11,22,33,44,55)
# print(age[0:3])
# print(age)
#3、长度
# age=(11,22,33,44,55)
# print(len(age))
#4、成员运算in和not in
# age=(11,22,33,44,55)
# print(11 in age)
#5、循环
# for item in age:
#     print(item)


#熟练掌握
# age=(11,22,33,44,55)
# print(age.index(33))   #找索引
# print(age.index(33333))  #查找不到报错

# print(age.count(33))   #统计

View Code

该类型总结：

1 存一个值or存多个值
     可以存多个值，值都可以是任意类型

 2 有序

 3 可变or不可变
    ！！！不可变：值变，id就变。不可变==可hash

View Code

六.字典：

#作用：存多个值,key-value存取，取值速度快

#定义：key必须是不可变类型（int，float，str，tuple），value可以是任意类型
# info={'name':'egon','age':18,'sex':'male'}
#info=dict({'name':'egon','age':18,'sex':'male'})

# info=dict(age=18,sex='male',name='egon')
# print(info)

# info=dict([('name','egon'),('age',18),('sex','male')])
# info=dict([['name','egon'],['age',18],['sex','male']])
# print(info)

# info={}.fromkeys(['name','age','sex'],None  #快速创建空字典，以列表内的为key
# print(info)

# info={}.fromkeys('hello',None) #按照字符串创建，重复不可重复创建
# print(info)

了解：字典的多种写法

优先掌握的操作：

#1、按key存取值：可存可取
# d={'name':'egon'}
# print(d['name'])
#
# d['age']=18
# print(d)

#2、长度len
# info={'name':'egon','age':18,'sex':'male'}
# print(len(info))

#3、成员运算in和not in
# info={'name':'egon','age':18,'sex':'male'}
# print('name' in info)

#4、删除
info={'name':'egon','age':18,'sex':'male'}
# print(info.pop('name'))
# print(info)
# print(info.popitem()) #('sex', 'male')
# print(info)

#5、键keys()，值values()，键值对items() #了解
# print(info.keys())
# print(list(info.keys())[0])

# print(list(info.values()))
# print(list(info.items()))

#6、循环
# info={'name':'egon','age':18,'sex':'male'}
# for k in info:
#     print(k,info[k])

View Code

其他掌握的方法：

# info={'name':'jianghao,'age':18,'sex':'male'}
# print(info['hobbies'])
# print(info.get('hobbies','没有'))
# print(info.pop('name1',None))

# d={'x':1,'y':2,'name':'EGON'}
# info.update(d)
# print(info)

# info={'name':'jianghao','sex':'male'}
# value=info.setdefault('age',18)
# print(value)

# info={'name':'jianghao','age':16,'sex':'male'}
# value=info.setdefault('age',18) #如果key存在，则不修改，返回已经有的key对应的value
# print(value)
# print(info)

info={'name':'jianghao',}
# info['hobbies']=[]
# info['hobbies'].append('music')
# info['hobbies'].append('read')
# print(info)

info={'name':'jianghao',}
# if 'hobbies' not in info:
#     info['hobbies']=[]
# else:
#     info['hobbies'].append('music')

# hobbies_list=info.setdefault('hobbies',[])
# print(hobbies_list)
# hobbies_list.append('play')
# hobbies_list.append('read')
#
# print(info)

参考

该类型的总结：

1 存一个值or存多个值
#     可以存多个值，值都可以是任意类型,key必须是不可变类型
#
# 2 无序

# 3 可变or不可变
#     ！！！可变：值变，id不变。可变==不可hash

View Code

练习：

1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 
的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中

即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

a={'k1':[],'k2':[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
    if i>66:
        a['k1'].append(i)
    else:
        a['k2'].append(i)
print(a)
复制代码

View Code

2 统计s='hello alex alex say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

s='hello alex alex say hello sb sb'

l=s.split()
dic={}
for item in l:
    if item in dic:
        dic[item]+=1
    else:
        dic[item]=1
print(dic)

View Code

#利用setdefault解决重复赋值
'''
setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
d={}
print(d.setdefault('a',1)) #返回1

d={'a':2222}
print(d.setdefault('a',1)) #返回2222
'''
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
for word in words: #word='alex'
    dic.setdefault(word,s.count(word))
    print(dic)



#利用集合，去掉重复，减少循环次数
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
words_set=set(words)
for word in words_set:
    dic[word]=s.count(word)
    print(dic)

setdefault的用法（去重）

七.集合：

#作用：去重，关系运算，

#定义：
            知识点回顾
            可变类型是不可hash类型
            不可变类型是可hash类型

#定义集合:
            集合：可以包含多个元素，用逗号分割，
            集合的元素遵循三个原则：
             1：每个元素必须是不可变类型(可hash，可作为字典的key)
             2:没有重复的元素
             3：无序

注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

优先掌握的操作:

#1、长度len
# s={1,2,3,1} #s=set({1,2,3,1})
# print(len(s))

#2、成员运算in和not in
# names={'egon','alex'}
# print('egon' in names)

#3、|合集
pythons={'egon','axx','ysb','wxx'}
linuxs={'egon','oldboy','oldgirl','smallboy','smallgirl'}

#4、&交集:同时报名两门课程的学生
# print(pythons & linuxs)
# print(pythons.intersection(linuxs))

#5、|合集:老男孩所有的学生
# print(pythons | linuxs)
# print(pythons.union(linuxs))

#6、^对称差集:没有同时报名两门课程
# print(pythons ^ linuxs)
# print(pythons.symmetric_difference(linuxs))

#7.1  -差集：只报名python课程的学生
# print(pythons - linuxs)
# print(pythons.difference(linuxs))

#7.2  -差集：只报名linux课程的学生
# print(linuxs-pythons)

#8 父集:>,>=,子集：<，<=
# s1={1,2,3}
# s2={1,2,}
# print(s1 >= s2)

View Code

# s1={1,2,3}
# s2={1,2,}
# print(s1-s2)
# print(s1.difference(s2))   #减去
# s1.difference_update(s2) #s1=s1.difference(s2)   #减完并更新
# print(s1)

# s2={1,2,3,4,5,'a'}
# print(s2.pop())b  # 随机删除

# s2.add('b')     #添加
# print(s2)

# s2.discard('b')   #明确指定删除，删除的元素不存在不报错
# s2.remove('b') #删除的元素不存在则报错
# print(s2)


# s1={1,2,3,4,5,'a'}
# s2={'b','c',}
# print(s1.isdisjoint(s2)) #两个集合没有共同部分时，返回值为True


# s2={1,2,3,4,5,'a'}
# s2.update({6,7,8})    #更新
# print(s2)


# l=['a','b',1,'a','a']
# print(list(set(l)))

# print(set('hello'))
# print(set({'a':1,'b':2,'c':3}))

了解的知识点

练习：

　二.去重

　　 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到
新列表,且新列表无需保持列表原来的顺序

　　 2.在上题的基础上，保存列表原来的顺序

　　 3.去除文件中重复的行，肯定要保持文件内容的顺序不变
　　 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列
表一定要保持列表原来的顺序

l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]　　

#去重,无需保持原来的顺序
l=['a','b',1,'a','a']
print(set(l))

#去重,并保持原来的顺序
#方法一:不用集合
l=[1,'a','b',1,'a']

l1=[]
for i in l:
    if i not in l1:
        l1.append(i)
print(l1)
#方法二:借助集合
l1=[]
s=set()
for i in l:
    if i not in s:
        s.add(i)
        l1.append(i)

print(l1)


#同上方法二,去除文件中重复的行
import os
with open('db.txt','r',encoding='utf-8') as read_f,\
        open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')

#列表中元素为可变类型时,去重,并且保持原来顺序
l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
# print(set(l)) #报错:unhashable type: 'dict'
s=set()
l1=[]
for item in l:
    val=(item['name'],item['age'],item['sex'])
    if val not in s:
        s.add(val)
        l1.append(item)

print(l1)






#定义函数,既可以针对可以hash类型又可以针对不可hash类型
def func(items,key=None):
    s=set()
    for item in items:
        val=item if key is None else key(item)
        if val not in s:
            s.add(val)
            yield item

print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))

View Code

八 .数据类型总结

按存储空间的占用分（从低到高）

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

 

 

按可变不可变区分

可变	列表，字典
不可变	数字，字符串，元组

 

 

按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

 

 

  

九 运算符

#身份运算（is ，is not）
is比较的是id，而双等号比较的是值
毫无疑问，id若相同则值肯定相同，而值相同id则不一定相同
>>> x=1234567890
>>> y=1234567890
>>> x == y
True
>>> id(x),id(y)
(3581040, 31550448)
>>> x is y
False

字符编码总结：

1、存取文件不乱码的法则：用什么编码存的，就要用什么编码读
2、
    unicode-----encode----->gbk
    gbk-------->decode----->unicode

3、
    python3解释器默认使用的字符编码是utf-8
    python2解释器默认使用的字符编码是ascii
4
    python2的str就是python3的bytes
    python2的unicode就是python3的str

View Code

http://www.cnblogs.com/iamjianghao/p/8029067.html

参考：http://www.cnblogs.com/linhaifeng/articles/5950339.html

文件处理：

 

文件句柄 = open('文件路径', '模式')

 

模式可以是以下方式以及他们之间的组合：

 

Character	Meaning
‘r'	open for reading (default)
‘w'	open for writing, truncating the file first
‘a'	open for writing, appending to the end of the file if it exists
‘b'	binary mode
‘t'	text mode (default)
‘+'	open a disk file for updating (reading and writing)
‘U'	universal newline mode (for backwards compatibility; should not be used in new code

 

参考：http://www.cnblogs.com/linhaifeng/articles/5984922.html

练习一: 三级菜单
#要求:
打印省、市、县三级菜单
可返回上一级
可随时退出程序

menu = {
    '北京':{
        '海淀':{
            '五道口':{
                'soho':{},
                '网易':{},
                'google':{}
            },
            '中关村':{
                '爱奇艺':{},
                '汽车之家':{},
                'youku':{},
            },
            '上地':{
                '百度':{},
            },
        },
        '昌平':{
            '沙河':{
                '老男孩':{},
                '北航':{},
            },
            '天通苑':{},
            '回龙观':{},
        },
        '朝阳':{},
        '东城':{},
    },
    '上海':{
        '闵行':{
            "人民广场":{
                '炸鸡店':{}
            }
        },
        '闸北':{
            '火车战':{
                '携程':{}
            }
        },
        '浦东':{},
    },
    '山东':{},
}

level=[]    #建立空列表
while True:
    for k in  menu:   #循环取值
        print(k)
    choicel=input('choicel>>:').strip()     #输入，移除空格
    if choicel == 'quit':       #判断是否等于‘quit’
        if len(level)==0:break  #判断列表长度等于空时结束
        menu=level[-1]          #修改列表，退到上级目录
        level.pop()             #移除列表中最后一个元素并返回该元素的值
    if choicel == 0 or choicel not in menu:continue   #判断值等于空或者不在字典内，如果条件通过结束本次循环
    level.append(menu)          #在level列表末尾添加新的对象
    menu=menu[choicel]          #从新定义字典内容

三级菜单参考

练习二：请闭眼写出购物车程序
#需求:
用户名和密码存放于文件中，格式为：egon|egon123
启动程序后，先登录，登录成功则让用户输入工资,然后打印商品列表，失败则重新登录，超过三次则退出程序
允许用户根据商品编号购买商品
用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
可随时退出，退出时，打印已购买商品和余

 

转载于:https://www.cnblogs.com/iamjianghao/p/8028035.html