Python中常见的数据类型
Python基本数据类型一般分为：数字、字符串、列表、元组、字典、集合（可变集合和不可变集合）这六种基本数据类型，
其中 数字、字符串、元祖和可变集合为不可变类型，列表、字典和不可变集合为可变类型。
下面我们来详细的介绍一下他们：
数字：
数字类型是不可更改的对象。对变量改变数字值就是生成/创建新的对象。Python支持多种数字类型：
整型(标准整型和长整型(Python2.7及之前的有这种类型))、布尔型、双精度浮点型、十进制浮点型、复数。
标准整型
int，标准整型，在大多数32位机器上标准整型取值范围是-231到231-1，也就是-2147483648~2147483647，如果在64位机器使用64位编译器，那么这个系统的标准整型将是64位。
布尔型
bool，从Python2.3开始Python中添加了布尔类型。布尔类型有两种True和False。对于没有__nozero__方法的对象默认是True。
对于值为0的数字、空集（空列表、空元组、空字典等）在Python中的布尔类型中都是False。
>>> bool(1)
True
>>> bool('a')
True
>>> bool(0)
False
>>> bool('')
False
浮点型
float，每个浮点型占8个字节（64位），完全遵守IEEE754号规范（52M/11E/1S）,其中52个位用于表示底，11个位用于表示指数（可表示的范围大约是±10**308.25），剩下的一个位表示符号。这看上去相当完美，然而，实际精度依赖于机器架构和创建Python解释器的编译器。
浮点型值通常都有一个小数点和一个可选的后缀e（大写或小写，表示科学计数法）。在e和指数之间可以用正（+）或负（-）表示指数的正负（正数的话可以省略符号）。更多内容，请点击python学习网。
以上是Python核心编程的对浮点型(双精度浮点型)的说明。经过Python实测浮点型默认长度是24字节如果超出这个范围会自动
复数类型
complex，在复数中虚数不能单独存在，它们总是和一个值为0.0的实数部分一起来构成一个复数。复数由实数部分和虚数部分构成。
表示虚数的语法：real+imagj。
实数部分和虚数部分都是浮点型。
虚数部分必须有后缀j或J。
字符串：
字符串(string)是***不可变类型***，就是说改变一个字符串的元素需要新建一个新的字符串。字符串是由独立的字符组成的，并且这些字符可以通过切片操作顺序地访问。里面通过在引号间包含字符的方式创建字符串，单引号和双引号的作用是相同的。
Python用“原始字符串”操作符来创建直接量字符串，所以再做区分就没什么意义了。其他的语言，比如C语言里面用单引号来标示字符，双引号标示字符串，而在Python里面没有字符这个类型。这可能是双引号和单引号在Python里面被视作一样的另一个原因。
Python实际上有三类字符串。通常意义的字符串（str） 和Unicode字符串（unicode） 实际上都是抽象类basestring的子类。这个basestring是不能实例化的。
字符串常见的操作方法：
| 操作方法 | 作用 | 案例 |
|---|---|---|
| index() | 查找字符串中第一次出现的子字符串的位置；可以规定字符串的索引查找范围[star,end)。若无则会报错 | my_str="hello word hello python" ret_01=my_str.index(“lo”,5,17) print(ret_01) |
| find() | 找字符串中指定的子字符串第一次出现的位置（find默认从左侧开始查找，rfind从右侧开始查找），可以规定字符串的索引查找范围。若无则返回 -1 | str.find(sub,start,end) -> int 返回整数 - sub —要索引的子字符串。 - start —索引的起始位置。默认值为0。 - end —索引的结束位置。默认值为字符串长度len(str)。 |
| count() | 查找指定字符在字符串中出现的次数 | my_str="hello word hello python" ret_06=my_str.count(“lo”) print(ret_06) |
| replace() | 替换字符串中指定字符 | replace(“被替换的字符”,“替换成的字符”，替换次数) 替换次数不写默认全部替换 |
| split() | 拆分字符串。 通过指定分隔符sep对字符串进行分割，并保存分割后的字符串列表。 | my_str=“hello word hello python" ret_03=my_str.split(” ") print(ret_03) |
| capitalize() | 将字符串的第一个字母变成大写，其余字母变为小写。 | my_str="hello word hello python" ret_04=my_str.capitalize() print(ret_04) |
| title() | 返回一个满足标题格式的字符串。即所有英文单词首字母大写，其余英文字母小写 | my_str="hello word hello python" ret_05=my_str.title() print(ret_05) |
| startswith() | 判断字符串是否以指定字符或子字符串开头 | str.endswith(“suffix”, start, end) 或str[start,end]. 注意：空字符的情况。返回值通常为True |
| endswith() | 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。 | str.endswith(“suffix”) |
| isalnum() | 检测字符串是否由字母和数字组成。str中至少有一个字符且所有字符都是字母或数字则返回 True,否则返回 False | str.isalnum() -> bool 返回值为布尔类型（True,False） |
| isalpha() | 检测字符串是否只由字母组成。字符串中至少有一个字符且 所有字符都是字母则返回 True,否则返回 False。 |
str.isalpha() -> bool 返回值为布尔类型（True,False） |
| isdigit() | 检测字符串是否只由数字组成.字符串中至少有一个字符且所有字符都是数字则返回 True,否则返回 False | str.isdigit() -> bool 返回值为布尔类型（True,False） 注：能判断“①”，不能判断中文数字。但 isnumeric() 函数可以。 |
| islower() | 检测字符串中的字母是否全由小写字母组成。（字符串中可包含非字母字符）字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是小写，则返回 True，否则返回 False。 | str.islower() -> bool 返回值为布尔类型（True,False） |
| isupper() | 检测字符串中的字母是否全由大写字母组成。（字符串中可包含非字母字符）。字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是大写，则返回 True，否则返回 False。 | str.isupper() -> bool 返回值为布尔类型（True,False） |
| strip() lstrip() rstrip() | 该函数的作用是去除字符串开头和结尾处指定的字符，不会去除字符串中间对应的字符 lstrip() 方法用于截掉字符串左边的空格或指定字符。 删除 str 字符串末尾的指定字符（默认为空格 |
str.strip(chars) 参数：chars – 要去除的字符 默认为空格或换行符 |
| join() | 将iterable变量的每一个元素后增加一个str字符串 | sep.join(iterable) sep——分隔符。可以为空。 iterable（可迭代对象）—— 要连接的变量 ，可以是 字符串，元组，字典，列表等。 |
| upper() | 将字符串中所有小写字母转换成大写字母 | my_str="hello word hello python" ret_06=my_str.upper() print(ret_06) |
| center() | 返回一个长度为width,两边用fillchar(单字符)填充的字符串，即字符串str居中，两边用fillchar填充。若字符串的长度大于width,则直接返回字符串str | width —— 指定字符串的输出长度。 fillchar—— 将要填充的单字符，默认为空格 |
| just() ljust() rjust() | 返回一个原字符串左对齐（默认）,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。ljust()左对齐，rjust()右对齐 | |
| issapce() | 检测字符串是否只由空格组成。若字符串中只包含空格，则返回 True，否则返回 False | str.isspace() -> bool 返回值为布尔类型（True,False） |
| istitle() | 检测判断字符串中所有单词的首字母是否为大写，且其它字母是否为小写，字符串中可以存在其它非字母的字符。若字符串中所有单词的首字母为大写，且其它字母为小写，则返回 True，否则返回 False. | str.istitle() -> bool 返回值为布尔类型（True,False） |
注意：
- find和index都可以查找指定字符字符串的下标，不同点为find查找的字符不存在时输出-1，而index直接报错
列表：
认识列表:
names = [“Alise”, 123, None, [1, 2, 3], {“name”: “张珊”}, 999, 110]
我们将由中括号包裹的代码块称作列表，为了方便对裂变进行操作，我们将列表赋值给了变量names。注意，在特定情况下，变量需要先声明。变量中的每一个数据称作元素，元素可以为任意类型。
列表的常见操作：
| 操作方法 | 作用 | 案例 |
|---|---|---|
| append() | 用于在列表末尾追加新的对象 | a = [1, 2, 3] a.append(4) result: [1, 2, 3, 4] |
| insert() | 方法用于将对象插入到列表中 | a = [1, 2, 3] a.insert(0, ‘aa’) result: [‘aa’, 1, 2,3] |
| extend() | 方法可以在列表的末尾一次性追加另一个序列中的多个值 | a = [1, 2, 3] b = [4, 5, 6] a.extend(b) result: [1, 2, 3, 4, 5, 6] |
| count() | 方法统计某个元素在列表中出现的次数 | a = [‘aa’, ‘bb’, ‘cc’, ‘aa’, ‘aa’] print(a.count(‘aa’)) result: 3 |
| index() | 函数用于从列表中找出某个值第一个匹配项的索引位置 | a = [1, 2, 3, 1] print(a.index(1)) result: 0 |
| in or not in | 返回bool类型的结果 True 或者 False | list = [‘aa’, ‘bb’, ‘cc’, ‘aa’, ‘aa’] print(“a” in list) # True |
| pop() | 方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值 | a = [1, 2, 3] a.pop() result: [1, 2] a.pop(0) result: [2] |
| remove() | 方法用于移除列表中某一个值的第一个匹配项 | a = [‘aa’, ‘bb’, ‘cc’, ‘aa’] a.remove(‘aa’) result: [‘bb’, ‘cc’, ‘aa’] |
| clear() | 清除列表中所有的元素 | list= [“aa”, “bb”, “cc”, “dd”, “ee”, “ff”] list.clear() print(list) # 运行结果:[ ] |
| del() | 删除整个列表 | list= [“aa”, “bb”, “cc”, “dd”, “ee”, “ff”] del list print(list) # 报错 name ‘list’ is not defined |
| reverse() | 方法将列表中的元素反向存放 | a = [‘a’, ‘b’, ‘c’] a.reverse() result: [‘c’, ‘b’, ‘a’] |
| enumerate() | 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中 | li = [11, 22, 33] for k,v in enumerate(li, 1): print(k, v) |
| len() | 返回一个列表的长度 | names = [“Alise”, 123, None, [1, 2, 3], {“name”: “张珊”}, 999, 110] print(len(names)) # 7 |
| sort()和sorted() | 方法用于在原位置对列表进行排序，意外着改变原来的列表，让其中的元素按一定顺序排列 | # 对字母进行排序： nums = [“a”, “b”, “c”, “e”, “z”, “x”] nums.sort(reverse=True) print(nums) # [‘z’, ‘x’, ‘e’, ‘c’, ‘b’, ‘a’] # [‘z’, ‘x’, ‘e’, ‘c’, ‘b’, ‘a’] # 对数字进行排序： nums = [3, 9, 15, 51, 75, 6, 1, 4, 45] nums.sort(reverse=True) print(nums) # [75, 51, 45, 15, 9, 6, 4, 3, 1] |
列表推导式（又称列表解析式）提供了一种简明扼要的方法来创建列表。
它的结构是在一个中括号里包含一个表达式，然后是一个for语句，然后是 0 个或多个 for 或者 if 语句。那个表达式可以是任意的，意思是你可以在列表中放入任意类型的对象。返回结果将是一个新的列表，在这个以 if 和 for 语句为上下文的表达式运行完成之后产生。
列表推导式的执行顺序：各语句之间是嵌套关系，左边第二个语句是最外层，依次往右进一层，左边第一条语句是最后一层
[x*y for x in range(1,5) if x > 2 for y in range(1,4) if y < 3]
# 他的执行顺序是：
for x in range(1,5)
if x > 2
for y in range(1,4)
if y < 3
x*y
注意：
- sort只可对列表进行操作，而sorted可对所有可迭代对象使用，且sort 和 sorted 都有两个参数 ，第一个参数:key=None默认为空,可以是自定义函数,系统函数,或者lambda匿名函数 ，第二个参数是reverse=Fals 默认为False表示不反转，即从小到大的顺序
元祖：
元组的定义由（）定义，相邻元素之间采用，进行分割，在形式上，可以称为不可变的列表
元组是不可变类型，无法对其中的元素进行单独的修改和增加
元祖的常见操作
| 操作方法 | 作用 | 案例 |
|---|---|---|
| del | 元组的删除(由于元祖不可变，所以这里是删除整个元祖) | tu1 = (‘123’, ‘元组’, [1, 2, 3], {‘name’: ‘zhou’, ‘age’: 18}) del tu1 |
| count | 查找的为某个元素在元组中出现的次数 | tu = (11, 22, 33, 44, 55, 44, 33, 22, 11) print(tu.count(22)) # 输出结果 2 |
| index | 查找的为元素的索引值，第一个参数代表需要查找的元素，第二个参数可以指定从哪个索引值开始查找 | tu = (11, 22, 33, 44, 55, 44, 33, 22, 11) print(tu.index(44)) print(tu.index(44, 4)) # 输出结果 3 5 |
| 通过索引取值 | 通过切片的方式获取指定的元素，第一个参数为开始索引，第二个参数为结束索引，第三个参数为步长 | tu = (11, 22, 33, 44, 55, 44, 33, 22, 11) # 通过索引取出索引为3的值 print(tu[3]) print(tu[2:8:2]) # 输出结果 44 |
修改元组元素
虽然我们开始就说到元组无法进行单独的修改，但是我们可以对原组进行重新赋值，拼接等操作达到修改元组
tu = (11, 22, 33, 44, 55, 44, 33, 22, 11)
# 给元组重新赋值
tu = (77, 88, 99)
print(tu)
# 使用元组进行拼接得到新元祖，注意，拼接的类型一定要为元组格式
tu1 = (33, 44, 55)
tu2 = (66, 77, 88)
tu1 = tu1 + tu2
print(tu1)
# 输出结果
(77, 88, 99)
(33, 44, 55, 66, 77, 88)
元组的拆包
在元组有多个元素的时候，我们可以进行元组拆包来分别得到元组的元素
tu = (77, 88, 99)
# 有几个元素就用几个变量接收
a, b, c = tu
print(a)
print(b)
print(c)
# 输出结果
77
88
99
元组推导式
元组推导式和我们的列表推导式是一样的，只需要修将列表的[]改为()就可以了，此处我们不做过多的演示，详细内容请看列表（list）的常用操作
字典：
字典的定义：
字典是一种可变容器模型，且可存储任意类型对象。字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
字典的常见操作：
| 操作方法 | 格式 |
|---|---|
| 查看元素 | print(字典名[key值]) #获取不存在的key会发生异常 print(字典名.get(key值)) #获取到不存在的key不会发生异常 |
| 修改元素 | 字典名[key值] 赋予新的值即可 dict[key] = “runtu” |
| 添加元素 | 字典名[key值] = “qiuqiu” #key值不存在 dict[key] = “qiuqiu” |
| 删除元素 | del 字典[key值] del dict[key] |
| 删除字典 | del 字典名 del dict |
| 清空字典 | 字典名.clear dict.clear |
| 测量键值对的长度或个数 | len(字典名) len(dict) |
| 返回一个字典的所以key的列表 | print(字典名.keys) print(dict.keys) |
| 返回一个包含字典所有value的列表 | print(字典名.values) print(dict.values) |
| 返回一个包含所有（键，值）元组的列表 | print(字典名.items()) print(dict.items()) |
| .has_key查看key值是否在字典内，返回True(存在)，返回False(不存在) | 字典名.has_key(key值) dict.has_key(key) |
字典的特性：
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
-
不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'} print "dict['Name']: ", dict['Name'] # 输出结果： dict['Name']: Manni -
键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：
dict = {['Name']: 'Zara', 'Age': 7} print(dict) #输出结果（报错信息）： dict = {['Name']: 'Zara', 'Age': 7} Traceback (most recent call last): File "" , line 1, in <module> TypeError: unhashable type: 'list'
Python字典包含了以下内置函数：
| 序号 | 函数 | 描述 |
|---|---|---|
| 1 | cmp(dict1, dict2) | 比较两个字典元素。 |
| 2 | len(dict) | 计算字典元素个数，即键的总数。 |
| 3 | str(dict) | 输出字典可打印的字符串表示。 |
| 4 | type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |
Python字典包含了以下内置方法：
| 序号 | 函数 | 描述 |
|---|---|---|
| 1 | dict.clear() | 删除字典内所有元素 |
| 2 | dict.copy() | 返回一个字典的浅复制 |
| 3 | dict.fromkeys(seq[, val]) | 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 |
| 4 | dict.get(key, default=None) | 返回指定键的值，如果值不在字典中返回default值 |
| 5 | dict.has_key(key) | 如果键在字典dict里返回true，否则返回false |
| 6 | dict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
| 7 | dict.keys() | 以列表返回一个字典所有的键 |
| 8 | dict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | dict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
| 10 | dict.values() | 以列表返回字典中的所有值 |
| 11 | pop(key[,default]) | 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 12 | popitem() | 返回并删除字典中的最后一对键和值。 |
集合：
集合的定义：
集合（set）是一个无序的不重复元素序列
可以使用大括号 { } 或者 set( ) 函数创建集合
创建一个空集合必须用 set( ) 而不是 { }，因为 { } 是用来创建一个空字典
集合的常见操作：
| add | 增加元素 | a_set = {1, 2, 3, 4, 5} a_set.add(6) a_set.add(“a”) print(a_set) {1, 2, 3, 4, 5, 6, ‘a’} |
| update | 把要传入的元素拆分，作为个体传入到集合中 | a_set = {1, 2, 3, 4, 5} b_set = {6, 7, 8, 9} a_set.update(b_set) print(a_set) {1, 2, 3, 4, 5, 6, 7, 8, 9} |
| remove | 删除集合中的元素 如果有，直接删除 如果没有 程序报错 | c_set = {1, 2, 3, 4, 5, 6, 7, 8, 9} c_set.remove(8) print(c_set) {1, 2, 3, 4, 5, 6, 7, 9} |
| pop | 随机删除集合中的元素，如果set1没有元素程序报错 | c_set = {1, 2, 3, 4, 5, 6, 7, 8, 9} c_set.pop() print(c_set) #{2, 3, 4, 5, 6, 7, 8, 9} |
| discard | 如果元素存在 直接删除 如 果元素不存在 不做任何操作 | c_set = {1, 2, 3, 4, 5, 6, 7, 8, 9} c_set.discard(5) print(c_set) #{1, 2, 3, 4, 6, 7, 8, 9} |
集合的交集和并集：
| 方法 | 代码 |
|---|---|
| 交集 | set1 = {1, 2, 3, 4} set2 = {3, 4, 5, 6} new_set = set1 & set2 print(new_set) |
| 并集 | set1 = {1, 2, 3, 4} set2 = {3, 4, 5, 6} new_set = set1 | set2 print(new_set) |
Python 集合的优势：
由于集合中的元素不能出现多次，这使得集合在很大程度上能够高效地从列表或元组中删除重复值，并执行取并集、交集等常见的的数学操作
注意：
集合分为可变集合和不可变集合，
不可变集的一个主要的缺点是：由于它们是不可变的，这意味着你不能向其中添加元素或者删除其中的元素