python中的字符串和常用数据结构

字符串

简单直接上字符串的使用代码

def main():
    str1 = 'hello, world!'
    # 通过len函数计算字符串的长度
    print(len(str1))  # 13
    # 获得字符串首字母大写的拷贝
    print(str1.capitalize())  # Hello, world!
    # 获得字符串变大写后的拷贝
    print(str1.upper())  # HELLO, WORLD!
    # 从字符串中查找子串所在位置
    print(str1.find('or'))  # 8
    print(str1.find('shit'))  # -1
    # 与find类似但找不到子串时会引发异常
    # print(str1.index('or'))
    # print(str1.index('shit'))
    # 检查字符串是否以指定的字符串开头
    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])  # c

***　# 字符串切片(从指定的开始索引到指定的结束索引)
    print(str2[2:5])  # c12
    print(str2[2:])  # c123456
    print(str2[2::2])  # c246
    print(str2[::2])  # ac246
    print(str2[::-1])  # 654321cba
    print(str2[-3:-1])  # 45
    # 检查字符串是否由数字构成
    print(str2.isdigit())  # False
    # 检查字符串是否以字母构成
    print(str2.isalpha())  # False
    # 检查字符串是否以数字和字母构成
    print(str2.isalnum())  # True
    str3 = '  jackfrued@126.com '
    print(str3)
    # 获得字符串修剪左右两侧空格的拷贝
    print(str3.strip())


if __name__ == '__main__':
    main()

练习：生成指定位数的验证码（数字，大小写字母组成的）:2种写法，第一种要根据数字和大小写字母的ASCII来计算随机数的生成；第二种方法利用字符串的切片来完成。另外还要学习第二种中的文本注释写法。

import random

def getcode():
    x = eval(input("你要几位验证码"))
    y = ""
    for i in range(x):
        r = random.randint(0, 74)
        while not(0 < r < 10 or 16 < r < 43 or 48 < r < 74):
            r = random.randint(0, 74)
        y = chr(ord('0') + r) + y
    print(y)


if __name__ == '__main__':
    getcode()

import random

def generate_code(code_len=4):
    '''
    生成指定长度的验证码
    :param code_len: 验证码的长度

    :return: 由大小写字母和数字构成的随机验证码
    '''
    all_chars = '0123456789abcdefghijklmnopqrstuvwxyzASDFGHJKLMNBVCXZQWERTYUIOP'
    last_pos = len(all_chars) - 1
    code = ''
    for _ in range(code_len):
        index = random.randint(0, last_pos)
        code += all_chars[index]
    return code

列表

　　列表可以存储一个有序的元素集合，其大小是可变的，我们可以使用循环对容器中的额保存的数据进行操作。列表的下标都是从0开始的。

列表的创建

list1 = list([1, 2, 3])
list2 = [1, 3 ,5]

我们还可以利用列表的生成式和生成器来创建列表，如下：

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) #<generator object main.<locals>.<genexpr> at 0x00426C60>
    for val in f: #需要数据就要遍历循环
        print(val)


if __name__ == '__main__':
    main()

　　Python里面还有另外一种定义生成器的方式，通过yield关键字将一个普通函数改造成生成器函数，以下用递归方法来定义计算斐波拉契数列：Fn = Fn-1 + Fn-2(n>2)

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()

元组

　　元组简单理解就是把多个不同的元素组合到一起，它和列表一样可以保存多条数据，但是元组中的元素不能修改。

