03、Python数据类型

• 序列:一组按顺序排列的值，【数据集合】
• 序列优点：支持索引和切片操作
• 特征:第一个正索引为0，指向的是左端， 第一个索引为负数，指向的是右端
• 切片是指截取字符串中的某一段内容，
• 切片使用语法：[起始下标：结束下标：步长] 切片截取的内容不包含结束下标对应的数据，步长指的是隔几个下标获取一个字符
• 下标会越界，切片不会：

字符串

不可变的字符序列

• 字符串驻留机制：

仅仅保存一份相同且不可变字符串的方法，不同的值被存放 在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符窜的地址赋给新创建的变量

在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比‘+’效率高

a = 'python'
b = "Python"
c = '''Python'''
print(a, id(a))
print(b, id(b))
print(c, id(c))

"""结果如下"""
python 2090039786608
Python 2089748023280
Python 2089748023280

• 查询操作的方法

"""index() rindex()  find()  rfind()"""
s='hello,hello'
print(s.index('lo'))#从头找到的第一次出现的
print(s.find('lo'))#从头找到的第一次出现的
print(s.rindex('lo'))#从头开始找，找最后一次出现的
print(s.rfind('lo'))#从头开始找，找最后一次出现的

# print(s.index('k'))#index()方法找不到会报错
#find()方法找不到会返回-1
print(s.find('k'))


"""结果如下"""
3
3
9
9
-1

• 大小写转换

s = 'hello,Python'
q = s.upper()  # 转成大写后，会产生一个新的字符串对象
print(q, id(q))
print(s, id(s))
print(s.lower(), id(s.lower()))  # 转换小写后也会转成一个新的对象
print(s, id(s))
s2 = 'hello,Python'
print(s2.swapcase())  # 所有的大写转小写，所有的小写转大写
print(s2.title())   # 把每个单词的第一个字符转成大写，把每个单词剩余的字符串转成小写
print(s2.capitalize()) # 第一个字符转大写，剩余的单词 转成小写

• 字符串内容对齐的操作方法

print(s2.center(20, '*'))
"""左对齐"""
print(s2.ljust(20, '*'))
print(s2.ljust(20))
"""右对齐"""
print(s2.rjust(20,'*'))
print(s2.rjust(20))
print(s2.rjust(8))
"""右对齐，使用0填充"""
print(s2.zfill(20))
print(s2.zfill(10))
print('-8910'.zfill(8))

"""结果如下"""
****hello,Python****
hello,Python********
hello,Python        
********hello,Python
        hello,Python
hello,Python
00000000hello,Python
hello,Python
-0008910#用0填充至8位

• 字符串分割 操作的方法

split():从字符串的左边开始分割，默认的分隔符时空格字符串，返回的值时一个列表

以通过参数step指定分割字符串的分割数

通过参数maxsplit指定分割字符串时的最大分割次数，在经过了最大分割之后，剩余的子串会单独作为一部分

rsplit():跟上述有一样，只不过是从右边开始分割

s='hello world python'
lst=s.split()
print(lst)
s1='hello|world|python'

print(s1.split(sep='|',maxsplit=1))

"""rsplit()从右侧开始分割"""
print(s.rsplit())
print(s1.rsplit('|',maxsplit=1))

"""结果如下"""
['hello', 'world', 'python']
['hello', 'world|python']
['hello', 'world', 'python']
['hello|world', 'python']

• 判断字符串操作方法

print(str.startswith(‘I’))#返回布尔型 判断是否以什么什么开始
print(str.endswith(‘i’))#判断是否以什么什么结尾

s='hello,pytohn'
print('1',s.isidentifier())
print('2','hello'.isidentifier())
print('3','\t'.isalpha())
print('4','\t'.isspace())
print('5','python'.isalpha())
print('6','132'.isdecimal())
print('7','132死'.isdecimal())
print('8','456'.isnumeric())
print('9','abc1'.isalnum())
print('10','张三ada1'.isalnum())

