'''
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
?優(yōu)美勝于丑陋（Python 以編寫(xiě)優(yōu)美的代碼為目標(biāo)）
?明了勝于晦澀（優(yōu)美的代碼應(yīng)當(dāng)是明了的，命名規(guī)范，風(fēng)格相似）
?簡(jiǎn)潔勝于復(fù)雜（優(yōu)美的代碼應(yīng)當(dāng)是簡(jiǎn)潔的，不要有復(fù)雜的內(nèi)部實(shí)現(xiàn)）
?復(fù)雜勝于凌亂（如果復(fù)雜不可避免，那代碼間也不能有難懂的關(guān)系，要保持接口簡(jiǎn)潔）
?扁平勝于嵌套（優(yōu)美的代碼應(yīng)當(dāng)是扁平的，不能有太多的嵌套）
?間隔勝于緊湊（優(yōu)美的代碼有適當(dāng)?shù)拈g隔，不要奢望一行代碼解決問(wèn)題）
?可讀性很重要（優(yōu)美的代碼是可讀的）
?即便假借特例的實(shí)用性之名，也不可違背這些規(guī)則（這些規(guī)則至高無(wú)上）
?不要包容所有錯(cuò)誤，除非你確定需要這樣做（精準(zhǔn)地捕獲異常，不寫(xiě) except:pass 風(fēng)格的代碼）
?當(dāng)存在多種可能，不要嘗試去猜測(cè)
?而是盡量找一種，最好是唯一一種明顯的解決方案（如果不確定，就用窮舉法）
?雖然這并不容易，因?yàn)槟悴皇?Python 之父（這里的 Dutch 是指 Guido ）
?做也許好過(guò)不做，但不假思索就動(dòng)手還不如不做（動(dòng)手之前要細(xì)思量）
?如果你無(wú)法向人描述你的方案，那肯定不是一個(gè)好方案；反之亦然（方案測(cè)評(píng)標(biāo)準(zhǔn)）
?命名空間是一種絕妙的理念，我們應(yīng)當(dāng)多加利用（倡導(dǎo)與號(hào)召）
'''

>>> bin(1)
'0b1'
>>> bin(9)
'0b1001'
>>> oct(90)
'0o132'
>>> bin(9)
'0b1001'
>>> bin(1)
'0b1'
>>> oct(10)
'0o12'
>>> oct(9)
'0o11'
>>> hex(14)
'0xe'
>>> hex(15)
'0xf'
>>> 10
10
>>> 11
11
>>> oct(0b10)
'0o2'
>>> oct(0b111)
'0o7'
>>> hex(100)
'0x64'
>>> hex(0b1111)
'0xf'
>>> hex(0o77)
'0x3f'

Python基本數(shù)據(jù)類(lèi)型：
數(shù)字：整型int，浮點(diǎn)型float，bool型，復(fù)數(shù)complex
組分為序列，集合，字典
序列（有序（此處有序是指輸入后順序不改變，即不具備自動(dòng)排序功能），可下標(biāo)索引，切片操作）：字符串str，列表list，元組tuple
集合set：無(wú)序（此處的無(wú)序是指輸入后set內(nèi)部進(jìn)行自己排序，導(dǎo)致序列可能與之前的不同），沒(méi)有索引，不能切片
字典dict：（{key，value}是其基本概念與形式）
>>> type(1)
<class 'int'>
>>> type(1.1)
<class 'float'>
>>> type((1,1))
<class 'tuple'>
>>> type((1,2))
<class 'tuple'>
>>> type((1,1,1,))
<class 'tuple'>
>>> type([1,1,1,1])
<class 'list'>
>>> type(None)
<class 'NoneType'>
>>> type(36j)
<class 'complex'>
>>> type('a')
<class 'str'>
>>> type("a")
<class 'str'>
>>> type('''a''')
<class 'str'>
>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>
>>> type(['hello', 'world', 90, True, False])
<class 'list'>
>>> type({})
<class 'dict'>
空集合表示方法：
>>> type(set())
<class 'set'>
>>> type({1,2,3})
<class 'set'>
>>> type({1,'2',3.3,True})
<class 'set'>
需要注意的是True與False的區(qū)別（集合是自動(dòng)排序的）：
>>> {1,'2',3.3,True}
{'2', 1, 3.3}
>>> {1,'2',3.3,False}
{'2', 1, 3.3, False}

轉(zhuǎn)義字符的使用：
當(dāng)使用IDLE直接輸出時(shí)：
例：
'"k"'
輸出：'"k"'
"'k'"
輸出："'k'"
轉(zhuǎn)義字符的使用：
單一轉(zhuǎn)義均可轉(zhuǎn)（轉(zhuǎn)雙引號(hào)顯示‘'，轉(zhuǎn)單引號(hào)顯示“”）：
>>> 'lets\'go'
"lets'go"
>>> 'lets\'go''lets\'go'
"lets'golets'go"
>>> 'lets\"go''lets\"go'
'lets"golets"go'
>>> "lets\"go""lets\"go"
'lets"golets"go'
>>> "lets\'golets\'go"
"lets'golets'go"
>>> 'lets\"go'"lets\"go"
'lets"golets"go'
>>> "lets\'go"'lets\'go'
"lets'golets'go"
轉(zhuǎn)義混合只轉(zhuǎn)雙（由于只轉(zhuǎn)雙引號(hào)，因此全顯示‘'）：
>>> "lets\"go""lets\'go"
'lets"golets\'go'
>>> "lets\'go""lets\"go"
'lets\'golets"go'
>>> 'lets\'go''lets\"go'
'lets\'golets"go'
>>> 'lets\"go''lets\'go'
'lets"golets\'go'
>>> "lets\"go"'lets\'go'
'lets"golets\'go'
>>> 'lets\'go'"lets\"go"
'lets\'golets"go'
>>> "lets\'go"'lets\"go'
'lets\'golets"go'
>>> 'lets\"go'"lets'go"
'lets"golets\'go'
print函數(shù)直接轉(zhuǎn)：
>>> print('lets\"go''lets\'go')
lets"golets'go
>>> print('let\'sgolet\'sgo')
let'sgolet'sgo

