列表、字典、元组、集合的内置方法、可变与不可变类型、练习

作业讲解

2.基于列表充当数据库完成用户登录(拔高练习)  # 多个用户数据
	 data_source = ['jason|123', 'kevin|321','oscar|222']
  
解题思路：
    1.获取用户名密码
    2.想办法将列表中的数据值取出来，用for循环
    3.会用到.split() 和解压赋值
    4.用if来判断用户名和密码
    data_source = ['jason|123', 'kevin|321','oscar|222']
    real_name = input('请输入你的用户名：>>>').strip()
    real_pwd = input('请输入你的密码:>>>').strip()
    for i in data_source:
        name,pwd = i.split('|')
        if real_name == name and real_pwd == pwd:
            print("登录成功")
            break
    else:
        print("登录失败")  

列表的内置方法

列表在调用内置方法之后不会产生新的值，它修改的是自己（ps：字符串在调用内置方法是产生新的数据值，不改变原数据）

相关操作

l1=[11,22,33,44,55,66,77]
1.统计列表中数据值的个数 len()
  eg： print(len(l1))
2.查看数据值对应的索引值  list.index()
  eg:print(l1.index(22))  # 1
3.统计某个数据值出现的次数 list.count()
  eg:
  l1 =['nana','nana','xiaoxiao','mingming','nana']
  print(l1.count('nana'))  # 3
4.排序 list.sort() 升序； list.sort(reverse=True) 降序
  eg:
  l2 = [1,4,3,7,8,9,0]
  l2.sort()  
  print(l2)  # [0, 1, 3, 4, 7, 8, 9]
  l2.sort(reverse=True)
  print(l2)  # [9, 8, 7, 4, 3, 1, 0]
5.翻转 list.reverse()
  eg:
  l2.reverse()
  print(l2)  # [0, 9, 8, 7, 3, 4, 1]
6.比较运算
  eg:
  l3 = [33,22]
  l4 = [22,33,44]
  print(l3>l4)  # True  >>>按照位置顺序一一比较 33>22

  l3 = [33,22]
  l4 = ['e',33,44]
  print(l3>l4)  # 报错 不同数据类型之间默认无法直接作比较

增加数据值的操作

1.尾部增加数据值  list.append() >>> append 后面的括号只有一个参数
  l1=[11,22,33,44,55,66,77]
  eg:
  l1.append(9999)
  print(l1)
  res = l1.append(9999)  # [11, 22, 33, 44, 55, 66, 77, 9999]
  print(res)  # None
  ps: 这里也可以看出列表不产生新的值，修改的是自己
    
  s1 = '$$haha$'
  print(s1.strip('$'))  # haha
  print(s1)  # $$haha$
  ps： 可以看出字符串产生新的值 而原来的值没有变
2.任意位置插入数值 list.insert()  括号内无论写入什么数据类型 都当成一个数据值插入
  eg:
  l1.insert(0,'你好')
  print(l1)  # ['你好', 11, 22, 33, 44, 55, 66, 77]
  
  l1.insert(1,['nana','xiaoxiao'])
  print(l1)  # [11, ['nana', 'xiaoxiao'], 22, 33, 44, 55, 66, 77]
3.扩展列表  
  l1= [1,2,3]
  l2 = [11,22,33,44,55]
  >>>得出[11,22,33,44,55,1,2,3]的列表
  方式1：for循环
  for i in l1:
      l2.append(i)
  print(l2)
  方式2：两个列表相加
  print(l2+l1)
  方式3：list.extend() >>>括号里面必须是支持for循环的数据类型 
  l2.extend(l1)
  print(l2)
    

删除数据值的操作

1.用del删除
  eg:
  l1=[11,22,33,44,55,66,77]
  del l1[1]
  print(l1)  # [11, 33, 44, 55, 66, 77]
  del l1
  print(l1)  # NameError: name 'l1' is not defined
2.指定删除 list.remove()  >>>括号内必须填写明确的数据值
  eg:
  res = l1.remove(11)
  print(l1)  # [22, 33, 44, 55, 66, 77]
  print(res)  # None 
3.先取出数据值再删 list.pop()  >>>默认取出列表尾部数据值 然后再删 
  eg:
  res = l1.pop()
  print(l1)  # [11, 22, 33, 44, 55, 66]
  print(res)  # 77
  ps:pop()括号里不填东西     
  

查询和修改数据值的操作

1.查询：也就是索引取值
  l1=[11,22,33,44,55,66,77]
  eg: print(l1[0])  # 11
2.修改数据
  eg: 
  l1[0] = 'nana'
  print(l1)  # ['nana', 22, 33, 44, 55, 66, 77]

元组的内置方法

eg：t1=(1,2,3,4)
1.概念：用小括号括起来的，里面可有多个数据值（可是任意类型），数据值与数字值用逗号隔开 
		ps：元组也称不可变列表   t1[0] = 'nana' >>>报错
