python初识-day3

1.字符串常用操作（较多，用代码加注释表示）　

 name = '\tMy name is congcong'
 print(name.capitalize())#输出结果为 My name is congcong（首字母大写）
 print(name.count('n')) #输出结果为 3(统计)
 print(name.center(30,'-')) #输出结果为 -----My name is congcong------(一共打印30个字符，并将字符串放中间)
 print(name.encode(encoding='utf-8'))#编码，输出结果为 b'I have a dream'，'b'代表byte二进制
 print(name.endswith('cong'))#判断字符串结尾的字符，输出结果为布尔类型，输出结果为 True
 print(name.expandtabs(tabsize=10))#将'\t'转换成10个空格
 print(name.find('is'))#查找，字符串也可切片，#输出结果为 9

 dream = '{who} have a dream that to be a {what}'
 print(dream.format(who = 'I',what = 'CEO'))#字符串格式化，输出结果为I have a dream that to be a CEO
 print(dream.format_map({'who':'I','what':'CEO'}))#字典，输出结果同上

 print('qwer123'.isalnum())#判断字符串是否为英文字母或阿拉伯数字，输出结果 True
 print('asdQWE3'.isalpha())#判断字符串是否全为英文字母，输出结果 False
 print(''.isdecimal()) #判断字符串是否全为十进制数字，输出结果 True
 print(''.isdigit()) #判断字符串是否为整数
 print('_23a'.isidentifier()) #判断字符串是否为合法的标识符
 print('zxcv'.islower()) #判断字符串是否全为小写
 print('UIOP'.isupper())#判断字符串是否全为大写
 print('My Great Dream'.istitle())#判断是否只有首字母为大写
 print(' '.isspace())#串中是空格则为真
 print('+'.join(['','','']))#输出结果为1+3+5
 print(dream.ljust(45,'@'))#将字符串优先从左排起来，如果长度不够45，就用@补全，输出结果为{who} have a dream that to be a {what}@@@@@@@
 print(dream.rjust(45,'@'))#将字符串优先从右排起来，如果长度不够45，就用@补全，输出结果为@@@@@@@{who} have a dream that to be a {what}
 print('QUHLI'.lower())#将字符串全部改为小写
 print('sdfsdg'.upper())#将字符串全部改为大写

 print('\n\tqeqr\tere\n'.rstrip())#去除字符串右侧的空格或换行
 print('\nqeqr\tere'.lstrip())#去除字符串左侧的空格或换行
 print('\nqeqr\tere'.strip())#去除字符串两侧的空格或换行

 ps = str.maketrans('qwerasdf','123456@#')#字符串和密码一一对应（密码本）
 print('we qwer ffd'.translate(ps))#加密

2.列表

　　（1）序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

　　（2）Python有6个序列的内置类型，但最常见的是列表和元组。序列都可以进行的操作包括索引，切片，加，乘，检查成员。此外，Python已经

内置确定序列的长度以及确定最大和最小的元素的方法。

（3）列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型，创建一个列表，只要把

逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

 names = ['ZhangSan','LiSi','WuDa','XiShi','HouYi']  #列表，'[]'表示

　　 （4）列表常用操作（数量较多，直接用代码加注释表示）

　　　<1>列表的切片

 names = ['ZhangSan','LiSi','WuDa','XiShi','HouYi']  #列表，'[]'表示
 print(names[0],names[-1])   #输出结果为 ZhangSan HouYi ，位置从0开始算起
 print(names[1:4]) #输出结果为 ['LiSi', 'WuDa', 'XiShi']，切片“顾头不顾尾”
 print(names[-3:-1]) #输出结果为 ['WuDa', 'XiShi'],末尾为-1，切片自左向右，所以“[]”内顺序必须遵循，否则无法取出
 print(names[3:]) #输出结果为 ['XiShi', 'HouYi'],冒号后不写时，默认取到最后
 print(names[:-3]) #输出结果为 ['ZhangSan', 'LiSi'],同理
 

