一、基本資料型別的內建方法

1.1 整數和浮點數

1、整數
# 整數的轉換
    age = "18"
    print = int(age)
# 非整數型的是轉換不了整數，比如
	height = 1.8
    print = int(height)  # 這個是錯誤的，帶了小數點，應該轉換成浮點型
    name = "Ame"
    print = int(name)  # 這個是錯誤的，因為字串是英文字母組成的
	print(int(11.11))  # 11
    print(int("11.11"))  #報錯 因為裡面是字串型的浮點型 
2、浮點型
# 浮點型的裝換
	height = 180.1
    print(float(180.1))  # 180.1
    print(float("180.1"))  # 180.1
    print(float(180))  # 180.0
    print(int(11.11))  # 11
 

1.2 字串

1、字串的查詢(索引)   索引是從0開始的
	name = "ameameame"
    print(name[0])  # a
    print(name[-1])  # e
2、字串的查詢(切片)
	name = "ameameame"
    print(name[0:6:1])  # ameame 1 乃是步長的意思
    print(name[0:6:2])  # aem	2 乃是步長的意思
    print(name[-1:-6:-1])  #emaem 	3 因為查詢預設是從左到右，所以得加-1來從右到左的查詢
3、字串的長度
	name = "ameameame"
	print(len(name))  # len是能弄清楚字串的長度  name長度為9  提示 空格也算字元
4、字串的.sprit()用法
	# .strip是去除字串指定首尾的字元，預設不指定的時候則是去除首尾空格
    name = "      ameameame    "
    print(name.strip())  # ameameame 去除了首尾空格
    name = "%%ameameame%%"
    print(name.strip("%"))  # ameameame 去除了首尾%
    name = "%%ameame%a%m%eame%%"
    print(name.strip("%"))  # ameame%a%m%eame  只能去首尾，中間的不能去除
    # 如何才能去除左邊的保留右邊的(.lstrip)
    name = "%%ameameame%%"
    print(name.lstrip("%"))  # ameameame%%
    # 如何才能去除右邊的保留左邊的(.rstrip)
    name = "%%ameameame%%"
    print(name.rstrip("%"))  # %%ameameame
5、字串的判斷在不在字串裡面(in      not in)
	name = "ameameame"
    print("a" in name)  # True
    print("q" not in name)  # False
6、字串的.split()用法
	str = "1!2!3!4!5!6!7!8!9"
    list = str.split("!")
    print(list)  # ['1', '2', '3', '4', '5', '6', '7', '8', '9']
    # 因此可以看出字串轉換成了列表，切割的"！"也不會被保留，所以切記，以後碰到字串轉列表就可以用.split用法。
    list1 = str.split("!",maxsplit=2) # print(list)  # ['1', '2', '3!4!5!6!7!8!9']
    # 預設.split是從左到右切割
    list2 = str.rsplit("!",maxsplit=2)  # ['1!2!3!4!5!6!7', '8', '9']
7、字串的迴圈方法
	name = "ameameame"
	for i in name
    	print(i)  # 依次獲取字串中單個單個的字元
        
8、把字串全部變成大寫或者小寫
	name = "amEaMeame"
    # 全部轉成大寫
    print(name.upper())  # "AMEAMEAME"
    # 全部轉成小寫
    print(name.lower())  # "ameameame"
    # 應用於圖片驗證碼
    
9、字串開頭結尾
    res = 'Ame Yuki lalala'
    # 判斷字串是否以Ame開頭
    print(res.startswith('Ame'))  # True
    # 判斷字串是否以lalala結尾
    print(res.endswith('lalala'))  # True
 
