数据类型：
计算可以处理各种不同文件，图形，音频，视频，网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：
一：nubmer（数字）
1.1数据类型的创建：
1 a=90 2 b=a 3 b=9000 4 print(a) 5 print(b)
1.2number 数据类型的转换：
1 var1=3.14 2 var2=5 3 var3=int(var1) 4 var4=float(var2) 5 print(var3,var4)
Python内置函数：
1 x=10 2 abs(x) #x的绝对值， 例如-10,结果就是10 3 ceil(x) #返回数字的上入整数，如math.ceil(4.1) 返回 5 4 cmp(x, y) #如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 5 exp(x) # 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 6 fabs(x) # 返回数字的绝对值，如math.fabs(-10) 返回10.0 7 floor(x) # 返回数字的下舍整数，如math.floor(4.9)返回 4 8 log(x) # 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 9 log10(x) # 返回以10为基数的x的对数，如math.log10(100)返回.0 10 max(x1, x2,...) #返回给定参数的最大值，参数可以为序列。 11 min(x1, x2,...) #返回给定参数的最小值，参数可以为序列。 12 modf(x) #返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 13 pow(x, y) # x**y 运算后的值。 14 round(x [n]) #返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 15 sqrt(x) # 返回数字x的平方根，数字可以为数，返回类型为实数，如math.sqrt(4)返回 2+0j
二：字符串类型：string
字符串的格式：是以英文状态下的："abcd",或者‘123 ‘以单引号，或者以双引号格式书写的；
2.1创建字符串：
1 print("helloworld") 2 print(‘nihao‘)
2.2对应的操作：
2 # 1 * 重复输出字符串 3 print(‘hello123‘*2) 5 # 2 [] ,[:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表 6 print(‘helloworld123456‘[2:])
8 # 3 in 成员运算符 - 如果字符串中包含给定的字符返回 True 9 print(‘el‘ in ‘helloworld123‘)
11 # 4 % 格式字符串 12 print(‘%s is a good teacher‘%‘wing‘) 15 # 5 + 字符串拼接 16 a=‘123‘ 17 b=‘abc‘ 18 c=‘789‘ 19 d1=a+b+c 20 print(d1) 21 # +效率低,该用join 22 d2=‘‘.join([a,b,c]) 23 print(d2)
2.3string的内置函数：
1 # string.capitalize() 把字符串的第一个字符大写 2 # string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 3 # string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 4 # string.decode(encoding=‘UTF-8‘, errors=‘strict‘) 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 5 # string.encode(encoding=‘UTF-8‘, errors=‘strict‘) 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是‘ignor 6 # string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 Fals 7 # string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 8 # string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 9 # string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常. 10 # string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False 11 # string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
三：字节类型：
四：布尔值：
4.1：True和False，在Python中，布尔值，要区分大小写：
1 2 print(True) 3 print(4>2) 4 print(True+1) 5 print(bool([3,4]))
4.2或与非的操作：
1 bool(1 and 0) 2 bool(1 and 1) 3 bool(1 or 0) 4 bool(not 0)
4.3布尔值的常用场景：
1 # 2 # age=18 3 # if age>18: 4 # print(‘成功‘) 5 # else: 6 # print(‘haha‘)
五：list列表
list是Python中数据最长用的数据类型，列表是可变的：
5.1查：[]
1 names_class2=[‘小米‘,‘华为‘,‘联想‘,‘三星‘] 2 3 print(names_class2[2]) 4 print(names_class2[0:3]) 5 print(names_class2[0:7]) 6 print(names_class2[-1]) 7 print(names_class2[2:3]) 8 print(names_class2[0:3:1]) 9 print(names_class2[3:0:-1])
5.2增
append可以在列表的最后追加内容，insert是在列表里面插入内容；
1 names_class2.append(‘月月‘) 2 names_class2.insert(2,‘mimi‘) 3 print(names_class2)
5.3改（重新赋值）
1 names_class2[3]=(‘haha‘) 2 names_class2[0:2] =(‘hhh‘,‘www‘) 3 print(names_class2)
5.4删除：del remove pop
1 2 names_class2.remove(‘haha‘) 3 del names_class2[0] 4 names_class2.pop() 5 del names_class2 6
5.5 count
count()用于统计某个字母在列表里面出现的次数；
x=[‘to‘,‘me‘,‘to‘,‘me‘,‘to‘,‘haha‘,‘hello‘] x.count(‘to‘) y=[1,2,[1,2],[1,2],[4,5]] y.count([1,2]) y.count(1)
5.6extend,可以在另一个序列的后边追加一个序列；
x=[1,2,3] y=[4,5,6] x.extend(y) print(x)
extend 的是改变了原来的列表，而原来的 +这是返回一个全新的列表
x=[1,2] y=[3,4] print(x+y) print(x)
5.8 index ,找出序列的第一个匹配的索引的位置；
1 print(names_class2.index(‘www‘))
5.9reverse(),方法是将列表中的元素反向存放；
1 names_class2.reverse( 2 print(names_class2)
6.0 sort 是在原来的基础上，让原来的列表排序
1 x=[4,5,1,2] 2 x.sort() 3 print(x)
6.1深浅拷贝
对于一个列表，我们可以对其进行，复制，而不是通过重新赋值的方式；重新赋值的内存空间是两个独立的内存空间；
1 names1=[‘张三‘,‘李四‘,‘王五‘,‘赵六‘] 2 names1.copy=[‘张三‘,‘李四‘,‘王五‘,‘赵六‘]
通过如上的方式，可以实现两个值得一样，但是并不是使用于所有的场合，如果说所有的数据都通过这种方式赋值的方式复制，因为其数据量比较大不适合，所有这里面我们可以使用copy（）
1 2 n=[‘张三‘,‘李四‘,‘王五‘,‘赵六‘,[1,7,8]] 3 ncopy=n.copy() 4 5 n[0]=‘zhangsan‘ 6 print(n) 7 print(ncopy)
1 #这里查看如下代码，发现两者并不是一直独立的； 2 n[4][0]=0 3 print(n) 4 print(ncopy)
这里简单的介绍一下什么是深浅拷贝：
1、首先给大家介绍一下，哪些基本的数据类型是可变的，哪些是不可变的：
可变数据类型：字典，列表，这些是可变的
不可变的数据类型：元组，数字，字符串
通过id()函数我们可以获取一个对象的内存地址；如果两个对象的内存地址是一样的，那么这两个对象肯定是一个对象。和is是等价的。Python源代码为证：
1 static PyObject * 2 cmp_outcome(int op, register PyObject *v, register PyObject *w) 3 { 4 int res = 0; 5 switch (op) { 6 case PyCmp_IS: 7 res = (v == w); 8 break; 9 case PyCmp_IS_NOT: 10 res = (v != w); 11 break;
2、当我们对列表进行修改的时候，注意不变的是列表的内存地址，不是里面的元素；
1 2 u=[1,2,3,4] 3 print(id(u)) #执行结果3247840 4 u[0]=‘a‘ 5 print(id(u)) #执行结果3247840
2.1像：数字，元组，字符串这些不可变的数据类型，要想改变，必须重新赋值，指针指向新的内存地址；
1 r=‘wing‘ 2 print(id(r))#内存地址4551520 3 # r[0]=‘a‘ #报错 4 r=‘mimi‘ 5 print(id(r)) #内存地址：6750304
2.3有关拷贝知识：这里我们只需要掌握浅拷贝的知识，就可以了;
1 2 a=[[1,2],3,4] 3 b=a[:]#b=a.copy() 4 5 print(a,b) 6 print(id(a),id(b)) 7 print(‘a[0]:‘,id(a[0]),‘b[0]:‘,id(b[0])) 8 print(‘a[0][0]:‘,id(a[0][0]),‘b[0][0]:‘,id(b[0][0])) 9 print(‘a[0][1]:‘,id(a[0][1]),‘b[0][1]:‘,id(b[0][1])) 10 print(‘a[1]:‘,id(a[1]),‘b[1]:‘,id(b[1])) 11 print(‘a[2]:‘,id(a[2]),‘b[2]:‘,id(b[2])) 12 13 print("-------------------------------------------") 14 15 b[0][0]=0 16 print(a,b) 17 print(id(a),id(b)) 18 print(‘*************************************‘) 19 print(‘a[0]:‘,id(a[0]),‘b[0]:‘,id(b[0])) 20 print(‘a[0][0]:‘,id(a[0][0]),‘b[0][0]:‘,id(b[0][0])) 21 print(‘a[0][1]:‘,id(a[0][1]),‘b[0][1]:‘,id(b[0][1])) 22 print(‘a[1]:‘,id(a[1]),‘b[1]:‘,id(b[1])) 23 print(‘a[2]:‘,id(a[2]),‘b[2]:‘,id(b[2]))
如图参考：
六：元组，tuple：
元组是不可变的，即数据不能修改，只能被查询，元组在小括号里面（），元组用逗号隔开，元组可以被查询，所以可以像列表一样使用切片查询；
1 a=() 2 b=(2,)
元组可以是空的，元组是一个元素的时候要使用逗号；
元组的作用：
1 对于一些数据我们不想被修改，可以使用元组；
2 另外，元组的意义还在于，元组可以在映射（和集合的成员）中当作键使用——而列表则不行；元组作为很多内建函数和方法的返回值存在。
七：字典：
1、字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。
2、python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。
3、可哈希表示key必须是不可变类型，如：数字、字符串、元组。
4、字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。
5、列表是有序的对象结合，字典是无序的对象集合。
6、两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
7.1创建字典：
1 2 dic={‘name‘:‘wing‘,‘age‘:34,‘sex‘:‘nv‘} 3 dic2=dict(((‘name‘,‘wing‘),)) 4 print(dic) 5 print(dic2)
执行结果：
1 {‘name‘: ‘wing‘, ‘age‘: 34, ‘sex‘: ‘nv‘} 2 {‘name‘: ‘wing‘}
7.2字典常用的操作方法：
1 dic={} 2 dic[‘name‘]=‘wing‘ 3 dic[‘age‘]=12 4 print(dic)
执行结果：
1 {‘name‘: ‘wing‘, ‘age‘: 12}
7.2查：
1 dic={} 2 dic[‘name‘]=‘wing‘ 3 dic[‘age‘]=12 4 print(dic) 5 6 print(dic[‘name‘]) 7 8 print(dic.items()) 9 10 print(dic.keys()) 11 12 print(dic.values()) 13 14 print(‘name‘ in dic) 15 16 print(list(dic.values()))
执行结果：
1 {‘name‘: ‘wing‘, ‘age‘: 12} 2 wing 3 dict_items([(‘name‘, ‘wing‘), (‘age‘, 12)]) 4 dict_keys([‘name‘, ‘age‘]) 5 dict_values([‘wing‘, 12]) 6 True 7 [‘wing‘, 12]
7.3删除：
1 dic={} 2 dic[‘name‘]=‘ 3 dic[‘age‘]=12 4 print(dic) 5 6 7 dic[‘name‘]=‘ 8 del dic[‘name 9 print(dic) 10 11 a=dic.popitem 12 print(a,dic)
执行结果：
1 {‘name‘: ‘wing‘, ‘age‘: 12} 2 {‘age‘: 12} 3 (‘age‘, 12) {}
7.4 改：
1 2 dic={‘name 3 dic[‘name‘ 4 dic2={‘sex 5 dic.update 6 print(dic)
7.5 字典的嵌套：
1 dic={ ‘zhangsan‘:{‘age‘:23,‘sex‘:‘male‘}, 2 ‘李二敏‘:{‘age‘:33,‘sex‘:‘male‘}, 3 ‘wing‘:{‘age‘:27,‘sex‘:‘women‘} }
八：集合：（set）
8.1：集合是无序的，不重复的，它的作用：
1、去重，把列表变成集合，就会自动的去重了；
2、交叉，并集，交集，差集等关系；
在Python中，集合是不能重复的；
li=[1,2,3,4] s=set(li) print(s) li2=[1,2,3,4,1,1] s2=set(li2) print(s2)
执行结果：
{1, 2, 3, 4}
{1, 2, 3, 4}
集合的对象无序排列的可哈希的值：集合成员可以做字典的键；
集合分类：可变集合，不可变集合；
可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素
不可变集合(frozenset)：与上面恰恰相反
1 li=[1,2,3] 2 s =set(li) 3 dic={s:‘123‘} #TypeError: unhashable type: ‘set‘
8.2集合的相关操作：
集合通过：set()和frozenset()创建；
1 s1=set(‘aaaal‘) 2 s2=frozenset(‘abcd‘) 3 print(type(s1)) #<class ‘set‘> 4 print(type(s2)) #<class ‘frozenset‘>
集合本身是无序的，所有不能通过切片来访问集合，只能通过in，not in来访问和判断集合元素；
s1=set(‘abcd‘) print(‘a‘ in s1) print(‘e‘ not in s1)
执行结果：
True
True
b
d
a
c
8.3更新集合：
通过如下的方法更新集合：
add()
remove()
update()
8.3.1如上的方法只有在可变集合中才能更新使用；
1 s1=set(‘abcd‘) 2 s2=frozenset(‘efch‘) 3 s2.add(0) #‘frozenset‘ object has no attribute ‘add‘
1 s1=set(‘abcd‘) 2 s2=frozenset(‘efch‘) 3 s1.add(‘wing‘) #{‘wing‘, ‘c‘, ‘b‘, ‘a‘, ‘d‘} 4 print(s1) #{‘c‘, ‘b‘, ‘wing‘, ‘a‘, ‘d‘} 5 s1.update(‘hello‘) 6 print(s1) #{‘wing‘, ‘l‘, ‘c‘, ‘o‘, ‘b‘, ‘e‘, ‘a‘, ‘h‘, ‘d‘} 7 s1.remove(‘a‘) 8 print(s1) #{‘wing‘, ‘l‘, ‘c‘, ‘o‘, ‘b‘, ‘e‘, ‘h‘, ‘d‘}
del 是删除集合本身；
8.4集合的操作类型：
in，not in，
等价==
不等价：！=
子集，超集
1 s=set(‘wanghelloworld‘) 2 s1=set(‘wang‘) 3 print(‘w‘ in s) #True 4 print(s1 <s) #True
8.4联合：|
联合(union)操作与集合的or操作其实等价的，联合符号有个等价的方法，union()；
1 s=set(‘wanghelloworld‘) 2 s1=set(‘wang‘) 3 s2=s|s1 4 print(s2) # {‘a‘, ‘o‘, ‘g‘, ‘w‘, ‘d‘, ‘l‘, ‘n‘, ‘r‘, ‘h‘, ‘e‘} 5 print(s.union(s1)) #{‘a‘, ‘o‘, ‘g‘, ‘w‘, ‘d‘, ‘l‘, ‘n‘, ‘r‘, ‘h‘, ‘e‘}
8.5交集：
和and等级，在集合里面的等价方法是：intersection()
1 s1=set(‘abc‘) 2 s2=set(‘ahc‘) 3 s3=s1&s2 4 print(s3) #{‘c‘, ‘a‘} 5 print(s1.intersection(s2)) #{‘c‘, ‘a‘}
8.6 差集 -
1 s1=set(‘abc‘) 2 s2=set(‘ahc‘) 3 s3=s1-s2 4 print(s3) #{‘b‘} 5 print(s1.difference(s2)) #{‘b‘}
8.7 对称差集：
其等价方法是：symmetric_difference()，就是集合里面的异或，属于s1,和s2,但是不同时属于s1,s2,就是说，s1和s2的所有的元素，去除公共部分；
1 2 s1=set(‘abc‘) 3 s2=set(‘ahc‘) 4 s3=s1^s2 5 print(s3) # {‘b‘, ‘h‘} 6 print(s1.symmetric_difference(s2)) #{‘b‘, ‘h‘}
如下最简单的驱虫方式：
1 """最简单的去重方式""" 2 lis=[1,2,3,4,56,1,2,2] 3 print(list(set(lis))) #[1, 2, 3, 4, 56]
九：文件操作
文件操作的流程：
1.打开文件，获取文件的句柄，并且赋值给变量；
2.通过句柄对文件进行操作；
3.关闭文件；
1 锄禾日当午 2 汗滴和下土 3 谁知盘种餐 4 丽丽皆辛苦 5 美丽的生活 6 开心的生活 7 我想好好活
现有如上述的文件；名字为：‘小文件’
f=open(‘小文件‘,encoding=‘utf8‘)#打开文件 data=f.read()#获取文件的内容 f.close()
备注：如果首次打开使用如下代码会报错；
1 f=open(‘小文件‘)#打开文件 2 data=f.read()#获取文件的内容 3 f.close() 4
执行结果：
Traceback (most recent call last):
File "D:/pytest/Demo/Basictest.py", line 274, in <module>
data=f.read()#获取文件的内容
UnicodeDecodeError: ‘gbk‘ codec can‘t decode byte 0xa6 in position 4: illegal multibyte sequence
所以：文件是utf8保存的，打开文件时open函数是通过操作系统打开的文件，而win操作系统
默认的是gbk编码，所以直接打开会乱码，需要f=open(‘小文件‘,encoding=‘utf8‘)，如果小文件如果是gbk保存的，则直接打开即可。所以说：第一段代码加入：encoding=‘utf8‘，才不会报错；
9.2文件打开的模式：
1 ‘r‘ open for reading (default) 2 ‘w‘ open for writing, truncating the file first 3 ‘x‘ create a new file and open it for writing 4 ‘a‘ open for writing, appending to the end of the file if it exists 5 ‘b‘ binary mode 6 ‘t‘ text mode (default) 7 ‘+‘ open a disk file for updating (reading and writing) 8 ‘U‘ universal newline mode (deprecated)
1 2 f=open(‘小文件‘,encoding=‘utf8‘)#打开文件 3 data1=f.read()#获取文件内容 4 print(data1)
接下来我们扩展文件格式：
1 f = open(‘小文件‘,‘w‘) #打开文件 2 f = open(‘小文件2‘,‘a‘) #打开文件 3 f.write(‘云云UN11111\n‘) 4 f.write(‘白了少年头2\n‘) 5 f.write(‘空悲切!3‘) 6 f.close()
1 #r+,w+模式 2 f = open(‘小文件2‘,‘r+‘) #以读写模式打开文件 3 print(f.read(5))#可读 4 f.write(‘hello‘) 5 print(‘-------------------‘) 6 print(f.read())
1 f = open(‘小文件2‘,‘w+‘) #以写读模式打开文件 2 print(f.read(5))#什么都没有,因为先格式化了文本 3 f.write(‘hello alex‘) 4 print(f.read())#还是read不到 5 f.seek(0) 6 print(f.read())
1 #w+与a+的区别在于是否在开始覆盖整个文件 2 # ok,重点来了,我要给文本第三行后面加一行内容:‘hello !!!!!!!!!‘ 3 # 有同学说,前面不是做过修改了吗? 大哥,刚才是修改内容后print,现在是对文件进行修改!!! 4 # f = open(‘小文件2‘,‘r+‘) #以写读模式打开文件 5 # f.readline() 6 # print(f.tell()) 7 # f.write(‘hello !!!!!!!!!!!‘) 8 # f.close() 9 # 和想的不一样,不管事!那涉及到文件修改怎么办呢? 10 11 # f_read = open(‘小文件‘,‘r‘) #以读模式打开文件 12 # f_write = open(‘小文件_back‘,‘w‘) #以写读模式打开文件
注意1: 无论是py2还是py3，在r+模式下都可以等量字节替换，但没有任何意义的！
注意2：有同学在这里会用readlines得到内容列表，再通过索引对相应内容进行修改，最后将列表重新写会该文件。
这种思路有一个很大的问题，数据若很大，你的内存会受不了的，而我们的方式则可以通过迭代器来优化这个过程
9.4 为了避免打开文件后忘记关闭，可以使用with语句：
1 with open(‘小文件‘,‘r‘) as f: 2 pass
这种方法的方便之处在于：当with执行完毕了，解释器会自动关闭，并释放文件的资源；
在Python3中支持对多个文件打开，在Python2.6之前的版本都是不可以的；
1 2 with open(‘文件1‘) as obj1, open(‘文件2‘) as obj2: 3 pass
原文：http://www.cnblogs.com/surewing/p/7745734.html