Python 常用类型相关操作

相关类型操作

• 字符串

# 字符串对象是不可变对象
  s1 = 'i love you more than'
  s2 = ' you love me '
  # 根据下标取得字符
  print(s1[0])
  # 字符串拼接
  s = s1 + s2
  # 查找字符串,返回第一个匹配到的下标
  print(s1.find('o'))
  # 从右查找,返回字符出现的最高位下标
  print(s1.rfind('o'))
  # 返回首字母大写的字符串版本
  print(s.capitalize())
  # 单词首字母大写
  print(s.title())
  # 去除左右空白
  print(s2.strip())
  # 去除有空白
  print(s2.rstrip())
  # 去除左空白
  print(s2.lstrip())
  # 获取字符串第一次出现的下标,如果没有匹配到的substr则会出错
  print(s.index('love'))
  # 统计字符出现的次数
  print(s.count('lo'))
  # 切割字符串，返回一个列表，可以指定切割次数
  print(s1.split(' ', maxsplit=1))
  # 从右切割
  print(s1.rsplit(' ', maxsplit=1))
  # 按行切割,返回一个列表
  s4 = '''abc
  def
  ghk
  '''
  print(s4.splitlines())
  # 转大写
  print(s.upper())
  # 转小写
  print(s.lower())
  # 按特定字符拼接字符串
  s3 = ' '.join(['i', 'love', 'you'])
  print(s3)
  # 判断是否以什么开头
  print(s1.startswith('i'))
  # 判断是否以什么结尾
  print(s1.endswith('i'))
  # 大小写转换
  print(s1.swapcase())

• 切片(序列都可以，必须是有序的)

  s = 'abcdefg'
  # 从开头进行提取，下标从0开始
  print(s[0])
  # 从末尾进行提取，下标从-1开始
  print(s[-1])

  # 切片
  # 格式：s[开始:结束:步进]
  print(s[1:3])
  # 当一边的边界省略，则提取到改侧的边缘
  print(s[1:])
  print(s[:4])
  print(s[1:-2])
  print(s[:-3])
  print(s[-3:])

  # 指定步进值，默认为1
  print(s[::2])
  # 逆序提取
  print(s[::-1])

• 列表操作

lt = [1, 7, 8, 9, 2, 3, 4, 5, 0]
  # print(lt, type(lt))

  # 列表是有序的，可重复的

  # 通过下标获取元素
  print(lt[0])

  # 通过append()在列表末尾添加元素
  lt.append(1)
  print(lt)

  # 拷贝列表，返回一个新列表
  lt1 = lt.copy()
  print(lt1, id(lt), id(lt1))

  # 统计值出现的次数
  num = lt1.count(1)
  print(num)

  # 移除从下标0开始匹配到的元素
  lt1.remove(1)
  print(lt1)

  # 通过可迭代对象追加元素
  lt1.extend([1, 2, 3])
  print(lt1)

  # 获取第一个匹配到的元素的下标
  print(lt1.index(1))

  # 在下标处插入元素
  lt1.insert(0, 1)
  print(lt1)

  # 弹出元素（默认末尾元素）
  print(lt1.pop(0))
  print(lt1.pop())

  # 反转列表元素
  lt1.reverse()
  print(lt1)

  # 对列表排序，默认升序，没有任何参数
  lt1.sort()
  print(lt1)

• 元组操作

  # tp1 = (1, 2, 3)
  # tp1 = (1,)
  tp1 = 1, 2, 3
  tp2 = (4, 5, 6)
  # 可以直接拼接在一起
  # tp3 = tp1 + tp2
  # print(tp3, type(tp3))
  # 重复指定次数
  tp4 = tp1 * 3
  print(tp4)
  # 统计元素个数
  print(len(tp4))
  tp = (1, 2, 3, 4, 5, 6)
  # 切片操作
  print(tp[0], tp[-1])
  print(tp[1:-1])
  # 获取指定元素的索引
  print(tp.index(3))
  # 统计元素出现的次数
  print(tp.count(3))
  # 最大值
  print(max(tp))
  # 最小值
  print(min(tp))
  

