笔记-4：python组合数据类型

1.字符串（str）

• 字符串是字符的序列表示， 根据字符串的内容多少分为单行字符串和多行字符串。
• 单行字符串可以由一对单引号（'） 或双引号（"）作为边界来表示， 单引号和双引号作用相同。
• 多行字符串可以由一对三单引号（'''） 或三双引号（"""） 作为边界来表示， 两者作用相同。

print('这是"单行字符串"')

print("这是'单行字符串'")

print("""这是'多行字符串'的第一行
这是'多行字符串'的第二行""")

print('''这是"多行字符串"的第一行
这是"多行字符串"的第二行''')

• python转义符：

转义符	作用
\n	换行
\	反斜杠
\‘	单引号
\"	双引号
\t	制表符

1.1 字符串的索引

• 字符串最左端位置标记为0， 依次增加。 对字符串中某个字符的检索被称为索引。

• 如果字符串长度为L， 正向递增需要以最左侧字符序号为0，向右依次递增， 最右侧字符序号为L-1；

• 反向递减序号以最右侧字符序号为-1， 向左依次递减， 最左侧字符序号为-L。

• 字符串以Unicode编码存储， 字符串的英文字符和中文字符都算作1个字符。

<字符串或字符串变量>[序号]
# 正数索引取值从左到右，下标从0开始
# 负数索引取值从右到左，下标从-1开始

a = 'HelloWorld'
print(a[0])

1.2 字符串的切片

• 对字符串中某个子串或区间的检索被称为切片。

<字符串或字符串变量>[N: M]
# [N: M]--->左闭右开

a = '青青子衿,悠悠我心'
print(a[:4])
print(a[0:5])
print(a[5:])
print(a[-1:])
print(a[5:-1])

1.3 字符串的操作符

# 字符串相加
x + y

# 复制n次字符串x
x * n或n * x

# 如果x是s的子串，返回True，否则返回False
x in s

1.4 字符串的处理函数

# len(x):返回字符串x的长度，也可以返回其他数据类型的元素个数。
print(len('Hello World'))

# str(x):返回任意类型x所对应的字符串形式。
print(str('helloworld'))

# chr(x):返回Unicode编码x对应的单字符
print(chr(10000))

# ord(x):返回单字符x表示的Unicode编码
print(ord('✐'))

# hex(x):返回整数x对应的十六进制数的小写形式字符串。
print(hex(10020))

# oct(x):返回整数x对应八进制数的小写形式字符串
print(oct(10020))

1.5 字符串的处理方法

# str.lower():将字符串全部小写。
str = 'HelloWorld'
print(str.lower())

# str.upper():就字符串全部大写。
str = 'HelloWorld'
print(str.upper())

# str.split(sep=None):分割字符串，返回一个列表。
str = 'Hello World'
print(str.split(sep=' '))

# str.count(sub):返回sub子串出现的次数。
str = 'Hello World'
print(str.count('l'))

# str.replace(old,new):将old子串被替换为new。
str = 'Hello World'
print(str.replace('l','o'))

# str.center(width,fillchar):字符串居中函数， fillchar参数可选。
str = 'HelloWorld'
print(str.center(20, '='))

# str.strip(chars):从字符串str中去掉在其左侧和右侧chars中列出的字符。
str = ' ==python==  '
print(str.strip(' '))
str = '  ==python==  '
print(str.strip(' ='))

# str.join(iter):将iter变量的每一个元素后增加一个str字符串。
print(','.join(''))
print(','.join(['','','','']))

1.6 format()方法的基本使用

基本使用格式：
<模板字符串>.format(<逗号分隔的参数>)

# 模板字符串是一个由字符串和槽组成的字符串， 用来控制字符串和变量的显示效果。槽用大括号({})表示， 对应format()方法中逗号分隔的参数。
print("{}曰： 学而时习之， 不亦说乎。 ".format("孔子"))

# 如果模板字符串有多个槽， 且槽内没有指定序号，则按照槽出现的顺序分别对应.format()方法中的不同参数。
print("{}曰： 学而时习之， 不亦{}。 ".format("孔子","说乎"))

# 通过format()参数的序号在模板字符串槽中指定参数的使用， 参数从0开始编号
print("{1}曰： 学而时习之， 不亦{0}。 ".format("说乎","孔子"))

format()方法的格式控制：{<参数序号>:<格式控制标记>}

# 左对齐(默认)：<
print("{:<10}".format("好好学习"))

# 居中对齐：^
print("{:^10}".format("好好学习"))

# 右对齐：>
print("{:>10}".format("好好学习"))

# 居中对齐且填充*号
print("{:*^25}".format("好好学习"))

# 居中对齐且填充+号
print("{:+^25}".format("好好学习"))

# 保留小数点后2位
print("{:.2f}".format(12345.67890))

# 右对齐保留小数点后3位
print("{:>25.3f}".format(12345.67890))

# 取字符串的前5位
print("{:.5}".format("全国计算机等级考试"))

# b: 输出整数的二进制方式；
# c: 输出整数对应的Unicode字符；
# d: 输出整数的十进制方式；
# o: 输出整数的八进制方式；
# x: 输出整数的小写十六进制方式；
# X: 输出整数的大写十六进制方式；
print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425))

# e: 输出浮点数对应的小写字母e的指数形式；
# E: 输出浮点数对应的大写字母E的指数形式；
# f: 输出浮点数的标准浮点形式；
# %: 输出浮点数的百分形式。
print("{0:e},{0:E},{0:f},{0:%}".format(3.14))

2.元组（tuple）

• 元组类型用小括号()表示，也可以通过tuple(x)函数将字符串或列表转换成为元组类型。

• 元组是不可变序列类型，不能修改元组中的元素，因此元组没有增加元素，修改元素，删除元素相关的方法。

• 如果需要增加，修改，删除元素，可以先将其转换为列表。

print((1,))         # 定义一个唯一元素的元组，需要在元素后面加一个','
print((1,2,'Hello','你好','='))

2.1 元组的索引

a=(1,2,'你好','HelloWorld')
b=a[0]
print(b)  

r = (1,2,'Hello','你好','=')
print(type(r))
for i in r:
    print(i)

2.2 元组的切片

a=(1,2,4,5,'你好','HelloWorld')
print(a[0:5:2])
(1, 4, '你好')

2.3 元组的操作函数和方法

a_tuple = (1,2,3,4,1)

# a.count(x):查询元组a中元素x的个数
print(a_tuple.count(1))    

# a.index(x):查询元组a中元素x的下标
print(a_tuple.index(1))    

# a.index(x,start,end:查询元组a中[start,end]区间的元素x的下标
print(a_tuple.index(2,0,2))

# a.index(x,x):查询元组a中两个相同元素之间最后一个元素x的下标
print(a_tuple.index(1,1))  

# len(a):查询元组的长度
print(len(a_tuple))

# max(a):查询元组a中元素的最大值
print(max(a_tuple))

# min(a):查询元组a中元素的最小值
print(min(a_tuple))

# sum(a):求和
print(sum(a_tuple))

# 如果需要对元组进行排序，只能使用内置函数sorted(tupleObj),生成新的列表对象，从而进行排序
a = (1,2,3,4,1)
print(sorted(a))

3.列表（list）

• 列表类型用中括号（[]） 表示， 也可以通过list(x)函数将集合或字符串类型转换成列表类型 。

• 列表没有长度限制， 元素类型可以不同， 不需要预定义长度 。

• 列表可以由字符串生成。

• 列表属于序列类型， 所以列表类型支持序列类型对应的操作 。

print([1,2,3,4])
print(list('列表可以由字符串生成'))

3.1 列表的索引

# 索引是列表的基本操作， 用于获得列表的一个元素。 使用中括号作为索引操作符。
r = [1010, "", [1010, ""], 1010]
print(r[3])
print(r[-2])

# 使用遍历循环对列表类型的元素进行遍历操作。
for <循环变量> in <列表变量>:
    <语句块>

r = [1010, "", [1010, ""], 1010]
for i in r:
    print(i)

3.2 列表的切片

# 切片是列表的基本操作， 用于获得列表的一个片段， 即获得一个或多个元素。
<列表或列表变量>[N: M]
        或
<列表或列表变量>[N: M: K]

# 切片获取列表类型从N到M（不包含M） 的元素组成新的列表。
# 当K存在时，切片获取列表类型从N到M（不包含M） 以K为步长所对应元素组成的列表。

ls = [1010, "", [1010, ""], 1010]
print(ls[1:4])
print(ls[-1:-3])
print(ls[0:4:2])

3.3 列表的操作函数

s = [1, 2, 3, 4, 5, 6]

# len(s):列表s的元素个数(长度)
print(len(s))

# min(s):列表s的最小元素
print(min(s))

# max(s):列表s的最大元素
print(max(s))

# list(x):将x转换为列表类型
x = 'abc'
print(list(x))

3.4 列表的操作方法

ls = [1,2,5,9,40]

# ls.append(x):在列表ls最后增加一个元素x。
ls.append('')

# ls.insert(i,x):在列表ls第i位增加一个元素x。
ls.insert(1,10)

# ls.clear():删除ls中所有的元素
ls.clear()

# ls.pop(i):将列表ls中第i项元素取出并删除该元素。
ls.pop(0)

# ls.remove(x):将列表中出现的第一个x元素删除
ls.remove(1)

# ls.reverse():列表ls中元素反转。
ls.reverse()

# ls.copy():生成一个新列表，复制ls中所有的元素
ls.copy()

# 使用del对列表元素或片段进行删除
del <列表变量>[<索引序号>]
            或
del <列表变量>[<索引起始>: <索引结束>]

lt = ["", "10.10", "Python"]
del lt[1]
del lt[1:]

# 使用索引配合等号（=） 可以对列表元素进行修改。
lt = ["", "10.10", "Python"]
lt[1] = 100

4.集合（set）

• 集合是无序组合， 用大括号（{}） 表示， 它没有索引和位置的概念， 集合中元素可以动态增加或删除 。

• 集合中元素不可重复， 元素类型只能是固定数据类型。整数、 浮点数、 字符串、 元组等， 列表、 字典和 集合类型本身都是可变数据类型， 不能作为集合的元素出现。

• 由于集合元素是无序的， 集合的打印效果与定义顺序可以不一致。

• 由于集合无序且唯一，所以使用集合类型能够过滤掉重复元素。

T = {1010, "", 12.3, 1010, 1010}
print(T)

4.1 集合类型操作符

• 集合类型有4个操作符， 交集（&） 、 并集（|） 、 差集（-） 、 补集（^）

S = {1,5,9,10,20,30}
T = {2,10,20,30,40,50}

print(S - T)
print(T - S)
print(S & T)
print(S ^ T)
print(S | T)

4.2 集合的操作函数和方法

s = {1,5,9,10,20,30}

# s.add(x):如果数据项x不在集合s中，将增加x到s。
s.add(100)

# s.remove(x):如果x在集合s中，移除x；不在产生KeyError异常
s.remove(100)

# s.clear():移除集合s中所有的数据项。
s.clear()

# len(s):返回集合s元素个数。
len(s)

# x in s:如果x是S的元素， 返回True， 否则返回False
1 in s

# x not is s: 如果x不是S的元素， 返回True， 否则返回False
1 not is s

4.3 元素去重

s = set('知之为知之不知为不知')
for i in s:
    print(i, end="")

5.字典(dict)

• 字典使用大括号{}建立， 每个元素是一个键值对 。

• 键和值通过冒号连接， 不同键值对通过逗号隔开。

• 键值对之间没有顺序且不能重复。

{<键1>:<值1>, <键2>:<值2>, … , <键n>:<值n>}

d = {"":"小明", "":"小红", "":"小白"}
print(d)

5.1 字典的索引

• 字典元素“键值对” 中键是值的索引， 因此， 可以直接利用键值对关系索引元素。

<值> = <字典变量>[<键>]

d = {"":"小明", "":"小红", "":"小白"}
print(d[201801])

• 利用索引和赋值（=） 配合， 可以对字典中每个元素进行修改。

d[""] = '新小红'
print(d)

• 使用大括号可以创建字典。 通过索引和赋值配合，可以向字典中增加元素。

t = {}
t[""] = "小小"
print(d)

5.2 字典的操作函数

# len(d):字典d的元素个数(长度)
print(len(d))

# min(d):字典d中键的最小值
print(min(d))

# max(d):字典d中键的最大值
print(max(d))

# dict():生成一个空字典
a = dict()
print(type(a))

5.3 字典的操作方法

# d.keys():返回所有的键信息
print(d.keys())

# d.values():返回所有的值信息
print(d.values())

# d.items():返回所有的键值对
print(d.items())

# d.get(key,default):键存在则返回相应值， 否则返回默认值
print(d.get(key,default))

# d.pop(key,default):键存在则返回相应值， 同时删除键值对， 否则返回默认值
print(d.pop(key,default))

# d.popitem():随机从字典中取出一个键值对， 以元组(key, value)形式返回
print(d.popitem())

# d.clear():删除所有的键值对
d.clear()

# 所有保留字del删除某一个元素
d = {"":"小明", "":"小红", "":"小白"}
del d[""]

# 使用保留字in，判断一个键是否在字典中。
d = {"":"小明", "":"小红", "":"小白"}
print("" in d)

5.4 字典的循环遍历

for <变量名> in <字典名>
    <语句块>

# for循环返回的变量名是字典的索引值。 如果需要获得键对应的值， 可以在语句块中通过get()方法获得。
d = {"":"小明", "":"小红", "":"小白"}
for k in d:
    print("字典的键和值分别是： {}和{}".format(k, d.get(k)))