【澳门葡京备用网址】浅谈字符串,Python元组与字典详解

Python3字典特点

Python 元组

  Python的元组与列表类似,不相同之处在于元组的要素无法改改。
  元组使用小括号,列表使用方括号。
  元组创设很不难,只必要在括号中添比索素,并运用逗号隔开即可。
一般来说实例:

tup = ('abc', [12, 434, 54], 1231 )
tup = (1, 2, 3, 4, 5 )
tup = "a", "b", "c", "d"
  • 创设空元组

tup = ()
  • 元组中只包蕴一个要素时,须要在要素前面添加逗号

tup = (1,)

  原因:那是因为括号()既可以象征tuple,又足以代表数学公式中的小括号,那就发出了歧义,由此,Python规定,这种情形下,按小括号举办测算,统计结果自然是1。所以,唯有1个成分的tuple定义时务必加一个逗号,,来解除歧义。

  • 元组与字符串,列表类似,下标索引从0伊始,可以展开截取,组合等。在此就不在赘述。

字典

字符串

字符串是 Python
中最常用的数据类型。大家可以使用引号(‘或”)来成立字符串。Python
不匡助单字符类型,单字符也在Python也是作为一个字符串使用。

  1. 无序

修改元组

元组中的成分值是不允许修改的,但我们能够对元组举办连接组合,如下实例:

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的。
# tup1[0] = 100

# 创建一个新的元组
tup3 = tup1 + tup2
print tup3

# (12, 34.56, 'abc', 'xyz')

字典是另一种可变容器模型,且可存储任意档次对象。

字符串索引(下标)

所谓“下标”,就是编号,就好比超市中的存储柜的号码,通过这一个号码就能找到呼应的囤积空间!

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

从左到右索引默许0初阶的,最大范围是字符串长度少1
从右到左索引默许-1初始的,最大范围是字符串初始

假设您要完成从字符串中拿到一段子字符串的话,可以利用变量
[头下标:尾下标],就足以截取相应的字符串,其中下标是从 0
初始算起,可以是正数或负数,下标可以为空表示取到头或尾。
例如:

str1 = 'hello world!'

