目录
Day007:字符串和常用数据结构
1、使用字符串
现代电子计算机的诞生，最初想法很简单，就是用计算机来计算导弹的弹道，因此在计算机刚刚诞生的那个年代，计算机处理的信息主要是数值，而世界上的第一台电子计算机ENIAC每秒钟能够完成约5000次浮点运算。随着时间的推移，虽然对数值运算仍然是计算机日常工作中最为重要的事情之一，今天的计算机处理得更多的数据都是以文本信息的方式存在的，而Python表示文本信息的方式我们在很早以前就说过了，那就是字符串类型。所谓字符串，就是由零个或多个字符组成的有限序列，一般记为$${\displaystyle s=a_{1}a_{2}\dots a_{n}(0\leq n \leq \infty)}$$。
我们可以通过下面的代码来了解字符串的使用。
def main():
str1 = 'hello, world!'
print(len(str1)) # 通过len函数计算字符串的长度
print(str1.capitalize()) # 首字母大写
print(str1.upper()) # 字符串大写
print(str1.find('or')) # 返回or在字符串中的位置
print(str1.find('shit')) # 当查找的字符串不存在时会引发异常，返回-1
print(str1.startswith('He')) # 查看字符串是否以He开头，是返回True，不是返回False
print(str1.startswith('hel')) # 查看字符串是否以hel开头
print(str1.endswith('!')) # 看字符串是否以!结束，是返回True，不是返回False
print(str1.center(50, '*')) # 将字符串以指定的宽度居中并在两侧填充指定字符
print(str1.rjust(50, ' ')) # 将字符串以指定的宽度靠右放置，左侧填充指定的字符
print(str1.ljust(50,' ')) # 将字符串以指定的宽度靠左防止，右侧天厨指定的字符
str2 = 'abc123456'
# 字符串切片（从指定的开始索引到指定的索引结束）
print(str2[2])
print(str2[2:5]) # 从str2[2]开始到str[4]的字符进行切片
print(str2[2::2]) # 从str2[2]开始到字符串结束位置，每隔2个位置的字符进行切片
print(str2[::2]) # 默认从str2开始字符到结束字符，每个2个位置的字符进行切片
print(str2[::-1]) # 从str2默认结束字符到开始字符，每1个位置的字符进行切片，相当于字符串倒置
print(str2[-3:-1]) # 从str2倒数第三个字符开始到最后一个字符之前的字符进行切片
print(str2.isdigit()) # 检查字符串是否以字母构成
print(str2.isalnum()) # 检查字符串中是否含有字母
str3 = ' [email protected]'
print(str3)
print(str3.strip()) # 去除字符串两端的空格
if __name__ == '__main__':
main()
13
Hello, world!
HELLO, WORLD!
8
-1
False
True
True
******************hello, world!*******************
hello, world!
hello, world!
c
c12
c246
ac246
654321cba
45
False
True
[email protected]
[email protected]除了字符串，Python还内置了多种类型的数据结构，如果要在程序中保存和操作数据，绝大多数时候可以利用现有的数据结构来实现，最常用的包括列表、元组、集合和字典。
2、使用列表
下面的代码演示了如何定义列表、使用下标访问列表元素以及添加和删除元素的操作。
def main():
list1 = [1, 3, 5, 7, 100]
print(list1)
list2 = ['hello'] * 5
print(list2)
print(len(list1)) # 计算列表长度（元素个数）
print(list1[0]) # 打印列表第一个元素
print(list1[4]) # 打印列表最后一个元素
# pirnt(list[5]) # IndexError: list index out of range
print(list1[-1]) # 打印列表最后一个元素
print(list1[-3]) # 打印列表倒数第三个元素
list1[0] = 300 # 修改列表元素
print(list1)
# 添加元素
list1.append(200) # 在列表末尾添加元素
list1.insert(1, 400) # 在列表第二个位置插入值为400的元素
list1 += [1000, 2000] # 为列表添加1000， 2000两个新元素
print(list1)
print(len(list1))
# 删除元素
list1.remove(3) # 删除list1中的3这个元素
if 1234 in list1:
list1.remove(1234)
del list1[0] # 删除list1的第一个元素
print(list1)
# 清空列表元素
list1.clear()
print(list1)
if __name__ == '__main__':
main()[1, 3, 5, 7, 100]
['hello', 'hello', 'hello', 'hello', 'hello']
5
1
100
100
5
[300, 3, 5, 7, 100]
[300, 400, 3, 5, 7, 100, 200, 1000, 2000]
9
[400, 5, 7, 100, 200, 1000, 2000]
[]和字符串一样，列表也可以做切片操作，通过切片操作我们可以实现对列表的复制或者将列表中的一部分取出来创建出新的列表，代码如下所示。
def main():
fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango']
# 循环遍历列表元素
for fruit in fruits:
print(fruit.title(), end = ' ')
print()
# 列表切片
fruits2 = fruits[1:4]
print(fruits2)
# fruit3 = fruits # 没有复制列表只创建了新的引用
# 可以通过完整切片操作来完成对列表的复制
fruits3 = fruits[:]
print(fruits3)
fruits4 = fruits[-3:-1]
print(fruits4)
# 可以通过反向切片来获得倒转以后的列表的拷贝
fruits5 = fruits[::-1]
print(fruits5)
if __name__ == '__main__':
main()Grape Apple Strawberry Waxberry Pitaya Pear Mango
['apple', 'strawberry', 'waxberry']
['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
['pitaya', 'pear']
['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']下面的代码实现了对列表的排序操作。
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()['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
['apple', 'blueberry', 'internationalization', 'orange', 'zoo']
['zoo', 'orange', 'internationalization', 'blueberry', 'apple']
['zoo', 'apple', 'orange', 'blueberry', 'internationalization']
['zoo', 'orange', 'internationalization', 'blueberry', 'apple']我们还可以使用列表的生成式语法来创建列表，代码如下所示。
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, 20)]
print(f)
print(sys.getsizeof(f)) # 查看对象占用内存的字节数
# 请注意下面的代码创建的不是一个列表而是一个生成器对象
# 通过生成器可以获取到数据但它不占用额外的空间存储数据
# 每次需要数据的时候就通过内部的运算得到数据（需要花费额外的时间）
f = (x ** 2 for x in range(1, 20))
print(sys.getsizeof(f)) # 相比生成式生成器不占用存储数据的空间
print(f)
for val in f:
print(val)
if __name__ == '__main__':
main()[1, 2, 3, 4, 5, 6, 7, 8, 9]
['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'D1', 'D2', 'D3', 'D4', 'D5', 'D6', 'D7', 'E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7']
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]
264
88
<generator object main.<locals>.<genexpr> at 0x000001A63D963410>
1
4
9
16
25
36
49
64
81
100
121
144
169
196
225
256
289
324
361除了上面提到的生成器语法，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()1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
67653、使用元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改，在前面的代码中我们已经不止一次使用过元组了。顾名思义，我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。下面的代码演示了如何定义和使用元组。
def main():
t = ('骆昊', 38, 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()
('骆昊', 38, True, '四川成都')
骆昊
四川成都
骆昊
38
True
四川成都
('王大锤', 20, True, '云南昆明')
['王大锤', 20, True, '云南昆明']
['李小龙', 25, True, '云南昆明']
('apple', 'banana', 'orange')这里有一个非常值得探讨的问题，我们已经有了列表这种数据结构，为什么还需要元组这样的类型呢？
元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境（后面会讲到）中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改. 所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。
元组在创建时间和占用的空间上面都优于列表。我们可以使用sys模块的getsizeof函数来检查存储同样的元素的元组和列表各自占用了多少内存空间，这个很容易做到。我们也可以在ipython中使用魔法指令%timeit来分析创建同样内容的元组和列表所花费的时间，下图是我的macOS系统上测试的结果。
## 3、使用集合
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]) # update只支持列表、元组、集合，不支持number
print(set1)
print(set2)
set2.discard(5)
# remove的元素如果不存在会引发KayError
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)
print(set2)
print(set1 & set2) # print(set1.intersection(set2)) 交集
print(set1 | set2) # print(set1.union(set2)) 合集
print(set1 - set2) # print(set1.difference(set2)) set1中存在而set2中不存在的元素
print(set1 ^ set2) # print(set1.symmetric_difference(set2)) set1和set2的合集减去set1和set2的并集
#判断子集和超集
print(set2 <= set1) # print(set2.issubset(set1)) 判断set2是不是set1的子集
print(set3 <= set1) # print(set3.issubset(set1)) 判断set3是不是set1的子集
print(set1 >= set2) # print(set2.superset(set1)) 判断set1是不是set2的超集
print(set1 >= set3) # print(set3.superset(set1)) 判断set1是不是set3的超集
if __name__ == '__main__':
main()
{1, 2, 3}
Length = 3
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
{1, 2, 3, 6, 7, 8, 9, 11, 12}
1 4 9 36 49 64 81 121 144
1
{2, 3}
{1, 2, 3, 4, 5}
{1, 2, 3, 6, 7, 8, 9, 11, 12}
{1, 2, 3}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
{4, 5}
{4, 5, 6, 7, 8, 9, 11, 12}
False
True
False
True说明： Python中允许通过一些特殊的方法来为某种类型或数据结构自定义运算符（后面的章节中会讲到），上面的代码中我们对集合进行运算的时候可以调用集合对象的方法，也可以直接使用对应的运算符，例如&运算符跟intersection方法的作用就是一样的，但是使用运算符让代码更加直观。
4、使用字典
字典是另一种可变容器模型，类似于我们生活中使用的字典，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。下面的代码演示了如何定义和使用字典。
def 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))
# 删除字典中的元素
print(scores.popitem())
print(scores.popitem())
print(scores.pop('骆昊', 100))
# 清空字典
scores.clear()
print(scores)
if __name__ == '__main__':
main()
95
82
白元芳 --> 78
狄仁杰 --> 82
骆昊 --> 95
{'诸葛元朗': 71, '冷面': 67, '骆昊': 95, '白元芳': 65, '方启鹤': 85, '狄仁杰': 82}
None
60
('诸葛元朗', 71)
('冷面', 67)
95
{}4、练习
4.1：在屏幕上显示跑马灯文字
import os
import time
def main():
content = '北京欢迎您，为你开天辟地……'
while True:
# 清理屏幕上的输出
os.system('cls') # os.system('clear')
print(content)
# 休眠200秒
time.sleep(0.2)
content = content[1:] + content[0]
if __name__ == '__main__':
main()
4.2 设计一个函数产生指定长度的验证码，验证码由大小写字母和数字构成。
import random
def generate_code(code_len = 4):
"""
生成指定长度的验证码
:param code_len: 验证码的长度(默认4个字符)
:return: 由大小写英文字母和数字构成的随机验证码
"""
all_chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' # 生成由数字大小写字母组成的列表
last_pos = len(all_chars) - 1
code = []
for _ in range(code_len):
index = random.randint(0, last_pos)
code += all_chars[index]
return code
def main():
for x in generate_code():
print(x, end ='')
return 0
if __name__ == '__main__':
main()
QS9z4.3 设计一个函数返回指定文件名的后缀名。
def get_suffix(filename, has_dot=False):
"""
获取文件名的后缀名
:param filename: 文件名
:param has_dot: 返回的后缀名是否需要带点
:return: 文件的后缀名
"""
pos = filename.rfind('.')
if 0 < pos < len(filename) - 1:
index = pos if has_dot else pos + 1
return filename[index:]
else:
return -1
def print_name(filename):
if get_suffix(filename) == -1:
print("该文件没有后缀名")
else:
print(get_suffix(filename))
def main():
filename1 = '123456.txt'
filename2 = '22334455'
print_name(filename1)
print_name(filename2)
if __name__ == '__main__':
main()txt
该文件没有后缀名4.4 设计一个函数返回传入的列表中最大和第二大的元素的值
def max(x):
m1, m2 = (x[0], x[1]) if x[0] > x[1] else (x[1], x[0])
for n in range(2,len(x)):
if m1 < x[n]:
m2 = m1
m1 = x[n]
elif m2 < x[n]:
m2 = x[n]
return m1, m2
def main():
x = [8, 12, 13, 18, 9, 22, 25, 21, 10, 13]
print(max(x))
if __name__ == '__main__':
main()
(25, 22)4.5 计算指定的年月日是这一年的第几天
def is_leap_year(year):
return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
"""
判断指定的年份是不是闰年
:param year: 年份
:return: 闰年返回True平年返回False
"""
def which_day(year, month, day):
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 index in range(month - 1):
total += days_of_month[index]
return total + day
"""
计算传入的日期是这一年的第几天
:param year: 年
:param month: 月
:param date: 日
:return: 第几天
"""
def main():
print(which_day(1980, 11, 28))
print(which_day(1981, 12, 31))
print(which_day(2018, 1, 1))
print(which_day(2016, 3, 1))
if __name__ == '__main__':
main()333
365
1
614.6 打印杨辉三角
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()Number of rows: 12
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1 5、综合案例
5.1 双色球选号
from random import randrange, randint, sample
def display(balls):
"""
输出列表中的双色球号码
"""
for index, ball in enumerate(balls):
# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
if index == len(balls) - 1:
print('|', end = ' ')
print('%02d' % ball, end = ' ')
print()
def random_select():
"""
随机选择一组号码
"""
red_balls = [x for x in range(1, 34)]
selected_balls = []
selected_balls = sample(red_balls, 6)
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
07 11 24 29 32 33 | 05
08 16 17 20 23 33 | 16
01 02 17 22 27 33 | 07
01 09 15 20 27 28 | 11 5.2 约瑟夫环问题
"""
《幸运的基督徒》
有15个基督徒和15个非基督徒在海上遇险，为了能让一部分人活下来不得不将其中15个人扔到海里面去，有个人想了个办法就是大家围成一个圈，
由某个人开始从1报数，报到9的人就扔到海里面，他后面的人接着从1开始报数，报到9的人继续扔到海里面，直到扔掉15个人。由于上帝的保佑，
15个基督徒都幸免于难，问这些人最开始是怎么站的，哪些位置是基督徒哪些位置是非基督徒。
"""
def main():
persons = [True] * 30
counter, index, number = 0, 0, 0
while counter < 15:
if persons[index]:
number += 1
if number == 9:
persons[index] = False
counter += 1
number = 0
index += 1
index %= 30
for person in persons:
print('基' if person else '非', end = '')
if __name__ == '__main__':
main()
基基基基非非非非非基基非基基基非基非非基基非非非基非非基基非
END
2019-5-24 11:35:28
2019-5-24 11:35:28