精华内容
下载资源
问答
  • python字典概念:字典是另一种可变容器类型,且可存储任意类型对象,如其他容器类型。字典由键和对应值成对组成。字典也被称作关联数组或哈希表。理解好一一对应关系很重要1. 掌握字典类型a) 字典特点无序: 通过...

    python字典

    概念:字典是另一种可变容器类型,且可存储任意类型对象,如其他容器类型。

    字典由键和对应值成对组成。字典也被称作关联数组或哈希表。理解好一一对应的

    关系很重要

    1. 掌握字典类型

    a) 字典的特点

    无序: 通过键实现元素存取,故无序

    可变:可以通过键进行改变值

    异构:支持多种数据类型

    嵌套:可以在键值对中的值部分出现字典

    b) 定义字典:

    ii. 方法一:{key1:value1,key2:value2,...}

    iii. 方法二:dict()内置函数:指定键值

    例:d2=dict(name="jerry",age="45",gender="m")

    iv. 关键点:

    键与值用冒号“:”分开;

    项与项用逗号“,”分开;

    字典中的键必须是唯一的,而值可以不唯一

    实例:

    dict = {'Alice': '16', ' MadKing ': '17', 'Cecil': '18'}

    dict1 = { 'abc': 456 }dict2 = { 'abc': 123, 98.6: 37 } 嵌套定义

    访问字典里的值

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

    dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

    print "dict['Name']: ", dict['Name'];

    print "dict['Age']: ", dict['Age'];

    0818b9ca8b590ca3270a3433284dd417.png

    如果用字典里没有的键访问数据,会输出错误如下:

    dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

    print "dict['Alice']: ", dict['Alice'];

    以上实例输出结果:

    1

    2

    3

    4

    5

    dict['Zara']:

    Traceback (most recent call last):

    File "test.py", line 4, in 

    print "dict['Alice']: ", dict['Alice'];

    KeyError: 'Alice'

    修改字典

    向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对如下实例:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    #coding:utf8

    dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

    dict['Age'] = 8; # update existing entry

    dict['School'] = "DPS School"; # Add new entry

    print "dict['Age']: ", dict['Age'];

    print "dict['School']: ", dict['School'];

    以上实例输出结果:

    1

    2

    dict['Age']:  8

    dict['School']:  DPS School

    删除字典元素

    能删单一的元素也能清空字典,清空只需一项操作。

    显示删除一个字典用del命令,如下实例:

    #coding:utf8

    dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

    del dict['Name']; # 删除键是'Name'的条目

    dict.clear();     # 清空词典所有条目

    del dict ;        # 删除词典

    print "dict['Age']: ", dict['Age'];

    print "dict['School']: ", dict['School'];

    但这会引发一个异常,因为用del后字典不再存在:

    1

    2

    3

    4

    5

    dict['Age']:

    Traceback (most recent call last):

    File "test.py", line 8, in 

    print "dict['Age']: ", dict['Age'];

    TypeError: 'type' object is unsubscriptable

    注意:删除元素尽量用字典内置方法,不需要直接del,后面会讨论。

    字典键的特性

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

    两个重要的点需要记住:

    1)不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住,如下实例:

    1

    2

    3

    4

    5

    #coding:utf8

    dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};

    print "dict['Name']: ", dict['Name'];

    以上实例输出结果:

    1

    dict['Name']:  Manni

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

    1

    2

    3

    4

    5

    #coding:utf8

    dict = {['Name']: 'Zara', 'Age': 7};

    print "dict['Name']: ", dict['Name'];

    以上实例输出结果:

    1

    2

    3

    4

    Traceback (most recent call last):

    File "test.py", line 3, in 

    dict = {['Name']: 'Zara', 'Age': 7};

    TypeError: list objects are unhashable

    掌握字典相关方法

    1.1 添加元素:dict1[key] = value

    例如:

    0818b9ca8b590ca3270a3433284dd417.png

    0818b9ca8b590ca3270a3433284dd417.png

    1.2 items():变量解包:即将字典转化为键、值作为元组的列表

    例如:

    0818b9ca8b590ca3270a3433284dd417.png

    0818b9ca8b590ca3270a3433284dd417.png

    dict = {'Name': 'Zara', 'Age': 7}

    print "Value : %s" %  dict.items()

    Value : [('Age', 7), ('Name', 'Zara')]

    1.3keys();键列表

    例如:

    0818b9ca8b590ca3270a3433284dd417.png

    0818b9ca8b590ca3270a3433284dd417.png

    1.4 values():值列表

    例如:

    0818b9ca8b590ca3270a3433284dd417.png

    0818b9ca8b590ca3270a3433284dd417.png

    1.5 has_key():判断是否存在某个键,返回结果true 或false

    例如:

    0818b9ca8b590ca3270a3433284dd417.png

    0818b9ca8b590ca3270a3433284dd417.png

    1.6 len():取得字典中键值对个数

    例如:

    0818b9ca8b590ca3270a3433284dd417.png

    1.7         update():在原字典上合并字典,键相同时会被覆盖。

    例如:

    0818b9ca8b590ca3270a3433284dd417.png

    1.8         get():取得某个键对应的值

    例如:

    0818b9ca8b590ca3270a3433284dd417.png

    1.9         pop():弹出指定键对应的值

    0818b9ca8b590ca3270a3433284dd417.png

    1.10         popitem():随机弹出键值对

    0818b9ca8b590ca3270a3433284dd417.png

    1.11         clear():清除所有元素

    例如:

    0818b9ca8b590ca3270a3433284dd417.png

    2. 掌握字典的遍历:

    0818b9ca8b590ca3270a3433284dd417.png

    概念:Python的元组与列表类似,也是一种容器类型,不同之处在于元组的元素不能修改。

    元组使用小括号,列表使用方括号。

    Python的元组与列表类似,不同之处在于元组的元素不能修改。

    特点:支持异构;

    支持嵌套;

    不可变

    元组使用小括号,列表使用方括号。

    元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

    如下实例:

    1

    2

    3

    tup1 = ('physics', 'chemistry', 1997, 2000);

    tup2 = (1, 2, 3, 4, 5 );

    tup3 = "a", "b", "c", "d";

    创建空元组

    tup1 =();

    元组中只包含一个元素时,需要在元素后面添加逗号

    tup1 =(50,);

    元组与字符串类似,下标索引从0开始,可以进行截取,组合等。

    访问元组

    元组可以使用下标索引来访问元组中的值,如下实例:

    tup1 = ('physics', 'chemistry', 1997, 2000);

    tup2 = (1, 2, 3, 4, 5, 6, 7 );

    print "tup1[0]: ", tup1[0]

    print "tup2[1:5]: ", tup2[1:5]

    以上实例输出结果:

    tup1[0]:  physics

    tup2[1:5]:  [2, 3, 4, 5]

    修改元组

    元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例:

    tup1 = (12, 34.56);

    tup2 = ('abc', 'xyz');

    # 以下修改元组元素操作是非法的。

    # tup1[0] = 100;

    # 创建一个新的元组

    tup3 = tup1 + tup2;

    print tup3;

    以上实例输出结果:

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

    删除元组

    元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例:

    tup = ('physics', 'chemistry', 1997, 2000);

    print tup;

    del tup;

    print "After deleting tup : "

    print tup;

    以上实例元组被删除后,输出变量会有异常信息,输出如下所示:

    1

    2

    3

    4

    5

    6

    ('physics', 'chemistry', 1997, 2000)

    After deleting tup :

    Traceback (most recent call last):

    File "test.py", line 9, in 

    print tup;

    NameError: name 'tup' is not defined

    元组运算符

    与字符串一样,元组之间可以使用+号和*号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。

    Python表达式

    结果

    描述

    len((1, 2, 3))

    3

    计算元素个数

    (1, 2, 3) + (4, 5, 6)

    (1, 2, 3, 4, 5, 6)

    连接

    ['Hi!'] * 4

    ('Hi!', 'Hi!', 'Hi!', 'Hi!')

    复制

    3 in (1, 2, 3)

    True

    元素是否存在

    for x in (1, 2, 3): print x,

    1 2 3

    迭代

    元组索引,截取

    因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素,如下所示:

    元组:

    L =('spam', 'Spam', 'SPAM!')

    Python表达式

    结果

    描述

    L[2]

    'SPAM!'

    读取第三个元素

    L[-2]

    'Spam'

    反向读取;读取倒数第二个元素

    L[1:]

    ['Spam', 'SPAM!']

    截取元素

    无关闭分隔符

    任意对象 以逗号隔开,默认为元组,如下实例:

    print 'abc', -4.24e93, 18+6.6j, 'xyz';

    x, y = 1, 2;

    print "Value of x , y : ", x,y;

    元组内置函数

    Python元组包含了以下内置函数

    序号

    方法及描述

    1

    len(t)  计算元组元素个数。

    0818b9ca8b590ca3270a3433284dd417.png

    2

    max(t)返回元组中元素最大值。

    0818b9ca8b590ca3270a3433284dd417.png

    3

    min(t)返回元组中元素最小值。

    0818b9ca8b590ca3270a3433284dd417.png

    4

    tuple(li)将列表转换为元组

    0818b9ca8b590ca3270a3433284dd417.png

    5

    index():返回指定元素第一次出现的索引位置

    count():指定元素出现的次数

    例如:

    0818b9ca8b590ca3270a3433284dd417.png

    展开全文
  • 元组(tuple)用圆括号()标识,定义元组后,元组元素不可修改。如果想修改元组只能重新定义元组。因为元组不可更改,所以也没有增删改等用法,主要语法就是访问元组元素,遍历元组。访问元组元素:1 tuple1 = (1, 2, 3...

    元组(tuple)

    用圆括号()标识,定义元组后,元组元素不可修改。如果想修改元组只能重新定义元组。

    因为元组不可更改,所以也没有增删改等用法,主要语法就是访问元组元素,遍历元组。

    访问元组元素:

    1 tuple1 = (1, 2, 3, 4)

    2 print(tuple1)

    3 print(tuple1[0]) # 虽然元组是用(),但是当使用索引时还是使用tuple[]。

    输出结果:

    (1, 2, 3, 4)

    1

    遍历元组:

    用while循环遍历:

    1 index = 0

    2 while index < len(tuple1):

    3 print(tuple1[index])

    4 index += 1

    输出结果:

    1

    2

    3

    4

    用for循环遍历:

    1 tuple1 = (1, 2, 3, 4)

    2 for i in tuple1:

    3 print(i)

    字典(dictionary)

    是一系列键值对,包括在花括号内({}),每个对之间用逗号隔开,键必须是唯一的,值则不必。

    字典的增删查改:

    (1)添加键值对

    1 dic_people = {'name': 'abc', 'color': 'yellow'}

    2 print(dic_people)

    3

    4 dic_people['old'] = 18           # 添加键

    5 dic_people['language'] = 'english'    # 添加值

    6

    7 print(dic_people)

    输出结果:

    {'name': 'abc', 'color': 'yellow'}

    {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english'}

    (2)删除键值对

    1 dic_people = {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english'}

    2 print(dic_people)

    3

    4 del dic_people['language']    # 字典使用del语句删除一对键值对

    5

    6 print(dic_people)

    输出结果:

    {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english'}

    {'name': 'abc', 'color': 'yellow', 'old': 18}

    (3)查询字典

    1 dic_people = {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english'}

    2 print(dic_people)

    3 # print(dic_people[0]) # 字典不能通过索引小标来访问

    4 print(dic_people['old'])

    5 # print(dic_people[18]) # 只能通过键值查询key值,不能通过key值查询

    输出结果:

    {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english'}

    18

    (4)修改字典

    1 dic_people = {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english'}

    2 print(dic_people)

    3

    4 dic_people['old'] = 20

    5 print(dic_people)

    输出结果:

    {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english'}

    {'name': 'abc', 'color': 'yellow', 'old': 20, 'language': 'english'}

    遍历字典

    (1)遍历所有的键值对

    使用dic.items()

    1 dic_people = {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english'}

    2

    3 for key,value in dic_people.items():

    4 # print(key1, value1)

    5 # print(key1 + ':'+ value1) # 注意:使用加号(+)会出错,因为dic_people中old的值是int型

    6 print(key, ':', value)

    输出结果:

    name : abc

    color : yellow

    old : 18

    language : english

    (2)遍历所有的键值

    使用dic.keys()

    1 dic_people = {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english'}

    2

    3 for key in dic_people.keys():

    4 print(key)

    输出结果:

    name

    color

    old

    language

    (3)遍历所有的value值

    使用dic.values()

    1 dic_people = {'name': 'abc', 'color': 'yellow', 'old': 20, 'language': 'english', 'length': 18}

    2 for value in dic_people.values():

    3 print(value)

    输出结果:

    abc

    yellow

    18

    english

    18

    从上面的示例可以看到输出结果中有重复项,如果我们不想要重复项怎么办?可以使用set(dic.values())

    1 dic_people = {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english', 'length': 18}

    2

    3 for value in set(dic_people.values()): # 去掉重复项

    4 print(value)

    输出结果:

    english

    18

    abc

    yellow

    从上面的几个实例可以看出都是for循环加上字典调用函数实现遍历相应的值,那么不调用函数可以for循环遍历吗?

    1 dic_people = {'name': 'abc', 'color': 'yellow', 'old': 18, 'language': 'english'}

    2 for key in dic_people:

    3 print(key)

    输出结果:

    name

    color

    old

    language

    可以看出不调用函数的结果是遍历key值,为什么会这样呢?这就涉及到for循环的本质了,在后面的迭代器中会讲的for循环的本质是什么。

    希望与广大网友互动??

    点此进行留言吧!

    展开全文
  • 元组 — tuple元组:也是一个容器类型,可以...元组的表现形式: (1, "3"),最外层表现形式是一对小括号my_tuple = (1, 3.14, True, "abc", [1, 2], (1, 54))print(my_tuple)print(type(my_tuple))######### 运行结...

    元组 — tuple

    元组:也是一个容器类型,可以存储多个任意类型的数据,元组好比是一个只读的列表,只能获取数据不能对元组中的数据进行修改。

    元组的表现形式: (1, "3"),最外层表现形式是一对小括号

    my_tuple = (1, 3.14, True, "abc", [1, 2], (1, 54))

    print(my_tuple)

    print(type(my_tuple))

    ######### 运行结果 ############

    (1, 3.14, True, 'abc', [1, 2], (1, 54))

    不能对元组中的数据进行修改

    如果对元组中的数据进行修改就会报错:

    my_tuple = (1, 3.14, True, "abc", [1, 2], (1, 54))

    my_tuple[0] = 2

    del my_tuple[-1]

    print(my_tuple)

    ######### 运行结果 ############

    TypeError: 'tuple' object does not support item assignment

    注意:元组只能获取数据

    根据下标获取元组中的数据

    my_tuple = (1, 3.14, True, "abc", [1, 2], (1, 54))

    result = my_tuple[0]

    print(result)

    result = my_tuple[-1]

    print(result)

    ######### 运行结果 ############

    1

    (1, 54)

    元组的切片

    字符串,列表,元组都有切片处理

    my_tuple = (1, 3.14, True, "abc", [1, 2], (1, 54))

    result = my_tuple[1:4]

    print(result)

    ######### 运行结果 ############

    (3.14, True, 'abc')

    元组的使用场景:

    函数的返回值是元组,保证返回的数据不能修改

    print函数进行格式化输出的时候使用元组

    通过元组给多个格式化占位符进行传参:

    print("我叫:%s 年龄:%d" % ("李四", 20))

    ######### 运行结果 ############

    我叫:李四 年龄:20

    元组的注意点:

    元组里面的数据不能修改(添加,删除,修改)

    当元组里面只有一个元素,元组里面的逗号不能省略

    元祖中若只有一个元素时把后面的逗号省去了将不再是元祖类型:

    my_tuple = ("abc",)

    my_tuple1 = ([1, 2],)

    print(my_tuple, type(my_tuple))

    print(my_tuple1, type(my_tuple1))

    print("=== 元祖中只有一个元素把后面的逗号省去了将不再是元祖类型 ===")

    my_tuple2 = ("abc")

    my_tuple3 = ([1, 2])

    print(my_tuple2, type(my_tuple2))

    print(my_tuple3, type(my_tuple3))

    ######### 运行结果 ############

    ('abc',)

    ([1, 2],)

    === 元祖中只有一个元素把后面的逗号省去了将不再是元祖类型 ===

    abc

    [1, 2]

    index和count方法结合元组使用

    count: 统计指定数据在元组里面的次数

    my_tuple = (1, 3, "1", 1)

    # 统计指定数据1在元组里面出现的次数

    result = my_tuple.count(1)

    print(result)

    ######### 运行结果 ############

    2

    index: 根据指定数据,获取数据在元组的下标

    my_tuple = (1, 3, "1", 1)

    # 元祖结合index使用获取数据3在元组的下标

    result = my_tuple.index(3)

    ######### 运行结果 ############

    1

    元祖的遍历

    for循环遍历元组中的每一个数据

    my_tuple = ('西施', "貂蝉", "王昭君", "杨玉环")

    for value in my_tuple:

    print(value)

    ######### 运行结果 ############

    西施

    貂蝉

    王昭君

    杨玉环

    while循环遍历元祖中的每一个数据

    my_tuple = ('西施', "貂蝉", "王昭君", "杨玉环")

    index = 0

    while index <= 3:

    result = my_tuple[index]

    print(result)

    index += 1

    ######### 运行结果 ############

    西施

    貂蝉

    王昭君

    杨玉环

    扩展:len: 获取容器类型数据的长度, len函数获取字符串、列表、元组类型的个数

    my_tuple = ('西施', "貂蝉", "王昭君", "杨玉环")

    number = len(my_tuple)

    print(number)

    ######### 运行结果 ############

    4

    应用:

    my_tuple = ('西施', "貂蝉", "王昭君", "杨玉环")

    ##len函数获取元组的结束下标

    index = len(my_tuple) - 1

    while index >= 0:

    result = my_tuple[index]

    print(result)

    index -= 1

    ######### 运行结果 ############

    杨玉环

    王昭君

    貂蝉

    西施

    扩展:反向输出

    my_tuple = ('西施', "貂蝉", "王昭君", "杨玉环")

    result = my_tuple[::-1]

    print(result)

    ######### 运行结果 ############

    ('杨玉环', '王昭君', '貂蝉', '西施')

    字典 — dict

    字典:也是一个容器类型,字典里面的每一个数据都是键值对(key:value), 字典的最外层表现形式: {key:value, ....}

    学习字典的目的: 对于存储描述性信息可以使用字典,比如:存储学生信息,老师信息,教室信息,电脑信息

    注意:字典中的key是唯一的, 不能重复

    定义字典

    my_dict = {"age": 20, "name": "李四", "address": "北京", "sex": "女"}

    print(my_dict, type(my_dict))

    ######### 运行结果 ############

    {'age': 20, 'name': '李四', 'address': '北京', 'sex': '女'}

    通过key获取对应的value值

    my_dict = {"age": 20, "name": "李四", "address": "北京", "sex": "女"}

    value = my_dict["age"]

    print(value)

    sex = my_dict["sex"]

    print(sex)

    ######### 运行结果 ############

    20

    使用上面这种中括号方式获取字典中的value值,如果key不存在那么程序会报错

    比如我们想要获取“李四”的学历(educational_history)字典中并没有:

    my_dict = {"age": 20, "name": "李四", "address": "北京", "sex": "女"}

    result = my_dict["educational_history"]

    print(result)

    ######### 运行结果 ############

    KeyError: 'educational_history'

    get方式取值(value)

    get方式取值可以提供默认值,如果字典有对应的key,获取key对应的value值,没有就使用默认值:

    my_dict = {"age": 20, "name": "李四", "address": "北京", "sex": "女"}

    # get方式取值,如果字典有对应的key就获取key对应的value值

    value = my_dict.get("age")

    print(value)

    # 如果字典没有对应的key使用默认值

    result = my_dict.get("educational_history", "硕士")

    print(result)

    ######### 运行结果 ############

    20

    硕士

    字典的增删改查

    添加键值对

    注意点:如果操作的key在字典里面不存在,那么是添加键值对操作

    my_dict = {"name": "西施", "age": 25}

    print(my_dict)

    # 添加键值对

    my_dict["address"] = "杭州"

    print(my_dict)

    my_dict["sex"] = "女"

    print(my_dict)

    ######### 运行结果 ############

    {'name': '西施', 'age': 25}

    {'name': '西施', 'age': 25, 'address': '杭州'}

    {'name': '西施', 'age': 25, 'address': '杭州', 'sex': '女'}

    修改键值对

    注意点:如果操作的key在字典里面,那么是修改键值对操作

    my_dict = {"name": "西施", "age": 25}

    print(my_dict)

    # 修改键值对,注意点:如果操作的key在字典里面,那么是修改键值对操作

    my_dict["age"] = 20

    print(my_dict)

    ######### 运行结果 ############

    {'name': '西施', 'age': 25}

    {'name': '西施', 'age': 20}

    删除键值对

    del

    my_dict = {"name": "西施", "age": 25, "address": "杭州"}

    print(my_dict)

    ##删除键值对

    del my_dict["address"]

    print(my_dict)

    ######### 运行结果 ############

    {'name': '西施', 'age': 25, 'address': '杭州'}

    {'name': '西施', 'age': 25}

    pop

    扩展:根据key删除键值对,并且返回key对应的value值

    my_dict = {"name": "西施", "age": 25, "address": "杭州"}

    print(my_dict)

    ##pop有返回值

    value = my_dict.pop("age")

    print(value, my_dict)

    ######### 运行结果 ############

    {'name': '西施', 'age': 25, 'address': '杭州'}

    25 {'name': '西施', 'address': '杭州'}

    查看数据,获取数据

    my_dict = {"name": "西施", "age": 25, "address": "杭州"}

    result1 = my_dict["name"]

    result2 = my_dict["address"]

    print(result1, result2)

    ######### 运行结果 ############

    西施 杭州

    清除字典中的所有数据

    my_dict = {"name": "西施", "age": 25, "address": "杭州"}

    print(my_dict)

    ##清除字典中的所有数据

    my_dict.clear()

    print(my_dict)

    ######### 运行结果 ############

    {'name': '西施', 'age': 25, 'address': '杭州'}

    {}

    清除列表中的所有数据

    my_list = [1, 3, 5]

    print(my_list)

    ##清除列表中的所有数据

    my_list.clear()

    print(my_list)

    ######### 运行结果 ############

    [1, 3, 5]

    []

    扩展:列表里面通过 extend 完成列表的合并,字典里面通过 update 完成字典的合并

    字典的合并 — update

    my_dict1 = {"name": "貂蝉", "age": 20}

    my_dict2 = {"sex": "女", "address": "无锡", "age": 25}

    print(my_dict1)

    print(my_dict2)

    # 把my_dict2字典中的每一个键值对添加到my_dict1里面

    print("====== 合并后 =====")

    my_dict1.update(my_dict2)

    print(my_dict1)

    ######### 运行结果 ############

    {'name': '貂蝉', 'age': 20}

    {'sex': '女', 'address': '无锡', 'age': 25}

    ====== 合并后 =====

    {'name': '貂蝉', 'age': 25, 'sex': '女', 'address': '无锡'}

    字典的常见的操作

    len函数获取字典的个数

    len函数还可以获取:字符串,列表,元组,字典的个数

    my_dict = {"name": "猪八戒", "sex": "男"}

    # 获取字典的个数

    result = len(my_dict)

    print(result)

    ######### 运行结果 ############

    2

    keys方法获取字典中的所有key

    my_dict = {"name": "猪八戒", "sex": "男"}

    # keys方法获取字典中的所有key

    result = my_dict.keys()

    # 返回的是dict_keys类型, 查看数据不方便,可以转换成list类型

    print(result, type(result))

    # 把dict_keys类型转成list

    my_list = list(result)

    print(my_list, type(my_list))

    ######### 运行结果 ############

    dict_keys(['name', 'sex'])

    ['name', 'sex']

    values方法获取字典中的所有value

    my_dict = {"name": "猪八戒", "sex": "男"}

    # values方法: 获取字典中的所有value

    result = my_dict.values()

    # 返回的类型是dict_values,查看数据不方便,可以转换成list类型

    print(result, type(result))

    my_list = list(result)

    print(my_list, type(my_list))

    ######### 运行结果 ############

    dict_values(['猪八戒', '男'])

    ['猪八戒', '男']

    items方法获取字典中的所有项数据,每一项数据是一个键值对数据

    my_dict = {"name": "猪八戒", "sex": "男"}

    result = my_dict.items()

    # 返回的数据类型:dict_items,查看数据不方便可以转换list类型

    print(result, type(result))

    my_list = list(result)

    print(my_list, type(my_list))

    ######### 运行结果 ############

    dict_items([('name', '猪八戒'), ('sex', '男')])

    [('name', '猪八戒'), ('sex', '男')]

    字典的遍历

    遍历字典中的所有key

    my_dict.keys() 获取字典中的所有key

    my_dict = {"name": "小明", "age": 18, "sex": "男", "address": "北京"}

    # 遍历字典中的所有key

    for key in my_dict.keys(): # my_dict.keys() 获取字典中的所有key

    # 根据key获取对应的value值

    value = my_dict[key]

    print(key, value)

    ######### 运行结果 ############

    name 小明

    age 18

    sex 男

    address 北京

    遍历字典中的所有value

    my_dict = {"name": "小明", "age": 18, "sex": "男", "address": "北京"}

    for value in my_dict.values():

    print(value)

    ######### 运行结果 ############

    小明

    18

    北京

    遍历字典中的所有项(item)

    my_dict = {"name": "小明", "age": 18, "sex": "男", "address": "北京"}

    for item in my_dict.items():

    # 遍历的每项数据是一个元组类型,元组里面存放的是key和value

    print(item, type(item))

    # 根据下标获取元组中的数据

    # 获取key

    key = item[0]

    value = item[1]

    print(key, value)

    ######### 运行结果 ############

    ('name', '小明')

    name 小明

    ('age', 18)

    age 18

    ('sex', '男')

    sex 男

    ('address', '北京')

    address 北京

    遍历的每项数据是一个元组,使用不同变量保存元组中的每一个数据,这里是操作是拆包:

    my_dict = {"name": "小明", "age": 18, "sex": "男", "address": "北京"}

    for key, value in my_dict.items():

    print(key, value)

    ######### 运行结果 ############

    name 小明

    age 18

    sex 男

    address 北京

    扩展: 直接遍历字典,默认取的是字典的key

    my_dict = {"name": "小明", "age": 18, "sex": "男", "address": "北京"}

    for key in my_dict:

    print(key)

    ######### 运行结果 ############

    name

    age

    sex

    address

    enumerate函数的使用

    enumerate函数:当使用for循环遍历数据时,又想使用数据对应的下标又想使用数据就可以使用enumerate函数了。

    如果不使用 enumerate 函数想要遍历数据时又获取下标又获取数据,就需要设置一个变量存放下标:

    my_list = ["a", "b", "c"]

    # 记录当前数据的下标

    index = 0

    for value in my_list:

    print(index, value)

    index += 1

    ######### 运行结果 ############

    0 a

    1 b

    2 c

    使用enumerate函数就会方便很多:

    my_list = ["a", "b", "c"]

    for item in enumerate(my_list): # enumerate(my_list)表示又取下标又取数据

    # 遍历的每项数据是一个元组

    print(item)

    ######### 运行结果 ############

    (0, 'a')

    (1, 'b')

    (2, 'c')

    遍历的每项数据是一个元组,对元组进行拆包处理:

    my_list = ["a", "b", "c"]

    for index, value in enumerate(my_list):

    print(index, value)

    ######### 运行结果 ############

    0 a

    1 b

    2 c

    结合break语句使用:

    my_list = ["a", "b", "c"]

    for index, value in enumerate(my_list): # enumerate(my_list)表示又取下标又取数据

    print(index, value)

    if index == 1:

    break

    ######### 运行结果 ############

    0 a

    1 b

    扩展: enumerate可以结合列表,字符串,元组,字典

    例如,enumerate结合字典:

    my_dict = {"name": "小明", "age": 18, "sex": "男", "address": "北京"}

    for index, item in enumerate(my_dict.items()):

    if index == 2:

    break

    # 利用拆包,获取元组中的每项数据

    key, value = item

    print(key, value)

    ######### 运行结果 ############

    name 小明

    age 18

    enumerate结合字符串:

    my_str = "hello"

    for index, value in enumerate(my_str):

    print(index, value)

    ######### 运行结果 ############

    0 h

    1 e

    2 l

    3 l

    4 o

    字典的使用练习题:一个学校,有3个办公室,现在有8位老师等待工位的分配,请使用字典编写程序,完成随机的分配

    import random

    # 1. 三个办公室,办公室是可以容纳老师的,所以每一个办公室就是一个小列表

    # my_list1 = []

    # my_list2 = []

    # my_list3 = []

    # 办公室列表,里面的每个元素表示一个办公室,每个办公室还是一个列表

    office_list = [[], [], []]

    # 2. 8位老师,可以定义一个老师列表,存储8位老师

    teacher_list = ["刘老师", "王老师", "郭老师", "马老师", "牛老师", "杨老师", "朱老师", "侯老师"]

    # 3. 依次获取老师列表中的每一位老师,然后把老师随机分配到指定办公室

    for teacher in teacher_list:

    # 生产随机数字,随机数字就是办公室的下标

    index = random.randint(0, 2)

    # 根据生产的下标获取对应的办公室

    office = office_list[index]

    # 把老师添加到随机的办公室里面

    office.append(teacher)

    # 遍历办公室列表,获取每一个办公室

    for index, office in enumerate(office_list):

    # 查看每一个办公室,每个办公室是一个列表

    num = index + 1

    # 获取办公室老师的个数

    count = len(office)

    print("第%d个办公室总人数为:%d人" % (num, count))

    # 遍历办公室,获取每一个老师信息

    for teacher in office:

    # 查看每一个老师的信息

    print(teacher)

    num += 1

    ######### 运行结果 ############

    第1个办公室总人数为:2人

    王老师

    朱老师

    第2个办公室总人数为:3人

    郭老师

    马老师

    侯老师

    第3个办公室总人数为:3人

    刘老师

    牛老师

    杨老师

    黑马程序员Python45期基础课上课笔记

    展开全文
  • 笔记目录第二章 变量和简单数据类型2.1 输出一个hello world2.2 变量定义2.3.1 使用方法修改字符串大小写(title,upper,lower)2.3.2 合并字符串(str + str)2.3.4 删除空白(str.strip() str.lstrip() str.rstrip()...

    笔记目录

    第二章 变量和简单数据类型

    2.1 输出一个hello world

    2.2 变量的定义

    2.3.1 使用方法修改字符串的大小写(title,upper,lower)

    2.3.2 合并字符串(str + str)

    2.3.4 删除空白(str.strip() str.lstrip() str.rstrip() )

    第三章 列表简介

    3.1 建立并访问列表

    3.2 修改添加和删除元素

    3.3 组织列表(永久排序,临时排序,永久反转,确定长度)

    第四章 操作列表

    4.1 遍历列表(for语句)

    4.3 创建数字列表

    4.4 使用列表的一部分(切片)

    4.5 元组(不可变的列表)

    第五章 if语句

    5.1 基本句法

    5.2 用if检查列表中是否有某一个元素

    5.3 确定列表不是空的

    第六章 字典

    6.2 使用字典

    6.3 遍历字典

    6.4 嵌套

    第七章 用户输入和while循环

    7.1 用函数input()进行用户输入

    7.2 while循环简介

    第八章 函数

    8.1 定义函数

    第二章 变量和简单数据类型

    2.1 输出一个hello world

    print("hello world")

    #用#进行注释

    2.2 变量的定义

    num1 = 1 #整型

    num2 = 1.0 #浮点型

    str1 = 'abcd' #字符串型

    str2 = "abcd" #字符串型

    bool1 = True #布尔型

    直接用 变量名=变量值 来定义,系统自动检测变量的类型

    2.3.1 使用方法修改字符串的大小写(title,upper,lower)

    name = "i loVe pYthon"

    print(name.upper()) #临时转为大写

    print(name.lower()) #临时转为小写

    print(name.title()) #临时首字母大写

    2.3.2 合并字符串(str + str)

    first_name = "abc"

    last_name = "def"

    name = first_name + last_name

    print(name)

    ================ 运行结果 ================

    abcdef

    >>>

    2.3.4 删除空白(str.strip() str.lstrip() str.rstrip() )

    c = " python "

    print("."+c.rstrip()+".") #删除右边的空白

    print("."+c.lstrip()+".") #删除左边的空白

    print("."+c.strip()+".") #删除两边的空格

    ================ 运行结果 ================

    . python.

    .python .

    .python.

    >>>

    第三章 列表简介

    3.1 建立并访问列表

    arr = ['a','b','c']

    print(arr[0]) #类似于C,用下标的方式寻找

    print(arr[-2]) #访问倒数第二个元素

    3.2 修改添加和删除元素

    1.修改元素

    s = ["abc","def"]

    s[0] = "ghi" # 修改

    >>>

    2.添加元素(添加append、插入insert)

    s = ["a","b","c","d"]

    s.append("添加了e")

    s.insert(1,"插入了python")

    print(s)

    ============= RESTART: C:\Users\Administrator\Desktop\python.py =============

    ['a', '插入了python', 'b', 'c', 'd', '添加了e']

    >>>

    3.删除元素

    s = ["a","b","c","d"]

    del s[0] #无返回值删除

    temp1 = s.pop() #删除最后一个元素 并返回

    temp2 = s.pop(1) #删除index=1的元素 并返回

    s.remove('b') #根据值删除元素

    3.3 组织列表(永久排序,临时排序,永久反转,确定长度)

    arr = [2,1,3,4,5]

    arr.sort() #顺序永久排序

    arr.sort(reverse=True) #倒序永久排序

    print(arr.sorted) #临时顺序排序

    arr.reverse() #永久反转

    lenth=len(arr) #获取列表的长度

    第四章 操作列表

    4.1 遍历列表(for语句)

    ss = ['ab','cd','ef']

    for s in ss:

    print('进入循环')

    print(s)

    print("Thanks")

    ============= RESTART: C:\Users\Administrator\Desktop\python.py =============

    进入循环

    ab

    进入循环

    cd

    进入循环

    ef

    Thanks

    >>>

    1.第二行代码让python从列表ss中依次取出一个元素,并将其储存在s变量中

    2.在代码行for s in ss:后面缩进的代码行都是循环的一部分

    4.3 创建数字列表

    1.使用range()函数

    for value in range(1,5):

    print(value)

    ============= RESTART: C:\Users\Administrator\Desktop\python.py =============

    1

    2

    3

    4

    >>>

    实际上range()函数返回一个临时的列表

    2.用list()将range()的结果转换为列表

    numbers = list(range(1,5))

    print(numbers)

    ============= RESTART: C:\Users\Administrator\Desktop\python.py =============

    [1, 2, 3, 4]

    >>>

    3.创建一个包含前10个整数平方的列表

    arr = []

    for value in range(1,11):

    arr.append(value**2)

    print(arr)

    ============= RESTART: C:\Users\Administrator\Desktop\python.py =============

    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

    >>>

    value**2表示value的平方,同理value**n代表value的n次方

    4.对数字进行简单的统计计算(min,max,sum函数)

    >>> digits = [1,2,3,4,5,6,7,8,9,10]

    >>> min(digits)

    1

    >>> max(digits)

    10

    >>> sum(digits)

    55

    5.列表解析(一行代码生成 前10个整数平方的 列表)

    arr = [value**2 for value in range(1,11)]

    for value in range(1,11)语句依次对value赋值

    4.4 使用列表的一部分(切片)

    1.切片

    >>> ss = ['a','b','c','d','e','f']

    >>> print(ss[1:3]) #输出下标 1-2 的元素

    ['b', 'c']

    >>> print(ss[:3]) #输出前三个元素

    ['a', 'b', 'c']

    >>> print(ss[1:]) #输出下标 1 之后的元素

    ['b', 'c', 'd', 'e', 'f']

    >>> print(ss[-2:]) #输出倒数2个元素

    ['e', 'f']

    2.遍历切片

    >>> ss = ['a','b','c','d','e','f']

    >>> for temp in ss[1:4]:

    >>> print(temp)

    b

    c

    d

    3.复制列表

    ss = ['a','b','c','d','e','f']

    temp1 = ss[:]

    temp2 = ss

    temp1 = ss[:]为值的复制,若修改temp1,ss不会受到影响

    temp2 = ss为地址的复制,相当于C++中的创建引用。若修改temp2,那么ss也会被修改

    4.5 元组(不可变的列表)

    #定义元组(用括号)

    arr = (1,2,3,4)

    print(arr[0])

    #遍历元组的值

    for temp in arr:

    print(temp)

    #修改元组的值(不能修改元组的元素,但是可以给存储元组的变量赋值

    arr1 = (1,2)

    arr1[0] = 2 ×

    arr1 = (3,4) √

    第五章 if语句

    5.1 基本句法

    old = 18

    if old<2:

    print("婴儿")

    elif old>=2 and old<4:

    print("蹒跚学步")

    elif old>=4 and old<13:

    print("儿童")

    elif old>=13 and old<18:

    print("青少年")

    else:

    print("成年人")

    5.2 用if检查列表中是否有某一个元素

    ss = ['a','b','c']

    if 'a' in ss:

    print("YES")

    else:

    print("NO")

    ‘a’ in ss 如果a能在ss列表中找到,那么就返回True

    5.3 确定列表不是空的

    >>> ss = []

    >>> if ss:

    >>> print("不是空的")

    >>> else:

    >>> print("是空的")

    是空的

    第六章 字典

    6.2 使用字典

    1.字典的定义

    dic = {'name':'Amy','age':18}

    2.访问字典中的值(以1的定义为例)

    print(dic['name'])

    字典是一系列 键-值对 ,与键相关联的可以是 数字、字符串、列表甚至字典(任何python对象都可以与其相关联)

    3.添加 键-值对

    dic = {'name':'Amy','age':18}

    dic['score'] = 100

    添加’score’-100键-值对到字典的最后面

    4.修改字典中的值

    dic = {'name':'Amy','age':18}

    dic['name'] = 'Tom'

    5.删除键-值对

    dic = {'name':'Amy','age':18}

    del dic['name']

    print(dic)

    ============= RESTART: C:\Users\Administrator\Desktop\python.py =============

    {'age': 18}

    >>>

    6.3 遍历字典

    1.遍历所有的键-值对(用items()方法)

    dic = {

    'name':'Amy',

    'age':18,

    'score':100

    }

    for key,value in dic.items():

    print(key + ':' + str(value))

    ============= RESTART: C:\Users\Administrator\Desktop\python.py =============

    name:Amy

    age:18

    score:100

    >>>

    1.dic.items() 分别将键与值赋值给key与value

    2.str(value)将数值强制转换为字符型,才可以用+运算符

    2.遍历字典中所有的键(keys()方法)与值(values()方法)

    for key in dic.keys():######

    for value in dic.values():######

    遍历键也可以不用keys,直接for key in dic:,但是用keys方法更容易被理解

    3.按顺序遍历字典中所有的键

    for key in sorted(dic.keys()):#####

    使用sorted函数将dic的键列表暂时排序

    4.用set()函数去重

    dic = {1:'a',2:'b',3:'a'}

    for value in set(dic.values()):

    print(value)

    ============= RESTART: C:\Users\Administrator\Desktop\python.py =============

    a

    b

    >>>

    6.4 嵌套

    P93:有时候,需要将一系列字典存储在列表里,或将列表作为值存储在字典里,这称为嵌套(略)

    第七章 用户输入和while循环

    7.1 用函数input()进行用户输入

    name = input("Enter your name: ")

    name = 'Hello ' + name

    print(name)

    ============= RESTART: C:\Users\Administrator\Desktop\python.py =============

    Enter your name: Tom

    Hello Tom

    >>>

    7.2 while循环简介

    i = 1

    while i<=5:

    print(i)

    i+=1

    while语句内部也可以用continue和break,规则与C++相同

    第八章 函数

    8.1 定义函数

    python莫得数据类型(好吧,是弱化了),所以不需要

    def show():

    '''文档字符串,可以用来描述函数功能'''

    print('Hello World')

    show()

    展开全文
  • Python for循环能够遍历任何序列项目,如列表、字符串、元组、字典、集合等序列类型。java 语法:pythonfor循环语法格式以下:shellfor iterating_var insequence:statements(s)流程图:数据结构 animals="dog",...
  • 一个Python字典短则包含一个键值对,长则可能数百万计。所以我们不会遍历字典可不行。因为Python字典是由一系列键值对组成,所以我们可以遍历字典所有键值对、键或值。1.遍历字典中所有键值对我们还是从一个...
  • 在学习C语言或者Python时,一个很头疼问题就是格式化输出,因此在本文中,将几种常见格式化输出形式进行归纳总结,以便记忆。 Python格式化字符串 在 % 操作符左侧放置一个需要进行格式化字符串,这...
  • 作用:将字典dit列表返回可遍历的(键, 值) 元组数组 如: dict = {'b':'B','a':'A'} print(dict.items()) for i in dict.items(): print(i) 输出结果: ...现在知道items()是列表的形式返...
  • 一、将下列姓名长度小于2字符的删除,将写法不同但名字一样的名字合并,并按首字母大写形式输出。 names=[‘Bob’,‘JOHN’,‘alice’,...二、将上题列表中所有重名人员进行计数并字典的形式表示出来 。要求输出 格
  • python格式化输出

    千次阅读 2018-09-28 09:18:16
    以及format,前者是从C借鉴过来语法,但是这对于拥有很多先进数据结构的Python来说有点力不从心,Python的元组、列表、字典等不适合这种结构表示,所以需要更合适format,它是借鉴C#语法。 %形式格式化...
  • 字符串常量的形式存储在内存中,在向变量赋值时仅将字符串常量的地址赋给相应变量,当用此变量赋值给其他变量时,仅将地址赋值给新变量(使用三引号声明的字符串会单独的常量池中开辟空间,因此若同一字符串使用三引号...
  • 函数定义 函数代码块def关键字开头,后接函数标识符名称和圆括号()。...4、形式为*name,接收一个包含除了己有形参列表以外位置参数 元组 形参 5、特殊参数 仅限关键字,在参数前面加def medth(*,a
  • 序列是python中最基本的数据结构,包括列表...食用方法:本次内容代码块的形式展现代码块中#号后面的文字是对代码的解释每个代码块后都有一个输出结果,展示的是该代码块在python中运行后的输出结果。#列表的特征 ...
  • 2. 编写函数,接收一个字符串,分别统计大写字母、小写字母、数字、其他字符的个数,并以元组的形式返回结果。3. 使用循环方法求解百钱买百鸡问题。假设公鸡5元一只,母鸡3元一只,小鸡1元3只,现有100元钱想买100只...
  • Python中*args与**kwargs的使用方法和区别 首先他们的共同点是,他们都...结果是以元组的形式输出 示例2: 结果是a,b会接受前两个参数,后面的全部参数由*args接收。 二、**kwargs的使用方法 **kwarg...
  • python正则表达式

    2021-01-12 20:06:15
    python正则表达式笔记 学习正则表达式笔记 代码如下: import re #match 匹配以xxx开头的字符串,第一个参数是正则,第二个是所需要匹配的...res.group(1)#如果有多个匹配结果以元组的形式存放在哪group对象中 r
  • 1.只想单纯排序key或者value这种情况只会以元组的形式输出排序好的key或者value 2.按key/value排序并以列表形式输出排好序key(value)以及相对应的value(key)
  • (注:本文部分内容摘自互联网,由于...一、*args的使用方法*args 用来将参数打包成tuple给函数体调用例子一:def function(*args):print(args, type(args))function(1)输出结果以元组的形式展示:例子二:def fun...
  • 注:《python核心编程第2版》的11.6可变长度的参数---章节中有详细介绍。 一、*args的使用方法 *args 用来将参数打包成tuple给函数体调用 例子一: def function(*args): ... 输出结果以元组的形式展示: ...
  • 不定长参数一:*args将实参中剩余的值都传递给变量args剩余的值在args中,以元组的形式保存如图,test函数中的3,4将会以一个元组的形式传递给args,具体表现看输出结果第三行元组(3,4),那么函数中的*args中的星号...
  • Python学习15--函数补充

    2018-07-19 20:11:56
    def f(*args): print(args) a = [1,2,3] f(*a)#为了直接显示一个列表,不加*则以元组中以一个列表作为... # 加* 以元组的形式输出:(1, 2, 3) def f(**kwargs): print(kwargs) f(name="duyang")#正...
  • python 04

    2019-08-09 17:41:33
    生成器: 异常信息的获取对于程序的调试非常重要,可以有助于快速定位有错误程序语句的位置。 在Python中,我们可以将那些在运行时...输出结果以元组的形式展示:              **kwargs:代参数名称...
  • Python中time模块用法

    千次阅读 2020-08-08 23:18:14
    前言:在平常代码中,我们常常需要与时间打交道。那么在Python中,与时间处理有关模块就包括:...格式化时间字符串: 即格式化字符串格式输出时间形式元组格式表示法: 即一种Python的数据结构表示。这
  • Python字典基本操作

    2020-06-08 21:59:25
    概念:字典是一种键值对(key:value)的形式保存数据的数据结构。 特点: 键必须是唯一的,值可以不唯一 键的类型只能是字符串,数字或元组;值的类型可以是任意类型 字典中的数据是可变的,无序的 通过键可以快速...
  • 当数据这种形式呈现时候,通过Python标准API来同关系型数据库进行交互相对来说就显得很直接了。这个API要点就是数据库上所有操作都通过SQL查询来实现,每一行输入或输出数据都由一个元组来表示。我们可以...
  • 格式化时间字符串: 即格式化字符串格式输出时间形式元组格式表示法: 即一种Python的数据结构表示。这个元组有9个整型内容(不能少),分别表示不同时间含义。 索引(Index) 属性(Attribute) 值

空空如也

空空如也

1 2 3 4 5
收藏数 96
精华内容 38
关键字:

python以元组的形式输出

python 订阅