Python基础之数据类型
一 整形（int）
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，2，-1，0，等等
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
二 浮点型（float）
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x105和12.3x104是完全相等的
浮点数可以用数学写法，如1.23，-1.23，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差
复数、实数、有理数可参考：http://www.cnblogs.com/alex3714/articles/5895848.html
三 布尔值
布尔值和布尔代数的表示完全一致，一个布尔值只有真、假两种值，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：
>>> True True >>> False False >>> 1<2 True >>> 1>2 False
布尔值还可通过and、or和not运算，这部分后面会详解
四 字符串
字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"abc"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。
如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识，比如：
'I\'m \"OK\"!' # 表示内容I'm "OK"!
转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串看看：
>>> print('I\'m Joe')
I'm joe
>>> print('\\\n\t\\')
\
\
如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义，在后面使用路径时用处很大。举例如下：
>>> print(r'I\'m joe') I\'m joe >>> print(r'\\\n\t\\') \\\n\t\\
另外，python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。
4.1 字符串的格式化
方式一：%
举例如下：
name = 'Joe'
age = 18
print('%s,%s' %(name,age)) # Joe,18
print('%d' %age) # 18
在字符串内部，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
常用占位符有：
注：其实%s可以代指多种数据类型，万能的
另外，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：
age = 18
height = 180.0
print('%.2f' %height) # 180.00
print('%5d' %age) # 18
方式二：format
print('My Name is {},{},{} years old.'.format('Joe','male',18))
print('My Name is {2},{1},{0} years old.'.format(18,'male','Joe'))
print('My Name is {x},{y},{z} years old.'.format(x='Joe',y='male',z=18))
4.2 字符串基本操作
msg = ' Hello World! ' msg1 = 'Hello World!' msg2 = 'hello world' # strip():移除空白，也可以去除其他的字符，还有rstrip(),lstrip() *** print(msg.strip()) # Hello World! # split():分割，默认以空格分割。也可以指定以其他的字符分割 *** print(msg.split()) # ['Hello', 'World!'] # len():获取长度 *** print(len(msg)) # 15 # index():获取索引，如果是不存在，报错 *** print(msg.index('H')) # 2 # 切片 *** print(msg1[0:3]) # Hel print(msg1[:3]) # Hel print(msg1[6:-1]) # World print(msg1[-6:]) # World! print(msg1[:-1:2]) # HloWrd 指定步长,走两步，切一次 # capitalize():首字母大写 print(msg2.capitalize()) # Hello world! # startswith()&endswith():判断以什么结尾、结尾 print(msg2.startswith('h')) # True print(msg2.endswith('h')) # False # count():计数，统计某个字符的个数，空格也算一个字符 print(msg2.count('l')) # 3 # center():居中显示 print(msg1.center(30, '*')) # *********Hello World!********* # ljust()：左对齐 print(msg1.ljust(30, '*')) # Hello World!****************** # rjust()：右对齐 print(msg1.rjust(30, '*')) # ******************Hello World! # find():获取索引，如果是负数，代表查找失败，这是与index的区别 print(msg.find('H')) # 2 # isdigit()：判断是否是数字 print('11'.isdigit()) # True # islower()：判断是否是全部小写 print(msg2.islower()) # True # isupper():判断是否是全部大写 print(msg2.isupper()) # False # lower():全部转换为小写 *** print('ABC'.lower()) # abc # upper()：全部转换为大写 *** print('abc'.upper()) # ABC # isspace()：判断是否是全都是空格 print(' '.isspace()) # True # istitle()：判断是否是标题（首字母大写） print(msg1.istitle()) # True # swapcase()：大小写字母翻转 print(msg1.swapcase()) # hELLO wORLD! # join()：连接 *** print(''.join(['a','b','c'])) # abc # repalce()：替换，可指定替换次数 *** print('HelloHelloHello'.replace('H','h',2)) # hellohelloHello
五 列表（list）
列表是我们最常用的数据类型之一，是一种有序的集合，通过列表可以对数据实现最方便的存储、修改等操作
5.1 创建列表
list1 = ['Joe', 18, 'male'] print(list1,type(list1)) # ['Joe', 18, 'male'] <class 'list'> list2 = list(['Joe', 18, 'male']) print(list2,type(list2)) # ['Joe', 18, 'male'] <class 'list'>
5.2 列表基本操作
l = ['a','b','c','d','e','f'] # index()：获取元素索引（有多个，只返回第一个），可以指定开始、结束位置 *** print(l.index('d')) # 3 # []：切片 *** # 取下标0~4之间的元素，包括0不包括4 print(l[0:4]) # ['a','b', 'c', 'd'] # 如果从头开始取，0可以忽略 print(l[:4]) # ['a', 'b', 'c', 'd'] # 取下标1~-1之间的元素，包括1不包括-1 print(l[1:-1]) # ['b', 'c', 'd', 'e'] # 如果先取到最后一个元素，后面不写 print(l[1:]) # ['b', 'c', 'd', 'e', 'f'] # 按步长2在指定范围取元素 print(l[::2]) # ['a', 'c', 'e'] # 取单个元素 print(l[1]) # b # append()：追加 *** l.append('g') print(l) # ['a', 'b', 'c', 'd', 'e', 'f', 'g'] # pop()：删除，不是单纯的删除，是删除并且把删除的元素返回，可以用一个变量名去接收返回值 *** pop_item = l.pop(6) print(pop_item) # g print(l) # ['a', 'b', 'c', 'd', 'e', 'f' # remove()：删除，单纯的删除，指定元素去删除 *** l.remove('a') print(l) # ['b', 'c', 'd', 'e', 'f'] # del：删除，单纯的删除，指定索引去删除 *** del l[4] print(l) # ['b', 'c', 'd', 'e'] # copy()：拷贝 new_list = l.copy() print(new_list) # ['b', 'c', 'd', 'e'] # 注意：关于拷贝后面会详细介绍 # len()：长度 *** print(len(l)) # 4 # in：包含 *** print('a' in l) # False print('b' in l) # True # 修改 *** l[1] = 'ccc' print(l) # ['b', 'ccc', 'd', 'e'] # insert():插入 ** l.insert(0,'a') print(l) # ['a', 'b', 'ccc', 'd', 'e'] # extend()：扩展 ** new_l = ['f','g','h'] l.extend(new_l) print(l) # ['a', 'b', 'ccc', 'd', 'e', 'f', 'g', 'h'] # count()：统计 print(l.count('a')) # 1 l.append('a') print(l.count('a')) # 2 # sort()：排序&reverse()：反转 l.sort() print(l) # ['a', 'a', 'b', 'ccc', 'd', 'e', 'f', 'g', 'h'] # # 注意：py3里不同数据类型不能放在一起排序 l.reverse() print(l) # ['h', 'g', 'f', 'e', 'd', 'ccc', 'b', 'a', 'a'] # clear()：清除 l.clear() print(l) # []
# 队列：先进先出
l1 = []
# 入队
l1.append('first')
l1.append('second')
l1.append('third')
print(l1) # ['first', 'second', 'third']
# 出队
print(l1.pop(0)) # first
print(l1.pop(0)) # second
print(l1.pop(0)) # third
# 堆栈：先进后出
l2 = []
# 入栈
l2.append('first')
l2.append('second')
l2.append('third')
print(l2) # ['first', 'second', 'third']
# 出栈
print(l2.pop()) # third
print(l2.pop()) # second
print(l2.pop()) # first
六 元组（tuple）
元组其实跟列表差不多，也是存一组数据，只不过它一旦创建，便不能再修改，所以又叫只读列表
6.1 创建元组
tuple1 = ('Joe', 18, 'male')
print(tuple1,type(tuple1)) # ('Joe', 18, 'male') <class 'tuple'>
tuple2 = tuple(('Joe', 18, 'male'))
print(tuple2,type(tuple2)) # ('Joe', 18, 'male') <class 'tuple'>
6.2 元组基本操作
t = ('a','b','c','d','e','f','g')
# []：切片
# 与列表类似
# in
print('a' in t) # True
# index()：索引
print(t.index('a')) # 0
# count()：统计
print(t.count('a')) # 1
# 补充：元组本身是不可变的，但是内部的元素可以是可变类型
t = (1,'xxx',['a','b'])
print(t) # (1, 'xxx', ['a', 'b'])
t[2][0] = 'aaa'
print(t) # (1, 'xxx', ['aaa', 'b'])
七 字典（dict）
字典是一种key - value 的数据类型，在其他语言中也称为map，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。字典的特性：
- dict是无序的
- key必须是唯一的，所以天生去重
7.1 创建字典
dict1 = {"name": "Joe", "age": 18, "gender":'male'}
print(dict1,type(dict1)) # {'name': 'Joe', 'gender': 'male', 'age': 18} <class 'dict'>
dict2 = dict({"name": "Joe", "age": 18, "gender":'male'})
print(dict2,type(dict2)) # {'name': 'Joe', 'age': 18, 'gender': 'male'} <class 'dict'>
dict3 = dict(name="Joe", age=18, gender='male')
print(dict3,type(dict3)) # {'name': 'Joe', 'age': 18, 'gender': 'male'} <class 'dict'>
dict4 = dict([('name',"Joe"),("age",18),("gender",'male')])
print(dict4,type(dict4)) # {'name': 'Joe', 'age': 18, 'gender': 'male'} <class 'dict'>
7.2 字典基本操作
dict1 = {"name": "Joe", 'age': 18, "gender":'male'}
# 增加
dict1["gender"] = 'male'
print(dict1) # {'age': 18, 'name': 'Joe', 'gender': 'male'}
# pop()&del&popitem()：删除
pop_item = dict1.pop('gender','默认值') # key存在则返回，不存在则返回默认值（可省略），如果没有默认值则报错
print(pop_item) # male
print(dict1) # {'age': 18, 'name': 'Joe'}
dict1["gender"] = 'male'
del dict1['gender'] # 没有返回值
print(dict1) # {'age': 18, 'name': 'Joe'}
dict1["gender"] = 'male'
pop_item = dict1.popitem() # 随机删除一组键值对
print(pop_item) # ('age', 18)
print(dict1) # {'gender': 'male', 'name': 'Joe'
# 修改
dict2 = {"name": "Joe", 'age': 18, "gender":'male'}
dict2['name'] = 'Joe1991'
print(dict2) # {'age': 18, 'name': 'Joe1991', 'gender': 'male'}
# 查询
dict3 = {"name": "Joe", 'age': 18, "gender":'male'}
# 利用in判断某个key是否存在于某个字典
print('name' in dict3) # True
# 利用key直接查询
print(dict3['name']) # Joe
# print(dict3['namee']) # 不存在则报错
# 利用get()查询
print(dict3.get('name')) # Joe
print(dict3.get('namee')) # None 不存在不报错
print(dict3.get('namee','不存在')) # 指定不存在时返回值
# 获取key,value,key-value
print(dict3.keys()) # dict_keys(['name', 'age', 'gender'])
print(dict3.values()) # dict_values(['Joe', 18, 'male'])
print(dict3.items()) # dict_items([('name', 'Joe'), ('age', 18), ('gender', 'male')])
# 其他
dict4 = {"name": "Joe", 'age': 18}
# len()：长度
print(len(dict4)) # 2
# update()：更新
update_dict = {'name':'Joe1991',"gender":'male'}
dict4.update(update_dict)
print(dict4) # {'age': 18, 'name': 'Joe1991', 'gender': 'male'}
# setdefault()：D.get(k,d), also set D[k]=d if k not in D
dict4.setdefault('hobbies',['read','running'])
print(dict4) # {'age': 18, 'name': 'Joe1991', 'hobbies': ['read', 'running'], 'gender': 'male'}
print(dict4.setdefault('hobbies')) # ['read', 'running']
# clear()：清除
dict4.clear()
print(dict4) # {}
dict1 = {"name": "Joe", 'age': 18, "gender":'male'}
# 默认循环key
for k in dict1:
print(k)
# 如果需要循环value
for v in dict1.values():
print(v)
# 如果需要循环key-value
for k,v in dict1.items():
print(k,v)
补充说明：作为key的对象为不能变类型
这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。
要保证hash的正确性，作为key的对象就不能变。
八 集合
作用：
- 去重，把一个列表变成集合，就自动去重了
- 关系运算（测试两组数据之前的交集、差集、并集等关系）
定义：可以包含多个元素，用逗号分割，集合的元素遵循三个原则：
- 每个元素必须是不可变类型（可hash，可作为字典的key）
- 没有重复的元素，天然去重
- 无序
注意：集合的目的是将不同的值存放在一起，不同的集合间用来做关系运算，无需纠结集合中的单个值
8.1 创建集合
s = set([1, 2, 11, 'a', 'b', 'c'])
print(s) # {1, 2, 'a', 11, 'b', 'c'}
s = set([1, 1, 2, 2, 3, 3])
print(s) # {1, 2, 3}
8.2 关系测试
s1 = {'Python', 'C', 'HTML', 'JavaScript', 'java'}
s2 = {'Python', 'Go', 'CSS', 'C++', 'java'}
# 交集：两个都有，A.intersection(B)或A & B
print(s1.intersection(s2)) # {'java', 'Python'}
print(s1&s2) # {'java', 'Python'}
# 差集：A有，B没有，A.difference(B)或A - B)
print(s1.difference(s2)) # {'HTML', 'C', 'JavaScript'}
print(s1-s2) # {'HTML', 'C', 'JavaScript'}
# 并集：两个里的元素合并并去重。A.union(B)或(A | B)
print(s1.union(s2)) # {'C++', 'HTML', 'CSS', 'Go', 'java', 'C', 'JavaScript', 'Python'}
print(s1|s2) # {'C++', 'HTML', 'CSS', 'Go', 'java', 'C', 'JavaScript', 'Python'}
# 对称差集：相互之间不存在的。A.symmetric_difference(B)或(A ^ B)
print(s1.symmetric_difference(s2)) # {'HTML', 'C++', 'JavaScript', 'CSS', 'Go', 'C'}
print(s1^s2) # {'HTML', 'C++', 'JavaScript', 'CSS', 'Go', 'C'}
# 父级&子集&相等
s3 = {1, 2, 3, 4, 5}
s4 = {1, 2, 3, 4}
print(s3 >= s3) # True
print(s3.issuperset(s4)) # True
print(s3 == s4) # False
print(s3 <= s4) # False
print(s3.issubset(s4)) # False
8.3 其他方法
s1 = {'Python', 'C', 'HTML', 'JavaScript', 'java'}
s2 = {'Python', 'Go', 'CSS', 'C++', 'java'}
# A.add()： 对A集合进行元素增加 ***
s2.add('JavaScript')
print(s2) # {'CSS', 'Python', 'JavaScript', 'java', 'C++', 'Go'}
# A.discard("a")： 删除一个元素，元素不存在不报错，单纯的删除，没有返回值 ***
s2.discard('JavaScript')
print(s2) # {'CSS', 'Python', 'java', 'C++', 'Go'}
# A.remove("a")： 指定元素删除，元素不存在则报错，单纯的删除，没有返回值 ***
s2.remove('CSS')
print(s2) # {'Python', 'java', 'C++', 'Go'}
# A.pop()： 随机删除一个元素，有返回值 ***
res = s2.pop()
print(res) # Python
print(s2) # {'java', 'C++', 'Go'}
# A.difference_update(B)： 将A与B的差集重新赋值给A
s1.difference_update(s2)
print(s1) # {'Python', 'JavaScript', 'C', 'HTML'}
# A.update(B)： 更新，相当于把B加到A中，与并集类似，只是赋值了
s1.update(s2)
print(s1) # {'Python', 'JavaScript', 'java', 'HTML', 'C', 'C++', 'Go'}
# A.isdisjoint(B)： 如果A与B无交集，则返回真
print(s1.isdisjoint(s2)) # False
# A.copy()： 拷贝（浅拷贝）
print(s1.copy()) # {'JavaScript', 'Go', 'java', 'Python', 'HTML', 'C'}
# A.clear()： 清除
s1.clear()
print(s1) # set()
注意：存储对象为不能变类型
九 总结
9.1 按存储空间的占用区分（从低到高）
数字（整形、浮点型等）
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息
列表：有序，需要存索引相关信息，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，需要处理数据的增删改
9.2 按存值个数区分
9.3 按可变不可变区分
可变数据类型：在id不变的情况下，value可改变
不可变数据类型：value改变，id也跟着改变。
补充：可变类型是不可hash类型，不可变类型是可hash类型
9.4 按访问顺序区分
浙公网安备 33010602011771号