Python數(shù)據(jù)類型：

字符串' ', " "：

# 字符串基本操作
a = 'Life is short, you need Python'
a.lower()                   # 'life is short, you need Python'
a.upper()                   # 'LIFE IS SHORT, YOU NEED PYTHON'
a.count('i')                # 2
a.find('e')                 # 從左向右查找'e'褂萧，3
a.rfind('need')             # 從右向左查找'need'，19
a.replace('you', 'I')   # 'Life is short, I need Python'
tokens = a.split()      # ['Life', 'is', 'short,', 'you', 'need', 'Python']
b = ' ---'.join(tokens) # 用指定分隔符把字符串列表組合成新字符串唱凯，Life---is---short,---you---need---Python
c = a + '\n'                # 加了換行符，注意+用法是字符串作為序列的用法
c.rstrip()                  # 右側(cè)去除換行符
[x for x in a]              # 遍歷每個(gè)字符并生成由所有字符按順序構(gòu)成的列表
'Python' in a               # True

# 字符串格式化
a = 'I’m like a {} chasing {}.'
a.format('dog', 'cars') # 按順序格式化字符串磕昼，'I’m like a dog chasing cars.'

b = 'I prefer {1} {0} to {2} {0}'
b.format('food', 'Chinese', 'American')  # 在大括號中指定參數(shù)所在位置
                                         # 貌似這個(gè)功能在Python2.6有舶得，在Python3.6沒了爽蝴？

# >代表右對齊，>前是要填充的字符九孩，依次輸出：
# 000001
# 000019
# 000256
for i in [1, 19, 256]:
    print('The index is {:0>6d}'.format(i))

# <代表左對齊发框，依次輸出：
# *---------
# ****------
# *******---
for x in ['*', '****', '*******']:
    progress_bar = '{:-<10}'.format(x)
    print(progress_bar)

for x in [0.0001, 1e17, 3e-18]:
    print('{:.6f}'.format(x))   # 按照小數(shù)點(diǎn)后6位的浮點(diǎn)數(shù)格式
    print('{:.1e}'.format(x))   # 按照小數(shù)點(diǎn)后1位的科學(xué)記數(shù)法格式
    print ('{:g}'.format(x))    # 系統(tǒng)自動(dòng)選擇最合適的格式

template = '{name} is {age} years old.'
c = template.format(name='Tom', age=8)) # Tom is 8 years old.
d = template.format(age=7, name='Jerry')# Jerry is 7 years old.

# format在生成字符串和文檔的時(shí)候非常有用，更多更詳細(xì)的用法可以參考Python官網(wǎng)：
https://docs.python.org/3/library/string.html

列表[]宪拥，list([])（各種元素铣减，通過下表訪問元素，類似C語言的數(shù)組）：

# 列表的基本操作有訪問葫哗，增加，刪除校镐，和拼接：
a = [1, 2, 3, 4]
a.pop()             # 把最后一個(gè)值4從列表中移除并作為pop的返回值
a.append(5)         # 末尾插入值捺典，[1, 2, 3, 5]
a.index(2)          # 找到第一個(gè)2所在的位置，也就是1
a[2]                # 取下標(biāo)肝箱，也就是位置在2的值，也就是第三個(gè)值3
a += [4, 3, 2]      # 拼接煌张，[1, 2, 3, 5, 4, 3, 2]
a.insert(1, 0)      # 在下標(biāo)為1處插入元素0，[1, 0, 2, 3, 5, 4, 3, 2]
a.remove(2)         # 移除第一個(gè)2链嘀，[1, 0, 3, 5, 4, 3, 2]
a.reverse()         # 倒序档玻，a變?yōu)閇2, 3, 4, 5, 3, 0, 1]
a[3] = 9            # 指定下標(biāo)處賦值，[2, 3, 4, 9, 3, 0, 1]
b = a[2:5]          # 取下標(biāo)2開始到5之前的子序列误趴，[4, 9, 3]
c = a[2:-2]         # 下標(biāo)也可以倒著數(shù)（-2表示倒數(shù)第二個(gè)元素），方便算不過來的人枣申，[4, 9, 3]
d = a[2:]           # 取下標(biāo)2開始到結(jié)尾的子序列看杭，[4, 9, 3, 0, 1]
e = a[:5]           # 取開始到下標(biāo)5之前的子序列，[2, 3, 4, 9, 3]
f = a[:]            # 取從開頭到最后的整個(gè)子序列模孩，相當(dāng)于值拷貝贮缅，[2, 3, 4, 9, 3, 0, 1]
a[2:-2] = [1, 2, 3] # 賦值也可以按照一段來，并且左右兩邊長度可以不等谴供，[2, 3, 1, 2, 3, 0, 1]
g = a[::-1]         # 將a中元素倒序賦值給g，[6, 5, 4, 3, 2, 1, 0]
g = a[::-2]         # [6, 4, 2, 0]
g = a[::1]          # 將a中元素正序賦值給g龟劲，[0, 1, 2, 3, 4, 5, 6]
a.sort()
print(a)            # 列表內(nèi)排序轴或，a變?yōu)閇0, 1, 1, 2, 2, 3, 3]

