Day 11

今日内容概要

• 列表内置方法
• 穿插知识：可变与不可变类型
• 元组内置方法
• 字典内置方法
• 集合内置方法
• 可变类型和不可变类型

今日内容详细

1.列表内置方法

'列表在调用内置方法之后不会产生新的值，而是修改自身'
1.关键字
	list
2.类型转换
  #能被for循环的数据类型都可以转换成列表
   print(list(123)) #整数型不可转换
   print(list(123.1)) #浮点型不可转换
   print(list(True)) #布尔值不可转换
   print(list([1,2,3])) #列表可转换 [1,2,3]
   print(list({'name':'张'})) #字典可转换 ['name',]
   print(list((1,2,3))) #元组可转换 [1,2,3]
   print(list({1,2,3})) #集合可转换 [1,2,3]
3.需要掌握的方法
    lx = ['cat','tony','kevin']
  1)索引取值
    print(lx[0])#cat
    print(lx[-1])#kevin
  2)切片操作
    print(lx[0:2])#['cat', 'tony']
    print(lx[:])#['cat', 'tony', 'kevin']
    print((lx[-3:-1]))#['cat', 'tony']
  3)间隔/方向
    print(lx[::2])#['cat', 'kevin']
  4)统计列表中数据值的个数
    print(len(lx))#3
  5)增加数据
   5.1)尾部追加数据值 '括号内无论写什么数据类型 都会当作一个数据值追加
    lx.append([1，2])#在最后追加数据值
    print(lx)#结果为['cat','tony','kevin',[1,2]]
    '列表在调内置方法时是在原数据上修改，与字符串相反'
   5.2)任意位置插入数据值
      lx.insert(0,'插队')#在首位插入数据值
      print(lx)#['插队'cat','tony','kevin']
   5.3)扩展列表(让两个列表的值放在一个列表中)
     eg:
        l1=[1,2,3,4]
        l2=[5,6]
      方式一：
    	for i in l1:#让i循环打印出l1的值
            l2.append(i)#在l2尾部追加i的值
         print(l2)#打印l2
      方式二：
    	print(L1+l2)
      方式三：推荐使用！(仅支持for循环的数据类型:列表、字典、字符串、元组、集合)
    	l1.extend(l2)
         print(l1)
  6)修改数据
    eg:
        l1=[1,2,3,4]
        l1[0]='z' #把l1索引0的值改为'z'
        print(l1)#['z',2,3,4]
  7)删除数据
    7.1)通用删除
        del l1[0]#删除l1索引0的数据值
        print(l1)#[2,3,4]
    7.2)指定删除
        l1.remove(1)#在l1中指定删除这个数据值
        print(l1)#[2,3,4]
    7.3)先取出数据值然后删除
        l1.pop()#括号内不写默认是最后一个，0代表第一个，1代表第二个
        print(l1)#[2,3,4]
        
       与指定删除不同的是：
        pop是把删除的数据提取出来了，remove是彻底不存在了
       l1=[1,2,3,4]
       a = l1.pop()#把删除的数据赋值给a
       print(a)#4
       #常用于观战人数中xx退出观战
    
       l1=[1,2,3,4]
       a = l1.remove(1)
       print(a)#None(没有)
  8)查看数据值对应的索引值
      print(l1.index(1))#0 l1中1的索引值为0
  9)统计某个数据值出现的次数
       l1 = [1,1,2,3,4]
       print(l1.count(1))#2 列表中1出现的次数
 10)排序
       l1.sort() #升序
       l1.sort(reverse=True) #降序
 11)翻转
       l1.reverse()
       print(l1)#[4,3,2,1,1]
 12)比较
     a = [99,11]
     b = [11,12,13]
     print(a>b)#True 列表在比较大小时是按照位置顺序比较，索引0互相比较，99>11，结果就为True
    #不同数据类型之间无法比较
    #a比A大，因为中间涉及字符编码，a=97 A=65
    #中文也各有编码

2.穿插知识：可变与不可变类型

    '疑问：为什么字符串调用的内置方法是产生新的值，而列表却是改变自身？'
 1.可变数据类型 list列表
    值改变(内置方法来改变)，内存地址可不变
      l1 = [11, 22, 33]
      print(id(l1))  # 1931283911552
      l1.append(44)  # [11, 22, 33, 44]
      print(id(l1))  # 1931283911552
      #列表在索引3下可以自由伸缩创建索引4

 2.不可变数据类型 str字符 int整型 float浮点
    值改变(内置方法来改变)，内存地址肯定变
      s1 = '$hello$'
      print(id(s1)) #2623221532
      s1 = s1.strip('$')
      print(id(s1)) #2852135153

3.元组内置方法

'''支持for循环的数据类型都可以转为元组()
 for循环支持的数据类型：字符串、列表、字典、元组、集合
      不支持的数据类型：整型、浮点型、布尔值'''
1.关键字
    tuple