　　<2>列表的增、删、改、查（内容较多）

 names = ['ZhangSan','LiSi','WuDa','XiShi','HouYi']  #列表，'[]'表示
 #添加，插入，删除，查找
 names.append('YaSe') #.append()方法是添加，添加的内容位置默认是列表末尾
 print(names) #输出结果为 ['ZhangSan', 'LiSi', 'WuDa', 'XiShi', 'HouYi', 'YaSe']

 names.insert(1,'DaJi')  #.insert()方法是插入，括号内依次是插入位置和内容
 print(names) #输出结果为 ['ZhangSan', 'DaJi', 'LiSi', 'WuDa', 'XiShi', 'HouYi', 'YaSe']

 names.remove('WuDa') #.remove()方法是删除，括号内即为要删除的内容
 print(names) #输出结果为 ['ZhangSan', 'DaJi', 'LiSi', 'XiShi', 'HouYi', 'YaSe']
 del names[0] #删除的第二种方法
 print(names) #输出结果为 ['DaJi', 'LiSi', 'XiShi', 'HouYi', 'YaSe']
 names.pop() #删除的第三种方法，不输入下标时默认删除最后一个
 print(names) #输出结果为 ['DaJi', 'LiSi', 'XiShi', 'HouYi']
 names.pop(1) #删除下标指定位置的内容
 print(names) #输出结果为 ['DaJi', 'XiShi', 'HouYi']
 print(names.pop(1)) #输出结果为 XiShi，说明.pop()方法是将此列表中删除的内容移到别处储存起来了，可以再调用

 print(names.index('DaJi')) #.index()方法为查找，输出结果为 0,即位置为第一个

 #替换列表中的内容
 names[2] = 'YaSe' #将列表中下标为2的内容替换为’YaSe‘
 print(names) #输出结果为 ['DaJi', 'HouYi', 'YaSe']

　　<3>列表统计相同姓名人数--count方法

 names = ['ZhangSan','LiSi','WuDa','XiShi','HouYi']
 names.append('DaJi')
 print(names)#输出结果为 ['DaJi', 'HouYi', 'DaJi']
 print(names.count('DaJi')) #输出结果为 2,表明names列表中有2个DaJi

　　<4>列表反转，即头变尾，颠倒-reverse方法

 names = ['DaJi', 'HouYi','YaSe'] 

 #列表反转，即头变尾，颠倒
 names.reverse()
 print(names)# 输出结果为 ['YaSe', 'HouYi', 'DaJi']

　　<5>将列表内容进行排序（按ASCII表）--sort方法

names = ['YaSe', 'HouYi', 'DaJi']
names.sort()# sort即排序的意思
print(names)#输出结果为 ['DaJi', 'HouYi', 'YaSe']

　　<6>列表延伸，扩展--extend方法

 names = ['DaJi', 'HouYi', 'YaSe']
 name2 = ['DianWei','CaoCao']
 names.extend(name2) #将name2列表并入names列表中
 print(names) ##输出结果为 ['DaJi', 'HouYi', 'YaSe', 'DianWei', 'CaoCao']

　　<7>列表清空

 names = ['DaJi', 'HouYi', 'YaSe', 'DianWei', 'CaoCao']
 names.clear() #括号内为空
 print(names) #输出结果为 []，即列表为空

