数据类型
学习目标
- 掌握python数据类型
1. Int数据类型
# 定义int类型，整数型
a = 10
print(a, type(a))
2. Int数据类型转换
# int数据类型转换，使用int()函数
b = int("1") # 将字符串转成int类型，要求字符串本身是一个整数数字（包含负数）
# c = int("1.7") # 转型失败
# d = int("abc") # 转型失败
e = int(True) # 布尔类型转成int，True = 1；False = 0
f = int(False)
g = int(17.92) # 将浮点类型转成int，需要舍弃小数点部分
print(b, type(b))
print(e, type(e))
print(f, type(f))
print(g, type(g))
3. 应用案例
age = input("请输入你的年龄：")
age = int(age)
当用户输入的值满足int转型要求，可以转成功，否则报错
3. Float浮点类型
# 定义float浮点类型
a = 3.7
print(a, type(a))
4. Float浮点类型转换
# float数据类型转换，使用float()函数
b = float("1") # 1.0 字符串转float，要求字符串本身是数值
c = float("1.98") # 1.98
# d = float("abc") # 失败
e = float(True) # 1.0 布尔类型转float，True=1.0；False=0.0
f = float(False) # 0.0
g = float(8) # 8.0 int类型转float，会增加小数部分
print(b, c, e, f, g)
print(int(float("1.98"))) # 字符串转为浮点，再转成int
5. Str字符串类型
# 定义字符串
a = '蒂姆·伯纳斯·李'
b = "爱达·拉乌莱斯"
c = '''西摩·克雷'''
d = """加里·麦金农"""
e = '''比尔·盖兹说：
我创办
了微软！
'''
f = """ 史蒂夫·乔布斯说：
我
是苹果
公司 创始人
！
"""
g = '吉多·范罗苏姆' \
'说：我发明了python' \
'你们都要好好听课！' # 一对单引号（或一对双引号）定义字符串时，若换行，则使用\斜杠进行字符串拼接，输出时仍然是一行字符串
h = "世界未解之谜" + """
今天中午吃什么？
女朋友为什么又生气了？
"""
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)
print(h)
6. 字符串切片索引
# 字符串切片索引
name = "阿尔伯特·爱因斯坦" # 从左往右的索引下标从0开始数：0 1 2 3 4 5 6 7 8 从右往左的索引下标从-1开始数
print(name)
print(name[2]) # 打印name变量值中下标为2的字符，结果：伯
print(name[7]) # 打印name变量值中下标为7的字符，结果：斯
print(name[-2]) # 打印name变量值中下标为-2的字符，结果：斯
print(name[2:5]) # 打印截取下标2~下标5的字符，含头不含尾
print(name[2:]) # 打印截取下标2往后所有字符，包含下标2
print(name[:5]) # 打印截取下标5往前所有字符，不包含下标5
print(name[:]) # 打印截取全部字符
7. 修改字符串值
# 修改字符串值，原有字符串值不会被改变，会重新开辟一个新的同名内存进行存储新值
name_1 = "廖伟"
print(name_1, id(name_1))
name_1 = "廖伟伟"
print(name_1, id(name_1))
# 与52行的id不是同一个id，表示当name_1重新赋值为“廖伟伟”时，51行的name_1空间被销毁，创建了一个新的同名空间取代原有空间
8. 字符串常用方法
# 字符串常用方法、函数
print("a" in "abc") # T 判断字符“a”是否存在于“abc”中，存在返回True，不存在返回False
print("a" not in "abc") # F 判断字符“a”是否不存在于“abc”中，不存在返回True，存在返回False
print("ac" in "abc") # F 判断字符串“ac”是否存在于“abc”中（要求连贯字符），存在返回True，不存在返回False
# 获取字符串长度len()函数
print(len(name))
print(len("巴勃罗·迭戈·何塞·弗朗西斯科·狄·保拉·胡安·纳波穆西诺·玛莉亚·狄·洛斯·雷梅迪奥斯·西普里亚诺·狄·拉·圣地西玛·特里尼达·路易斯·毕加索"))
phone = "18677226666"
# 统计某[值]在字符串内出现的次数count()
print(phone.count('6')) # 统计“6”在phone变量值中出现的次数
print(phone.count('0')) # 未找到指定目标字，则返回0
print(phone.count('16'))
# print(phone.count(6)) # 报错，要求传入被查找的目标字需要是字符串类型
# 在字符串中寻找某[值]首次出现的位置
print(phone.find('2')) # 在phone变量值中找“2”字符首次出现的位置，返回位置下标
print(phone.find('26')) # 在phone变量值中找“26”字符首次出现的位置，返回位置下标
# print(phone.find(2)) # 报错，要求传入被查找的目标字需要是字符串类型
print(phone.find('6', 5)) # 在phone变量中指定起始位置是下标5（包含5），寻找“6”首次出现的位置
print(phone.find('6', 5, 8)) # 在phone变量中指定起始位置是下标5（包含5）结束位置是下标8（不包含8），寻找“6”首次出现的位置
print(phone.find('6', -6)) # 负数下标也通用
print(phone.find('6', -6, -3))
print(phone.find('9')) # 若被查找的目标字未找到，则返回-1
# 在字符串内将某[值]换成[新值]
newPhone = phone.replace('6', '0') # 将phone变量值中的“6”全部替换成“0”，赋值给一个新变量
newPhone_1 = phone.replace('6', '0', 3) # 将phone变量值中的“6”替换成“0”，只替换3次，赋值给一个新变量
print(newPhone)
print(newPhone_1)
print(phone) # phone原值没有被更改
# 将字符串中有效的python语句进行执行
str_1 = "print(1+1)"
eval(str_1)
# 大小写转换
code = "AtbR"
upper_code = code.upper() # 将字符串转成全大写
lower_code = code.lower() # 将字符串转成全小写
print(upper_code)
print(lower_code)
print(code) # 原值仍然不会被更改
# 判断字符串的内容是否为纯数字
num = input("请输入年龄：")
print(num.isdigit()) # 判断num变量的值是否为纯数字（小数点不算数字）
9. 字符串数据类型转换
# 将其他数据类型转换成str字符串，使用str()，啥都能转，相当于直接在原值上加引号
print(str(1))
print(str(1.1))
print(str(True))
print(str([1, 2, 3]))
10. Bool布尔类型
# 定义布尔类型，只有2个合法值：True、False，即1和0
a = True
b = False
print(a, type(a))
print(b, type(b))
11. python中的0值
# python认为除0以外的所有值，全都是真值
# 以下属于0值：
int_0 = 0
float_0 = 0.0
str_0 = ""
none_0 = None
bool_0 = False
list_0 = []
tuple_0 = ()
set_0 = set()
dict_0 = {}
print(bool(int_0))
print(bool(float_0))
print(bool(str_0))
print(bool(none_0))
print(bool(bool_0))
print(bool(list_0))
print(bool(tuple_0))
print(bool(set_0))
print(bool(dict_0))
除以上值以外的值，全都认为是真值
12. List列表类型
# 定义list列表：使用[]中括号作为标识，元素有序排列
list_1 = [] # 空列表
list_2 = [1, 2, 3] # 列表中有3个元素，元素和元素之间用英文逗号分隔
list_3 = [1, 8.8, True, "ABC", [1, 2, 3, [4, 5, 6]]]
print(list_3, type(list_3))
13. list列表切片
# 列表的切片索引，下标取值规则和字符串一致
list_4 = ["苹果", "梨子", "香蕉", "橘子", ["草莓", "甘蔗", ["西瓜", "哈密瓜"], "杨桃"], "樱桃"]
print(list_4[0])
print(list_4[4])
print(list_4[-3])
print(list_4[4][1])
print(list_4[4][2][0])
# 通过下标截取列表
print(list_4[1:4]) # 截取下标1~下标4的元素（包含1，不包含4）
print(list_4[2:])
print(list_4[:3])
print(list_4[:])
print(list_4[4][0:2])
14. 修改list中的元素值
list_4 = ["苹果", "梨子", "香蕉", "橘子", ["草莓", "甘蔗", ["西瓜", "哈密瓜"], "杨桃"], "樱桃"]
# 更改list列表的值
list_4[3] = "山竹"
list_4[4][1] = "柚子"
list_4[4][2][1] = "火龙果"
print(list_4)
15. list的常用方法
list_4 = ["苹果", "梨子", "香蕉", "橘子", ["草莓", "甘蔗", ["西瓜", "哈密瓜"], "杨桃"], "樱桃"]
# 常用函数方法
print('苹果' in list_4) # T 判断list_4列表中是否有元素=“苹果”字符串
print('草莓' in list_4) # F 判断list_4列表中是否有元素=“草莓”字符串
print(["西瓜", "哈密瓜"] in list_4[4]) # T 判断list_4[4]列表中是否有元素=["西瓜", "哈密瓜"]列表
print("果" in list_4) # F
print("果" in list_4[0]) # T
print('苹果' not in list_4) # F 判断“苹果”是否不存在于list_4，不存在返回T，存在返回F
# 最大值、最小值
list_5 = [1, 44, 909, 100, -99]
print(max(list_5))
print(min(list_5))
list_6 = ["abz", "cbd", "A", "a", ""] # 通过ASCII编码比较大小
print(max(list_6))
print(min(list_6))
# 获取列表长度，len()
print(len(list_4))
# 往list中追加元素
list_4.append("芒果")
print(list_4)
# 将新元素插入到指定位置
list_4.insert(3, '人参果')
print(list_4)
list_4.append(["杨梅", "荔枝", "菠萝"])
print(list_4)
list_7 = ["土拨鼠", "孔雀", "大象", "鸵鸟", "老虎", "海豚", "老虎", "袋鼠", "金鱼", "老虎", "狮子"]
print(list_7.count("老虎")) # 统计元素”老虎“在列表中出现的次数
print(list_7.index("老虎")) # 找元素在列表中首次出现的位置
print(list_7.index("老虎", 5)) # 第一个参数：目标 第二个参数：开始位置（包含本身）
print(list_7.index("老虎", 7, 10)) # 第三个参数：结束位置（不包含本身）
# print(list_7.index("老虎", 1, 4)) # 如果目标未找到，则报错ValueError
# 复制
list_8 = list_7 # 将list_7整个对象赋值给list_8，属于浅拷贝，两个变量共用同一片内存空间
list_9 = list_7[:] # 将list_7的所有元素赋值给list_9，属于深拷贝，list_9会自行开辟一个新内存空间
list_10 = list_7.copy() # 将list_7的值复制给list_10，属于深拷贝，list_10会自行开辟一个新内存空间
print(list_7, id(list_7))
print(list_8, id(list_8)) # list_8的值与list_7是一样的，内存空间的id也是一样的
print(list_9, id(list_9)) # list_9的值与list_7是一样的，内存空间的id是不一样的
print(list_10, id(list_10)) # list_10的值与list_7是一样的，内存空间的id是不一样的
list_7.remove("狮子") # 删除list_7中的“狮子”元素，会同时改变list_7和list_8
print(list_7, id(list_7))
print(list_8, id(list_8))
print(list_9, id(list_9))
print(list_10, id(list_10))
# 删除元素
pop_value = list_7.pop(3) # 删除指定下标的元素，返回值是对应的元素
# pop_value_1 = list_7.pop(20) # 当下标不存在时，会报错IndexError
print(list_7)
print(pop_value)
list_7.remove("海豚")
# list_7.remove("蚂蚁") # 当指定的元素不存在时，会报错ValueError
list_7.remove("老虎") # 当指定元素存在多个时，仅删除第一个
print(list_7)
# 清空
list_7.clear() # 清空list_7里的所有元素，但变量空间还在，只是没有值
print(list_7) # 打印出空列表
del list_7 # 销毁变量空间
# print(list_7) # 当变量被销毁后，打印该变量时会报错NameError
16. list列表数据类型转换
# 将其他数据类型转换成list列表，使用list()、split()
# print(list(123456)) # int转list 报错
# print(list(99.99)) # 浮点转list 报错
print(list('123456')) # 字符串转list，每个字符作为元素
print(list((1, 2, "3", 4, 5))) # 元组转list，保留原本的元素
print(list({1, 2, 3, 4, "5"})) # 集合转list，保留原本的元素
print(list({"姓名": "刘亦菲", "年龄": "18"})) # 字典转list，保留key作为元素
str_1 = "188-0989-6800"
print(str_1)
print(str_1.split("-"))
print(str_1.split("9"))
print(str_1.split("0"))
17. Tuple元组类型
# 定义元组，使用的是()小括号作为标识，元素有序，元素值不允许被修改
tup_1 = () # 空元组
tup_2 = (1, 2, 3)
tup_3 = (1, 4.56, "梨子", True, [1, 2, 3], (4, 5, 6), {1, 2, 3})
print(tup_3, type(tup_3))
18. tuple元组切片
# 元组的索引下标，和字符串规则一致
tup_4 = ("亚索", "皇子", "石头人", "永恩", ("VN", "哈哈哈", "小炮", ("塞拉斯", "瑞兹", "维克托"), "女警"), "奶妈")
print(tup_4[1])
print(tup_4[-3])
print(tup_4[4][3][0])
print(tup_4[-2][-2][-3])
# 通过下标索引截取元组值，规则和字符串一致
print(tup_4[0:2])
print(tup_4[3:])
print(tup_4[:4])
print(tup_4[:])
19. 改变tuple元组内的值
# 改变元组值
tup_5 = ("亚索", "皇子", "石头人", "永恩", ["VN", "哈哈哈", "小炮", ("塞拉斯", "瑞兹", "维克托"), "女警"], "奶妈")
tup_5[0] = "盲僧" # 元组内的元素不允许被改值
tup_5[4][3] = "寒冰" # tup_5[4]是一个列表，列表中的值是允许修改的
print(tup_5)
20. tuple元组的常用方法
# 常用函数
print("皇子" in tup_5) # T
print("皇子" not in tup_5) # F
print("VN" in tup_5) # F
print(("塞拉斯", "瑞兹", "维克托") in tup_5[4]) # T
tup_6 = ("亚索", "皇子", "石头人", "永恩")
print(len(tup_6))
print(max(tup_6))
print(min(tup_6))
print(tup_6.count('皇子')) # 统计“皇子”在tup_6中出现的次数
print(tup_6.index('永恩')) # “永恩”在tup_6中首次出现的位置
print(tup_6.index('永恩', 1)) # 下标1往后的范围内，找“永恩”首次出现的位置
# print(tup_6.index('永恩', 1, 3)) # 下标1~3之间（不包含3）范围内，找“永恩”首次出现的位置，如果未找到则报错
del tup_6
# print(tup_6) # 变量已被销毁，再打印该变量时，会报错NameError
5. 元组数据类型转换
# 其他数据类型转换成元组，使用tuple()函数
# print(tuple(123)) # 数值类型非容器，无法转换成元组类型
print(tuple("123456")) # ('1', '2', '3', '4', '5', '6')
print(tuple([1, 2, 3])) # (1, 2, 3)
print(tuple({1, 2, 3})) # (1, 2, 3)
print(tuple({"姓名": "墨菲特", "年龄": 3})) # ('姓名', '年龄')
1. Set集合类型定义和使用
# 定义集合，使用{}花括号作为标识，元素无序，且元素不可重复
set_1 = set() # 空集合
set_2 = {1, 2, 3}
set_3 = {1, 7.90, True, "苹果", (2, 4, 3)} # 除了能被改变值的容器不允许作为元素外，其他数据类型都可作为元素
set_4 = {"苹果", "栗子", "菠萝", "苹果", "荔枝", "苹果"}
print(set_3, type(set_3))
print(set_4)
print(set_4)
print(set_4)
21. set集合常用的方法
# 常用的函数
set_5 = {"苹果", "梨子", "香蕉", "菠萝", "山竹", "草莓"}
print("山竹" in set_5)
print("山竹" not in set_5)
print(len(set_5)) # 统计集合的长度，元素的个数
# 修改集合的元素
set_5.add("荔枝") # 追加单一元素
set_5.update({"龙眼", "火龙果"}) # 批量追加元素
set_5.update(("龙眼", "火龙果")) # 批量追加元素
set_5.update(["龙眼", "火龙果"]) # 批量追加元素
set_5.update({"龙眼": 111, "火龙果": 222}) # 批量追加元素，仅保留key值
set_5.remove("甘蔗") # 删除集合中指定元素，如果元素不存在，会报错
set_5.discard("甘蔗") # 删除集合中的指定元素，如果元素不存在，不会报错
pop_value = set_5.pop() # 随机删除一个元素，并且把被删除的元素值进行返回
print(pop_value)
set_5.clear() # 清空集合，被清空后打印的是set()
print(set_5)
del set_5 # 销毁集合
22. set集合数据类型转换
# 其他数据类型转换成set集合，使用set()
# set_6 = set(123) # 报错
# set_7 = set(22.36) #报错
set_8 = set("123") # 可转，每一个字符是一个元素，元素保留原本的数据类型，元素顺序随机
set_9 = set((1, 2, 3, 4, 5, 1, 2, 3)) # 可转，保留元组里的元素，会去重，顺序一致
set_10 = set([1,2,3,4,5,1,2,3]) # 可转，保留列表里的元素，会去重，顺序一致
set_11 = set({1: 11, 2: 22, 1: 333}) # 可转，保留字典里的key值作为元素值，会去重，顺序一致
print(set_11) # 不建议使用set()函数对元组、列表、字典进行转数据类型
23. Dict字典类型
# 定义字典dict：使用{}花括号作为标识符，元素是键值对key:value，无下标 通过key定位
dict_1 = {} # 空字典
dict_2 = {"姓名": "启小帆", "考勤": "请假", "原因": "参加总部面试"}
dict_3 = {"姓名": "启小帆", 1: 111, 8.8: 8888.88, (1, 2, 3): [1, 2, 3]}
# key可以使用字符串、元组、整数、小数；value可以使用任意数据类型
print(dict_3, type(dict_3))
dict_4 = {"姓名": "美伢", "姓名": "梦伢"} # 如果出现同名key，保留最新的一个
print(dict_4)
24. 改变dict字典的值
# 改变字典的value值
dict_3["姓名"] = "丁老头"
dict_3[1] = 222
dict_3[8.8] = 777.77
dict_3[(1, 2, 3)] = "103"
dict_3[(1, 2, 3)][1] = '5'
print(dict_3[(1, 2, 3)][1])
print(dict_3)
25. dict字典的常用方法
# 常用的函数 dict_2 = {"姓名": "启小帆", "考勤": "请假", "原因": "参加总部面试"}
print("姓名" in dict_2) # “姓名”作为key，是否存在于字典中，in在此处只能比较字典里的key
print("姓名" not in dict_2)
print("启小帆" in dict_2) # F
print('"姓名": "启小帆"' in dict_2)
print("姓名: 启小帆" in dict_2)
print({"姓名": "启小帆"} in dict_2) # 会报错
print(len(dict_2))
print(dict_2.keys()) # 返回字典中全部的key
print(dict_2.values()) # 返回字典中全部的value
print(dict_2.get("原因")) # 获取字典中key=“原因”的value值
print(dict_2.get("原因", "没找到！")) # 获取字典中key=“原因”的value值，若无对应的key，则返回“没找到！”
pop_value_1 = dict_2.pop("考勤") # 通过key，删除指定的字典元素，若删除成功 则返回被删除的value值
pop_value_2 = dict_2.pop("考勤", "又没找到！") # 通过key，删除指定的字典元素，若删除成功 则返回被删除的value值；若未找到指定值，则返回“又没找到”
print(pop_value_1)
print(pop_value_2)
dict_2.popitem() # 删除最后一个键值对
dict_2.clear() # 清空字典的元素
del dict_2 # 销毁变量
print(dict_2)
26. dict字典数据类型转换
# 其他数据类型转换成字典，使用dict()
dict_5 = dict(a="aaa", b="bbb") # 此处的key只能写字符串
dict_6 = dict(姓名="aaa", 年龄="bbb") # key=姓名，value=aaa；key=年龄，value=bbb {'姓名': 'aaa', '年龄': 'bbb'}
dict_7 = dict(zip(["姓名", "年龄"], ["丁老头", 21])) # 使用zip()函数，第一个[]写的是所有的key；第二个[]写的是一一对应的值
dict_8 = dict([("姓名", "丁老头"), ("年龄", 21)]) # 直接使用[]+()，每一个()里都是一个键值对
print(dict_8) # 不建议使用set()函数对元组、列表、字典进行转数据类型
27. 各个容器的对比
"""
list列表：使用[]，元素有序，有索引下标，元素可重复，元素可被修改 空列表：[]
tuple元组：使用()，元素有序，有索引下标，元素可重复，元素不可被修改 空元组：()
dict字典：使用{}，元素无序，没有索引下标，key不可重复，value可重复，元素value可被修改 空字典：{}
set集合：使用{}，元素无序，没有索引下标，元素不可重复，元素可被修改 空集合：set()
str字符串：使用引号，元素有序，有索引下标，元素可重复，元素不可被修改 空字符串：""
"""