# 列表推導(dǎo)式
# 列表推導(dǎo)式的結(jié)構(gòu)是：在一個(gè)方括號里，首先是一個(gè)表達(dá)式蚕愤，隨后是一個(gè) for 子句，然后是零個(gè)或更多的 for 或 if 子句萍诱。
# 返回結(jié)果是一個(gè)根據(jù)表達(dá)從其后的 for 和 if 上下文環(huán)境中生成出來的列表。 
# 示例：
squares = [x**2 for x in range(10)]  # 推導(dǎo)式
print(squares)
# 輸出是[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 二維列表初始化
2D_list=[ [ 0 for x in range(column) ] for y in range(row) ]

pairs = [(x, y) for x in [1,2,3] for y in [3,1,4] if x!=y]  # 推導(dǎo)式
print(pairs)
# 輸出是[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

元組()包竹，tuple([])（不能被賦值的列表籍凝，類似在列表前修飾const）：

c = (5,) # 如果初始化只包含1個(gè)元素的tuple，語法必須明確声诸，必須在元素后加上逗號
b = tuple(['3', 4]) # 也可以從列表初始化

集合{}（用于去重退盯，求集合的∪，∩渊迁，差）：

A = set([1, 2, 3, 4])
B = {3, 4, 5, 6}
C = set([1, 1, 2, 2, 2, 3, 3, 3, 3])
print(C)        # 集合的去重效果宫纬，set([1, 2, 3])
print(A | B)    # 求并集膏萧，set([1, 2, 3, 4, 5, 6])
print(A & B)    # 求交集，set([3, 4])
print(A - B)    # 求差集榛泛，屬于A但不屬于B的，set([1, 2])
print(B - A)    # 求差集孤个，屬于B但不屬于A的沛简，set([5, 6])
print(A ^ B)    # 求對稱差集，相當(dāng)于(A-B)|(B-A)给郊，set([1, 2, 5, 6])

字典{key:value,key:value}捧灰，dict(key=value,key=value)：

# 字典操作
a = {'Tom': 8, 'Jerry': 7}
print(a['Tom'])             # 8
b = dict(Tom=8, Jerry=7)    # 一種字符串作為鍵更方便的初始化方式
print(b['Tom'])             # 8
if 'Jerry' in a:            # 判斷'Jerry'是否在keys里面
    print(a['Jerry'])        # 7
print(a.get('Spike'))       # None，通過get獲得值，即使鍵不存在也不會(huì)報(bào)異常
a['Spike'] = 10
a['Tyke'] = 3
a.update({'Tuffy': 2, 'Mammy Two Shoes': 42})
print(a.values())   # dict_values([8, 2, 3, 7, 10, 42])
print(a.pop('Mammy Two Shoes'))     # 移除'Mammy Two Shoes'的鍵值對饲窿，并返回42
print(a.keys())     # dict_keys(['Tom', 'Tuffy', 'Tyke', 'Jerry', 'Spike']) 

# 字典排序
# 使用items()或者iteritems()
b = a.items()
print(b)  # [('Tuffy', 2), ('Spike', 10), ('Tom', 8), ('Tyke', 3), ('Jerry', 7)]
from operator import itemgetter
c = sorted(a.items(), key=itemgetter(1)) # 
print(c)  # [('Tuffy', 2), ('Tyke', 3), ('Jerry', 7), ('Tom', 8), ('Spike', 10)]
d = sorted(a.iteritems(), key=itemgetter(1))
print(d)  # [('Tuffy', 2), ('Tyke', 3), ('Jerry', 7), ('Tom', 8), ('Spike', 10)]
e = sorted(a)
print(e)  # 只對鍵排序焕蹄，['Jerry', 'Spike', 'Tom', 'Tuffy', 'Tyke']

