人生苦短，我用python，基础(2) --- 常用数据类型及其操作

写在前面，该文章是博主在学习python时，参考金角大王的文章写的:Python之路,Day2 - Python基础2

本节内容

1、列表(list)、元组(tuple)操作

2、字符串(str)操作

3、字典(dict)操作

4、集合(set)操作

一. 列表(list)、元组(tuple)操作

列表是python最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改的操作

1、列表(list)操作

1、有序的集合 
2、通过偏移来索引，从而读取数据 
3、支持嵌套 
4、可变的类型

(1)定义列表

>>> names = ['Jin','Yin','Tong']

(2)通过下标访问列表中的元素，下标从0开始

 
       >>> names[ 
       0 
       ] 
      
       'Jin' 
      
       >>> names[ 
       2 
       ] 
      
       'Tong' 
      
       >>> names[ 
       - 
       1 
       ] 
      
       'Tong' 
      
       >>> names[ 
       - 
       2 
       ]  
       #还可以倒着取,-1表示最后一个 
      
       'Yin'

(3)切片：取多个元素

list取值的一种方式,  取值是顾头不顾尾，注：切片的步长默认为1，不可为0

索引方式：

正向索引 
反向索引 
默认索引

>>> names = ["Jin","Yin","Tong","Rain","Tom","Amy"]
>>> names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4
['Yin', 'Tong', 'Rain']
>>> names[1:-1] #取下标1至-1的值，不包括-1 (-1表示最后一个元素)
['Yin', 'Tong', 'Rain', 'Tom']
>>> names[0:3]    #下标从0开始
['Jin', 'Yin', 'Tong']
>>> names[:3] #如果是从头开始取，0可以忽略，跟上句效果
['Jin', 'Yin', 'Tong']
>>> names[3:] #如果想取最后一个，必须不能写-1，只能这么写
['Rain', 'Tom', 'Amy'] 
>>> names[3:-1] #这样-1就不会被包含了
['Rain', 'Tom']
>>> names[0::2] #后面的2是代表，每隔一个元素，就取一个
['Jin', 'Tong', 'Tom']
>>> names[::2] #和上句效果一样
['Jin', 'Tong', 'Tom']

(4)追加

>>> names
['Jin', 'Yin', 'Tong', 'Rain', 'Tom', 'Amy']
>>> names.append("我是新来的")
>>> names
['Jin', 'Yin', 'Tong', 'Rain', 'Tom', 'Amy', '我是新来的']

(5)插入

