'''
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 以編寫優(yōu)美的代碼為目標(biāo)）
?明了勝于晦澀（優(yōu)美的代碼應(yīng)當(dāng)是明了的，命名規(guī)范，風(fēng)格相似）
?簡潔勝于復(fù)雜（優(yōu)美的代碼應(yīng)當(dāng)是簡潔的，不要有復(fù)雜的內(nèi)部實現(xiàn)）
?復(fù)雜勝于凌亂（如果復(fù)雜不可避免，那代碼間也不能有難懂的關(guān)系，要保持接口簡潔）
?扁平勝于嵌套（優(yōu)美的代碼應(yīng)當(dāng)是扁平的，不能有太多的嵌套）
?間隔勝于緊湊（優(yōu)美的代碼有適當(dāng)?shù)拈g隔，不要奢望一行代碼解決問題）
?可讀性很重要（優(yōu)美的代碼是可讀的）
?即便假借特例的實用性之名，也不可違背這些規(guī)則（這些規(guī)則至高無上）
?不要包容所有錯誤，除非你確定需要這樣做（精準(zhǔn)地捕獲異常，不寫 except:pass 風(fēng)格的代碼）
?當(dāng)存在多種可能，不要嘗試去猜測
?而是盡量找一種，最好是唯一一種明顯的解決方案（如果不確定，就用窮舉法）
?雖然這并不容易，因為你不是 Python 之父（這里的 Dutch 是指 Guido ）
?做也許好過不做，但不假思索就動手還不如不做（動手之前要細(xì)思量）
?如果你無法向人描述你的方案，那肯定不是一個好方案；反之亦然（方案測評標(biāo)準(zhǔn)）
?命名空間是一種絕妙的理念，我們應(yīng)當(dāng)多加利用（倡導(dǎ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ù)類型：
數(shù)字：整型int，浮點型float，bool型，復(fù)數(shù)complex
組分為序列，集合，字典
序列（有序（此處有序是指輸入后順序不改變，即不具備自動排序功能），可下標(biāo)索引，切片操作）：字符串str，列表list，元組tuple
集合set：無序（此處的無序是指輸入后set內(nèi)部進(jìn)行自己排序，導(dǎo)致序列可能與之前的不同），沒有索引，不能切片
字典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ū)別（集合是自動排序的）：
>>> {1,'2',3.3,True}
{'2', 1, 3.3}
>>> {1,'2',3.3,False}
{'2', 1, 3.3, False}

轉(zhuǎn)義字符的使用：
當(dāng)使用IDLE直接輸出時：
例：
'"k"'
輸出：'"k"'
"'k'"
輸出："'k'"
轉(zhuǎn)義字符的使用：
單一轉(zhuǎn)義均可轉(zhuǎn)（轉(zhuǎn)雙引號顯示‘'，轉(zhuǎn)單引號顯示“”）：
>>> '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)雙引號，因此全顯示‘'）：
>>> "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

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

字符串的運算：
可加性：
>>> 'hello'+'world'
'helloworld'
通過[]下標(biāo)形式獲取字符串的字符：
>>> 'helloworld'[7]
'r'
>>> 'hello'[0]
'h'
負(fù)數(shù)時從后面開始計數(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
字符串的截取（左閉右開區(qū)間，截取字符個數(shù)為右減左，但是要注意字符串是從0開始的）（格式：字符串后加[左區(qū)間:右區(qū)間]）：
>>> 'helloworld'[0:2]
'he'
>>> 'helloworld'[1:5]
'ello'
我們截取到最后時可以數(shù)到最后一位截取，也可以超出規(guī)定位數(shù)進(jìn)行截取：
>>> 'hello'[0:5]
'hello'
>>> 'hello'[0:20]
'hello'
負(fù)數(shù)表示概念：步長（從字符串末尾往回數(shù)幾個字符）（負(fù)數(shù)在截取字符串中表示的含義與獲取字符時相同，但是截取時是左閉右開區(qū)間，如果要截到最后一位（序號為-1），就要加一為0，但是實際操作并不是要寫0,可看下面的例子）：
>>> 'helloworld'[0:-1]
'helloworl'
>>> 'hellowprld'[0:0]
''
>>> 'hello'[0:]
'hello'
由上面的這個例子可以推出：
>>> 'hello'[:3]
'hel'
由前兩個例子可以得到從頭截取到尾的表示方法：
>>> '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（元組）都可以看做序列：
每個元素都有一個序號：
>>> (1,2,3)[1]
2
>>> [1,2,3][1]
2
>>> '123'[1]
'2'
bool類型在序列中的判斷使用：
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ù)組
空元組與空列表（元組內(nèi)表示單個元素時要加逗號，否則直接計算出來變?yōu)樵瓉淼臄?shù)據(jù)類型）：
>>> ((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ù)類型可以不唯一：
>>> ['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'>
列表與字符串類似，也具有可加性：
>>> [1,2]+[1]
[1, 2, 1]
列表內(nèi)元素的獲?。愃朴谧址嚓P(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ù)類型不會變。
需要注意的是，我們用冒號截取一段時，截取結(jié)果依然是列表，而我們不使用冒號獲取單一元素時，截取結(jié)果的數(shù)據(jù)類型只是該元素的數(shù)據(jù)類型（比如我們截取“3”，那么截取結(jié)果的數(shù)據(jù)類型就是字符串，結(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ù)的簡單使用（len(),min(),max()等）：
>>> len([1,2,3])
3
size是沒有定義的：
>>> 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
未知量是無法比較的（并不是字符串的比較，未知量會出錯）：
>>> 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'
對字符串：
>>> min('abcde')
'a'
>>> max('aaa111ccc')
'c'
>>> min('aaa111ccc')
'1'
>>> min('a b')
' '
上面的例子實際是有輸出的，是空格。
對于元組與列表的比較和對字符串的比較是不同的（字符串的比較是無論多少字符串只輸出最大或最小的字符，而元組或列表是對每個元素的比較，元素可能就是字符串，那么就是對字符串的比較）：
>>> max('abbcc''bccaa')
'c'
>>> max("abc""def")
'f'
>>> max(["abc","cde"])
'cde'
>>> max(('abc','def'))
'def'
ord()函數(shù)是直接輸出字符（單個字母或符號，Python中無字符概念）所對應(yīng)的ASCII碼：
只能是單個字符：
>>> 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
空格所對應(yīng)的ASCII碼：
>>> ord(' ')
32
單雙引號均可（Python都表示字符串）：
>>> ord('0')
48
>>> ord("0")
48

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

系統(tǒng)關(guān)鍵字也可以自定義但是系統(tǒng)關(guān)鍵字之前的功能就失效了
沒有必要給自己挖這樣的坑：
>>> 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就失去原來功能。
引用類型是可變的，賦值改變時不新增對象，只是對原來的對象進(jìn)行改變，值類型是不可變的，值類型重新賦值時會新增一個對象。
上面注意引用類型的使用
>>> 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
對于str類型也是如此：
（如下圖）
str由于是不可變類型，所以'python'[0]='o'是錯誤的。

or and not :
或 且 非：
或只需一個真就不必往后進(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

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

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

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

下面的解包方式都是正確的（對應(yīng)元素個數(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ù)（形參，實參）：形參是定義時括號內(nèi)的參數(shù)，實參是調(diào)用時括號內(nèi)的參數(shù)
1.必須參數(shù)：定義了多少個形參就要傳遞多少個實參
2.關(guān)鍵字參數(shù)：對實參進(jìn)行標(biāo)注，然后可以隨意調(diào)換實參順序
例：
函數(shù)定義：def add(x,y):
函數(shù)調(diào)用：result = add(y = 3, x = 2)
3.默認(rèn)參數(shù)：在形參上進(jìn)行操作，當(dāng)存在實參時，代入該實參，否則代入默認(rèn)參數(shù)（一般傳參數(shù)較多時使用，但是不推薦傳入?yún)?shù)過多，當(dāng)參數(shù)過多時可傳入對象）
例：
def test(z, x = 1, y = 2):
    print(x, y, z)
test(3)
輸出：
1 2 3
注意定義函數(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
另外對于調(diào)用來說也可以使用關(guān)鍵字參數(shù)來進(jìn)行指明傳參量
但是對于關(guān)鍵值參數(shù)也是不可以將必須參數(shù)與默認(rèn)參數(shù)的順序隨意混亂，仍然遵循默認(rèn)參數(shù)之后不可存在必須參數(shù)（除非每個參數(shù)都是關(guān)鍵字參數(shù)）
'''

