輸出與輸入
數據類型
變量和常量
條件語句，循環語句
列表(list),元組(tuple)，字典(dict),集合(set)
函數
面向對象(類)
輸出與輸入：
輸出：
1.print("…")這裏面可以是單引號，可以沒有括號(老版的)。
2.還可以連續輸出，只需要在前一個輸出結果加一個逗號就行：print“。。。”，“。。。”.
3.還可以輸出表達式的結果print 4+2
4.可以輸出不同類型的結果：print “你好：”,4+2。
輸入：
自帶一個raw_input()函數，並且可以把輸入的結果放到變量當中：language=raw_input(“please input your best language:”),括號裏爲輸入之前打印的話，但是它返回的是字符串類型，索引當我們想要其它類型的時候（比如說int類型），我們就可以a=int(input()).
數據類型
數據類型：整數，浮點數（小數），字符串：單引號或者雙引號括起來的，布爾，空值
注意：對變量進行聲明的時候不需要標註聲明數據類型，系統會自動識別，比如說我聲明一個整型的數等於十：a=10，而不是int a = 10。它與c++差別比較大。
1.整數之間運算結果是整數，整數與浮點數運算時結果是浮點數，但會出現四捨五入的情況。
2.轉義字符：print(‘hello’ world’),這個時候裏面的單引號和外面的衝突了，而這個時候想輸出單引號，那麼必須用轉義字符\，雙引號也是如此。\n表示換行，當我們要寫多行時，就可以使用三個單引號。
3.布爾類型：True,False.
4.布爾運算：通過比較運算出來的值，比如說3>2就是一個True類型。
5.與或非：and，or，not
6.字符串：
常見方法：
center：通過在兩邊填充字符（默認爲空格），讓字符串居中。center（39）：通過填充字符，讓字符串長度變爲39
center（39，’’），填充字符變爲’’。
find:在字符串當中查找字串，如果找到，就返回字串的第一個字符的索引，否則返回-1.
join:用於合併序列的元素成一個字符串：
seq=[‘1’,‘2’,‘3’,‘4’,‘5’]
sep=’+’
sep.join(seq)
最終變成’1+2+3+4+5’
lower：返回字符串的小寫版本,x.lower()。
replace：將指定字串換成另一個字符串：replace(‘is’,‘hello’),is爲字串，hello爲替換字符串。
split：將字符串分解成一個序列：
‘1+2+3+4+5’.split(’+’)-------->[‘1’,‘2’,‘3’,‘4’,‘5’]
strip：將字符串開頭和末尾的空白但是不包括中間的空白刪除，並且返回刪除後的結果。
字符串.strip()。
當然這個還可以指定刪除哪些字符或者字符串，strip(’*’)。
變量和常量
1.變量：不僅僅時數字，還可以是各種數據類型：str=“你好”，其必須是數字，大小寫英文和—的仁義組合。變量在定義是不能用數字或者特殊的字符開頭。原理舉例：定義一個字符串變量時，會在內存開闢一個空間，並且讓該變量指向這個空間。
2.常量：就是不能被改變的量，比如說PI就是圓周率，它本身是不能被改變的。
條件語句，循環語句
1.if語句：if+條件+冒號+實現語句：if num>0: print(‘hello world’) //冒號後面最好換行並且縮進一格
2.else語句：else：實現語句
3.if else語句連續使用：
舉例：if num>0:
…
elif num<0:
…
else:
…
需要注意縮進！！！！
4.更加複雜的條件語句：
a.比較運算符：相等運算符(==)，相同運算符(is)(注意這裏的is運算符是檢測兩個變量是否相同，而不是相等，更加嚴謹)
成員資格運算符(in)：比如說name當中的n就是name當中的成員，即爲n in name爲真。
5.循環語句：
a.while語句：while+條件：
執行語句(執行語句之間縮進必須一樣，並且比while縮進要多)
舉例：while x<100:
print(x)
x++;
b.for語句：舉例：
words = [“this”,“that”,…]
for word in words:
print(word)
c.跳出循環：break
列表(list),元組(tuple)，字典(dict),集合(set)
列表，元組，字典，集合都是python裏面的數據結構，最基本的數據結構爲序列。列表可以修改但是元組不可以。
1.序列：
a.索引：通過使用編號來訪問各個元素，但是一次只能訪問單個元素
舉例：greeting =“hello”
我們可以通過greeting[0]來訪問h字符，python裏面的序列都是從零開始的，當然也有一些特殊之處，就是索引還可以爲負數，比如說：greeting[-1]就是最後一個字符o。
b.切片：可以一次性訪問特定範圍內的多個元素。
舉例：name=[1,2,3,4,5,6,7,8,9]
name[3:6]就是訪問name序列當中的第四個到第六個元素，後一個索引6不在範圍內。
注意：執行切片操作的時候，如果第一個索引指定的元素位於第二個指定元素的後面，結果就爲空序列。
如果第一個索引位於序列開頭，那麼可以省略：name[:6]訪問第一個到第六個元素。
c.序列相加：通過加法運算來實現序列拼接：[1,2,3]+[4,5,6]=[1,2,3,4,5,6].
d.序列乘法：當序列與數x相乘的時候，將會重複這個序列x次，比如說：[42]*5就是[42,42,42,42,42]
2.列表：
a.list函數：list(“hello”),直接建立一個[‘h’,‘e’,‘l’,‘l’,‘o’].
b.修改列表：直接找到索引賦值就可以了
舉例：x=[1,1,1]
x[1]=2
那麼x列表就會變成[1,2,1]了。
c.刪除元素：使用del語句。
舉例：names=[“Peter”,“Zam”,“Lisa”]
del names[1]
最終names變成[“Peter”,“Lisa”].
d.給切片賦值:
舉例:name=list(“hello”)
name[2:]=list(“y”)
最終列表會變成：[‘h’,‘e’,‘y’]
此功能還可以實現插入：
number=[1,5]
number[1:1]=[2,3,4]
最終列表變成[1,2,3,4,5].
還可以實現刪除：
舉例：
number=[1,2,3,4,5]
number[1:4]=[]
最終列表變成[1,5]。
e.列表方法：
len():獲得列表的長度，len(x)
append：將一個對象加到列表末尾，如：
lst = [1,2,3]
lst.append(4)
最終列表變成[1,2,3,4]，把4這個數加到了列表的後面。
clear:清空列表,如：
lst=[1,2,3]
lst.clear()
最終列表被清空，變成[]。
copy：複製列表,如：
a=[1,2,3]
b=a.copy()
於是我們就把a列表裏面的內容複製到了b列表當中。
count：計算指定的元素在列表當中出現了多少次，如：
x=[1,2,3,4]
x.count(1)
表示1在count當中出現了一次。
extend：將多個值加到列表末尾，如：
a=[1,2,3]
b=[4,5,6]
a.extend(b)
於是a列表就變成了[1,2,3,4,5,6]。但是其與拼接不一樣，其是直接修改列表，而不是創建一個新的列表，效率比拼接高。
index:在列表當中查找指定值第一次出現的索引，如，name.index(‘h’),就是查找h在name裏面第一次出現的索引。
insert：將一個對象插入列表：
number=[1,2,3]
number.insert(1,‘four’)
列表變成了[1,‘four’,2,3]。
pop：從列表當中刪除一個元素，默認爲最後一個元素，並且返回該元素：
x=[1,2,3]
print(x.pop())
結果就是3，並且列表變成了[1,2]。
或者：
print(x.pop(0))
刪去了第一個元素，結果是1，並且列表變成了[2,3]。
remove：刪去第一個爲指定值的元素。remove(指定值)
reverse：倒序。
sort()：把列表排序（不返回任何值，就是把列表給修改了），但是sorted可以：x.sort(),sorted(x).,默認爲升序。
3.元組：
元組是不可修改的,tuple裏面的元素可以是任何類型。
a.其實元組的創建很簡單，就是把一些值用逗號隔開，然後元組就可以自動創建了：x=1,4，x就是一個元組。或者可以用小括號
b.turple函數：以一個序列作爲參數，將其轉換爲元組，如果序列已經是元組，那麼就原封不動的返回即可。
turple([1,2,3])------>(1,2,3)
turple(‘abc’)-------->(‘a’,‘b’,‘c’)
index：返回指定值的索引：x.index(元素)
注意：
定義一個空的tuple，可以寫成(),但是空的tuple不是None，即爲空值。
定義一個元素的元組時，要寫成(x,)，而不能寫成（x）
不可以改變tuple裏面的成員，但是tuple成員本身可以改變：
s=(1,2,[1,2])
s[2]=“hello"會報錯
s[2][1]=3不會報錯表面上看，tuple元素的確改變了，但是其實變的不是tuple的元素，而是list裏面的元素，tuple一開始指向的list並沒有改成其他的list，指向還是原來的指向，我們可以稱之爲所謂的"不變”
tuple不可變，比較安全，儘量能用tuple替代list就替代list
4.dict字典：
字典由鍵和值組成，鍵-值對稱爲項。鍵與值之間用冒號隔開，用花括號括起來。
比如說{1:‘peter’,2:‘lisa’}就是一個字典。但是dict成員的數據順序和我們定義的順序不一定一樣，我們刪除項的時候只需要刪除鍵。
a.dict不可以通過下表（索引）來訪問，只能通過鍵。
b.用pop函數刪除，x.pop(鍵)
c.修改鍵對應的值的時候，就是用鍵訪問的時候賦值，但是鍵不能夠改變，而且字典裏的鍵是唯一的，不能重複。
x={1:‘a’,2:‘b’}
刪除：x.pop(1)。
修改：x[1]=‘c’。
d.鍵必須可以hash，鍵是一個常量。
e.get方法：判斷鍵是否存在：
x.get(1),鍵中是否有1，若不存在，則返回None。
x.get(1,“key not exist”)，若不存在，輸出後面的提示信息。
f.對dict成員的key進行增加，刪除操作的時候，dict的hash表的結構就會改變，成員的存儲順序會變化，在遍歷的時候就會出現混亂，因爲已經遍歷過的成員可能再次被遍歷。
比如說：
y={1:‘a’,2:‘b’}
for key in y:
y.pop(key)
print(key)
這樣就會報錯。
對於這種情況，咱們可以這樣解決：
我們可以把dict成員的key取出來放在一個list或者其它容器當中，我們再遍歷整個list，取出key，根據key去刪除dict，這樣就不會遍歷經過刪除後而改變的dict。
y={1:‘a’,2:‘b’,3:‘c’}
list =[]
for key in y:
list.append(key)
print(list)
for value in list:
if value==1:
print(y[value])
y.pop(value)
print(y)
5.set集合
1.定義和用法：
a.set和dict類似，它是一組key的集合，但是不存儲value，它們兩個key的屬性是一樣的，不可修改鍵元素，但是元素本身可以修改，和tuple差不多。
b.set的定義需要一個list作爲輸入集合：ss=set([2,3,4])
c.set的key是無序的，因此不可以通過下標訪問，但是可以通過轉化成list來訪問。
d.可以通過add函數添加元素，也可以重複添加，但是重複添加的元素無效，就是說set裏面無重複元素。
e.通過remove函數刪除元素，如果不存在則拋出異常，如果不想讓它拋出異常，我們可以使用dischard函數
f.pop函數也可以實現刪除，但是方法不太一樣，它是從上面依次刪除。ss.pop()
2.set交集和並集計算：
ss1=set([1,2,3,4])
ss2=set([2,3,4,5,6])
ss=ss1&ss2---------------->交集運算，結果爲{2，3，4}
ss=ss1|ss2--------------------->並集運算。
函數：
1.內置函數：
內置函數包括函數名，參數（注意參數類型），返回值(也可能沒有返回值)。像這些內置函數都是python庫裏面自帶的。
abs：絕對值函數：value=abs(-10)的結果就是10.
2.自定義函數：
1.自定義函數是我們自己根據需求所定義的函數。
2.我們定義一個這樣的函數的時候需要使用def語句，並且一次寫出函數名，括號，括號裏面可以寫參數，之後寫冒號，然後在縮進塊當中編寫函數體，然後可以有返回值。
def myabs(value):
if value>=0:
return value
else:
return -value
注意縮進！！！！！
3.如果說函數體沒想好怎麼寫，那麼我們就可以在函數裏面寫一個pass。
3.高階函數
可以接收函數作爲參數的函數就是高階函數
a.map函數： 接收一個函數 f 和一個 list , 並通過把函數 f 依次作用在 list 的每個元素上 , 得到一個新的 list 並返回
map(f,[1,2,3])
b.reduce函數：和map用法一樣，但是f必須接收兩個參數值，reduce()對list的每個元素反覆調用函數f , 並返回最終結果值。
reduc可以用來求和。
c.filter函數：接收一個函數 f 和一個list , 這個函數 f 的作用是對每個元素進行判斷 , 返回 True或 False , filter()根據判斷結果自動過濾掉不符合條件的元素 , 返回由符合條件元素組成的新list，裏面的函數必須爲布爾類型的函數。
d.排序函數：sorted，可進行自定義，默認爲升序排序。
sorted(iterable, key=None, reverse=False)，iterable爲可迭代對象，key爲進行比較的元素，reverse爲升序和降序，False降序，True升序
類
1.類的定義：
class Style(object):
…
2.構造函數：
我們有一個固定的構造函數，所有的類都是如此：def init(self,…):
def init(self, name, sex):
self.name = name
self.sex = sex
3.析構函數：
類似於：def del(self,…):
4.屬性定義：
屬性可以直接定義，比如說，直接在class那一行下面寫：name=“Peter”,這就相當於定義了一個name屬性，這個相當於公有屬性。
或者我們可以在構造函數裏面定義，比如說：
def init(self, name, sex):
self.name = name
self.sex = sex
這裏面就相當於定義了name和sex屬性了，但是隻能在類裏面訪問，相當於私有的。
5.方法定義：
定義格式：def 方法名(self,…):
def BMethon(self, args):
super(B, self).AMethod(args)
6.繼承：
格式：class 子類(父類):
子類可以使用父類的方法，通過super來調用：
class B(A):
def BMethon(self, args):
super(B, self).AMethod(args)