python 序列(字符串、字符串、元组、集合、字典)

运行环境:python3.8 Anaconda


字符串

在python中,单个字符就是字符串。
字符串不可改变,使用单引号' ',双引号" ",三引号'" "'(三个单引号)作为界定符。
在需要使用单引号时使用双引号或是使用转移字符表示(\')。
在需要使用反斜杠\ 时,因为反斜杠+后面的字母,会使系统认为你想要引用转义字符,可以在等于号后面加上r/R,表示引用原始字符串。
在需要自由使用单引号和双引号时,可以使用三引号。

  • 访问
    使用整数作为索引来访问其中的元素:
    正整数 从左到右,0表示第一个元素,1表示第二个元素,2表示第三个元素……
    负整数 从右到左,情况完全相反,-1表示倒数第一个元素,-2表示倒数第二个元素,-3表示倒数第三个元素……

    可以用切片访问。

  • 增添连接
    字符串允许‘+’操作符和‘*’操作符的使用,生成一个新字符串。
    在连接时也可以使用 字符串名='元素1''元素2'+…… 的形式
    将‘+’操作符去掉也可以连接,仅仅只是适用字符串常量。

>>> print('i'+' am', 'bob'*3)
i am bobbobbob
>>> a='abc''123'
>>> a
'abc123'
  • 字符串中的判断操作符:in,not in
>>> str = "Hello world"
>>> "He" in str
True
>>> "Me" not in str
True

列表(list)

列表名=[元素1,元素2,元素3……]
所有元素放置于方括号[ ]中,元素间使用逗号‘,’分离,元素可以是任意类型。

  • 增添删改
    允许使用‘+’操作符和“*”操作符的使用,生成一个新列表。
>>> a=[1,23,4]
>>> b=a+[5,6,7]
>>> c=a*2
>>> b
[1,23,4,5,6,7]
>>> c
[1,23,4,1,23,4]

因为当列表增加或删除元素时,列表对象会自动进行内存的扩展或收缩,从而保证相邻元素之间没有缝隙。所以应尽量从列表尾部进行元素的追加或删除操作,不然在后续元素索引改变的情况下,你的很多操作都会出错。

  • 访问
    支持双向索引(用正整数访问还是负整数访问都没有问题!)。

  • 列表常用函数

    1. 列表名.append(x)
      追加整体x(一整个x连括号带内容插入)到列表尾部。

    2. 列表名.insert(插入位置的索引,x)
      在列表你要要的位置插入个体x(x若数量>1,把每一项拆分,再进行插入),后面所有元素后移并索引+1。
      索引的大小若大于列表长度,则表示在:列表最末尾追加x;若为小于列表长度相反数的负数,则表示:在列表最开头插入x。

    3. 列表名.extend([想要追加的列表])
      将另一个列表中的所有元素全部追加到当前列表的最末尾。(恕我直言,对初学者而言,直接用‘+’联取不香吗?)

    4. 列表名.remove(x)
      删除第一个值为x的元素,后面所有元素前移并索引-1。

    5. 列表名.pop(想要删除的元素相应索引)
      删除并返回你想要删除的一个元素。若不指定索引则默认为-1(最后一个元素)。
      删除中间的元素后,后面所有元素前移并索引-1。

    6. 列表名.index(x)
      返回列表中第一个值为x的索引。

    7. 列表名.count(x)
      返回x在列表中出现的次数。

    8. 列表名.reverse() 和 list(reversed(列表名))
      对列表所有元素进行逆序排列。
      但要注意list(reversed(列表名))仅仅返回一个逆序排列的值,实际上列表并没有改变,可以将值赋给另外一个列表(自己本身或其他别人都行)。

    9. 列表名.sort()
      对列表进行排序,默认为从小到大排序。
      若想要从大到小排序,改成 列表名.sort(reverse=True) 即可。

    10. sorted(列表名)
      产生一个从小到大排序的新列表,与上面一条不同的是:sorted(a)产生的是一个新列表,而a.sort()是对a直接排序了。

    11. 列表名.replace(被查找词,替换词)
      用于查找后替换,若被查找词不存在,原列表不会发生改变;若存在,全部的被查找词都被替换为替换词,生成一个新列表。

元组(tuple)

元组名=(元素1,元素2,元素3……)
所有元素放置于圆括号( )中,元素间使用逗号‘,’分离。若只有一个元素,元素后的逗号不能省略。元素固定不变,但可以是任意类型。

>>> a=(1,) 
>>> a
(1,)
>>> b=(2)
>>> b          #(2)是整形2,但是(2,)就是元组
2
  • 增添删改
    允许使用‘+’操作符和“*”操作符的使用,生成一个新的元组。
    但因为元组属于不可变序列,元素固定不变,所以不可以直接修改元组中元素的值,也无法修改和删除元素。致使在列表中能修改和删除的相应函数,在元组内无法使用。切片操作也是,只能进行访问,无法修改删除。
  • 访问
    与列表相同支持双向索引(可以使用正整数/负整数)
>>> a=(1, 2, 3, 4, 5, 6)
>>> print(a[0], a[3:5])
 1 (4, 5)
>>> a[0]=3 # 修改元组元素的操作是非法的
 Traceback (most recent call last):
   File "", line 1, in 
     a[0]=3
 TypeError: 'tuple' object does not support item assignment
  • 元组常用函数
    1. len(tuple):计算元组元素个数。
    2. max(tuple):返回元组中元素最大值。
    3. min(tuple):返回元组中元素最小值。
    4. 新元组名=tuple(列表名):将列表转换为元组。
  • 访问二元元组(二维)
>>> a=(1,2,3)  
>>> b=('a','b','c')  
>>> c=(a,b)      #将a看作是第一个元素;b是第二个元素
>>> print(c[1][2])     #序列中第一个元素中的第二个小元素
   c
  • 赋值
    虽然不能改变元素,但是却可以把元素赋给别的值:使用解包。
>>> x=(1,2,3)
>>> a,b,c = user    #变量个数要等于元组的长度
>>> a
1

集合(set)

集合名={元素1,元素2,元素3……}
所有元素放置于大括号{ }中元素间使用逗号‘,’分离,其中的元素不允许重复,且只能使用不可变数据(数字、字符串、元组等)。
建立一个空集合必须使用 集合名=set() 而非 集合名={} 。因为{}是用来创建一个空字典。
跟数学上的集合差不多概念(完全可以用数学上的知识进行理解没毛病)

  • 增添删改
    不支持使用‘+’操作符和“*”操作符的使用。

    1. 字典名.add(x) 可以增添新元素;但若该元素已经存在,则此操作无效。
    2. 字典名.pop() 可以随机删除并返回集合中的一个元素。
    3. 字典名.remove(x) 可以删除集合中的元素。
    4. 字典名.discard(x) 可以从集合中删除一个特定元素。
  • 访问
    不支持索引,因为是无序的,所以每次每次输出时元素的排列顺序可能都不相同。

  • 去重
    因为其元素不允许重复,集合有过滤重复元素的功能。可以将其他序列结构转化为集合,生成的新集合就会自动将内重复的元素删除,然后自动排序。

  • 集合运算

  1. 使用 集合名=set('字符串') 可以将字符串中的各个字母拆成集合,然后去重,并且他会自动从大到小进行排序。
  2. 允许 集合1-集合2 求去除集合1元素后的新集合2,注意只能长的减去短的,不能短减长。
    集合1|集合2 求两集合相加的元素——并集。
    集合1&集合2 求两集合提取的公共元素——交集。
    集合1^集合2 求提取两个集合不同时存在的元素——补集等操作符的使用。
>>> a=set('hallowword')  #将字符串拆成集合后去重、排序
>>> a
{'a', 'd', 'h', 'l', 'o', 'r', 'w'}
>>> b=set('areyouok') 
>>> b
{'a', 'e', 'k', 'o', 'r', 'u', 'y'}
>>> a-b                    # 从a中去除b的元素
{'d', 'h', 'l', 'w'}
>>> a|b                    # a和b的并集
{'a', 'd', 'e', 'h', 'k', 'l', 'o', 'r', 'u', 'w', 'y'}
>>> a&b              #提取 a和b的公共元素(交集)
{'a', 'o', 'r'}
>>> a^b    #提取 a和b中不同时存在的元素(交集的补集,也叫对称差)
{'d', 'e', 'h', 'k', 'l', 'u', 'w', 'y'}

字典(dict)

字典名={'键1':'值1','键2':'值2','键3':'值3'……};键(key),值(value)。
所有元素放置于大括号{ }中,元素间使用逗号‘,’分离,元素形式为“键:值”。

  • 键与值
    键不允许重复,且只能使用不可变数据(数字、字符串、元组等);但值允许重复,且允许是任意类型。

  • 增添删改
    不支持使用‘+’操作符和“*”操作符的使用。
    字典名['键']='新值'表示当该“键”存在时,修改该“键”对应的值;若不存在,则表示增添一个新的“键:值”元素。
    需要删除字典中指定元素,可以使用del命令(del 字典名['键'])。

>>> x={'a':1,'b':2,'c':3}
>>> x['b']='10'
>>> x['d']=3
>>> x
{'a': 1, 'b': '10', 'c': 3, 'd': 3}
>>> del x['c']
>>> x
{'a': 1, 'b': '10', 'd': 3}
  • 访问
    键与值之间表示一种映射关系,“键”在这里作为一种特别的下标形式,可以访问相应的“值”。

  • 字典常用函数

    1. 字典名.get('键','默认值')
      访问键对应的"值"。若值不存在,返回指定的默认值(默认值无要求可不写。但在值不存在和无默认值的双重条件下,不会有任何事发生)。

    2. 字典名.keys()
      返回一个显示字典所有键的列表。

    3. 字典名.values()
      返回一个显示字典所有值的列表。

    4. 字典名.update(想要添加的字典名/内容)
      合并字典,将另一个字典增添到当前字典中。

    5. 字典名.pop('键')
      从字典中删除指定的键值对,必须有键名这个参数。

    6. 字典名.popitem()
      从字典中随机删除并返回一个键值对,若字典已空才返回异常。

    7. 字典名.clear()
      清空字典,注意与del函数的删除字典有所不同。

    8. 新字典名=字典名.copy()
      克隆旧字典的内容至新字典中。

    9. 字典1.update(字典2)
      将字典2的内容增加到字典1中。

    10. 字典名.items()
      将字典里的元素(键值对)转化为元组作为列表的一个元素。
      将字典转化为元组作为元素的一个列表。

>>> d={'a':1, 'b':2, 'c':3}
>>> x=d.items()
>>> print(x)
   dict_items([('a',1),('b',2),('c',3)])
>>> list(x)
   [('a',1),('b',2),('c',3)]

上面的过程也可以用类型转换换回,即这样形式的元组列表也可以初始化成字典:

>>> x=[('a',1),( 'b',2),( 'c',3)]
>>> y=dict(x)
>>> print(y)
[('a',1),('b',2),('c',3)]
  • 排序
    1.按“键”排序
    sorted(字典名.items(),key=lambda e:e[0],reverse=True)表示按键从大到小排列。
    把True改成False,就表示按键从小到大排列。

    2.按“值”排序
    sorted(字典名.items(),key=lambda e:e[1],reverse=True)表示按值从大到小排列。
    把True改成False,就表示按值从小到大排列。

    因为字典的items()函数返回的是一个列表,列表的每一个元素都是一个键和值相应组成的元组。所以此函数返回的值是一个元组组成的新列表

  • 合成、创建一个新字典
    除了用上面的update函数之外,还可以这么做:

  1. fromkeys函数用于创建一个新字典
    新字典名=dict.fromkeys(seq, value)
    以序列 seq 中元素做字典的键;value 为字典所有键对应的初始值,可以不写。
>>> a=('name', 'age', 'sex')   
>>> b=dict.fromkeys(a)      #给字典键赋值来自seq(a)
>>> b      #因为仅有键,没有value,所以显示键值为默认值:空None
{'name': None, 'age': None, 'sex': None}
>>> c=dict.fromkeys(a, 1)    #给字典键值对赋值,这里假设都赋1
>>> c
{'name': 1, 'age': 1, 'sex': 1}
  1. format函数将列表合成新字典。
    原理就是每次从name中取一个姓名记为n1,再从tel中取一个号码记为t1,再把n1和t1组成键值对n1:t1,成为字典Tellbook中的一个元素,如此循环,就全部构成了字典的元素。
>>> name=["Bob","Jeny","Holly","Anna","Ai","Green"]
>>> age=[20,16,84,94,52,67]
>>> a={}  #创建一个空字典
>>> for i in range(len(name)):
        x="{}".format(name[i])    #从name中取一个姓名
        y="{}".format(age[i])     #从tel中取一个电话
        a[x]=y    
                      #再把d2这个号码赋值给字典Tellbook的d1键
>>> print(a)
{'Bob': '20', 'Jeny': '16', 'Holly': '84', 'Anna': '94', 'Ai': '52', 'Green': '67'}

这些是我学python时整理的学习笔记,所以如果有出错或者是不完善的地方。
欢迎在评论区指正!

你可能感兴趣的:(python 序列(字符串、字符串、元组、集合、字典))