Python基础 - 基本数据类型常见操作（包含字符串常见操作、列表常见操作、元组常见操作、字典常见操作）
1、数字
int（整型） 在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647 在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807 long（长整型） 跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。 注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。 float（浮点型） 浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。 complex（复数） 复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。 注：Python中存在小数字池：-5 ～ 257
2、布尔值
真或假 1 或 0 True 或 False
3、字符串
基本操作：
# 1.字符串长度
a='hello world'
print len(a) # 11
# 2、字符串中字母大小写转换
a = 'HELLO WORLD'
print a.lower() # 转换为小写 hello world
a = 'hello world'
print a.upper() # 转换为大写 HELLO WORLD
a='hello world'
print a.capitalize() # 首字母大写 Hello world
a = 'Hello World'
print a.swapcase() # 大小写互换 hELLO wORLD
# 3.将字符串放入中心位置可指定长度以及位置两边字符
a = 'hello world'
print a.center(20,'-') # ----hello world-----
print len('----hello world-----') # 20
# 4.删除空白
# str.strip()：删除字符串两边的空格
a = ' hello '
b = a.strip()
print b
# str.lstrip():删除字符串左边空格
a = ' hello'
b = a.lstrip()
print b
# str.rstrip():删除字符串右边的空格
a = 'hello '
b = a.rstrip()
print b
# 5.分割:前中后三部分
a = 'hello world'
print a.partition(' ') # ('hello', ' ', 'world')
print a.partition('o') # ('hell', 'o', ' world')
# 6.复制字符串
a = 'hello'
b = a
print a,b # hello hello
# 7.字符串拼接
# A. +：拼接2个字符串
a = 'hello '
b = 'world'
print a + b # hello world
注：此方法又称为 "万恶的加号",因为使用加号连接2个字符串会调用静态函数string_concat(register PyStringObject *a ,register PyObject * b)，
在这个函数中会开辟一块大小是a+b的内存的和的存储单元，然后将a,b字符串拷贝进去。如果是n个字符串相连，那么会开辟n-1次内存，是非常耗费资源的。
# B. str.join:连接2个字符串,可指定连接符号
a = ["hello", "world"]
b = "******".join(a)
print b # hello******world
a = ("hello", "world")
b = "######".join(a)
print b # hello######world
# 8.查找字符串(检测字符串中是否包含子字符串str，可指定范围)
# str.index 和str.find 功能相同，区别在于find()查找失败会返回-1，不会影响程序运行。一般用find!=-1或者find>-1来作为判断条件。
a = 'hello world'
print a.index('w') # 6
print a.index('x') # ValueError: substring not found
a = 'hello world'
print a.find('w') # 6
print a.find('x') # -1
# 9.是否包含指定字符串(in |not in)
a = 'hello world'
if 'hello' in a:
print 'in'
if 'qwe' not in a:
print 'not in'
# 10. 字符串统计
a = 'hello world'
print a.count('l') # 3
# 11.字符串的测试、判断函数 结果是布尔型
# startswith() 以...开头
print 'Hello World'.startswith('H') # True
print 'hello world'.startswith('A') # False
# endswith() 以...结尾
print 'Hello World'.endswith('d') # True
print 'hello world'.endswith('D') # False
# islower() 字符串中的字母是否全是小写
print 'Hello World'.islower() # False
print 'hello world'.islower() # True
# isupper() 字符串中字母是否全是大写
print 'Hello World'.isupper() # False
print 'hello world'.isupper() # False
# istitle()是否是首字母大写的(会对每个进行判断)
print 'Hello World'.istitle() # True
print 'Hello world'.istitle() # False
# 12.字符串切片(顾头不顾尾)
使用一对方括号、起始偏移量start、终止偏移量end 以及可选的步长step 来定义一个分片。
格式： [start:end:step]
[:] 提取从开头（默认位置0）到结尾（默认位置-1）的整个字符串
[start:] 从start 提取到结尾
[:end] 从开头提取到end - 1
a = '0123456789'
print a[0:3] #截取第一位到第三位的字符（0可省，等价于 print a[:3]）
print a[:] #截取字符串的全部字符
print a[6:] #截取第七个字符到结尾
print a[:-3] #截取从头开始到倒数第三个字符之前
print a[2] #截取第三个字符
print a[-1] #截取倒数第一个字符
print a[::-1] #字符串倒序
print a[-3:-1] #截取倒数第三位与倒数第一位之前的字符
print a[-3:] #截取倒数第三位到结尾
print a[:-5:-3] #逆序截取，截取倒数第五位数与倒数第三位数之间
# 13.切割
a = 'hello world'
print a.split(' ') # ['hello', 'world']
print a.split('o') # ['hell', ' w', 'rld']
# 14.替换
a = 'hello world'
print a.replace(' ', 'my') # hellomyworld
print a.replace('hello', 'my') # my
# 15.根据换行执行分割
a = 'hello\nworld'
print a.splitlines() # ['hello', 'world']
# 16.索引：str[下标]
a = 'hello world'
print a[0] # 从0开始
列表和元组的主要不同在于：列表是可以修改的，而元组不可以。
Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。两种主要的容器是序列（如列表和元组）和映射（如字典）。在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。
4、列表
基本操作：
# 1.索引(第一个索引是0，第二个是1，以此类推)，可以使用索引来获取元素，这种索引方式适用于所有序列。
当你使用负数索引时，Python将从右（即最后一个元素）开始往左数，因此-1是最后一个元素的位置。
可以直接对其执行索引操作，无需先将其赋给变量。
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list[0] # a
print my_list[3] # d
# 2.切片
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list[1:] # 除了第一个元素之外的其他元素 ['b', 'c', 'd', 'e']
print my_list[:-1] # 除了最后一个元素之外的其他元素 ['a', 'b', 'c', 'd']
# 列表的翻转
# 方式一：
print my_list[::-1] # ['e', 'd', 'c', 'b', 'a']
# 方式二：
my_list.reverse()
print my_list # ['e', 'd', 'c', 'b', 'a']
# 3.重复
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list * 2 # ['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e']
# 4.连接
my_list1 = ['a', 'b', 'c', 'd', 'e']
my_list2 = ['a', 'b', 'c', 'd', 'e']
print my_list1 + my_list2 # ['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e']
# 5.是否包含(in |not in)
my_list = ['a', 'b', 'c', 'd', 'e']
print 'a' in my_list # True
print 'a' not in my_list # False
# 6.遍历
my_list = ['a', 'b', 'c', 'd', 'e']
for i in my_list:
print i
# a
# b
# c
# d
# e
# 7.列表的增删改查操作
# 增加
my_list = ['a', 'b', 'c', 'd', 'e']
my_list.append('f') # append:追加 追加一个元素到列表中(末尾位置添加)
print my_list # ['a', 'b', 'c', 'd', 'e', 'f']
my_list = ['a', 'b', 'c', 'd', 'e']
my_list.extend(['f', 'g']) # extend:拉伸 追加多个元素到列表中(末尾位置添加)
print my_list # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
my_list = ['a', 'b', 'c', 'd', 'e']
my_list.insert(1, 'bb') # insert:在指定索引位置插入元素
print my_list # ['a', 'bb', 'b', 'c', 'd', 'e']
# 删除(可以用del语句、pop()方法、remove()方法进行删除。)
my_list = ['a', 'b', 'c', 'd', 'e']
del my_list[1] # del可以删除任意已知位置的列表元素,从内存中删除列表.
print my_list # ['a', 'c', 'd', 'e']
# pop()可以传递索引值，也可在括号里指定索引，来删除指定位置的列表元素,如果不指定索引，默认删除最后一个元素。
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list.pop() # e
print my_list # ['a', 'b', 'c', 'd']
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list.pop(1) # b
print my_list # ['a', 'c', 'd', 'e']
my_list = ['a', 'b', 'c', 'd', 'e']
my_list.remove('a') # remove()不需要知道元素位置，根据元素的值即可删除元素。
print my_list # ['b', 'c', 'd', 'e']
# 修改
my_list = ['a', 'b', 'c', 'd', 'e']
my_list[0] = 'aaa' # 通过索引，重新赋值
print my_list # ['aaa', 'b', 'c', 'd', 'e']
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list[:2] # ['a', 'b']
my_list[:2] = ['aaa','bbb'] # 通过切片
print my_list # ['aaa', 'bbb', 'c', 'd', 'e']
# 查看
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list.count('a') # 1 查看列表中元素出现的次数
print my_list.index('a') # 0 查看指定元素的索引值
print my_list[0] # a 查看指定索引的元素值
# 8.长度
my_list = ['a', 'b', 'c', 'd', 'e']
print len(my_list) # 5
# 9.排序
my_list = ['d', 'c', 'b', 'a', 'e']
my_list.reverse() # reverse列表反转排序：是把原列表中的元素顺序从左至右的重新存放，而不会对列表中的参数进行排序整理。
print my_list # ['e', 'a', 'b', 'c', 'd']
# sort排序方法是直接修改原列表list排序方法。
my_list = ['d', 'c', 'b', 'a', 'e']
my_list.sort() # 正序排序
print my_list # ['a', 'b', 'c', 'd', 'e']
my_list = ['d', 'c', 'b', 'a', 'e']
my_list.sort(reverse=True) # 倒序排序
print my_list # ['e', 'd', 'c', 'b', 'a']
# sorted()方法即可以保留原列表，又能得到已经排序好的列表。
my_list = ['d', 'c', 'b', 'a', 'e']
print sorted(my_list) # ['a', 'b', 'c', 'd', 'e']
print my_list # ['d', 'c', 'b', 'a', 'e']
5、元组
基本操作：
# 1.特性
# 元组如果只有一个元素的时候，后面一定要加逗号，否则数据类型不确定
my_tuple1 = ('a')
my_tuple2 = ('a',)
print type(my_tuple1), type(my_tuple2)
# <type 'str'> <type 'tuple'>
# 2.拼接元组
my_tuple1 = ('a', 'b', 'c', 'd', 'e')
my_tuple2 = ('a', 'b', 'c', 'd', 'e')
print my_tuple1 + my_tuple1 # ('a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e')
# 3.重复
my_tuple = ('a', 'b', 'c', 'd', 'e')
print my_tuple * 2 # ('a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e')
# 4.len 求元组的元素个数
my_tuple = ('a', 'b', 'c', 'd', 'e')
print(len(my_tuple)) # 5
# 5.in| not 判断是否包含元素
# 6.元组的增删改查操作(元组本身不能增删改查，但是如果元组里面包含可变数据类型，可以间接修改元组的内容)
my_tuple = ('a', ['b', 'c'], 'd', 'e')
# my_tuple[0] = 'aa' 如此执行会报错
my_tuple[1][0] = 'bb'
print my_tuple # ('a', ['bb', 'c'], 'd', 'e')
my_tuple = ('a', ['b', 'c'], 'd', 'e')
my_tuple[1].append('cc')
print my_tuple # ('a', ['b', 'c', 'cc'], 'd', 'e')
my_tuple = ('a', ['b', 'c'], 'd', 'e')
my_tuple[1].remove('c')
print my_tuple # ('a', ['b'], 'd', 'e')
# 7.计算，max，min，sum
my_tuple = ('a', 'b', 'c', 'd', 'e')
print(max(my_tuple)) # e
print(min(my_tuple)) # a
# sum 注意如果元组里面不是全是数值是无法求和的
# 8.排序和反转，不支持：sort()，reverse()，支持：sorted()
my_tuple = ('d', 'c', 'b', 'a', 'e')
print sorted(my_tuple) # ['a', 'b', 'c', 'd', 'e']
print my_tuple # ('d', 'c', 'b', 'a', 'e')
# 注：不改变元组中元素的位置，只是临时排序，是可以的
# 9.查找，index
my_tuple = ('a', 'b', 'c', 'd', 'e')
print(my_tuple.index('a')) # 0
# 10.统计出现的次数 count
my_tuple = ('a', 'b', 'c', 'd', 'e')
print(my_tuple.count('a')) # 1
6、字典（无序）
基本操作：
注：
# 字典中的 key 不允许重复
# 在使用 {} 创建字典时，{} 应包含多个 key-value 对，key 与 value 之间用英文冒号隔开；多个 key-value 对之间用英文逗号隔开。
字典的基本用法
# 应牢记字典包含多个 key-value 对，而 key 是字典的关键数据，因此程序对字典的操作都是基于 key 的。基本操作如下：
# 1.通过 key 访问 value 。
my_dict = {'a': 1, 'b': 2, 'c': 3}
print my_dict['a'] # 1
# 注 没有添加，有修改
# 2.通过 key 添加 key-value 对。
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['d'] = 4
print my_dict # {'a': 1, 'c': 3, 'b': 2, 'd': 4}
# 3.通过 key 修改 key-value 对。
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['a'] = 11
print my_dict # {'a': 11, 'c': 3, 'b': 2}
# 4.通过 key 删除 key-value 对。
my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['a']
print my_dict # {'c': 3, 'b': 2}
# 5.通过 key 判断指定 key-value 对是否存在(in | not in)。
my_dict = {'a': 1, 'b': 2, 'c': 3}
print 'd' in my_dict # False
print 'd' not in my_dict # True
字典的常用方法
# 1.字典由 dict 类代表，因此我们可使用 dir(dict) 来查看该类包含哪些方法。
# 2.clear()方法: clear() 用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。
my_dict = {'a': 1, 'b': 2, 'c': 3}
# # 清空 my_dict 所有 key-value 对
my_dict.clear()
print my_dict # {}
# 3.get()方法: get() 方法其实就是根据 key 来获取 value，它相当于方括号语法的增强版，当使用方括号语法访问并不存在的 key 时，字典会引发 KeyError 错误；
# 但如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，不会导致错误。
my_dict = {'a': 1, 'b': 2, 'c': 3}
# # 获取'a'对应的 value
print my_dict.get('a') # 1
print my_dict.get('d') # None
# print my_dict['d'] # KeyError
# 4.update()方法: update() 方法可使用一个字典所包含的 key-value对 来更新己有的字典。
# 在执行 update() 方法时，如果被更新的字典中己包含对应的 key-value 对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去。
my_dict1 = {'a': 1, 'b': 2, 'c': 3}
my_dict2 = {'d': 4, 'e': 5, 'f': 6}
my_dict1.update(my_dict2)
print my_dict1 # {'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4, 'f': 6}
my_dict1 = {'a': 1, 'b': 2, 'c': 3}
my_dict2 = {'a': 4, 'b': 5, 'f': 6}
my_dict1.update(my_dict2)
print my_dict1 # {'a': 4, 'c': 3, 'b': 5, 'f': 6}
# 从上面的执行过程可以看出，由于被更新的 dict 中己包含 key 为'a'与'b'的 key-value 对，因此更新时该 key-value 对的 value 将被改写；
# 但如果被更新的 dict 中不包含 key 为'f'的 key-value 对，那么更新时就会为原字典增加一个 key-value 对。
# 5.items()、keys()、values() : 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。如下代码示范了这三个方法的用法：
my_dict = {'a': 1, 'b': 2, 'c': 3}
# 获取字典所有的key-value对
ims = my_dict.items()
print ims # [('a', 1), ('c', 3), ('b', 2)]
print type(ims) # <type 'list'>
# 获取字典所有的key
my_dict = {'a': 1, 'b': 2, 'c': 3}
kys = my_dict.keys()
print kys # ['a', 'c', 'b']
print type(kys) # <type 'list'>
# 获取字典所有的value
my_dict = {'a': 1, 'b': 2, 'c': 3}
val = my_dict.values()
print val # [1, 3, 2]
print type(val) # <type 'list'>
# 在 Python 2.x 中，items()、keys()、values() 方法的返回值本来就是列表，完全可以不用 list() 函数进行处理。当然，使用 list() 函数处理也行，列表被处理之后依然是列表。
# 6.pop方法: pop() 方法用于获取指定 key 对应的 value，并删除这个 key-value 对。如下方法示范了 pop() 方法的用法：
my_dict = {'a': 1, 'b': 2, 'c': 3}
print my_dict.pop('a') # 1 会获取 'a' 对应的 value，并删除该 key-value 对。
print my_dict # {'c': 3, 'b': 2}
# 7.popitem()方法: popitem() 方法用于随机弹出字典中的一个 key-value 对。
# 此处的随机其实是假的，正如列表的 pop() 方法总是弹出列表中最后一个元素，实际上字典的 popitem() 其实也是弹出字典中最后一个 key-value 对。
# 由于字典存储 key-value 对的顺序是不可知的，因此开发者感觉字典的 popitem() 方法是“随机”弹出的，但实际上字典的 popitem() 方法总是弹出底层存储的最后一个 key-value 对。
my_dict = {'a': 1, 'b': 2, 'c': 3}
print my_dict.popitem() # ('a', 1)
print my_dict # {'c': 3, 'b': 2}
# 8.setdefault()方法也用于根据 key 来获取对应 value 的值。但该方法有一个额外的功能，即当程序要获取的 key 在字典中不存在时，该方法会先为这个不存在的 key 设置一个默认的 value，然后再返回该 key 对应的 value。
# 总之，setdefault() 方法总能返回指定 key 对应的 value；如果该 key-value 对存在，则直接返回该 key 对应的 value；如果该 key-value 对不存在，则先为该 key 设置默认的 value，然后再返回该 key 对应的 value。
my_dict = {'a': 1, 'b': 2, 'c': 3}
# 设置默认值，该key在dict中不存在，新增key-value对
print my_dict.setdefault('d', 4) # 4
print my_dict # {'a': 1, 'c': 3, 'b': 2, 'd': 4}
# # 设置默认值，该key在dict中存在，不会修改dict内容
my_dict = {'a': 1, 'b': 2, 'c': 3}
print my_dict.setdefault('c', 4) # 3
print my_dict # {'a': 1, 'c': 3, 'b': 2}
# 9.fromkeys()方法使用给定的多个 key 创建字典，这些 key 对应的 value 默认都是 None；也可以额外传入一个参数作为默认的 value。该方法一般不会使用字典对象调用（没什么意义），通常会使用 dict 类直接调用。
# 使用列表创建包含2个key的字典
a_dict = dict.fromkeys(['a', 'b'])
print(a_dict) # {'a': None, 'b': None}
# 使用元组创建包含2个key的字典
b_dict = dict.fromkeys((13, 17))
print(b_dict) # {13: None, 17: None}
# 使用元组创建包含2个key的字典，指定默认的value
c_dict = dict.fromkeys((13, 17), 'good')
print(c_dict) # {13: 'good', 17: 'good'}
