python基礎---（變量、數據類型、在pycharm中查看源碼）

***如何在pycharm中查看源碼：

　　

 

　　　　　　選中方法，Ctrl 加鼠標左鍵，即可打開方法的源碼。

一、變量

1. 定義：把程序運行的中間結果臨時的存在內存里，以便后續的代碼調用。
2. 定義變量的原則：
   1. 只能由數字、字母、下划線組成，數字不能開頭（不能有特殊字符）；
   2. 不能是python環境內的關鍵字
   3. 變量的定義要具有可描述性。
   4. 變量不能是中文。
   5. 不可太長

　　3.Python中查看關鍵字的方法:1.import keyword　　2.keyword.kwlist（獲取所有關鍵字）

　　　　使用keyword模塊查看python關鍵字；使用keyword.iskeyword()，來查看某一個是否

位關鍵字 

常量 

《：在Python中沒有一個專門的語法代表常量，程序員約定俗成用變量名全部大寫代表常量

AGE_OF_OLDBOY = 56》

        定義方式：下划線(age_of_oldboy = 56)；和駝峰法(AgeOfOldboy = 56)

二、數據類型轉換

　　1.　　int和bool數據類型轉換：

　　　　int---->bool　　非0即True

　　　　bool---->int　　True是1；Flase是0

　　2.　　int和str類型轉換：

　　　　所有的int都能轉換成str    123；’123’　　123=str('123')

　　　　只有純數字組成的str，才能轉化成int       s=’123’   int(s)

　　3.　　str和bool類型的轉換：　　#空list ,tuple ,dict的bool值都是False

　　　　str---->bool　　s = bool('')空字符串是False  ;  s = bool('qwe')是Ture。

　　　　bool---->str　　i = str(True/False)  print(i,type(i)) ;　　都是字符串。

　　4.　　字符串的split方法，可以將str----->list

　　　　　join（適用於str、列表、字典等可迭代對象）方法，可以將list等---->str

　　　　　用字符串做一個連接符，鏈接可迭代對象中的每一個元素（每一個元素都必須是str：li = [1,'qwe']就會出錯），形成一個新的字符串。

　　　　　

　　　　5.str與bytes類型的轉換

　　　　str---->bytes　　encode方法；s.encode('utf-8')或('gbk')

　　　　bytes---->str　　decode方法；s.decode('utf-8')或('gbk')

　　　　6.元組與列表的轉換

　　　　tuple--->list　　list(tuple)

　　　　list--->tuple　　tuple(list)

　　　　7.集合與列表的轉換

　　　　set--->list　　list(set)

　　　　list--->set　　set(list)

三、數據類型

　　 基礎數據類型引言：

　　　數據類型的分類：

　　　　　　可變數據型（不可hash）：list,dict.set　

　　　　　　不可變數據（可hash）：int,bool,str,tuple

　　　容器類型：

　　　　　　容器類（承載各種數據類型）：list，tuple,dict

　　 （一）int 運算。+ - * / ** % ...

　　  #bit_lenth 方法

　　　　i = 4

　　　　print(i.bit_lenth())

　　　　# 轉化成二進制的最小位數。

　　  （二）bool：判斷，真假，作為條件

　　  （三）str（字符串） 存儲少量的數據。  操作簡單，便於傳輸。

　　　　1、str的索引與切片

　　　　（索引出來的數據，之前是什么類型，索引出來還是原來的類型；

　　　　　　切片形成的數據，對誰（list，str，tuple）進行切片，之后還是

　　　　　　原先（list，str，tuple）的數據類型）

　　　　　a.字符串的拼接

　　　　　　字符串可以進行相加和相乘

　　　　　b.字符串在內存中的存儲

　　　　　　n="oldboy"　　如果是漢字，編碼不同，則占用的字節不同。

　　　　　　一個字母會占用一個字節，最后加一個'\o'；即n一共占用8個字節。()

　　　　　c.字符中的下標，索引

