Python基础之四：Python3 基础数据类型

Python基础之四：Python3 基础数据类型

一、数据类型简介

我们人类作为高级生物，可以很容易区分数据类型，但是计算机不能，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，什么是数字，什么是字符串，否则它是分不清数据之间的区别的，因此，在每个编程语言里都会有一个叫数据类型的东西，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给它。

二、Python3中的基础数据类型简介

Python3中的基础数据类型共6种，分别是：
1.Number（数字）： int（整数）、float（浮点数）、bool（布尔值）、complex（复数）

2.String（字符串）：用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符

3.List（列表）：写在方括号 [] 之间、用逗号分隔开

4.Tuple（元组）：写在方括号 （）之间、用逗号分隔开

5.Set（集合）：由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员，写在大括号{ }之间、用逗号分隔开
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

6.Dictionary（字典）：是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合

三、Python3中的基础数据类型详解

1.Number（数字）

Python3 支持 int、float、bool、complex（复数）

1.int（整数类型）

通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。

1.1 十进制数转换为二进制数

十进制整数转换为二进制整数：采用"除2取余，逆序排列"法。

具体做法是：
用2整除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为小于1时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。

# 将十进制数25转换成二进制数：
# 25/2=12---余数1
# 12/2=6---余数0
# 6/2=3---余数0
# 3/2=1---余数1
# 1/2=0---余数1
# 最终结果：10011

十进制小数转换为二进制小数：采用"乘2取整，顺序排列"法。

具体做法是：
用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，此时0或1为二进制的最后一位。或者达到所要求的精度为止；
然后把取出的整数部分按顺序排列起来，先取的整数作为二进制小数的高位有效位，后取的整数作为低位有效位。

#将十进制数0.625转换成二进制数：
#0.625*2=1.25======取出整数部分1
#0.25*2=0.5========取出整数部分0
#0.5*2=1==========取出整数部分1
#结果：（0.101）B

1.2 二进制数转换为十进制数

要从右到左用二进制的每个数去乘以2的相应次方,小数点后则是从左往右

例如：二进制数1101.01转化成十进制

1101.01（2）=1*2^0+0*2^1+1*2^2+1*2^3 +0*2^-1+1*2^-2=1+0+4+8+0+0.25=13.25（十进制数）

所以总结起来通用公式为：

abcd.efg(2)=d*2^0+c*2^1+b*2^2+a*2^3+e*2^-1+f*2^-2+g*2^-3（十进制数）

1.3 int操作

计算整数在内存中占用的二进制码的长度，使用bit_length()方法：

# 将十进制数25转换成二进制数：
# 25/2=12---余数1
# 12/2=6---余数0
# 6/2=3---余数0
# 3/2=1---余数1
# 1/2=0---余数1
# 最终结果：10011
m = 25
print(m.bit_length())
#运行结果：5

2.bool（布尔类型）

布尔值只有两个：True（1）、False（0）

2.1 int str bool 三者数据类型之间的转换

str => int int(str)

int => str str(int)

int => bool bool(int) 0是 False， 非0 就是 True

str = > bool bool(str) 空字符串 就是 False ， 非空就是 True

bool => str str(bool) 把 bool 值转换成相对应的 “值”

# int ---> bool
i = 100
print(bool(i))  # True  # 非零即True(1)
i1 = 0
print(bool(i1))  # False 零即False(0)

# bool ---> int
t = True
print(int(t))  # 1  True --> 1
t = False
print(int(t))  # 0  False --> 0

# int ---> str
i1 = 100
print(str(i1))  # '100'

# str ---> int  # 全部由数字组成的字符串才可以转化成数字
s1 = '90'
print(int(s1))  # 90

# str ---> bool
s1 = '晴朗'
s2 = ''
print(bool(s1))  # True 非空即True
print(bool(s2))  # False
# bool ---> str
t1 = True
print(str(True))  # 'True'

3.float（浮点数类型）

浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

m = 55.7
print(float(m))#55.5
print(int(m))#55

4.complex（复数）

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

5.数字类型转换

int(x) 将x转换为一个整数。

float(x) 将x转换到一个浮点数。

complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

5.数字相关函数

5.1 数学函数