def main():
    # 定义元组
    t = ('橘子', 6, True, '丹棱')
    print(t)
    # 获取元组中的元素
    print(t[0])
    print(t[3])
    # 遍历元组中的值
    for member in t:
        print(member)
    # 重新给元组赋值
    # t[0] = '苹果'  # TypeError
    # 变量t重新引用了新的元组原来的元组将被垃圾回收
    t = ('橙子’', 6, True, '丹棱')
    print(t)
    # 将元组转换成列表
    fruit = list(t)
    print(fruit是可以修改它的元素的
    fruit[0] = '香蕉'
    fruit[1] = 25
    print(fruit)
    # 将列表转换成元组
    fruits_list = ['apple', 'banana', 'orange']
    fruits_tuple = tuple(fruits_list)
    print(fruits_tuple)


if __name__ == '__main__':
    main()

为什么在有列表的情况下，还会需要元组类型呢？

答：1、元组中的元素是无法修改的，那么一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问。因此如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。2、元组在创建时间和占用的空间上面都优于列表。

集合

　　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里面的字典也是一种可变容器模型，但与列表、集合不同的是，字典的每个元素都是由键值对（一个键和一个值组成的），键和值通过：分开，如下：

def main():
    dict1 = {'name': '狗', 'age': 5, 'gender': True,'motto':'hello'}
    print(dict1['name']) #狗
    print(dict1['age']) #5
    dict1['name'] = '猫' # 把字典里的狗改成猫
    print(dict1)
    print(dict1.pop('age')) #删除‘age’：5
    print(dict1.popitem()) #打印删除最后的键值对
    print(dict1)
    del dict1['name'] #删除name键值对
    dict1.update(height = 178, fav = ['吃','玩'])#增加键值对
    dict1.setdefault('motto','hhgh')
    if 'motto' in dict1:
        print(dict1['motto'])
    print(dict1)
    for i in dict1:
        print(i, '--->', dict1[i])


if __name__ == '__main__':
    main()

练习题1：

输入5个学生的三门成绩打印成表格形式

def main():
    names = ['关羽', '张飞', '赵云', '马超', '貂蝉']
    subjects = ['语文','数学','python']
    table = [[0 for _ in range(3)] for _ in range(len(names))]
    #table = [[0]*len(subjects) for _ in range(len(names))]这种可以，用生成式
    print(id(table[0]))
    print(id(table[1]))
    #scores = [[0] * len(subjects)] * len(names)这是错误的，复制的5个都是同一地址
    for row, name in enumerate(names):
        print('请输入%s的成绩:' % name)
        for col, subject in enumerate(subjects):
            score = input('%s:' % subject)
            table[row][col] = score
    print(table)


if __name__ == '__main__':
    main()

小结：#scores = [[0] * len(subjects)] * len(names)这是错误的，复制的5个列表都是同一地址，后面计算复制总会覆盖之前的，因此最后结果全是最后一名学生的成绩。

练习2

设计一个函数传入年月日返回这一天是这一年的第几天

def which_day(year, month, date):
    list1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    days = 0
    for i in range(month-1):
        days += list1[i]
    days = days + date
    if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
        if month > 2:
            days = days + 1
    return days

if __name__ == '__main__':
    print(which_day(2016, 3, 1))

def which_day1(year, month, date):
    #把平年和闰年放在列表[0],[1]中，Ture 返回1 ，Flase 返回0
    days_of_month = [[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
                     [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]][is_leap_year(year)]
    total = 0
    for i in range(month - 1):
        total += days_of_month[i]
    return total + date


if __name__ == '__main__':
　　　print(which_day1(2016, 3, 1))

小结：1、尽量不要再函数中设置print，而用return来返回。2、可以把判断闰年的单独定义为一个函数。

练习3：模拟下注双色球

from random import randrange, randint

def display(select):
    for index, balls in enumerate(select):
        if index == len(select)-1:
            print('丨', end='')
        print('%02d' % balls, end=' ') ##格式化用0来补位
    print()

def random_select():
    red_balls = list(range(1,34))
    selected_balls = []
    for _ in range(6):
        index = randrange(len(red_balls))
        selected_balls.append(red_balls[index])
        del red_balls[index]
    selected_balls.sort()
    selected_balls.append(randint(1,16))
    return selected_balls

def main():
    n = int(input('机选几注'))
    for _ in range(n):
        display(random_select())


if __name__ == '__main__':
    main()

练习4：约瑟夫环

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

if __name__ == '__main__':
    huan()

小结：用布尔类型来表示人的死活，注意这是个圆。

练习5

打印出杨辉三角

def main():
    num = int(input('Number of rows: '))
    yh = [[]] * num
    for row in range(len(yh)):
        yh[row] = [None] * (row + 1)
        for col in range(len(yh[row])):
            if col == 0 or col == row:
                yh[row][col] = 1
            else:
                yh[row][col] = yh[row - 1][col] + yh[row - 1][col - 1]
            print(yh[row][col], end='\t')
        print()


if __name__ == '__main__':
    main()