python字符串字符序数怎么写出来的

字符串的使用

字符串是用来记录文本信息的，它是由是由零个或多个字符组成的有限序列序列中的元素包含了一个从左到右的顺序——序列中的元素根据它们的相对位置进行存储和读取。从严格意义上来说，字符串是单个字符的字符串序列，其他类型的序列还包括列表和元组。在Python程序中，如果我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。

'''
例1：字符串的表示与打印
'''
s1 = 'hello,world!!'
s2 = "hello,world!!"
# 以三个双引号或单引号开头的字符串可以折行
s3 = """
hello,
world!
"""
print(s1,s2,s3,end='')

在python字符串中，单引号和双引号字符是可以互换的。也就是说，字符串常量表达式可以用两个单引号或两个双引号来表示——两种形式同样有效并返回相同类型的对象。
在字符串中，可以用转义字符来代表一些特殊的字节。通常在一个字符之前使用反斜杠\表示转义，也就是说\后面的字符不再是它原来的意义。如：\n不是代表反斜杠和字符n，而是表示换行；而\t也不是代表反斜杠和字符t，而是表示制表符。
在\后面还可以跟一个八进制或者十六进制数来表示字符，还可以跟Unicode字符编码来表示字符。下面的表格是一些转义字符的意思。

转义字符	意义
\newline	忽略（连续）
\ \	反斜杠（保留\）
\’	单引号（保留’）
\"	双引号（保留"）
\a	响铃
\b	倒退
\f	换页
\n	换行
\r	返回
\t	水平制表符
\v	垂直制表符
\xhhh	十六进制值
\ooo	八进制值
\0	NULL

'''
例2：转义字符的表示
'''
s1 = '\u4f60\u597d \n'    #你好
s2 = '\141\142\143\x61\x62\x63 \n'   #abcabc
s3 = ' \" hello world \" \n'   #" hello world "
print(s1,s2,s3)

在python中，很多符号都可以用来对字符串进行操作。+可以用来拼接两个字符串，*可以重复一个字符串，可以使用in和not in来判断一个字符串是否包含另外一个字符串（成员运算），我们也可以用[]和[:]运算符从字符串取出某个字符或某些字符（切片运算)

'''
例3：运算符对字符串的操作
'''
s1 = 'hello ' * 3
print(s1) #hello hello hello 
s2 = 'world'
s1 = s1 + s2
print(s1) #hello hello hello world
print('hel' in s1)#True
print('kkk' in s1)#False
str2 = 'abcdefg'
# 从字符串中取出指定位置的字符(下标运算)
print(str2[0]) #a
# 字符串切片(从指定的开始索引到指定的结束索引)
print(str2[2:5])#cde
print(str2[2:])#cdefg
print(str2[2::2])#ceg
print(str2[::2])#aceg
print(str2[::-1])#gfedcba
print(str2[-3:-1])#ef

下面的例子是python中的一些函数，这些函数可以用来判断字符串的一些相应的内容：

'''
例4：字符串的一些比较函数
'''
str1 = 'hello, world!'
# 通过内置函数len计算字符串的长度
print(len(str1)) # 13
# 获得字符串首字母大写的拷贝
print(str1.capitalize()) # Hello, world!
# 获得字符串每个单词首字母大写的拷贝
print(str1.title()) # 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.isdigit())  # False
# 检查字符串是否以字母构成
print(str2.isalpha())  # False
# 检查字符串是否以数字和字母构成
print(str2.isalnum())  # True
str3 = '  [e-mail] '
print(str3)
# 获得字符串修剪左右两侧空格之后的拷贝
print(str3.strip())

对于输出一个字符串，可以采用多种方式：
格式化输出字符串

(a,b) = (1,2)
print('%d + %d = %d' %(a,b, a+b))

列表的使用

python的列表对象是这个语言提供的最通用的序列，是一种结构化的、非标量类型，它是值的有序序列，每个值都可以通过索引进行标识，定义列表可以将列表的元素放在[]中，多个元素用,进行分隔，可以使用for循环对列表元素进行遍历，也可以使用[]或[:]运算符取出列表中的一个或多个元素。

'''
例5：列表的定义、列表的遍历、列表的下标运算
'''
list1 = [1,2,3,4,100]
print(list1) #[1, 2, 3, 4, 100]
# 乘号表示列表元素的重复
list2 = ['hello'] * 3
print(list2) #['hello', 'hello', 'hello']
# 计算列表长度(元素个数)
print(len(list2)) #3
# 下标(索引)运算
print(list1[0]) # 1
print(list1[4]) # 100
# print(list1[10])  # IndexError: list index out of range
print(list1[-1]) # 100
print(list1[-3]) # 3
list1[2] = 200
print(list1) #[1, 2, 200, 4, 100]
print(' ')
# 通过循环用下标遍历列表元素
for index in range(len(list1)):
    print(list1[index])

print(' ')
# 通过for循环遍历列表元素
for elem in list1:
    print(elem)

print(' ')
# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
for index,elem in enumerate(list1):
    print(index,elem)

'''
例6：向列表中添加元素和移除元素
'''
list = [1,2,3,4,5]
list.append(200)
print(list)   #[1, 2, 3, 4, 5, 200]
list.insert(1,100)
print(list)   #[1, 100, 2, 3, 4, 5, 200]
# 合并两个列表
#list.extend([1000,2000])
list += [1000,2000]
print(list)  #[1, 100, 2, 3, 4, 5, 200, 1000, 2000]
# 先通过成员运算判断元素是否在列表中，如果存在就删除该元素
if 3 in list:
    list.remove(3)
if 1234 in list:
    list.remove(1234)
print(list) #[1, 100, 2, 4, 5, 200, 1000, 2000]
# 从指定的位置删除元素
list.pop(0)
list.pop(0) #以pop后的序列为角标
print(list)  #[2, 4, 5, 200, 1000, 2000]
# 清空列表元素
list.clear()
print(list)  #[]

'''
例7：列表的切片操作
'''
fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango']
print(fruits) #['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
# 列表切片
fruit1 = fruits[1:4]
print(fruit1) #['apple', 'strawberry', 'waxberry']
# 可以通过完整切片操作来复制列表
fruit2 = fruits[:]
print(fruit2) #['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
fruit3 = fruits[-3:-1]
print(fruit3) #['pitaya', 'pear']
# 可以通过反向切片操作来获得倒转后的列表的拷贝
fruit4 = fruits[::-1]
print(fruit4) #['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']

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

生成式和生成器

我们还可以使用列表的生成式语法来创建列表.

'''
例9：生成式与生成器
'''
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)

元组的使用

元组对象（tuple）基本上就像一个不可以改变的列表。元组与列表类似也是一种容器数据类型，可以用一个变量（对象）来存储多个数据，不同之处在于元组的元素不能修改，把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。

'''
例10：元组的定义、元组的使用及元组中的元素不可修改
'''
# 定义元组
t = ('LaoWu', 38, True, '湖北武汉')
print(t)
# 获取元组中的元素
print(t[0])
print(t[2])
# 遍历元组中的值
for val in t:
    print(val)
# 重新给元组赋值
#t[0]='Uzi' #'tuple' object does not support item assignment
# 变量t重新引用了新的元组原来的元组将被垃圾回收
t = ('王大锤', 20, True, '云南昆明')
print(t)
# 将元组转换成列表
person = list(t)
print(person)
# 列表是可以修改它的元素的
person[0] = 'ming'
person[2] = False
print(person)
# 将列表转换成元组
fruits_list = ['apple', 'banana', 'orange']
fruits_tuple = tuple(fruits_list)
print(fruits_tuple)

元组在实际的开发中并不想列表那样常用，但它的关键是不可变性。如果在程序中以列表的形式传递一个对象的集合，它可能在任何地方发生改变；如果使用元组的话则不能。也就是说，元组提供了一种完整的约束，这对于比我们这里所编写的更大型的程序来说是方便的。

集合的使用

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

'''
例11：集合的定义和使用
'''
# 创建集合的字面量语法
set1 = {1,2,3,4,5,6,7}
print(set1)
print('Length =', len(set1))
# 创建集合的构造器语法
set2 = set(range(1,10))  
set3 = set((1,2,3,4,5,6,7))  
print(set2,set3)
# 创建集合的推导式语法(推导式也可以用于推导集合)
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
print(set4)

'''
例12：向集合添加元素或删除元素
'''
set1 = {1,2,3}
set1.add(4)
set1.add(5)
print(set1) #{1, 2, 3, 4, 5}
set1.update([6,7])
print(set1) #{1, 2, 3, 4, 5, 6, 7}
set1.discard(4)
print(set1) #{1, 2, 3, 5, 6, 7}
if 2 in set1:
    set1.remove(2)
print(set1) #{1, 3, 5, 6, 7}
print(set1.pop()) #1 
print(set1) #{3, 5, 6, 7}

'''
例13：集合的交、并、差、对称差运算，判断子集和超集
'''
set1 = {1,2,3}
set2 = {2,3,4}
# 集合的交集、并集、差集、对称差运算
print(set1 & set2)   #{2, 3}
print(set1.intersection(set2 )) #{2, 3}
print(set1 | set2) #{1, 2, 3, 4}
print(set1.union(set2)) #{1, 2, 3, 4}
print(set1 - set2, set2 - set1) #{1} {4}
print(set1.difference(set2),set2.difference(set1)) #{1} {4}
#对称差运算：数学上，两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合。
print(set1 ^ set2) #{1, 4}
print(set1.symmetric_difference(set2)) #{1, 4}
#判断子集和超集
set3 = {1,2,3,4,5}
set4 = {1,2,3}
print(set4 <= set3) #True
print(set4.issubset(set3)) # True
print(set3 <= set4) #False
print(set3.issubset(set4)) #Fasle
print(set1 >= set2) #False
# print(set1.issuperset(set2))
print(set1 >= set3) #False
# print(set1.issuperset(set3))

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

字典的使用

Python中的字典它不是序列，而是一种映射。映射是一个其他对象的集合，但是它们是通过键而不是通过相对位置来存储的。它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。

'''
例14：字典的创建以及相关操作
'''
# 创建字典的字面量语法
scores = {'uzi': 95, 'ming': 78, 'mlxg': 82}
print(scores)  #{'uzi': 95, 'ming': 78, 'mlxg': 82}
# 创建字典的构造器语法
items1 = dict(one=1, two=2, three=3, four=4)
# 通过zip函数将两个序列压成字典
items2 = dict(zip(['a','b','c'],'123'))
# 创建字典的推导式语法
items3 = {num: num ** 2 for num in range(1, 10)}
print(items1) #{'one': 1, 'two': 2, 'three': 3, 'four': 4}
print(items2) #{'a': '1', 'b': '2', 'c': '3'}
print(items3) #{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
# 通过键可以获取字典中对应的值
print(scores['uzi']) #uzi:95
print(scores['ming']) #ming:78
# 对字典中所有键值对进行遍历
for key in scores:
    print(f'{key}: {scores[key]}')
# 更新字典中的元素
scores['uzi'] = 100
scores['xiaohu'] = 71
scores.update(letme=67, xlb=85)
print(scores) #{'uzi': 100, 'ming': 78, 'mlxg': 82, 'xiaohu': 71, 'letme': 67, 'xlb': 85}
if 'clearlove' in scores:
    print(scores[clearlove])
print(scores.get('clearlove')) 
# get方法也是通过键获取对应的值但是可以设置默认值
print(scores.get('clearlove', 60))
#删除字典中的元素
print(scores.popitem()) #('xlb', 85)
print(scores.popitem()) #('letme', 67)
print(scores.pop('uzi',100))  
print(scores)  #{'ming': 78, 'mlxg': 82, 'xiaohu': 71}
# 清空字典
scores.clear()
print(scores) #{}

参考资料：
[1]https://github.com/jackfrued/Python-100-Days
[2]《Python学习手册（第4版）》