Python学习07_字符串和常用数据结构
字符串
字符串是零个或多个字符组成的有限序列。在Python中，如果我们把单个或多个字符用单引号或双引号包围起来，就可以表示一个字符串。
s1='hello,world!'
s2="hello,world!"
s3="""
hello,
world!
"""
print(s1,s2,s3,end=' ')
转义字符
在字符串中可以使用'\'(反斜杠)来表示转义。也就是说，字符不再是它原来的意义。通过与其他内容的组成呈现不同的含义。
\n代表换行；\t代表制表符。
在反斜杠后面还可以跟一个八进制或十六进制数来表示字符例如'\141'和\x61都代表小写字母a。如果不希望字符串中的\表示转义，我们可以通过在字符串的最前面加上字母r来加以说明。
s1 = r'\'hello, world!\''
s2 = r'\n\\hello, world!\\\n'
print(s1, s2, end='')
字符串使用
Python为字符串类型提供了非常丰富的运算符，我们可以使用+运算符来实现字符串的拼接，可以使用*运算符来重复一个字符串的内容，可以使用in和not in来判断一个字符串是否包含另外一个字符串（成员运算），我们也可以用[]和[:]运算符从字符串取出某个字符或某些字符（切片运算），代码如下所示。
s1 = 'hello' * 3
print(s1)
s2 = 'world'
s1+=s2
print(s1)
print('ll' in s1)
print('good' in s1)
str2='abc123456'
print(str2[2])
print(str2[2:5])
print(str2[2:])
print(str2[2::2])
print(str2[::2])
print(str2[::-1])
print(str2[-3:-1])
在Python中，我们还可以通过一系列的方法来完成对字符串的处理，代码如下所示。
str1 = 'hello , world!'
print(len(str1)) # len计算字符串长度
print(str1.capitalize()) # 获得字符串首字母大写的拷贝
print(str1.title()) # 获得字符串每个单词大写的拷贝
print(str1.upper()) # 获得字符串变大写后的拷贝
# 从字符串中查找子串所在的位置
print(str1.find('or'))
print(str1.find('shit'))
# 检查字符串是否以指定的字符串开头
print(str1.startswith('He'))
print(str1.startswith('hel'))
# 检查字符串是否以指定的字符串结尾
print(str1.endswith('!'))
# 将字符串以指定的宽度剧中并在两侧填充指定的字符
print(str1.center(50, '*'))
# 将字符串以指定的宽度靠右放置左侧填充指定的字符
print(str1.rjust(50, ' '))
str2 = 'abc123456'
# 检查字符串是否以数字构成
print(str2.isdigit())
#检查字符串是否以字母构成
print(str2.isalpha())
# 检查字符串是否以数字和字母构成
print(str2.isalnum())
str3 = ' jackfrued@126.com '
print(str3)
# 获得字符串修剪左右两侧空格之后的拷贝
print(str3.strip())
Python 3.6以后，格式化字符串可以用在字符串前加上字母f的方式来进行。
a, b = 5, 10
print(f'{a} * {b} = {a * b}')
使用列表
类似C/C++中的数组。表示着一种结构化的、非标量类型，它是值的有序序列，每个值都可以通过索引进行标识，定义列表可以将列表的元素放在[]中，多个元素用,进行分隔，可以使用for循环对列表元素进行遍历，也可以使用[]或[:]运算符取出列表中的一个或多个元素。
list1 = [1, 3, 5, 7, 100]
print(list1)
# 乘号表示列表元素的重复
list2 = ['hello']*3
print(list2)
# 计算列表长度(元素个数)
print(len(list1))
# 下标(索引)运算
print(list1[0])
print(list1[4])
print(list1[-1])
print(list1[-3])
list1[2] = 300
print(list1)
# 通过循环用下标遍历列表元素
for index in range(len(list1)):
print(list1[index])
# 通过for循环遍历列表元素
for elem in list1:
print(elem)
# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
for index,elem in enumerate(list1):
print(index,elem)
列表也可以x像字符串一样做切片操作。
fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango']
# 列表切片
fruits2 = fruits[1:4]
print(fruits2)
# 可以通过完整切片操作来复制列表
fruits3 = fruits[:]
print(fruits3)
fruits4 = fruits[-3:-1]
print(fruits4)
# 可以通过反向切片操作来获得倒转后的列表的拷贝
fruits5 = fruits[::-1]
print(fruits5)
可以使用sorted来对列表进行排序
list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)#字典序排序
list3 = sorted(list1,reverse=True)#倒序
list4 = sorted(list1,key=len) # 通过key关键字参数指定根据字符串长度进行排序
print(list1)
print(list2)
print(list3)
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)
for val in f:
print(val)
另外，可以通过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中有与列表类似的容器数据类型，可以通过一个变量（对象）来存储多个数据，不同之处在于元组的元素不能修改。
把多个元素组合到一起就形成了一个元组，它可以和列表一样保存多条数据。
t = ('熊猫',101,True,'成都')
print(t)
print(t[0])
print(t[3])
for mem in t:
print(mem)
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)
如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。元组在创建时间和占用的空间上面都优于列表。
使用集合
Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。
创建和使用集合
# 创建集合
set1 = {1, 2, 3, 3, 3, 2}
print(set1) # 不允许有重复元素
print('Length =', len(set1))
# 使用构造器创建集合
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
print(set2, set3)
# 使用推导时语法创建集合
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
print(set4)
添加、删除元素
# 创建集合
set1 = {1, 2, 3, 3, 3, 2}
print(set1) # 不允许有重复元素
print('Length =', len(set1))
# 使用构造器创建集合
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
print(set2, set3)
# 使用推导时语法创建集合
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
print(set4)
# 添加，删除
print('-------------------------')
set1.add(4)
set1.add(5)
set2.update([11, 12])
set2.discard(5)
if 4 in set2:
set2.remove(4)
print(set1, set2)
print(set3.pop())
print(set3)
交集、并集、差集等运算
# 创建集合
set1 = {1, 2, 3, 3, 3, 2}
print(set1) # 不允许有重复元素
# 使用构造器创建集合
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
print(set2, set3)
# 使用推导时语法创建集合
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
print(set4)
# 添加，删除
print('-------------------------')
# 集合的交集、并集、差集、对称差运算
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))
使用字典
字典是另一种可变容器模型，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。
# 创建字典的字面量语法
scores = {'开心': 95, '白元芳': 78, '狄仁杰': 82}
print('scores:',scores)
# 使用构造器创建字典
items1 = dict(one=1,two=2,three=3,four=4)
print('items1:',items1)
items2 = dict(zip(['a','b','c'],'123'))
print('items2:',items2)
# 使用推导式语法创建字典
items3={num:num**2 for num in range(1,10)}
print('items3',items3)
print(scores['开心'])
print(scores['狄仁杰'])
for key in scores:
print(f'{key}: {scores[key]}')
# 更新字典中的元素
scores['白元芳'] = 65
scores['诸葛王朗'] = 71
scores.update(冷面=67, 方启鹤=85)
print('scores:',scores)
if '武则天' in scores:
print(scores['武则天'])
print(scores.get('武则天'))
# get方法也是通过键获取对应的值但是可以设置默认值
print(scores.get('武则天', 60))
print('scores:',scores)
# 删除字典中的元素
print(scores.popitem())
print(scores.popitem())
print(scores.pop('开心', 100))
print('scores:',scores)
# 清空字典
scores.clear()
print(scores)
不积硅步，无以至千里。
