Python 是由Guido Van Rossum在 90 年代早期設計，現在是最常用的編程語言之一。特別是人工智能的火熱，再加之它的語法簡潔且優美，實乃初學者入門AI必備的編程語言。

Python基本語法

標識符

第一個字符必須是英文字母或下劃線 _ 。標識符的其他的部分由字母、數字和下劃線組成。標識符對大小寫敏感。

保留字

保留字即關鍵字，不能用作任何標識符名稱。keyword 模塊可以輸出當前版本的所有關鍵字：

import keyword

print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

注釋

單行注釋采用#，注釋是給人看的，可以是任意內容，解釋器會忽略掉注釋。

多行注釋采用'''或"""。

# print("我是注釋，不會執行")

print("正常執行代碼")

'''

這是多行注釋，用三個單引號

這是多行注釋，用三個單引號

'''

print("Hello, World!")

"""

這是多行注釋，用三個雙引號

這是多行注釋，用三個雙引號

"""

print("Hello, World!")

行與縮進

Python 使用縮進來表示代碼塊而不是大括號 {}。縮進的空格數是可變的，但是同一個代碼塊的語句必須是相同的縮進空格數。建議四個空格數。

注意Tab和四格空格混用會報錯，這個錯誤還不容易被察覺。

輸入輸出

通常是一條語句一行，如果語句很長，我們可以使用反斜杠(\)來實現多行語句。在 , {}, 或 中的多行語句，則不需要反斜杠。

sentence1 = "I love " + \

"python"

sentence2 = ["I", "love",

"python"]

基本數據類型

計算機程序要處理不同的數據，需要定義不同的數據類型。Python 中的變量不需要聲明，每個變量在使用前都必須賦值，變量賦值以后該變量才會被創建。

Python中變量就是變量，沒有類型，所說的"類型"是變量所指的內存中對象的類型。等號（=）用來給變量賦值。等號（=）運算符左邊是一個變量名,等號（=）運算符右邊是存儲在變量中的值。

數字類型(Number)

數字類型是不可變數據。Python3 支持 int(整數)、float(浮點數)、bool(布爾)、complex(復數)，數值類型的賦值和計算是很直觀的。

# int(整數)

a = 3

# float(浮點數)

b = 3.5

#bool(布爾)

c = True

#complex(復數)

d = 4+3j

print(a, b, c, d)

#內置的 type 函數可以用來查詢變量所指的對象類型

print(type(a), type(b), type(c), type(d))

#還可以用 isinstance 來判斷

#isinstance 和 type 的區別在于：type不會認為子類是一種父類類型，isinstance會認為子類是一種父類類型

print(isinstance(a, int))

print(isinstance(a, float))

關于數值運算，可以同時為多個變量賦值，如a, b = 1, 2。一個變量可以通過賦值指向不同類型的對象。

除法包含兩個運算符：/ 返回一個浮點數，// 返回一個整數。混合計算時，Python會把整型轉換成為浮點數。

# 加

print("Add operation: 5 + 4 = ",5 + 4)

# 減

print("Sub operation: 5 - 4 = ",5 - 4)

# 乘

print("Mul operation: 5 * 4 = ",5 * 4)

# 除，得到一個浮點數

print("Div operation: 5 / 4 = ",5 / 4)

# 除，得到一個整數

print("Div operation: 5 // 4 = ",5 // 4)

# 取余

print("Mod operation: 5 % 4 = ",5 % 4)

# 乘方

print("Pow operation: 5 ** 4 = ",5 ** 4)

字符串類型(String)

Python 沒有單獨的字符類型，一個字符就是長度為1的字符串。字符串用單引號 ' 或雙引號 " 括起來。

s1 = "I love python"

s2 = 'I love python'

print(s1)

print(s2)

#索引值以 0 為開始值，-1 為從末尾的開始位置

print("s1首字母字符：", s1[0])

print("s1末尾字母字符：", s1[-1])

print("輸出從第三個開始到第五個的字符:", s1[2:5])

#加號 + 是字符串的連接符

#星號 * 表示復制當前字符串，緊跟的數字為復制的次數

str = "I love python "

print("連接字符串:", str + "!!!")

print("輸出字符串兩次:", str * 2)

#反斜杠 \ 轉義特殊字符

#若不想讓反斜杠發生轉義，可以在字符串前面添加一個 r

print('I\nlove\npython')

print("反斜杠轉義失效:",r'I\nlove\npython')

列表類型(List)

列表類型是一種有序的集合。列表中元素的類型可以不相同，它支持數字，字符串甚至可以包含列表（所謂嵌套）。列表是寫在方括號 之間、用逗號分隔開的元素列表。

list_a = [1, 2, 3, 4, 5, 6]

list_b = [7, 8, 9]

print(list_a)

print(list_b)

#列表可以被索引和截取，列表被截取后返回一個包含所需元素的新列表

print ("輸出完整列表: ", list_a)

print ("輸出列表第一個元素:", list_a[0])

print ("從第二個開始輸出到第三個元素:", list_a[1:3])

print ("輸出從第三個元素開始的所有元素:", list_a[2:])

print ("連接兩次列表:", list_a * 2)

print ("連接列表:", list_a + list_b)

#列表中的元素是可以改變的

list_a = [1, 2, 3, 4, 5, 6]

print("變化前：", list_a)

list_a[0] = 0

list_a[2:5] = [7, 8, 9]

print("變化后：", list_a)

#append方法：在列表末尾添加新的對象

list_a = [1, 2, 3, 4, 5, 6]

print("添加前：", list_a)

list_a.append(7)

list_a.append(8)

print("添加后：", list_a)

#del語句：刪除列表元素

list_a = [1, 2, 3, 4, 5, 6]

print("刪除前：", list_a)

del list_a[0]

print("刪除后：", list_a)

#len方法：計算列表長度

list_a = [1, 2, 3, 4, 5, 6]

print("列表長度：", len(list_a))

#max方法：返回列表元素最大值。min方法：返回列表元素最小值

list_a = [1, 2, 3, 4, 5, 6]

print("列表最小值：", min(list_a))

print("列表最大值：", max(list_a))

#list方法：將字符串轉換為列表

str = '123456'

print("轉換后：", list(str))

#count方法：統計某個元素在列表中出現的次數

list_a = [1, 1, 2, 3, 4, 5, 6]

print("1在list_a中出現的次數：", list_a.count(1))

#index方法：從列表中找出某個值第一次出現的索引位置

list_a = [1, 2, 3, 4, 5, 6]

print("3第一次出現的位置：", list_a.index(3))

#insert方法：將對象插入列表指定位置

list_a = [1, 2, 3, 4, 5, 6]

print("插入前：", list_a)

list_a.insert(0 ,7)

print("插入后：", list_a)

#pop方法：移除列表中的一個元素（默認最后一個元素），并且返回該元素的值

list_a = [1, 2, 3, 4, 5, 6]

print("默認移除最后一個元素：", list_a.pop)

print("指定移除第一個元素：", list_a.pop(0))

#reverse方法：翻轉列表中元素

list_a = [1, 2, 3, 4, 5, 6]

print("翻轉前：", list_a)

list_a.reverse

print("翻轉后：", list_a)

#sort方法：該方法沒有返回值，但是對原列表進行排序

list_a = [1, 3, 2, 5, 4, 6]

print("排序前：", list_a)

list_a.sort

print("升序排序：", list_a)

list_a.sort(reverse = True)

print("降序排序：", list_a)

元組類型(Tuple)

元組類型是不可變類型，元組使用小括號。

tup1 = (1, 2, 3, 4, 5 )

# 元組中只包含一個元素時，需要在元素后面添加逗號,否則括號會被當作運算符使用

tup2 = (50,)

tup3 = (50)

print(type(tup2))

print(type(tup3))

#訪問元組:使用下標索引來訪問元組中的值

tup1 = (1, 2, 3, 4, 5 )

print ("tup1[0]: ", tup1[0])

print ("tup1[1:3]: ", tup1[1:3])

#修改元組:元組中的元素值是不允許修改的，但可以對元組進行連接組合

tup1 = (1, 2)

tup2 = ('a', 'b')

# 創建一個新的元組

tup3 = tup1 + tup2

print(tup3)

#刪除元組：元素值是不允許刪除，但可以使用del語句來刪除整個元組

tup1 = (1, 2, 3, 4, 5 )

print(tup1)

del tup1

print("刪除后的元組 tup1: ")

print(tup1)

#元組運算符：如 + 號和 * 號

tup1 = (1, 2)

tup2 = ('a', 'b')

print("連接：", tup1 + tup2)

print("復制3次：", tup1 * 3)

#len：計算元組元素個數

tup1 = (1, 2)

print("元組長度：", len(tup1))

#max方法: 返回元組中元素最大值。min方法: 返回元組中元素最小值

tup1 = (1, 2)

print("元組最大值：", min(tup1))

print("元組最大值：", max(tup1))

#tuple方法：將列表轉換為元組

list1= ['1', '2']

print("轉換前：", list1)

tup1 = tuple(list1)

print("轉換后：", tup1)

集合類型(Set)

集合類型是無序的不重復元素序列。使用大括號 {} 或者 set 函數創建集合。

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

a={'a','b','c'}

b=set('abc')

c=set

d={}

print(a)

print(b)

print(type(a), type(b), type(c), type(d))

#無序性

a = set('python')

print(a)

#互異性

a = set('good')

print(a)

#add方法：為集合添加元素

a = set('good')

a.add('p')

print(a)

#update方法：給集合添加元素

a = set('good')

a.update('p')

print("添加一個元素", a)

a.update(['a', 'b', 'c'])

print("添加多個元素", a)

a.update(['H', 'e'], {'l', 'l', 'o'})

print('添加列表和集合', a)

#remove方法：移除指定元素

s = {'P', 'y', 't', 'h', 'o', 'n'}

s.remove('t')

print("去掉t", s)

#pop方法：隨機移除元素

s = {'P', 'y', 't', 'h', 'o', 'n'}

print("隨機刪除元素：", s.pop)

#clear方法：移除集合中的所有元素

s = {'P', 'y', 't', 'h', 'o', 'n'}

s.clear

print("清空集合：", s, len(s))

#issubset方法：判斷指定集合是否為該方法參數集合的子集

A = set('abcd')

B = set('cdef')

C = set('ab')

print("C是否A子集：", C.issubset(A))

#union方法：返回兩個集合的并集，也可以用 |

print("A和B并集:", A|B)

print("A和B并集:",A.union(B))

#intersection方法：返回集合的交集，也可以用&

print("A和B交集:", A&B)

print("A和B交集:",A.intersection(B))

#difference方法：差集，也可以用-

print("A和B差集:", A-B)

print("A和B差集:",A.difference(B))

字典類型(Dictionary)

字典類型是可變類型。在同一個字典中，鍵(key)必須是唯一的。

字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括號({})中。

# 用{}創建字典

dict1 = {"a":"1", "b":"2"}

print(dict1)

# 用內置函數dict

dict2 = dict(a="1", b="2")

print(dict2)

#訪問字典里的值

dict1 = {"a":"1", "b":"2"}

print ("dict1['a']: ", dict1['a']) #如果沒有會報錯

print ("dict1.get('a'): ", dict1.get('a')) #如果沒有返回None

print("獲取所有的key值：", dict1.keys)

print("獲取所有的value值：", dict1.values)

#增加新的鍵/值對

dict1 = {"a":"1", "b":"2"}

print ("增加前：", dict1)

dict1['c'] = 3

print ("增加后：", dict1)

#刪除字典指定元素

dict1 = {"a":"1", "b":"2"}

print ("刪除前：", dict1)

del dict1['a']

print ("刪除后：", dict1)

#清空字典

dict1 = {"a":"1", "b":"2"}

print ("清空前：", dict1)

dict1.clear

print ("清空后：", dict1)

#dir方法：查看dict所有方法

print(dir(dict))

條件判斷和循環

條件控制：通過一條或多條語句的執行結果（True或者False）來決定執行的代碼塊。

每個條件后面要使用冒號:，表示接下來是滿足條件后要執行的語句塊。使用縮進來劃分語句塊，相同縮進數的語句在一起組成一個語句塊。在Python中沒有switch–case語句。

#if操作

x = 5

if x > 3:

print("yes")

#if嵌套:if...elif...else

#也可以把 if...elif...else 結構放在另外一個 if...elif...else 結構中

x = 99

if x<60:

print("不及格")

elif x<80:

print("良好")

else:

print("優秀")

#while循環

sum = 0

counter = 1

while counter <= 10:

sum = sum + counter

counter += 1

print("1 到 10 之和為: %d" % sum)

#while 循環使用 else 語句

count = 0

while count < 5:

print (count, " 小于 5")

count = count + 1

else:

print (count, " 大于或等于 5")

#for 語句：for循環可以遍歷任何序列(列表、字符串等)

str = 'python'

list1 = ['I', 'love', 'python']

print("遍歷字符串")

for i in str:

print(i)

print("遍歷列表")

for i in list1:

print(i)

#range函數：遍歷數字序列，可以使用內置range函數生成數列

for i in range(5):

print(i)

#也可以使用range指定區間的值

for i in range(2,6):

print(i)

#也可以使range以指定數字開始并指定不同的增量(步長),可以是負數

for i in range(0, 10, 3):

print(i)

for i in range(-10, -100, -30):

print(i)

#可以結合range和len函數以遍歷一個序列的索引

list1 = ['I', 'love', 'Python']

for i in range(len(list1)):

print(list1[i])

#break語句：跳出 for 和 while 的循環體

list1 = ['I', 'love', 'Python']

for i in list1:

if i == 'love':

break

print('當前為 :', i)

#continue語句:跳過當前循環塊中的剩余語句，然后繼續進行下一輪循環

var = 10

while var > 0:

var = var -1

# 變量為 5 時跳過輸出

if var == 5:

continue

print ('當前值 :', var)

print ("hello world!")

#pass 語句：pass是空語句，是為了保持程序結構的完整性，pass 不做任何事情，一般用做占位語句

while True:

pass # 等待鍵盤中斷 (Ctrl+C)

函數

函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。函數能提高應用的模塊性，和代碼的重復利用率。

Python提供了許多內建函數，比如“print”，也可以自己創建函數，這被叫做用戶自定義函數。

# 1.無參函數

# 用def定義新函數

defmy_func:

print("test...")

return 1

# 調用函數

my_func

# 2.有參函數

# 關鍵字參數、默認參數、可變參數。

# 關鍵字參數: 調用時指定參數的名稱，且與函數聲明時的參數名稱一致。使用關鍵字參數允許函數調用時參數的順序與聲明時不一致。

defmy_func1(x, y):

print(x)

print(y)

# 標準調用

my_func1(1, 2)

# 關鍵字調用

defmy_func1(y = 1, x = 2)

# 默認參數：在函數聲明時，指定形參的默認值，調用時可不傳入參數（使用默認值）。

defmy_func2(x, y=1):

print(x+y)

my_func2(2)

#可變參數:變參數就是傳入的參數個數是可變的，可以是1個、2個到任意個。

#在參數前面加了一個*號。在函數內部，參數numbers接收到的是一個tuple。

defmy_func3(*numbers):

sum = 0

for n in numbers:

sum = sum + n * n

return sum

# 函數調用

my_func3 #返回結果0

my_func3(1,2) #返回結果5

# 關鍵字參數：可變參數允許你傳入0個或任意個參數，這些可變參數在函數調用時自動組裝為一個tuple。而關鍵字參數允許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝為一個dict。

defmy_func4(x, **kw):

print ('x:', x, 'other:', kw)

#除了必選參數x外，還接受關鍵字參數kw。在調用該函數時，可以只傳入必選參數。

my_func4(8)

#也可以傳入任意個數的關鍵字參數

my_func4(8, z="66")

類

類(Class):用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。

類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作為實例變量使用。

數據成員：類變量或者實例變量, 用于處理類及其實例對象的相關的數據。

#創建類Student

class Student(object):

"學生成績"

def __init__(self, name, score):

self.name = name

self.score = score

def print_score(self):

print('%s: %s' % (self.name, self.score))

#創建Student類的對象bart

jack = Student('Bart Simpson', 59)

#創建Student類的對象lisa

bob = Student('Lisa Simpson', 87)

#訪問類的屬性

jack.print_score

bob.print_score

# 添加一個 'age' 屬性

jack.age = 7

print("添加一個 'age' 屬性：",hasattr(jack, 'age'))

# 修改 'age' 屬性

jack.age = 8

print("修改 'age' 屬性：",getattr(jack, 'age'))

# 刪除 'age' 屬性

del jack.age

print("刪除 'age' 屬性：",hasattr(jack, 'age'))

類的繼承

面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是通過繼承機制。

通過繼承創建的新類稱為子類或派生類，被繼承的類稱為基類、父類或超類。

#編寫一個名為Fruit的class，執行run方法可以直接打印

#編寫Apple和Orange類時，就可以直接從Fruit類繼承

class Fruit(object):

'父類Animal'

def run_father(self):

print('調用父類方法...')

class Apple(Fruit):

'子類1 Apple'

def run_son(self):

print('調用子類方法...')

class Orange(Fruit):

'子類2 Orange'

def run_son(self):

print('調用子類方法...')

#實例化子類

apple = Apple

orange = Orange

#調用父類方法

apple.run_father

orange.run_father

#調用子類方法

apple.run_son

orange.run_son

方法重寫

如果父類方法的功能不能滿足你的需求，你可以在子類重寫你父類的方法

class Fruit(object):

'父類Animal'

def run(self):

print('調用父類方法...')

class Apple(Fruit):

'子類1 Apple'

def run(self):

print('子類1 Apple 重寫父類方法...')

class Orange(Fruit):

'子類2 Orange'

def run(self):

print('子類2 Orange 重寫父類方法...')

#實例化子類

apple = Apple

orange = Orange

#調用父類方法

apple.run

orange.run

模塊

Python 模塊(Module)，是一個 Python 文件，以 .py 結尾，包含了 Python 對象定義和Python語句。模塊讓你能夠有邏輯地組織你的 Python 代碼段。

把相關的代碼分配到一個模塊里能讓你的代碼更好用，更易懂。模塊能定義函數，類和變量，模塊里也能包含可執行的代碼。

# 導入模塊

import math

# 現在可以調用模塊里包含的函數了

print("求e的n次冪：",math.exp(1))

# from…import 語句：從模塊中導入一個指定的部分到當前命名空間中

# 導入模塊中的特定函數

from math import exp

# 現在可以直接使用該函數了

print("求e的n次冪：",exp(1))

# from…import* 語句：導入一個模塊中的所有項目。然而這種聲明不該被過多地使用

from math import *

2020年最新python教程

如果你處于想學python或者正在學習python，python的教程不少了吧，但是是最新的嗎？

說不定你學了可能是兩年前人家就學過的內容，在這我分享一波2020最新的python全套教程最后我為大家準備了11月份新出的python自學視頻教程，共計約400集，免費分享給大家！

2020Python自學教程全新升級為《Python+數據分析+機器學習》，九大階段能力逐級提升，打造技能更全面的全棧工程師。

1.Python爬蟲基礎2.Ppython爬蟲Scrapy框架以上這些教程小編已經為大家打包準備好了，不全面找我希望對正在學習的你有所幫助！

以上資料我全部是無償分享的希望對大家有幫助的

需要DD我拿走