数据类型之字符串练习

第一题： 已知字符串 a = "aAsmr3idd4bgs7Dlsf9eAF"，请将a字符串的大写改为小写，小写改为大写。

 1 def handle_str(params,*arg,**args): #为了函数的健壮性，定义*arg，**args多余的参数传到这里
 2     result=‘‘
 3     if isinstance(params,str):#函数的健壮性，对输入参数的类型做判断
 4         for each in params:
 5             if each.isalpha():
 6                 if each.isupper():
 7                     result=result+each.lower()
 8                 else:
 9                     result=result+each.upper()
10             else:
11                 result=result+each
12         return result
13     else:
14         return ‘该函数需要的是字符串类型的数据‘
15 assert handle_str([1,2,3],5)==‘该函数需要的是字符串类型的数据‘
16 print handle_str([1,2,3],5)
17 assert handle_str(‘A12cD‘)==‘a12Cd‘
18 print handle_str(‘A12cD‘)
19 print handle_str(a)

对自己定义的函数一定要清楚的明白函数输入什么，输出什么，为了健壮性，必要的类型检查，异常捕获不可缺少，

第二题：请将a字符串的数字取出，并输出成一个新的字符串。

 1 def get_int(params,*arg,**args): #*arg,**args接收多余的参数
 2     result=‘‘
 3     if isinstance(params,str): #参数类型判断
 4         for each in params:
 5             if each.isdigit():
 6                 result=result+each
 7         return result
 8     else:
 9         return ‘该函数需要的是字符串类型的数据‘
10 assert get_int(‘a1b4c5d67‘,2,3,4,5)==‘14567‘
11 print get_int(‘a1b4c5d67‘,2,3,4,5)
12 assert get_int([1,2],[1,2],[1,2])==‘该函数需要的是字符串类型的数据‘
13 assert get_int(1,2,3)==‘该函数需要的是字符串类型的数据‘
14 print get_int(1,2,3)
15 print get_int(a)

第三题：请统计a字符串出现的每个字母的出现次数（忽略大小写，a与A是同一个字母），并输出成一个字典。 例 {‘a‘:4,‘b‘:2}

 1 def count_alp_times(params,*arg,**args):#定义*arg,**args接收多余的参数
 2     dict_count={}
 3     if isinstance(params,str):
 4         for each in params:
 5             if each.isalpha():
 6                 loweach=each.lower()#把字符串中的字符都转换为小写
 7                 if loweach not in dict_count.keys():#判断字符是否在字典的key中存在
 8                     dict_count[loweach]=1
 9                 else:
10                     dict_count[loweach]+=1
11         return dict_count
12     else:
13         return ‘该函数需要的是字符串类型的数据‘
14 print count_alp_times(a)

第四题：请去除a字符串多次出现的字母，仅留最先出现的一个。例 ‘abcabb‘，经过去除后，输出 ‘abc‘

 1 def no_repeat_str(params,*arg,**args):
 2     str_list=[]
 3     if isinstance(params,str):
 4         for each in params:
 5             if each not in str_list:
 6                 str_list.append(each)
 7         return ‘‘.join(str_list)
 8     else:
 9         return ‘该函数需要的是字符串类型的数据‘
10 assert no_repeat_str(‘abcadeys‘)==‘abcdeys‘
11 print no_repeat_str(‘abcadeys‘)

第五题：请将a字符串反转并输出。例：‘abc‘的反转是‘cba‘,a = "aAsmr3idd4bgs7Dlsf9eAF"

1 a = "aAsmr3idd4bgs7Dlsf9eAF"
2 list_a=list(a) #把字符串转换为列表
3 list_a.reverse() #运用列表的翻转函数
4 print ‘‘.join(list_a)#再运用字符串的join函数

第六题：去除a字符串内的数字后，请将该字符串里的单词重新排序（a-z），并且重新输出一个排序后的字符 串。（保留大小写,a与A的顺序关系为：A在a前面。例：AaBb）

1 def str_sorted(params,*arg,**args):#*，**接收多余的参数
2     result=‘‘
3     if isinstance(params,str):#参数类型判断
4         for each in params:
5             if each.isalpha():
6                 result=result+each
7         m=sorted(result) #运用sorted 对字符串从小到大排序
8         return ‘‘.join(sorted(m,key=string.upper)) #运用sorted内置函数中的key关键字，对迭代对象的每一项隐式操作

第七题：此时的单词判断，由‘boy‘改为四个，分别是 ‘boy‘,‘girl‘,‘bird‘,‘dirty‘，请判断如上这4个字符串里的每个字母，是否都出现在a字符串里。

 1 def find_alp_many(target,sourse):
 2     for each in target: #遍历传入要查找的所有对象
 3         if not isinstance(each,str):#判断每一个要查找的对象的数据类型，过滤非字符串形式的
 4             return ‘not all items  is string type‘
 5         else:
 6             for eachalp in each:
 7                 if eachalp not in sourse:#每一项进行查找
 8                     return ‘find %s not all alpha is in sourse‘% each
 9     else:
10         return ‘all alpha in sourse‘
11 a=‘abcdysogirdgtl‘
12 assert find_alp_many([‘boy‘,‘girl‘,‘bird‘,‘dirty‘],a)==‘all alpha in sourse‘
13 print find_alp_many([‘boy‘,‘girl‘,‘bird‘,‘dirty‘],a)     

第八题：输出a字符串出现频率最高的字母

 1 a = "aAsmr3idd4bgs7Dlsf9eAF"
 2 dict_a={}
 3 for each in a:
 4     if each.isalpha():
 5         if each not in dict_a.keys():
 6             dict_a[each]=1
 7         else:
 8             dict_a[each]+=1
 9
10 data=dict_a.items()
11 print sorted(data,key=lambda x:x[1],reverse=True)