python初识-day3

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

 1 name = ‘\tMy name is congcong‘
 2 print(name.capitalize())#输出结果为 My name is congcong（首字母大写）
 3 print(name.count(‘n‘)) #输出结果为 3(统计)
 4 print(name.center(30,‘-‘)) #输出结果为 -----My name is congcong------(一共打印30个字符，并将字符串放中间)
 5 print(name.encode(encoding=‘utf-8‘))#编码，输出结果为 b‘I have a dream‘，‘b‘代表byte二进制
 6 print(name.endswith(‘cong‘))#判断字符串结尾的字符，输出结果为布尔类型，输出结果为 True
 7 print(name.expandtabs(tabsize=10))#将‘\t‘转换成10个空格
 8 print(name.find(‘is‘))#查找，字符串也可切片，#输出结果为 9
 9
10 dream = ‘{who} have a dream that to be a {what}‘
11 print(dream.format(who = ‘I‘,what = ‘CEO‘))#字符串格式化，输出结果为I have a dream that to be a CEO
12 print(dream.format_map({‘who‘:‘I‘,‘what‘:‘CEO‘}))#字典，输出结果同上
13
14 print(‘qwer123‘.isalnum())#判断字符串是否为英文字母或阿拉伯数字，输出结果 True
15 print(‘asdQWE3‘.isalpha())#判断字符串是否全为英文字母，输出结果 False
16 print(‘121‘.isdecimal()) #判断字符串是否全为十进制数字，输出结果 True
17 print(‘1231‘.isdigit()) #判断字符串是否为整数
18 print(‘_23a‘.isidentifier()) #判断字符串是否为合法的标识符
19 print(‘zxcv‘.islower()) #判断字符串是否全为小写
20 print(‘UIOP‘.isupper())#判断字符串是否全为大写
21 print(‘My Great Dream‘.istitle())#判断是否只有首字母为大写
22 print(‘ ‘.isspace())#串中是空格则为真
23 print(‘+‘.join([‘1‘,‘3‘,‘5‘]))#输出结果为1+3+5
24 print(dream.ljust(45,‘@‘))#将字符串优先从左排起来，如果长度不够45，就用@补全，输出结果为{who} have a dream that to be a {what}@@@@@@@
25 print(dream.rjust(45,‘@‘))#将字符串优先从右排起来，如果长度不够45，就用@补全，输出结果为@@@@@@@{who} have a dream that to be a {what}
26 print(‘QUHLI‘.lower())#将字符串全部改为小写
27 print(‘sdfsdg‘.upper())#将字符串全部改为大写
28
29 print(‘\n\tqeqr\tere\n‘.rstrip())#去除字符串右侧的空格或换行
30 print(‘\nqeqr\tere‘.lstrip())#去除字符串左侧的空格或换行
31 print(‘\nqeqr\tere‘.strip())#去除字符串两侧的空格或换行
32
33 ps = str.maketrans(‘qwerasdf‘,‘[email protected]#‘)#字符串和密码一一对应（密码本）
34 print(‘we qwer ffd‘.translate(ps))#加密

2.列表

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

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

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

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

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

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

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

　　　<1>列表的切片

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

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

 1 names = [‘ZhangSan‘,‘LiSi‘,‘WuDa‘,‘XiShi‘,‘HouYi‘]  #列表，‘[]‘表示
 2 #添加，插入，删除，查找
 3 names.append(‘YaSe‘) #.append()方法是添加，添加的内容位置默认是列表末尾
 4 print(names) #输出结果为 [‘ZhangSan‘, ‘LiSi‘, ‘WuDa‘, ‘XiShi‘, ‘HouYi‘, ‘YaSe‘]
 5
 6 names.insert(1,‘DaJi‘)  #.insert()方法是插入，括号内依次是插入位置和内容
 7 print(names) #输出结果为 [‘ZhangSan‘, ‘DaJi‘, ‘LiSi‘, ‘WuDa‘, ‘XiShi‘, ‘HouYi‘, ‘YaSe‘]
 8
 9 names.remove(‘WuDa‘) #.remove()方法是删除，括号内即为要删除的内容
10 print(names) #输出结果为 [‘ZhangSan‘, ‘DaJi‘, ‘LiSi‘, ‘XiShi‘, ‘HouYi‘, ‘YaSe‘]
11 del names[0] #删除的第二种方法
12 print(names) #输出结果为 [‘DaJi‘, ‘LiSi‘, ‘XiShi‘, ‘HouYi‘, ‘YaSe‘]
13 names.pop() #删除的第三种方法，不输入下标时默认删除最后一个
14 print(names) #输出结果为 [‘DaJi‘, ‘LiSi‘, ‘XiShi‘, ‘HouYi‘]
15 names.pop(1) #删除下标指定位置的内容
16 print(names) #输出结果为 [‘DaJi‘, ‘XiShi‘, ‘HouYi‘]
17 print(names.pop(1)) #输出结果为 XiShi，说明.pop()方法是将此列表中删除的内容移到别处储存起来了，可以再调用
18
19 print(names.index(‘DaJi‘)) #.index()方法为查找，输出结果为 0,即位置为第一个
20
21 #替换列表中的内容
22 names[2] = ‘YaSe‘ #将列表中下标为2的内容替换为’YaSe‘
23 print(names) #输出结果为 [‘DaJi‘, ‘HouYi‘, ‘YaSe‘]

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

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

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

1 names = [‘DaJi‘, ‘HouYi‘,‘YaSe‘]
2
3 #列表反转，即头变尾，颠倒
4 names.reverse()
5 print(names)# 输出结果为 [‘YaSe‘, ‘HouYi‘, ‘DaJi‘]

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

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

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

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

　　<7>列表清空

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

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

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

　　<9>列表的循环打印

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

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

 1 product_list = [(‘XiaoMi‘,1800),(‘HuaWei‘,3000),(‘DaJiang‘,5000),(‘LaoGanMa‘,10),(‘WeiLong‘,5)]
 2 shopping_cart = []
 3 salary = input(‘Please input your salary:‘)
 4 if salary.isdigit(): #判断输入的是否为数字
 5     salary = int(salary)
 6     while True:
 7         for index,item in enumerate(product_list): #enumerate意为列举，枚举，此处作用是列举列表的下标
 8             print(index,item) #打印下标和内容
 9         user_choice = input(‘请输入要买的物品序号:‘) #用户开始输入
10         if user_choice.isdigit():        #判断用户输入的是否为数字
11             user_choice = int(user_choice) #强制类型转换
12             if user_choice < len(product_list) and user_choice >= 0: #判断输入的数字是否在列表中存在
13                 product_item = product_list[user_choice] #将商品传到购买清单
14                 if product_item[1] <= salary:  #判断是否买得起
15                     salary -= product_item[1]  #计算剩余金额
16                     shopping_cart.append(product_item) #将商品加入到购物车
17                     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为绿色
18                 else:
19                     print(‘\033[41;1m Your balance is %s that not enough to buy it \033[0m‘%salary) #41表示背景为红色，31则是字体为红色
20             else:
21                 print(‘\033[31;1m%s is not exist\033[0m‘%user_choice) #商品不存在
22
23         elif user_choice == ‘q‘:  #按q退出
24             print(‘------shopping list ------‘)
25             for s in shopping_cart: #打印购物车商品
26                 print(s)
27             print(‘Your balance is $\033[32;1m%s\033[0m‘%salary) #输出剩余金额
28             break #跳出循环
29         else:
30             print(‘Invalid option‘) #不合法的输入

3.元组

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

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

1 names1 = (‘YaSe‘,‘DaJi‘,‘HouYi‘,‘LuNa‘,‘DaJi‘)

　　（2）创建空元组

1 tup1 = ()

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

1 tup1 = (30)
2 print(type(tup1)) #输出结果为<class ‘int‘>
3 tup2 = (30,)
4 print(type(tup2))#输出结果为<class ‘tuple‘>

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

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

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

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

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

 1 tup = (‘Google‘, ‘Runoob‘, 1997, 2000)
 2 print (tup)
 3 del tup;
 4 print ("删除后的元组 tup : ")
 5 print (tup)
 6 ‘‘‘
 7 删除后的元组 tup :
 8 Traceback (most recent call last):
 9   File "test.py", line 8, in <module>
10     print (tup)
11 NameError: name ‘tup‘ is not defined
12 ‘‘‘

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

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

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

 1 names1 = (‘YaSe‘,‘DaJi‘,‘HouYi‘,‘LuNa‘,‘DaJi‘) #元组，只有两个方法，分别是count(统计)和index(查找)
 2 print(names1.count(‘DaJi‘)) #输出结果为 2
 3 print(names1.index(‘LuNa‘)) #输出结果为 3
 4
 5 tuple1 = (1,3,2,6,8,7)
 6 list = [‘Google‘, ‘Taobao‘, ‘Runoob‘, ‘Baidu‘]
 7 print(len(tuple1))# 计算元组元素个数。结果为 6
 8 print(max(tuple1))# 返回元组中元素最大值。结果为 8
 9 print(min(tuple1))# 返回元组中元素最小值。结果为 1
10 tuple2 = tuple(list) #将列表转换为元组
11 print(tuple2) #结果为 (‘Google‘, ‘Taobao‘, ‘Runoob‘, ‘Baidu‘)

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

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

　  （2）常用操作：

 1 info = {
 2     ‘stu001‘:‘HuangYuTing‘,
 3     ‘stu002‘:‘CongCong‘,
 4     ‘stu003‘:‘YaoYuLing‘,
 5     ‘stu004‘:‘WenZhanLing‘
 6 }
 7 print(info[‘stu001‘]) # 查找，打印结果：HuangYuTing,结果不存在时会报错
 8 print(info.get(‘stu002‘)) # 查找，打印结果：CongCong，结果不存在时返回None
 9 print(‘stu006‘ in info) # 查找判断，打印结果：False
10 info[‘stu003‘] = ‘TianYan‘ #修改
11 print(info) #打印结果：{‘stu004‘: ‘WenZhanLing‘, ‘stu003‘: ‘TianYan‘, ‘stu001‘: ‘HuangYuTing‘, ‘stu002‘: ‘CongCong‘}
12 info[‘stu005‘] = ‘SongHuiQiao‘ #添加
13 print(info)#打印结果：{‘stu003‘: ‘TianYan‘, ‘stu002‘: ‘CongCong‘, ‘stu001‘: ‘HuangYuTing‘, ‘stu004‘: ‘WenZhanLing‘, ‘stu005‘: ‘SongHuiQiao‘}
14 del info[‘stu003‘] #删除，通用方法
15 info.pop(‘stu004‘) #删除
16 #info.popitem()随机删
17 print(info)#打印结果：{‘stu002‘: ‘CongCong‘, ‘stu005‘: ‘SongHuiQiao‘, ‘stu001‘: ‘HuangYuTing‘}
18
19
20 Travel_Places ={
21     ‘HuBei‘:{
22         ‘YingShan‘:[‘WuYunShan‘,‘ShiLiHuaHai‘]
23     },
24     ‘HuNan‘:{
25         ‘YueYang‘:[‘YueYangLou‘,‘QuYuan‘]
26     },
27     ‘XiZang‘:{
28         ‘LaSa‘:[‘NaMuCuo‘,‘BuDaLaGong‘]
29     }
30 }
31 Travel_Places[‘XiZang‘][‘LaSa‘][0] = ‘DaZhaoSi‘#修改
32 print(Travel_Places)
33 Travel_Places.setdefault(‘HuBei‘,{‘YingShan‘:[‘BiSheng‘,‘Tea‘]})#能取到‘HuBei‘时便返回，不修改初始值
34 Travel_Places.setdefault(‘HuangGang‘,{‘YingShan‘:[‘BiSheng‘,‘Tea‘]})#不能取到‘HuBei‘时，创建
35 print(Travel_Places)
36
37
38 info = {
39     ‘stu001‘:‘HuangYuTing‘,
40     ‘stu002‘:‘CongCong‘,
41     ‘stu003‘:‘YaoYuLing‘,
42     ‘stu004‘:‘WenZhanLing‘
43 }
44 info2 ={
45     ‘stu001‘:‘HeiHuaJun‘,
46     ‘Woo‘:‘Hello‘,
47     ‘Linux‘:‘Great‘
48 }
49 info.update(info2)#更新
50 print(info)#key相同时，则更新value;不同时，则创建，
51 # 结果：{‘Linux‘: ‘Great‘, ‘stu004‘: ‘WenZhanLing‘, ‘stu001‘: ‘HeiHuaJun‘, ‘stu003‘: ‘YaoYuLing‘, ‘Woo‘: ‘Hello‘, ‘stu002‘: ‘CongCong‘}
52 print(info.items())#字典转成列表
53 info3 = dict.fromkeys([1,2,],[‘Good‘,{‘Hello‘:‘World‘},‘God‘])#初始化
54 print(info3)#结果：{1: [‘Good‘, {‘Hello‘: ‘World‘}, ‘God‘], 2: [‘Good‘, {‘Hello‘: ‘World‘}, ‘God‘]}
55 info3[1][1][‘Hello‘] = ‘Everyone‘#当有两层时，内存地址相同，一改全改
56 print(info3) #结果：{1: [‘Good‘, {‘Hello‘: ‘Everyone‘}, ‘God‘], 2: [‘Good‘, {‘Hello‘: ‘Everyone‘}, ‘God‘]}
57
58 #字典的循环
59 for i in info:
60     print(i,info[i])

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

 1 City_Datas = {
 2     ‘HuBei‘:{
 3         ‘HuangGang‘:{
 4             ‘YingShan‘:[‘HongShan‘,‘ZhangFan‘,‘YaZhangShu‘],
 5             ‘HongAn‘:[],
 6             ‘LuoTian‘:[‘TianTangZhai‘],
 7         },
 8         ‘WuHan‘:{
 9             ‘HanYang‘:[‘HuoChe‘],
10             ‘HanKou‘:[‘JiangHan‘,‘JiangAn‘],
11             ‘WuChang‘:[‘QingShan‘,‘HongShan‘]
12         },
13     },
14     ‘BeiJing‘:{
15         ‘ChaoYang‘:{
16             ‘WangJing‘:[‘BenChi‘,‘MoMo‘],
17             ‘GuoMao‘:[‘CICC‘,‘HP‘],
18         },
19         ‘HaiDing‘:[],
20     },
21 }
22 exit_flag = False
23 while not exit_flag:
24     for i in City_Datas:
25         print(i)
26     choice = input(‘Please choose 1>>>‘)
27     if choice in City_Datas:
28         while not exit_flag:
29             for i in City_Datas[choice]:
30                 print(‘\t‘,i)
31             choice2 = input(‘Please choose 2>>>‘)
32             if choice2 in City_Datas[choice]:
33                 while not exit_flag:
34                     for i in City_Datas[choice][choice2]:
35                         print(‘\t\t‘,i)
36                     choice3 = input(‘Please choose 3>>>‘)
37                     if choice3 in City_Datas[choice][choice2]:
38
39                         for i in City_Datas[choice][choice2][choice3]:
40                             print(‘\t\t\t‘,i)
41                         choice4 = input("This is last level,press ‘b‘ back? :")
42                         if choice4 == ‘b‘:
43                             pass  #占位符，无实际意义，防报错
44                         elif choice4 == ‘q‘:
45                             exit_flag = True
46                     if choice3 == ‘b‘:
47                         break
48                     elif choice3 == ‘q‘:
49                         exit_flag = True
50             if choice2 == ‘b‘:
51                 break
52             elif choice2 == ‘q‘:
53                 exit_flag = True