python中数字有些加双引号有些没加_2021-01-05python的数据类型

python里面常用的数据类型有：数字，布尔值，字符串，元组，列表，字典，集合

数字

数字类型重点关注 整数和浮点数

整数的关键字是int

浮点数的关键字是float

注意：python中变量的使用不用声明数据类型(这点不同于java)

可以使用type()函数打印你使用的变量属于哪种数据类型。

age=18

height=1.65

print(type(age))

print(type(height))

打印结果如下：

问题：什么时候用整数，什么时候用浮点数？

这个需要根据实际的业务场景来决定。

布尔值

布尔值有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))

打印结果：

0

(2)元组只有一个元素，需要加逗号(否则被当成整型)

t=(1)

print(type(t))

t2=(1，)

print(type(t2))

打印结果：

(3)元组里面的数据用逗号隔开，数据可以是任意类型

t=(1,0.02,True,'hello',(1,2,3,'python'))#整型，浮点型，布尔值，字符春，元组

print(type(t))

print(len(t))#长度等于元素个数

打印结果：

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))

打印结果：

0

(2)列表可以只有一个元素

t=[1]

print(type(t))

打印结果：

(3)列表里面的数据用逗号隔开，数据可以是任意类型

t=[1,0.02,True,'hello',(1,2,3,'python'),[4,5,'world']]#整型，浮点型，布尔值，字符春，元组,列表

print(type(t))

print(len(t))#长度等于元素个数

打印结果：

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之列表常用方法