第三章：数据类型

数据类型

一、数字类型

• int
  类型（整型）：一般包括正整数和负整数，如1, 0，-1
• float类型（浮点型）:整数后面有小数点，如0.1；1.00；1.68

# int 
age = 20
用途：标记年龄、银行账号、个数等
# float 
height = 1.68
用途：标记工资、身高、体重等

1. 数字类型常用操作

• 内置函数：int()

num_1 = 3.6
print(int(num_1))  # 将数字num_1转换成一个整数

>> > 3

• 内置函数：float()

num_2 = 3
print(float(num_2))  # 将数字#num_2转换成一个浮点数
>> > 3.0

常用运算符：+、-、 * 、 / 、 ** 、 // 、 %
常用函数：max() 、min()、abs()、round()
常用公共模块：random()、math() # 需要导入后使用

二、字符串（str）

用单引号，双引号，三引号括起来的内容就是str类型

# str
name = 'Alay'
print(name)
用途：用来描述内容，如姓名、提示语
>> > Alay_

1.字符串常用操作

(一)、字符串转义

# 1.转义字符:\\  (反斜杠-可以打印出一个反斜杠)
s = '\\'
print(s)
>>> \
# 2.转义字符:\' (单引号-可以打印出一个单引号)
s = '\''
print(s)
>>> '

# 3.转义字符:\"   (双引号-可以打印出一个双引号)
s = '\"'
print(s)
>>> "

# 4.转义字符:\n  (换行符-将光标移动到下一行的开头)
s = 's\na'
print(s)
>>> s
a

# 5.转义字符:\t  (水平制表符-将光标向右移动一个制表符位)
s = 's\ta'
print(s)
>>> s
a
# 6.防转义字符：r'\n' 
s = r'\t'
print(s)
>>>  \t

(二)、字符串格式化

# 1.格式化字符：%s 格式化字符串
name = Alay
print("你的姓名是：%s" % name)
>>> 你的年龄是：Alay

# 2.格式化字符：%d 格式化整数。
age = 18
print("你的年龄是：%d" % age)
>> > 你的年龄是：18

# 格式化字符：%f 格式化浮点数字，可指定小数点后的精度。
height = 1.68
print('你的身高是：%.2f ' % height)  # %.2f 最小宽度为0，小数点后保留2位
>> > 你的身高是：1.68

• 基于元组字符串格式化

s = '你的姓名是: %s 你的年龄是: %d ' % ('Alay', 18)
print(s)
>> > 你的姓名是: Alay
你的年龄是: 18

• 基于字典字符串格式化

s = '你的姓名是: %(name)s 你的年龄是: %(age)d ' % {'name': 'Alay', 'age': 18}
print(s)
>> > 你的姓名是: Alay
你的年龄是: 18

s = '你的姓名是: %(name)s 你的年龄是: %(age)d '
information = {'name': 'Alay', 'age': 18}
print(s % information)
>> > 你的姓名是: Alay
你的年龄是: 18

• ‘{}’.format()字符串格式化函数

# '{}'通过位置指出替换目标和即将插入的参数。默认位置为(0,1,2,3...),插入参数默认位置为(0,1,2,3...) 相当于%s，其占位符的作用
s = '你的姓名是: {} 你的年龄是: {} '.format('Alay', 18)
print(s)
>> > 你的姓名是: Alay
你的年龄是: 18

# '{}'通过指定位置，将参数插入。按照索引对应值，与索引序列相关对应
s = '你的姓名是: {1} 你的年龄是: {0} '.format('Alay', 18)
print(s)
>> > 你的姓名是: 18
你的年龄是: Alay

# '{}'通过关键字，将参数插入(字符串、数字、列表、元组等)。按照关键字对应值，只与key对应。
s = '你的姓名是: {name} 你的年龄是: {age} '.format(name='Alay', age=18)
print(s)
>> > 你的姓名是: Alay
你的年龄是: 18

• f - Strings字符串格式化函数

name = 'Alay'
age = 18
print(f"你的名字是{name},你的年龄是{age}")
>> > 你的名字是Alay, 你的年龄是18

(三)、索引取值

