python 數(shù)據(jù)類型
Python中的數(shù)據(jù)結構的說明
在Python中，不需要提前聲明而涉，當給一個變量賦值的時候就會創(chuàng)建這個值所對應的數(shù)據(jù)類型偎球。并且變量出現(xiàn)在表達式中的時候就會用其值替換斟湃。所以在使用變量的值之前必須對其賦值
類型通用法則：可作用于多種類型的通用型操作都是以內置函數(shù)或表達式的形式出現(xiàn)的[例如 len(X) X[0]]熏迹，類型特定的操作是以方法調用的形式出現(xiàn)的[例如 a.upper()]
Python的類型特點
Python是一種動態(tài)類型的語言，在程序執(zhí)行過程中凝赛，變量名稱會被綁定到不同的值注暗，這些值可以屬于不同的類型。例如：a = 10 賦值運算符的作用僅僅是在名稱和值之間創(chuàng)建的一種關聯(lián)墓猎。盡管每個值都有一個相關類型捆昏，如integer或string，但變量名稱是無類型的毙沾，在執(zhí)行過程中可以引用任意類型的數(shù)據(jù)屡立。
整數(shù)
整型
長整型 long
在py3中已經(jīng)不區(qū)分整型與長整型，統(tǒng)一都叫做整型搀军，也就是說自py2.2起，如果整數(shù)發(fā)生溢出勇皇，Python會自動將整數(shù)數(shù)據(jù)轉換為長整數(shù)罩句。所以在長整數(shù)數(shù)據(jù)后面不加字母L也不會導致數(shù)據(jù)溢出的后果了，甚至Python的int可以存儲任意大小的整數(shù)敛摘，甚至超過64位
浮點型 float
浮點數(shù)用來處理實數(shù)门烂，帶有小數(shù)的數(shù)字，類似于C語言中的double類型兄淫，占8個字節(jié)(64位)屯远，其中52位表示底，11位表示指數(shù)捕虽，剩下的一位表示符號
復數(shù)Complex
復數(shù)由實數(shù)部分和虛數(shù)部分組成慨丐，一般的想形式為x+yj,x為復數(shù)的實數(shù)部分，y是復數(shù)的虛數(shù)部分泄私，x和y都是實數(shù)
布爾類型
計算機中最基本的數(shù)據(jù)類型
布爾只有兩種類型 真（True 注意 Python中的真是大寫字母開頭） 值 或者 假 （False） Python中的布爾是以大寫字母開頭
在Python中True可以用1表示房揭，F(xiàn)lase用0表示
字符串
在計算機中嗜憔，一切皆對象
- 字符串是任意字符的集合
- 字符串在Python中是作為序列府树，序列中的元素包含了一個從左到右的順序，序列中的元素根據(jù)它們的相對位置進行存儲和讀取
- 字符串是單個字符的序列
- 字符串屬于不可變序列這一類型
字符串操作
基本操作
-
使用str() repr() format()函數(shù)可以將非字符串值轉換為字符串表示形式
* str()生成的輸出與使用print語句得到的輸出相同
* repr() 創(chuàng)建的字符串可表示程序中某個對象的精確值
`````` 使用\對一些字符進行轉義
使用+進行拼接
使用*復制
使用[]提取字符
在字符串名后面添加[],并在括號里指定偏移量可以提取該位置的單個字符帚称。第一個的字符的偏移量是0咧纠，下一個是1
>>> str = 'abcdefg'
>>> str[0]
'a'
>>> str[1]
'b'
-
序列操作
- 字符串支持對其中各個元素包含位置順序的操作
str_file = 'span' print(len(str_file)) print(str_file[0])在Python中蓬痒，索引是按照從最前面的偏移量進行編碼的，也就是從0開始漆羔，第一項的索引為0,依次類推
反向索引：反向索引就是從右邊開始計算梧奢，一般來說狱掂，負的索引號會簡單的與字符串的長度相加。
s[-1] # 等效于 s[len(s)+(-1)] -
分片
- 所謂的分片就是一種一步就能夠提取整個分片的方法就是從一個字符串中抽取子字符串的方法粹断。
- X[I:J] 表示取出在X中從偏移量為I直到但不包括偏移量為J的內容
- 在一個分片中符欠，左邊界默認為0,又邊界默認為分片序列的長度。
'''字符串分片操作''' print(str_file[1:3]) print(str_file[1:]) print(str_file[0:len(str_file)]) print(str_file[:1])- 作為一個序列字符串也支持使用加號進行合并瓶埋，或者重希柿。合并使用 ‘+’ 。重復使用 ‘*’
- [:] 提取從開頭到結尾的整個字符串
- [start:] 從start提取到結尾
- [:end] 從開頭提取到end-1
- [start:end] 從start提取到end-1
- [start:end:step]從start提取到end-1每step個字符提取一個
此處注意养筒，區(qū)間不包含尾部曾撤，包頭不包尾，所以為end-1
使用len()獲取長度
我們可以使用字符串的len()函數(shù)獲取字符串的字符數(shù)
字符串不可變性
字符串在Python中具有不可變性——在創(chuàng)建后不能被就地改變晕粪。在Python中 數(shù)字挤悉、字符串、元組這些數(shù)據(jù)類型是不可邊的巫湘。-
字符串find
find方法是一個基本的子字符串查找的操作装悲，它將返回一個傳入子字符串的偏移量，或者沒有找到的情況下返回-1- 格式：
- find(self,start,end)
- self 要查找的子字符串
- 開始的索引位置
- 結束的位置
'''字符串查找find操作'''
print(str_file.find('123', 0, 1))
- 查找最后 rfind
rfind會返回指定查找的字符串最后出現(xiàn)的偏移量
>>> a_z.rfind('x')
23
count返回指定字符串出現(xiàn)的次數(shù)
使用字符串的count方法可以返回要查找的字符的數(shù)量-
replace 全局替換
replace可以將字符串中的目標子字符串替換為新的字符串并返回替換后的全局字符串- 格式
- replace(old: str, new: str,count)
- old str 要被替換的子字符串
- new str 替換的字符串
- count 替換幾次
print(str_file.replace("span", "naps"))
- splite 分割字符串
- 格式
- splite(str) 返回分割后的列表 str:分割符
- str 分割標識
'''分割字符串''' print(str_file.split('12')) - join()合并字符串
使用join()需要首先指定粘合用的字符串尚氛，然后再指定需要合并的列表
>>> crypto_list = ['a','b','c','d','e']
>>> copy_str = '.'.join(crypto_list)
>>> print(copy_str)
a.b.c.d.e
-
rsplite
- 按照指定的分隔符诀诊，并指定最大分割數(shù)
- 并且以從右邊分割為準
-
大小寫轉換
- upper() 轉換為大寫
- lower() 轉換為小寫
- capitalize() 把第一個字母轉換為大寫，其余小寫
- title() 把每個單詞的第一個字母轉換為大寫阅嘶，其余的小寫
- swapcase()將所有字母的大小寫轉換,小寫變大寫
a_z.swapcase() 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' str_change = "hello i am hero" # 轉換為大寫 print(str_change.upper()) # 轉換為小寫 print(str_change.lower()) # 首字母大寫 print(str_change.capitalize()) # 按照標題轉換 所有單詞首字母大寫其余小寫 print(str_change.title()) -
排版操作
- 居中 center() 返回一個使用指定字符填充至指定長度的的新字符串
>>> test_a = 'abc'
test_a.center(10,'x')
'xxxabcxxxx'
* 左對齊 ljust(width,fillchar) 返回一個使用指定字符串填充至指定長度的左對齊的新字符串
test_a.ljust(20,'v')
'abcvvvvvvvvvvvvvvvvv'
* 右對齊 rjust(width,fillchar)返回一個使用指定字符串填充至指定長度的右對齊的新字符串
test_a.rjust(20,'c')
'cccccccccccccccccabc'
* 占位符操作
'''占位符'''
print('%s , is ,%s,a ,str' % ('a', 'b'))
* 字符串包含在單引號或者是雙引號中代表相同的東西属瓣，字符串包含在三引號中是，所有的行都合并在一起讯柔，并在每一行的末尾增加換行符
* 去掉反斜線raw
python支持原始字符串常量抡蛙，即去掉反斜線轉義機制
* 模式匹配
* 字符串模式匹配使用正則表達式需要導入一個re的模塊。
import re
match = re.match(格式);
mathc.group(1)
* 判斷子字符串是否存在
if '123' in '123abc':
print('yes')
* join拼接
str.join(str1)
* join的參數(shù)是一個iterable 可以使用列表 元組
* 將str拼接到str1的每一項后面
a = 'a'
b = a.join("1234567")
print(b)
輸出結果
1a2a3a4a5a6a7
* 填充字符
center 以指定的字符填充到字符數(shù)
a = 'abcde'
print(a.center(20, '*'))
結果
*******abcde********
* 判斷是否以某個內容結尾
endwith(str)
print(a.endswith('e'))
* 判斷是否以某個內容開頭
* startWith(str)
print(a.startswith('a'))
* 格式化輸出 format
a = 'my name is {name}'
print(a.format(name='kkk'))
輸出結果
my name is kkk
* 字典形式 format_map
a = 'my name is {name}{age}'
print(a.format_map({'name': 'wx', 'age': 22}))
* isalnum() 判斷字符串是否是字母或者數(shù)字的字符串
* isdecimal() 判斷是否是10進制的數(shù)
* isdigit() 判斷是否是一個數(shù)
* islower() 判斷是否全部小寫
* isupper() 判斷是否全部大寫
* isspace() 是否全部是空格
* lower() 大寫變小寫
* upper() 小寫變大寫
* swipecase() 大寫變小寫 小寫變大寫 反轉
* strip() 去掉兩端的空格和換行符
* rfind(str) 找到從右開始的第一個str的真實索引值
*
#### 列表
* 列表是一個任意類型的對象的位置相關的有序集合魂迄。是序列的一種
* 沒有固定大小
* 支持字符串序列的所有操作粗截，返回的結果往往還是列表，支持索引极祸，切片等操作
* Python的列表沒有固定類型的約束慈格，一個列表中可以存在多種數(shù)據(jù)類型的元素
* 由于列表沒有固定大小，所以Python會對列表進行邊界的檢查
* 列表可以修改
L = [1, 2, 3, 4, 5]
print(L[0])
print(L[:-1])
print(L + [6, 7, 8])
print(L + ['aaa', 'bbb'])
##### 列表類型特定的操作
> 列表的特定操作都會就地改變列表對象遥金，而不是創(chuàng)建一個新的列表
* append 在列表的末尾增加一個數(shù)據(jù)項
append擴充列表的大小并在列表的尾部插入一項元素
L.append('abc')
print(L)
* extend 在列表末尾增加一個數(shù)據(jù)集合
list = ['a', 'b', 'c']
list.extend(['d', 'e', 'f'])
print(list)
* pop
pop移除給定偏移量的一項浴捆，從而減小列表大小,不指定索引將會刪除最后一個數(shù)據(jù):pop(0)將返回列表元素的頭部，pop()或pop(-1)則會返回列表的尾部元素
L.pop(2)
print(L)
* insert
在列表指定偏移量出插入元素
L.insert(1, True)
print(L)
* index() 查詢具有特定值得元素位置
list = ['aaa','bbb','ccc','ddd']
list.index('aaa')
0
* 使用in判斷值是否存在
可以使用in來判斷是否存在在指定的列表中
'bbb' in list
True
* remove
按照指定值刪除元素
L.remove("abc")
print(L)
* count 記錄特定值出現(xiàn)的次數(shù)
list.count('aaa')
2
* sort
按照升序對列表進行排序稿械，返回一個新的列表选泻，會對原列表進行排序，會改變原列表的內容
L.sort()
降序
ks.sort(reverse=False) # 默認false
* sorted會返回排好序的列表副本，原列表內容不變
list_sorted = sorted(list)
list_sorted
['aaa', 'aaa', 'bbb', 'ccc', 'ddd']
* 改變排序行為
我們可以指定sort的排序行為页眯，我們可以使用name=value
* reverse 允許排序按照降序而不是升序進行
```
L = ['abc','abC','ABC']
L.sort(key=str.lower)
```
> 在Python3中梯捕，不再支持這種排序，所以建議使用內置的sorted方法
list = ['abc', 'Abc', 'ABC']
print(sorted(list, key=str.upper, reverse=False))
* reverse
對列表進行翻轉
L.reverse()
* clear()
清除列表所有數(shù)據(jù)窝撵，但并不刪除列表
* del 列表[index] 刪除列表(直接刪除內存地址的指向)
##### 列表的嵌套
由于列表支持任意的嵌套傀顾，能夠以任意的組合對其進行嵌套，并可以多個層次進行嵌套碌奉《淘可以實現(xiàn)多維數(shù)組等復雜數(shù)據(jù)類型
##### 列表的解析
* 先來一個2*2的矩陣
LL = [[1, 2], [3, 4]]
* 運用列表解析表達式 取出第一行數(shù)據(jù)
col = [row[1] for row in LL]
> 列表表達式是一種通過對序列中的每一項運行一個表達式來創(chuàng)建一個新列表的方法，每次一個從左到右赐劣。
> 列表解析是卸載方括號中的嫉拐，并且由使用了同一個變量名的表達式和循環(huán)結構組成
#### 字典
* Python中的字典是一種映射。映射是一個其他對象的集合魁兼。通過鍵來進行存儲
* 字典是Python核心對象集合中唯一的一種映射類型婉徘。也具有可變性
* 格式
* directory = {"key",value,"key2","value2"}
* 保存在字典中的項沒有特定的順序，Python字典采用最優(yōu)化的散列算法來尋找鍵咐汞，因此搜索是很快速的盖呼。
##### 映射操作
* 作為常量編寫時，字典編寫在大括號中化撕，并且包含一系列的“鍵：值”對
D = {'name': 'wx', 'age': 12, 'phone': 1366666666}
我們可以通過索引來操作字典塌计，通過索引操作使用的是和序列相同的語法，在方括號中填寫的是元素的鍵侯谁，而不是相對位置索引
print(D['name'])
##### 字典的創(chuàng)建方式
1
D = {}
D['name'] = 'hello'
D['age'] = 20
D['phone'] = 123456
print(D)
2 函數(shù)
dic2 = dict((('key','value'),))
3. 創(chuàng)建時初始化值
dic_test = dic.fromkeys(存放所有的鍵，對應鍵的值)
dic_test = dic.fromkeys(['a','b','c'],0)
輸出結果
{'a': 0, 'b': 0, 'c': 0}
##### 添加內容方式
setDefault 在key不存在的情況下會添加key-value的默認值章钾，如果key存在則不會修改墙贱，并且會返回已有的值
如果key不存在的情況，在字典里增加鍵值對并返回相應的值
setdefault('key','value'
* 使用[key]添加或修改元素
向字典中添加元素只需指定該元素的鍵并賦予相應的值即可贱傀。如果該元素的鍵已經(jīng)存在于字典中惨撇，那么該鍵對應的舊值會被新值取代。如果該元素的鍵并未在字典中出現(xiàn)府寒，則會被加入到字典中
pyhons
{'cleese': 'john', 'chapman': 'graham', 'idle': 'eric'}
pyhons['wx']='niubi'
pyhons
{'cleese': 'john', 'chapman': 'graham', 'idle': 'eric', 'wx': 'niubi'}
pyhons
{'cleese': 'john', 'chapman': 'graham', 'idle': 'eric', 'wx': 'niubi'}
pyhons['chapman']='ahahaha'
pyhons
{'cleese': 'john', 'chapman': 'ahahaha', 'idle': 'eric', 'wx': 'niubi'}
* 字典的鍵必須不相同魁衙，如果創(chuàng)建字典時同一個鍵出現(xiàn)了兩次，后面出現(xiàn)的值會取代之前的值
##### 查
1. 通過鍵去查找 keys() 獲取的字典的key也是無序的
dict_a = dict((('a', 'b'), ('c', 'd')))
print(dict_a['a'])
2. 查找所有對應的值 value(),會返回字典所有的值
pyhons.values()
dict_values(['john', 'ahahaha', 'eric', 'niubi'])
3. 查找所有的元素 items(),可以獲取字典中所有的鍵值對
dict_a = dict((('a', 'b'), ('c', 'd')))
print(dict_a.items())
> 以上3中查找元素的方法在Python3.0中已經(jīng)被修改為返回一個可迭代的對象株搔，而不是列表剖淀，所以在Python3.0中使用的時候需要將可迭代對象轉換為列表
dict_a = {'a': 'b', 'c': 'd', 'e': 'f', 'h': 'g'}
print(list(dict_a.keys()))
print(list(dict_a.values()))
print(list(dict_a.items()))
4.通過get()方法避免misskey錯誤
在字典中可以通過get(key,default)來獲取指定Key對應的value值，如果key不存在則返回默認值default
dic = {'a':'b','c':'d'}
print(dic.get('a','default'))
4. 查看列表的長度 len()
len()是內置方法纤房，同樣適用于字典纵隔，len()會返回字典的元素數(shù)目或者是keys集合的長度
##### 改
* 通過鍵修改
dict_a = dict((('a', 'b'), ('c', 'd')))
dict_a['a'] = 22
print(dict_a)
* update可以將一個字典的鍵值對復制到另一個字典中去方法指定具體的鍵值，如果鍵值不存在則增加這個鍵值對，如果鍵存在則修改更新這個值
* 格式
```
a.update(b) 將b字典合并到a字典中
```
c_pro = {'type':'language','hard':1}
pyhons.update(c_pro)
pyhons
{'cleese': 'john', 'chapman': 'ahahaha', 'idle': 'eric', 'wx': 'niubi', 'type': 'language', 'hard': 1}
* setdefault(k,v) 如果找到字典中的k鍵對應的值則返回捌刮，否則返回v 并將字典中k鍵對應的值設置為v
print(dic.setdefault('aa', 0))
print(dic)
{'a': '1', 'b': 'abcdef', 'c': 1234, 'aa': 0}
##### 刪
1. clear() 刪除字典所有元素
> 使用clear()可以將字典中所有元素刪除
dirc_a.clear()
2. 刪除字典某一個鍵對應的值 del
del dic4[鍵名]
3.刪除指定鍵值對并返回該鍵值對的值碰煌，如果不指定會刪除最后一個，并返回刪除的這個值
dict_a.pop(key)
4.隨機刪除一個
dict_a.popitem()
5. 刪除整個字典
del dict_a
#### 查
##### 字典重訪嵌套
human_info = {'name': {'last': 'wx', 'first': 'xw'}, 'age': 18, 'age': 40.5,
unit: {'abc': 123, '1': '234', True: False}}
print(human_info[unit])
print(human_info[unit]['1'])
##### 字典的遍歷
> 字典不是序列绅作，并不包含任何可靠的從左到右的順序芦圾，但是如果希望字典的鍵是順序的
可以通過字典的keys方法收集一個鍵的數(shù)據(jù)，有點像但并不是列表俄认，然后使用sort進行排序
dir_keytest = {'a': 1, 'e': 2, 'c': 3, 'd': 4}
ks = list(dir_keytest.keys())
ks.sort()
print(ks)
* 在新版的Python中个少，可以使用最新的sorted調用返回結果并對各種對象類型進行排序
key_list = sorted(dir_keytest)
for i in key_list:
print(i)
##### 查詢字典中的鍵是否存在
* 查詢字典中的一個鍵是否存在
* 格式
* 鍵值 in 字典
> 在3.0中已經(jīng)取消了2.x中的判斷一個鍵在字典中是否存在的has_key方法，而在3.0中使用in來判斷鍵是否在字典中存在
if 'f' in D:
print('鍵值存在')
else:
print('鍵值不存在')
* python 2.x has_key
在python2.x中存在has_key方法用于判斷字典中的指定的鍵是否存在梭依，但這個方法在python3中不可用
##### 使用[key]獲取元素
可以指定字典名稱和鍵名即可獲得對應的值
* 格式
dict[key]
##### 使用get()獲取鍵
可以使用get(鍵)獲取鍵在字典中的值稍算，#如果指定了可選值，那么get()函數(shù)將返回這個可選值役拴，否則會返回None
pyhons.get('wx')
'niubi'
pythons.get('cleesea','123')
'123'
##### 使用keys()獲取所有的鍵
使用keys()可以獲得字典中的所有鍵,keys()會返回一個列表糊探。python3中會返回dict_key(),是鍵的迭代形式，這種形式不需要時間和空間來創(chuàng)建返回的列表,在python2中會返回一個列表
pythons.keys()
dict_keys(['cleese', 'chapman', 'idle', 'wx', 'type', 'hard'])
##### 使用items() 返回由(key,values)對組成的一個序列
#### 元組
* 元組是任意對象的有序集合
* **不可改變的列表河闰，也就意味著長度不能增長或者縮短**
* 元組是序列科平，具有不可變性
* 編寫在圓括號中，支持任意類型任意嵌套以及常見的序列操作
* 格式
* tupple = (item1,item2)
* 創(chuàng)建包含一個或多個元素的元組時姜性，每一個元素后面都需要跟一個逗號瞪慧，即使只包含一個元素也不能省略
one_marx = 'abcde',
type(one_marx)
<class 'tuple'>
one_marx
('abcde',)
##### 特定類型方法
* 在Python3中，元組有特定的方法
* index(i) 獲取指定元素的索引
* count(i) 獲取指定元素在元組中的個數(shù)
##### 創(chuàng)建
* 直接創(chuàng)建
tumple_test = (1,2,3,4,5)
* 通過可迭代對象創(chuàng)建
tuple_Test = tuple('1234')
print(tuple_Test)
* 如果圓括號內的單一對象是元組對象而不是簡單的表達式需要對Python進行說明部念，需要在這個元素后弃酌，關閉括號之前加入一個，（逗號）
x = (40)
out
40 # int type
x = (40,)
out
(40,) #tuple type
##### 元組解包
我們可以一口氣將元組賦值給多個變量儡炼，這樣的操作我們稱為元組解包,這個解包中接收的變量要和元組的元素相等
list_sorted
['aaa', 'aaa', 'bbb', 'ccc', 'ddd']
a,b,c,d,e = list_sorted
a
'aaa'
b
'aaa'
c
'bbb'
d
'ccc'
e
'ddd'
###### 增
* 通過序列操作擴充元組
(1,2)+(3,4)
out
(1,2,3,4)
> 由于元組不可變妓湘，所以通過序列的操作會返回一個新的元組
> 元組不支持字符串和列表的方法，如果需要使用使用需要將元組轉換為列表
* 對元組排序
tuple_sort = (3, 5, 6, 4, 2, 1, 5, 6)
list = list(tuple_sort)
print(sorted(list))
### 文件類型
* 文件對象是Python對外部文件的主要接口
* 沒有特定的常量語法創(chuàng)建文件
* 需要調用內置的open函數(shù)以字符串的形式傳遞給它一個外部的文件名以及一個處理模式的字符串
* 在當前文件夾下創(chuàng)建文件乌询，并向它寫入文本
* ‘w’ 寫文件 ‘r’ 讀文件 默認讀取
f = open('data.txt', 'w')
f.write("hello\n")
f.write("hi\n")
f.write("how are you\n")
f.close()
* 讀取文件
f = open('data.txt', 'r')
text = f.read()
print(text)
### 集合
* 集合是唯一的不可變的對象的無序集合榜贴。集合是無序的，也無法通過數(shù)字進行索引妹田。集合中的元素不能重復
* 集合不提供索引或切片操作唬党，也不存在相關的鍵值
* 集合通過調用內置set函數(shù)創(chuàng)建
* 可變集合set是非哈希的，不能用作字典的鍵
* 集合的元素都是不同的鬼佣，相同的元素會只保留一個
* 集合分為兩種集合：set是可變集合驶拱，frozenset不可變集合，不可以添加刪除
#### 創(chuàng)建方式：
x = set('ABCabc')
Y = {'a', 'b', 'c'}
print(x, Y)
* 將字典作為參數(shù)傳入set()函數(shù)時只有鍵會被使用
#### 向集合中添加新項
使用add()或update()可以在集合中添加新項
s = set([3, 5, 9, 1, 2, 7])
使用add向集合添加新項
s.add(20)
print(s)
使用update向集合中添加新項
s.update([22])
print(s)
* add向集合中添加一項
* update(iterable) 向集合中添加多項晶衷，這里添加的是可迭代的對象
#### 使用in測試值是否在集合中存在
* 交集 intersection **&** 返回兩個集合相同的部分
s = set([1,2,3,4,5,6])
s1 = set([5,6,7,8,9,0])
s.intersection(s1)
s&s1
* 并集 union **|**
s = set([1,2,3,4,5,6])
s1 = set([5,6,7,8,9,0])
s.union(s1)
s | s1
* 差集 **-**
s = set([1,2,3,4,5,6])
s1 = set([5,6,7,8,9,0])
s.difference(s1)
s-s1
* 對稱差集 (項在t或者s中屯烦，但不會同時出現(xiàn)在二者中) **^**
s1=set([1,2,3,4,5])
s2=set([2,3,4,5,6])
print(s1.symmetric_difference(s2))
s1^s2
* 父集 超集 **a>=b**
print(a.issuperset(b))
a>=b
* 子集 **a<=b**
a.issubset(b)
a <= b
### 數(shù)字
python中的數(shù)字分為
* 整數(shù)和浮點數(shù)
* 復數(shù)
* 固定精度的十進制數(shù)
* 有理分數(shù)
* 集合
* 布爾類型
* 無窮的整數(shù)精度
* 各種數(shù)字內置函數(shù)和模塊
### Python中的進制表示
* Python一般以10位基數(shù)也就是10進制的記數(shù)法來記錄數(shù)字
* 各種進制的格式
* 十六進制 0xff
* 八進制 0o 或者0O 0o1
* 二進制 0b
* python提供了轉換為其它進制字符串的內置函數(shù)
* oct 將十進制轉換為八進制
* hex 將十進制轉換為十六進制
* bin 將十進制轉換為二進制
* int 將一個數(shù)字的字符串變換為一個整數(shù)坷随，并且可以通過第二個參數(shù)來確定變換后的進制
```
int('64',16) 將表示64的字符串表示為2進制的整數(shù)
```
## 可變與不可變對象分類
