# 字串(接第二課)
# 5.字串替換
# 語法：變數名.replace(原字串，新字串，次數)
# 可以指定替換次數，如果不指定，則全部替換
# str="python,world,python,hello"
# print("這個是替換之前的字串",str)
# print("這個是替換之後的字串",str.replace("python","linux",1))#指定次數後替換的是從左邊開始的要替換的字串
# print("這個是替換之後的字串",str.replace("python","linux"))#不指定次數全部替換
# print("替換後檢視原字串結果",str)#列印結果是原字串，說明替換時，僅在當次輸出臨時替換，顯示替換後的結果，原字串是一種不可變資料型別

# 6.替換指定位置的小字串(字串的拆分和拼接)
# 格式：變數名.split('切分標記',次數)#分隔後的資料會生成一個列表
# 替換字串"python,world,python,hello"中的第二個python為其它內容
# 把第二python替換為linux
# str="python,world,python,hello"
# list=str.split(",")#通過逗號把原字串進行分隔
# print(list)#分隔完列印生成的列表
# list[2]="linux"#通過索引替換列表中的資料
# print(list)#列印替換後列表的資料
# new_str1=",".join(list)#通過逗號拼接將新列表中的內容重新生成字串
# print(new_str1)#列印重新拼接後的字串
#如果不指定切分標記，字串整體作為列表的一個元素
# list=str.split()

# 7.字串的大小寫轉換
# 01.字串轉換為小寫
# 格式:字串名.lower()
# str="AABBcc"
# print(str)
# print(str.lower())#列印轉換為小寫後的內容
# 02.字串轉換為大寫
# 格式:字串名.upper()
# str="aabbccDD"
# print(str)
# print(str.upper())#列印轉換為大寫後的內容

# 8.字串的拆分
# 格式：變數名.split('切分標記',次數)
# 可以指定切分次數，如果不指定，則全部切分
# my_str = 'hello,python,python,java'
# print(my_str.split(',')) # 不指定次數，全部切分，返回結果：['hello', 'python', 'python', 'java']
# print(my_str.split(',', 1)) #指定切分1次，返回列表：['hello', 'python,python,java']
# print(my_str.split('python')) # 僅做理解，返回列表：['hello,', ',', ',java']

# 若不指定切分標記，預設切分字串中的回車符\r、製表符\t(代表4個空格)、換行符\n、空格
# info_str1 = 'he\rllo,\tpytho\nn,py thon,java'
# info_str2 = 'hello,python,python,java'
# print(info_str1)
# print(info_str1.split())
# print(info_str2)
# print(info_str2.split()) # 未指定切分標記，字串整體作為列表的一個元素

# 9.字串的拼接
# 01字串的加法拼接
# str="hello"
# str1="python"
# print(str1+str)#拼接後沒有空格
# 02字串的逗號拼接
# str="hello"
# str1="python"
# print(str,str1)#逗號拼接有空格
# 03指定內容作為分隔符，拼接變數中的所有元素，拼接成一個新字串
# 格式：'拼接內容'.join(變數名)
# my_str='0123456789'
# print('#'.join(my_str))
# print('$'.join(my_str))
# print(''.join(my_str)) #空
# print(' '.join(my_str)) #空格

# 10.字串的切片
# 1.通過字串的切片，獲取字串中指定部分的字元
# 語法：字串[開始索引：結束索引：步長]
# 步長：獲取資料的步調長度，步長為正1時，可以省略
# 注意：切片的範圍：包含開始位置索引，不包含結束位置的索引，只能獲取到結束位置索引的前一個位置的資料，是一個左閉右開的區間[ )。

# str="hello,python"
#切出字串"hello"
# print(str[0:5])#切片的範圍，包含開始位置索引，不包含結束位置的索引，步長為1時可以省略
# #切出字串"eo"
# print(str[1:5:3])#索引從指定位置開始切片，指定位置先被切出，然後通過步長切片
# #把hello,python切出來
# print(str[::])#開始位置索引是邊界，開始位置索引可以省略，步長為1可以省略，結束位置索引為邊界，可以省略
# #把python切出來
# print(str[6::])#結束位置為索引邊界，可以省略，步長為1可以省略
# 練習：切出字串，開始索引是6，切到字串結尾，步長為2
# info_str = 'hello,python'
# print(info_str[6::2])

# 2.倒序切片，步長是負數（表示倒序方向切片）
# str="hello,python"
#切出 nohtyp
# print(str[-1:-7:-1])#獲取開始索引，不獲取結束位置索引，-1表示從右往左切，步長為1
# print(str[:-7:-1])#開始位置是字串邊界，開始位置索引可以省略
# print(str[11:5:-1])#倒序切片，可以用正序的索引號，注意開始和結束位置，不包含結束位置的索引號
# print(str[-10:-7:1])#正序切片，也可以用倒序的索引號，注意開始和結束位置，不包含結束位置的索引號
# print(str[-10:5:1])#正序索引和倒序索引號，可以一起使用，注意開始結束位置索引，不包含結束位置索引號。
# 面試題：將字串str1逆(倒)序輸出
# str1="hello,python"
# print(str1[::-1])#開始位置和結束位置為邊界，可以省略
# 總結：
# 開始位置索引是邊界時，可以省略
# 結束位置索引是邊界時，可以省略
# 步長為1時，可以省略
# 切片範圍：獲取開始索引位置字元，不獲取結束位置索引字元

