len()函數可計算字符串的字符個數
注意正向和反向的索引序號
切片的各個參數：start,end,step
注意各參數的含義和默認值
s="helloworld"
s1=s[0:5:1] #指定起始和結束位置以及步長
print(s1) #輸出為hello
序列相加：要求序列類型相同（序列的類型有列表、元組、集合、字典和字符串），元素的 類型可以是字符型或整型。理解序列類型和序列中的元素類型
列表是可變長序列，因為其可以增加、刪除元素
#列表的創建
#直接使用[]創建
lst=["hello","world",99.8,] #變量名為lst不是list,因為list是內置函數
#使用內置函數list()創建
lst2=list("hello") #結果為["h","e","l","l","0"]
lst3=list(range(1,10,2)) #從1開始，到10結束(不包括10)且步長是2，輸出結果為[1,3,5,7,9]
#列表中的操作
print(lst2+lst3) #結果為["h","e","l","l","0",1,3,5,7,9]
print(lst2*3) #結果為["h","e","l","l","0","h","e","l","l","0","h","e","l","l","0"]
print(len(lst2))
print(max(lst3)) #序列的操作同樣適用
print(min(lst3))
#列表的刪除
del lst #刪除列表，則列表不存在
del lst2
del lst3
#使用for循環遍歷列表元素
lst=["hello","world","python","php"]
for item in lst:
print(item)
#使用for循環，range()函數，len()函數，根據索引進行遍歷元素
for i in range(len(lst)):
print(i,"-->",lst[i])
#使用for循環，enumerate()函數進行遍歷
for index,item in enumerate(lst): #默認index序號從0開始
print(index,item)
for index,item in enumerate(lst，1): #修改index序號從1開始
print(index,item)
lst=["hello","python","php"]
print("原列表："，lst,id(lst)) #id()函數表示該地址，輸出為原列表：["hello","python","php"]
#使用insert(index,x)在指定位置插入元素
lst.insert(1,100) #在位置1處插入元素100(默認位置從0開始)
#刪除元素
lst.remove("hello")
#使用pop(index),根據索引移出元素，先將元素取出，再將元素刪除
lst.pop(1) #該語句直接在窗口輸出100
#清空列表所有元素
lst.clear()
#將列表中元素的位置反轉
lst.reverse()
#列表的拷貝，並產生新的列表
new_lst=lst.copy() #兩個列表的內存地址不一樣
#列表元素的修改
lst[1]="mysql" 
sort方法：reverse=True,則降序排序；False是升序排序，默認是升序排序對
sorted函數：是內置函數
注意sort()是方法，而sorted()是內置函數
對中文的排序效果不是很好，但可以對英文排序，按照首字母的unicode碼值進行排(ASCII碼是unicode碼的一部分)
#用sort()方法進行排序
lst=[5,15,46,3,59,62]
lst.sort() #默認是升序排序
lst.sort(reverse=True) #降序排序
#對英文排序
lst2=["banana","apple","Cat","Orange"]
lst2.sort() #默認升序排序，先排大寫再排小寫(按照首字母的unicode碼排序)
lst2.sort(reverse=True) #降序排序，先排小寫在排大寫
#忽略大小寫進行排序
lst2.sort(key=str.lower) #默認升序排序且部分大小寫，用到參數key(是比較排序的鍵)#用sorted()內置函數進行排序
lst=[5,15,23,86,3,87]
asc_lst=sorted(lst) #默認是升序排序
print(lst)
print(asc_lst) #輸出會發現lst未改變，asc_lst排序改變
#sorted()函數的參數和sort()方法相同，可采用一樣的形式
expression是表達式的意思，即前面的可以是任何表達式
#列表生成式
#生成整數列表
lst=[i for i in range(1,11)]
lst1=[i*i for i in range(1,11)] #前面是表達式
#產生10個隨機數列表
import random #要產生隨機數要導入random模塊
lst3=[random.randint for _ in range(10)] #因為前面沒有用到循環變量，所以用下劃線代替則該循環表示循環的次數
#從列表中選擇符合條件的元素組成新的列表
lst4=[i for i in range(10) if i%==0] #產生0~9之間的偶數列表
#創建二維列表
lst=[["城市","環比","同比"],
["北京",102,103],
["上海",104,504],
["深圳",103,205]
]
#遍歷二位列表
for row in lst
for item in row
print(item,end="\t")
print()
#列表生成式創建四行五列的列表
lst2=[[j for j in range(5)]for i in range(4)]
print(lst2) #輸出是[[0,1,2,3,4],[0,1,2,3,4],[0,1,2,3,4],[0,1,2,3,4]]
#也可效仿一維列表生成式添加條件篩選
元組是不可變序列
元組中的數據類型可以是字符串、整型、也可以是列表,元組
#直接使用()創建元組
t=("hello","python",[0,1,2],10)
print(t) #輸出是("hello","python",[0,1,2],10)，輸出中帶有()
#使用內置函數tuple()創建元組
t=tuple("hello")
print(t) #輸出為("h","e","l","l","o")
t=tuple([1,2,3])
print(t) #輸出是(1,2,3)
t=tuple(range(1,5))
print(t) #輸出是(1,2,3,4)
#元組的相關操作和序列的操作一樣
#若元組中只有一個元素，括號中應帶“,”
z=(10)
print(type(z)) #輸出<class:int>
m=(10,)
print(type(m)) #輸出<class:tuple>
#刪除元組
del m
print(m) #報錯:nameerror:m is not defined
t=("python","php","hello")
print(t[0]) #輸出為python,根據索引訪問
t1=t[0:3:1]
print(t1) #輸出是("python","php","hello"),切片操作
#元組的遍歷
#1，直接使用for循環遍歷
t=("python","php","hello")
for item in t:
print(item)
#2,for循環+range()+len()組合遍歷
t=("python","php","hello")
for i in range(0,len(t)):
print(t[i])
#3,enumerate()函數遍歷
for index,item in enumerate(t):
print(index,item) #使用enumerate()函數時index默認從0開始
t=(i for i in range(1,4))
print(t) #結果是<generator object <genexpr>>生成器對象
#1，生成器對象可轉換成元組類型輸出
t=tuple(t)
print(t) #輸出(1,2,3)
#2,生成器對象可以直接只用for循環遍歷，不用轉成元組類型
for item in t:
print(item)
#3，生成器對象方法__next__()方法遍歷
print(t.__next__()) #拿到第一個元素
print(t.__next__()) #拿到第二個元素
print(t.__next__()) #拿到第三個元素
t=tuple(t)
print(t) #輸出會發現元素為空
#生成器遍歷之後，再想重新遍歷必須重新創建一個生成器對象，因為遍歷之後原生成器對象不存在注意：生成器遍歷之後，再想重新遍歷必須重新創建一個生成器對象，因為遍歷之後原生成器對象不存在
1，列表時可變序列，可進行添加刪除操作；元組是不可變序列。
2，列表是可變序列故不能作為字典的鍵；元組是不可變序列可作為字典的鍵
3，當只需要訪問元素而不修改元素時，用元組
字典沒有索引，只能通過鍵來訪問
字典中的鍵必須是不可變序列，值可以是任意類型
字典是可變序列，可以添加和刪除元素
字典的刪除：del 字典名
#1，直接使用{}創建
d={10:"car",20:"dog",30:"pet"}
#2,映射函數zip()函數結合dict()使用
lst1=[10,20,30,40]
lst2=["cat","dog","car","zoo"]
ziph=zip(lst1,lst2) #映射函數的結果是zip對象
#zip()函數將兩個列表中對應位置的元素作為元組結合，並產生zip對象
#print(ziph) #輸出是<zip object>
#print(list(ziph)) #zip對象需轉化成列表或元組才能輸出
d=dict(ziph)
print(d) #輸出是{10:"cat",20:"dog",30:"car",40:"zoo"}
#3,使用dict()並用參數創建字典
d=dict(cat=10,dog=20,car=30) #括號若寫成10=cat則報錯因為變量不能是數字
print(d) #輸出是{"cat":10,"dog":20,"car":30}
t=(10,20,30)
m={t:10} #鍵必須是不可變序列
print(m) #輸出是{(10,20,30):10}
n=[10,20,30]
m={n:10}
print(m) #報錯typeError:unhashable type:"list"
#刪除字典
del m #刪除後就不存在
del n
字典元素遍歷：方法items()指的是鍵值對
d={"hello":10,"world":20,"php":30}
#訪問字典元素
#1，使用[key]
print(d["hello"])
#2,使用d.get(key)
print(d.get("hello"))
#[key]和d.get(key)的區別，若鍵不存在時會出現區別
#print(d["java"]) 直接報錯：KeyError鍵錯誤
print(d.get("java")) #不會報錯，輸出None，d.get("java")默認值None
print(d.get("java","不存在")) #輸出默認值不存在
#字典的遍歷
for item in d.items():
print(item) #輸出是元組形式，即("hello",10)形式，因為items是鍵值對形式
for key,value in d.items():
print(key,value) #輸出對應的值
d={1001:"李梅",1002:"王華",1003:"張鋒"}
#向字典中添加數據
d[1004]="張麗" #直接使用d[key]=value賦值運算，添加數據
#獲取字典中所有的key
key=d.keys() #d.keys()結果是dict_keys,python中的一種內部數據類型，專用於表示字典的key
#若希望更好的顯示數據，可用list()或tuple()轉為列表或元組
print(list(key))
print(tuple(key))
#獲取字典中所有的value
value=d.values() #d.values()結果是dict_values
print(list(value))
print(tuple(value))
#使用pop()方法
print(d.pop(1008,"不存在")) #若鍵不存在，輸出默認值“不存在”
#清除字典
d.clear()
print(bool(d)) #輸出False
#使用指定范圍的數做鍵key
import random
d={item:random.randint(1,100) for item in range(4)}
print(d) #輸出{0:39,1:25,2:45,3:56}
#使用映射函數zip()作為生成表達式
lst1=[1001,1002,1003]
lst2=["劉偉","張強","李華"]
d={key:value for key,value in zip(lst1,lst2)}
print(d)
集合中的元素不能重復，若重復則自動降重，可實現字符串的降重
本博客只敘述可變集合set
#第一種創建集合方法
s={10,20,30,40]
print(s) #輸出為{40,10,20,30},因為集合是無序的
s={[10,20],[30,40]}
print(s) #報錯TypeError,因為列表是可變的
s={} #創建的是空字典
s=set() #創建的是空集合
#第二種創建集合，set(可迭代對象)，可迭代對象就是能用for循環遍歷的類型
s1=set("hello")
s2=set([10,20,30])
s3=set(range(1,10))
print(s1) #輸出{"h","l","o","e"},集合中的元素不能重復，可實現字符串的去重
print(s2)
print(s3)
del s1 #刪除s3
a={10,20,30,60}
b={20,30,40,80}
print(a&b) #輸出是{20,30},仍為集合
print(a|b) #輸出仍是集合
print(a-b)
print(a^b) #補集，即去掉a和b中重復的元素後剩下的所有元素
s={10,20,30}
#添加元素
s.add(100) #結果是{100,10,20,30}
#刪除元素
s.remove(20)
#清除集合中所有元素
s.clear()
#遍歷集合元素
for i in s:
print(i)
#使用ennumerate()函數遍歷
for index,value in ennumerate(s,1): #index是序號，不是索引
print(index,value)
#集合生成式
s={i for i in range(1,10)}
m={i for i in range(1,10) if i%2==0}
#千年蟲
lst=[88,89,90,98,00,99] #表示員工的兩位整數的出生年份
#遍歷列表
for index in range(len(lst)):
if str(lst[index])!="0":
lst[index]="19"+str( lst[index])#拼接之後再賦值
else:
lst[index]="200"+str( lst[index])
#使用enumerate()函數遍歷列表
for index,value in enumerate(lst):
if value!=0:
lst[index]="19"+str(value)
else:
lst[index]="200"+str(value)#模擬京東購物流程
#創建列表，用來存放入庫的商品信息
lst=[]
for i in range(1,6):
goods=input("輸入商品編號和商品名稱,每次輸入一件")
lst.append(goods)
#輸出所有的商品信息
for item in lst:
print(item)
#創建空列表，用來存放購物車的商品
cart=[]
while True:
flag=False
num=input("請輸入要購買的商品編號")
#遍歷商品列表，查詢購買的商品是否存在
for item in lst:
if num==item[0:4]
cart.append(item)
print("商品已添加到購物車")
break
if flag==False and num!="q":
print("該商品不存在")
if num="q":
break
print("購物車已選擇的商品為")
#反向
cart.reverse()
for item in cart:
print(item)
#模擬12306購票流程,字典的應用
#創建字典，用來存儲車票信息，車次做key,使用其他信息做value
dict_ticket={"G1569":["北京南-天津北"，"18:06","18:39"],"G1567":["北京南-天津南"，"18:15","18:50"],"G1845":["北京南-天津西"，"18:13","18:36"],"G1902":["北京南-天津東"，"18:23","18:56"]}
#遍歷字典元素
for key in dict_ticket.keys():
print(key,end="")
#遍歷車次詳細信息
for item in dict_ticket.get(key):#根據key獲取值，dict_ticket[key]
print(item,end="")
print()
#輸入用戶的購票車次
train_no=input("輸入用戶購買的車次")
#根據鍵獲取值
info=dict_ticket.get(train_no,"車次不存在")#get()方法若沒有對應的key,則輸出默認參數"車次不存在"
if info!="車次不存在":
person=input("輸入乘車人")
#獲取車次詳細信息
s=info[0]+" "+"開"+info[1]
print("已購買"+train_no + person + s + "換取車票【鐵路12306】")
else:
print("車次不存在")
#模擬手機通訊錄,集合的應用
#創建空集合
phones=set()
for i in range(5):
info=input("請輸入第"+str(i)+"位人間好友")
#添加到集合中
phones.add(info)
for item in phones:
print(item)