10、格式化輸出 format
	2.1
    res = "班上的時常達{}年的練習生{}, 他的愛好就是{}," \
          "並且在他{}歲的時候， 編出了雞你太美舞蹈".format(2.5, "小明", "唱 跳 rap 籃球", 60)
    print(res)
    班上的時常達2.5年的練習生小明, 他的愛好就是唱 跳 rap 籃球,並且在他60歲的時候， 編出了雞你太美舞蹈
    

    res = "班上的時常達{0}{0}年的練習生{1}{1}, 他的愛好就是{2}{2}," \
    	  "並且在他{3}{3}歲的時候， 編出了雞你太美舞蹈".format(2.5, "小明", "唱 跳 rap 籃球", 60)
    print(res)
    班上的時常達2.52.5年的練習生小明小明, 他的愛好就是唱 跳 rap 籃球唱 跳 rap 籃球,並且在他6060歲的時候， 編出了雞你太美舞蹈

	2.2 
	res = "班上的時常達{year}年的練習生{name}, 他的愛好就是{hobby},".format(name="小明", year=2.5, hobby="籃球")
	print(res)
    班上的時常達2.5年的練習生小明, 他的愛好就是籃球,	
    
11、統計字串中字元出現的次數
	name = "ameameame"
	print(name.count("a"))  # 3 統計"a"出現的次數
    print(name.count("a", 0, 4))  # 2 在索引0-3 統計"a"出現的次數
    
12、把字串首字母都變成大寫(可以用於標題)
	res = 'my name is ame nis IO KSn kls  '
	print(res.title())  # 將所有英文單詞首字母大寫   My Name Is Ame Nis Io Ksn Kls 
	print(res.capitalize())  # 首字母大寫 後面統一變小寫    My name is ame nis io ksn kls
    
13、判斷字串是否為純數字
	guess_age = input('請輸入您的年齡>>>:')
    if guess_age.isdigit():
    	將字串的數字轉為整型的數字
        guess_age = int(guess_age)  
    else:
        print('請輸入純數字')
        
 14、文字功能 替換關鍵字
	res = "my name is Ame Ame Ame"
    res.replace('Ame', 'yuki')  # my name is yuki yuki yuki
    res.
 15、列表轉換成字串 .join
	list = ["1", "2", "3", "4", "5", "6"]
	print(",".join(list))  # 1,2,3,4,5,6
    # 切記 只能轉換列表是字串你型別
 

1.3 列表

1、列表的查詢(索引)
	list = [1, 2, 3, 4, 5, 6]
    list[0]  # 1
    list[-1]  # 6
2、列表的查詢(切片)
	list = [1, 2, 3, 4, 5, 6]
    list[0:5]  # 預設步長為一  [1, 2, 3, 4, 5] 
    list[0:5:2]  # [1, 3, 5]
3、列表中元素的個數 len
	list = [1, 2, 3, 4, 5, 6]
    len(list)  # 6
4、 列表的增刪改查
	list = ["ame", "yuki", "vlicecream"]
    list[0] = "yuki"
5、列表增加元素 append 尾部追加
	list = ["ame", "yuki", "vlicecream"]
    list.append["monica"]  # list =  list = list = ["ame", "yuki", "vlicecream", "monica"]
6、列表刪除元素 del remove pop
	# del
	list = ["ame", "yuki", "vlicecream"]
    del list[0]  # list = ["yuki", "vlicecream"]
    # remove  指名道姓的刪除
    list = ["ame", "yuki", "vlicecream"]
    list.remove("ame")  # list = ["yuki", "vlicecream"]
    # pop
    list = ["ame", "yuki", "vlicecream"]
    list.pop()  # 如果沒有加索引，那麼是預設尾部彈出 也就是刪除尾部，但是這個傳出來的值是尾部的值   list = ["ame", "yuki"]
   
7、列表插入元素
	list = ["ame", "yuki", "vlicecream"]
    list.insert(0, "monica")  #list = ["monica", "ame", "yuki", "vlicecream"]
    
8、拓展列表
	list = ["ame", "yuki", "vlicecream"]
    list1 = ["am", "yuk", "vlicecrea"]
    list.extend(list1)
    print(list)  # ['ame', 'yuki', 'vlicecream', 'am', 'yuk', 'vlicecrea']
    
9、統計列表元素出現的個數
    list = ["ame", "yuki", "vlicecream"]
    print(list.count("yuki"))  # 1 統計列表中某個元素出現的次數

10、清理列表
    list.clear()  # 清空列表
    print(name_list)  # list = []