　　<8>列表复制(浅copy和深copy属于个人理解，如有错漏，欢迎指正)

 name2 = ['DianWei','CaoCao']
 name3 = name2.copy() #将name2复制一份给name3，还可以用name3 = list(name2)或 name3 = name2[:]
 print(name2,name3) #输出结果为 ['DianWei', 'CaoCao'] ['DianWei', 'CaoCao']
 name2[0] = 'XiaoQiao' #将name2中"DianWei"改为“XiaoQiao”
 print(name2,name3) #输出结果为 ['XiaoQiao', 'CaoCao'] ['DianWei', 'CaoCao']，name3中的“DianWei”并未改变，此为’浅copy‘
 name2.append(['LiuBei','ZhaoYun']) #在name2中添加一个小列表
 name3 = name2.copy() #复制一份给name3
 name2[0] = 'DianWei'#将name2中"XiaoQiao"改为"DianWei"
 name2[2][1] = 'ZhuGeLiang' #将name2中的小列表中的“CaoCao”改为“ZhuGeLiang”
 print(name2,name3) #输出结果为 ['DianWei', 'CaoCao', ['LiuBei', 'ZhuGeLiang']] ['XiaoQiao', 'CaoCao', ['LiuBei', 'ZhuGeLiang']]
 #第一层中修改的未被copy,因为是单独克隆，修改时不相互影响；小列表中修改的则都被改变了，因为小列表为第二层，保存的只是内存地址，一改全改

 import copy #引入copy模块，深copy
 name3 = copy.deepcopy(name2)# 深copy，完全克隆，一变全变
 print(name2,name3)#输出结果为 ['DianWei', 'CaoCao', ['LiuBei', 'ZhuGeLiang']] ['DianWei', 'CaoCao', ['LiuBei', 'ZhuGeLiang']]

　　<9>列表的循环打印

 name2 = ['DianWei','CaoCao']
 for i in name2:  #for i in range(0,10,2),输出0到10内的偶数
     print(i) #依次打印列表的三个元素
 name4 = ['DianWei', 'CaoCao',['LiuBei', 'ZhuGeLiang'],'GuanYu']
 print(name4[0:-1:2]) #输出结果为 ['DianWei', ['LiuBei', 'ZhuGeLiang']],从头到尾每两个打印一个
 #name4[0:-1:2]等同于name4[::2] ,头和尾的下标可省

<10>列表的扩展应用-购物车

 product_list = [('XiaoMi',1800),('HuaWei',3000),('DaJiang',5000),('LaoGanMa',10),('WeiLong',5)]
 shopping_cart = []
 salary = input('Please input your salary:')
 if salary.isdigit(): #判断输入的是否为数字
     salary = int(salary)
     while True:
         for index,item in enumerate(product_list): #enumerate意为列举，枚举，此处作用是列举列表的下标
             print(index,item) #打印下标和内容
         user_choice = input('请输入要买的物品序号:') #用户开始输入
         if user_choice.isdigit():        #判断用户输入的是否为数字
             user_choice = int(user_choice) #强制类型转换
             if user_choice < len(product_list) and user_choice >= 0: #判断输入的数字是否在列表中存在
                 product_item = product_list[user_choice] #将商品传到购买清单
                 if product_item[1] <= salary:  #判断是否买得起
                     salary -= product_item[1]  #计算剩余金额
                     shopping_cart.append(product_item) #将商品加入到购物车
                     print('You have gotten \033[32;1m%s\033[0m into your ShoppingCart,your salary is \033[31;1m%s\033[0m'%(product_item[0],salary))#31为红色，32为绿色
                 else:
                     print('\033[41;1m Your balance is %s that not enough to buy it \033[0m'%salary) #41表示背景为红色，31则是字体为红色
             else:
                 print('\033[31;1m%s is not exist\033[0m'%user_choice) #商品不存在

         elif user_choice == 'q':  #按q退出
             print('------shopping list ------')
             for s in shopping_cart: #打印购物车商品
                 print(s)
             print('Your balance is $\033[32;1m%s\033[0m'%salary) #输出剩余金额
             break #跳出循环
         else:
             print('Invalid option') #不合法的输入

3.元组

　　（1）Python 的元组与列表类似，不同之处在于元组的元素不能修改，所以又叫只读列表。元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。如下实例：

 names1 = ('YaSe','DaJi','HouYi','LuNa','DaJi')

　　（2）创建空元组

tup1 = ()

