Python20期课堂总结-20171209-Python数据类型字符编码文件处理

Posted 2020-10-17

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python20期课堂总结-20171209-Python数据类型字符编码文件处理相关的知识，希望对你有一定的参考价值。

第1章上节课课程回顾

1.1 安装python解释器

python C:\\test.py

1 启动python解释器

2 把文件内容读入内存

3 解释执行

1.2 变量

age=18

id:id(age)

type:type(age)

value:age

is:比较id

==：比较value

强调：id不同，value可以相同

1.3 数据类型

整形int

浮点型float

字符串str

列表list

字典dict

1.4 用户与程序交互

python3

input：把任何输入的内容都存成字符串

python2

raw_input:把任何输入的内容都存成字符串

input:必须输入一个明确的数据类型的值

1.5 格式化输出

%s：接收字符串和整型

%d：只能接收整型

1.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

1.7 if判断

if 条件1：

pass

elif 条件2：

pass

elif 条件3：

pass

else:

pass

1.8 while

while 条件：

pass

while+break

while+continue

1.9 数据类型

1.9.1 数据有哪些类型

#1.数字 2.字符串 3.元祖 4.列表 5.字典 6.集合

1.9.2 数据类型总结

#数字 1.只存一个值值必须是数字 2.有序 3.不可变类型

#字符串 1.只存一个值值字母或者数字 2.有序 3.不可变

#元祖 1.存多个值值必须是不可变量 2.有序 3.不可变

#列表 1.存多个值什么值都可以 2.有序 3.可变类型

#字典 1.存多个值什么值都可以 2.有序 3.可变

#集合 1.存多个值什么值都可以 2.无序 3.不可变

第2章数字类型

2.1 整型与浮点型

2.1.1 整型int

　　作用：年纪，等级，身份证号，qq号等整型数字相关

　　定义：

　　　　age=10 #本质age=int(10)

# x=11

# print(id(x))

# x=12

# print(id(x))

2.1.2 浮点型float

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

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

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

2.2 其他数字类型（了解）

2.2.1 长整形（了解）

在python2中（python3中没有长整形的概念）：　　　　　　

>>> num=2L

>>> type(num)

2.2.2 复数（了解）　　

>>> x=1-2j

>>> x.real

1.0

>>> x.imag

-2.0

第3章字符串类型

3.1 作用

#作用：名字，性别，国籍，地址等描述信息

#定义：在单引号\\双引号\\三引号内，由一串字符组成

msg=‘hello world‘

3.2 优先掌握的操作

优先掌握的操作：

1、按索引取值(正向取+反向取) ：只能取

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

3、长度len

4、成员运算in和not in

5、移除空白strip

6、切分split

7、循环

3.2.1 按索引取值(正向取+反向取) ：只能取

msg=‘hello world‘

print(msg[0],type(msg[0]))

print(msg[-1])

3.2.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])

3.2.3 长度len

msg=‘hello world‘

print(msg.__len__())

print(len(msg)) #msg.__len__()

3.2.4 成员运算in和not in

msg=‘hello world‘

print(‘llo‘ in msg)

print(‘llo‘ not in msg)

3.2.5 移除空白strip

password=‘ alex3714 ‘

print(password.strip())

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

password=‘alex 3714 ‘

print(password.strip())

3.2.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))

3.2.7 循环

msg=‘hel‘

n=0

size=len(msg)

while n < size:

print(msg[n])

n+=1

for i in msg: #i=l

print(i)

for i in range(0,5,2): #0 2 4

print(i)

# msg=‘hel‘

# for i in range(len(msg)): #0 1 2

# print(msg[i])

# for i in range(3):

# print(i)

# x=‘aaa‘

# print(id(x))

# x=‘bbb‘

# print(id(x))

3.2.8 该类型总结

1 只能存一个值

2 有序

3不可变类型：值变，id就变。不可变==可hash

3.3 需要掌握的操作

1、strip,lstrip,rstrip

2、lower,upper

3、startswith,endswith

4、format的三种玩法

5、split,rsplit

6、join

7、replace

8、isdigit

3.3.1 strip,lstrip,rstrip

#strip 去除空格 strip内如果什么都不写就是去前后空格可以填写内容在strip内则表示去除填写的相应内容 lstrip去除左边rstrip去除右边。

print("**alex****".strip(‘*‘))

print("**alex****".lstrip(‘*‘))

print("**alex****".rstrip(‘*‘))

3.3.2 lower,upper

#lower大写全部转化为小写 upper小写全部转化为大写

print(‘ALeX‘.lower())

print(‘aaa‘.upper())

3.3.3 startswith,endswith

###startwith判断字符串开头是否为某些字符，是返回True，不是返回False。endwith判断字符串末尾是否为某些字符，是返回True，不是返回False。

msg=‘alex is SB‘

print(msg.startswith(‘alex‘))

print(msg.startswith(‘a‘))

print(msg.endswith(‘SB‘))

3.3.4 format的三种玩法

# 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‘))

3.3.5 split,rsplit

#split  把字符串按照指定分隔符划分成NoType格式

info=‘root:x:0:0‘

l=info.split(‘:‘)

print(l)

name=‘root:x:0:0::/root:/bin/bash‘

print(name.split(‘:‘)) #默认分隔符为空格

name=‘C:/a/b/c/d.txt‘ #只想拿到顶级目录

print(name.split(‘/‘,1))

name=‘a|b|c‘

print(name.rsplit(‘|‘,1)) #从右开始切分

3.3.6 join

#join 把字符串中单个字符分别加入到字符串头列，如果是列表就将列表中的内容给字符串首列。

print(‘:‘.join(l))

