Python之列表、元组、集合与字典

一、python列表

1、列表的创建

1、列表:可以存储任意数据类型的集合
2、列表里：可以存储不同的数据类型
li = [1,1.2,True,'hello']
print li
print type(li)

3、列表里面也可以嵌套列表(列表：也是一种数据类型)
li = [1,1.2,True,'hello',[1,2,3,4,5]]
print li
print type(li)

2、列表的特性

# 索引
print service[0]
print service[-1]

# 切片
print service[::-1] # 倒序
print service[1:] # 除了第一个不显示
print service[2:] # 除了前两个不显示
print service[:-1] # 除了最后一个不显示
print service[:3] # 显示前三个

# 重复
print service * 3

# 连接
service1 = ['mysql','firewalld']
print service + service1

# 成员操作符
print 'firewalld' in service
print 'firewalld' in service1
print 'firewalld' not in service

#for循环
print 'PYTHON'.center(50,'*')
for se in service:
    print se

#列表里嵌套列表----------
service2 = [['http',80],['ssh',22],['ftp',21]]

#索引----------
print service2[0][1]
print service2[-1][1]

#切片----------
print service2[:][1]      
print service2[:-1][0]
print service2[0][:-1]

列表练习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]

3、列表的操作

--------1.列表的增加--------------------------------

service = ['fttp','ssh','ftp']

1，print service + ['firewalld']

2,service.append('firewalld')   #append 追加一个元素到列表中

3，service.extend(['mysql','firewalld'])  ##extend 拉伸 追加多个

4，service.insert(1,'samba')      ##insert:在指定索引位置插入元素




----------2.列表的删除-----------------------------

1，如果pop()不传递值时，默认弹出最后一个元素
print service.pop()
print service.pop(0)   ##弹出第一个元素

2，remove:删除指定元素
service.remove('ssh')

3，del: 关键字 从内存中删除列表
print service    ##显示
del service
print service    ##报错

--------3.列表的修改-----------------------

1，通过索引重新赋值
service[0]='mysql'

2，通过切片重新赋值
service[:2]=['samba','firewalld']   ##把前两个换掉


--------4.列表的查看-----------------------

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

1,查看列表中元素出现的次数
print service.count('ssh')

2,查看指定元素的索引值
print service.index('ssh')



--------5.列表的排序------------------------

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

1，按照ASCII码进行排序
service.sort()
print service

2，service.sort(reverse=True)   ##降序
print service

3，phones = ['bob', 'harry', 'Lily', 'Alice']
# phones.sort()
# phones.sort(key=str.lower)  ##对字符列表不区分大小写
phones.sort(key=str.upper)
print phones

列表练习2：

import random
li = list(range(10))
print li
# 将原有的列表顺序打乱
random.shuffle(li)
print li

列表练习3：
用户管理系统

users = ['root', 'westos']
passwds = ['123', '456']

for i in range(3):
            user = raw_input('请输入用户名:')
            passwd = raw_input('请输入密码:')
            if user in users:
                j=user.index(user)
                if passwd == passwds[j]:
                    print '登陆成功'
                    break
                else:
                        print '登陆失败'
                        print '请重新登陆，您还有%d次机会'%(2-i)
            else:
                print '用户不存在,请重新登陆'
else:
    print '三次机会已经用完'

列表练习4：后台管理前台用户信息

print '管理员登陆'.center(50, '*')

inuser = raw_input('用户名:')
inpasswd = raw_input('密码:')

users = ['root', 'westos']
passwds = ['123', '345']

if inuser == 'admin' and inpasswd == 'admin':
    print '管理员登陆成功'
    print '用户信息管理'.center(50, '*')
    while True:
        print  """
        1 -添加用户信息
        2 -删除用户信息
        3 -查看用户信息
        4 -退出

        """
        choich = raw_input('请选择你的操作:')

        if choich == '1':
            print '添加用户信息'.center(50, '*')
            addUser = raw_input('添加用户:')
            if addUser in users:
                print '用户%s已经存在' % addUser
            else:
                addPasswd = raw_input('密码:')
                # 把用户名和密码添加到列表中
                users.append(addUser)
                passwds.append(addPasswd)
                print '添加用户%s 成功' % addUser

        elif choich == '2':
            print '删除用户信息'.center(50, '*')
            deluser = raw_input('请选择需要删除的用户:')
            if deluser in users:
                j = users.index(deluser)
                delpasswd = passwds[j]
                users.remove(deluser)
                passwds.remove(delpasswd)
                print '%s用户删除成功' % deluser
            else:
                print '用户不存在'


        elif choich == '3':
            print '查看用户信息'.center(50,'*')
            userCount = len(users)  # 2
            print '\t用户名\t密码'
            for i in range(userCount):  # 0 ,1
                print '\t%s\t%s' %(users[i],passwds[i])

            catuser = raw_input('请输入想要查看的用户:')
            if catuser in users:
                j = users.index(catuser)
                catpasswd = passwds[j]
                print '用户名：%s   密码: %s' % (catuser, catpasswd)
            else:
                print '没有此用户信息'

        elif choich == '4':
            exit()

        else:
            print '请输入正确的选择'
