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

'''
sadasdj
adas
'''
Out[1]: '\nsadasdj\nadas\n'

'asda
 File "<ipython-input-2-6af9d7d5e65d>", line 1
  'asda
     ^
SyntaxError: EOL while scanning string literal


'asdd\
adsad\
sad'
Out[3]: 'asddadsadsad'

print('asda\nsada\n')
asda
sada


'''
asda\n
'''
Out[5]: '\nasda\n\n'

print(r'c:\nsda\nsds')
c:\nsda\nsds

print(r'let's go')
 File "<ipython-input-3-a81b31c0c433>", line 1
  print(r'let's go')
        ^
SyntaxError: invalid syntax

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

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

"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'

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

["新月打擊","蒼白之瀑","月之降臨","月神沖刺"]
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]

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

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

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

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

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

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

a = [1,2,3,4]

a.append('5')

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

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

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

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

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

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

a[3][1] = '2'

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

{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}

type({})
Out[8]: dict

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

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

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]

a = 'hello'

id(a)
Out[15]: 1510080259608

a = a + 's'

id(a)
Out[17]: 1510081716832

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

 File "<ipython-input-18-02436d67df37>", line 1, in <module>
  a[0] = 's'

TypeError: 'str' object does not support item assignment

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

a = 1

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

a = '1'

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

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

a = 'sds'

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

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

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

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',......]

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

if __name__ == '__main__':
  pass

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

# 由父包引入子包或者同級別引入的情況

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è)變量可用逗號隔開

from packet import * # 這行代碼會引入被引入包中__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)置的變量。

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

import sub11.c3

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

flie: D:\pycode\sub1\sub11\c3.py

# __doc__記錄的是該模塊的開頭注釋

# __name__記錄該模塊的名字

# __package__記錄該模塊屬于的包

# __file__記錄該模塊的文件的絕對路徑

'''
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文件，可見此時(shí)如果在c3.py中打印內(nèi)置變量，__name__被強(qiáng)制定位__main__，而且package上也不會顯示出所屬于的包，file路徑也發(fā)生了變化。

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

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)

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

<class 'tuple'>
1 2 3
----------------
1 1 1

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

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

(1, 2, 3, [4, 5, 6])
<class 'tuple'>

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

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

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

((1, 2, 3),)
<class 'tuple'>
(1, 2, 3)
<class 'tuple'>

# *可以解包。

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

demo(q='萬能牌', w='切牌', e='占卜')

{'q': '萬能牌', 'w': '切牌', 'e': '占卜'}
<class 'dict'>

# 可見傳進(jìn)來以后是一個(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='切牌', e='占卜')

{'q': '萬能牌', 'w': '切牌', 'e': '占卜'}
<class 'dict'>
q : 萬能牌|| 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':'切牌', 'e':'占卜'}
demo(**a)

{'q': '萬能牌', 'w': '切牌', 'e': '占卜'}
<class 'dict'>
q : 萬能牌|| w : 切牌|| e : 占卜||

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

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

a
1
(2, 3)

# 可見如果默認(rèn)參數(shù)在可變參數(shù)之前，會發(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'}

class Student():
  name = 'Catherian'
  age = 0
  high = 170
  def __init__(self, name, age, high):
    self.name = name
    self.age = age
    high = high
    # 注意這里的身高沒有用self.high來定義
  
  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 # 這里打印出的才是類變量

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

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

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

{'__module__': '__main__', 'name': 'Catherian', 'age': 0, 'high': 170, '__init__': <function Student.__init__ at 0x000001F06B70F9D8>, 'doHomework': <function Student.doHomework at 0x000001F06B70FA60>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}

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

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

# 我們定義一個(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 <module>
  print(student1.__score)
AttributeError: 'Student' object has no attribute '__score'
# 可以看到不能這樣訪問。
---------------------------------------------------------------------

# 如果我們再加上一句再執(zhí)行：

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

-1

# 我們發(fā)現(xià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}

# 我們可以看到，我們再里面定義的__score變量被定義成了_Student__score變量，__score變量是我們根據(jù)Python動態(tài)特性新定義出的實(shí)例變量。所以要訪問私有變量也很簡單：

print(student1._Student__score)

0

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

# 定義一個(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) # 這里注意通過類名調(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  # 可見通過父類方法里對sum的操作，繼承到子類中時(shí)，對于重名變量仍然可以操作子類中的重名變量。
2 # 根據(jù)搜索機(jī)制，實(shí)例變量里沒有找到子類里的類變量，再沒有找父類。
okk
None
this is a parent method # 可見調(diào)用了父類中的方法。
doHomework
None

from enum import Enum

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


diamond.YELLOW

# 可見打印出的就是diamend.YELLOW

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出來的是YEELOW。
odict_items([('YELLOW', <diamond.YELLOW: 1>), ('BLUE', <diamond.YELLOW: 1>), ('GREEN', <diamond.GREEN: 3>), ('RED', <diamond.RED: 4>)])

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)

枚舉類型為： <enum 'diamond'> diamond.GREEN
枚舉的名稱為 <class 'str'> GREEN
枚舉的值為： 3

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

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


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

from enum import Enum
from enum import IntEnum, unique

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