2.python 基本数据类型

# python 基本数据类型


# python中等号用来给变量赋值
counter = 100  # 整形变量
miles = 1000.0  # 浮点型变量
name = "runoob"  # 字符串
print(counter)
print(miles)
print(name)

# python允许同时为多个变量赋值
a = b = c = 1
print(a)
print(b)
print(c)

# 为多个对象指定多个变量
a, b, c = 1, "runoob", 2
print(a)
print(b)
print(c)

"""
标准数据类型：
Number
String
bool
List
Tuple
Set
Dictionary

不可变数据：String ，Number ，Tuple
可变数据：List ， Set， Dict
"""

# Number
# python3支持int float bool complex
# 内置type()函数可以用来查询变量所指的对象类型
a, b, c, d = 20, 0.5, True, 1 + 5j
print(a, "a的类型为：", type(a))  # 20 a的类型为： <class 'int'>
print(b, "b的类型为：", type(b))  # 0.5 b的类型为： <class 'float'>
print(c, "c的类型为：", type(c))  # True c的类型为： <class 'bool'>
print(d, "d的类型为：", type(d))  # (1+5j) d的类型为： <class 'complex'>

# 还可以用isinstance来判断
a = 111
print(isinstance(a, int))  # True

"""
isinstance和type的区别：
type()不会认为子类是一种父类类型
isinstance()会认为子类是一种父类类型
"""
print("============================================")


class A:
    pass


class B(A):
    pass


print(isinstance(A(), A))  # True
print(type(A()) == A)  # True
print(isinstance(B(), A))  # True
print(type(B()) == A)  # False

# 当你指定一个值时Number对象就会被创建
var1 = 1
var2 = 10

# 可以使用del 语句删除一些对象的引用，可以删除单个或多个对象
# del var1
del var1, var2
# print(var1, var2)  # NameError: name 'var1' is not defined

# 布尔值为False的十种类型：0，0.0，False，0j，None，空字符串(''),空列表([]),空元组(()),空集合(set()),空字典({})

# 列表
# 列表截取的语法格式：变量[头下标:尾下标:步长]
# 列表被截取后返回一个包含所需元素的新列表
# 加号 + 是列表链接运算符，星号 * 是重复操作
list1 = ["abc", 123, 2.3, 0j]
list2 = [456, 'abc']
print(list1+list2)  # ['abc', 123, 2.3, 0j, 456, 'abc']
a = list1[0:3:2]
print(a)  # ['abc', 2.3]
b = list1[::-1]
print(b)  # [0j, 2.3, 123, 'abc']
# 列表元素修改
list1[1] = 0
print(list1)  # ['abc', 0, 2.3, 0j]

# 数据基本类型 ： 元组
# 元组（tuple）与列表类似，不同之处在于元组的元素不能修改，元组写在小括号（）里，不同的元素用逗号隔开
tup1 = (123, "abc", 0.5, 0j, False)
tup2 = ([123, "set"], {456, "qaz"})
print(tup1[0])  # 123
print(tup1[0:2])  # (123, 'abc')
print(tup1[2:])  # (0.5, 0j, False)
print(tup1[::-1])  # (False, 0j, 0.5, 'abc', 123)
# tup1[0:2] = tup2  # 修改元素的操作是非法的
# print(tup1)  # TypeError: 'tuple' object does not support item assignment
# 虽然tuple的元素不可变，但他可以包含可变对象,比如列表；
tup2[0][1] = '000'  # 修改元组内可变类型元素（例如：列表）的元素是允许的
print(tup2)  # ([123, '000'], {456, 'qaz'})

# 构造0个或1个元素的元组
tup1 = ()  # 空元组
tup2 = (20,)  # 一个元素需要在元素后面添加逗号

not_a_tuple = (42)  # 不加逗号将是整数类型，不是元组类型

# String，List，Tuple 都属于sequence序列


# python中集合Set是一种无序，可变的数据类型，用于存储唯一的元素
# 空集合
sites1 = set()
print(sites1, type(sites1))  # set() <class 'set'>
# 集合的元素组成：不可变数据类型，String Number Tuple
# sites2 = {"123", 456, (20, ), {"1": 2}}
# print(sites2)  # TypeError: unhashable type: 'dict'
# sites2 = {'123', {'123', 456}, 123, (20, )}
# print(sites2)  # TypeError: unhashable type: 'set'

# 输出集合，重复的元素被自动去掉
sites3 = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu', 'Baidu'}
print(sites3)  # {'Baidu', 'Runoob', 'Facebook', 'Google', 'Taobao', 'Zhihu'}
# 成员测试
if 'Google' in sites3:
    print('Google在集合中')
else:
    print('Google不在集合中')
# Set可以进行集合运算
a = {1, 2, 3, 4, 5, 6}
b = {4, 5, 6, 7, 8, 9}
# a 和 b 的差集
print(a - b)  # {1, 2, 3}
# b 和 a 的差集
print(b - a)  # {8, 9, 7}
# a 和 b 的并集
print(a | b)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}
# a 和 b 的交集
print(a & b)  # {4, 5, 6}
# a 和 b 中不同时存在的元素（补集）
print(a ^ b)  # {1, 2, 3, 7, 8, 9}

# 字典Dict
# 列表是有序的对象集合，字典是无序的对象集合
# 两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取
# 字典是一种映射类型，字典用{}标识，他是一个无序的键（key）：值（value）组合
# key必须使用不可变数据类型
# 在同一字典中key必须是唯一的
dict1 = {}
dict1['one'] = "1 - 菜鸟教程"
dict1[2] = '2 - 菜鸟教程'
print(dict1)  # {'one': '1 - 菜鸟教程', 2: '2 - 菜鸟教程'}
# 输出所有的键
print(dict1.keys())  # dict_keys(['one', 2])
# 输出所有的值
print(dict1.values())  # dict_values(['1 - 菜鸟教程', '2 - 菜鸟教程'])

# 字典推导式
dict2 = {x: x ** 2 for x in [2, 4, 6]}
print(dict2)  # {2: 4, 4: 16, 6: 36}