tag=‘ ‘

print(tag.join([‘egon‘,‘say‘,‘hello‘,‘world‘])) #可迭代对象必须都是字符串

l=[1,2,3]

print(‘‘.join(l))

#####‘ ‘.join(l) #报错：只有在列表内的元素全是字符串类型，才能用join拼接

3.3.7 replace

#replace 修改字符串内容,replace(‘被替换的内容‘,‘新内容‘,‘替换次数‘)括号内填写‘要修改内容‘加逗号‘替换的新内容‘逗号‘替换次数‘如果不填写次数就全部替换。

msg=‘alex say my name is alex ,alex have on tesla‘

msg=msg.replace(‘alex‘,‘SB‘,1)

print(msg)

3.3.8 isdigit

#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法

age=input(‘>>: ‘).strip()

# print(age.isdigit()) #age=‘123‘

if age.isdigit():

age=int(age)

else:

print(‘必须输入数字‘)

3.4 其他操作（了解即可）

#1、find,rfind,index,rindex,count

#2、center,ljust,rjust,zfill

#3、expandtabs

#4、captalize,swapcase,title

#5、is数字系列

#6、is其他

3.4.1 find,rfind,index,rindex,count

#find从左到右查找字符串中的某些字符或字符串，找到并显示首次出现时候的索引,如果没有该字符返回-1

#index从左到右查找字符串中的某些字符或字符串,找到并显示首次出现时候的索引,如果没有就报错

#count查找字符串中的某些字符或字符串出现的次数

name=‘egon say hello‘

print(name.find(‘o‘,1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引

# print(name.index(‘e‘,2,4)) #同上,但是找不到会报错

print(name.count(‘e‘,1,3)) #顾头不顾尾,如果不指定范围则查找所有

3.4.2 center,ljust,rjust,zfill

# #center,ljust,rjust,zfill center两边添加字符center(宽度，‘添加的字符‘),ljust左边添加字符ljust(宽度，‘添加的字符‘),rjust右边边添加字符rjust(宽度，‘添加的字符‘)，zfill用0填充

name=‘egon‘

print(name.center(30,‘-‘))

print(name.ljust(30,‘*‘))

print(name.rjust(30,‘*‘))

print(name.zfill(50)) #用0填充

3.4.3 expandtabs

# #expandtabs 改动缩进空格数expandtabs(两组字符串之前空格个数)

name=‘egon\\thello‘

print(name)

print(name.expandtabs(1))

3.4.4 captalize,swapcase,title

# captalize,swapcase,title captalize首字母大写 swapcase大小写反转 title 字符串每段的首字母大写

print(name.capitalize()) #首字母大写

print(name.swapcase()) #大小写翻转

msg=‘egon say hi‘

print(msg.title()) #每个单词的首字母大写

3.4.5 is数字系列

#在python3中

num1=b‘4‘ #bytes

num2=u‘4‘ #unicode,python3中无需加u就是unicode

num3=‘四‘ #中文数字

num4=‘Ⅳ‘ #罗马数字

#isdigt:bytes,unicode

print(num1.isdigit()) #True

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

‘‘‘

3.4.6 is其他

#isdigit 全部由数字组成

# num=‘12345‘

# print(num.isdigit()) #全部为数字组成

#print(name.isalnum()) #字符串由字母或数字组成

#print(name.isalpha()) #字符串只由字母组成

#islower是否全小写 isupper是否全大写 isspace判断是否有空格 istitle是否首字母全大写

print(‘===>‘)

name=‘egon123‘

print(name.isalnum()) #字符串由字母或数字组成

print(name.isalpha()) #字符串只由字母组成

print(name.isidentifier())

print(name.islower())

print(name.isupper())

print(name.isspace())

print(name.istitle())

3.5 本节练习

# 写代码,有如下变量,请按照要求实现每个功能（共6分，每小题各0.5分）

name = " aleX"

# 1) 移除 name 变量对应的值两边的空格,并输出处理结果

name = ‘ aleX‘

a=name.strip()

print(a)

# 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果?

name=‘ aleX‘

if name.startswith(name):

print(name)

else:

print(‘no‘)

# 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果?

name=‘ aleX‘

if name.endswith(name):

print(name)

else:

print(‘no‘)

# 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果

name=‘ aleX‘

print(name.replace(‘l‘,‘p‘))

# 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。

name=‘ aleX‘

print(name.split(‘l‘))

# 6) 将 name 变量对应的值变大写,并输出结果?

name=‘ aleX‘

print(name.upper())

# 7) 将 name 变量对应的值变小写,并输出结果?

name=‘ aleX‘

print(name.lower())

# 8) 请输出 name 变量对应的值的第 2 个字符?

name=‘ aleX‘

print(name[1])

# 9) 请输出 name 变量对应的值的前 3 个字符?

name=‘ aleX‘

print(name[:3])

# 10) 请输出 name 变量对应的值的后 2 个字符??

name=‘ aleX‘

print(name[-2:])

# 11) 请输出 name 变量对应的值中 “e” 所在索引位置??

name=‘ aleX‘

print(name.index(‘e‘))

# 12) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。

name=‘ aleX‘

a=name[:-1]

print(a)

第4章列表

4.1 作用

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

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

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5] #本质my_girl_friends=list([...])

或

l=list(‘abc‘)

4.2 优先掌握的操作

#1、按索引存取值(正向存取+反向存取)：即可存也可以取

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

#3、长度

#4、成员运算in和not in

#5、追加

#6、删除

#7、循环

4.2.1 按索引存取值(正向存取+反向存取)：即可存也可以取

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5]

print(my_girl_friends [0])