2.类型转换：支持for循环的数据类型都可以转换为元组
  eg:
  print(tuple(123))
  print(tuple([1,2]))  # (1, 2)
  print(tuple('nana'))  # ('n', 'a', 'n', 'a')
  print(tuple({1,2,3}))  # (1, 2, 3)
  print(tuple({'name':'naan','age':18}))  # ('name', 'age')
  ps:当元组内只有一个数据值的时候 逗号不能省略(eg:(111,))
     以后在遇到可以存储多个数据值的数据类型 如果里面也只有一个数据，也需要将逗号加上
3.内置方法
  3.1 索引相关操作
    eg:
    print(t1[0])  # 1
	print(t1[-1])  # 4
	print(t1[::2])  # (1, 3)
  3.2 统计元组数据值个数 len()
	eg:print(len(t1))  # 4
  3.3查与改  >>>可以查 但不能该
	eg:
    print(t1[0])  # 1
    t1[0] = 22
    print(t1)  # 报错
    ps:元组的索引不能改变绑定的地址
    t1 = (11, 22, 33, [11, 22])
    t1[-1].append(33)
    print(t1)  # (11, 22, 33, [11, 22, 33])

字典的内置方法

类型转换

1.字典很少涉及到类型转换，都是直接定义使用
2.定义字典
    print(dict([('name','nana'),('age',18)]))  # {'name': 'nana', 'age': 18}
    print(dict(name='nana',pwd = 123))  # {'name': 'nana', 'pwd': 123}
    info = {
        'username': 'jason',
        'pwd': 123,
        'hobby': ['read', 'run']
    }
   
    ps:K是对V的描述性性质的信息一般是字符串 K其实只要是不可变类型(字符串 整型 浮点型)都可以
   

相关操作

dic1 = {
    'name':'nana',
    'age':18,
    'pwd':123,
    'hobby':['read','play']
    
}
1.取值操作 >>>字典k：v键值对是无序的,所以不能够索引取值
  1.1 按k取值
    eg:
    print(dic1['name'])  # nana
    print(dic1['xxx'])  # 报错 
    ps:键不存在会直接报错
  1.2 dict.get()
	eg:
     print(dic1.get('name'))  # nana
	 print(dic1.get('xxx'))  # None
     ps：键不存在返回None
     print(dic1.get('name', '键不存在返回的值 默认返回None'))  # nana
	print(dic1.get('xxx', '键不存在返回的值 默认返回None'))  # 键不存在返回的值 默认返回None
2.统计字典中键值对的个数 len()
  eg： print(len(dic1))  # 4
3.更新修改字典数据  dict.update() >>>update括号里面填字典 键存在则是修改  键不存在则是新增
  eg:
  dic1.update({'name':'xiao'})
  print(dic1)  # {'name': 'xiao', 'age': 18, 'pwd': 123, 'hobby': ['read', 'play']}
  
  dic1.update({'salary':100000})
  print(dic1)  # {'name': 'nana', 'age': 18, 'pwd': 123, 'hobby': ['read',   'play'], 'salary': 100000}
4.快速构建字典 dict.fromkeys(k,v) >>>给的值默认情况下所有的键都用一个
  eg：
  res1 = dict.fromkeys([1,2,3],None)
  print(res2)  # {1: None, 2: None, 3: None}
  
  res2 = dict.fromkeys(['name','age','hobby'],['nana',18,'read'])
  print(res2)  #  {'name': ['nana', 18, 'read'], 'age': ['nana', 18, 'read'], 'hobby': ['nana', 18, 'read']}
  res3 = dict.fromkeys(['name','age','hobby'],[])
  print(res3)  # {'name': [], 'age': [], 'hobby': []}
  res3['name'] =[]
  res3['name'].append('nana')
  res3['age'] =[]
  res3['age'].append(18)
  res3['hobby']=[]
  res3['hobby'].append('read')
  print(res3)  # {'name': ['nana'], 'age': [18], 'hobby': ['read']}
    
  res = dict.fromkeys([1, 2, 3], 234234234234234234234)
  print(id(res[1]))
  print(id(res[2]))
  print(id(res[3]))  >>>地址一样
5.dict.setdefault() >>>键存在则获取键对应的值 键不存在则添加 并返回设置的新值
  eg:
  res = dic1.setdefault('name','enen')
  print(dic1)  # {'name': 'nana', 'age': 18, 'pwd': 123, 'hobby': ['read', 'play']}
  print(res)  # nana
  res1 = dic1.setdefault('xxx','enen')
  print(dic1)  # {'name': 'nana', 'age': 18, 'pwd': 123, 'hobby': ['read', 'play'], 'xxx': 'enen'}
  print(res1)  # enen
  
  
  

增删改查相关操作

dic1 = {
    'name':'nana',
    'age':18,
    'pwd':123,
    'hobby':['read','play']
    
}
1.增加数据
  eg:
  dic1['salary'] = 100000
  print(dic1)  # {'name': 'nana', 'age': 18, 'pwd': 123, 'hobby': ['read', 'play'], 'salary': 100000}