# items()可以把字典中的鍵值對轉(zhuǎn)化成一個(gè)列表，其中每個(gè)元素是一個(gè)tuple
# tuple的第一個(gè)元素是鍵嘲驾，第二個(gè)元素是值迹卢。變量c是按照值排序，所以需要一個(gè)操作符itemgetter誊垢，去位置為1的元素作為排序參考症见，
# 如果直接對字典排序，則其實(shí)相當(dāng)于只是對鍵排序谋作。字典被當(dāng)作一個(gè)普通的可遍歷結(jié)構(gòu)使用時(shí)，都相當(dāng)于遍歷字典的鍵帖池。

# 另外需要注意的一點(diǎn)是字典是通過哈希表實(shí)現(xiàn)的吭净，所以鍵必須是可哈希的， list不能被哈希囚巴，所以也不能作為字典的鍵友扰，而tuple就可以。

迭代器：

# 上段代碼用到了itemgetter()函數(shù)村怪，因此這里插入說一下迭代器（iterator）
# 迭代器相當(dāng)于一個(gè)函數(shù)实愚，每次調(diào)用都返回下一個(gè)元素
# 從遍歷的角度來看就和列表沒有區(qū)別兔辅，區(qū)別是迭代器占用更少內(nèi)存
# 在Python3中击喂，range()就不再產(chǎn)生一個(gè)列表了，而是作為迭代器懂昂，xrange()直接沒了

Python運(yùn)算符

+, -, *, /
%: 求余數(shù)
and:相當(dāng)于C++的&
*在對列表操作時(shí)相當(dāng)于復(fù)制，例如:
g = [0]*3 + [1]*4 + [2]*2 # [0, 0, 0, 1, 1, 1, 1, 2, 2]
**: 冪運(yùn)算符

Python縮進(jìn)

同一層次代碼縮進(jìn)量相同沸柔，建議跨平臺(tái)跨編輯器縮進(jìn)用空格铲敛，因?yàn)橛械木庉嬈?code>tap=2個(gè)空格，有的編輯器tap=4個(gè)空格

Python控制流

if & elif & else 條件結(jié)構(gòu)：

# if結(jié)構(gòu)包括三個(gè)關(guān)鍵字：if, elif, else
pets =['dog', 'cat', 'droid', 'fly']

for pet in pets:
    if pet == 'dog':        # 狗糧
        food = 'steak'     # 牛排
    elif pet == 'cat':      # 貓糧
        food = 'milk'       # 牛奶
    elif pet == 'droid':   # 機(jī)器人
        food = 'oil'          # 機(jī)油
    elif pet == 'fly':       # 蒼蠅
        food = 'sh*t'       # ...
    else:
        pass                  # pass 關(guān)鍵字占位用工三，什么也不做
    print(food)

# if表達(dá)式中的小技巧
food = food_for_pet[pet] if pet in food_for_pet else None # 一個(gè)if-else常見的行內(nèi)應(yīng)用先鱼，就是代替三元操作符

if -1 < x < 1:  # 等效于 if x > -1 and x < 1:
    print('The absolute value of x is < 1')

if x in ['piano', 'violin', 'drum']:    # 等效于 if x == 'piano' or x == 'violin' or x =='drum':
    print("It's an instrument!")

food = food_for_pet[pet] if pet in food_for_pet else None

while 循環(huán)結(jié)構(gòu)：

while(條件):
     執(zhí)行語句

for 循環(huán)結(jié)構(gòu)（常用）：

# 遍歷列表
a=["aa","bb","cc"]
for i in a:
    print(i)

# 常規(guī)循環(huán)
for i in range(0,10): # range(0,10)生成0—9這10個(gè)數(shù)字
    print(i)

# 以上兩種循環(huán)屬于for_each風(fēng)格，C++11中也開始支持這種for循環(huán)方式
# 不過如果還是需要下標(biāo)呢掸读？比如遍歷一個(gè)list的時(shí)候宏多，希望把對應(yīng)下標(biāo)也打印出來
# 這時(shí)可以用enumerate
names = ["Rick", "Daryl", "Glenn"]
for i, name in enumerate(names):
    print(i, name)

