Python基础之数据类型

一、字符串

　　定义：它是一个有序的字符的集合，用于存储和表示基本的文本信息，' '或" "中间包含的内容称之为字符串
　　特性：
　　　　1.只能存放一个值
　　　　2.不可变
　　　　3.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
　　补充：
　　　　1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l\thf'
　　　　2.unicode字符串与r连用必需在r前面，如name＝ur'l\thf'

　　字符串的创建：

　　"hello world"

　　字符串常用操作：

　　　　1、移除空白：

name = "    michael,egon,jack"
print(name.strip())  #去掉行头和尾部的空格
"michael,egon,jack"  #输出结果

　　　　2、分割：

name = "michael,egon,jack"
print(name.split(",")) #分割，以","为分隔符把一个字符串分割成列表
['michael', 'egon', 'jack'] #输出结果

　　　　3、长度：

name = "michael,egon,jack"
print(len(name)) #统计字符串的长度
17  #输出结果

　　　　4、索引：

name = "michael,egon,jack"
print(name.index("a")) #索引
4  #输出结果，找到第一个对应的值的下标返回值

　　　　5、切片：

name = "michael,egon,jack"
print(name[0:7])  #取出第一个名字，就是在[]里以":"分割左右分别写出元素对应的下标，默认从左往右取。记住“顾头不顾尾”
michael  #输出结果
print(name[8:12])  #取出第二个名字
egon  #输出结果
print(name[-4:])  #取出最后一个名字，从后面往前面数元素的下标，有几个元素，就写-（几个） 注意：要记住“顾头不顾尾”
jack  #输出结果

　　　　6、步长：

　　string[start:end:step]的序列切片中，第一个“:”隔离了 起始索引 和 结束索引，第二个“：”隔离了 结束索引 和 步长

• step为正，则从左到右切片，如果start > end，则为空
• step为负，则从右到左切片，如果start < end，则为空
• start和end非同时为空，前者表示最开始的一个位，后者表示一直到最后一个，同时为空的时候，表示取所有。至于方向，还是取决于step的值。

　　可以总结一句规律：step为正表示从左到右切片，反之为从右到左，然后根据index依次切片。

name = "michael,egon,jack"
print(name[::3]) #取所有，step为3
mhlg,c #输出结果
print(name[12:3:-3]) #取索引3---12的元素，从右到左切片step为3 注意：记住“顾头不顾尾”
,gl  #输出结果

 二、列表

　　定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
　　特性：
　　　　1.可存放多个值
　　　　2.可修改指定索引位置对应的值，可变
　　　　3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

　　列表的创建：

list_test=[’afg‘,12,'ok']
或
list_test=list('abc')
或
list_test=list([’afg‘,12,'ok'])　　

　　列表的常用操作：

　　1、索引：

names = ["michael","egon","jack","alex","tom"]
print(names.index("jack")) #检索“jack”的下标值
2 #输出结果

　　2、切片：

names = ["michael","egon","jack","alex","tom"]
print(names[0:4])#通过下标找出列表中的元素0---3给切出来
['michael', 'egon', 'jack', 'alex'] #输出结果

　　3、追加：

names = ["michael","egon","jack","alex","tom"]
names.append("rose") #追加内容
print(names) #输出列表names
['michael', 'egon', 'jack', 'alex', 'tom', 'rose'] #输出结果，最后一个位追加的内容

　　还有一种追加的方式：insert() 函数用于将指定对象插入列表的指定位置。

　　注意：该方法没有返回值，但会在列表指定位置插入对象。

names = ["michael","egon","jack","alex","tom"]
names.insert(2,"jerry") #可以在指定位置添加元素，因为没有返回值，所以此时不用打印输出
print(names) #打印输出结果
['michael', 'egon', 'jerry', 'alex', 'jack', 'tom'] #输出结果

　　4、删除：

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

names = ["michael","egon","jack","alex","tom"]
print(names.pop(3)) #删除，指定删除下标位为3的元素
alex #输出结果
print(names.pop()) #默认删除最后一个
tom #输出结果

　　第二种方法：remove() 函数用于移除列表中某个值的第一个匹配项。该方法没有返回值但是会移除两种中的某个值的第一个匹配项。

names = ["michael","egon","jack","alex","tom","egon"]
print(names.remove("egon")) #删除egon，匹配列表中第一个对应的元素，后面的不会影响
None #输出结果
print(names.remove("rose")) #删除rose，因为列表没有这个元素，so，会报错“rose”没在列表中
print(names) #输出删除后的names的值
['michael', 'jack', 'alex', 'tom', 'egon'] #输出的结果

　　第三种方法：使用 del 语句来删除列表的的元素。

