内置函数（二）

列表

存多个值，有序，可变数据类型

定义

my_hobby_list = ['唱','跳','rap']
my_hobby_list = list('唱跳rap')  #将以['唱','跳','r','a','p']的形式存放

内置方法

1. 取值

   ##通过列表的索引取值，正向取值和反向取值
   my_hobby_list = list('唱跳rap')
   print(my_hobby_list[0])  # 唱
   print(my_hobby_list[-1])  # p
   

2. 切片

   ##通过列表的索引切片，正向切片和反向切片
   my_hobby_list = list('唱跳rap')
   print(my_hobby_list[1:])  # ['跳', 'r', 'a', 'p']
   print(my_hobby_list[1:3])  # ['跳', 'r']  ##顾头不顾尾，取得到第一个下标的值，取不到第二个下标的值
   print(my_hobby_list[::-1])  # ['p', 'a', 'r', '跳', '唱']  ##反向取值
   print(my_hobby_list[-1:-3:-1])  # ['p', 'a']  ## 同样是顾头不顾尾
   

3. 长度

   ##计算列表的长度值
   my_hobby_list = list('唱跳rap')
   print(len(my_hobby_list))  # 5
   

4. 成员运算

   ##判断元素是否在这个列表里面
   my_user_info = ['Gredae',170,140,21]
   print(170 in my_user_info)  # True
   print('siri' not in my_user_info)  # True
   

5. 添加

   ##往列表的尾部添加一个元素
   my_hobby_list = ['唱','跳','rap']
   my_hobby_list.append('篮球')
   print(my_hobby_list)  # ['唱', '跳', 'rap', '篮球']
   

6. 删除

   ##del既可以删除整个列表也可以删除单个元素
   my_hobby_list = ['唱','跳','rap']
   del my_hobby_list[1]
   print(my_hobby_list)  # ['唱', 'rap']
   del my_hobby_list
   print(my_hobby_list)  # NameError: name 'my_hobby_list' is not defined  ##变量名没有定义
   

7. 循环

   my_hobby_list = ['唱','跳','rap']
   for i in my_hobby_list:
       print(i,end=' ')  # 唱 跳 rap 
   

8. 插入

   ##在索引为x的元素前面插入另一个元素
   my_hobby_list = ['唱','跳','rap']
   my_hobby_list.insert(1,'篮球')
   print(my_hobby_list)  # ['唱', '篮球', '跳', 'rap']
   

9. 弹出

   ##返回列表指定索引位置的元素并删除，默认弹出列表最后一个元素
   my_hobby_list = ['唱','跳','rap']
   print(my_hobby_list.pop())  # rap
   print(my_hobby_list)  # ['唱', '跳']
   print(my_hobby_list.pop(1))  # 跳
   print(my_hobby_list)  # ['唱', 'rap']
   

10. 删除

    ##删除指定元素
    my_hobby_list = ['唱','跳','rap']
    my_hobby_list.remove('跳')  ##当列表中没有该元素时，将会报错
    print(my_hobby_list)  # ['唱','rap']
    

11. 计数

    ##计算元素在列表中出现的次数
    my_hobby_list = ['唱','跳','rap','唱']
    print(my_hobby_list.count('唱'))  # 2
    print(my_hobby_list.count('rap'))  # 1
    

12. 查看索引

    ##查看指定元素在列表第一次出现的索引位置
    my_hobby_list = ['唱','跳','rap','唱']
    print(my_hobby_list.index('唱'))  # 0
    print(my_hobby_list.index('rap'))  # 2
    

13. 清空列表

    ##清空指定列表的所有元素
    my_hobby_list = ['唱','跳','rap','唱']
    my_hobby_list.clear()
    print(my_hobby_list)  # []  ##一个空列表
    

14. 拷贝

    ##浅拷贝一个列表
    my_hobby_list = ['唱','跳','rap','唱']
    my_hobby_list2 = my_hobby_list.copy()
    print(my_hobby_list2)  # ['唱','跳','rap','唱']
    

