1.list
列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可
li = [1,1.2,True,'hello']
print(li)
print(type(li))
1.1 访问列表中的值(索引)
使用下标索引来访问列表中的值
service = ['http','ssh','ftp']
print(service[0])
print(service[-1])
1.2 切片
print(service[::-1])
print(service[1:])
print(service[:-1])
1.3 重复
print(service * 3)
1.4 连接
service1 = ['mysql','firewalld']
print(service + service1)
1.5 检查成员
print('firewalld' in service)
print('firewalld' in service1)
print('firewalld' not in service1)
1.6 列表中嵌套列表
service2 = [['http','80'],['ssh','22'],['ftp','21']]
print(service2[0][1])
print(service2[-1][1])
print(service2[:][1])
print(service2[:-1][0])
示例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])
1.7 列表中常见的方法
1 list.append(obj):在列表末尾添加新的对象
service = ['http','ssh','ftp']
service.append('firewalld')
print(service)
2 list.extend(seq):在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
service.extend(['mysql','firewalld'])
print(service)
3 list.insert(index, obj):将对象插入列表
service.insert(1,'samba')
print(service)
4 list.pop([index=-1]):移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list1 = ['Google', 'Runoob', 'Taobao']
list_pop=list1.pop(1)
print "删除的项为 :", list_pop
print "列表现在为 : ", list1
5 list.remove(obj):移除列表中某个值的第一个匹配项,该方法没有返回值但是会移除列表中的某个值的第一个匹配项
service = ['http','ssh','ftp']
a = service.remove('ssh')
print(service)
print(a)
6 list.count(obj):统计某个元素在列表中出现的次数
service = ['http','ssh','ftp','http']
print(service.count('http'))
7 list.index(obj):从列表中找出某个值第一个匹配项的索引位置
print(service.index('ssh'))
print(service.index('http'))
8 list.sort(cmp=None, key=None, reverse=False):对原列表进行排序
sort() 函数用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数
cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key – 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则,reverse = True 降序, reverse = False 升序(默认)
service = ['http','ssh','ftp','http']
service.sort()
print(service)
names = ['alice','bob','harry','Borry']
names.sort(key=str.lower)
print(names)
names = ['alice','bob','harry','Borry']
names.sort(reverse=True)
print(names)
8 shuffle() :将序列的所有元素随机排序
import random
list = [20, 16, 10, 5];
random.shuffle(list)
print ("随机排序列表 : ", list)
1.8 del 函数:将列表从内存中清空
service = ['http','ssh','ftp']
print(service)
del service
print(service)
1.9 更新列表
service = ['http','ssh','ftp']
service[0] = 'mysql'
print(service)
service = ['http','ssh','ftp']
print(service[:2])
service[:2] = ['samba','nfs']
print(service)
示例:
"""
- 添加用户:
1). 判断用户是否存在?
2). 如果存在, 报错;
3). 如果不存在,添加用户名和密码分别到列表中;
- 删除用户
1). 判断用户名是否存在
2). 如果存在,删除;
3). 如果不存在, 报错;
- 用户登陆
- 用户查看
1) 通过索引遍历密码
- 退出
"""
"""
1.系统里面有多个用户,用户的信息目前保存在列表里面
users = ['root','westos']
passwd = ['123','456']
2.用户登陆(判断用户登陆是否成功
1).判断用户是否存在
2).如果存在
1).判断用户密码是否正确
如果正确,登陆成功,退出循环
如果密码不正确,重新登陆,总共有三次机会登陆
3).如果用户不存在
重新登陆,总共有三次机会
"""
users = ['root', 'westos']
passwds = ['123', '456']
trycount = 0
while trycount < 3:
inuser = input('Username:')
inpasswd = input('Password:')
trycount += 1
if inuser in users:
index = users.index(inuser)
passwd = passwds[index]
if inpasswd == passwd:
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!')
示例:
"""
# 1. 后台管理员只有一个用户: admin, 密码: admin
# 2. 当管理员登陆成功后, 可以管理前台会员信息.
# 3. 会员信息管理包含:
# 添加会员信息
# 删除会员信息
# 查看会员信息
# 退出
"""
print('管理员登陆'.center(50,'*'))
inuser = input('Username:')
inpasswd = input('Password:')
users = ['root', 'westos']
passwds = ['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':
pass
elif choice == '2':
pass
elif choice == '3':
pass
elif choice == '4':
exit()
else:
print('Please check your input!')
else:
print('管理员登陆失败!')
1.10 列表中常见函数
1 max(list):返回列表元素最大值
list1, list2 = ['123', 'xyz', 'zara', 'abc'], [456, 700, 200]
print "Max value element : ", max(list1);
print "Max value element : ", max(list2);
输出结果:
Max value element : zara
Max value element : 700
2 min(list):返回列表元素最小值
list1, list2 = [123, 'xyz', 'zara', 'abc'], [456, 700, 200]
print "min value element : ", min(list1);
print "min value element : ", min(list2);
输出结果:
min value element : 123
min value element : 200
3 sum() 方法对系列进行求和计算
>>>sum([0,1,2])
3
>>> sum((2, 3, 4), 1) # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2) # 列表计算总和后再加 2
12
4 zip():用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。我们可以使用 list() 转换来输出列表。如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反,*zipped 可理解为解压,返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]
5 enumerate():用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1)) # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
for i,v in enumerate('hello'):
print(i,v)
2.tuple
Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
创建空元组:
tup1 = ()
元组中只包含一个元素时,需要在元素后面添加逗号:
tup1 = (50,)
访问元组:
元组可以使用下标索引来访问元组中的值,如下实例:
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[0]: physics
tup2[1:5]: (2, 3, 4, 5)
修改元组:
元组中的元素值是不允许修改的,但是元组中可以包含列表,我们可以对列表进行修改
t1 = ([1,2,3],4)
t1[0].append(4)
print(t1)
2.1 索引
Users = ('root','westos','redhat')
Passwds = ('123','456','789')
#index slide
print(Users[0])
print(Users[-1])
print(Users[1:])
print(Users[::-1])
2.2 重复
Users = ('root','westos','redhat')
Passwds = ('123','456','789')
print(Passwds * 3)
2.3 连接
Users = ('root','westos','redhat')
print(Users + ('linux','python'))
2.4 in/not in
Users = ('root','westos','redhat')
Passwds = ('123','456','789')
print('westos' in Users)
print('westos' not in Users)
示例:
Users = ('root','westos','redhat')
Passwds = ('123','456','789')
for user in Users:
print(user)
for index, user in enumerate(Users):
print(index, user)
for user, passwd in zip(Users, Passwds):
print(user, ':', passwd)
示例:计算平均成绩
scores = (100,89,45,78,65)
scoreli = list(scores) #将元组转为列表
scoreli.sort() #对分数进行排序
t = tuple(scoreli) #转为元组
print(t)
minscore,*middlescore,maxscore = t #将元组中的元素分为三组
print(minscore) #最小值
print(middlescore) #中间值
print(maxscore) #最大值
print(sum(middlescore) / len(middlescore)) #平均值
~
3.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))
列表和集合的转换:集合最大的特点是元素不重复,可以用来将重复的元素去掉
li = [1,2,3,1,2,3]
print(set(li))
print(list(set(li)))
集合只支持成员操作,其他的索引切片连接重复均不支持
s = {1,2,3}
for i in s:
print(i,end='|')
3.1 在集合中添加元素
s = {6,7,8,9}
s.add(1)
print(s)
3.2 更新集合
s = {6,7,8,9}
s.update({5,3,2})
print(s)
3.3 集合中弹出元素,随机弹出
s = {6,7,8,9}
s.pop()
print(s)
3.4 集合中删除元素
s = {6,7,8,9}
s.remove(6)
print(s)
3.5 并集
s1 = {1,2,3}
s2 = {2,3,4}
print('并集:',s1.union(s2))
print('并集:',s1 | s2)
3.6 交集
s1 = {1,2,3}
s2 = {2,3,4}
print('交集:',s1.intersection(s2))
print('交集:',s1 & s2)
3.7 差集
s1 = {1,2,3}
s2 = {2,3,4}
print('差集:',s1.difference(s2)) # s1-(s1&s2)
print('差集:',s2.difference(s1)) # s2-(s1&s2)
3.8 Set issuperset(),Set issubset() 方法 以及Set isdisjoint() 方法
issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中,如果是则返回 True,否则返回 False
issubset() 方法用于判断集合的所有元素是否都包含在指定集合中,如果是则返回 True,否则返回 False
isdisjoint() 方法用于判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False
s3 = {1, 2}
s4 = {1, 2, 3}
print(s3.issuperset(s4))
print(s3.issubset(s4))
print(s3.isdisjoint(s4))
示例:
"""
明明想在学校中请一些同学一起做一项问卷调查,为了实验的客观性
他先用计算机生成了N个1~1000之间的随机整数(N<=1000),N是用户输入的,
对于
其中重复的数字,只保留一个,把其余相同的数字去掉,不同的数对应着不>同的学生的学>号,然后再把这些
数从小到大排序,按照排好的顺序去找同学做调查,请你协助明明完成“去重
”与排序工作
"""
import random
s = set([])
for i in range(int(input('N:'))):
s.add(random.randint(1,1000))
print(sorted(s))
4.dict
字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,格式如下所示:
d = {key1 : value1, key2 : value2 }
键必须是唯一的,但值则不必。
值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组
s = {
'linux':[100,99,88],
'westos':[190,543,345]
}
print(s)
print(type(s))
字典嵌套字典:
students = {
'westos':{
'id':'03113009',
'age':18,
'score':90
},
'redhat':{
'id':'03113010',
'age':20,
'score':100
}
}
print(students['westos']['id'])
4.1 Python字典包含的内置方法
1 radiansdict.fromkeys():创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
print({}.fromkeys({'1','2'},'000000'))
2 radiansdict.update(dict2):把字典dict2的键/值对更新到dict里
services = {
'http':80,
'ftp':21,
'ssh':22
}
services_backup = {
'https':443,
'tomcat':8080,
'http':8080
}
services.update(services_backup)
print(services)
3 radiansdict.setdefault(key, default=None):和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
services = {
'http':80,
'ftp':21,
'ssh':22
}
print(services.setdefault('http',9090))
print(services)
services.setdefault('oracle',44575)
print(services)
4 radiansdict.keys():返回一个迭代器,可以使用 list() 来转换为列表
services = {
'http':80,
'ftp':21,
'ssh':22
}
print(services.keys())
5 radiansdict.values():返回一个迭代器,可以使用 list() 来转换为列表
services = {
'http':80,
'ftp':21,
'ssh':22
}
print(services.values())
6 radiansdict.items():以列表返回可遍历的(键, 值) 元组数组
services = {
'http':80,
'ftp':21,
'ssh':22
}
print(services.items())
7 radiansdict.get(key, default=None):返回指定键的值,如果值不在字典中返回default值
services = {
'http':80,
'ftp':21,
'ssh':22
}
print(services.get('https','key not exist'))
print(services.get('https'))
4.2 修改字典
向字典中添加新的值
services = {
'http':80,
'ftp':21,
'ssh':22
}
services['mysql'] = 3306
print(services)
修改字典中存在的键对应的值
services = {
'http':80,
'ftp':21,
'ssh':22
}
services['http'] = 443
print(services)
4.3 del函数:删除字典中指定的键
services = {
'http':80,
'ftp':21,
'ssh':22
}
del services['http']
print(services)
弹出字典中指定的键并返回该键的值
services = {
'http':80,
'ftp':21,
'ssh':22
}
item = services.pop('http')
print(item)
print(services)
弹出字典中最后一个键并返回该键的值
services = {
'http':80,
'ftp':21,
'ssh':22
}
item = services.popitem()
print('The last key-value is:',item)
print(services)
清空字典中的所有内容:
services.clear()
print(services)
示例:
"""
# 数字重复统计:
1). 随机生成1000个整数;
2). 数字的范围[20, 100],
3). 升序输出所有不同的数字及其每个数字重复的次数;
"""
import random
all_nums = []
for item in range(1000):
all_nums.append(random.randint(20,100))
# print(all_nums)
sorted_nums = sorted(all_nums)
num_dict = {}
for num in sorted_nums:
if num in num_dict:
num_dict[num] += 1
else:
num_dict[num] = 1
print(num_dict)
示例:
"""
重复的单词: 此处认为单词之间以空格为分隔符, 并且不包含,和.;
# 1. 用户输入一句英文句子;
# 2. 打印出每个单词及其重复的次数;
"hello java hello python"
# hello 2
# java 1
# python 1
"""
input_words = input("Please input a sentences:")
words = input_words.split()
print(words)
num_dict = {}
for word in words:
if word in num_dict:
num_dict[word] += 1
else:
num_dict[word] = 1
print(num_dict)
示例
"""
# 1. 随机生成100个卡号;
# 卡号以6102009开头, 后面3位依次是 (001, 002, 003, 100),
# 2. 生成关于银行卡号的字典, 默认每个卡号的初始密码为"redhat";
# 3. 输出卡号和密码信息, 格式如下:
卡号 密码
6102009001 000000
"""
import random
account_num = []
for i in range(100):
account_num.append('6102009%.3d' %(i+1))
account_info = {}.fromkeys(account_num,'redhat')
print('卡号\t\t\t\t 密码')
for k,v in account_info.items():
print(k,'\t\t',v)