Linux —— Python（string,list,tuple,set,dict）的使用

String的练习

设计一个程序,帮助小学生练习10以内的加法:
- 随机生成加法题目
- 学生查看题目并输入答案
- 判别学生答题是否正确?
- 退出时,统计学生答题总数,正确数量及正确率(保留前两位)

import random
count = 0
right = 0
while True:
    a = random.randint(0,9)
    b = random.randint(0,9)
    print('%d+%d=' %(a,b))
    question = input('Please input your answer:(q for exit)')
    result = a + b
    if question == str(result):
        print('OK!')
        right += 1
        count += 1
    elif question == 'q':
        break
    else:
        print('Failed!')
        count += 1
percent = right / count
print('测试结束,共回答%d道题,正确个数为%d,正确率为%.2f%%' %(count,right,percent*100))

输入两个字符串,从第一个字符串中删除第二个字符串中所有的字符。例如: > 输入"They are students"和"aeiou" > 则删除之后的第一个字符串变为"Thy r stdnts" - 输入描述: 每个测试输入包含2个字符串 - 输出描述: 输出删除后的字符串

str = input('Please input str:')
delete = input('Please input del part:')
for i in str:
    for j in delete:
        if j == i:
            str1 = str.replace(j,'')
print(str1)

list

# list列表
s = ['lili',1.2,True]
print(s)
print(type(s))
# list嵌套
s1 = ['lili',1.2,True,[1,2,3,4]]
print(s1)
print(type(s1)

service = ['http','ssh','ftp']
# index
print(service[0])
print(service[-1])
# slide 切片
print(service[::-1]) # 反转
print(service[1:])
print(service[:-1])
# repeat 重复
print(service * 3)
# link 连接
service1 = ['mysql','firewalld']
print(service + service1)
# in/ not in
print('firewalld' in service)
print('firewalld' in service1)
print('firewalld' not in service1)
# for
for se in service:
    print(se)

service2 = [['http','80'],['ssh','22'],['ftp','21']]
# index
print(service2[0][1])
print(service2[-1][1])
# slide 切片
print(service2[:][1])

增加

service = ['http','ssh','ftp']
#1 添加
print(service + ['firewalld'])
#2 append追加
service.append('firewalld')
print(service)
#3 extend拉伸
service.extend(['mysql','firewalld'])
print(service)
#4 insert插入[在指定地方]
service.insert(1,'samba')
print(service)

删除

# service = ['http','ssh','ftp']
# #1 pop,默认弹出最后一个
# a = service.pop()
# b = service.pop(0)
# print(a)
# print(b)
# print(service)
#2 remove 移除选中
service1 = ['http','ssh','ftp']
a = service1.remove('ssh')
print(a)
print(service1)
#3 del 从内存中已经删除,已经不占用空间
# print(service1)
# del service1
# print(service1)

修改

service = ['http','ssh','ftp']
# 通过索引方式重新赋值
service[0] = 'mysql'
print(service)
# 通过切片方式
print(service[:2]) #除去索引为2的值
service[:2] = ['samba','nfs'] # 将索引值2前的替换掉
print(service)

查看

# look 查看
service = ['http','ssh','ftp','http']
# count
print(service.count('http')) # 查看http出现了几次
# 查看指定元素的索引值
print(service.index('ssh'))
print(service.index('http',0,9))

排序

# 按照ASCLL码排序
service = ['http','ssh','ftp','http']
service.sort()
print(service)
#
import random
li = list(range(10))
print(li)
random.shuffle(li) # 使用random.shuffle()打乱顺序
print(li)

练习 

示例1：

假定有下面这样的列表:
names = ['fentiao','fendai','fensi','apple']
输出结果为:'I have fentiao,fendai,fensi and apple.'

names = ['fentiao', 'fendai', 'fensi', 'apple']
print('I have ' + ','.join(names[:-1]) + ' and ' + names[-1])
# ','.join(names[:-1]):除最后一项外其余,中间通过,隔开
# name[-1]: 最后一位

示例2： 

1、系统里面有多个用户,用户的信息目前保存在列表里面
    users = ['root','westos']
    passwd = ['123','456']
2、用户登陆(判断用户登陆是否成功)
    1). 判断用户是否存在
    2). 如果存在
        1). 判断用户密码是否正确
        如果正确,登陆成功,退出循环
        如果密码不正确,重新登陆,总共有三次机会登陆
    3). 如果用户不存在
        重新登陆,总共有三次机会

