The Python Tutorial — Python 3.10.0 documentation
Learn Python - Free Interactive Python Tutorial
#! /root/python-3.6.5/bin/python3.6 (制定用谁来解析下面的code,我没有将pthon3.6安装到系统路径,就这样写了)
#! /usr/bin/env python3 (如果安装在系统路径,可以直接这样写)
print()
shoplist = ['apple', 'mango', 'carrot', 'banana']
print('I have', len(shoplist), 'items to purchase.')
print('These items are:', end=' ')
for item in shoplist:
print(item, end=' ')
random()
import random
import string
# 随机整数:
print random.randint(1,50)
# 随机选取0到100间的偶数:
print random.randrange(0, 101, 2)
# 随机浮点数:
print random.random()
print random.uniform(1, 10)
# 随机字符:
print random.choice('abcdefghijklmnopqrstuvwxyz!@#$%^&*()')
# 多个字符中生成指定数量的随机字符:
print random.sample('zyxwvutsrqponmlkjihgfedcba',5)
# 从a-zA-Z0-9生成指定数量的随机字符:
ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 8))
print ran_str
# 多个字符中选取指定数量的字符组成新字符串:
print ''.join(random.sample(['z','y','x','w','v','u','t','s','r','q','p','o','n','m','l','k','j','i','h','g','f','e','d','c','b','a'], 5))
# 随机选取字符串:
print random.choice(['剪刀', '石头', '布'])
# 打乱排序
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print random.shuffle(items)
python debug:
#python -m pdb abc.py
基本运算
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转换为一个整数。int(x, base=16) 按照16进制转换得到一个整数
• 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))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
>>> 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位精度)
str4 = "arg{} is {}".format(iIndex, strArg) #格式化字符串
str4 = "I love {0}, she is {1} years old, {0} loves me,too. ".format("abc", 16.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是步长
'{:*>10}'.format(str) #将str右对齐,10位宽度,左边不足部分用 * 填充
str(bin(str1)).replace('0b','').rjust(10,'x') #将bit字符串转换为对应的二进制数,去掉前面的0b,然后按照10bit位宽右对齐,不足部分 前补x
• 常用的字符串库函数 >>>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.join(lista) split的相反操作,以str作为连接符,将list中的各个item连接起来得到一个string
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将被改写)ps: list1[::-1] 返回一个reverse的拷贝
list1.clear() 清空列表的所有元素
list1.copy() 返回一个列表,和list1的元素完全相同,slice的方式: mylist = 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)]
由数值 组成的list <===> 数值对应的string 组成的list
list_test = [i for i in range(10)]
str_list = list(map(str, list_test)) # 将list中每一个值都转换为str, 然后再组织成list
int_list = list(map(eval, str_list)) # 将list中每一个值都转换为数值, 然后再组织成list
# 对 list_test 中的每一个值,都做如下处理: 将其转变为str后,将数字5去掉,处理完成后,组织成tuple
process_list = tuple(map(lambda x : str(x).replace('5',''), list_test))
list 的 reduce 操作:
from functools import reduce
sum_list = reduce(lambda x, y: x+y, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list 的 filter 操作:
def is_odd(n):
return (n % 2) == 0
res = list(filter(is_odd, [0, 1, 2, 3, 4, 5, 6, 7, 8])) #res=[0,2,4,6,8]
list的sorted操作(与自身sort不同在于这个返回一个新的列表。以上就是python的四大高阶函数)
res = sorted([3,5,-87,0,-21], key=abs, reverse=True) #res=[-87, -21, 5, 3, 0]
元组
写在小括号 ( ) 里,元素之间逗号隔开,数据项可不同类型。与列表类似,但元组的元素不能修改,亦不可增删。但可以一次删除整个元组,元组的整体赋值相当于指向另一个新的元组。函数多值返回得到的就是元组。
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)
import operator
sortedDict = sorted(dict2.items(), key=operator.itemgetter(1), reverse=True) #对字典,以 键值对 的 值 为关键字倒序排序,返回一个items组成的list
xx = list(filter(lambda k: dct[k] == value, dict)) #找到dict中值为value的键值对
流程控制
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 <variable> in <sequence>:
<statements>
else:
<statements> #顺次全部执行完毕后进入(区别于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 <as fa>
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文件就被当作子包) python基础-生成包、导入模块、包下_init_模块(__all__方法)_全干工程师-CSDN博客
(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哪些
eg. 目录下有ma.py, mb.py, mc.py,那么 __all__=['ma', 'mb', 'mc']
3.执行一些python语句(他们会在import的时候被调用),比如 初始化包的语句 或者 import语句
import sys, os
sys.path.append(os.pardir) #好像直接写 ".." 也是可以的
from common.functions import *
from common.gradient import numerical_gradient
if __name__=='__main__': 的作用:
当import的时候 if 子句不会执行,只有在python abc.py(直接执行此py)的时候才会执行。不然当此.py被当作模块被其他.py导入的时候,写在if外的都会被执行
更高level的调用
import os
str=('../B.py') //也可以是一段shell脚本或者c的binary,只要是能在终端打的命令都可以
p=os.system(str) //执行
print(p) //打印执行结果 0表示 success, 1表示 fail
调用c/c++模块 Python实例浅谈之三Python与C/C++相互调用 - CalvinChu - 博客园
Extending and Embedding the Python Interpreter — Python 3.10.0 documentation
(首先将c/c++文件make成so文件)
import ctypes
#load the shared object file
xxx = ctypes.cdll.LoadLibrary('./xxx.so')
xxx.funcA()
xxx.funcB()
将c++模块封装为python接口 【转】用C语言扩展Python的功能 - gkwang - 博客园
远古时期将python导出到python的方法包括swig、boost::python,但是自从pybind11出来以后,一切都变得格外简单了。这里记录一下pybind11在mac里面的安装使用方法。
在mac中使用pybind11 - 知乎 (zhihu.com)
pybind11的最佳实践 - 知乎 (zhihu.com)
查看一个python包包含哪些东西:
import numpy
dir(numpy) # 模块内有大量以下画线开头的成员,其实这些成员并不希望被其他程序使用,因此列出这些成员意义不大
print([e for e in dir(numpy) if not e.startswith('_')]) # e 是 string
print(numpy.__all__) # 模块中的 __all__ 变量,该变量相当于该模块开放的功能接口