python3:列表、元组、字典、集合

列表

• 属于容器、顺序、可变类型

>>> l1 = [10, 20, 30, 10, 15, 8]
>>> len(l1)
6
>>> l1[-1] = 80   # 因为列表可变，所以可以对某个元素重新赋值
>>> l1
[10, 20, 30, 10, 15, 80]
>>> l1[1:3] = [1, 2, 3, 4, 5]   # 将下标为1、2的元素替换
>>> l1
[10, 1, 2, 3, 4, 5, 10, 15, 80]

• 列表的方法

>>> l1.append(10)  # 向列表尾部追加数据
>>> l1.insert(2, 80)  # 向下标为2的位置插入数字80
>>> l1
[10, 1, 80, 2, 3, 4, 5, 10, 15, 80, 10]
>>> l1.extend([10, 20, 30])   # 批量向列表尾部增加数据
>>> l1
[10, 1, 80, 2, 3, 4, 5, 10, 15, 80, 10, 10, 20, 30]
>>> l1.remove(80)  # 将列表中的第一个80删除
>>> l1.pop()       # 默认弹出列表中最后一项
30
>>> l1.index(80)   # 获取80的下标
8
>>> l1.pop(8)      # 弹出下标为8的数据项
80
##############################
# 方法其实就是函数。remove没有返回值，它默认返回None；pop有返回值，返回的>是删除项
>>> a = l1.remove(1)  # 把列表中出现的第一个1删除
>>> print(a)
None
>>> l1
[10, 2, 3, 4, 5, 10, 15, 10, 10, 20]
>>> b = l1.pop(1)     # 把列表中下标为1的项目弹出
>>> print(b)
2
>>> l1
[10, 3, 4, 5, 10, 15, 10, 10, 20]
##############################
>>> l1.index(10, 2)   # 从下标为2的位置开始查找10的下标
4
>>> l1.count(10)      # 统计列表中有几个10
4
>>> l1.sort()         # 升序排列
>>> l1
[3, 4, 5, 10, 10, 10, 10, 15, 20]
>>> l1.reverse()      # 翻转列表
>>> l1
[20, 15, 10, 10, 10, 10, 5, 4, 3]

>>> l3 = l1.copy()    # 将l1的值赋值给l3，它们使用不同的内存地址
>>> l3
[3, 4, 5, 10, 10, 10, 10, 15]
>>> l3.clear()        # 清空l3
>>> l3
[]
>>> l1
[3, 4, 5, 10, 10, 10, 10, 15]

元组

• 属于容器、序列、不可变类型
• 单元素元组，数据项后面必须有逗号，否则它不表示元组

>>> t1 = (10)   # t1是数字，不是元组
>>> type(t1)
<class 'int'>
>>> t1
10
>>> t2 = (10,)  # t2是元组，长度为1
>>> type(t2)
<class 'tuple'>
>>> len(t2)
1
>>> t2
(10,)

• 元组的方法