　　（3）元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：

 tup1 = (30)
 print(type(tup1)) #输出结果为<class 'int'>
 tup2 = (30,)
 print(type(tup2))#输出结果为<class 'tuple'>

　　  （4）元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

 tup1 = ('Google', 'Runoob', 1997, 2000)
 tup2 = (1, 2, 3, 4, 5, 6, 7 )
 print ("tup1[0]: ", tup1[0])#输出结果为 tup1[0]:  Google
 print ("tup2[1:5]: ", tup2[1:5])#输出结果为 tup2[1:5]:  (2, 3, 4, 5)

　　（5）修改元组，元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

 tup1 = (12, 34.56);
 tup2 = ('abc', 'xyz')
 # 以下修改元组元素操作是非法的。
 # tup1[0] = 100
 # 创建一个新的元组
 tup3 = tup1 + tup2;
 print (tup3) #输出结果为 (12, 34.56, 'abc', 'xyz')

　　（6）删除元组，元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

 tup = ('Google', 'Runoob', 1997, 2000)
 print (tup)
 del tup;
 print ("删除后的元组 tup : ")
 print (tup)
 '''
 删除后的元组 tup :
 Traceback (most recent call last):
   File "test.py", line 8, in <module>
     print (tup)
 NameError: name 'tup' is not defined
 '''

　　（7）元组运算符，与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

 tup1 = (1,2,3)
 tup2 = (4,5,6)
 print(len(tup1)) #计算元素个数,结果为3
 print(tup1+tup2) #连接,结果为 (1, 2, 3, 4, 5, 6)
 print(tup1*2) #复制,结果为 (1, 2, 3, 1, 2, 3)
 print(1 in tup1) #元素是否存在，结果为 True
 for i in tup1:
     print(i)#迭代（同一个变量,用不同的数值来代替），结果为1 2 3

　　（8）元组常用方法及内置方法

 names1 = ('YaSe','DaJi','HouYi','LuNa','DaJi') #元组，只有两个方法，分别是count(统计)和index(查找)
 print(names1.count('DaJi')) #输出结果为 2
 print(names1.index('LuNa')) #输出结果为 3

 tuple1 = (1,3,2,6,8,7)
 list = ['Google', 'Taobao', 'Runoob', 'Baidu']
 print(len(tuple1))# 计算元组元素个数。结果为 6
 print(max(tuple1))# 返回元组中元素最大值。结果为 8
 print(min(tuple1))# 返回元组中元素最小值。结果为 1
 tuple2 = tuple(list) #将列表转换为元组
 print(tuple2) #结果为 ('Google', 'Taobao', 'Runoob', 'Baidu')

4.字典（不太好整理，注释和代码一起放出，已成功运行）

　  （1）特点：字典是key-value的数据类型，用{}表示#字典的特性：无序性；Key必须唯一，天生去重复