names = ["michael","egon","jack","alex","tom",'egon']
del names[3:5] #实际删除下标位3到5的元素，注意：最后一个5删不了，记住“顾头不顾尾” 
['michael', 'egon', 'jack', 'egon'] #输出结果
del names[-3:] #删除倒数第三至最后一个
['michael', 'egon', 'jack'] #输出结果

　　还有一种 clear() 函数用于清空列表，该方法没有返回值，类似于del list[:]。

names = ["michael","egon","alex","jack","tom"]
names.clear() #清空列表names
print("清空后的列表:",names) #输出打印结果
清空后的列表: [] #注意：此时列表names里的元素被清空了，但是列表names还是存在的

　　5、长度：

　　len() 方法返回列表元素个数。

names = ["michael","egon","jack","alex","tom"]
print(len(names)) #统计列表的元素个数
5 #输出结果

　　6、循环：　　

　　第一种：这个迭代names,并且每次迭代取names的值到 i 这个变量里。

names = ["michael","egon","jack","alex","tom"]
for i in names:
    print(i)
        michael #以下这几个都是列表里的值
        egon
        jack
        alex
        tom    

　　第二种：这个也是类似,只是每次迭代取索引的值到 i 这个变量里。

names = ["michael","egon","jack","alex","tom"]
for i in range(len(names)):
    print(i,names[i])
        0 michael
        1 egon
        2 jack
        3 alex
        4 tom        

　　总结：这两种用起来区别不大,用第一个的话是用不到索引的时候用,后面这个是用到索引的时候用,其他的实际用那个看个人需求了。

　　7、包含：在python中可以通过in和not in关键字来判读一个list中是否包含一个元素。

names = ["michael","egon","jack","alex","tom"]
if "michael" in names: #判断“michael”是否在names列表里
    print("%s in the names"%("michael")) #在的话，打印输出结果
if "rose" not in names: #判断“rose”是否在names列表里
    print("%s is not in the names"%("rose")) #不在的话，打印输出结果
        michael in the names #输出结果
        rose is not in the names #输出结果

三、元组 

　　定义：与列表类似，只不过［］改成（）。

　　特性：

　　　　1、可存放多个值

　　　　2、不可变

　　　　3、按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

 　　元组的创建： （注意：元组中只包含一个元素时，需要在元素后面添加逗号）

ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))
print(ages)
(11, 22, 33, 44, 55) #输出结果
a = (11,) #只有一个元素的时候，后面要加“,”标识
print(a)
(11,) #输出结果

　　元组常用操作：

　　1、索引：

ages = (11,22,33,"a","b","c")
print(ages.index("a")) #索引"a"元素的下标
3 #输出结果

　　2、切片：

ages = (11,22,33,"a","b","c") #注意：在取值的时候一定要记住“顾头不顾尾”
print(ages[:3]) #取元组的最开始到下标索引为2的元素
(11, 22, 33) #输出结果
print(ages[2:4]) #取下标索引为2到3的元素
(33, 'a') #输出结果
print(ages[-3:]) #取元组的后三个元素
('a', 'b', 'c') #输出结果
print(ages[-3:-1]) #取从元组的倒数第三个元素开始取到倒数第一个（不包含最后一个）
('a', 'b') #输出结果

　　3、循环：

　　同上列表的循环

　　4、长度

　　len() 方法返回元组元素个数。

ages = (11,22,33,"a","b","c")
print(len(ages)) #统计元组元素的个数
6 #输出结果

　　5、包含：（同列表一样）

ages = (11,22,33,"a","b","c")
if 22 in ages: #判断22是否在names列表里
    print("%s in the ages"%(22)) #在的话，打印输出结果
if "e" not in ages: #判断“e”是否在names列表里
    print("%s is not in the names"%("e")) #不在的话，打印输出结果
22 in the ages #输出结果
e is not in the names #输出结果

　　6、删除：

ages = (11,22,33,"a","b","c")
del ages #删除元组
print(ages) #打印输出元组
NameError: name 'ages' is not defined #输出报错，此元组不存在

四、字典

　　定义：字典是另一种可变容器模型，且可存储任意类型对象。键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

　　　　｛key1:value1,key2:value2｝,key-value结构，key必须可hash

　　特性：

　　　　1.可存放多个值

　　　　2.可修改指定key对应的值，可变

　　　　3.无序

　　字典的创建：

person = {"name": "michael", 'age': 18}
person = dict(name='michael', age=18)
person = dict({"name": "michael", 'age': 18})
person = dict((['name','michael'],['age',18]))
{}.fromkeys(seq,100) #不指定100默认为None

　　注意：