4.2.2 切片(顾头不顾尾，步长)

l=[1,2,3,4,5,6]

print(l[2::1])#正向步长

print(l[2::-1])#反向步长

print(l[::-1])#列表反转

4.2.3 长度

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5]

#print(my_girl_friends.__len__())

print(len(my_girl_friends))

4.2.4 成员运算in和not in

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5]

print(‘wupeiqi‘ in my_girl_friends)

4.2.5 追加

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5]

#my_girl_friends[5]=3 #IndexError: list assignment index out of range

my_girl_friends.append(6)

print(my_girl_friends)

4.2.6 删除

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‘

###remove 只是单纯的删除不会返回删除的值，并且是按照值来删除

###pop 按照索引去删除默认从末尾开始删除，并且可以取出删除的值

4.2.7 循环

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5]

i=0

while i < len(my_girl_friends):

print(my_girl_friends[i])

i+=1

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5]

for item in my_girl_friends:

print(item)

for i in range(10):

if i== 3:

break

# continue

print(i)

else:

print(‘===>‘)

4.3 需要掌握的操作

4.3.1 insert

#向列表中的某个位置插入某些内容，可以自定义插入内容和插入位置

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘yuanhao‘,4,5]

my_girl_friends.insert(1,‘egon‘)

print(my_girl_friends)

4.3.2 clear

#清空表中所有内容

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘yuanhao‘,4,5]

my_girl_friends.clear()

print(my_girl_friends)

4.3.3 copy

#复制指定表的所有内容给另一个变量

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘yuanhao‘,4,5]

l=my_girl_friends.copy()

print(l)

4.3.4 count

#统计列表出现某个元素出现的次数

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘yuanhao‘,4,5]

print(my_girl_friends.count(‘yuanhao‘))

4.3.5 extend

# 两个列表合并，把另一个列表的全部内容赋值给另一个列表

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘yuanhao‘,4,5]

l=[‘egon1‘,‘egon2‘]

my_girl_friends.extend(l)

my_girl_friends.extend(‘hello‘)

print(my_girl_friends)

4.3.6 index

#查找列表中的某个元素所在位置，可以限制查询列表的范围

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘yuanhao‘,4,5]

print(my_girl_friends.index(‘wupeiqi‘))

print(my_girl_friends.index(‘wupeiqissssss‘))

4.3.7 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)

4.3.8 sort

#队列表中的内容进行排序，列表内容必须为纯数字或者为纯字符串，否则无法运行

l=[‘egon‘,‘alex‘,‘wupei‘]

l.sort()

print(l)

4.4 本节总结

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

2 有序

3可变：值变，id不变。可变==不可hash

4.5 本节练习

1. 有列表data=[‘alex‘,49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量

data=[‘alex‘,49,[1900,3,18]]

name=data[0]

age=data[1]

year=data[2][0]

mouse=data[2][1]

day=data[2][2]

print(name,age,year,mouse,day)

2. 用列表模拟队列

方法一：

l=[]

l.append(‘alex‘)

l.append(‘wupeiqi‘)

l.append(‘yuanhao‘)

l.append(‘huowentian‘)

print(l)

print(l.pop(0))

方法二：

l=[]

l.insert(0,‘alex‘)

l.insert(0,‘wupeqiqi‘)

l.insert(0,‘yuanhao‘)

l.insert(0,‘huowentian‘)

print(l)

print(l.pop())

3. 用列表模拟堆栈(先进后出，后进先出)

l1=[]

l1.append(‘first‘)

l1.append(‘second‘)

l1.append(‘third‘)

print(l1.pop())

4. 有如下列表，请按照年龄排序（涉及到匿名函数）

l=[

{‘name‘:‘alex‘,‘age‘:84},

{‘name‘:‘oldboy‘,‘age‘:73},

{‘name‘:‘egon‘,‘age‘:18},

]

答：

l2=[]

num1=l[2][‘age‘]

for i in l:

if num1 > i[‘age‘]:

l2.append(i)

else:

l2.insert(0,i)

print(l2)

l.sort(key=lambda abc:abc[‘age‘])

print(l)

第5章元组

5.1 作用

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

#定义：与列表类型比，只不过[]换成()

age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

print(id(age),type(age),age)

#t=(1,2,[‘a‘,‘b‘])

#print(id(t[2]))

#t[2][0]=‘A‘

#print(id(t[2]))

#print(t)

5.2 优先掌握的操作

#1、按索引取值(正向取+反向取)：只能取

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

#3、长度

#4、成员运算in和not in

#5、循环

5.2.1 按索引取值(正向取+反向取)：只能取

#查看元祖中某元素第一次出现所在索引位置，可以指定查看位置

ages=(10,20,18,33) #ages=tuble((10,12,18,33))

#print(id(ages),type(ages),ages)

print(ages.index(10))

5.2.2 切片(顾头不顾尾，步长)

age=(11,22,33,44,55)

print(age[0:3])

print(age)

5.2.3 长度

age=(11,22,33,44,55)

print(len(age))

5.2.4 成员运算in和not in

age=(11,22,33,44,55)

print(11 in age)

5.2.5 循环

age=(11,22,33,44,55)

for item in age:

print(item)

5.3 需要掌握的操作

5.3.1 index

#查看元祖中某元素第一次出现所在索引位置，可以指定查看位置

age=(11,22,33,44,55)

print(age.index(33))

print(age.index(33333))

5.3.2 count

#查看元祖某元素出现的次数

age=(11,22,33,44,55)

print(age.count(33))

5.4 本节总结

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

2 有序

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

5.5 本节练习(简单购物车)

#简单购物车,要求如下：

实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　

msg_dic={

‘apple‘:10,

‘tesla‘:100000,

‘mac‘:3000,

‘lenovo‘:30000,

‘chicken‘:10,

}

msg_dic={

‘apple‘:10,

‘tesla‘:100000,

‘mac‘:3000,

‘lenovo‘:30000,

‘chicken‘:10,

}

goods=[]

while True:

    for k in msg_dic:

        print(k,msg_dic[k])

    choice=input(‘商品名: ‘).strip()

    if len(choice) == 0 or choice not in msg_dic:

        print(‘商品名非法‘)

        continue

    while True:

        num=input(‘购买个数: ‘).strip()

        if num.isdigit():

            break

    goods.append((choice,msg_dic[choice],int(num)))

    print(‘购物车‘,goods)

简单购物车

第6章字典

6.1 作用

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

#定义：key必须是不可变类型，value可以是任意类型

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘} #本质info=dict({....})

