88是python语言的整数类型_1.python数据类型详解

python数据类型分类

1).数值型：整数型(int)、浮点型(float)、布尔型(bool 取值：True、False)

2).容器类型

: 字符串型(str)、列表(list)、元祖(tuple)、字典(dict)、集合(set)

3).自定义类型：Person、Animal、Dog、Cat、Student...

4).NoneType：None (理解：不存在、未明确的、未知的)

一. 字符串类型(str)

特点：属于容器类型之一，满足有序的(有索引)、可重复的、不可变的数据类型（不可变：指字符串中某个位置的元素不允许改变，但是可以将整个字符串变量中的地址进行改变(意味着将字符串完全覆盖掉)）

1.自定义打印效果的显示

使用：""" ... """ 或者 ''' ... ''' 来定义字符串数据，对于有些情况下，需要对定义的字符数据进行显示样式的把控，可以使用如下的方式定义字符串数据，可以做到换行的效果

1 content = """遥想公瑾当年，小乔出嫁了!2 雄姿英发，羽扇纶巾，3 谈笑间，樯橹灰飞烟灭"""

4 content1 = '''遥想公瑾当年，小乔出嫁了!5 雄姿英发，羽扇纶巾，6 谈笑间，樯橹灰飞烟灭'''

7 print(content)8 print(content1)

2.转义字符

转义字符：将字符原本的含义去除，赋予一个新的含义

常见的转义字符如下：

\n： 换行符

\t： 制表符

\b： 退格

\”： 双引号

\'： 单引号

如果字符串描述的是一串物理地址，在其中可能会包含一些转义字符，那么对于我们路径的解析会造成错误，所以我们需要在字符串第一个引号的前面显示的追加一个r，目的：就是为了避免转义

1 address = "d:\\basic\\tpython1809\\day02\\note.txt"

2 address = r"d:\basic\tpython1809\day02\note.txt"

3 print(address)

3.字符串的*和+操作

字符串数据和字符串数据之间可以做拼接操作，使用+号来实现

字符串数据和整数之间使用*号连接，作用：让字符串数据重复执行多次

4.字符串的索引

起始索引：0

结束索引：-1 /

length - 1

5.内置函数len()的作用

例如：len(obj)

--> 得到容器对象obj的长度/尺寸/容量

6.如何访问字符串元素

1).获取元素：

通过变量名配合下标来实现

2).设置元素：

由于字符串属于不可变的数据类型，所以没有设置元素这一说

7.常见的运行时异常：IndexError

以下代码有问题：由于str1的长度为10，所以它的最大索引为9，

导致代码出现IndexError类型的异常，原因是下标越界了，这种情况是需要避免的

8.字符串的切片操作

目的：从原串中得到部分子串数据，最终原串不会发生改变

格式：字符串变量[[start]:[end]:[step]]

【注意】：内部的中括号表示可选的意思

参数解释：start：起始位置;end：结束位置;step：步长(默认为1),满足含头不含尾的特点(99%的情况) [start,end)

9.占位符

在定义字符串数据时，可能在某些位置并不清楚需要填入什么内容，那么就先将位置占了，等到之后确定了数据再填入进去

1).百分号原则：

符号：

%d：整数占位符

%f：小数占位符

%s：万能占位符

2).大括号原则：

需要配合str类中的format()来使用得到效果

1 name = "jerry"

2 age = 18

3 height = 185.5

4

5 print("姓名：%s，年龄：%d，身高：%.1fcm" %("韩梅梅",21,163.5))6 print("姓名：%s，年龄：%010d，身高：%010.1fcm" %(name,age,height))7

8 print("最喜欢的歌手：{}，最喜欢看的电影：{}，最喜欢玩的游戏：{}，最喜欢的编程语言：{}".format("张学友","海王","魔兽世界","python"))9 print("最喜欢的歌手：{3}，最喜欢看的电影：{1}，最喜欢玩的游戏：{2}，最喜欢的编程语言：{0}".format("java","蜘蛛侠","LOL","周杰伦"))10 print("最喜欢的老师：{teacher}，最喜欢看的电影：{film}，最喜欢玩的游戏：{game}，最喜欢的编程语言：{language}".format(language="js",11 teacher="微微姐",film="小电影",game="超级玛丽"))

