1、数学计算：
n的m次方：n**m
n除以m的整数值：n // m
n除以m的浮点值：n / m
Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 
复数的实部a和虚部b都是浮点型
tuple的元素不可改变，但它可以包含可变的对象，可变对象中的元素可以改变。
string、list和tuple都属于sequence（序列）

集合(set)的运算：- | & ^
2  进制是 0b 
8  进制是 0o
16 进制是 0x 

创建一个空集合用 set()
创建一个空字典用 { }。


2、转义字符输出，添加 r 使用原始字符
反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
print('C:\name\111')
#输出 C:
      ame\111
print(r'C:\name\111')
#输出 C:\name\111

3、多行输出,去除第一行换行加 \ 
print('''
nihao
zaima
''')
#输出
[space]
nihao
zaima
print('''\
nihao
zaima
''')
#输出
nihao
zaima

3、使用 + 进行字符串的连接，使用 * 进行字符串的重复
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
3*'aaa'+'bbb'
#输出
aaaaaaaaabbb

4、最后式子的值作为下面的输入  _
'aaaa'
a=_
print(a)
#输出
aaaa
3*5
3+_
#输出
18

5、多个赋值,右侧的表达式在赋值发生之前都是计算的
a,b=1,2
a,b=a,a+b
a,b
#输出
(2,3)


6,print()输出
print('aaaa',end=',')
print('bbbb')
#输出
aaaabbbb

7、在循环内修改正在迭代的序列（例如，复制所选的项目），建议首先创建原序列的拷贝。
对序列进行迭代不会隐式地进行复制。
切片符号使这特别方便：
for w in words[:]:  # Loop over a slice copy of the entire list.
     if len(w) > 6:
         words.insert(0, w)
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']

for w in words:
     if len(w) > 6:        
        words.insert(0, w)
#死循环

8、for循环的else子句在未出现break时运行
for x in range(7):
    if x>5:
        print(x)
        break
else:
    print('else')
#输出
6
for x in range(7):
    if x>5:
        print(x)
else:
    print('else')
#输出
6
else

9、默认值在函数定义的时刻，在定义的作用域中计算，当默认值是一个可变对象（如列表，字典或大多数类的实例）时，这会产生不同。
i=5
def f(arg=i):
    print(arg)
i=6
f()
#输出
5
def f(a,L=[]):
    L.append(a)
    return L
f(1) #输出[1]
f(2) #输出[1,2]
f(3) #输出[1,2,3]
如果你不想在后续调用之间共享默认值，你可以写这样的函数
def f(a,L=None):
    if L is None:
        L=[]
    L.append(a)
    return L
    
10、如果存在一个**name形式的形式参数，它将接收一个字典（参见映射类型——字典），这个字典包含除形式参数之外的所有关键字参数。
它可以与*name形式的形式参数组合，这种形式接收一个元组，这个元组包含除形式参数之外的所有位置参数。(*name必须出现在**name之前）
def test(**kr):
    return kr
def test2(*z):
    return z
def test3(*kr,**z):
    return kr,z
def test4(a,b=1,e=3,*c,**d):
    return a,b,e,c,d
print(test(a=4,b=2,c=5))    
print(test2(1,2,3,4))
print(test3('a','b','c',a=1,b=3))
print(test4(1,1,2,2,3,4,c=5))
#输出
{'a': 4, 'b': 2, 'c': 5}
(1, 2, 3, 4)
(('a', 'b', 'c'), {'a': 1, 'b': 3})
(1, 1, 2, (2, 3, 4), {'c': 5})

11、函数：string.join()
  join()：连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
def testJoin(*arg,seq='/'):
    return seq.join(arg)
print(testJoin('D:','com','geng'))
print(testJoin('D:','com','geng',seq='\\'))
#输出
D:/com/geng
D:\com\geng

12、Lambda函数可用于需要函数对象的任何地方。它们在语法上限于单个表达式。语义上，它们只是用于正常函数定义的语法
def func(n):
    return lambda x,y:x+y+n
f=func(1)
print(f)
print(f(1,23))
print(f(2,3))
pair=[(1,2),(3,7),(4,3)]
pair.sort(key=lambda x:x[1])
print(pair)


13、函数注解
注解以字典形式存储在函数的__annotations__属性中，对函数其它任何部分没有任何影响。
参数注解的定义是参数名后面跟着一个冒号，然后紧跟着一个用于计算注解的表达式。
def functest(t:str,eg:int=1)->str:
    print(functest.__annotations__)
    print(t+'aaa',eg)
functest('11111', 111)
#输出
{'t': <class 'str'>, 'eg': <class 'int'>, 'return': <class 'str'>}
11111aaa 111

def my_function():
     """Do nothing, but document it.

     No, really, it doesn't do anything.
     """
     pass
print(my_function.__doc__)
#输出
Do nothing, but document it.

    No, really, it doesn't do anything.

14、string.strip(str),
声明：string为字符串，str为要删除的字符序列
s.strip(rm)      删除s字符串中开头、结尾处，位于rm删除序列的字符
s.lstrip(rm)     删除s字符串中开头处，位于rm删除序列的字符
s.rstrip(rm)     删除s字符串中结尾处，位于rm删除序列的字符
string.strip(' ')
'111 2222 333 444'
string.lstrip(' ')
'111 2222 333 444   '
string.rstrip(' ')
' 111 2222 333 444'
!!!!!!!当rm为空时，默认删除空白符（包括'\n', '\r',  '\t',  ' ')
 string=''' \n nihao \t'''
 string.strip()
 'nihao'

