第二章数据类型与数据类型转换

一、 数据类型

python3中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Sets（集合）
• Dictionary（字典）

注意：给变量赋值何种类型的常量，该变量就是对应类型的变量。

1、Number（数字）

• python3支持int(整型)、float(浮点型)、bool(布尔型)、complex（复数）。

整型 (int ) , 就是整数 , 即不带小数点的数。
浮点型( float ), 就是小数。
布尔类型(bool), 只有两个值

• 真 True , 1
• 假 False 0, 非 0 即真
  注意：
  True 和 False 都是 Python 中的关键字, 注意大小写,不要写错了。

复数类型 3 + 4i, 不会用的

• 在python3里，只有一种整数类型int，表示为长整型，没有python2中的long。
• 内置的type()函数可以用来查询变量所指的对象类型。
• 内置的id ()函数可以用来查询变量的内存空间地址。

注意：
python可以同时为多个变量赋值，如a,b=1,2。 一个变量可以通过赋值指向不同类型的对象。
数值的除法/总是返回一个浮点数，取整用//，取余用%。 在混合计算时，python会把整型转换成为浮点数。

2、String（字符串）

2.1 下标

下标(索引): 就是指字符在字符串中的位置编号, 这个编号就是下标。

这个编号一般来说都是从左到右进行编号的, 从 0 开始的(Python 中支持负数下标,从右到左进行编号的, 从-1 开始)。

下标作用: 可以使用下标获取字符串中某个位置的字符。

​语法:

字符串[下标]  # 获取指定位置的字符

2.2 切片

