Day08

总结

字典内置方法

1.类型转换
    '''
       dict = {'name': 'tom', 'age': 20}
        # 字典转为字符串
        print(type(str(dict)))  # <class 'str'>
        # 字典可以转为元组
        print(type(tuple(dict)))  # <class 'tuple'>
        # 字典转为列表
        print(type(list(dict)))  # <class 'list'>
    '''	
2.key取值
    
    d1 = {
        'name': 'jack',
        'gender': 'male',
        'age': '20'
 	}
    '''
        print(d1['name'])
        取不存在的键会报错
        所以更推荐以下的方式
        print(d1.get('name'))  # jack  在
        print(d1.get('1'))  # None  键不存在返回None
        print(d1.get('1', '键不存在'))  # 第二个参数默认返回None,可以自行修改
        print(d1.get('name', '键不存在'))  # 如果键存在 则不用第二个参数
    '''
3.修改value
    '''
        d1['name'] = 'jerry'
        print(d1)  # {'name': 'jerry', 'gender': 'male', 'age': '20'}
    '''
4.添加键值对
    '''
        d1['']
    '''
5.统计字典中元素的个数
    '''
        # print(len(d1))  # 3
    '''
6.成员运算  # 只能判断key
    '''
        print('age' in d1)  # True
        print('20' in d1)  # False
    '''
7.删除元素(键值对)
    '''
        del d1['age']  # 通用的方式

        print(d1.pop('age')) # 返回值20 先拿出来，再删除
        print(d1)  # {'name': 'jack', 'gender': 'male'}
    '''
8.获取所有元素(在python2中返回一个列表)
    '''
        (1)获取所有的键
            print(d1.keys())  # dict_keys(['name', 'gender', 'age'])  
        (2)获取所有的值  
            print(d1.values())  # dict_values(['jack', 'male', '20'])
        (3)获取所有的键值对
            print(d1.items())  # dict_items([('name', 'jack'), ('gender', 'male'), ('age', '20')])  列表套元组
    '''

:

了解一下
1.update 更新字典
    '''
        d1.update({'a': '1', 'name': 'jane'})
        print(d1)  # {'name': 'jane', 'gender': 'male', 'age': '20', 'a': '1'}
        修改存在的键，新增不存在的键
    '''
2.fromkeys() 快速生成字典
    '''
        d1 = dict.fromkeys(['a', 'b', 'c'], [1])
        print(d1)  # {'a': [1], 'b': [1], 'c': [1]}

        dic['a'].append(123) 
        print(dic)  # {'a': [1, 123], 'b': [1, 123], 'c': [1, 123]}
        三个键指向同一个列表，其中一个插入值则所有都插入值
    '''
3.setdefault
    '''
        d1 = {'a': 123, 'b': 321}
        print(d1.setdefault('c', 111))  # 111 新增不存在的键且返回新增键的value
        print(d1)  # {'a': 123, 'b': 321, 'c': 111}

        print(d1.setdefault('b', 123))  # 321 键存在 则返回存在键的值 并且不做修改
        print(d1)	{'a': 123, 'b': 321}
    '''

元组内置方法

1.类型转换

	# 列表、集合、字典等支持for循环的都可以跟元组转换
2.元组的特性
	'''
		t1 = (1)
		print(type(t1))  # <class 'int'>
		t1 = (1,)
		print(type(t1))  # <class 'tuple'>
		如果元祖里面只有一个元素，则必须在元素后接都号,
		=>如果可以存储多个数据的类型中石油一个元素，也要习惯性的加一个逗号
	'''
3.索引取值
t2 = (1, 2, 3, 4, 5, 6)
    '''
         print(t2[0])  # 1
    '''
4.切片
    '''
        print(t2[1:3])  # (2, 3)
        print(t2[3:1:-1])  # (4, 3)
    '''
5.间隔
    '''
        print(t2[1:4:2])  # (2, 4)
     '''
6.统计元组内元组的个数
    '''
        print(len(t2))  # 6
    '''
7.成员运算
    '''
        print(2 in t2)  # True
    '''
8.统计某元素出现的次数
    '''
        print(t2.count(1))  # 1
    '''
