您的位置:首页 > 编程语言 > Python开发

【Python】2.字符串、列表、元组、字典、集合的基本操作

2019-04-24 16:32 891 查看

Python 字符串、列表、元组、字典、集合的基本操作

文章目录

  • 列表
  • 深拷贝、浅拷贝
  • 元组
  • 字典
  • 集合
  • string字符串

    使用引号

    '
    来创建字符串。

    Python 不支持单字符类型,单字符在 Python 中也是作为一个字符串使用。

    Python 访问子字符串,可以使用方括号来截取字符串

    var1 = 'Hello World!'
    var2 = "Runoob"
    print ("var1[0]: ", var1[0])
    print ("var2[1:5]: ", var2[1:5])

    可以截取字符串的一部分并与其他字段拼接,使用

    +

    字符串运算符

    + 字符串连接
    * 重复输出字符串
    [] 通过索引获取字符串中字符
    [ : ] 截取字符串的一部分,遵循左闭右开原则
    in 如果字符串中包含给定字符返回True
    not in 不包括返回True
    r/R 原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。
    % 格式字符串

    Python三引号

    python三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。

    para_str = """这是一个多行字符串的实例
    多行字符串可以使用制表符
    TAB ( \t )。
    也可以使用换行符 [ \n ]。
    """
    print (para_str)
    这是一个多行字符串的实例
    多行字符串可以使用制表符
    TAB (    )。
    也可以使用换行符 [
    ]。

    在Python3中,所有的字符串都是Unicode字符串。

    内建函数

    capitalize()

    将字符串的第一个字符转换为大写

    a='vtl'
    a.capitalize()

    count()

    用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

    #定义
    str.count(sub, start= 0,end=len(string))
    #实例
    str="www.runoob.com"
    sub='o'
    print ("str.count('o') : ", str.count(sub))
    
    sub='run'
    print ("str.count('run', 0, 10) : ", str.count(sub,0,10))
    #输出如下
    str.count('o') :  3
    str.count('run', 0, 10) :  1

    decode()

    以指定的编码格式解码 bytes 对象。默认编码为 ‘utf-8’。

    str = "菜鸟教程";
    str_utf8 = str.encode("UTF-8")
    str_gbk = str.encode("GBK")
    
    print(str)
    
    print("UTF-8 编码:", str_utf8)
    print("GBK 编码:", str_gbk)
    
    print("UTF-8 解码:", str_utf8.decode('UTF-8','strict'))
    print("GBK 解码:", str_gbk.decode('GBK','strict'))
    
    #输出结果如下
    菜鸟教程
    UTF-8 编码: b'\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b'
    GBK 编码: b'\xb2\xcb\xc4\xf1\xbd\xcc\xb3\xcc'
    UTF-8 解码: 菜鸟教程
    GBK 解码: 菜鸟教程

    endwish()

    str.endswith(suffix[, start[, end]])#start 参数以 0 为第一个字符索引值。end 参数以 1 为第一个字符索引值
    
    #示例
    print('01234'.endswith('234', 0, 4))
    >>> False
    print('01234'.endswith('234', 0, 5))
    >>> True

    expandtabs()

    把字符串中的 tab 符号(’\t’)转为空格,tab 符号(’\t’)默认的空格数是 8。

    str = "this is\tstring example....wow!!!"
    
    print ("原始字符串: " + str)
    print ("替换 \\t 符号: " +  str.expandtabs())
    print ("使用16个空格替换 \\t 符号: " +  str.expandtabs(16))
    #输出
    原始字符串: this is     string example....wow!!!
    替换 \t 符号: this is string example....wow!!!
    使用16个空格替换 \t 符号: this is         string example....wow!!!

    find()

    >>>info = 'abca'
    >>> print(info.find('a'))      # 从下标0开始,查找在字符串里第一个出现的子串,返回结果:0
    0
    >>> print(info.find('a', 1))   # 从下标1开始,查找在字符串里第一个出现的子串:返回结果3
    3
    >>> print(info.find('3'))      # 查找不到返回-1
    -1

    join()

    用于将序列中的元素以指定的字符连接生成一个新的字符串。

    >>> jn1="-"
    >>> str='name'
    >>> jn1.join(str)    #字符串也属于序列
    'n-a-m-e'
    >>> fruits={'apple','banana'}
    >>> jn1.join(fruits)   #连接的序列是集合
    'apple-banana'
    >>> animals=("pig","dog")
    >>> jn1.join(animals)   #连接的序列是元祖
    'pig-dog'
    >>> students={"name1":"joy","name2":"john","name3":"jerry"}   #连接的序列是字典,会将所有key连接起来
    >>> jn1.join(students)
    'name1-name2-name3'

    str.join(sequence) 函数中的 sequence 中的元素必须的字符串,否则会报错

    >>> seq = ['a','b',1,2]
    >>> jn = '-'
    >>> jn.join(seq)
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    TypeError: sequence item 2: expected str instance, int found

    replace()

    把字符串中的 old(旧字符串) 替换成 new(新字符串),如果指定第三个参数max,则替换不超过 max 次。

    str = "this is string example....wow!!!"
    print (str.replace("is", "was", 3))
    
    thwas was string example....wow!!!

    列表

    更新

    list = ['Google', 'Runoob', 1997, 2000]
    
    print ("第三个元素为 : ", list[2])
    list[2] = 2001
    print ("更新后的第三个元素为 : ", list[2])

    删除

    list = ['Google', 'Runoob', 1997, 2000]
    
    print ("原始列表 : ", list)
    del list[2]
    print ("删除第三个元素 : ", list)

    列表脚本操作符

    列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表,* 号用于重复列表。

    [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合
    [‘Hi!’] * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] 重复

    其他常用操作

    1 list.append(obj) 在列表末尾添加新的对象
    2 list.count(obj) 统计某个元素在列表中出现的次数
    3 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
    4 list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
    5 list.insert(index, obj) 将对象插入列表
    6 [list.pop(index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
    7 list.remove(obj) 移除列表中某个值的第一个匹配项
    8 list.reverse() 反向列表中元素
    9 list.sort( key=None, reverse=False) 对原列表进行排序
    10 list.clear() 清空列表
    11 list.copy() 复制列表

    深拷贝、浅拷贝

    (1)直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变,被赋值的b也会做相同的改变

    (2)copy浅拷贝,没有拷贝子对象,所以原始数据改变,子对象会改变

    (3)深拷贝,包含对象里面的自对象的拷贝,所以原始对象的改变不会造成深拷贝里任何子元素的改变

    import copy
    l=[1,2,3,[4,5]]
    l1=l
    l2=copy.copy(l)
    l3=copy.deepcopy(l)
    l.append(6)
    l[3].append(7)
    print(l1)
    print(l2)
    print(l3)
    #输出
    [1, 2, 3, [4, 5, 7], 6]
    [1, 2, 3, [4, 5, 7]]
    [1, 2, 3, [4, 5]]

    元组

    Python 的元组与列表类似,不同之处在于元组的元素不能修改

    元组使用小括号,列表使用方括号。

    元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

    基本操作

    • 访问元组

      tup1 = ('Google', 'Runoob', 1997, 2000)
      tup2 = (1, 2, 3, 4, 5, 6, 7 )
      
      print ("tup1[0]: ", tup1[0])
      print ("tup2[1:5]: ", tup2[1:5])
      
      tup1[0]:  Google
      tup2[1:5]:  (2, 3, 4, 5)
    • 修改元组

      元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例:

      tup1 = (12, 34.56);
      tup2 = ('abc', 'xyz')
      
      # 以下修改元组元素操作是非法的。
      # tup1[0] = 100
      
      # 创建一个新的元组
      tup3 = tup1 + tup2;
      print (tup3)
      
      (12, 34.56, 'abc', 'xyz')

    字典

    字典的每个键值 key=>value 对用冒号 : 分割,每个键值对之间用逗号 , 分割,整个字典包括在花括号 {} 中 ,值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。

    更新删除字典

    dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
    dict['Age'] = 8 		# 更新
    print("dict['Age']: ", dict['Age'])
    del dict['Name']  # 删除键是'Name'的条目
    dict.clear()	#清空词典所有条目
    del dict		#删除词典

    字典键的特性

    1)不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住,如下实例:

    dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
    print "dict['Name']: ", dict['Name']
    #输出
    dict['Name']:  Manni

    2)键必须不可变,所以可以用数字,字符串或元组充当,所以用列表就不行

    字典内置方法

    1 dict.clear() 删除字典内所有元素
    2 dict.copy() 返回一个字典的浅复制
    3 [dict.fromkeys(seq, val]) 创建一个新字典,以序列 seq 中元素做字典的键,val 为字典所有键对应的初始值
    4 dict.get(key, default=None) 返回指定键的值,如果值不在字典中返回default值
    5 dict.has_key(key) 如果键在字典dict里返回true,否则返回false
    6 dict.items()列表返回可遍历的(键, 值) 元组数组
    7 dict.keys()列表返回一个字典所有的键
    8 dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
    9 dict.update(dict2) 把字典dict2的键/值对更新到dict里
    10 dict.values() 以列表返回字典中的所有值
    11 [pop(key,default]) 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
    12 popitem() 随机返回并删除字典中的一对键和值。
    d={'a':1,'b':2,'c':3}
    d['a']=8
    d.keys()
    d.values()
    d.items()
    #输出
    dict_keys(['a', 'b', 'c']) #以**列表返回**一个字典所有的键
    dict_values([8, 2, 3])		#以列表返回字典中的所有值
    dict_items([('a', 8), ('b', 2), ('c', 3)])#以**列表返回**可遍历的(键, 值) **元组数组**

    集合

    集合(set)是一个无序的不重复元素序列。

    可以使用大括号 { } 或者 set() 4000 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

    基本操作

    >>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
    >>> print(basket)                      # 这里演示的是去重功能
    {'orange', 'banana', 'pear', 'apple'}
    >>> 'orange' in basket                 # 快速判断元素是否在集合内
    True
    >>> 'crabgrass' in basket
    False
    
    >>> # 下面展示两个集合间的运算.
    ...
    >>> a = set('abracadabra')
    >>> b = set('alacazam')
    >>> a
    {'a', 'r', 'b', 'c', 'd'}
    >>> a - b                              # 集合a中包含而集合b中不包含的元素
    {'r', 'd', 'b'}
    >>> a | b                              # 集合a或b中包含的所有元素
    {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
    >>> a & b                              # 集合a和b中都包含了的元素
    {'a', 'c'}
    >>> a ^ b                              # 不同时包含于a和b的元素
    {'r', 'd', 'b', 'm', 'z', 'l'}

    添加元素

    # add只能添加一个元素,且不可以是列表,集合,字典,可以是元组
    s.add(x)
    # 添加元素,且参数可以是列表,元组,字典等
    s.update(x)
    # 实例
    >>>thisset = set(("Google", "Runoob", "Taobao"))
    >>> thisset.update({1,3})			#参数是集合,不能直接写1,3
    >>> print(thisset)
    {1, 3, 'Google', 'Taobao', 'Runoob'}
    >>> thisset.update([1,4],[5,6])     #参数是列表
    >>> print(thisset)
    {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

    移除元素

    # s.remove(x)
    >>>thisset = set(("Google", "Runoob", "Taobao"))
    >>> thisset.remove("Taobao")
    >>> print(thisset)
    {'Google', 'Runoob'}
    >>> thisset.remove("Facebook")   # 不存在会发生错误
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    KeyError: 'Facebook'
    
    # s.discard(x) 也是移除集合中的元素,且如果元素不存在,不会发生错误
    
    #s.pop() 设置随机删除集合中的一个元素
    内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
    标签: 
    相关文章推荐