https://docs.python.org/3/tutorial/
#! /root/python-3.6.5/bin/python3.6 （制定用谁来解析下面的code，我没有将pthon3.6安装到系统路径，就这样写了）
#! /usr/bin/env python3 （如果安装在系统路径，可以直接这样写）
基本运算
Python算术运算符
/ 除，x 除以 y（返回浮点型）
** 幂，返回x的y次幂
// 取整除，返回商的整数部分（类C语言的除） 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
Python比较运算符
==, !=, >, <, >=, <= （全部类C）
Python赋值运算符
=, +=, -=, *=, /=, %=, **=, //= （全部类C）
Python位运算符（全部类C）
&, |, ^, ~, <<, >>,
Python逻辑运算符
and （试图找到第一个false）从左到右计算表达式的值，为真则continue，所有均为真则结果为最后一个值，遇假返回第一个假的值
or （试图找到第一个true）从左到右计算表达式的值，为假则continue，所有均为假则结果为最后一个值，遇真则返回第一个为真的值
除了True和False外，None，数字0，空序列（空字符串 "" ，空元组，空list和空字典）均被python认为是假，其他认为是真
Python成员运算符 in / not in
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
for xx in 序列，遍历序列元素，序列可以是(有序的) string/list/tuple 或 (无序的) set/dict（dict.keys()）
Python身份运算符
身份运算符用于比较两个对象的存储单元
is 判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not 判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。
注： id()函数用于获取对象内存地址。如果x 和 y 赋予相同的value，那么python会让两个变量引用到 那个相同的内存
数值类型
Python3 支持 int（python3中唯一的整数类型）、float、bool、complex（复数）。Number值本身不允许改变（即，change某个变量的值其实就是新分配空间了） 。内置的 type() 函数可以用来查询变量所指的对象类型。
数据类型的转换:
• int(x) 将x转换为一个整数。
• str(x) 将x转换为一个string。
• float(x) 将x转换到一个浮点数。
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
• 1、Python可以同时为多个变量赋值，如a, b = 1, 2。
• 2、一个变量可以通过赋值指向不同类型的对象。
• 3、在混合计算时，Python会把整型转换成为浮点数。
• 4、Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型
• 5、del value即删除变量对数字对象的引用 (当引用计数为0时，此数字对象可能会被garbage collect )
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
>>> isinstance(a, int)
True
字符串
• 字符串使用单引号和双引号等价。• 字符串相加表示连接，相乘表示重复。 • 索引字符串 或 切片式索引 都是只读的
str1 = "hello fangding\n" #转义字符串,\n被转义为换行
str2 = r"hello fangding\n" #raw字符串,告诉python关闭转义
str3 = u"hello fangding\n" #u字符串,告诉python此串为unicode编码(也会转义的)
str4 = "your age %d,sex %s,record %12.5f\n"%(28,"male",78.5) #格式化字符串(类C)(12.5f表示整个78.5占12个字符，小数点后保留5位精度)
str5 = '''
多
行
串''' #''' '''或者 """ """ 之间用于表示多行字符串(有\则同样会转义)
str1 = "hello fangding\n", 则str1[0]=="h", str1[1]=="e", str1[0]=="l",……. #索引字符串，只读，str1[0]="a"会导致出错
str1[2:5] 字符串取片段(左闭右开!) ，str1的第[2][3][4]个字符
str1[2:] str1的第[2]到最后的所有字符
str1[2:-1] str1的第[2]到第[-2]个字符(倒数第二个)
str1[:5] str1从开始到第四个字符
str1[8:3:-1] str1的第[8]到第[4]个字符，-1是步长
• 常用的字符串库函数 >>>help(str)
len(str) 字符串的长度，特殊转义字符包括\n也计算在内
int(str) 将纯数字字符串转换为int(若字符串内含非数字则会报错)
ord(str) 获得字符的ASCII码值(str的len只能是1，否则报错)
chr(int) 根据ASCII码值得到字符
str.find(s,a,b) 在str[a,b)区间内查找字符串s(a和b均为可选参数，不写则默认整个字符串)，若出现多处，返回最左边的index，没找到返回-1
str.rfind(s,a,b) 在str[a,b)区间内查找字符串s(a和b均为可选参数，不写则默认整个字符串)，若出现多处，返回最右边的index，没找到返回-1
str.strip() 去掉str左右两边的空格，相当于str.strip(" ")，若写作str.strip("\n")，则去掉str左右两边的\n字符
str.lstrip() 只是去掉str左边的空格，相当于str.lstrip(" ")
str.rstrip() 只是去掉str右边的空格，相当于str.rstrip(" ")
str.split(" ") 以空格字符作为分隔符，分割str(若有多个连续空格，则中间的那些空格也会被捕捉),空格即split()默认参数
str.replace("fang","ding") 将str中的所有"fang"全部替换为"ding",此函数返回一个副本，str引用的string变量没有改变
str.isdigit() str是否是纯数字?
str.isalpha() str是否是纯英文字符?
str.isalnum() str是否是 数字+英文字符?
str.islower() str中包含的string是否都是小写?
str.lower() 将str中包含的string全部转为小写
str.isspace() str是纯空格吗
列表
[ ] 之间、用逗号分隔开的元素列表，类似C中的数组，不同在于数据项可不同类型(甚至可为列表)，可动态增减，长度不定。具有数组风格和链表风格。
list = []
list1 = [12, "hello fang", 23.5]
list3 = list("this is ABC") #将一个string转化为一个list，list每个元素对应了string中的每个字符
len(list1) 计算list1长度
list1[0] 访问index为0的元素，越界会报错，可读写访问(string、元组均只读访问)、
list1[0:2:1] 左闭右开取片段，返回一个包含有list[0] list[1] 数据的新的list，1为缺省步长
for c in list1: 迭代器访问list元素
xxx
list1= ( list1+ list2 ) * 2 等价于 list1.extend(list2) * 2 ，链表的连接
list1.append("www.baidu.com"); 在list末尾添加元素
list1.insert(index, 35.2) 在list[index]元素前面插入新元素35.2
del list1[index] 删除list[index]元素
list1.remove(12) 删除list中值为12的元素
list1.pop(index) 删除list[index]元素并将其值返回,默认pop最后一个
list1.index(23.5) 返回 值为23.5的元素的index
list1.count(12) 统计 值为12的元素的个数，可用于查看set中某个元素是否存在
min(list) 返回列表中最小的元素
max(list) 返回列表中最大的元素
sum(list) 返回列表中所有元素的总和（一般为纯数字list）
list1.sort([func]) 对原来的列表进行排序（list1将被改写，使用sorted(list1)则获得临时副本），可指定func作比较函数，可指定reverse=True。
list1.reverse() 反向列表的所有元素（list1将被改写）
list1.clear() 清空列表的所有元素
list1.copy() 返回一个列表，和list1的元素完全相同
从序列创建列表。将一些操作应用于序列的每个元素，结果作为生成新列表的元素，或者根据确定的判定条件创建子序列
#对列表中的每个元素x，做x->[x,x^2]的映射，得到列表 [[2, 4], [4, 16], [6, 36]]
[[x, x**2] for x in vec1]
#完整的for-if列表推导,对序列中 >3 的那些元素x，做x->3x的映射。if作为可选过滤器
[3*x for x in vec1 if x > 3]
#嵌套,对每一个元素x,执行后面的for-if, 得到一个长度为 len(vec1)*len(vec2)的list
[x*y for x in vec1 for y in vec2]
#两个序列对应元素的乘积
[vec1[i]*vec2[i] for i in range(len(vec1))]
#得到一个string组成的list,string代表355/113,精度不断增加
[str(round(355/113, i)) for i in range(1, 6)]
元组
写在小括号 ( ) 里，元素之间逗号隔开，数据项可不同类型。与列表类似，但元组的元素不能修改，亦不可增删。但可以一次删除整个元组，元组的整体赋值相当于指向另一个新的元组。函数多值返回得到的就是元组。
tuple string list均属于sequence，三者之间可以互相转换
tup1=() 初始化一个空的元组
tup2=(1,) 初始化一个只有一个元素的元组，注意必须要加上","不然会被python理解成int类型
tup1[index] 只读访问第[index]个元素(不可以改变其指向)
tup3 = tup1+tup2*2 元组的连接，因为元组只读，所以肯定是返回一个新的元组
for x in (1,2,3): print x 遍历元组中的元素
集合
只关心元素存在与否，无序的不重复序列。用于成员关系测试和去重复元素，可以增删元素。使用 { } 可用于创建集合或字典（区别在于里面的元素是单个数据还是键值对）。
set1=set() 创建一个空的集合只能用set(), {}用于创建空的字典了
set2=set("abcasdg hkdf\n") 将一个string强制转换为一个set,进set过程自动去重复,空格和\n也被认为普通成员
set4={"Tom","Jim","Mary","Rose"} 字面量创建一个set
set4.add("fang") 向集合中添加一个元素
set4.pop() 这是从集合中随机弹出一个元素
set4.remove(xxx) 从集合中删除元素xxx，若xxx不在集合中则会报错
xxx in set4 判断xxx是否在集合中
xxx not in set4 判断是否不在集合中
set2.issubset(set3) 判断set2是否是set3的子集合
set2.updata(set3) 返回增加了set3元素后的集合set2
#返回一个集合，为set2 和set3的差集(即在set2中但不在set3中的元素), 等价于set2.difference(set3)
set2 - set3
#返回一个集合，为set2 和set3的并集(即在set2中或者在set3中的元素或者两个都在的元素) 等价于 set2.union(set3)
set2 + set3
#返回一个集合，为set2 和set3的交集(即同时在set2和set3中的元素) 等价于 set2.intersection(set3)
set2 & set3
#返回一个集合，不同时在set2和set3中的元素
set2 ^ set3
a = {x for x in 'abracadabra' if x not in 'abc'} 集合推导式（推导出一个集合）
键值对集合(字典)
键值对集合，即字典，多为哈希表实现。无序，通过key来访问元素而不是index。key使用常量类型，且在同一个字典中应该唯一
dict1 = {} #初始化一个空的字典
dict2 = {"tom":98,"jim":86,"mary":92} #初始化一个字典，若此时存在相同的key,则先出现的那个被覆盖
dict1["one"] = "fang" #访问修改字典某个key对应的值。写入时key不存在则向字典中添加键值对,key已存在则覆盖,读取时key不存在会报错,key为字面常量,value无要求
dict1.get("tom","0") #获取key为"tom"的value，若key不存在则返回"0"(不写则返回None)
"one" in dict1.keys() #等价于 dict1.has_key("one"), dict1.keys()返回键值组成的list,dict1.values()返回值组成的list,dict1.items()返回(key,value)元组 组成的list
del dict1["tom"] #删除某个键值对
dict1.clear() #清空字典，对字典本身操作
del dict1 #删除整个字典
dict1.pop("tom") #返回key为tom的value，并键值对从字典中删除
dict1.popitem() #随机删除字典中的一个键值对，并返回他们的键值对组成的元组
dict3 = {x : x**2 for x in (2, 4, 6)} #字典的推导式
for k,v in dict1.items():
print(k,v)
流程控制
if 表达式1: #冒号
语句
elif 表达式4:
语句
else:
语句
没有switch–case语句
while 判断条件： #冒号
语句
没有do-while循环
#!/usr/bin/env python3
n = 100
sum,counter = 0,1 #复合赋值
while counter <= n:
sum = sum + counter #若此循环体只有一句的话，是可以直接与while放在同一行的
counter += 1 #计算1到100的和
print("1 到 %d 之和为: %d" % (n,sum))
while mylist:
mylist.pop()
while循环和else配合使用(区别于while内部提前break)
#!/usr/bin/python3
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else: print (count, " 大于或等于 5") #循环条件顺次全部执行完毕的时候才会进入
for
in
:
else:
#顺次全部执行完毕后进入(区别于while内部提前break)
for可以遍历任何序列 eg.列表/字符串，可以遍历range()函数生成的数字序列（c中 for(int i=0;i<10;i++)就使用range()来对标）。
range(5) #生成一个0-4的序列，类型就是叫range
range(5,10) #生成一个5-9的序列
range(5,10,2) #生成一个5-10,步长为2的序列（最后一个数可能并非10而是一个<10的数）
list(range(5)) #range强制转换为一个list
for i in range(5): #打印0-4
print(i)
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)): #C风格访问list
print(i, a[i])
#enumerate()能顺便获取序列元素的index（对string/list/tuple均适用）
for i,x in enumerate(tup3):
print(i,x)
#使用zip平行遍历(同时访问 list[i],tup[i])多个不要求同类型的序列
for a,b in zip(list1,tup1)
print(a,b)
break 和 continue(类c)
pass 空语句,不做任何事情,一般用做占位语句
while True: #相当于while(1);
pass
函数
def funcA(a,b,c):
return a+b+c
print(funcA(2,3,4))
def funcB(*x)
print(x) # 函数的参数前有*表示运行时python收集可变参数,组织成x传入,x是一个元组
f = lambda a,b,c:a+b+c
print(f(2,3,4))
调用其它模块
import其它python模块（模块是一个py文件，以.py结尾，其中包含python函数，或python的class，或python对象）。（import 包） ， （from 包 import 子包或子包内的func/class/others）
import sys
sys.path.append('fileA.py所在的路径') #同一个目录下可以省略
#导入python文件level,貌似文件名不可以是数字,eg.2.py,不然 import 2 的时候会语法报错
import fileA
fileA.funcA()
import sys
sys.path.append('fileA.py/fileB.py所在的路径')
#导入python文件中的具体某个函数(from fileA import * 也是可以的)
from fileA import funcA,funcB
#导入python文件中的具体某个类 (from fileA import * 也是可以的)
from fileB import classA,classB
funcA()
ca = classA()
如果某个 目录 dirA 下有 __init__.py 文件,那么这个 目录 就 会被当成一个包 (dirA下面的python文件就被当作子包) https://blog.csdn.net/u013210620/article/details/78554138
（python认为 . 的左边必须是一个python包，不满足这个要求，就报错）
import dirA #dirA.fileA.funcA()
import dirA.fileA #dirA.fileA.funcA()
from dirA import fileA #fileA.funcA()
from dirA.fileA import funcA,funcB
__init__.py 三个作用：
1.表明此目录作为一个python包，很多空的 __init__.py 就是只使用了功能（fileA.py 则 fileA 就被python默认是一个包）
2.定义__all__=['subpackage', 'funcA', 'funcB', 'classA', 'classB'], 这样外部调用 import * 的时候知道要import哪些
3.执行一些python语句（他们会在import的时候被调用），比如 初始化包的语句 或者 import语句
import sys, os
sys.path.append(os.pardir) #好像直接写 ".." 也是可以的
from common.functions import *
from common.gradient import numerical_gradient
更高level的调用
import os
str=('../B.py') //也可以是一段shell脚本或者c的binary,只要是能在终端打的命令都可以
p=os.system(str) //执行
print(p) //打印执行结果 0表示 success, 1表示 fail
调用c/c++模块 https://www.cnblogs.com/apexchu/p/5015961.html
(首先将c/c++文件make成so文件)
import ctypes
#load the shared object file
xxx = ctypes.cdll.LoadLibrary('./xxx.so')
xxx.funcA()
xxx.funcB()
将c++模块封装为python接口 https://www.cnblogs.com/gkwang/p/4353220.html
