Python基础——— 数据类型详解

Python基础——— 数据类型详解

在这一个多月的时间里，Python基础基本已经学习完成。在接下来的一段时间里，我主要把自己学习中的一些代码和易出现问题的地方，在这里再次备注方便自己之后的复习、再学习。

八大数据类型

Python作为弱类型语言，对于数据的各种类型的使用，我们不需要像C语言一样，需要提前声明。在Python中，你需要一个变量直接创建就可以了，Python解释器本身会自己识别各个类型，并存入相应的内存中，以便我们后续对变量的操作。
Python的六大数据类型主要有：number、string、tuple、list、set、dictionary、Boolean、None

1.number(数字)

在数字类型中，python又有整数(int)、浮点数(float)、复数(complex)

(1)三种数字类型的基本使用

1) int

python中对于整数型数字类型的使用较为常见，不但包括正整数且包含负整数均可在python中进行你想要的处理。并且，我们不需要提前声明变量，什么时间用什么时间直接赋值即可。

a.赋值方式

单个变量赋值和多变量同时赋值

1.单变量赋值

int_01 = 9
int_02 = -2
print('正整数{}，负整数{}'.format(int_01,int_02))

2.多变量赋值

int_01 = int_02 = 4
int_03,int_04 = 9,-2
print('多变量赋值整数_01{}，多变量赋值整数_02{}'.format(int_01,int_02))
print('正整数{}，负整数{}'.format(int_03,int_04))

2) float

浮点数是由整数部分和小数部分组成，因此我们在进行浮点数的运算时小数的保留位数是必须考虑的问题。
浮点数的赋值和使用方式可以参考int型变量。

3) complex

学习过复变函数这门课的都应该知道，复数是由实部和虚部两部分组成。表示方式 a+bj 或者complex(a,b)。

#**input**
	complex_01 = 1+9j
	complex_02 = 2+7j
	print(complex_01 +complex_02)
	
	#**output**
	(3+16j)

(2)数字类型之间的相互转换

1) int(a)

将任意类型的a转换为整数

2) float(a)

将任意类型的a转换为浮点数

3) warning(注意事项)

我们在进行数据类型转换中，一般我们使用UTF-8的规则进行转换，当转换中规则中不存在时就会出现报错。

(3)常见的内置函数

abs(x)--------------取X（数字类型）的绝对值
max(x,y,z…)---------比较括号内参数的大小，并返回最大值
min(x,y,z…)-----------比较括号内参数的大小，并返回最小值
pow(x,y)---------------求x的y次方

2.string(字符串)

(1)字符串的创建方式

我们使用单引号或者双引号将任意文本内容包含起来形成字符串。

(2)字符串的使用方式

字符串和字符串直接的连接。

#**input**
	str_01 ='时间' 
	str_02 ='都去哪了'
	str_03 = str_01 +str_02
	print('str_03 = ',str_03)
	
	#**output**
	str_03 =  时间都去哪了

想重复输入多个字符串，直接使用 * 即可

#**input**
	str_04 = '*'*30
	print(str_04)
	
	#**output**
	******************************

(3)字符串的访问

访问字符串的格式：字符串名[下标] or 字符串名[start:end] or 字符串名[:] __开始和结束可以选择性省略
warning:索引的启始下标为0

#**input**
	str_05 = 'python真好玩！'
	print(str_05[6])
	print(str_05[0:6])

	#**output**
	真
	python

(4)数据类型的转换

将别的数据类型转换为字符串类型：和三种数字类型的转换格式一样—str(a)__将参数a强转为字符串类型

#**input**
	int_06 = 123456
	print(str(int_06))
	print(type(str(int_06)))
	
	#**output**
	123456
	<class 'str'>

(5)格式化输出

除字符串的格式化输出外，还有整数和浮点数的格式化输出的问题。
整数：%d
浮点数：%f
字符串：%s

a. 使用%的形式格式化输出

#**input**
	int_01 = 123
	float_01 = 12.34
	str_01 = '小明'
	print('%s 今年 %d 岁，每天有%.2f 元零花钱！'%(str_01,int_01,float_01))

	#**output**
	小明 今年 123 岁，每天有12.34 元零花钱！

