Python(三)序列类型

学习思路：通过'大量的练习'来掌握相应的知识点,培养'编程思维(思路)',并'不单纯'的讲解语法！

Python'有6个序列'的内置类型,但最'常见'的是列表('list')和元组('tulpe')

一、列表(list)、元组(tulpe)、字典(dict)

思路：各个击破、'求同存异'(分析)

（1）列表

构成：通过逗号分隔的不同的数据项使用方括号括起来构成列表！

特点：有顺序(所以可以通过索引index获取值)，列表的数据项不需要具有相同的类型(存储任意类型的数据)，可变的数据类型！

特性：索引(index)、切片(slice)，加(连接)，乘(重复)，检查成员(判断)

内置：len()确定序列的长度、确定最大max()和最小的min()元素的方法(同一类型)

service = ['ftp', 'http', 'ftp', 'ssh', 'mysql']

# 通过索引值，重新赋值
service[0] = 'samba'
print(service)

# 通过切片赋值[0,1]两个-->nfs是追加的-->注意：并不需要赋值个数和元素的位置匹配！！！
service[:2] = ['mysql', 'nginx', 'nfs']
print(service)

（2）元组（tuple）

细节

    1）如果元组里面包含可变数据类型，可以间接的修改元组内容

t1 = ([1,2,3],4)
# 如果元组里面包含可变数据类型，可以间接的修改元组内容
t1[0].append(5)
print(t1

    2）元组如果只有一个元素，元素后面一定要加逗号，否则数据类型不确定(根据这个数据的类型)

t = (2,)#tuple元组类型

t = (2) #int类型

需求1：元组和列表的转换

t2=()
print(t2,type(t2))
t3=tuple([])
print(t3,type(t3))
t4=list(t3)
print(t4,type(t4))

（3）元组和列表的差异对比

          不同之处在于元组的元素不能修改(没有增删改-->没有对应的方法！)

          元组使用小括号()，列表使用方括号[]

形容数据的可变性

         列表：打了激素的数组--->增强版的元组！

         元组：带了紧箍咒的列表

二、练习

需求1：

"""
1.系统里面有多个用户，用户的信息目前保存在列表里面
    users = ['root','westos']
    passwd = ['123','456']


 - 添加用户:
    1).  判断用户是否存在?
    2).  如果存在， 报错；
    3).  如果不存在，添加用户名和密码分别到列表中;

- 删除用户
    1). 判断用户名是否存在
    2). 如果存在，删除；
    3). 如果不存在， 报错；
- 用户登陆
- 用户查看
- 退出

"""

分析：其实就是一个权限管理系统，首先必须登陆，用一个列表模拟用户名和密码的文件(数据库)，登陆的时候验证，登陆之后用户进行权限的管理和查看，操作完毕就退出系统！

# (1)列表嵌套，每一个元素是用户名和密码-->模拟数据库文件!

list1 = [['root', 'westos'], ['kiosk', '456']]
# print(list1,type(list1))

# (2)登陆-->用一个死循环模拟登陆!
while True:
    # 输入用户名
    username = input('Please input your username:')
    # (2)判断用户名是否存在
    for i in list1:
        if username in i[0]:
            # 用户名存在，则判断密码是否相等!
            password = input('Please input your password:')
            # 统计次数--->后续！
            if password in i[1]:
                print('登陆成功')
                # 进入登陆之后的界面-->给三个动作
                while True:
                    operation = input('Please input your operation C[re]|D[el]|E[xit]:')
                    # (1)退出
                    if operation == 'E':
                        exit()
                    name = input('Please input the name your wanted to add|del:')
                    # 定义一个标志位-->表明是否已经有该用户了！
                    flag = 0
                    index1 = 0
                    # 遍例用户-->判断用户名是否存在
                    for i in list1:
                        if name in i[0]:
                            flag = 1
                            index1 = i
                            # 不再向后判断了！
                            break
                    # (2)创建-->说明:创建之后应该进入下一次操作
                    if operation == 'C':
                        # 判断用户是否存在-->0表示不存在
                        if flag == 0:
                            # 追加一个列表-->添加用户的信息(用户名和密码)
                            list1.append([])
                            list1[-1].append(name)
                            passd = input('Please input your password:')
                            list1[-1].append(passd)
                            print('用户创建成功')
                            print(list1)
                            continue
                        else:
                            print('Error,用户已经存在，无法创建！')
                    # (3)删除
                    elif operation == 'D':
                        if flag == 1:
                            list1.remove(index1)
                            print('删除成功')
                            print(list1)
                            continue
                        else:
                            print('Error，用户不存在，无法删除')
            else:
                #后续补充！
                print('密码不正确,还有三次机会')
        else:
            # print('输入的用户名不正确,清重新输入!')
            print('')

说明：查看模块没有写，后续完善(通过字典数据类型和函数来简化)！

需求2：元组的应用场景

a = 1
b = 2
b,a = a,b
# (1)说明:完成了封包和拆包-->两个元素互换！-->中间元组(t)
# b,a = (1,2) b=(1,2)[0] a=(1,2)[1]
print(a)
print(b)

# (2)打印变量-->等价方式(理解)-->封包
name = 'westos'
age = 11
t = (name,age)
print('name:%s,age:%d' %(name,age))
print('name:%s,age:%d' %t)

# (3)元组的赋值：有多少个元素，就用多少个变量接收-->拆包
t = ('westos',10,100)
name,age,score =t
print(name,age,score)

（2）集合-->set

# 集合里面的元素不可重复的-->即使定义时是重复的，也会去重！
s = {1,2,3,4,1,2,3,4,[1,2,3,4]}
print(s,type(s))
# 定义一个空集合
# s2 = {}
# print(s2,type(s2))

# 说明: 默认情况下是dict,所以必须强转！
# s3 = set([])
# print(s3,type(s3))

# 列表去重-->两次倒腾！
li = [1,2,3,1,2,3,4,5,6,4,5,6]
print(list(set(li)))

集合特性：只支持成员操作符！

集合的方法

# (1)集合是一个"可变"的数据类型
# (2)添加顺序和在集合中存储的顺序不同

# s = {6,7,8,9,1,2,3}
# print(s)
#
# 需求1：添加
# s.add(10)
# s.add(0)
# print(s)
#
# 需求2：增加多个元素
# s.update({3,4,5,6,7,8})
# print(s)
#
# 需求3：删除
# s.pop()
# s.pop()
# s.pop()
# print(s)
#
# 需求4：删除指定元素 元素必须要存在，否则报错！
# s.remove(100)
# print(s)

############数据分析必备(set集合)################

# 交集 并集 差集
s1 = {1,2,3}
s2 = {2,3,4}
# 并集
print('并集：',s1.union(s2))
print('并集：',s1 | s2)
# 交集
print('交集：',s1.intersection(s2))
print('交集：',s1 & s2)
# 差集
# s1和s2的差集：s1中有哪些元素s2中没有
print('差集：',s1.difference(s2))
print('差集：',s1-s2)
# s2和s1的差集
print('差集：',s2.difference(s1))
print('差集：',s2-s1)
# 对等差分:并集 - 交集
print('对等差分：',s1.symmetric_difference(s2))
print('对等差分：',s1^s2)
s3 = {'redhat','westos'}
s4 = {'redhat','westos','linux'}
# s3是否s4的子集
print(s3.issubset(s4))
# s3是否s4的超集-->与子集相反！
print(s3.issuperset(s4))
# 两个集合是不是不相交
print(s3.isdisjoint(s4))

需求2：

"""

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性；
（1）他先用计算机生成了N个1～1000之间的随机整数(N<=1000),N是用户输入的，
（2）对于其中重复的数字，只保留一个，把其余相同的数字去掉，不同的数对应着不同的学生的学号，
（3）然后再把这些数从小到大排序，按照排好的顺序去找同学做调查，请你协助明明完成“去重”与排序工作！

"""

import random
#强转
s = set([])
for i in range(int(input('N:'))):
    s.add(random.randint(1,1000))
print(sorted(s))

说明：利用了集合自带的去重！

（4）字典

字典的创建

s = {}
# 注意1:花括号没有元素是dict类型！
print(s,type(s))

# 字典：key-value 键值对
# 说明：类似于数学上的映射-->键唯一(所以不能是可变的-->比如列表！)
s = {
    'linux':[100,99,88],
    'python':[190,56,78]
}
print(s,type(s))

# 工厂函数-->产生字典！
d = dict()
print(d,type(d))

# 创建字典对象，并初始化(key=value的形式)！
d = dict(a=1,b=2)
print(d,type(d))

# 字典的嵌套(key:value，多个key-values对以逗号分割！)

student = {
    '123':{
        'name':'tom',
        'age':18,
        'score':99
    },
    '456':{
        'name':'lily',
        'age':19,
        'score':100
    }
}

#说明:调用字典的方式-->键找值
#可以理解为:字典是列表的高级形式-->高级体现在"键"不仅仅是数字索引！
print(student['123']['name'])

字典的特性(三种)

d = {
    '1':'a',
    '2':'b'
}

print(d['1'])-->查看！

# 字典不支持切片的-->没有索引

# 成员操作符(针对key)！！！

print('1' in d)
print('1' not in d)

# for循环 针对key！！！
for key in d:
    print(key)
# 遍历字典
for key in d:
    #输出一个元组！
    print(key,d[key])

字典元素的增加

service = {
    'http':80,
    'ftp':23,
    'ssh':22
}

# 需求1：增加一个元素
# 如果key值存在，则更新对应的value值
# 如果key值不存在，则添加对应的key-value值
# 好好体会这一特性！！！

service['https'] = 443
print(service)
service['ftp'] = 21
print(service)
# 需求2：增加多个key值
service_backup = {
    'tomcat':8080,
    'mysql':3306
}

service.update(service_backup)
print(service)
# 需求3：python的Web框架形式
service.update(flask=9000,dns=53)
print(service)

# 如果key值存在：不做修改！
# 如果key值不存在：则添加对应的key-value
service.setdefault('http',9090)
print(service)
service.setdefault('oracle',44575)
print(service)

字典元素的删除

service = {
    'http':80,
    'ftp':23,
    'ssh':22
}
# del service['http']
# print(service)
"""
pop删除指定key对应的value值
如果key存在，删除，并且返回删除key对应的value(可以用变量取接收)-->有点人性！
如果不存在，直接报错
"""
# item = service.pop('https')
# print(item)
# print(service)
# popitem删除最后一个key-value值！！！
item = service.popitem()
print(item)
print(service)

# 清空字典内容
service.clear()
print(service)

字典的查看

service = {
    'http':80,
    'ftp':23,
    'ssh':22
}
# 查看字典的key值
print(service.keys())
# 查看字典的value值
print(service.values())
# 查看字典的key-value值
print(service.items())
"""
key不存在，默认返回None
key存在，default就返回defalut的值 没有就返回None

说明:与[]键找值的方式查看的区别-->[]找不到会报错！！！
"""
print(service.get('https','443'))