python初识-day3

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

name = '	My 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))#将'	'转换成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('121'.isdecimal()) #判断字符串是否全为十进制数字，输出结果 True
print('1231'.isdigit()) #判断字符串是否为整数
print('_23a'.isidentifier()) #判断字符串是否为合法的标识符
print('zxcv'.islower()) #判断字符串是否全为小写
print('UIOP'.isupper())#判断字符串是否全为大写
print('My Great Dream'.istitle())#判断是否只有首字母为大写
print(' '.isspace())#串中是空格则为真
print('+'.join(['1','3','5']))#输出结果为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('
	qeqr	ere
'.rstrip())#去除字符串右侧的空格或换行
print('
qeqr	ere'.lstrip())#去除字符串左侧的空格或换行
print('
qeqr	ere'.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 33[32;1m%s33[0m into your ShoppingCart,your salary is 33[31;1m%s33[0m'%(product_item[0],salary))#31为红色，32为绿色
                else:
                    print('33[41;1m Your balance is %s that not enough to buy it 33[0m'%salary) #41表示背景为红色，31则是字体为红色
            else:
                print('33[31;1m%s is not exist33[0m'%user_choice) #商品不存在

        elif user_choice == 'q':  #按q退出
            print('------shopping list ------')
            for s in shopping_cart: #打印购物车商品
                print(s)
            print('Your balance is $33[32;1m%s33[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('	',i)
            choice2 = input('Please choose 2>>>')
            if choice2 in City_Datas[choice]:
                while not exit_flag:
                    for i in City_Datas[choice][choice2]:
                        print('		',i)
                    choice3 = input('Please choose 3>>>')
                    if choice3 in City_Datas[choice][choice2]:

                        for i in City_Datas[choice][choice2][choice3]:
                            print('			',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