b.使用format的形式格式化输出

#**input**
	int_01 = 123
	float_01 = 12.34
	str_01 = '小明'
	print('{} 今年 {}岁，每天有{} 元零花钱！'.format(str_01,int_01,float_01))

	#**output**
	小明 今年 123岁，每天有12.34 元零花钱！

(6)字符串与转义字符

转义字符在字符串的输入或输出的过程中极为常见，单个或多个转义符又或者配合字母使用可以出现极好的效果。

1) \ \‘ 和\“

上述的这三种较为常见的转义字符的用法，主要是前面的转义字符转义后面的内容，使得后者可以正常输出。

#**input**
	print('\"时\"间\'都\'去\\哪了')
	
	#**output**
	"时"间'都'去\哪了

2) \n 和 \t

\n：换行符，表示一个字符。和我们键盘中常用的enter键，具有部分相同的功能
\t：制表符，默认4个空格。和我们键盘中常用的Tab键，具有部分相同的功能

#**input**
	print('时间\n\t都去哪了！！')
	
	#**output**
	时间
		都去哪了！！

3) 字符串前使用 ：r

python中在字符串前使用r，表示内部的字符串默认不转义，以可见形式输出。

3.tuple(元组)

元组最大的特点是，有序，不可以进行增加、删除、更改。

(1) 创建元组

格式：元组名 = (元素1,元素2,元素3…)
元组名 = 元素1,元素2,元素3…

#input
tuple_01 = (1,2,3,'dog','猫')
tuple_02 = 1,2,3,'dog','猫'

print('tuple_01 = {},tuple_02 = {}'.format(tuple_01,tuple_02))
print(type(tuple_01))
print(type(tuple_02))

#output
tuple_01 = (1, 2, 3, 'dog', '猫'),tuple_02 = (1, 2, 3, 'dog', '猫')
<class 'tuple'>
<class 'tuple'>

(2) 常见的内置函数

1、len(tuple)：计算元组元素个数。
2、max(tuple)：返回元组中元素最大值。
3、min(tuple)：返回元组中元素最小值。
4、tuple(seq)：将列表转换为元组。
5、count()：查找元素在tuple中出现的次数。
6、index()：查找元素的索引值。

(3) 元组的访问

1.访问格式：元组名[下标]
warning:下标从0 开始，且当我们使用负数下标时，是从尾部先开始访问
2.部分访问格式：元组名[开始下标:结束下标]
从开始下标开始访问元组，到结束下标之前结束访问。

(4) 元组的操作

由于元组一旦定义不可改变的性质，元组可进行操作的方式较少。主要有：元组相加、元组重复、判断元素是否在元组中、删除整个元组（目前我用到的也就这几个八）

1)元组相加

#input
tuple_01 = (1,2,3,'dog','猫')
tuple_02 = 1,2,3,'dog','猫'
tuple_03 = tuple_01 +tuple_02
print(tuple_03)

#output
(1, 2, 3, 'dog', '猫', 1, 2, 3, 'dog', '猫')

2)元组重复

#input
tuple_01 = (1,2,3,'dog','猫')
tuple_03 = tuple_01 *3
print(tuple_03)

#output
(1, 2, 3, 'dog', '猫', 1, 2, 3, 'dog', '猫', 1, 2, 3, 'dog', '猫')

3)判断元素是否在元组中

#input
tuple_01 = (1,2,3,'dog','猫')
print('dog' in tuple_01)

#output
True

4)删除整个元组

#input
tuple_01 = (1,2,3,'dog','猫')
del tuple_01
print( tuple_01)

#output
NameError: name 'tuple_01' is not defined #元组被删除后，地址不存在无法访问

4.list(列表)

列表可以进行增删改所有操作且有序，因此灵活性很高。在python运用极为广泛。

(1)创建列表

创建列表格式：列表名 = [列表选项1,列表选项2,列表选项3…]

#input
list_01 = []
print(type(list_01))

#output
<class 'list'>

(2)列表的访问

