zoukankan      html  css  js  c++  java
  • Python开发【第二章】:补充

    一.字符串方法讲解:

      1 #---------字符串各种方法----------
      2 s = "Hello world!"
      3 
      4 #1.swapcase():大小写互换
      5 print(s.swapcase())
      6 #输出:hELLO WORLD!
      7 
      8 #2.capitalize():返回第一个字符为大写,其他字符为小写
      9 #源码:
     10 '''
     11 Return a capitalized version of S, i.e. make the first character
     12         have upper case and the rest lower case.
     13 '''
     14 print(s.capitalize())
     15 #输出:Hello world!
     16 
     17 #3.casefold():返回所有字符为小写
     18 #源码:
     19 '''
     20 Return a version of S suitable for caseless comparisons.
     21 '''
     22 print(s.casefold())
     23 #输出:hello world!
     24 
     25 #4.center():参数为一个数字和一个字符,在这个数字为长度的范围内,字符串居中,两边由那个字符补足
     26 print(s.center(50,'#'))
     27 #输出:###################Hello world!###################
     28 
     29 #5.count():统计字符串中某个字符的个数,也可以从一个范围开始
     30 #如:print(s.count('o',0,5))  输出为1
     31 print(s.count('o'))
     32 #输出:2
     33 
     34 #6.endswith():判断字符串以什么结尾
     35 print(s.endswith('d!'))
     36 #输出:True
     37 
     38 #7.expandtabs():扩展tab键
     39 s2 = 'a	b'    #	就是tab键
     40 print(s2.expandtabs())
     41 #输出:a       b    #tab键默认8个空格
     42 print(s2.expandtabs(20))   #tab键可以指定空格
     43 #输出:a                   b
     44 
     45 #8.find():返回字符在字符串中的位置,没有则返回-1;也可以从一个范围开始
     46 #如:print(s.find('o',0,3))  输出:-1
     47 print(s.find('o'))
     48 #输出:4
     49 print(s.find('sdaf'))
     50 #输出:-1
     51 
     52 #9.format():字符串格式化输出
     53 #方法一:
     54 s3 = 'my name is {0},i am {1} years old'
     55 print(s3.format('Mm',18))
     56 #输出:my name is Mm,i am 18 years old
     57 
     58 #方法二:
     59 s4 = 'my name is {name},i am {age} years old'
     60 print(s4.format(name = 'Mm',age = 18))
     61 #输出:my name is Mm,i am 18 years old
     62 
     63 #10.isalnum():是否为阿拉伯数字或字符
     64 print('22'.isalnum())
     65 #输出:True
     66 
     67 #11.isalpha():是否为字符
     68 print('mm'.isalpha())
     69 #输出:True
     70 
     71 #12.isdecimal():是否是个数字
     72 
     73 #13.isdigit():是否是个数字
     74 
     75 #14.isidentifier():是否是个合法的变量名
     76 
     77 #15.islower():是否都是小写
     78 
     79 #16.isnumeric():是否都是数字
     80 
     81 #17.isprintable():是否是可打印的(文本文件或者是字节型文件)
     82 
     83 #18.issapce():判断是否是空格
     84 print(' '.isspace())
     85 #输出:True
     86 
     87 #19.istitle():判断是不是标题
     88 
     89 #20.isupper():判断是不是都是大写
     90 
     91 #21.join():列表元素以一种方式,如下例中的'*'连接成字符串
     92 names = ['mm','mumu','tt']
     93 print('*'.join(names))
     94 #输出:mm*mumu*tt
     95 
     96 #22.ljust():右填充
     97 print(s.ljust(50,'*'))
     98 #输出:Hello world!**************************************
     99 
    100 #23.rjust():左填充
    101 print(s.rjust(50,'#'))
    102 #输出:######################################Hello world!
    103 
    104 #24.lower():将字符串改成小写
    105 print(s.lower())
    106 #输出:hello world!
    107 
    108 #25.upper():将字符串改成大写
    109 print(s.upper())
    110 #输出:HELLO WORLD!
    111 
    112 #26.strip():去掉空格或换行
    113 
    114 #27.lstrip():只去掉左边空格或换行
    115 
    116 #28.rstrip():只去掉右边空格或换行
    117 
    118 #29.maketrans():生成对应表
    119 #30.translate():翻译
    120 str_in = 'abcdef'
    121 str_out = '!@#$%^'
    122 
    123 table = str.maketrans(str_in,str_out)
    124 
    125 print(table)
    126 #输出:{97: 33, 98: 64, 99: 35, 100: 36, 101: 37, 102: 94}
    127 
    128 print(s.translate(table))
    129 #输出:H%llo worl$!
    130 
    131 #31.partition():一个字符串以其中的字符分割成三段
    132 print(s.partition('o'))
    133 #输出:('Hell', 'o', ' world!')
    134 
    135 #32.rpartition():一个字符串以其中的字符分割成三段,从右边开始寻找
    136 print(s.rpartition('o'))
    137 #输出:('Hello w', 'o', 'rld!')
    138 
    139 #33.replace():替换,不指定一个数字将全部换掉
    140 print(s.replace('o','*',1))
    141 #输出:Hell* world!
    142 
    143 #34.rfind():从右边开始找,找不到的时候为-1
    144 print(s.rfind('l'))
    145 #输出:9
    146 
    147 #34.rindex():从右边找,当找不到的时候报错
    148 
    149 #35.split(): 默认以空格来分割字符串为列表
    150 print(s.split())
    151 #输出:['Hello', 'world!']
    152 
    153 #36.rsplit():从右边开始分
    154 #如:
    155 print(s.split('o',1))
    156 print(s.rsplit('o',1))
    157 #输出:
    158 # ['Hell', ' world!']
    159 # ['Hello w', 'rld!']
    160 
    161 #37.splitlines():按行来分
    162 t = 'a
    b
    mm
    c'
    163 print(t.splitlines())
    164 #输出:['a', 'b', 'mm', 'c']
    165 
    166 #38.startswith():判断以什么开始
    167 print(s.startswith('He'))
    168 #输出:True
    169 
    170 #39.zfill():字符串变成一个长度的,不够用0填充
    171 print(s.zfill(40))
    172 #输出:0000000000000000000000000000Hello world!

    二.元组类型:

      (1)特性:
         1.不可变
         2.元组本身不可变,如果元组中包含其他可变元素,这些可变元素可以改变

      (2)功能:
         1.index
         2.count
         3.切片

      (3)使用场景:
         1.显示的告知别人,此处数据不可修改
         2.数据库连接配置信息等

    三.hash函数:

      (1)定义:将任意长度的消息压缩到某一固定长度的消息摘要的函数

      (2)特征:     hash值的计算过程是依据这个值的一些特征计算的,这就是要求hash的值必须固定,因此被hash的值必须是不可变的。

      (3)用途:
         1.文件签名
         2.md5加密
         3.密码验证

    四.字典类型:

      (1)特性:
         1.key-value结构
         2.key必须可hash,且必须为不可变数据类型,必须唯一
         3.可存放任意多个值,可修改,可以不唯一
         4.无序
         5.查找速度快(key转换成hash数字,然后排序,通过二分法来查找,最多2的多少次幂,但是hash不是这种方法,但是更快)

      (2)方法:

     1 info = {
     2     'stu001':'mm',
     3     'stu002':'tt',
     4     'stu003':'mumu'
     5 }
     6 
     7 方法:
     8 #1.clear():清空字典
     9 
    10 #2.copy():类似于列表的深浅copy
    11 
    12 #3.values():
    13 print(info.values())
    14 #输出:dict_values(['mm', 'tt', 'mumu'])
    15 
    16 #4.keys():
    17 print(info.keys())
    18 #输出:dict_keys(['stu001', 'stu002', 'stu003'])
    19 
    20 #5.items():
    21 print(info.items())
    22 #输出:dict_items([('stu001', 'mm'), ('stu002', 'tt'), ('stu003', 'mumu')])
    23 
    24 #6.updates():两个字典组合起来,当有相同的key时,更新的value会替换掉原有的value
    25 dic1 = {1:2,2:3,'stu003':['mumu','small dog']}
    26 info.update(dic1)
    27 print(info)
    28 #输出:{'stu001': 'mm', 'stu002': 'tt', 'stu003': ['mumu', 'small dog'], 1: 2, 2: 3}
    29 
    30 #7.setdefault():输入的key如果字典中有,则不更新,如果没有,则创建
    31 info.setdefault('test','new')
    32 
    33 #8.fromkeys():批量创造字典元素
    34 
    35 #9.循环:
    36 for k in info:
    37      print(k,info[k])
    38 #输出:
    39 # stu001 mm
    40 # stu002 tt
    41 # stu003 ['mumu', 'small dog']
    42 # 1 2
    43 # 2 3
    44 # test new
    45 
    46 for k,v in info.items():  #相对低效,有一个字典转换成列表的过程
    47     print(k,v)
    48 #输出:
    49 # stu001 mm
    50 # stu002 tt
    51 # stu003 ['mumu', 'small dog']
    52 # 1 2
    53 # 2 3
    54 # test new

    (3)习题:

      1 #写代码,有如下字典,按照要求实现每一个功能:dic = {'k1':'v1','k2':'v2','k3':'v3'}
      2 
      3 #1.请循环遍历出所有的 key
      4 dic = {'k1':'v1','k2':'v2','k3':'v3'}
      5 for k in dic:
      6     print(k)
      7 # k1
      8 # k2
      9 # k3
     10 
     11 #2.请循环遍历出所有的 value
     12 for k in dic:
     13     print(dic[k])
     14 # v1
     15 # v2
     16 # v3
     17 
     18 #3.请循环遍历出所有的 key 和 value
     19 for k in dic:
     20     print(k,dic[k])
     21 # k1 v1
     22 # k2 v2
     23 # k3 v3
     24 
     25 #4.请在字典中添加一个键值对,'k4':'v4',输出添加后的字典
     26 dic['k4'] = 'v4'
     27 print(dic)
     28 #输出:{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}
     29 
     30 #5.请删除字典中键值对 'k1':'v1',并输出删除后的字典
     31 dic.pop('k1')
     32 #或者
     33 #del dic['k1']
     34 print(dic)
     35 
     36 #输出:{'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}
     37 
     38 #6.请删除字典中的键'k5'对应的键值对,如果字典中不存在键'k5',则不报错,并且让其返回 None
     39 
     40 # for k in dic:
     41 #     if dic.get('k5'):
     42 #         dic.pop('k5')
     43 #         print(dic)
     44 #     else:
     45 #         print(dic.get('k5'))
     46 # # None
     47 # # None
     48 # # None
     49 # #返回3个none,在检查考虑一下
     50 
     51 if dic.get('k5'):
     52     dic.pop('k5')
     53     print(dic)
     54 else:
     55     print(dic.get('k5'))
     56 #输出:None
     57 
     58 #7.请获取字典中'k2'对应的值
     59 print(dic['k2'])
     60 #输出:v2
     61 
     62 #8.请获取字典中'k6'对应的值,如果键'k6'不存在,则不报错,并且让其返回 None
     63 print(dic.get('k6'))
     64 #输出:None
     65 
     66 #9.现有 dic2 = {'k1':'v111','a':'b'}通过一行操作使 dic2 = {'k1':'v1','k2':'v2','k3':'v3','a':'b'}
     67 dic2 = {'k1':'v111','a':'b'}
     68 dic2.update({'k1':'v1','k2':'v2','k3':'v3'})
     69 print(dic2)
     70 #输出:{'k1': 'v1', 'a': 'b', 'k2': 'v2', 'k3': 'v3'}
     71 
     72 #10.组合嵌套题,学代码,有如下列表,按照要求实现每一个功能
     73 lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
     74 #a.将列表lis中的'tt'变成大写(用两种方式)
     75 # lis[0][1][2].get('k1')[0] = 'TT'
     76 # print(lis)
     77 # #输出:[['k', ['qwe', 20, {'k1': ['TT', 3, '1']}, 89], 'ab']]
     78 print(lis[0][1][2].get('k1')[0].upper())
     79 print(lis[0][1][2].get('k1')[0].swapcase())
     80 # TT
     81 # TT
     82 
     83 #b.将列表中的数字 3 变成字符串 '100'(用两种方式)
     84 lis[0][1][2].get('k1')[1] = '100'
     85 print(lis)
     86 #输出:[['k', ['qwe', 20, {'k1': ['tt', '100', '1']}, 89], 'ab']]
     87 
     88 dic3 = {'k1': ['tt', '100', '1']}
     89 lis[0][1][2].update(dic3)
     90 print(lis)
     91 #输出:[['k', ['qwe', 20, {'k1': ['tt', '100', '1']}, 89], 'ab']]
     92 
     93 #c.将列表中的字符串'1'变成数字101(用两种方式)
     94 lis[0][1][2].get('k1')[2] = 101
     95 print(lis)
     96 #输出:[['k', ['qwe', 20, {'k1': ['tt', '100', 101]}, 89], 'ab']]
     97 
     98 dic4 = {'k1': ['tt', '100', 101]}
     99 lis[0][1][2].update(dic4)
    100 print(lis)
    101 #输出:[['k', ['qwe', 20, {'k1': ['tt', '100', 101]}, 89], 'ab']]
    102 
    103 #11 按照要求实现以下功能:
    104 
    105 #现有一个列表li = [1,2,3,'a','b',4,'c'],有一个字典(此字典是动态生成的,你并不知道他里面有多少键值对,所以
    106 
    107 #用dic = {}模拟此字典);现在需要完成这样的操作:如果该字典没有'k1'这个键,那就创建'k1'键和其对应的值(该键对应的值设置为空列表)
    108 
    109 #并将列表li 中的 索引为奇数的对应元素,添加到'k1'这个键对应的空列表中。如果该字典有'k1'这个键,且'k1'对应的value
    110 
    111 #是列表类型,那就将li中的索引为奇数的对应元素,添加到'k1'这个键对应的键中
    112 
    113 li = [1,2,3,'a','b',4,'c']
    114 
    115 dic = {}
    116 
    117 if not 'k1' in dic:
    118     dic['k1'] = []
    119     for i in li:
    120         if li.index(i) %2 == 1:
    121             dic['k1'].append(i)
    122 else:
    123     if type(dic['k1']) == type([]):
    124         for i in li:
    125             if li.index(i) %2 == 1:
    126                 dic['k1'].append(i)
    127     print("字典k1,value不是列表,无法追加!")
    128 
    129 print(dic)

    五.集合类型:

     (1) 集合是一个无序的,不重复的数据组合,它的主要作用如下:
         1.去重,把一个列表变成集合,就自动去重了
         2.关系测试,测试两组数据之前的交集,差集,并集的关系

    (2)方法:

     1 #1.去重:
     2 s = {1,2,3,4,2,3,7}
     3 print(s)
     4 #输出:{1, 2, 3, 4, 7}
     5 
     6 #2.可将列表和元组转换成集合
     7 l = [2,3,4,3,4,5]
     8 s1 = set(l)
     9 print(s1)
    10 #输出:{2, 3, 4, 5}
    11 
    12 #3.add:增加
    13 s.add(6)
    14 print(s)
    15 #输出:{1, 2, 3, 4, 6, 7}
    16 
    17 #4.pop:随机删除
    18 s.pop()
    19 print(s)
    20 #输出:{2, 3, 4, 6, 7}
    21 
    22 #5.remove:删除,不存在会报错
    23 s.remove(7)
    24 print(s)
    25 #输出:{2, 3, 4, 6}
    26 
    27 #6.discard:删除,不存在不报错
    28 
    29 #7.update:两个集合联合
    30 
    31 #8.clear:清除

      (3)集合关系测试:

     1 #1.交集:intersection和&
     2 iphone7 = {'tt','mm','zz'}
     3 iphone8 = {'mm','zz','mumu'}
     4 
     5 print(iphone7.intersection(iphone8))
     6 #输出:{'mm', 'zz'}
     7 print(iphone7 & iphone8)
     8 #输出:{'mm', 'zz'}
     9 
    10 #2.差集:difference和-
    11 print(iphone7.difference(iphone8))
    12 #输出:{'tt'}
    13 print(iphone7 - iphone8)
    14 #输出:{'tt'}
    15 
    16 #3.并集:union 和 |
    17 print(iphone7.union(iphone8))
    18 #输出:{'zz', 'tt', 'mumu', 'mm'}
    19 print(iphone7 | iphone8)
    20 #输出:{'zz', 'tt', 'mumu', 'mm'}
    21 
    22 #4.对称差集:symmetric_difference和^
    23 s2 = {1,2,3,4}
    24 s3 = {2,3,5,6}
    25 print((s2|s3)-(s2&s3))
    26 #输出:{1, 4, 5, 6}
    27 
    28 print(s2.symmetric_difference(s3))
    29 #输出:{1, 4, 5, 6}
    30 print(s2^s3)
    31 #输出:{1, 4, 5, 6}
    32 
    33 #5.issubset:判断是否为子集 <=
    34 s3.add(1)
    35 s3.add(4)
    36 print(s3)
    37 #输出:{1, 2, 3, 4, 5, 6}
    38 print(s2.issubset(s3))
    39 #输出:True
    40 
    41 #6.issuperset:判断是否为父集  >=
    42 print(s3.issuperset(s2))
    43 #输出:True
    44 
    45 #7.isdisjoint:判断两个集合是不是不相交
    46 
    47 #8.s2.difference_update(s3):将两者的差集赋值给s2
  • 相关阅读:
    MongoDB
    前端框架之vue初步学习
    mysql再回首
    oracle之回顾二
    oracle再回首
    springboot之对之前的补充
    springCloud学习
    springboot-ssm的pom.xml
    MyCat
    11.Java反射机制 哦对了,前面的序号来自随笔关于编程之路的思索第一篇
  • 原文地址:https://www.cnblogs.com/mumupa0824/p/8550471.html
Copyright © 2011-2022 走看看