10.字符串中常用的函数

1). ‘sep‘.join(seq)：sep分隔符，可以为空；seq连接的元素序列、字符串、元组、字典

【补充】os.path.join()： 将多个路径组合后返回

2). ljust(width,format)：将str数据显示在左侧，如果长度/尺寸不满width，那么右侧补format

3). rjust(width,format)：将str数据显示在右侧，如果长度/尺寸不满width，那么左侧补format

4). center(width,format)：将str数据显示在中间，如果长度/尺寸不满width，那么左右侧补format

5). zfill(width)：将str数据显示在右侧，如果长度/尺寸不满width，那么左侧补0

6). strip()： 去除字符串左、右两侧匹配到的字符数据，返回一个新串

7). lstrip()：去除字符串左侧匹配到的字符数据，返回一个新串

8). rstrip()：去除字符串右侧匹配到的字符数据，返回一个新串

9). replace(old,new,[number])：将str中的old内容替换为new，默认全部替换；也可以选择性的替换number次

10). split(format)：将str以format格式进行切割，返回一个列表对象；默认空参数的split()可以切割的内容：' '、\n、\t

11). index(s)：返回字符串s在原串中对应的下标/索引，若存在多个相同数据,返回第一个匹配成功的，如果都没有匹配成功，会报错

12). count(s)：返回字符串s在原串中出现的次数，如果一次都没有出现，不会报错，返回0

13). find(format)：查找字符串中首次出现的format的位置

14). rfind(format)：查找字符串中最后一次出现的format的位置

15). upper()：将字符串数据变为全大写

16).lower()：将字符串数据变为全小写

17).capitalize()：将字符串数据首字母大写，其余字母小写

18). title()：将字符串数据首字母大写，其余字母小写 备注：如果存在多个单词，每个单词首字母都要考虑

19). swapcase()：将字符串中大写变为小写，小写变为大写

20). startswith(format)：判断字符串是否以format开头，函数结果是布尔值

21). endswith()：判断字符串是否以format结尾，函数结果是布尔值

22). isalnum()：判断字符串的内容是否都是英文、数字字符；如果是，返回True；反之，返回False

23). isalpha()：判断字符串的内容是否都是英文字符；如果是，返回True；反之，返回False

24). isdecimal()：判断字符串的内容是否都是数字字符；如果是，返回True；反之，返回False

25). isdigit()：判断字符串的内容是否都是数字字符；如果是，返回True；反之，返回False

26). islower()：判断字符串中英文字符是否全小写；如果是，返回True；反之，返回False 【注意】数字、其它字符不影响

27). isupper()：判断字符串中英文字符是否全大写；如果是，返回True；反之，返回False 【注意】数字、其它字符不影响

28). istitle()：判断字符串内容中的英文子串(多组)的首字母是否大写

1 lt = ['i','love','you','very','much']2 print('-'.join(lt))3 print(str.join('#',lt))4

5 str1 = 'i love you very much'

6 print(str1.ljust(50,'*')) #i love you very much******************************

7 print(str1.rjust(50,'-')) #------------------------------i love you very much

8 print(str.rjust(str1,50,'$')) #$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$i love you very much

9 print(str1.center(50,'^')) #^^^^^^^^^^^^^^^i love you very much^^^^^^^^^^^^^^^

10 print(str1.zfill(50)) #000000000000000000000000000000i love you very much

11

12 str1 = ',,,..\ i hate you very much ...,,;;\'

13 print(str1.lstrip('\ ,.')) #i hate you very much ...,,;;\

14 print(str1.rstrip('\;.,')) #,,,..\ i hate you very much

15 print(str1.strip(',\;.')) #i hate you very much

16

