字符串和常用数据结构

使用字符串

第二次世界大战促使了现代电子计算机的诞生,当初的想法很简单,就是用计算机来计算导弹的弹道,因此在计算机刚刚诞生的那个年代,计算机处理的信息主要是数值,而世界上的第一台电子计算机ENIAC每秒钟能够完成约5000次浮点运算。随着时间的推移,虽然对数值运算仍然是计算机日常工作中最为重要的事情之一,但是今天的计算机处理得更多的数据都是以文本信息的方式存在的,而Python表示文本信息的方式我们在很早以前就说过了,那就是字符串类型。所谓字符串,就是由零个或多个字符组成的有限序列,a{1}a{2}....a{n}

def main():
    str1 = 'hello world'
    print(len(str1))  # 计算长度
    print(str1.capitalize())  # 首字符大写拷贝
    print(str1.upper())  # 所有字符大写拷贝
    print(str1.lower())  # 所有字符小写拷贝
    print(str1.find('or'))  # 查找子串位置
    print(str1.find('shit'))
    # print(str1.index('or')) # 与find类似,找不到抛出错误
    # print(str1.index('shit'))
    print(str1.startswith('He'))  # 查找字符串开头是否以子串开头
    print(str1.startswith('he'))
    print(str1.endswith('d'))  # 查找字符串结尾是否以子串开头
    print(str1.endswith('D'))
    print(str1.center(50, '*'))  # 将字符串以指定的宽度居中并在两侧填充指定的字符
    print(str1.rjust(50, '*'))  # 将字符串以指定的宽度靠右放置左侧填充指定的字符
    print(str1.ljust(50, '*'))  # 将字符串以指定的宽度靠左放置左侧填充指定的字符
    # 从字符串中取出指定位置的字符(下标运算)
    str2 = 'abcdefg123456'
    print(str2[2])  # c
    print(str2[2:5])  # cde
    print(str2[2:])  # cdefg123456
    print(str2[2::2])  # ceg246
    print(str2[::2])  # aceg246
    print(str2[::-1])  # 654321gfedcba
    print(str2[-3:-1])  # 45
    print(str2.isdigit())  # 检查字符串是否全由数字构成
    print(str2.isalpha())  # 检查字符串是否全由字母构成
    print(str2.isalnum())  # 检查字符串是否由数字+字母构成
    str3 = '   hello world   '
    print(str3.strip())  # 去除字符串左右的多余空格拷贝


if __name__ == '__main__':
    main()

除了字符串,Python还内置了多种类型的数据结构,如果要在程序中保存和操作数据,绝大多数时候可以利用现有的数据结构来实现,最常用的包括列表、元组、集合和字典

使用列表

下面的代码演示了如何定义列表、使用下标访问列表元素以及添加和删除元素的操作。

def main():
    list1 = [1, 3, 5, 7, 100]
    print(list1)
    list2 = ['hello'] * 5
    print(list2)
    # 计算列表长度(元素个数)
    print(len(list1))
    # 下标(索引)运算
    print(list1[0])
    print(list1[4])
    # print(list1[5])  # IndexError: list index out of range
    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)
    if 1234 in list1:
        list1.remove(1234)
    del list1[0]
    print(list1)
    # 清空列表元素
    list1.clear()
    print(list1)


if __name__ == '__main__':
    main()

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

def main():
    list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
    list2 = sorted(list1)
    # sorted函数返回列表排序后的拷贝不会修改传入的列表
    # 函数的设计就应该像sorted函数一样尽可能不产生副作用
    list3 = sorted(list1, reverse=True)
    # 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
    list4 = sorted(list1, key=len)
    print(list1)
    print(list2)
    print(list3)
    print(list4)
    # 给列表对象发出排序消息直接在列表对象上进行排序
    list1.sort(reverse=True)
    print(list1)


if __name__ == '__main__':
    main()

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

import sys


def main():
    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)


if __name__ == '__main__':
    main()

除了上面提到的生成器语法,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)


if __name__ == '__main__':
    main()

使用元组

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

def main():
    # 定义元组
    t = ('aaron', 22, True, '四川')
    print(t)
    # 获取元组中的元素
    print(t[0])
    print(t[3])
    # 遍历元组中的值
    for member in t:
        print(member)
    # 重新给元组赋值
    # t[0] = '王大锤'  # TypeError
    # 变量t重新引用了新的元组原来的元组将被垃圾回收
    t = ('王大锤', 20, True, '云南昆明')
    print(t)
    # 将元组转换成列表
    person = list(t)
    print(person)
    # 列表是可以修改它的元素的
    person[0] = '李小龙'
    person[1] = 25
    print(person)
    # 将列表转换成元组
    fruits_list = ['apple', 'banana', 'orange']
    fruits_tuple = tuple(fruits_list)
    print(fruits_tuple)


if __name__ == '__main__':
    main()

