数据类型之字符串练习

 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)

 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)

 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)

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

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

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关键字，对迭代对象的每一项隐式操作

 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)     

 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)