[19/09/18-星期三] Python中的序列

1、

# 第四章 序列（视频58-76）
## 列表（list）
    - 列表是Python中的一个对象
    - 对象（object）就是内存中专门用来存储数据的一块区域
    - 以前咱们学习的对象，像数值，它只能保存一个单一的数据
    - 列表中能够保存多个有序的数据
    - 列表是用来存储对象的对象
    - 列表的使用：
        1.列表的建立
        2.操做列表中的数据

    - 练习：
        - 建立一个列表，在列表中保存你最好的5个朋友的名字
            而后分别经过索引来获取每个朋友的名字

## 序列（sequence）
    - 序列是Python中最基本的一种数据结构
    - 数据结构指计算机中数据存储的方式
    - 序列用于保存一组有序的数据，全部的数据在序列当中都有一个惟一的位置（索引）
        而且序列中的数据会按照添加的顺序来分配索引
    - 序列的分类：
        可变序列（序列中的元素能够改变）：
            > 列表（list）
        不可变序列（序列中的元素不能改变）：
            > 字符串（str）    
            > 元组（tuple）
        - 刚刚咱们所讲全部操做都是序列的通用操做01 02 03 三个文件中的操做
        
## EMS（Employee Manager System 员工管理系统） 练习
    - 作命令行版本的员工管理系统
    - 功能：
        四个：
            1.查询
                - 显示当前系统当中的全部员工
            2.添加
                - 将员工添加到当前系统中
            3.删除
                - 将员工从系统当中删除
            4.退出
                - 退出系统
    - 员工信息要保存到哪里？ 列表，在系统中应该有一个列表，专门用来保存全部员工信息的 

## 可变对象
    - 每一个对象中都保存了三个数据：
        id（标识）
        type（类型）
        value（值）    

    - 列表就是一个可变对象
        a = [1,2,3]

    - a[0] = 10 （改对象）
        - 这个操做是在经过变量去修改对象的值
        - 这种操做不会改变变量所指向的对象    
        - 当咱们去修改对象时，若是有其余变量也指向了该对象，则修改也会在其余的变量中体现

    - a = [4,5,6] （改变量）
        - 这个操做是在给变量从新赋值
        - 这种操做会改变变量所指向的对象
        - 为一个变量从新赋值时，不会影响其余的变量

    - 通常只有在为变量赋值时才是修改变量，其他的都是修改对象

## 字典（dict）
    - 字典属于一种新的数据结构，称为映射（mapping）
    - 字典的做用和列表相似，都是用来存储对象的容器
    - 列表存储数据的性能很好，可是查询数据的性能的不好
    - 在字典中每个元素都有一个惟一的名字，经过这个惟一的名字能够快速的查找到指定的元素
    - 在查询元素时，字典的效率是很是快的
    - 在字典中能够保存多个对象，每一个对象都会有一个惟一的名字
        这个惟一的名字，咱们称其为键（key），经过key能够快速的查询value
        这个对象，咱们称其为值（value）
        因此字典，咱们也称为叫作键值对（key-value）结构
        每一个字典中均可以有多个键值对，而每个键值对咱们称其为一项（item）

## 集合（set）
    - 集合和列表很是类似
    - 不一样点：
        1.集合中只能存储不可变对象
        2.集合中存储的对象是无序（不是按照元素的插入顺序保存）
        3.集合中不能出现重复的元素

 

2、

# 建立列表，经过[]来建立列表
my_list = [] # 建立了一个空列表
# print(my_list , type(my_list))

# 列表存储的数据，咱们称为元素
# 一个列表中能够存储多个元素，也能够在建立列表时，来指定列表中的元素
my_list = [10] # 建立一个只包含一个元素的列表

# 当向列表中添加多个元素时，多个元素之间使用,隔开
my_list = [10,20,30,40,50] # 建立了一个保护有5个元素的列表

# 列表中能够保存任意的对象
my_list = [10,'hello',True,None,[1,2,3],print]

# 列表中的对象都会按照插入的顺序存储到列表中，
#   第一个插入的对象保存到第一个位置，第二个保存到第二个位置
# 咱们能够经过索引（index）来获取列表中的元素
#   索引是元素在列表中的位置，列表中的每个元素都有一个索引
#   索引是从0开始的整数，列表第一个位置索引为0，第二个位置索引为1，第三个位置索引为2，以此类推
my_list = [10,20,30,40,50]

