摘要：會認為子類是一種父類類型。一般記為它是編程語言中表示文本的數據類型。運算是與運算，只有所有都為，運算結果才是布爾值經常用在條件判斷中列表列表是中使用最頻繁的數據類型。是中內置的一種數據類型，可以隨時添加和刪除其中的元素。

了解過了Python的發展歷史，現在開始我們的Python基礎吧，如果你有學習過其他的編程語言，你可以跳過這一篇

開發python的工具你可以自己選擇， 這里我推薦的是PyCharm界面操作和webstorm一樣，要是你弄過前端，肯定很熟悉

軟件的下載安裝步驟，可以看下這個文章：
http://blog.csdn.net/qq_29883...

安好之后呢，來創建一個項目，寫一句滿滿儀式感的hello world
File->New Project ..

這個地方選擇你的python安裝路徑，點擊create即可完成創建，項目創建好了，開始創建我們的文件

最后運行一下

什么是變量？給你一個官方一點的回答：
變量指向各種類型值的名字，以后再用到這個值時，直接引用名字即可

Python中定義一個變量的語法：

name="小明" #變量名=變量對應的值
name=input("請輸入姓名")

這樣我們就成功的定義一個變量，和其他編程語言不一樣的是變量沒有數據類型的修飾，這就是前面我們說過的動態類型，變量的類型由值來決定
問：噗，還有一個問題上面那個#號什么鬼
答：在python中#為單行注釋，多行注釋 """ 注釋內容 """
問：那input又是什么
答：python3.X里input是接收用戶輸入，這個時候會讓你輸入姓名并賦值給變量name,在python2.X里面時raw_input

變量的命名規則：

變量名只能是 字母、數字或下劃線的任意組合

變量名的第一個字符不能是數字

不能使用python中的關鍵字

Python3中共有33個關鍵字，都不能作為變量名來使用：
False/None/True/and/as/assert/break/class/continue/def/del/elif/else/except/finally/for/from/global/if/import/in/nonlocal/lambda/is/not/or/pass/raise/return/try/while/with/yield

Python中數據類型：

Number(數字) Python3支持3種不同的數值類型：整型(int)、浮點型(float)、復數(complex)

布爾值(真或假)

String(字符串)

List(列表)

Tuple(元組)

Sets(集合)

Dictionary(字典)

小故事：為什么叫布爾值? 為了紀念一個人他的名字叫布爾，他出版的《邏輯的數學分析》、《思維規律的研究》以他名字命名布爾代數，因為他在符號邏輯運算中做的的特殊貢獻，很多計算機語言中將邏輯運算稱為布爾運算，運算的結果稱為布爾值

通過type()來查看數據類型

Microsoft Windows [版本 6.1.7601]
版權所有 (c) 2009 Microsoft Corporation。保留所有權利。

C:UsersAdministrator>python
Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 17:26:49) [MSC v.1900 32 bit (Intel)]
 on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> type("張三")

>>>

此外還可以用 isinstance 來判斷：

a = 111
isinstance(a, int)
True

isinstance 和 type 的區別在于：

class A:
    pass

class B(A):
    pass

print(isinstance(A(),A)) # True
print(isinstance(B(),A)) # True
print(type(A())==A)      # True
print(type(B())==A)      # False
#type()不會認為子類是一種父類類型。isinstance()會認為子類是一種父類類型。

當然數據類型也可以進行轉換

>>> type("張三")

>>> type(int("18"))

>>>

#一、數據類型轉換
# number="1"
# number=1
# number="True"
# number="aa,bb,cc"
# number=65
number="A"
print(type(number))
print(number)
# number1=int(number) #轉換為int
# number1=float(number) #轉換為float
# number1=str(number) #轉換為str
# number1=bool(number) #轉換為str
# number1=list(number) #轉換為一個列表
# number1=chr(number) #將一個整數轉換為一個字符
# number1=ord(number) #將一個字符轉換為它的整數值
print(type(number1))
print(number1)

字符串(String)是由數字、字母、下劃線組成的一串字符。一般用一對單引號或雙引號或三引號來包裹。一般記為 : s = "a1a2···an" 它是編程語言中表示文本的數據類型。
轉義字符：在需要在字符中使用特殊字符時，python用反斜杠()轉義字符。

python的字符串列表有2種取值順序:

從左到右索引默認0開始的，最大范圍是字符串長度少1