else:
    print '管理员登陆失败！'

二、python元组

1、元组的创建

1、元组（tuple）：带了紧箍咒的列表
元组本身不可变数据类型，没有增删改查
元组内可以存储任意数据类型
t = (1, 2, 3, 4.0, 'star')
print t, type(t)
(1, 2, 3, 4.0, 'star') <type 'tuple'>

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

([1, 2, 3, 4], 4)

3、元组如果只有一个元素的时候，后面一定要加逗号，否则数据类型不确定
t2 = ('hello',)
t3 = (1,)
print type(t2),type(t3)

2、元组的特性

allowUsers = ('z', 'x', 'y')
--------索引----------
print allowUsers[0]
print allowUsers[-1]

--------切片----------
print allowUsers[1:]   #除了第一个，其他输出
print allowUsers[2:]      #除了第二个，其他输出
print allowUsers[:-1]   #除了最后一个，其他输出
print allowUsers[:3]    #输出前三个
print allowUsers[::-1]

---------重复----------
print allowUsers * 3

---------连接----------
print allowUsers + ('a', 'b')

----------成员连接符----------
print 'westos' in allowUsers
print 'westos' not in allowUsers

3、元组的应用场景

---------1.交换变量值---------------
a = 1
b = 2
b,a = a,b
#先把(a,b)封装成一个元组(1,2)
#b,a = a,b
#b=(1,2)[0]  a=(1,2)[1]
print a,b


---------2.打印变量值---------------
name = 'westos'
age = 10
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

----------4.元组的排序----------------
scoresLi = list(scores)   ##转化为list之后排序
scoresLi.sort()
print scoresLi

scores = sorted(scores)   ##python自带的排序
print scores

三、python集合

1、集合的定义

# 集合里面的元素是不可重复的
s = {1,2,3,1,2,3,4,5}
print s,type(s)
s1 = {1}
print s1,type(s1)
# 如何定义一个空集合
s2 = {}
print type(s2)  ----{} <type 'dict'>
s3 = set([])
print s3,type(s3)  ----set([]) <type 'set'>

# 集合的应用(列表去重)
li = [1,2,3,1,2,3]
print list(set(li))

2、集合的特性

不支持索引 切片 重复 连接
只支持成员操作符 和 for循环  

s={1,2,3}
print 1 in s     #成员操作符
True

for i in s:      #for循环
    print i,

for i,v in enumerate(s):   #枚举可以列出索引值i
    print 'index: %s,value:%s' %(i,v)

-----------Python中常用的内置方法-----------------
# 枚举：返回索引值和对应的value值

for i,v in enumerate('hello'):
    print i
    print type(i)
    print v
    print type(v)
    print str(i) + '---->' + v
    print i, v

s1 = 'abc'
s2 = '123'

for i in zip(s1,s2):
    #print i
('a', '1')
('b', '2')
('c', '3')
    print '-'.join(i)
a-1
b-2
c-3

3、集合的方法

s = {6,7,8,1,2,3}
#增加
s.add(10)
s.add(9)
print s   #并排序

#增加多个元素
s.update({4,5})
print s   #并排序

#删除
print s
s.pop()   ##删除1
print s

#删除指定元素
s.remove(3)
print s


#交集 并集 差集

s1 = {1,2,3}
s2 = {2,3,6}
#交集
print '交集：',s1.intersection(s2)
print '交集：',s1&s2

#并集
print '并集：',s1.union(s2)
print '并集：',s1 | s2

