python基础入门（二）

待我称王封你为后i 2022-05-29 04:56 459阅读 0赞

1.列表

  1. list类中提供的方法
  2. 1. 原来值最后追加
  3. 对象.方法(..)   # li对象调用append方法
  4.     li.append(5)
  5.     li.append("alex")
  6.     li.append([1234,2323])
  7.     print(li)
  8. 2 清空列表
  9.     li.clear()
  10.     print(li)
  12. 3 拷贝，浅拷贝
  13.     v = li.copy()
  14.     print(v)
  15. 4. 计算元素出现的次数
  16.     v = li.count(22)
  17.     print(v)
  18. 5. 扩展原列表，参数：可迭代对象，注意：append，extend区分开来。
  19.     li = [11, 22, 33, 22, 44]
  20.     li.append([9898,"不得了"])  作为整体加到列表
  21.     输出：[11, 22, 33, 22, 44, [9898, '不得了']]
  23.     li.extend([9898,"不得了"])   每一个元素单独加到列表
  24.     for i in [9898,"不得了"]:
  25.         li.append(i)
  26.     输出：[11, 22, 33, 22, 44, 9898, '不得了']
  28.     li.extend("不得了")
  29.     print(li)
  31. 6. 根据值获取当前值索引位置（左边优先）
  32.     li = [11, 22, 33, 22, 44]
  33.     v= li.index(22)
  34.     print(v)
  36. 7. 在指定索引位置插入元素
  37.     li = [11, 22, 33, 22, 44]
  38.     li.insert(0,99)
  39.     print(li)
  41. 8、 删除某个值(1.指定索引；2. 默认最后一个)，并获取删除的值
  42.     li = [11, 22, 33, 22, 44]
  43.     v1 = li.pop(3)   删除22
  44.     v2 = li.pop()    删除44
  45.     print(li)
  46.     print(v)
  48. 9. 删除列表中的指定值，左边优先
  49.     li = [11, 22, 33, 22, 44]
  50.     li.remove(22)
  51.     print(li)
  53. 删除元素的方法: pop remove del   clear（清空）
  55. 10 将当前列表进行翻转
  56.     li = [11, 22, 33, 22, 44]
  57.     li.reverse()
  58.     print(li)
  60. 11 列表的排序
  61.     li = [11,44, 22, 33, 22]
  62.     li.sort()
  63.     li.sort(reverse=True)
  64.     print(li)
  65. 列表格式，中括[]括起来
  66. 列表中可以嵌套任何类型用，分割每个元素
  67. 列表中的元素可以是 数字，字符串,列表，布尔值..所有的都能放进去
  68. 索引取值
  69.     print(li[3])
  70. 切片，切片结果也是列表
  71.     print(li[3:-1])
  72. 列表元素，可以被修改
  73.     li = [1, 12, 9, "age", ["abc", ["19", 10], "def"], "gh", True]
  74. 修改
  75.     li[1] = 120
  76.     print(li)
  77.     li[1] = [11,22,33,44]
  78.     print(li)
  80. 12 切片
  81. 修改
  82.     li[1:3] = [120,90]
  83.     print(li)
  84. 删除
  85.     del li[2:6]
  86.     print(li)
  88. 13 in 操作
  89. li = [1, 12, 9, "age", ["a", ["19", 10], "b"], "c", True]
  90. v1 = "a" in li
  91. print(v1)
  92. v2 = "age" in li
  93. print(v2)
  95. 14 转换类型
  96. #字符串转换列表 
  97. li =  list("asdfasdfasdf"), 内部使用for循环
  98. s = "pouaskdfauspdfiajsdkfj"
  99. new_li = list(s)
  100. print(new_li)
  102. #列表转换成字符串，
  103. 需要自己写for循环一个一个处理： 既有数字又有字符串
  104. li = [11,22,33,"123","abc"]
  105. r = str(li) 
  106. print(r)
  107. # 输出：'[11,22,33,"123","abc"]'
  108. s = ""
  109. for i in li:
  110.     s = s + str(i)
  111. print(s)   112233123abc
  113. #直接使用字符串join方法：要求列表中的元素只有字符串
  114. li = ["123","abc"]
  115. v = "".join(li)
  116. print(v)
  118. #列表创建后可修改，且列表有序
  119. #字符串创建后，不可修改
  120. v = "alel"
  121. v = v.replace('l','abc')
  122. print(v)    #aadceabc 全部替换
  124. li = [11,22,33,44]
  125. li[0]
  126. li[0] = 999
  128. s = "alex"
  129. li[0]
  130. s[0] = "E"   #报错