從右到左索引默認-1開始的，最大范圍是字符串開頭

如果你要實現從字符串中獲取一段子字符串的話，可以使用變量 [頭下標:尾下標]，就可以截取相應的字符串，其中下標是從 0 開始算起，可以是正數或負數，下標可以為空表示取到頭或尾。 比如:

s = "ilovepython"
# s[1:5]的結果是love。

使用上述方式獲取的新字符串為“love”。而s[1]的值為 l，s[5]的值為p。
不難發現：上面的結果包含了左邊界的值（s[1]`的值l），而不包括右邊界的值（s[5]的值p）。
加號（+）是字符串連接運算符，星號（*）是重復操作。如下實例：

str = "Hello World!"
str=R"helloPython"
print("ha" not in str)
print(str)          # 輸出完整字符串
print(str[0])        # 輸出字符串中的第一個字符
print(str[2:5])      # 輸出字符串中第三個至第五個之間的字符串
print(str[2:])       # 輸出從第三個字符開始的字符串
print(str * 2 )      # 輸出字符串兩次
print(str + "TEST")  # 輸出連接的字符串 
#完整版
str=" Hello python ll5 "
print(str.capitalize()) #將字符串的第一個字符轉換為大寫
#Python count() 方法用于統計字符串里某個字符出現的次數。可選參數為在字符串搜索的開始與結束位置。
print(str.count("l",0,10)) 
"""
sub – 搜索的子字符串 
start – 字符串開始搜索的位置。默認為第一個字符,第一個字符索引值為0。 
end –字符串中結束搜索的位置。字符中第一個字符的索引為 0。默認為字符串的最后一個位置。
"""
print(str.count("l"))
print(str.endswith("l")) #是否以l結尾返回true 和 false
print(str.endswith("o",0,5)) #在指定的范圍內以什么結尾
print(str.find("wl")) 
print(str.index("l")) #跟find()方法一樣，只不過如果str不在字符串中會報一個異常.
print(str.isalnum()) #如果字符串至少有一個字符并且所有字符都是字母或數字則返 回 True,否則返回 False(包含其他符號都是false)
print(str.isalpha()) #如果字符串至少有一個字符并且所有字符都是字母則返回 True, 否則返回 False
print(str.isdigit()) #如果字符串只包含數字則返回 True 否則返回 False..
print(len(str)) #返回字符串長度
print(str.lower()) #轉換字符串中所有大寫字符為小寫.
print(str.upper()) #轉換字符串中的小寫字母為大寫
print(str.swapcase()) #將字符串中大寫轉換為小寫，小寫轉換為大寫
print(str.lstrip()) #截掉字符串左邊的空格或指定字符。
print(str.rstrip()) #刪除字符串字符串末尾的空格.
print(str.strip(str)) #在字符串上執行 lstrip()和 rstrip()

布爾值和布爾代數的表示完全一致，一個布爾值只有True、False兩種值，要么是True，要么是False，在Python中，可以直接用True、False表示布爾值（請注意大小寫），也可以通過布爾運算計算出來：

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5
False

布爾值可以用and、or和not運算。and運算是與運算，只有所有都為True，and運算結果才是True：布爾值經常用在條件判斷中

List（列表） 是 Python 中使用最頻繁的數據類型。列表用 [ ] 標識，是 python 最通用的復合數據類型,應該不會有疑問列表是什么吧，舉個例子，喜洋洋是一只羊，那么羊村里面的羊是不是就應該用列表來表示了。list是python中內置的一種數據類型，可以隨時添加和刪除其中的元素。

list1 = ["Google", "Baidu", 1997, 2000];

print(list1[-2]) #從右側開始讀取，-1開始
print(list1[1:])#輸出從第二個元素開始后的所有元素
print(len(list1)) #返回列表長度
print([1, 2, 3] + [4, 5, 6]) #組合
print(list1*4) #重復
print(1997 in list1) #元素是否存在于列表中
#迭代
for x in list1: 
    print(x)
#列表嵌套
list2=[1,2,3]    
list1=["baidu",list2]
print(list1[1][5]) #輸出2
print(max([1,2,3])) #輸出3
print(min([1,2,3])) #輸出1
yangcun=["喜洋洋","美羊羊","懶洋洋"]#定義一個列表
print(yangcun)
#列表基礎操作
list = [ "runoob", 786 , 2.23, "john", 70.2 ]
tinylist = [123, "john"]
# list.clear()
# list.reverse()
print(list)               # 輸出完整列表
print(list[0])            # 輸出列表的第一個元素
print(list[1:3])          # 輸出第二個至第三個的元素 
print(list[2:] )          # 輸出從第三個開始至列表末尾的所有元素
print(tinylist * 2)       # 輸出列表兩次
print(list + tinylist)    # 打印組合的列表

問：如何獲取到列表的某一個元素呢？
答：通過索引的方式，注意索引從0開始yangcun[0]即為喜洋洋
問：索引可以為負數么
答：如果yangcun[-1]即取到最后一個元素，依次類推
問：羊村如果來了新羊怎么辦
答：yangcun.append("沸羊羊")
問：新來的小羊可以選擇自己喜歡的位置么
答：yangcun.insert(1,"沸羊羊")這樣沸羊羊就跑到美羊羊前面了
問：美羊羊的名字打錯了，怎么辦
答：別擔心，yangcun[1]="美洋洋" 就可以了
問：灰太狼來了，我想找到喜洋洋在哪，怎么找到喜洋洋的索引呢
答：yangcun.index("喜洋洋")
問：那萬一有小羊被灰太狼抓走了羊村的羊少了怎么表示
答：yangcun.pop() 即刪除list末尾的元素，yangcun.pop(1) 刪除指定索引位置的元素
問：yangcun[1:3] 這是什么語法
答：這是python中的分片，意思是取索引為1和2的元素 (其實很好記，就是顧頭不顧尾，所以索引不包含3本身)

呼呼~ 一連串的問題下來大家應該get到了基本的列表操作，當然這還不夠全，你可以輸入完列表名稱.后看下給出的提示上面的方法都可以試一試。

yangcun=["喜洋洋","美羊羊","懶洋洋",["小羊1","小羊2"]]
xinyangcun=yangcun.copy();
yangcun2=yangcun[:];
yangcun[3][0]="小小羊"
print(xinyangcun[3][0]) #問：輸出結果時什么
print(yangcun2) #問：輸出什么

理解列表：

輸出的是小小羊，這個和列表的內存存儲方式有關，xinyangcun只是指向了和yangcun一樣的內存地址，但是當這塊空間的內容變了，最后輸出的內容肯定就變了，反過來即你改變xinyangcun的值yangcun也會跟著變。

輸出["喜洋洋","美羊羊","懶洋洋",["小羊1","小羊2"]]

元素和列表概念上其實是一樣的，最大的區別是元組一旦創建不能修改，所以可以成為只讀列表,定義上用()

yangcun=("喜洋洋","美羊羊","懶洋洋")
print(yangcun[0]) #喜洋洋
#元組基礎操作
tuple = ( "runoob", 786 , 2.23, "john", 70.2 )
tinytuple = (123, "john")

print(tuple)               # 輸出完整元組
print(tuple[0])            # 輸出元組的第一個元素
print(tuple[1:3])          # 輸出第二個至第三個的元素 
print(tuple[2:])           # 輸出從第三個開始至列表末尾的所有元素
print(tinytuple * 2)       # 輸出元組兩次
print(tuple + tinytuple)   # 打印組合的元組

那么元組和列表區別：

Tuples are immutable, lists are mutable.（元組是不可變的， 而列表是可變的）

元組通常由不同的數據，而列表是相同類型的數據隊列。元組表示的是結構，而列表表示的是順序。

你不能將列表當作字典的key， 而元組可以。

由于元組支持的操作比列表小， 所以元組會比列表稍快

a=(1,2)
b=[4,5]

c={a:"tuples"}
c={b:"list"}

title=" hello world "

print(title.capitalize()) #Hello world 首字母大寫
print(title.casefold()) #全部轉換為小寫
print(title.upper()) #全部轉換為大寫
print(title.swapcase()) #大小寫互轉
print(title.center(30,"-")) #---------hello world----------
print(title.find("h")) #查找返回索引 0，找不到返回-1
print(title.index("h"))#返回所在索引
print(title.endswith("com"))#判斷是否以com結尾 False
print(title.strip()) #刪除字符串兩邊的指定字符，括號的寫入指定字符，默認為空格
print(len(title)) #字符串長度
print(title.count("l"))#字符串統計，出現的次數
print(title.replace("l", "a"))  #替換字符串
print(title.split(" ")) #字符串分隔
print("aa".isalpha())  # 是否是英文字母，返回布爾值
print("111".isdigit())  # 是否是數字，返回布爾值
print("_name".isidentifier())  # 是否是一個合法的變量名，返回布爾值
print("aaaAAAA".islower())  # 是否是小寫字母，返回布爾值
print("AAAAA".isupper())  # 是否是大寫字母，返回布爾值

字典一種key - value 的數據類型，使用就像我們上學用的字典，通過筆劃、字母來查對應頁的詳細內容，字典中沒有下標是無序的

列表和字典兩者之間的區別在于：字典當中的元素是通過鍵來存取的，而不是通過索引存取。
字典的創建格式如下：注意鍵必須唯一

d={key1:value1,key2:value2}
#字典基礎操作
dict = {}
dict["one"] = "This is one"
dict[2] = "This is two"

tinydict = {"name": "john","code":6734, "dept": "sales"}


print(dict["one"])          # 輸出鍵為"one" 的值
print(dict[2])              # 輸出鍵為 2 的值
print(tinydict)             # 輸出完整的字典
print(tinydict.keys())      # 輸出所有鍵
print(tinydict.values())    # 輸出所有值

moviesdict={
    "芳華":"黃軒",
    "心理罪":"鄧超"
}
print(moviesdict.items())
print(moviesdict.keys())
print(moviesdict.values())
print("芳華" in moviesdict) #指定的key在列表中是否存在
# print(moviesdict.pop("芳華"))#根據指定的key刪除
# print(moviesdict.keys())
print(moviesdict.popitem()) #刪除，末尾元素
# moviesdict.clear()
print(moviesdict.keys()) 
print(moviesdict.get("芳華")) #根據key找value

字典常用方法：

yang={
    "y1":"美羊羊",
    "y2":"懶洋洋",
    "y3":"喜洋洋",
    "y4":"沸羊羊"
}
#添加
yang["y5"]="慢羊羊"
#通過key來取值
print(yang["y1"])
#修改
yang["y1"]="美羊羊1"
print(yang)
#刪除
del yang["y1"]
print(yang)
#查找
print(yang.get("y2"))
print(yang.keys());#獲取所有的key
print(yang.items())

集合就像舍棄了值，僅剩下鍵的字典一樣，鍵與鍵之間也不允許重復，如果你僅僅想知道某一個元素是否存在而不關心其他的，使用集合是一個非常不錯的選擇，如果需要為鍵附加其他信息的話，建議使用字典
set是無序的集合，不能有重復的元素，也不能排序，sort()是不能使用的。同列表相比set驗證元素是否存在會更快。注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。
創建一個set：myset = {3, 4, 5, 1}
type(myset) 輸出 set

Python運算符分類:

算數運算符（+ - / /% * //）

關系運算符（== != > < >= <=）

賦值運算符（= += -= = /= %= *= //=）

邏輯運算符（and or not ）

位運算符（& | ^ ~ << >>）

成員運算符（in not in）

身份運算符（is is not）

以上的運算符其實看字面意思都可以，這里挑幾個和其他語言中不一樣的運算符做下解釋：
** ：冪，返回x 的 y次冪
// ：返回商的整數部分
in ：如果在指定的序列中找到值，就返回True，否則false
is ：is 判斷兩個標識符是否引用自一個對象

分支又稱為流程控制，什么意思呢，也就是計算機其實比較傻的，如果你不告訴它該怎么執行，它會從第一行按序一行一行執行，但是我們的程序都是有邏輯，就是指揮計算機應該怎么執行我們寫的代碼。

要是上面我寫的這一長串，你懶得看的話，可以看看下圖(喜洋洋與灰太狼)幫助你更好的理解分支語句
][8]

huitailang="灰太狼"

#基礎用法
# hongtailang=input("請輸入紅太狼想不想吃羊:")
# if hongtailang=="吃羊":
#     # 坑
#       print("紅太狼逼灰太狼去抓羊")
#       print("啦啦啦啦啦") 
# else:
#     print("灰太狼自己去抓羊")    
#     print("lalla")

#多條件：else if 存在多個，但是不能獨立出現，必須和if ,可以沒有else
# yang=input("灰太狼抓到了哪只羊:")
# if yang=="喜洋洋":
#     print("成功逃離")
# elif yang=="美羊羊":
#     print("等待喜洋洋來就她")
# elif yang=="懶洋洋":
#     print("哭")
# else:
#     print("吃了")      

#分支嵌套：不建議嵌套太多層 3
hongtailang=input("請輸入紅太狼想不想吃羊:")
if hongtailang=="吃羊":
    yang=input("灰太狼抓到了哪只羊:")
    if yang=="喜洋洋":
        print("成功逃離")
    elif yang=="美羊羊":
        print("等待喜洋洋來就她")
    elif yang=="懶洋洋":
        print("哭")
    else:
        print("吃了") 
else:
    print("灰太狼自己去抓羊")    

要是用代碼來試下應該怎么做

huitailang="灰太狼"
hongtailang=input("紅太狼是否想吃羊：")
if hongtailang=="吃羊":
    print("紅太狼逼灰太狼去抓羊")
else:
    print("{name}自己去抓羊".format(name=huitailang))

語法上面和其他語言并沒有變化太多，縮進這種語法當你看習慣了就會發現很不錯
問：print前面的縮進或者那個冒號刪了可以么
答：都不可以刪，會報語法錯誤
問：python中是否和其他語言中一樣存在else if ?
答：當然，但是不叫else if ，算是一個小簡寫 elif ，注意elif不能多帶帶使用，必須和if 結合使用

上面的if弄明白了么，我們來加點料做個if的嵌套，情景：當灰太狼遇見喜洋洋

huitailang="灰太狼"
xiyangyang="喜洋洋"
hongtailang=input("紅太狼是否想吃羊：")
if hongtailang=="吃羊":
    print("紅太狼逼灰太狼去抓羊")
else:
    print("{name}自己去抓羊".format(name=huitailang))
    yang=input("抓到哪只羊：")
    if yang==xiyangyang:
        print("成功逃離")
    else:
        print("抓到羊")

循環很好理解，循環也就是重復，重復某一個語句

第一種：while循環,來大家和我一起寫下面的代碼執行下

while True:
    print("當條件成立的時候執行")

大家看到什么結果？為了讓大家對這個循環條件的作用理解深刻一些，發現一不小心寫了一個死循環，這也是我們寫循環的禁忌，怎么能避免死循環，也很簡單，在循環體內一定要有改變循環條件的代碼即可。

剛剛上圖的喜洋洋與灰太狼里，灰太狼什么時候才能抓到羊還記得么，是不是怒氣值到3的時候，那么我們來用代碼模擬下

nuqizhi=0;  #怒氣值
while nuqizhi<3:
    nuqizhi = nuqizhi + 1
    print("怒氣值為"+str(nuqizhi))
if nuqizhi==3:
    print("怒氣值夠了抓到羊")

第二種：for循環 我們用for 來數一數羊村里面的羊吧

yangcun=["喜洋洋","懶洋洋","美羊羊","沸羊羊"]
for yang in yangcun:
    print(yang)

輸出結果：
喜洋洋
懶洋洋
美羊羊
沸羊羊

怎么跳轉循環（break、continue）

yangcun=["喜洋洋","懶洋洋","美羊羊","沸羊羊"]
for yang in yangcun:
    if yang=="美羊羊":
        break;
    print(yang)

輸出結果：
喜洋洋
懶洋洋

yangcun=["喜洋洋","懶洋洋","美羊羊","沸羊羊"]
for yang in yangcun:
    if yang=="美羊羊":
        continue;
    print(yang)

輸出結果：
喜洋洋
懶洋洋
沸羊羊

在上一章我們給大家介紹了什么是編譯型語言、什么是解釋型語言，
當然還有混合型比如JAVA,JAVA執行過程是通過編譯器編譯成字節碼文件，然后在運行時通過解釋器給解釋成機器文件，所以JAVA是先編譯后解釋的語言。

而python是一門解釋型語言，那么有沒有注意到.pyc文件(在安裝路徑下的__pycache__文件夾下)，其實Python當你去執行的時候，它也做了編譯同JAVA一樣，在執行之前編譯并把編譯的結果保存在內存中，結束后寫入到.pyc文件里。第二次再運行就會先讀.pyc文件，要是沒有這個文件，就去執行編譯寫入的步驟。

通過上面你應該get到的Python基礎語法，數據類型，分支，循環