或

info=dict(name=‘egon‘,age=18,sex=‘male‘)

或

info=dict([[‘name‘,‘egon‘],(‘age‘,18)])

或

{}.fromkeys((‘name‘,‘age‘,‘sex‘),None)

6.2 优先掌握的操作

#1、按key存取值：可存可取

#2、长度len

#3、成员运算in和not in

#4、删除

#5、键keys()，值values()，键值对items()

#6、循环

6.2.1 按key存取值：可存可取

d={‘name‘:‘egon‘}

print(d[‘name‘])

d[‘age‘]=18

print(d)

6.2.2 长度len

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}

print(len(info))

6.2.3 成员运算in和not in

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}

print(‘name‘ in info)

6.2.4 删除

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}

print(info.pop(‘name‘))

print(info)

print(info.popitem()) #(‘sex‘, ‘male‘)

print(info)

6.2.5 键keys()，值values()，键值对items() #了解

print(info.keys())

print(list(info.keys())[0])

print(list(info.values()))

print(list(info.items()))

6.2.6 循环

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}

for k in info:

print(k,info[k])

6.3 需要掌握的操作

6.3.1 get

# info.get() 查看某个key是否在字典里，如果在显示key在字典了则返回key对应的value，如果不在再不声明的情况下返回None，声明则显示返回内容。

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}

print(info[‘hobbies‘])

print(info.get(‘hobbies‘,‘没有‘))

6.3.2 pop

#info.pop() 字典删除指定key以及key对应的元素并获取值

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}

print(info.pop(‘name1‘,None))

6.3.3 update

#info.update() 连接字典，把另一个字典把所有值传递给字典。

d={‘x‘:1,‘y‘:2,‘name‘:‘EGON‘}

info.update(d)

print(info)

6.3.4 setdefault

#info.setdefault() 默认查看字典中的是否有对应的key，如果有，则获取对应key的value，如果没有就创建新的键值对。

info={‘name‘:‘egon‘,‘sex‘:‘male‘}

value=info.setdefault(‘age‘,18)

print(value)

info={‘name‘:‘egon‘,‘age‘:16,‘sex‘:‘male‘}

value=info.setdefault(‘age‘,18) #如果key存在，则不修改，返回已经有的key对应的value

print(value)

print(info)

###小练习

法一：append追加的方式

info={‘name‘:‘egon‘,}

info[‘hobbies‘]=[]

info[‘hobbies‘].append(‘music‘)

info[‘hobbies‘].append(‘read‘)

print(info)

法二：

info={‘name‘:‘egon‘,}

if ‘hobbies‘ not in info:

info[‘hobbies‘]=[]

else:

info[‘hobbies‘].append(‘music‘)

法三：setdefault方式

info={‘name‘:‘egon‘,}

hobbies_list=info.setdefault(‘hobbies‘,[])

print(hobbies_list)

hobbies_list.append(‘play‘)

hobbies_list.append(‘read‘)

print(info)

6.4 本节总结

1 可以存多个值，值都可以是任意类型,key必须是不可变类型

2 无序

3 可变：值变，id不变。可变==不可hash

6.5 本节练习

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

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

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

d={‘k1‘:[],‘k2‘:[]}

for num in nums:

    if num > 66:

        d[‘k1‘].append(num)

    if num < 66:

        d[‘k2‘].append(num)

print(d)

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的用法）

s=‘hello alex alex say hello sb sb‘

dic={}

words=s.split()

print(words)

for word in words: #word=‘alex‘

dic[word]=s.count(word)

print(dic)

#利用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)

第7章集合

7.1 集合前的引子

pythons=[‘egon‘,‘axx‘,‘ysb‘,‘wxx‘]

linuxs=[‘egon‘,‘oldboy‘,‘oldgirl‘,‘smallboy‘,‘smallgirl‘]

python_linux=[]

for student in pythons:

if student in linuxs:

python_linux.append(student)

print(python_linux)

7.2 作用

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

#定义：

知识点回顾

可变类型是不可hash类型

不可变类型是可hash类型

#定义集合:

集合：可以包含多个元素，用逗号分割，

集合的元素遵循三个原则：

1：每个元素必须是不可变类型(可hash，可作为字典的key)

2:没有重复的元素

3：无序

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

7.3 符号一览表

符号	定义
\|	合集
&	交集
-	差集
^	对称差集
==	相同集合
>，>= ，<,<=	父集，子集

7.4 优先掌握的操作

#1、长度len

#2、成员运算in和not in

#3、|合集

#4、&交集

#5、-差集

#6、^对称差集

#7、==

#8、父集：>,>=

#9、子集：<,<=

7.4.1 长度len

s={1,2,3,1} #s=set({1,2,3,1})

print(len(s))