　  （2）常用操作：

 info = {
     'stu001':'HuangYuTing',
     'stu002':'CongCong',
     'stu003':'YaoYuLing',
     'stu004':'WenZhanLing'
 }
 print(info['stu001']) # 查找，打印结果：HuangYuTing,结果不存在时会报错
 print(info.get('stu002')) # 查找，打印结果：CongCong，结果不存在时返回None
 print('stu006' in info) # 查找判断，打印结果：False
 info['stu003'] = 'TianYan' #修改
 print(info) #打印结果：{'stu004': 'WenZhanLing', 'stu003': 'TianYan', 'stu001': 'HuangYuTing', 'stu002': 'CongCong'}
 info['stu005'] = 'SongHuiQiao' #添加
 print(info)#打印结果：{'stu003': 'TianYan', 'stu002': 'CongCong', 'stu001': 'HuangYuTing', 'stu004': 'WenZhanLing', 'stu005': 'SongHuiQiao'}
 del info['stu003'] #删除，通用方法
 info.pop('stu004') #删除
 #info.popitem()随机删
 print(info)#打印结果：{'stu002': 'CongCong', 'stu005': 'SongHuiQiao', 'stu001': 'HuangYuTing'}

 Travel_Places ={
     'HuBei':{
         'YingShan':['WuYunShan','ShiLiHuaHai']
     },
     'HuNan':{
         'YueYang':['YueYangLou','QuYuan']
     },
     'XiZang':{
         'LaSa':['NaMuCuo','BuDaLaGong']
     }
 }
 Travel_Places['XiZang']['LaSa'][0] = 'DaZhaoSi'#修改
 print(Travel_Places)
 Travel_Places.setdefault('HuBei',{'YingShan':['BiSheng','Tea']})#能取到'HuBei'时便返回，不修改初始值
 Travel_Places.setdefault('HuangGang',{'YingShan':['BiSheng','Tea']})#不能取到'HuBei'时，创建
 print(Travel_Places)

 info = {
     'stu001':'HuangYuTing',
     'stu002':'CongCong',
     'stu003':'YaoYuLing',
     'stu004':'WenZhanLing'
 }
 info2 ={
     'stu001':'HeiHuaJun',
     'Woo':'Hello',
     'Linux':'Great'
 }
 info.update(info2)#更新
 print(info)#key相同时，则更新value;不同时，则创建，
 # 结果：{'Linux': 'Great', 'stu004': 'WenZhanLing', 'stu001': 'HeiHuaJun', 'stu003': 'YaoYuLing', 'Woo': 'Hello', 'stu002': 'CongCong'}
 print(info.items())#字典转成列表
 info3 = dict.fromkeys([1,2,],['Good',{'Hello':'World'},'God'])#初始化
 print(info3)#结果：{1: ['Good', {'Hello': 'World'}, 'God'], 2: ['Good', {'Hello': 'World'}, 'God']}
 info3[1][1]['Hello'] = 'Everyone'#当有两层时，内存地址相同，一改全改
 print(info3) #结果：{1: ['Good', {'Hello': 'Everyone'}, 'God'], 2: ['Good', {'Hello': 'Everyone'}, 'God']}

 #字典的循环
 for i in info:
     print(i,info[i])

　　（3）字典扩展应用-三级菜单　

 City_Datas = {
     'HuBei':{
         'HuangGang':{
             'YingShan':['HongShan','ZhangFan','YaZhangShu'],
             'HongAn':[],
             'LuoTian':['TianTangZhai'],
         },
         'WuHan':{
             'HanYang':['HuoChe'],
             'HanKou':['JiangHan','JiangAn'],
             'WuChang':['QingShan','HongShan']
         },
     },
     'BeiJing':{
         'ChaoYang':{
             'WangJing':['BenChi','MoMo'],
             'GuoMao':['CICC','HP'],
         },
         'HaiDing':[],
     },
 }
 exit_flag = False
 while not exit_flag:
     for i in City_Datas:
         print(i)
     choice = input('Please choose 1>>>')
     if choice in City_Datas:
         while not exit_flag:
             for i in City_Datas[choice]:
                 print('\t',i)
             choice2 = input('Please choose 2>>>')
             if choice2 in City_Datas[choice]:
                 while not exit_flag:
                     for i in City_Datas[choice][choice2]:
                         print('\t\t',i)
                     choice3 = input('Please choose 3>>>')
                     if choice3 in City_Datas[choice][choice2]:

                         for i in City_Datas[choice][choice2][choice3]:
                             print('\t\t\t',i)
                         choice4 = input("This is last level,press 'b' back? :")
                         if choice4 == 'b':
                             pass  #占位符，无实际意义，防报错
                         elif choice4 == 'q':
                             exit_flag = True
                     if choice3 == 'b':
                         break
                     elif choice3 == 'q':
                         exit_flag = True
             if choice2 == 'b':
                 break
             elif choice2 == 'q':
                 exit_flag = True