users = ['root', 'westos']
passwd = ['123', '456']
count = 0
while count < 3:  # 三次机会
    inuser = input('Username:')
    inpasswd = input('Password:')
    count += 1
    if inuser in users: # 如果用户存在
        index = users.index(inuser) # 找到对应索引值
        password = passwd[index] # 通过用户名对应索引值来寻找对应的密码
        if inpasswd == password: # 如果输入的密码与该用户名对应的密码一致时
            print('%s login success!' %inuser)
            break
        else:
            print('%s login failed: password not correct!' %inuser)
    else: # 如果用户不存在
        print('User %s not exist!' %inuser)
else: # 超过三次机会,则没有机会
    print('no more chance!')

示例3：

输入两个字符串,从第一个字符串中删除第二个字符串中所有的字符。例如:
> 输入"They are students"和"aeiou"
> 则删除之后的第一个字符串变为"Thy r stdnts"
- 输入描述:
每个测试输入包含2个字符串
- 输出描述:
输出删除后的字符串 

str = input('Please input str:')
delete = input('Please input del part:')
for i in str:
    if i in delete:
        str = str.replace(i,'')
print(str)

示例4： 

1、后台管理员只有一个用户:admin,密码:admin
2、当管理员登陆成功后,可以管理前台会员信息
3、会员信息管理包括:
        添加会员信息
        删除会员信息
        查看会员信息
        退出

print('管理员登陆'.center(50,'*'))
inUser = input('Username:')
inPasswd = input('Password:')
user = ['root','westos']
passwd = ['123','456']
if inUser == 'admin' and inPasswd == 'admin':
    print('管理员登陆成功!')
    print('会员信息管理'.center(50,'*'))
    while True:
        print('''
          目录
       1. 添加会员信息 
       2. 删除会员信息 
       3. 查看会员信息 
       4. 退出
       ''')
        choice = input('Please input your choice:')
        if(choice == '1'):
            print('添加会员信息'.center(50,'*'))
            addUser = input('添加会员名:')
            if addUser in user:
                print('会员%s已存在!'%addUser)
            else:
                addPasswd = input('Password:')
                user.append(addUser)
                passwd.append(addPasswd)
                print('添加会员%s成功!'%addUser)
        elif(choice == '2'):
            print('删除会员信息'.center(50,'*'))
            delUser = input('删除会员名:')
            delIndex = user.index(delUser)
            user.remove(delUser)
            passwd.pop(delIndex)
            print('删除会员%s成功!'%delUser)
        elif(choice == '3'):
            print('查看会员信息'.center(50,'*'))
            print('\t会员名\tPassword')
            userCount = len(user)   # 通过len()函数测量user长度
            for i in range(userCount):
                print('\t%s\t%s' %(user[i],passwd[i]))
        elif(choice == '4'):
            print('退出'.center(50,'*'))
            exit()
        else:
            print('Please check your input!')
else:
    print('管理员登陆失败!')

python内置方法 

min(3,4)                # min()求最小值
max(3,4)                # max()求最大值
sum(range(1,101,2))     # sum()方法求和,range(start,stop,step)函数整数列表
enumerate('hello')      
# enumerate(sequence, [start=0])可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标

示例1： 

for i,v in enumerate('hello'):
    print(i,v)   # 
(索引值,对应的value值)

示例2：

s1 = 'abc'
s2 = '123'
for i in zip(s1,s2):
    print(i)
for i in zip(s1,s2):
    print(''.join(i))

tuple元组 

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

tup1 = ()    # 创建空元组
tup1 = (50,) # 元组中只包含一个元素时，需要在元素后面添加逗号

t = (1,2.3,True,'westos')
print(type(t))   # The type is tuple
t[0] = 2
print(t)

# 元组不支持赋值
# Traceback (most recent call last):
#   File "D:/Pycharm/Project/day03/03_tuple.py", line 3, in <module>
#     t[0] = 2
# TypeError: 'tuple' object does not support item assignment

元组查看 

 元组可以使用下标索引来访问元组中的值

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]

元组修改

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的。
# tup1[0] = 100

# 创建一个新的元组
tup3 = tup1 + tup2
print tup3

元素删除

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元素

tup = ('physics', 'chemistry', 1997, 2000)
print(tup)
del tup
print(tup)

基本用法

users = ('westos','root','redhat')
password = ('123','456','789')
# index切片
print(users[0])
print(users[-1])
print(users[1:])
print(users[::-1])
# repeat重复
print(password * 2)
# link 连接
print(users + ('linux','python'))
# in/not in
print('westos' in users)
print('westos' not in users)
# for
for user in users:
    print(users)
for index,user in enumerate(users):
    print(index,user)
for user,password in zip(users,password):
    print(user,':',password)

t = (1,1.2,True,'westos')
print(t.count('westos'))  # westos出现的数量
print(t.index(1))         # 寻找1所在的索引值

求平均成绩(去除最大值和最小值) 