7.4.2 成员运算in和not in

names={‘egon‘,‘alex‘}

print(‘egon‘ in names)

7.4.3 &交集:同时报名两门课程的学生

pythons={‘egon‘,‘axx‘,‘ysb‘,‘wxx‘}

linuxs={‘egon‘,‘oldboy‘,‘oldgirl‘,‘smallboy‘,‘smallgirl‘}

print(pythons & linuxs)

print(pythons.intersection(linuxs))

7.4.4 |合集:老男孩所有的学生

pythons={‘egon‘,‘axx‘,‘ysb‘,‘wxx‘}

linuxs={‘egon‘,‘oldboy‘,‘oldgirl‘,‘smallboy‘,‘smallgirl‘}

print(pythons | linuxs)

print(pythons.union(linuxs))

7.4.5 ^对称差集:没有同时报名两门课程

pythons={‘egon‘,‘axx‘,‘ysb‘,‘wxx‘}

linuxs={‘egon‘,‘oldboy‘,‘oldgirl‘,‘smallboy‘,‘smallgirl‘}

print(pythons ^ linuxs)

print(pythons.symmetric_difference(linuxs))

7.4.6 -差集：只报名python课程的学生

pythons={‘egon‘,‘axx‘,‘ysb‘,‘wxx‘}

linuxs={‘egon‘,‘oldboy‘,‘oldgirl‘,‘smallboy‘,‘smallgirl‘}

print(pythons - linuxs)

print(pythons.difference(linuxs))

#### -差集：只报名linux课程的学生

pythons={‘egon‘,‘axx‘,‘ysb‘,‘wxx‘}

linuxs={‘egon‘,‘oldboy‘,‘oldgirl‘,‘smallboy‘,‘smallgirl‘}

print(linuxs-pythons)

7.4.7 父集:>,>=,子集：<，<=

###实例一

s1={1,2,3}

s2={1,2,}

print(s1 >= s2)

print(s1.issuperset(s2))

print(s2.issubset(s1))

###实例二

linuxs={‘egon‘,‘oldboy‘,‘oldgirl‘,‘smallboy‘,‘smallgirl‘}

for student in linuxs:

print(student)

7.5 了解的知识点

7.5.1 difference() 差集

s1={1,2,3}

s2={1,2,}

print(s1-s2)

print(s1.difference(s2))

7.5.2 difference_update 求s1和s2的差集并把值赋值给s1

s1={1,2,3}

s2={1,2,}

s1.difference_update(s2) #s1=s1.difference(s2)

print(s1)

7.5.3 pop() 随机删除一个集合内的元素

# s2={1,2,3,4,5,‘a‘}

# print(s2.pop())

# s2.add(‘b‘)

# print(s2)

7.5.4 discard与remove

###discard() 删除集合中存在的指定元素并返回删除元素后的集合，如果删除的元素不存在，则返回原集合

###remove 删除集合中存在的指定元素并返回删除元素后的集合，如果删除的元素不存在，则报错

s2={1,2,3,4,5,‘a‘}

s2.discard(‘b‘)

s2.remove(‘b‘) #删除的元素不存在则报错

print(s2)

7.5.5 isdisjoint() #判断是否是相交集，返回bool值

s1={1,2,3,4,5,‘a‘}

s2={‘b‘,‘c‘,}

print(s1.isdisjoint(s2)) #两个集合没有共同部分时，返回值为True

7.5.6 update() 拼接一个集合到另外一个集合

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}))

7.6 本节练习

7.6.1 关系运算

# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合

pythons={‘alex‘,‘egon‘,‘yuanhao‘,‘wupeiqi‘,‘gangdan‘,‘biubiu‘}

linuxs={‘wupeiqi‘,‘oldboy‘,‘gangdan‘}

# 求出即报名python又报名linux课程的学员名字集合

print(pythons & linuxs)

# 求出所有报名的学生名字集合

print(pythons | linuxs)

# 求出只报名python课程的学员名字

print(pythons - linuxs)

# 求出没有同时这两门课程的学员名字集合

print(pythons ^ linuxs)

7.6.2 去重

　　 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‘},

]

答：

#去重,无需保持原来的顺序

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‘},

]

# 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‘]))))

第8章数据类型总结

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

数字

字符串

集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息，不可变

列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

8.2 按存值个数区分

标量／原子类型数字，字符串

容器类型列表，元组，字典

8.3 按可变不可变区分

可变列表，字典

不可变数字，字符串，元组

8.4 按访问顺序区分

直接访问数字

顺序访问（序列类型）字符串，列表，元组

key值访问（映射类型）字典

第9章运算符

#身份运算（is ，is not）

is比较的是id，而双等号比较的是值

毫无疑问，id若相同则值肯定相同，而值相同id则不一定相同

>>> x=1234567890

>>> y=1234567890

>>> x == y

True

>>> id(x),id(y)

(3581040, 31550448)

>>> x is y

False

第10章字符编码

10.1 字符编码总结

1、存取文件不乱码的法则：用什么编码存的，就要用什么编码读

2、

unicode-----encode----->gbk

gbk-------->decode----->unicode

3、

python3解释器默认使用的字符编码是utf-8

python2解释器默认使用的字符编码是ascii

python2的str就是python3的bytes

python2的unicode就是python3的str

10.2 字符编码测试

#coding:gbk

# x=‘上‘

# y=‘下‘

# # print([x,y])

# print(x)

# z=u‘上‘

# print([z,])

# z=u‘上‘

# print(z)

x=‘上‘ #gbk,python2的str类型，

# print([x.decode(‘gbk‘),])

print(type(x))

bytes

