python学习--基础1概览

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__ 变量，该变量相当于该模块开放的功能接口