>>> t2.<tab><tab>
t2.count(  t2.index(

创建stack.py脚本，要求如下：

栈是一个后进先出的结构
编写一个程序，用列表实现栈结构
需要支持压栈、出栈、查询功能

stack = []

def push():
    '用于实现压栈功能'
    data = input('data: ').strip()  # 删除用户输入字符串两端的空格
    if data:  # 非空字符串为真，空为假
        stack.append(data)
        
def pop():
    '用于实现出栈功能'
    if stack:  # 非空列表为真，空为假
        print('从栈中，弹出: %s' % stack.pop())
    else:
        print('\033[31;1m空栈\033[0m')

def view():
    '实现查询功能'
    print(stack)

def show_menu():
    '用于实现菜单，根据用户的选择调用相应的函数'
    # 字典是容器类型，将函数保存到字典
    cmds = {'0': push, '1': pop, '2': view}
    prompt = '''(0) push
(1) pop
(2) view
(3) quit
Please input your choice(0/1/2/3): '''
    while 1:
        xuan = input(prompt).strip()  # 删除用户输入字符串两端的空格
        if xuan not in ['0', '1', '2', '3']:
            print('无效的选择，请重试。')
            continue
        if xuan == '3':
            print('Bye-bye')
            break
        cmds[xuan]()  # 在字典中取出函数，再加上()调用函数

if __name__ == '__main__':
    show_menu()

字典

• 属于容器、可变、映射类型

>>> d1 = {'name': 'tom', 'age': 20}
>>> d2 = dict(['ab', (10, 20), ['email', 'tom@tedu.cn']])
>>> d2
{'a': 'b', 10: 20, 'email': 'tom@tedu.cn'}
>>> dict([('name', 'tom'), ('age', 20), ('email', 'tom@tedu.cn')])
{'name': 'tom', 'age': 20, 'email': 'tom@tedu.cn'}
# 为字典的每个key设置相同的value
>>> d3 = {}.fromkeys(['tom', 'jerry', 'bob', 'alice'], 20)
>>> d3
{'tom': 20, 'jerry': 20, 'bob': 20, 'alice': 20}

• 通过key来访问字典的values

>>> len(d1)
2
>>> 'tom' in d1   # 'tom'是字典的key吗？
False
>>> 'name' in d1
True
>>> d1['name']
'tom'
>>> for k in d1:
...   print('%s: %s' % (k, d1[k]))
...
name: tom
age: 20

• 字典的Key不能重复。通过key进行赋值时，如果key已在字典中，则更新value，key不在字典中是增加新项

>>> d1['age'] = 22
>>> d1['email'] = 'tom@tedu.cn'
>>> d1
{'name': 'tom', 'age': 22, 'email': 'tom@tedu.cn'}

• 字典的key必须使用不可变对象

>>> d4 = {1: 'aaaa', 'name': 'tom', (10, 20): 'jerry'}

• 字典常用方法

# get是字典最重要的方法，必须熟练掌握
>>> d1.get('name')       # 在d1中取出name对应的值
'tom'
>>> print(d1.get('qq'))  # d1中没有qq这个key，默认返回None
None
>>> d1.get('age', 'not found')  # 在字典中取出age对应的值，没有age返回
not found
22
>>> d1.get('qq', 'not found')  # 在字典中取出qq对应的值，没有qq返回not found
'not found'

>>> d1.keys()     # 返回所有的key
dict_keys(['name', 'age', 'email'])
>>> list(d1.keys())
['name', 'age', 'email']
>>> d1.values()   # 返回所有的value
dict_values(['tom', 22, 'tom@tedu.cn'])
>>> list(d1.values())
['tom', 22, 'tom@tedu.cn']
>>> d1.items()    # 返回所有的(key, value)
dict_items([('name', 'tom'), ('age', 22), ('email', 'tom@tedu.cn')])
>>> list(d1.items())
[('name', 'tom'), ('age', 22), ('email', 'tom@tedu.cn')]
>>> d1.pop('email')  # 弹出key为email的项目
'tom@tedu.cn'
>>> d1.popitem()     # 弹出字典中某一项的(key, value)
('age', 22)
>>> d1.update({'aaa': 'bbb', 'ccc': 'ddd'})
>>> d1
{'name': 'tom', 'aaa': 'bbb', 'ccc': 'ddd'}

编写login.py脚本，实现以下目标：

支持新用户注册，新用户名和密码注册到字典中
支持老用户登陆，用户名和密码正确提示登陆成功
主程序通过循环询问进行何种操作，根据用户的选择，执行注册或是登陆操作

#!/usr/local/bin/python3
import getpass
stack={}
def adduser():
    username=input('请输入注册用户名：').strip()
    if (username not in stack) and username:
        passwd = input('请输入密码：')
        stack[username]=passwd
    else:
        print('用户已存在或为空')
def loguser():
    username=input('请输入登陆用户名：').strip()
    passwd = getpass.getpass('请输入密码：')
#    if (username not in stack) or (stack[username]!=passwd):
    if stack.get(username) != passwd:
        print('登陆失败')
    else:
        print("登陆成功")
def show_menu():
    csdn={'0':adduser,'1':loguser}
    prompt='''(0) 注册
(1) 登陆
(2) 退出
Please input your choice(0/1/2):'''
    while 1:
        xuan=input(prompt).strip()
        if xuan not in ['0','1','2']:
            print('输入错误，请重新输入(0/1/2)')
            continue
        if xuan == '2':
            print('Bey-bey')
            break
        csdn[xuan]()
if __name__ == '__main__':
    show_menu()
    print(stack)

集合

• 数学概念，由不同元素构成的数据类型
• 集合也是容器类型
• 它有可变集合set和不可变集合frozenset
• 集合元素不能重复
• 集合元素必须是不可变对象
• 集合没有顺序
• 集合就像是一个无值的字典，所以也使用{}来表示

>>> s1 = {10, 20, 'tom', 'jerry'}
>>> type(s1)
<class 'set'>
>>> len(s1)
4
>>> 10 in s1
True
>>> 'o' in s1
False
>>> for data in s1:
...   print(data)

• 集合常用操作

>>> s1 = set('abc')
>>> s2 = set('bcd')
>>> s1
{'b', 'c', 'a'}
>>> s2
{'b', 'c', 'd'}
>>> s1 & s2    # 取交集
{'b', 'c'}
>>> s1 | s2    # 取并集
{'c', 'd', 'b', 'a'}
>>> s1 - s2    # 差补，在s1中有但s2中无的元素
{'a'}
>>> s2 - s1
{'d'}
# 集合常用的场景是去重
>>> from random import randint
>>> nums = [randint(1, 50) for i in range(20)]
>>> nums
[28, 31, 27, 28, 43, 11, 2, 13, 4, 50, 4, 13, 12, 39, 23, 42, 35, 26, 19, 6]
>>> set(nums)
{2, 35, 4, 6, 39, 42, 11, 43, 13, 12, 50, 19, 23, 26, 27, 28, 31}
>>> list(set(nums))
[2, 35, 4, 6, 39, 42, 11, 43, 13, 12, 50, 19, 23, 26, 27, 28, 31]

• 集合方法

>>> s1.intersection(s2)   # s1 & s2
{'b', 'c'}
>>> s1.union(s2)          # s1 | s2
{'c', 'd', 'b', 'a'}
>>> s1.difference(s2)     # s1 - s2
{'a'}
>>> s1.add('hello')       # 增加一个元素
>>> s1
{'b', 'c', 'hello', 'a'}
>>> s1.update(s2)         # 批量增加元素
>>> s1
{'c', 'd', 'b', 'hello', 'a'}
>>> s1.issuperset(s2)     # s1是s2的超集吗？
True
>>> s2.issubset(s1)       # s2是s1的子集吗？
True

编写程序，完成以下要求：

有两个文件：a.log和b.log
两个文件中有大量重复内容
取出只有在b.log中存在的行

with open('/tmp/a.log') as f1:
    s1 = set(f1)
with open('/tmp/b.log') as f2:
    s2 = set(f2)
with open('/tmp/result.txt', 'w') as f3:
     f3.writelines(s2 - s1)