x=u‘上‘ # python2的unicode字符串就是python3的str类型

# print([x.encode(‘gbk‘),])

print(type(x))

10.3 在python3中的字符串

#!/usr/bin/env python

# -*- coding: utf-8 -*-

x=‘上‘ #在python3中字符串，默认就是unicode

# print(x.encode(‘gbk‘))

# print(x.encode(‘utf8‘))

# print(type(x.encode(‘gbk‘)))

# b=x.encode(‘utf-8‘)

# print(type(b.decode(‘utf-8‘)))

第11章文件处理

http://www.cnblogs.com/linhaifeng/articles/5984922.html

11.1 在python中

#1. 打开文件，得到文件句柄并赋值给一个变量

f=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘) #默认打开模式就为r

#2. 通过句柄对文件进行操作

data=f.read()

#3. 关闭文件

f.close()

11.2 f=open(‘a.txt‘,‘r‘)的过程分析

#1、由应用程序向操作系统发起系统调用open(...)

#2、操作系统打开该文件，并返回一个文件句柄给应用程序

#3、应用程序将文件句柄赋值给变量f

# f=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘)

# data=f.read()

# print(data)

# print(f)

# f.close() #文件关闭，回收操作系统的资源

# print(f)

# f.read()

# with open(‘a.txt‘,‘r‘,encoding=‘utf-8‘) as f: #f=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘)

# pass

11.2.1 读操作:r只读模式，默认是rt文本读

#读操作:r只读模式，默认是rt文本读

# f=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘)

# # data1=f.read()

# # print(‘=1===>‘,data1)

# # data2=f.read()

# # print(‘=2===>‘,data2)

# # print(f.readlines())

# # print(f.readline(),end=‘‘)

# f.close()

11.2.2 写操作:w只写模式，默认是wt文本写

#写操作:w只写模式，默认是wt文本写，如果文件不存在则创建，存在则清空+覆盖

f=open(‘a.txt‘,‘w‘,encoding=‘utf-8‘)

# f.write(‘11111\\n‘)

# f.write(‘222222\\n‘)

# f.write(‘1111\\n2222\\n3333\\n‘)

# f.writelines([‘哈哈哈哈\\n‘,‘你好‘,‘alex‘])

f.close()

11.3 强调！！！

11.3.1 强调第一点

#强调第一点：

打开一个文件包含两部分资源：操作系统级打开的文件+应用程序的变量。在操作完毕一个文件时，必须把与该文件的这两部分资源一个不落地回收，回收方法为：

1、f.close() #回收操作系统级打开的文件

2、del f #回收应用程序级的变量

其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件还没有关闭，白白占用资源，

而python自动的垃圾回收机制决定了我们无需考虑del f，这就要求我们，在操作完毕文件后，一定要记住f.close()

虽然我这么说，但是很多同学还是会很不要脸地忘记f.close(),对于这些不长脑子的同学，我们推荐傻瓜式操作方式：使用with关键字来帮我们管理上下文

with open(‘a.txt‘,‘w‘) as f:

pass

with open(‘a.txt‘,‘r‘) as read_f,open(‘b.txt‘,‘w‘) as write_f:

data=read_f.read()

write_f.write(data)

11.3.2 强调第二点

#强调第二点：

f=open(...)是由操作系统打开文件，那么如果我们没有为open指定编码，那么打开文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。

这就用到了上节课讲的字符编码的知识：若要保证不乱码，文件以什么方式存的，就要以什么方式打开。

f=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘)

11.4 python2中的file与open

#首先在python3中操作文件只有一种选择，那就是open()

#而在python2中则有两种方式：file()与open()

两者都能够打开文件，对文件进行操作，也具有相似的用法和参数，但是，这两种文件打开方式有本质的区别，file为文件类，用file()来打开文件，相当于这是在构造文件类，而用open()打开文件，是用python的内建函数来操作，我们一般使用open()打开文件进行操作，而用file当做一个类型，比如type(f) is file

11.5 打开文件的模式

文件句柄 = 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)

#1. 打开文件的模式有(默认为文本模式)：

r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】

w，只写模式【不可读；不存在则创建；存在则清空内容】

a，之追加写模式【不可读；不存在则创建；存在则只追加内容】

#2. 对于非文本文件，我们只能使用b模式，"b"表示以字节的方式操作（而所有文件也都是以字节的形式存储的，使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式）

注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码

#3. 了解部分

"+" 表示可以同时读写某个文件

r+，读写【可读，可写】

w+，写读【可读，可写】

a+，写读【可读，可写】

x，只写模式【不可读；不存在则创建，存在则报错】

x+ ，写读【可读，可写】

11.6 操作文件的方法

11.6.1 使用方法

#掌握

f.read() #读取所有内容,光标移动到文件末尾

f.readline() #读取一行内容,光标移动到第二行首部

f.readlines() #读取每一行内容,存放于列表中

f.write(‘1111\\n222\\n‘) #针对文本模式的写,需要自己写换行符

f.write(‘1111\\n222\\n‘.encode(‘utf-8‘)) #针对b模式的写,需要自己写换行符

f.writelines([‘333\\n‘,‘444\\n‘]) #文件模式

f.writelines([bytes(‘333\\n‘,encoding=‘utf-8‘),‘444\\n‘.encode(‘utf-8‘)]) #b模式

#了解

f.readable() #文件是否可读

f.writable() #文件是否可读

f.closed #文件是否关闭

f.encoding #如果文件打开模式为b,则没有该属性

f.flush() #立刻将文件内容从内存刷到硬盘

f.name

11.6.2 小练习

练习，利用b模式，编写一个cp工具，要求如下：