9.元组内元素不能"修改": 元组内各个索引值指向的内存地址不能修改,但是如果指向的是字典这种可变类型，则可以修改其中的值
    eg:
        '''
            笔试题
                tt = (11, 22, 33, [11, 22])
                tt[-1].append('heiheihei')
                问:执行之后的结果   正确答案选B
                    A.报错    B.正常添加   C.不知道   
        '''

集合内置方法

1.类型转换
    '''
        # print(set(12))  # 报错
        # print(set(1.2))  # 报错
        # print(set('abcd'))  # {'c', 'b', 'a', 'd'}
        # print(set([1, 2, 3, 4]))  # {1, 2, 3, 4}
        # print(set({'a': '1234'}))  # {'a'}
        # print(set((1, 2, 3)))  # {1, 2, 3}
        # print(set(True))  # 报错 
    '''
    '''
        集合内元素只能是不可变类型
        集合类型要求元素是独一无二的，不能存在相同的元素，但是如果其中的某一个元素是可以被改变的，它一旦改变之后可能会和其他的元素相同，这样子的话集合类型就会出现错误，
    '''
2.去重
	集合中不能出现相同的元素
    集合会自动去重
3.关系运算
	判断两个群体的差异  # 共同部分，差异部分
    s1 = {'jack', 'jane', 'john', 'jimmy'}
	s2 = {'billy', 'katty', 'tom', 'jimmy'}
    &: 两个群体的共同之处
        eg：
        	print(s1 & s2)  # {'jimmy'}
    -: 两个群体的不同(单方)
        eg:
            print(s1 - s2)  # {'jack', 'jane', 'john'}
            print(s2 - s1)  # {'billy', 'tom', 'katty'}
    |: 并集
        eg:
            print(s2 | s1)  # {'jack', 'jane', 'john', 'tom', 'billy', 'katty', 'jimmy'}
    ^:各自特有的部分
        eg:
             print(s2 ^ s1)  # {'jane', 'billy', 'katty', 'john', 'jack', 'tom'}

垃圾回收机制

1.引用计数
    '''
        引用计数就是：变量值被变量名关联的次数
        eg:
            count = 1 # 引用计数为1
            num = count  # 引用技术为2
    '''
2.标记清除
    '''
        当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作，第一项则是标记，第二项则是一次性清除
    '''
3.分代回收
    '''
        在历经多次扫描的情况下，都没有被回收的变量，垃圾回收机制就会认为，该变量是常用变量，垃圾回收机制对其扫描的频率会降低，
    '''

:

作业

1.练习昨日注册登录作业
2.去重列表元素并保留原来的顺序
	l = ['a', 'b', 1, 'a', 'a']
    '''
    	l = ['a', 'b', 1, 'a', 'a']

        j = list(set(l))
        j.sort(key=l.index)
        print(j)
    '''
3.去重下列数据字典并保留原来的顺序
    # 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
    l=[
        {'name':'lili','age':18,'sex':'male'},
        {'name':'jack','age':73,'sex':'male'},
        {'name':'tom','age':20,'sex':'female'},
        {'name':'lili','age':18,'sex':'male'},
        {'name':'lili','age':18,'sex':'male'},
    ]
      '''
      l = [
          {'name': 'lili', 'age': 18, 'sex': 'male'},
          {'name': 'jack', 'age': 73, 'sex': 'male'},
          {'name': 'tom', 'age': 20, 'sex': 'female'},
          {'name': 'lili', 'age': 18, 'sex': 'male'},
          {'name': 'lili', 'age': 18, 'sex': 'male'},
      ]

      remove_repeat = []
      for i in l:
          if i in remove_repeat:
              continue
          else:
              remove_repeat.append(i)
      print(remove_repeat)

      '''
4.一.关系运算
　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
　　linuxs={'oscar','tony','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
        print(pythons & linuxs)  # {'gangdan', 'oscar'}
　　2. 求出所有报名的学生名字集合
	print(pythons | linuxs)  # {'ricky', 'tony', 'kevin', 'oscar', 'biubiu', 'gangdan', 'jason'}
　　3. 求出只报名python课程的学员名字
	print(pythons - linuxs)  # {'jason', 'kevin', 'biubiu', 'ricky'}
　　4. 求出没有同时这两门课程的学员名字集合
	print(pythons ^ linuxs)  # {'tony', 'jason', 'kevin', 'ricky', 'biubiu'}
5.整理今日内容及笔记
6.思考本周大作业

今天周四了，明天要测验

: