基本數據類型

# Python 中的變量不須要聲明。每一個變量在使用前都必須賦值，變量賦值之後該變量纔會被建立。
# 在 Python 中，變量就是變量，它沒有類型，咱們所說的"類型"是變量所指的內存中對象的類型。
# 等號（=）用來給變量賦值。
# 等號（=）運算符左邊是一個變量名,等號（=）運算符右邊是存儲在變量中的值。
# 變量定義的規則：
# 1.變量名只能是 字母、數字或下劃線的任意組合
# 2.變量名的第一個字符不能是數字
# 3.如下關鍵字不能聲明爲變量名
# ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else',
#  'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
#  'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
# python中的數據又稱爲對象，每建立一個對象都會建立三個屬性
# 一：身份id
# 二：類型type
# 三：值
# is：比較id,id同樣，類型確定同樣，值確定也同樣
# ==：比較的是值

# 基本的數據類型：
# num數字
# str字符串
# 它是一個有序的字符的集合，用於存儲和表示基本的文本信息，‘’或「」或‘’‘ ’‘’中間包含的內容稱之爲字符串

#  list列表 可迭代對象
# []內以逗號分隔，按照索引，存放各類數據類型，每一個位置表明一個元素

# tuple元組
# 與列表相似，只不過［］改爲（）

# dict字典
# 字典是一種映射類型，字典用"{ }"標識，它是一個無序的鍵(key) : 值(value)對集合。
# 鍵(key)必須使用不可變類型。在同一個字典中，鍵(key)必須是惟一的。

# set集合 無序不重複元素的序列

# 一：可變不可變
# 可變數據類型：列表 字典 集合
# 不可變數據類型：數字 元組 字符串
# 二：存放值的個數
# 一個值：數字，字符串
# 多個值(容器類型)：列表，元組，字典
# 三：取值方式
# 直接取值：數字
# 序列類型：字符串，元組，列表
# 映射：字典


# num數字
# int整型
# float浮點型   Python的浮點數就是數學中的小數
# bool布爾值   True和False   1和0
# complex複數   複數由實數部分和虛數部分組成，通常形式爲x＋yj，其中的x是複數的實數部分，y是複數的虛數部分，這裏的x和y都是實數。

# 布爾值
# None '' () [] {} 0  都是False
#1 -1 都是True

#數字
# m=10
# a=m.bit_length() #當前數字的二進制，至少用n位表示
# print(a)

# 將字符串轉換成數字
# num='b'
# v=int(num,base=16)#把b以十六進制方式轉換成10進制
# print(v)
# print(bin(10))#十進制轉換成二進制
# print(oct(10))#十進制轉換成八進制
# print(hex(16))#十進制轉換成十六進制

# 列表list
l=[1,2,3,3,4,5,6,7,'z']
l1=['jack']
# 查
# print(l.index(3))#返回3這個元素的索引
# a=l.count(3)#統計3的個數
# print(a)
# print(len(l))#統計l中有幾個元素

# 切片
# print(l[2:5])#第三個到第四個
# print(l[-2:])

# 增
# l.append('a') #追加
# print(l)
# l.insert(3,'abc')#把abc插到索引3的位置
# print(l)
# l.extend([7,8])#在最後插入多個
# l.extend('asd')#在最後插入'a','s','d'
# print(l)
# l.extend(l1)
# print(l)
# l=l+l1
# print(l)



# 刪
# l.pop(5)  #刪除索引爲5的元素,默認刪除最後一個值
# print(l)
# l.remove('z')#刪除z這個元素
# print(l)
# del l[2]#刪除索引爲2的元素
# print(l)
# del l #刪除列表

# 改
# l[2]=555 #賦值操做
# print(l)
# l.clear() #沒動內存空間，只清理了值
# print(l)
# l=[]   #推薦這種方式   指向空列表的內存地址

# l1=[2,3,5,6,4,1]
# l1.sort(reverse=True)   #排序，reverse=Ture表示從大到小排，不寫默認從小到大
# print(l1)
# l1.reverse()#反轉
# print(l1)
# print(l1.copy())#淺拷貝

#隊列：先進先出
# l=[]
# #入隊列
# l.append('people1')
# l.append('people2')
# l.append('people3')
# print(l)
# #出隊列
# print(l.pop(0))
# print(l.pop(0))
# print(l.pop(0))
#
# #insert
# l.insert(0,'people1')
# l.insert(0,'people2')
# l.insert(0,'people3')
# print(l.pop())
# print(l.pop())
# print(l.pop())
# #堆棧：先進後出或後進先出
# l=[]
# #入隊列
# l.append('people1')
# l.append('people2')
# l.append('people3')
# print(l)
# #出隊列
# print(l.pop())
# print(l.pop())
# print(l.pop())