• 集合操作

  s = {'a', 'b', 'b', 'd', 'e', 'f'}
  
  # 添加元素
  s.add('g')
  
  # 删除元素
  # s.remove('a')
  # 删除不存在元素会报KeyError错
  # s.remove('z')
  # 删除元素，元素存在则删除，不存在也不报错
  s.discard('z')
  
  # 返回并删除，元素是随机的
  # print(s.pop())
  
  # 清空元素
  s.clear()
  
  # print(s)
  
  s1 = {'a', 'b', 'c'}
  s2 = {'c', 'd', 'e', 'f', 'g'}
  
  # 并集
  # print(s1.union(s2))
  
  # 交集
  # print(s1.intersection(s2))
  # 求交集，并用交集覆盖原来的集合
  # s1.intersection_update(s2)
  
  # 差集
  # print(s1.difference(s2))
  # 求差集，并用差集覆盖原来的集合
  # s1.difference_update(s2)
  # print(s1)
  
  # 判断是否没有交集
  print(s1.isdisjoint(s2))
  # 判断是否是另一集合的子集
  print(s1.issubset(s2))
  # 判断是否是另一集合的父集/超集
  print(s2.issuperset(s1))
  

• 字典操作

  d = {'name': 'xiaoming', 'age': 20}
  
  # 获取元素
  # 有就返回对应的值，没有就报KeyError错
  print(d['name'])
  # 有就返回对应的值，没有就返回None，可以指定默认值
  print(d.get('namexxx', '默认值'))
  
  # 修改元素
  # 键存在则修改对应的值
  d['name'] = 'xiaohei'
  # 键不存在则添加键值对
  d['height'] = 180
  
  # 更新：存在的键会覆盖，不存在的键会添加
  d.update({'name': 'xiaobai'})
  
  # 删除元素
  # del d['height']
  # 返回并删除
  print(d.pop('age'))
  
  # 清空元素
  d.clear()
  
  print(d)
  

• 字符串格式化

# 格式化
# 第一种：老式的
# %s：字符串
# %d：整型
# %f：浮点
# %c：字符
name = 'Jack'
like = 'Tom'
age = 18
print("I'm %s, %d years old. Like %s." % (name, age, like))
# 第二种 format
# 默认按顺序指定
print("I'm {}, {} years old. Like {}.".format(name, age, like))
# 自定义位置
print("I'm {2}, {1} years old. Like {0}.".format(name, age, like))
# 变量形式指定
print("I'm {a}, {b} years old. Like {c}.".format(a=name, b=age, c=like))
# 第三种 f格式化
print(f"I'm {name}, {age} years old. Like {like}.")

• 数据类型转换

# 隐式类型转换：不需要声明
print(3/2)  # >>> 1.5 从int->float
# 强制类型转换：函数声明强制转换（不符合逻辑进行转换的会报ValueErrer,比如int('abc')）
'''
int：转换为整型
float：转换为浮点
str：转换为字符串
list：转换为列表
tuple：转换为元组
set：转换为集合
dict：转换为字典
'''

# 转换为整数
# a = int(3.14)
# 参数1：需要转换的数据
# base：数据的进制类型，默认为十进制
# a = int('123', base=8)
# a = int('abc', base=16)

# 浮点
# a = float(250)

# 字符串
# a = str(123)

# 列表
# a = list('hello')
# a = list((1, 2, 3))
# a = list({1, 2, 3})
# 可以转换不会报错，但是只保留了键
# a = list({'name': 'ergou', 'age': 18})

# 元组
# a = tuple([1, 2, 3])

# 集合
# a = set([1, 2, 3])

# 字典
lt = [('name', 'dahua'), ('age', 18)]
a = dict(lt)
print(a, type(a))