　　　　　　n="oldboyOLDBOY"  下標是用0開始；n[0]的輸出是"o";n[-1]的輸出是"Y"

　　　　　d.字符串的切片、逆序

　　　　　　[索引初值:索引終值:步長] （默認的步長是1）（原則就是顧頭不顧尾）

　　　　　　n[1:4] 的輸出是“ldbo”

　　　　　　n[2:]第一個：后面什么都不寫，會取到最后一個字符；輸出的是：“dboyOLDBOY”

　　　　　　n[2:-1:2]步長=2，跳一個，取一個；輸出的是：“doODO”

　　　　　　n[::-1]表示逆序，起始值什么不寫，可能是第一個也可能是倒數第一個；如果步長是-1就表示逆序。輸出的是：“YOBDLOyobdlo”。

　　　　2、字符串（str）的使用方法　　(通過查看源碼，學習其他方法)

 1.captalize(首字母大寫)；title(每個單詞首字母大寫)
 2 ps:
 3     s = 'laonahai'         
 4     print(s.captalize())
 5     
 6     s = 'lao nan,hai7is' (以空格數字特殊符號非字母認為是分開的單詞)   
 7     print(s.title())
 8 
 9 2.upper(全部大寫)；lower(全部小寫)
10     s = 'laonahai'         
11     print(s.upper())
12 
13     s = 'laonahai'         
14     print(s.lower())
15 
16 3.swapcase(大小寫翻轉)
17     s = 'laOnaHai'                
18     print(s.swapcase())
19 
20 4.center(20,"$")內容居中，總長度，空白處填充
21     s = 'laonahai'         
22     print(s.center(25,"*"))
23 
24 5.startswith(判斷以什么開頭)；endswith(判斷以什么結尾)
25      s = 'laonahailaonahai'         
26      print(s.startswith('l')   
27      ()內的參數必須是一個整體，不能調隔；可以傳切片（start和end）參數。
28 
29 6.strip(去除首尾的空格，/n ,/t)   lstrip(去除左邊的) rstrip(去除左邊的)
30     s = ' \n laonahai \t '         
31     print(s.strip())
32 
33 7. find(通過元素查找索引)；找不到時會返回一個"-1"
34     index(通過元素查找t(s.startswith('l') 
35      s = 'laonahailaonahai'         
36      print(s. find('l',1,9)      可以傳切片（start和end）參數。
37 8.count(尋找元素出現的個數，可切片)
38      s = 'laonahailaonahai'         
39      print(s.count('l',3,12) 
40 9.replace(替換)
41     s = 'laonahailaonahai'         
42      print(s.count('l','m') 
43 10. split 分割  str ---> list
44      s = 'alex wusir taibai'
45     print(s.split())
46     s1 = 'alex,wusir,taibai'
47     print(s1.split(','))
48     s2 = 'alexawusirataibai'
49     print(s2.split('a'))（會把a干掉）
50     s3 = 'alexawusirataibai'
51     print(s3.split('a',1))  # 分割次數
52 
53 11.format(格式化輸出)
54     三種用法
55     第一種用法：
56     s = '我叫{}，今年{}，愛好{}'.format('MT',18,'母牛')
57     print(s)    **{}中間不能有空格，否則報錯
58     第二種用法
59     s = '我叫{0}，今年{1}，愛好{2}，我依然叫{0},今年還是{1}'\
60     .format('MT',18,'母牛')    **{}內的數字依據format()內的個數來填寫；在這里不能超過2，填3就會報錯。
61     print(s)
62     第三種 鍵值對
63     s = '我叫{name}，今年{age}，愛好{hobby}'.format(age=18, name='MT', hobby='悶兒')
64  
65 12.isalnum,isalpha,isdigit
66     name='123a'
67     print(name.isalnum()) #字符串由字母或數字組成
68     print(name.isalpha()) #字符串只由字母組成
69     print(name.isdigit()) #字符串只由數字組成
70     if name.isdigit():
71         name = int(name)
72         print(name,type(name))
73     else:
74         print('您輸入的由非數字元素')

　　　strip()的注意點：

 

　　（四）list  列表 存放大量的數據，大量的數據放在列表中便於操作。而且列表有序，有索引值，可切片，方便取值

　　　　A.列表定義：

　　　　方法一：names =  [1，2，"qwe"，{"name":"老男孩"},[3.14，55,66]]

　　　　方法二：names =  list('qwer')　　迭代的添加方法；會生成這樣一個列表 ['q', 'w', 'e', 'r']

　　　　方法三：names = list(['qwer',8,9,7])

　　　　B.增刪改查：

復制代碼
增：
1.append：一次只能添加一個，追加到最后一個元素。
2.insert：指定索引位置添加，一次只能添加一個元素。
3.extend：迭代的添加，到列表最后。
刪：
pop：按照索引值刪除，一次只能刪除一個，
remove：按照元素刪除，一次只能刪除一個。
clear：清空列表
del list：刪除列表    /del list[索引值]可切片。
改：
1.[索引值] = new，通過索引賦新值。
2.[切片] = new，通過切片的改回迭代的條件到列表中。
查：
1.[]索引或切片查
2.循環查

補充：
in    not in 判斷列表中是否存在該元素。
復制代碼

刪的pop和remove一側只能刪除一個；切片刪除用 del list[:]

　　　　C.列表的方法：

　　　　　　可以索引值，切片，步長，

　　　　其他操作方法：

　　　　1，sort 從小到大， 正向排序

　　　　　　l1 = [1, 2, 1, 7, 5, 4, 9, 8, 3]

　　　　　　l1.sort()

　　　　2，從大到小，反向排序

　　　　　　l1.sort(reverse=True)

　　　　3.翻轉　　#str或int類型都可以

　　　　　　l1.reverse()

　　　　4.len 長度　　len(l1)

　　　　5.index  通過元素找索引  ；(列表只有index方法；沒有find方法。)

 　　　　D.列表的嵌套：列表再有列表

 　　　　li = [1,2,'alex',['100','wusir',99,[44]],22]　　

　　　　　

li = [1,2,'alex',['100','wusir',99],22]
li[2] = li[2].capitalize()
#print(li)
li[3][1]=li[3][1].upper()
print(li)
li [3][2] = 99+1
print(li)

列表嵌套查詢的方法：li.[索引值][索引值]

　　　　E.在循環一個列表是，最好不要進行刪除操作，（一旦刪除，索引會隨之改變，容易出錯）

　　　　eg：li = [11,22,33,44,55]將索引為奇數的元素刪除。

　　　　方法1：用切片刪除

　　　　　　del li[1::2]

　　　　方法2：定義一個空列表，for循環出每一個奇數元素，添加到空列表中，再賦值給原先的列表。　　li = [11,22,33,44,55]

　　　　　l2 = []

　　　　　for i in range(len(li)):

　　　　　　if i%2==0:

　　　　　　　　l2.append(li[i])

　　　　　　li = l2

　　　　方法3：倒序刪除

　　　　　　for i in range(len(li)-1,-1,-1):

　　　　　　　　if i %2 == 1:

　　　　　　　　　　del li[I]

　　備注：列表中不使用多行注釋

　　　　（五）tuple 元組   只讀列表。(1,2,{"name":"老男孩"})數據可以被查詢，不能被修改。所以，字符串的切片同樣適用於元組。

　　　　A.創建：ages = ()

　　　　　　　　ages = tuple(())

 　　　　兒子不能改，孫子可以改：如果元組中有列表、字典等，可以修改的元素，那么列表等可以進行修改。

　　　　B.常用操作：

　　　　索引，切片，循環，長度，包含（in  not in）

　　　　C.對於元組：如果只有一個元素，並且沒有逗號　　；t = (2)　　<==>t = 2

　　　　　此元素是什么數據類型，該表達式就是什么數據類型。　t = (2,)　則是一個元組　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　（六）dic 字典  存儲關系型的數據，查詢速度非常快，二分查詢。

　　　A.字典的定義：python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，所以字典是無須存儲，（3.5之前；3.6以后的版本，字典在創建的時候，按照一定的順序插入的數值，看起來是有序的。）

　　　B.列表是有序的對象集合，字典是無須的對象集合，兩只之間的區別在於：

　　　　字典當值的元素是通過鍵來存儲，而不是通過偏移存儲。

　　　　　創建：info = {key1:value1,key2:value2}

　　　　　　1.鍵與值用“:”冒號分開

　　　　　　2.項與項用“,”號分開

　　　　　創建方法：1.person = {'name':'les','age',18}

　　　　　　　　　　2.person = dict(name='les','age'=19)

　　　　　　　　　　3.preson = dict({'name':'les','age',18})

　　　　　　　　　　4.dic = dict([("k1", "v1"), ("k2", "v2")])　　有序字典：OrderedDict([("k1", "v1"), ("k2", "v2")])

　　　　　特性：

　　　　　　1.key-value結構

　　　　　　2.key必須可hash，且必須為不可變類型，必須唯一

　　　　　　3.可存放任意多個值，可修改，可以不唯一。

　　　　　　4，無序。（3.5之前；3.6以后的版本，字典在創建的時候，按照一定的順序插入的數值，看起來是有序的。）

　　　　　info= {"name":"班長"，"addr":"山東"，"age":18}

　　　　　　print("%s %d %s"%(info["name"],info["addr"],info["age"]))

　　　　注意：

　　　　　　

 

　　　c.增刪改查：

增：

　　　　第一種：給key賦value（有則覆蓋，無責添加）

　　　　　　dic['key'] = 'value'

　　　　　第二種：.setdeafult（有則不變，無責添加）

　　　　　　　dic.setdefault()

　　　　刪：

　　　　第一種：.pop()　　 有返回值的

　　　　　　dic.pop('key')　　根據key刪除鍵值對，並返回對應的值，如果沒有key則返回默認返回值。eg：print(dic.pop('na','沒有此鍵'))　　如果dic中沒有'na'這個值，后面可以再自己定義一個參數，提示出，沒有'na'這個key值對。


　　　　　第二種：.popitem()　　隨機刪除，有返回值。
　　　　　dic.popitem()
　　　　第三種:.clear　清空
　　　　　dic.clear
　　　　第四種：del　　刪除字典；也可以帶入key,刪除鍵值對
　　　　　　del dic
　　　　　　del dic['key']
　　　改:
　　　　第一種:給key賦value（有則覆蓋，無責添加）
　　　　dic['name'] = '太黑'
　　　　第二種：.update方法　　兩個字典的改，
　　　　dic = {"name":"jin","age":18,"sex":"male"}

　　　　dic2 = {"name":"alex","weight":75}

　　　　dic2.update(dic)  # 將dic所有的鍵值對覆蓋添加（相同的覆蓋，沒有的添加）到dic2中
　　　　　查：

　　　　第一種:print(dic['name'])　　通過key來查看，value

　　　　　第二種：.get方法

　　　　　print(dic.get('name1')) # 默認返回None

　　　　　print(dic.get('name1','咩有此鍵值對')) # 默認返回None

　　　D.其他方法：

　　　　1.keys()　　values()　　items()

　　　　　　print(dic.keys())

　　　　　　#for i in dic.keys:　　#<==>for i in dic:

　　　　　　　　print(i)#　　循環key

　　　　　　keys = dic.keys()

　　　　　　print(keys,type(keys)) 

　　　　　　dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>特殊的字典類列表。

　　　　　　print(dic.vaules())

　　　　　　......

　　　　　　dic.items()　　key.value都打印出來

　　　　2.字典的　　fromkeys(*args, **kwargs)方法：　　*args必須是一個可迭代對象。

　　　　dic = dict.formkeys('abc','alex')　　#會把abc迭代的添加到字典中，對應的每一個值都是'alex'

　　　　dic = dic.formkeys([1,2,3],[])　　#先生成{'1':[],'2':[],'3':[]}

　　　　dic[1].append('老男孩')　　　　#再分別把'老男孩'添加到每一個字典的值中。

　　　　dic[1] = 777　　#則改變的只有dic[1]的值是777；其他都是'老男孩'

v = dict.fromkeys(['k1','k2'],[])
   v[‘k1’].append(666)
   print(v){'k1': [666], 'k2': [666]}
   v[‘k1’] = 777 # 單獨對k1進行賦值
   print(v){'k1': 777, 'k2': [666]}

　　　　　　循環鍵值對

　　　　　　1.for i in dic.items:　　2.for k,v in dic.items():　　　3.　for i in dic:

　　　　　　　　　print(i)　　　　　　print(k,v)　　　　　　　　　　print(i,dic[i])　　

　　　　　　2.長度：len(dict)　

　　　　E.字典的嵌套

　　　　　　dic = {"name_list":['張三','lisi','隔壁王叔叔'],'dic2':{'name':'太白','age':12}}

　　　　　　1 ,給列表追加一個元素：'旺旺'

　　　　　　　　dic['name_list'].append('旺旺')

　　　　　　2,給列表lisi全部大寫

　　　　　　　　dic['name_list'][1] = dic['name_list'][1].upper()

　　　　　　3，給dic2 對應的字典添加一個鍵值對：hobby：girl

　　　　　　　　dic['dic2']['hobby'] = 'girl'

　　　　　　　　dic['dic2'].setdefault('hobby','girl')

　　　　F.在循環字典中，不能增加或刪除此字典的鍵值對。(字典中不能有重復的key，循環添加會被覆蓋)

　　　　eg：dic = {'k1':'value1','k2':'value2','name':'wusir'}

　　　　將字典中含有k元素的鍵，對應的鍵值對刪除。

　　　　解決方法：把包含K元素的鍵，添加到列表中；再循環列表時，刪除鍵值。

li = []
for i in dic:
    if 'k' in i:
        li.append(i)
for i in li:
    del dic[i]
print(dic)

for i in list(dic):
    if 'k' in i:
        del dic[i]
print(dic)

　　　　set 集合  交集，並集，補集...

　　集合是無序的，不重復的數據集合，它里面的元素是可哈希的(不可變類型)，但是集合本身是不可哈希（所以集合做不了字典的鍵）

　　　但是：frozenset不可變集合，讓集合變成不可變類型。也就可以做字典的key了。frozenset轉換之后，里面的還是無序的({'a', 'y', 'b', 'r'})

s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

 　　　　集合的兩個重要應用：

　　　　1.去重，把一個列表變成集合，會自動去除列表的重復元素；

　　　　2.關系測試，測試兩組數據之間的交集，差集，並集等關系。

1.集合的創建、形式

　　創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。　

　　有元素集合set 1= {1,2,3}　　

2.集合的增

set1.add()

set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('景女神')
print(set1)

set1.update()

set1.update('abc')
# set1.update([1,2,3])
# print(set1)

3.集合的刪

set1 = {'alex','wusir','ritian','egon','barry'}

set1.remove('alex')  # 刪除一個元素
print(set1)

set1.pop()  # 隨機刪除一個元素
print(set1)

set1.clear()  # 清空集合
print(set1)

del set1  # 刪除集合
print(set1)

set1.discard('alex')　　<==>  remove

4.集合的其他操作

4.1 交集。（&  或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

　　4.2 並集。（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7}

print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7}

　　4.3 差集。（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

 　　4.4反交集。 （^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

　　4.5子集與超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 這兩個相同，都是說明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 這兩個相同，都是說明set2是set1超集。

集合set的查詢：集合是無許的，只能通過循環的方式查詢。