学习Python低手之路【二】python基本数据类型

一：数字 int

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位表示指数，剩下一位表示符号int

二：字符串 str

str

字符串是 Python 中最常用的数据类型。我们可以使用引号，双引号，或三引号来创建字符串。

1. a = 'poe'
2. b = "bruce"
3. c = """Jacky Chen"""

1：字符串连接

方法一：join方法

1. a = ['a','b','c','d']
2. content = ''
3. content = ' '.join(a)
4. print(content)

方法二：用字符串的替换占位符替换

1. a = ['a','b','c','d']
2. content = ''
3. content = '%s%s%s%s' % tuple(a)
4. print(content)

方法三：for循环

1. a = ['a','b','c','d']
2. content = ''
3. for i in a:
4. content += i
5. print(content)

注意：方法三效率低，不推荐使用！

原因：在循环连接字符串的时候，他每次连接一次，就要重新开辟空间，然后把字符串连接起来，再放入新的空间，再一次循环，又要开辟新的空间，把字符串连接起来放入新的空间，如此反复，内存操作比较频繁，每次都要计算内存空间，然后开辟内存空间，再释放内存空间，效率非常低，你也许操作比较少的数据的时候看不出来，感觉影响不大，但是你碰到操作数据量比较多的时候，这个方法就要退休了。

2：字符串截取

我们可以通过索引来提取想要获取的字符，可以把python的字符串也做为字符串的列表就更好理解

python的字串列表有2种取值顺序：

1是从左到右索引默认0开始的，最大范围是字符串长度少1

1. s = 'ilovepython'
2. s[0]的结果是i

2是从右到左索引默认-1开始的，最大范围是字符串开头

1. s = 'ilovepython'
2. s[-1]的结果是n

上面这个是取得一个字符，如果你的实际要取得一段子串的话，可以用到变量[头下标:尾下标]，就可以截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

比如

1. s = 'ilovepython'
2. s[1:5]的结果是love

当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界，比如上面的结果包含了s[1]的值l，而取到的最大范围不包括上边界，就是s[5]的值p

注：s[1:5]形式截头不截尾

3：字符串替换

方法一：使用repalce方法

1. a = 'hello world'
2. b = a.replace('world','python')
3. print(b)

方法二：使用正则表达式

1. import re
2. a = 'hello world'
3. strinfo = re.compile('world')
4. b = strinfo.sub('python',a)
5. print(b)

4：字符串比较

cmp方法比较两个对象，并根据结果返回一个整数。cmp(x,y)如果X< Y,返回值是负数 如果X>Y 返回的值为正数。

1. str1 = 'strch'
2. str2 = 'strchr'
3. print(cmp(str1,str2))
4. ## -1

5：字符串相加

我们通过操作符号+来进行字符串的相加，不过建议还是用其他的方式来进行字符串的拼接，这样效率高点。
原因：在循环连接字符串的时候，他每次连接一次，就要重新开辟空间，然后把字符串连接起来，再放入新的空间，再一次循环，又要开辟新的空间，把字符串连接起来放入新的空间，如此反复，内存操作比较频繁，每次都要计算内存空间，然后开辟内存空间，再释放内存空间，效率非常低。

1. str1 = 'strch'
2. str2 = 'strchr'
3. print(str1+str2)
4. ## strchstrchr

6：字符串查找

python 字符串查找有4个方法，1 find,2 index方法，3 rfind方法,4 rindex方法。

方法一：find方法

1. info = 'abca'
2. print info.find('a')##从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
4. info = 'abca'
5. print info.find('a',1)##从下标1开始，查找在字符串里第一个出现的子串：返回结果3
7. info = 'abca'
8. print info.find('')##返回-1,查找不到返回-1

方法二：index方法

python 的index方法是在字符串里查找子串第一次出现的位置，类似字符串的find方法，不过比find方法更好的是，如果查找不到子串，会抛出异常，而不是返回-1