# 當(dāng)然你也可以通過下標(biāo)遍歷
words = ["This", "is", "not", "recommended"]
# not pythonic
for i in range(len(words)):
    print(words[i])

break & continue 中斷結(jié)構(gòu)：

# break 直接全部退出當(dāng)前循環(huán)模塊 
a=["aa","bb","cc"]
for i in a:
    if (i="bb"):
        break
    print(i)

# continue 中斷當(dāng)前循環(huán)绷落，繼續(xù)下一次循環(huán)
a=["aa","bb","cc"]
for i in a:
    if (i="bb"):
        continue
    print(i)

循環(huán)練習(xí)始苇，輸出乘法口訣表：

# 正序打印乘法口訣表
for i in range(1,10):
    for j in range(1,i+1):
        print(str(i) + "*" + str(j) + "=" +str(i*j), end=" ") # end=" "表示不換行輸出，我在雙引號間加了一個(gè)空格為了美觀
    print()

# 逆序打印乘法口訣表
for i in range(1,10):
    for j in range(i,10):
        print(str(10-i)+"*" + str(10-j)+ "="+str((10-i)*(10-j)),end=" ")
    print()

Python函數(shù)

def 函數(shù)名(參數(shù)1,,參數(shù)2...):
    函數(shù)體

# 注意點(diǎn)
# 默認(rèn)參數(shù)必須放后面函喉，如：
def create_a_list(x, y=2, z=3): # 默認(rèn)參數(shù)項(xiàng)必須放后面
    return [x, y, z]

# lambda匿名函數(shù)
# Lambda表達(dá)式在Python中是一種匿名函數(shù)荣月，lambda關(guān)鍵字后面跟輸入?yún)?shù)，然后冒號后面是返回值
some_ops = lambda x, y: x + y + x*y + x**y # 形參是x,y哺窄，返回x + y + x*y + x^y
some_ops(2, 3)  # 2 + 3 + 2*3 + 2^3 = 19

Python生成器（Generator）

# 生成器是迭代器的一種账锹，形式上看和函數(shù)很像坷襟，只是把return換成了yield
# 在每次調(diào)用的時(shí)候婴程，都會(huì)執(zhí)行到y(tǒng)ield并返回值，同時(shí)將當(dāng)前狀態(tài)保存档叔，等待下次執(zhí)行到y(tǒng)ield再繼續(xù)：
# 從10倒數(shù)到0
def countdown(x):
    while x >= 0:
        yield x
        x -= 1
for i in countdown(10):
    print(i)
# 可以通過next()函數(shù)返回下一個(gè)值
a=countdown(3)
print(a.next())
print(next(a))
print(next(a))
print(next(a))
# 如果迭代結(jié)束就會(huì)拋出StopIteration異常

Python模塊

import 模塊名
from 模塊名 import 模塊中的方法

模塊的類別：
1. Python自帶模塊（在./python/Lib路徑下）
2. 第三方模塊（pip）
3. 自己寫的模塊（寫好*.py放到./python/Lib路徑下）

Python文件操作衙四、用pickle序列化、轉(zhuǎn)換為JSON標(biāo)準(zhǔn)格式

在Python中传蹈，推薦用上下文管理器（with-as）來打開文件，IO資源的管理更加安全宴胧，而且不用老惦記著給文件執(zhí)行close()函數(shù)

# 打開文件
file=open(文件地址表锻，操作形式（包括：w:寫入,r：讀取,b：以二進(jìn)制形式,a：在文件末尾追加）)
# 讀出文件
file.read()
file.readline() # 讀取文件的一行
# 關(guān)閉文件
file.close() #打開文件一定要關(guān)閉
# 寫入文件（覆蓋原來的）
file.write(要寫入的數(shù)據(jù)) # 寫入后一定要關(guān)閉才能保存
# 寫入文件（追加寫入，不覆蓋）

# Python文件操作例子
FilePath='D:\\Code_hub\\test\\tmp1.txt'
data1="data1"
data2="data2"

# 新建文件：file显歧，寫入數(shù)據(jù)确镊，關(guān)閉保存
File=open(FilePath,'w')
File.write(data1)
File.close()