"""结果如下"""
1 False
2 True
3 False
4 True
5 True
6 True
7 False
8 True
9 True
10 True

• 字符串替换

s='hello,python'
print(s.replace('python','Java'))
s2='hello python python python'
print(s2.replace('python','Java',2))


"""结果如下"""
hello,Java
hello Java Java python

• 字符串比较操作

"""
运算符：> >=  <  <=   ==   !=
比较规则：首先比较两个字符串中的第一个字符，如果相等则继续往下比较，直到两个字符串中的字符串不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再继续比较

比较原理：
	两个字符进行比较，比较的是(ordinal value)原始值，调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的内置函数是chr，调用内置函数chr时指定ordinal value可以得到其对应的字符
"""

print('apple' > 'app')
print('apple' > 'banana')#False 相当于 97>98 返回False
print(ord('a'),ord('b'))


print(ord('张'))
print(chr(24352))
print(chr(97),chr(98))
"""
== 与 is 的区别
    ==比较的是 value
    is比较的是 di是否相等
"""
a=b='python'
c='python'
print(a==b)
print(b==c)
print(a is b)
print(c is b)
print(id(a))
print(id(b))
print(id(c))

"""结果如下"""
True
False
97 98
24352
张
a b
True
True
True
True
2163358525104
2163358525104
2163358525104

• 字符串合并

s=['hello','pytohn','java']
print('|'.join(s))
t=('hello','world')
print('*'.join(t))
print('*'.join('python'))

"""结果如下"""
hello|pytohn|java
hello*world
p*y*t*h*o*n

• 格式化字符串3中方法

（1）%作占位符

name='李四'
age=18
print('%s的今年%s岁'%(name,age))

（2）{}作占位符

name='李四'
age=18
print('{}的今年{}岁'.foramt(name,age))

（3）f-string

name='李四'
age=18
print(f'{name}的今年{age}岁')

宽度精度的设置

print("%d"%99)
print('%10d'%100)#10表示宽度
print('%.3f'%3.1415926)#.3表示小数点后三位
print("%10.3f"%3.1415926)#总宽度为10，小数点后有3位
print('{0:.3}'.format(3.1415926))#.3表示一共3位
print('{:.3f}'.format(3.1415926))#.3f表示3位小数
print('{:10.3f}'.format(3.14152949))#同时设置宽度和精度，一共10位，小数点后有3位

"""结果如下"""
99
       100
3.142
     3.142
3.14
3.142
     3.142

• 去除空格

a='         python     '
print(a.strip())#去除两边的空格
print(a.lstrip())#去除左边空格
print(a.rstrip())#去除右边空格
#赋值字符串
b=a
print(b)
print(id(a))#查看内存地址
print(id(b))

• 索引切片

st='hello world'
print(st[0])
print(str[::-1])#逆序输出
print(st[2:5])#从下标2开始不包含5【左闭右开】
print(st[2:])#从第三个字符到最后
print(st[0:3])#从0开始可以省略0
print(st[:3])

• 编码与解码

s = '天涯共此时'
#编码
print(s.encode(encoding='GBK'))  # GBK编码格式中，一个中文占两个字节
print(s.encode(encoding='UTF-8'))  # 在UTF-8编码格式中，一个中文占三个字节
#解码
byte=s.encode(encoding='GBK')
print(byte.decode('GBK'))

列表

• 特点：
  ‘’’
  支持增删改查
  列表中的数据是可以变化的，【数据项可以变化，内存地址不会改变】
  用[]来表示列表类型，数据项之间用逗号来分割， 注意：数据项可以说任意的数据类型
  ‘’’

list=[]#空列表
print(list)
print(len(list))#获取列表对象 中数据个数
str='lodsa'
print(len(str))

• 查找

listA=['abcd',123,456,798,True,12.255]
print(listA)
print(listA[0])#找出第一个元素
print(listA[1:3])
print(listA[3:])
print(listA[::-1])#倒叙
print(listA*3)#输出多次列表中数据【复制多次】

• 添加

