python的list的基本操作、list循環、切片、字典基本操作、字典嵌套、字符串常用方法

上面說了字符串和整形，那現在要是想存一個班級的人的名字，這個班有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','[e-mail]')

#分別用上面兩種新增方法新增已經存在的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='[e-mail]')
print(k)
J ={'addr':'北京','email':'[e-mail]','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('輸入次數過多')