# 文件：file，寫入數(shù)據(jù)（會(huì)將原來文件內(nèi)容覆蓋）蕾域，關(guān)閉保存
File=open(FilePath,'w')
File.write(data2)
File.close()

# 文件：file旨巷，寫入數(shù)據(jù)（在原來文件內(nèi)容后面追加），關(guān)閉保存
File=open(FilePath,'a')
File.write(data2)
File.close()

# 用上下文管理器（with-as）來打開文件
# IO資源的管理更加安全采呐，而且不用惦記著給文件執(zhí)行close()函數(shù)
# open()的第一個(gè)參數(shù)是文件名，第二個(gè)參數(shù)是模式
# 文件的模式一般有四種又固，讀取(r)，寫入(w)娄周，追加(a)和讀寫(r+)
# 如果希望按照二進(jìn)制數(shù)據(jù)讀取沪停，則將文件模式和b一起使用（wb, r+b…）
# 現(xiàn)有一文件'name_age.txt'
# 文件內(nèi)容為：
Tom+8
Jerry+7
Tyke+3

with open('name_age.txt', 'r') as f:    # 打開文件，讀取模式
    lines = f.readlines()               # 一次讀取所有行
    for line in lines:                      # 按行格式化并顯示信息
        name, age = line.rstrip().split('+') # rstrip()：右側(cè)去除換行符木张；split()：以某符號為分隔符劃分字符串
        print('{} is {} years old.'.format(name, age))
# 執(zhí)行后結(jié)果為：
Tom is 8 year old.
Jerry is 7 year old.
Tyke is 3 year old.

# 如果要讀取文件內(nèi)容舷礼，并把年齡和名字的順序交換存成新文件age_name.txt，這時(shí)可以同時(shí)打開兩個(gè)文件：
with open('name_age.txt', 'r') as fread, open('age_name.txt', 'w') as fwrite:
    line = fread.readline()
    while line:
        name, age = line.rstrip().split('+')
        fwrite.write('{}-{}\n'.format(age, name))
        line = fread.readline()
# 此時(shí)age_name.txt文件內(nèi)容為：
8-Tom
7-Jerry
3-Tyke

# 序列化
# 把變量從內(nèi)存中變成可存儲(chǔ)或傳輸?shù)倪^程稱之為序列化
# 在Python中叫pickling妻献，在其他語言中也被稱之為serialization育拨，marshalling，flattening等
# 反過來熬丧，把變量內(nèi)容從序列化的對象重新讀到內(nèi)存里稱之為反序列化，即unpickling
# Python提供了pickle模塊來實(shí)現(xiàn)序列化
import pickle
d = dict(name='Bob', age=20, score=88)
a=pickle.dumps(d) # pickle.dumps()方法把任意對象序列化成一個(gè)bytes害捕，然后闷畸，就可以把這個(gè)bytes寫入文件
print(a)
with open('dumps.txt', 'wb') as f:
    f.write(a)

with open('dump.txt', 'wb') as f:
    pickle.dump(d, f)
# 上述兩段代碼生成的文件dump.txt和dumps.txt內(nèi)容都是一樣的

# 反序列化，使用loads()或load()函數(shù)
a1=pickle.loads(a)
print(a1)

with open('dump.txt', 'rb') as f:
    d = pickle.load(f)
    print(d)

# 轉(zhuǎn)換為JSON標(biāo)準(zhǔn)格式
# 如果我們要在不同的編程語言之間傳遞對象盾沫，就必須把對象序列化為標(biāo)準(zhǔn)格式
# 比如XML倘待，但更好的方法是序列化為JSON
# 因?yàn)镴SON表示出來就是一個(gè)字符串组贺，可以被所有語言讀取，也可以方便地存儲(chǔ)到磁盤或者通過網(wǎng)絡(luò)傳輸
# JSON不僅是標(biāo)準(zhǔn)格式啊奄，并且比XML更快，而且可以直接在Web頁面中讀取菇夸，非常方便。
# Python內(nèi)置的json模塊提供了非常完善的Python對象到JSON格式的轉(zhuǎn)換
import json
d= dict(name='Bob',age=20,score=88)
a=json.dumps(d) # 使用dumps()方法序列化為JSON鞠眉，也可以使用dump()
print(d)
print(type(d))
print(a)
print(type(a))
# 控制臺(tái)輸出為：
{'name': 'Bob', 'age': 20, 'score': 88}
<class 'dict'>
{"name": "Bob", "age": 20, "score": 88}
<class 'str'>