dic = {}.fromkeys(["k1","k2"],11) #创建字典dic
{'k1': 11, 'k2': 11} #输出结果

　　 字典的常用操作：　

• len(d)返回d中项（键-值对）的数量；
• d[k]返回关联到k上的值；
• d[k]=v将值v关联到键k上；
• del d[k]删除键为k的项；
• k in d检查d中是否有含键为k的项。

 

　　1、clear

　　clear方法清除字典中所有的项，这是个原地操作，无返回值（或者说返回none）。

dic = {"k1":"v1","k2":"v2","k3":"v3"}
dic.clear() #清空字典
print(dic) #打印输出
{} #输出结果

　　2、cope

　　copy方法返回一个具有相同键-值对的新字典（这个方法实现的是浅复制，因为值本身是相同的，而不是副本）

　　在副本中替换值时，原始字典不受影响，但是如果修改了某个值，原始字典会改变。

>>> x = {'a':1,'b':[2,3,4]}
>>> y = x.copy()
>>> y['a'] = 5 #替换key对应value值
>>> y['b'].remove(3) #修改了“b”对应的value值
>>> y 
 {'a':5,'b':[2,4]} #被修改的字典
>>> x
 {'a':1,'b':[2,4]} #原字典输出的结果，替换的值没变，修改的变了

　　避免这个问题的方法是使用深度复制-deepcopy()，复制其包含所有的值。

>>> x = {'a':1,'b':[2,3,4]}
>>> y = x.copy()
>>> z = x.deepcopy() #x深cope成z
>>> x['a'].append(5) #对原文件进行操作
>>> y 
 {'a':1,5,'b':[2,3.4]} #浅cope的值发生了改变
>>> z
 {'a':1,'b':[2,3,4]} #深cope的值没有发生改变

　　3、get：

　　get方法是个更宽松的访问字典项的方法。当使用get访问一个不存在的键时，会得到None值。还可以自定义“默认”值，替换None。

>>> d = {}
>>> print d.get('name') #默认为None
None
>>> d.get("name",'N/A') #自定义为'N/A'
'N/A'
>>> d[''name] = 'Eric' #给字典d赋值
>>> d.get('name') #当键存在，输出键对应的值
'Eric' #输出结果

　　4、has_key

　　has_key方法可以检查字典中是否含有给出的键。d.has_key(k)

>>> d = {}
>>> d.has_key('name')
False

　　5、items和iteritems

　　items方法将所有的字典项以列表方式返回，但是列表中的每一项(键,值)返回时并没有特殊的顺序。

　　iteritems方法的作用大致相同，但是会返回一个迭代器对象而不是列表：

>>> d = {'a':1,'b':2,'c':3}
>>>d.items
[('a',1),('b',2),('c',3)]
>>> it = d.iteritems()
>>> it
<dictionary-iteritems object at 169050>
>>> list(it)
[('a',1),('b',2),('c',3)]

　　6、pop

　　pop方法用来获得对应给定键的值，然后将这个键-值对从字典中移除。

>>> d = {'a':1,'b':2,'c':3}
>>> d.pop('a') #删除a及对应的值
>>> d
{'b':2,'c':3} #输出结果

　　7、popitem

　　popitem方法会弹出随机项，并没有顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效了。

>>> d = {'a':1,'b':2,'c':3}
>>> d.popitem() #随机删除一个键、值
>>> d
{'a':1,'c':3} #输出结果

　　8、setdefault

　　setdefault方法在某种程度上类似于get方法，就是能够获得与给定键相关联的值，还能在字典中不含有给定键的情况下设定相应的键值。

>>> d = {}
>>> d.setdefault('name','N/A')
'N/A'
>>> d
{'name': 'N/A'}
>>> d.setdefault('name',A)
'N/A'

　　9、update

　　update方法可以利用一个字典项更新另一个字典。提供的字典项会被添加到旧的字典中，若有相同的键则会进行覆盖。

>>> d = {'a':1,'b':2,'c':3}
>>> x = {'a':5,'d':6}
>>> d.update(x)
>>> d
{'a': 5, 'c': 3, 'b': 2, 'd': 6} #遇到相同的键会覆盖对应的value的值

　　10、values

　　values方法以列表的形式返回字典中的值（itervalues返回值的迭代器），与返回键的列表不同的是，返回值列表中可以包含重复的元素。

>>> d = {}
>>> d[1]=1
>>> d[2]=2
>>> d[3]=3
>>> d[4]=1
>>> d
{1: 1, 2: 2, 3: 3, 4: 1}
>>> d.values()
[1, 2, 3, 1] #值可以重复

　　五、集合

　　定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key

　　基本功能：是进行成员关系测试和删除重复元素。