# 经过索引获取列表中的元素
# 语法：my_list[索引] my_list[0]
# print(my_list[4])
# 若是使用的索引超过了最大的范围，会抛出异常
# print(my_list[5]) IndexError: list index out of range

# 获取列表的长度，列表中元素的个数
# len()函数，经过该函数能够获取列表的长度
# 获取到的长度的值，是列表的最大索引 + 1
print(len(my_list)) # 5

3、

 

# 切片
# 切片指从现有列表中，获取一个子列表
# 建立一个列表，通常建立列表时，变量的名字会使用复数
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# 列表的索引能够是负数
# 若是索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个 以此类推
# print(stus[-2])

# 经过切片来获取指定的元素
# 语法：列表[起始:结束] 
#   经过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
#   作切片操做时，总会返回一个新的列表，不会影响原来的列表
#   起始和结束位置的索引均可以省略不写
#   若是省略结束位置，则会一直截取到最后
#   若是省略起始位置，则会从第一个元素开始截取
#   若是起始位置和结束位置所有省略，则至关于建立了一个列表的副本
# print(stus[1:])
# print(stus[:3])
# print(stus[:])
# print(stus)

# 语法：列表[起始:结束:步长] 
# 步长表示，每次获取元素的间隔，默认值是1
# print(stus[0:5:3])
# 步长不能是0，可是能够是负数
# print(stus[::0]) ValueError: slice step cannot be zero
# 若是是负数，则会从列表的后部向前边取元素
print(stus[::-1])

 4、通用操做

# + 和 *
# +能够将两个列表拼接为一个列表
my_list = [1,2,3] + [4,5,6] # 输出[1,2,3,4,5,6]

# * 能够将列表重复指定的次数
my_list = [1,2,3] * 5

# print(my_list)

# 建立一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']

# in 和 not in
# in用来检查指定元素是否存在于列表中
#   若是存在，返回True，不然返回False
# not in用来检查指定元素是否不在列表中
#   若是不在，返回True，不然返回False
# print('牛魔王' not in stus)
# print('牛魔王' in stus)

# len()获取列表中的元素的个数

# min() 获取列表中的最小值
# max() 获取列表中的最大值
arr = [10,1,2,5,100,77]
# print(min(arr) , max(arr))

# 两个方法（method），方法和函数基本上是同样，只不过方法必须经过 对象.方法() 的形式调用
# xxx.print() 方法实际上就是和对象关系紧密的函数。//与Java中方法相似。
# s.index() 获取指定元素在列表中的第一次出现时索引
# print(stus.index('沙和尚')) //方法的重载
# index()的第二个参数，表示查找的起始位置 ， 第三个参数，表示查找的结束位置
# print(stus.index('沙和尚',3,7))
# 若是要获取列表中没有的元素，会抛出异常
# print(stus.index('牛魔王')) ValueError: '牛魔王' is not in list
# s.count() 统计指定元素在列表中出现的次数
print(stus.count('牛魔王'))

5、修改元素

# 建立一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# print("修改前：",stus)
# 修改列表中的元素
# 直接经过索引来修改元素
stus[0] = 'sunwukong'
stus[2] = '哈哈'
# 经过del来删除元素
del stus[2] # 删除索引为2的元素

# print('修改后：',stus)

stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# print("修改前：",stus)

# 经过切片来修改列表
# 在给切片进行赋值时，只能使用序列，就是加上中括号[ ]
# stus[0:2] = ['牛魔王','红孩儿'] 使用新的元素替换旧元素 [0,2]实际就是选中下标0-1的元素
# stus[0:2] = ['牛魔王','红孩儿','二郎神'] 能够传多个元素超过2个限制。
# stus[0:0] = ['牛魔王'] # 向索引为0的位置插入元素
# 当设置了步长时，序列中元素的个数必须和切片中元素的个数一致
# stus[::2] = ['牛魔王','红孩儿','二郎神']

# 经过切片来删除元素
# del stus[0:2]
# del stus[::2] //删除从0开始步长为2的元素 指的是0 2 4
# stus[1:3] = [] 也表示删除从1-2的元素

# print('修改后：',stus)

# 以上操做，只适用于可变序列
s = 'hello'
# s[1] = 'a' 不可变序列，没法经过索引来修改
# 能够经过 list() 函数将其余的序列转换为list
s = list(s) #输出结果['h','e','l','l','o']
print(s)

6、列表的方法

# 列表的方法
stus = ['孙悟空','猪八戒','沙和尚']
# print('原列表：',stus)