import math
print(abs(-10))	#返回数字的绝对值,结果：10
print(math.ceil(3.2))	#返回数字的上入整数,结果：4
print(math.exp(1))	#返回e的x次幂(ex),结果：2.718281828459045
print(math.fabs(-10))	#返回数字的绝对值，结果：10.0
print(math.floor(4.9))	#返回数字的下舍整数，结果：4
print(math.log(100, 10))# log函数，结果：2.0
print(math.log10(100))# 返回以10为基数的x的对数，结果： 2.0
print(max(1,5,3,6,4,8))	#返回给定参数的最大值，结果：8。
print(min(1,5,3,6,4,8))	#返回给定参数的最小值，结果：1。
print(math.modf(3.88))	#返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。，结果：(0.8799999999999999, 3.0)
print(pow(2, 4))	#x**y 运算后的值,即x的y次幂。结果：16
print(round(10.8765,2))#返回浮点数 x 的四舍五入值，如给出n值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。结果：10.88
print(math.sqrt(16))	#返回数字x的平方根。结果：4.0

5.2 随机数函数

import random
print(random.choice(range(10)))#从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
print(random.randrange(1, 100, 2))#从指定范围内，按指定基数递增的集合中获取一个随机数。1-100随机一个奇数
print(random.random())	#随机生成下一个实数，它在[0,1)范围内。
random.seed(10)	#改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
print(random.shuffle([]))	#将序列的所有元素随机排序
print(random.uniform(0, 10))	#随机生成下一个实数，它在[0,10]范围内。

5.3三角函数

# acos(x)	返回x的反余弦弧度值。
# asin(x)	返回x的反正弦弧度值。
# atan(x)	返回x的反正切弧度值。
# atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
# cos(x)	返回x的弧度的余弦值。
# hypot(x, y)	返回欧几里德范数 sqrt(x*x + y*y)。
# sin(x)	返回的x弧度的正弦值。
# tan(x)	返回x弧度的正切值。
# degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
# radians(x)	将角度转换为弧度

5.3数字常量

pi 数学常量 pi（圆周率，一般以π来表示）

e 数学常量 e，e即自然常数（自然常数）

2.String（字符串）

凡是用引号引起来的数据可以称为字符串类型，组成字符串的每个元素称之为字符，将这些字符一个一个连接起来，然后在用引号起来就是字符串。

2.1 字符串的索引与切片

索引：即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推

st = 'ABCDEFG'
print(st[0])#A
print(st[2])#C
print(st[6])#G

切片：就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）

2.2 字符串的访问

按索引：s1[index]
按照切片： s1[start_index: end_index+1]
按照切片步长： s1[start_index: end_index+1:2]
反向按照切片步长： s1[start_index: end_index后延一位:2]

st = 'ABCDEFG'
print(st[0:6:2])#ACE，A到F范围内(不包括F)，每隔2取一个值
print(st[0:6:3])#AD，A到F范围内(不包括F)，每隔3取一个值
print(st[:7])#ABCDEFG，A到G范围内（包括G），每隔1取一个值
print(st[-2:1:-1])#FEDC，F到B范围内（不包括B），每隔-1取一个值
print(st[-3:0:-2])#EC，E到A范围内（不包括A），每隔-2取一个值

 1 str = '0123456789′
 2 print str[0:3] #截取第一位到第三位的字符
 3 print str[:] #截取字符串的全部字符
 4 print str[6:] #截取第七个字符到结尾
 5 print str[:-3] #截取从头开始到倒数第三个字符之前
 6 print str[2] #截取第三个字符
 7 print str[-1] #截取倒数第一个字符
 8 print str[::-1] #创造一个与原字符串顺序相反的字符串
 9 print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
10 print str[-3:] #截取倒数第三位到结尾
11 print str[:-5:-3] #逆序截取，截取倒数第五位数与倒数第三位数之间

2.3 转义字符

在需要在字符中使用特殊字符时，python用反斜杠()转义字符

2.4 字符串运算符

2.5 字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

f-string： python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法

name = '小明'
age = 18
print (f"我叫{name}，今年{age}岁!" )
#我叫小明，今年18岁!

2.6 字符串常用方法

1.字符串大小写变换

st = 'aBcDe'
print(st.upper())#将字符串转换成大写，结果：ABCDE
print(st.lower())#将字符串转换成小写，结果：abcde
print(st.title())#返回字符串的标题式样（即首字母大写）
print(st.swapcase())#返回字符串大小写交换

2.字符串元素内容检查

st = 'aBcDe'
print(st.startswith('a'))#字符串是否以a开头，结果：True
print(st.endswith('m'))#将字符是否以m结尾，结果：False
print(st.isalnum()) #检查所有字符串是否只有数字和字母
print(st.isalpha())# 检查字符串中是否只有字母
print(st.isdigit())# 检查字符串字符是否全为数字
print(st.islower())#检查字符串字符是否全为小写
print(st.isupper())#检查字符串字符是否全为大写
print(st.istitle())# 检查字符串字符是否为标题式样

3.字符串分隔、剥离与连接

