字符串和常用数据结构

痛定思痛。 2021-10-29 14:52 340阅读 0赞

使用字符串：  
\--------所谓字符串，就是由零个或多个字符组成的有限序列

我们可以通过下面的代码来了解字符串的使用。

def main():
        str1 = 'hello,world'
        #通过len函数计算字符串的长度
        print(len(str1))#11
        #获得字符串首写字母大写的拷贝
        print(str1.capitalize()) #Hello,world
        #获得字符串大写后的拷贝
        print(str1.upper())# HELLO,WORLD
        #从字符串中查找子串所在位置
        print(str1.find('or'))#7
        print(str1.find('shit'))#-1
        #检查字符串是否以指定的子字符串开头
        print(str1.startswith('He'))#False
        print(str1.startswith('hel'))  # True
        # 检查字符串是否以指定的字符串结尾
        print(str1.endswith('!'))#True
        # 将字符串以指定的宽度居中并在两侧填充指定的字符
        print(str1.center(50,'*'))
        # 将字符串以指定的宽度靠右放置左侧填充指定的字符
        print(str1.rjust(50,' '))
    
        str2 = 'abc123456'
        # 从字符串中取出指定位置的字符(下标运算)
        print(str2[2])
        # 字符串切片(从指定的开始索引到指定的结束索引)
        print(str2[2:5])
        print(str2[2:])  # c123456
        print(str2[2::2])  # c246
        print(str2[::2])  # ac246
        print(str2[::-1])  # 654321cba
        print(str2[-3:-1])  # 45
        # 检查字符串是否由数字构成
        print(str2.isalpha())  # False
        # 检查字符串是否以数字和字母构成
        print(str2.isalnum())  # True
        str3 = '  jackfrued@126.com '
        print(str3)
        # 获得字符串修剪左右两侧空格的拷贝
        print(str3.strip())
    main()

使用列表：

def main():
        list1 = [1,3,45,7,100]
        # print(list1)
        # list2 = ['hello']*5#['hello', 'hello', 'hello', 'hello', 'hello']
        # print(list2)
        # # 计算列表长度(元素个数)
        # print(len(list1))
        #  # 下标(索引)运算
        """
        print(list1[0])
        print(list1[4])
        print(list1[-1])
        print(list1[-3])
        list1[2] = 300
        """
        print(list1)
        # list1.append(200)
        # list1.insert(1,400)
        # list1 += [1000,2000]
        # print(list1)
        # print(len(list1))
    
        # list1.remove(3)
        # print(list1)
        if 1234 in list1:
            list1.remove(1234)
            print(list1)
        del list1[0]
        print(list1)
        list1.clear()
        print(list1)

和字符串一样，列表也可以做切片操作，通过切片操作我们可以实现对列表的复制或者将列表中的一部分取出来创建出新的列表，代码如下所示

fruits = ['grape','apple','strawberry','waxberry','pitaya','pear','mango']
    #fruits += ['pitaya','pear','mango']
    # for fruit in fruits:
    #     print(fruit.title(), end=' ')
    # print()
    
    #列表切片
    print(fruits)
    fruits2 = fruits[1:4]
    print(fruits2)
    #通过完整切片来复制列表
    fruits3 = fruits[:]
    print(fruits3)
    fruits4 =  fruits[-3:-1]
    print(fruits4)
    #可以通过反向切片操作来获得倒转后的列表的拷贝
    fruits5 = fruits[::-1]
    print(fruits5)

下面的代码实现了对列表的排序操作

list1 = ['orange','apple','zoo','internationalization','blieberry']
    print(list1)
    # list2 = sorted(list1)
    # #sort的函数返回列表排序后的拷贝不会修改传入的列表
    # print(list2)
    # #reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）
    # list3 = sorted(list1,reverse = True)
    # print(list3)
    # #通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
    # list4 = sorted(list1,key = len)
    # print(list4)
    #给列表对象发出排序消息直接在列表对象上排序
    list1.sort(reverse = True)
    print(list1)

我们还可以使用列表的生成式语法来创建列表，代码如下所示。

import sys
    #f = [x for x in range(1,10)]
    #print(f)
    #f = [x + y for x in'ABCDE' for y in '1234567']
    #print(f)
    # 用列表的生成表达式语法创建列表容器
    # 用这种语法创建列表之后元素已经
    # 准备就绪所以需要耗费较多的内存空间
    # f = [x ** 2 for x in range(1,1000)]
    # print(sys.getsizeof(f))
    # print(f)
    # 请注意下面的代码创建的不是一个列表而是一个生成器对象
    # 通过生成器可以获取到数据但它不占用额外的空间存储数据
    # 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
    #  相比生成式生成器不占用存储数据的空间
    f = (x**2 for x in range(1,1000))
    #  相比生成式生成器不占用存储数据的空间
    # print(sys.getsizeof(f))
    # print(f)
    for val in f:
        print(val)

