python的基础知识3

##1.python中的列表创建##
数组：存储同一种数据类型的集合 scores = [12,23.5,423]
列表(打了激素的数组)：可以存储任意数据类型的集合
“”"
li = [1,1.2,True,‘hello’]
print(li,type(li))

#列表里面也是可以嵌套列表的
li1 = [1,1.4,True,‘hello’,[1,2,3,4,5]]
print(li1,type(li1))

##2.列表的特性##
service = [‘http’, ‘ssh’, ‘ftp’]

索引

正向索引

print(service[0])

反向索引

print(service[-1])

切片

print(service[::-1]) # 列表的反转
print(service[1:]) # 除了第一个之外的其他元素
print(service[:-1]) # 除了最后一个之外的其他元素

重复

print(service * 3)

连接

service1 = [‘mysql’, ‘firewalld’]
print(service + service1)

成员操作符

print(‘firewalld’ in service)
print(‘ftp’ in service)
print(‘firewalld’ not in service)

for 循环遍历

print(‘服务显示’.center(50,’*’))
for service in service:
# print不换行输出
print(service,end=’ ')

“”"
python2：不换行输出
print ‘hello’,
“”"

列表里面嵌套列表
service2 = [[‘http’,80],[‘ssh’,22],[‘ftp’,21]]

索引
print(service2[0][0])
print(service2[-1][1])

切片
print(service2[:][1])
print(service2[:-1][0])
print(service2[0][:-1])

##3.列表元素的增加##
services = [‘http’,‘ssh’,‘ftp’]

append()：追加 append是追加一个元素到列表中
services.append(‘firewalld’)
print(services)

extend():拉伸 追加多个元素到列表中
services.extend([‘mysql’,‘nfs’])
print(services)

insert():在指定索引位置插入数据
services.insert(1,‘https’)
print(services)

##4.列表元素的删除##

In [1]: servers = [‘ftp’,‘ssh’,‘http’,‘ftp’]

In [2]: servers.pop()
Out[2]: ‘ftp’

In [3]: servers
Out[3]: [‘ftp’, ‘ssh’, ‘http’]

In [4]: a = servers.pop()

In [5]: a
Out[5]: ‘http’

In [6]: servers
Out[6]: [‘ftp’, ‘ssh’]

In [7]: servers.pop(0)
Out[7]: ‘ftp’

In [8]: servers
Out[8]: [‘ssh’]

In [9]: servers.pop()
Out[9]: ‘ssh’

In [10]: servers
Out[10]: []

n [11]: servers.pop()

IndexError Traceback (most recent call last)
in
----> 1 servers.pop()

IndexError: pop from empty list
“”"
remove：删除列表元素
servers = [‘ftp’,‘ssh’,‘http’,‘ftp’]
a = servers.remove(‘ftp’)
print(servers)
print(a)

从内存中删除
del servers[1]
print(servers)

##5.列表元素的修改##
通过索引，重新赋值
servers = [‘ftp’,‘ssh’,‘http’,‘ftp’]
servers[0] = ‘mysql’
print(servers)

通过切片
servers[:2] = [‘mysql’,‘firewalld’]
print(servers)

##6.列表的查看##
servers = [‘ftp’,‘ssh’,‘http’,‘ftp’]

查看出现的次数

print(servers.count(‘ftp’))

查看指定元素的索引值(可以指点索引范围查看)

print(servers.index(‘ssh’))
print(servers.index(‘ftp’,4,8))

此时的1到8不包括0，所以之出现了三次。

##7.列表的排序##
import random
排序查看 按照Ascii码进行排序的
services = [‘ftp’, ‘ssh’, ‘http’, ‘ftp’]
services.sort()
print(services)

对字符串排序不区分大小写
“”"
In [15]: phones = [‘alice’,‘bob’,‘harry’,‘Borry’]

In [16]: phones.sort()

In [17]: phones
Out[17]: [‘Borry’, ‘alice’, ‘bob’, ‘harry’]

In [18]: phones.sort(key=str.lower)

In [19]: phones
Out[19]: [‘alice’, ‘bob’, ‘Borry’, ‘harry’]

In [20]: phones.sort(key=str.upper)

In [21]: phones
Out[21]: [‘alice’, ‘bob’, ‘Borry’, ‘harry’]

In [22]: phones.sort(key=str.upper)

In [23]: phones
Out[23]: [‘alice’, ‘bob’, ‘Borry’, ‘harry’]

“”"

li = list(range(10))
print(li)

讲原有的列表顺序打乱
random.shuffle(li)
print(li)

##8.元组##
元组相当于一个被限制了的列表
t = (1,1.2,True,‘westos’)
print(t.count(‘westos’))
print(t.index(1))

##9.用户管理系统##

• 添加用户:
  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(‘用户名:’)
inpasswd = input(‘密码：’)
# 尝试次数加1
trycount += 1
if inuser in users:
index = users.index(inuser) # 先找出用户对应的索引值
passwd = passwds[index]
if inpasswd == passwd:
print(’%s登陆成功’ %(inuser))
break
else:
print(’%s登陆失败：密码错误’ %(inuser))
else:
print(‘用户%s不存在’ %(inuser))

else:
print(‘已经超过三次机会了～’)

##10.元组的应用##

变量交换数值

a = 1
b = 2
b,a = a,b
“”"
1.先把(a,b)封装成一个元组(1,2)
2.b,a=a,b ====>b,a=(1,2)
b=(1,2)[0] a=(1,2)[1]
“”"
print(b)
print(a)

打印变量的值

name = ‘westos’
age = 11
t = (name,age)
print(‘name: %s,age:%d’ %(name,age))
print(‘name:%s,age:%d’ %t)

元组的赋值，有多少个元素，就用多少个变量接收

t = (‘westos’,11,100)
name,age,score = t
print(name,age,score)

scores = (100,89,45,78,65)
scoreLi = list(scores)
scoreLi.sort()
print(scoreLi)
scores = sorted(scores)
print(scores)
python3
minscore,*middlescore,maxscore = scores
print(minscore)
print(middlescore)
print(maxscore)
print(‘最终成绩为： %.2f’ %(sum(middlescore)/len(middlescore)))

##11.后台管理用管理用户信息##

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('请选择你的操作:')
    if choice == '1':
        print('添加会员信息'.center(50,'*'))
        addUser = input('添加会员名：')
        if addUser in users:
            print('用户%s已经存在' %(addUser))
        else:
            addPasswd = input('密码:')
            users.append(addUser)
            passwds.append(addPasswd)
            print('添加用户%s成功' %(addUser))
    elif choice == '2':
        print('删除会员信息'.center(50,'*'))
        delUser = input('删除会员名:')
        delIndex = users.index(delUser)
        users.remove(delUser)
        passwds.pop(delIndex)
        print('删除会员%s成功' %(delUser))

    elif choice == '3':
        print('查看会员信息'.center(50,'*'))
        print('\t用户名\t密码')
        userCount = len(users)
        for i in range(userCount):
            print('\t%s\t%s' %(users[i],passwds[i]))
    elif choice == '4':
        exit()

    else:
        print('请输入正确的选择')

else:
print(‘管理员登陆失败！’)

##12.通过列表实现栈的工作原理##
“”"
栈是一种数据结构，其特点为存储的数据先入后出，区别于队列的先入先出。
栈的工作原理
入栈
出栈
栈顶元素
栈的长度
栈是否为空

“”"
stack = []

info = “”"
栈操作
1.入栈
2.出栈
3.栈顶元素
4.栈的长度
5.栈是否为空
“”"
while True:
print(info)
choice = input(‘请输入选择：’)
if choice == ‘1’:
item = input(‘入栈元素：’)
stack.append(item)
print(‘元素%s入栈成功’ %(item))

elif choice == '2':
    # 先判断栈是否为空
    if not stack:
        print('栈为空，不能出栈')
    else:
        item = stack.pop()
        print('%s元素出栈成功' %(item))
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 == 'q':
    print('退出')
    break
else:
    print('请输入正确的选择')

##13.python中常用的内置方法##
In [1]: min(3,4)
Out[1]: 3

In [2]: min(2,3)
Out[2]: 2

In [3]: max(2,3)
Out[3]: 3

In [4]: max(4,3)
Out[4]: 4

In [5]: sum(range(1,101))
Out[5]: 5050

In [6]: sum(range(2,101,2))
Out[6]: 2550

In [7]: sum(range(1,101,2))
Out[7]: 2500

“”"
枚举：返回索引值和对应的value值
for i,v in enumerate(‘hello’):
print(i,v)
print(str(i) + ‘----->’ + v)

zip
s1 = ‘abc’
s2 = ‘123’
for i in zip(s1,s2):
print(i)

for i in zip(s1,s2):
print(’’.join(i))

for i in zip(s1,s2):
print(’-’.join(i))

##14.元组的创建##
“”"
元组：带了紧箍咒的列表
元组是一个不可变数据类型，没有增删改查
可以存储任意的和数据类型
“”"
定义一个元组
t = (1,1.2,True,‘westos’)
print(t,type(t))

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

元组如果只有一个元素，后面一定要加逗号，否则数据类型不确定
t2 = (1,)
t3 = (‘hello’,)
print(type(t2))
print(type(t3))
t4 =()
print(type(t4))

##15.元组的特性##
allowUsers = (‘root’,‘westos’,‘redhat’)
allowPasswd = (‘123’,‘456’,‘789’)

索引 切片
print(allowUsers[0])
print(allowUsers[-1])
print(allowUsers[1:])
print(allowUsers[2:])
print(allowUsers[:-1])
print(allowUsers[::-1])

重复
print(allowUsers * 3)

连接
print(allowUsers + (‘linux’,‘python’))

成员操作符
print(‘westos’ in allowUsers)
print(‘westos’ not in allowUsers)

for循环
for user in allowUsers:
print(user)

for index,user in enumerate(allowUsers):
print(‘第%d个白名单用户: %s’ %(index+1,user))

zip:两个元组的元素之间一一对应
for user,passwd in zip(allowUsers,allowPasswd):
print(user,’:’,passwd)

##16.集合##
集合里面的元素不可重复
s = {1,2,3,3,4,4,5,6}
print(s,type(s))

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

如何定义一个空集合
s2 = set([])
print(type(s2))

列表去重
li = [1,2,2,2,3,4,4,5]
print(list(set(li)))

##集合的特性##
“”"
集合支持的特性只有：成员操作符，索引 切片 重复 连接 均不支持
“”"
s = {1,2,3}
print(1 in s)
print(1 not in s)

for 循环
for i in s:
print(i,end=’|’)

for i,v in enumerate(s):
print(‘index:%s,value:%s’ %(i,v)）

##17.集合的常用方法##
集合：
无序数据类型
添加顺序和在集合中存储的顺序是不同的

“”"
s = {6,7,8,9}

增加一个元素

s.add(1)
print(s)

增加多个元素

s.update({5,3,2})
print(s)

删除

s.pop()
print(s)

删除指定元素

s.remove(2)
print(s)

pop是指拿出，还可以加回去，remove是从内存中删除

交集，并集，差集
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}
s3是否为s4的超集
print(s3.issuperset(s4))
s3是否为s4的子集
print(s3.issubset(s4))
两个集合是不是 不相交
print(s3.isdisjoint(s4))

##列表练习题1##
用户输入月份，输出月份的季节
例如输入三月，输出春季
month = int(input(‘Month:’))
if month in [3,4,5]:
print(‘春季’)
elif month in [6,7,8]:
print(‘夏季’)
elif month in [9,10,11]:
print(‘秋季’)
elif month in [1,2,12]:
print(‘冬季’)
else:
print(‘输入不合法’)

##列表练习题2##

假定有下面这样的列表:
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])

华为机测题:
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性
他先用计算机生成了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))