s = "  www.jianchi-jiushi-shengli.com  "
print('1:', s.split('.'))           #以"."进行字符串分割，返回结果为列表。以split()括号里的参数为标准进行字符串分割
print('2:', s.strip(' '))           #剥离字符串两端空格。 不指定参数时默认剥离首尾空格和换行
print('3:', s.lstrip(' w'))         #剥离字符串左端空格和w
print('4:', s.rstrip(' om'))        #剥离字符串右端空格及字符o和m
print('5:', "-".join(s.split('.'))) #以“.”进行字符串分割后，再以“-”进行字符串连接

4.字符串的查找与替换

s = "www.jianchi-jiushi-shengli.com  "
print(s.count('g')) #统计某个字符出现的次数
print(s.capitalize()) #返回字符串首字母大写
print(s.find('q'))#找到q返回下标，多个时返回第一个；不存在的字符返回-1
print(s.index('c'))#找到这个字符返回下标，多个时返回第一个；不存在的字符报错
print(s.replace('g', 'a'))#字符串替换
print(s.center(40, '*'))#输出一个两边用*补充的长度为40的字符串

5.字符串的格式化输出

name = 'liang'
age = 18
print('my name is {name},I am {age}'.format(name = name, age = age))
#my name is liang,I am 18

3.List（列表）

列表是python的基础数据类型之一 ,其他编程语言也有类似的数据类型.比如JS中的数 组, java中的数组等等. 它是以[ ]括起来, 每个元素用’ , '隔开而且可以存放各种数据类型: 列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

简单概括：1.承载任意数据类型，存储大量的数据，对应别的语言：数组

1.列表的创建

方式一：（常用）

l1 = [1, 2, '学习']

方式二：（不常用）

l1 = list() 空列表
l1 = list(iterable)  可迭代对象
l1 = list('123')
print(l1)  ['1', '2', '3']

方式三：列表推导式

l1 = [i for i in range(1,5)]
print(l1)  # [1, 2, 3, 4]

2.列表的增删改查

2.1增加

# append 追加，给列表的最后面追加一个元素
l = [1, 2, 'a']
l.append(666)
print(l) # [1, 2, 'a', 666]

# insert  插入在列表的任意位置插入元素
l = [1, 2, 'a']
l.insert(1, '学习')
print(l) # [1, '学习', 2, 'a']

# extend  迭代着追加，在列表的最后面迭代着追加一组数据
l = [1, 2, 'a']
l.extend('学习a')
print(l)#[1, 2, 'a', '学', '习', 'a']

2.2查找

names = ["aaron", "alex", "james", "meihengfan"]
print(names)            #列出列表的内容
print(names[3])         #访问列表中第4个值
print(names[1:3])       #访问列表中从第2个到第3个的值
print(names[-1])        #访问列表中的最后一个值
print(names[:-2])       #访问列表中的所有值，但是把倒数第二个及后面的所有值都去掉
print(names[-3:])       #访问列表中倒数第一个到倒数第三个的值
print(names[0],names[3])    #注意取多个值的时候，不能直接把下标写到一起，需要按照这种方式写
print(names[::2])       #打印列表，但是以2为步长，就是跳着切，也可以根据需求把这个步长给改了
print(names.index("james"))         #查找列表中james这个元素的下标
print(len(names))                   #确定列表的长度

2.3删除

names = ["aaron", "alex", "james", "meihengfan"]
names.remove("aaron")#指定元素删除，默认删除第一个
del names[2] #按索引和切片删除
del names #直接删除列表
names.pop() #按索引删除，默认删除最后一个
names.clear()#清空列表，危险操作，请慎用

2.4修改

直接操作

names = ["aaron", "alex", "james", "meihengfan"]
names[2] = "liming" #把索引为2的元素修改成了‘liming’

3.列表的其他操作

3.1列表的常用方法

a = ["q","w","q","r","t","y"]
print(a.count('q'))#统计列表中q出现的次数
print(a.index('q'))#找出列表中第一个q出现位置的索引
a.reverse()#反向存放列表
print(a)
print(sorted(a))#对列表进行临时性排序
a.sort()#将原列表排序
print(a)

3.2列表的相加和相乘

相加

l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

相乘

l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

4.Tuple（元组）

俗称不可变的列表，又被成为只读列表，元祖也是python的基本数据类型之一，用小括号括起来，里面可以放任何数据类型的数据，查询可以，循环也可以，切片也可以，但就是不能改。

元组的操作方法基本和列表一致，就是不能增加、删除、修改，只能查找！

5.TupleDictionary（字典）

字典是以键值对形式存储的容器型数据类型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一不可变的，但值则不必，值可以是任意数据类型或者对象。