字符串是字符的有序集合，字符串的字符可以通过位置（索引）来提取，
可以得到从起始索引到结束索引（不包括结束索引所对应的元素）之间的元素
规则：
1.左闭右开，取头不取尾
2.从前往后取，从0开始取
3.从后往前取，从 - 1
开始取

hobby = 'music basketball'
print(hobby[0])  # 下标第0个取m
print(hobby[1])  # 下标第1个取u
print(hobby[5])  # 下标第5个取空
print(hobby[0:5])  # 提取下标从0到5，但是不包括5之间的字符->music
print(hobby[:5])  # 提取下标从0到5，但是不包括5之间的字符->music
print(hobby[:-1])  # 提取下标从0到-1，但是不包括-1之间的字符->music basketbal
print(hobby[0:5:2])  # 步长为正数，从hobby [0:5:2]中，从左往右的顺序，提取0-5之间，间隔了一个字符的字符，也就是提取下标0、2、4的字符。—>msc
print(hobby[0:5:-2])  # 步长为负数，第一个索引必须比第二个索引值要大，否则无法取值。
print(hobby[11:5:-2])  # 步长为负数，从print(hobby[11:5:-2]中，以从右往左的顺序，提取11-5之间字符，间隔了一个字符的字符，也就是提取下标11、9、7的字符，取头不取尾，尾部下标为5不取。->tka
print(hobby[5:-1])  # 提取下标从5到-1，但是不包括-1之间的字符->basketbal

(四)、 字符串链接

符号：+
格式：str1 + str2
示例：
str1 = 'Hello '
str2 = 'world '
print(str1 + str2)
>> > Hello
world

(五)、字符串重复

符号： *
格式：str1 * num
示例：
str1 = 'Hello '
num = 3
print(str1 * num)
>> > Hello
Hello
Hello

2.字符串常用方法

(六)、 字符串拼接

方法：x.join(str)
# 以指定的字符连接生成一个新的字符串
示例：
str1 = 'Hello'
print('_'.join(str1))
>> > H_e_l_l_o

(七)、 字符串替换

方法：x.replace(old, new, count)
# old -- 指定的旧子字符串
# new -- 指定的新子字符串
# count -- 可选参数，替换的次数，默认为指定的旧子字符串在字符串中出现的总次数。
示例：
s = 'https://www.runoob.com/python/python-tutorial.html'
print('Python2教程地址：', s)
print('Python3教程地址：', s.replace('python', 'python3'))
>> > Python2教程地址： https: // www.runoob.com / python / python - tutorial.html
Python3教程地址： https: // www.runoob.com / python3 / python3 - tutorial.html

（八）、字符串去除

方法：x.strip(str)
# 去除字符串两边的指定字符串，中间的指定字符串不做处理，默认去除的是空格
示例：
# 去除空格
s = '  Alay  '
print(s.strip())
>> > Alay
# 去除指定字符
s = 'Alay'
print(s.strip('A'))
>> > lay

（九）、字符串切片

方法：x.split(str)
# 通过指定分隔符对字符串进行分割并返回一个列表
示例：
# str.split()默认以空格,换行\n,制表符\t分割
str1 = '我 是 Alay'
print(str1.split())
>> > ['我', '是', 'Alay']

# str.split(‘字符串’):以字符串为分割
str1 = '我 是 Alay'
print(str1.split('是'))
>> > ['我 ', ' Alay']

# str.split(‘字符串’,1):以字符串为分隔，分割1次
str2 = 'I am is Alay'
print(str2.split('a', 1))
>> > ['I ', 'm is Alay']

（十）、字符串个数统计

方法：x.count(str, start, end)
# 指定开始和结束范围来统计某字符串的个数，返回的是int类型
示例：
# 不指定范围，统计字符中所有出现字符出现的次数
s = 'unbelievable'
print(s.count('e'))
>> > 3
# 指定开始位置，统计从开始位置之后出现字符出现的次数
s = 'unbelievable'
print(s.count('e', 4))
>> > 2
# 指定开始位置和结束位置，统计从这个范围中出现字符出现的次数
s = 'unbelievable'
print(s.count('e', 4，7))
>> > 1

