python基本数据类型

1.Number（不可变数据）

• 包括：int、float、bool（int的子类）、complex

a = 1
b = 1.1
c = True
d = 1 + 1j
print(type(a), type(b), type(c), type(d))
# <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

•  type（）与 isinstance（）的区别

a = 1
c = True
# bool在python3中是int的子类，True==1，false==0，可加减
print(True + False)  # 1

print(type(a) == int)  # True
print(isinstance(a, int))  # True
# type()不会认为子类是一种父类类型
print(type(c) == int)  # false
# isinstance()会认为子类是一种父类类型
print(isinstance(c, int))  # True

• ==和is的区别

list1 = [1, 2]
list2 = list1
list3 = [1, 2]
# ==比较的是对象地址中的值
print(list1 == list2)  # True
print(list1 is list2)  # True
# is比较的是对象地址的值
print(list1 == list3)  # True
print(list1 is list3)  # False
print(id(list1), id(list2), id(list3))  # 2266877106496 2266877106496 2266877105536

• 数值运算

# 加法
print(1 + 2)  # 3
# 减法
print(1 - 2)  # -1
# 乘法
print(1 * 2)  # 2
# 除法，结果为浮点数
print(1 / 2)  # 0.5
# 除法，结果为整数
print(1 // 2)  # 0
# 乘方
print(2 ** 2)  # 4
# 取余
print(1 % 2)  # 1

2.String（不可变数据）

• 基本操作

# 字符串用单引号‘或双引号“括起来
s1 = "abc"
s2 = 'abc'
# 使用反斜杠\转义特殊字符
s3 = "a\nb"
# 使用r可以使转义字符失效从而打印转义字符
s4 = r"a\nb"
# 使用三引号（单双都可）可以换行输出
s5 = '''a
    b'''
print(s1)
print(s2)
print(s3)
print(s4)
print(s5)

•  其他操作

s = "you are handsome"  # s[0] = "x"不被允许
# 输出字符串
print(s)  # you are handsome
# 索引值以 0 为开始值，-1 为从末尾的开始位置
print(s[0])  # y
print(s[-1])  # e
# 输出第一个到倒数第二个的所有字符
print(s[0:-1])  # you are
# 输出从第一个开始的后的所有字符
print(s[0:])  # you are handsome
# 输出字符串两次，也可以写成 print (2 * str)
print(s * 2)  # you are handsomeyou are handsome
# 连接字符串
print(s + "! do I?")  # you are handsome! do I?

3.Tuple（不可变数据）

• 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
• 基本操作

tup1 = (1, 2, 3, 4)
tup2 = (5, 6)
# 输出完整列表
print(tup1)  # (1, 2, 3, 4)
# 输出列表第一个元素
print(tup1[0])  # 1
# 输出列表最后一个元素
print(tup1[-1])  # 4
# 从第二个开始输出到第三个元素
print(tup1[1:3])  # (2, 3)
# 输出从第三个元素开始的所有元素
print(tup1[2:])  # (3, 4)
# 输出两次列表
print(tup1 * 2)  # (1, 2, 3, 4, 1, 2, 3, 4)
# 连接列表
print(tup1 + tup2)  # (1, 2, 3, 4, 5, 6)

tup = ("siri", "love", "apple")
print(tup)  # ('siri', 'love', 'apple')
# 截取列表，从第一个参数开始，到第二个参数，截取第三个参数的长度，第三个参数为负数表示逆向读取
tup = tup[-1::-1]
print(tup)  # ('apple', 'love', 'siri')

# 一个元素，需要在元素后添加逗号
tup1 = (1,)  # (1,)
# 空元组
tup2 = ()  # ()
# 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
list1 = [1, 2, 3]
tup3 = (list1,)
list1[0] = 4  # ([4, 2, 3],)
print(tup3)

4.List（可变数据）

• 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
• 基本操作

list1 = [1, 2, 3, 4]
list2 = [5, 6]
# 输出完整列表
print(list1)  # [1, 2, 3, 4]
# 输出列表第一个元素
print(list1[0])  # 1
# 输出列表最后一个元素
print(list1[-1])  # 4
# 从第二个开始输出到第三个元素
print(list1[1:3])  # [2, 3]
# 输出从第三个元素开始的所有元素
print(list1[2:])  # [3, 4]
# 输出两次列表
print(list1 * 2)  # [1, 2, 3, 4, 1, 2, 3, 4]
# 连接列表
print(list1 + list2)  # [1, 2, 3, 4, 5, 6]
# 元素可改变
list1[0] = 9
print(list1)  # [9, 2, 3, 4]

s = "siri love apple"
list_s = s.split(" ")
print(list_s)  # ['siri', 'love', 'apple']
# 截取列表，从第一个参数开始，到第二个参数，截取第三个参数的长度，第三个参数为负数表示逆向读取
list_s = list_s[-1::-1]
print(list_s)  # ['apple', 'love', 'siri']

5.Set（可变数据）

• 集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
• 基本操作：

set1 = {1, 2, 3, 4, 5, 6, 1}
set2 = {1, 3, 5, 7, 9}
# 创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
set3 = set()
# 输出集合，重复的元素被自动去掉
print(set1)  # {1, 2, 3, 4, 5, 6}
# 查看元素是否在集合中
if 1 in set1:
    print(True)
# 差集
print(set1 - set2)  # {2, 4, 6}
# 并集
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 9}
# 交集
print(set1 & set2)  # {1, 3, 5}
# 两个集合中不同时存在的元素
print(set1 ^ set2)  # {2, 4, 6, 7, 9}

6.Dictionary（可变数据）

• 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。
• 基本操作

# 创建空字典
dict1 = {}
dict2 = {"1": "one", "2": "two"}
# 添加值
dict1[1] = 'siri'
dict1[2] = 'apple'

print(dict1)  # {1: 'siri', 2: 'apple'}
print(dict2)  # {'1': 'one', '2': 'two'}
print(dict1[1])  # siri
print(dict1.keys())  # dict_keys([1, 2])
print(dict1.values())  # dict_values(['siri', 'apple'])

# 构造函数 dict() 可以直接从键值对序列中构建字典
dict3 = dict([(1, "one"), (2, "two")])
print(dict3)  # {1: 'one', 2: 'two'}
dict4 = {x: x**2 for x in (1, 2, 3)}
print(dict4)  # {1: 1, 2: 4, 3: 9}
dict5 = dict(one=1, two=2)
print(dict5)  # {'one': 1, 'two': 2}