11、列表的升序和降序
	l2 = [11,88,22,44,33,77,66,55]
    l2.sort()  # 排序  預設是升序
    print(l2)  # [11, 22, 33, 44, 55, 66, 77, 88]
    l2.sort(reverse=True)  # reverse=True 降序
    print(l2)  # [88, 77, 66, 55, 44, 33, 22, 11]

    l2.reverse()  # 倒序
    print(l2)

 

1.4 字典

1. 字典的查詢(key)
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap籃球"}
    print(dirt["name"])  # Ame
    # 輸入不存在的key 會報錯
2. 字典keys:Value的個數(len)
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap籃球"}
    print(len(dirt))  # 3

3.字典的增改
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap籃球"}
    dirt["name"] = "yuki"
    print(dirt)  # {'name': 'yuki', 'age': 18, 'hobby': '唱跳Rap籃球'}
    dirt["id_card"] = 123456789
    print(dirt)  # {'name': 'yuki', 'age': 18, 'hobby': '唱跳Rap籃球', 'id_card': 123456789}

4. 字典的成員運算 in      not in
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap籃球"}
    print("name" in dirt)  # True
    print("hobby" not in dirt)  # False

5. 字典的刪除(del   pop)
	# del
	dirt = {"name": "Ame",
        "age": 18,
        "hobby": "唱跳Rap籃球"}
    del dirt["name"]
    print(dirt)  # {'age': 18, 'hobby': '唱跳Rap籃球'}
    # pop
    dirt = {"name": "Ame",
        "age": 18,
        "hobby": "唱跳Rap籃球"}
    dirt.pop("name")
    print(dirt)  # pop 則是指定key就去彈出，如果不指定 則預設尾部彈出
    
6. 字典的keys values items
	# keys 顯示出所有的key
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap籃球"}  
    print(dirt.keys())  # dict_keys(['name', 'age', 'hobby'])
    # values 顯示出所有的value
    dirt = {"name": "Ame",
        "age": 18,
        "hobby": "唱跳Rap籃球"}
	print(dirt.values())  # dict_values(['Ame', 18, '唱跳Rap籃球'])
    # items 將items()的結果可以直接看成是列表[]套小列表()
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap籃球"}
    print(dirt.items())  # dict_items([('name', 'Ame'), ('age', 18), ('hobby', '唱跳Rap籃球')])
    for k, v in dirt.items():  # 解壓賦值 結合 for迴圈
        print(k, v)  # name Ame   age 18   hobby 唱跳Rap籃球
        
7.字典的迴圈
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap籃球"}
    for i in dirt:
        print(i)  # name  age   hobby
  
8.字典的推薦使用查詢方法(get)
	dirt = {"name": "Ame",
        "age": 18,
        "hobby": "唱跳Rap籃球"}
	print(dirt.get("name"))  # Ame
    dirt = {"name": "Ame",
        "age": 18,
        "hobby": "唱跳Rap籃球"}
    print(dirt.get("id card"))  # None
    print(dirt.get("id card", 123456))  # 123456
    dirt.get("name", "yuki")  # Ame
    print(dirt)  # {'name': 'Ame', 'age': 18, 'hobby': '唱跳Rap籃球'}
    # get 假如輸入沒有的key是不會報錯的，會返回None ，所以推薦用get
    
9. 字典的建立方法
	I   dirt = {'name': 'Ame', 'age': 18, 'hobby': '唱跳Rap籃球'}
    II  diet = {key1:value1, key2:value2}
    III list = [
        ['username','jason'],
        ['password',123],
        ['hobby',['read','run']]
        ]
        dirt = {}
        for k, v in list:
            dirt[k] = v
        print(dirt)
        # 列表轉字典 方法，一定要注意
        
 10. 字典的清空(clear)
	dirt = {'name': 'Ame', 'age': 18, 'hobby': '唱跳Rap籃球'}
    dirt.clear()
    print(dirt)  # {}
    
