1、前面第三章有说过了Python有的数据类型，在开始介绍各种数据类型之前，我们先要知道Python的一个内置函数 type() ，用以查询变量所赋值的数据类型。
>>> a=1
>>>type(a)
>>> b='abc'
>>>type(b)
2、整型（int 型）
整型就是整数的意思，在数学里整数包括有正整数、0 、负整数，Python中同样如此。
>>> a,b,c=-1,0,1
>>>type(a)
>>>type(b)
>>>type(c)
3、浮点型 （float 型）
浮点型通俗的说就是小数点型，Python 中的小数有两种书写形式：1.3， 1.3e4(等价于1.4*104)
>>> a,b=1.3,1.3e4
>>>type(a)
>>>type(b)
4、布尔型（bool型）
布尔型表示真假值，Python中用两个常量 True 和 False 表示真假。通常用于条件判断和循环语句中
>>> 3>2True>>> 3<2False
注：
1) True 和 False 是 Python 中的关键字，当作为 Python 代码输入时，一定要注意字母的大小写，否则解释器会报错。
>>> trueTraceback (most recent call last):
File"", line 1, in NameError: name'true' isnot defined>>>True
True
2) 布尔类型可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0
>>> True+1
2
>>> False+1
1
3) 布尔值可以用 and、or和 not运算
and是与运算，只有所有都为True，结果才是True；
or 是或运算，只要其中有一个为True，结果就是True；
not 是非运算，结果取反。
5、字符型 （str 型)
字符串是以单引号 '' 或双引号 "" 括起来的任意字符集，字符的内容可以包含字母、数字、标点、特殊符号、中文、日文等全世界的所有文字。
1） Python 字符串中的双引号和单引号没有任何区别。当字符串中需要出现 ’或者“ 时需要使用转义字符 \
>>> a,b='123',"123"
>>>type(a)
>>>type(b)
2）字符串拼接
两个字符串相加，就相当于把两个字符串拼接起来，用 +号实现连接。
>>> "py" + "thon"
'python'
3）索引和切片
字符串是由多个字符组成的集合，通过索引找到对应的字符，由左往右的第一个字符对应的索引值是 0 ，依次加 1 位。
>>> a='hello world'
>>> a[0]'h'
>>> a[4]'o'
如何通过字符得到对应索引值？这时候就使用到 index() 函数
>>> a.index('e')1
通过索引得到字符的过程，称之为切片。
>>> a='hello world'
>>> a[1:] #得到从索引值1开始到最末尾的字符'ello world'
>>> a[1:4] #得到从索引值1开始到索引值4之前的字符，不含4的值'ell' #即1<=x<4
>>> a[:4] #得到从索引值4之前的字符，不含4的值'hell'
>>>a[:] #得到从所有的字符'hello world'
4）字符串的一些基本操作>>> a,b='qw','qwe'
>>> a+b #字符串拼接'qwqwe'
>>> 'a' ina #判断某个字符串是否存在于另一个字符串内，存在为真，否为假
False>>> 'q' ina
True
#每个字符在计算机内都是有编码的，也就是对应着一个数字,即在ASCII中的值。根据数字大小进行比较>>>max(a) #提取字符串中的最大值，'w'
>>>min(a) #提取字符串中的最小值'q'
>>>cmp(a,b) #两个字符串进行比较，也是首先将字符串中的符号转化为对一个的数字，然后比较。如果返回的数值小于零，说明第一个小于第二个，等于0，则两个相等，大于0，第一个大于第二个。-1 #在字符串的比较中，是两个字符串的第一个字符先比较，如果相等，就比较下一个，如果不相等，就返回结果。直到最后，如果还相等，就返回0。位数不够时，按照没有处理
>>> ord('a') #ord()函数，返回某个字符（注意，是一个字符，不是多个字符组成的串）所对一个的ASCII值（是十进制的），字符a在ASCII中的值是97，空格在ASCII中的值是32。97>>> chr(97) #chhr()函数，根据ASCII值得到对应字符
'a'
>>>len(a) #得到字符串的长度2>>>type(a) 查询变量类型
6、列表（List）
python中用方括号 [ ] 表示一个list，方括号里面可以是各种数据类型。
>>> a=[1,'q',True]>>>type(a)
1）列表也有类似字符串一样的索引和切片，方法一样
>>> a=[1,23,2]>>> a[0]1
>>> a.index(1)0
2）反转：字符串倒过来。
反转，不是在“原地”把原来的值倒过来，而是新生成了一个值，那个值跟原来的值相比，是倒过来了，原来的值还存在于变量中
反转有两种方式：
>>> a=[1,23,2]>>> a[::-1] #方式一
[2, 23, 1]>>>a
[1,23,2]>>>list(reversed(a)) #方式二
[2, 23, 1]
3）基础操作
>>> a.append("like") #增加列表元素，追加到尾部>>>a
[1, 23, 2, 'like']>>> b=['q', 'w']>>>a.extend(b) #b中的所有元素加入到a中>>>a
[1, 2, 3, 'q', 'w']>>>b
['q', 'w']>>> a = "python"
>>> hasattr(a,'__iter__')
False>>>b = [1,2]>>> hasattr(b,'__iter__')
True
#hasattr()判断一个字符串是否是可迭代的，是返回True,否返回False。其判断本质就是看该类型中是否有__iter__函数。用dir()查询整型、字符串、列表中，谁有__iter__。>>>dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']>>>dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
#id()函数查看变量在内存的位置编码>>>id(a)140571421973464
>>>id(b)140571377764352
4）insert(i, x)函数，含义是将元素 x 插入到索引值是 i 的元素前面。索引值是从0开始的。
>>> a=['a','b','c','d']>>> a.insert(2,'q')>>>a
['a', 'b', 'q', 'c', 'd']>>> a.insert(9,'w')>>>a
['a', 'b', 'q', 'c', 'd', 'w']
注：当 i 的值大于 list 中的最大索引值时，元素 x 自动插入 list 末尾。
5）remove(x)函数，删除列表中的x元素。注：当列表中含有多个不紧邻的x元素时，只删除第一个x元素，若相邻的就一起删除
>>> a=['a', "a",'b', 'c', 'd', 'w']>>> a.remove('a')>>>a
['a', 'b', 'c', 'd', 'w']>>> a=['a','b','a', 'c', 'd', 'w']>>> a.remove('a')>>>a
['b', 'a', 'c', 'd', 'w']
6）pop(i)函数，删除指定索引值 i 对应的元素，并将删除结果返回，若不写 i , 默认删除最后一个元素。
>>> a=['b', 'a', 'c', 'd', 'w']>>>a.pop()'w'
>>>a
['b', 'a', 'c', 'd']>>> a.pop(2)'c'
7）reverse()函数，将列表反转，等同于 list[ : :-1]
>>> a=['a','b','c']>>>a.reverse()>>>a
['c', 'b', 'a']>>> a[::-1]
['a', 'b', 'c']
8）sort()函数，对原列表进行排序，语法：
list.sort(cmp=None, key=None, reverse=False) #python 2.x
list.sort(key=None,reverse=False)#python 3.x
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。默认值None
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
>>> a=['qwe','rty','uiop']>>>a.sort()>>>a
['qwe', 'rty', 'uiop']>>> a.sort(key=len)>>>a
['qwe', 'rty', 'uiop']>>> a.sort(key=len,reverse=True)>>>a
['uiop', 'qwe', 'rty']>>> b=[45,5,7,3]>>>b.sort()>>>b
[3, 5, 7, 45]
此外，还有一个内置函数sorted()用于排序
sorted(iterable, cmp=None, key=None, reverse=False) #python 2.x
sorted(iterable, key=None, reverse=False) #python 3.x
注：两函数的的区别是， sort( )函数时是在原列表上进行排序，无返回值；而sorted( )函数是返回一个新的list,不在原来的list上进行操作，调用其返回一个排好序的list。
>>>b
[3, 5, 7, 45]>>> c=sorted(b)>>>c
[3, 5, 7, 45]
9）split()函数，指定分隔符对字符串进行分割，分割后的字符串以逗号“，”隔开。
语法：str.split(str="",num=string.count(str))
str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。分隔出 num+1 个子字符串，默认为 -1, 即分隔所有。
>>> a="hello world to you"
>>>a.split()
['hello', 'world', 'to', 'you']>>>a'hello world to you'
>>> a.split(" ",1)
['hello', 'world to you']>>> a.split(" ",2)
['hello', 'world', 'to you']
10）join() 函数用于将序列中的元素以指定的字符连接生成一个新的字符串。
语法：str.join(sequence)
str：指定字符 sequence:序列名
>>> a,b=(1,2,3,4,5),['a','b','c','d']>>> "".join(b)'abcd'
>>> "".join(a)
Traceback (most recent call last):
File"", line 1, in TypeError: sequence item0: expected string, intfound>>> print(" ".join('%s' %id for id ina))1 2 3 4 5
>>> " ".join('%s' %id for id ina)'1 2 3 4 5'
注：若序列中元素包含数字，则join()会报错。需遍历序列中元素，将之转化成字符串。这样就能成功输出数字结果。
11）remove()函数，删除列表中的某个元素
>>> b=[1,2,3]>>> b.remove(2)>>>b
[1, 3]
Python的序列类型：字符串、列表、元组
7、元组（tuple）
Python 中元组用圆括号 () 括起来的，其中的元素之间用逗号隔开。
1)元组的创建
>>> a=() #创建空元组>>>type(a)
>>> b=(1)>>>type(b)
>>> b=(1,) #创建元组时，元素的数量必须大于1，只有1个元素是整型int,不是元组型>>>type(b)
>>> c=1,'q',[1,2] #多种数据类型组合在一起，是元组型>>>type(c)
2）元组也是序列类型，也存在索引和切片操作
>>> c=1,'q',[1,2]>>>type(c)
>>> c[1]'q'
>>> c[2]
[1, 2]>>> c[2][0] #单独提取元素中的小元素1
>>> c[2][1]2
3) 元组操作
元组中的元素不允许修改和删除，可以对元组进行拼接（+），也使用del语句来删除整个元组
>>> tup1 = (12, 34.56)>>> tup2 = ('abc', 'xyz')>>> tup1+tup2
Traceback (most recent call last):
File"", line 1, in TypeError: can only concatenate tuple (not"list") to tuple>>> tup1+tup2
(12, 34.56, 'abc', 'xyz')>>> tup3=tup1+tup2>>>tup3
(12, 34.56, 'abc', 'xyz')>>>del tup3>>>tup3
Traceback (most recent call last):
File"", line 1, in NameError: name'tup3' isnot defined
注：元组拼接的数据类型必须相同，否则拼接不成功。
>> tup1,tup2=(1,2,3),[2,'qw','c']>>> tup3=list(tup1) #数据类型强制转换，转换成列表>>> tup3+tup2
[1, 2, 3, 2, 'qw', 'c']
8、字典（dict）
Python中字典由花括号 {} 加键值对组成，每个键值对(key：value) 用冒号 : 隔开，每个对之间用逗号(,)分割，格式如下所示：
dict ={key1 :value1,key2 :value2,key3 :value3 }
键是唯一的不能重复，所以可以用数字，字符串或元组充当，而用列表就不行。值不唯一。
1）字典创建
>>> a={} #创建空字典>>> a["key1"]=12#给字典中添加键值对>>>a
{'key1': 12}>>> b=dict(key1=32,key2=43) #利用dict()函数创建字典>>>b
{'key2': 43, 'key1': 32}>>> c=(['q','w'],[1,2])>>> c=dict(c) #dict()函数加元组构成字典>>>c
{'q': 'w', 1: 2}
以上方法得到的还是原来的字典，即在字典上操作
Python 字典 fromkeys() 函数，创建一个新字典
语法： dict.fromkeys(seq, value)
以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
参数
seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）的值。
返回值
该方法返回一个新字典。
>>> d= {}.fromkeys(("q","w"),(1,2)) #>>>c
{'q': 'w', 1: 2}>>>d
{'q': (1, 2), 'w': (1, 2)}
2）基本操作：
len(d)，返回字典(d)中的键值对的数量
d[key]，返回字典(d)中的键(key)的值,若键不存在，则报错
d.get(key)，得到键key的值，若键不存在，则返回None
d[key]=value，将值(value)赋给字典(d)中的键(key)
del d[key]，删除字典(d)的键(key)项（将该键值对删除）
d.clear() 函数，清空字典
key in d，检查字典(d)中是否含有键为key的项
str(d),输出字典，以可打印的字符串表示。
>>> a={1:12,2:13,3:14}>>> a.[4]
File"", line 1a.[4]^SyntaxError: invalid syntax #dict[key]与dict.get(key)的区别>>> a.get(4)>>>
>>> print(a.get(4))
None
copy()函数，复制新的变量 dict.copy()
>>> q=d.copy() #copy后在新变量上操作不影响原来的变量>>>q
{'q': (1, 2), 'w': (1, 2)}>>>id(d)139753898228264
>>>id(q)139753942536832
>>> w=d #在原来变量上操作>>>id(w)139753898228264
3）setdefault() 函数和 get()类似, 得到键的值，如果键不存在于，则添加键并将值设为默认值None。
语法：dict.setdefault(key,default=None)
>>>a
{1: 12, 2: 13, 3: 14}>>> a.setdefault(4)>>>a
{1: 12, 2: 13, 3: 14, 4: None}>>> a.setdefault(5,16)16
>>>a
{1: 12, 2: 13, 3: 14, 4: None, 5: 16}
4）items()和iteritems()函数
items()函数，将字典以列表形式返回，列表中的元素是由字典中的键和值组成的元组
>>> b={1: 12, 2: 13, 3: 14, 4: None, 5: 16}>>>b.items()
[(1, 12), (2, 13), (3, 14), (4, None), (5, 16)]>>> b={1: 12, 7: 13, 3: 14, 4: None, 5: 16}>>>b.items()
[(1, 12), (3, 14), (4, None), (5, 16), (7, 13)]
iteritems()函数，将字典返回成迭代器，是一个'dictionary-itemiterator'类型，不过这种迭代器类型的数据不能直接输出，必须用list()转换一下，才能看到里面的真面目。
>>> b={1: 12, 7: 13, 3: 14, 4: None, 5: 16}>>>b.items()
[(1, 12), (3, 14), (4, None), (5, 16), (7, 13)]>>> c=b.iteritems()>>>c
>>>list(c)
[(1, 12), (3, 14), (4, None), (5, 16), (7, 13)]
5）keys()和values()函数
>>> b={1: 12, 7: 13, 3: 14, 4: None, 5: 16}>>>b.keys() #提取字典中的键
[1, 3, 4, 5, 7]>>>b.values() #提取字典的值
[12, 14, None, 16, 13]
6）pop()和popitem()函数
pop(key[,default])函数 ，删除字典给定键 key 及对应的值，返回值为被删除的值，key必须写
key: 要删除的键值
default: 如果没有对应key值，返回default值，[]内为可选
popitem()函数，随机删除字典中一对键和值。并返回该键值对。若字典为空，就报出 KeyError 异常。
>>> b={1: 12, 7: 13, 3: 14, 4: None, 5: 16}>>>b.popitem()
(1, 12)>>> b.pop(7)13
7) has_key() 函数，判断字典中是否存在某个键，等同于 "key in dict"
>>> b={1: 12, 7: 13, 3: 14, 4: None, 5: 16}>>> b.has_key(1)
True>>> 1 inb
True
9、集合（set）
集合创建用花括号 { } 或者 set() 函数。
注意：
创建一个空集合必须用set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合中的元素无序，不可重复。
不推荐使用花括号{}创建集合，因为Python难以分辨是字典还是集合
set()函数可以创建一个无序不重复的元素集，这个函数至多可以传一个参数，否则会报错；可以传比如串一个字符串或者一个列表，只含有一个参数
>>> a=set("A",12)
Traceback (most recent call last):
File"", line 1, in TypeError:set expected at most 1 arguments, got 2#实例中传了2个参数，所以会报错>>> a=set("Asdad")
>>> a=set(["["a","b"]","q","w","e"])
File "", line 1
a=set(["["a","b"]","q","w","e"])
^
SyntaxError: invalid syntax
>>> a=set(['["a","b"]',"q","w","e"]) #单引号和双引号配合使用，不能单引号嵌套单引号，或者双引号嵌套双引号
1）list()和set()能够实现两种数据类型之间的转化。
2）基本操作
set.add(元素) 向set集合中添加元素
set1.update(set2) 将集合set2更新到集合set1中
>>> a.add("q")>>>aset(['A', 1, 2, 'q'])>>> b=set()>>>b.update(a)>>>bset(['A', 1, 2, 'q'])>>>c.update(a)
Traceback (most recent call last):
File"", line 1, in AttributeError:'dictionary-itemiterator' object has no attribute 'update'# 注得先创建集合才能使用update，否则会报错，字典也是一样，得先创建出存在的字典
set.pop()函数，任意选一个元素删除并将这个值返回。pop()不能有参数，否则报错。此外,如果set是空的了,也报错。
set.remove(obj)函数，删除指定元素obj,该元素必须是set中的元素,否则就报错。
set.discard(obj)函数，删除指定元素obj，obj如果是set中的元素,就删除,如果不是,就什么也不做。
set.clear()函数，清空集合中的所有元素，得到空集合。
3) set()创立的集合都是可原处修改的集合，即里面的元素可变；frozenset()创立的集合不能在原处修改，里面的元素不可变。
>>> a=frozenset()>>>type(a)
4）判断集合A与集合B的关系
>>> a=set(['q', 'w', 'e', 'r'])>>> b=set(['q', 'w'])>>> b
True>>>b.issubset(a) #或者用这种方法，判断c是否是a的子集
True>>>a.issuperset(c) #判断a是否是c的超集
True>>> a |b #并集，可以有两种方式，结果一样set(['q', 'w', 'e', 'r'])>>>a.union(b)set(['q', 'w', 'e', 'r'])>>> a &b #交集，两种方式，等价set(['q', 'w'])>>>a.intersection(b)set(['q', 'w'])>>> a -b #A相对B的差（补）set('e', 'r'])>>>a.difference(b)set(['e', 'r'])>>> c=set(['q', 'w','s']) #A、B的对称差集>>>a.symmetric_difference(c)set(['s', 'r', 'e'])
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
