摘要：入門細(xì)節(jié)相除后的類型雙斜杠是整除，出來(lái)的類型是。序列，集合和字典屬于組，是的基本數(shù)據(jù)類型。變量名區(qū)分大小寫(xiě)。盡量避免循環(huán)引入。變量函數(shù)等引入內(nèi)指定的變量函數(shù)等。中如果沒(méi)有出現(xiàn)模塊名也是絕對(duì)導(dǎo)入。頂級(jí)包與入口文件的位置

type(2/2)
float
type(2//2)
int

雙斜杠是整除，出來(lái)的類型是int。單斜杠的出來(lái)的是float類型。

進(jìn)制表示：

二進(jìn)制：0b
八進(jìn)制：0o
十六進(jìn)制：0x

進(jìn)制轉(zhuǎn)換：

轉(zhuǎn)換為二進(jìn)制：bin()
轉(zhuǎn)換為八進(jìn)制：oct()
轉(zhuǎn)換為十進(jìn)制：int()
轉(zhuǎn)換為十六進(jìn)制：hex()
轉(zhuǎn)換為布爾類型：bool()

布爾類型轉(zhuǎn)換：bool()

布爾類型屬于數(shù)字這個(gè)基本數(shù)據(jù)類型里面

只要是非零的數(shù)字，bool類型的值為True

對(duì)于字符串，布爾類型為True，除了空字符串

bool值為False:

bool(0)
bool("") 中間沒(méi)有空格
bool([])
bool({})
bool(None)
bool(NoneType)
bool(set{})

三個(gè)引號(hào)可以再IDLE下回車不會(huì)執(zhí)行換行。print函數(shù)可以輸出n這樣的反義字符。
單個(gè)引號(hào)想回車換行可以再前面加上字符即可。

"""
sadasdj
adas
"""
Out[1]: "
sadasdj
adas
"

"asda
  File "", line 1
    "asda
         ^
SyntaxError: EOL while scanning string literal


"asdd
adsad
sad"
Out[3]: "asddadsadsad"

print("asda
sada
")
asda
sada


"""
asda

"""
Out[5]: "
asda

"

原始字符串在print時(shí)只是輸出里面的字符，不考慮反義之類的，小心r大寫(xiě)R都沒(méi)有關(guān)系。

print(r"c:
sda
sds")
c:
sda
sds

print(r"let"s go")
  File "", line 1
    print(r"let"s go")
                ^
SyntaxError: invalid syntax

1.字符串的"+"和"*"

"hello"+"world"
Out[1]: "helloworld"

"hello"*3
Out[2]: "hellohellohello"

2.獲取字符串里的字符

"hello world"[0]
Out[3]: "h"

"hello world"[-1]
Out[4]: "d"

# 包括左面但是不包括右面
"hello world"[0:4]
Out[5]: "hell"

"hello world"[0:-1]
Out[6]: "hello worl"

# 超出長(zhǎng)度時(shí)會(huì)按字符串最大的長(zhǎng)度進(jìn)行截取
"hello world"[0:20]
Out[7]: "hello world"
# 沒(méi)有右邊的值的時(shí)候，表示直接輸出到末尾
"hello world"[6:]
Out[8]: "world"
# 負(fù)數(shù)在冒號(hào)前面的時(shí)候
"hello world"[-4:]
Out[9]: "orld"

列表中的元素可以是任意類型的組合，比如列表的嵌套，布爾類型，字符串等等。

1.1 基本操作
1.1.1 基本選取(切片）

["新月打擊","蒼白之瀑","月之降臨","月神沖刺"]
Out[10]: ["新月打擊", "蒼白之瀑", "月之降臨", "月神沖刺"]

["新月打擊","蒼白之瀑","月之降臨","月神沖刺"][0]
Out[11]: "新月打擊"

["新月打擊","蒼白之瀑","月之降臨","月神沖刺"][0:2]
Out[12]: ["新月打擊", "蒼白之瀑"]

["新月打擊","蒼白之瀑","月之降臨","月神沖刺"][-1:]
Out[13]: ["月神沖刺"]


a = [1,2,3,4,5,6,7,8]
print(a[0:3])
print(a[0:len(a):2])
print(a[len(a):0:-2])

[1, 2, 3]
[1, 3, 5, 7]
[8, 6, 4, 2]

#可以看到，切片操作很簡(jiǎn)單，第二個(gè)冒號(hào)后面的數(shù)字可以看作是步長(zhǎng)。注意負(fù)數(shù)時(shí)的用法。

可以看到，當(dāng)沒(méi)有冒號(hào)的時(shí)候，單個(gè)選取出的是元素的類型。但是當(dāng)有冒號(hào)的時(shí)候，選取出的是序列的類型。這里需要注意

1.1.2 列表的相加和乘法

["新月打擊","蒼白之瀑","月之降臨","月神沖刺"]+["虛弱","點(diǎn)燃"]
Out[14]: ["新月打擊", "蒼白之瀑", "月之降臨", "月神沖刺", "虛弱", "點(diǎn)燃"]

["虛弱","點(diǎn)燃"]*3
Out[15]: ["虛弱", "點(diǎn)燃", "虛弱", "點(diǎn)燃", "虛弱", "點(diǎn)燃"]

1.1.3 判斷元素是否存在

運(yùn)用in和not in即可

3 in [1,2,3,4]
Out[21]: True

3 not in [1,2,3,4]
Out[22]: False

1.1.4 計(jì)算長(zhǎng)度，最大小值

len([1,2,3])
Out[23]: 3

len("hesadad")
Out[24]: 7

max([1,2,3,4,5,6])
Out[25]: 6

min([1,2,3,4])
Out[26]: 1

1.1.5 append()
可以向列表中追加元素。

a = [1,2,3,4]

a.append("5")

Out[22]: [1, 2, 3, 4, "5"]

元組的操作，包括訪問(wèn)，加，乘，in等操作和列表是相同的。

需要注意一點(diǎn)是：

type((1))
Out[16]: int

type(("sd"))
Out[17]: str

type((1,2,3))
Out[18]: tuple

如果括號(hào)里有一個(gè)元素，默認(rèn)為是一個(gè)運(yùn)算，不會(huì)認(rèn)為是元組的括號(hào)。如果要定義只有一個(gè)元素的元組的：

type((1,))
Out[19]: tuple
# 括號(hào)里面什么都沒(méi)有表示一個(gè)空元組
type(())
Out[20]: tuple

元組是序列，不可變類型，但是如果元組里包含了列表，比如：

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

a[3][1] = "2"

print(a)
(1, 2, 3, [4, "2"])

我們可以看到元組里的列表可以改變

字符串和元組都是不可變的類型
序列包括了字符串，列表和元組，序列都可以用下標(biāo)索引和切片的方式。

set集合里的元素是無(wú)序的，不重復(fù)的。

in,not in,len,max,min,但是沒(méi)有加，乘這種操作。

集合有相減，交集，并集等操作

{1,2,3,4,5,6} - {1,2}
Out[1]: {3, 4, 5, 6}

{1,2,3,4,5,6} & {1,2}
Out[2]: {1, 2}

{1,2,3,4,5,6} | {1,2,7}
Out[3]: {1, 2, 3, 4, 5, 6, 7}

定義一個(gè)空集合的方法：set()

type({})
Out[8]: dict

type(set())
Out[9]: set

len(set())
Out[10]: 0

字典和集合類型(set)有些類似，里面是無(wú)序的，所以字典不是序列。

字典中可以value可以使任意類型；但是key是可以的，key必須是不可變的類型，比如Int,str,tuple等，例如list就是不可以的。

字典的訪問(wèn)：{"key1":"value1,"key2":"value2"}["key1"]，字典的訪問(wèn)通過(guò)key來(lái)進(jìn)行

字典里，key值是不可以重復(fù)的，如果定義有重復(fù)雖然不會(huì)報(bào)錯(cuò)，但是會(huì)自動(dòng)選擇其中一個(gè)。

序列，集合和字典屬于組，是Python的基本數(shù)據(jù)類型。

變量的定義時(shí)，首字母不能是數(shù)字，但可以是下劃線。字母，數(shù)組，下劃線可以組成變量。

Python 變量名區(qū)分大小寫(xiě)。定義變量的時(shí)候不用指明類型，和C++不一樣。

值類型和引用類型：

a = 1

b = a

a = 3

print(b)
1

a = [1,2,3,4]

b = a

a[0] = "1"

print(b)
["1", 2, 3, 4]

值類型：int str tuple（不可改變），在重新定義的時(shí)候，因?yàn)椴豢筛淖儠?huì)生成一個(gè)新的對(duì)象，這個(gè)時(shí)候b仍然指向原對(duì)象，a指向了一個(gè)新對(duì)象
引用類型:list,set,dict（可以改變），在定義一個(gè)新對(duì)象的時(shí)候，會(huì)在原對(duì)象的基礎(chǔ)上進(jìn)行改變而不產(chǎn)生新對(duì)象，所以無(wú)論是a還是b都會(huì)指向已經(jīng)改變的原對(duì)象，所以a和b的值都會(huì)變化。

再進(jìn)一步的，可以看以下代碼:

a = "hello"

id(a)
Out[15]: 1510080259608

a = a + "s"

id(a)
Out[17]: 1510081716832

a[0] = "s"
Traceback (most recent call last):

  File "", line 1, in 
    a[0] = "s"

TypeError: "str" object does not support item assignment

id()是查詢?cè)谟?jì)算機(jī)中的內(nèi)存位置，我們可以看到發(fā)生了變化。所以a = a + "s"是可以的。但是對(duì)字符串的賦值操作，是不可以的，因?yàn)閟tr是不可變的類型。

python中是沒(méi)有自增和自減這種操作的。

表示“等于”是"==",“不等于”是"!="

字符串相比較的時(shí)候，把字符串中每一個(gè)字符拿出來(lái)相比較，比較AscII碼值

比較兩個(gè)列表，和字符串是相同的。元組也可以進(jìn)行比較，和列表和字符串是相同的。

非bool類型在參與邏輯運(yùn)算的時(shí)候，比如int,float,str等類型，在參與and,or,not的時(shí)候，遵循的規(guī)則和c++中類似。

0 and 1
Out[1]: 0

1 and 2
Out[2]: 2

1 and 0
Out[3]: 0

1 or 2
Out[4]: 1

0 or 1
Out[5]: 1

由上面的例子我們可以看出and和or的邏輯判斷規(guī)則和c++一致?？兆址?，0等判斷為空，在上面的筆記中有記載。

成員運(yùn)算符: in, not in

成員運(yùn)算符表示一個(gè)元素是否在一個(gè)組里；成員運(yùn)算符返回值類型是bool類型。在字典中，是判斷key值。

a = 1

a in {1:"1"}
Out[7]: True

a = "1"

a in {1:"1"}
Out[9]: False

身份運(yùn)算符

is, is not
身份運(yùn)算符比較的是身份而不是值，簡(jiǎn)單來(lái)說(shuō)就是內(nèi)存地址。和關(guān)系運(yùn)算符“==”不一樣。

a = 1

b = 1

a is b
Out[12]: True

id(a)
Out[13]: 1438837200

id(b)
Out[14]: 1438837200

b = 1.0

a is b
Out[16]: False

id(b)
Out[17]: 2197963106536

a ==b
Out[18]: True

a = {1,2,3}

b = {2,1,3}

a==b
Out[21]: True

a is b
Out[22]: False

c = (1,2,3)

d = (2,1,3)

c ==d
Out[25]: False

c is d
Out[26]: False

id(a)
Out[27]: 2197907160424

id(b)
Out[28]: 2197990760232

我們可以看到，在無(wú)序的set集合中，元素順序不一樣在內(nèi)存中位置不同，雖然值相同但是身份仍然不一樣。

位運(yùn)算符

&, |, ^, ~, <<, >>
以上都是把數(shù)字當(dāng)作二進(jìn)制進(jìn)行運(yùn)算。把數(shù)字按照二進(jìn)制進(jìn)行換算，以&舉例，相同位1，不同為0。然后再把二進(jìn)制數(shù)轉(zhuǎn)換成數(shù)字原來(lái)的進(jìn)制。eg: 2&3 == 2

python中一切都是對(duì)象，對(duì)象有三大特征，值(value), 身份(id), 類型(type)。判斷變量的類型，可以使用isinstance()這個(gè)函數(shù)。

a = "sds"

isinstance(a,str)
Out[30]: True

isinstance(a,(str,int,float))
Out[31]: True

isinstance(a,int)
Out[32]: False

isinstance可以判斷對(duì)象中的子類是否滿足條件，所以比較好。

+　單行注釋：＃　快捷鍵：ctrl + /
+　多行注釋：""" """ 快捷鍵：alt + shift + a

每個(gè)文件（模塊）需要有開(kāi)篇的注釋來(lái)說(shuō)明作用。

python中不存在常量（constant）一說(shuō)，但是對(duì)于形式上的常量，一般以全部大寫(xiě)來(lái)表示

Python變量中兩個(gè)名字的銜接用下劃線，eg:test_account.

包和模塊是不會(huì)被重復(fù)導(dǎo)入的。

盡量避免循環(huán)引入。

導(dǎo)入一個(gè)模塊的時(shí)候，會(huì)執(zhí)行這個(gè)模塊里面的代碼。

python中的普通模塊必須有一個(gè)包，當(dāng)想要把一個(gè)可執(zhí)行文件當(dāng)作一個(gè)普通模塊運(yùn)行時(shí)，可以使用-m參數(shù)，如：
python -m 命名空間.模塊名
注意：此處若當(dāng)作普通模塊，必須包括包名/命名空間。python中可執(zhí)行文件沒(méi)有所屬包。此外，當(dāng)使用-m參數(shù)后，頂級(jí)包也相對(duì)改變。

用來(lái)查看模塊或者類內(nèi)部的變量，包括系統(tǒng)內(nèi)置變量。

import sys
infos = dir(sys)
print(infos)


["__displayhook__", "__doc__", "__excepthook__", "__interactivehook__", "__loader__", "__name__", "__package__", "__spec__", "__stderr__", "__stdin__", "__stdout__", "_clear_type_cache", "_current_frames", "_debugmallocstats", "_enablelegacywindowsfsencoding",......]

# 可見(jiàn)打出了許多的變量，是sys模塊內(nèi)部的變量。下面的代碼中也有應(yīng)用，只不過(guò)沒(méi)有參數(shù)。

if __name__ == "__main__":
    pass

#來(lái)判斷模塊是否被當(dāng)作入口文件被調(diào)用，如果被當(dāng)做模塊就不會(huì)打印if條件成立執(zhí)行的語(yǔ)句，如果被當(dāng)做入口文件才會(huì)執(zhí)行

# 由父包引入子包或者同級(jí)別引入的情況

import module  # 只能引入同一個(gè)包（不包括子包）里的模塊。注意這里不能直接引入模塊的變量。

import module as name  # 使用的時(shí)候name.變量/函數(shù)等。

from packet import module # 可以父包里的子包引入模塊。

from packet.module import module.變量/函數(shù)等 

from module import *  # 引入module內(nèi)__all__指定的變量/函數(shù)等。

from module import module.變量1, module.變量2,......  # 引入多個(gè)變量可用逗號(hào)隔開(kāi)

該文件，可以在導(dǎo)入一個(gè)包，或者導(dǎo)入包中的函數(shù)的時(shí)候，系統(tǒng)會(huì)首先執(zhí)行該文件。

from packet import *  # 這行代碼會(huì)引入被引入包中__init__.py中__all__指定的模塊。

a = 2
b = 1
infos = dir()
print(infos)

["__annotations__", "__builtins__", "__cached__", "__doc__", "__file__", "__loader__", "__name__", "__package__", "__spec__", "a", "b"]

# 上方除了"a","b"都是系統(tǒng)內(nèi)置的變量。

下面介紹幾個(gè)比較重要的內(nèi)置變量，利用import一個(gè)模塊的時(shí)候會(huì)執(zhí)行該模塊里面的內(nèi)容的機(jī)制。對(duì)于入口文件和模塊文件，內(nèi)置變量的值有所不同。

模塊文件：

"""
this is a c3 doc
"""
print("name: "+__name__)
print("package: "+__package__)
print("doc: "+__doc__)
print("flie: "+__file__)

import sub11.c3

PS D:pycodesub1> python c2.py
name: sub11.c3
package: sub11
doc:
this is a c3 doc

flie: D:pycodesub1sub11c3.py

# __doc__記錄的是該模塊的開(kāi)頭注釋

# __name__記錄該模塊的名字

# __package__記錄該模塊屬于的包

# __file__記錄該模塊的文件的絕對(duì)路徑

入口文件

如果一個(gè).py文件被當(dāng)做一個(gè)應(yīng)用程序的入口：
①它的名稱不再是本身的模塊名稱，而是被強(qiáng)制更改為_(kāi)_main__
②它不屬于任何包
③file內(nèi)置變量不會(huì)像普通模塊一樣顯示絕對(duì)路徑，它所顯示的值也不是確定值，和執(zhí)行命令所在目錄有關(guān)
注：python入口文件和普通導(dǎo)入的模塊文件是有差異的。

"""
this is a c3 doc
"""
print("name: "+__name__)
print("package: "+ ( __package__ or "當(dāng)前模塊不屬于任何包"))
print("doc: "+__doc__)
print("flie: "+__file__)



name: __main__
package: 當(dāng)前模塊不屬于任何包
doc:
this is a c3 doc

flie: c3.py

# 該文件屬于sub11包（有__init__.py這個(gè)文件），但是我們是直接執(zhí)行的c3.py文件，可見(jiàn)此時(shí)如果在c3.py中打印內(nèi)置變量，__name__被強(qiáng)制定位__main__，而且package上也不會(huì)顯示出所屬于的包，file路徑也發(fā)生了變化。

導(dǎo)入機(jī)制：

python模塊導(dǎo)入時(shí)的搜索路徑：

程序主目錄，執(zhí)行程序是包含執(zhí)行代碼文件的目錄，交互模式下為當(dāng)前工作目錄,優(yōu)先級(jí)最高

PYTHONPATH中的目錄

標(biāo)準(zhǔn)鏈接庫(kù)目錄，就是python的安裝目錄，源碼在里面

3.x 中可以用.pth 文件

以上這些構(gòu)成了sys.path。你寫(xiě)的模塊存儲(chǔ)路徑在sys.path 里面就可以import。

絕對(duì)導(dǎo)入是指從入口文件引入執(zhí)行文件所在的文件夾的包中的模塊的時(shí)候，需要進(jìn)行絕對(duì)導(dǎo)入。from ... import...中如果沒(méi)有出現(xiàn).模塊名,也是絕對(duì)導(dǎo)入。

相對(duì)導(dǎo)入指從模塊引入父級(jí)的模塊時(shí)，需要進(jìn)行相對(duì)導(dǎo)入。在入口文件切記不能使用相對(duì)導(dǎo)入，即帶.號(hào)。比如你多帶帶運(yùn)行某個(gè)模塊，但是在這個(gè)模塊里你用了相對(duì)導(dǎo)入，那么就會(huì)報(bào)錯(cuò)。但是你在外面引入這個(gè)模塊的時(shí)候是不存在問(wèn)題的。

注意在模塊下面，最好不要有和模塊名重名的文件。

頂級(jí)包與入口文件main.py的位置有關(guān)，與main.py同級(jí)的包就是該包下所有模塊的頂級(jí)包。而對(duì)于入口文件來(lái)說(shuō)不存在包的概念。
絕對(duì)導(dǎo)入/絕對(duì)路徑：從頂級(jí)包到被導(dǎo)入模塊名稱的完整路徑。注意一定是完整的路徑。
相對(duì)導(dǎo)入,一個(gè)"."表示當(dāng)前包,兩個(gè)".."表示上一級(jí)包."..."上上級(jí)包,以此類推。

注意:

import不支持相對(duì)導(dǎo)入，只能使用from import格式實(shí)現(xiàn)相對(duì)導(dǎo)入。

入口文件中不能使用相對(duì)導(dǎo)入，因?yàn)樗鼪](méi)有包的概念。

