小小总结，写得有些乱
字符串：
字符串常用方法：
# -*- 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 copynames = ["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中的唯一的映射類型，它是無序的，因此像列表那樣不能通過下標來訪問，字典中的鍵是唯一的，值不唯一。特點：
?
訪問字典的值：
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 另外，它可以不用傳參。
?
?
? 總結，這次總結得挺亂的，因為知識的多，有點趕，就顯得凌亂。當然，也是學到很多，同時心里有些浮躁，穩住，加油啦！
轉載于:https://www.cnblogs.com/ke-T3022/p/7598443.html
超強干貨來襲 云風專訪：近40年碼齡，通宵達旦的技術人生總結
以上是生活随笔為你收集整理的小小总结，写得有些乱的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： uva 11464 Even Parit
- 下一篇： 【Luogu】P1896互不侵犯King