各种序列的用法

各种序列的用法

目录

• 各种序列的用法
  • 列表
    • 创建
    • 管理列表
    • 获取列表
    • 操作符
    • 常用方法
  • 元组
    • 创建、访问和更改
    • 操作符
    • 其他
  • 字符串
    • 转义字符
    • 切片与方法
    • 格式化字符串
  • 字典
    • 创建与访问
    • 内置方法
  • 集合
    • 创建和访问
    • 其他方法
    • 转换、不可变集合
  • 序列
    • 内置函数
  • 备注
    • 数组说明
    • 异或

---

列表

创建

• 创建一个普通列表

  x = ["11","22","33","44"]
  print(x)
  # ['11', '22', '33', '44']
  

• 利用range创建一个列表

  x = list(range(1，10，2))#范围1-10（不包括10，步长为2（步长可以为负数）
  print(x)
  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  

• 利用推导式创建一个列表

  x = [i for i in range(10)]
  print(x)
  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  

• 推导式创建二维数组

  x = [i for i in range(3)]
  y = [x for i in range(3)]
  print(y)
  # [[0, 1, 2], [0, 1, 2], [0, 1, 2]]
  

  • 推导式是一个快速生成数组的方式，for前面代表数组的内容，for后面表示循环的次数

• 混合列表

  解释：列表中存在两种或以上类型的值

  x = [1,"二",'c',True,0.5,[1,2,3]]
  print(x)
  # [1, '二', 'c', True, 0.5, [1, 2, 3]]
  

• 注意：

  1. 数组赋值给变量后变量值不会因为赋值前数组中的变量改变而改变
  2. 数组中的变量值不是固定不变的

管理列表

函数	解释
list.append(n)	在列表末尾追加新的对象
list.extend([a,b,c....n])	在列表末尾一次性追加另一个序列中的多个值
list.insert(index,n)	在列表的指定位置前插入新的对象
list.remove(n)	删除列表中的匹配项
list.pop([index=n])	删除列表中的指定项
del x[m,n]	删除列表中m-n位置的对象

获取列表

• 第一个值：x[0]
• 最后一个值：x[-1]
• 第三个及以后的值：x[2:]
• 前三个值：x[:3]
• 后三个值：x[:-3]
• 第2-5个值：x[1:4]
• 偶数位的值：x[1👎2]
• 奇数位的值：x[0👎2]
• 倒数第m-n的值：x[-m,-n-1] #此处n为不包含