引入三引號(hào)便于在換行時(shí)可繼續(xù)輸入：
單雙三引號(hào)換行方式：
正常不換行：
>>> 'helloworld helloword'
'helloworld helloword'
三引號(hào)（單引號(hào)形式）換行：
>>> '''helloword
... '''
'helloword\n'
>>> '''
... hello world
... helloworld
... '''
'\nhello world\nhelloworld\n'
三引號(hào)（雙引號(hào)形式）換行（與單引號(hào)形式的三引號(hào)沒(méi)有區(qū)別）：
>>> """hello world
... hello world
... '''
... """
"hello world\nhello world\n'''\n"
>>> """
... helloword
... 'kkk''
... """
"\nhelloword\n'kkk''\n"
>>> """
... hello world
... "kkk""
... """
'\nhello world\n"kkk""\n'
對(duì)于轉(zhuǎn)義字符換行的使用（單雙引號(hào)與三引號(hào)）：
>>> print("""\nhello\nhello""")
hello
hello
>>> print("\nhello\nhello")
hello
hello
print函數(shù)也是單雙引號(hào)限制在同一行，三引號(hào)形式可多行
>>> print("hello
  File "<stdin>", line 1
    print("hello
               ^
SyntaxError: EOL while scanning string literal
>>> print('''hello
... hello''')
hello
hello
在后面加\可在下一行輸入，但是是直接銜接，沒(méi)有\(zhòng)n符號(hào)：
>>> 'hello\
... hello'
'hellohello'
>>> print('hello
  File "<stdin>", line 1
    print('hello
               ^
SyntaxError: EOL while scanning string literal
>>> print('hello\
... hello')
hellohello

字符串的運(yùn)算：
可加性：
>>> 'hello'+'world'
'helloworld'
通過(guò)[]下標(biāo)形式獲取字符串的字符：
>>> 'helloworld'[7]
'r'
>>> 'hello'[0]
'h'
負(fù)數(shù)時(shí)從后面開(kāi)始計(jì)數(shù)：
>>> 'hello'[-1]
'o'
>>> 'hello'[-2]
'l'
>>> 'hello'[-4]
'e'
越界：
>>> 'hello'[10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> 'hello'[-10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
字符串的截?。ㄗ箝]右開(kāi)區(qū)間，截取字符個(gè)數(shù)為右減左，但是要注意字符串是從0開(kāi)始的）（格式：字符串后加[左區(qū)間:右區(qū)間]）：
>>> 'helloworld'[0:2]
'he'
>>> 'helloworld'[1:5]
'ello'
我們截取到最后時(shí)可以數(shù)到最后一位截取，也可以超出規(guī)定位數(shù)進(jìn)行截?。?
>>> 'hello'[0:5]
'hello'
>>> 'hello'[0:20]
'hello'
負(fù)數(shù)表示概念：步長(zhǎng)（從字符串末尾往回?cái)?shù)幾個(gè)字符）（負(fù)數(shù)在截取字符串中表示的含義與獲取字符時(shí)相同，但是截取時(shí)是左閉右開(kāi)區(qū)間，如果要截到最后一位（序號(hào)為-1），就要加一為0，但是實(shí)際操作并不是要寫(xiě)0,可看下面的例子）：
>>> 'helloworld'[0:-1]
'helloworl'
>>> 'hellowprld'[0:0]
''
>>> 'hello'[0:]
'hello'
由上面的這個(gè)例子可以推出：
>>> 'hello'[:3]
'hel'
由前兩個(gè)例子可以得到從頭截取到尾的表示方法：
>>> 'hello'[:]
'hello'
字符串不支持字符串間相乘，但是可以乘數(shù)字：
>>> '1'*'1'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'str'
>>> "1"*8
'11111111'

組（序列）的概念與含義：
str（字符串），list（列表），tuple（元組）都可以看做序列：
每個(gè)元素都有一個(gè)序號(hào)：
>>> (1,2,3)[1]
2
>>> [1,2,3][1]
2
>>> '123'[1]
'2'
bool類(lèi)型在序列中的判斷使用：
in / not in:
>>> 3 in [1,2]
False
>>> 3 in (1,2,3)
True
>>> 3in(1,2,3)
True
>>> 3 not in (1,2,3)
False
>>> 3 not in [1,2]
True
注意字符串內(nèi)判斷要用‘'
>>> '1' in '1234'
True
>>> 2 not in '134'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'in <string>' requires string as left operand, not int
>>> '2' not in '134'
True
首先要區(qū)分元組與列表：
>>> 1,2
(1, 2)
>>> (1,2)
(1, 2)
>>> type((1,2))
<class 'tuple'>
>>> [1,2]
[1, 2]
>>> [[1],[2]]
[[1], [2]]
>>> [[1,2,3],[1,2,3,4,5]]
[[1, 2, 3], [1, 2, 3, 4, 5]]
>>> type([[1],[2]])
<class 'list'>
[[1],[2]]，[[1, 2, 3], [1, 2, 3, 4, 5]]又叫嵌套列表，實(shí)際就是二維數(shù)組
空元組與空列表（元組內(nèi)表示單個(gè)元素時(shí)要加逗號(hào)，否則直接計(jì)算出來(lái)變?yōu)樵瓉?lái)的數(shù)據(jù)類(lèi)型）：
>>> ((1))
1
>>> ('a')
'a'
>>> ((1,))
(1,)
>>> (1,)
(1,)
>>> ()
()
>>> type((1,))
<class 'tuple'>
>>> type(())
<class 'tuple'>
>>> type([1])
<class 'list'>
>>> type([])
<class 'list'>
列表內(nèi)的數(shù)據(jù)類(lèi)型可以不唯一：
>>> ['hello','world',90]
['hello', 'world', 90]
>>> type(['hello', 'world', 90])
<class 'list'>
>>> ['hello', 'world', 90,True,False]
['hello', 'world', 90, True, False]
>>> type(['hello', 'world', 90, True, False])
<class 'list'>
列表與字符串類(lèi)似，也具有可加性：
>>> [1,2]+[1]
[1, 2, 1]
列表內(nèi)元素的獲?。?lèi)似于字符串相關(guān)截取操作）：
>>> [1,2,3,4][2]
3
>>> ['1','2','3'][2]
'3'
>>> ['1','2','3'][0:1]
['1']
>>> [1,'2',3][0:1]
[1]
>>> ['1',2,3][0:1]
['1']
是字符串截取出字符串，是整型截取出整型，數(shù)據(jù)類(lèi)型不會(huì)變。
需要注意的是，我們用冒號(hào)截取一段時(shí)，截取結(jié)果依然是列表，而我們不使用冒號(hào)獲取單一元素時(shí)，截取結(jié)果的數(shù)據(jù)類(lèi)型只是該元素的數(shù)據(jù)類(lèi)型（比如我們截取“3”，那么截取結(jié)果的數(shù)據(jù)類(lèi)型就是字符串，結(jié)果是‘3'）
列表不支持列表間相乘，但是可以乘數(shù)字：
>>> [1,2]*[1,2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'list'
>>> [1,2]*3
[1, 2, 1, 2, 1, 2]
列表中一些函數(shù)的簡(jiǎn)單使用（len(),min(),max()等）：
>>> len([1,2,3])
3
size是沒(méi)有定義的：
>>> size([1,2,3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'size' is not defined
>>> max([1,2,3])
3
未知量是無(wú)法比較的（并不是字符串的比較，未知量會(huì)出錯(cuò)）：
>>> max([a,b,c])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> min(('a','b'))
'a'
>>> max(['a','b'])
'b'
對(duì)字符串：
>>> min('abcde')
'a'
>>> max('aaa111ccc')
'c'
>>> min('aaa111ccc')
'1'
>>> min('a b')
' '
上面的例子實(shí)際是有輸出的，是空格。
對(duì)于元組與列表的比較和對(duì)字符串的比較是不同的（字符串的比較是無(wú)論多少字符串只輸出最大或最小的字符，而元組或列表是對(duì)每個(gè)元素的比較，元素可能就是字符串，那么就是對(duì)字符串的比較）：
>>> max('abbcc''bccaa')
'c'
>>> max("abc""def")
'f'
>>> max(["abc","cde"])
'cde'
>>> max(('abc','def'))
'def'
ord()函數(shù)是直接輸出字符（單個(gè)字母或符號(hào)，Python中無(wú)字符概念）所對(duì)應(yīng)的ASCII碼：
只能是單個(gè)字符：
>>> ord('we')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: ord() expected a character, but string of length 2 found
>>> ord('p')
112
空格所對(duì)應(yīng)的ASCII碼：
>>> ord(' ')
32
單雙引號(hào)均可（Python都表示字符串）：
>>> ord('0')
48
>>> ord("0")
48

集合（set）也是序列的一種：
集合的運(yùn)算：
集合支持序列的相關(guān)運(yùn)算，同時(shí)不一樣的地方在于：
集合是不允許元素重復(fù)的，會(huì)自動(dòng)清除相同元素，同時(shí)元素是有序的（默認(rèn)從小到大），之前的元組以及列表都是無(wú)序的。
>>> {1,2,2}
{1, 2}
>>> {1,2,4,3,2}
{1, 2, 3, 4}
>>> {4,3,2,1}
{1, 2, 3, 4}
集合支持減號(hào)：（除去集合中相同的項(xiàng)并返回到減號(hào)前面的集合）（差集）
>>> {1,2,3}-{1}
{2, 3}
>>> {1,2,3}-{4}
{1, 2, 3}
>>> {1,2,3}-{2,3,4}
{1}
集合支持并和與的計(jì)算（交集：&，并集：|）：
>>> {1,2,3}&{3}
{3}
>>> {1,2,3}|{4}
{1, 2, 3, 4}
集合與字典：
>>> type({})
<class 'dict'>
空集合的表示方法：
>>> type(set())
<class 'set'>
空集合的長(zhǎng)度：
>>> len(set())
0
字典是無(wú)序的，字典不屬于序列，無(wú)法用下標(biāo)的形式進(jìn)行查詢(xún)，但是字典存在key值，我們可以通過(guò)直接查詢(xún)key值來(lái)查詢(xún)相關(guān)元素：
鍵值key是不允許相同的，同時(shí)key可以是不同數(shù)據(jù)類(lèi)型：
>>> {1:2,1:3}
{1: 3}
>>> {1:2,'1':2}
{1: 2, '1': 2}
>>> {1:2,'1':3}['1']
3
>>> {1:2,'1':3}[1]
2
這里需要注意的是：value值是可以任意的數(shù)據(jù)類(lèi)型，比如str，int，float，tuple，甚至是list，set，dict，但是key值存在限制，key值只能是不可變對(duì)象，比如str，int，float，tuple等，可變對(duì)象就不可以是key值，比如list，set，dict。

系統(tǒng)關(guān)鍵字也可以自定義但是系統(tǒng)關(guān)鍵字之前的功能就失效了
沒(méi)有必要給自己挖這樣的坑：
>>> type=1
>>> type(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> 1(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> print(type)
1
當(dāng)然上面也可以將type改為print，print就失去原來(lái)功能。
引用類(lèi)型是可變的，賦值改變時(shí)不新增對(duì)象，只是對(duì)原來(lái)的對(duì)象進(jìn)行改變，值類(lèi)型是不可變的，值類(lèi)型重新賦值時(shí)會(huì)新增一個(gè)對(duì)象。
上面注意引用類(lèi)型的使用
>>> a=3
>>> id(a)
1687645280
>>> b=9
>>> a=a+b
>>> print(a)
12
>>> id(a)
1687645568
>>> a=3
>>> id(a)
1687645280
>>> a=4
>>> id(a)
1687645312
對(duì)于str類(lèi)型也是如此：
（如下圖）
str由于是不可變類(lèi)型，所以'python'[0]='o'是錯(cuò)誤的。

or and not :
或 且 非：
或只需一個(gè)真就不必往后進(jìn)行判斷了，且是需要判斷到最后才能算出是否為真，因此結(jié)果如下：
>>> not True
False
>>> 1 or 2
1
>>> 2 or 3
2
>>> 3 or 4
3
>>> 1 and 2
2
>>> 2 and 3
3

身份運(yùn)算符（is）判斷內(nèi)存地址是否相等
相等返回True，反之返回False
判斷類(lèi)型：
type(a)==int 
如果a是整型返回True
，一般可用isinstance函數(shù)：
instance(a,int)
如果a是整型返回True
當(dāng)然也可以使用ininstance(a,(int,str,float))來(lái)進(jìn)行判斷，看a是否屬于后面給出的其中一類(lèi)。
對(duì)象的三個(gè)特征：id、value、type
判斷：is，==，isinstance
位運(yùn)算：先將十進(jìn)制數(shù)轉(zhuǎn)化為二進(jìn)制數(shù)
按位與：只有二進(jìn)制對(duì)應(yīng)的位都為1時(shí)才為1，否則為零
按位或：二進(jìn)制對(duì)應(yīng)的位有1時(shí)就記為1

優(yōu)先級(jí)：not>and>or
系統(tǒng)命令行cmd
調(diào)用D盤(pán)：D:
dir顯示目錄
執(zhí)行python文件時(shí)：python+文件名

'''
一般程序存在智能感知,回車(chē)鍵選中自己想要的即可
'''
# if else for while switch
# 注釋方法：
'''
if else for while switch 
'''
'''
mood=True
if mood:
    print('1')
else:
    print('0')
輸出：1
'''
'''
account = '123'
password = '0000'
user_account = input()
user_password = input()
print(user_account)
if (account == user_account) and (password == user_password):
    print('success')
else:
    print('false')
輸入輸出：
123
0000
success
'''
'''
對(duì)于常量，python是使用全部大寫(xiě)（規(guī)范）（實(shí)際在python中是不存在常量
這個(gè)概念的，這里只是指不變的量
對(duì)于運(yùn)算符，標(biāo)識(shí)符，以及縮進(jìn)都比較嚴(yán)格
運(yùn)算符：比如==，要左右都有空格
標(biāo)識(shí)符：冒號(hào)：前面不要有空格,逗號(hào)，后面留一個(gè)空格（在元組，列表等可不用），注釋#前面距離代碼至少兩個(gè)空格等
縮進(jìn)：if else等注意縮進(jìn)：Tab（四個(gè)空格）
snippet 
elif相當(dāng)于else if 
switch在python沒(méi)有語(yǔ)法定義
字典的使用要強(qiáng)于elif
input()函數(shù)每次都將接收到的變量認(rèn)為是字符串
a=input()
type(a)為字符串類(lèi)型
要使a變?yōu)閕nt整數(shù)型
使用：a=int(a)
例：
a = input()
print(type(a))
a = int(a)
print(type(a))
if a == 1:
    print('success')
小應(yīng)用：
當(dāng)a與b一真一假時(shí)，我們要返回真可以使用if else語(yǔ)句實(shí)現(xiàn)，也可以使用or來(lái)實(shí)現(xiàn)
a or b 返回為真的一個(gè)
'''
'''
循環(huán)語(yǔ)句：
for while
解決無(wú)限循環(huán)方法：
上面工具欄Run stop終止程序
或者下面窗口欄右擊程序 Close Tab
while循環(huán)例：
a = 1
while a <= 10:
    print(a)
    a += 1
else:
    print('EOF!')
while可與else搭配
但是while與else搭配，for與else搭配并不常用，很多語(yǔ)言也沒(méi)有這種語(yǔ)法
'''
'''
for循環(huán)例：
b = ((1, 2, 3), [1, 3, 2])
for x in b:
    for y in x:
        if y == 2:
            print(y,  end='abc\n')
            break
        print('bbb')
    print('aaa\n', end='')  # print的end本來(lái)就默認(rèn)打出回車(chē)鍵，不必繼續(xù)打回車(chē)，這里將end改為空''
else:
    print('EOF!', end='\n12345678')
輸出結(jié)果：
bbb
2abc  #跳出內(nèi)循環(huán)
aaa
bbb
bbb
2abc  #跳出內(nèi)循環(huán)
aaa
EOF!  #for循環(huán)執(zhí)行結(jié)束后執(zhí)行else語(yǔ)句
12345678
'''
'''
# 當(dāng)執(zhí)行指定次數(shù)的循環(huán)時(shí)：
# range()函數(shù)，左閉右開(kāi)區(qū)間：
for x in range(1, 11, 1):
    print(x, end=' ')
# 執(zhí)行結(jié)果：1 2 3 4 5 6 7 8 9 10
print('')  # 由于內(nèi)置回車(chē)，因此這里什么都不必輸入就會(huì)打出一行空行
# 當(dāng)然對(duì)于遞增1位也可以不加后面的1：
for x in range(1, 11):
    print(x, end=' ')
print('')
# 執(zhí)行結(jié)果：1 2 3 4 5 6 7 8 9 10
for x in range(1, 11, 3):
    print(x, end=' | ')
# 執(zhí)行結(jié)果：1 | 4 | 7 | 10 |
print('')
for x in range(11, 1, -3):
    print(x, end=' | ')
# 執(zhí)行結(jié)果：11 | 8 | 5 | 2 |
'''
'''
# range()函數(shù)與切片：
# 對(duì)于上面的range()函數(shù)，如果又有給定的序列等可以使用，則可以搭配len()函數(shù)
a = [1, 2, 3, 4]  # 指定序列
for x in range(0, len(a), 2):  # 這里的len(a)只是獲取長(zhǎng)度，與序列內(nèi)容無(wú)關(guān)
    print(a[x], end=' ')
# 執(zhí)行結(jié)果（當(dāng)上面是x而不是a[x]時(shí))：0 2   # 這里從0到4左閉右開(kāi)
# 當(dāng)是a[x]時(shí)：1 3  # 就是a[0],a[2]即1,3
# 我們也完全可以使用切片的方式來(lái)代替上面的for循環(huán)：
# 三個(gè)參數(shù)，兩個(gè)冒號(hào)，最后一個(gè)參數(shù)為步長(zhǎng)
b = a[0:len(a):2]  # 這里就是對(duì)序列直接進(jìn)行切片
print(type(b))  # 這里b返回的不是序列內(nèi)的元素，而是返回切片之前的序列類(lèi)型
print(b)
# 輸出結(jié)果：
# <class 'list'>
# [1, 3]
'''
'''
會(huì)寫(xiě)代碼很容易
高性能，封裝性（可復(fù)用），抽象能力（編程是現(xiàn)實(shí)生活到計(jì)算機(jī)里的映射）
不要太直白
美與不美
'''
'''
Python組織結(jié)構(gòu)：
包（物理表現(xiàn)：文件夾），模塊（.py文件），類(lèi)(java,C#認(rèn)為一個(gè)文件就寫(xiě)一個(gè)類(lèi)）
包：C#：dll，JAVA：jar包
包可以建立子包，當(dāng)然包下面的模塊也可以與子包同級(jí)
命名空間（文件路徑）
模塊：
首先要建立一個(gè)包，必須建立一個(gè)特殊的模塊，模塊名叫做__init__.py
如果沒(méi)有這樣一個(gè)特殊模塊，python就會(huì)認(rèn)為這只是一個(gè)普通的文件夾，而不是一個(gè)包
該文件可以什么都不寫(xiě)，只是標(biāo)注這是一個(gè)包，當(dāng)然也可以像普通文件一樣編寫(xiě)代碼
該文件名不是.__init__.py，而是包名
比如test包中該模塊就叫test，而不是test.__init__.py
模塊之間的調(diào)用：
注意命名空間的添加
一定是模塊的調(diào)用（.py文件）
第一種導(dǎo)入（調(diào)用）形式：
模塊調(diào)用從后往前調(diào)用，依次調(diào)用執(zhí)行：
例：
D:\untitled1\python\__init__.py 文件內(nèi)代碼如下：
import python.c7
print(python.c7.a)
print('__init__.py')
b = input()
print(b)
D:\untitled1\python\c7.py 文件內(nèi)代碼如下：
a = 1
print('123')
# 該代碼的調(diào)用就是先調(diào)用.c7后調(diào)用python
# 執(zhí)行過(guò)程如下：
123  # 首先執(zhí)行c7
1  # 然后執(zhí)行python,打出變量a，下一行繼續(xù)打印
__init__.py
2  # 該行為input()輸入的
2  # 調(diào)用過(guò)程結(jié)束，執(zhí)行當(dāng)下剩余代碼
1  
__init__.py
b  # 該行為input()輸入的
b
Process finished with exit code 0
再舉一個(gè)例子：
D:\untitled1\c6.py 文件內(nèi)代碼如下：
import python.c7
print(python.c7.a)
# 該代碼的調(diào)用也是先調(diào)用.c7后調(diào)用python
# 執(zhí)行過(guò)程如下：
123  # 首先執(zhí)行c7
1  # 然后執(zhí)行python,打出變量a，下一行繼續(xù)打印
__init__.py
b  # 該行為input()輸入的
b  # 調(diào)用過(guò)程結(jié)束，執(zhí)行當(dāng)下剩余代碼
1
Process finished with exit code 0
# 根據(jù)上面兩個(gè)例子告訴我們__init__.py文件在每次調(diào)用該包內(nèi)文件時(shí)都會(huì)被自動(dòng)調(diào)用
# 因此，__init__.py文件適合應(yīng)用于模塊的初始化（可進(jìn)行對(duì)庫(kù)的批量導(dǎo)入）
命名空間過(guò)長(zhǎng)時(shí)，可以使用as來(lái)進(jìn)行替代
例如上面的python.c7可以替換為c7或者任何簡(jiǎn)單的名字：
格式（這里將python.c7轉(zhuǎn)換為c7）：import python.c7 as c7
然后就可以使用了：例：print(c7.a)
第二種導(dǎo)入（調(diào)用）形式：
from 包 import 對(duì)象/函數(shù)
然后直接使用這些變量名或者函數(shù)
當(dāng)然也可以從包中導(dǎo)入文件，不過(guò)這樣使用就跟直接使用import導(dǎo)入文件沒(méi)有差別了
如果要導(dǎo)入全部變量，其實(shí)也可以這樣使用：
from 包 import *
以星號(hào)的形式導(dǎo)入全部變量
但是當(dāng)我們使用這些變量時(shí)由于該文件中沒(méi)有過(guò)出現(xiàn)這些變量名，系統(tǒng)會(huì)提示語(yǔ)法錯(cuò)誤，但實(shí)際上仍然是可以運(yùn)行的
模塊的內(nèi)置變量，模塊的內(nèi)置屬性
__all__=['a', 'b']  一定是字符串類(lèi)型的
然后再利用*進(jìn)行導(dǎo)入時(shí)只導(dǎo)入列表內(nèi)存在的元素變量
也可以直接導(dǎo)入多個(gè)變量
from c7 import a, b, c
編譯代碼時(shí)會(huì)自動(dòng)生成一些文件：
如：__pycache__文件夾以及.cpython-36.pyc等中間編譯文件
如果是VScode編譯器也可以在資源管理器進(jìn)行隱藏這些文件
PyCharm編譯器直接自動(dòng)隱藏了
Python編碼規(guī)范，一行盡量不要超過(guò)80個(gè)字符
如果要換行可以使用反斜杠\進(jìn)行換行連接（不過(guò)不好看）
建議使用括號(hào)來(lái)?yè)Q行
對(duì)庫(kù)的批量導(dǎo)入：
對(duì)庫(kù)的批量導(dǎo)入可放在該文件下然后對(duì)要導(dǎo)入該庫(kù)的文件直接導(dǎo)入包即可（其實(shí)包名也就是該文件名）
批量導(dǎo)入不能重復(fù)導(dǎo)入（即不能循環(huán)導(dǎo)入）
有時(shí)候循環(huán)導(dǎo)入是不易發(fā)現(xiàn)的，可能涉及到多個(gè)文件之間導(dǎo)入的閉合，這就需要更細(xì)心一點(diǎn)
入口文件的概念
'''
'''
# 函數(shù)
IDLE內(nèi)：
help(函數(shù)名)即可查看函數(shù)內(nèi)置操作
也可使用import this查看python之禪
比如round函數(shù)，保留到小數(shù)點(diǎn)后面幾位（四舍五入原則）
例如:
a = 1.123456
a = round(a, 2)
print(a)
a = round(a, 5)
print(a)
當(dāng)然上面的一段輸出是有問(wèn)題的，輸出結(jié)果如下：
1.12
1.12
因?yàn)閍 = round(a, 2)這一步a就已經(jīng)變成了1.12，然后繼續(xù)執(zhí)行是無(wú)法得到原來(lái)的a保留五位小數(shù)的結(jié)果的
改成下面的：
a = 1.123456
b = round(a, 2)
print(b)
c = round(a, 5)
print(c)
輸出結(jié)果：
1.12
1.12346
可以看到round()函數(shù)默認(rèn)為四舍五入
函數(shù)的使用：
1.功能性
2.隱藏細(xì)節(jié)（函數(shù)內(nèi)部細(xì)節(jié)可能很復(fù)雜，但是在使用時(shí)不必看其內(nèi)部結(jié)構(gòu)）
# 但是如果要深入學(xué)習(xí)或者函數(shù)內(nèi)部出現(xiàn)了bug，我們就需要進(jìn)入函數(shù)內(nèi)部進(jìn)行查看
3.避免編寫(xiě)重復(fù)的代碼
也可以進(jìn)行組織代碼，但是面向?qū)ο髮?duì)于組織代碼更合適一些
可自定義函數(shù)
函數(shù)的定義：
def關(guān)鍵字 函數(shù)名 (參數(shù)列表):
          函數(shù)體
函數(shù)體內(nèi)可以返回直接value，如果沒(méi)有return，默認(rèn)返回None空值
自定義函數(shù)名如果跟某些系統(tǒng)函數(shù)名沖突等容易造成函數(shù)循環(huán)調(diào)用
例：
def print(code):
    print(code)
本來(lái)想要打印傳入的參數(shù)，但是由于函數(shù)名的問(wèn)題會(huì)造成一直調(diào)用自身，導(dǎo)致函數(shù)無(wú)限循環(huán)
但是Python也是非常的人性化，當(dāng)函數(shù)循環(huán)調(diào)用執(zhí)行到大概1000次左右時(shí)會(huì)自動(dòng)停止程序并報(bào)錯(cuò)
當(dāng)然我們也可以自定義進(jìn)行設(shè)置最大遞歸次數(shù)
如何設(shè)置：
import sys
sys.setrecursionlimit(遞歸次數(shù))  # 這里的遞歸次數(shù)我們可以自由設(shè)定
當(dāng)然python內(nèi)部不會(huì)過(guò)于大了，由于計(jì)算機(jī)系統(tǒng)的原因也不會(huì)達(dá)到太大
例：
a = 3
b = 2
def add(x, y):
    result = x + y
    return result
print(add(a,b))
print(add(1, 2))
輸出：
5
3
有的函數(shù)存在可變參數(shù)：如系統(tǒng)的print()函數(shù)參數(shù)個(gè)數(shù)不確定
'''
'''
序列解包：
元組索引解包操作（不推薦使用該解包方式，容易亂）：
具體使用：
該處的3,6為隨意輸入的數(shù)據(jù)，對(duì)應(yīng)的輸出結(jié)果為9,22：
如下圖：

下面的解包方式都是正確的（對(duì)應(yīng)元素個(gè)數(shù)要相等）：
d = 1, 2, 3
print(type(d))
a, b, c = d
print(a, b, c)
a, b, c = [4, 5, 6]
print(a, b, c)
a = b = c = 1
print(a, b, c)
輸出結(jié)果：
<class 'tuple'>
1 2 3
4 5 6
1 1 1
'''
'''
函數(shù)參數(shù)：
形式參數(shù)，實(shí)際參數(shù)（形參，實(shí)參）：形參是定義時(shí)括號(hào)內(nèi)的參數(shù)，實(shí)參是調(diào)用時(shí)括號(hào)內(nèi)的參數(shù)
1.必須參數(shù)：定義了多少個(gè)形參就要傳遞多少個(gè)實(shí)參
2.關(guān)鍵字參數(shù)：對(duì)實(shí)參進(jìn)行標(biāo)注，然后可以隨意調(diào)換實(shí)參順序
例：
函數(shù)定義：def add(x,y):
函數(shù)調(diào)用：result = add(y = 3, x = 2)
3.默認(rèn)參數(shù)：在形參上進(jìn)行操作，當(dāng)存在實(shí)參時(shí)，代入該實(shí)參，否則代入默認(rèn)參數(shù)（一般傳參數(shù)較多時(shí)使用，但是不推薦傳入?yún)?shù)過(guò)多，當(dāng)參數(shù)過(guò)多時(shí)可傳入對(duì)象）
例：
def test(z, x = 1, y = 2):
    print(x, y, z)
test(3)
輸出：
1 2 3
注意定義函數(shù)時(shí)必須傳入的參數(shù)只能放到默認(rèn)參數(shù)之前，即默認(rèn)參數(shù)之后不可存在待傳參數(shù)
例：
def test(x = 1, y = 2, z):
    print(x, y, z)
test(3)
SyntaxError: non-default argument follows default argument
另外對(duì)于調(diào)用來(lái)說(shuō)也可以使用關(guān)鍵字參數(shù)來(lái)進(jìn)行指明傳參量
但是對(duì)于關(guān)鍵值參數(shù)也是不可以將必須參數(shù)與默認(rèn)參數(shù)的順序隨意混亂，仍然遵循默認(rèn)參數(shù)之后不可存在必須參數(shù)（除非每個(gè)參數(shù)都是關(guān)鍵字參數(shù)）
'''

'''
面向?qū)ο?
有意義的面向?qū)ο蟮拇a
有類(lèi)不能等同于是面向?qū)ο?
類(lèi)的實(shí)例化
student = Student()
類(lèi)最基本的作用：封裝
類(lèi)下面的函數(shù)一定要加self，否則會(huì)報(bào)錯(cuò)，而且在使用類(lèi)內(nèi)的變量時(shí)一定要加self，否則也會(huì)報(bào)錯(cuò)
建議類(lèi)的模塊內(nèi)只寫(xiě)類(lèi)，不寫(xiě)類(lèi)的實(shí)例化與調(diào)用
如果寫(xiě)在一起代碼結(jié)構(gòu)會(huì)變得非常松散
方法和函數(shù)的區(qū)別：很多時(shí)候已經(jīng)模糊了這兩個(gè)概念：
C，C++：函數(shù)，java，C#：方法
方法：更多的是面向?qū)ο蟮母拍?，面向?qū)ο蟾P(guān)注的是設(shè)計(jì)，設(shè)計(jì)代碼結(jié)構(gòu)，設(shè)計(jì)封裝
因此方法更多的是設(shè)計(jì)層面的稱(chēng)謂
函數(shù)：更多的是面向過(guò)程的概念，沒(méi)有設(shè)計(jì)層面的意義在里面
程序運(yùn)行，過(guò)程式的一種稱(chēng)謂
類(lèi)是現(xiàn)實(shí)世界或思維世界的實(shí)體在計(jì)算機(jī)中的反映
它將數(shù)據(jù)（數(shù)據(jù)成員）以及這些數(shù)據(jù)上的操作（方法）封裝在一起
python內(nèi)類(lèi)構(gòu)造函數(shù)在實(shí)例化時(shí)會(huì)自動(dòng)調(diào)用
格式如下：def __init__(self):
默認(rèn)返回為None，而且只能返回None，不能返回其他類(lèi)型
要傳入?yún)?shù)的話(huà)寫(xiě)在構(gòu)造函數(shù)內(nèi)，而且一旦確定就必須傳入相應(yīng)實(shí)參
構(gòu)造函數(shù)：初始化對(duì)象的屬性（特征）
等號(hào)左邊為類(lèi)內(nèi)變量（數(shù)據(jù)成員），右邊為形參名
數(shù)據(jù)成員與形參名可以相等
例：
name = name
而不必非要寫(xiě)成name =  name1或者name = name_等
之前講到的模塊部分局部變量與全局變量的作用域：
模塊內(nèi)局部變量不會(huì)覆蓋全局變量
（函數(shù)的局部變量與模塊的全局變量可重名）
類(lèi)變量，實(shí)例變量的概念（見(jiàn)下面例題）
python尋找機(jī)制：
如果要尋找實(shí)例變量，如果沒(méi)有找到會(huì)到類(lèi)變量?jī)?nèi)去尋找，如果還是沒(méi)有找到，會(huì)到類(lèi)的父類(lèi)里面去尋找（繼承）
'''
'''
class Student:  # 在這里Student后面也可以選擇加上括號(hào)，但是加不加無(wú)所謂，加上在PyCharm中反而會(huì)提示多余的括號(hào)
    name = 'MJG'
    age = 0
    # 類(lèi)變量
    def __init__(self, name, age):
        self.name = name
        self.age = age
        # 實(shí)例變量（必須加上self）（當(dāng)然self可以是任意的，只不過(guò)使用self是一種常用習(xí)慣）
        # 有了實(shí)例變量的概念，那么還有實(shí)例方法的概念（對(duì)象實(shí)例可以調(diào)用的方法）
student = Student('1', '2')
print(student.name)
print(student.age)
student = Student
print(student.name)
print(student.age)
# 輸出結(jié)果：
# 1
# 2
# MJG
# 0
'''
'''
# 如果代碼是下面一段：

class Student:
    name = 'MJG'
    age = 0
    def __init__(self, name, age):
        name = name
        age = age

student = Student('1', '2')
print(student.name)
print(student.age)
# 輸出結(jié)果：
# MJG
# 0
# 卻并不是我們想要的'1', '2',這是因?yàn)樵跇?gòu)造函數(shù)內(nèi)沒(méi)有標(biāo)明self，導(dǎo)致變量只作用于局部
# 當(dāng)輸出時(shí)找不到對(duì)象變量就只能尋找類(lèi)變量進(jìn)行輸出
'''
'''
下面介紹一下變量__dict__（系統(tǒng)內(nèi)置到對(duì)象中保存對(duì)象的所有變量）：
可通過(guò)打印__dict__變量查看對(duì)象的所有變量，當(dāng)然我們也可以打印該類(lèi)變量打出類(lèi)內(nèi)的所有變量
例：
class Student:
    name = 'MJG'
    age = 0
    def __init__(self, name, age):
        self.name = name
        self.age = age

student = Student('1', '2')
print(student.name)
print(student.age)
print(student.__dict__)
print(Student.__dict__)
輸出結(jié)果：
1
2
{'name': '1', 'age': '2'}
{'__module__': '__main__', 'name': 'MJG', 'age': 0, '__init__': <function Student.__init__ at 0x000001B3A9AD0048>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
# 分別顯示了所有的對(duì)象變量與類(lèi)變量
'''
'''
Python類(lèi)：
變量：類(lèi)變量，實(shí)例變量
方法：實(shí)例方法，類(lèi)方法，靜態(tài)方法
特殊函數(shù)：構(gòu)造函數(shù)
實(shí)例變量：訪問(wèn)實(shí)例變量在類(lèi)內(nèi)必須加上self，否則會(huì)出現(xiàn)誤解，導(dǎo)致找不到實(shí)例變量
在類(lèi)外可以直接調(diào)用
例：
    def __init__(self, name1, age1):
        self.name = name1
        self.age = age1
        print(self.name)  # 調(diào)用實(shí)例變量（正確）
        print(name)  # 既不是調(diào)用實(shí)例變量也不是調(diào)用類(lèi)變量（類(lèi)變量?jī)?nèi)雖然存在name變量，但是這并不是調(diào)用類(lèi)變量的方式，依然會(huì)報(bào)錯(cuò)）
        print(name1) # 既不是調(diào)用實(shí)例變量也不是調(diào)用類(lèi)變量（但是這里并不會(huì)報(bào)錯(cuò)，調(diào)用的是形參）
        # 調(diào)用類(lèi)變量的兩種方法：
        print(Student.name)  # 訪問(wèn)類(lèi)變量（類(lèi)內(nèi)類(lèi)外都可以這樣調(diào)用）
        print(self.__class__.name)  # 類(lèi)變量的調(diào)用（類(lèi)內(nèi)）
對(duì)于類(lèi)內(nèi)變量的操作：
    class Student:
    name = 'MJG'
    age = 0
    sum = 0
    def __init__(self, name1, age1):
        self.name = name1
        self.age = age1
        print('name:' + self.name)
        print('age:' + self.age)
        self.__class__.sum += 1
        print('當(dāng)前sum數(shù)：' + str(self.__class__.sum))

student = Student('1', '2')
student__ = Student('3', '4')
print('最后類(lèi)變量sum：' + str(Student.sum))
輸出：
name:1
age:2
當(dāng)前sum數(shù)：1
name:3
age:4
當(dāng)前sum數(shù)：2
最后類(lèi)變量sum：2
類(lèi)方法：
對(duì)于類(lèi)變量我們可以在構(gòu)造函數(shù)或?qū)嵗椒ㄖ羞M(jìn)行操作，當(dāng)然我們完全可以通過(guò)類(lèi)方法來(lái)進(jìn)行操作：
一般來(lái)說(shuō)，對(duì)于類(lèi)變量的操作我們都是放在類(lèi)方法中去執(zhí)行，而不是構(gòu)造函數(shù)與實(shí)例方法
定義：
標(biāo)志（裝飾器）：@classmethod
類(lèi)方法代表名：cls（參數(shù)列表內(nèi)），也像實(shí)例方法一樣可以更改，但是也是一種習(xí)慣性表達(dá)
例：
class Student:
    sum = 0
    @classmethod
    def sum_(cls):
        cls.sum += 1
        print(cls.sum)
Student.sum_()  # 類(lèi)方法就要使用類(lèi)去調(diào)用
但是python也是允許對(duì)象去調(diào)用類(lèi)方法的，但是這在實(shí)際上是說(shuō)不通的，一般不建議使用這種方法
# student = Student
# student.sum_()
輸出結(jié)果：
1
靜態(tài)方法：
定義：
標(biāo)志（裝飾器）：@staticmethod
類(lèi)方法與實(shí)例方法、類(lèi)方法的區(qū)別：
靜態(tài)方法沒(méi)有像實(shí)例方法、類(lèi)方法那樣要求強(qiáng)制傳入一個(gè)默認(rèn)指定的名字，類(lèi)方法的cls代表的是類(lèi)本身，實(shí)例方法的self代表的是實(shí)例本身
靜態(tài)方法沒(méi)有這樣一個(gè)默認(rèn)傳入，只是一個(gè)普普通通的方法
總結(jié)：
類(lèi)訪問(wèn)類(lèi)變量（OK），實(shí)例變量（也OK）
對(duì)象訪問(wèn)類(lèi)變量，實(shí)例變量，都OK
類(lèi)與對(duì)象都可以訪問(wèn)靜態(tài)方法
類(lèi)方法，實(shí)例方法，靜態(tài)方法之間的相互訪問(wèn)：
類(lèi)方法與靜態(tài)方法都不可以訪問(wèn)實(shí)例變量
實(shí)例方法與靜態(tài)方法都可以訪問(wèn)類(lèi)變量

一般不建議使用靜態(tài)方法，除非使用的方法非常純粹，與類(lèi)和對(duì)象都沒(méi)有太大的關(guān)聯(lián)
'''
'''
class Student:
    sum = 0
    def __init__(self, name1, age1):
        self.name = name1
        self.age = age1
    # 自動(dòng)為對(duì)象創(chuàng)建新變量sum
    def __sum__(self):
        self.sum += 1
        print(self.sum)
    # 結(jié)果由{'name': 'MJG', 'age': '20'}變?yōu)椋?
    # {'name': 'MJG', 'age': '20', 'sum': 1}
student = Student('MJG', '20')
print(student.__dict__)
student.__sum__()
print(student.__dict__)
# 輸出：
# {'name': 'MJG', 'age': '20'}
# 1
# {'name': 'MJG', 'age': '20', 'sum': 1}
'''
'''
***
class Student:
    sum = 0
    def __init__(self, name1, age1, test1, test2):
        self.name = name1
        self.age = age1
        self.test = test1  # 公開(kāi)
        self.__test = test2  # 私有，這里允許重名（一個(gè)私有，一個(gè)公開(kāi)）
        self.__class__.test = 10  # 調(diào)用類(lèi)變量，如果一開(kāi)始沒(méi)有選擇創(chuàng)建
        Student.__test = 20  # 調(diào)用類(lèi)變量，如果一開(kāi)始沒(méi)有選擇創(chuàng)建(允許重名）（兩種不同的調(diào)用類(lèi)變量的方式）
    # 前面加兩條下劃線(xiàn)，變?yōu)樗接?，?lèi)外直接調(diào)用該方法會(huì)報(bào)錯(cuò)
    def __sum(self):
        self.sum += 1
        print(self.sum)
print(Student.__dict__)  # 最初始時(shí)，只有一個(gè)sum變量
student = Student('MJG', '18', 'test1', 'test2')
print(student.__dict__)  # 注意到test是公開(kāi)的，__test是私有的：{'name': 'MJG', 'age': '18', 'test': 'test1', '_Student__test': 'test2'}
student.__test = 100  # 對(duì)象內(nèi)雖然存在test私有變量，但是這里并不是正確的訪問(wèn)私有變量的方式
# 而且就算可以這樣訪問(wèn)，也不能更改私有變量，因?yàn)檫@兩個(gè)類(lèi)型本身就是不同的，不能賦值，這里是類(lèi)外為對(duì)象創(chuàng)建了新變量__test
print(student.__test)  # 并不是可以訪問(wèn)私有成員（訪問(wèn)私有成員的方式也不是這樣），而是上一行已經(jīng)為對(duì)象創(chuàng)建了新變量__test（如果上一行沒(méi)有創(chuàng)建過(guò)程是會(huì)報(bào)錯(cuò)的）
print(student.__dict__)  # 加上構(gòu)造時(shí)的test(test1)和__test（私有）(test2)以及新創(chuàng)建的__test變量（形式，并非私有）：{'name': 'MJG', 'age': '18', 'test': 'test1', '_Student__test': 'test2', '__test': 100}
# 對(duì)類(lèi)變量：
print(Student.__dict__)# 在構(gòu)造時(shí)就已經(jīng)創(chuàng)建了新的類(lèi)變量：公開(kāi)變量：test和私有變量__test（僅測(cè)試用）
# {'__module__': '__main__', 'sum': 0, '__init__': <function Student.__init__ at 0x000002BD60FF0048>, '_Student__sum': <function Student.__sum at 0x000002BD60FF01E0>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None, 'test': 10, '_Student__test': 20}
# 對(duì)對(duì)象進(jìn)行再創(chuàng)建與測(cè)試：
student1 = Student('test_name', 'test_age', 'test1.1', 'test2.1')
print(student1.__dict__)
# print(student1.__test)  # 這里不對(duì)其進(jìn)行創(chuàng)建，是會(huì)報(bào)錯(cuò)的
print(Student.__dict__)
# 輸出：
# {'name': 'test_name', 'age': 'test_age', 'test': 'test1.1', '_Student__test': 'test2.1'}
# {'__module__': '__main__', 'sum': 0, '__init__': <function Student.__init__ at 0x000002548D330048>, '_Student__sum': <function Student.__sum at 0x000002548D3301E0>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None, 'test': 10, '_Student__test': 20}
強(qiáng)制讀取私有數(shù)據(jù)成員：
print(student._Student__test)
print(student1._Student__test)
print(Student._Student__test)
# 上面的方法是可以的，但是強(qiáng)行讀取類(lèi)就沒(méi)有了意義（python的保護(hù)機(jī)制是比較弱的，比較簡(jiǎn)單）
輸出：
test2
test2.1
20
'''
'''
面向?qū)ο蟮娜筇卣鳎?
繼承，封裝，多態(tài)：
繼承：
一、首先導(dǎo)入一個(gè)模塊（一般不用這種方式）
import 模塊名
class Student(模塊名.類(lèi)名):
二、直接導(dǎo)入模塊下的類(lèi)
from 模塊名 import 類(lèi)名
class Student(類(lèi)名):
繼承后構(gòu)造：
首先要傳入父類(lèi)構(gòu)造函數(shù)內(nèi)的參數(shù)
一、顯示調(diào)用父類(lèi)的構(gòu)造函數(shù)
二、（一般這樣操作）：super關(guān)鍵字：super(子類(lèi)名, self).__init__(父類(lèi)構(gòu)造函數(shù)參數(shù)表）
（調(diào)用父類(lèi)的方法：super(子類(lèi)名, self).方法名）
子類(lèi)內(nèi)方法可與父類(lèi)內(nèi)方法名重名并進(jìn)行覆蓋
'''

寫(xiě)一個(gè)有用的代碼自動(dòng)調(diào)節(jié)工具：
pep8:
安裝方法：
首先在系統(tǒng)命令行輸入：
python -m pip install autopep8
系統(tǒng)會(huì)自動(dòng)下載安裝autopep8
根據(jù)提示進(jìn)行更新等操作即可完成安裝，然后配置autopep8

一、（三個(gè)python通用的，不過(guò)沒(méi)試過(guò)）
下載編譯好的python擴(kuò)展庫(kù)（不過(guò)好像停用了）（可以百度一下，很多類(lèi)似的庫(kù)）（一般pip或者搭配鏡像即可）：
　　http //www lfd.uci.edu/~gohlke/pythonlibs/
　　下載完畢后直接解壓放入：
　　C:\Python27\Lib\site-packages(對(duì)應(yīng)自己的庫(kù)）
　　就可以import使用了。
　　大部分庫(kù)都是有的，特別是機(jī)器學(xué)習(xí)類(lèi)的，很全。
二、cmd pip
python -m pip install 包名
三、Anaconda直接安裝

解決pip超時(shí)問(wèn)題：
問(wèn)題狀況如下：
 raise ReadTimeoutError(self._pool, None, "Read timed out.")
pip._vendor.urllib3.exceptions.ReadTimeoutError: HTTPSConnectionPool(host='files.pythonhosted.org', port=443): Read timed out.
一、（實(shí)驗(yàn)可用有效）
解決辦法（采用鏡像下載）：//例如這里采用豆瓣鏡像，下載wordcloud詞云庫(kù)：
//下載什么庫(kù)就在pip install -i https://pypi.douban.com/simple后面寫(xiě)什么
pip install -i https://pypi.douban.com/simple wordcloud
國(guó)內(nèi)鏡像源：
http://pypi.douban.com/ 豆瓣
http://pypi.hustunique.com/ 華中理工大學(xué)
http://pypi.sdutlinux.org/ 山東理工大學(xué)
http://pypi.mirrors.ustc.edu.cn/ 中國(guó)科學(xué)技術(shù)大學(xué)
二、（可用但未嘗試）
可對(duì)pip進(jìn)行時(shí)間限制，在指定時(shí)間限制內(nèi)忽略中停止問(wèn)題（加大下載時(shí)間）