print('------------------增加---------------------')
listA.append('Jay')
listA.append([1,1,2,'dfgs',{"al":12}])
print(listA)
listA.insert(1,'插入的元素')#插入操作，需要指定插入位置
# reData=list(range(10))#强制转换list对象
listA.extend([12,45,484])#扩展，批量添加
print(listA)

• 修改

print('-----------------修改--------------')
print('修改之前',listA)
listA[0]='Peter'
print('修改之后',listA)

• 删除

print('----------------------删除---------------')
del listA[0] #删除列表中第一个元素
print(listA)
del listA[1:3]#批量删除
print(listA)
listA.remove(798)#指出指定元素
print(listA)
listA.pop(0)#移除第一个元素 #根据下标来移除
print(listA)

• 列表生成式

lst=[i*i for i in range(6)]
print(lst)

元组

• 元组是不可变序列，在创建后不能做任何修改，没有增删改操作
• 用()来创建元组类型，数据项用逗号来分割
• 可以是任何类型
• 当元组中只有一个元素时，要加上逗号，不然解释器会当作本身的类型处理
• 同样支持切片操作

t=(10,[10,30,40],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
#t[1]=100报错，元祖是不允许修改元素的
"""由于[10,30,40]是列表，而列表是可变序列，所以可以向列表中添加爱元素，而列表的内存地址不变"""
t[1].append(100)#向列表中添加元素
print(t,id(t[1]))

"""结果如下"""
#(10, [10, 30, 40], 9)
#<class 'tuple'>
#10 <class 'int'> 2775649288720
#[10, 30, 40] <class 'list'> 2775650645440
#9 <class 'int'> 2775649288688
#(10, [10, 30, 40, 100], 9) 2775650645440

• 创建

"""第一种方式：使用()"""
t=('pytohn','hello',454)
print(type(t))
"""第二种方式创建使用内置函数tuple()"""
t=typle(('hello',45,'world'))

• 查找

tupleA=()#空列表
tupleA=('abcd',123,12.55,[123,45,'45hf'])
print(tupleA)
print(tupleA[2])
print(tupleA[1:3])
print(tupleA[::-1])
print(tupleA[::-2])
print(tupleA[-2:-1:])#倒着取下标， -2到-1区间的数据
print(tupleA[-4:-1])

• 对元组中的列表元素进行修改

tupleA[3][0]=250#对元组中的列表类型的数据进行修改

tupleB=tuple(range(10))
print(tupleB.count(9))

• 遍历

t=('python',20,[10,20,2])
for item in t:
	print(item)

字典

• 字典不是序列类型，没有下标的概念，是一个无序的键值集合，是内置的高级数据类型
• 不可变序列
• 字典可以存储任意对象
• 字典以键值对的形式创建的{key:value}利用大括号包裹
• 字典中某个元素时，是根据键 ，值 字典的每个元素由2部分组成：键：值
• 访问值的安全方法get()方法，在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get()方法，还可以设置默认的值
• 字典创建

"""最常用方式：使用花括号"""
socres={'张三':100,'李四':520,'王五':51}
"""使用内置函数dict()"""
dict(name='jack',age=20)

• 获取元素

如果查找的键不存在，使用dictA[]的方式会报错，

但是使用.get()的方式不会报错，会返回一个None

dictA={"pro":"艺术专业","school":'上海戏剧学院'}
print(dictA['pro'])
print(dictA.get('pro'))

• 键的判断

存在返回True

不存在返回False

dictA={"pro":"艺术专业","school":'上海戏剧学院'}
print('pro' in dictA)
print('pro' not in dictA)

• 添加，修改，获取字典数据

dictA={"pro":"艺术专业","school":'上海戏剧学院'}
dictA['name']='李易峰'
dictA['age']=29
print(dictA)
print(len(dictA))
print(dictA['name'])#通过键获取值
dictA['name']='成龙'#修改键对应的值
print(dictA)
print(dictA.keys())#获取所有的键
print(dictA.values())#获取所有的值
print(dictA.items())#获取所有的键和值
for key,value in dictA.items():
    # print(item)
    print('%s值==%s'%(key,value))

dictA.update({'age':32})#更新  存在就更新，不存在就添加
dictA.update({"height":1.78})#添加
print(dictA)

• 删除

del dictA['name']
dictA.pop('age')
print(dictA)
dictA.clear()#清空字典元素

• 内置函数zip()：
  • 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表

items = ['Fruit', 'Books', 'Others']
prices = [96, 88, 65]
lst=zip(items,prices)
print(list(lst))

• 字典生成式

items = ['Fruit', 'Books', 'Others']
prices = [96, 88, 65]
d = {item.upper(): price for item, price in zip(items, prices)}
print(d)

共有方法

#+  合并
strA='人生苦短'
strB='我用Python'
print(strA+strB)
List_A=list(range(10))
list_B=list(range(10,21))
print(List_A+list_B)
#  * 复制
print(strA*3,end=' ')
print(List_A*3)

#  in 判断对象是否存在
print('我' in strA)
print(10 in  list_B)

不可变序列与可变序列

不可变序列：字符串、元组

• 不可变序列：没有增、删、改操作，

"""不可变：元组，字符串"""
s='hello'
print(id(s))#2213691636720
s=s+'world'
print(id(s))#2213691680432

"""对象地址发生改变所以是不可变序列"""

可变序列：列表、字典

• 可变序列：可以对序列执行增、删、改操作，对象地址不发生改变

"""可变：列表，字典"""
lst=[10,20]
print(id(lst))#2250871125440
lst.append(100)
print(id(lst))#2250871125440
"""
添加元素后对象地址不变，所以是可变序列
"""

set集合

• set 不支持索引切片，是一个无序的且不重复的容器

• 类似于字典，但是只有Key,没有value

• 与列表、字典一样都属于可变类型的序列

• 创建

"""第一种方式使用{}"""
t={20,20,202,30,202,70}
print(t)#{202, 20, 70, 30},集合中的元素不允许重复

"""第二种方式set()"""
s=set(tange(6))
print(s)
s2=set([1,2,3,4,5,6,8,7])
print(s2)
s3=set((1,2,3,4,5,6,8,7)
print(s3)
s4=set('pytohn')
print(s4)

• 判断操作

"""in     not in """
s={10,20,111,220,12020,1515}
print(10 in  s)
print(7 not in s)

• 添加操作

"""add()  update()"""
s={10,20,11,22,12}
s.add(80)#一次添加一个元素
print(s)
s.update({500,800,8080})#一次至少添加一个元素
print(s)
s.update([100,200,5056])
s.update((78,99,46))
print(s)

• 删除操作

"""remove()  discard()   pop()  clear()"""
s.remove(100000)#KeyError
print(s)
s.discard(1)
s.pop()#随机删除元素,不能指定元素
s.clear()

• 两个集合是否相等

s={10,20,30,40,50}
s2={10,30,40,20,50}
print(s1 == s2)#True
print(s1 != s2)#False

• 一个集合是否是另一个集合的子集

s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,80}
print(s2.issubset(f1))#True
print(s3.issubset(s1))#False

• 一个集合是否是另一个集合的超集

print(s1.issuperset(s2))#True
print(s1.issuperset(s3))#False

• 两个集合是否含有交集

print(s2.isdisjoint(s3))#False
有交集为False

• 集合的数学操作

  • 交集

  s1={10,20,30,40}
  s2={20,30,50,40,60}
  print(s1.intersection(s2))
  print(s1 & s2)
  

  • 并集

  print(s1.union(s2))
  print(s1 | s2)
  

  • 差集

  print(s1.difference(s2))#a中有的b中没有的
  print(s1 - s2)
  

  • 对称差集

  print(s1.symmetric_difference(c2))
  print(s1 ^ s2)
  

• 集合生成式

"""将{}修改为[]就是列表生成式"""

没有元组生成式

s={i*i for i in range(6)}
print(s)

总结