[点击返回元组处](# 创建、访问和更改)

[点击返回字符串处](# 切片与方法)

操作符

列表相互拼接可以组成一个新的列表

• 等号操作符：==
• 连接操作符：+
• 重复操作符：*
• 成员关系操作符：in、not in

等号操作符返回结果为bool值

常用方法

函数	解释
list.count(n)	统计n在列表中出现的次数
list.index(x,start,end)	从列表的指定范围中找出x第一次出现的所以位置
list.reverse()	反序
list.sort()	对列表中的元素进行排序

元组

元组创建后无法对其进行修改

创建、访问和更改

• 创建元组可以加括号也可以不加括号

  x = (1,2,3)
  y = 4,5,6
  print (x,y)
  # (1, 2, 3) (4, 5, 6)
  

• 获取列表中元素的方式同样适用于元组，内容详见[获取列表](# 获取列表)

• 元组中只存在单个int元素时，可以直接使用并进行计算

  print(10*(10))
  # 100
  print(3*(10,20))
  # (10,20,10,20,10,20)
  

• 元组拥有不可更改的特性，但是只要元组中的元素拥有可更改的性质，即可更改该元素

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

操作符

• 连续操作符：+
• 重复操作符：*
• 成员关系操作符：in、not in

其他

1. 内置方法

   • 函数	解释
     tuple.count(n)	n在tuple元组中出现的次数
     tuple.index(n)	n在tuple中的索引

2. 解压元组

   x = 1,2,3,4,5,6
   a, b, *c, d = x
   print (a,b,c,d)
   # 1 2 [3, 4, 5] 6
   

   元组解压后可以通过赋值的变量随意调用

字符串

转义字符

转义字符	解释
\\	反斜杠
\'	单引号
\"	双引号
\n	换行
\t	横向制表符
\r	回车

切片与方法

字符串的切片与列表中用法相同，[点击查看](# 获取列表)

字符串常用的内置方法

函数	解释
text.capitalize()	将字符串中的第一个字符转换成大写
text.lower()	转换字符串中所有大写字符为小写
text.upper()	转换字符串中所有小写为大写
text.swapcase()	转换字符串的大小写
text.count(h,beg=n,end=m)	指定范围内的h出现次数
text.endswith(h,beg=n,end=m)	指定范围内是否以h结束，返回值为bool型
text.startswith(h,beg=n,end=m)	指定范围内是否以h开始，返回值为bool型
text.find(h,beg=n,end=m)	指定范围内是否包含h，返回索引值，没有则返回-1
text.rfind(h,beg=n,end=m)	指定范围内是否包含h，返回索引值，没有则返回-1，查找顺序为从右向左
text.isnumeric()	判断字符串中是否全是数字，返回值为bool型
text.ljust(w,fillchar=t)	原字符追加t直至长度达到w为止
text.rjust()	原字符前面追加t直至长度达到w为止
text.lstrip()	截取字符串左边的空格
text.rstrip()	截取字符串右边的空格
text.(lstrip().)/(rstrip().)strip()	在rstrip和lstrip后执行，示例：text.lstrip().strip('n'),解释：在text字符串中以n为条件进行截取，截取方向根据前面函数决
text.strip().partition(s)	将字符串根据n分割成一个三元组，若不存在给定字符，则返回("原字符串","","")
text.strip().rpartition(n)	方法同partition，但是查找顺序相反
text.strip().replace(m,n[x,y])	替换字符串中指定内容，可以指定新内容的替换次数，默认为1
text.strip().split(str="",n)	根据str分割字符串，str默认为空格，n为分割字符串数量，返回值为分割后的子字符换组成的列表
text.splitlines([keepends])	根据回车、换行字符进行分割，返回各行列表，若keepends分False，则不包含换行符，反之则包含
n=text.maketrans(x,y)	将text中指定字符x转换为y，结果复制到n
text.translate(n,d="")	根据n给出的表，转换字符串的字符，要过滤掉的字符放到d中（让n转换的字符生效）

以上表格中所有方法都需要将结果赋值给变量，否则无法使用

格式化字符串

• format函数

1. 位置参数

   x = "{}是第一个参数，{}是第二个参数".format("a","b")
   print(x) # 大括号中可以写索引，也可以为空时使用默认顺序：0，1，2，3...n
   # a是第一个参数，b是第二个参数
   

2. 关键字参数

   x = "{a}是第一个参数，{b}是第二个参数".format(a="A",b="B")
   print(x)
   # A是第一个参数，B是第二个参数
   

3. 保留小数点后n位

   x = "{0:.3f}".format(303.23543843)
   print(x)
   # 303.235
   

以上三种方式可以同时使用，但要注意索引顺序

• 格式化符号

符号	描述
%c	转换为为ASCII码
%s	处理字符串
%d	处理整数
%o	处理无符号八进制数字
%x	处理无符号十六进制数字
%X	处理无符号十六进制数字（大写）
%f	处理浮点数字，可指定小数点后的精度
%e	将浮点数转换成科学计数法表示形式
%E	将浮点数转换成科学计数法表示形式，效果同%e
%g	根据值的大小决定使用%f还是%e
%G	根据值的大小决定使用%f还是%e，效果同%g

以上格式化符号表示方式：

print("这是科学计数法表示数字%e" % 2.56345)
# 这是科学计数法表示数字2.563450e+00

---

字典

解释：字典是无序的{键:值}的集合，同一个字典中，不允许存在相同的键

创建与访问

1. 赋值创建字典

   x = {'a':111,'b':222,'c':333} # 直接赋值
   print(x)
   # {'a': 111, 'b': 222, 'c': 333}
   

2. dict函数创建字典

   x = dict([('A',"aaa"),('B',"bbb")])
   y = dict(a = 111,b = "ccc")
   print (x)
   print (y)
   # {'A': 'aaa', 'B': 'bbb'}
   # {'a': 111, 'b': 'ccc'}
   

3. 访问字典

   x = dict([('A',"aaa"),('B',"bbb")])
   y = dict(a = 111,b = "ccc")
   print (x['A'])
   print (y['b'])
   # ccc
   # aaa
   

• 字典的键只可以是字母组成的字符或字符串

内置方法

方法	解释
dict.formkeys(n,s)	以序列n为键，序列s为对应的值
dict.keys()	可以使用list()转换为列表，输出内容为字典中的所有键
dict.values()	可以使用list()转换为列表，输出内容为字典中所有的值
dict.items()	将字典中每队元素以元组的形式赋值
dict.get(key,s)	返回键对应的值，如果不存在，则返回s
dict.sedefault(key,s)	返回键对应的值，如果不存在，则返回s
dict.pop(key)	删除给定键的值
del dict[key]	删除指定的键
dict.popitem()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict.update(dict2)	将dict2内容更新到dict中

• 以上方法都需要向结果赋值或直接打印

---

集合

集合就是不可更改的字典

创建和访问

1. 创建集合

   # 使用set函数创建集合：
   x = set(['a','b','c'])
   print(x) 
   # {'a', 'b', 'c'}
   
   # 创建集合可以省略set函数，直接写法：
   x = {'a', 'b', 'c'}
   print(x)
   # {'c', 'b', 'a'}
   # 集合是一个无序的组合，输出内容会随机排列
   

2. 访问集合

   # 通过循环的方式对集合中的元素遍历一遍，从而读取数值
   x = set('a','b','c')
   for i in x:
       print(i)
   # c
   # b
   # a
   # 访问集合无法使用索引的方式，因为集合中的元素是无序的
   

其他方法

方法	解释
set.add(n)	向集合中添加元素n
set.update(set2)	更新当前集合并去重
set.remove(n)	移除指定元素n，若元素不存在，则会报错
set.discard(n)	移除指定元素n，若元素不存在，则不会报错
set.pop()	随机移除一个元素
set.intertersection(set1,set2...)	返回指定集合的交集(任意个数)
set1 & set2	返回指定集合的交集(任意个数)
set.intersection_update(set1,set2...)	返回指定集合的交集（去重）
set.union(set1,set2...)	返回指定集合的并集(任意个数)
set1 | set2	返回指定集合的并集(任意个数)
set.difference(set)	返回集合的差集（两个集合中只出现过一次的元素）
set1 - set2	返回集合的差集（两个集合中只出现过一次的元素）
set.difference_update(set)	返回集合的差集并去重
set.symmetric_difference(set)	返回集合的[异或](# 异或)(点击查看解释)
set1 ^ set2	返回集合的异或
set.symmetric_difference_update(set2)	两个集合去重并合并
set1.issubset(set2)	判断set2中是否包含set1
set1 <= set2	判断set2中是否包含set1
set1.issuperset(set2)	判断set1中是否包含set2
set1 >= set2	判断set1中是否包含set2
set.isdisjoint(set2)	判断两个集合是否相交，返回值为bool型

转换、不可变集合

1. 集合可以转换为列表和元组

   x = {'a', 'b', 'c'}
   y = list(x)
   z = tuple(x)
   print(type(x))
   print(type(y))
   print(type(z))
   # <class 'set'>
   # <class 'list'>
   # <class 'tuple'>
   

2. 创建不可变集合

   x = {'a', 'b', 'c'}
   y = frozenset(x) # 使用frozenset改变集合类型
   print(x)
   print(y)
   # {'b', 'a', 'c'}
   # frozenset({'b', 'a', 'c'})
   

   不可变集合不可添加、删除元素，但仍可以访问

序列

python中序列可以转换成一下数组类型：列表、元组、字符串

如果一个数组，不是列表、元组和字符串，他就是一个序列

内置函数

函数	解释
list(sub)	将序列转换成列表
tuple(sub)	将序列转换成元组
str(sub)	将序列转换成字符串
len(sub)	返回序列的长度
max(sub)	返回序列中的最大值
min(sub)	返回序列中的最小值
sum(sub,n)	返回sub元素的和+n的和
sorted(sub,key,reverse)	对sub进行排序，key为比较的条件，reverse为True时为降序，False时为升序
reversed(sub)	将sub内容反转
enumerate()	将普通序列组成一个索引序列，给每个元素添加键
zip(sub1,sub2)	将sub1的元素作为sub2的索引，组合成索引序列

以上函数需要赋值给变量才能调用

备注

数组说明

1. 序列是以连续的整数为索引，字典以关键字为索引，关键字是任意不可变的类型,通常使用字符串或数值

2. 在Python中，字符串、元组、列表属于序列类型，字典是唯一一个映射类型

3. 判断变量是否为可变类型：

   • 使用hash()函数，只要不报错，证明变量不可变，反之则可变

异或

• a 或 b表示两个中一个满足，a 异或 b表示两个都不满足则不满足，可以理解为a和b都满足
• 点击返回集合[其他方法](# 其他方法)