Python 常见的数据类型有整型、浮点型、布尔型、None型、字符串、序列、字典、集合。

1. 整型

i = 5 
u = 123_456_678_789 # Python支持用 _ 分割数字。 
# 或 
i = '5' 
u = int(i)

10进制整数不能以0开头；0b表示二进制；0o表示八进制；0x表示十六进制

将字符串转化为整数时，字符串只能包含[0-9]中的数字，不然回报invalid literal for int() with base 10错误。

2. 浮点型

f = 2.45
# 或
i = 3
f = float(i)

Python中小数只有一个float，且范围无限。两个float值相加可能会得到一个不精确的值。

3.布尔型

result = 5 > 4
print('result =', result, type(result) # result = True <class 'bool'>
# 相对的，还有一个False  要注意首字母大写才是关键字

在Python中，True相当于1，Fasle相当于0，可以与数值进行运算，得到一个数值类型。

4. None值

# None（空值）
# None专门用来表示不存在
# 有返回值的函数，如果返回值不存在，就会返回None，见了要知道None是什么。
b = None
print(b)

5. 序列

序列即有序的数列，常见的有列表、元组和字符串。

5.1 可变序列-列表

# 通用操作
# 创建列表
my_list = []
my_list = [10, 20, 10, '30', [40, 50]]  # 列表的值可重复
# 索引
print('my_list[0] =',my_list[0]) # my_list[0] = 10 正数第一个 
print('my_list[-1] =',my_list[-1]) # my_list[-1] = [40, 50] 倒数第一个
#切片
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
# 通过切片来获取指定的元素
# 语法：列表[起始:结束] 
#   通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
#   做切片操作时，总会返回一个新的列表，不会影响原来的列表
#   起始和结束位置的索引都可以省略不写
#   如果省略结束位置，则会一直截取到最后
#   如果省略起始位置，则会从第一个元素开始截取
#   如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本
print(stus[0:3]) # ['孙悟空', '猪八戒', '沙和尚']
# 语法：列表[起始:结束:步长] 
#   步长表示，每次获取元素的间隔，默认值是1
#   步长不能是0，但是可以是负数
#   如果是负数，则会从列表的后部向前边取元素
print(stus[3:0:-1]) # ['唐僧', '沙和尚', '猪八戒']

# 修改操作
# 更新
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
stus[0] = 'sunwukong'
print('stus =', stus) # stus = ['sunwukong', '猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
# 增加
stus.append('红孩儿')
print('stus =', stus) # stus = ['孙悟空', '猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精', '红孩儿']

stus.insert(2,'唐僧') # 两个参数 第一个插入的位置，第二个插入的值
print('stus =', stus) # stus = ['孙悟空', '猪八戒', '唐僧', '沙和尚', '唐僧', '蜘蛛精', '白骨精']

stus.extend(['白骨精']) # 等价于 stus = stus + ['白骨精'] 都是扩展列表
print('stus =', stus) stus = ['孙悟空', '猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精', '白骨精']
# 删除
del stus[2]
print('stus =', stus) # stus = ['孙悟空', '猪八戒', '唐僧', '蜘蛛精', '白骨精'] del支持切片

result = stus.pop(2) # 删除索引=2的数据。如果pop的参数为空，删除最后一个元素
print('result =',result)  # result = 沙和尚 pop()不支持切片，会把删除的元素返回

stus.remove('猪八戒') # 删除指定值的元素；如果有多个相同的值，只会删除第一个。
print('stus =', stus) # stus = ['孙悟空', '沙和尚', '唐僧', '蜘蛛精', '白骨精']

stus.clear() # 清空列表，这时stus == []，而不是None

# 其他操作
# 反转列表
my_list = [10,1,20,3,4,5,0,-2]
# reverse()
# 用来反转列表
my_list.reverse()
print('my_list =', my_list) # my_list = [-2, 0, 5, 4, 3, 20, 1, 10]
# 排序
my_list.sort()
print('my_list =', my_list) # my_list = [-2, 0, 1, 3, 4, 5, 10, 20]

列表存储方便，但查询起来效率比较慢；可通过list()将其他类型对象转换为列表。

5.2 元组

元组（tuple）和列表类似，但不支持修改的操作，为不可变对象。用的相对比较少一些。

# 
my_tuple = (1, 2, 3) # 等价于 my_tuple = 1, 2, 3 但是元组至少要有一个“,”
print('my_tuple[1] =', my_tuple[1]) # my_tuple[1] = 2
# tuple不支持reverse()和sort()函数
my_list = (1, 2)
my_list.sort()
print('my_list =', my_list) # 'tuple' object has no attribute 'sort'
# 解包 解包时可以用 *加变量 代表元组中的几个元素；一次解包中只能出现一次 *加变量的格式
my_tuple = 10, 20, 'a', [11,22,33]
a, *c, d = my_tuple
print('a =', a, end='  ')
print('c =', c, end='  ')
print('d =', d, end='  ')# a = 10  c = [20, 'a']  d = [11, 22, 33]  
a = 10
b = 20
a, b = b, a
print('a =', a, end='  ')
print('b =', b, end='  ') # a = 20  b = 10  python支持这样互换变量而不用中间值，属于解包的一种用法

5.3 字符串

字符串(str)是序列的一种，属于不可变对象。

# str也可以遍历
s = 'abc'
n = 0
for i in s:
    print(f's[{n}] =', i, end='  ')
    n +=1  # s[0] = a  s[1] = b  s[2] = c  
# 字符串可以用单引号也可以用双引号，但二者不能混合使用
# 三重引号(''' """)代表长字符串，三重引号可以换行，并且会保留字符串中的格式
s = '''a
b
c'''
print('s =', s)
# s = a
  b
  c
# 如果想输出引号和单引号之类的字符，可使用转义字符的方式
# 转义字符
# 可以使用 \ 作为转义字符，通过转义字符，可以在字符串中使用一些特殊的内容
# 例子：
#   \' 表示'
#   \" 表示"
#   \t 表示制表符
#   \n 表示换行符
#   \\ 表示反斜杠
#   \uxxxx 表示Unicode编码
s = "子曰:\"学而时习之，\\\n乐呵乐呵！\""
print(s) # 子曰:"学而时习之，\
乐呵乐呵！"

6. 字典

字典(map)可以看成键值对的集合，相对于列表来说，查询更快。

# 创建字典
# 字典会自动忽略重复的键，如果有重复的键，后面的会替换前面的
# 字典的值可以是任意对象
# 字典的键可以是任意的不可变对象（int、str、bool、tuple ...），但是一般我们都会使用str
m = {}
m = {'name': '孙悟空', 'age': 18, 'gender': '男', 'name': 'sunwukong'} # 直接用{}
m = dict(name='孙悟空', age=18, gender='男', 'name' = 'sunwukong') # dict()函数
m = dict(['name', '孙悟空'], ['age', 18], ['gender', '男'], ['name', 'sunwukong']) # 双值字序列
print('m =', m, type(m)) # m = {'name': 'sunwukong', 'age': 18, 'gender': '男'} <class 'dict'>
m = {}
m = {'name': '孙悟空', 'age': 18, 'gender': '男', 'name': 'sunwukong'}
print('m[name]', m['name'], type(m['name'])) # m[name] sunwukong <class 'str'>

# 字典的方法
m = {'name': '孙悟空', 'age': 18, 'gender': '男'}
i = len(m) # len()函数获取字典中键值对的个数；i的值是3
s = m.get('name') # get()函数根据键获取值；s的值是孙悟空 m['name']具有相同的效果，如果键不存在会报错
# in 检查字典中是否包含指定的键
# not in 检查字典中是否不包含指定的键
print('hello' in m) # False 返回布尔值
# 修改字典的值
m['name'] = 'suwukong'  # m = {'name': 'suwukong', 'age': 18, 'gender': '男'}
# 增加字典的键值对
# setdefault(key[, default]) 可以用来向字典中添加key-value
#   如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
#   如果key不存在，则向字典中添加这个key，并设置value
result = m.setdefault('name', '猪八戒') # 因键'name'已存在，不做任何操作
result = m.setdefault('hello', '猪八戒') # 增加键值对['hello', '猪八戒']
print('m =', m) # m = {'name': '孙悟空', 'age': 18, 'gender': '男', 'hello': '猪八戒'}

d = {'a': 1, 'b': 2, 'c': 3}
d2 = {'d': 4, 'e': 5, 'f': 6, 'a': 7}
d.update(d2) # update()方法将d2键值对添加到d中。重复的键，后面的会覆盖前面的
print('d =', d) # d = {'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
# 删除字典中的键值对
del d['a'] # del 可以删除键为'a'的键值对；del可以删除变量，释放内存
result = d.popitem() # popitem()会随机删除一个键值对，一般是最后一个；会将删除的键值对以元组的形式返回；如果对一个空字典使用popitem()函数，会抛出异常
result = d.pop('b', None) # result的值时2 pop()会返回删除键值对的‘值’。pop()有两个参数，第一个是要删除键值对的‘键’；第二个是‘键’不存在时返回的值
d.clear() # 清空字典

# 浅复制 copy()
# 该方法用于对字典进行浅复制
# 复制以后的对象，和原对象是独立，修改一个不会影响另一个
# 注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
d = {'a': 1, 'b': 2, 'c': 3}
d2 = d.copy()
d['a'] = 100
print('d2 =', d2, type(d2) # d2 = {'a': 1, 'b': 2, 'c': 3} <class 'dict'>

d = {'a': {'name': '孙悟空', 'age': 18}, 'b': 2, 'c': 3}
d2 = d.copy()
d2['a']['name'] = '猪八戒'
print('d = ', d, id(d))
print('d2 = ', d2, id(d2))
# d =  {'a': {'name': '猪八戒', 'age': 18}, 'b': 2, 'c': 3} 1890616490560
# d2 =  {'a': {'name': '猪八戒', 'age': 18}, 'b': 2, 'c': 3} 1890616489600

# 遍历字典
# keys() 该方法会返回字典的所有的key
#   该方法会返回一个序列，序列中保存有字典的所有的键
d = {'name':'孙悟空','age':18,'gender':'男'}

# 通过遍历keys()来获取所有的键
# for k in d.keys() :
#     print(k , d[k])

# values()
# 该方法会返回一个序列，序列中保存有字典的左右的值
# for v in d.values():
#     print(v)

# items()
# 该方法会返回字典中所有的项
# 它会返回一个序列，序列中包含有双值子序列
# 双值分别是，字典中的key和value
# print(d.items())
for k,v in d.items() :
    print(k , '=' , v)

7.集合

集合（set）也是用{}表示，不按照顺序排列。集合会自动删除重复的元素。

# 创建集合
s = set() # 创建空集合
s = set({'a':1,'b':2,'c':3}) # set()函数将字典转换为集合，只保留‘键’  {'c', 'b', 'a'} <class 'set'>
s = {(1,2,3),(4,6,7)} # 可以将元组转换为集合，但列表不行 {(4, 6, 7), (1, 2, 3)} <class 'set'>
s = {1, 2, 3, 5 ,'6'}
# 使用in和not in来检查集合中的元素
print('c' in s) # False

# 使用len()来获取集合中元素的数量
print(len(s)) # 5

# add() 向集合中添加元素
s.add(10)
s.add(30)

# update() 将一个集合中的元素添加到当前集合中
#   update()可以传递序列或字典作为参数，字典只会使用键
s2 = set('hello')
s.update(s2)
s.update((10,20,30,40,50))
s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})
print('s =', s, type(s)) # s = {1, 2, 3, 'o', 5, 'e', 100, 40, 1000, 10, 50, 20, '6', 'h', 'l', 30} <class 'set'>

# 删除元素
result = s.pop() # 删除随机元素并将元素返回
remove() # 删除指定元素，如果元素不在集合中，会报错
s.remove(1) # 无返回值
s.clear() # 清空集合
s.copy() # 对集合进行浅复制

# 集合的运算
# 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
# 创建两个集合
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集运算
result = s & s2 # {3, 4, 5}

# | 并集运算
result = s | s2 # {1,2,3,4,5,6,7}

# - 差集
result = s - s2 # {1, 2}

# ^ 异或集 获取只在一个集合中出现的元素
result = s ^ s2 # {1, 2, 6, 7}

# <= 检查一个集合是否是另一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}

result = a <= b # True
result = {1,2,3} <= {1,2,3} # True
result = {1,2,3,4,5} <= {1,2,3} # False

# < 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集
result = {1,2,3} < {1,2,3} # False
result = {1,2,3} < {1,2,3,4,5} # True

# >= 检查一个集合是否是另一个的超集
# > 检查一个集合是否是另一个的真超集
print('result =',result)