'''
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)美的代碼為目標）
?明了勝于晦澀（優(yōu)美的代碼應當是明了的，命名規(guī)范，風格相似）
?簡潔勝于復雜（優(yōu)美的代碼應當是簡潔的，不要有復雜的內部實現(xiàn)）
?復雜勝于凌亂（如果復雜不可避免，那代碼間也不能有難懂的關系，要保持接口簡潔）
?扁平勝于嵌套（優(yōu)美的代碼應當是扁平的，不能有太多的嵌套）
?間隔勝于緊湊（優(yōu)美的代碼有適當?shù)拈g隔，不要奢望一行代碼解決問題）
?可讀性很重要（優(yōu)美的代碼是可讀的）
?即便假借特例的實用性之名，也不可違背這些規(guī)則（這些規(guī)則至高無上）
?不要包容所有錯誤，除非你確定需要這樣做（精準地捕獲異常，不寫 except:pass 風格的代碼）
?當存在多種可能，不要嘗試去猜測
?而是盡量找一種，最好是唯一一種明顯的解決方案（如果不確定，就用窮舉法）
?雖然這并不容易，因為你不是 Python 之父（這里的 Dutch 是指 Guido ）
?做也許好過不做，但不假思索就動手還不如不做（動手之前要細思量）
?如果你無法向人描述你的方案，那肯定不是一個好方案；反之亦然（方案測評標準）
?命名空間是一種絕妙的理念，我們應當多加利用（倡導與號召）
'''

>>> 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型，復數(shù)complex
組分為序列，集合，字典
序列（有序（此處有序是指輸入后順序不改變，即不具備自動排序功能），可下標索引，切片操作）：字符串str，列表list，元組tuple
集合set：無序（此處的無序是指輸入后set內部進行自己排序，導致序列可能與之前的不同），沒有索引，不能切片
字典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}