17 str1 = "python啊python，你是我的骄傲！python啊python，我为你自豪！"

18 print(str1.replace('python','java')) #java啊java，你是我的骄傲！java啊java，我为你自豪！

19 print(str1.replace('python','java',2)) #java啊java，你是我的骄傲！python啊python，我为你自豪！

20

21 str1 = 'i love\nabc you\t very\n much'

22 print(str1.split(' ')) #['i', 'love\nabc', 'you\t', 'very\n', 'much']

23 print(str1.split()) #['i', 'love', 'abc', 'you', 'very', 'much']

24 print(str1.split('\n')) #['i love', 'abc you\t very', ' much']

25 print(str1.splitlines()) #['i love', 'abc you\t very', ' much']

26

27 str1 = 'abcdefgd1234567'

28 print(str1.index('d')) #3

29 print(str1.index('efg')) #4

30 print(str1.index('xyz')) #报错

31

32 str1 = 'dsaalkfaaasdfaaaa2141aaaaaaxyz'

33 print(str1.count('a')) #15

34 print(str1.count('aa')) #7

35 print(str1.count('www')) #0

36

37 str1 = '山不在在高，有仙则灵；水不在在深，有龙则灵；斯是在在陋室，惟吾德馨'

38 print(str1.find('在在')) #2

39 print(str1.rfind('在在')) #24

40

41 str1 = 'today is thursday PM'

42 print(str1.upper()) #TODAY IS THURSDAY PM

43 print(str1.lower()) #today is thursday pm

44 print(str1.capitalize()) #Today is thursday pm

45 print(str1.title()) #Today Is Thursday Pm

46 print(str1.swapcase()) #TODAY IS THURSDAY pm

47

48 str1 = 'hahaha abcdefghijk 32141234 hehehe'

49 print(str1.startswith('h')) #True

50 print(str1.startswith('ha')) #True

51 print(str1.startswith('haha')) #True

52 print(str1.startswith('Haha')) #False

53 print(str1.startswith('hahha')) #False

54

55 print(str1.endswith('e')) #True

56 print(str1.endswith('he')) #True

57 print(str1.endswith('ehe')) #True

58 print(str1.endswith('Hehe')) #False

59

60 str1 = '3214Love&Tdsajflks*^'

61 print(str1.isalnum()) #False

62 print(str1.isalpha()) #False

63 print(str1.isdigit()) #False

64 print(str1.isdecimal()) #False

65 print(str1.islower()) #False

66 print(str1.isupper()) #False

67 print(str1.istitle()) #Ture

二. 列表类型(list)

特点：有序的(有索引、定义和显示的顺序是一致的)、可变的(既可以改变元素的内容也可以自动(扩缩)容)、可重复的、可以存储任何数据类型的元素

1.如何访问列表中的元素

1).获取元素

列表名配合下标获取 --> 例如：lt[0],lt[-1]

2).设置元素(和str有区别)

列表名配合下标 = ... --> 例如：lt[4] = "武大郎"

2.列表的+和*操作

对于+操作而言：将两个列表对象中的元素都组合起来以一个新的列表返回

对于*操作而言：将列表中的元素重复出现n次，以新的列表返回

3.和列表有关的一些函数

append(obj)：将obj元素追加到列表的末尾

clear()：清空列表，元素没了，列表对象还在 : lt.clear()

4.del关键字配合列表对象/元素使用

目的：回收列表对象，并且回收其中的元素内容(即可以回收列表对象，也可以回收列表元素)：del ltdel可以删除列表中指定位置的元素：del lt[1]

5.列表的切片操作

格式和特点和str一模一样...

1 lt6 = ['葫芦娃','黑猫警长','熊出没','灌篮高手','柯南','海尔兄弟']2 lt7 = lt6[1:5]3 print(lt7,type(lt7))4 print(lt6,type(lt6))5 print(lt6[2:-2])6 print(lt6[:])7 print(lt6[::-1])

6.归纳总结列表的定义格式

格式一：列表名 = [值1,值2,...,值n]

