上面说了字符串和整形，那现在要是想存一个班级的人的名字，这个班有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

# 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\n')

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\n'%(user_name,user_passcword)

fr.write('%s,%s\n'%(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('输入次数过多')