2.类型转换
   print(tuple(123)) #整数型不可转换
   print(tuple(123.1)) #浮点型不可转换
   print(tuple(True)) #布尔值不可转换
   print(tuple([1,2,3])) #列表可转换 (1,2,3)
   print(tuple({'name':'张'})) #字典可转换('name',)
   print(tuple((1,2,3))) #元组可转换 (1,2,3)
   print(tuple({1,2,3})) #集合可转换 (1,2,3)
    
   t1 = ()#空元组
   t1 = (1,)#当元组只有一个数据值时不要忘记加逗号，否则就会变成括号里的数据类型。
    #ps:今后遇到可以存储多个数据值的数据类型，如果里面只有一个数据值，都建议加上逗号
    
   t1 = (1,2,3)
3.索引相关操作
   print(t1[0])#1
4.统计元组内数据值个数
   print(len(t1))#3
5.元组的索引不能改变绑定的地址
   eg：
    t1 = (1, 2,[3,4])
    t1[-1].append(5) #在元组索引-1(最后)的位置添加数据值5 由于最后的数据类型是列表 所以可以改变
    print(t1)  # (1,2,[3,4,5])

4.字典内置方法

核心1~8

1.关键字
	dict
2.类型转换(了解即可)
  print(dict([('name','jason'), ('pwd',123)]))
  print(dict(name='jason', pwd=123))
 #字典一般都是直接定义使用
3.字典取值
  info={'name':'zhang','pwd':'123','hobby':'run'}
1)print(info['usname'])#不推荐使用，当k不存在时会报错
2)print(info.get('usname'))#推荐使用
#当k不存在时会默认返回None,也可以自己编辑返回的内容。
  print(info.get('usname','不存在'))
#k存在时会返回对应的数据值
4.统计字典中键值对的个数
  print(len(info))
5.修改字典V的值
   inf=['name'] = 'li'
   print(info)#{'name':'li','pwd':'123','hobby':'run'}
6.新增键值对
   info={'name':'zhang','age':'18'}
   info['pwd']=123#当键存在时是修改，键不存在时是新增
   print(info)#{'name':'zhang','age':'18','pdw':'123'}
7.删除数据
 7.1)del info['name'] #删除name键值对 
 7.2)a=info.pop('name')#输出a就是被删除的v值
 7.3)info.popitem()#随即删除 一般不用
8.快速获取键 值 键值对数据
   print(info.keys())#获取字典所有的K值，结构当作列表
    #info_keys(['name','pwd','age'])
   print(info.values())#获取字典所有的v值,同样当列表
    #info_values(['zhang','123','18'])
   print(info.items())#获取字典所有的kv键值对数据,组城列表套元组
    #info_items([('name','zhang'),('pwd','123'),('age','18')])
9.快速构造字典  给的值默认情况下所有的键都用一个
  仅在笔试题中出现过：
  dict=dict.fromkeys(['name','pwd'],[])
  dict['name'].append('张')
  dict['pwd'].append('123')
  问：print(dict)出现的结果是什么？
  答：{'name':['张','123'],'pwd':['张':'123']}
10.键存在则获取对应的值，键不存在则设置

5.集合内置方法

1.关键字
	set
2.类型转换
    支持for循环的 且数据必须是不可变类型
3. 定义空集合需要使用关键字才可以
   集合内数据必须是不可变类型(整型、浮点型、字符串、元组、布尔值)
4.去重
   s1 = {1,1,2,2,3,3,4,4}
   print(s1)#{1,2,3,4}

  eg:把一个列表内的名字去重显示
     l1=['jason','jason','oscar','tony']
     s1=set(l1)#把列表转换成集合
     l2=list(s1)#再把刚刚的集合转回列表
     print(l2)#['jason','oscar','tony']
5.关系运算
  eg：模拟两个人的好友集合
    f1 = {'jason', 'tony', 'oscar', 'jerry'}
    f2 = {'kevin', 'jerry', 'jason', 'lili'}
 1)求f1和f2的共同好友
  print(f1 & f2)#{'jason','jerry'}
 2)求是f1的好友，但不是f2的好友
  print(f1 - f2)#{'oscar', 'tony'}
 3)求f1和f2所有的好友(没重复的)
  print(f1 | f2)#f1和f2所有的好友(无重复)
 4)求f1和f2各自独有的好友(排除共同好友)
  print(f1 ^ f2)
6.父集 子集
  eg:
     s1 = {1, 2, 3, 4, 5, 6, 7}
     s2 = {3, 2, 1}
     print(s1 > s2)#判断s1是不是s2的父集 True
    #集合在做比较时是依照谁包含谁来判断谁是父谁是子

作业

1.利用列表编写一个员工姓名管理系统
	输入1执行添加用户名功能
	输入2执行查看所有用户名功能
 	输入3执行删除指定用户名功能
	ps:思考如何让程序循环起来并且可以根据不同指令执行不同操作
	提示: 循环结构 + 分支结构
	拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写 不会没有关系)
   
2.去重下列列表并保留数据值原来的顺序
	eg: [1,2,3,2,1] 去重之后 [1,2,3]
	l1 = [2,3,2,1,2,3,2,3,4,3,4,3,2,3,5,6,5]
 
3.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
　　linuxs={'kermit','tony','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合

4.整理今日内容及博客
	针对可变不可变类型可参考老师博客进一步查看
    	https://www.cnblogs.com/Dominic-Ji/articles/15959963.html

——————————————————————————————————————————————————————————————————————————————————————
1.