Python入门课程系列：
- Python学习 day1：认识Python
- Python学习 day2：判断语句与循环控制
序列（sequence）：序列是python中最基本的数据结构。序列是一组按照顺序排列的值，其中的元素带编号（编号从0开始）
在python中，存在三种内置的序列类型 ，即：字符串、列表和元组。其中列表是可变的（你可修改其内容），而元组和字符串是不可变的（一旦创建，内容就是固定的）。
字典不属于序列，没有下标，不能取切片
优点：可以支持索引和切片的操作
特征：第一个正索引为0，指向是从左往右。当使用负数索引时，Python将从右（即从最后一个元素）开始往左数，因此-1是最后一个元素的位置。
⚠️1. 字符串及常用方法
所有标准序列操作（索引、切片、乘法、成员资格检查、长度、最小值和最大值）都适用于字符串，但字符串是不可变的，因此所有的元素赋值和切片赋值都是非法的。
- 将值转换为字符串并设置其格式是一个重要的操作，主要的解决方案是使用字符串格式设置运算符——百分号。在%左边指定一个字符串（格式字符串），并在右边指定要设置其格式的值。指定要设置其格式的值时，可使用单个值（如字符串或数字），可使用元组（如果要设置多个值的格式），还可使用字典，其中最常见的是元组。
- %s称为转换说明符，指出了要将值插入什么地方。s意味着将值视为字符串进行格式设置。如果指定的值不是字符串，将使用str将其转换为字符串。其他说明符将导致其他形式的转换。例如，%.3f将值的格式设置为包含3位小数的浮点数。
难点
1.字符串常用方法
2.切片操作
❗️ 切片：可以根据下标来获取序列对象的任意部分数据，语法结构[start:end:step]，step默认为1。
❗️切片是左包含右不包含
3.与其他类型综合操作
字符串及常用方法 ❗️「方法是与对象（列表、数、字符串等）联系紧密的函数。通常，调用方法： object.method(arguments)。方法调用与函数调用很像，只是在方法名前加上了对象和句点」
常用字符串函数。此外，常见函数还有：1.center(通过在两边添加填充字符（默认为空格）让字符串居中)；
Test="python"
print('Test的内存地址%d'%id(Test)) #id函数可以查看一个对象的内存地址
Test1=Test #这里只是把Test对象的地址赋给了Test1，Test和Test1的ip地址是一样的
print(type(Test))
print('获取第一个字符%s'%Test[0])
#取切片操作
strMsg='hello world'
#slice[start:end:step] #左闭右开 范围：start<=value", line 1, in ?
#TypeError: sequence item 0: expected string, int found
seq = ['1', '2', '3', '4', '5']
print(sep.join(seq)) # 合并一个字符串列表
# '1+2+3+4+5'
⚠️⚠️2. 列表及常用方法
list：python中非常重要的数据结构，是一种有序的数据集合
内置函数list可以将字符串转化成列表
特点：
1.支持增、删、改、查
2.列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】
3.用[]来表示列表类型，数据项之间用逗号来分割 ，注意：数据项可以是任意类型的数据
4.支持索引和切片来进行操作
列表与元组的主要不同在于：列表可以修改，元组不可以。这意味着列表适用于需要中途添加元素的情形，而元组适用于处于某种考虑禁止修改序列的情形。
列表及常用方法。除上面这些以外，还有1. clear(清空列表的内容)；2. copy(复制列表)；
li=[1,2,3,'你好'] #使用[]创建列表
print(len(li)) #len函数可以获取列表对象中的数据个数/也可查看字符串中的字符数
#鉴于不能像修改列表那样修改字符串，因此在有些情况下使用字符串来创建列表很有帮助。
#为此，可使用内置函数list
a=list('Hello')
print(a)
#['H', 'e', 'l', 'l', 'o'] #将字符串转换为列表
#取切片操作
listA=['abcd',789,12.23,'qiuzhi',True]
print(listA) #输出完整列表
print(listA[0]) #输出第一个元素
print(listA[1:3]) #获取第2-3个元素
print(listA[2:]) #获取3到最后一个元素
print(listA[::-1]) #倒序输出
print(listA*2) #输出两遍【复制】
#修改
listA[0]='Peter'
print(listA)
listA[0]=1
print(listA)
#方法1: append 追加操作
listA.append(['fff','ddd',333]) #在列表里面插入列表，插入的列表算一个元素，只是这个元素又包含了三个元素
print(listA)
print(len(listA))
#方法2: insert 插入操作，需要指定位置
listA.insert(1,'新插入') #插入在第二个位置
print(listA)
#方法3: entend 拓展数据，等于批量添加
rsData=list(range(10))
listA.extend(rsData)
print(listA)
listA.extend([11,12,13,14]) #直接追加也可以 ⚠️和append不同
print(listA)
# 方法4: reverse 按相反的顺序排列列表中的元素
#❗️如果要按相反的顺序迭代序列，可使用函数reversed。这个函数不返回列表，而是返回一个迭代器，可使用list将返回的对象转换为列表。
x = [1, 2, 3]
x.reverse()
print(x)
#[3, 2, 1]
# 方法5: 删除 del remove pop
listB=list(range(10,50))
print(listB)
del listB[0] #删除第一个数据
print(listB)
del listB[1:3] #通过切片删除多个数据（第二项到第三项）
listB.remove(20) #移除指定元素，括号内的是需要移除的指定项
listB.pop(1) #移除指定元素，如果不指定，则移除第一个数据。pop后面的参数是需要移除的指定项的索引值
#❗️pop是唯一既修改列表又返回一个非None值的列表方法。
#❗️方法6: copy 复制列表
#常规复制只是将另一个名称关联到列表
a = [1, 2, 3]
b = a
b[1] = 4 #指向相同的内存内容
print(a)
# [1, 4, 3]
#要让a和b指向不同的列表，就必须将b关联到a的副本。
a = [1, 2, 3]
b = a.copy()
b[1] = 4
print(a)
# [1, 2, 3]
#❗️方法7: sort 于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。
x = [4, 6, 2, 1, 7, 9]
x.sort()
print(x)
# [1, 2, 4, 6, 7, 9]
x = [4, 6, 2, 1, 7, 9]
y = x.sort() # Don't do this!
print(y) #鉴于sort修改x且不返回任何值，最终的结果是x是经过排序的，而y包含None。
#None.
#为实现前述目标，正确的方式之一是先将y关联到x的副本，再对y进行排序
x = [4, 6, 2, 1, 7, 9]
y = x.copy()
y.sort()
print(x)
#[4, 6, 2, 1, 7, 9]
print(y)
#[1, 2, 4, 6, 7, 9]
#❗️或者使用函数sorted。实际上，这个函数可用于任何序列，但总是返回一个列表。
x = [4, 6, 2, 1, 7, 9]
y = sorted(x)
print(x)
#[4, 6, 2, 1, 7, 9]
print(y)
#[1, 2, 4, 6, 7, 9]
#方法sort接受两个可选参数：key和reverse。
#这两个参数通常是按名称指定的，称为关键字参数。
#参数key类似于参数cmp：你将其设置为一个用于排序的函数。然而不会直接使用这个函数来判断一个元素是否比另一个元素小，而是使用它来为每个元素创建一个键，再根据这些键对元素进行排序。因此，要根据长度对元素进行排序，可将参数key设置为函数len。
#对于另一个关键字参数reverse，只需将其指定为一个真值（True或False），以指出是否要按相反的顺序对列表进行排序。
#函数sorted也接受参数key和reverse。在很多情况下，将参数key设置为一个自定义函数很有用。
⚠️3. 元组
元组是一种不可变的序列，在创建之后不能做任何的修改
元组语法很简单，只要在括号中添加元素，并使用逗号分隔。
函数tuple的工作原理与list很像：它将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。
元组可以用作映射中的键（以及集合的成员），而列表不行。
特点：
1.不可变
2.用（）创建元组类型，数据项用逗号来分割
3.可以是任何的类型
4.当元组中只有一个元素时 ，要加上逗号，不然解释器会当作整型来处理
5.同样可以支持切片操作
#tuple函数可以把序列转为tuple。
a=tuple('1,2,3') #并不是创建了包含1,2和3的tuple，而是单引号包含了1 2 3和两个逗号这五个元素的字符串，a是把这个字符串转为 tuple，所以有5个元素
print(len(a))
#5
print(a)
#('1', ',', '2', ',', '3')
for item in tupleA:
print(item,end=' ')
pass #pass是一个占位符，能够保证程序的代码结构正确，程序运行时，关键字不会执行任何 操作
print(tupleA[2:4])
print(tupleA[::-1]) #倒序
print(tupleA[::-2]) #倒序 每两个数取一个
print(tupleA[-2:-1:]) #倒着取下标为-2到-1之间的数据
#元组不可修改，但元组中包含的列表中的数据可以修改
tupleA=('abcd',89,9.13,'peter',[11,12,13])
print(tupleA)
tupleA[4][0]=345
print(tupleA)
#当元组中只有一个元素时 ，要加上逗号
tupleB=('1')
print(type(tupleB))
tupleB=('1',)
print(type(tupleB))
#数值转成元组
tupleC=tuple(range(10))
print(tupleC)
print(tupleC.count(8)) #统计8出现了几次
⚠️⚠️4. 字典及常用方法
字典是python中重要的数据类型，字典是由键值对组成的集合，通常使用键来访问数据，效率非常高，和list一样支持对数据的添加、修改、删除。
函数dict可以从其他映射（如其他字典）或键值对创建字典。
特点：
1.不是序列类型，没有下标概念 ，是一个无序的键值集合，是内置的高级数据类型
2.用{}来表示字典对象，每个键值对用逗号分隔
3.键必须是不可变的类型【元组、字符串等】值可以是任意的类型
4.每个键必定是唯一的，如果存在重复的键，后者会覆盖前者
#创建/更新字典 （以前不存在，就直接创建，已经存在就在原有基础追加）
dictA={}
print(type(dictA))
#方法1
dictA['name']='hui' #左边[]中的是键，右边{}中的是value
dictA['age']='24'
dictA['pos']='med'
print(dictA)
#方法2
dictB={'name':'me','school':'tjmu'}
print(dictB)
#方法3 #使用dict函数从其他映射或键值对创建字典
items = [('name', 'Gumby'), ('age', 42)]
d = dict(items)
print(d)
#{'age': 42, 'name': 'Gumby'}
d['name']
# 'Gumby'
#方法4
dictA.update({'school':'hnmu'})
#方法5 fromkeys创建一个新字典，其中包含指定的键，且每个键对应的值都是None。
a={}.fromkeys(['name', 'age'])
print(a)
# {'age': None, 'name': None}
#查找元素
print(dictB['name']) #通过键获取对应的值
dictB['name']='lee' #更改键对应的值
print(dictB)
#获取所有的键
print(dictA.keys())
#获取所有的值
print(dictA.values())
#获取所有的项/键值对
print(dictA.items())
for key,value in dictA.items():
print('%s==%s'%(key,value))
#通过指定键来进行删除
del dictA['name']
print(dictA)
dictA.pop('age')
print(dictA)
#对字典进行排序 ??
print(sorted(dictA.items(),key=lambda d:d[0]))
print(sorted(dictA.items(),key=lambda d:d[1]))
5. 共有操作
#合并
strA='人生苦短'
strB='我用python'
print(strA+strB)
listA=list(range(10))
listB=list(range(11,20))
print(listA+listB)
#复制
print(strA*3)
# 在位于屏幕中央且宽度合适的方框内打印一个句子
sentense=input("请输入Sentence:")
screen_width=80
text_width=len(sentense)
box_witdth=text_width+2
left_margin=(screen_width-box_witdth)//2
print()
print(' '*left_margin+'*'+'-'*(box_witdth-2)+'*')
print(' '*left_margin+'|'+' '*text_width+'|')
print(' '*left_margin+'|'+ sentense +'|')
print(' '*left_margin+'|'+' '*text_width+'|')
print(' '*left_margin+'*'+'-'*(box_witdth-2)+'*')
*------------------------*
| |
|carpe diem,seize the day|
| |
*------------------------*
#in 判断对象是否存在,结果是一个bool值
print('生' in strA)
print('20' in listA)
dictA={'name':'Peter'}
print('name' in dictA)
>课后练习题（答案见正文示例）
- 在位于屏幕中央且宽度合适的方框内打印一个句子
>思考
- 方法与函数的区别