# append() 
# 向列表的最后添加一个元素
# stus.append('唐僧')

# insert()
# 向列表的指定位置插入一个元素
# 参数：
#   1.要插入的位置
#   2.要插入的元素
# stus.insert(2,'唐僧')

# extend()
# 使用新的序列来扩展当前序列
# 须要一个序列做为参数，它会将该序列中的元素添加到当前列表中
# stus.extend(['唐僧','白骨精'])
# stus += ['唐僧','白骨精'] #跟上边的效果是同样的  

# clear()
# 清空序列
# stus.clear()

# pop()
# 根据索引删除并返回被删除的元素

# result = stus.pop(2) # 删除索引为2的元素
# result = stus.pop() # 删除最后一个
# print('result =',result)

# remove()
# 删除指定值的元素，若是相同值得元素有多个，只会删除第一个。没有返回值，没有意义。
# stus.remove('猪八戒')

# reverse()
# 用来反转列表
# stus.reverse()

# sort()
# 用来对列表中的元素进行排序，默认是升序排列
# 若是须要降序排列，则须要传递一个reverse=True做为参数
my_list = list('asnbdnbasdabd')
my_list = [10,1,20,3,4,5,0,-2]

print('修改前',my_list)

my_list.sort(reverse=True)
print('修改后',my_list)
# print('修改后：',stus)

 7、遍历列表

# 遍历列表，指的就是将列表中的全部元素取出来
# 建立列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','白骨精','蜘蛛精']

# 遍历列表
# print(stus[0])
# print(stus[1])
# print(stus[2])
# print(stus[3])

# 经过while循环来遍历列表
# i = 0
# while i < len(stus):
#     print(stus[i])
#     i += 1

# 经过for循环来遍历列表
# 语法：
#   for 变量 in 序列 :
#       代码块
# for循环的代码块会执行屡次，序列中有几个元素就会执行几回
#   每执行一次就会将序列中的一个元素赋值给变量，
#   因此咱们能够经过变量，来获取列表中的元素

for s in stus :
    print(s)

练习：员工管理系统

# 显示系统的欢迎信息
print('-'*20 , '欢迎使用员工管理系统', '-'*20)
# 建立一个列表，用来保存员工的信息，员工的信息以字符串的形式统一保存到列表
emps = ['孙悟空\t18\t男\t花果山','猪八戒\t28\t男\t高老庄']

# 建立一个死循环
while True:
    # 显示用户的选项
    print('请选择要作的操做：')
    print('\t1.查询员工')
    print('\t2.添加员工')
    print('\t3.删除员工')
    print('\t4.退出系统')
    user_choose = input('请选择[1-4]:')
    print('-'*62)
    # 根据用户的选择作相关的操做
    if user_choose == '1' :
        # 查询员工
        # 打印表头
        print('\t序号\t姓名\t年龄\t性别\t住址')
        # 建立一个变量，来表示员工的序号
        n = 1
        # 显示员工信息
        for emp in emps :
            print(f'\t{n}\t{emp}')
            n += 1
    elif user_choose == '2':
        # 添加员工
        # 获取要添加员工的信息，姓名、年龄、性别、住址
        emp_name = input('请输入员工的姓名：')
        emp_age = input('请输入员工的年龄：')
        emp_gender = input('请输入员工的性别：')
        emp_address = input('请输入员工的住址：')

        # 建立员工信息
        # 将四个信息拼接为一个字符串，而后插入到列表中
        emp = f'{emp_name}\t{emp_age}\t{emp_gender}\t{emp_address}'
        # 显示一个提示信息
        print('如下员工将被添加到系统中')
        print('-'*62)
        print('姓名\t年龄\t性别\t住址')
        print(emp)
        print('-'*62)
        user_confirm = input('是否确认该操做[Y/N]:')

        # 判断
        if user_confirm == 'Y' or user_confirm == 'yes' or user_confirm == 'y' :
            # 确认
            emps.append(emp)
            # 显示提示信息
            print('添加成功！')
        else :
            # 取消操做
            print('添加已取消！')
        
    elif user_choose == '3':
        # 删除员工，根据员工的序号来删除员工
        # 获取要删除的员工的序号
        del_num = int(input('请输入要删除的员工的序号：'))

        # 判断序号是否有效
        if 0 < del_num <= len(emps) :
            # 输入合法，根据序号来获取索引
            del_i = del_num - 1
            # 显示一个提示信息
            print('如下员工将被删除')
            print('-'*62)
            print('\t序号\t姓名\t年龄\t性别\t住址')
            print(f'\t{del_num}\t{emps[del_i]}')
            print('-'*62)
            user_confirm = input('该操做不可恢复，是否确认[Y/N]:')
            # 判断
            if user_confirm == 'y' or user_confirm == 'yes'or user_confirm == 'Y' :
                # 删除元素
                emps.pop(del_i)
                # 显示提示
                print('员工已被删除！')
            else :
                # 操做取消
                print('操做已取消！')
        else :
            # 输入有误
            print('您的输入有误，请从新操做！')

    elif user_choose == '4':
        # 退出
        print('欢迎使用！再见!')
        input('点击回车键退出！')
        break
    else :
        print('您的输入有误，请从新选择！')

    # 打印分割线
    print('-'*62)

 8、随机数