使用相對(duì)導(dǎo)入不要超出頂級(jí)包，和入口文件同級(jí)都不能使用相對(duì)導(dǎo)入

pycharm中，你打開(kāi)一個(gè)工程，你的入口文件處的sys.path中會(huì)自動(dòng)添加該工程中的目錄，所以假設(shè)你在模塊a中相對(duì)引入其他模塊b，模塊b所在的位置超過(guò)了你現(xiàn)在所運(yùn)行的文件（入口文件）所在的位置，但是只要不超過(guò)當(dāng)前的工程目錄所在的位置，仍然可以進(jìn)行相對(duì)導(dǎo)入。

python默認(rèn)有一個(gè)遞歸次數(shù)限制來(lái)防止無(wú)限遞歸調(diào)用，但可以設(shè)置遞歸最大次數(shù)：

import sys
sys.setrecursionlimit(10000)
# 可以設(shè)置最大迭代10000次。不過(guò)理論上雖然設(shè)置這么多，但實(shí)際上仍然達(dá)不到允許迭代這么多次。

python中for循環(huán)內(nèi)定義的變量可以在外部使用，這點(diǎn)和c和java不相同。

若函數(shù)體中沒(méi)有返回值，則認(rèn)為返回None。

python函數(shù)返回多個(gè)值直接在return后面用逗號(hào)分隔要返回的值即可，返回結(jié)果是tuple元組類型。比較好的接收函數(shù)返回的多個(gè)值的方法不是用一個(gè)變量接收元組然后用序號(hào)訪問(wèn)它的元素，而是直接用多個(gè)值接收然后分別使用這些變量，如：

