python入门day02数据类型

字符串：数据类型的学习

#======================================基本使用======================================
#1、用途

#2、定义方式

#3、常用操作+内置的方法

#======================================该类型总结====================================
#存一个值or存多个值

#有序or无序

#可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

• 一、字符串索引

s2 = 'abc123嘿嘿'

# 正向索引，从0开始编号
print(s2[3])
# 反向索引，从-1开始编号
print(s2[-3])

•  二、字符串切片

切片：(获取子字符串):

语法[开始索引:结束索引:步长]
i) 步长省略，默认为1
ii) 起始索引省略，默认为从头开始
iii) 结束索引省略，默认到最后结束

# 顾头不顾尾[6:8]，从索引6截取到索引8之前
ss2 = 'hello world'
new_ss2 = ss2[6:8:]
print(new_ss2)
>wo
# 结束索引:-1代表截取到最后一位之前，省略代表截取到最后
# 开始索引省略代表从头开始截取
print(ss2[6:-1:])
>worl
# 截取一次只截取一个字符，但是截取后迈2步截取下一个hlowrd
print(ss2[::2])
>hlowrd
# 打印'dlrow olleh'，翻转字符串
# 步长为负数时，从后往前截取(开始索引建议使用负值)
print(ss2[-1::-1])
>dlrow olleh

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

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

#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
#2、切片(顾头不顾尾，步长)
#3、长度len
#4、成员运算in和not in
#5、移除空白strip
#6、切分split
#7、循环

需要掌握：

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

# 1.获取字符串长度
s3 = 'abcdef'
print(len(s3))  # len(s) 获取s的字符长度
>6

# 2.成员运算
#语法：in | not in：子字符串是否在父字符串中
s5 = 'abc123嘿嘿'
# in | not in: 子字符串 in 父字符串
print('abcd' in s5)
print('abc' not in s5)
print('呵呵' not in s5)
>False
>False
>True
# not in要同步出现
# print('>>>', '呵呵' not in s5)
# 3.首尾去白 #语法：strip()
print(' hello wolrd  '.strip())
>hello wolrd
print('===login success==='.strip('='))
>login success
# 4.拆分
#语法：split(拆分规则, 拆分次数) 

print('D:\\python36\\python3.exe'.split('\\', 1))
>['D:', 'python36\\python3.exe']
s4 = "D:\\pathon36\\python3.exe"
# 需求：1.获取python的安装盘符；2.获取python的执行文件
s4_list = s4.split('\\')  # 拆分：就是将字符串转化为列表
print(s4_list)
>['D:', 'pathon36', 'python3.exe']
print(s4_list[0])
>D:
print(s4_list[-1])
>python3.exe
# 完成以上需求还要保证拆分得到的结果尽可能短
## 注：拆分的依据，拆分的次数
s4_list = s4.split('\\', 1)
print(s4_list[0])

#strip,lstrip,rstrip
name='*egon**'
print(name.strip('*')) # *全部去掉
print(name.lstrip('*')) # 去掉左边的* leftstrip=lstrip
print(name.rstrip('*')) # 去掉右边的* rightstrip=rstrip

#lower,upper
name='simoN'
print(name.lower()) # name内容全部小写
print(name.upper()) # name内容全部大写

#startswith,endswith
name='alex_SB'
print(name.endswith('SB'))      #以SB结尾为真：True
print(name.startswith('alex'))  #以alex开头为真：True

#format的三种玩法
res='{} {} {}'.format('egon',18,'male')
>egon 18 male
res='{1} {0} {1}'.format('egon',18,'male')
>18 egon 18
res='{name} {age}{sex}'.format(sex='male',name='egon',age=18)
>egon 18 male

#split
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)) #从右开始切分
>['a|b', 'c']

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

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
>SB say :i have one tesla,my name is alex

#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age=input('>>: ')
print(age.isdigit())

各类参数例子

参数

#  rsplit：从右开始拆分
s4 = "D:\\pathon36\\python3.exe"
s4_list = s4.rsplit('\\', 1)
print(s4_list)

#  startswith | endswith：以某某开头 | 结尾：返回值为bool类型
print("http://www.baidu.com".startswith('https://'))
print("http://www.baidu.com".endswith('com'))  # 思考：自学正则：re

