第二章 数据类型
2.1 数据类型分类
-
可变数据（3 个）：list（列表）、dict（字典）、set（集合）
-
不可变数据（4 个）：bool 布尔类型、int（整型）、str（字符串）、tuple（元组）
-
可变数据类型：value 值改变，内存地址不变
-
不可变数据类型：value 值改变，内存地址也随着改变
2.2 整型：int
-
整型在 python2 。/ " xxx " 、而 python3 输出 ：print(" xxx ")
-
python2 默认的编码是ASCII 、而 python3默认的编码是UTF-8
-
python2 输出：print " xxx " 、而 python3 输出 ：print(" xxx ")
-
python2 输入：name = raw_input("请输入姓名：") 、而 python3输入：name = input("请输入姓名：")
-
整型的不同 --> python2：分为整型（int）和 长整型（long） / python3：只有整型（int）
-
除法的不同 --> python2: 除法只保留整数 / python3：除法全部保留
-
-
注意：开发过程中，如果是python2版本，要在头部添加：
# -*- coding:utf-8 -*-
- 编写文件时，用什么文件编码保存的，就用什么文件编码打开。
a = 'assd' #增 del a #删 a = 'aaa' #改 print(a[0]) #查
name = "zhumingMei" print(name.upper()) # 运行结果：name = "ZHUMINGMEI"
name = "ZHUMINGMEI" print(name.lower()) # 运行结果：name = "zhumingMei"
name = 'zhumingMei' new_name = name.capitalize()# 运行结果：name = "ZhumingMei"
name = 'zhumingMei' new_name = name.count('i') # 运行结果：2
name = 'zhumingMei' new_name = name.find('u') # 运行结果：2
去除空格：strip()
tel = " 176 0000 1007 " print(tel.strip()) # 运行结果：176 0000 1007（两边无空格）
替换指定字符：replace()：将指定的字符替换成想替换的。
text = "name tel age tel tel address" # 用法一： print(text.replace("tel","iphone")) # 运行结果：name iphone age iphone iphone address # 用法二： # 指定替换指定个数字符，搜索前几个，换成想换的字符。 print(text.replace("tel","iphone",1)) # 运行结果：name iphone age tel tel address # 用法三： num = '1 + 2 * 3/5 + ( 6/7 + (6+5*4) + 99) * 89' #将空格替换掉 print(num.replace(" ","")) # 运行结果：1+2*3/5+(6/7+(6+5*4)+99)*89
分割：split()：将字符串按指定的方式进行分割，返回的是列表。
# 注意：split()默认是按照空格分割字符 name = "I,love,you " print(name.split(",")) # 运行结果：['I', 'love', 'you '] # 此用法比较便捷 num = "1+3" a,b = num.split('+') print(a,b) # 运行结果：1,3
获取长度：len(): 获取字符串的长度。
name = "Meet" print(len(name)) # 运行结果：4
判断数字：isdigit()：判断是否为数字。(返回布尔值，True 或者 False)
text = input("请输入数字：") # '1'-> True; '二'-> False; '②' -> True print(text.isdigit()) #如果输入全是数字返回Ture 如果输入有一个不是就返回False
判断数字：isdecimal() (推荐)：判断是否是数字。(返回布尔值，True 或者 False)
# 以后推荐用 isdecimal 判断是否是10进制的数。 num = "二" # '1'-> True; '二'-> False; '②' --> False print(num.isdecimal()) # 如果输入全是数字返回Ture 如果输入有一个不是就返回False
以什么开头：startswith()：判断是否以指定的字符开头(返回布尔值，True 或者False)
name = "Are you ready !! Good Good Study Day Day up" print(name.startswith("Are")) # 运行结果：True
以什么结尾：endswitch()：判断是否以指定的字符结尾(返回布尔值，True 或者False)
name = "Are you ready !! Good Good Study Day Day up" print(name.endswith("Day")) # 运行结果：False
字符串格式化: format()：表现形式{索引}，可以通过索引，对指定字符进行赋值。
message = "我的名字叫{0}，我今年{1}岁".format("唐僧",2000) print(message) # 运行结果：我的名字叫唐僧，我今年2000岁
编码转换：encode()：程序默认Unicode编码，可以将字符串的保存编码通过encode进行修改 。
name = "你好" # 用encode转换成字节类型 print(name.encode("UTF-8")) # UTF-8用三个字节表示一个汉字 # 运行结果：b'\xe4\xbd\xa0\xe5\xa5\xbd' now_name= name.encode("UTF-8") print(now_name.decode('utf-8')) #用什么编码转换成字节，就要用什么编码转换成字符 print(name.encode("GBK")) # GBK用两个字节表示一个汉字 # 运行结果：b'\xc4\xe3\xba\xc3' now_name= name.encode("GBK") print(now_name.decode('GBK')) #用什么编码转换成字节，就要用什么编码转换成字符
字符串拼接：join()：循环字符串中得每个字符，按照指定得连接方式，调用方式：" 我是字符串".join()。
#join对字符串进行连接 name = "人生苦短，我用python" print("_".join(name) ) #运行结果： 人_生_苦_短_，_我_用_p_y_t_h_o_n # join可以对列表元素连接 users = ["人生苦短","我用","python"] print(",".join(users)) # 运行结果：人生苦短,我用,python # join可以对元组元素连接 users = ("人生苦短","我用","python") print(",".join(users)) # 运行结果：人生苦短,我用,python # join可以对元组里的列表进行拼接 v2 =(["小苹果",'玫瑰花']) # 空字符串就是什么都不连接 print("".join(v2)) # 运行结果：小苹果玫瑰花 # join对列表进行拼接 nums = [11,22,33,44] for i in range(0,len(nums)): # join连接必须是-->字符串.join() nums[i] = str(nums[i]) # 先转换成字符串类型 nums = ["11","22","33","44"] print('_'.join(nums) ) # 运行结果：11_22_33_44
列表特性：有序的，可重复，可修改 ，表示多个元素时可以用列表，可变类型的，可以对列表进行增删改。
2.4.1 列表的增删改查
列表的增加模式（append，insert，extend）
lst = ["1", "2", "3", "4"] # 1.追加模式:append()，在list最后增加 lst.append("5") # 运行结果：lst = ['1', '2', '3', '4', '5'] # 2.插入模式:insert()，在指定下标处添加 lst.insert(1, "1.5") # 运行结果：lst = ['1', '1.5', '2', '3', '4', '5'] # 3.迭代添加:extend()，在list最后迭代添加 lst.extend(["6", "7"])# 运行结果：lst = ['1', '1.5', '2', '3', '4', '5', '6', '7']
列表的删除模式（pop，remove，clear）
lst = ['1', '2', '3', '4', '5'] # 1.删除模式:pop()，通过下标删除元素（默认删除最后一个） lst.pop() # 运行结果：lst = ['1', '2', '3', '4'] deleted = lst.pop() # 运行结果：deleted = '4' lst.pop(2) # 运行结果：lst = ['1', '2', '4'] # 2.删除模式:remove()，通过指定元素删除（如果删除的元素不在列表里，则报错） lst.remove('4') # 运行结果：lst = ['1', '2'] # 3.删除模式：clear()，清空列表里的数据 lst.clear() # 运行结果：lst = [] # 4.删除模式：del()，指定要删除的元素索引 del lst[1:3] # 删除索引1到索引3的元素 运行结果：['1','5'] # 5.pop、del、remove的区别 # pop：不仅仅是删除，还将删除的元素可以赋值给一个变量 # del：仅仅是删除 # remove：删除指定的元素，不用指定索引
2.4.2 列表的常用操作
列表的修改：索引切片修改
lst = ["1", "2", "3", "4", "5"] lst[1] = "1.5" # 运行结果：lst = ['1', '1.5', '3', '4', '5'] lst[1:4:2] = ["2.5",'2'] # 运行结果：lst = ['1', '2.5', '3', '2', '5'] lst[1:4] = ["1.5"] # 运行结果：lst = ['1', '1.5', '5']
列表的查询：列表是一个可迭代对象,所以可以进行for循环
lst = ["1", "2", "3", "4"] for i in lst: print(i) # 运行结果：1 2 3 4
反转：reverse()：把列表进行旋转
v1 = [11,22,33,44,55] v1.reverse() print(v1) # 运行结果：[55,44,33,22,11]
排序：sort()：对列表进行排序
v1 = [117,22,833,44,545] v1.sort(reverse=False)#从小到大 默认的 print(v1) # 运行结果： [22,44,117,545,833] v1.sort(reverse=True) #从大到小 print(v1) # 运行结果：[833,545,117,44,22]
循环：extend()：循环添加每个元素（元组没有此功能）
函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） s = "qwert" li = ["alex","WuSir","ritian","wenzhou"] li.extend(s) print(li)# 运行结果：['alex','WuSir','ritian','wenzhou','q','w','e','r','t']
列表的嵌套
users = ["alex",0,True,[11,22,33,"123"],[1,['1','2'],2,3]] print(users[0]) # "1" print(users[2]) # "True" print(users[0][2]) # "e" print(users[3]) # [11,22,33,"123"] print(users[3][-1]) # "123" print(users[3][-1][1]) # '2' users[3] = 666 print(users) # ["alex",0,True,666,[1,['1','2'],2,3]]
2.5 字典：dict
2.5.1 字典的增删改查
字典的添加：
dic = {} dic['name'] = '汪峰' dic['age'] = 18 print(dic) # dic = {'name': '汪峰','age': 18} # 如果dict中没有出现这个key,就会将key-value组合添加到这个字典中 # 如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值 # setdefault() # 我们使用setdefault这个方法 里边放的这个内容是我们字典的健,这样我们添加出来的结果就是值是一个None s1 = dic.setdefault('王菲') print(dic) # dic = {'王菲': None} # 总结: 当setdefault中第一个参数存在这个字典中就就不进行添加操作,否则就添加 dic.setdefault('王菲',歌手) # 这样就是不会进行添加操作了,因为王菲在dic这个字典中存在 s2 = dic.setdefault('汪峰','歌手') print(dic1) # dic = {'王菲': None,'汪峰': '歌手'}
字典的删除：
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
s = dic.pop('哈啥给') # pop删除有返回值,返回的是被删的值
print(s)
print(dic) # 打印删除后的字典
dic.popitem() # 随机删除 python3.6是删除最后一个
print(dic)
dic.clear() # 清空
字典的修改：
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
dic['哈啥给'] = '剑姬' # 当哈哈给是字典中的健这样写就是修改对应的值,如果不存在就是添加
print(dic)
dic.update({'key':'v','哈啥给':'剑姬'})
# 当update中的字典里没有dic中键值对就添加到dic字典中,如果有就修改里边的对应的值
print(dic)
字典的查看：
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
s = dic['大宝剑'] #通过健来查看,如果这个健不在这个字典中.就会报错
s1 = dic.get('剑圣') #通过健来查看,如果这个健不在这个字典中.就会返回None
s2 = dic.get('剑姬','没有还查你是不是傻') # 我们可以在get查找的时候自己定义返回的结果
2.5.2 字典的常用操作
一. OrderedDict()：使用OrderedDict实现字典有序
from collections import OrderedDict val = OrderedDict() val['k1'] = 'v1' # 实现了# __setitem__内置方法 val['k2'] = 123 val['k3'] = 999 val['k4'] = True val['k4'] # # 实现了# __getitem__内置方法 for k,v in val.items(): print(k,v)
二. 键值对保存 ：事物有多个属性，表示多个事物的时候，可以用字典。
keys()：取出所有的key值。
message = { "username":"小红",
"age":12}
item_key = message.keys()
for i in item_key:
print(i) # 返回每个 key 的值
values()：取出所有的value值
message = { "username":"小红",
"age":12 }
item_value = message.values()
for i in item_value:
print(i) # 返回每个 value 的值
items()：取出字典中的keys和values
message = { "username":"小红",
"age":12 }
for i in message.items():
print(i) # 返回的是一个元组
for i,j in message.items():
print(i,j) # 返回key 和 value的值
update()：把字典的键/值对更新到dict里，不存在，则添加。存在，则更新。
info = {'k1':'v1','k2':'v2'}
# 不存在，则添加,存在，则更新
info.update({'k3':'v3','k4':'v4','k2':666})
print(info)
# 输出 {'k1':'v1','k2':'v2','k3':'v3','k4':'v4','k2':666}
数据类型嵌套
整型 int / 布尔 bool / 字符串 str / 列表 list / 元组 tuple / 字典 dict info = { 'k1':'v1', 'k2':True, 'k3':1, 'k4':(11,22,33), 'k5':[11,22,33], 'k6':{'kk':'vv'}, 1:{'kk':'vv'}, False:{'kk':'vv'}, [11,2]:{'kk':'vv'}, # 不可哈希 列表 (11,2):{'kk':'vv'}, {'k1':'v2'}:{'kk':'vv'}, # 不可哈希 字典 } 字典中的键必须是可哈希的数据类型，是不能被改变的， （ 列表 字典 和 集合 ）都是可以被改变的，所以不能做字典的键
2.6 集合：set（去重）
集合：无序的，不可重复的
2.6.1 集合的增删改查
集合的增加：添加元素，集合是无序的不可重复的，所以在添加重复元素的时候不会形成新元素。
info = {12,True,"人生苦短，我用..",("python",12)}
info.add(13)
info.add(12) # 输出时‘12’在集合中只存在一个
集合的删除 ：删除集合中指定的元素
info = {12,True,"人生苦短，我用..",("python",12)}
info.discard(True) # 删除指定的集合元素
print(info) # {12,"人生苦短，我用..",("python",12)}
item = s.pop() # 随机删除⼀个.
s.remove("True") # 直接删除元素 不存在这个元素. 删除会报错
s.clear() # 清空set集合.如果是空的. 打印出来是set() 和dict区分
集合的修改 ：集合中的数据没有索引，也没有办法去定位⼀个元素，所以没有办法进⾏直接修改。可以采⽤先删除后添加的⽅式来完成修改操作。
info = {12,True,"人生苦短，我用..",("python",12)}
# 把刘嘉玲改成赵本⼭
s.remove("刘嘉玲")
s.add("赵本⼭")
print(s)
集合的查询 ：集合是⼀个可迭代对象. 所以可以进⾏for循环。
info = {12,True,"人生苦短，我用..",("python",12)}
for el in info:
print(el)
2.6.2 集合的常用操作
intersection()：取集合的交集
info01 = {12,34,22,"python"}
info02 = {33,99,22,12}
new_set = info01.intersection(info02) # 取info01 和 info02的交集
union(): 返回两个集合的并集
info01 = {168,34,22,"python"}
info02 = {33,99,22,"大海"}
new_set = info01.union(info02) # 将两个集合合并成一个新的集合
difference(): 返回多个集合的差集
info01 = {168,34,22,"python"}
info02 = {666,34,"人生","python"}
new_info = info01.difference(info02) # {168，22}
# 返回的是info01在info02中没有的元素，即168，22在info02中没有
symmetric_difference() : 返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素。
info01 = {168,34,22,"python"}
info02 = {666,34,"人生","python"}
new_info = info01.symmetric_difference(info02) # 去掉了两个集合相同的元素
update(): 给集合添加元素
info01 = {168,34,22,"python"}
info02 = {666,34,"人生","python"}
info01.update(info02) # update合并两个集合，更新info01集合，重复的元素只出现一次
嵌套问题（⭐常用）：
True和1同时在集合中的时候，解释器会默认把True转换为1，集合是不可重复的，所以只输出一个1，不会输出True (False和0同理)。 info = {12,"abc",1,True,(7,8,9)} for i in info: print(i) info = {12,"abc",0,False,(7,8,9)} for i in info: print(i)
拓展：若字典中存在这种情况，同理
info = { 1:"小红", "age":18, True:110 } print(info) # {1: 110, 'age': 18}
2.7 布尔类型：bool
-
只有两个值：True 和 False
-
整型转布尔类型：只有0 转换后是False，其他都是True
-
字符串转布尔类型：只有"" 转换后是False，其他都是True
2.8 元组：tuple
元组：有序的，不可修改
-
不可变类型，对元组中的元素不能进行修改
-
没有独立的功能
-
空括号是一个元组 val = ()
- 和列表的 len，索引，切片，步长，for循环用法相同
# 元组的元素不可修改，但是元组中的元素若是一个列表，则列表中的元素是可以修改的 举例： name = ("age" , 123 , ["aa",111,True],False) name[2][0] = "bbb" print(name) # ("age" , 123 , ["bbb",111,True],False)
2.9 可哈希 和 不可哈希
-
可哈希的数据类型，即"不可改变的"数据结构(字符串str、元组tuple)
- 不可哈希的数据类型，即可改变的数据结构 (字典dict，列表list，集合set)
str1 = "小红" # 2264481799488 str1 = "小李" # 2264481799752 print(id(str1),id(str1)) # 输出不同的内存地址 # str1指向的内存地址发生了改变，一旦存在，只要不销毁，内存地址就不会发生改变，∴字符串 可哈希
内存相关的（垃圾回收gc）
-
内存相关的
-
type()方法：判断属于哪种数据类型，id()方法：获取内存地址
-
python缓存机制，小数据池（只有数字和字符串类型具有小数据池的特点）
- 小数据池的作用就是节省内存
举例1： v1 = [123,456,789] print(id(v1)) v2 = [123,456,789] print(id(v2)) # 不同的内存地址 举例2： v1 = 666 v2 = 666 print(id(v1),id(v2)) # 变量不同，相同的内存地址 举例3： v1 = "asdf" v2 = "asdf" print(id(v1),id(v2)) # 变量不同，相同的内存地址 ⭐按照常理，应该是不同的内存地址，但是由于python具有缓存机制，-5~256归类于常用的数字，∴就放到了小数据池中进行缓存，用到的时候就会直接取，所以v1,v2的内存地址是相同的 （ 整型、字符串、浮点型都有这个机制 ） 举例4： v1 = "asdf_*" * 2 v2 = "asdf_*" * 2 print(id(v1),id(v2)) # 不同的内存地址 # 当字符串中有除了_以外的其他字符时（比如：$#&等）* 1以上，内存地址就会发生变化
- 垃圾回收机制
v1 = [11,22,33,44] # 开辟了新空间 print(id(v1)) # 1562692159880 v1 = [11,22,33] # 此时对v1再次重新赋值，又开辟了新空间 # 此时上面开辟的空间若没有东西指向它，它将等待python的垃圾回收机制进行回收 print(id(v1)) # 1562692160008
- 判断内存地址是否发生变化（判断修改内部元素还是重新赋值）
v1 = [11,22,33] v2 = v1 v1.append(666) print(v2) # 含 666 内部修改了v1的值，输出 [11,22,33，666] v1 = [11,22,33] v2 = v1 v1 = [1,2,3,4] # 对v1重新赋值，v1内存地址发生改变，v2的内存地址指向不变 print(v2) # 输出：[11,22,33] v1 = 'alex' v2 = v1 v1 = 'oldboy' # 对v1重新赋值，v1内存地址发生改变，v2的内存地址指向不变 print(v2) # 地址指向不变，v2的值不变，输出：'alex' # 字符串不可变类型 v1 = 'alex' v2 = v1 # v1和v2指向同一块内存地址 v1.upper() # 字符串是不可变类型，新生成一个字符串，没有变量接收 print(v1，v2) # v1 和 v2还是指向alex
2.10 数据类型转换
- str转换成int
str = "666" new_str = int(str) # 注意：只有当字符串的内容是数字的时候，才能进行转换。
- bool转换成int
age = True
new_age = int(age)
- bool转换成str
age = True
new_age = str(age)
- int转换成str
age = 18
new_age = str(age)
- list转换成tuple
# 列表转换成元组 v1 = tuple([12,"abc",[1,2,3]]) # (12,"abc",[1,2,3])
- tuple转换成list
# 元组转换成列表 v1 = list( (11,22,33,44,) ) # [11,22,33,44]
- 任何类型转成布尔类型
# 任何类型转成布尔类型，只有这几个是False，其他的都是True v1 = bool(0) v2 = bool("") v3 = bool([]) v4 = bool(()) v5 = bool({}) v6 = bool(set()) V7 = bool(None)
2.11 字节类型：bytes
8bit = 1byte 1024byte = 1KB 1024PB = 1EB 1024KB = 1MB 1024EB = 1ZB 1024MB = 1GB 1024ZB = 1YB 1024GB = 1TB 1024YB = 1NB 1024TB = 1PB 1024NB = 1DB 常⽤到TB就够了
浙公网安备 33010602011771号