15. 拓展

    ##将另一个列表的内容拓展到当前列表
    my_hobby_list = ['唱','跳','rap','唱']
    my_hobby_list2 = ['篮球']
    my_hobby_list.extend(my_hobby_list2)
    print(my_hobby_list)  # ['唱', '跳', 'rap', '唱', '篮球']
    

16. 翻转列表

    ##将列表的内容前后颠倒
    my_hobby_list = ['唱','跳','rap']
    my_hobby_list.reverse()
    print(my_hobby_list)  # ['rap', '跳', '唱']
    

17. 排序

    ##以ASCII表的顺序进行排序
    lis = ['Google', 'Runoob', 'Taobao', 'Facebook']
    lis.sort()
    print (lis)  # ['Facebook', 'Google', 'Runoob', 'Taobao']
    lis.sort(reverse=True)
    print (lis)  # ['Taobao', 'Runoob', 'Google', 'Facebook']  ##以降序的形式排列
    

元组

存多个值，有序，不可变数据类型

列表与元组的区别

列表可改变，元组不可改变

定义

my_hobby_list = ('唱','跳','rap')
my_hobby_list = list('唱跳rap')  #将以('唱', '跳', 'r', 'a', 'p')的形式存放

内置方法

1. 取值

   ##通过元组的索引取值，正向取值和反向取值
   my_hobby_tuple = tuple('唱跳rap')
   print(my_hobby_tuple[0])  # 唱
   print(my_hobby_tuple[-1])  # p
   

2. 切片

   ##通过元组的索引切片，正向切片和反向切片
   my_hobby_tuple = tuple('唱跳rap')
   print(my_hobby_tuple[1:])  # ('跳', 'r', 'a', 'p')
   print(my_hobby_tuple[1:3])  # ('跳', 'r')  ##顾头不顾尾，取得到第一个下标的值，取不到第二个下标的值
   print(my_hobby_tuple[::-1])  # ('p', 'a', 'r', '跳', '唱')  ##反向取值
   print(my_hobby_tuple[-1:-3:-1])  # ('p', 'a')  ## 同样是顾头不顾尾
   

3. 长度

   ##计算元组的长度值
   my_hobby_tuple = list('唱跳rap')
   print(len(my_hobby_tuple))  # 5
   

4. 成员运算

   ##判断元素是否在这个元组里面
   my_user_info = ('Gredae',170,140,21)
   print(170 in my_user_info)  # True
   print('siri' not in my_user_info)  # True
   

5. 循环

   my_hobby_tuple = ('唱','跳','rap')
   for i in my_hobby_tuple:
       print(i,end=' ')  # 唱 跳 rap 
   

6. 计数

   ##计算元素在元组中出现的次数
   my_hobby_tuple = ['唱','跳','rap','唱']
   print(my_hobby_tuple.count('唱'))  # 2
   print(my_hobby_tuple.count('rap'))  # 1
   

7. 查看索引

   ##查看指定元素在元组第一次出现的索引位置
   my_hobby_list = ['唱','跳','rap','唱']
   print(my_hobby_list.index('唱'))  # 0
   print(my_hobby_list.index('rap'))  # 2
   

字典

存多个值，key必须是不可变类型，无序，可变数据类型

定义

dic = {'a': 1, 'b': 2}  
dic = dict(a=1, b=2, c=3)

内置方法

1. 按key取值

   my_user_info = {'name':'Gredae','height':170,'weight':140}
   print(my_user_info['name'])  # Gredae
   

2. 长度

   my_user_info = {'name':'Gredae','height':170,'weight':140}
   print(len(my_user_info))  # 3
   

3. 成员运算

   my_user_info = {'name':'Gredae','height':170,'weight':140}
   print('age' in my_user_info)  # False
   print('age' in my_user_info)  # True
   