可变数据类型：列表、字典、集合

不可变数据类型：数字（包含布尔值）、字符串、元组

1.字典的创建

# 方式1:
dic = dict((('one', 1),('two', 2),('three', 3)))
# dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic)  # {'one': 1, 'two': 2, 'three': 3}


# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic)  # {'one': 1, 'two': 2, 'three': 3}


# 方式3:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式4: 字典推导式
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)

2.字典的增删改查

2.1增加

# 通过键值对直接增加
dic = {'name': '小明', 'age': 18}
dic['weight'] = 75 # 没有weight这个键，就增加键值对
print(dic) # {'name': '小明', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name这个键，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}

# setdefault
dic = {'name': '小明', 'age': 18}
dic.setdefault('height', 175) # 没有height此键，则添加
print(dic) # {'name': '小明', 'age': 18, 'height': 175}
dic.setdefault('name', 'barry') # 有此键则不变
print(dic) # {'name': '小明', 'age': 18, 'height': 175}

2.2删除

# pop 通过key删除字典的键值对，有返回值，可设置返回值。
dic = {'name': '小明', 'age': 18}
# ret = dic.pop('name')
# print(ret, dic) # 小明 {'age': 18}
ret1 = dic.pop('n', None)
print(ret1, dic) # None {'name': '小明', 'age': 18}

#popitem 3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值
dic = {'name': '小明', 'age': 18}
ret = dic.popitem()
print(ret, dic) # ('age', 18) {'name': '小明'}

#clear 清空字典
dic = {'name': '小明', 'age': 18}
dic.clear()
print(dic) # {}

# del
# 通过键删除键值对
dic = {'name': '小明', 'age': 18}
del dic['name']
print(dic) # {'age': 18}
#删除整个字典
del dic

2.3修改

# 通过键值对直接改
dic = {'name': '小明', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}

# update
dic = {'name': '小明', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '小明', 'age': 18, 'sex': '男', 'height': 175}

dic = {'name': '小明', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '小明', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}

dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75} 

2.4查找

# 通过键查询
# 直接dic[key](没有此键会报错)
dic = {'name': '小明', 'age': 18}
print(dic['name']) # 小明

# get
dic = {'name': '小明', 'age': 18}
v = dic.get('name')
print(v) # '小明'
v = dic.get('name1')
print(v) # None
v = dic.get('name2','没有此键')
print(v) # 没有此键 