def damage(skill1, skill2)
    damage1 = skll1 * 3
    damage2 = skill2 * 3 + 10
    return damage1, damage2
    
skill1_damage, skill2_damage = damage(3, 6)
print(skill1_danage, skill2_damage)

上面的接受參數(shù)的方式叫做序列解包。

鏈?zhǔn)劫x值和序列解包

d = 1, 2, 3
print(type(d))
a, b, c = d
print(a, b, c)
print("----------------")
a = b = c = 1
print(a, b, c)


1 2 3
----------------
1 1 1

因?yàn)槭切蛄薪獍钥梢圆皇窃M，列表也是可以的。最后如果多個(gè)變量取同一個(gè)值，那么可以用上面的方法來(lái)進(jìn)行賦值。

函數(shù)參數(shù)有：

必須參數(shù)：形參和實(shí)參。

關(guān)鍵字參數(shù)

默認(rèn)參數(shù)

可變參數(shù)

可變參數(shù)可以解開(kāi)可變，并且可以進(jìn)行可變關(guān)鍵字參數(shù)。定義可變參數(shù)后，傳值的時(shí)候可以什么都不傳，這個(gè)時(shí)候是空元組或者空字典。

def demo(*param):
    print(param)
    print(type(param))

demo(1,2,3,[4,5,6])