切片: 可以获取字符串中多个字符(多个字符的下标是有规律的, 等差数列

语法:

字符串[start:end:step]#起始值：结束值：步长

start 是开始位置的下标, end 是结束位置的下标(注意,不能取到这个位置的字符) step 步长,等差数列的差值,
所取的相邻字符下标之间的差值,默认是 1, 可以不写

str1 = "zhang san"#字符串是有序，有下标的，每一位可以通过下标来表示，从左到右，第一位0位，最有一位总长度减1
print(str1[0:4])#切片，中括号中的第一位表示起始位置下标，第二位表示截止位置下标，左闭右开
print(str1[0:len(str1)])#取整个字符串
print(str1[:])#取整个字符串
print(str1[0:])#取整个字符串
print(str1[0:-1])#-1代表最后一个字符的下标，也就是倒数第一位，因为左闭右开所以结果不包含最后一位的n
print(str1[0:9:2])#第三位数字代表步长，可以让切片结果跳着取，2代表隔1位去一个
print(str1[0:9:3])#代表隔2位取一个

2.3 转义

转义符：\n回车，\r换行。\t制表符，\代表一个反斜杠

• 转义符 \ n的前后内容进行换行输出

str1 = 'zhang\nsan'
print(str1)
#zhang
#san

• 字符串前面加一个r或R表示让字符串原样输出，即里面的转义符不转义

str2 = r'zhang\nsan'
print(str2) # zhang\nsan

• 两个str类型的对象之间可以使用+号运算符拼接在一起

str1 = "王者"
str2 = "荣耀"
str3 = str1 + str2 
print(str3) # 王者荣耀

• 如果+号运算符两边都是数值型，那么就会进行算术运算

a,b =1,2
print(a + b) # 3

• 使用*运算符进行重复输出，输出多少个取决于运算符后面数字

str1 = "王者"
print(str1 * 3) # 王者王者王者

2.4 字符串常用操作方法

• 判断字符串是否为纯数字isdigit( )

列表.isdigit() #如果为真，返回 True ,如果为假，返回 False

str1 ="zhangsan"
print(str1.isdigit()) # False

• 判断是否是纯大写isupper( )

列表.isupper()#如果为真，返回 True ,如果为假，返回 False

str1 ="zhangsan"
print(str1.isupper()) # False

• 判断是否是纯小写islower( )

列表.islower()#如果为真，返回 True ,如果为假，返回 False

str1 ="zhangsan"
print(str1.islower()) # True

• 判断是否是纯字母isalpha( )

列表.isalpha()#如果为真，返回 True ,如果为假，返回 False

str1 ="zhangsan"
print(str1.isalpha()) # True

• 判断是否字母或者数字isalnum( )

列表.isalnum()#如果为真，返回 True ,如果为假，返回 False

str1 ="zhangsan"
print(str1.isalnum()) # True

• 字符串的查找find( )

字符串.find(sub_str, start, end)
作用: 在字符串中查找是否存在 sub_str 这样的字符串。

• sub_str: 要查找的小的字符串。
• start: 开始位置, 从哪个下标位置开始查找, 一般不写,默认是 0
• end: 结束位置, 查找到哪个下标结束, 一般不写,默认是 len()
• 返回(代码执行之后会得到什么, 如果有返回,就可以使用变量保存):
  注意：
  （1）如果在字符串中找到了 sub_str , 返回 sub_str 第一次出现的正数下标（sub_str 中第一个字符在大字符串中的下标）
  （2）如果没有找到,返回 -1

str1 = "and itcast and itheima and Python"
num = str1.find('and')# 在字符串中查找 and
num1 = str1.find('and', num+1)# 在字符串中查找 第二个 and 出现的下标, 从第一次出现的后一位开始找

• 字符串的替换replace( )

字符串.replace(old_str, new_str, count) # 将字符串中 old_str 替换为 new_str

• old_str: 被替换的内容。
• new_str: 替换为的内容。
• count: 替换的次数, 一般不写,默认是全部替换。
• 返回: 替换之后的完整的字符串, 注意: 原来的字符串没有发生改变。

str1 ="zhangsan"
print(str1.replace('a','u'))#将字符串中的a全部替换为u
print(str1.replace('a','u',1))#只替换1次

• 字符串的链接join( )

字符串.join(列表) # 括号中的内容主要是列表,可以是其他容器
作用: 将字符串插入到列表中每相邻的两个数据之间, 组成一个新的字符串。

• 列表中的数据使用使用逗号隔开的。
• 注意点: 列表中的数据必须都是字符串, 否则会报错。

list1 = ['1','2','3']
print(''.join(list1))#可以将列表转换成字符串

• 字符串拆分split( )

字符串.split(sep, maxsplit) # 将字符串按照 sep 进行分割(拆分)

• sep, 字符串按照什么进行拆分, 默认是空白字符(空格, 换行\n, tab键\t)。
• max_split, 分割次数,一般不写, 全部分割。
• 返回: 将一个字符串拆分为多个,存到列表中。

注意: 如果 sep 不写, 想要指定分割次数 则需要按照如下方式使用。字符串.split(maxsplit=n) # n 是次数

str1 ="zhangsan"
print(str1.split('a'))#将字符串使用指定的字符串分割，以列表形式返回
print(str1.split('a',1))#分割1次

总结：可变对象修改之后，前后地址不变；不可变对象修改之后，前后地址会变

3、列表

3.1 列表定义

• 列表是写在方括号[]之间、用逗号隔开的元素列表。

list1 = [1,2,3]

• 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

list1 = list() #方式一：定义一个空列表
#list1 = [] #方式二：定义一个空列表
list2 = [1,2,3,'abc']#列表中可以存在不同类型的对象
list3 = [1,2,3,'abc',['a','b']]#嵌套列表

3.2 列表切片

• 列表支持下标和切片操作, 使用方法和字符串中的使用方法一致。
• 区别: 列表的切片得到的是列表列。

变量[头下标:尾下标]；#索引值以0为开始值，-1为从末尾的开始位置

list1 = [1,2,3,4,5,6,7,8,9,10]
print(list1[:])#输出整个列表
print(list1[0:10])#输出整个列表
print(list1[0:len(list1)])#输出整个列表
print(list1[0:10:2])#步长为2，每隔一位取一个

3.3 列表拼接

• 加号+是列表连接运算符

list1 = [1,2,3]
list2 = ['a','b','c']
print(list1 + list2)#列表拼接
#[1, 2, 3, 'a', 'b', 'c']

• 星号*是重复添加的操作

list1 = [1,2,3]
print(list1 * 2)#将列表当中成员重复添加
#[1, 2, 3, 1, 2, 3]

3.4 列表替换

• 与python字符串不一样的是，列表中的元素是可以改变的

list1 = ['a','b','c']
list1[1] = 'B'
print(list1)

总结：
（1）字符串和列表都有序（即支持索引下标）；
（2）支持切片；字符串定义用引号，列表用中括号；
（3）字符串成员不可以通过下标修改，列表可以

3.5 列表的常见操作方法

• 查找下标的方法 index( )

列表.index(数据, start, end) 使用和 find 方法一样, 同时在字符串中也有 index 方法。
区别: 返回, index() 方法,找到返回第一次出现的下标, 没有找到代码直接报错。

list1 = ['a','b','c']
print(list1[1])#查询列表中下标为1的数据
result =list1.index('b')#查询列表中b的下标
print(result) # 1

• 更改列表数据的方法

list1 = ['a','b','c']
list1[1] = 11#将下标为1的数据更改为11

• 尾部添加的方法 append( )

列表.append(数据) # 将数据添加到列表的尾部
返回: 返回的 None(关键字,空), 一般就不再使用 变量 来保存返回的内容。

list1 = ['a','b','c']
list1.append(12)#列表尾部添加一个数据12
print(list1)#['a', 'b', 'c', 12]

• 指定下标位置添加的方法 insert( )

列表.insert(下标, 数据) # 在指定的下标位置添加数据, 如果指定的下标位置本来有数据, 原数据会后移 ​。
返回: 返回的None(关键字,空), 一般就不再使用 变量 来保存返回的内容。

list1 = ['a','b','c']
list1.insert(1,'aa')#在下标为1的位置进行添加
print(list1) # ['a', 'aa', 'b', 'c']

• 列表合并的方法 extend( )

列表1.extend(列表2) # 将列表 2 中的所有数据逐个添加的列表1 的尾部
返回: 返回的 None(关键字,空)，一般就不再使用 变量 来保存返回的内容 。

list1 = ['a','b','c']
list2 = [1,2,3]
list1.extend(list2)#将列表1和列表2合并在一起
print(list1) #['a', 'b', 'c', 1, 2, 3]

• 删除指定下标 pop( )

列表.pop(下标) # 删除指定下标位置对应的数据

1. 下标不写,默认删除最后一个数据(常用)
2. 书写存在的下标, 删除对应下标位置的数据
   返回: 返回的删除的数据

list1 = ['a','b','c']
list1.pop(0)#删除指定下标的成员
print(list1)#['b', 'c']

• 删除指定成员 remove( )

列表.remove(数据值) # 根据数据值删除 ​
返回: None
注意: 如果要删除的数据不存在, 会报错

list1 = ['a','b','c']
list1.remove('a')#删除指定内容的成员
print(list1)#['b', 'c']

• 清空列表 clear( )

列表.clear() #一般不用
列表 = [] 等同于 列表.clear()

list1 = ['a','b','c']
list1.clear()#清空列表
list1 = []#将一个空列表赋给它，相当于清空
print(list1)#[]

• 判断是否存在 in

判断容器中某个数据是否存在可以使用 in 关键字。
​数据 in 容器 # 如果存在返回 True ,如果不存在,返回 False

list1 = ['a','b','c']
if 'a' in list1: # 判断a是否在列表中
    print('在列表中！')
else:
    print('不在列表中！')

• 统计指定对象的个数 count( )

列表.count(被测值)
功能：统计被测值出现的次数

list1 = ['a','b','c']
print(list1.count('b'))

• 复制列表 copy( )

将列表中的数据复制一份,给到一个新的列表。
使用场景: 有一个列表, 需要修改操作列表中的数据, 修改之后, 需要和原数据进行对比,即原数据不能改
（1）使用切片 变量 = 列表[:]
（2）使用 copy 方法 变量 = 列表.copy()

list1 = ['a','b','c']
list2 = list1.copy()
print(list2) # ['a','b','c']

• 排序

列表的排序, 一般来说都是对数字进行排序的
列表.sort() # 按照升序排序, 从小到大
列表.sort(reverse=True) # 降序排序, 从大到小
列表.reverse() #反序，倒置列表，列表反转

list1 = ['a','b','c']
list1.sort()#升序  ['a','b','c']
list1.sort(reverse=True)#降序  ['c', 'b', 'a']
list1.reverse()#反序  ['c', 'b', 'a']

4、元组

4.1 元组定义

• 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号里()，元素之间用逗号隔开

tuple1 = ()#定义一个空元组

• 元组中的元素类型也可以不相同，元组用小括号定义，里面可以放置不同类型的对象，甚至嵌套

tuple1 = (1,2,3,'aa',(11,22))#定义一个嵌套元组

4.2 元组拼接

• 元组通过加号+运算符进行拼接

tuple1 = (1,2,3)
tuple2 = (11,12,13)
print(tuple1 + tuple2)#元组的拼接

• 星号*在元组中重复添加

tuple1 = (1,2,3)
print(tuple1 * 3)#在元祖中重复添加
print(tuple1)#(1, 2, 3, 1, 2, 3, 1, 2, 3)

4.3 元组切片

• 元组与字符串类似，可以被索引且下标索引从0开始，-1为从末尾开始的位置，也可以进行截取

tuple1 = (1,2,3,4,5,6,7)
print(tuple1[:])# (1, 2, 3, 4, 5, 6, 7)
print(tuple1[0:-1])#(1, 2, 3, 4, 5, 6)
print(tuple1[0:7:2])#(1, 3, 5, 7)

4.4 元组的常见操作方法

• 查

tuple1 = (1,2,3)
print(tuple1[1])#查下标为1的对象
print(tuple1.index(2,0,len(tuple1)))#查对象2的首次出现的下标

• 统计

tuple1 = (1,2,3)
print(tuple1.count(2))#统计对象2的个数

小结：元组用（）定义，支持索引下标和切片，不支持修改元组内数据。

5、集合

5.1 集合定义

• 集合（set）是一个无序不重复元素的序列

python set1 = set()#定义一个空集合 

注意：集合无序，不支持索引下标，更不支持切片截取

5.2 集合运算

• 并集 |

集合1 | 集合2 # 集合1和集合2所有元素合并在一起，自动去重

set1 = {1,2,3,4}
set2 = {3,4,5,6}
print(set1 | set2) #{1, 2, 3, 4, 5, 6}

• 差集 -

集合1 - 集合2 # 从集合1中去掉集合1和集合2相交的数

set1 = {1,2,3,4}
set2 = {3,4,5,6}
print(set1 - set2) #{1, 2}

• 交集 &

集合1 & 集合2 # 集合1和集合2相交的数

set1 = {1,2,3,4}
set2 = {3,4,5,6}
print(set1 & set2) #{3, 4}

• 异或 ^

集合1 ^ 集合2 # 取两边不同时存在的元素

set1 = {1,2,3,4}
set2 = {3,4,5,6}
print(set1 ^ set2) #{1, 2, 5, 6}

5.3 集合的常见操作方法

• 删

集合.remove(字符)#删除指定字符
集合.clear()#清空集合

set1 = {'zhangsan','lisi','wangmazi'}
set1.remove('lisi') # 删除指定字符
print(set1) # {'zhangsan','wangmazi'}
set1.clear() # 清空集合
print(set1) # {}

• 增

集合.add(字符)#添加成员
集合.update({字符})#将wangwu加入集合

set1 = {'zhangsan','lisi','wangmazi'}
set1.add('wangwu')#添加成员
print(set1) # {'wangwu', 'zhangsan', 'wangmazi', 'lisi'}
set1.update({'wangwu'})#将wangwu加入集合
print(set1) # {'zhangsan', 'lisi', 'wangwu', 'wangmazi'}

• 复制

集合.copy()

set1 = {'zhangsan','lisi','wangmazi'}
set2 = set1.copy()#将set1集合复制到set2集合中
print(set2) # {'zhangsan','lisi','wangmazi'}

6、字典

6.1 字典的定义

• 字典（dictionary）是python中另一个非常有用的内置数据类型。
• 字典 dict, 字典中的数据是由键(key)值(value)对组成的(键表示数据的名字, 值就是具体的数据)。
• 在字典中一组键值对是一个数据, 多个键值对之间使用 逗号隔开。
  变量 = {key: value, key:value, …}

dict1 = {}#定义一个空字典

注意：
（1）字典无序，不支持索引下标。
（2）一个字典中的键是唯一的,不能重复的, 值可以是任意数据。
（3） 字典中的键 一般都是 字符串,可以是数字, 不能是列表。

6.2 字典的常用操作

• 增加和修改键值

语法: 字典[键] = 数据值
（1）如果键已经存在,就是修改数据值
（2）如果键不存在,就是添加数据(即添加键值对)

dict1 = {'name':'张三','age':18}
dict1['sex'] = '男'#再加一个sex键，键值为男
print(dict1)#{'name': '张三', 'age': 18, 'sex': '男'}
dict1['age'] = 20#修改健名为age的键值
print(dict1) # {'name': '张三', 'age': 20, 'sex': '男'}

• 删除

del 字典[键] or 字典.pop(键) # 键必须书写
字典.clear() # 清空

dict1 = {'name':'张三','age':18}
del dict1['name']#删除指定键值
#{'age':18}
dict1.pop('name')#删除指定键值
#{'age':18}
dict1.clear()#清空字典
#{}

• 返回

字典.keys()#返回所有健名
字典.values()#返回所有键值
字典.get(‘name’)#返回所有对应键的值

dict1 = {'name':'张三','age':18}
print(dict1.keys())#返回所有健名
#dict_keys(['name', 'age'])
print(dict1.values())#返回所有键值
#dict_values(['张三', 18])
print(dict1.get('name'))#返回所有对应键的值
#张三

列表是有序的对象集合，字典是无序的对象结合。

二、数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，只需要将数据类型作为函数名即可。

1、 整型转换成float型

a = 5
b = float(a) # 5.0

2、float型转化为int型

自动去掉小数据，仅保留整数，不会四舍五入。

a = 5.5
b = int(a) # 5

3、数值型转换字符型

a = 5
b = str(a) # 5

4、将字符串转int型

只能将纯数字的字符串转化为数值型，不然会报错。

a = '5'
b = int(a) # 5

5、将字符串的算数表达式进行计算

a = '1 + 2'
b = eval(a) #3

6、将字符串对象转化为列表

每个字符，包括字符都是列表的一个成员。

a = 'zhang san'
b = list(a)#['z', 'h', 'a', 'n', 'g', ' ', 's', 'a', 'n']

7、将字符串对象转化为元组

每个字符，包括字符都是元组的一个成员。

a = 'zhang san'
b = tuple(a)#('z', 'h', 'a', 'n', 'g', ' ', 's', 'a', 'n')

8、将字符串对象转化为集合

自动去重，每个字符，包括字符都是集合的一个成员。

a = 'zhang san'
b = set(a)#{' ', 'z', 'n', 'h', 's', 'a', 'g'}

9、进制转换

bin( ) ：二进制转换
oct( ) ：八进制转换
hex( )：十六进制转换

a = 9#十进制
print(bin(a))#转二进制
#0b1001
print(oct(a))#转八进制
#0o11
print(hex(a))#转十六进制
#0x9