第五篇.python进阶

￡神魔★判官ぃ 2021-11-01 09:06 414阅读 0赞

*  第五篇.python进阶
    
     *  1. 异常处理
     *  2. 数字类型内置方法
        
         *  2.定义：
         *  3.常用操作+内置方法：
         *  4.存一个值or多个值：
         *  5.有序or无序：
         *  6.可变和不可变
         *  1.用途：
         *  2.定义：
         *  3.常用操作+内置方法：
         *  4.存一个值or多个值：
         *  5.有序or无序：
     *  4. 字符串类型内置方法
        
         *  1.用途：
         *  2.定义：
         *  3.**常用操作+内置方法：**
     *  5. 列表类型的内置方法
     *  6. 元组类型的内置方法
     *  7. 字典类型的内置方法
     *  8. 集合类型的内置方法
     *  9. 数据类型分类

# 第五篇.python进阶 #

## 1. 异常处理 ##

\#\#\# 1. 什么是异常  
\#\#\# 2. 异常的种类  
\#\#\# 3. 异常的处理  
\#\#\# 4. try-except总结  
\#\#\# 5. 抛出异常raise  
\#\#\# 6. 断言assert

## 2. 数字类型内置方法 ##

\#\#\#1. 整型内置方法（int）

\#\#\#2.用途：

年龄、号码、等级

### 2.定义： ###

可以使用int()方法将纯数字的字符串转为十进制的整型

age = 19  # age = int(10)
    print(type(age))

`<class 'int'>`

x = int('111')
    print(type(x))

`<class 'int'>`

x = int('11.1')  # 报错
    print(x)

### 3.常用操作+内置方法： ###

算术运算+比较运算

### 4.存一个值or多个值： ###

一个值

### 5.有序or无序： ###

整型麻油有序or无序一说

### 6.可变和不可变 ###

可变：变量值变了，id不变

不可变：变量值变了，id也变了

**整型属于不可变：**

age = 19
    print(f'first:{id(age)}')
    age = 20
    print(f'second:{id(age)}')

`first:4384901776`

`second:4384901808`

\#\#3. 浮点型内置方法（float）

### 1.用途： ###

薪资、身高、体重

### 2.定义： ###

可以使用float()方法将纯数字的字符串转为浮点型数字。

age = 3.1  # age = float(3.1)
    print(type(age))

`<class 'float'>`

x = float('111')
    print(x)
    print(type(x))

`111.0`

`<class 'float'>`

x = float('11.1')  # 报错
    print(type(x))

`<class 'float'>`

### 3.常用操作+内置方法： ###

算术运算+比较运算

### 4.存一个值or多个值： ###

一个值

### 5.有序or无序： ###

无有序or无序一说

**浮点型是不可变：**

salary = 3.1
    print(f'first:{id(salary)}')
    salary = 5.1
    print(f'second:{id(salary)}')

`first:4423173584`

`second:4423173800`

## 4. 字符串类型内置方法 ##

### 1.用途： ###

描述性质的东西，如人的名字、单个爱好、地址、国家等

### 2.定义： ###

使用''、""、''''''、""""""包裹的的一串字符

*  u'unicode': unicode编码的字符串
 *  b'101': 二进制编码的字符串
 *  r'\\n': 原生字符串，也就是说'\\n'这是普通的两个字符，并没有换行的意思
    
        name = 'nick'  # name =str('nick')
        s1 = str(1.1)
        s2 = str([1, 2, 3])
        
        print(f's1:{s1}, type:{type(s1)}')
        print(f's2:{s2}, type:{type(s2)}')
    
        s1:1.1, type:<class 'str'>
        s2:[1, 2, 3], type:<class 'str'>

### 3.**常用操作+内置方法：** ###

**常用操作和内置方法分为优先掌握（今天必须得记住）、需要掌握（一周内记住）、其他操作（了解）三个部分。**

#### 1.1优先掌握 ####