(1, 2, 3, [4, 5, 6])


# 傳入可變參數(shù)，會(huì)定義為元組。

def demo(*param):
    print(param)
    print(type(param))

a = 1,2,3
demo(a)
demo(*a)

((1, 2, 3),)

(1, 2, 3)


# *可以解包。

def demo(**param):
    print(param)
    print(type(param))

demo(q="萬(wàn)能牌", w="切牌", e="占卜")

{"q": "萬(wàn)能牌", "w": "切牌", "e": "占卜"}


# 可見(jiàn)傳進(jìn)來(lái)以后是一個(gè)字典，很方便。這就是關(guān)鍵字可變參數(shù)。

def demo(**param):
    print(param)
    print(type(param))
    for key,value in param.items():
        print(key,":",value,end="|| ")

demo(q="萬(wàn)能牌", w="切牌", e="占卜")

{"q": "萬(wàn)能牌", "w": "切牌", "e": "占卜"}

q : 萬(wàn)能牌|| w : 切牌|| e : 占卜||

# 傳入字典時(shí)可以采用上面的方式取出鍵值和內(nèi)容。

def demo(**param):
    print(param)
    print(type(param))
    for key,value in param.items():
        print(key,":",value,end="|| ")

a = {"q":"萬(wàn)能牌", "w":"切牌", "e":"占卜"}
demo(**a)