#  format：格式化
print('name:%s，age:%s' % ('owen', 18))
# 占位与实际数据要进行个数与位置的匹配
print('name:{}，age:{}'.format('Liuxx', 8))
# 指定位置要数据：{0}要0号位数据
print('name:{0}，age:{1}, name:{0}'.format('Linoo', 58))
# 指定名字要数据
print('name:{usr}，age:{age}, name:{usr}'.format(age=58, usr='Linoo'))

#  replace：替换
# 语法：replace(oldS, newS, count)
s6 = 'abcabcabc'
newS6 = s6.replace('a', 'A', 2)
print(newS6)

补充

参数补充

# 1. find | rfind：查找子字符串索引，无结果返回-1
s1 = 'abcabc'
print(s1.rfind('ab'))  # 返回第一次查询到的（目标字符串首位）正向索引

# 2. index | rindex：查找子字符串索引，无结果抛出异常
print(s1.index('cb'))  # 崩溃

# # 3. count：计算子字符串个数
print(s1.count('abc'))
#
# 4. center | ljust | rjust | zfill：按位填充,一般在进制时使用，不足填0
# 语法：center(所占位数, '填充符号')
# 使用： 调用者.center(参数)
print("华丽分割线".center(30, '-'))
print("华丽分割线".ljust(30, '-'))
print("".zfill(5))
print("".zfill(5))
print("".zfill(5))
#
# # 5. expandtabs：规定\t所占空格数
print('hello\tworld'.expandtabs(8))
#
# # 6. captialize | title | swapcase：首字母大写 | 单词首字母大写 | 大小写反转
print("hello world".capitalize())
print("hello world".title())
print("hello WORLD".swapcase())
#
# # 7. isdigit | isdecimal | isnumeric：数字判断
s7 = b''  # isdigit来判断是否可以转换为数字
print(b''.isdigit())
# 三个方法均有
print(u''.isdigit())
print(u''.isdecimal())
print(u''.isnumeric())

print('肆'.isdigit())
print('肆'.isdecimal())
print('肆'.isnumeric())  # 可以判断中文数字
print('Ⅳ'.isdigit())
print('Ⅳ'.isdecimal())  # 不用管
print('Ⅳ'.isnumeric())  # 可以判断罗马数字
#
# # 8. isalnum | isalpha：是否由字母数字组成 | 由字母组成
print('abc123_'.isalnum())
print('abc'.isalpha())
#
# # 9. isidentifier：是否为合法变量名
print('>>>', 'a_123'.isidentifier())
#
# # 10. islower | isupper：是否全小 | 大写
print("aBc".islower())
print("ABC".isupper())
#
# # 11. isspace：是否是空白字符
print(" ".isspace())
#
# 12. istitle：是否为单词首字母大写格式
print("Hello World".istitle())

• 三、字符串循环

s = 'hello world'

# 字符串循环（遍历）
i = 0
while i < len(s):
    print(s[i])
    i += 1

# 迭代
for c in s:
    print(c)
# 总结：
# 1.循环迭代s，一次在s中取出一个字符，存放到c中
# 2.下一次取出会覆盖上一次c
# 3.当s中所有字符取出后，循环自动停止

# 哪些变量是可以被迭代的：str、list、dict、tuple、set、range生产的对象
print(range(5))
# 从什么数字开始，到什么数字前结束，步长是多少
for i in range(1, 5, 2):
    print(i)

for i in range(10, 16):
    print(i)

# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

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

# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
# 6)    将 name 变量对应的值变大写,并输出结果

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

# 8)    请输出 name 变量对应的值的第 2 个字符
# 9)    请输出 name 变量对应的值的前 3 个字符
# 10)    请输出 name 变量对应的值的后 2 个字符
# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

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

练习题目

name = " aleX"

# 1)
print(name.strip())  # >aleX
# 2)
print(name.startswith("al")) # >False
# 3)
print(name.endswith("X")) # >True
# 4)
print(name.replace('l','p')) #> apeX
#5)
print(name.split("l")) # >[' a', 'eX']
# 6)
print(name.lower()) # > alex
# 7)
print(name.upper()) # > ALEX
# 8)
print(name[2]) #> l
# 9)
print(name[:3]) # > al
# 10)
print(name[3:]) # >eX
print(name[-2:]) #步长为正数时从前往后取值，为负数时从后往前取值
#11)
print(name.index("e")) # >3
#12)
print(name[:4]) #> ale
print(name[:-1]) #> ale