1.  按索引取值
2.  切片
3.  长度len
4.  成员运算in/not in
5.  移除空白strip
6.  切分split
7.  循环
    
    1.按索引取值（只能区，不能改变里面的东西）
    
        # str索引取值
        msg = 'hello nick'
        #      0123456789  # 索引序号
        
        print(f'索引为6: {msg[6]}')
        print(f'索引为-3: {msg[-3]}')
    
    `索引为6: n`
    
    `索引为-3: i`
    
    2.切片（顾头不顾尾：步长）
    
        # 索引切片
        msg = 'hello nick'
        #      0123456789  # 索引序号
        
        print(f'切片3-最后: {msg[3:]}')
        print(f'切片3-8: {msg[3:8]}')
        print(f'切片3-8，步长为2: {msg[3:8:2]}')
        print(f'切片3-最后，步长为2: {msg[3::2]}')
        
        # 了解，步长为正从左到右；步长为负从右到左
        print('\n**了解知识点**')
        print(f'切片所有: {msg[:]}')
        print(f'反转所有: {msg[::-1]}')
        print(f'切片-5--2: {msg[-5:-2:1]}')
        print(f'切片-2--5: {msg[-2:-5:-1]}')
    
        切片3-最后: lo nick
        切片3-8: lo ni
        切片3-8，步长为2: l i
        切片3-最后，步长为2: l ik
        
        **了解知识点**
        切片所有: hello nick
        反转所有: kcin olleh
        切片-5--2:  ni
        切片-2--5: cin
    
    3.长度len（）
    
        # str长度
        msg = 'hello nick'
        
        print(len(msg))
    
        4.成员运算in/not in
    
    # str成员运算 #
    
    msg = 'my name is nick, nick handsome'
    
    print(f"'nick' in msg: \{'nick' in msg\}")  
    print(f"'jason' not in msg: \{'jason' not in msg\}")  
    print(f"not 'jason' in msg: \{not 'jason' in msg\}")
    
    'nick' in msg: True  
    'jason' not in msg: True  
    not 'jason' in msg: True
    
        5.移除空白
    
    # str移除空白strip() #
    
    name = '&&&n ick'
    
    print(f"name.strip('&'): \{name.strip('&')\}") \# strip()默认为‘ ’，并且不修改原值，新创建空间  
    print(f"name: \{name\}")
    
    # strip()应用场景 #
    
    pwd = input('password: ') \# 用户可能会手抖输入空格  
    if pwd.strip() == '123':  
    print('密码输入成功')
    
    print(f"'*-& nick+'.strip('*\-& +'): \{'*-& nick+'.strip('*\-& +')\}")
    
    name.strip('&'): n ick  
    name: &&&n ick  
    password: 123  
    密码输入成功  
    '*-& nick+'.strip('*\-& +'): nick
    
        5.切分split
    
    # str切分split #
    
    info = 'nick:male:19'  
    info\_list1 = info.split(':')  
    info\_list2 = info.split(':', 1)
    
    print(f'info\_list1:\{info\_list1\}')  
    print(f'info\_list2:\{info\_list2\}')
    
    info\_list1:\['nick', 'male', '19'\]  
    info\_list2:\['nick', 'male:19'\]
    
        7.循环
    
    msg = 'hello nick'
    
    for i in msg:  
    print(i)  
    \`\`\`
    
    1.2需要掌握
    
    1.  lstrip&rstrip
    2.  lower&upper
    3.  startswith&endswith
    4.  rsplit
    5.  join
    6.  replace
    7.  isdigit
        
        1.  .lstrip()和rstrip()
            
                # str之lstrip()和rstrip()
                name = '&&nick&&'
                
                print(f"nick.lstrip('&'): {name.lstrip('&')}")
                print(f"nick.rstrip('&'): {name.rstrip('&')}")
            
                nick.lstrip('&'): nick&&
                nick.rstrip('&'): &&nick
        2.  lower()和upper()
            
                # str之lower()和upper()
                name = 'Nick Chen'
                
                print(f"name.upper(): {name.lower()}")
                print(f"name.upper(): {name.upper()}")
            
                name.upper(): nick chen
                name.upper(): NICK CHEN
        3.  startswith()和endswith()
            
                # str之startswith()和endswith()
                name = 'Nick Chen'
                
                print(f"name.startswith('Nick'): {name.startswith('Nick')}")
                print(f"name.endswith('chen'): {name.endswith('chen')}")
            
                name.startswith('Nick'): True
                name.endswith('chen'): False
        4.  rsplit()
            
                # str之rsplit()
                info = 'nick:male:19'
                
                print(f"info.rsplit(':', 1): {info.rsplit(':', 1)}")  # 从右开始切割
            
                info.rsplit(':', 1): ['nick:male', '19']
        5.  join()
            
                lis = [1,2,'19']
                print(f"':'.join(lis): {':'.join(lis)}")  # 报错，数字不可和字符串拼接
            
                # str之join()
                lis = ['nick', 'male', '19']
                
                print(f"':'.join(lis): {':'.join(lis)}")
            
            `':'.join(lis): nick:male:19`
        6.  replace()
            
                # str值replace()
                name = 'nick shuai'
                
                print(f"name.replace('shuai','handsome'): {name.replace('shuai','handsome')}")
            
            `name.replace('shuai','handsome'): nick handsome`
        7.  isdigit()
            
                # str值isdigit()
                salary = '111'
                print(salary.isdigit())  # True
                
                salary = '111.1'
                print(salary.isdigit())  # False
            
                True
                False
            
                # str之isdigit()应用场景
                age = input('age: ')
                if age.isdigit():
                    age = int(age)
                
                    if age < 18:
                        print('小姐姐')
                    else:
                        print('阿姨好')
                else:
                    print(f'你的年龄能是这个{age}?')
            
                age: 逗你玩？
                你的年龄能是这个逗你玩？?
            
            1.3其他操作
            
            1.  find|rfind|index|rindex|count
            2.  center|ljust|rjust|zfill
            3.  expandtabs
            4.  captalize|swapcase|title
            5.  is系列
                
                1.  1.find()、rfind()、index()、rindex()、count()
                2.  center()、ljust()、rjust()、zfill()
                3.  expandtabs()
                4.  captalize()、swapcase()、title()
                5.  is数字系列
                6.  is其他

## 5. 列表类型的内置方法 ##

1.  列表类型内置方法（list）
    
    1.  用途：多个装备、多个爱好、多门课程
    2.  定义：\[\]内可以有多个类型的值，逗号隔开多个元素
        
            # my_girl_friend = list(['jason','tank','sean'])
            my_girl_friend = ['jason', 'tank', 'sean']
            
            print(f"my_girl_friend: {my_girl_friend}")
        
            my_girl_friend: ['jason', 'tank', 'sean']
        
            l = list('hello nick')
            print(f"l: {l}")
        
            l: ['h', 'e', 'l', 'l', 'o', ' ', 'n', 'i', 'c', 'k']
        
        **3.常用操作+内置方法：常用操作和内置方法分为优先掌握（今天必须得记住）、需要掌握（一周内记住）、其他操作（了解）三个部分。**

## 6. 元组类型的内置方法 ##

1.  元组类型内置方法（tuple）
    
    1.用途：多个装备、多个爱好、多门课程，甚至是多个女朋友
    
    2.定义：在()内可以有多个任意类型的值，逗号分隔元素
    
        # my_girl_friend = tuple(('jason','tank','sean'))
        my_girl_friend = ('jason', 'tank', 'sean')
        
        print(f"my_girl_friend: {my_girl_friend}")
    
    `my_girl_friend: ('jason', 'tank', 'sean')`
    
        name_str = ('egon')  # ()只是普通包含的意思
        name_tuple = ('egon',)
        
        print(f"type(name_str): {type(name_str)}")
        print(f"type(name_tuple): {type(name_tuple)}")
    
    `type(name_str): <class 'str'>`
    
    `type(name_tuple): <class 'tuple'>`
    
    3.常规操作+内置方法：**常用方法和内置方法**
    
    1.1 优先掌握
    
    1.  索引取值
    2.  切片（顾头不顾尾，步长）
    3.  长度len
    4.  成员运算in和not in
    5.  循环
    6.  count
    7.  index
        
        1.索引取值
        
            # tuple之索引取值
            name_tuple = ('nick', 'jason', 'tank', 'sean')
            # name_tuple[0] = 'nick handsom'  # 报错
            
            print(f"name_tuple[0]: {name_tuple[0]}"
        
        `name_tuple[0]: nick`
        
        2.切片（顾头不顾尾，步长）
        
            # tuple之切片
            name_tuple = ('nick', 'jason', 'tank', 'sean')
            
            print(f"name_tuple[1:3:2]: {name_tuple[1:3:2]}")
        
            name_tuple[1:3:2]: ('jason',)
        
        3.长度
        
            # tuple之长度
            name_tuple = ('nick', 'jason', 'tank', 'sean')
            
            print(f"len(name_tuple): {len(name_tuple)}")
        
        `len(name_tuple): 4`
        
        4.成员运算
        
            # tuple之成员运算
            name_tuple = ('nick', 'jason', 'tank', 'sean')
            
            print(f"'nick' in name_tuple: {'nick' in name_tuple}")
        
        `'nick' in name_tuple: True`
        
        5.循环
        
            # tuple之循环
            name_tuple = ('nick', 'jason', 'tank', 'sean')
            
            for name in name_tuple:
                print(name)
        
        `nick`
        
        `jason`
        
        `tank`
        
        `sean`
        
        6.count
        
            # tuple之count()
            name_tuple = ('nick', 'jason', 'tank', 'sean')
            
            print(f"name_tuple.count('nick'): {name_tuple.count('nick')}")
        
        `name_tuple.count('nick'): 1`
        
        7.index()
        
            # tuple之index()
            name_tuple = ('nick', 'jason', 'tank', 'sean')
            
            print(f"name_tuple.index('nick'): {name_tuple.index('nick')}")
        
        `name_tuple.index('nick'): 0`
        
        4.存一个值or多个值：
        
        **多个值**
        
        5.有序or无序：
        
        **有序**
        
            name_tuple = ('nick',)
            print(f'first:{id(name_tuple)}')
        
        `first:4394454152`
        
        6.可变不可变：
        
        **不可变**
        
        7.元组和列表的区别
        
            l = ['a', 'b', 'c']
            print(f"id(l[0]): {id(l[0])}")
            l[0] = 'A'
            print(f"id(l[0]): {id(l[0])}")
        
            id(l[0]): 4357367208
            id(l[0]): 4357775176
        
        **列表可变的原因**：索引对应的内存地址是可以改变的
        
        元组**不可变的原因**：索引对应的值得内存地址是不可以改变的
        
        索引对应的地址没有变，则元组的值不会变的
        
            t1 = (['a', 'b', 'c'], 'wc', 'office')
            
            print(f"id(t1[0]): {id(t1[0])}")
            print(f"id(t1[1]): {id(t1[1])}")
            print(f"id(t1[2]): {id(t1[2])}")
            
            t1[0][0] = 'A'
            print(f"t1[0][0]: {t1[0][0]}")
            print(f"id(t1[0]): {id(t1[0])}")
            print(f"t1: {t1}")
        
            id(t1[0]): 4394709960
            id(t1[1]): 4374626968
            id(t1[2]): 4394453568
            t1[0][0]: A
            id(t1[0]): 4394709960
            t1: (['A', 'b', 'c'], 'wc', 'office')

## 7. 字典类型的内置方法 ##

1.  字典类型内置方法（dict）
    
    1.  用途：存多个值，但每个值对应一个键，键相当于列表隐藏的索引，所以取值方法和列表有些类似
    2.  定义
        
        \{\}内用逗号分隔开多个元素，每一个元素都是key：value的形式，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型。
        
            dic = {'a': 1, 'b': 2}  # dic = dict({'a':1,'b':2})
            
            print(f"dic: {dic}")
        
            dic: {'a': 1, 'b': 2}
        
            dic = dict(a=1, b=2, c=3)
            
            print(f"dic: {dic}")
        
            dic: {'a': 1, 'b': 2, 'c': 3}
        
            dic = {1: 'a', 0: 'b'}
            
            print(f"dic[0]: {dic[0]}")  # 无法区分dic是列表，还是字典，并且key不再具有描述信息
            dic[0]: b
            dic = {[1,2]: 'a', 0: 'b'}  # 报错
        
        1.1 优先掌握
        
        1.  按key存值：可存可取
        2.  长度len
        3.  成员运算in和not in
        4.  删除del
        5.  键keys()、值values()、键值对items()
        6.  循环
            
            1.  按key取值
                
                    # dic之按key存取值
                    dic = {'a': 1, 'b': 2}
                    
                    print(f"first dic['a']: {dic['a']}")
                    
                    dic['a'] = 3
                    
                    print(f"second dic['a']: {dic['a']}")
                
                    first dic['a']: 1
                    second dic['a']: 3
                
                2.长度len
                
                    # dic之长度len
                    dic = {'a': 1, 'b': 2}
                    
                    print(f"len(dic): {len(dic)}")
                
                    len(dic): 2
                
                3.成员运算in和not in
                
                    # dic之成员运算in和not in
                    dic = {'a': 1, 'b': 2}
                    
                    print(f"'a' in dic: {'a' in dic}")
                    print(f"1 in dic: {1 in dic}")
                
                    'a' in dic: True
                    1 in dic: False
                
                4.删除
                
                    # dic之删除del
                    dic = {'a': 1, 'b': 2}
                    del dic['a']
                    
                    print(f"dic.get('a'): {dic.get('a')}")
                
                    dic.get('a'): None
                
                    # dic之删除pop()
                    dic = {'a': 1, 'b': 2}
                    dic.pop('a')  # 指定元素删除
                    
                    print(f"dic.pop('b'): {dic.pop('b')}")
                    print(f"dic.get('a'): {dic.get('a')}")
                
                    dic.pop('b'): 2
                    dic.get('a'): None
                
                    # dic之删除popitem()
                    dic = {'a': 1, 'b': 2}
                    
                    print(f"dic.popitem(): {dic.popitem()}")  # popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。
                
                    dic.popitem(): ('b', 2)
                
                5.键keys()、值values()、键值对items()
                
                    # dic之键keys()、值values()、键值对items()，python2中取出的是列表（鸡蛋）；python3中取出的是元组（鸡）
                    dic = {'a': 1, 'b': 2}
                    
                    print(f"dic.keys(): {dic.keys()}")
                    print(f"dic.values(): {dic.values()}")
                    print(f"dic.items(): {dic.items()}")
                
                    dic.keys(): dict_keys(['a', 'b'])
                    dic.values(): dict_values([1, 2])
                    dic.items(): dict_items([('a', 1), ('b', 2)])
                
                6.循环
                
                    # dic之循环
                    # dic是无序的，但是python3采用了底层优化算法，所以看起来是有序的，但是python2中的字典是无序
                    dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
                    
                    for k, v in dic.items():  # items可以换成keys()、values()
                        print(k, v)
                
                    a 1
                    b 2
                    c 3
                    d 4
                
                ### **1.2 需要掌握(\***\*\*\*） ###
                
                1.  get
                2.  update
                3.  fromkeys
                4.  setdefault
                
                1.get()
                
                    # dic之get()
                    dic = {'a': 1, 'b': 2}
                    
                    print(f"dic.get('a'): {dic.get('a')}")
                    print(f"dic.get('c'): {dic.get('c')}")
                
                    dic.get('a'): 1
                    dic.get('c'): None
                
                2.update()
                
                    # dic之update()
                    dic1 = {'a': 1, 'b': 2}
                    dic2 = {'c': 3}
                    dic1.update(dic2)
                    
                    print(f"dic1: {dic1}")
                
                    dic1: {'a': 1, 'b': 2, 'c': 3}
                
                3.fromkeys()
                
                    # dic之fromkeys()
                    dic = dict.fromkeys(['name', 'age', 'sex'], None)
                    
                    print(f"dic: {dic}")
                
                    dic: {'name': None, 'age': None, 'sex': None}
                
                4.setdefault()
                
                    # dic之setdefault()，有指定key不会改变值；无指定key则改变值
                    dic = {'a': 1, 'b': 2}
                    
                    print(f"dic.setdefault('a'): {dic.setdefault('a',3)}")
                    print(f"dic: {dic}")
                    print(f"dic.setdefault('c'): {dic.setdefault('c',3)}")
                    print(f"dic: {dic}")
                    dic.setdefault('a'): 1
                    dic: {'a': 1, 'b': 2}
                    dic.setdefault('c'): 3
                    dic: {'a': 1, 'b': 2, 'c': 3}
                
                \#\# 二.练习
                
                统计`s='hello tank tank say hello sb sb'`中每个单词的个数
                
                结果如：`{'hello': 2, 'tank': 2, 'say': 1, 'sb': 2}`
                
                    s='hello tank tank say hello sb sb'
                    
                    l=s.split()
                    
                    dic={}
                    for item in l:
                        if item in dic:
                            dic[item]+=1
                        else:
                            dic[item]=1
                    print(dic)
                
                    {'hello': 2, 'tank': 2, 'say': 1, 'sb': 2}
                
                4.存一个值or多个值：多个值，值可以是多个类型，key必须是不可变类型，通常应该是不可变类型中的字符串类型
                
                5.有序or无序：无序
                
                    dic = {'a': 1, 'b': 2}
                    print(f'first:{id(name)}')
                    dic['a'] = 3
                    print(f'second:{id(name)}')
                    first:4356627632
                    second:4356627632
                
                6.可变or不可变：可变数据类型

## 8. 集合类型的内置方法 ##

1.  集合类型内置方法（set）
    
    集合可以理解为集合体
    
        pythoners = ['jason', 'nick', 'tank', 'sean']
        linuxers = ['nick', 'egon', 'kevin']
        
        # 即报名pythoners又报名linux的学生
        py_li_list = []
        for stu in pythoners:
            if stu in linuxers:
                py_li_list.append(stu)
        print(f"pythoners and linuxers: {py_li_list}")
    
    `pythoners and linuxers: ['nick']`
    
    由此可见，用列表方式求两个集合体的关系比较复杂，所以就有了集合数据类型
    
    2.定义
    
    **\{\}内用逗号分隔开多个元素，每个元素必须是不可变类型。** 集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。
    
        s = {1, 2, 1, 'a'}  # s = set({1,2,'a'})
        
        print(f"s: {s}")
    
        s: {1, 2, 'a'}
    
        s = {1, 2, 1, 'a', 'c'}
        
        for i in s:
            print(i)
    
        1
        2
        c
        a
        s = set('hello')
        
        print(f"s: {s}")
        s: {'e', 'o', 'h', 'l'}
    
    1.1 优先掌握
    
    1.  长度len
    2.  成员运算in和not in
    3.  |并集、union
    4.  &交集、intersection
    5.  \-差集、difference
    6.  ^对称差集、symmetric\_difference
    7.  ==
    8.  父集：>、>= 、issuperset
    9.  子集：<、<= 、issubset
        
        **注意：**以上的参数都为集合
2.  练习

## 9. 数据类型分类 ##

1.  按存值个数区分
    
    <table> 
     <thead> 
      <tr> 
       <th>存值个数</th> 
       <th>数据类型</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>单个值</td> 
       <td>数字，字符串，浮点型</td> 
      </tr> 
      <tr> 
       <td>多个值(容器)</td> 
       <td>列表，元组，字典，集合</td> 
      </tr> 
     </tbody> 
    </table>
2.  按可变不可变区分
    
    <table> 
     <thead> 
      <tr> 
       <th>可变or不可变</th> 
       <th>数据类型</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>可变</td> 
       <td>列表，字典，集合</td> 
      </tr> 
      <tr> 
       <td>不可变</td> 
       <td>数字，字符串，元组，浮点型</td> 
      </tr> 
     </tbody> 
    </table>
3.  有序无序之分
    
    <table> 
     <thead> 
      <tr> 
       <th style="text-align:center;">有序or无序</th> 
       <th>数据类型</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td style="text-align:center;">有序(可按索引取值)</td> 
       <td>字符串，列表，元组</td> 
      </tr> 
      <tr> 
       <td style="text-align:center;">不可变</td> 
       <td>字典，集合</td> 
      </tr> 
     </tbody> 
    </table>
4.  按访问类型区分
    
    <table> 
     <thead> 
      <tr> 
       <th>访问类型</th> 
       <th>数据类型</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>直接访问</td> 
       <td>数字</td> 
      </tr> 
      <tr> 
       <td>顺序访问(序列类型)</td> 
       <td>字符串，列表，元组</td> 
      </tr> 
      <tr> 
       <td>key值访问(映射类型)</td> 
       <td>字典</td> 
      </tr> 
     </tbody> 
    </table>
5.  六大类型内置方法

转载于:https://www.cnblogs.com/demiao/p/11254300.html