python--02

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)