# 反序列化
# 跟上文一樣用loads()或load()方法
d1=json.loads(a)
print(d1)
print(type(d1))
# 控制臺(tái)輸出為：
{'name': 'Bob', 'age': 20, 'score': 88}
<class 'dict'>

# 將Python中的對象（可以先看Python面向?qū)ο缶幊淘賮砜矗┬蛄谢蒍SON對象
import json
class Student(object):
    def __init__(self,name='NoOne',age=0,score=0):
        self.name=name
        self.age=age
        self.score=score
s = Student('Bob', 20, 88)

# 默認(rèn)情況下择诈，dumps()方法不知道如何將Student實(shí)例變?yōu)橐粋€(gè)JSON的{}對象
# 可選參數(shù)default就是把任意一個(gè)對象變成一個(gè)可序列為JSON的對象
# 我們只需要為Student專門寫一個(gè)轉(zhuǎn)換函數(shù)羞芍，再把函數(shù)傳進(jìn)去即可
def student2dict(std):
    return {
        'name': std.name,
        'age': std.age,
        'score': std.score
    }
print(json.dumps(s,default=student2dict))

# 一般類的實(shí)例中都會(huì)有一個(gè)__dict__屬性，它就是一個(gè)dict
# 可以偷懶一點(diǎn)不寫實(shí)例轉(zhuǎn)換成dict的函數(shù)荷科，直接用__dict__屬性
print(json.dumps(s,default=lambda obj:obj.__dict__))

# JSON對象反序列化成實(shí)例
# 首先需要將json的dict類型轉(zhuǎn)換為對象類型
def dict2student(dicType):
    return Student(dicType['name'], dicType['age'], dicType['score']) 
# 這里d[ ]表示從字典取值，剛開頭講過的知識不要忘記

json_str = '{"age": 20, "score": 88, "name": "Bob"}' # 注意json對象是str畏浆，不要漏寫''符號
print(json.loads(json_str,object_hook=dict2student))
# dict2student返回值為一個(gè)對象實(shí)例，這樣json.loads()解析時(shí)就不會(huì)使用默認(rèn)的dict類型解析
# 輸出結(jié)果為
<__main__.Student object at 0x0000022F3707D048>

# 如果dict類型中包含中文字符串煮剧，使用json.dumps(obj, ensure_ascii=False)進(jìn)行序列化将鸵，默認(rèn)ensure_ascii=True，不改成False不能正常顯示中文字符

Python異常處理

# 異常處理格式：
try:
    程序
except Exception as 異常名稱:
    異常處理部分

# 注意：try和except的縮進(jìn)是在對應(yīng)的同一層次

Python異常處理例子：

# 捕獲異常草娜，輸出異常并結(jié)束
try:
    for i in range(10):
        print(i)
        if(i==4):
            print(unknown)
except Exception as err:
    print(err)

# 捕獲異常痒筒，輸出異常并繼續(xù)下一次循環(huán)
for i in range(10):
    try:
        print(i)
        if(i==4):
            print(unknown)
    except Exception as err:
        print(err)

Python面向?qū)ο缶幊?/h1>

# Python中的類的概念和其他語言相比沒什么不同
# 比較特殊的是protected和private在Python中是沒有明確限制的
# 一個(gè)慣例是用單下劃線開頭的表示protected，用雙下劃線開頭的表示private

# Python中定義一個(gè)類
class class1:
        """Class A"""  # 類定義中緊跟著類名字下一行的字符串叫做docstring移袍，
                       # 可以寫一些用于描述類的介紹老充，如果有定義則通過“類名.__doc__”訪問
        print('class1')
    # 構(gòu)造函數(shù)，用關(guān)鍵字“__init__”
    # 在實(shí)例化對象時(shí)觅够，構(gòu)造函數(shù)被自動(dòng)調(diào)用，一般用于初始化變量
    # self：在類中的方法喘先，第一個(gè)參數(shù)必須是self  
    def __init__(self,name,job):
        print('I am __init__ in class1')
        print('My name is '+ name+' My job is '+job)
        # 定義屬性窘拯，一定要用self.屬性名
        self.myname=name
        self.myjob=job

        # 定義類中的方法：
    def myfunc(self,funcName):
        print('I an in class1.myfunc')
        print(funcName)

