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

了解過了Python的發(fā)展歷史，現(xiàn)在開始我們的Python基礎(chǔ)吧，如果你有學(xué)習(xí)過其他的編程語言，你可以跳過這一篇

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

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

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

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

最后運行一下

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

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

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

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

變量的命名規(guī)則：

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

變量名的第一個字符不能是數(shù)字

不能使用python中的關(guān)鍵字

Python3中共有33個關(guān)鍵字，都不能作為變量名來使用：
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中數(shù)據(jù)類型：

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

布爾值(真或假)

String(字符串)

List(列表)

Tuple(元組)

Sets(集合)

Dictionary(字典)

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

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

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

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 的區(qū)別在于：

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()不會認(rèn)為子類是一種父類類型。isinstance()會認(rèn)為子類是一種父類類型。

當(dāng)然數(shù)據(jù)類型也可以進(jìn)行轉(zhuǎn)換

>>> type("張三")

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

>>>

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

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

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

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

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

如果你要實現(xiàn)從字符串中獲取一段子字符串的話，可以使用變量 [頭下標(biāo):尾下標(biāo)]，就可以截取相應(yīng)的字符串，其中下標(biāo)是從 0 開始算起，可以是正數(shù)或負(fù)數(shù)，下標(biāo)可以為空表示取到頭或尾。 比如:

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

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

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()) #將字符串的第一個字符轉(zhuǎn)換為大寫
#Python count() 方法用于統(tǒng)計字符串里某個字符出現(xiàn)的次數(shù)。可選參數(shù)為在字符串搜索的開始與結(jié)束位置。
print(str.count("l",0,10)) 
"""
sub – 搜索的子字符串 
start – 字符串開始搜索的位置。默認(rèn)為第一個字符,第一個字符索引值為0。 
end –字符串中結(jié)束搜索的位置。字符中第一個字符的索引為 0。默認(rèn)為字符串的最后一個位置。
"""
print(str.count("l"))
print(str.endswith("l")) #是否以l結(jié)尾返回true 和 false
print(str.endswith("o",0,5)) #在指定的范圍內(nèi)以什么結(jié)尾
print(str.find("wl")) 
print(str.index("l")) #跟find()方法一樣，只不過如果str不在字符串中會報一個異常.
print(str.isalnum()) #如果字符串至少有一個字符并且所有字符都是字母或數(shù)字則返 回 True,否則返回 False(包含其他符號都是false)
print(str.isalpha()) #如果字符串至少有一個字符并且所有字符都是字母則返回 True, 否則返回 False
print(str.isdigit()) #如果字符串只包含數(shù)字則返回 True 否則返回 False..
print(len(str)) #返回字符串長度
print(str.lower()) #轉(zhuǎn)換字符串中所有大寫字符為小寫.
print(str.upper()) #轉(zhuǎn)換字符串中的小寫字母為大寫
print(str.swapcase()) #將字符串中大寫轉(zhuǎn)換為小寫，小寫轉(zhuǎn)換為大寫
print(str.lstrip()) #截掉字符串左邊的空格或指定字符。
print(str.rstrip()) #刪除字符串字符串末尾的空格.
print(str.strip(str)) #在字符串上執(zhí)行 lstrip()和 rstrip()

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

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

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

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

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

print(list1[-2]) #從右側(cè)開始讀取，-1開始
print(list1[1:])#輸出從第二個元素開始后的所有元素
print(len(list1)) #返回列表長度
print([1, 2, 3] + [4, 5, 6]) #組合
print(list1*4) #重復(fù)
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)
#列表基礎(chǔ)操作
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]即為喜洋洋
問：索引可以為負(fù)數(shù)么
答：如果yangcun[-1]即取到最后一個元素，依次類推
問：羊村如果來了新羊怎么辦
答：yangcun.append("沸羊羊")
問：新來的小羊可以選擇自己喜歡的位置么
答：yangcun.insert(1,"沸羊羊")這樣沸羊羊就跑到美羊羊前面了
問：美羊羊的名字打錯了，怎么辦
答：別擔(dān)心，yangcun[1]="美洋洋" 就可以了
問：灰太狼來了，我想找到喜洋洋在哪，怎么找到喜洋洋的索引呢
答：yangcun.index("喜洋洋")
問：那萬一有小羊被灰太狼抓走了羊村的羊少了怎么表示
答：yangcun.pop() 即刪除list末尾的元素，yangcun.pop(1) 刪除指定索引位置的元素
問：yangcun[1:3] 這是什么語法
答：這是python中的分片，意思是取索引為1和2的元素 (其實很好記，就是顧頭不顧尾，所以索引不包含3本身)

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

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

理解列表：

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

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

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

yangcun=("喜洋洋","美羊羊","懶洋洋")
print(yangcun[0]) #喜洋洋
#元組基礎(chǔ)操作
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)   # 打印組合的元組

那么元組和列表區(qū)別：

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

元組通常由不同的數(shù)據(jù)，而列表是相同類型的數(shù)據(jù)隊列。元組表示的是結(jié)構(gòu)，而列表表示的是順序。

你不能將列表當(dāng)作字典的key， 而元組可以。

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

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

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

title=" hello world "

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

字典一種key - value 的數(shù)據(jù)類型，使用就像我們上學(xué)用的字典，通過筆劃、字母來查對應(yīng)頁的詳細(xì)內(nèi)容，字典中沒有下標(biāo)是無序的

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

d={key1:value1,key2:value2}
#字典基礎(chǔ)操作
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("芳華"))#根據(jù)指定的key刪除
# print(moviesdict.keys())
print(moviesdict.popitem()) #刪除，末尾元素
# moviesdict.clear()
print(moviesdict.keys()) 
print(moviesdict.get("芳華")) #根據(jù)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())

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

Python運算符分類:

算數(shù)運算符（+ - / /% * //）

關(guān)系運算符（== != > < >= <=）

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

邏輯運算符（and or not ）

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

成員運算符（in not in）

身份運算符（is is not）

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

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

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

huitailang="灰太狼"

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

#多條件：else if 存在多個，但是不能獨立出現(xiàn)，必須和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("灰太狼自己去抓羊")    

要是用代碼來試下應(yīng)該怎么做

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

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

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

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

循環(huán)很好理解，循環(huán)也就是重復(fù)，重復(fù)某一個語句

第一種：while循環(huán),來大家和我一起寫下面的代碼執(zhí)行下

while True:
    print("當(dāng)條件成立的時候執(zhí)行")

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

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

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

第二種：for循環(huán) 我們用for 來數(shù)一數(shù)羊村里面的羊吧

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

輸出結(jié)果：
喜洋洋
懶洋洋
美羊羊
沸羊羊

怎么跳轉(zhuǎn)循環(huán)（break、continue）

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

輸出結(jié)果：
喜洋洋
懶洋洋

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

輸出結(jié)果：
喜洋洋
懶洋洋
沸羊羊

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

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

通過上面你應(yīng)該get到的Python基礎(chǔ)語法，數(shù)據(jù)類型，分支，循環(huán)