keys()
dic = {'name': '小明', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age']) 

values()
dic = {'name': '小明', 'age': 18}
print(dic.values()) # dict_values(['小明', 18])

items()
dic = {'name': '小明', 'age': 18}
print(dic.items()) # dict_items([('name', '小明'), ('age', 18)])

3.字典的嵌套

用一个简单的例子说明字典的嵌套

dic = {
    'name':'汪峰',
    'age':48,
    'wife':[{'name':'国际章','age':38}],
    'children':{'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'}
}

# 1. 获取汪峰的名字。
print(dic['name'])
# 2.获取这个字典：{'name':'国际章','age':38}。
print(dic['wife'][0])
# 3. 获取汪峰妻子的名字。
print(dic['wife'][0]['name'])
# 4. 获取汪峰的第三个孩子名字。
print(dic['children']['girl_three'])

3.关于拆包应用到字典

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

a,b = ('你好','世界')  # 元组的拆包
print(a,b)#你好 世界

a,b = ['你好','大飞哥']# 列表的拆包
print(a,b)#你好 大飞哥

a,b = {'汪峰':'北京北京','王菲':'天后'}# 字典的拆包
print(a,b)#汪峰 王菲

6.Set（集合）

集合是一个无序的不重复元素序列

1.集合的创建

#方法一：
se1 = {1, 2, 8, 2}
print(se1)
#方法二：
se2 = set({1, 2, 8, 2})
print(se2)

强调：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

se1 = set()
print(type(se1))#<class 'set'>
se2 = {}
print(type(se2))#<class 'dict'>

2.集合的增加和删除

由于集合是无序的、不重复的，所以集合在储存元素时会自动删除重复的元素，并且无序性使之不能查找单个元素

2.1集合的增加

#方法一：add
se1 = {1, 2, 8, 2}
se1.add('小明')
print(se1)#{8, 1, 2, '小明'}

#方法二：update
se1 = {1, 2, 8, 2}
# se1.update('小明')
# print(se1)#{1, 2, '明', 8, '小'}
se1.update(['xiaoming', 'xiaoai'])
print(se1)#{1, 2, 'xiaoming', 8, 'xiaoai'}

2.2集合的删除

set1 = {1, 2, 8, 2}
set1.remove(8)  # 删除一个元素
print(set1)

set1.pop()  # 随机删除一个元素
print(set1)

set1.clear()  # 清空集合
print(set1)

del set1  # 删除集合
print(set1)

3.集合的关系测试

3.1交集（& 或者 intersection）

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

3.2并集（| 或者 union）

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

3.3差集（- 或者 difference）

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

3.4反交集（^ 或者 symmetric_difference）

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

3.5子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

四、Python3中的基础数据类型图

五、基础数据类型的常见问题

1、元组

元组中如果只含有一个元素且没有逗号，则该元组不是元组，与改元素数据类型一致，如果有逗号，那么它是元组。

tu = (1)
print(tu, type(tu))  # 1 <class 'int'>
tu1 = ('晴朗')
print(tu1, type(tu1))  # '晴朗' <class 'str'>
tu2 = ([1, 2, 3])
print(tu2, type(tu2))  # [1, 2, 3] <class 'list'>

tu = (1,)
print(tu, type(tu))  # (1,) <class 'tuple'>
tu1 = ('晴朗',)
print(tu1, type(tu1))  # ('晴朗',) <class 'tuple'>
tu2 = ([1, 2, 3],)
print(tu2, type(tu2))  # ([1, 2, 3],) <class 'tuple'>

2、列表

在循环一个列表时的过程中，如果你要改变列表的大小（增加值，或者删除值），那么结果很可能会出错或者报错
例题：删除列表li = [11, 22, 33, 44, 55]中索引为奇数对应的元素删除
正常思路解题：循环列表，然后进行判断，只要他的索引为奇数，就删除

li = [11, 22, 33, 44, 55]
for i in range(len(li)):
    if i % 2 != 0:
        li.pop(i)
print(li)#[1, 3, 4]

按照题目要求应该得到： [11， 33， 55]，但通过上述方法得到的结果却是：[11, 33, 44]，原因如下：

解决方法：
方法一：直接删除

li = [11, 22, 33, 44, 55]
del li[1::2]
print(li)

方法二：倒序删除

li = [11, 22, 33, 44, 55]
for i in range(len(li) - 1, -1, -1):
    if i % 2 != 0:
        li.pop(i)
print(li)

方法三：置换

li = [11, 22, 33, 44, 55]
new_li = []
for i in range(len(li)):
    if i % 2 == 0:
        new_li.append(li[i])
print(new_li)

注意：循环一个列表时，如果要改变其大小，一定要注意最终结果可能会出错或报错！

3、字典

在循环一个字典的过程中，不要改变字典的大小（增，删字典的元素），这样会直接报错。
例题：将字典中dic = {‘k1’:‘AA’, ‘s2’:‘BB’, ‘k3’:‘CC’, ‘s4’:‘DD’}键值带‘k’的元素删除
正常思路：遍历字典，然后判断键值是否带‘k’，如果带，则删除

dic = {'k1':'AA', 's2':'BB', 'k3':'CC', 's4':'DD'}
for key in dic:
    if 'k' in key:
        del dic[key]
print(dic)#报错：RuntimeError: dictionary changed size during iteration

按照题目要求应该得到：{‘s2’:‘BB’, ‘s4’:‘DD’}，但通过上述方法得到的结果却是：错误信息RuntimeError: dictionary changed size during iteration。
解决办法：
方法一：把字典的键值添加到列表，然后循环列表删除字典对应值

dic = {'k1':'AA', 's2':'BB', 'k3':'CC', 's4':'DD'}
li = []
for key in dic:
    if 'k' in key:
        li.append(key)
for i in li:
    dic.pop(i)
print(dic)#{'s2': 'BB', 's4': 'DD'}

方法二：直接循环字典键值，并将其强制转换成列表

dic = {'k1':'AA', 's2':'BB', 'k3':'CC', 's4':'DD'}
for key in list(dic.keys()):
    if 'k' in key:
        dic.pop(key)
print(dic)#{'s2': 'BB', 's4': 'DD'}

六、基础数据类型的划分

1、按存储空间的占用分

从低到高：数字→字符串→集合→元组→列表→字典

2、按存值个数区分

2.1标量/原子类型：数字、字符串

2.2容器类型：列表、元组、字典、集合

3、按可变不可变区分

3.1可变（不可哈希）：列表、字典、集合

3.2不可变（可哈希）：数字（包含布尔）、字符串、元组

4、按访问顺序区分

4.1直接访问：数字

4.2顺序访问（序列类型）：字符串，列表，元组

4.3key值访问（映射类型）：字典

4.4特殊访问：集合