Python基础(三) 数据类型
我们首先要看的是几乎任何语言都具有的数据类型，包括字符串、整型、浮点型以及布尔类型。这些基本数据类型组成了基本控制块，从而创建的Python应用程序。
一、基本结构
1、数值:
Python支持不同的数值类型：
int (有符号整数): 通常被称为只是整数或整数，是正或负整数，不带小数点。
long (长整数 ): 或长，是无限大的整数，这样写整数，后面跟着一个大写或小写的L。
注意：自从Python2.2起，如果整数发生溢出，Python会自动将整数转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
float (浮点实数值) : 或浮点数，表示实数，并写入一个小数点分隔的整数部分和小数部分。浮点数也可以是科学记数法，用e或E表示的功率10 (2.5e2 = 2.5 x 102 = 250).
数值类型转换：
类型int（X）将X转换为一个普通的整数。
类型long(X)将X转换为一个长整数（在python3中已经没有了这个函数）。
类型float(X)转换X为一个浮点数。
2、布尔值:
Ture&False 即真或假、1或0.
3、字符串：
字符串(String） 是一段文本字符，通常以某种形式向用户输出。如果我们打开Python的解释器，我们试着最常见的输出“Hello World!”应用:
1 print("hello world!!") ##python3的print()函数的方法必须加上() 2 hello world!!
python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，字符串拼接使用+号进行连接，每次使用+号的时候就会在内存中重新开辟一块空间，在python中使用了下面的格式进行拼接，这种方法不会在去占用新的内存,下面来看一下字符串的格式：
1 msg=''' 2 personal information: 3 name: %s 4 age: %d'''%('alex',23) #%s可以代表字符串，%d代表整数，还有一种为%f代表浮点数 5 6 print(msg) 7 8 personal information: 9 name: alex 10 age: 23 11 #还有一种方法,这种方式要比%那种方式处理快一些，%执行要先转换成下面这种方式执行 12 13 name = "i am {0},age {1}" 14 new_name=name.format('jack',18) 15 print(new_name)
字符串常用功能：
1、移除空白：这里我们通过一个例子来说明：
1 #!/usr/bin/env python 2 3 name=input("please input your name:") 4 age=input("please input your age:") 5 sex=input("please input your sex:") 6 7 8 print(''' 9 This is my message: 10 name:%s 11 age:%s 12 sex:%s'''% (name,age,sex))
执行结果如下：
1 This is my message: 2 name:henry 3 age:25 4 sex:man
如果在用户输入信息的时候，无意输入多个空格，影响美观，我想不管用户输入多少个空格都去掉正常格式输出，这里就用到了strip()来去掉空格：
1 #!/usr/bin/env python 2 #coding:utf-8 3 4 name=input("please input your name:").strip() #还有两张用法：lstrip或rstrip(去除左边的空格，去除右边的空格) 5 age=input("please input your age:").strip() 6 sex=input("please input your sex:").strip() 7 8 9 print(''' 10 This is my message: 11 name:%s 12 age:%s 13 sex:%s'''% (name,age,sex))
这样用户输入的空格就会去掉，注意：这里的strip()不会去掉中间的空格。
2、使用split()进行字符串分割，下面来看一段代码：
1 #!/usr/bin/env python 2 #coding:utf-8 3 4 s="hello World! Everyone! This Is My First String!" ##首先定义一段字符串 5 6 print(s.split("!")) ##使用split()来以!为分割线进行分割 7 8 ['hello World', ' Everyone', ' This Is My First String', ''] #执行结果
使用方法：
s.split([sep, [maxsplit]]) 以sep是分隔符，把s分割成一个list。sep默认为空格。maxsplit是分割的次数，默认是对整个s进行分割。
s.rsplit([sep, [maxsplit]]) 和split()的区别是它是从s的串尾往前进行分割。
3、python中使用len()来判断字符串的长度：
1 name=henry ##定义一个变量 2 print(len(name)) ##使用len()来判断字符串的长度 3 4 5 ##执行结果
4、这里我们一起来实验一下python的索引和切片：
1 name="helloworld" 2 3 print(name[0]) ## 在字符中中每个字母对应的一个下标，从左往右以0开始，从右往左-1开始 4 print(name[-1]) 5 6 print(name[0:5]) ##这里面的[0:5]代表的是截取下标0到5的字符，当然这里也可以从右往左 7 print(name[-5:])
二、高级结构
（一）、列表(list)
首先我们来看一下怎么创建列表：
1 name_list=['Henry','tom','seven'] 2 name_list=list(['Henry','tom','seven']) #上面那种方法会调用下面这个来实现的
下面来看下列表有那些基本操作：
1、列表的索引、分片、步长 注：列表的修改不会再内存中申请新的地址
1 name=['Henry','tom','seven','alex','wusir','penny'] ##定义一个列表 2 3 print(name[0]) ##列表的索引跟字符串类似，在列表中的元素都对应一个下标。 4 5 Henry ##执行结果 6 7 #列表的分片 8 9 print(name[0:4]) ##取下标从0到4的元素 10 11 ['Henry', 'tom', 'seven', 'alex']
12 print(name[0:5:2]) ##这种方法是取下标从0到5的元素，步长为2，也就是间隔2个元素，
13 ['Henry','seven','wusir']
2、列表的方法
方法是一个与某些对象有紧密联系的函数，对象可能是列表、数字，也可能是字符串或者其他类型的对象。方法可以这样进行调用：
对象.方法（参数）下面我们一起来看一下列表的方法：
1 x=[1,2,3,4,1,2,3]
2 >>> dir(x) 3 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__',
'__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
1. append:列表末尾追加新的对象。
1 lst=[1,2,3] 2 lst.append(4) #会在最后追加一个字符 3 lst 4 [1,2,3,4]
5
6 "_".join(name_list) #通过“”.join()可以将列表转换成字符串
7 'alex_eric_serven'
8 'alex' in name_list #in函数判断字符串在不在列表里
9 True
10 'jack' in name_list
11 False
2.count：统计某个元素在列表中出现的次数。
1 name=[1,2,3,1,5,6,3,2,1,7,8,2] 2 print(name.count(1)) ##统计1在列表中出现的次数 3 3 ##执行结果
3.index：从列表中找出某个值第一个匹配项的索引位置。
1 name="we are the knights who say ni" 2 lst=name.split() ##将字符串以空格切片存到列表中 3 4 print(lst.index('the')) ##取元素the在列表中的位置下标 5 6 2
4.insert：将对象插入到列表中。
1 name="we are the knights who say ni" 2 lst=name.split() 3 lst.insert(1,'haha') ##在下标1的位置上插入字符串haha， 4 print(lst) 5 6 ['we', 'haha', 'are', 'the', 'knights', 'who', 'say', 'ni']
5.pop:会移除列表中的一个元素（默认是最后一个），并且返回该元素的值。
1 x=[1,2,3] 2 x.pop() ##pop方法默认删除最后一个元素 3 print(x) 4 x.pop(0) ##当然也可以根据下标位置进行删除 5 print(x)
注意：pop方法是唯一一个既能修改列表又能返回元素值（除了none）的列表方法。
6.remove：移除列表中某个值的第一个匹配项。
1 x=[1,2,3,1] 2 x.remove(1) #删除第一个匹配到的元素 3 print(x)
1 #!/usr/bin/env python 2 #coding:utf-8 3 4 x=[1,2,3,1,1,1,3,2] 5 print(x.count(1)) 6 7 for i in range(x.count(1)): ##统计出1在列表中出现的次数 8 x.remove(1) ##循环删除 9 10 print(x)
7.reverse：将列表中的元素反向存放：
1 >>> x=[1,2,3,4,5] 2 >>> x.reverse() 3 >>> x 4 [5, 4, 3, 2, 1]
8.sort:用于在原位置对列表进行排序，在"原位置排序"意味着改变原来的列表，从而让其中的元素按一定的顺序排列，而不是简单的返回一个已排序的列表副本。
1 >>> x=[3,4,2,87,54,34,56] 2 >>> x.sort() 3 >>> x 4 [2, 3, 4, 34, 54, 56, 87]
9.extend:可以在列表的末尾追加另一个序列中的多个值。
1 a=[1,2,3,4,5] 2 b=[2,3,4,5,6] 3 a.extend(b) ##将b列表追加到a列表中 4 5 print(a) 6 7 [1, 2, 3, 4, 5, 2, 3, 4, 5, 6]
10.copy:复制一份列表。
1 >>> x=[1,2,3] 2 >>> y=x.copy() 3 >>> y 4 [1, 2, 3]
（二）、元组(tuple)
元组和列表一样，也是一种序列。唯一不同是元组不能修改。
x=(1,2,3,4,5) dir(x) ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
#这里可以看到元组的方法只有count和index，这里不在详细介绍使用方法
下面看一下元组和列表之间的转换：
1 x=(1, 2, 3, 4) ##定义一个元组 2 y=list(x) ##使用list()函数可以将x转换为列表存放在y中 3 y 4 [1, 2, 3, 4] 5 type(x) 6 <class 'tuple'> 7 >>> type(y) 8 <class 'list'> 9 >>> z=tuple(y) ##可以使用tuple()函数将列表转换成列表 10 >>> z 11 (1, 2, 3, 4)
（三）、字典（Dict）
字典是Python中唯一内建的映射类型，在字典中的值没有特殊的顺序，但是都存储在一个特定的键（Key）下。键可以是数字、字符串甚至是元组。
1、字典的特点：
1，key-value格式，key是唯一的。
2，无序，与列表有序的特点不同，字典是无序的，列表只所以有序是因为你需要通过索引来定位相应元素，而字典已经可以通过key来定位相对应value，因此为了避免浪费存储空间，
字典不会对数据的位置进行记录，当然如果你想让其变成有序的，也是可以切换的。
3，查询速度快，dict是基于hash表的原理实现的，是根据关键字（key-alue）而直接访问在内存存储位置的数据结构。也就是说，它通过把键值通过一个函数的计算，映射到一个表中
一个位置累访问记录，还加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。
2、dict的语法格式：
1 >>> info={'name':'henry', 2 ... 'job':'IT', 3 ... 'age':'24', 4 ... 'company':'xlwb'} 5 >>> info 6 {'age': '24', 'job': 'IT', 'company': 'xlwb', 'name': 'henry'
3、dict的方法：
>>> info. info.__class__( info.__ge__( info.__len__( info.__setitem__( info.items( info.__contains__( info.__getattribute__( info.__lt__( info.__sizeof__( info.keys( info.__delattr__( info.__getitem__( info.__ne__( info.__str__( info.pop( info.__delitem__( info.__gt__( info.__new__( info.__subclasshook__( info.popitem( info.__dir__( info.__hash__ info.__reduce__( info.clear( info.setdefault( info.__doc__ info.__init__( info.__reduce_ex__( info.copy( info.update( info.__eq__( info.__iter__( info.__repr__( info.fromkeys( info.values( info.__format__( info.__le__( info.__setattr__( info.get(
1 >>> info 2 {'age': '24', 'job': 'IT', 'company': 'xlwb', 'name': 'henry'} 3 >>> info['name'] ##查看key为'name'的value 4 'henry' 5 >>> info['job']='Boss' ##将key的value改为'Boss' 6 >>> info 7 {'age': '24', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'} 8 >>> info['city']='BJ' ##如果dict中有key为'city',就将其值改为'BJ'，如果没有这个key，就创建一条新记录 9 >>> info 10 {'age': '24', 'city': 'BJ', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'}
1 >>> info 2 {'age': '24', 'city': 'BJ', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'} 3 >>> info.pop('age') ##删除key为‘age’的数据，跟del info['age']一样 4 '24' 5 >>> info.popitem() ##随机删除一条数据，dict为空时用此语法会报错。 6 ('city', 'BJ') 7 >>> info 8 {'job': 'Boss', 'company': 'xlwb', 'name': 'henry'} 9 10 >>> info 11 {'city': 'BJ', 'job': 'Boss', 'company': 'xlwb', 'name': 'henry'} 12 >>> info.items() ##将dict的key，value转换成列表的形式显示 13 dict_items([('city', 'BJ'), ('job', 'Boss'), ('company', 'xlwb'), ('name', 'henry')]) 14 15 >>> info.get('age') 16 >>> info.get('name') ##查找key，如果存在返回其value，否则返回None 17 'henry' 18 19 >>> info.fromkeys(['a','b','c'],'Test') ##根据列表['a','b','c']来创建dict里的key，后面的‘Test’是默认的value，如果不指定的话则为None 20 {'a': 'Test', 'c': 'Test', 'b': 'Test'}
1 >>> info.clear() ##清空字典 2 >>> info 3 {} 4 5 >>> info=info.fromkeys(['a','b','c'],'Test') #info.fromkeys()可以已列表的方式打印出所有的key值，info.fromvalues()打印出所有的value值 6 >>> info 7 {'a': 'Test', 'c': 'Test', 'b': 'Test'} 8 >>> info.setdefault('d','Henry') ##找一个key为'd'的记录，如果这个key不存在，那就创建一个叫'd'的key，并且将value设置为'Henry'，如果这个key存在，就直接返回key值。10 'Henry' 11 >>> info 12 {'d': 'Henry', 'a': 'Test', 'c': 'Test', 'b': 'Test'} 13 >>> info.setdefault('c','Henry') 14 'Test' 15 16 17 >>> info 18 {'d': 'Henry', 'a': 'Test', 'c': 'Test', 'b': 'Test'} 19 >>> dict2={'e':'fromDict2','a':'fromDict2'} 20 >>> info.update(dict2) ##拿这个新字典去更新info，注意dict2中有一个key值'a'与dict info相冲突，这时dict2的值会覆盖info中的a，如果dict2的key在info中不存在，则创建相应的记录。22 >>> info 23 {'b': 'Test', 'd': 'Henry', 'e': 'fromDict2', 'a': 'fromDict2', 'c': 'Test'}
4、遍历©字典：
遍历字典dict与遍历列表差不多，只不过记得dict是key-value的结构，要想在遍历时同时打印这key和value,需要这样写：
1 #!/usr/bin/env python 2 #coding:utf-8 3 4 info={ ##定义info dict 5 'name':'Henry', 6 'age':25, 7 'job':'IT', 8 'company':'xlwb' 9 } 10 for item in info: 11 print(item,info[item]) ##print(item)只会打印key，如果想同时打印value，需要通过item去取 12 13 #另一种方法 14 for key,val in info.items(): 15 print(key,val)
以上是默认把字典转换成一个大列表，并且把每对key-value值转换成了元组，所以你可以在每次循环时赋2个变量进去，因为循环的数据格式如下：
[('age', 25), ('job', 'IT'), ('name', 'Henry'), ('company', 'xlwb')]
因此每循环依稀，其实就是把相对应元组中的2个值赋值key，val这两个变量并打印。