#差集
#可以理解为s1中有哪些s2中没有的元素
print '差集：',s1.difference(s2)    #s1-(s1&s2)
print '差集：',s1 - s2
#可以理解为s2中有哪些s1中没有的元素
print '差集：',s2.difference(s1)    #s2-(s2&s1)
print '差集：',s2 - s1

s3 = {1,2}
s4 = {1,2,3}
#s3是否为s4的子集
print s3.issubset(s4)

#s3是否为s4的超集
print s3.issuperset(s4)


##两个集合是不是相交
print s3.isdisjoint(s4)

集合练习1：

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

import random
# 先 生成n个随机数
# 优先选择集合
s = set([])
for i in range(int(raw_input('N:'))):
    # num = random.randint(1,1000)
    # s.add(num)
    s.add(random.randint(1,1000))
print s
print sorted(s)

N:4
set([644, 493, 22, 477])
[22, 477, 493, 644]

四、python字典

1、字典的定义

字典是一个无序的数据集合，
使用print输出字典的时候
通常输出的顺序和定义的顺序是不一致的

定义方式一：

message = {
    'name':'tom',
    'age':18,
    'height':1.80,
    'weight':75.5
}               
#注意冒号和逗号
print message

定义方式二：
s = {}
print type(s)
s = {
    'fentiao':[100,90,80],
    'westos':[199,199,199]
}
print s

定义方式三
d = dict()
print d,type(d)

d = dict(a=1,b=2)
print d,type(d)

2、字典的特性

d = dict(a=1,b=2)
print d

# 成员操作符(默认判断key值是否存在)
print 'a' in d
print 1 in d

# for循环(默认循环遍历字典的key值)
for i in d:
    print i

3、字典的操作

---------1、字典的增加或更改----------
添加或者更改key的值
d = dict(a=1,b=2,c=3,d=4)
d['g'] = 10  #添加
print d
d['a'] = 10  #更改
print d
{'a': 10, 'c': 3, 'b': 2, 'd': 4, 'g': 10}

"""
update:
    如果key值存在，更新value值
    如果key值不存在，添加key-value值
"""
d.update({'a':4,'f':1})
print d
{'a': 0, 'c': 3, 'b': 2, 'd': 4, 'f': 7}

"""
setdefault
    如果key值已经存在，不做修改
    如果key值不存在，添加key-value值
"""
d.setdefault('a',10)
print d
{'a': 1, 'c': 3, 'b': 2, 'd': 4}

----------2、字典的删除------------

d = dict(a=1,b=2,c=3)
d.pop('a')   ##弹出指定key的value值
d.popitem()  ##删除第一个
del d['a']   ##直接删除
print d


----------3、字典的修改和查看------------
service = {
    'http': 80,
    'mysql': 3306
}

# 查看字典里面的所有key值
print service.keys()

# 查看字典里面的所有value值
print service.values()

# 查看字典里面的所有key-value值
print service.items()

-------4、字典的遍历------

service = {
    'http': 80,
    'mysql': 3306
}

for k,v in service.items():
    print k,'----->',v

for k in service:
    print k,'----->',service[k]

#用get简化
print service['https']
if 'https' in service:
   print service['https']
else:
   print 'key not exist'

"""
get 方法获取指定key对应的value值
    如果key值存在，返回对应的value值
    如果key值不存在，默认返回None，如果需要指定返回值，传值即可
"""
print service.get('http','key not exist')

字典练习1:

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

s = raw_input('s:')
# 1.把每个单词分割处理
s_li = s.split()
print s_li

# 2.通过字典存储单词和该单词出现的次数
words_dict = {}

# 3.
"""
依次循环遍历列表
    如果列表元素不在字典的key中，将元素作为key 1作为valus值
    如果列表元素在字典的key中，直接更新元素value值，在原有的基础上加1
"""
for item in s_li:
    if item not in words_dict:
        words_dict[item] = 1
    else:
        words_dict[item] += 1

# 4.打印生成的字典
print words_dict

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

import random
# 1.随机生成1000个整数
all_nums = []
for item in range(1000):
    # 2.数字的范围
    all_nums.append(random.randint(20, 100))

# 3.升序输出所有不同的数字及其每个数字重复的次数
sorted_num = sorted(all_nums)

nums_dict = {}
for num in sorted_num:
    if num in nums_dict:
        nums_dict[num] += 1
    else:
        nums_dict[num] = 1

print nums_dict