Python3 数据类型

一. 内置数据类型

文本类型	str
数值类型	int, float, complex
序列类型	list, tuple, range
映射类型	dict
集合类型	set, frozenset
布尔类型	bool
二进制类型	bytes, bytearray, memoryview

0b：前缀表示二进制 bin(0x23) = 0b10011
0o：前缀表示八进制 oct(0x10) = 0o20
0x：前缀表示十六进制 hex(0b1010) = 0xa

不可变数据：Number, String, Tuple
可变数据：List, Dictionary, Set

二. Number 数字类型

数字值不能改变，如果改变数字数据类型的值，将重新分配内存空间
type()或isinstance()函数判断数值的类型。

# type()：不会认为子类是一种父类类型。
# isinstance()：会认为子类是一种父类类型。
>>> a = 1
>>> type(a)
>>> isinstance(a, int)
>>> del a  # 删除对象引用

int：Python3 没有 Long
bool：True / False
float：3e-2 / 0.03
complex：1.1+2.2j 或  complex(1.1, 2.2)

注：实际上，除空值（例如 ()、[]、{}、“”、数字 0 和值 None）外，没有多少值会被评估为 False。

>>> print(786, True+3, False+1, bool(-2), bool(''), 
	bool(), 3E-2, 1.1+2.2j, '\n')
>>> issubclass(bool, int)
True

三. str 字符串类型

字符串不能改变

