数据类型之内置方法

今日内容概要

• 字符串的其他内置方法

• 列表的内置方法

• 字典的内置方法

• 队列与队栈

  ..............

   

  今日内容详细

  字符串的其他内置方法

  

   

   

  # 1.移除字符串首尾的指定字符  可以选择方向
  # s1 = '$$$jason$$$'
    print(s1.strip('$'))  # 输出 jason
    print(s1.lstrip('$'))  # 将左边$符号移除
    print(s1.rstrip('$'))  # 将右边$符号移除
   
  ​
  # 2.大小写相关操作
  # s2 = 'tomNB'
  # print(s2.lower()) # 将所有的英文字母变为小写 tomnb
  # print(s2.upper()) # 将所有的英文字母变为大写TOMNB
  # print(s2.islower()) # 判断字符串找那个所有的英文字母是否是纯小写 结果是布尔值 True or False
  # print(s2.isupper()) # 判断字符串找那个所有的英文字母是否是纯大写 结果是布尔值 True or False
  学习大小写操作的目的是为了图形验证码：一串有数字 大写字母 小写字母组成
  为什么以前的认证码需要一模一样 大小写不能忽略 现在的验证码却可以 如何实现
  # code = 'toNY6'
  # print('这是返回给用户的图片验证码：%s' % code)
  # user_code = input('请输入验证码>>>:').strip()
  # if code.lower() == user.lower(): # 验证码忽略大小写 只需要统一转大小写即可
  #     print('验证码正确')
  ​
  # 3.判断字符串的开头或者结尾是否是指定的字符
  # s3 = 'jason kevin jason tony 888'
  # print(s3.startswith('j'))  # True
  # print(s3.startswith('jason')) # True
  # print(s3.startswith('tony')) # False
  # print(s3.startswith('8')) # True
  # print(s3.startswith('888')) # True
  # print(s3.startswith('jason')) # False
  ​
  # 4.格式化输出
  # 方式1 占位符：%s %d
  # 方式2 利用format方法》》》：四种用法
  # 用法1：跟占位符一样的用法 使用{}占位
  # print('my name is {} my age is {}'.format('jason',18))
  # 用法2:根据索引取值 可以反复使用 可以随意几个到语句中
  # print('my name mis {0}{0}{1} my age is {1}{1}'.format('jason',18))
  # 用法3：根据指名道姓的方式取值
  # print('my name is {name}{name} my age is {age}{passwoed}'.format(name='tony',age=17,password=123))
  # 用法4：直接使用已经出现过的变量
  # name = 'jason'
  # age = 19
  # print(f'my name is {name} my age is {age}{name}{name}')
  在python官网以前推荐使用format格式化输出 甚至说要把%s要直接删除
  ​
  # 5.拼接字符串join
  # s1 = '举头望明月 低头思故乡'
  # s2 = '世上无难事 只怕有心人'
  # print(s1+s2) #  举头望明月 低头思故乡世无难事 只怕有心人(如果是字符串很大，加好会加大CPU工作效率,降低电脑的效率 )
  # print(s1*10) # 会重复s1十次
  # print('|'.join(s1))  # 举|头|望|明|月| |低|头|思|故|乡
  # print('$'.join['jason','kevin','jason','tony'])
  # jason$kevin$jsaon$tony
  join方法相当于是将括号内的元素进行for循环,从左往右,一个一个取出来
  # l1 = [11,'jason','kevin']
  # print('|'.join(l1))  # join的元素必须都是字符串才可以，否则系统就会报错
  ​
  # 6.替换字符串中指定的字符
  # s6 = 'jason is DSB DSB DSB jason jason jason'
  # 将jason替换成tony
  # print(s6.replace('jason','tony')) # 默认一次性替代所有
  # 指定替换的个数
  # print(s6.replace('jason','tony'，2)) # 还可以通过控制替换的个数 从左往右
  很多文本编辑器里面的替换功能 就可以使用replace完成
   
  # 7.判断字符串中是否是纯数字
  # s7 ='jason123'
  # print(s7.isdigit())  # False
  # print('123'.isdigit()) # True
  # print('123.21'.isdigit())  # False
  前面我们在学评分系统时学过一个 score = int(score)在输入时系统会报错，为了解决这个问题，，我们可以：
  score = input('score>>>:')
  if score.isdigit():
      score = int(score)
  else: 
      print('能不能好好写')
  ​
  ​

   

   

  字符串需要了解的内置方法

  1.查找指定字符对应的索引值
  s1 = 'jason justin kevin tony'
  print(s1.find('s'))  # 从左往右查找 查找到一个就会结束
  print(s1.find('k',1,9))  # -1 y意思是没有 找不到
  print(s1.index('s'))
  print(s1.index('k',1,9))  # 找不到会直接报错 我们在编写代码时最怕的就是报错,所以不推荐使用会报错的结果
  ​
  2.文本位置改变
  name = 'tony'
  print(name.center(30,'-'))  # 总宽度是30，字符串居中显示，不够用短横线填充
  print(name.ljust(30,'*'))  # 总宽度是30，字符串左对齐显示，不够用*填充
  print(name.rjust(30,'$'))  # 总宽度是30，字符串右对齐显示，不够用$填充
  print(name.zfill(50))  #  总宽度为50，字符串右对齐显示，不够用0填充
   
  3.特殊符号：斜杆与一些英文字母的组合会产生特定的含义
  print('ja\tson\nke\avin')
  \t:表示的是空四格 ja    ton
  \n：表示的是换行
  如果想取消它们的特定含义 可以在字符串的前面加上一个字母r
  print('ja\tson\nke\avin')
    
  4.captalize(首字母大写),swapcase(大小写翻转)，title(每个单词首字母大写)
  ​

   

   

  列表内置方法

  1.类型转换
  print(11)  # 不能转换
  print(lise(11.11))  # 不能转换
  print(list('jason'))  # ['j','a','s','o','n']
  print(list({'name':'jason','pwd':123}))  # ['name','pwd']
  print(list((11,22,33,44,55))) # [11,22,33,44,55]
  print(list({1,2,3,4,5}))  # [1,2,3,4,5]
  print(list(True))
  ​
  ​
  因此可以找出规律list可以转换支持for循环的数据类型
     可以被for循环的数据类型：字符串 列表 字典 元组 集合 
   
  常见操作
   name_list = ['jason','kevin','tony','tom','jerry']
  1.索引取值
  print(name_list[0])
  print(name_list[-1])
  2.切片操作
  print(name_list[1:4])  # ['kevin','tony','tom']
  print(name_list[-4:-1])  # ['kevin','tony',tom]
  print(name_list[-1:-4:-1])  # ['jerry','tom','tony']
  3.间隔
  print(name_list[0:4:1])  # ['jason','kevin','tony','tom']
  print(name_list[0:4:2])  # ['jason','tony']
  print(name_list[-1:-4:-1])  # 
  ['jerry','tom','tony']
  4.统计列表中元素的个数
  print(len(name_list))  # 5
  5.成员运算 最小判断单位是元素而不是元素内的单个字符
  print('j' in name_list)  # False
  print('jason' in name_list)  # True
  6.列表添加元素的方式
  6.1.尾部追加单个元素
  name_list.append('小李')
  print(name_list)   # ['jason','kevin','tony','tom','小李']
  name_list.append([11,22,33,44])
  print(name_list)  # ['jason','kevin','tony','tom',[11,22,33,44]]
  6.2.指定位置插入单个元素
  name_list.insert(0,123) # 是指在索引零位置处插入一个123元素
  name_list.insert(2,'可以插个队')  # 是指在索引2位置处插入一个'可以插个队'的元素
  name_list.insert(1,[11,22,33])  # 是指在索引1位置处插入一个元素[11,22,33]
  6.3.合并列表
  name_list.extend([11,22,33,44,55])
  print(name_list)
   extend其实可以看成是for循环+append
      for i in [11,22,33,44,55]:
          name_list.append(i)
       print(name_list)
   name_list += [11,22,33,44,55]
  print(name_list)  # 加号的效率不高
  7.删除元素
   7.1 通用的删除元素
  del name_list[0]  # 删除列表中索引零位置处的元素
  print(name_list)
   7.2 就地删除 # 指名道姓的直接删除列表中的某个元素
   print(name_list.remove('jerry'))  # None 表示的是系统没有反馈的信息
   print(name_list)
   7.3 延迟删除
    print(name_list.pop())  # 默认是尾部删除  jerry
    print(name_list)
    print(name_list.pop(2))  # 还可以指定索引值 指定索引值2位置处的元素 tony
    print(name_list)
  8.修改列表元素
  print(id(name_list[0]))  获取列表中索引值为零的元素的内存地址
  name_list[0] = 'jasonDSB'
  print(id(name_list[0]))  表示的是获取列表中索引值为零的元素的内存地址
  print(name_list)
  9.排序
  ss = [44,77,99,11,22,33,88,66]
  ss.sort()  # 默认是升序
  print(ss)  # [11,22,33,44,66,77,88,99]
  ss.sort(reverse=true)  # 表示可以修改为降序
  print(ss)  # [99,88,77,66,44,33,22,11]
  ​
  10.翻转
  ss = [44,77,99,11,22,33,88,66]
  ss.reverse()  # 前后颠倒
  print(ss)  # [66,88,33,22,11,99,77,44]
  11.比较运算
  s1 = [11,22,33]
  s2 = [1,2,3,4,5,6,7,8]
  print(s1 > s2)  # True 列表在做比较的时候 ，其实比的是对应索引位置上的元素
  s1 = ['A','B','C']  # A>>>65
  S2 = ['a']  # a >>>97 
  print(s1 > s2)  # False
  12.index计算对应的索引值
  ss = [44,77,99,11,22,33,88,66]
  print(ss.index(99))
  13.统计列表中某个元素出现的次数
  l1 = [11,22,33,44,33,22,11,22,11,22,33,22,33,44,55,44,33]
  print(l1.count(11))  # 统计元素11在列表中出现的次数
  14.clear() # 清空列表
  print(l1)  # 列表清空元素