2.删除数据
  2.1 del直接删
    eg:
	del dic1['name']
	print(dic1)  # {'age': 18, 'pwd': 123, 'hobby': ['read', 'play']}
  2.2 dict.pop()  >>>pop括号里天要删除的键
	eg:
    res = dic1.pop('name')
	print(dic1)  # {'age': 18, 'pwd': 123, 'hobby': ['read', 'play']}
	print(res)  # nana 
  2.3 dict.popitem() 随机删除
	eg:
	dic1.popitem()
	print(dic1)  # {'name': 'nana', 'age': 18, 'pwd': 123}
3.修改数据  >>>键存在则修改，键不存在则新增
  eg:
  dic1['name'] = 'xiaoxiao'
  print(dic1)  # {'name': 'xiaoxiao', 'age': 18, 'pwd': 123, 'hobby': ['read', 'play']}
4.查 快速获取键值对数据  dict.keys()   dict.values()  dict.items()
  eg:
  print(dic1.keys())  # dict_keys(['name', 'age', 'pwd', 'hobby'])
  ps:获取字典所有的k值 结果当成列表即可
  print(dic1.values())  # dict_values(['nana', 18, 123, ['read', 'play']])
  ps:获取字典kv键值对数据 组织成列表套元组
  

集合的内置方法

概要

eg:s1={1,2,3}
1.集合用于去重和关系运算（数学所学的并、交、差...）
2.定义空集合：必须使用关键字才能定义空集合
	eg:s1 = set()
3.集合内数据必须是不可变类型(整型 浮点型 字符串 元组 布尔值)
3.类型转换：支持for循环的并且数据必须是不可变类型

去重

集合本身是无序的，去重之后无法保留原来的顺序
s1 = {1,1,1,2,2,3,3,34,4,5,5,6,66,7,7,7}
print(s1)  # 1, 2, 3, 34, 4, 5, 6, 66, 7}  

关系运算

关系运算：并 交 差
eg:模拟两个人的好友集合
f1 = {'jason', 'tony', 'oscar', 'jerry'}
f2 = {'kevin', 'jerry', 'jason', 'lili'}
1.交 &
  print(f1 & f2)  # {'jason', 'jerry'}
2.差 -
  print(f1-f2)  # {'oscar', 'tony'}
  print(f2-f1)  # {'kevin', 'lili'}
3.并 |
  print(f1|f2)  # {'kevin', 'jerry', 'lili', 'tony', 'jason', 'oscar'}
4.排除交集 ^ = |-&
  print(f1^f2)  # {'tony', 'lili', 'oscar', 'kevin'}
5.父集与子集 >>>包含于被包含的关系
  s1 ={1,2,3,4}
  s2={1,2}
  print(s1>s2)  # True
  print(s1<s2)  # False

可变于不可变类型

1.可变类型：值发生改变，内存地址不变，改变了原值   list dict 
    l1 =[11,2,22,33]
    print(id(l1))  # 2601436333768
    l1[0] = 10
    print(l1)  # [10, 2, 22, 33]
    print(id(l1))  # 2601436333768

2.不可变类型：值发生改变，内存地址也发生改变，产生了新的值，原值没变  str int float tuple
  x = 1
  print(id(x))  # 1346596320
  x = 2
  print(id(x))  # 1346596352

作业

1.利用列表编写一个员工姓名管理系统
	输入1执行添加用户名功能
	输入2执行查看所有用户名功能
 	输入3执行删除指定用户名功能
	ps:思考如何让程序循环起来并且可以根据不同指令执行不同操作
	提示: 循环结构 + 分支结构
	拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写 不会没有关系)
   
name_list = []
while True:
    print("1  添加用户名功能")
    print("2  查看所有用户名功能")
    print("3  删除指定用户名功能")
    num = input("请输入你的指令（1-3）：>>>").strip()
    num = int(num)
    if num == 1:
        add_name = input("请输入你添加的用户名：>>>").strip()
        if add_name in name_list:
            print("用户已存在")
        else:
            name_list.append(add_name)
    elif num ==2:
        for i in name_list:
            print(i)
    elif num == 3:
        del_name = input("请输入你想删除的用户名:>>>").strip()
        if del_name in name_list:
            name_list.remove(del_name)
        else:
            print("删除的用户不存在")
    else:
        print('指令输入错误 ')




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]
    
        l2 =[]
        for i in l1:
            if i in l2:
                continue
            else:
                l2.append(i)
        print(l2)
        
3.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
　　linuxs={'kermit','tony','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
       print(pythons&linuxs)
　　2. 求出所有报名的学生名字集合
       print(pythons|linuxs)
　　3. 求出只报名python课程的学员名字
       print(pythons-linuxs)
　　4. 求出没有同时这两门课程的学员名字集合
       print(pythons^linuxs)