• 用单引号' 或 双引号''括起来，同时使用反斜杠\转义特殊字符。在字符串前添加r，表示原始字符串；
• 用三引号'''可以指定一个多行字符串；
• 加号+是字符串的连接符，星号*表示复制当前字符串；
• 索引值以 0 为开始值，-1 为末尾的开始位置；
• 字符串的截取的语法格式：变量[头下标:尾下标:步长]（左闭右开原则）。

f-string格式化字符串相关知识

str = 'Runoob'
print(str, str[0], str[0:-1], str[2:], str[-1::-1], str * 2, 
	str + ' + Hello', 'Ru\noob', r'Run\noob')
# 字符串格式化  通过 {} 和 : 来代替以前的 %
print("My name is %s, I'm %d years old." % ('lizhong', 25))
print("My name is {0}, I'm {1:03d} years old.".format('lizhong', 25), '\n')
# f-Strings      
# 字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去
>>> name = 'Runoob'  
>>> f'Hello, My name is {name}'  # {}替换变量
'Hello, My name is Runoob'
>>> f'{1+2}'  # 使用表达式
'3'
# 可以使用 = 符号来拼接运算表达式与结果
>>> x = 1
>>> print(f'{x+1=}')  
x+1=2

# 内置方法: dir(str)
a = 'i LovE pytHoN'
a.capitalize() # 将字符串的第一个字母变成大写,其他字母变小写。
a.casefold() # 将所有字符均设为小写。

a.center(20, '*') # 返回一个原字符串居中,并使用特殊字符填充至指定长度新字符串。

str = "this is string example....wow!!!"
str.count('i', 4, 40) # 用于统计字符串里某个字符或子字符串出现的次数.

四. list 列表类型 []

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

列表中的元素是可以修改

# list 的创建方式
l  = []  # 空列表
l1 = list('abcd')
l2 = list((1,2,3,4,5))
l3 = list({'one':1, 'two':2, 'three':3})
l4 = list(range(1, 10, 2))
l5 = ['abcd', 786, 2.23, 1.1+2.2j]

# 列表推导式
l6 = [x.upper() for x in ['lizhong', 'Google', 'Facebook'] if len(x)>7]  
l8 = [1]*10
l7 = l5  # 引用自同一个对象的两个标识符
print(id(l5), id(l7))  # l5改变则l7改变
print(l5 is l7)
# is 用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等。
print(l, l1, l2, l3[1:], l3[-1::-1], l3 * 2, 
	l + ['Hello', 123, 3.14], '\n')

# 内置方法 dir([]) l[i]=x, l[i:j]=it, l[i:j:k]=it, del l[i:j]
a = [1,2,3]

a.insert(3, 100) # 用于将指定对象插入列表的指定位置。
a.append(5) # 用于在列表末尾添加新的对象。
a.extend([9,6,7]) # 用于在列表末尾一次性追加另一个序列中的多个值.
a.clear() # 用于清空列表.
b = a.copy() # 浅拷贝，修改不影响原始数据   不能b=a

a.count(3) # 用于统计某个元素在列表中出现的次数。
a.index(4) # 用于从列表中找出某个值第一个匹配项的索引位置。

a.pop() # 用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
a.remove(4) # 用于移除列表中某个值的第一个匹配项。

a.reverse() # 用于反向列表中元素。
a.sort(reverse=True) # 用于对原列表进行排序, True降序，False升序
a.sort()

五. tuple 元组类型 ()

A tuple is in many ways similar to a list; one of the most important differences is that tuples can be used as keys in dictionaries and as elements of sets, while lists cannot.
元组中的元素不能修改

# tuple 的创建方式
t = () # 空元组
t1 = (20, ) # 一个元素，需要在元素后添加逗号
t2 = tuple('hello')
t3 = tuple([1, 2, 3, 4, 5])
t4 = tuple({'one':1, 'two':2, 'three':3})
t5 = tuple(range(1, 10, 2))
t6 = ('abce', 786, 2.23, 1.1+2.2j)

# 元组推导式，返回的是生成器对象
a = (x for x in range(1,10)) 
tuple(a) # 直接将生成器对象转换为元组

print(t, t1, t2, t3, t4, t5, t6[1:], t6[-1::-1], t6 * 2,
	t + ('Hello', 123, 3.14), '\n')
	
# 内置方法: dir(())
a = tuple([1,2,3,5,3,2,6,7,3])
a.count(3)  # 返回指定值在元组中出现的次数。
a.index(3)  # 查找指定值的第一次出现索引。
del a

六. set() 集合类型 {}

集合中的元素可以修改
集合主要利用其唯一性，并集|，交集&，差集-等操作。
不可以通过下标来访问其中的元素，可以通过转化为list类型，然后通过下标来访问。

# set 一组无序且不可重复的序列
# set 的创建方式
s = set() # 空集合
s1 = set('12345')
s2 = set([1, 2, 3, 4, 5])
s3 = set(('Google', 'Runoob', 'Facebook'))
s4 = set({'one':1, 'two':2, 'three':3})  # key构成集合
s5 = set(range(1, 10, 2))
s6 = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

# 集合推导式
a = set('abracadabra')
b = set('alacazam')
c = { x for x in a if x not in 'abc' }

# a^b: (a-b)与(b-a)这两个差集的并集
print(a, a-b, a|b, a&b, a^b, c)
print(s, len(s), s1, s2, s3, s4, '\n')


# 内置方法: dir(set)
a = set('lizhong')
b = set('google')
# add 与 update 区别
## a.add('hello') {'hello'}   a.add([1,2,3])❌
## a.update('hello') {''d', 'l', 'o', 'r', 'w'}  a.update([1,2,3])✅ 
a.add('k') 
a.update(b) # 方法用于修改当前集合，可以添加新的元素或集合到当前集合中

a.discard('g') # 于移除指定的集合元素.
a.remove('g') # 用于移除集合中的指定元素。该方法不同于 discard() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

a.pop() # 用于随机移除一个元素。
a.clear()
b = a.copy()  # 浅拷贝，修改不会影响原始数据a  (不能使用b=a)

a = {'1', '2', '3'}
b = {'2', '1', '5'}
a.difference(b)  # {'3'}  差集 a-b 
a.intersection(b) # {'1', '2'} 交集 a&b
a.union(b) # 并集 a|b

a.isdisjoint(b) # a,b是否包含相同元素  包含False, 不包含True

a.issubset(b)  # a是b的子集吗  是子集True，不是子集False
a.issupset(b) # a包含全部b吗  包含True，不包含False

七. dict() 字典类型 {}

字典中元素的关键字key不可修改，且不能重复，但值value可以修改

# dict 的创建方式
a = {} # 空字典
b = dict([('foo', 100), ('bar', 200), ('dic', 300)]) # 列表
c = dict((('one',1), ('two',2), ('three',3))) # 元组
d = dict({('one',1), ('two',2), ('three',3)}) # 集合
e = {'one':1, 'two':2, 'three':3}

f = dict(zip(['name', 'code', 'site'], ['runoob', 1, 'www.runoob.com']))
g = dict({'lizhong':5408}, jack=4098, sjoerd=4127)

# 字典推导式
dic = {x: x**2 for x in (2, 4, 6)} 

h = {}
h['one'] = '1 - 菜鸟教程'
h[2] = '2 - 菜鸟工具'
h['two'] = '3 - 菜鸟家园'
del h['two']

# 内置方法: dir({}) 或 dir(dict) 
a = {'one':1, 'two':2, 'three':3}  
b = {'google':'US', 'baidu':'CN'}
seq = ('Google', 'Runoob', 'Taobao')
c = dict.fromkeys(seq) # 以seq为键，值为None
d = dict.fromkeys(seq, 10) # 以seq为键，值为10

a.update(b) # 把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。

a.get('one') # 返回指定键的值。如果键不在字典中返回None
a.setdefault('four')  # 返回指定键的值，如果键不在字典中，将会添加键并将值设为默认值。
list(a.items()) # 以列表返回可遍历的(键, 值) 元组数组
list(a.keys()) # 以列表返回一个字典所有的键。
list(a.values()) # 以列表返回一个字典所有的值。

a.pop('one') # 删除字典给定键 key 所对应的值，返回值为被删除的值。如果删除的键不存在会触发异常。
a.popitem() # 返回并删除字典中的最后一对键和值。如果字典已经为空,报出 KeyError 异常。
a.clear() # 用于删除字典内所有元素
b = a.copy() # 浅拷贝，修改不会影响原数据a  （不能b=a）