1. info = 'abca'
2. print info.index('a')
3. print info.index('')

7：字符串分割

字符串分割，可以用split,rsplit方法，通过相应的规则来切割成生成列表对象

1. info = 'name:haha,age:20$name:python,age:30$name:fef,age:55'
2. content = info.split('$')
3. print content
4. ## ['name:haha,age:20', 'name:python,age:30', 'name:fef,age:55']

8：字符串反转

1. a = 'abcd'
2. b = a[::-1]##[::-1]通过步进反转
3. print b

9：字符串编码

10：字符串追加和拼接

通过字符串的占位符来进行字符串的拼接

1. #1 元组拼接
2. m = 'python'
3. astr = 'i love %s' % m
4. print astr
6. #2 字符串的format方法
7. m = 'python'
8. astr = "i love {python}".format(python=m)
9. print astr
11. #3 字典格式化字符串
12. m = 'python'
13. astr = "i love %(python)s " % {'python':m}
14. print astr

11：字符串复制

1. #通过变量来进行赋值
2. fstr = 'strcpy'
3. sstr = fstr
4. fstr = 'strcpy2'
5. print sstr

12：字符串长度

1. #通过内置方法len()来计算字符串的长度，注意这个计算的是字符的长度。
2. aa = 'afebb'
3. bb = '你'
4. print len(aa)
5. print len(bb)

13：字符串大小写

1. #通过下面的upper(),lower()等方法来转换大小写
2. S.upper()#S中的字母大写
3. S.lower() #S中的字母小写
4. S.capitalize() #首字母大写
5. S.istitle() #S是否是首字母大写的
6. S.isupper() #S中的字母是否便是大写
7. S.islower() #S中的字母是否全是小写

14：字符串去空格

1. #通过strip(),lstrip(),rstrip()方法去除字符串的空格
2. S.strip() #去掉字符串的左右空格
3. S.lstrip() #去掉字符串的左边空格
4. S.rstrip() #去掉字符串的右边空格
5. #注意：strip()函数不仅可以去空格还可以去除指定的字符，如
6. S.strip("\n")

15：字符串其他方法

1. #字符串相关的其他方法:count(),join()方法等。
2. S.center(width, [fillchar]) #中间对齐
3. S.count(substr, [start, [end]]) #计算substr在S中出现的次数
4. S.expandtabs([tabsize]) #把S中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个
5. S.isalnum() #是否全是字母和数字，并至少有一个字符
6. S.isalpha() #是否全是字母，并至少有一个字符
7. S.isspace() #是否全是空白字符，并至少有一个字符
8. S.join()#S中的join，把列表生成一个字符串对象
9. S.ljust(width,[fillchar]) #输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。
10. S.rjust(width,[fillchar]) #右对齐
11. S.splitlines([keepends]) #把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。
12. S.swapcase() #大小写互换

三：列表 list

list

1：创建列表

1. list1 = ['physics', 'chemistry', 1997, 2000];
2. list2 = [1, 2, 3, 4, 5 ];
3. list3 = ["a", "b", "c", "d"];

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等

2：访问列表

1. list1 = ['physics', 'chemistry', 1997, 2000];
2. list2 = [1, 2, 3, 4, 5, 6, 7 ];
3. print(list1[0])
4. print(list2[2:5])#截头不截尾
5. ## physics
6. ## [3, 4, 5]

3：append方法：在列表末尾添加新的对象

1. aList = [123, 'xyz', 'zara', 'abc'];
2. aList.append( 2009 );
3. print "Updated List : ", aList;
4. ## Updated List : [123, 'xyz', 'zara', 'abc', 2009]

4：count方法：统计某个元素在列表中出现的次数

1. aList = [123, 'xyz', 'zara', 123];
2. print(aList.count(123))
3. ## 2

5：extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

1. aList = [123, 'xyz', 'zara', 'abc', 123];
2. bList = [2009, 'manni'];
3. aList.extend(bList)
5. print "Extended List : ", aList ;
6. ## Extended List : [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']

