One—python的六种数据类型及数据转换

python的六种数据类型

python中数据类型分为不可变数据类型和可变数据类型

可变数据类型

可变数据类型包括：List（列表）、Dictionary（字典）、Set（集合）

不可变数据类型

不可编数据类型包括：Number（数字）、String（字符串）、Tuple（元组）

不可变数据类型与可变数据类型的区别

1. 不可变数据类型
   • 不可变数据类型赋值后会创建一个新的内存地址空间
   • 并让赋值数据指向这一新创建的地址，故两个变量的内存地址并不相同
   • 重新赋值的数据，绑定到了新的内存地址，而不是修改之前的内存地址

#不可变数据类型
str1 = "ascdfg"
str2 = str1
print(str2)
     
print("----------------------------")
str1 = "ooooooopo"
print(id(str1))
print(id(str2))
--------------------------------------------
ascdfg
----------------------------
2278845527984
2278844137392

 > 运行结果显示：内存地址不同

2. 可变数据类型

   • 可变数据类型赋值后不会创建新的内存地址空间

   • 赋值数据与被赋值数据还是同时指向同一块地址

#可变数据类型
list1 = [1,2,3]
list2 = list1 #将list1的值赋给list2
print("改变前")
print(list2) #输出list2

print("----------------------------")

list1[0] = 2 #将list1的第一个元素赋值为2

print("改变后")
print("list1:\t",id(list1))
print("list2:\t",id(list2))

运行结果显示：内存地址相同

Nmuber（数字）---不可变数据类型

1. 整型（int）-通常被称为是整型或整数，是正或负整数，不带小数点，在python3中不限制大小，可以当作Long类型使用。布尔（bool）是整型的子类型。
2. 浮点型（float）-浮点型由整数部分与小数部分组成，浮点型也可以用科学计数法表示。
3. 复数（conplex）-复数由实数部分和虚数部分构成，可以用a+bi，或者complex（a，b）表示，复数的实部a和虚部b都是浮点型。

String（字符串）---不可变数据类型

1. 字符串用单引号或双引号括起来，+号是字符串的连接符，星号*表示复制当前字符串，与之结合的数字为复制的次数。
2. python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
3. python中的字符串不能该改变

List（列表）---可变数据类型

1. 列表中元素类型可以不相同，支持数字，字符串甚至可以包含列表（所谓嵌套）
2. 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表

#列表截取
t = [1,5,6,7,2,9]
a = t[2:5]
b = t[2:]
print(a)
print(b)
---------------------------------------------------
[6, 7, 2]
[6, 7, 2, 9]

[2:5]是左闭右开的一个区间，故截取的是[6，2，7],而[2:]译为截取从编号2开始到最后一个

列表函数及方法

append()方法添加列表项,并对数据项进行修改或更新

#append()方法添加列表项
list1 = ['aaaa','qwe','zxc']
list2 = list1
print("第三个元素为",list1[2])
list1.append('cccccc')
print(list2)
---------------------------------------------------
第三个元素为 zxc
['aaaa', 'qwe', 'zxc', 'cccccc']

del语句删除列表元素

#使用del语句进行删除列表项
list1 = ['asd','zxc','qwe']
del list1[0]
print(list1)
---------------------------------------------------
['zxc', 'qwe']

len(list)函数查询列表元素个数

list1 = [1,2,5,6,8,2,4,2]
print(len(list1))
---------------------------------------------------
8

max(list)函数返回列表元素的最大值

list1 = [1,2,7,8,9,2,4,2]
print(max(list1))
---------------------------------------------------
9

min(list)函数返回列表元素的最小值

list1 = [1,2,7,8,9,2,4,2]
print(min(list1))
---------------------------------------------------
1

list(seq)函数将元组转换为列表

tup = ('asx','apple',1,5,5)
print("tup的数据类型为",type(tup))
list1 = list(tup) #将tup元组转换为列表并赋值给list1
print(list1)
print("list1的数据类型为",type(list1))
---------------------------------------------------
tup的数据类型为 <class 'tuple'>
['asx', 'apple', 1, 5, 5]
list1的数据类型为 <class 'list'>