# 元組 一級元素不能被修改，刪除和增長
# tu=(11,22,22,33,44)
# print(tu.count(22))#統計22的個數
# print(tu.index(22))#第一個22的索引


# 字典dict
# d1={}
# d2=dict(x=1,y=2)
# d3=dict({'x':1,'y':2})
# 字典的value能夠是任何值
# 字典能夠有多個key，只有後面的纔會生效
#字典的key必須是不可變類型，或者說是可hash類型
# print(hash(1))
# print(hash('xxx'))
# print(hash((1,2,3)))
# print(hash([1,2,3]))
# print(hash({'a':1,'b':2}))
# 列表、字典不能做爲字典的key,布爾值能做爲key,但會和1,0重複，致使沒法顯示
# python中惟一具備映射關係的數據類型： 字典的查詢效率高於列表
# 建立
# d={[1,2,3]:"yuan","name":"egon"}# 鍵惟一且爲不可變數據類型
# d={1:"yuan","name":"egon"}

# 查
# v=d['name']#找不到key會報錯
# print(v)
# v=d.get("names",None)  #推薦,key不存在，返回默認值（None）
# print(v)

# d={5:"yuan","name":"egon"}
# for i in d:
#     print(i)#遍歷keys
#     print(i,"----->",d[i])
#     print("%s---->%s======"%(i,d[i]))
# for i in d.values():
#     print(i)#遍歷value
# for k,v in d.items():
#     print(k,v)#取keys和values
# for i,v in enumerate(list,1):#遍歷列表或字符串的索引和值，1表示索引發始值，可不寫，默認爲0
#     print(i,v)



# 增
d={5:"yuan","name":"egon"}
# d["age"]=123
# print(d)

# 修改
# d[1]=666
# print(d)

# 刪除
# ret=d.pop(5,'None')#刪除d中key值爲5的元素，後面加默認值找不到不會報錯
# print(ret)
# print(d)
# del d[5]#刪除d中key值爲5的元素
# print(d)
# v=d.popitem() #隨機刪一個鍵值對
# print(v)
# d2={"height":123,"sex":"male","name":"alex"}
# d.update(d2)#更新 把d2增長到d，key同樣就覆蓋
# print(d)
# print(list(d.keys()))#查找d全部的key,以列表的形式打印
# print(d.values())#查找d全部的value
# print(d.items())
#已存在，不設置，獲取當前key對應的值
#不存在，設置新的key和value值
# v=d.setdefault('k111','123')
# print(d,v)
#兩種更新方式，已經有的直接覆蓋,沒有的更新
# d.update({'k1':'1111','k3':123})
# print(d)
# d.update(k1=1111,k3=123)
# print(d)
# d6={}.fromkeys(['name','age'],None)#{'name': None, 'age': None}
# print(d6)



# 集合set
# s=frozenset('hello')#不可變集合
# 兩個功能：1 去重 2關係測試
# s1=set([1,3,"hello"])
# s2={1,2,3}
# print(s1)
# print(type(s2))
# print(s.add())#增長一個值
# s.update(s2)#更新多個值
# print(s1)
# print(s1.clear())#清空
# print(s1.copy())#拷貝
# print(s1.remove())#刪除指定元素，不存在會報錯
# print(s1.pop())#隨機刪
# print(s1.discard())#刪除指定元素，不存在不會報錯


#去重：
# l=[1,2,2,34,45]
# s="hello"
# print(set(l))
# print(set(s))

# print({{1,2}:"hello"})#  set是可變數據類型
# print({[]:"hello"})

# s3={1,2,[1,2]}     #  set集合內元素必定是不可變數據類型
# print(s3)

#關係測試
# s1={"hello",1,2,3}
# s2={1,2,("a","b")}

# 取兩者全部的元素：求並集
# print(s1.union(s2)) # {1, 2, 3, ('a', 'b'), 'hello'}
# print(s1|s2)

# 取共同部分：求交集
# print(s1.intersection(s2))# {1, 2}
# print(s1&s2)
# print(s1.isdisjoint(s2))#沒有交集返回True

# 求差集
# print(s1.difference(s2))# {3, 'hello'}
# print(s1-s2)
# print(s2.difference(s1))# {('a', 'b')}
# print(s2-s1)