# range()是一个函数，能够用来生成一个天然数的序列
r = range(5) # 生成一个这样的序列[0,1,2,3,4]
r = range(0,10,2)
r = range(10,0,-1)
# 该函数须要三个参数
#   1.起始位置（能够省略，默认是0）
#   2.结束位置
#   3.步长（能够省略，默认是1）

# print(list(r))

# 经过range()能够建立一个执行指定次数的for循环
# for()循环除了建立方式之外，其他的都和while同样，
#   包括else、包括break continue均可以在for循环中使用
#   而且for循环使用也更加简单
# 将以前使用while循环作的练习，再使用for循环完成一次！
for i in range(30):
    print(i)

# for s in 'hello':
#     print(s)

 9、元组

# 元组 tuple
# 元组是一个不可变的序列
# 它的操做的方式基本上和列表是一致的
# 因此你在操做元组时，就把元组当成是一个不可变的列表就ok了
# 通常当咱们但愿数据不改变时，就使用元组，其他状况都使用列表

# 建立元组
# 使用()来建立元组
my_tuple = () # 建立了一个空元组
# print(my_tuple,type(my_tuple)) # <class 'tuple'>

my_tuple = (1,2,3,4,5) # 建立了一个5个元素的元组
# 元组是不可变对象，不能尝试为元组中的元素从新赋值
# my_tuple[3] = 10 TypeError: 'tuple' object does not support item assignment
# print(my_tuple[3])

# 当元组不是空元组时，括号能够省略
# 若是元组不是空元组，它里边至少要有一个, 加个逗号
my_tuple = 10,20,30,40
my_tuple = 40,
# print(my_tuple , type(my_tuple))

my_tuple = 10 , 20 , 30 , 40

# 元组的解包（解构）
# 解包指就是将元组当中每个元素都赋值给一个变量
a,b,c,d = my_tuple

# print("a =",a)
# print("b =",b)
# print("c =",c)
# print("d =",d)

a = 100
b = 300
# print(a , b)

# 交互a 和 b的值，这时咱们就能够利用元组的解包
a , b = b , a

# print(a , b)
my_tuple = 10 , 20 , 30 , 40


# 在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
# 也能够在变量前边添加一个*，这样变量将会获取元组中全部剩余的元素
a , b , *c = my_tuple #剩下的30和40都给c
a , *b , c = my_tuple
*a , b , c = my_tuple
a , b , *c = [1,2,3,4,5,6,7]
a , b , *c = 'hello world'
# 不能同时出现两个或以上的*变量
# *a , *b , c = my_tuple SyntaxError: two starred expressions in assignment
print('a =',a)
print('b =',b)
print('c =',c)
 

10、可变对象

# # 可变对象，改变对象中的value值
# a = [1,2,3]
# print('修改前：', a , id(a))

# # 经过索引修改列表
# a[0] = 10
# print('修改后：', a , id(a)) #id并无改变，和上边同样

# # 为变量从新赋值
# a = [4,5,6] #id也变了，是个新的对象。
# print('修改后：', a , id(a))


a = [1,2,3]
b = a
# b[0] = 10
b = [10,2,3]
# print("a",a,id(a))
# print("b",b,id(b))

# == !=  is is not
# == != 比较的是对象的值是否相等 
# is is not 比较的是对象的id是否相等（比较两个对象是不是同一个对象）

a = [1,2,3]
b = [1,2,3]
print(a,b)
print(id(a),id(b)) #id值不一样
print(a == b) # a和b的值相等，使用==会返回True
print(a is b) # a和b不是同一个对象，内存地址不一样，使用is会返回False