# 在實(shí)例化類時(shí)傳入?yún)?shù)給構(gòu)造函數(shù)
a=class1("keloli","student")
print(a.myname)
a.myfunc("func1")

# 輸出
class1
I am __init__ in class1
My name is keloli My job is student
keloli
I an in class1.myfunc
func1

# 類的繼承與重載
# 繼承：把某一個(gè)或多個(gè)類（基類）的特征拿過來
# 重載：在子類（派生類）中多繼承來的特征重新定義

# 單繼承：父親可以說話，小兒子繼承了父親涤姊，但是減弱了父親的說話能力
# 父親類（基類）
class father():
    def speak(self):
        print("father speak")
# 大兒子類（單繼承父親類）
class son1(father):
    pass

s1=son1()
s1.speak()

# 多繼承：父親可以說話，母親可以寫字奔誓，
# 女兒繼承了父親和母親搔涝，還可以聽
# 母親類（基類）
class mother():
    def write(self):
        print('mother write')

# 女兒類（多繼承父親和母親）
class daughter(father,mother):
    def listen(self):
        print('daughter listen')

dau=daughter()
dau.speak()
dau.write()
dau.listen()

# 重載
# 小兒子類重載父親類，減弱了父親的說話能力
class son2(father):
    def speak(self):
        print('son2 speak')

s2=son2()
s2.speak()

# 輸出
father speak
father speak
mother write
daughter listen
son2 speak

map, reduce和filter（函數(shù)式編程）

# map可以用于對可遍歷結(jié)構(gòu)的每個(gè)元素執(zhí)行同樣的操作蜕煌，批量操作：
map(lambda x: x**2, [1, 2, 3, 4])                 # [1, 4, 9, 16]
map(lambda x, y: x + y, [1, 2, 3], [5, 6, 7])     # [6, 8, 10]
  
# 在Python3種輸出上述結(jié)果
result1=list(map(lambda x: x**2, [1, 2, 3, 4]) )                # [1, 4, 9, 16]
print(result1)
result2(map(lambda x, y: x + y, [1, 2, 3], [5, 6, 7]))     # [6, 8, 10]
print(result2)

# reduce則是對可遍歷結(jié)構(gòu)的元素按順序進(jìn)行兩個(gè)輸入?yún)?shù)的操作
# 并且每次的結(jié)果保存作為下次操作的第一個(gè)輸入?yún)?shù)诬留，還沒有遍歷的元素作為第二個(gè)輸入?yún)?shù)
# 這樣的結(jié)果就是把一串可遍歷的值文兑，減少（reduce）成一個(gè)對象
from functools import reduce
res=reduce(lambda x, y: x + y, [1, 2, 3, 4])    # ((1+2)+3)+4=10
print(res)

# filter顧名思義盒刚，根據(jù)條件對可遍歷結(jié)構(gòu)進(jìn)行篩選
filter(lambda x: x % 2, [1, 2, 3, 4, 5])    # 篩選奇數(shù)因块，[1, 3, 5]

列表生成

# For More :http://www.codebelief.com/article/2017/02/python-advanced-programming-list-comprehensions/
# 列表生成可以非常方便地用來生成列表和迭代器
# 比如上節(jié)中map的兩個(gè)例子和filter的一個(gè)例子可以用列表生成重寫為
[x**2 for x in [1, 2, 3, 4]]                      # [1, 4, 9 16]

[sum(x) for x in zip([1, 2, 3], [5, 6, 7])]       # [6, 8, 10]
# zip()函數(shù)可以把多個(gè)列表關(guān)聯(lián)起來籍铁，這個(gè)例子中，通過zip()可以按順序同時(shí)輸出兩個(gè)列表對應(yīng)位置的元素對
# 有一點(diǎn)需要注意的是吩愧，zip()不會(huì)自動(dòng)幫助判斷兩個(gè)列表是否長度一樣增显，所以最終的結(jié)果會(huì)以短的列表為準(zhǔn)
# 想要以長的列表為準(zhǔn)的話可以考慮itertools模塊中的izip_longest()

[x for x in [1, 2, 3, 4, 5] if x % 2]             # [1, 3, 5]


