上面说了字符串和整形，那现在要是想存一个班级的人的名字，这个班有200个人，怎么存呢，用字符串的话，那就是names = 'marry lily king .....'这样，但是这样存是可以存，那要是想取到某个人的名字怎么取呢，不能再去里面看一遍吧，那累死人了，为了解决这个问题，又有一种新的数据类型应运而生，那就是列表，这也是我们在以后的开发过程中，最常用的数据类型之一，列表也叫数组，列表定义，使用[]
#list的是一种新的数据类型，也可以叫数组：
stus=['谢谢','谢1','谢2','谢3','谢4',19.3,89]
#里面的每个元素可以叫下标、索引、角标
print(stus[6])
#定义一个空的数组：stus=[]或者stus = list()
# 关于List的增、删、改、查
# list 的增
stus=['谢谢','谢1','谢2','谢3','谢4']
stus.append('谢5')#append在list的末尾增加一个元素
stus.append('谢6')
stus.insert(0,'谢0')#insert在list的指定位置增加元素
stus.insert(2,'谢哈')
stus.insert(20,'谢20')#insert时，如果指定位置不存在时，直接在最后增加这个元素
print(len(stus))#看list里面元素的个数有几个
print(stus)
# list的改，改只有下面一种方式
stus=['谢谢','谢1','谢2','谢3','谢4']
stus[0] = 'xiexie'
print('改完之后的：',stus)
#下标写负数时，是指从后面元素开始找,下标-1代表最后一个元素
print(stus[-1])
#list的删除
stus=['谢谢','谢1','谢2','谢3','谢4']
# 方法一：
stus.pop()#用pop时，默认删除最后一个元素，同时也可以传一个下标来删除
stus.pop(-1)
# 方法二：
stus.remove('谢谢')#只能删除指定的元素，不能不传
#用pop传一个不存在的下标、用remove传一个不存在的元素：
stus.pop(-10)#会报错：IndexError: pop index out of range（下标越界，下标不存在）
stus.remove('哈哈')#会报错：ValueError: list.remove(x): x not in list（元素不存在列表中）
del stus[-1] #删除指定的元素
stus.clear()#清空列表
print(stus)
#list的查询
stus=['谢谢','谢1','谢2','谢3','谢4']
stus.insert(-1,'谢谢')
stus.remove('谢3')
print(stus)
#根据下标来取值
print(stus[-1])
# 查询方法
stus.count('谢谢')#查询某个元素在list里面出现的次数
#删除一个不存在的元素：返回0
stus.count('谢3')
print(stus.count('谢3'))
#找某个元素的下标index
stus.index('谢1')
print(stus.index('谢1'))
#如果list里面有多个元素，返回的是第几个的下标：返回第一个元素的下标
stus.index('谢谢')
print(stus.index('谢谢'))
#如果元素不存在时，返回的是什么：报错：ValueError: '谢10' is not in list（该元素不在这个列表里面）
stus.index('谢10')
print(stus.index('谢10'))
列表操作，一些内置的方法
stus.reverse()#反转
nums = [1,5,3,4]
nums.sort()#排序 中文无法排序，英文和数字可以(默认升序)
nums.sort(reverse=True)#如果想要降序排列sort里面加reverse=True,升序False
print(nums)
# stus.extend()#把一个元素里面的List加到另外一个元素里面
stus.extend(nums)#把nums里面的元素加到stus里面
print(stus)
#布尔类型
#True Flase 我们在写判断的时候所有的表达式都会转换成布尔类型
#
stus=['谢谢','谢1','谢2','谢3','谢4']
print(stus)
#用count判断：
if stus.count('哈哈')>0:
print('存在')
else:
print('不存在')
#用in判断
if '谢谢' in stus:
print('存在')
else:
print('不存在')
list循环
stus = ['杨静', '王志华', '王银梅', '乔美玲',
'段鑫琪', '王立文', '赵燕',
'杨华', '周永波', '杨静']
# for s in stus:
# print('用户名是:%s'%s)
# for a in range(len(stus)):#rang下标
# print(stus[a])
# count = 0
# while count<len(stus):
# print(stus[count])
# count+=1
#导致第三方模块就值转成拼音：下载第三方模块安装xpinyin
# p = xpinyin.Pinyin()
# for s in stus:
# stu_pinyin =p.get_pinyin(s,'')
# print(stu_pinyin)
#同时取下标和值的方法：enumerate同时取下标和值的函数
#方法一：
# for i in range(len(stus)):#同时取到下标和值
# print('下标是：%s ,值是:%s'%(i,stus[i]))
#方法二：用enumerate函数：
for index,stu in enumerate(stus):
print('%s ===> %s'%(index,stu))
enumerate的一般用途：
choice = ['注册','登录','退出','购物']
s ='输入编号进入对应的操作:'
print(s)
for index,a in enumerate(choice):
print('%s ===>%s'%(index,a))
多维数组
表里面可以再套列表，一个里面套一个列表，叫二维数组；一个里面套一个列表，里面的列表再套一个列表，这个叫三维数组，套几层就是几维，定义格式如下：
stu =[1,2,3,4]#一维
stu1 =[1,2,3,4,['a','b','c'],['d','e','f']]#二维
#把d改成dd
stu1[5][0] = 'dd'
print(stu1)
stu2 =[1,2,3,4,['a','b','c',['啊','啊1','啊2']]]#三维
#在啊前面增加一个元素呵
stu2[4][3].insert(0,'呵呵')
print(stu2)
通过下标访问列表中的元素，下标从0开始计数，也就是说，比如说一个列表，有个5元素，那么它第一个元素下标就是0，第二个就是1，以此类推，字符串也有下标，和列表一样 对列表的操作，分以下几种增、删、改、查
增：
msg = '你好'
name = ['andashu','cc','niuniu']
name.append(msg)#从最后面开始插入
name.insert(1,msg) #从指定位置插入，这个1代表下标
print(name)
改：
|
1
2
3
|
msg = '你好'
name = ['andashu','cc','niuniu']
name[1] = 'baby' #修改指定位置的值
print(name)
|
查：
|
1
2
3
4
|
msg = '你好'
name = ['andashu','cc','niuniu']
print(name[0])#获取第一个元素
print(name[-1])#-1代表最后一个元素
|
删：
|
1
2
3
4
5
6
|
msg = '你好'
name = ['andashu','cc','niuniu']
name.remove('baby')#删除指定的值
del name[0]#删除指定位置的值
name.pop()#不传入下标的话，删除最后一个值，传入下标删除指定位置的值
name.clear()#清空列表
print(name)
|
#切片：列表取值的一种方式，可以指定范围取值：语法：【起始：结束：步长】
# 切片，切片也就是另一种方式获取列表的值，它可以获取多个元素，可以理解为，从第几个元素开始，到第几个元素结束，获取他们之间的值，格式是name:[1:10]，比如说要获取name的第一个元素到第五个元素，就可以用name[0:6]，
切片是不包含后面那个元素的值的，记住顾头不顾尾；前面的下标如果是0的话，前面可以省略不写，这样写，name[:6]，切片后面还有可以写一个参数，叫做步长，也就是隔多少个元素，取一次，默认可以不写，也就是隔一个取一次，
切片操作也可以对字符串使用，和列表的用法一样，实例如下：
stu =[1,2,3,4,5,6,7,8,9]
print(stu[2:6])
print(stu[2:9:2])
print(stu[::-3])#如果步长为负数时，从右往左取值
print(stu[0:5])
print(stu[:5])#如果最前面的下标没有写代表从最前面开始取
print(stu[5:10])
print(stu[5:])#如果最后面的下标没有写代表取到最后
print(stu[:])#什么都没写代表从前取到尾
new_stu = stu[:] #复制一个新的list
new_stu = stu
print(new_stu)
#下标，索引，切片，同样适用于字符串,字符串也是可以循环的
# 字符串一旦定义好就不能修改
name = '马上要去吃饭了'
print(name[2:])
print(len(name))
#循环字符串
for a in range(len(name)):
print('下标是：%s,字是：%s'%(a,name[a]))
for a,b in enumerate(name):
print('下标是：%s,文字是：%s'%(a,b))
name[1]='去吃饭'#报错TypeError: 'str' object does not support item assignment（字符串一旦定义好就不能修改）
# stus_info = [['杨静',18,'女','dddd'],['王志华',18,'女','dddd'],['王银梅',18,'女','dddd'],['周永波',18,'女','dddd']]#多维数组
#
# for stu in stus_info:
# if stu[0]=='王志华':
# print(stu)
字典
上面说了，整形、浮点型、字符串、列表和元组，下面说个新的数据类型，字典，字典也是我们开发过程中最常用的一种数据类型；想一个问题，现在要存整个北京市的所有人的信息，每个人有姓名、年龄、性别、家庭住址、学历等等，那要是用列表存的话，那就得定义N多个数组，然后存上每个人的信息，那累死人了。。。这时候又有一种新的数据类型出现了，那就是字典，dict，全称是dictionary，它具有极快的查找速度；字典是一种key-value的数据类型，比如说要存每个人的信息，那么每个人的编号就是key，value就是每个人的信息，这样的话，一个字典就能存所有人的信息了。字典的定义使用{}，大括号，每个值用“，”隔开，key和value使用“：”分隔。
举个列子，如果用列表存每个人的信息的话，需要用两个列表，一个存人名，一个存信息：
|
1
2
|
names = ['marry','amy','lily']
infos = [[18,18612512981,'北京'],[20,18612512991,'山东'],[25,18612532981,'河南']]
|
给一个名字，如果要查他的对应信息，那就要先从names里面找到它的位置，然后再从infos中找到它的信息，如果这个列表越长，那么它的查询速度越慢。
如果用字典实现的话，只需要一个名字和信息对应的一个表，这样就很快的根据名字找到它对应的信息，无论这个表有多大，查找速度都不会变慢。
|
1
2
|
infos = {'marry':[18,18612512981,'北京'],'amy':[20,18612512991,'山东'],'lily':[25,18612532981,'河南']}
infos['marry'] #取marry的信息
|
为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。
第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢，这种就是字典的实现方式。
字典的特性：
字典是无序的，因为它没有下标，用key来当索引，所以是无序的
字典的key必须是唯一的，因为它是通过key来进行索引的，所以key不能重复，天生就去重
字典的增删改查：
#定义空字典，字典是一种Key values形式的
stu_info = {}
stu_info = dict()
#定义空字典：stu_info = dict() stu_info{}
#字典一个逗号代表一个元素，字典比列表的速度快，字典里面的Key是不能重复的，如果有重复的，后面的那个会覆盖前面的那个
# stu_info = {'name':'王志华','age':18,'addr':'北京'}
# print(stu_info['name'])
# res =list(range(1000000))
# print(res)
# list越慢去找list会越慢，但是字典不会，因为字典里面的里面key不能重复
# josn是个字符想，想变成字典必须转换，josn只是格式长的像字典
#字典查询方法：
stu_info = {'name': '王志华', 'age': 18, 'addr': '北京'}
print(stu_info)
方法一：
print(stu_info['name'])
print(stu_info['age'])
方法二：
print(stu_info.get('name'))
#用,get方法和【】的取值来看看如果key不存在的情况分别做如何处理：
# print(stu_info['sex'])#[]取值时会报错：KeyError: 'sex'
# print(stu_info.get('sex'))#不会报错：None,None代表什么都没有
print(stu_info.get('sex','女'))#如果从系统里面get不到这个参数，就给他一个默认值
#字典修改方法：修改只有下面一种方法
stu_info = {'name': '王志华', 'age': 18, 'addr': '北京'}
stu_info['addr']='上海'
print(stu_info)
#字典新增方法：
stu_info = {'name': '王志华', 'age': 18, 'addr': '北京'}
# 方法一：
stu_info['zhiye']='测试'
# 方法二：
stu_info.setdefault('email','5852546@qq.com')
#分别用上面两种新增方法新增已经存在的key：字典的key都是无序的
# stu_info['name'] ='刘美燕'#不报错替换之前的value
stu_info.setdefault('name','哈全哈')#不报错也不修改之前value的值
print(stu_info)
#字典删除方法：
stu_info = {'name': '王志华', 'age': 18, 'addr': '北京'}
# 方法一：
stu_info.pop('addr')
# 方法二：
# stu_info.clear()#清空这个字典
# 方法三：
# stu_info.popitem()#从字典里面随机删除一个元素
# 方法四：
# del stu_info['addr']
# 分别用方法一和方法四删除一个不存在的Key
# stu_info.popitem('email')#报错：TypeError: popitem() takes no arguments (1 given)
del stu_info['email']#报错：KeyError: 'email'
print(stu_info)
#关于字典的其他一些方法：
d1={'b':'1'}
d2={'a':'v'}
d1.update(d2)#将d2的元素指定到d1里面
print(d1)
d1.keys()
print(d1.keys())#key获取字典里面所有的key
d1.values()
print(d1.values())#values获取字典里所有的values
#试一下直接循环字典，看看每次都循环的是:每次循环的是字典的key
stu_info = {'name': '王志华', 'age': 18, 'addr': '北京'}
for a in stu_info:
print(a)
#判断这个字典的Key是否存在:下面第一种方法更快
# 方法一：
print('name' in stu_info)
# 方法二：
print('name' in stu_info.keys())
# 同时取到key和value的方法：下面两种方法第一种方法更快因为第二种会把字典里面的key和value变成一个二维数组
# 方法一：
for a in stu_info:
# print('字典的key是：%s,字典的value是：%s'%(a,stu_info.get(a)))
print('字典的key是：%s,字典的value是：%s'%(a,stu_info[a]))
# 方法二：用.items方法可以同时取到key和value
for a,b in stu_info.items():
print('字典的key是：%s,字典的value是：%s'%(a,b))
字典的内置方法：
|
1
2
3
4
5
6
7
|
dic = {'stu1':'cc','stu2':'andashu','stu3':'niuniu'}
print(dic.values())#打印所有value
print(dic.keys())#打印所有的key
print(dic.setdefault('stu1','fengluo'))#如果这个key存在的话，那就不动它，不存在的话，添加一个
dic2 = {'stu1':'sriba','stu10':'baidu'}
dic.update(dic2)#更新字典值，如果key存在的话，就更新，不存在的话就添加
print(dic.items())#字典转换成一个list
|
#字典多层嵌套字典
# stu_info ={
# '王志华':{'password':'w12345','phone':12233432123,'age':18,'addr':'北京'},
# '王银梅':{'password':'w32123','phone':13333432123,'age':20,'addr':'上海'}
# }
# print(stu_info['王志华']['phone'])
d = {
'春波':{"car":['BMW','ben-a','五菱宏光'],"house":["北京",'南京','上海'], "money":1000000,},
'乔美玲':{"bag":['xx','lv',],"house":['三环','4环'],"hzp":['skii','ysl']}
}
#春波买了一辆雪佛兰
# d ['春波']['car'].insert(3,'雪佛兰')
# print(d)
#春波需要卖一套房
# d['春波']['house'].pop(2)
# d['春波']['house'].remove('上海')
# print(d)
#春波因为卖房钱增加500万
# d['春波']['money']=d['春波']['money']+5000000
# d['春波']['money']+= 5000000
# print(d)
f = {
'春波':{ "car":{'BMW':5,'BENZ':3,'audi':3,'byd':4}, "house":["北京",'南京','上海'],"money":1000000,},
'乔美玲':{"bag":['xx','lv',], "house":['三环','4环'],"hzp":['skii','ysl'],'language':{'普通话':10,'东北话':20,'日语':0,'英语':4}}
}
#乔美玲东北话降为10级
# f['乔美玲']['language']['东北话'] =10
# print(f)
#看一下乔美玲会多少种语言
# s = f['乔美玲']['language'].keys()
# print(s)
#春波总共有多少辆车
# 方法一：
# s =f['春波']['car'].values()
# count =0
# for d in s:
# count = d+ count
# print(count)
# 方法二：
# 用内置函数sum
# s =f['春波']['car'].values()
# print(sum(s))
#自主完成：
g = {
'春波':{ "car":{'BMW':5,'BENZ':3,'audi':3,'byd':4}, "house":["北京",'南京','上海'],"money":1000000,},
'乔美玲':{"bag":['xx','lv',], "house":['三环','4环'],"hzp":['skii','ysl'],'language':{'普通话':10,'东北话':20,'日语':0,'英语':4}}
}
#1、春波卖了一大上海的房子,卖了5000000:
g['春波']['house'].remove('上海')
g['春波']['money']+=5000000
print(g)
#2、春波有多少辆车：
h =g['春波']['car'].values()
print(sum(h))
#3、春波买了一辆劳斯莱斯
g['春波']['car'].setdefault('劳斯莱斯',1)
print(g)
#4、乔美玲东北话从20级变成10级
g['乔美玲']['language']['东北话']=10
print(g)
#5、乔美玲会哪些语言：
g['乔美玲']['language'].keys()
print(g['乔美玲']['language'].keys())
import getpass
# s=' abc '
# print(s.strip())#strip去空格
# password.getpass.getpass()#getpass输入密码什么都看不见，pycharm不支持getpass
#字符串常用方法：
s ='.abc.'
# new_s =s.strip('.')#默认是去空格和换行符，也可以指定某个内容
# print(s)
# print(s.rstrip('.'))
# print(s.lstrip('.'))
# print(s.strip('.'))#strip默认去掉字符串两边的空格和换行符，字符串都是有返回值的，调用某个方法后，只会生成一个新的字符串，原来的字符串不改变
# print(s.count('.'))#看某个元素出现的次数跟List是一样的
print(s.index('a'))#找索引，找某个字符串的下标
print(s.find('a'))#找索引，找某个字符串的下标
#index和find的区别,如果字符串不存在时
print(s.index('d'))#查找的字符串不存在时，会报错：ValueError: substring not found
print(s.find('d'))#查找的字符串不存时不会报错：返回-1
print(s.replace('a','A'))#替换字符串
f ='.abc.，abc，abcd,abEde'
print(f.replace('abc','ABC',3))#后面加个值代表里面有多个时，替换几个（从前往后数），如果不写就全部替换
#下面两个可以在注册时候用到
print(f.upper())#将里面的字母全部变成大写
print(f.lower())#将里面的字母全部变成小写
e ='abcdefg12汉'
print(e.capitalize())#首字母大写
print(e.startswith('a'))#判断是否以什么开头
print(e.endswith('f'))#判断是否以什么结尾
print(e.islower())#判断是否全部小写
print(e.isupper())#判断是否全部大写
print(e.istitle())#判断是否是个标题，首字母大写可能是个标题
print(e.isdigit())#判断是否为纯数字
print(e.center(50))#把字符串放在中间
print(e.center(50,'*'))#把字符串放在中间,其它不够以什么来补齐
print(e.isspace())#判断他是否是空格
print(e.isalpha())#判断他是否都是字母或汉字，不能有数字和特殊字符
print(e.isalnum())#字符串里面只要没有特殊字符就返回true
print(e.isnumeric())#判断是否为数字
print(e.isidentifier())#是否为合法的变量名，变量名不能以数字和特殊字符开头
# h ='insert into user value (%s,%s,%s)'%('name','password','sex')#这种太多了不好弄，需要限定顺序
# format方法：format是用大括号来占位的,不限定顺序
l = 'insert into user value({name},{password},{addr},'
'{email})'
k=l.format(addr='上海',password=1345677,name='cuimeiping',email='9890@qq.com')
print(k)
J ={'addr':'北京','email':'20876701@qq.com','password':'c123','name':'cuimeiping'}
# l.format_map()#可以传一个字典
J =l.format_map(J)
print(J)
#把下面的数字变成01，02，03.。。
P = [1,2,3,4,5,6,7,8,9,10,11,12]
# for i in P:
# if i>9:
# print(i)
# else:
# res = '0' + str(i)
# print(res)
#字符串提供一个方法可以不用循环zfill
U ='1'
print(U.zfill(3))#3代表几位数，不够补0
#有下面一批用户需要把它们单独插入到数据库，需要单独拿出user1，user2。。。
R ='user1,user2,user3,user4,user5,user6,user7'
#可以按,分割一下,分割成一个List，按照某个字符在分隔字符串，返回一个List
print(R.split(','))
print(R.split())#默认什么都不传时，按照一个空格来分隔字符串，多个空格也是一样分隔
cars =['BMW','BEN-Z','BYD']
res ='-'.join(cars)#以某个字符串把list里面元素连起来（把list的变成一个字符串）前面指定一个字符串，把list的里面的元素变成一个字符串
print(res)
print(str(cars))#直接把List转成字符串，但是会带【】，这样第一个元素变成【
操作文件
#操作文件
#读文件：读文件时文件必须存在
f =open('users.txt',encoding='utf-8')
res = f.read()
print(res)
f.close()
#写文件：w模式写文件的时候如果重新写会覆盖之前写的 a模式之前的东西还在
# e = open('user1',mode='w',encoding='utf-8')
# e.write('cuimeiping2,c890')
# e.close()
#a模式写之前的东西还在
e = open('user1',mode='a',encoding='utf-8')
e.write('cuimeiping3,c890 ')
e.close()
e =open('user1',encoding='utf-8')
e =open('user1',encoding='utf-8')
res = e.read()
print(res)
f.close()
#练习
1、写注册的程序：
username：
password：
cpassword：
册过的，两次密码必须输入一致
账号、密码的长度要在6-10之间
注册完成之后，存到文件里面
2、登录，账号密码是从文件里面取的，如果输入的账号不存在要提示。
登录的时候账号不区分大小写
#先把文件的账号和密码放到list或字典里
fw=open('a',encoding='utf-8')
list= fw.read()
fw.close()
#分隔
rest=list.split()#分隔
print(rest)
user_dict={}#定义一个空字典
for i in rest:
# name= i.split(',')[0]
# password = i.split(',')[1]
# print(name)
# print(password)
name,password=i.split(',')
# print(name)
# print(password)
user_dict[name]=password
print(user_dict)
fr = open('a','a')
# ----注册------
for a in range(3):
user_name=input('请输入用户名').strip().upper()
user_password=input('请输入密码').strip()
user_passcword=input('请输入确认密码').strip()
if user_name==name:
print('用户名已经存在')
elif user_password !=user_passcword:
print('两次密码不一致')
elif len(user_name )not in range(6,11) or len(user_passcword) not in range(6,11):
print('账号、密码的长度要在6-10之间')
# elif user_name==''or user_passcword=='':
# print('用户名密码不能为空')
else:
print('注册成功')
user_dict[user_name]=user_passcword
# g='%s,%s '%(user_name,user_passcword)
fr.write('%s,%s '%(user_name,user_passcword))
break
else:
print('输入次数过多')
fr.close()
#-----登录-----
fl=open('a','a+',encoding='utf-8')
fl.seek(0)
res=fl.read()
print(res)
#要把文件内容分隔出来放到一个List里面
res_list=res.split()
print(res_list)
dic ={}
#
for a in res_list:
# if a.strip() !='':#判断是否为空行
name,password=a.split(',')
print(name)
print(password)
dic[name]=password
print(dic)
for i in range(3):
res_name=input('请输入用户名').strip().lower()
res_password=input('请输入密码').strip()
if res_name==''or res_password=='':
print('用户名密码不能为空')
elif res_name not in dic:
print('用户名不存在')
elif res_password!=dic.get(res_name):
print('密码不正确')
else:
print('登录成功')
break
else:
print('输入次数过多')