{"q": "萬(wàn)能牌", "w": "切牌", "e": "占卜"}

q : 萬(wàn)能牌|| w : 切牌|| e : 占卜||

# 和傳入元組一樣，解序列可以傳入兩個(gè)*。

形參是定義函數(shù)的時(shí)候定義的參數(shù)，實(shí)參是調(diào)用函數(shù)的時(shí)候傳遞的參數(shù)。

關(guān)鍵字參數(shù)通過(guò)指定形參來(lái)進(jìn)行參數(shù)賦值。

可變參數(shù)在必須參數(shù)之后，默認(rèn)參數(shù)之前，否則會(huì)出現(xiàn)賦值的錯(cuò)誤

def demo(param1,param2 = 2,*param3):
    print(param1)
    print(param2)
    print(param3)
    
demo("a", 1,2,3)

a
1
(2, 3)

# 可見(jiàn)如果默認(rèn)參數(shù)在可變參數(shù)之前，會(huì)發(fā)生錯(cuò)誤，和預(yù)想的（1,2,3）賦值給param3有區(qū)別。

---------------------------------------------------------------------------

# 調(diào)整一下順序可以得到想要的結(jié)果

def f1(name1, *args, name2="2", **kw):
    print(name1)
    print(name2)
    print(args)
    print(kw)