　　1. 既可以拷贝文本又可以拷贝视频，图片等文件

　　2. 用户一旦参数错误，打印命令的正确使用方法，如usage: cp source_file target_file

　　提示：可以用import sys，然后用sys.argv获取脚本后面跟的参数

import sys

if len(sys.argv) != 3:

    print(‘usage: cp source_file target_file‘)

    sys.exit()

 

source_file,target_file=sys.argv[1],sys.argv[2]

with open(source_file,‘rb‘) as read_f,open(target_file,‘wb‘) as write_f:

    for line in read_f:

        write_f.write(line)

View Code

11.7 文件内光标移动

11.7.1 介绍

一: read(3)：

　　1. 文件打开方式为文本模式时，代表读取3个字符

　　2. 文件打开方式为b模式时，代表读取3个字节

二: 其余的文件内光标移动都是以字节为单位如seek，tell，truncate

注意：

　　1. seek有三种移动方式0，1，2，其中1和2必须在b模式下进行，但无论哪种模式，都是以bytes为单位移动的

　　2. truncate是截断文件，所以文件的打开方式必须可写，但是不能用w或w+等方式打开，因为那样直接清空文件了，所以truncate要在r+或a或a+等模式下测试效果

11.7.2 练习：基于seek实现tail -f功能

####练习：基于seek实现tail -f功能

import time

with open(‘test.txt‘,‘rb‘) as f:

    f.seek(0,2)

    while True:

        line=f.readline()

        if line:

            print(line.decode(‘utf-8‘))

        else:

            time.sleep(0.2)

练习：基于seek实现tail -f功能

11.8 文件的修改

11.8.1 介绍

文件的数据是存放于硬盘上的，因而只存在覆盖、不存在修改这么一说，我们平时看到的修改文件，都是模拟出来的效果，具体的说有两种实现方式：

方式一：将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）

import os

with open(‘a.txt‘) as read_f,open(‘.a.txt.swap‘,‘w‘) as write_f:

data=read_f.read() #全部读入内存,如果文件很大,会很卡

data=data.replace(‘alex‘,‘SB‘) #在内存中完成修改

write_f.write(data) #一次性写入新文件

os.remove(‘a.txt‘)

os.rename(‘.a.txt.swap‘,‘a.txt‘)

方式二：将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件

import os

with open(‘a.txt‘) as read_f,open(‘.a.txt.swap‘,‘w‘) as write_f:

for line in read_f:

line=line.replace(‘alex‘,‘SB‘)

write_f.write(line)

os.remove(‘a.txt‘)

os.rename(‘.a.txt.swap‘,‘a.txt‘)

11.8.2 小练习

1. 文件a.txt内容：每一行内容分别为商品名字，价钱，个数，求出本次购物花费的总钱数

apple 10 3

tesla 100000 1

mac 3000 2

lenovo 30000 3

chicken 10 3

with open(‘a.txt‘,mode=‘r‘,encoding=‘utf-8‘) as f:

 lines=f.readlines()

sum=0

for line in lines:

     l = line.replace(‘\\n‘,‘‘)

     k = l.split(‘ ‘)

     sum=sum + int(k[1])*int(k[2])

print(sum)

View Code

2. 修改文件内容，把文件中的alex都替换成SB

import os

with open(‘e.txt‘,‘r‘,encoding=‘utf-8‘) as read_f,
        open(‘.e.txt‘,‘w‘,encoding=‘utf-8‘) as write_f:

    for line in read_f:

        line=line.replace(‘alex‘,‘sb‘)

        write_f.write(line)

os.remove(‘e.txt‘)

os.rename(‘.e.txt‘,‘e.txt‘)

View Code

第12章作业

12.1 作业一: 三级菜单

#作业一: 三级菜单

#要求:

打印省、市、县三级菜单

可返回上一级

可随时退出程序

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#省列表 list(l.key) 市列表 list(l[‘city‘].keys())  县列表list(l[‘city‘][‘street‘])

l={

    ‘河南省‘:{‘许昌市‘:[‘鄢陵县‘,‘襄城县‘,‘许昌县‘],‘开封市‘:[‘通许县‘,‘尉氏县‘,‘兰考县‘],‘周口市‘:[‘扶沟县‘,‘西华县‘,‘太康县‘]},

    ‘山东省‘:{‘滨州市‘:[‘无棣县‘,‘邹平县‘,‘博兴县‘],‘济宁市‘:[‘金乡县‘,‘鱼台县‘,‘梁山县‘],‘东营市‘:[‘利津县‘,‘广饶县‘,‘垦利县‘]},

    ‘河北省‘:{‘邯郸市‘:[‘大名县‘,‘磁县‘,‘魏县‘],‘保定市‘:[‘雄县‘,‘容城县‘,‘望都县‘],‘廊坊市‘:[‘固安县‘,‘永清县‘,‘香河县‘]},

}

count=0

