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': , 'eg': , 'return': }
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表达式,并返回一个对象
130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