# 列表
# 列表：存放多個變數組成大量資料
# 列表可以存放多個數據，並且列表是有序的序列容器，列表是可變的
# 1.列表格式
# list1=[值1,值2,值3...]
# list1=list()#空列表
# print(list1)
# 列表可以儲存任意型別的資料:數字型別、字串、列表、元組、字典。
# 例如:
# my_list=[100,12.35,True,"hello",[10,22],(44,"py"),{"name":"流川楓"}]
# print(my_list)

# 2.列表中的資料通過索引號的方式來訪問：（列表是有序的資料容器）
# 格式：列表名[索引號碼]
# my_list=[100,12.35,True,"hello",[10,22],(44,"py"),{"name":"流川楓"}]
# print(my_list[3])
# print(my_list[-1])#逗號分隔了不同索引號的資料

# 3.列表的新增
# 01.在指定位置插入資料
# 語法：列表名.insert(索引號,資料)
# list1=[1,2,3,4,5,6,7,8,9]
# print("這是原來的列表:",list1)
# list1.insert(2,"A")#在指定的索引號位置插入資料。插入資料，列印列表，分兩步走
# print(list1)
#插入位置的索引號的資料往後邊移動

# 02.向列表中插入小列表
# list1=[1,2,3,4,5,6,7,8,9]
# print("這是原來的列表:", list1)
# list1.insert(10,[10,22])#在列表中插入小列表
# print(list1)

# 03.在列表末尾追加資料
# 格式:列表名.append(資料)
# list1=[1,2,3,4,5,6,7,8,9]
# print("這是原來的列表:", list1)
# list1.append("李白")#在列表末尾追加資料。追加資料，列印列表，分兩步走
# print(list1)
# list1.append(12)
# print(list1)

# 4.合併列表資料
# 把列表2的資料合併到列表1中去
# 語法：列表1.extend(列表2)
# list1=[1,2,3,4,5,6,7,8,9]
# print("這是原來的列表:", list1)
# list1.extend([10,55,66])#把列表2資料放到列表1中，列表2的資料在列表1末尾顯示
# print(list1)

# list1=[1,2,3,4,5,6,7,8,9]
# list2=[10,55,66]
# print("這是原來的列表:", list1)
# list1.extend(list2)#把列表2資料放到列表1中，列表2的資料在列表1末尾顯示
# print(list1)

# 5.列表的刪除
# 01.刪除指定索引的資料
# 語法:del 列表[索引] #中間有空格
# list1=[1,2,3,4,5,6,7,8,9]
# print("這是原來的列表:", list1)
# del list1[4]
# print(list1)
# del list1[-1]
# print(list1)

# 02.把列表從記憶體當中清除(變數是儲存在記憶體中的)
# 語法: del 列表名
# list1=[1,2,3,4,5,6,7,8,9]
# print("這是原來的列表:", list1)
# del list1 #刪除後 list1 變數不存在
# print(list1)

# 03.清空列表
# 語法：格式：列表名.clear() 清空列表內容
# list1=[1,2,3,4,5,6,7,8,9]
# print("這是原來的列表:", list1)
# list1.clear()#清空後列表變成空列表
# print(list1)

# 04.刪除列表的末尾資料(可以返回刪除的資料)
# 語法:列表名.pop()
# list1=[1,2,3,4,5,6,7,8,9]
# print("這是原來的列表:", list1)
# num=list1.pop()#刪除末尾的最後的資料。可以用變數來接收刪除的資料
# print(num)
# print(list1)#列印的是刪除末尾資料的列表

# 05.刪除指定索引資料(可以返回刪除的資料)
# 語法：列表名.pop(索引號)
# list1=[1,2,3,4,5,6,7,8,9]
# print("這是原來的列表:", list1)
# num=list1.pop(3)#pop後的括號內寫索引號
# print(num)#列印刪除掉的資料
# print(list1)#列印刪除資料後的列表

# 6.列表的修改
# 列表中的資料是可以修改的(字串不能修改)
# 格式:列表名[索引號]=新內容
# list1=[1,2,3,4,5,6,7,8,9]
# print("這是原來的列表:", list1)
# list1[1]=10
# print(list1)

# 7.列表的查詢
# 01.通過索引號獲取資料
# 格式:列表名[索引號]
# list1=[1,2,3,4,5,6,7,8,9]
# print(list1[6])