练习结果

• 四、可变和不可变类型

# 数字
# 1.只能存放一个值
# 2.数字为不可变类型: 值改变了id一定改变（值一旦确定，就不能再修改）

a = 10
print(id(a))
# a = 11
a += 1
print(id(a))

# 字符串
# 1.只能存放一个值
# 2.字符串为不可变类型
s = ''
print(id(s))
s = s * 2
print(id(s))

# 列表: 为可变类型，在id不改变的情况下，还可以修改内部数据
l = [1, 2, 3]
print(id(l))
# print(l[0])
l[0] = 10
print(id(l))
l.append(20)
print(id(l))

• 五、列表

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

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

l1 = [1, 3.14, 5 + 4j, True, 'abc', [[1]]]
print(l1)

l2 = list([1, 3.14, 5 + 4j, True, 'abc', [[1]]])
print(l2)

#优先掌握的操作： #1、按索引存取值(正向存取+反向存取)：即可存也可以取  #2、切片(顾头不顾尾，步长) #3、长度 #4、成员运算in和not in #5、追加 #6、删除 #7、循环

#ps:反向步长
l=[1,2,3,4,5,6]

#正向步长
l[0:3:1] #[1, 2, 3]
#反向步长
l[2::-1] #[3, 2, 1]
#列表翻转
l[::-1] #[6, 5, 4, 3, 2, 1]

1.字符串转换为列表

# 将字符串转换为列表: 字符串方法
l3 = 'hello world'.split(' ')
print(l3)

# 将列表转换为字符串: 字符串方法，调用方法的字符串为拼接字符串的依据
# 将列表中的所有数据，从前往后，安装拼接符进行拼接
newStr = '@'.join(l3)  # hello@world
print(newStr)

列表转换为字符串：

l = ["hi","hello","world"]
print(" ".join(l))

2.列表切片

list3 = [1, 2, 3, 4, 5]
print(list3[1:-1:2])  # [2, 4]

3.列表的增删改查

#1. 删除普通变量
a = 10
del a
print(a)

#2. 增：append(obj) 在末尾添加对象
list4 = []
print(id(list4)) #id:35656200
list4.append(1)
list4.append(5)
list4.append(2)
print(list4)       #[1, 5, 2]
print(id(list4)) # id:35656200

#3. 插入(对应位置插入数据)
list4.insert(0, 10)
print(list4)    #[10, 1, 5, 2]
print(id(list4)) #

#4. 删
# 删除指定索引
del list4[0]
print(list4) # [1, 5, 2]
# 删除指定对象
list4.remove(5)
print(list4) #[1, 2]

#5. 改：
list4[0] = 10000
print(list4) #[10000, 2]

#6. 查
print(list4[1]) #

#7.长度
print(list4)
list4.append(88888)
print(len(list4))  # list4: [10000, 2, 88888] 共3个值

#8. 成员运算
print(2 in list4)  #True

# 9. 循环：迭代
list7 = [1, 3, 5, 7, 0]

for obj in list7:
    print(obj, end=',')
# 1,3,5,7,0,

# 需求：打印1,3,5,7,0
sss = ""
for obj in list7:
    sss += str(obj) + ','  # obj是int类型，不能直接做字符串拼接，转化成字符串
print('>>>', sss[:-1])
# >>> 1,3,5,7,0

增删改查

# 翻转
a = [1, 3, 2]
a.reverse()
print(a) # [2, 3, 1]

# 排序:
# 前提：1.数据之间全部具有可比性；2：数据要统一类型
b = [1, 3, 2, 5, 4]
b.sort()
print(b) # [1, 2, 3, 4, 5]
# 倒序
b.reverse()
print(b) # [4, 5, 2, 3, 1]
b.sort(reverse=True)
print(b) # [5, 4, 3, 2, 1]

''' ***
1. copy：复制
2. clear：清空
3. count：计算成员个数
4. extend：添加多个值(参数为可迭代对象)
5. index：查找索引
'''
x = [1, 3, 5, 3]
y = x
print(x, id(x)) # [1, 3, 5, 3] 32117256
print(y, id(y)) # [1, 3, 5, 3] 32117256