这里有一个非常值得探讨的问题,我们已经有了列表这种数据结构,为什么还需要元组这样的类型呢?

  1. 元组中的元素是无法修改的,事实上我们在项目中尤其是多线程环境(后面会讲到)中可能更喜欢使用的是那些不变对象(一方面因为对象状态不能修改,所以可以避免由此引起的不必要的程序错误,简单的说就是一个不变的对象要比可变的对象更加容易维护;另一方面因为没有任何一个线程能够修改不变对象的内部状态,一个不变对象自动就是线程安全的,这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问)。所以结论就是:如果不需要对元素进行添加、删除、修改的时候,可以考虑使用元组,当然如果一个方法要返回多个值,使用元组也是不错的选择。
  2. 元组在创建时间和占用的空间上面都优于列表。我们可以使用sys模块的getsizeof函数来检查存储同样的元素的元组和列表各自占用了多少内存空间

使用集合

Python中的集合跟数学上的集合是一致的,不允许有重复元素,而且可以进行交集、并集、差集等运算。

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)
    set2.update([11, 12])
    print(set1)
    print(set2)
    set2.discard(5)
    # remove的元素如果不存在会引发KeyError
    if 4 in set2:
        set2.remove(4)
    print(set2)
    # 遍历集合容器
    for elem in set2:
        print(elem ** 2, end=' ')
    print()
    # 将元组转换成集合
    set3 = set((1, 2, 3, 3, 2, 1))
    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))


if __name__ == '__main__':
    main()

说明:Python中允许通过一些特殊的方法来为某种类型或数据结构自定义运算符(后面的章节中会讲到),上面的代码中我们对集合进行运算的时候可以调用集合对象的方法,也可以直接使用对应的运算符,例如&运算符跟intersection方法的作用就是一样的,但是使用运算符让代码更加直观。

使用字典

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

def main():
    scores = {'aaron': 95, '白元芳': 78, '狄仁杰': 82}
    # 通过键可以获取字典中对应的值
    print(scores['aaron'])
    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))
    # 删除字典中的元素
    print(scores.popitem())
    print(scores.popitem())
    print(scores.pop('aaron', 100))
    # 清空字典
    scores.clear()
    print(scores)


if __name__ == '__main__':
    main()

练习

练习1:在屏幕上显示跑马灯文字
import os
import time


def main():
    s = 'hello world'
    while True:
        os.system('cls')
        print(s)
        time.sleep(0.2)
        s = s[1:] + s[0]


if __name__ == '__main__':
    main()
练习2:设计一个函数产生指定长度的验证码,验证码由大小写字母和数字构成
import random


def main():
    all_chars = 'abcdefghigklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
    length = len(all_chars) - 1
    code = ''
    for _ in range(4):
        index = random.randint(0, length)
        code += all_chars[index]
    print(code)


if __name__ == '__main__':
    main()
练习3:设计一个函数返回给定文件名的后缀名
def main():
    filename = input('type filename:  ')
    index = filename.rfind('.')
    print(filename[index+1:])


if __name__ == '__main__':
    main()
练习4:设计一个函数返回传入的列表中最大和第二大的元素的值
def findIts(x):
    maxListX = max(x)
    y = x[:]
    y.remove(maxListX)
    maxListY = max(y)
    return maxListX, maxListY


def main():
    x = findIts([1, 32, 56, 12, 45])
    print(x)


if __name__ == '__main__':
    main()
练习5:打印杨辉三角
def main():
    row = int(input('row = '))
    yh = [[]] * row
    for i in range(row):
        yh[i] = [None] * (i + 1)
        for j in range(i+1):
            if j == i or j == 0:
                yh[i][j] = 1
            else:
                yh[i][j] = yh[i-1][j-1] + yh[i-1][j]
    for x in yh:
        for y in x:
            print(y, end=' ')
        print(end='\n')


if __name__ == '__main__':
    main()
练习6: 约瑟夫环问题
description
《幸运的基督徒》
有15个基督徒和15个非基督徒在海上遇险,为了能让一部分人活下来不得不将其中15个人扔到海里面去,有个人想了个办法就是大家围成一个圈,由某个人开始从1报数,报到9的人就扔到海里面,他后面的人接着从1开始报数,报到9的人继续扔到海里面,直到扔掉15个人。由于上帝的保佑,15个基督徒都幸免于难,问这些人最开始是怎么站的,哪些位置是基督徒哪些位置是非基督徒。
n = int(input('n = '))
m = int(input('m = '))
listMan = [True] * n
droop = 0
count = 0
index = 0
while droop < 15:
    if listMan[index]:
        count += 1
        if count % m == 0:
            listMan[index] = False
            droop += 1
    index += 1
    index %= n
for x in listMan:
    print('基' if x else '非', end=' ')

列表移动,判断是否已经移除(置false),若未移除(true),则报数count+=1,否则不能报数

Copyright © aaron 2023 all right reserved,powered by Gitbook该文章修订时间: 2020-03-27 17:33:30

results matching ""

    No results matching ""