15、zip()函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表
 a=[[1,2,3,4],[5,6,7],[8,9,10,11,12]]
 list(zip(*a))
>>>[(1, 5, 8), (2, 6, 9), (3, 7, 10)]
 list(zip(a))
>>>[([1, 2, 3, 4],), ([5, 6, 7],), ([8, 9, 10, 11, 12],)]
aa=[1,2,3]
bb=[1,2]
cc=[1,2,3,4]
zip(aa,bb,cc)
[(1, 1, 1), (2, 2, 2)]

16、当循环遍历字典时，键和对应的值可以使用items()方法同时提取出来。
k={'111':1,'222':2,'33333':3}
for k,v in k.items():
    print(k,':',v)
111 : 1
222 : 2
33333 : 3

17、两个或更多的序列，使用zip()函数可以成对读取元素。
q=['name','age','sex']
a=['geng',23,'man']
for x,y in zip(q,a):
     print('{0}:{1}'.format(x,y))
     
18、is和is not比较两个对象是否为相同的对象；这只对列表这样的可变对象比较重要
    x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False，id() 函数用于获取对象内存地址。

19、str()与repr(),str()用于显示人类所看到的，repr()用于编译所看到的
s='\n'
str(s) #输出 \n
repr(s) #输出 \\n  #编译时对 \ 进行了转义

20、str.center()、str.ljust(int)和str.rjust(int),str占用int个字节，并且左右对齐
如果输入的字符串太长，字符串不会被截断，会完整输出。
a='10'
a.center(5)  #'  10 '
a.ljust(5)   #'10   '
a.rjust(5)   #'   10'
如果你真的想要截断，可以加上一个切片操作，例如x.ljust(n)[:n],不过将失去对齐方式

21、str.zfill()，它向数值字符串左侧填充零。它理解加号和减号，超出是也不会截断
'-3.14'.zfill(7)
#'-003.14'

22、str.format()
'!a'（运用ascii()）、'!s'（运用str()）和'!r'（运用repr()）可以用来在格式化之前转换相应的值。
':'后面紧跟一个整数可以限定该字段的最小宽度。
print('---{1!r:10}---{2!a:10}---{0!s:10}---'.format("111\n","222\n","3333\n"))
#输出
---'222\n'   ---'3333\n'  ---111
      ---
可以传入一个字典，然后使用'[]'访问
dict={"str":"string",10:10,"PI":3.1415926}
print('str{0[str]:10s},int{0[10]:5d},{0[PI]:.3f}'.format(dict))
#输出
strstring    ,int   10,3.142

23、其他类型的对象,在写入之前则需要转换成 字符串 （在文本模式下） 或 字节对象 （以
二进制模式）
value = ('the answer', 42)
s = str(value)  # convert the tuple to string
f.write(s)
#文件中显示
('the answer', 42)

24、f.seek(offset, from_what)更改该文件对象的位置，
from_what可以省略，默认为0，使用文件的开头作为参考点。
当from_what的值为0，1，2 时，分别使用文件开头、当前文件位置和文件结尾作为参考点
位置由参考点加上offset 计算得来。
f=open('test.txt','rb+')
print(f.write(b'011234567asdcvfg'))
f.seek(5)               #默认0开始读取
print(f.read(1))
print(f.tell())          #当前位置
f.seek(5,1)              #当前位置开始读取
print(f.read(1))
f.seek(-1,2)             #文件末尾开始读取
print(f.read(1))
#输出
16
b'4'
6
b'd'
b'g'

