.1# 數的定義：
#

1.整型：int 如 1

2.長整型 long ,是比較大的整數

3.浮點數float/double 如：1.1

4.複數： a+bj 如1+2j

格式化：

format ---字串拼接

%d,%f,%s 格式化輸出

str()、int()、float()強轉型別函式

#age=int(input('請輸入您的年齡：'))
#print ( age-1)

#強轉化的函式例子
#age=int(input('請輸入您的年齡：'))
#print ( '你的週歲是：'+str(age-1))

#age=input('請輸入你的年齡：')
#print('你的週歲是：'+str(int(age)-1))
強轉型別的函式總結（int、float、str）
1.如果想要將一個整數和浮點與一個字串連線，str()函式比較方便
2.如果有一個些字串，希望將他們用於數值運算，int()函式比較方便
3.如果將一個不能求值為整數的值傳遞給int(),python報錯valueErro.
4.如果需要對浮點數進行取整運算，也可以int（）函式。

#編寫一個程式（可以詢問姓名和年齡，並且告知姓名的字元個數和你明年的年齡）

print('welcome')

name=str(input('what's your name:'))

print('很高興見到你：'+name)

age=int(input('你的年齡：'))

print ('你的姓名字元個數：'+str(len(name)))

print('你明年的年齡：'+str(age+1))

#綜合資料型別-list
列表 list 是處理一組有序專案的資料結構，即你可以在一個列表中儲存一個序列的專案。
常規操作： 訪問列表中的值 、更新列表、刪除列表元素、列表函式&方法。
使用方括號定義列表。  type() 檢視型別

>> str(11)
'11'
>> float(11)
11.0
定義列表：
>> list1=[1,1,2,3,]
>> list1
[1, 1, 2, 3]
檢視型別：
>> type(list1)

>>

訪問列表：

>> len(list1)
4
>> print(list1[2])
2
>> print(list1[1])
1
>> print(list1[0])
1
雙重列表：
>> list2=[1.,2.,3.,4.]
>> list3=[list1,list2]
>> print(list1)
[1, 1, 2, 3]
>> print(list2)
[1.0, 2.0, 3.0, 4.0]
>> print(list3[0])
[1, 1, 2, 3]
>> print(list3[0] [2])
2
>> print(list3[1] [2])
3.0
>> print(list3[1] [2])
3.0
>> print(list3[1] [3])
4.0
>> print(list3)
[[1, 1, 2, 3], [1.0, 2.0, 3.0, 4.0]]
>> list3
[[1, 1, 2, 3], [1.0, 2.0, 3.0, 4.0]]

更新列表：

>> list3[0]=[1,2,3,4,5,6,7,8,]
>> list3
[[1, 2, 3, 4, 5, 6, 7, 8], [1.0, 2.0, 3.0, 4.0]]
>> del list3[0]
刪除列表
>> list3
[[1.0, 2.0, 3.0, 4.0]]
>>

插入資料列表：

>> list1=[1,2,3,4]
>> list1.append('11')
>> list1
[1, 2, 3, 4, '11']

統計元素出現的次數

>> print(list1.count(2))
1
追加列表
>>list1.extend[1,2,3]
>>list1
[1,2,3,4,11,1,2,3]

在定製的索引位置新增元素

>>list1.insert(4,'22')
>>list1
[1,2,3,4,'22',11,1,2,3]

刪除指定座標的元素

>> list1.pop(2)
3
>> list1
[1, 2, 4, '22', 11, 1, 2, 3]
>>

remove移除列表某個值第一次匹配的項

>>list1.remove(1)
>>list1
[2, 4, '22', 11, 1, 2, 3]

方向列表

>> list1.reverse()
>> list1
[3, 2, 1, 11, '22', 4, 2]

排序列表  sort

>> list1.sort()
Traceback (most recent call last):
File "", line 1, in
TypeError: unorderable types: str() 報錯，因為列表有字串，先刪掉字元在排序而python2不會報錯這樣錯的。
>> list1
[1, 2, 3, 11, '22', 4, 2]
指定刪除某個元素
>> list1.pop(4)
'22'
>> list1
[1, 2, 3, 11, 4, 2]
>> list1.sort()
>> list1
[1, 2, 2, 3, 4, 11]
>>

切片：

>> list1=[1,2,2,3,4]
>> print(list1[2:4])
[2, 3]
>> print(list1[1:4])
[2, 2, 3]
>> print(list1[-2:-4])
[]
>> print(list1[-4:-2])
[2, 2]
>>

元祖 tuple
python的元組合列表類似，不同之處在於元組的元素不能修改。
常規操作：
訪問元組、修改元組、刪除元組 、無關閉分隔符、內建函式
2.定義一個值得元祖

>> t2=(9)
>> t2
9
>> type(t2)

定義元祖
>> t3=()
>> type(t3)

>> t1=(1,2,3,4,4)
>> type(t3)

>> t3
()
>> t1
(1, 2, 3, 4, 4)
>>

訪問元組

>> t1
(1, 2, 3, 4, 4)
>> print (t1[1])

修改元組元素 不能修改（保證資料安全），可以先轉化為列表 在修改後在轉元組。

>> egg=('hello',2,3,4,5)
>> egg[1]=99
Traceback (most recent call last):
File "", line 1, in
TypeError: 'tuple' object does not support item assignment

刪除元組

>> del t1
>> t1
Traceback (most recent call last):
File "", line 1, in
NameError: name 't1' is not defined
>>

無關閉分隔符。

>> type(('hello'))

>> type(('hello',))

多元素賦值

>> x,y,z=(1,2,3)
>> print(x，x,y)
1,2,3

例題：
x=2,y=3  進行互換：
1.使用變數，進行賦值

>> x=2
>> y=3
>> z=x
>> x
2
>> z
2
>> x=y
>> x
3
>> y=z
>> y
2

B.使用

>> x=2
>> y=3
>> x,y=(y,x)
>> print(x,y)
3 2

元組的優勢
1.可以用元組告訴所有讀程式碼的人，你不打算改變這個序列的值
如果需要一個永遠不改變的值的序列，就使用的元組
2.因為元組的不可變性，內容不會變化的，python可以實現一些最佳化，讓使用元組的程式碼閉
使用列表程式碼更快。

綜合資料型別-dict

字典-dict

字典是另一種可變容器模型，且可儲存任意型別物件。
常規操作。
訪問字典裡的值
修改字典
刪除字典元素
字典鍵的特性
字典內建函式&方法

-花括號定義 鍵值對形式存在

>> dict={'a':1,b:2}
>> type(dict)

在字典中，鍵是唯一的，如果存在兩個一樣的鍵，後者會替代前者
#鍵不可變得，可以使用數字，字串，元組，但是列表不行
訪問字典

>> print(dict2['a'])
4

如果訪問不存在的鍵，會報錯keyerro.

>> dict1['c']+dict1['a']+dict1['b']
Traceback (most recent call last):
File "", line 1, in
KeyError: 'a'

--->>在列表中不存在的下標不能進行元素的修改。
----》》在字典中可以直接設定一個不存在的鍵，並且給他一個值

>> list1[6]=10
Traceback (most recent call last):
File "", line 1, in
IndexError: list assignment index out of range

>> dict1
{'c': 1, 'b': 2}
>> dict1['a']=dict1['c']+dict['b']
>> dict1
{'c': 1, 'a': 21, 'b': 2}

刪除字典中的元素

>> del dict2['c']
>> dict2
{'a': 4, 'b': 2}

清空：dict2.clear()

>> dict2.clear()
>> dict2
{}

字典函式：
建立一個字典，以序列中的元素作為新字典的鍵，val作為字典的使用鍵的初始值。
dict.fromkeys(seq,val)
如：

>> dict3={}
>> dict4=dict3.fromkeys([1,2,3,4],0)
>> dict4
{1: 0, 2: 0, 3: 0, 4: 0}
>> dict3
{}

當訪問一個不存在鍵會報錯，
為了避免返回錯誤，影響程式正常的執行
dict.get(key,default=value)
返回指定鍵的值，如果鍵不存在，返回default預設值value

>> dict5={'a':1,'b':2}
>> print(dict5.get('b','沒有這個值'))
2
>> print(dict5.get('c','沒有這個值'))
沒有這個值
>>

ID    名字   年齡
1      後裔    24
2      嫦娥   30
3      露露

>> dict1={1:{'ID':'001','名字':'後裔','年齡':24},2:{'ID':'002','名字':'嫦娥','
年齡':30},3:{'ID':'003','名字':'露露'}}
>> print(dict1[3].get('年齡',25))
25

9.與get類似，區別鍵不存在，增加鍵，並賦值。
dict.setdefault(key,value)

>> print(dict1.setdefault('年齡',18))  *與dict1 元素並列了*** .
18
>> dict1
{1: {'名字': '後裔', '年齡': 24, 'ID': '001'}, 2: {'名字': '嫦娥', '年齡': 30, '
ID': '002'}, 3: {'名字': '露露', 'ID': '003'}, '年齡': 18}
>> del dict1['年齡']
>> print(dict1[3].setdefault('年齡',18))    
18
>> dict1
{1: {'名字': '後裔', '年齡': 24, 'ID': '001'}, 2: {'名字': '嫦娥', '年齡': 30, '
ID': '002'}, 3: {'名字': '露露', '年齡': 18, 'ID': '003'}}
>>

判斷字典中是否存在某個鍵

>> dict1
{'a': 0, 'b': 'meiyou'}
>> print('a' in dict1)
True

返回字典中所有的鍵、所有的值。
dict.keys()/dict.values()

>> dict7={0:[1,2,3],1:[2,3,4],2:[4,5,6]}
>> print(dict7.keys())
dict_keys([0, 1, 2])
>> print(dict7.values())
dict_values([[1, 2, 3], [2, 3, 4], [4, 5, 6]])

把字典中鍵/值更新到另一個字典中。
dict.update()

>> dict1_1={'a':1,'b':2}
>> dict1_2={'c':3,'d':4}
>> dict1_1.update(dict1_2)
>> dict1_1
{'a': 1, 'b': 2, 'd': 4, 'c': 3}
>>

資料綜合型別-set&序列、切片
A.序列和分片
str1='my name is leon'
#1.取得name子串

>> str1='my name is leon'
>> print(str1[3:7])
name

>> print(str1[-12:-8])
name
#2.取得leon子串
>> print(str1[11:])
leon
>> print(str1[-4:])
leon

F.集合 set
集合（set）和字典（dict）類似，它是一組key的集合，但不儲存value.
集合的特性就是：key不能重複，唯一。
常用操作：
建立集合
遍歷集合
新增元素
交集、並集、差集

-花括號定義-

>> s1={'a','b','c'}
>> type(s1)

>> s2=set('abc')
>> s2
{'a', 'b', 'c'}
>> type(s2)

訪問 透過迴圈結構
>> for e in s2 :print(e)
...
a
b
c
轉化列表在訪問
>> list1=list(s2)
>> print(list1[0])
a

增加元素

>> s3=set('abcder')
>> s3.add('g')
>> s3
{'d', 'r', 'g', 'e', 'b', 'c', 'a'}
>>
刪除元素
>> s3.remove('a')
>> s3
{'d', 'r', 'g', 'e', 'b', 'c'}

交集、並集，差集
交集

>> set4_1=set('acvsdf')
>> set4_2=set('aacvskk')
>> print(set4_1&set4_2)
{'a', 'v', 's', 'c'}
>>
並集：
>> print(set4_1|set4_2)
{'d', 'k', 'v', 'c', 'f', 'a', 's'}
>>

差集

>> print(set4_1-set4_2)
{'d', 'f'}
>>
>> print(set4_2-set4_1)
{'k'}