列表的访问和元组基本相同，均是通过下标进行访问，且从0开始,唯一不同的是访问格式，元组是小括号包括下标、列表是中括号包括下标

#input
list_02 = ['时间','都','去哪了','']
print(list_02[2])
print(list_02[0:3])

#output
去哪了
['时间', '都', '去哪了']

(3)常见的内置函数

1、len(liste)：计算列表元素个数。
2、max(list)：返回列表中元素最大值。
3、min(list)：返回列表中元素最小值。
4、list(tuple)：将元组转成列表。
5、count()：查找元素在tuple中出现的次数。
6、index()：查找元素的索引值。
7、sort()：升序排列
8、reverse():倒序排列

(4)列表的操作

列表的操作主要包括以下几种：增加、删除、替换

1)增加

a.append()

在列表的最后添加一个新的元素(这个新的元素可以是一个数，也可以是一个列表)，新的元素放在append()括号内。

#input
list_05 = [0,1,2,3,4,5]
list_05.append(10)
print(list_05)

#output
[0, 1, 2, 3, 4, 5, 10]

b.extend()

在列表末尾增加一个列表中的多个值，使其组成新的长列表。

#input
list_05 = [0,1,2,3,4,5]
list_05.extend([10,11,12])
print(list_05)

#output
[0, 1, 2, 3, 4, 5, 10, 11, 12]

c.insert()

insert()的括号内放下标和需要添加的新元素：insert(1,10),不覆盖原有的列表数据，原来的数据向后直接延伸即可得到新的列表。

#input
list_05 = [0,1,2,3,4,5]
list_05.insert(0,[10,11,12])
print(list_05)

#output
[[10, 11, 12], 0, 1, 2, 3, 4, 5]

2)删除

a.pop()

移除列表中指定下标处的元素（未指定下标时，默认移除最后一个元素），并返回删除的数据

#input
list_05 = [0,1,2,3,4,5]
a = list_05.pop()
b = list_05.pop(1)
c = list_05.pop(-2)
print(a,b,c)

#output
5 1 3

b.remove()

移除列表中的某个元素，当移除元素为多个时，优先匹配第一个元素

#input
list_04 = [1,2,2,3,4,5,5]
list_04.remove(2)
print(list_04)

#output
[1, 2, 3, 4, 5, 5]

c.clear() or del

清除列表中所有元素

#input
list_03 = [1,2,'dog','cat',(1,2)]
list_03.clear()
print(list_03)

#output
[]

warning：clear仅仅是清空列表内的所有内容，列表地址依旧存在。del是连同地址一起删除

3)替换

可以使用赋值的方式直接替换列表中某个元素

#input
list_03 = [1,2,'dog','cat',(1,2)]
list_03[2] = 3
print(list_03)

#output
[1, 2, 3, 'cat', (1, 2)]

5.set(集合)

无序的不重复的元素。

(1)创建集合

1. set_01 = set() #创建空集合
2. set_02 = set([1,2,3,3,4,4,5])
   创建集合，我们首先需要一个tuple或者list或者dict作为集合的参数，输入进去。集合会自动过滤重复的元素

(2)集合的操作

增加元素和删除元素

1)增加元素

1. add() 可以添加一个元素，也可以添加一个元组、列表等
2. update()
   t1 = (‘时间’,’好日子’)
   set_01.update(t1)

2)删除元素

1. remove()
   如果元素存在则删除，不存在则报错_keyerror
2. pop()
   随机删除 （一般删除第一个元素）
3. clear()
   删除所有元素
4. dicard()
   类似remove() ,但移除不存在的元素不会报错

(3)集合的符号操作

1. In
2. == 判断两个集合中的内容是否相等
3. !=
4. +集合不支持加号
5. -表示差集，difference()和减号的功能相同 eg: set_1 = set1-set2/set_1 = set1.difference(set2)
6. *集合不支持乘号
7. & 表示交集 ，相应的函数 intersection() 使用方法同差集
8. | 表示并集，相应的函数 union()
9. ^ 表示对称差集，求得的是两个集合中的不同元素，对应函数 symmetric_difference()

(4)不可变集合