# 如果要生成迭代器只需要把方括號換成括號，生成字典也非常容易：
iter_odd = (x for x in [1, 2, 3, 4, 5] if x % 2)

print(type(iter_odd))                       # <type 'generator'>

square_dict = {x: x**2 for x in range(5)}   # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
至于列表生成和map/filter應(yīng)該優(yōu)先用哪種甘穿，這個(gè)問題很難回答梢杭，不過Python創(chuàng)始人Guido似乎不喜歡map/filter/reduce，他曾在表示過一些從函數(shù)式編程里拿來的特性是個(gè)錯(cuò)誤武契。

Python 多線程

# 進(jìn)程由一個(gè)或多個(gè)線程組成咒唆，在單核CPU中采用各個(gè)任務(wù)交替執(zhí)行的方法達(dá)到任務(wù)并行處理的效果
# 多進(jìn)程和多線程的程序涉及到同步、數(shù)據(jù)共享的問題全释，編寫起來更復(fù)雜
# 廖雪峰老師這個(gè)章節(jié)講解比較詳細(xì)

from multiprocessing import Process
import os

# 子進(jìn)程要執(zhí)行的代碼
def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print('Child process will start.')
    p.start()
    p.join()
    print('Child process end.')

Python OS模塊

# OS模塊常用函數(shù)
import os

abspath=os.path.abspath('') # 顯示當(dāng)前目錄的絕對路徑
print('abspath: ',abspath)

FileName1=os.path.basename(__file__) # 獲取當(dāng)前代碼所在文件的文件名，包含后綴
FileName2=FileName1.split('.')[-2] # 獲取當(dāng)前代碼所在文件的文件名妄迁，通過'.'分割字符串李命，[-1]是文件后綴，[-2]是文件名

newpath=os.path.join(abspath,'mkdir_test') # 在某目錄下創(chuàng)建新目錄黔州，先將新路徑表示出來
                                           # 把兩個(gè)路徑合成一個(gè)時(shí)阔籽，不要直接拼字符串，而要通過os.path.join()函數(shù)
                                           # 這樣可以正確處理不同操作系統(tǒng)的路徑分隔符
print('newpath: ',newpath)

try: # 與文件相關(guān)操作可能會(huì)出現(xiàn)路徑錯(cuò)誤等異常合冀，所以使用'try-except'語句對
    os.mkdir(newpath) # 創(chuàng)建目錄
except Exception as err: 
    print(err) 

try:
    DelatePath='D:\\Code_hub\\test\\16\\aa'
    os.rmdir(DelatePath) # 刪除目錄
    print('Delate:',DelatePath,'success!') 
except Exception as err:
    print(err)

FilePath='D:\\Code_hub\\test\\16\\text.py'
SplitPath=os.path.split(FilePath) # 一個(gè)路徑拆分為兩部分项贺，后一部分總是最后級別的目錄或文件名
print(SplitPath)

SplitextPath=os.path.splitext(FilePath) # 得到文件擴(kuò)展名
print(SplitextPath)
# print(type(SplitextPath))
print(SplitextPath[0])
print(SplitextPath[1]) # 建議使用print(SplitextPath[-1])如果你要獲取文件拓展名

# 注意：OS模塊不提供復(fù)制文件的函數(shù)，原因是復(fù)制文件并非由操作系統(tǒng)提供的系統(tǒng)調(diào)用
# shutil模塊提供了copyfile()的函數(shù)
# 你還可以在shutil模塊中找到很多實(shí)用函數(shù)棕叫，它們可以看做是os模塊的補(bǔ)充

# 列出當(dāng)前目錄下的所有目錄及文件
FatherPath='D:\\Code_hub\\test'
for x in os.listdir(FatherPath):
    print(x)

# 列出當(dāng)前目錄下的所有目錄及文件
for x in os.listdir('.'):
    print(x)

# 列出所有.py文件
for x in os.listdir('.'):
    if os.path.isfile(x) and os.path.splitext(x)[-1]=='.py':
        print(x)

參考資料：

• Python3官方文檔
• 廖雪峰的Python3教程
• 推薦奕删！給深度學(xué)習(xí)入門者的Python快速教程 - 基礎(chǔ)篇
• github開源項(xiàng)目：快速瀏覽Python語言所包含的知識點(diǎn)
• Python遍歷目錄下所有文件