格式二：列表名 = [变量1,变量2,...,变量n] = [值1,值2,...,值n]

格式三：列表名 = []

7. list中常用的函数

1). append(obj)：将obj存入到列表的最后一个位置

2). extend(iterable)：将iterable对象中的每个元素分别取出存入到列表的最后位置

3).index(obj)：返回obj在列表中出现的索引位置；如果存在多个相同的obj元素，返回的是第一次出现的那个元素的索引；如果一个有没有，直接报错

4). count(obj)：返回obj在列表中出现的次数；如果一次都没有出现，返回0

5). pop([index])：如果是空参数的pop()，将列表最后一个元素弹出(作为返回值给程序)；如果有参数，必须是索引值，将具体索引位置上的元素弹出

6). remove(element)：删除和element匹配的某个元素，没有返回值；如果有多个匹配的，只删除第一个

7). reverse()：反转列表元素

8). sort([reverse=True],[key=...])：默认以升序排列(reverse=False)，如果想要降序排列，显示定义reverse=True

1 lt = ['路飞','索罗','山治','娜美','乌索普','乔巴','布鲁克']2 lt.append('香克斯')3 print(lt) #['路飞','索罗','山治','娜美','乌索普','乔巴','布鲁克','香克斯']

4 lt.append(['卡卡西','鸣人','佐助','樱'])5 print(lt) #['路飞','索罗','山治','娜美','乌索普','乔巴','布鲁克','香克斯',['卡卡西','鸣人','佐助','樱']]

6

7 lt = ['路飞','索罗','山治','娜美']8 lt.extend(['卡卡西','鸣人','佐助','樱']) #['路飞', '索罗', '山治', '娜美','卡卡西', '鸣人', '佐助', '樱']

9 lt.extend('大蛇丸')10 print(lt) #['路飞', '索罗', '山治', '娜美', '卡卡西', '鸣人', '佐助', '樱', '大', '蛇', '丸']

11 lt.extend(200) #TypeError: 'int' object is not iterable

12

13 lt = ['路飞','索罗','山治','娜美','乌索普','乔巴','布鲁克','娜美']14 print(lt.index('娜美')) #3

15 #print(lt.index('娜美1')) # 报错ValueError

16

17 print(lt.count('路飞')) #1

18 print(lt.count('娜美')) #2

19 print(lt.count('娜美1')) #0

20

21 print(lt.pop()) #娜美

22 print(lt) #['路飞','索罗','山治','娜美','乌索普','乔巴','布鲁克']

23 print(lt.pop(1)) #索罗

24 print(lt) #['路飞', '山治', '娜美', '乌索普', '乔巴', '布鲁克']

25# lt.pop('乔巴')# 报错 非法操作

26

27 lt = ['路飞','索罗','山治','娜美','乌索普','乔巴','布鲁克','娜美']28 print(lt.remove('山治')) #None

29 print(lt) #['路飞','索罗','娜美','乌索普','乔巴','布鲁克','娜美']

30 lt.remove('娜美')31 print(lt) #['路飞','索罗','乌索普','乔巴','布鲁克','娜美']

32

33 print(lt.clear()) #None

34 print(lt) #[]

35

36 lt = ['路飞','索罗','山治','娜美','乌索普','乔巴','布鲁克','娜美']37 lt.reverse()38 print(lt) #得到['娜美','布鲁克','乔巴','乌索普','娜美','山治','索罗','路飞']

39

40 lt1 = [53,23,-17,9,-21,0,79,88,-30]41 lt1.sort()42 print(lt1) #[-30, -21, -17, 0, 9, 23, 53, 79, 88]

43 lt1.sort(reverse=True)44 print(lt1) #[88, 79, 53, 23, 9, 0, -17, -21, -30]

三. 元祖类型(tuple)

特点：有序的(有索引、定义和显示的顺序是一致的)、不可变的(和str一样理解)、可重复的、可以存储任何数据类型的元素

1.如何访问元祖中的元素

1).获取元素