4. 删除

   my_user_info = {'name':'Gredae','height':170,'weight':140}
   del my_user_info['name']
   print(my_user_info)  # {'height': 170, 'weight': 140}
   del my_user_info
   print(my_user_info)  # NameError: name 'my_user_info' is not defined ##变量未定义
   

5. 键keys()、值values()、键值对items()

   ##items取出的键值对是以元组的形式
   my_user_info = {'name':'Gredae','height':170,'weight':140}
   print(my_user_info.keys())  # dict_keys(['name', 'height', 'weight'])
   print(my_user_info.values())  # dict_values(['Gredae', 170, 140])
   print(my_user_info.keys())  # dict_items([('name', 'Gredae'), ('height', 170), ('weight', 140)])
   

6. 循环

   my_user_info = {'name':'Gredae','height':170,'weight':140}
   for k,v in my_user_info.items():
   	print(k,v)
   #name Gredae
   #height 170
   #weight 140
   

7. 获取元素

   my_user_info = {'name':'Gredae','height':170,'weight':140}
   print(my_user_info.get('name'))  # Gredae
   print(my_user_info.get('age'))  # None  ##如果字典中没有这个key，便返回None
   

8. 更新

   ##将一个字典的数据更新到另一个字典中
   my_user_info = {'name':'Gredae','height':170,'weight':140}
   my_user_info2 = {'age':21}
   my_user_info.update(my_user_info2)
   print(my_user_info)  # {'name': 'Gredae', 'height': 170, 'weight': 140, 'age': 21}
   

9. 创建一个新字典 fromkeys()

   ##fromkeys有两个参数，第一个参数为新字典的key，第二个参数为新字典的value，如果不设value默认None
   ref = [1,2,3]
   b = dict.fromkeys(ref)
   print(b)  # {1: None, 2: None, 3: None}
   c = dict.fromkeys(ref,'Gredae')
   print(c)  # {1: 'Gredae', 2: 'Gredae', 3: 'Gredae'}
   

10. 设置默认值

    #如果键不已经存在于字典中，将会添加键并将值设为默认值。如果键存在返回该键对应的值
    my_user_info = {'name':'Gredae','height':170,'weight':140}
    print(my_user_info.setdefault('age',21))  # 21
    print(my_user_info)  # {'name': 'Gredae', 'height': 170, 'weight': 140, 'age': 21}
    print(my_user_info.setdefault('name','gredae'))  #{'name': 'Gredae', 'height': 170, 'weight': 140}
    

集合

存多个值，且值需为不可变类型，无序，可变数据类型

定义

{}内用逗号分隔开多个元素，每个元素必须是不可变类型。

内置方法

1. 长度

   s = {1,2,'a'}
   print(len(s))  # 3
   

2. 成员运算

   s = {1,2,'a'}
   print(3 in s)  # False
   print(3 not in s)  #True
   

3. 并集

   s = {1,2,'a'}
   s2 = {2,4,6,1}
   print(s | s2)  # {1, 2, 'a', 4, 6}
   

4. 交集

   s = {1,2,'a'}
   s2 = {2,4,6,1}
   print(s & s2)  # {1, 2}
   

5. 差集

   ##我有的你没有
   s = {1,2,'a'}
   s2 = {2,4,6,1}
   print(s - s2)  # {1, 2}
   

6. 对称差集

   ##我有的你没有和你有的我没有（互相没有的）
   s = {1,2,'a'}
   s2 = {2,4,6,1}
   print(s ^ s2)  # {4, 6, 'a'}
   

7. 相等

   ##判断两个集合是否一样
   s = {1,2,'a'}
   s2 = {2,4,6,1}
   print(s == s2)  # False
   

8. 父集

   s = {1,2}
   s2 = {2,4,6,1}
   print(s >= s2)  # False
   print(s2 >= s)  # True
   

9. 子集

   s = {1,2}
   s2 = {2,4,6,1}
   print(s <= s2)  # True
   print(s2 <= s)  # False