list.count(obj)函数统计某个元素在列表中出现的次数

#count()方法统计某个元素在列表中出现的次数
list1 = [1,2,5,6,8,2,4,2]
list2 = list1.count(2)
print(list2)
---------------------------------------------------
3

list.extend(seq)函数在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

#extend()方法进行扩展列表
list1 = ['apple','qaz','wsx']
list2 = list(range(0,5)) #range()创建0-4的列表
list1.extend(list2)
print(list1)
---------------------------------------------------
['apple', 'qaz', 'wsx', 0, 1, 2, 3, 4]

list.index(obj)从列表中找出某个值第一个匹配项的索引位置

#index()从列表找出某一个值第一个匹配项的索引位置
list1 = [1,5,3,6,9,8]
print(list1.index(3))
---------------------------------------------------
2

list.insert(index,obj)将对象插入列表

#insert()将对象插入列表
list1 = ['apple','qaz','wsx']
list1.insert(1,'qwe') #insert(索引位置，要插入的对象)
print(list1)
---------------------------------------------------
['apple', 'qwe', 'qaz', 'wsx']

list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

#pop()移除列表的一个元素（默认最后一个元素），并返回该元素的值
list1 = ['apple','qaz','wsx']
list_pop = list1.pop(1)
print("删除项为",list_pop)
print("列表现在为",list1)
---------------------------------------------------
删除项为 qaz
列表现在为 ['apple', 'wsx']

list.remove(obj)移除列表中某个值的第一个匹配项

#remove()移除列表中某个值的第一个匹配项
list1 = ['qsd','apple','wsx','apple']
list_remove = list1.remove('apple')
print(list1)
---------------------------------------------------
['qsd', 'wsx', 'apple']

list.reverse()反向列表中的元素

#reverse()反向列表中的元素
list1 = ['apple','qaz','wsx']
list_re = list1.reverse()
print(list1)
---------------------------------------------------
['wsx', 'qaz', 'apple']

list.sort(key=None,reverse=False)对列表进行排序

#sort()对原列表进行排序
list1 = [1,5,3,6,9,8]
list0 = [1,6,4,2,3,8,1,9]
list2 = list0.sort(reverse=True) #reverse=true 降序
list3 = list1.sort(reverse=False) #reverse=falses 升序
print("降序",list0)
print("升序",list1)
---------------------------------------------------
降序 [9, 8, 6, 4, 3, 2, 1, 1]
升序 [1, 3, 5, 6, 8, 9]

list.clear()清空列表

#clear()清空列表
list1 = [1,5,3,6,9,8]
list1.clear()
print(list1)
---------------------------------------------------
[]

list.copy()复制列表

#copy()复制列表
list1 = [1,5,3,6,9,8]
list2 = list1.copy()
print(list2)
---------------------------------------------------
[1, 5, 3, 6, 9, 8]

Tuple（元组）---不可变数据类型

1. 元组的元素不能更改，指的是元组所指向的内存地址不可变
2. 元组使用小括号（），列表使用[]
3. 元组中元素使用逗号分隔
4. 元组中只包含一个元素时，需要在元组后面加逗号，否则括号会被当做运算符使用

tup1 = ("asd","asdasd",[1,2,5,9,8])
print(type(tup1))
print(tup1[-1])
---------------------------------------------------
<class 'tuple'>
[1, 2, 5, 9, 8]

Dictionary（字典）---可变数据类型

1. 字典是可变容器模型，可以存储任意类型对象
2. 字典的每个键值{key：value}对用冒号进行分割，每个对之间用逗号分隔，整个字典包括在大括号中{}
3. dict为python的关键字和内置函数，不能命名为变量
4. 键必须是唯一的，且键是不可变的，如字符串、数字。但值不必，值可以是任何数据类型
5. 字典值可以是任何python对象，可以是标准的，也可以是定义的，但键不行：（1）不允许同一个键出现两次，创建是如果同一个键被赋值两次，后一个值会被记住（2）键必须不可变，所以可以用数字，字符串或元组充当，而不能使用列表。

访问字典中的值（通过键去访问对应的值）