f1("1","3","4",a="1",b="2")


1
2
("3", "4")
{"a": "1", "b": "2"}

類名最好不要用下劃線，有多個(gè)單詞的時(shí)候可以采用大寫(xiě)首字母的方法。

類的最基本作用就是封裝。定義類，實(shí)例化對(duì)象

類只負(fù)責(zé)定義和刻畫(huà)，并不負(fù)責(zé)去執(zhí)行代碼。所以在類里面去執(zhí)行方法是不正確的。

在一個(gè)模塊里面，不要既定義類，又去實(shí)例化類執(zhí)行代碼。

不要把類和模塊搞混，類里面有自己的規(guī)則

構(gòu)造函數(shù)即__init__(self):

實(shí)例化類的時(shí)候構(gòu)造函數(shù)被自動(dòng)執(zhí)行

構(gòu)造函數(shù)返回值為None ，不能人為return更改。

可以通過(guò)類名.__init__()來(lái)執(zhí)行構(gòu)造函數(shù)。

類變量是定義在類內(nèi)但是不在__init__()中；實(shí)例變量是定義在___init__()中的。換句話說(shuō)，實(shí)例變量是對(duì)象的，類變量是類的，二者不能混淆。

python中，類與對(duì)象的變量查找是有順序的。

class Student():
    name = "Catherian"
    age = 0
    high = 170
    def __init__(self, name, age, high):
        self.name = name
        self.age = age
        high = high
        # 注意這里的身高沒(méi)有用self.high來(lái)定義
    
    def doHomework(self):
        print("doHomework")

student1 = Student("呵呵噠", 18, 180)
student2 = Student("ojbk", 16, 175)
print(student1.name, student1.age, student1.high)
print(student2.name, student2.age, student2.high)
print(Student.name, Student.age, Student.high)
print(student1.__dict__)
print(Student.__dict__)



呵呵噠 18 170 

ojbk 16 170

Catherian 0 170  # 這里打印出的才是類變量

# 可以看到，盡管我們?cè)趯?shí)例化student1,student2的時(shí)候傳入了身高h(yuǎn)igh這個(gè)數(shù)據(jù)，但是打印的時(shí)候我們發(fā)現(xiàn)輸出的是類變量high，并不是實(shí)例變量。

{"name": "呵呵噠", "age": 18}

# __dict__對(duì)與對(duì)象，打印出的是對(duì)象的實(shí)例變量。可見(jiàn)里面并沒(méi)有high。所以實(shí)例變量是用 self. 來(lái)定義的。類的__dict__是打印出對(duì)象里面的內(nèi)容，包括數(shù)據(jù)成員和方法，下面即是