可变类型与不可变类型

可变类型与不可变类型
内存地址变不变参考的是有两个：变量名与内存之间的绑定绳、
                            变量值与索引值之间的绑定绳
可变类型(列表)
值(本身形式）改变 内存地址不变 修改的是本身的形式
不可变类型(字符串)
值(本身形式)改变 内库地址肯定变 修改过程中产生了新的值
比如：s1 = '$$$jason$$$'
  print(s1.strip('$'))  # jason 本身没有修改 产生了新的结果
  print(s1)  # $$$jason$$$
  
  s2 = [1,2,3]
  print(s2.extend([11,22,33,44,55]))  # None 空
  print(s2)  # [1,2,3,11,22,33,44,55]
比如2：
  s2 = [1,2,3]
  print(id(s2))  # 2171184953160
  s2.append(11)
  print(id(s2))  # 2171184953160
 
  s1 = 'jason'
  print(id(s1))
  res = s1.strip()
  print(res)
  print(s1,id(s1))

队列与队栈

队列 
    先进先出
       eg：超市排队结账 符合队列的特征
 队栈
     先进后出
       eg:叠衣服 符合队栈的特征
  下面使用列表模拟出队列与队栈的特征：
队列：
new_list = []
先进
new_list.append(111)
new_list.append(222)
new_list.append(333)
先出
for i in new_list:
    print(i)
print(new_list.pop(0))
print(new_list.pop(0))
print(new_list.pop(0))
​
队栈
new_list = []
先进
new_list.append(111)
new_list.append(222)
new_list.append(333)
后出
print(new_list.pop())
print(new_list.pop())
print(new_list.pop())
​