while True:

    if count==0:

        city=input(‘{} \\n请输入省份:  ‘.format(list(l.keys()))).strip()

        while city not in list(l.keys()):

            if city == ‘quit‘:

                exit()

            city=input(‘{} 未在省份列表内，请您重新输入:  ‘.format(city)).strip()

        count+=1

    elif count==1:

        area=input(‘{} \\n请输入市:  ‘.format(list(l[city].keys()))).strip()

        while area not in list(l[city].keys()):

            if area == ‘quit‘:

                exit()

            elif area == ‘back‘:

                count-=2

                break

            area=input(‘{} 未在市列表内，请您重新输入:  ‘.format(area)).strip()

        count+=1

    elif count==2:

        street=input(‘{}\\n请输入县:  ‘.format(list(l[city][area])))

        while street not in list(l[city][area]):

            if street == ‘quit‘:

                exit()

            elif street == ‘back‘:

                count-=2

                break

            street=input(‘{} 未在县列表内，请您重新输入:   ‘.format(street)).strip()

        count+=1

    else:

        print(‘输入back可返回上一级，输入quit可直接退出‘.center(30,‘#‘))

        while True:

            content=input(‘>>:  ‘)

            if content == ‘quit‘:

                exit()

            elif content == ‘back‘:

                count-=1

                break

打印三级菜单

12.2 作业二：请闭眼写出购物车程序

#作业二：请闭眼写出购物车程序

#需求:

用户名和密码存放于文件中，格式为：egon|egon123

启动程序后，先登录，登录成功则让用户输入工资,然后打印商品列表，失败则重新登录，超过三次则退出程序

允许用户根据商品编号购买商品

用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒

可随时退出，退出时，打印已购买商品和余额

#!/usr/bin/env python

# -*- coding: utf-8 -*-

product_list = [

        ["Iphone",6800],

        ["MAC PRO",16800],

        ["红米5plus",1299],

        ["空气净化器",800],

]

shopping_list = []

salary = input("请输入你的工资：")

#判断是否为数字

if salary.isdigit():

    salary = int(salary)

    while True:

        for index,item in enumerate(product_list):

            #打出菜单

            print(index,item[0],item[1])

        choice = input("请选择要购买的商品编号[quit]>>：")

        if choice.isdigit():

            choice = int(choice)

            if choice >=0 and choice < len(product_list):

                #判断钱是否够用

                p = product_list[choice]

                if p[1] <= salary:

                    shopping_list.append(p)

                    salary -= p[1]

                    print("Added \\033[32;1m[%s]\\033[0m into your shopping cart,and your current balance is \\033[1;31;40m%s\\033[0m"%(p,salary))

                else:

                    print("钱不够，你只有 \\033[5;31;42m[%s] \\033[0m "% salary)

            else:

                print("没有此商品...")

        elif choice == "quit":

            print("已购买的商品".center(50,"-"))

            for i in shopping_list:

                print(i)

            print("Your left balance is ",salary)

            exit()

        else:

            print("未识别，请输入正确的指令！！")

购物车程序

以上是关于Python20期课堂总结-20171209-Python数据类型字符编码文件处理的主要内容，如果未能解决你的问题，请参考以下文章

Python20期课堂总结-20180113day6-常用模块与面向对象基础

Python20期课堂总结-20180127day8-异常处理与网络编程

Python20期课堂总结-20180120day7-面向对象之继承组合多态封装等

老男孩Linux运维第41期20171016第六周学习重点课堂记录

第20期-什么是朴素贝叶斯算法

老男孩Linux运维第41期20170924开班第五周学习重点课堂记录

Python20期课堂总结-20171209-Python数据类型字符编码文件处理

第1章 上节课课程回顾

1.1 安装python解释器

1.2 变量

1.3 数据类型

1.4 用户与程序交互

1.5 格式化输出

1.6 基本运算符

1.7 if判断

1.8 while

1.9 数据类型

1.9.1 数据有哪些类型

1.9.2 数据类型总结

第2章 数字类型

2.1 整型与浮点型

2.1.1 整型int

2.1.2 浮点型float

2.2 其他数字类型（了解）

2.2.1 长整形（了解）

2.2.2 复数（了解）

第3章 字符串类型

3.1 作用

3.2 优先掌握的操作

3.2.1 按索引取值(正向取+反向取) ：只能取

3.2.2 切片(顾头不顾尾，步长)

3.2.3 长度len

3.2.4 成员运算in和not in

3.2.5 移除空白strip

3.2.6 切分split

3.2.7 循环

3.2.8 该类型总结

3.3 需要掌握的操作

3.3.1 strip,lstrip,rstrip

3.3.2 lower,upper

3.3.3 startswith,endswith

3.3.4 format的三种玩法

3.3.5 split,rsplit

3.3.6 join

3.3.7 replace

3.3.8 isdigit

3.4 其他操作（了解即可）

3.4.1 find,rfind,index,rindex,count

3.4.2 center,ljust,rjust,zfill

3.4.3 expandtabs

3.4.4 captalize,swapcase,title

3.4.5 is数字系列

3.4.6 is其他

3.5 本节练习

第4章 列表

4.1 作用

4.2 优先掌握的操作

4.2.1 按索引存取值(正向存取+反向存取)：即可存也可以取

4.2.2 切片(顾头不顾尾，步长)

4.2.3 长度

4.2.4 成员运算in和not in

4.2.5 追加

4.2.6 删除

4.2.7 循环

4.3 需要掌握的操作

4.3.1 insert

4.3.2 clear

4.3.3 copy

4.3.4 count

4.3.5 extend

4.3.6 index

4.3.7 reverse

4.3.8 sort

4.4 本节总结

4.5 本节练习

第5章 元组

5.1 作用

5.2 优先掌握的操作

5.2.1 按索引取值(正向取+反向取)：只能取

5.2.2 切片(顾头不顾尾，步长)

5.2.3 长度

5.2.4 成员运算in和not in

5.2.5 循环

5.3 需要掌握的操作

5.3.1 index

5.3.2 count

第1章上节课课程回顾

第2章数字类型

2.2.2 复数（了解）　　

第3章字符串类型

第4章列表

第5章元组

第6章字典

第7章集合

7.5.2 difference_update 求s1和s2的差集并把值赋值给s1

第8章数据类型总结

第9章运算符

第10章字符编码

第11章文件处理

第12章作业