轉義字符的使用：
當使用IDLE直接輸出時：
例：
'"k"'
輸出：'"k"'
"'k'"
輸出："'k'"
轉義字符的使用：
單一轉義均可轉（轉雙引號顯示‘'，轉單引號顯示“”）：
>>> '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"
轉義混合只轉雙（由于只轉雙引號，因此全顯示‘'）：
>>> "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ù)直接轉：
>>> 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'
對于轉義字符換行的使用（單雙引號與三引號）：
>>> 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'
通過[]下標形式獲取字符串的字符：
>>> 'helloworld'[7]
'r'
>>> 'hello'[0]
'h'
負數(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ù)進行截?。?
>>> 'hello'[0:5]
'hello'
>>> 'hello'[0:20]
'hello'
負數(shù)表示概念：步長（從字符串末尾往回數(shù)幾個字符）（負數(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
注意字符串內判斷要用‘'
>>> '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ù)組
空元組與空列表（元組內表示單個元素時要加逗號，否則直接計算出來變?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'>
列表內的數(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]
列表內元素的獲?。愃朴谧址嚓P截取操作）：
>>> [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ù)類型不會變。
需要注意的是，我們用冒號截取一段時，截取結果依然是列表，而我們不使用冒號獲取單一元素時，截取結果的數(shù)據(jù)類型只是該元素的數(shù)據(jù)類型（比如我們截取“3”，那么截取結果的數(shù)據(jù)類型就是字符串，結果是‘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中無字符概念）所對應的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
空格所對應的ASCII碼：
>>> ord(' ')
32
單雙引號均可（Python都表示字符串）：
>>> ord('0')
48
>>> ord("0")
48

集合（set）也是序列的一種：
集合的運算：
集合支持序列的相關運算，同時不一樣的地方在于：
集合是不允許元素重復的，會自動清除相同元素，同時元素是有序的（默認從小到大），之前的元組以及列表都是無序的。
>>> {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
字典是無序的，字典不屬于序列，無法用下標的形式進行查詢，但是字典存在key值，我們可以通過直接查詢key值來查詢相關元素：
鍵值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)關鍵字也可以自定義但是系統(tǒng)關鍵字之前的功能就失效了
沒有必要給自己挖這樣的坑：
>>> 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
當然上面也可以將type改為print，print就失去原來功能。
引用類型是可變的，賦值改變時不新增對象，只是對原來的對象進行改變，值類型是不可變的，值類型重新賦值時會新增一個對象。
上面注意引用類型的使用
>>> 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 :
或 且 非：
或只需一個真就不必往后進行判斷了，且是需要判斷到最后才能算出是否為真，因此結果如下：
>>> not True
False
>>> 1 or 2
1
>>> 2 or 3
2
>>> 3 or 4
3
>>> 1 and 2
2
>>> 2 and 3
3

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

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

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

'''
面向對象
有意義的面向對象的代碼
有類不能等同于是面向對象
類的實例化
student = Student()
類最基本的作用：封裝
類下面的函數(shù)一定要加self，否則會報錯，而且在使用類內的變量時一定要加self，否則也會報錯
建議類的模塊內只寫類，不寫類的實例化與調用
如果寫在一起代碼結構會變得非常松散
方法和函數(shù)的區(qū)別：很多時候已經模糊了這兩個概念：
C，C++：函數(shù)，java，C#：方法
方法：更多的是面向對象的概念，面向對象更關注的是設計，設計代碼結構，設計封裝
因此方法更多的是設計層面的稱謂
函數(shù)：更多的是面向過程的概念，沒有設計層面的意義在里面
程序運行，過程式的一種稱謂
類是現(xiàn)實世界或思維世界的實體在計算機中的反映
它將數(shù)據(jù)（數(shù)據(jù)成員）以及這些數(shù)據(jù)上的操作（方法）封裝在一起
python內類構造函數(shù)在實例化時會自動調用
格式如下：def __init__(self):
默認返回為None，而且只能返回None，不能返回其他類型
要傳入?yún)?shù)的話寫在構造函數(shù)內，而且一旦確定就必須傳入相應實參
構造函數(shù)：初始化對象的屬性（特征）
等號左邊為類內變量（數(shù)據(jù)成員），右邊為形參名
數(shù)據(jù)成員與形參名可以相等
例：
name = name
而不必非要寫成name =  name1或者name = name_等
之前講到的模塊部分局部變量與全局變量的作用域：
模塊內局部變量不會覆蓋全局變量
（函數(shù)的局部變量與模塊的全局變量可重名）
類變量，實例變量的概念（見下面例題）
python尋找機制：
如果要尋找實例變量，如果沒有找到會到類變量內去尋找，如果還是沒有找到，會到類的父類里面去尋找（繼承）
'''
'''
class Student:  # 在這里Student后面也可以選擇加上括號，但是加不加無所謂，加上在PyCharm中反而會提示多余的括號
    name = 'MJG'
    age = 0
    # 類變量
    def __init__(self, name, age):
        self.name = name
        self.age = age
        # 實例變量（必須加上self）（當然self可以是任意的，只不過使用self是一種常用習慣）
        # 有了實例變量的概念，那么還有實例方法的概念（對象實例可以調用的方法）
student = Student('1', '2')
print(student.name)
print(student.age)
student = Student
print(student.name)
print(student.age)
# 輸出結果：
# 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)
# 輸出結果：
# MJG
# 0
# 卻并不是我們想要的'1', '2',這是因為在構造函數(shù)內沒有標明self，導致變量只作用于局部
# 當輸出時找不到對象變量就只能尋找類變量進行輸出
'''
'''
下面介紹一下變量__dict__（系統(tǒng)內置到對象中保存對象的所有變量）：
可通過打印__dict__變量查看對象的所有變量，當然我們也可以打印該類變量打出類內的所有變量
例：
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__)
輸出結果：
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ù)：構造函數(shù)
實例變量：訪問實例變量在類內必須加上self，否則會出現(xiàn)誤解，導致找不到實例變量
在類外可以直接調用
例：
    def __init__(self, name1, age1):
        self.name = name1
        self.age = age1
        print(self.name)  # 調用實例變量（正確）
        print(name)  # 既不是調用實例變量也不是調用類變量（類變量內雖然存在name變量，但是這并不是調用類變量的方式，依然會報錯）
        print(name1) # 既不是調用實例變量也不是調用類變量（但是這里并不會報錯，調用的是形參）
        # 調用類變量的兩種方法：
        print(Student.name)  # 訪問類變量（類內類外都可以這樣調用）
        print(self.__class__.name)  # 類變量的調用（類內）
對于類內變量的操作：
    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('當前sum數(shù)：' + str(self.__class__.sum))

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

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

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

一、（三個python通用的，不過沒試過）
下載編譯好的python擴展庫（不過好像停用了）（可以百度一下，很多類似的庫）（一般pip或者搭配鏡像即可）：
　　http //www lfd.uci.edu/~gohlke/pythonlibs/
　　下載完畢后直接解壓放入：
　　C:\Python27\Lib\site-packages(對應自己的庫）
　　就可以import使用了。
　　大部分庫都是有的，特別是機器學習類的，很全。
二、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
國內鏡像源：
http://pypi.douban.com/ 豆瓣
http://pypi.hustunique.com/ 華中理工大學
http://pypi.sdutlinux.org/ 山東理工大學
http://pypi.mirrors.ustc.edu.cn/ 中國科學技術大學
二、（可用但未嘗試）
可對pip進行時間限制，在指定時間限制內忽略中停止問題（加大下載時間）