>>> names
['Jin', 'Yin', 'Tong', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.insert(0,"我强行从Jin前面插入")
>>> names
['我强行从Jin前面插入', 'Jin', 'Yin', 'Tong', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.insert(5,"从Rain后面插入试试新姿势")
>>> names
['我强行从Jin前面插入', 'Jin', 'Yin', 'Tong', 'Rain', '从Rain后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

(6) 删除

del 我们通过索引删除指定位置的元素
remove 移除列表中指定值的第一个匹配值。如果没找到的话，会抛出异常。
pop 返回最后一个元素，并从list中删除她，pop(2),加入索引就删除指定的元素

>>> names

['我强行从Jin前面插入', 'Jin', 'Yin', 'Tong', 'Rain', '从Rain后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

>>> del names[2]        # 删除指定位置的元素
>>> names
['我强行从Jin前面插入', 'Jin', 'Tong', 'Rain', '从Rain后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> del names[4]
>>> names
['我强行从Jin前面插入', 'Jin', 'Tong', 'Rain', 'Tom', 'Amy', '我是新来的']
>>>
>>> names.remove('Tom')        # 删除指定的元素
>>> names
['我强行从Jin前面插入', 'Jin', 'Tong', 'Rain', 'Amy', '我是新来的']
>>> names.pop()    #删除列表的最后一个元素    # names.pop()#默认删除最后一个元素  
'我是新来的'                                 # names.pop(2)#pop写入索引，就删除指定的元素
>>> names
['我强行从Jin前面插入', 'Jin', 'Tong', 'Rain', 'Amy']

(7)修改：用下标的方式给对应下标重新赋值

>>> names
['我强行从Jin前面插入', 'Jin', 'Tong', 'Rain', 'Amy']
>>> names[2] = 'JinJin'
>>> names
['我强行从Jin前面插入', 'Jin', 'JinJin', 'Rain', 'Amy']
>>> names[1] = '该换人了'
>>> names
['我强行从Jin前面插入', '该换人了', 'JinJin', 'Rain', 'Amy']

(8)扩展

>>> names
['我强行从Jin前面插入', '该换人了', 'JinJin', 'Rain', 'Amy']
>>> b = [1,2,3]
>>> b
[1, 2, 3]
>>> names.extend(b)
>>> names
['我强行从Jin前面插入', '该换人了', 'JinJin', 'Rain', 'Amy', 1, 2, 3]

(9)拷贝:简单版

>>> names
['我强行从Jin前面插入', '该换人了', 'JinJin', 'Rain', 'Amy', 1, 2, 3]
>>> names_copy = names.copy()
>>> names_copy
['我强行从Jin前面插入', '该换人了', 'JinJin', 'Rain', 'Amy', 1, 2, 3]

关于拷贝，想了解更多请：python深浅拷贝详解

(10)统计

>>> names
['JinJin', '该换人了', 'JinJin', 'Rain', 'Amy', 1, 2, 3]
>>> names.count("JinJin")    # count 查找元素出现多少次
2

(11)排序&翻转

# names.sort()            #升序
# names.sort(reverse=True)#sort 默认升序，加上reverse=True，直接降序排序

>>> names
['Amy', 'JinJin', 'JinJin', 'Rain', '该换人了', 1, 2, 3]
>>> names.sort()    #排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'str'    #python3 里不同数据类型不能放在一起排序
>>> names[-1] = '3'
>>> names[-2] = '2'
>>> names[-3] = '1'
>>> names
['Amy', 'JinJin', 'JinJin', 'Rain', '该换人了', '1', '2', '3']
>>> names.sort()
>>> names
['1', '2', '3', 'Amy', 'JinJin', 'JinJin', 'Rain', '该换人了']
>>>
>>> names.reverse()    #翻转
>>> names
['该换人了', 'Rain', 'JinJin', 'JinJin', 'Amy', '3', '2', '1']

(12)获取下标

# index 查询元素的下标,如果列表里面有重复的元素，只能显示出第一个索引

>>> names
['该换人了', 'Rain', 'JinJin', 'JinJin', 'Amy', '3', '2', '1']
>>> names.index("JinJin")
2    #只返回第一个出现的下标

(13)判断某个元素是否在列表里

>>> names
['该换人了', 'Rain', 'JinJin', 'JinJin', 'Amy', '3', '2', '1']
>>> 'Rain' in names
True
>>> 'rain' in names
False

(14）添加操作的区别
+ 生成一个新的列表
extend 接收参数并将该参数的每个元素都添加到原有的列表中，原地修改列表而不是新建列表
append 添加任意对象的引用到列表的末端

insert 插入任意对象的引用到列表中，可以控制插入位置

1）+ 的用法

# + 的用法
>>> name1 = [1,1,1]
>>> name1
[1, 1, 1]
>>> name2 = [2,2,2]
>>> name2
[2, 2, 2]
>>> name1+name2
[1, 1, 1, 2, 2, 2]
>>> name1
[1, 1, 1]
>>> name2
[2, 2, 2]

2）extend的用法

>>> name1
[1, 1, 1]
>>> name2
[2, 2, 2]
>>> name1.extend(name2)    # 把name的元素按原来的位置添加到name1的末尾(相当于对name2进行迭代再append到name1)
>>> name1
[1, 1, 1, 2, 2, 2]
>>> name2
[2, 2, 2]

3） append 添加任意对象的引用到列表的末端

>>> name1 = [1,1,1]
>>> name2 = [2,2,2]
>>> name1.append(name2)    #append把其参数name2作为一个元素添加到name1到的末尾
>>> name1
[1, 1, 1, [2, 2, 2]]

4）insert 插入任意对象的引用到列表中，可以控制插入位置

>>> name1=[1,1,1]
>>> name2
[2, 2, 2]
>>> name1.insert(0,name2) #insert把第二个参数name2作为一个元素插入到name1指定的第一个参数的索引所对应的位置上
>>> name1
[[2, 2, 2], 1, 1, 1]

2、元组(tuple)操作
元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表，用小括号括起来表示。

>>> names = ('ddd' 'aaa','ccc','hhh')
>>> names
('dddaaa', 'ccc', 'hhh')
>>> names(1) = 111        #不能修改
  File "<stdin>", line 1
SyntaxError: can't assign to function call
>>> names.count('ccc')
1
>>> names.index('ccc')
1

它只有两个方法，为count和index。

注意：当想表示只有一个元素的元组时，要在元素后面加个","，不然会把小括号作为括号运算符使用。

>>> name = (11,)        #表示有一个元素的元组
>>> name
(11,)
>>> name1 = (11)        # 表示对11进行括号运算并赋值给name1
>>> name1
11
>>> name2 = ([11,22,33],)
>>> name2
([11, 22, 33],)
>>> name3 = ([11,22,33])
>>> name3
[11, 22, 33]

二. 字符串(str)操作

特性：不可修改(不可改变)，也就是说在用python创建一个字符串后，就不能把该字符串的某一部分改变。

(1)str_obj.capitalize() #返回一个首字母大写的字符串

>>> name = 'david'
>>> print(name.capitalize())
David

(2)center() #返回一个把原字符串放在中间，默认两边放空格(可以放其他字符)的字符串。

center(width, fillchar)
#返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格

>>> name
'david'
>>> print(name.center(20))        #使用默认方式
       david
>>> print(name.center(20,'-'))    #自己指定填充物，20为接收一个数字来表示返回字符串的长度
-------david--------

(3) count(...) #

| S.count(sub[, start[, end]]) -> int

| # 返回子字符串在S中出现的次数，可以指定起始位置

	
count(str, beg= 0,end=len(string))
# 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

>>> name = "aabbaaccddhhlkj"
>>> print(name.count('aa'))        // 查找aa串在name中出现的次数
2
>>> print(name.count('a'))
4

(4) encode() #将字符串编码成bytes格式,并将之返回

	
encode(encoding='UTF-8',errors='strict')
# 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'

>>> name = '中文'
>>> print(name.encode('gb2312'))    #以gb2312编码对name进行编码，获得bytes类型对象
b'\xd6\xd0\xce\xc4'
>>> print(name.encode('utf8'))      #以utf8编码对name进行编码，并返回bytes类型对象
b'\xe4\xb8\xad\xe6\x96\x87'
>>> print(name.encode('gbk'))       
b'\xd6\xd0\xce\xc4'

(5) decode(...) #对字符串按给定的编码方式进行解码，如果该字符串在进行压缩时的方式与解码方式不同，则返回错误(即保持编解码方式相同)

bytes.decode(encoding="utf-8", errors="strict")
# Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

>>> name = '中文'
>>> str1 = name.encode('utf8')    #对name按utf-8编码方式编码
>>> print(str1)
b'\xe4\xb8\xad\xe6\x96\x87'
>>> str2 = str1.decode('gbk')    #对str1按gbk方式解码，因为编解码方式不同，所以报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'gbk' codec can't decode byte 0xad in position 2: illegal multibyte sequence
>>> str2 = str1.decode('utf8')    #编解码方式相同，正确解码
>>> print(str2)
中文

(6) endswith(...) # 检查是否以某个串结尾，可以指定位置，返回bool值。做循环的判定条件很有用，免去==

endswith(suffix, beg=0, end=len(string))
# 检查字符串是否以 suffix 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

>>> name
'中文'
>>> name.endswith('文')
True
>>> name.endswith('中')
False

(7) expendtabs() #把字符串中的制表符tab转换为tabsize(参数 )个空格，默认为8个字符

expandtabs(tabsize=8)
# 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

>>> name
'11\t11'
>>> name.expandtabs()    #默认8
'11      11'
>>> name.expandtabs(10)    #指定为10
'11        11'

(8) find() #在字符串中查找子串，返回其下标，找不到则返回-1

	
find(str, beg=0 end=len(string))
# 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1

>>> name = '123456'
>>> print(name.find('1234567'))    #name中不包含串，得到-1
-1
>>> print(name.find('1234'))       #包含，返回下标0(起始),且 有多个也只返回第一个的起始下标
0
>>> print(name.find('4'))          
3

>>> name = '123412341234'    
>>> print(name.find('1234'))    #多个也只返回找到的第一个的起始下标
0
>>> print(name.find('1'))
0

rfind() #查找，返回符合结果的最大下标，即最靠右那个(r就是right的意思) ，找不到返回-1

>>> name = '123412341234'
>>> print(name.rfind('1234'))
8
>>> print(name.rfind('12345'))
-1

(9) format() # 字符串的格式化输出！官方文档，注意format中转移是{}而不是\

format :
    >>> msg = "my name is {}, and age is {}"    #默认按左到右方式填充
    >>> msg.format("dav",22)
    'my name is dav, and age is 22'
    >>> msg = "my name is {1}, and age is {0}"  #指定位置
    >>> msg.format("dav",22)
    'my name is 22, and age is dav'
    >>> msg = "my name is {name}, and age is {age}"    #指定标识
    >>> msg.format(age=22,name="dav")
    'my name is dav, and age is 22'
format_map
    >>> msg.format_map({'name':'dav','age':22})
    'my name is dav, and age is 22'

(10) index() #与find相似，返回寻找的串的第一个下标索引，找不到会报错(find方法找不到返回-1)

index(str, beg=0, end=len(string))
# 跟find()方法一样，只不过如果str不在字符串中会报一个异常.

>>> name = 'adfajjjkkklll'
>>> print(name.index('a'))    #返回查到的匹配的第一个
0
>>> print(name.index('aj'))    
3
>>> print(name.index('kkkk'))    #找不到匹配的串返回错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

rindex() #返回符合寻找的字符串的最后(r就是right)一个串的起始下标，没找到报error

>>> 'AsAsAsA'.rindex('s')        #返回最后一个的下标（最右）
5
>>> 'AsAsAsA'.rindex('ss')        #没有符合的目标，报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

(11) isalnum() #判断字符串中是否全为数字或者字母【并至少有一个字符】，是则返回True。有符号或者没有字符返回False(中文也是字母？)

Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise.

isalnum()
# 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False

>>> name = '09akg'
>>> name.isalnum()    #都是字母和数字，True
True
>>> name = ''
>>> name.isalnum()    #空字符串，False
False
>>> name = '>>>.09dd'    
>>> name.isalnum()    #包含符号，False
False
>>> name = '你好呀'
>>> name.isalnum()    #所以中文也是字符？？？ 反正返回True
True
>>> name = '09a你好'
>>> name.isalnum()
True

(12)一些常用判断

isalpha() #判断是否为全字母,空串时返回False

>>> 'abcd'.isalpha()    #全是字母，True
True
>>> 'abcd123'.isalpha()    #不全是字母，False
False

>>> ''.isalpha()        #空字符串，False
False

isdigit() #判断是数字

>>> '11123'.isdigit()     #全是数字，True
True
>>> '011123'.isdigit()    #以0开头，全是数字，True
True
>>> ''.isdigit()          #空串，False
False
>>> '12jj'.isdigit()      #不全是数字，False
False

islower() #判断是否全是小写字母，数字不影响

>>> 'abcd'.islower()     #全小字母，True
True
>>> 'abCd'.islower()     #不是全小字母，False
False
>>> 'abcd123'.islower()  #数字不影响
True

isupper() #判断时候全是大写字母，数字不影响，空串为False.

isupper()
# 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

isspace() #判断是否为全空白字符【不能是空串】

>>> '    '.isspace()    #全是空白字符，True
True
>>> ''.isspace()        #空串，False
False
>>> '   h   '.isspace()  #不全是空白字符，False
False

istitle() #判断字符串是否是首字母大写，后面全为小写，空串返回False【注意，只能时一个单词的字符串，当出现符号或者数字时，只能继续为符号或数字】

>>> 'Ahhh'.istitle()  #单个词，首字母大写，其余小写，True
True
>>> 'AAhhhh'.istitle()    #不是只有首字母大写，False
False
>>> 'AhhA'.istitle()        
False
>>> 'Ahh,kkk'.istitle()   #中间包含符号，False
False
>>> ''.istitle()           #空串，False
False
>>> 'aAddd'.istitle()       
False
>>> 'A111ddd'.istitle()    #中间出现数字，False
False
>>> 'Addd11'.istitle()     #一数字结尾，True
True
>>> "Addd's".istitle()     #中间包含字符
False

>>> "Addds,,,".istitle()    #后面全是符号，True
True    
>>> "Addds,,,111".istitle()    #后面是符号和数字，True
True
>>> "Addds,,,111'''".istitle()
True

(13) join() #把迭代器中的内容用S作为连接符连接起来！迭代器中内容必须也为子符串！

S.join(iterable) -> string

>>> '@'.join(['aa','AA','aA'])    #把迭代器的内容用@连接起来，成为一个字符串
'aa@AA@aA'
>>> '@&*'.join(['aa','AA','aA'])
'aa@&*AA@&*aA'

>>> '@'.join([11,222,11])        #迭代器的内容也必须为字符串类型，否则出现TypeError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found

(14) swapcase() #对字符串进行大小互换

>>> 'AAaaAAaa'.swapcase()
'aaAAaaAA'

(15) zfill() #左侧以字符0进行填充，在输出整数是常用！接受一个长度的参数

>>> name = 'da'
>>> name.zfill(10)
'00000000da'

(16)title() #返回一个每个单词都大写，其他小写的字符串

>>> 'aaaa'.title()
'Aaaa'
>>> 'aaa,bbb,ccc'.title()
'Aaa,Bbb,Ccc'
>>> 'AA,BBB,cCCC'.title()
'Aa,Bbb,Cccc'

(17) strip() #strip() 方法用于移除字符串头尾指定的字符（默认为空格）。（注意：只是去掉两端符合的字符串，采用贪心的方法，从两端开始找，直到不符合才停下）

str.strip([chars])

>>> '   aa gg    '.strip()        #默认去掉两端的空格
'aa gg'
>>> '   aa gg    '.strip('aa')    #两端没有符合的字符串，所以没变
'   aa gg    '
>>> '   aa gg    '.strip('a')     #两端没有符合的字符串，所以没变
'   aa gg    '
>>> 'aa gg    '.strip('a')        #直到不符合才停下
' gg    '
>>> 'aa gg    '.strip('aa')       
' gg

lstrip()
# 截掉字符串左边的空格或指定字符。
rstrip()
# 截掉字符串右边的空格或指定字符。

(18) split() #经常使用！split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串。且得到的字符串列表中字符串不在包含分隔符。

语法:

str.split(str="", num=string.count(str))

参数: str--分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

num -- 分割次数。

返回值：返回分割后的字符串列表

>>> str = 'this is string example...wow!!!'
>>> print(str.split())
['this', 'is', 'string', 'example...wow!!!']
>>> print(str.split('i',1))
['th', 's is string example...wow!!!']
>>> print(str.split('i'))
['th', 's ', 's str', 'ng example...wow!!!']
>>> str = 'this is string    example...wow!!!'
>>> print(str.split())
['this', 'is', 'string', 'example...wow!!!']

rsplit() #与split()相同，只是从最后边开始分割

>>> print(str.rsplit('i',1))
['this is str', 'ng example...wow!!!']

(19) ljust() #返回一个原字符串左对齐，并用指定字符(默认空格)填充自指定的长度

ljust(width[, fillchar])
# 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

>>> print(name.ljust(10,'-'))
dav-------

rjust() #同ljust()，只是为右对齐

>>> name = 'dav'
>>> print(name.ljust(10,'-'))
dav-------
>>> print(name.rjust(10,'-'))
-------dav

(20) lower() #将字符串转化成小写

>>> 'AaAa'.lower()
'aaaa'

(21) maketrans() #方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

语法：

str.maketrans(intab, outtab)

参数：

intab -- 字符串中要替代的字符组成的字符串。
outtab -- 相应的映射字符的字符串。

>>>intab = "aeiou"
>>>outtab = "12345"
>>>trantab = str.maketrans(intab, outtab)
>>>str = "this is string example....wow!!!"        #intab和outtab是按下标对应
>>>print (str.translate(trantab))
th3s 3s str3ng 2x1mpl2....w4w!!!

(22)max() 和 min()

max(str)
#返回字符串 str 中最大的字母。	
min(str)
#返回字符串 str 中最小的字母。

>>> max('ABCa')
'a'
>>> min('ABCa')
'A'

(23) replace() #对字符串进行替换

replace(old, new [, max])
# 把将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次

参数

old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次

>>> name = 'fhajdfa'
>>> print(name.replace('a','A',1))    #指定次数
fhAjdfa
>>> print(name.replace('a','A'))        #非指定次数
fhAjdfA

(24) splitlines()

splitlines([keepends])
# 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

(25) startswith() #检查字符串开头是否已指定字符串开始，返回bool

startswith(str, beg=0,end=len(string))
# 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

>>> "ababcdef".startswith('ab')    #不指定范围
True
>>> "ababcdef".startswith('ba')    
False    
>>> "ababcdef".startswith('ba',1)  #指定范围检测，True
True

(26) isdecimal() #是否只包含十进制字符，返回bool

isdecimal()
# 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

>>> '0123456'.isdecimal()
True
>>> '01A23456'.isdecimal()
False

2、字符串的切片

str[0:5] 截取第一位到第四位的字符
str[:] 截取字符串的全部字符
str[4:] 截取第五个字符到结尾
str[:-3] 截取从头开始到倒数第三个字符之前
str[2] 截取第三个字符
str[::-1] 创造一个与原字符串顺序相反的字符串 字符串的反转

三、字典(dict)操作

字典是一种可变容器模型，且可存储任意类型对象。

是一种key - value 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

>>> d = { 'a' : '1','b':2, 'c':5}
>>> d
{'a': '1', 'b': 2, 'c': 5}

1、字典的特性：

dict是无序的
key必须是唯一的,so 天生去重（值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。）

(1) 字典值(value)可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1> 不允许同一个键出现两次。如果创建时一个键被赋值两次，后一个值会被记住，即替换前面的值。

>>> d = { 'a' : '1','b':2, 'a':5}        #键‘a’被赋值两次
>>> print(d['a'])                        #记住最后一次
5
>>> d
{'a': 5, 'b': 2}

2> 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：

>>> d = {['name']:'hh','age':5}        #有一个键为列表，报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list

2、字典(dict)的函数

(1) len(dict) #计算字典元素个数，也就数键的总数。

len(dict)
# 计算字典元素个数，即键的总数。

>>> d = {1:2, 3:5, 4:2}
>>> print(len(d))
3

(2) str(dict) # 输出字典可打印的字符串表示

str(dict)
# 输出字典可打印的字符串表示。

>>> dict1 = {'aa':'bb','cc':7,'ee':'ff'}
>>> print(str(dict1))
{'aa': 'bb', 'cc': 7, 'ee': 'ff'}
>>> type(str(dict1))
<class 'str'>

(3) type(variable) #返回输入的参数的类型(python内置函数),如果参数是字典就返回字典类型。

type(variable)
# 返回输入的变量类型，如果变量是字典就返回字典类型。

>>> dict1 = {'aa':'bb','cc':7,'ee':'ff'}
>>> type(dict1)
<class 'dict'>

3、字典(dict)的内置方法

(1) dict.clear() #删除字典内的所有元素，无返回值

>>> dic = {1:2, 3:14,5:45}
>>> print(dic)
{1: 2, 3: 14, 5: 45}
>>> print(len(dic))
3
>>> dic.clear()
>>> dic
{}

(2) dict.copy() #返回一个字典的浅复制

>>> dict1 = {'name':'david', 'agr':20,'py':'hello'}
>>> dict2 = dict1.copy()        # 浅复制一个字典
>>> print(dict2)
{'name': 'david', 'agr': 20, 'py': 'hello'}

直接赋值和copy()的区别

dict1 =  {'user':'runoob','num':[1,2,3]}
dict2 = dict1          # 浅拷贝: 引用对象
dict3 = dict1.copy()   # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
# 修改 data 数据
dict1['user']='root'
dict1['num'].remove(1)
# 输出结果
print(dict1)
print(dict2)
print(dict3)

三个输出对应的结果

{'user': 'root', 'num': [2, 3]}
{'user': 'root', 'num': [2, 3]}
{'user': 'runoob', 'num': [2, 3]}

dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。

如果你还不知道什么是深浅拷贝，请转到python深浅拷贝详解，后面的对比要认真看。

(3) dict.fromkeys(seq[,val]) #创建一个新的字典，以序列seq中的元素做字典的键，val为字典所有键对应的初始值

注意：通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个

dict.fromkeys()
# 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

>>> seq = ('name','age','sex')
>>> dict1 = dict.fromkeys(seq)        #不指定val的值，默认为None
>>> print(dict1)
{'name': None, 'age': None, 'sex': None}
>>> dict2 = dict.fromkeys(seq,[10,11,12])    #指定val的值为列表[10,11,12]
>>> dict2
{'name': [10, 11, 12], 'age': [10, 11, 12], 'sex': [10, 11, 12]}
>>> dict2 = dict.fromkeys(seq,10)            #指定val的值为10
>>> dict2
{'name': 10, 'age': 10, 'sex': 10}

(4) dict.get(key,default=None) #返回指点键的值，如果值不在不在字典中返回default值(默认为None)

dict.get(key, default=None)
# 返回指定键的值，如果值不在字典中返回default值

>>> dict2
{'name': 10, 'age': 10, 'sex': 10}
>>> print(dict2.get('name'))           # 键存在，返回对应的值
10
>>> print(dict2.get('not'))            # 键不存在，返回默认的default值None
None
>>> print(dict2.get('not','hello'))    # 指定default为'hello'
hello

(5) key in dict #如果键在字典dict里返回True，否则返回False

key in dict
# 如果键在字典dict里返回true，否则返回false

>>> dict2
{'name': 10, 'age': 10, 'sex': 10}
>>> 'name' in dict2
True
>>> 'home' in dict2
False

一般结合if语句来用：

if 'key' in dict:        # 'key' 为想要查找的key,dict为字典
    pass
else :
    pass

(6) dict.items() #以列表的形式返回可遍历的(key,value)元组数组

dict.items()
# 以列表返回可遍历的(键, 值) 元组数组

>>> dict1 = {'name':'david','age':'100','sex':'man'}
>>> print(dict1.items())
dict_items([('name', 'david'), ('age', '100'), ('sex', 'man')])    # 返回的结果

(7) dict.keys() # 以列表返回一个字典所有的键

dict.keys()    # 以列表返回一个字典所有的键

>>> dict1 = {'name':'david','age':'100','sex':'man'}
>>> print(dict1.keys())
dict_keys(['name', 'age', 'sex'])

(8) dict.setdefault(key,default=None) #与get()方法类似，但是如果键不存在字典中，将会添加该键(参数中key)到字典里并将值设为default(默认为None)

dict.setdefault(key, default=None)
# 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

>>> dict1 = {'name':'david','age':'100','sex':'man'}
>>> print(dict1.setdefault('name','SG'))        # 键‘name’存在，返回其对应的值‘david’
david
>>> print(dict1.setdefault('kk','SG'))          # 键'kk'不存在，返回设置的default的值'SG',并把该键-值对添加到字典里
SG
>>> print(dict1)
{'name': 'david', 'age': '100', 'sex': 'man', 'kk': 'SG'}

(9) dict.update(dict2) #把字典dict2的key-value对更新到dict中

dict.update(dict2)
# 把字典dict2的key-value对更新到dict里

>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
>>> info.update(b)    #把字典b更新到info中
>>> info
{'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

(10) dict.values() #以列表返回字典中的所有值

dict.values()
# 以列表返回字典中的所有值

>>> dict1
{'name': 'david', 'age': '100', 'sex': 'man', 'kk': 'SG'}
>>> print(dict1.values())
dict_values(['david', '100', 'man', 'SG'])

(11) pop(key[,default]) #删除字典给定的key所对应的值，并返回该被删掉的值。key必须给出。

pop(key[,default])
# 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。

>>> dict1
{'name': 'david', 'age': '100', 'sex': 'man', 'kk': 'SG'}
>>> print(dict1.pop('name'))
david
>>> dict1
{'age': '100', 'sex': 'man', 'kk': 'SG'}

(12) popitem() #随机返回并删除字典中的一对键和值

popitem()
# 随机返回并删除字典中的一对键和值(一般删除末尾对)。

>>> dict1
{'sex': 'man', 'kk': 'SG'}
>>> dict1.popitem()
('kk', 'SG')

4、字典(dict)补充

(1)增加

>>> dict1 = {'name':'david','age':'20'}
>>> dict1['sex'] = 'man'        # 通过赋值的方式增加元素（注意：键必须不同）
>>> dict1
{'name': 'david', 'age': '20', 'sex': 'man'}

(2)修改

>>> dict1
{'name': 'david', 'age': '20', 'sex': 'man'}
>>> dict1['sex'] = 'wom'            # 通过键来修改重新赋值，可修改
>>> dict1
{'name': 'david', 'age': '20', 'sex': 'wom'}

(3)删除

# 前面dict提供的内置方法有pop和popitem,这里不再说

>>> dict1
{'name': 'david', 'age': '20', 'sex': 'wom'}
>>> del dict1['sex']        # 通过del方式删除
>>> dict1
{'name': 'david', 'age': '20'}

(4)查找

>>> dict1 = {'name':'david','age':'18'}
>>> 'name' in dict1        # 标准版，推荐使用
True
>>> dict1.get('name')      # 获取，不存在时返回None
'david'
>>> dict1['name']          # 同上，但是看下面
'david'
>>> dict1['hhh']           # 如果一个key不存在，就报错，推荐使用get()方法
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'hhh'

(5) 多级嵌套

就直接嵌套，即值为字典，一级一级的嵌套进去，但是要注意：key必须是不可变数据类型，且唯一

(6) 循环字典(dict)的方法

方法一：

方法一：
for key in dict1:
    print(key,dict1[key])
方法二：
for k,v in dict1.items():    #会先把dict转换成list，数据大时不要使用
    print(k,v)