（十一）、字符串居中，两边默认以空格填充

方法：x.center(width[, fillchar])
# width -- 字符串的总宽度。
# fillchar -- 填充字符。
示例：
# 定义字符串的长度，不足长度时，两边以指定字符串进行填充
s = '游戏开始'
print(s.center(20, '*'))
>> > ** ** ** ** 游戏开始 ** ** ** **

（十二）、字符串查找

# 测字符串中是否包含指定检索的字符串str，如果包含返回字符串的索引值，不包含返回-1 
方法：x.find(str, beg, end)
# str – 指定检索的字符串
# beg – 开始索引，默认为0。
# end – 结束索引，默认为字符串的长度。
示例：
# 不指定范围，查找整个字符串
s = 'unbelievable'
print(s.find('b'))
>> > 2
# 指定开始位置，从字符串开始位置之后查找
s = 'unbelievable'
print(s.find('b', 5))
>> > 9
# 指定开始位置和结束位置，在这个范围里查找指定字符，有的话返回索引值，没有返回-1
s = 'unbelievable'
print(s.find('b', 5, 8))
>> > -1

三、列表（list）

用一个变量储存多个值，用中括号[]
括起来任意数据类型，中括号内，多个元素用逗号分割，列表是有序的，是可变类型。

# list
names = ['Alay', 'Lisa', 'Joyce']
print(names)
用途：存储多个值，如名单
>> > ['Alay', 'Lisa', 'Joyce']

1.列表常用操作

(一)、创建列表

list1 = []
print(list1)
>> > []

(二)、 列表拼接

list1 = [1, 2, 3, 4]
list2 = ['a', 'b', 'c', 'd']
print(list1 + list2)
>> > [1, 2, 3, 4, 'a', 'b', 'c', 'd']

(三)、列表重复