元祖名配合下标获取 -->

例如：tp[0],tp[-1]

2).设置元素(和str保持一致)

没有此操作，是非法的，原因元祖是不可变的数据类型

2.元祖的+和*操作

对于+操作而言：将两个元祖对象中的元素都组合起来以一个新的元祖返回

对于*操作而言：将元祖中的元素重复出现n次，以新的元祖返回

【注意事项】元祖有没有类似于列表的append或者clear函数,因为append和clear这类函数改变的都是容器对象内部的元素内容，这和不可变所冲突

3.del关键字配合元祖对象使用

目的：回收整个元祖对象，但是对于tuple类型而言无法回收其任何一个元素

4.元祖的切片操作

格式和特点和str一模一样...

5.归纳总结元祖的定义格式

格式一：元祖名 = (值1,值2,...,值n)

格式二：元祖名 = (变量1,变量2,...,变量n) = (值1,值2,...,值n)

格式三：元祖名 = ()

格式四：元祖名 = (值1,) 【注意】：定义元祖并且只有一个元素，必须在元素后显示的加上一个逗号

四. 字典类型(dict)

特点：无序性(没有索引，通过键找值)、可变的数据类型(值可变、键不可变)；字典的结构是键值对组合 --> key-value对象；键(key)：唯一性(不可重复)、不可变的数据类型(例如：list就不能作为键);值(value)：没有任何要求，可以是任何类型的数据，甚至可以重复

1.如何访问字典元素

1).获取值:字典名配合键名可以得到对应的值

1 dic1 = {"name":"韩梅梅","age":23,"height":165.0}2 dic1['name'] #韩梅梅

2).设置值:字典名配合键名 = ...

【注意事项】1.在定义字典对象的时候如果出现了重复的键，保留键名的同时，将后者的值覆盖前面的值。2.在添加新的键值对的过程中，如果原字典对象中没有此键，那么就将其键值对一并加入进去，称为一个元素。

1 dic2 = {"name":"韩梅梅","age":23,"height":165.0,"name":"李雷"}2 dic2['weight'] = 120

3 print(dic2)

2.字典相关函数

clear()：清空字典元素，保留空字典对象，dic2.clear( )

3.和关键字del配合使用

目的：回收键值对组合，或者整个字典对象；deldic2['age'] # 删除年龄键值对；deldic2 # 删除所有(数据和整个字典结构)

4.通过键查找值的情况

方式一：字典名[键名] 如果键不存在，报错；出现KeyError类型的异常；dic2["name1"]

方式二：字典名.get(键名) 如果键不存在，不会报错，会返回给程序一个None值；此方式比较安全/友好(更加好用)；dic2.get("name1")

【注意事项】键：必须满足不可变的数据类型；枚举：int、float、bool、str、None等都可以充当键，满足唯一性（不可重复）；值：没有要求，任何类型都可以,甚至可重复。

5.dict中常用的函数

1). dic1.update(dic2)：将dic2中每一个键值对和dic1中的进行比较，如果dic1中经过存在相同的 键，那么就保证键不变，值被覆盖；如果dic1中没有相应的键值对，那么就将其加入进dic1中

items()：返回一个dict_items类型的对象，内部封装了一个一个元祖充当其元素，元祖中包含键和值两块内容

keys()：返回一个dict_keys类型的对象，内部封装了键集

values()：返回一个dict_values类型的对象，内部封装了值集

popitem()：弹出最后一个键值对，以元祖的形式返回

pop(key)：传入key时，弹出整个键值对，最终返回给程序value

copy():拷贝 ；dict1.copy（）

1 dic1 = {"name":"张三丰","age":120,"height":168.0}2 dic2 = {"name":"金毛狮","weight":100,"faceValue":False,"girlFriend":"灭绝师太"}3 dic1.update(dic2)4 print(dic1) #得到{'name': '金毛狮王', 'age': 120, 'height': 168.0, 'weight': 100, 'faceValue': False, 'girlFriend': '灭绝师太'}

