python整数三位分节,Python学习 day3-2021.3.1（高级数据类型）

序列(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

print(strMsg) #输出完整的数据

print(strMsg[0]) #输出第一个数据

print(strMsg[2:5]) #取第三个到第五个数据之间数据

print(strMsg[2:]) #从第三个值取到最后

print(strMsg[:3]) #从第一个值取到第三个

print(strMsg[::-1]) #倒序输出负号表示方向是从右往左

#常用函数操作

#1. 首字母大写

name='Peter'

print('姓名首字母转换大写%s'%name.capitalize())

#2. 删除空格

a=' hello '

b=a.strip() #strip是删除空格，lstrip是删除左边空格，rstrip是删除右边空格

print(b)

#3. 查找某个字符是否在某个字符串内

dataStr='I love python'

print(dataStr.find('p')) #查找目标对象在序列对象中的位置，返回第一个下标值，没找到返回-1，并非返回布尔值

print(dataStr.index('l')) #检测 字符串中是否包含子字符串，返回第一个下标值，没找到会报错

#4. 判断字符串 的开头和结尾

dataStr='I love python'

print(dataStr.startswith('I'))

print(dataStr.endswith('I'))

#5. 大小写转换

print(dataStr.upper())

print(dataStr.lower())

#6. join 其作用与split相反，用于合并序列的元素。

#所合并序列的元素必须都是字符串。

seq = [1, 2, 3, 4, 5]

sep = '+'

sep.join(seq) # 尝试合并一个数字列表 会报错

#Traceback (most recent call last):

#File "", 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)

>课后练习题(答案见正文示例)

在位于屏幕中央且宽度合适的方框内打印一个句子

>思考

方法与函数的区别