scores = (100,89,75,78,65)
scorelist = list(scores)
scorelist.sort()
t = tuple(scorelist)
print(t)

minscore,*middlescore,maxscore = t
# *表示接收多个值
print(minscore)
print(middlescore)
print(maxscore)
print(minscore,*middlescore,maxscore)
# 求平均成绩
averageScore = sum(middlescore) / len(middlescore)
print(averageScore)

set集合

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等，不支持索引、切片、重复

s = {1,2,3,1,2,3,4,5}
print(s)
print(type(s))

s1 = {1}
print(s1)
print(type(s1))

s2 = {}
print(type(s2))

s3 = set([])
print(type(s3))

循环遍历

s = {1,2,3}
print(1 in s)
print(1 not in s)

# for i in s:
#     print(i,end='|')

for i,v in enumerate(s):
    print(i,v)

增添和删除

s = {6,7,8,9}   # 增加单个元素
s.add(1)
print(s)

s.update({5,3,2})  # 增加多个元素
print(s)

s.pop()
print(s)   # 随意弹出元素

s.remove(5) # 移除特定元素
print(s)

交集、差集、并集和对等差分

# 交集、并集、差集
s1 = {1,2,3}
s2 = {2,3,4}

# 并集:两个集合所有元素
print('并集:',s1.union(s2))
print('并集:',s1 | s2)
# 交集:两个集合相交的元素
print('交集:',s1.intersection(s2))
print('交集:',s1 & s2)
# 差集
print('差集:',s1.difference(s2)) # s1-(s1&s2)
print('差集:',s2.difference(s1)) # s2-(s1&s2)
# 对等差分:并集-差集
print('对等差分:',s1.symmetric_difference(s2))
print('对等差分:',s1^s2)

超集和子集 

s3 = {1,2}
s4 = {1,2,3}
print(s3.issuperset(s4))  # s3是不是s4的超集
print(s3.issubset(s4))    # s3是不是s4的子集

set练习 

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

import random
s = set([]) # 先注册一个set空集合
for i in range(int(input('Num:'))):
    s.add(random.randint(1,1001))
print(s)    # 去重后集合内容
print(sorted(s)) # 排序后

字典 

dict() 函数用于创建一个字典

dict()   # 传入空字典
dict(a='a', b='b', t='t') # 传入关键字
dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典

字典的简单使用

users = ['user1','user2']
passwds = ['123','456']
print(zip(users))
print(list(zip(users,passwds)))
print(dict(zip(users,passwds)))

s = {}
print(type(s))
# 字典是通过[key,value]形式,key只有一个,但value可有多个
s1 = {
    'linux':[100,99,88],
    'westos':[190,543,345]
}
print(s1)
print(type(s1))

d = dict()
print(d)
print(type(d))

student = {
    'westos':{
        'id':'03113009',
        'age':'18',
        'score':90,
    },
    'redhat':{
        'id':'03113010',
        'age':'20',
        'score':'100'
    }
}
print(student['westos']['id'])

print({}.fromkeys({'1','2'},000000))

d = {
    '1':'a',
    '2':'b'
}
# 不支持索引,切片会报错
# print(d[0])
print('1' in d)
print('1' not in d)
for key in d:
    print(key)
    print(key,d[key])

增改

services = {
    'http':80,
    'ftp':21,
    'ssh':22
}
# 不存在的增加(增加一个元素)
services['mysql'] = 3306
print(services)
# 已存在的修改
services['http'] = 443
print(services)
# 更新多个元素
services_backup = {
    'http':443,
    'tomcat':8080,
    'http':8080
}
services.update(services_backup)
print(services)

services.update(flask=9000,http=8000)
print(services)
# setdefault添加key值,如果key存在则不改变,若不存在，则添加
services.setdefault('http',9090)
print(services)
services.setdefault('oracle',44575)
print(services)

删除

services = {
    'http':80,
    'ftp':21,
    'ssh':22
}
# del services['http']
# print(services)

# item = services.pop('http')
# print(item)
# print(services)
# # 如果key不存在,直接报错
# # 如果key存在,删除key和value键值对，并且返回key对应的value值

# item = services.popitem()
# # 删除最后一个key/value值
# print('The last key-value is:',item)
# print(services)

# 全部删除,清空字典
services.clear()
print(services)

查找

services = {
    'http':80,
    'ftp':21,
    'ssh':22
}
# 显示所有的key
print(services.keys())
# 显示所有的value
print(services.values())
# 显示所有的item
print(services.items())
# 查找对应key的value值
print(services['http'])
# 如果key不存在,默认返回none
# 如果key不存在,但是有default值,就会返回该default值(可为value值,可为报错信息)
print(services.get('https'))
print(services.get('https',443))
# 遍历字典,注意只写services时,只访问它的key值，若key和value都访问,此时需要services.items
for k,v in services.items():
    print('key:',k,'value:',v)