# 02.通過資料獲取索引號
# 格式:列表名.index(資料)
# list1=[1,2,3,4,5,6,7,8,9]
# print(list1.index(4))#數字4的索引號是3

# 8.列表的高階操作
# 01.統計列表中的資料個數
# 格式:len(列表名)
# list1=[1,2,3,4,5,6,7,[8,9]]
# print(len(list1))#列表中的資料是通過逗號分隔的

# 02.統計資料在列表中出現的次數
# 格式：列表名.count(資料)
# list1=[1,2,8,3,4,5,5,6,"2",7,[8,9]]
# print(list1.count("2"))
# print(list1.count(8))
# print(list1.count([8,9]))
# print(list1.count(5))

# 03.列表的排序
# 升序
# 格式:列表名.sort() 先排序，後列印，兩步走
# my_list = [-1,3,6,2,9,10,-5,66,2,5,7,9,66,1,0]
# my_list.sort()#升序排序
# print(my_list)#列印排序後的列表

# 降序
# 格式：列表名.sort(reverse=True) 先排序，後列印，兩步走
# my_list = [-1,3,6,2,9,10,-5,66,2,5,7,9,66,1,0]
# my_list.sort(reverse=True)#對列表降序排序
# print(my_list)#列印降序後的列表

# 列表的逆序、反轉
# 格式: 列表名.reverse()先反轉，再列印，兩步走
# my_list = [-1,3,6,2,9,10,-5,66,2,5,7,9,66,1,0]
# my_list.reverse()#逆序
# print(my_list)列印逆序後的列表

# 9.列表的拷貝
# 格式:新列表名=原列表名.copy()
# id()函式可以檢視變數儲存資料的記憶體地址，括號內填寫變數名
# my_list = [-1,3,6,2,9,10,-5,66,2,5,7,9,66,1,0]
# print(my_list,id(my_list))
# list1=my_list.copy()
# print(list1,id(list1))
#copy後的記憶體地址發生變化

# 10.dir()函式，檢視變數(物件)所有的方法和屬性
# print(dir(str))#檢視字串的所有方法和屬性
# print(dir(list))#檢視列表的所有方法和屬性
# print(dir(tuple))#檢視元組的所有方法和屬性
# print(dir(dict))#檢視字典的所有方法和屬性

# 元組
# 元組和列表一樣，都是用來儲存多個數據
# 通過元組可以存放多個數據，並且這些資料不會被修改
# 1.列表和元組異同
# 相同點:
# 1.都是序列
# 2.都可以儲存任意型別資料
# 3.都可以通過索引訪問
# 不同點:
# 1.使用方括號[]建立列表，使用小括號()建立元組
# 2.列表是可變的，元組是不可變的，這是二者之間的關鍵差異
# 3.可以修改列表的值，不能修改元組的值。(元組中的資料修改是收到限制的，當元組中包
# 含列表或字典，列表和字典中的資料是可以修改的)
# 4.由於列表是可變的，不能將列表作為字典的鍵，但是元組可以作為字典的鍵

# 2.元組的應用場景
# 1.函式進階部分，函式的引數使用到了元祖，函式的多個返回值使用到了元祖
# 2.print格式化輸出多個變數 print('姓名:%s,年齡：%s,身高:%s' % (name, age, hight))
# 3.列表與元祖進行格式相互轉換時
# 4.要求對資料只讀，不能修改的場景。

# 3.定義元組(元素組合)
# 格式:元組名=(資料1，資料2，資料3...)
# 空元組： 元組名=()或元組名=tuple()
# a=()
# b=tuple()
# print(a)
# print(b)

# 空列表
# c=[]
# print(c)
# d=list()
# print(d)

# 例：
# my_tuple=(100,25.36,"10",True,{"name":11},[10,22],(10,656))
# my_tuple1=()
# print(my_tuple)
# print(my_tuple1)

# 4.元組中只有一個數據時，需要加逗號
# 格式:元組名=(資料,)
# tuple1=("aa",)#不加逗號括號會被當做運算子中的括號。列印結果為字串或數字型別
# tuple2=("aa")
# print(type(tuple1))
# print(type(tuple2))
# print(tuple1)
# print(tuple2)

# 5.訪問元組中的資料，通過索引(元組是有序的資料容器)
# 格式:元組名[索引號]
# my_tuple=(100,25.36,"10",True,{"name":11},[10,22],(10,656))
# print(my_tuple[2])
# print(my_tuple[5])

# 6.修改元組中的資料，是受到限制的
# 當元組中包含列表或字典，列表和字典的資料時可以修改的
# tuple1=(100,25.36,"10",True,{"name":11},[10,22],(10,656))
# list1=tuple1[5]#通過索引號獲取元組中的列表元素，賦值給變數list1
# print(list1)#列印一下拿出來的列表中的內容[10,22]
# list1[0]=60#通過列表的索引號修改列表中的值
# print(list1)#列印一下修改後的列表
# print(tuple1)#列印修改資料後的元組的內容