Python中的数据类型
1、数据类型（Number、String、list、typle、set、dictionary）
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型，一个变量可以通过赋值指向不同类型的对象
#!/usr/bin/python3
counter = 100 # 整型变量
miles = 1000.0 # 浮点型变量
name = "runoob" # 字符串
a = b = c = 1 # 同时为多个变量赋值
a, b, c = 1, 2, "runoob" # 分别同时为多个变量指定值。两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c
Python3 中有六个标准的数据类型：
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
string、list 和 tuple 都属于 sequence（序列）。
内置的 type() 和 isinstance() 函数可以用来查询变量所指的对象类型：
a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d)) # <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
a = 111
isinstance(a, int) # True
isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型，isinstance()会认为子类是一种父类类型。
>>> class A:
... pass
...
>>> class B(A):
... pass
...
>>> isinstance(A(), A)
True
>>> type(A()) == A
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False
2、数字类型（Number）
数字类型是不允许改变的。python中数字有四种类型：整数、布尔型、浮点数和复数。
- int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
Python允许在数字中间以
_分隔，因此，写成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4。Python的整数和浮点数都没有大小限制。
- bool (布尔), 如 True。（在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加）
- float (浮点数), 如 1.23、3E-2
- complex (复数), 如 1 + 2j、 1.1 + 2.2j
2.1、布尔值（true、false）
Python中的布尔值可以用and、or和not运算。
>>> True and True True >>> True or False True >>> not True False
2.2、数字类型转换方法（int()、float()、complex()）
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
-
int(x) 将x转换为一个整数。
-
float(x) 将x转换到一个浮点数。
-
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
-
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
3、字符串（string）
python中的字符串有以下特点：
- python中单引号和双引号使用完全相同。
- 使用三引号('''或""")可以指定一个多行字符串。
- 转义符 '\'。转义字符
\可以用来转义，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\。使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。 - 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
- 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
- Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
- Python中的字符串不能改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。
- Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
- 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
单行及多行字符串：
word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成""" #多行字符串'''...'''还可以在前面加上r使用，将认为里面的字符串默认不转义：
字符串截取及转义：
#!/usr/bin/python3
str='Runoob'
print(str) # 输出字符串 Runoob
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符 Runoo
print(str[0]) # 输出字符串第一个字符 R
print(str[2:5]) # 输出从第三个开始到第五个的字符 noo
print(str[2:]) # 输出从第三个开始后的所有字符 noob
print(str[1:5:2]) # 输出从第二个开始到第五个且每隔两个的字符 uo
print(str * 2) # 输出字符串两次 RunoobRunoob
print(str + '你好') # 连接字符串 Runoob你好
print('------------------------------')
print('hello\nrunoob') # 使用反斜杠(\)+n转义特殊字符
# hello
# runoob
print(r'hello\nrunoob') # 在字符串前面添加一个 r，表示原始字符 串，不会发生转义 hello\nrunoob
len()方法可以得到字符串的长度：
>>> len('ABC')
3
>>> len('中文')
2
在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。在Python3中，所有的字符串都是Unicode字符串。
3.1、字符串中的占位符（%）
在字符串中，我们可以用 % 占位符来代替变量输出格式化字符：
print ("我叫 %s 今年 %d 岁!" % ('小明', 10)) # 我叫 小明 今年 10 岁! 'Hello, %s' % 'world' # 只有一个占位符后面的变量可以省略括号 Hello, world
%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：
print('%2d-%02d' % (3, 1)) # 3-01 注意：3前面有1个空格
print('%.2f' % 3.1415926) #3.14
如果不确定应该用什么，可以直接用%s，它会把任何数据类型转换为字符串：
>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'
另外，可以用%%来表示一个%：
>>> 'growth rate: %d %%' % 7 'growth rate: 7 %'
3.2、format()、f-string输出格式化字符串
还可以使用字符串的format()方法来输出格式化的字符串，它会用传入的参数依次替换字符串内的占位符{0}、{1}、、
'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125) #'Hello, 小明, 成绩提升了 17.1%'
另外，还可以使用以f开头的字符串，称之为f-string。f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。它和普通字符串不同之处在于，字符串如果包含{xxx}，就会以对应的变量替换。
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：
r = 2.5 s = 3.14 * r ** 2 print(f' {r} and number {s:.2f}') # 2.5 and number 19.62
上述代码中，{r}被变量r的值替换，{s:.2f}被变量s的值替换，并且:后面的.2f指定了格式化参数（即保留两位小数），因此，{s:.2f}的替换结果是19.62。
4、list 列表（类似可变长数组）
Python 内置的一种数据类型是列表 list，列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
list是一种有序的集合，可以随时添加和删除其中的元素。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套），因此 list 可以是一个二维数组，类似的还有三维、四维……数组。。
a = ['Michael', 'Bob', 'Tracy']
L = ['Apple', 123, True]
s = ['python', 'java', ['asp', 'php'], 'scheme']
用len()函数可以获得list元素的个数，如果一个list中一个元素也没有，就是一个空的list，它的长度为0：
len(classmates) #3
L = []
print(len(L)) #0
可以用 + 号和 * 号对列表进行操作，加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：
#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (tinylist * 2) # 输出两次列表 [123, 'runoob', 123, 'runoob']
print (list + tinylist) # 连接列表 ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
4.1、截取list中的元素（listObj[头下标:尾下标]）
和字符串一样，列表同样可以被索引和截取。列表截取的语法格式：变量[头下标:尾下标]，不包含尾下标的元素。索引值以 0 为开始值，-1 为从末尾的开始位置。列表被截取后返回一个包含截取元素的新列表。
实例：
#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list) # 输出完整列表 ['abcd', 786, 2.23, 'runoob', 70.2]
print (list[0]) # 输出列表第一个元素 abcd
print (list[1:3]) # 从第二个开始输出到第三个元素 [786, 2.23]
print (list[2:]) # 输出从第三个元素开始的所有元素 [2.23, 'runoob', 70.2]
当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1。
与Python字符串不一样的是，列表中的元素是可以改变的。要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：
a = [1, 2, 3, 4, 5, 6]
a[0] = 9 #修改list
a[2:5] = [13, 14, 15]
print(a) #[9, 2, 13, 14, 15, 6]
a[2:5] = [] # 将对应的元素值设置为 []
print(a) #[9, 2, 6]
4.2、给list添加元素（append()、insert()）
list是一个可变的有序表，所以，可以往list中追加元素到末尾：
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
也可以把元素插入到指定的位置，比如索引号为1的位置：
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
4.3、删除list中的元素（pop()、remove）
要删除list末尾的元素，用pop()方法，pop() 方法返回被移除的元素。
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
要删除指定位置的元素，用pop(i)方法，其中i是索引位置：
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']
list.remove(obj) remove() 函数用于移除列表中某个值的第一个匹配项：
#!/usr/bin/python3 list1 = ['Google', 'Runoob', 'Taobao'] list1.remove('Taobao') print ("列表现在为 : ", list1) #['Google', 'Runoob']
5、tuple元组（不可变的list）
另一种有序列表叫元组：tuple。元组（tuple）与列表类似，不同之处在于元组的元素不能修改，tuple一旦初始化就不能修改。当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来。
元组写在小括号 () 里，元素之间用逗号隔开。元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取，同时也可以使用 + 号和 * 符号。我们可以把字符串看作一种特殊的元组。
示例：
#!/usr/bin/python3 tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 ) tinytuple = (123, 'runoob') print (tuple) # 输出完整元组 ('abcd', 786, 2.23, 'runoob', 70.2) print (tuple[0]) # 输出元组的第一个元素 abcd print (tuple[1:3]) # 输出从第二个元素开始到第三个元素 (786, 2.23) print (tuple[2:]) # 输出从第三个元素开始的所有元素 (2.23, 'runoob', 70.2) print (tinytuple * 2) # 输出两次元组 (123, 'runoob', 123, 'runoob') print (tuple + tinytuple) # 连接元组 ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
tuple 中的元素不能修改，它也没有append()、insert()这样的方法。但如果tuple中的元素含有一些引用类型的值，比如 list ，那该 list 是可变的，但此时 tuple 并不违背定义后不可变的原则，因为只是 tuple 中的 list 发生了改变，但 tuple 指向 list 仍未发生改变。但不允许指向的 list 被替换成另一个 list。
元素中的元素不能修改，但是整个元组可以重新被赋值。所谓元组的不可变指的是元组所指向的内存中的内容不可变。重新赋值的元组就绑定到新的对象了，不是修改了原来的对象，所以是可以的。
tup = ('r', 'u', 'n', 'o', 'o', 'b') # tup[0] = 'g' # 修改元组中的元素将直接报错 tup = (1, 2, 3) #支持重新给元组赋值
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组 tup2 = (20,) # 构造一个元素的元组，需要在元素后添加逗号
要定义一个只有1个元素的 tuple 不能直接写 tup2 = (20)，此时定义的不是 tuple，而是将 20 赋值给了 tup2 这个变量。这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。所以，只有1个元素的tuple定义时必须加一个逗号，来消除歧义
6、set集合（类似不可重复数组）
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。在set中，没有重复的值，重复元素在set中自动被过滤。set 不是有序的，打印出的顺序并不能代表它里面元素的排序。set 可以看成数学意义上的无序和无重复元素的集合。集合之间还可以进行集合运算（差集 -、并集 |、交集 &、^）。
6.1、创建集合
可以使用大括号 { } 或者 set() 函数创建集合，使用 set() 函数时，括号里面需提供一个 list 作为输入参数：
parame = {value01,value02,...}
或者
set(value)
实例：
#!/usr/bin/python3 sites = {'Google', 'Taobao', 'Runoob', 'Google'} # 集合中的重复元素会被自动去掉，程序不会报错 print(sites) #输出集合 {'Runoob', 'Google', 'Taobao'} #判断元素是否存在于集合当中 if 'Runoob' in sites : print('Runoob 在集合中') #输出 在集合中 else : print('Runoob 不在集合中') # set可以进行集合运算 a = set('abracadabra') b = set('alacazam') print(a) # {'b', 'c', 'a', 'r', 'd'} print(a - b) # a 和 b 的差集 {'r', 'b', 'd'} print(a | b) # a 和 b 的并集 {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'} print(a & b) # a 和 b 的交集 {'c', 'a'} print(a ^ b) # a 和 b 中不同时存在的元素 {'z', 'b', 'm', 'r', 'l', 'd'}
set() 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。该函数的语法格式如下所示，其中，iteration 就表示字符串、列表、元组、range 对象等数据。
setname = set(iteration)
代码示例：
set1 = set("c.biancheng.net") set2 = set([1,2,3,4,5]) set3 = set((1,2,3,4,5)) print("set1:",set1) # set1: {'a', 'g', 'b', 'c', 'n', 'h', '.', 't', 'i', 'e'} print("set2:",set2) # set2: {1, 2, 3, 4, 5} print("set3:",set3) # set3: {1, 2, 3, 4, 5}
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合的原理和字典一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。比如把 list 放入set 程序将会报错。
6.2、添加元素（add）
通过add(key)方法可以添加元素到set中，重复添加不会报错，但不会有效果：
thisset = set(("Google", "Runoob")) thisset.add("Facebook") #{'Google', 'Facebook', 'Runoob'}
6.3、删除元素（remove、discard）
通过remove(key)方法可以删除元素，但是元素如果不存在，该方法会报错。
thisset = set(("Google", "Runoob", "Taobao")) thisset.remove("Taobao") #{'Google', 'Runoob'} thisset.remove("Facebook") # 不存在会发生错误
此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误：s.discard( x )
thisset = set(("Google", "Runoob", "Taobao")) thisset.discard("Facebook") # 不存在不会发生错误
7、Dictionary字典（类似对象）
Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
在同一个字典中，键(key)必须是唯一的，并且必须是不可变的，所以可以用数字，字符串或元组充当，而用列表就不行。
不可变对象是常量，该对象的内容是不会发生改变的。对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
创建及使用 dict 代码示例：
#!/usr/bin/python3 tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'} dict = {} dict['one'] = "菜鸟教程" dict[2] = "菜鸟工具" print (dict['one']) # 输出键为 'one' 的值 菜鸟教程 print (dict[2]) # 输出键为 2 的值 菜鸟工具 print (tinydict) # 输出完整的字典 {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'} print (tinydict.keys()) # 输出所有键 dict_keys(['name', 'code', 'site']) print (tinydict.values()) # 输出所有值 dict_values(['runoob', 1, 'www.runoob.com'])
创建空字典使用 { }。
使用构造函数 dict() 可以直接从键值对序列中构建字典如下：
dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)]) #{'Runoob': 1, 'Google': 2, 'Taobao': 3} dict(Runoob=1, Google=2, Taobao=3) #{'Runoob': 1, 'Google': 2, 'Taobao': 3} {x: x**2 for x in (2, 4, 6)} #{2: 4, 4: 16, 6: 36}
通过dict提供的get()方法可以返回指定键的值，如果该字典中不存在该键，则返回可以返回None，或者第二个参数指定的value：
d.get('Thomas') #none d.get('Thomas', -1) #-1
可以通过in来判断key是否存在于字典中：
'Thomas' in d # False
要删除一个key，用pop(key)方法，对应的value也会从dict中删除，该方法返回被删除的值：
d = {'name': 'wen', age: 11}
d.pop('name') #wen