frozenset()为不可变的集合，而set()则为可变集合。
从字面意思很容易明白他俩的区别，一个可进行增删改另一个不可以进行。

6.dictionary(字典)

字典是无序的，查找和储存均以键值对（key：value）的形式存在。

(1)创建字典

字典的创建格式：字典名 = {key1:value,key2:value......}

字典中的每一个key值是唯一的、不可改变的，查找value通过key实现极为方便、快捷

(2)字典的访问

字典的访问主要是通过key值来进行。
格式：字典名[key]

1)直接通过key值访问

#input
dict_01 = {
     '小明':18,'小红':19,'小刚':17}
a = dict_01['小明']
print(a)

#output
18

使用该方式时，如果访问的key值不存在，程序将会报错：KeyError: '小黑’

2)使用 字典名.get(key)

#input
dict_01 = {
     '小明':18,'小红':19,'小刚':17}
a = dict_01.get('小黑')
print(a)

#output
None

使用此方式访问字典中数据时，当访问的key值不存在时，返回None。该方式在我们写项目时较为常用。

(3)字典的操作

字典的操作主要有：增加、删除、替换以及遍历

1)增加

可以直接使用新的key值进行赋值即可。

#input
dict_01 = {
     '小明':18,'小红':19,'小刚':17}
dict_01['小黑'] = 24
print(dict_01)

#output
{
     '小明': 18, '小红': 19, '小刚': 17, '小黑': 24}

2)删除

a. del dict[key]

#input
dict_01 = {
     '小明':18,'小红':19,'小刚':17}
del dict_01['小明']
print(dict_01)

#output
{
     '小红': 19, '小刚': 17}

b. dict.pop(key,[default])

删除成功，返回key对应的value值。删除失败，返回default定义的值，中括号内的可省略
Eg: result = dict_1.pop(‘张三’,’字典中没有此键’)
1.

#input
dict_01 = {
     '小明':18,'小红':19,'小刚':17}
a = dict_01.pop('小明')
print(dict_01)
print(a)

#output
{
     '小红': 19, '小刚': 17}
18

#input
dict_01 = {
     '小明':18,'小红':19,'小刚':17}
a = dict_01.pop('小黑','字典中没有该key值')
print(dict_01)
print(a)

#output
{
     '小明': 18, '小红': 19, '小刚': 17}
字典中没有该key值

c. dict.popitem()

删除字典中最后一对键值对，然后将他们均返回出来

#input
dict_01 = {
     '小明':18,'小红':19,'小刚':17}
key_01,value_01 = dict_01.popitem()
print(dict_01)
print(key_01)
print(value_01)

#output
{
     '小明': 18, '小红': 19}
小刚
17

d. dict.clear()

clear() 同列表的clear()。清除字典内的所有内容

#input
dict_01 = {
     '小明':18,'小红':19,'小刚':17}
dict_01.clear()
print(dict_01)

#output
{
     }

3)替换

替换的原理和增加字典元素是基本相同的。
替换是对字典中已有元素进行赋值。

#input
dict_01 = {
     '小明':18,'小红':19,'小刚':17}
dict_01['小明'] = 24
print(dict_01)

#output
{
     '小明': 24, '小红': 19, '小刚': 17}

(4)字典的内置函数

1、items()：将字典里对应的一对键和值以元组的形式（键, 值），存储为所生成序列里的单个元素
2、keys()：将字典里的每个键以字符串的形式，存储为所生成序列里的单个元素
3、values()：将字典里的每个值以字符串的形式，存储为所生成序列里的单个元素

7.Boolean(布尔型)

布尔型共有两种：True or Flase
该数据类型，在返回值中极为常见，如：

a = 1
b = 2
if a > b：
	print(a)
else:
	print(b)

上述程序中，if函数在判断过程中的返回值即是Boolean

8.None(空值)

这一数字类型是除了Boolean中包含的True和Flase之外的另一特殊的数字类型。在python中主要起到占位符的作用，并且默认为Flase。
并且，当我们定义一个变量为None类型时，内存已经正常分配（warning）

部分内容参考下面这位大佬：https://blog.csdn.net/mdxiaohu/article/details/81811459