11. 快速生成字典(fromkeys)
	dict.fromkeys()  # 快速先生成一個字典
    list = ['username','pwd','hobby']
    res = dict.fromkeys(l,None)
	print(res)
    
12. 字典刪除鍵值對(popitem)
	dirt = {'name': 'Ame', 'age': 18, 'hobby': '唱跳Rap籃球'}
    dirt.popitem()
    print(dirt)  # 字典彈出鍵值對 尾部彈出
    
13. 字典的修改(setdefault, update)
	# setdefault
	dict.setdefault()  重點
    dd = {'name':'jason','pwd':123}
    dd.setdefault('age',18)  # 鍵不存在 則新建
    res = dd.setdefault('name','egonSBSBSB')  # 鍵存在不修改 而是獲取到鍵對應的值
    print(dd,res)  # {'name': 'jason', 'pwd': 123, 'age': 18} jason
	# update
    dict.update()
    dd = {'name':'jason','pwd':123}
    dd.update({'age':18})  # 鍵不存在 則新建
    dd.update({'name':'EGONDSB'})  # 鍵存在則修改
    print(dd)
    # 還不如使用下列方式
    dd['age'] = 18
    dd['name'] = 'jason'

1.5 元組

1. 什麼是元組
	小括號括起來，裡面可以裝N多元素的，以逗號隔開，元素可以是任意型別，但是元組是不可變型別，要注意元組只有一個元素時，一定要有逗號，所以以後凡是容器型別，只有一個元素時都不能省略逗號
2. 按索引取值
	tup = (1, 2, 3, 4, 5)
    print(tup[0])  # 1
    print(tup[-1])  # 5
3.	"""
	筆試題
    元組內元素的記憶體地址不能修改
    但是如果元素是可變型別 那麼元素值可以改
	"""
4. 切片
	跟列表一致
   
5. 長度(len)
	跟列表一致
    
6. 成員運算(in   not in)
	跟列表一致
    
7. 迴圈
	tup = (1, 2, 3, 4, 5)
    for i in tup
    	print(i)

1.6 集合

1.什麼是集合
	大括號括起來 內部可以存放多個元素
	元素與元素之間逗號隔開  元素只能是不可變型別(整型 浮點型 字串 元組)
    
2.集合的應用場景
	只有兩種情況才會考慮使用集合
        1.關係運算
            兩個群體之間判斷 交叉並集
                共同好友 共同關注 共同點贊...
        2.去重操作
            去除重複的元素
            
3. 集合的定義
	# 因為跟字典很像，所以定義空{}的時候 預設是空字典 所以需要加set來宣告這是集合
    
4. 集合的去重操作
	# 去重不保留順序
	l = [11,22,33,22,22,33,11,22,55,66,66,77,77]
    set = set()
    for i in l:
        if i not in set:
            set.add(i)
    print(set)
	
    
    # 去重保留順序
	l = [11,22,33,22,22,33,11,22,55,66,66,77,77]
    new_l = []
    for i in l:
        if i not in new_l:
            new_l.append(i)
    print(new_l)

5. 關係運算
	f1 = {'jason','egon','kevin','tony'}
	f2 = {'jason','jack','oscar','kevin'}
I 共同好友
	f1 & f2
II f1獨有的好友
	f1 - f2
III f2獨有的好友
	f2 - f1
IV 所有的好友
	f1 | f2
V  各自的好友 不包括共同好友
	f1 ^ f2
6. 父集 子集
"""
父級:A包含B 那麼A就是B的父級
子級:A包含B 那麼B就是A的子級
"""
s1 = {1,2,3,4,5}
s2 = {1,2,3}
print(s1 > s2)  # True
print(s1 < s2)  # False

二、可變型別與不可變型別

1.1 可變型別

"""
可變型別
    值改變 記憶體地址不變
"""
# 可變型別
l1 = [11,22]
print(id(l1))  # 2133952624128
l1.append(666)
print(id(l1))  # 2133952624128

1.2 不可變型別

"""
不可變型別
    值改變 記憶體地址一定變
"""
# 不可變型別
    a = 1
    print(id(a))  
    a = 2
    print(id(a))