z = x.copy()
print(z, id(z)) # [1, 3, 5, 3] 32091976
#copy复制,id会变,x值被修改，但copy出来的z却不会
x[0] = 10000
print(x[0]) #
print(y[0]) #
print(z[0]) #
#清空列表
z.clear()
print(z) # []
#统计成员个数
# # [10000, 3, 5, 3]
print(x.count(3))  # 2  3在列表中的总数量
#extend添加多个值
list1 = []
list1.extend('abc')
print(list1) # ['a', 'b', 'c']
#
list2 = ['abc', 'xyz']
list1.extend(list2)
print(list1) # ['a', 'b', 'c', 'abc', 'xyz']

参数补充

max(list)：返回列表元素最大值
min(list)：返回列表元素最小值
list(seq)：将元组转换为列表

总结：
1. 列表中可以存放多个值
2. 列表为可变类型：id不变的情况下，可以发生值变化
3. 列表为有序存储结构：可以通过索引取值

"""
#zip dict index list enumerate（取下标） len
s为字符串
s.isalnum() 所有字符都是数字或者字母
s.isalpha() 所有字符都是字母
s.isdigit() 所有字符都是数字
s.islower() 所有字符都是小写
s.isupper() 所有字符都是大写
s.istitle() 所有单词都是首字母大写，像标题
s.isspace() 所有字符都是空白字符、\t、\n、\r
"""
"""
name = "my \tname is {name} and I am {year} yearold"
print(name.capitalize())  #首字母大写
print(name.count("o"))  #统计出现o的次数
print(name.center(10,"-"))
print(name.endswith("on"))  #判断以什么结尾，True
print(name.expandtabs(tabsize=10))  #转换空格，很少用
print(name.find("name")) #列表中以什么开头
print(name[name.find("name"):]) #字符串切片
print(name.format(name='alex',year=23))
print(name.format_map( {'name':'alex','year':12} ))
print(name.isalnum())   #isalnum判断是不是阿拉伯数字，不能有特殊字符
print(name.isalpha())  #纯因为字符
print('1'.isdecimal())  #
print('11'.isdigit()) #是不是整数
print('_1A'.isidentifier()) #判断是不是一个合法的标识符或合法的变量名
print('11'.isnumeric())  #是不是一个整数字
print(' '.isspace()) #是不是空格
print('My Name Is'.istitle())  #每个首字母是否大写
print('My Name Is'.isprintable())  #pty、drive文件
print('MY'.isupper()) #是不是都是大写
print('+'.join(['1','2','3']))  #列表转换为字符串
print(name.ljust(50,'*'))  #末尾补齐50个字符
print(name.rjust(50,'*')) #开头补齐
print('Simon'.lower()) #转换为小写
print('Simon'.upper())  #转换为大写
print('\nSimon'.lstrip()) #从左边去掉空格和回车
print('\nSimon\n'.rstrip())  #从右边去掉空格和回车
print('  Simon\n'.strip())  #2变空格和换行都去掉
p = str.maketrans("abcdefmn",'1234567$')
print("simon xiong".translate(p))  #将内容进行对应转换，感觉加密的时候也许可以使用
print('simon'.replace('s','S'))  #小写s替换为大写
print('simons'.replace('s','S',1)) #只替换1个
print("simon xiong".rfind('n')) #找到最后边值的下标
print("simon".rsplit())
print("simon".split('m')) #将字符串按空格进行分隔
print('1=2\n+3+4'.splitlines())  #识别不同系统的换行
print('Simon Xiong'.swapcase()) #大小写转换
print('Simon Xiong'.title()) #首字母大写
print("Simon xiong".zfill(50))  #16进制补位

参数详细解释

练习：

# 1. 有列表data=['alex',49,[1970,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
data=['alex',49,[1970,3,18]]
name = data[0]
age = data[1]
born1 = [str(i) for i in data[2]]
born = '-'.join(born1)

print(name,age,born)

# 2. 用列表模拟队列
#队列的特点：先进先出、后进后出

#用列表insert、pop模拟进队出队:
>>> l = []
>>> l.insert(0,'s1')
>>> l.insert(0,'s2')
>>> l.insert(0,'s3')
>>> l
['s3', 's2', 's1']
>>> l.pop()
's1'
>>> l
['s3', 's2']
>>> l.pop()
's2'
>>> l
['s3']
>>> l.pop()
's3'
>>> l
[]

# 用列表append、pop模拟进队出队
>>> l
[]
>>> l.append('s4')
>>> l.append('s5')
>>> l.append('s6')
>>> l
['s4', 's5', 's6']
>>> l.pop(0)
's4'
>>> l
['s5', 's6']
>>> l.pop(0)
's5'
>>> l
['s6']
>>> l.pop(0)
's6'
>>> l
[]

# 3. 用列表模拟堆栈
# 堆栈特点：先进后出、后进先出
# 用列表insert、pop方法模拟进栈出栈:
>>> l = []
>>> l.insert(0,'a1')
>>> l.insert(0,'a2')
>>> l.insert(0,'a3')
>>> l
['a3', 'a2', 'a1']
>>> l.pop()
'a1'
>>> l
['a3', 'a2']
>>> l.pop()
'a2'
>>> l
['a3']
>>> l.pop()
'a3'
>>> l
[]

# 用列表append、pop方法模式进栈出栈:
>>> l = []
>>> l.append('a1')
>>> l.append('a2')
>>> l.append('a3')
>>> l
['a1', 'a2', 'a3']
>>> l.pop()
'a3'
>>> l
['a1', 'a2']
>>> l.pop()
'a2'
>>> l
['a1']
>>> l.pop()
'a1'
>>> l
[]

# 4. 有如下列表，请按照年龄排序（涉及到匿名函数）
l=[
    {'name':'alex','age':84},
    {'name':'oldboy','age':73},
    {'name':'egon','age':18},
]
# 答案：
l.sort(key=lambda item:item['age'])
print(l)

练习

• 六、元组

# 元组：可以理解为，不可变的列表
# 1.元组的长度不可以变化
# 2.元组中的值可以变化，但是变化其实是存放了可变的数据类型，元组本质没有改变

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

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

#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in
#5、循环

# 一、定义
t1 = (1, 2, 3, 4, 5)
print(t1) # (1, 2, 3, 4, 5)

t2 = tuple((1, 2, 3, 4, 5))
print(t2) # (1, 2, 3, 4, 5)

# 空元组
t3 = ()
print(t3) #()

t4 = tuple()
print(t4) # ()

# 含义一个值的元组
t5 = (1, )
print(t5)

# 元组取值
t7 = (5, 3, 2, 1, 6)
print(t7[0])
print(t7[-1])

# 不可改变: 但一个列表需要对其进行限制，让其无法发生改变，可以将其转化为元组
list1 = [1, 2, 3]
tuple1 = tuple(list1)
print(tuple1)  # (1, 2, 3)
# 如果重新想更改，可以转化回去
list2 = list(tuple1)
print(list2)  # [1, 2, 3]

# 注：元组中存放了可变类型数据，可以发生形式上的值改变，本质值未发生改变
t1 = (1, 'abc', [10, 'xyz'])
print(t1, id(t1))
>(1, 'abc', [10, 'xyz']) 41766776

# 成立：元组中列表值发生改变，列表自身id不变，所以元组中的中未发生改变
t1[2][1] = 'XYZ'
print(t1, id(t1))
>(1, 'abc', [10, 'XYZ']) 41766776

总结：
1. 可以存放多个值：t = (1, 2, 3)
2. 为不可变类型
3. 有序存储：按索引取值

练习：

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

msg_dic={
'appale':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}

shop_cart=[]

while True:
    for item, value in msg_dic.items():
        print(item, value)
        #print('name:{name} price:{price}'.format(price=item,name=key))
    product_name = input('please input product name:').strip()
    if not product_name or product_name not in msg_dic:continue
    count = input('please input amount:').strip()
    if not count.isdigit():continue
    shop_cart.append((product_name,msg_dic[product_name],count))
    print(shop_cart)
    #break

练习

• 七、字典

# 一、声明
dic1 = {'name': 'Owen', 'age': 18}
dic1 = {'name': None, 'age': None}
print(dic1)
>{'name': None, 'age': None}

dic2 = dict([('name', 'Egon'), ('age', 58)])
print(dic2)
>{'name': 'Egon', 'age': 58}

dic3 = dict(name='Zero', age=18)
print(dic3)
>{'name': 'Zero', 'age': 18}

dic4 = {}.fromkeys(['name', 'age'], None)
print(dic4)
>{'name': None, 'age': None}

# 二、get：有默认值的取值
dic = {'name': 'Owen', 'age': 18}
print(dic.get('name', "该key不存在"))  # 存在就会打印实际的值
>Owen
print(dic.get('name123', "该key不存在"))  # 不存在，未规定默认值，打印None，规定就打印规定的默认值
>该key不存在

# 三、字典的key可以为唯一不可变类型，value可以为任意类型
# 原因：字典的key是取值的唯一途径，所以一定要保证唯一性(一旦确定值，就不会再更改)
d1 = {}.fromkeys([1, 3.14, (1,), '', True], None)
print(d1)
>{1: None, 3.14: None, (1,): None, '': None}

# 四、增删改查
dic = {'name': 'Hou', 'age': 3}
print(dic)
# 增
dic['gender'] = '哇塞'
print(dic)
# 删
del dic['age']
print(dic)
# 改
dic['name'] = 'DaHou'
print(dic)
# 查
print(dic['name'])

#字典的循环

# 多值更新
dic = {'name': 'Engo', 'salary': 100}
dic.update({'name': "Egon", 'age': 58, 'gender': '未知'})
print(dic)

# 类列表类型，不能直接通过index取值，但可以被for循环迭代取值
print(dic.keys())
print(dic.values())
print(dic.items())

for k in dic.keys():
    print(k, ":", dic[k])
print('------------------------------------')
for v in dic.values():
    print(v)

print('------------------------------------')
for k, v in dic.items():  # *****
    print(k, v)

a, b, c = [1, 2, 3]
print(c)
a, b, _ = (1, 2, 3)
print(a)

# 嵌套: JSON
dic = {
    'students': [
        {
            'name': 'Bob',
            'id': 1,
            'gender': '男'
        },
        {
            'name': 'Tom',
            'id': 2,
            'gender': '女'
        }
    ],
    'teachers': []
}

stus = dic['students']  # list
tom_stu = stus[1]  # dic
name = tom_stu['name']
print(name)
print(dic['students'][1]['name'])
print('======================')
for k, v in dic.items():
    # 只遍历学生
    if k == 'students':
        for stu in v:
            for s_k, s_v in stu.items():
                print(s_k, ":", s_v)
            print('--------------')
    if k == 'teachers':
        pass

字典循环

# 总结：
# 1. 字典可以存放多个值
# 2. 字典为可变类型
# 3. 字典是无序存储，用key进行取值

练习1

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

# 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'
s1 = s.split()
dic = {}

for i in s1:
    if i in dic:
        dic[i] += 1
    else:
        dic[i]=1
print(dic)

练习2

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)

其他做法（重点看setdefault的用法）

练习2的其他解法

•  八、集合

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

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

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

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

#优先掌握的操作：
#1、长度len
#2、成员运算in和not in

#3、|合集
#4、&交集
#5、-差集
#6、^对称差集
#7、==
#8、父集：>,>=
#9、子集：<,<=

# 有如下两个集合，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)

练习

作业

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

menue = {
    '湖北省':{
        '黄冈市':{
            '罗田县':{
                '大别山':'板栗',
                '薄刀峰':'风景区',
                '錾字石村':'柿子',
            },
            '錾字石':{
                '杨梅冲':'渡桥',
                '夏家铺':'水库',
                '雷家塆':'道观',
            },
        },
        '黄梅':{},
        '黄石':{},
    },
    '上海市':{
        '徐汇区':{
            '徐家汇':{
                '徐家汇': '美罗城',
                '漕河泾': '开发区',
                '华山路': '交通大学',
            },
            '浦东区':{
                '陆家嘴':'金融区',
                '淮海中路':'酒吧',
                '人民广场':'南京东路步行街',
            },
        },
    },
    '山东省':{
        '青岛市':{
            '崂山区':{
                '风景':'崂山风景区',
                '道观':'崂山太清宫',
                '海边':'海边浴场',
            },
        },
    },
}

tag = True
while tag:
    for key in menue:
        print(key)
    choice = input("请输入省份,退出输入q>>").strip()
    if choice == "q": break
    if not choice or choice not in menue:continue

    #二级菜单
    while tag:
        menue2 = menue[choice]
        for key2 in menue2:
            print(key2)
        choice_2 = input("请输入市,退出输入q,返回上级菜单输入b>>").strip()
        if choice_2 == "b":
           # print("返回上一层")
            break
        if choice_2 == "q":
            tag = False
            #continue
        if choice_2 not in menue2:continue

        #三级菜单
        while tag:
            menue3 =menue2[choice_2]
            for key3 in menue3:
                print(key3)
            choice_3 = input("请输入县,退出输入q,返回上级菜单输入b>>").strip()
            if choice_3 == "b":
                # print("返回上一层")
                break
            if choice_3 == "q":
                tag = False
            if not choice_3 or choice_3 not in menue3:continue

            #四级详细菜单
            while tag:
                menue4 = menue3[choice_3]
                for key4,value in menue4.items():
                    print(key4,value)
                choice_4 = input("请看列出风景,退出输入q,返回上级菜单输入b>>").strip()
                if choice_4 == "b":
                    break
                if choice_4 == "q":
                    tag = False
                if not choice_4 or choice_4 not in menue4: continue

作业一

# 作业一优化答案

#part1（初步实现）：能够一层一层进入
layers = [menue, ]

while True:
    current_layer = layers[-1]
    for key in current_layer:
        print(key)

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

    if choice not in current_layer: continue

    layers.append(current_layer[choice])

#part2（改进）：加上退出机制
layers=[menue,]

while True:
    if len(layers) == 0: break
    current_layer=layers[-1]
    for key in current_layer:
        print(key)

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

    if choice == 'b':
        layers.pop(-1)
        continue
    if choice == 'q':break

    if choice not in current_layer:continue

    layers.append(current_layer[choice])

作业一改进

•  九、数据类型总结

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

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

按存值个数区分：

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

按可变不可变区分：

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

按访问顺序区分：

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

# 1.统计元组中所有数据属于字符串串的个数，提示：isinstance()
# 数据：t1 = (1, 2, '3', '4', 5, '6')
# 结果：3
# 2.将以下数据存储为字典类型
# 数据：info = "name:Owen|age:18|gender:男"
# 结果：{'name': 'Owen', 'age': 18, 'gender': '男'}
# 注：年年龄存储为数字类型
# 3.完成数据的去重
# 数据：t3 = (1, 2, 1, 2, 3, 5, 9)
# 结果：t3 = (1, 2, 3, 5, 9)
# 注：从不不考虑顺序、考虑顺序两⽅方⾯面完成
# 4.计算元组中所有可以转换为数字的数据的总和
# 数据：t4 = (10, 'abc', '100', '3')
# 运算结果：113
# 5.将数据转换类型存储
# 原数据：dic = {'name': 'Owen', 'age': 18, 'gender': '男'}
# 处理理后：info = [('name', 'Owen'), ('age', 18), ('gender', '男')]
# 拓拓展：选做
# 1.计算元组中所有可以转换为数字的数据的总和
# 数据：t4 = (10, 'abc', '100', '3', '壹', '肆', [1000], (10000,))
# 运算结果：11118
# 提示：
# -- 利利⽤用字符串串isnumeric()判断汉字
# -- 利利⽤用字典{'壹': 1 ...}将汉字转换为数字
# -- 利利⽤用isinstance()将list和tuple中数据取出来
# -- 先将所有转化为数字的数据存放在⼀一个单列列集合中，在做运算
# 2.完成录⼊入电话本
# 需求：
'''
-- 从键盘中录⼊入姓名(不不区分⼤大⼩小写)：
-- 姓名必须是全英⽂文组成，不不是则重新录⼊入姓名，如果是q，代表退出
-- 从键盘中再录⼊入电话：
-- 电话必须为数字且⻓长度必须是11位(不不能转换为数字)
-- 如果出现姓名相同，则保留留最后⼀一次电话号码
-- 形成的数据是有电话分组的，如：第⼀一次录⼊入Owen，13355667788，则会形成
-- {
'O': {
'Owen': '13355667788'
}
}
最终数据，分组名⼀一定⼤大写：
{
'E': {
'egon': '17788990000',
'engo': '16633445566'
},
'O': {
'Owen': '13355667788'
}
}

作业2

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