{"__module__": "__main__", "name": "Catherian", "age": 0, "high": 170, "__init__": , "doHomework": , "__dict__": , "__weakref__": , "__doc__": None}

雖然我們?cè)趯?shí)例化對(duì)象時(shí)傳入了數(shù)據(jù)，但是我們發(fā)現(xiàn)high是類變量不是實(shí)例變量，但是仍然sudent1.high打印出了變量，這是類變量而不是實(shí)例變量。這是因?yàn)?，python中的查找機(jī)制：當(dāng)查找實(shí)例變量不存在的時(shí)候，會(huì)繼續(xù)向上查找類中相對(duì)應(yīng)的類變量，如果子類中沒(méi)有父類中有（出現(xiàn)繼承）時(shí)，會(huì)查找到父類。所以我們打印出了類變量。

python中，實(shí)例方法的參數(shù)里必須要顯式的定義出self，但在外部調(diào)用的時(shí)候不需要給出self。self指的就是你在外部實(shí)例化的對(duì)象。所以self.給出的是實(shí)例變量。

在實(shí)例方法中調(diào)用實(shí)例變量最好用self.的形式來(lái)進(jìn)行調(diào)用。因?yàn)槟銈魅氲氖切螀?

在實(shí)例方法中調(diào)用類變量有兩種方法：類名.類變量和self.__class__.類變量

定義類方法：

class Student
    sum = 0
    @classmethod
    def student_sum(cls):
        pass
    
# cls可以更換，函數(shù)上面是一個(gè)裝飾器，表示了這是一個(gè)類方法。cls換成self或者其他任意的都是可以的，和實(shí)例方法中self可以任意替換別的字符是一樣的。

對(duì)于類方法，調(diào)用類變量：cls.類變量 即可。所以cls代表的就是所屬于的類。在調(diào)用類方法的時(shí)候，可以 Student.studen_sum 也可以通過(guò)對(duì)象來(lái)調(diào)用，即：student1.student_sum。但是建議用類名來(lái)調(diào)用比較好。

定義靜態(tài)方法：

class Student
    sum = 0
    @staticmethod
    def add(x,y)
        pass

靜態(tài)方法上同樣要有裝飾器來(lái)修飾，但是函數(shù)中不用顯式的傳入self或者cls，更像是一個(gè)普通的函數(shù)。在類方法和靜態(tài)方法中都不能調(diào)用實(shí)例變量。一般不建議用靜態(tài)方法，類方法更方便。

在python中，實(shí)際上沒(méi)有什么是不能訪問(wèn)的。成員可見(jiàn)性更像是一種標(biāo)志，一切全靠自覺(jué)。定義私有變量或者方法的時(shí)候，只需要在變量或者方法前面加上雙下劃線就代表了私有（注意不要同時(shí)在后面再加上雙下劃線）。

# 我們定義一個(gè)學(xué)生類

class Student():
    name = "Catherian"
    age = 0
    __high = 170
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__score = 0
    
    def __doHomework(self):
        print("doHomework")
        

student1 = Student("呵呵噠", 18)
print(student1.__score)

Traceback (most recent call last):
  File "c1.py", line 15, in 
    print(student1.__score)
AttributeError: "Student" object has no attribute "__score"
# 可以看到不能這樣訪問(wèn)。
---------------------------------------------------------------------

# 如果我們?cè)偌由弦痪湓賵?zhí)行：

student1 = Student("呵呵噠", 18)
student1.__score = -1
print(student1.__score)

-1

# 我們發(fā)現(xiàn)竟然可以成功賦值并且訪問(wèn)的。這是因?yàn)?studen1.__score = -1 這個(gè)操作其實(shí)是又定義了一個(gè)新的實(shí)例變量。我們可以打印看一下

student1 = Student("okk", 18)
student1.__score = -1
# print(student1.__score)
print(student1.__dict__)


{"name": "okk", "age": 18, "_Student__score": 0, "__score": -1}

# 我們可以看到，我們?cè)倮锩娑x的__score變量被定義成了_Student__score變量，__score變量是我們根據(jù)Python動(dòng)態(tài)特性新定義出的實(shí)例變量。所以要訪問(wèn)私有變量也很簡(jiǎn)單：

print(student1._Student__score)

0

# 所以這個(gè)真的全靠自覺(jué)，python中沒(méi)什么是不能訪問(wèn)的。

python中可以單繼承也可以多繼承。

子類繼承父類，會(huì)繼承父類中的變量（類變量和實(shí)例變量都會(huì)繼承）和父類中的方法。

在子類內(nèi)部，如果有和父類重名的變量，會(huì)按照我們?cè)?b>類變量和實(shí)例變量中說(shuō)明的搜索規(guī)則進(jìn)行。

如果有重名的方法，想在子類內(nèi)部進(jìn)行調(diào)用，可以采用super(子類名, self)進(jìn)行調(diào)用父類重名函數(shù)。

