Python中的六种基本数据类型

Python中分为六种基本数据类型

  • 不可变类型(又叫静态数据类型,没有增删改操作):数字(number)、字符串(string)、元组(tuple)
  • 可变类型(又叫动态数据类型,支持增删改操作):列表(list)、字典(dictionary)、集合(set)
  • 1. 数字类型(numbers):

    数字类型下还可分为整数(int)、浮点数(float)、复数(complex)、布尔(bool)

    age = 22        # 整数型,可以通过print(sys.maxsize)查看最大取值范围
    print(age)      # 输出:22
    
    weight = 116.65 # 浮点型
    print(weight)   # 输出:116.65
    
    c1 = 1 + 2j
    c2 = 2 + 3j
    print(c1+c2)    # 输出:(3+5j),复数在实际工作中几乎用不到,请自行了解
    print(complex(2,1)) # 输出:(2+1j)
    
    
    print(True == 1)  # 输出:True
    print(False == 0) # 输出:True
    # True==1,False==0 ,因此True 和 False 可以和数字相加
    print(True + 1)   # 输出:2
    print(False - 2)  # 输出:-2
    
    # ↓其实布尔型就是整数型的子类,可以使用内置函数issubclass()判断,该函数是用于判断一个类型对象是否是另一个类型对象的子类
    print(issubclass(bool, int)) # 输出:True
    

    2. 字符串类型(string)

    字符串必须使用''""括起来,对于特殊字符可以使用反斜杠\进行转义,用+拼接多个字符串, 用*复制字符串,字符串还支持索引截取(又叫切片)

    name = "ZhangSan"   # 字符串型,也可以使用单括号
    print(name)         # 输出:ZhangSan
    print(name * 2)    # 输出字符串两次,也可以写成 print (2 * name),输出:ZhangSanZhangSan
    print(name +'-123')# 拼接字符串,输出:ZhangSan-123
    print(name +'\'123\'')# 拼接字符串并将单引号转义,输出:ZhangSan'123'
    
    print(name[0:-1])  # 输出第一个至倒数第二个的字符,截取时顾头不顾尾,输出:ZhangSa
    print(name[0])     # 输出第一个字符,输出:Z
    print(name[-1])    # 输出最后一个字符,输出:n
    print(name[2:])    # 输出从第三个开始之后的所有字符,输出:angSan
    print(name[0:-1:2]) # 输出第一个至倒数第二个的字符,步长为2,输出:Zaga
    print(name[8])		# 若字符不存在,则会抛出IndexError: string index out of range
    

    3. 列表(list)

    列表是一组可重复且有序的数据集合,任何类型的数据都可以存到列表中,会根据需要动态分配和回收内存,是Python中使用最频繁的数据类型,列表同样也支持索引截取(又叫切片),列表中的元素是可变的,能够进行增删改操作

  • 列表创建

    l0 = []	# 创建空列表
    l1 = ["张三",'lisi',12,["22","lisi","王武"],"赵柳"]  # 直接使用中括号创建列表
    l2 = list(['lisi',12,("22","王武"),"赵柳"])  		# 或者调用内置函数list(),通常用于转换为列表时使用
    
  • 获取列表中的元素

    print(l1[1])        # 获取列表l1中第二个元素,输出:lisi
    print(l1[0:2])      # 获取列表l1中第一个和第二个元素,输出:['张三', 'lisi']
    print(l1[-5:-2])    # 获取列表l1中第一个至倒数第三个数据,反向索引,输出:['张三', 'lisi', 12]
    print(l1[2:-1])     # 获取列表l1中第三个至倒数第二个元素,输出:[12, ['22', 'lisi', '王武']]
    print(l1[1::2])     # 获取列表l1中第二个至最后一个元素,步长为2,输出:['lisi', ['22', 'lisi', '王武']]
    print(l1[:1:-2])    # 反向获取列表l1中元素,步长为-2,输出:['赵柳', 12]
    print(l1[::-1])     # 步长为-1时表示倒序排列元素,输出:['赵柳', ['22', 'lisi', '王武'], 12, 'lisi', '张三']
    print(l1[3][0])     # 获取l1嵌套列表(即第四个元素)中的第一个元素,输出:22
    print(l1[3][-1])    # 获取l1嵌套列表(即第四个元素)中的最后一个元素,输出:王武
    print(l1[5])		# 若元素不存在,则会抛出IndexError: list index out of range
    
    for i in l1:		# 使用for循环遍历列表中的元素
        print(i)		# 遍历元素后的操作,比如输出结果
    
  • 判断元素是否在列表中

    print("lisi" in l1)     # 判断l1列表中包含“lisi”,输出:True
    print("赵柳" not in l1)  # 判断l1列表中不包含“赵柳”,输出:False
    print("22" in l1[3])    # 判断l1嵌套列表中包含“22”,输出:True
    print("王武" not in l1)  # 判断l1列表中不包含“王武”,输出:True
    
  • 列表排序

    li = [22,18,9,-2,0,6]	# 对于需要排序的列表,元素类型必须一致,比如:元素统一为数字类型或字符串类型
    li.sort()				# 调用sort()方法,默认从小到大排序
    li.sort(reverse=True)	# 指定reverse=True后列表会进行降序排列
    # ↓还可以调用内置函数sorted()进行排序,此方式不会改变原列表
    sorted(li)				# 从小到大排序
    sorted(li,reverse=True)	# 同样指定reverse=True后列表会进行降序排列
    
  • 修改列表中的元素

    l1[1]="李思"			   # 将l1列表中第二个元素改为李思
    l1[3][0] = 22			# l1嵌套列表中的第一个元素改为22
    l1[1:3]= ["张珊","李思"]  # 将l1列表中第二个和第三个值改为张珊和李思
    
  • 列表中添加元素

    l3 = [1,2]
    l4 = ["壹","er"]
    l3.append(3)		# 在l3列表末尾添加元素3,输出:[1, 2, 3]
    l3.append(l4)		# 将l4列表添加到l3列表末尾,输出:[1, 2, ['壹', 'er']]
    l3.extend("3L")		# 在l3列表末尾至少添加两个元素,输出:[1, 2, '3', 'L']
    l3.extend(l4)		# 将l4列表添加到l3列表末尾,等同于l3+l4,输出:[1, 2, '壹', 'er']
    l3.insert(1,"张珊")  # 在l3列表中索引为1的位置插入元素,输出:[1, '张珊', 2]
    l3.insert(0,l4)		# 将l4列表添加到l3列表头部,输出:[['壹', 'er'], 1, 2]
    

    注意三者的区别:

  • append():指在列表的末尾添加一个元素,新元素会视为一个整体追加到列表末尾
  • extend():指在列表的末尾至少添加一个元素,新元素会将整体中的每个元素一个一个地追加列表末尾
  • insert():指在列表的指定索引位置添加元素
  • 删除列表中的元素

    l1.remove("张珊")		# 删除指定元素,一次只能删除一个元素,若出现重复元素则只删除第一个
    l1.remove("菡菡")		# 若元素不存在,则抛出ValueError: list.remove(x): x not in list
    l1.pop(1)			# 删除指定索引位置上的元素,若不指定索引则默认删除最后一个元素
    l1.pop(8)			# 若索引不存在,则抛出IndexError: pop index out of range
    l1.clear()			# 清空l1列表
    del l1				# 删除l1列表
    
  • 4. 元组(tuple)

    元组也是一组可重复且有序的对象集合,任何类型的数据都可以存到元组中,但是元组中的元素是不可变的,元组同样也支持索引截取(又叫切片)

  • 创建元组

    t0 = ()		# 创建空元组
    t1 = ("张珊","lisi",["李思",12,"Python"],("王武","22"))	# 直接使用小括号创建元组
    t2 = (1,)						# 当元组只有一个元素时需要在后面加上逗号
    t3 = tuple(("依儿",22,"Java"))   # 或者调用内置函数tuple(),通常用于转换为元组时使用
    
  • 获取元组中的元素

    print(t1[1])        # 获取元组t1中第二个元素,输出:lisi
    print(t1[0:2])      # 获取元组t1中第一个和第二个元素,输出:('张珊', 'lisi')
    print(t1[2:-1])     # 获取元组t1中第三个至倒数第二个元素,输出:(['李思', 12, 'Python'],)
    print(t1[1::2])     # 获取元组t1中第二个至最后一个元素,步长为2,输出:('lisi', ('王武', '22'))
    print(t1[::-1])     # 步长为-1时表示倒序排列,输出:(('王武', '22'), ['李思', 12, 'Python'], 'lisi', '张珊')
    print(t1[2][0:-1]) 	# 获取元组t1中第三个元素中的第一个至倒数第二个元素,输出:['李思', 12]
    
    for i in t1:		# 使用for循环遍历元组中的元素
        print(i)		# 遍历元素后的操作,比如输出结果
    
  • 修改元组中的可变对象

    # 修改元组t1中列表中的元素
    t1[2][1] = "十"		   # 将12改为10
    t1[2].remove("Python")  # 删除Python元素
    t1[2].pop()				# 删除最后一个元素
    t1[2].clear()			# 清空列表
    t1[2].append("啊哈")	   # 添加一个元素
    # 拼接元组
    print(t2+t3)			# 输出:('1', '依儿', 22, 'Java')
    

    注意:元组中存储的是对象的引用,若对象本身不可变则不可再引用其它对象(比如元组t2和t3,元素都是不可修改的),若对象本身可变则可变对象的引用不可改变,但是对象中的数据可以改变(比如t1中的列表,该列表不可删除,但可以修改列表中的元素)

  • 5. 字典(dictionary)

    字典是一组可变的无序的对象集合,字典中的元素是通过键(Key) : 值(Value)来保存的,一组键值对称为一个元素,其中键(Key)不可重复,必须唯一,而值(Value)是可重复的,字典会浪费较大内存,是一种使用空间换时间的数据类型

  • 创建字典

    d0 = {}		# 创建空字典
    d1 = {"张珊":100,"李思":120,"王武":110}	# 使用花括号创建字典
    d2 = dict(name="李尔",weight=116)		   # 调用内置函数dict()创建,通常用于转换为字典时使用
    
  • 获取字典中的元素

    print(d1["李思"])			# 使用中括号根据Key获取Value值,输出:120
    print(d1["张三"])			# 若Key不存在,则抛出KeyError: '张三'
    
    # ↓还可以使用get()方法取值,此方式若Key不存在则返回None,不会抛出KeyError异常,还可以设置默认Value
    print(d1.get("张珊"))		# 使用get()方法取值,输出:100
    print(d1.get("王武",98))	# 若对应Key不存在则输出默认值,否则输出对应的Value值,此处输出:110
    
    # ↓使用keys()方法获取所有Key
    print(d1.keys())		 # 获取字典中所有的Key,输出:dict_keys(['张珊', '李思', '王武'])
    print(list(d1.keys()))	 # 获取字典中所有的Key并转为列表,输出:['张珊', '李思', '王武']
    print(tuple(d1.keys()))	 # 获取字典中所有的Key并转为元组,输出:('张珊', '李思', '王武')
    
    # ↓使用values()方法获取所有Value值
    print(d1.values())		 # 获取字典中所有的Value值,输出:dict_values([100, 120, 110])
    print(list(d1.values())) # 获取字典中所有的Value值并转为列表,输出:[100, 120, 110]
    print(tuple(d1.values()))# 获取字典中所有的Value值并转为元组,输出:(100, 120, 110)
    
    # ↓使用items()方法获取所有的键值对
    print(d1.items())		 # 获取字典中所有的Key:Value,输出:dict_items([('张珊', 100), ('李思', 120), ('王武', 110)])
    print(list(d1.items()))	 # 获取字典中所有的Key:Value并转为列表,输出:[('张珊', 100), ('李思', 120), ('王武', 110)]
    print(tuple(d1.items())) # 获取字典中所有的Key:Value并转为元组,输出:(('张珊', 100), ('李思', 120), ('王武', 110))
    
    for item in d1:			 # 使用for循环遍历字典中的元素
        print(item)			 # 返回字典中所有的Key
    
  • 判断字典中是否存在指定的Key

    print("李思" in d1)		# 判断d1字典中存在Key"李思",输出:True
    print("王武" not in d1)	# 判断d1字典中不存在Key"王武",输出:False
    
  • 字典中元素的增删改

    d1["李思"] = 118		# 若Key存在,则修改对应的Value值,原李思对应的value值变为118
    d1["张三"] = 106		# 若Key不存在,则新增键值对,字典中新增'张三': 106
    d1.pop("张三")		# 删除Key为“张三”的键值对
    d1.pop("张凤")		# 必须传入一个Key,若Key不存在,则抛出KeyError: '张凤'
    del d1["张三"]		# 同样也是删除Key为“张三”的键值对
    d1.clear()			 # 清空字典
    del d1				 # 删除字典
    
  • 6. 集合(set)

    集合是一组可变的、无序的且不可重复的元素序列,可以理解为是没有Value值得字典,基本功能是测试元素之间的关系和删除重复元素,比如:共同好友、你可能认识的人、关注TA的人还关注了…等

  • 创建集合

    s0 = set()						 # 创建空集合,不能直接使用花括号,花括号默认是创建字典
    s1 = {"李思","张珊","李思","王武"}	# 花括号中元素非键值对时,创建的是集合
    s2 = set("李尔")					# 调用内部函数set()创建,通常用于转换为集合时使用
    
  • 获取集合中的元素

    # ↓若集合中存在相同的元素,只会出现输出一个,因为集合是无序的,所以每次输出结果顺序可能不一致
    print(s1)		# 获取集合s1中所有的元素,输出:{'李思', '王武', '张珊'} 
    for i in s1:	# 通过for循环获取集合中的元素
        print(i)	# 同样重复元素只返回一个
    # ↓集合中的某一个元素是不能直接获取的,可以先转换为列表,然后使用列表方式获取元素
    ls = list(s1)	# 将集合s1转换为列表
    print(ls[1])    # 获取列表l1中第二个元素,输出:李思
    print(ls[0:2])  # 获取列表l1中第一个和第二个元素,输出:['王武', '李思']
    ……
    
  • 判断元素是否存在

    print("李思" in s1)		# 判断s1集合中存在"李思",输出:True
    print("王武" not in s1)	# 判断s1集合中不存在"王武",输出:False
    
  • 集合中添加、更新元素

    s1.add("赵柳")		# 添加一个元素,因为集合是无序的,所以元素位置随机
    # update也可以理解为新增,当存在相同元素时,相同元素会被覆盖,不同元素会新增到集合中
    s1.update("张三")		# 集合中会添加两个元素,‘张’、‘三’
    s1.update("张三丰")   # 集合中会更新两个元素,‘张’和‘三’,新增一个元素‘丰’
    
  • 删除集合中的元素

    s1.remove("李思")		# 删除s1集合中的元素“李思”,若元素不存在,则抛出KeyError: '李思'
    s1.discard("张三")	# 删除s1集合中的元素“张三”,若元素不存在,不会抛出任何异常
    s1.pop()			# 随机删除任意一个元素
    s1.clear()			# 清空集合中的元素
    del s1				# 删除集合
    
  • 判断两个集合是否相等

    print(s1 == s2)		# 输出:False
    print(s1 != s2)		# 输出:True
    
  • 判断两个集合的关系

    s3 = {"李思","张珊","李思","王武","Andy"}
    s4 = {"李四","张珊","张三","王武"}
    s5 = {"Andy"}
    
    # ↓当s5中所有的元素s3里都有,但s5中的元素s3中未必有,则s3就是s5的超级,反之s5就是s3子集
    print(s3.issuperset(s5))	# 判断s3是否是s5的超集,输出:True,因为s3中有s5所有的元素
    print(s5.issubset(s3))		# 判断s5是否是s3的子集,输出:True,因为s5中的所有元素s3中都有
    print(s3.isdisjoint(s4))	# 判断s3和s4两个集合是否没有交集,输出:False,因为两个集合中都有"张珊"和"王武",存在交集
    
    print(s3.intersection(s4))	# 输出s3和s4交集(即二者都有)的元素,输出:{'张珊', '王武'}
    print(s3 & s4)				# 与intersection()等价,交集的一种符号表示法
    
    print(s3.union(s4))			# 输出s3和s4并集(即去掉二者都有)的元素,输出:{'李思', '张三', '王武', '李四', '张珊', 'Andy'}
    print(s3 | s4)				# 与union()等价,并集的一种符号表示法
    
    print(s3.difference(s4))	# 输出s3和s4差集(即所有属于s3但不属于s4)的元素,输出:{'Andy', '李思'}
    print(s3 - s4)				# 与union()等价,差集的一种符号表示法
    
    print(s3.symmetric_difference(s4))	# 输出s3和s4对称差集(即s3中不属于s4和s4中不属于s3)的元素,输出:{'Andy', '李思', '李四', '张三'}
    print(s3 ^ s4)				# 与symmetric_difference()等价,对称差集的一种符号表示法
    
  • 物联沃分享整理
    物联沃-IOTWORD物联网 » Python中的六种基本数据类型

    发表评论