　　特性：集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

　　可以使用大括号({})或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

　　集合分类：可变集合、不可变集合

　　　　可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素

　　　　不可变集合(frozenset)：与上面恰恰相反

　　集合的创建：

　　由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建

{1,2,3,1}
或
定义可变集合set
>>> set_test=set('hello')
>>> set_test
{'l', 'o', 'e', 'h'}
改为不可变集合frozenset
>>> f_set_test=frozenset(set_test)
>>> f_set_test
frozenset({'l', 'e', 'h', 'o'}) 

　　访问集合：

　　由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。

student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'})
print("Tom" in student) #判断“Tom”是否在集合student中
True #真，在集合student里
print("Egon" in student) #判断“Egon”是否在集合student中
False #假，不在集合student里
for i in student: #循环输出集合student中的所有元素
    print(i) #以下是输出结果
        Mary
        Jim
        Tom
        Jack
        Rose

　　集合常用操作：关系运算

　　1、in 和 not in：

student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'})
print(student)   # 输出集合，重复的元素被自动去掉
{'Mary', 'Rose', 'Tom', 'Jim', 'Jack'} #输出结果
# 成员测试
if('Rose' in student) :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')

　　2、等于（==）和不等于（!=）:

a = {1,2,3}
b = {1,2,3,4,5}
print(a == b)
False
print(a != b)
True

　　3、大于(>)与小于(<)和大于等于(>=)于小于等于(<=)：注意：小于（用函数表示 .issubset()） 大于（用函数表示 .issuperset()）

a = {1,2,3}
b = {1,2,3,4,5}
print(a <= b) #判断a小于或等于b
True
print(a < b) #判断a小于b
print(a.issubset(b)) #a是b的子集
print(b.issuperset(a)) #b是a的超集
True
print(a >= b) #判断a大于或等于b
False
print(a > b) #判断a大于b
False

　　4、交集：intersection()，简写符(&)

a = {1,2,3}
b = {1,2,3,4,5}
print(a.intersection(b))  #交集
print(a & b) #交集的简写
{1, 2, 3} #输出a与b的交集

　　5、并集：union()，简写符( | )

a = {1,2,3}
b = {1,2,3,4,5}
print(a.union(b)) #并集 两个合在一起 
print(a | b) #并集的简写 
{1, 2, 3, 4, 5} #输出a与b的并集

　　6、差集：difference()，简写符（-）

a = {1,2,3}
b = {1,2,3,4,5}
print(a.difference(b)) #差集 a相对于b不一样的打印出a有b没有的
print(a - b) #差集的简写
set() #因为a不包含b，so，为空
print(b.difference(a)) #差集 b相对于a不一样的打印出b有a没有的
print(b - a) #差集的简写
{4, 5} #打印出相差的部分

　　7、对称差分：symmetric_difference()，简写符（^）

a = {1,2,3,6,7}
b = {1,2,3,4,5}
print(a.symmetric_difference(b)) #对称差分 把a和b中不在的都打印出来
print(a ^ b) #对称差分的简写
{4, 5, 6, 7} #输出结果

　　注意：集合之间and,or

a = {1,2,3,6,7}
b = {1,2,3,4,5}
print(a and b) #取b的值
{1, 2, 3, 4, 5}
print(a or b) #取a的值
{1, 2, 3, 6, 7}

　　8、子集和超集： .issubset()  和  .issuperset()

a = {1,2,3}
b = {1,2,3,4,5}
print(a.issubset(b)) #a是b的子集 ，是真为True，反之亦然。
True
print(a.issuperset(b)) #b是a的超集， 是假为False，反之亦然。
False

　　集合更新：

　　可使用以下内建方法来更新：注意：只有可变集合才能更新。

• a.add()
• a.update()
• a.remove()
• a.discard()
• a.pop()

a = {1,2,3,6,7}
a.add(8) #在集合a里添加一个元素“8”
print(a) #打印输出
{1, 2, 3, 6, 7, 8} #输出结果

a = {1,2,3,6,7}
c = {6,,7,8,9}
a.update(c) #更新a集合，将c集合的元素添加到a中，注意：集合是天然去重的。
print(a)
{1, 2, 3, 6, 7, 8, 9}

a = {1,2,3,6,7}
a.remove(6) #移除集合a中的元素“6”，如果被移除的元素不存在时，会报错。
print(a)
{1, 2, 3, 7}

a = {1,2,3,6,7}
a.discard(9) #删除指定元素，但是如果要删除的不在集合里不会报错。
print(a)
{1, 2, 3, 7}

a = {1,2,3,6,7}
print(a.pop()) #随机删除
1 #随机删除的结果