python里面常用的数据类型有：数字，布尔值，字符串，元组，列表，字典，集合
数字
数字类型重点关注 整数和浮点数
整数的关键字是int
浮点数的关键字是float
注意：python中变量的使用不用声明数据类型（这点不同于java)
可以使用type()函数打印你使用的变量属于哪种数据类型。
age=18
height=1.65
print(type(age))
print(type(height))
打印结果如下：
<class 'int>
<class 'float'>
问题：什么时候用整数，什么时候用浮点数？
这个需要根据实际的业务场景来决定。
布尔值
布尔值有2个值：True和False (开头字母要大写）
布尔值用来干啥：跟条件判断/循环结合使用 判断的时候
有没有其他替代的值：
1 :非零值/非空字符串/非空列表/非空元组/非空字典------>True
0: 零值/空字符串/空列表/空元组/空字典-------->False
字符串
字符串定义：成对的单引号或者是成对的双引号，三引号括起来的字符内容。
字符串常见操作：
空字符串：s=' ' ， len(s）可以用来统计字符长度
字符串拼接：+
字符串的输出：print(),输出多个不同的数据用逗号隔开
特殊字符的处理：\n \r
代码演示1：
s1='hello'
s2="world"
#字符串拼接
print(s1+s2)
#输出多个不同的数据逗号隔开
print(s1,s2)
输出结果：
helloworld
hello world
问题：上面字符串拼接 hello和world之间有没有空格（这个待验证）
逗号隔开，hello和world之间是有空格的
特殊字符代码演示：
s1="hello ,\n语言world"
s2="人生苦短，\r我用python"
s3="hello,\t世界python"
print(s1)
print(s2)
print(s3)
打印结果如下：
hello
语言世界
我用python
hello, 世界python
上述\n，\r, \t都叫做转义字符，\n是换行，\r是回车 \t是横向制表符
将上述特殊字符变成普通字符：即将特殊字符当成普通字符原样输出，不需要转义效果
s1=r"人生苦短，\n我用python"
s2=R"人生苦短，\r我用python"
s3"人生苦短，\\t我用python"
print（s1）
print（s2）
print（s3）
打印结果如下：
人生苦短，\n我用python
人生苦短，\r我用python
人生苦短，\t我用python
三个不同引号之间的区别：
1.引号嵌套的时候，单引号只能嵌套双引号，双引号只能嵌套单引号，三引号没有区别
2.三引号括起来的内容没有赋值给变量，可以用来做注释
3.三引号可以保持字符格式，单引号需要依赖连接符\n拼接换行语句，不过打印出来是一样，没有保持字符格式
python字符串取值
字符串索引：字符串里面的每个字母都是有索引的，那么索引的顺序有2种：
正序： 从左到右索引默认从0开始，最大范围是字符串长度少一
反序：从右到左索引默认-1开始的，最大范围是字符串开头
字符串取值：根据索引取值 字符串名[索引值]
s1="python"
print(s1[5])
print(s1[-1])
打印结果：
n
n
#字符串常见操作：增删改查（放在字符串切片）
python字符串切片
切片操作（slice)可以从一个字符串中获取子字符串（即字符串的一部分），我们使用一对方括号，起始偏移量start,终止偏移量end 以及可选的步长step来定义一个分片。
格式：[start:end:step]
start:取值开始的索引值
end:取值结束的索引值
step:取值之间的间隔，如果不写step,默认值是1
特点：取头不取尾
s="hello world python"
#需求：取出world
print(s[6:11:1])#开始索引6,所以间隔步长是1.结束位置是11（取头不取尾）
打印结果：
world
切片常规操作如下：
(1)[:] 提取从开头（默认位置0）到结尾（默认位置-1）的整个字符串
(2)[start:] 从atart提取到结尾
(3)[:end] 从开头提取到end-1
(4)[start:end] 从start 提起到end-1
练习：
s="hello python world"
1.取出所有偶数位的字母： s[0:17:2]
2.取出所有奇数位的字母:s[1:18:2]
3.倒序输出所有的字母:s[-1::-1] 或者s[17::-1]
4.获取world这个单词:s[-5:] 或者s[13:18]
python字符串的格式化输出
知识回顾：
#输出一个字符串
print(‘hello world")
#输出多个字符串,逗号隔开
print("hello","world")
#字符串拼接（+）
print("hello"+"world")
打印结果如下：
hello world
hello world
helloworld
字符串的格式化输出-----%d %s %f
%d 数字
%s 字符串
%f 浮点数
占坑：%（）
print('''xx的个人信息:
address:%s
sex:%s
age:%d
salery:%f'''%("上海市","maile",18,8900.98))
打印结果如下：
xx的个人信息：
address:上海市
sex:maile
age:18
salary:8900.98
总结：%s这个坑位可以放任意数据 %d和%f只能反放数字（注意：给%d坑位传入带小数的数字，会舍弃小数位）
字符串的格式化输出---format
占坑：{} 字符串.format()
#不给定索引
print('''xx的个人信息:
address:{}
sex:{}
age:{}
salery:{}'''.format("上海市","maile",18,8900.98))
#给定索引
print('''xx的个人信息:
address:{0}
sex:{1}
age:{2}
salery:{3}'''.format("上海市","maile",18,8900.98))
上面打印结果都是：
xx的个人信息：
address:上海市
sex:maile
age:18
salary:8900.98
总结：
- {} 要和传入数据的个数要一致，如果不一致，{}要比传入的数要少
- .format()里面的值是有索引的，也是从0开始，我们可以在{}指定取值的索引
3.{}不能有的给索引取值，有的不给索引---》要么都通过索引取值要么都不通过索引取值
字符串的常用方法
（1）find()函数： 查找子字符串。返回-1表示未找到子字符串，如果找到了就返回首个字母所在索引值。（注意：子字符串可以是单个字符，也可以是多个字符）
s="leran python hello world"
#返回找到字符串的索引值
print(s.find('n')#结果是4
#返回找到字符串首个字母的索引值
print(s.find("python")#结果是6
#如果没有找到就返回-1
print(s.find("k")#结果是-1
#指定位置寻找字符
print(s.find('o',11)#结果是-1（待验证是从11开始找，还是只找11这个位置）
（2）isdigit()函数：如果是纯数字，就返回True,否则返回False
s="hello"
#判断字符串 111是不是纯数字
print('111'.isdigit())#True
#判断s字符串是不是纯数字
print(s.isdigit())#False
(4)replace(）函数：指定替换内容以及被替换内容，并且可以指定替换次数（默认全部替换，按顺位替换）【注意：替换后会生成一个新的字符串，可以用一个变量接收】
s="learn python hello world"
s[0]='k'
print(s[0])#执行时会报错：TypeErroe:'str' object does not support item assignment 不能根据索引重新指派
#将s字符串中的n替换成k（默认全部替换）
new_s1=s.replace('n','k')#会生成一个新的字符串
print)new_s1)#输出结果：leark pythok hellk wkrld
#指定替换次数(按顺位一次替换）
new_s2=new_s1('k','n',2)
print(new_s2)#输出结果：learn python hellk wkrld
(5)split()函数：根据指定字符对字符串进行切割，还可以指定切割的次数，默认是全部切割
s="learn python hello world"
#按空格切割,返回的是一个列表，列表中的每个元素都是字符串
print(s.split(' '))#输出结果：['lean','python','hello','world']
#指定切割字数(切割两次）
print(s.split(' ',2)#输出结果是：['learn','python','hello world']
#根据l切割
print(s.split('l'))#输出结果是：['','earn python','he','o','w','rld']
问题：为什么根据L切割，返回的列表，第一个是空字符
（6）strip()函数：去掉头和尾指定的字符，会生成一个新的字符串，可用变量接收
s='***learn python\n***'
#将头部和尾部的*都去掉
s1=s.strip('*')
print(s1)#learn python\n
#将头部尾部的\n都去掉
s2=s1.strip('\n')
print(s2)#learn python
（7）upper():将字符串字母全部转成大写
lower():将字符串中的字母全部转成小写
s='learn python'
print(s.upper().lower())#先大小，再小写，最后输出：learn python
(8)swapcase()函数：字符串的字母大小写互换（即：大写变小写，小写变大写）
s='LearN pYthon'
print(s.swapcase())# 输出结果：lEARn PyTHON
数据类型之元组
元组：关键字tuple()。
元组可以完成大多数集合类的数据结构实现。它支持数字，字符，字符串甚至可以包含元组（即嵌套）。
元组的一些特性：
（1）空元组
t=()
print(type(t))
print(len(t))
打印结果：
<class 'tuple'>
0
(2)元组只有一个元素，需要加逗号(否则被当成整型）
t=（1）
print(type(t))
t2=（1，）
print(type(t2))
打印结果：
<class 'int'>
<class 'tuple'>
（3）元组里面的数据用逗号隔开，数据可以是任意类型
t=(1,0.02,True,'hello',(1,2,3,'python'))#整型，浮点型，布尔值，字符春，元组
print(type(t))
print(len(t))#长度等于元素个数
打印结果：
<class 'tuple'>
5
（4）元组有序不可变
有序：说明有索引
不可变：元组一旦确定，那么值就不能做更改（即增删改都不行，只能查）
t=(1,0.02,True,'hello',(1,2,3,'python'))
#取出元素1
print(t[0])
#取出元素 1，2，3，python
print（t[-1])
#取出python中的y
print(t[-1][-1][1]
(5)元组切片：同字符串切片
方法：元组名[start:end:step]
t=(1,0.02,True,'hello',(1,2,3,'python'))
#取值是偶数位的元素即（索引值是偶数）
print(t[0::2]#返回的还是元组（True,(1,2,3,'python'))
#倒序输出
print(t[::-1])#((1,2,3,'python'),'hello','True',0.02,1))
（6）常用方法：
index(x):获取x元素的索引值。
count(x):统计元素出现的个数
t=(1,0.02,True,'hello',(1,2,3,'python'))
print(t.index(0.02))#结果是：1
print(t.count(1))#结果是：2（因为：True的值也是1，所以统计1的元素就是2个）
python数据类型之列表
列表：关键字list[]。
列表可以完成大多数集合类的数据结构实现。它支持数字，字符，字符串甚至可以包含列表（即嵌套）。是使用最频繁的数据类型
列表的一些特性：
（1）空列表
t=[]
print(type(t))
print(len(t))
打印结果：
<class 'list'>
0
(2)列表可以只有一个元素
t=[1]
print(type(t))
打印结果：
<class 'list'>
（3）列表里面的数据用逗号隔开，数据可以是任意类型
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,'world']]#整型，浮点型，布尔值，字符春，元组,列表
print(type(t))
print(len(t))#长度等于元素个数
打印结果：
<class 'list'>
6
（4）列表有序可变
有序：说明有索引
可变：值可以做更改（即增删改查都行）
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,'world']]
#取出元素1
print(t[0])
#取出元素 1，2，3，python
print（t[-2])
#取出python中的y（嵌套取值：根据索引一层一层去定位）
print(t[-2][-1][1])
(5)列表切片：同字符串切片
方法：列表名[start:end:step]
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,'world']]
#取值是偶数位的元素即（索引值是偶数）
print(t[0::2]#返回的还是列表[True,(1,2,3,'python')]
#倒序输出
print(t[::-1])#[[4,5,'world']，(1,2,3,'python'),'hello','True',0.02,1)]
总结：
区别：
1.元组不可变，列表可变
2.元组只有一个元素需要加逗号，列表不需要
3.元组关键字是tuple(),列表关键字list[]
相同：
1.有序有索引
2.都可以通过索引取值
3.切片方法都同字符串
python列表之常用方法：增删改查
增
1.append（)函数：
追加元素，默认在列表的末尾追加，每次只能添加一个元素
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
#列表末尾追加元素
t.append('java')
print（t)
打印结果：
[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']],'java']
2.insert()函数：
列表中插入元素（插入到索引指定位置，原索引位置的元素顺位向后移动）
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
t.insert(1,'java')#插入到索引指定位置
print(t)
打印结果：
[1,'java',0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
3.extend()函数：拓展列表即合并列表
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
t.extend([1,2,3,4])#t和列表[1,2,3,4]合并成一个列表
print(t)
打印结果：
[1,'java',0.02,True,'hello',(1,2,3,'python'),[4,5,['world']],1,2,3,4]
4.两个列表相加即合并
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
s-[1,2,3]
t=t+s
print(t)
打印结果：
[1,'java',0.02,True,'hello',(1,2,3,'python'),[4,5,['world']],1,2,3]
练习题：
添加php这个元素到world这个字符串所在的列表里面
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
t[-1][-1].append('php')
print(t)
打印结果：
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world','php']]]
删
1.pop()函数：可在括号里指定要删除元素的索引值
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
t.pop()#默认删除最后一个元素
print(t)
打印结果：
[1,0.02,True,'hello',(1,2,3,'python')]
t.pop(0)#指定删除索引值为0的元素
打印结果：
[0.02,True,'hello',(1,2,3,'python')]
2.clear():清空列表
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
t.clear()
print(t)
打印结果：
[]
改
赋值方法修改
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
t[0]='java'
print(t)
打印结果：
['java',0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
查
根据索引值取值以及切片（参考字符串切片）
其他用法
1.index():括号里填写元素获取元素的所以值
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
print(t.index('hello'))#获取元素hello在列表中的位置
打印结果：
3
print(t.index('python'))#ValueRrror:'python' is not in list，因为是元组，所以会报错
2.count()：括号里填写元素，统计列表中此元素的个数
t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,['world']]]
print(t.count(0.02)#统计列表中该元素的个数
打印结果：
1
python数据类型之字典
关键字：dict 。除列表以外python之中最灵活的内置数据结构类型。字典是无序的对象集合。
特点：
1.字典用{}标识
2.key:value的形式存储数据 ，键值对
3.key:是唯一的且不可变的数据（int,float,tuple boolean)
4.value: 任何数据类型都支持
5.无序可变
1.空字典
d={}
print(type(d))
打印结果：
<class 'dict'>
2.定义一个字典：{key:value}
(key:只支持int,float,tuple boolean，str,不支持list)
d={ 1:'整数’,
0.02:'浮点数',
True:'布尔值',
'result':'字符串',
(1,3):'tuple',
'LIST':[1,2,3]
}
print(d)
打印结果:
{ 0.02:'浮点数', 1:'布尔值', 'result':'字符串', (1,3):'tuple', 'LIST':[1,2,3]}
key不支持list,否则会报错
d={ 1:'整数’,
0.02:'浮点数',
True:'布尔值',
'result':'字符串',
(1,3):'tuple',
[1,2]:'test'
}
print(d)
打印结果如下：
TypeRrror:unhashable type :'list'
3.无序:
无序意味着没有索引
d={ 1:'整数’,
0.02:'浮点数',
True:'布尔值',
'result':'字符串',
(1,3):'tuple',
[1,2]:'test'
}
print(d)
打印结果：
每次打印出来的顺序是不一样的
4.取值：根据key取值->字典名[key]
d={ 1:'整数’,
0.02:'浮点数',
True:'布尔值',
'result':'字符串',
(1,3):'tuple',
'LIST':[1,2,3]
}
#取出[1,2,3]列表中3这个元素
print(d['LIST'][-1])
打印结果：
3
5.key必须是唯一的，不能重复
key重复，后面的值会后面覆盖前面的值
d={ 1:'整数’,
0.02:'浮点数',
True:'布尔值',
'result':'字符串',
(1,3):'tuple',
[1,2]:'test'
}
print(d)
打印结果：
{ 0.02:'浮点数', 1:'布尔值', 'result':'字符串', (1,3):'tuple', [1,2]:'test'}
问题：
上述打印结果：key=1的value为什么是result,因为True的也是1，等于key重复，，所以后面的value会覆盖前面的value
问题：什么时候需要用到字典
1.值要成对的存储的时候，如：
{'张三':'90分’，'里斯':'99分')
字典之常用方法
字典无序，所以不能根据索引查，以及切片都是不适应的
查：根据key来查询
字典嵌套字典
字典嵌套元组
字典嵌套列表
d={'class':'java',
'teacher':['java1','java2','java3','java4','java5'],
'student':['A':'张三','B':'李四','C':'王五']'
'score':(88.89.100)
}
#取出学生：张三。根据key一层一层去定位
print(d['student']['A']
#取出老师：java5
print(d['teacher'][-1])
#取出分数：89
print(d['score'][-2])