d = {"age":13,"sex":'男',"name":"lihua"}
print(d["sex"])
---------------------------------------------------
男

创建空字典的两种方法

#创建空字典法一
emptydict = {}
print(emptydict)
print(len(emptydict))
print(type(emptydict))
---------------------------------------------------
{}
0
<class 'dict'>

#创建空字典法二
emptydict1 = dict()
print(emptydict1)
print(len(emptydict1))
print(type(emptydict1))
---------------------------------------------------
{}
0
<class 'dict'>

修改字典

#修改字典
d = {"age":13,"sex":'男',"name":"lihua"}
d["age"] = 10 #更新age
d["school"] = "北京大学" #增添信息
print(d["age"])
print(d["school"])
---------------------------------------------------
10
北京大学

删除、添加字典元素

#删除字典元素
d = {"age":13,"sex":'男',"name":"lihua"}
d1 = dict() #创建空字典
d1["name"] = "张伟" #添加信息
print(d1["name"])
del d1["name"] #删除字典信息
d1.clear() #清除字典
print(d1)
---------------------------------------------------
张伟
{}

Set（集合）---可变数据类型

1. 集合是一个无序的不重复的元素序列
2. 可以使用大括号或set()函数创建集合（注：创建空集合必须用set()来创建，不可使用{}进行创建）

ax = {'apple','qwe','apple','lllsd','qwe'}
print(ax)
#创建集合
ax1 = set("adsa")
print(ax1)
#判断元素是否在集合中
z = 'apple' in ax
print(z)
---------------------------------------------------
{'qwe', 'lllsd', 'apple'}
{'a', 'd', 's'}
True

Python3中的数据转换

数据转换可分为两种：隐式类型转换--自动完成、显示类型转换--需要使用类型函数进行转换

隐式转换

1. 隐式转换中python会自动将一种数据类型转换成为另一种数据类型，不需要我们进行干预

将较低数据类型（整数）转换为较高数据类型（浮点数）以避免数据丢失

num_int = 123
num_float = 1.23

num_new = num_int + num_float

print("num_int的数据类型",type(num_int))
print("num_float的数据类型",type(num_float))

print("num_new的值",num_new)
print("num_new的数据类型",type(num_new))
---------------------------------------------------
num_int的数据类型 <class 'int'>
num_float的数据类型 <class 'float'>
num_new的值 124.23
num_new的数据类型 <class 'float'>

显示转换

由于整型和字符串类型相加运算结果会报错，输出TypeError，因此在这种情况下无法进行隐式转换。故python提供了一种解决方案称为显示转换。

• 在显示类型转换中，用户将对象的数据类型转换为所需的数据类型。
• 我们使用int()、float()、str()等预定义函数来执行显示类型转换

#显示类型转换
num_int = 123
num_str = "456"

print("num_int的数据类型",type(num_int))
print("类型转换前,num_str的数据类型",type(num_str))

num_str = int(num_str) #强制转换为整型
print("类型转换后,num_str的数据类型",type(num_str))

num_sum = num_int + num_str
print("num_int和num_str相加的结果为",num_sum)
print("sum的数据类型为",type(num_sum))
---------------------------------------------------
num_int的数据类型 <class 'int'>
类型转换前,num_str的数据类型 <class 'str'>
类型转换后,num_str的数据类型 <class 'int'>      
num_int和num_str相加的结果为 579
sum的数据类型为 <class 'int'>

Python推导式

python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构题，python支持各种数据结构的推导式。

列表（list）推导式

1. out_exp_res：列表生成元素表达式，可以是有返回值的函数
2. for out exp in input list：迭代input list将out exp传入到out exp res表达式中
3. if condition：条件语句，可以过滤列表中不符合条件的值

[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list]
或
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

#列表推导式
news = ['Tom','Bob','Smith','Lorry','James','Curry']
new_names = [name.upper() for name in news if len(name)>3]
print(new_names)
---------------------------------------------------
['SMITH', 'LORRY', 'JAMES', 'CURRY']

#计算从0到30可以整除3的整数
match_30 = [i for i in range(31) if i % 3 == 0]
print(match_30)
---------------------------------------------------
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]