for k in services:
    print('key:',k,'value:',services[k])

1. 随机生成100个卡号
    卡号以6102009开头,后面3位依次是(001,002,003...100),
2. 生成关于银行卡号的字典,默认每个卡号的初始密码位"redhat"
3. 输出卡号和密码信息,格式如下:
卡号                 密码
6102009001          000000

num = []
for i in range(100):
    num.append('6102009%.3d' %(i+1))
info = {}.fromkeys(num,'redhat')     # 创建一个新字典
print('卡号\t\t\t\t密码')
for k,v in info.items():
    print(k,'\t\t\t\t',v)

练习

示例1：

数字重复统计
1). 随机生成1000个整数
2). 数字的范围[20,100]
3). 升序输出所有不同的数字及其每个数字重复的次数

import random
nums = []
for item in range(1000):
    nums.append(random.randint(20,100))
print(nums)
sorted_nums = sorted(nums)
nums_dict = {}
for num in sorted_nums: # num为sorted_nums中的一个值
    if num in nums_dict: # 如果这个值在nums_dict字典中
        nums_dict[num] += 1
    else:
        nums_dict[num] = 1
print(nums_dict)

运行结果： 

{20: 10, 21: 12, 22: 11, 23: 15, 24: 13, 25: 9, 26: 13, 27: 13, 28: 13, 29: 11, 30: 9, 31: 11, 32: 14, 33: 15, 34: 19, 35: 10, 36: 17, 37: 12, 38: 16, 39: 11, 40: 10, 41: 13, 42: 12, 43: 9, 44: 9, 45: 10, 46: 13, 47: 10, 48: 11, 49: 8, 50: 13, 51: 17, 52: 17, 53: 19, 54: 14, 55: 15, 56: 14, 57: 8, 58: 9, 59: 10, 60: 7, 61: 15, 62: 15, 63: 16, 64: 9, 65: 20, 66: 7, 67: 8, 68: 11, 69: 10, 70: 12, 71: 6, 72: 12, 73: 16, 74: 9, 75: 11, 76: 15, 77: 14, 78: 13, 79: 11, 80: 9, 81: 18, 82: 12, 83: 16, 84: 14, 85: 11, 86: 13, 87: 14, 88: 12, 89: 16, 90: 13, 91: 17, 92: 11, 93: 8, 94: 13, 95: 16, 96: 7, 97: 13, 98: 12, 99: 14, 100: 9}

示例2： 

重复的单词:此处认为单词之间以空格为分隔符,并且不包含,和.
    # 1. 用户输入一句英文句子
    # 2. 打印出每个单词及重复的次数
    ”hello java hello python“
# hello  2
# java   1
# python 1

依次循环遍历列表
    如果列表元素不在字典的key中,将元素作为key 1作为value值
    如果列表元素在字典的key中,直接更新元素value值,在原有基础上加1

statement = input('Please enter a sentence in English:')
statements = statement.split(' ')		# 以空格为分隔符，按照空格分离字符串，形成列表
words = {}				                # 注册字典
for i in statements:			        # 遍历列表
    if i == ',' or i == '.':		    # 判断出现,和.时跳出此次循环
        continue
    count = statements.count(i)		    # 统计次数
    words[i] = count                    # key=单词，value=重复的次数，添加到字典中，字典中如果key值存在则更新value值，所以生成的字典中key不会重复。
print(words)				            # 打印字典

示例3：

栈的工作原理
    入栈 s.append()
    出栈 s.pop()
    栈顶元素 s[-1]
    栈的长度 len(s)
    栈是否为空 长度是否为0

stack = []
while True:
    print('''
        栈操作
    1.  入栈
    2.  出栈
    3.  栈顶元素
    4.  栈的长度
    5.  栈是否为空
    6.  退出
        ''')
    choice = input('请输入选择:')
    if choice == '1':
        inStack = input('入栈元素:')
        stack.append(inStack)
        print('元素%s入栈成功!' %inStack)
    elif choice == '2':
        # 判断是否空栈
        if not stack:
            print('栈为空')
        else:
            outStack = stack.pop()
            print('元素%s出栈成功!' %outStack)
    elif choice == '3':
        if len(stack) == 0:
            print('栈为空')
        else:
            print('栈顶元素为%s' %(stack[-1]))
    elif choice == '4':
        print('栈的长度为:%s' %(len(stack)))
    elif choice == '5':
        if len(stack) == 0:
            print('栈为空')
        else:
            print('栈不为空')
    elif choice == '6':
        print('退出')
        break
    else:
        print('请输入正确的选择')