25、file.tell()返回一个整数，代表文件对象在文件中的当前的位置，
在二进制模式中该数值表示自文件开头到指针处的字节数，在文本模式中则是不准确的。
例题看上面
在文本文件中（没有以b模式打开的文件），只允许从文件的开始查找（有个例外是查找到文件的末尾seek(0, 2)），
而且offset只有是从f.tell()返回的值或者是0才是合法的。任何其他偏移值会产生未定义的行为。

26、使用json存储结构化数据
json.dumps([1, 'simple', 'list'])
>>>'[1, "simple", "list"]'
dumps()函数的另外一个变体dump()，直接将对象序列化到一个文本文件。
如果f是为写入而打开的一个文件对象
json.dump(object, file)
为了重新解码对象，如果f是为读取而打开的文本文件对象 ：
object = json.load(f)

27、type与isinstance
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型

class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

27、构造函数 dict() 可以直接从键值对序列中构建字典
dictE = dict ([("ee",11), ("aaa", "bbbb"), (123, 123), (True, True)]); 
print (dictE);

dictF = {x: x*2 for x in (2, 4, 6)};
print (dictF);

dictG = dict (name = 1, goole = "name", bool = True);
print(dictG);

28、isdigit、isnumeric、isdecimal的差别
isdigit()
True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
False: 汉字数字
Error: 无

isdecimal()
True: Unicode数字，，全角数字（双字节）(十进制)
False: 罗马数字，汉字数字
Error: byte数字（单字节）

isnumeric()
True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
False: 无
Error: byte数字（单字节）

29、 splitlines() 
按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，
如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
print ('ab c\n\nde fg\rkl\r\n'.splitlines());
print ('ab c\n\nde fg\rkl\r\n'.splitlines(True));
>>>
['ab c', '', 'de fg', 'kl']
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

30、list.copy()与 = 赋值
使用 = 直接赋值，是引用赋值，更改一个，另一个同样会变；
copy() 则顾名思义，复制一个副本，原值和新复制的变量互不影响；

31、
循环语句可以有 else 子句，
它在穷尽列表(以for循环)或条件变为 false (以while循环)
导致循环终止时被执行,但循环被break终止时不执行。

sites = ['1', '2', '3', '4'];
for site in sites:
    if site == '3':
        print ("找到了");
        break;
    print ("循环数据 " + site);
else:
    print ("没有循环数据!");
print ("完成循环!");
>>>
循环数据 1
循环数据 2
找到了
完成循环

32、Python的作用域一共有4种，分别是：
    L （Local） 局部作用域
    E （Enclosing） 闭包函数外的函数中
    G （Global） 全局作用域
    B （Built-in） 内建作用域
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

x = int(2.9)  # 内建作用域
 
g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域


Python中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问

33、默认参数必须放在最后面，否则会报

34、global 和 nonlocal关键字
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

global关键字用来在函数或其他局部作用域中使用全局变量。
nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量

35、def(**kwargs) 把N个关键字参数转化为字典:

>>> def func(country,province,**kwargs):
...     print(country,province,kwargs)
... 
>>> func("China","Sichuan",city = "Chengdu", section = "JingJiang")
China Sichuan {'city': 'Chengdu', 'section': 'JingJiang'}
>>> 

36、同时遍历两个或更多的序列，可以使用 zip() 组合：

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...    #print('what is your %s? it is %s' %(q,a))
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

37、在:file:sounds/effects/__init__.py中包含如下代码:
__all__ = ["echo", "surround", "reverse"]
这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。 

38、使用del语句删除一些对象引用。
del var1[,var2[,var3[....,varN]]]]

39、注意：
Python可以同时为多个变量赋值，如a, b = 1, 2。
一个变量可以通过赋值指向不同类型的对象。
数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符。
在混合计算时，Python会把整型转换成为浮点数。

40、集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合。

41、
字典是一种映射类型，它的元素是键值对。
字典的关键字必须为不可变类型，且不能重复。
创建空字典使用 { }。

42、
x and y    布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。    
x or y    布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
not x    布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

43、
repr(x)
将对象 x 转换为表达式字符串

eval(str)
用来计算在字符串中的有效Python表达式,并返回一个对象