5 print(dic2) #得到{'name': '金毛狮王', 'weight': 100, 'faceValue': False, 'girlFriend': '灭绝师太'}

6

7 dic1 = {"name":"张三丰","age":120,"height":168.0}8 print(dic1.items(),type(dic1.items())) #得到dict_items([('name', '张三丰'), ('age', 120), ('height', 168.0)])

9 print(dic1.keys(),type(dic1.keys())) #得到dict_keys(['name', 'age', 'height'])

10 print(dic1.values(),type(dic1.values())) #得到dict_values(['张三丰', 120, 168.0])

11

12 dic2 = {"name":"金毛狮","weight":100,"faceValue":False,"girlFriend":"灭绝师太"}13 print(dic2.popitem()) #('girlFriend', '灭绝师太')

14 print(dic2) #{'name': '金毛狮王', 'weight': 100, 'faceValue': False}

15 print(dic2.pop('weight')) #100

16 print(dic2) #{'name': '金毛狮王', 'faceValue': False}

17

18 dic3 = dic2.copy() #id改变

19 print(dic2,id(dic2)) #得到{'name': '金毛狮王', 'weight': 100, 'faceValue': False, 'girlFriend': '灭绝师太'} 5999280

20 print(dic3,id(dic3)) #得到{'name': '金毛狮王', 'weight': 100, 'faceValue': False, 'girlFriend': '灭绝师太'} 5999352

五. 集合类型(set)

特点：无序性(没有索引，每一次显示的效果都不一样)、唯一性(不可重复)、可变的、只能存放不可变的数据。使用场景：在实际开发过程中，经常用于对数据进行去重(过滤)

1.集合的一些常用操作如下

以下的操作都是在两个集合对象中使用

符号：

&：取交集

|：取并集

-：取差集（对于取差集的操作，需要关注的是谁在-号的前面(左侧)，返回的就是谁独有的数据）

^：先取并集再舍弃交集部分

【注意事项】对于集合和集合之间没有+操作。会出现TypeError类型的错误

2.集合相关的函数

clear()：清空集合，保留外壳

3.和关键字del配合使用

目的：回收集合元素，或者回收整个集合对象

1 s1 = {"貂蝉","西施","王昭君","玉环"}2 s1.clear()3 print(s1) #set()

4 dels15 print(s1) #直接全删了,什么都不剩,所以报错NameError:name's1'is not defined

思考：删除"貂蝉"这个数据，该怎么做到？

1).可以使用remove(obj)函数来实现；2).先将集合转换为列表 --> 使用转换函数list() , 再使用循环的思想，来处理列表对象，一旦匹配上了"貂蝉"，就可以使用del关键字进行数据删除的行为

1 #方法1

2 s1.remove("貂蝉")3

4 #方法2

5 lt = list(s1) #将集合转换为列表

6 i =07 while i

12 print(lt)

4.定义一个空集合

s1 = set( )

5. set中常用的函数

1). add(e)：添加一个元素e(不可变的数据类型)到集合中

2). pop()： 只能是空参的(集合没有索引的概念)，随机从集合中弹出一个元素

3). remove(e)：从集合中删除和e匹配的元素

4).clear()：清空集合，保留容器

5).copy()： 拷贝

6).issubset(s)：判断一个集合是否是另一个集合的子集；s1.issubset(s2) >>> s1是否是s2的子集

7). issuperset(s)：判断一个集合是否是另一个集合的父集；s1.issubset(s2) >>> s1是否是s2的父集

8). isdisjoint(s)：判断两个集合之间是否存在交集，如果存在，返回False；反之，返回True

1 s1 = {10,100,3.14,"abcd"}2 s2 = {3.141,100}3 s1.add('hello')4 print(s1.pop())5 s1.remove(100)6 s1.clear()7 print(s1) #set()

8 print(s1.issubset(s2)) #False

9 print(s1.issuperset(s2)) #True

10 print(s1.isdisjoint(s2)) #False

11 print(s2.isdisjoint(s1)) #False