list1 = [1, 2, 3, 4]
print(list1 * 3)
>> > [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

(四)、列表切片（与字符串方法一样）

list1 = [1, 2, 3, 4, 5, 6]
print(list1[0])  # 下标第0个取1
print(list1[0:5])  # 提取下标从0到5，但是不包括5之间的字符->[1, 2, 3, 4, 5]
print(list1[:-2])  # 提取下标从0到-1，但是不包括-2之间的字符->[1, 2, 3, 4]
print(list1[0:5:2])  # 步长为正数，从list1 [0:5:2]中，从左往右的顺序，提取0-5之间，间隔了一个字符的字符，也就是提取下标0、2、4的字符。—>[1,3,5]
print(list1[0:2:-1])  # 步长为负数，第一个索引必须比第二个索引值要大，否则无法取值。
print(list1[4:2:-1])  # 以从右往左的顺序，提取4-2之间字符，也就是提取下标4,3的字符，取头不取尾，尾部下标为2不取。->[5,4]

(五)、列表更改元素（与字符串方法一样）

list1 = [1, 2, 3, 4, 5, 6]
list1[1] = 'aa'
print(list1)
>> > [1, 'aa', 3, 4, 5, 6]

（六）、列表删除

# del 删除列表中指定位置上的元素，也可以删除整个列表。
list1 = [1, 2, 3, 4, 5, 6]
del list1[1]
print(list1)
>> > [1, 3, 4, 5, 6]

2.列表常用方法

(一)、列表添加元素

# 1.append方法 在列表最后追加元素
l1 = ['a', 'b', 'c', 'd']
l1.append('e')
print(l1)
>> > ['a', 'b', 'c', 'd', 'e']

# 2.insert方法 在列表中插入元素。可以指定插入的位置
l1 = ['a', 'b', 'c', 'd', ]
l1.insert(3, 'x')  # 3 指定插入索引3这个位置，就是“d”，这个位置，把‘d’ 顶到了后面
print(l1)
>> > ['a', 'b', 'c', 'x', 'd']
# 3.extend方法 在列表中同时插入多个元素
l1 = [1, 2, 3, 4, 5, ]
l1.extend([6, 7, 8, 9])
print(l1)
>> > [1, 2, 3, 4, 5, 6, 7, 8, 9]

# extend方法使用以及与append方法的区别，append是整体添加，extend是逐个添加
l1.append([6, 7, 8, 9])
print(l1)
>> > [1, 2, 3, 4, 5, 6, 7, 8, 9, [6, 7, 8, 9]]

(二)、列表删除元素

# 1. del命令，删除列表中指定位置上的元素，也可以删除整个列表。
# 删除指定位置（下标）元素
l1 = [1, 2, 3, 4, 5]
del l1[0]
print(l1)
>> > [2, 3, 4, 5]
# 删除整个列表
del l1[:]
print(l1)
>> > []

# 2.pop() 删除并返回列表指定位置（默认为最后一个下标 -1）的元素。
l1 = [1, 2, 3, 4, 5, 6, ]
print(l1.pop())  # 删除并返回列表指定位置的元素
print(l1)
>> > 6
[1, 2, 3, 4, 5]

# 3.remove() 删除指定值
l1 = [1, 2, 3, 4, 5, 6, ]
l1.remove(4)  # 删除指定值
print(l1)
>> > [1, 2, 3, 5, 6]

# 4.clear() 保留列表名称，清空里面的值
l1 = [1, 2, 3, 4, 5, 6]
l1.clear()
print(l1)
>> > []

(二)、列表查找元素

# 1.count() 查找元素出现的次数
l1 = ['a', 'b', 'a', 'd', 'a', 'b', 'c']
print(l1.count('a'))
>> > 3

# 2.index() 返回查找元素的下标,默认搜索整个列表
l1 = ['a', 'b', 'a', 'd', 'a', 'b', 'c']
print(l1.index('a'))
>> > 0
# 返回指定切片内第一次出现的位置
l1 = ['a', 'b', 'a', 'd', 'a', 'b', 'c']
print(l1.index('a', 1, 5))
>> > 2

(四)、列表统计长度

# 1.len()
l1 = ['a', 'b', 'c', 'd', 'e']
print(len(l1))
>> > 5

(五)、列表统计元素个数

# 2.count
l1 = ['a', 'b', 'a', 'd', 'a', 'b', 'c']
print(l1.count('a'))
>> > 3

(六)、列表元素反序

# 1.reverse  反序排序
l1 = ['a', 1, 'b', 'c', 'd', 'e', 'b', 'c']
l1.reverse()
print(l1)
>> > ['c', 'b', 'e', 'd', 'c', 'b', 'a']
# 2.sort 按照ascii码来进行排序
l1 = ['a', '1', 'b', 'c', 'd', 'e', 'b', 'A', 'Z', 'c']
l1.sort()
print(l1)
l1.sort(reverse=True)  # reverse = True 降序， reverse = False 升序（默认）
print(l1)

(七)、列表enumerate对列表枚举（让列表有顺序）

# 1.enumerate enumerate多用于在for循环中得到计数
list1 = ["这", "是", "一个", "测试"]
for a, b in enumerate(list1):
    print(a, b)
>> > 0
这
1
是
2
一个
3
测试
# enumerate 还可以接收第二个参数，用于指定索引起始值
list1 = ["这", "是", "一个", "测试"]
for a, b in enumerate(list1, 1):
    print(a, b)
>> > 1 这
     2 是
     3 一个
     4 测试

(八)、列表复制

import copy

a = [1, 2, [3, 4], {'a': 1}]  # 原始对象
b = a  # 赋值，传对象的引用
c = copy.copy(a)  # 对象拷贝，浅拷贝
d = copy.deepcopy(a)  # 对象拷贝，深拷贝
e = a[:]  # 能复制序列，浅拷贝

a.append('add1')　　  # 修改对象a
a[2].append('add2')　　  # 修改对象a中的[3,4]数组对象
a[3] = '666'
print('a:', a)
print('b:', b)
print('c:', c)
print('d:', d)
print('e:', e)

>> >
a: [1, 2, [3, 4, 'add2'], '666', 'add1']
b: [1, 2, [3, 4, 'add2'], '666', 'add1']
c: [1, 2, [3, 4, 'add2'], {'a': 1}]
d: [1, 2, [3, 4], {'a': 1}]
e: [1, 2, [3, 4, 'add2'], {'a': 1}]
"""
解释：copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。子对象（数组）修改，也会修改
     copy.deepcopy 深拷贝 拷贝对象及其子对象（原始对象）
"""

四、元组（tuple）

与列表类型相比，非常类似只不过[]
换成()，作用：用于存储多个值，对比列表来说，元组不可变（是可以当做字典的key的），不可更改，主要是用来读。

# 定义形式：变量名 = (元素,元素,元素)
names = ('Alay', 'Lisa', 'Joyce')  # 储存多个人名字
Information = ('Alay', 20, 168)  # 储存一个人的信息
Informations = (('Alay', 20, 168), ('Lisa', 29, 170), ('Joyce', 32, 183))  # 储存多个人的信息
print(names)
>> > ('Alay', 'Lisa', 'Joyce')
print(Information)
>> > ('Alay', 20, 168)
print(Informations)
>> > (('Alay', 20, 168), ('Lisa', 29, 170), ('Joyce', 32, 183))

元组可以存储多个值，是有序的，是不可变类型，可以哈希。元组常用的方法，参考列表常用方法，需要注意的是，元组只能取值，而不能改变元组的值

五、字典（dict）

记录多个人信息时，要将人的姓名和年龄、身高查找对应的数据，如果用list就需要用到三个list，用dict
可以根据
姓名和年龄、身高直接查找对应的数据。
字典可以存储多个值，是无序的，是可变类型

# 定义形式：变量名 = {key:value,key:value,key:value}
# 储存一个人的信息
Information = {'name': 'Alay', 'age': 18, 'height': 168}
print(Information)
print(Information['age'])
>>>
{'name': 'Alay', 'age': 18, 'height': 168}
18

1. 字典常用方法

(一)、增加元素

# 1.dict['key'] = value 增加键值对
Information = {'name': 'Alay', 'age': 18, 'height': 168}
Information['gender'] = 'male'
print(Information)
>>> {'name': 'Alay', 'age': 18, 'height': 168, 'gender': 'male'}

# 2.formkeys()创建一个新的字典，并以可迭代对象中的元素分别作为字典中的键
"""
第一个参数li迭代循环的字典的key，第二个参数'I am Albert'表示value，
可以多个key循环对	应这个value，也可以只有一个key，也可以没有value
"""
a = l1.fromkeys(l1, 'I am Albert')
print(a)
>> > {'name': 'I am Albert', 'age': 'I am Albert', 'gender': 'I am Albert'}

b = dict.fromkeys('name')  # 必须有一个可迭代类型，作为字典的key
print(b)
>> > {'n': None, 'a': None, 'm': None, 'e': None}

b = dict.fromkeys('e')  # 也可以迭代
print(b)
>>> {'e': None}
>
# b = dict.fromkeys(1) #报错 数字类型不可迭代

b = dict.fromkeys([1, 2, 3, ])
print(b)
>>> {1: None, 2: None, 3: None}

(二)、修改元素

# 1.通过键值对修改
Information = {'name': 'Alay', 'age': 18, 'height': 168}
Information['gender'] = 'boy'
print(Information)
>>> {'name': 'Alay', 'age': 18, 'height': 168, 'gender': 'boy'}

# 2. 通过setdefault只添加不修改
Information = {'name': 'Alay', 'age': 18, 'height': 168}
Information.setdefault('gander', 'male')
print(Information)
>>> {'name': 'Alay', 'age': 18, 'height': 168, 'gander': 'male'}

# 3. 通过update即添加也修改
Information = {'name': 'Alay', 'age': 18, 'height': 168}
Information.update({'name': 'Lisa', 'gander': 'male'})  # 穿参方式与setdefault不同
print(Information)
>>> {'name': 'Lisa', 'age': 18, 'height': 168, 'gander': 'male'}

(三)、查询元素

# 1.通过键查找对应的值
Information = {'name': 'Alay', 'age': 18, 'height': 168}
a = Information['name']
print(a)
>>> Alay

# 2.通过get方法查找对应的值
Information = {'name': 'Alay', 'age': 18, 'height': 168}
a = Information.get('age')  # 找不到不报错
print(a)
>> > 18

# 3.通过enumerate 枚举，以序列的形式显示键
Information = {'name': 'Alay', 'age': 18, 'height': 168}
for a in enumerate(Information):
    print(a)
>>> (0, 'name')
(1, 'age')
(2, 'height')
# 4.通过.keys()获取字典的所有的键
Information = {
    'name': 'Alay',
    'age': 18,
    'gender': 'male',
}
a = Information.keys()  # 获取所有的键，可以转化为列表
print(a)
print(list(a)[0])  # 转化为列表，索引取值
>>> dict_keys(['name', 'age', 'gender'])
name

# 5.通过.values()获取字典所有的值
Information = {
    'name': 'Alay',
    'age': 18,
    'gender': 'male',
}
a = Information.values()  # 获取所有的值，可以转化为列表
print(a)
print(list(a)[0])  # 转化为列表，索引取值
>>> dict_values(['Alay', 18, 'male'])
Alay

# 6.通过.items()，获取所有键值对，每一个键值对应一个元祖，放在dict_items中
Information = {
    'name': 'Alay',
    'age': 18,
    'gender': 'male',
}
a = Information.items()
print(list(a)[0])  # 转化为列表，索引取值
>>> dict_items([('name', 'Alay'), ('age', 18), ('gender', 'male')])
('name', 'Alay')

# 7.通过for循环遍历，遍历出所有的键值对
Information = {
    'name': 'Alay',
    'age': 18,
    'gender': 'male',
}

for k, v in Information.items():
    print(k, v)
>>> name Alay
	age 18
	gender male

(三)、删除元素

# 1.del 通过字典的key删除键值对
Information = {
    'name': 'Alay',
    'age': 18,
    'gender': 'male',
}
del Information['name']
print(Information)
>>> {'age': 18, 'gender': 'male'}

# 2.pop 或者popitem删除
Information = {
    'name': 'Alay',
    'age': 18,
    'gender': 'male',
}
res = Information.pop('name')  # 删除指定key的value，并拿到一个返回值
print(res)
print(Information)
>>> Alay
	{'age': 18, 'gender': 'male'}

res2 = Information.popitem()  # 随机返回并删除字典中的一对键和值(一般删除末尾对)。
# 如果字典已经为空，却调用了此方法，就报出KeyError异常。
print(res2)
print(Information)
>>> ('gender', 'male')
	{'age': 18}

六、 集合（set）

过滤重复数据，用花括号括起来的元素，花括号内多个元素用逗号分割，每个元素可以是任意的数据类型，但是不能重复，集合是一个可变类型。

集合的元素遵循三个原则：
1: 每个元素必须是不可变类型(可作为字典的key)
2: 没有重复的元素
3: 无序
注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

# 定义形式：变量名 = {元素,元素,元素}
names = {'Alay', 'Lisa', 'Joyce', 'Alay'}  # 储存多个人名字
print(names)  # 因为set是无序的，所以打印的时候显示是乱序
>>
{'Lisa', 'Joyce', 'Alay'}
# 空集合定义形式：set()

1.集合常用方法

1.将列表转为集合，然后转换为列表，就可以得到一个没有重复元素的列表
2.交集、并集、补集

七、布尔值（bool）

判断一个条件成立时，用True标识，不成立则用False标识。

#布尔值，一个True一个False
>>> a=3
>>> b=5
>>> a > b #不成立就是False,即假
False
>>> a < b #成立就是True, 即真
True
# 接下来就可以根据条件结果来干不同的事情了：
if a > b:
   print(a is bigger than b )
else:
   print(a is smaller than b )
# 上面是伪代码，但意味着，计算机已经可以像人脑一样根据判断结果不同，来执行不同的动作。

• 布尔值重点知识

#所有数据类型都自带布尔值
1、None，0，空（空字符串，空列表，空字典等）三种情况下布尔值为False
2、其余均为真

• 可变类型与不可变类型（重点）

1.可变类型：在id不变的情况下，value可以变，则称为可变类型，如列表，字典
2.不可变类型：value一旦改变，id也改变，则称为不可变类型（id变，意味着创建了新的内存空间）