6：index() 函数用于从列表中找出某个值第一个匹配项的索引位置

1. aList = [123, 'xyz', 'zara', 'abc'];
3. print "Index for xyz : ", aList.index( 'xyz' ) ;
4. print "Index for zara : ", aList.index( 'zara' ) ;
6. ##Index for xyz : 1
7. ## Index for zara : 2

7：insert() 函数用于将指定对象插入列表的指定位置

1. aList = [123, 'xyz', 'zara', 'abc']
3. aList.insert( 3, 2009)
5. print "Final List : ", aList
7. ## Final List : [123, 'xyz', 'zara', 2009, 'abc']

insert()接收两个参数，list.insert(index, obj)，第一个参数index为要插入的索引位置，第二个参数要插入的元素

8：pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

1. aList = [123, 'xyz', 'zara', 'abc'];
3. print "A List : ", aList.pop();
4. print "B List : ", aList.pop();
6. ## A List : abc
7. ## B List : zara

9：remove() 函数用于移除列表中某个值的第一个匹配项

1. aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
3. aList.remove('xyz');
4. print "List : ", aList;
5. aList.remove('abc');
6. print "List : ", aList;
8. ## List : [123, 'zara', 'abc', 'xyz']
9. ## List : [123, 'zara', 'xyz']

10：列表的四种遍历方法

1. aList = [123, 'xyz', 'zara', 123];

方法一：只遍历列表中的值

1. for value in aList :
2. print(value)
3. ####################
4. 123
5. xyz
6. zara
7. 123

方法二：如果需要遍历列表中的索引与值，就需要用到enumerate

1. for key,value in enumerate(aList) :
2. print(key,value)
3. ######################
4. (0, 123)
5. (1, 'xyz')
6. (2, 'zara')
7. (3, 123)

enumrate：为可迭代的对象添加序号，默认从0开始！因为列表的索引也是从0开始，所以我们在enumerate中不指定第二个参数，如有需要，可以指定从几开始，如下：

1. for key,value in enumerate(aList,1) :
2. print(key,value)
3. ######################################
4. (1, 123)
5. (2, 'xyz')
6. (3, 'zara')
7. (4, 123)

方法三：

1. for i in range(len(aList)) :
2. print(i,aList[i])
3. ##############################
4. (0, 123)
5. (1, 'xyz')
6. (2, 'zara')
7. (3, 123)

range和xrange：指定范围，生成指定的数字

方法四：使用iter()

1. for i in iter(aList) :
2. print(i)
3. ##########################################
4. 123
5. xyz
6. zara
7. 123

四：元组 tuple

tuple

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

tuple只有两个可使用的功能：count , index

1：创建元组

1. tup1 = ();#创建空元组
3. tup1 = (50,);#元组中只包含一个元素时，需要在元素后面添加逗号

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。元组的访问与列表一样！

2：元组的连接组合

1. tup1 = (12, 34.56);
2. tup2 = ('abc', 'xyz');
4. # 以下修改元组元素操作是非法的。
5. # tup1[0] = 100;
7. # 创建一个新的元组
8. tup3 = tup1 + tup2;
9. print tup3;
10. ##########################################
11. (12, 34.56, 'abc', 'xyz')

3：删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

1. tup = ('physics', 'chemistry', 1997, 2000);
3. print tup;
4. del tup;
5. print "After deleting tup : "
6. print tup;
7. ##########################################
8. 以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
9. ('physics', 'chemistry', 1997, 2000)
10. After deleting tup :
11. Traceback (most recent call last):
12. File "test.py", line 9, in <module>
13. print tup;
14. NameError: name 'tup' is not defined

五：字典 dict

dict

字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

1. d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

1：访问字典里的值

1. dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
3. print "dict['Name']: ", dict['Name'];
4. print "dict['Age']: ", dict['Age'];
5. ##########################################
6. dict['Name']: Zara
7. dict['Age']: 7

2：修改字典里的值

1. dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
3. dict['Age'] = 8; # update existing entry
4. dict['School'] = "DPS School"; # Add new entry
6. print "dict['Age']: ", dict['Age'];
7. print "dict['School']: ", dict['School'];
8. ##########################################
9. dict['Age']: 8
10. dict['School']: DPS School

3：删除操作

能删单一的元素也能清空字典，清空只需一项操作。显示删除一个字典用del命令，如下实例：

1. dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
3. del dict['Name']; # 删除键是'Name'的条目
4. dict.clear(); # 清空词典所有条目
5. del dict ; # 删除词典
7. print "dict['Age']: ", dict['Age'];
8. print "dict['School']: ", dict['School'];
9. ##########################################
10. dict['Age']:
11. Traceback (most recent call last):
12. File "test.py", line 8, in <module>
13. print "dict['Age']: ", dict['Age'];
14. TypeError: 'type' object is unsubscriptable

clear() 函数用于删除字典内所有元素：

1. dict = {'Name': 'Zara', 'Age': 7};
3. print "Start Len : %d" % len(dict)
4. dict.clear()
5. print "End Len : %d" % len(dict)

注：clear函数是删除字典里的所有元素，删除后，该字典仍然存在，不过是个空字典而已

4： copy() 函数返回一个字典的浅复制

1. dict1 = {'Name': 'Zara', 'Age': 7};
3. dict2 = dict1.copy()
4. print "New Dictinary : %s" % str(dict2)
5. ##########################################
6. New Dictinary : {'Age': 7, 'Name': 'Zara'}

有关深浅复制的区别，请点击这里！

5：fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值

1. seq = ('name','age','sex')
2. dic = dict.fromkeys(seq)
3. print(dic)
4. #########################################
5. {'age': None, 'name': None, 'sex': None}

可以指定一个值，如：

1. seq = ('name','age','sex')
2. dic = dict.fromkeys(seq,10)
3. print(dic)
4. ##########################################
5. {'age': 10, 'name': 10, 'sex': 10}

6：get() 函数返回指定键的值，如果值不在字典中返回默认值

1. dic = {'Name': 'Zara', 'Age': 27}
2. print(dic.get('Age'))
3. print(dic.get('Sex','Never'))#Never为设置的默认值
4. ##########################################
5. 27
6. Never

7：has_key() 函数用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false

1. dic = {'Name': 'Zara', 'Age': 27}
2. print(dic.has_key('Name'))
3. print(dic.has_key('Sex'))
4. ##########################################
5. True
6. False

8：items() 函数以列表返回可遍历的(键, 值) 元组数组

1. dic = {'Name': 'Zara', 'Age': 27}
2. print(dic.items())
3. ##########################################
4. [('Age', 27), ('Name', 'Zara')]

9：keys() 函数以列表返回一个字典所有的键

1. dic = {'Name': 'Zara', 'Age': 27}
2. print(dic.keys())
3. ##########################################
4. ['Age', 'Name']

10：values() 函数以列表返回字典中的所有值

1. dic = {'Name': 'Zara', 'Age': 27}
2. print(dic.values())
3. ##########################################
4. [27, 'Zara']

11：update() 函数把字典dict2的键/值对更新到dict1里

1. dict1 = {'Name': 'Zara', 'Age': 7}
2. dict2 = {'Sex': 'female' }
3. dict1.update(dict2)
4. print(dict1)
5. ##########################################
6. {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}

12：字典的遍历

方法一：

1. dict1 = {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}
2. for k,v in dict1.items() :
3. print(k,v)
4. ##########################################
5. ('Age', 7)
6. ('Name', 'Zara')
7. ('Sex', 'female')

方法二：

1. dict1 = {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}
2. for (k,v) in dict1.items() :
3. print(k,v)
4. ##########################################
5. ('Age', 7)
6. ('Name', 'Zara')
7. ('Sex', 'female')