print(str1[:5]

其结果为’hello’,那就是透过下标将字符串切片的措施。

注意:字符串使用下标切片的时候入上边例子中是从str1这么些字符串中取出0到5的字符,可是不包含下标为5的字符,因而在应用字符串举行切开的时候应注意切片的是一个半闭半开区间。

  2.键唯一      #不可变对象:整数、字符串、元组;可变对象:列表、字典

去除元组

tup = ('abc', [12, 434, 54], 1231 )
print tup
del tup
print tup
# 实例元组被删除后,输出变量会有异常信息
# Traceback (most recent call last):
#  File "<console>", line 1, in <module>
#  NameError: name 'tup' is not defined

除此之外列表以外,字典是只怕是python中最灵敏的嵌入数据结构,借使把列表看成有序的聚合,那么字典可以算作无序的汇合。

字符串常用方法

字符串的章程有过多详尽的参照澳门葡京备用网址 ,Python3
字符串

透过以下代码浮现部分方法的选择:

str1 = 'hello, world!'
print(len(str1))  
#返回字符串的长度
print(str1.capitalize())  
#将字符串的第一个字符转换为大写!
print(str1.upper())   
#将字符串中所有小写字母转换为大写
print(str1.lower())   
#将字符串中所有字母转化为小写
print(str1.title())   
#将字符串中所有的单词首字母都大写
print(max(str1))     
#返回字符串中最大的字母(以ASCII码表为参考)同理也有min()方法
print(str1.find('or'))   
#从左到右进行查找,找到了返回索引,找不到返回-1,从右往左查找使用rfind()方法
#print(str1.index("shit"))   #z找不到就出现错误,找到了返回索引
print(str1.startswith("he"))  
#检查一个字符串是不是以he开头的,同理也有endswith()方法,检测以哪个字符串结尾
print(str1.center(50,'*'))  
#指定长度为50,不够用*填充,str1居中对齐
str2 = ' asds   ldjf  '
print(str2.strip())     
#跳过字符串两端的空格,当然也可以指定跳过的字符,默认为跳过空格
print(str2.split('d'))    
#以字符串d对当前字符串进行切割,切割后得到一个列表
print(str1[-1:-3:-1])     
#表示反向从-1取到-3,后面的-1表示反向选取步长为1,,类似range的用法,只有用负索引时才能给得到反向
print((str1[::-1]))    
#实现字符串的反转

【澳门葡京备用网址】浅谈字符串,Python元组与字典详解。    键:字典中,字典值能够是pyton
任意一个目的,但键不行;键在字典中不只怕出现同等的键,倘诺相同,后一个值会被铭记,
正如实例:

元组内置函数

方法 描述
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组

她俩的首要分化在于:字典当中的要素是通过键来存取的,而不是经过偏移量

列表

List(列表) 是 Python 中接纳最频繁的数据类型。

列表可以形成大部分集合类的数据结构完毕。它支持字符,数字,字符串甚至可以包涵列表等(即嵌套)。

列表与字符串类似同样的支持下标索引的法子取出列表中的成分,绝大部分字符串协理的演算方法在列表中也如出一辙适用。

dic = {'name':'xp','name':'26','job':'IT','salary':9000}
print(dic) # 打印结果为:{'name': '26', 'job': 'IT', 'salary': 9000}

元组与列表的区分

  • 元组是不可变的, 而列表是可变的。

  • 元组经常由差距的数据,而列表是同样类其他数量队列。元组表示的是协会,而列表表示的是各种。

  • 列表当作字典的key, 而元组可以。

>>> a= (1, 2)
>>> b = [3, 4]
>>> c = {a: 'abc'}
>>> d = {b: 'xyz'}
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: unhashable type: 'list'
  • 元组支持的操作比列表小, 所以元组会比列表稍稍快。

用作内置类型,字典可以取代许多搜索算法和数据结构,python字典的显要的品质如下:

列表中成分的增删改和遍历

  • 列表中追法郎素

当须求生成一个有一定规律的列表时,可以采取列表生成式急忙的变化一个列表:

list1 = [x * x for x in range(10)]

print('list1=',list1)

list1= [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  • 列表中成分更新

列表中的成分的更新可以一向利用索引对列表指定地方举行修改:

list2 = ['hello', 'world', 2562, 1589]
print('更新前的list:',list2)

list2[1] = 'Python'
print('更新后的list:',list2)

更新前的list: ['hello', 'world', 2562, 1589]
更新后的list: ['hello', 'Python', 2562, 1589]
  • 列表中成分的去除
    利用 del 语句来删除列表的的要素,如下实例:

list3 = ['hello', 'world', 1997, 2000]
print ('删除前的列表', list3)

del list3[2]
print ("删除第三个元素后的列表 : ", list3)

删除前的列表 ['hello', 'world', 1997, 2000]
删除第三个元素后的列表 :  ['hello', 'world', 2000]
  • 列表中成分的遍历

因此巡回对列表的遍历格局有无数中,然而普通大家使用如下的办法,既能得到值也能拿到索引:

list4 = ['hello', 'world', 'Python', 1997, 2000]
for index,value in enumerate(list4):
    print(index, ':', value)

0 : hello
1 : world
2 : Python
3 : 1997
4 : 2000

    键必须不可变,可以是数字,字符串恐怕元组,决无法用列表和字典。

Python 字典(Dictionary)

  字典是另一种可变容器模型,且可存储任意档次对象。类似于java中的map。
  字典的各样键值(key=>value)对用冒号(:)分割,每种对里面用逗号(,)分割,整个字典包罗在花括号({})中
,格式如下所示:

dict = {key1 : value1, key2 : value2 }

键必须是唯一的,但值则不用。
值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。
一个粗略的字典实例:

dict={ 1:'a', 2:'b'}

# {1: 'a', 2: 'b'}

动用内建艺术fromkeys()成立’暗中同意‘字典,字典中元素具有同样的value(如果没有提交,专擅认同为none)

dict={}.fromkeys(('x','y'),12)
#dict={'x':-1,'y':-1}

透过键而不是偏移量读取

列表中的常用方法和函数:

作者们透过如下的代码来精通列表的函数和措施的使用:

f = [100, 200, 500]
# enumerate()枚举的方式可以即返回list中的值,同时也可以返回其对于的索引值
for index, val in enumerate(f):
    print(index, val)
f.append(123)   #向列表最后追加元素123
f.insert(1, 300)  #在列表索引为1的元素之后插入300
f.insert(-1, 121)  # 在索引为-1的元素之前插入121
f.insert(100, 10)  # 如果不存在索引100则在最后添加
f.remove(200)  # 如果200不存在会报错,存在就删除,可以使用判断是否存在,然后在删除,eg:f.remove(5999) if 5999 in f
f.pop()  # 默认是移除最后一个,可以移除指定索引的元素f.pop(i)
f.index(500, 2, 5)  # 查找500在索引为2到5之间查找,如果找不到会报错,找到了返回索引
# f.clear() #表示清空
f.reverse()  # 表示将f这个列表反向,直接修改f
print(reversed(f))
f.sort()  # 表示将f进行排序,默认升序排列,可以使用reverse反向排序,也可以指定排序关键字key,直接修改f
sorted(f, reverse=True, key=len)  # python内置的排序函数,返回值为一个排好序的新list,
# key=len,key表示指定排序的方式
# 默认是升序排列,如果需要降序,可以通过reverse=True来实现
# python 中的函数几乎都是没有副作用的函数(调用函数后不会影响传入的参数)
print(reversed(f))  # 类似sorted()函数,但是它返回的值不是list列表
print(sorted(f))

print(f)

字典的创始

走访字典里的值

  • 通过key访问value

格式

dict[key]

或者
dict.get(key)

把相应的键放入熟稔的方括弧,如下实例:

dict={ 1:'a', 2:'b'}
dict[1]

# 如果用字典里没有的键访问数据,会输出错误如下:
dict['4']
Traceback (most recent call last):
  File "<console>", line 1, in <module>
KeyError: '4'
  • 重回字典所有值的列表,dict.values()

>>> dict={ 1:'a', 2:'b'}
>>> dict.values()
dict_values(['a', 'b'])

  字典有时又称作关联数组或散列表。它们通过键将一多元值连接起来,那样可以使用键从字典总取出值。

元组

元组是另一个数据类型,元组类似于列表,列表的切片方法在元组中依旧适用,不过元组和列表也有七个不一致的地点:

成立元组使用的是(),而成立列表使用的是[]
列表中的成分得以拓展增删改,元组是不接济增删改的,只可以对全体元组进行删除

如下示例不难介绍怎样创立元组和元组转换为列表:

list1 = ['hello', 'python']
tuple1 = (1, 2, 3, 4)  # 创建元组
print(tuple1)
tuple2 = tuple(list1)  # 将列表转换为元组
list2 = list(tuple1)   #将元组转换为列表

  字典的各个键值(key)对用冒号(:)分割,每种键值对中间用逗号(,)分割,整个字典包含在花括号({})中
,格式如下所示:

做客字典中的key

归来字典中键的列表  ** dict.keys()**
dict.has_key(key)   假使键在字典dict里重返true,否则再次来到false,python3中已经去掉那些点子了。

肆意对象的无序聚集

集合

在Python中set是着力数据类型的一种集合类型,它有可变集合(set())和不可变集合(frozenset)三种。创造集合set、集合set添加、集合删除、交集、并集、差集的操作都以极度实用的措施。Python中的集合跟数学上的聚众是均等的,内部的成分是无序不重复的。

  • 始建集合
    聚拢的成立很不难,使用花括号{},在括号中指定参数,七个参数用,隔开即可,在汇聚中set括号中须要的参数的数据类型有:系列(包罗字符串、列表、元组),字典可能是另一个汇聚,不过不恐怕是数值类型,如int类型。

list1 = [8, 9, 7, 6, 8, 9, 7]
set1 = set(list1)
set2 = {1, 1, 2, 2, 3, 3}


print(set1)
print(set2)

{8, 9, 6, 7}
{1, 2, 3}
  • 集合添日币素
    python 集合的丰盛有二种常用方法,分别是add和update。

set2 = {1, 1, 2, 2, 3, 3}

set2.add('5')
set2.update('Python')

print(set2)

{1, 2, 3, 't', '5', 'n', 'y', 'h', 'P', 'o'}
  • 会晤删除元素
    汇聚删除操作方法:remove

set3 = {1, 2, 3, 't', '5', 'n', 'y', 'h', 'P', 'o'}
set3.remove('5')

print(set3)

{1, 2, 3, 't', 'n', 'y', 'h', 'P', 'o'}
1 dic = {'name':'xp','age':'26','job':'IT','salary':9000}
2 print(dic)

访问键值对

遍历方式
for r in dici #r是dict中的键值对
dict.items() 以列表再次来到可遍历的(键, 值) 元组数组
修改(更新)或添加
dict[key1]=value1

  保存在字典中的数据尚未一定的逐条。键提供了字典中象征性(而非物理性)的职位

会见的插花并集

经过如下代码通晓集合的测算交集和并集的用法:

set1 = {1, 1, 2, 2, 3, 3}
set2 = {1, 3, 5, 7, 9}
set3 = set2 & set1   # 计算交集
set3 = set1.intersection(set2)  # 计算交集
print(set3)
set3 = set2 | set1   # 计算并集
set3 = set1.union(set2)  # 计算并集
print(set3)
set3 = set1.difference(set2)  # 计算差集
print(set3)
set3 = set2 ^ set1     # 计算对称差
set3 = set1.symmetric_difference(set2)  # 计算对称差
print(set3)
print(set1.issubset(set2))  # 判断set2是否是set1的子集
print(set1.issuperset(set2))  # 判断set2是否是set1的父集
set1.discard(100)    #如果集合中存在100,则删除,不存在不报错
print(set1)

查 通过键去查找

字典的翻新

dict.update(dict2) 将dict2中的值添加到dict中

dict = {"a" : "apple", "b" : "banana"}
>>> dict2={'c':"orange"}
>>> dict.update(dict2)
>>> dict
{'a': 'apple', 'b': 'banana', 'c': 'orange'}

可变长,异构,任意嵌套

字典

字典是另一种可变容器模型,且可存储任意档次对象。
字典的各类键值(key=>value)对用冒号(:)分割,逐个对里面用逗号(,)分割,整个字典包含在花括号({})中
,格式如下所示:
d = {key1 : value1, key2 : value2 }
键必须是绝无仅有的,但值则无需。
值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。!

  把相应的键放入到方括号中

### 删除 ###

  • 按key删除
    del dict[key1]

  • 删去并回到

  • dict.pop(key1)
    剔除字典给定键 key 所对应的值,再次回到值为被删除的值。key值必须提交。
    否则,重返default值。
  • popitem()
    私行回到并剔除字典中的一对键和值。

  • 去除所有项

  • dict.clear()
  • del dict

  与列表类似,可在原处增加或减弱,它们得以涵盖自由档次的对象,而且援救任意深度的嵌套

做客字典中的值

因为字典中键的唯一性,所以访问字典中的值的时候,只须求把相应的键放入方括弧中即可访问到键对应的值,如下实例:

dict1 = {'name': '王大锤', 'age': 38, 'gender': 'True'}
print(dict1['name'])

王大锤
1 dic = {'name':'xp','age':'26','job':'IT','salary':9000}
2 print(dic['age'])   #打印结果为:26
3 print(list(dic.keys())) #以列表形式打印字典中的键;也可以不用加liest转换    dic.keys()
4 #打印结果:['name', 'age', 'job', 'salary']
5 print(list(dic.values())) # 以列表形式打印字典中所有键对应的值            dic.values()
6 #打印结果为:['xp', '26', 'IT', 9000]
7 print(list(dic.items())) #以列表的形式打印字典中所有的键值对              dic.items()
8 #打印结果为:[('name', 'xp'), ('age', '26'), ('job', 'IT'), ('salary', 9000)]

字典常用方法

方法 描述
cmp(dict1, dict2) 比较两个字典元素。
len(dict) 计算字典元素个数,即键的总数。
str(dict) 输出字典可打印的字符串表示。
type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型。
dict.clear() 删除字典内所有元素
dict.copy() 返回一个字典的浅复制
dict.fromkeys(seq[, val])) 创建一个新字典,以序列 seq 中元素做字典的键,val 为字典所有键对应的初始值
dict.get(key, default=None) 返回指定键的值,如果值不在字典中返回default值
dict.items() 以列表返回可遍历的(键, 值) 元组数组
dict.keys() 以列表返回一个字典所有的键
dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
dict.update(dict2) 把字典dict2的键/值对更新到dict里
dict.values() 以列表返回字典中的所有值
pop(key[,default]) 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
popitem() 随机返回并删除字典中的一对键和值。

可变映射类型

修改字典

向字典添加新内容的办法是充实新的键/值对,修改已有键/值对的点子类似于修改列表中的元素,如下实例:

dict1 = {'name': '王大锤', 'age': 38, 'gender': 'True'}
print(dict1)
dict1['school'] = '成都七中' 
dict1['age'] = 18
print(dict1)

{'name': '王大锤', 'age': 38, 'gender': 'True'}
{'name': '王大锤', 'age': 18, 'gender': 'True', 'school': '成都七中'}

  上述顺序中有一种景况下需求用 list 转换,如下程序:

  通过给键赋值,字典可以在原处修改,不过不援救字符串或列表的行列操作,因为字典是无序汇聚

除去字典元素

删除字典中的成分有两种,能删单一的成分也能清空字典,清空只需一项操作。

dict2 = {'Name': '王大锤', 'Age': 7, 'Class': 'First'}

del dict2['Name'] # 删除键 'Name'
print (dict2)
#dict2.clear()     # 清空字典
del dict2         # 删除字典

{'Age': 7, 'Class': 'First'}

注意:当使用del删除字典、大概字典中的元素只怕其余的列表的时候若是去除的始末不设有,都会报错。在剔除以前都应该先判断是还是不是存在

1 dic = {'name':'xp','age':'26','job':'IT','salary':9000}
2 dic1 = dic.keys()
3 print(dic1)   #打印结果为:dict_keys(['name', 'age', 'job', 'salary'])
4 #print(dic1[1]) 打印这句话会报错
5 #报错 TypeError: 'dict_keys' object does not support indexing  是因为dic1打印出来的是对象不是列表,怎么办呢?
6 
7 print(list(dic1)[1]) #打印结果为: age
8 #加上list 转换,将dic1转换为列表:['name', 'age', 'job', 'salary'],然后取[1]元素。

对象引用表(散列表)

列表中的常用的章程

Python字典包涵了以下内置方法:

澳门葡京备用网址 1

字典常用方法

  字典中键不设有会是怎么吗?请看实例

  倘使说列表是援救地点读取对象引用数据,那么字典是支撑键读取的无序对象引用表

陶冶1:文字跑马灯

import os
import time


def main():
    str1 = "客上天然居居然天上客,人过大佛寺寺佛大过人。"
    while True:
        os.system('cls')
        str1 = str1[1:] + str1[0]
        print(str1)
        time.sleep(0.5)


if __name__ == '__main__':
    main()
1 dic = {'name':'xp','job':'IT','salary':9000}
2 print(dic)# 打印结果为:{'name': 'xp', 'job': 'IT', 'salary': 9000}
3 dic['age'] = 18
4 print(dic)#打印结果为:{'name': 'xp', 'job': 'IT', 'salary': 9000, 'age': 18}
5 #通过例子我们能看出字典中如果键不存在,将会添加对应的键值对。这也是添加字典的一种方法如果将dic['age'] = 18 改为 dic['age'] 那么会报错,大家可以试试。

 

勤学苦练2:打印杨辉三角

# def striangle():


def main():
    lines = int(input('请输入杨辉三角的行数:'))
    total_triangle = [[0 for x in range(i)] for i in range(1, lines + 1)]
    for i in range(1, lines + 1):
        for x in range(i):
            if x == 0 or x == (i - 1):
                total_triangle[i - 1][x] = 1
                print(total_triangle[i-1][x],end=' ')
                x == i-1 and print()
            else:
                total_triangle[i - 1][x] = total_triangle[i - 2][x - 1] + total_triangle[i - 2][x]
                print(total_triangle[i-1][x], end=' ')


if __name__ == '__main__':
    main()

请输入杨辉三角的行数:7
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 

  字典中键存在,又会是怎么结果吧?请看实例

字典的各样键值(key–>value)对用冒号(:)分割,各个对中间用逗号(,)分割,整个字典包罗在花括号({})中 

陶冶3:约瑟夫环

"""

有30个人在海上遇险,为了能让一部分人活下来不得不将其中15个人扔到海里面去,
有个人想了个办法就是大家围成一个圈,由某个人开始从1报数,报到9的人就扔到海里面,
他后面的人接着从1开始报数,报到9的人继续扔到海里面,直到扔掉15个人。
由于上帝的保佑,15个基督徒都幸免于难,问这些人最开始是怎么站的,哪些位置是基督徒哪些位置是非基督徒。

"""

def main():
    ring = [1] * 30
    ring_index = [i for i in range(30)]
    print('死掉的人的位置是:')
    while ring.count(0) < 15:
        for i in range(8):
            ring_index.append(ring_index[0])
            ring_index.remove(ring_index[0])
        kill = ring_index[0]
        print(ring_index[0] + 1, end=' ')
        ring_index.remove(ring_index[0])
        ring[kill] = 0
    print()
    for person in ring:
        print('基' if person else '非', end='')
if __name__ == '__main__':
    main()

死掉的人的位置是:
9 18 27 6 16 26 7 19 30 12 24 8 22 5 23 
基基基基非非非非非基基非基基基非基非非基基非非非基非非基基非
1 dic = {'name':'xp','age':26,'job':'IT','salary':9000}
2 
3 ret = dic.setdefault('age',34)  #setdefault() 函数 如果键存在,则返回对应的值,
4 print(ret) #打印结果为:26

d = {key1 : value1, key2 : value2
}
键必须是绝无仅有的,但值则无需。

总结

字符串、列表、元组、集合、字典这一个事物有好多的相似之处也有好多差别之处,比如字符串和列表,元组都接济索引,字符串是和元组无法更改内部的故事情节,而列表却足以修改里面的始末。知识点很多,不过找到相似之处和分化之处明白那么些知识点依旧很不难的,可是要想熟稔的利用这几个就还亟需多看多练才方可了。

改 修改字典

依然通过dict({key:value})的措施创立字典

  通过增添新的键值对,来修改大概去除字典中已有些内容

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

1 dic = {'name':'xp','age':'26','job':'IT','salary':9000}
2 dic['age'] = 20  #通过键来修改对应的值。
3 print(dic)
4 #打印结果为:{'name': 'xp', 'age': 20, 'job': 'IT', 'salary': 9000}
5 
6 dic['like'] = 'book'
7 print(dic)
8 #打印结果为:{'name': 'xp', 'age': 20, 'job': 'IT', 'salary': 9000, 'like': 'book'}

1 dic = {'name':'xp','age':'26','job':'IT','salary':9000}
2 dic1 = {'like':'book','name':'UUM'}
3 dic.update(dic1)# update()  通过函数进行修改,被修改的字典里与要添加的键相同,则被修改的字典对应的键值被更新
4 print(dic) 
5 #打印结果为:{'name': 'UUM', 'age': '26', 'job': 'IT', 'salary': 9000, 'like': 'book'}
6 
7 print(dic1)
8 #打印结果为:{'like': 'book', 'name': 'UUM'}

访问值:
  通过键访问 print(dic[‘list’])
返回:[‘list1′,’list2’]
  print(dic[12])
返回:’字符串12′
修改或抬高:

 

  操作已有的键是修改,操作没有的键是充裕
  dic[‘list’]=’唯有一个’
#修改
  dic[‘Age’]=17
#添加一个监键值对
删除字典/成分或清空:
  del dic[‘list’]
清除键为“list”的要素
  del dic 删除字典
  dic.clear() 清空字典
特性:

删 删除字典

  键是绝无仅有的,就算有三个一律的键,前边的会覆盖前面的

 1 #程序1
 2 dic = {'name':'xp','age':'26','job':'IT','salary':9000}
 3 del dic['name']  #通过键来删除字典中的键值对
 4 print(dic) # 打印结果为:{'age': '26', 'job': 'IT', 'salary': 9000}
 5 
 6 #程序2
 7 dic = {'name':'xp','age':'26','job':'IT','salary':9000}
 8 a=dic.pop('age')  #删除该键值对应的值,并返回该键值对应的值
 9 print(dic) #打印结果为:{'name': 'xp', 'job': 'IT', 'salary': 9000}
10 print(a) #打印结果为:26
11 
12 #程序3
13 dic = {'name':'xp','age':'26','job':'IT','salary':9000}
14 b = dic.popitem()  #随机删除字典中某组键对值,并以元组方式返回
15 print(b)   # 打印结果为:('salary', 9000)
16 print(dic) # 打印结果为:{'name': 'xp', 'age': '26', 'job': 'IT'}
17 
18 #程序4
19 dic = {'name':'xp','age':'26','job':'IT','salary':9000}
20 dic.clear()   #清空字典,但字典还存在,只不过是是一个空字典
21 print(dic) #打印结果为:{}
22 
23 del dic #删除字典,再打印的话会报错
24 print(dic) #提示错误:NameError: name 'dic' is not defined

  键不可变,可以用数字,字符串或元组充当

 


字典嵌套

 

   字典是永葆无限极嵌套的。

放置函数和章程:
  len(dict)
重回成分个数,键的总额
  str(dict)
输出字典,以可打印的字符串表示
  type(variable)
重回成分或变量的数据类型
  key in dict
假诺键在字典里,再次来到True
  clear() 清空字段所有因素
  copy() 再次回到一个字典的复制
  keys()
以列表再次来到一个字典所有的键
  values()
以列表重返字典中的所有值
  get(key,default==None)
再次回到指定键的值,即使值不存在字典中,重回default值
  setdefault(key,default=None)
和get()类似,
但假若键不存在于字典中,将会添加键并将值设为default
  update(dict)
把字典dict2的键/值对革新到dict中
  items()
以列表再次来到可遍历的(键,值)元组数组

 1 cities = {
 2     '河南省':{
 3         '商丘市':['民权县','睢县','宁陵县'],
 4         '开封市':['兰考县','杞县','通许县'],
 5         '洛阳市':['宜阳县','洛川县','伊川县']
 6             },
 7     '北京市':{
 8         '大兴区':['西红门','黄村','天宫院'],
 9         '丰台区':['郭公庄','科技园','总部基地'],
10         '朝阳区':['望京','将台','太阳宫'],
11         '海淀区':['万柳','三小','巴沟']
12             },
13     '河北省':{
14         '保定市':['涿州市','高碑店','保定'],
15         '廊坊':['永清','自然公园','安次区'],
16         '张家口':['怀安县','万全区','桥西区']
17             }
18         }
19 print(cities['河南省']['洛阳市'][1])
20 #打印结果为:洛川县

 

  由地方的例证可见,新疆省、香岛市、河南省是个大的字典,而新疆省又是个字典,字典里面又嵌套列表。

任何字典方法

其余操作

  字典方法提供了三种工具字典values和items方法分别重返字典值的列表和(key,value),可以把它们位于list中调用

  dic.formkeys(参数,子参数) 其中参数可以是列表、元组。

>>> dic={"name":'南希',"age":17}
>>> list(dic.values())
['南希', 17]
>>> list(dic.items())
[('name', '南希'), ('age', 17)]
1 dic = {}  #定义一个空字典
2 dic1 = dic.fromkeys(('host1','host2','host3'),'date')#.formkeys(参数,子参数)函数会生成一个字典
3 print(dic1)   #一般初始化用 
4 # 打印结果为:{'host1': 'date', 'host2': 'date', 'host3': 'date'}

dic = {}  #定义一个空字典
dic1 = dic.fromkeys(['host1','host2','host3'],#会打印字典里面有列表['date1','date2'])#.formkeys(参数,子参数)函数会生成一个字典
print(dic1)   #一般初始化用
# 打印结果为:{'host1': ['date1', 'date2'], 'host2': ['date1', 'date2'], 'host3': ['date1', 'date2']}

 

  sorted()

  但是只要当读取读取的键不存在是,将会回来一个暗中认同的None值

dic = {'name':'xp','age':26,'job':'IT','salary':9000}
print(sorted(dic))    # 对键进行排序
#打印结果为:['age', 'job', 'name', 'salary']
print(sorted(dic.items())) # 对键值对进行排序
#打印结果为:[('age', 26), ('job', 'IT'), ('name', 'xp'), ('salary', 9000)]
>>> print(dic.get("gender"))
None

巡回打印字典中的 values 和keys 的值

  dict的update方法类似合并,它和从左到右的相继非亲非故,它把参数字典的值合并到调用者字典中,可是盲目标update或然会招致覆盖相同的键值

1 dic = {'name':'xp','age':26,'job':'IT','salary':9000}
2 for i in dic.values():    #循环打印字典中键对应的值(values)
3     print(i)
4 for i in dic.keys():  #循环打印键的值(keys)
5     print(i)
dic2={"gender":"男"}
>>> dic.update(dic2)
>>> dic
{'name': '南希', 'gender': '男', 'age': 17}

字典方今学到的就那个,以上是自家读书进程中所统计的笔记,希望对我们享有协理,觉得不错可以关切自个儿啊~_~

 

 

 

 


 

字典使用注意:

  系列运算无效:即不可使用dic[0]来行使,她会抛出一个keyError的不得了

  对新索引赋值会添加项:添加字典中未出现的键值会新建这么些键值

  键不肯定总是字符串:可以是数字,字符串,元组等

 

至于列表和字典的用法技巧将在相应作品讲解

愈多的用法及描述如故需求查阅python的合法文档。

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website