除了上面提到的生成器语法，Python中还有另外一种定义生成器的方式，就是通过yield关键字将一个普通函数改造成生成器函数。下面的代码演示了如何实现一个生成斐波拉切数列的生成器。所谓斐波拉切数列可以通过下面递归的方法来进行定义

def fib(n):
        a,b = 0,1
        for _ in range(n):
            a, b = b,a+b
            yield a
            
    def main():
        for val in fib(20):
            print(val)
    main()

使用元组  
Python 的元组与列表类似，不同之处在于元组的元素不能修改，在前面的代码中我们已经不止一次使用过元组了。顾名思义，我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。下面的代码演示了如何定义和使用元组。

def main():
        #定义元祖
        t= ('张三',38, True, '四川')
        print(t)
        #获取元祖中的元素
        print(t[0])
        print(t[3])
        #遍历元祖中的值
        for number in t:
            print(number,end = ' ')
        #重新给元祖赋值
        t = ('王大锤',20,True,'云南昆明')
        print(t)
        #将元祖转换成列表
        person = list(t)
        print(person)
        #列表可以修改它的元素
        person[0] = '李小龙'
        person[1] = 25
        print(person)
        #将列表转换成元祖
        t1 = tuple(t)
        print(t1)
        friuts_list = ['apple','banana','oorange']
        friuts_tuple = tuple((friuts_list))
        print(friuts_list)
        print(friuts_tuple)
    main()

元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境（后面会讲到）中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。

元组在创建时间和占用的空间上面都优于列表。我们可以使用sys模块的getsizeof函数来检查存储同样的元素的元组和列表各自占用了多少内存空间，这个很容易做到。  
································································································  
使用集合  
Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。  
python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.

sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing, slicing, 或其它类序列（sequence-like）的操作。

def main():
        set1 = {
        1,2,3,3,3,2}
        # print(set1)
        # print('length = ',len(set1))
        set2 = set(range(1,10))
        # print(set2)
    
    
        # set1.add(4)
        # set1.add(5)
        # print(set1)
        # print(set2)
        #set2.discard(56)
    
        #print(set2)
        # remove的元素如果不存在会引发KeyError
        #if 4 in set2:
         #   set2.remove(422)
    
          #  print(set2)
        #遍历集合容器
        # for elem in set2:
        #     print(elem ** 2,end = ' ')
        # print()
        #将元祖转换成集合
        set3 = set((4,2,3,4,5,3,2,5))
        #print(set3)
        #pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
        #当集合是由列表和元组组成时,set.pop()是从左边删除
        #print(set3.pop())
        #print(set3)
        print(set1 & set2)
        # print(set1.intersection(set2))
        print(set1 | set2)
        # print(set1.union(set2))
        print(set1 - set2)
        # print(set1.difference(set2))
        print(set1 ^ set2)
        # print(set1.symmetric_difference(set2))
        # 判断子集和超集
        print(set2 <= set1)
        # print(set2.issubset(set1))
        print(set3 <= set1)
        # print(set3.issubset(set1))
        print(set1 >= set2)
        # print(set1.issuperset(set2))
        print(set1 >= set3)
        # print(set1.issuperset(set3))
    main()

使用字典  
字典是另一种可变容器模型，类似于我们生活中使用的字典，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。下面的代码演示了如何定义和使用字典

scores = {
        '骆昊': 95, '白元芳': 78, '狄仁杰': 82}
    # 通过键可以获取字典中对应的值
    print(scores['骆昊'])
    print(scores['狄仁杰'])
    # 对字典进行遍历(遍历的其实是键再通过键取对应的值)
    # for elem in scores:
    #         print('%s\t--->\t%d' % (elem, scores[elem]))
    # 更新字典中的元素
    scores['白元芳'] = 65
    scores['诸葛王朗'] = 71
    #scores.update(冷面=67, 方启鹤=85)
    print(scores)
    # if '武则天' in scores:
    #         print(scores['武则天'])
    #     print(scores.get('武则天'))
        # get方法也是通过键获取对应的值但是可以设置默认值
    print(scores.get('武则天', 60))
    # Python 字典 popitem() 方法返回并删除字典中的最后一对键和值。
    # 如果字典已经为空，却调用了此方法，就报出 KeyError 异常
    print(scores.popitem())
    #清空字典
    scores.clear()
    print(scores)