小小總結，寫得有些亂
字符串：
字符串常用方法：
# -*- coding:utf-8 -*-
# author:ke_T\
name = "ke_T"
print(name.capitalize()) #首字母大寫,但是不改變name值
print(name.count("k")) #尋找這個字符串中k這個字符串出現的次數
print(name.center(3,"*")) #這個10時一種占的長度，不夠的話，用*補充，夠的話則不用
print(name.endswith("T")) #判斷是否以某字符串結尾
print(name.find("k")) #找到這個字符串的索引，這裏k，返回0
print(name.isalnum()) #
print(name.isalpha()) #判斷是否為英文
print(name.isidentifier()) #判斷是否是合法的標識符，中文也是合法的但是想*這些就不是的，下劃線合法哦
print(name.islower())
print(name.strip()) #忽略空格還有換行符
# s隨機密碼的生成模式
p = str.maketrans("abcd","1903")
print("asdjsd".translate(p)) #生成結果1s3js3
print("kekkq".replace(‘ke‘,‘q‘,2)) #第一個參數，要替換的字符，第二個參數，替換成什麽字符，第三個參數，替換幾個，不寫默認全部替換
#當然，也可以替換字符串
print("kksad aa".rfind(‘a‘)) #找到該字符串最後出現的位置
print("bbq qc".title()) #變成標題的形式，就是首字母大寫
列表：
列表是python中最常見的數據類型，它可以作為一個方括號內的都好分隔值出現，列表中的值不需要是同一個類型。
import copy
names = ["kejinxun","keteng","huangchunxiao","xieyuanyi","liuchenggong","mahuateng"]
print(names[1])#根據下標去數據
print(names[1:2])#根據範圍取出數據,取出的是個列表，這裏取出的列表為[‘keteng‘]，因為這種方式的特點是，取頭不取尾
print(names[1:3][1])#根據範圍取出的列表，再拿數據的方式也就是列表拿數據的方式結果為huangchunxiao
print(copy.copy(names))#列表的復制，引入copy模塊，調用copy函數,淺copy,就是不會獨立的列表，指向同一個內存地址，深copy，則是用copy模塊的copy函數，這樣子會重新開辟一個內存，存放另一個列表
print(names[-3:-1])#負數，從列表右邊往左數起，因此結果為[‘xieyuanyi‘, ‘liuchenggong‘]
print(names[names.index("keteng")]) #keteng,根據元素內容找到下標，然後在通過下標，返回元素
#列表元素的插入
names.append("chenxiaomei")#直接在列表後邊添加元素
print(names)#打印結果為[‘kejinxun‘, ‘keteng‘, ‘huangchunxiao‘, ‘xieyuanyi‘, ‘liuchenggong‘, ‘mahuateng‘, ‘chenxiaomei‘]
names.insert(1,"ke") #按照下標插入
print(names) #打印結果為[‘kejinxun‘, ‘ke‘, ‘keteng‘, ‘huangchunxiao‘, ‘xieyuanyi‘, ‘liuchenggong‘, ‘mahuateng‘, ‘chenxiaomei‘]
#列表元素的刪除
names.remove("ke")#根據名字刪除
print(names) #[‘kejinxun‘, ‘keteng‘, ‘huangchunxiao‘, ‘xieyuanyi‘, ‘liuchenggong‘, ‘mahuateng‘, ‘chenxiaomei‘]
names.pop() #直接移除最後的那個元素
print(names) #[‘kejinxun‘, ‘keteng‘, ‘huangchunxiao‘, ‘xieyuanyi‘, ‘liuchenggong‘, ‘mahuateng‘]
names.pop(1) #移除下標為1的元素
print(names) #打印結果為[‘kejinxun‘, ‘huangchunxiao‘, ‘xieyuanyi‘, ‘liuchenggong‘, ‘mahuateng‘]
#列表常用功能
names.reverse() #反轉
print(names) #[‘mahuateng‘, ‘liuchenggong‘, ‘xieyuanyi‘, ‘huangchunxiao‘, ‘kejinxun‘]
names.sort() #排序,根據Ascii排序
print(names) #[‘huangchunxiao‘, ‘kejinxun‘, ‘liuchenggong‘, ‘mahuateng‘, ‘xieyuanyi‘]
name = [1,2,3]
names.extend(name) #繼承
print(names) #[‘huangchunxiao‘, ‘kejinxun‘, ‘liuchenggong‘, ‘mahuateng‘, ‘xieyuanyi‘, 1, 2, 3]
name.extend(name)
print(name) #[1, 2, 3, 1, 2, 3]
name.append("bbc")
name.append("bbc")
print(name)
print(name.index("bbc")) #只要找到最開始出現的那一次，就退出，並返回該下標
#循環
for i in name: #i指向了name，打印了相當於name[下標的東西]
print(i)
print(name[::1]) #[1, 2, 3, 1, 2, 3, ‘bbc‘, ‘bbc‘]
print(name[1::]) #[2, 3, 1, 2, 3, ‘bbc‘, ‘bbc‘],這樣子的形式，name[i:j:k],
# i表示開始的下標，即表示結束的下標，k表示隔著幾個遍歷，i默認為0，j默認為列表的長度，k默認為1
#列表刪除某個元素
del name[1]
print(3 in [1,2,3]) #查詢某個元素是否在這個列表
字典：
字典是key-value的形式，是Python中的唯一的映射類型，它是無序的，因此像列表那樣不能通過下標來訪問，字典中的鍵是唯一的，值不唯一。特點：
- 鍵與值用冒號:分開；
- 2.項與項用逗號,分開
- 字典的鍵必須唯一
訪問字典的值：
Addict[key]，存在則返回值，不存在則返回keyError錯誤。
修改字典的值：
Addict[key] = 內容，如果存在該key，則會修改該key的值，如果不存在，則會增加這個鍵
刪除字典的值：
和列表一樣，用del addict[key]
更新字典：
info = {
‘001‘: "keteng",
‘002‘: "wuzetian",
‘003‘: "liuchenggong"
}
info2 = {"bbc":[1,2],
‘002‘:{‘c‘:‘cvd‘}}
info.update(info2) #同key的，則改變原字典的，不同的則加入
print(info)
字典的遍歷：
for i in info: #遍歷字典，i指向了key
print(i,info[i])
for k,v in info.items(): #遍歷字典，k指向key，v指向了value
print(k,v)
元組
Python的元組與列表類似，不同之處在於元組的元素不能修改。
元組使用小括號，列表使用方括號。
元組創建很簡單，只需要在括號中添加元素，並使用逗號隔開即可。
訪問元組
元組可以使用下標索引來訪問元組中的值
修改元組
元組中的元素值是不允許修改的，但我們可以對元組進行連接組合，如下
yuzu1 = (1,2,3)
yuzu2 = (2,3,4)
yuanzu3 = yuzu1 + yuzu2
print(yuanzu3)
不過我總覺得沒有多大的意義。
刪除元組
元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組，如下實例:
yuzu1 = (1,2,3)
yuzu2 = (2,3,4)
del yuzu1
print(yuzu1)
輸出之後會報錯哦NameError: name ‘yuzu1‘ is not defined
元組運算符
與字符串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味著他們可以組合和復制，運算後會生成一個新的元組。
|
Python 表達式 |
結果 |
描述 |
|
len((1, 2, 3)) |
3 |
計算元素個數 |
|
(1, 2, 3) + (4, 5, 6) |
(1, 2, 3, 4, 5, 6) |
連接 |
|
(‘Hi!‘,) * 4 |
(‘Hi!‘, ‘Hi!‘, ‘Hi!‘, ‘Hi!‘) |
復制 |
|
3 in (1, 2, 3) |
True |
元素是否存在 |
|
for x in (1, 2, 3): print x, |
1 2 3 |
叠代 |
函數
函數就很重要的啦，函數的形式為def 函數名（），函數還分為無參函數，有參函數，還有缺省函數，匿名函數
無參函數：
def tes1():
這個就是無參函數的表現形式啦
有參函數
def test(a,b):
缺省函數
def test(a,d,b=22,c=33):
print(a)
print(b)
print(c)
print(d)
test(d=11,a=22,c=44)
這個就是缺省函數例子，一定例子要至少輸入兩個參數，因為a,d沒有賦值。
還有傳進的是元組和字典時，需要字符標識
def test(a,b,c=33,*args,**kwargs):#在定義的時候 *,**用來表示後面的變量有特殊功能
print(a)
print(b)
print(c)
print(args)
print(kwargs)
#test(11,22,33,44,55,66,77,task=99,done=89)
def test1(**a):
print(a["name"])
A = (44,55,66)
B = {"name":"laowang","age":18}
test(11,22,33,*A,**B)#在實參中*,**表示對元祖/字典進行拆包
test1(**B)
匿名函數
lambda，匿名函數的聲明
應用實例
infors = [{"name":"laowang","age":10},{"name":"xiaoming","age":20},{"name":"banzhang","age":10}]
infors.sort(key=lambda x:x[‘age‘])
print(infors)
我來解釋下這個例子吧。首先因為列表正常來說是可以用sort直接排序的，但是由於列表中的元素是字典類型，它不知道按照什麽來排序，所以我們需要告訴列表以什麽來排，因此這裏調用匿名函數，lambda x:x[‘age’]返回age的大小，這樣子，就完成了排序。
拓展：
a = [100]
b=[200]
def test2(num,num2):
num +=num
num2 = num2 + num2
print(num,num2)
test2(a,b)
print(a,b)
你覺得輸出結果是什麽呢？
在不了解之前，我想著是輸出
[100, 100] [200, 200]
[100, 100] [200, 200]
但是實際上不是，num+=num並不等於num = num +num,b並沒有改變，因為num2 = num2+num2中，num2+num2是開辟了一個新內存,然後，num2指向了這個新內存。
對象
什麽是對象，車，人，電腦都是對象，應該說一切皆對象。而對象會有屬性，比如人，身高就是他的屬性之一。對象還有方法，這個方法又是什麽呢？比如有的人會遊泳，這個遊泳就是方法，有了遊泳這個方法，這個人的這個對象就會遊泳，會談吉他，則他有會談吉他的方法。
對象的構造方法，構造方法則是對於一個對象的初始化，比如一輛車，制造出來之前是否應該有模型呢？照著這個模型的參數不就可以做出車子。因此通過構造方法初始化對象就是這麽一回事。而構造方法有參數的時候，就是定制不一樣的車子，寶馬和桑塔納能一樣嗎？它們之間因為構造參數的不同，因此造出來的對象不同。好了，我感覺自己扯犢子了，嘻嘻。還是正經點首先說下對象的構造方法，在Python中，一般構造方法的命名有規範，一般在構造函數前後使用兩個下劃線，__init__（）。
覺得對象這裏好像沒有什麽特別要說的，對象添加屬性就是實例化的對象.屬性名 = 什麽，如果存在該屬性名，則更改該屬性的值，如果不存在，則添加新屬性。我覺得有個很需要註意得就是，對象中的函數，都有個self參數，這個代表對象本身，如果修改對象本身的值，則需要self.屬性名 = xxx，以此完成賦值。
忘記了，對象的私有變量也是很重要的。 首先一定要雙下劃線開始，這就代表著定義了一個私有變量，self.__age = 0#定義了一個私有的屬性,屬性的名字是__age
私有方法，則和私有屬性定義一樣，也是雙下劃線開頭，才會被認定為是私有方法。
對象的繼承
繼承是什麽樣的概念？還是以車為例子，是不是所有的車都應該有基礎的屬性，比如車輪子，車身等基礎屬性。而車是不是又會有寶馬，法拉利。我們可以吧寶馬，法拉利看成是普通車子的繼承，寶馬法拉利有基本的車的屬性，但是它又擴展了新的功能。我們可以這麽想，繼承是為了完善。
class Animal:
def eat(self):
print("-----吃----")
def drink(self):
print("-----喝----")
class Dog(Animal):
def bark(self):
print("----汪汪叫---")
這個就是對象的繼承，Animal對象被Dog對象繼承，狗是不是屬於動物類，你要是說動物都會汪汪汪叫，這肯定不對，但是你說動物都會吃，都會喝，這不是動物的基本功能嗎？而繼承，則Dog對象自動繼承了吃喝的功能，它自己又有個新的功能就是汪汪汪叫。隨意要給他增加新的功能。
對象方法的重寫
重寫，只有繼承了對象的對象，然後又定義了它的父類已經擁有的方法，才叫重寫。
這裏舉不出什麽好例子，我就不舉了，嘻嘻。
私有屬性與私有方法的在繼承中的調用
私有的方法，繼承的對象無法繼承。而私有的屬性，也無法直接訪問，只能通過父類的方法調用來訪問私有的對象屬性
# -*- coding:utf-8 -*-
# author:ke_T
class A:
def __init__(self):
self.num1 = 100
self.__num2 = 200
def test1(self):
print("-----test1----")
def __test2(self):
print("-----test2----")
def test3(self):
self.__test2()
print(self.__num2)
def get_num2(self):
return self.__num2
class B(A):
def test4(self):
##self.__test2()
print(self.__num2)
b = B()
b.test4()
比如這個例子，當我想通過繼承的對象調用父類的私有屬性時，就報了錯誤。
多繼承
多繼承則是有多個父類，它有個很需要註意的點，看下面的案例
# -*- coding:utf-8 -*-
# author:ke_T
class Base(object):
def test(self):
print("----Base")
class A(Base):
def test(self):
print("-----A")
class B(Base):
def test(self):
print("-----B")
class C(A,B):
pass
#def test(self):
#
print("-----C")
c = C()
c.test()
print(C.__mro__)
打印結果：
-----A
(<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘__main__.Base‘>, <class ‘object‘>).
__mro函數，打印一個元組，是繼承對象方法調用的層次結構，，而這個順序，就是看繼承的時候的順序，C（A,B），則如果C中沒有重寫的方法調用，則會順著先到A，再到B，再到Base,最後到Object。當然，如果在C（B,A）則從B再到A。當然，在設計類的時候，要盡可能保證這些類中沒有相同的方法。像這樣子的形式，就是要調用B的test方法，那該怎麽辦？想想方法的重寫的調用，就要在A中的test函數寫上B.test(self),這樣就實現調用了
類屬性
類方法
類方法的格式，就需要寫@classmethod,聲明是類的方法，然後傳參的命名是cls，這個是規範命名，當然，你也可以不這樣子命名，不過會覺得你不專業。
靜態方法，也需要標識，@staticmethod 另外，它可以不用傳參。
總結，這次總結得挺亂的，因為知識的多，有點趕，就顯得淩亂。當然，也是學到很多，同時心裏有些浮躁，穩住，加油啦！
小小總結，寫得有些亂