元组

  1. 1. 书写格式
  2.  tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
  3. 一般写元组的时候，推荐在最后加入 ,
  4. 元素不可被修改，不能被增加或者删除
  6. 2. 索引
  7.  v = tu[0]
  8.  print(v)
  10. 3. 切片
  11.  v = tu[0:2]
  12.  print(v)
  14. 4. 可以被for循环，可迭代对象
  15.  for item in tu:
  16.  print(item)
  18. 5. 转换
  19.  s = "asdfasdf0"
  20.  li = ["asdf","asdfasdf"]
  21.  tu = ("asdf","asdf")
  22.  v = tuple(s)
  23.  print(v)
  24.  v = tuple(li)
  25.  print(v)
  27.  v = list(tu)
  28.  print(v)
  30.  v = "_".join(tu)
  31.  print(v)
  33.  li = ["asdf","asdfasdf"]
  34.  li.extend((11,22,33,))
  35.  print(li)
  37. #6.元组的一级元素不可修改/删除/增加
  38. tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
  39. 元组，有序。
  40. v = tu[3][0][0]
  41. print(v)
  42. v=tu[3]
  43. print(v)
  44. tu[3][0] = 567
  45. print(tu)
  47. 7.基本函数调用
  48.  tu = (11,22,33,44)
  49.  tu.count(22),获取指定元素在元组中出现的次数
  50.  tu.index(22) ，获取22的索引位置

字典

  1. #1、基本机构
  2.     info = {
  3.         "k1": "v1", # 键值对
  4.         "k2": "v2"
  5.     }
  6.     # 2 字典的value可以是任何值
  7.     info = {
  8.         "k1": 18,
  9.         "k2": True,
  10.         "k3": [
  11.             11,
  12.             [],
  13.             (),
  14.             22,
  15.             33,
  16.             {
  17.                 'kk1': 'vv1',
  18.                 'kk2': 'vv2',
  19.                 'kk3': (11,22),
  20.             }
  21.         ],
  22.         "k4": (11,22,33,44)
  23.     }
  24.     print(info)
  26. #3 布尔值(1,0)、列表、字典不能作为字典的key
  27.     info ={
  28.         1: 'asdf',
  29.         "k1": 'asdf',
  30.         True: "123",
  31.         # [11,22]: 123 报错
  32.         (11,22): 123,
  33.         # {'k1':'v1'}: 123 报错
  35.     }
  36.     print(info)
  38. #4 字典无序
  40.     info = {
  41.         "k1": 18,
  42.         "k2": True,
  43.         "k3": [
  44.             11,
  45.             [],
  46.             (),
  47.             22,
  48.             33,
  49.             {
  50.                 'kk1': 'vv1',
  51.                 'kk2': 'vv2',
  52.                 'kk3': (11,22),
  53.             }
  54.         ],
  55.         "k4": (11,22,33,44)
  56.     }
  57.     print(info)
  58.     print(info)  #两次打印出来不相同
  60. 5、索引方式找到指定元素
  61.     info = {
  62.         "k1": 18,
  63.         2: True,
  64.         "k3": [
  65.             11,
  66.             [],
  67.             (),
  68.             22,
  69.             33,
  70.             {
  71.                 'kk1': 'vv1',
  72.                 'kk2': 'vv2',
  73.                 'kk3': (11,22),
  74.             }
  75.         ],
  76.         "k4": (11,22,33,44)
  77.     }
  78.     v = info['k1']
  79.     print(v)
  80.     v = info[2]
  81.     print(v)
  82.     v = info['k3'][5]['kk3'][0]
  83.     print(v)
  85. #6 字典支持 del 删除
  86.     info = {
  87.         "k1": 18,
  88.         2: True,
  89.         "k3": [
  90.             11,
  91.             [],
  92.             (),
  93.             22,
  94.             33,
  95.             {
  96.                 'kk1': 'vv1',
  97.                 'kk2': 'vv2',
  98.                 'kk3': (11,22),
  99.             }
  100.         ],
  101.         "k4": (11,22,33,44)
  102.     }
  103.     del info['k1']
  105.     del info['k3'][5]['kk1']
  106.     print(info)
  108. 7 for循环
  109.     dict
  110.     info = {
  111.         "k1": 18,
  112.         2: True,
  113.         "k3": [
  114.             11,
  115.             [],
  116.             (),
  117.             22,
  118.             33,
  119.             {
  120.                 'kk1': 'vv1',
  121.                 'kk2': 'vv2',
  122.                 'kk3': (11,22),
  123.             }
  124.         ],
  125.         "k4": (11,22,33,44)
  126.     }
  127.     for item in info:
  128.         print(item)
  130.     for item in info.keys():  找键
  131.         print(item)
  133.     for item in info.values():    找值
  134.         print(item)
  136.     for item in info.keys():
  137.         print(item,info[item])
  139.     for k,v in info.items():    一起拿键和值
  140.         print(k,v)
  143. 8 设置值，
  144. 已存在，不设置，获取当前key对应的值
  145. 不存在，设置，获取当前key对应的值
  146.     dic = {
  147.         "k1": 'v1',
  148.         "k2": 'v2'
  149.     }
  150.     v = dic.setdefault('k1111','123')
  151.     print(dic,v)  
  153. 9 更新的两种传参方式
  154.     dic = {
  155.         "k1": 'v1',
  156.         "k2": 'v2'
  157.     }
  158.     dic.update({
  159.    'k1': '111111','k3': 123})
  160.     print(dic)
  161.     dic.update(k1=123,k3=345,k5="asdf")
  162.     print(dic)