'''
面向?qū)ο?
有意義的面向?qū)ο蟮拇a
有類不能等同于是面向?qū)ο?
類的實例化
student = Student()
類最基本的作用：封裝
類下面的函數(shù)一定要加self，否則會報錯，而且在使用類內(nèi)的變量時一定要加self，否則也會報錯
建議類的模塊內(nèi)只寫類，不寫類的實例化與調(diào)用
如果寫在一起代碼結(jié)構(gòu)會變得非常松散
方法和函數(shù)的區(qū)別：很多時候已經(jīng)模糊了這兩個概念：
C，C++：函數(shù)，java，C#：方法
方法：更多的是面向?qū)ο蟮母拍?，面向?qū)ο蟾P(guān)注的是設(shè)計，設(shè)計代碼結(jié)構(gòu)，設(shè)計封裝
因此方法更多的是設(shè)計層面的稱謂
函數(shù)：更多的是面向過程的概念，沒有設(shè)計層面的意義在里面
程序運行，過程式的一種稱謂
類是現(xiàn)實世界或思維世界的實體在計算機(jī)中的反映
它將數(shù)據(jù)（數(shù)據(jù)成員）以及這些數(shù)據(jù)上的操作（方法）封裝在一起
python內(nèi)類構(gòu)造函數(shù)在實例化時會自動調(diào)用
格式如下：def __init__(self):
默認(rèn)返回為None，而且只能返回None，不能返回其他類型
要傳入?yún)?shù)的話寫在構(gòu)造函數(shù)內(nèi)，而且一旦確定就必須傳入相應(yīng)實參
構(gòu)造函數(shù)：初始化對象的屬性（特征）
等號左邊為類內(nèi)變量（數(shù)據(jù)成員），右邊為形參名
數(shù)據(jù)成員與形參名可以相等
例：
name = name
而不必非要寫成name =  name1或者name = name_等
之前講到的模塊部分局部變量與全局變量的作用域：
模塊內(nèi)局部變量不會覆蓋全局變量
（函數(shù)的局部變量與模塊的全局變量可重名）
類變量，實例變量的概念（見下面例題）
python尋找機(jī)制：
如果要尋找實例變量，如果沒有找到會到類變量內(nèi)去尋找，如果還是沒有找到，會到類的父類里面去尋找（繼承）
'''
'''
class Student:  # 在這里Student后面也可以選擇加上括號，但是加不加無所謂，加上在PyCharm中反而會提示多余的括號
    name = 'MJG'
    age = 0
    # 類變量
    def __init__(self, name, age):
        self.name = name
        self.age = age
        # 實例變量（必須加上self）（當(dāng)然self可以是任意的，只不過使用self是一種常用習(xí)慣）
        # 有了實例變量的概念，那么還有實例方法的概念（對象實例可以調(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',這是因為在構(gòu)造函數(shù)內(nèi)沒有標(biāo)明self，導(dǎo)致變量只作用于局部
# 當(dāng)輸出時找不到對象變量就只能尋找類變量進(jìn)行輸出
'''
'''
下面介紹一下變量__dict__（系統(tǒng)內(nèi)置到對象中保存對象的所有變量）：
可通過打印__dict__變量查看對象的所有變量，當(dāng)然我們也可以打印該類變量打出類內(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}
# 分別顯示了所有的對象變量與類變量
'''
'''
Python類：
變量：類變量，實例變量
方法：實例方法，類方法，靜態(tài)方法
特殊函數(shù)：構(gòu)造函數(shù)
實例變量：訪問實例變量在類內(nèi)必須加上self，否則會出現(xiàn)誤解，導(dǎo)致找不到實例變量
在類外可以直接調(diào)用
例：
    def __init__(self, name1, age1):
        self.name = name1
        self.age = age1
        print(self.name)  # 調(diào)用實例變量（正確）
        print(name)  # 既不是調(diào)用實例變量也不是調(diào)用類變量（類變量內(nèi)雖然存在name變量，但是這并不是調(diào)用類變量的方式，依然會報錯）
        print(name1) # 既不是調(diào)用實例變量也不是調(diào)用類變量（但是這里并不會報錯，調(diào)用的是形參）
        # 調(diào)用類變量的兩種方法：
        print(Student.name)  # 訪問類變量（類內(nèi)類外都可以這樣調(diào)用）
        print(self.__class__.name)  # 類變量的調(diào)用（類內(nè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('最后類變量sum：' + str(Student.sum))
輸出：
name:1
age:2
當(dāng)前sum數(shù)：1
name:3
age:4
當(dāng)前sum數(shù)：2
最后類變量sum：2
類方法：
對于類變量我們可以在構(gòu)造函數(shù)或?qū)嵗椒ㄖ羞M(jìn)行操作，當(dāng)然我們完全可以通過類方法來進(jìn)行操作：
一般來說，對于類變量的操作我們都是放在類方法中去執(zhí)行，而不是構(gòu)造函數(shù)與實例方法
定義：
標(biāo)志（裝飾器）：@classmethod
類方法代表名：cls（參數(shù)列表內(nèi)），也像實例方法一樣可以更改，但是也是一種習(xí)慣性表達(dá)
例：
class Student:
    sum = 0
    @classmethod
    def sum_(cls):
        cls.sum += 1
        print(cls.sum)
Student.sum_()  # 類方法就要使用類去調(diào)用
但是python也是允許對象去調(diào)用類方法的，但是這在實際上是說不通的，一般不建議使用這種方法
# student = Student
# student.sum_()
輸出結(jié)果：
1
靜態(tài)方法：
定義：
標(biāo)志（裝飾器）：@staticmethod
類方法與實例方法、類方法的區(qū)別：
靜態(tài)方法沒有像實例方法、類方法那樣要求強(qiáng)制傳入一個默認(rèn)指定的名字，類方法的cls代表的是類本身，實例方法的self代表的是實例本身
靜態(tài)方法沒有這樣一個默認(rèn)傳入，只是一個普普通通的方法
總結(jié)：
類訪問類變量（OK），實例變量（也OK）
對象訪問類變量，實例變量，都OK
類與對象都可以訪問靜態(tài)方法
類方法，實例方法，靜態(tài)方法之間的相互訪問：
類方法與靜態(tài)方法都不可以訪問實例變量
實例方法與靜態(tài)方法都可以訪問類變量

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

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

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

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