#對稱差集
# print(s1.symmetric_difference(s2))# {3, 'hello', ('a', 'b')}
# print(s2.symmetric_difference(s1))# {3, 'hello', ('a', 'b')}
# print(s1^s2)#去掉相同的元素而後並集




# 字符串
# 切片
# s='hellowoRld'
# print(s[1:4])    #取第二個到第四個元素
# print(s[1:8:2])   #2 是步長  第二個到第七個每隔兩個取個元素
# print(s[-1])      #取最後一個元素
# print(s[:])    #從頭取到尾
# print(s[:8])    #取到第八個
# print(s[1:-1])   #第二個取到倒數第二個
# print(s[1:])   #第二個取到最後
# print(s[-3:-1])    #取倒數第三個到最後第二個

#查找
# print(s.find('l',5))   #從第5個開始找第一個l的索引  找不到返回-1
# print(s.rfind('l'))   #從右邊開始找第一個l的索引
# print(s.index('e'))#找到元素e的下標  找不到會報錯

# print(s.replace('hello','python',1))  #找到hello，替換成python,替換一次
# print(s.upper())#所有變大寫
# print(s.strip()) #刪除字符串前面和後面的空格和換行符
# print(s.lstrip()) #刪除字符串左邊的空格和換行符
# print(s.rstrip()) #刪除字符串右邊的空格和換行符
# s1="**hello\nworld\n***"
# print(s1)
# print(s1.strip("*"))  #刪除字符串前面和後面的*和換行符
# print(s.startswith('h'))#以什麼開頭，返回布爾值
# print(s.endswith('l')) #以什麼結尾，返回布爾值

# print(s.isidentifier())
# print(s.center(20,'*'))#s居中，*在兩邊，20代指總長度
# print(s.ljust(50,"*")) #左對齊
# print(s.rjust(50,"*")) #右對齊
# print(s.zfill(20)) #右對齊,左邊用0填充
# print(s.capitalize())  #第一個單詞首字母變大寫
# print(s.title())  #每一個單詞的首字母變大寫
# print(s.casefold())  #每一個字母都變成小寫，能處理特殊字符
# print(s.lower())# 每一個字母都變成小寫，只能處理普通字符(英文字母)
# print(s.swapcase())#把大寫變小寫，把小寫變大寫
# print(s.title())#把首字母變大寫

#分割
# print("hello world".split("l",1))    # ["he","lo world"]  l用來分割左右,1是分割次數
# a=s.split("l",3)
# print(type(a)) #類型爲列表
# print("HLLO world".rsplit())   #從右邊開始分割
# print("HELLO\n wor\nld\n".splitlines())    #以\n來分割字符，最後沒有空
# print("HELLO\n wor\nld\n".split("\n"))    #會分最後一個空
# print("HELLo world".zfill(20))      #一共20個字符，前面補0，內容右對齊，字符個數小於自己結果不變

#遍歷
# for i in "hello":
#     print(i)


# 字符串拼接
# s="hello"+"world"+"I"+"am"+"python"
# print(s)
# l=['h','e','l','l','o']
# print(''.join(l))
# 字符串的格式化輸出
# %s:字符串   %d:整型  %f:浮點型
# print('hello %s,%s'%('hehe','haha'))
# print('his age is %d'%25)
# print('hello %s,his age is %d'%('egon',25))
# print('hello %s,his age is %.4f'%('egon',25.1234456))
# print("hello {}, his age is {},sex is {}".format('alex',20,'male'))
# print("hello {0}, his age is {1},sex is {0}".format('alex',20))
# print("hello {name}, his age is {age}".format(age=30,name="egon")) #鍵值對，推薦
# print("hello {name}, his age is {age}".format(**{'age':30,'name':"egon"}))
# print("hello {name}, his age is {age}".format_map({"name":"egon","age":1000})) #字典數據
#判斷是不是數字
# print("一".isdecimal())
# print("一".isdigit())       #不支持負數，經常使用
# print("壹".isnumeric())   #支持最多的

#補充
# str='HEllo'
# sub='l'

# print('hello\tworld'.expandtabs(20))#hello\t一共佔20個
# print(s.count(sub,0,4))#sub在str中在索引[0,4]中存在兩次
# print(s.isalnum())#全部字符都是字母或數字則返回 True,不然返回 False
# print(s.isalpha())#全部字符都是字母則返回 True,不然返回 False
# print(s.islower())#全部這些字符都是小寫則返回 True，不然返回 False
# print(s.isupper())#全部這些字符都是大寫，則返回 True，不然返回 False
# print(s.isspace())#只包含空格，則返回 True，不然返回 False
# print(s.istitle())#判斷首字母是不是大寫，是返回True