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 = '01234567892 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用反斜杠()转义字符

转义字符 描述
(在行尾时) 续行符
\ 反斜杠符号
单引号
双引号
\a 响铃
\b 退格(Backspace)
\000
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数,yy 代表的字符,例如:\o12 代表换行,其中 o 是字母,不是数字 0。
\xyy 十六进制数,yy代表的字符,例如:\x0a代表换行
\other 其它的字符以普通格式输出
2.4 字符串运算符
操作符 描述 实例
+ 字符串连接
* 重复输出字符串
2.5 字符串格式化

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

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

符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数(大写)
%f 格式化浮点数字,可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e,用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址

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特殊访问:集合

版权声明:本文为qq_35092730原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。