str 字符串

  1. # 1 首字母大写
  2.     test = "aLex"
  3.     v = test.capitalize()
  4.     print(v)
  6. # 2 所有变小写，casefold更牛逼，很多未知的对相应变小写
  7.     v1 = test.casefold()
  8.     print(v1)
  9.     v2 = test.lower()
  10.     print(v2)
  12. # 3 设置宽度，并将内容居中，左，右
  13. # 20 代指总长度
  14. # * 空白未知填充，一个字符，可有可无
  15.     v = test.center(20,"中")
  16.     print(v)
  17.     test = "alex"
  18.     v = test.ljust(20,"*") print(v) test = "alex" v = test.rjust(20,"*")
  19.     print(v)
  21.     test = "alex"
  22.     v = test.zfill(20)   用0填充
  23.     print(v)
  25. # 4 去字符串中寻找，寻找子序列的出现次数
  26.     test = "aLexalexr"
  27.     v = test.count('ex')
  28.     print(v)
  29.     test = "aLexalexr"
  30.     v = test.count('ex',5,6)  #5,6 指定索引范围
  31.     print(v)
  34. # 5 以什么什么结尾，以什么什么开始
  35.     test = "alex"
  36.     v = test.endswith('ex')
  37.     v = test.startswith('ex')
  38.     print(v)
  40. # 6 expandtabs,断句tabs为20，
  41.     test = "username\temail\tpassword\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123"
  42.     v = test.expandtabs(20)
  43.     print(v)
  44. #输出 
  45. username            email               password
  46. laiying             ying@q.com          123
  47. laiying             ying@q.com          123
  48. laiying             ying@q.com          123
  50. # 7 从开始往后找，找到第一个之后，获取其位置
  51.     test = "alexalex"
  52.     未找到 -1
  53.     v = test.find('ex')
  54.     print(v)
  56. # 8 index找不到，报错 忽略
  57.     test = "alexalex"
  58.     v = test.index('8')
  59.     print(v)
  62. # 9 格式化，将一个字符串中的占位符替换为指定的值
  63.     test = 'i am {name}, age {a}'
  64.     print(test)
  65.     v = test.format(name='alex',a=19)
  66.     print(v)
  68.     test = 'i am {0}, age {1}'
  69.     print(test)
  70.     v = test.format('ndk',19)
  71.     print(v)
  73. # 10 格式化，传入的值 {"name": 'alex', "a": 19}
  74.     test = 'i am {name}, age {a}'
  75.     v1 = test.format(name='df',a=10)
  76.     v2 = test.format_map({
  77.    "name": 'alex', "a": 19})
  80. # 11 字符串中是否只包含 字母和数字
  81.     test = "123"
  82.     v = test.isalnum()
  83.     print(v)
  86. # 12 是否是字母，汉字
  87.     test = "as2df"
  88.     v = test.isalpha()
  89.     print(v)
  91. # 13 当前输入是否是数字
  92.     test = "二" # 1，②
  93.     v1 = test.isdecimal()
  94.     v2 = test.isdigit()
  95.     v3 = test.isnumeric()
  96.     print(v1,v2,v3)
  98. # 14 是否存在不可显示的字符
  99. # \t 制表符
  100. # \n 换行
  101.     test = "oiuas\tdfkj"
  102.     v = test.isprintable()
  103.     print(v)
  105. # 15 判断是否全部是空格
  106.     test = ""
  107.     v = test.isspace()
  108.     print(v)
  110. # 16 判断是否是标题
  111.     test = "Return True if all cased characters in S are uppercase and there is"
  112.     v1 = test.istitle()
  113.     print(v1)
  115. # 17 ***** 将字符串中的每一个元素按照指定分隔符进行拼接
  116.     test = "你是风儿我是沙"
  117.     print(test)
  118.     t = ' '
  119.     v = "_".join(test)
  120.     print(v)
  122. # 18 判断是否全部是大小写 和 转换为大小写
  123. test = "Alex"
  124. v1 = test.islower()
  125. v2 = test.lower()
  126. print(v1, v2)
  128. v1 = test.isupper()
  129. v2 = test.upper()
  130. print(v1,v2)
  131. # 19移除指定字符串，有限最多匹配
  132. test = "xa"
  133. v = test.lstrip('xa')
  134. v = test.rstrip('9lexxexa')
  135. v = test.strip('xa')
  136. print(v)
  138. # 去除左右空白 去除\t \n
  139. v = test.lstrip()
  140. v = test.rstrip()
  141. v = test.strip()
  142. print(v)
  144. # 20 对应关系替换
  145. test =  "aeiou"
  146. test1 = "12345"
  147. v = "asidufkasd;fiuadkf;adfkjalsdjf"
  148. m = str.maketrans("aeiou", "12345")
  149. new_v = v.translate(m)
  150. print(new_v)  #输出1s3d5fk1sd;f351dkf;1dfkj1lsdjf 将对应字符替换
  152. # 21 分割为三部分
  153. test = "testasdsddfg"
  154. v = test.partition('s')
  155. print(v)   #('te', 's', 'tasdsddfg')
  156. v = test.rpartition('s')
  157. print(v)   #('testasd', 's', 'ddfg')
  159. # 22 分割为指定个数
  160. v = test.split('s',2)
  161. print(v)
  162. test.rsplit()
  164. # 23 分割，只能根据，true，false：是否保留换行（True保留，False不保留）
  165. test = "asdfadfasdf\nasdfasdf\nadfasdf"
  166. v = test.splitlines(True)
  167. print(v)  #['asdfadfasdf\n', 'asdfasdf\n', 'adfasdf']
  170. # 24 字母，数字，下划线 ： 标识符 def class
  171. a = "def"
  172. v = a.isidentifier()
  173. print(v)
  176. # 25 将指定字符串替换为指定字符串
  177. test = "alexalexalex"
  178. v = test.replace("ex",'bbb')
  179. print(v)
  180. v = test.replace("ex",'bbb',2)  #替换次数
  181. print(v)

发表评论

表情：
评论列表 （有 0 条评论，459人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Python入门基础之二

    文章标题是十分钟入门Python，这么霸气，应该是有点作用的： 初试牛刀 假设你希望学习Python这门语言，却苦于找不到一个简短而全面的入门教程。那么本教程

    冷不防冷不防/ 0 赞/ 87 阅读