在python中，可以用類名調(diào)用實(shí)例方法。很奇怪但是是可以的。

在子類構(gòu)造函數(shù)中，通過(guò)傳入多個(gè)參數(shù)，調(diào)用父類構(gòu)造函數(shù)即可完成初始化。

多繼承容易出現(xiàn)BUG。

# 定義一個(gè)Human父類
class Human():
    sum = 0
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__class__.sum += 1
    def get_name(self):
        print(self.name)
    def do_Homework(self):   # 重名的方法
        print("this is a parent method")
        
# 定義一個(gè)子類Student

from c2 import Human
class Student(Human):
    sum = 0  # 和父類重名的類變量
    def __init__(self, name, age, score):  # 父類還有兩個(gè)參數(shù)，所以這里有三個(gè)參數(shù)
       Human.__init__(self, name, age)  # 這里注意通過(guò)類名調(diào)用方法，不能不加self
       self.score = score 
       self.__class__.sum += 1
    def do_Homework(self):  # 和父類重名的方法。
        super(Student, self).do_Homework()
        print("doHomework")

student1 = Student("okk", 18, 61)
print(student1.sum)
print(Student.sum)
print(student1.get_name())
print(student1.do_Homework())


2   # 可見(jiàn)通過(guò)父類方法里對(duì)sum的操作，繼承到子類中時(shí)，對(duì)于重名變量仍然可以操作子類中的重名變量。
2  # 根據(jù)搜索機(jī)制，實(shí)例變量里沒(méi)有找到子類里的類變量，再?zèng)]有找父類。
okk
None
this is a parent method # 可見(jiàn)調(diào)用了父類中的方法。
doHomework
None

python中的枚舉類型其實(shí)是一個(gè)類。

from enum import Enum

class diamond(Enum):  # 必須要繼承父類Enum
    YELLOW = 1
    BLUE = 2
    GREEN = 3
    RED = 4
print(diamond.YELLOW)


diamond.YELLOW

# 可見(jiàn)打印出的就是diamend.YELLOW

在枚舉類型中，每個(gè)類型有不同的值，不允許出現(xiàn)相同類型賦不同值，值可以是任意類型的。如果出現(xiàn)了兩個(gè)枚舉類型的值相同，下面的枚舉類型會(huì)被當(dāng)成是上面枚舉類型的別名。

from enum import Enum

class diamond(Enum):
    YELLOW = 1
    BLUE = 1
    GREEN = 3
    RED = 4
    
print(diamond.BLUE)
print(diamond.__members__.items()) # items()可以不需要。打印出所有的枚舉類型。


diamond.YELLOW # 可打印的是BLUE出來(lái)的是YEELOW。
odict_items([("YELLOW", ), ("BLUE", ), ("GREEN", ), ("RED", )])

不能在類的外部修改類型的值，比如diamond.YELLOW = 5是會(huì)報(bào)錯(cuò)的。

類型最好用大寫(xiě)表示，表示為常量不能修改。

枚舉類型，枚舉名稱，枚舉的值，代碼如下：

from enum import Enum

class diamond(Enum):
    YELLOW = 1
    BLUE = 2
    GREEN = 3
    RED = 4
print("枚舉類型為：", type(diamond.GREEN), diamond.GREEN)
print("枚舉的名稱為", type(diamond.GREEN.name), diamond.GREEN.name)
print("枚舉的值為：", diamond.GREEN.value)

枚舉類型為：  diamond.GREEN
枚舉的名稱為  GREEN
枚舉的值為： 3

可以采用for循環(huán)獲得枚舉類型等：

for i in diamond:
    print(i)
    
diamond.YELLOW
diamond.BLUE
diamond.GREEN
diamond.RED

枚舉類型之間不能做大小的比較，可以做等值的比較；枚舉類型和枚舉值之間不能做等值的比較；枚舉類型可以做身份（is）的比較。不同枚舉類之間的枚舉類型不能比較。

從枚舉值獲得枚舉類型：

class diamond(Enum):
    YELLOW = 1
    BLUE = 2
    GREEN = 3
    RED = 4
a = 1
print(diamond(a))


diamond.YELLOW
# 從一個(gè)具體的值獲得相應(yīng)的枚舉類型。很有用。

如果想要每個(gè)枚舉類型的值都是int類型，可以引入from enum import IntEnum，在枚舉類的括號(hào)里為IntEnum。

如果不想出現(xiàn)兩個(gè)枚舉類型出現(xiàn)同一個(gè)值（會(huì)報(bào)錯(cuò)），可以引入一個(gè)裝飾器：

from enum import Enum
from enum import IntEnum, unique

@unique # 裝飾器
class diamond(IntEnum):
    YELLOW = 1
    BLUE = 2
    GREEN = 3
    RED = 4