python3 基本语法

单行注释前面加#，多行注释在两个'''之间。
一行语句写不开，在上一行最后加\，可以折到下一行写，但是不能分割单词。在括号之间的多行语句，不需要加\。
import A 导入模块A，from A import f 从A中导入函数f。
python的输出自动换行，不让它换行的方法：
print(1,end='')
python里没有++运算符，只能i+=1

1.基本数据类型

$(1)$ Number（数字）：int float bool complex
变量不需要声明，直接赋值即为声明。
int是高精度int，支持大数运算。
bool：True和False，要大写
数值运算中的a/b结果是浮点数，当a，b都是int时，a//b结果是整数
complex：复数用a+bj表示
complex(x)=x+0j
complex(x,y)=x+yj
可以直接用max和min等函数（详见文档），并且支持多个参数和序列，但是必须先import math才能用sqrt等函数（详见文档）。
随机数函数：要import random才能用
choice(列表，元组或字符串)：随机返回一个元素。
randrange(start=0,stop,step=1):从[start,stop)中以step为步长随机选取一个元素。例：randrange(1,100,2)从[1,100)中选取一个奇数。
random()随机生成一个[0,1)之间的实数。
uniform(x,y)返回[x,y]之间的一个实数。

$(2)$ String(字符串)：str=‘string’，单引号双引号都可以
str[头下标：尾下标] 表示截取[头下标，尾下标)的字符串。
这里的下标可以按末位索引，-i表示倒数第i位。
str[i:]表示从i到末尾的所有字符。
str[:i]表示从开头到i之前的所有字符。
str*2表示将str重复两遍的新字符串，str1+str2表示将str1与str2相连形成的新字符串。
在字符串前加一个r，可以使转义字符失效。
字符串不能被逐个字符地改变，如str[0]='a'会报错。
格式化字符串：print ("我叫 %s 今年 %d 岁!" % ('小明', 10))相当于sprintf
在三引号之间的字符串可以跨越多行。
String的方法：
count(str,start=0,end=-1)：返回[start,end]之间str的个数
endwith(str,start=0,end=-1)：检查字符串是否以str结尾
find(str,start=0,end=-1)：如果字符串中含有str，返回str开始时的第一个下标，否则返回-1
isalnum()：检查字符串是否全是数字和字母（其他类似的谓词也可以用）
join(序列)：返回以字符串作为间隔，将序列元素拼接起来形成的新字符串
以空格作为间隔输出：

str=' '
list=['a','b','c']
print(str.join(list))

len(str)：返回str的长度，注意没有str.len()这种方法。
split(str,num=-1)：以str为分隔符对字符串分段，num表示分段次数，-1为完全分段，返回一个字符串列表。

$(3)$ List(列表)：list=['string',1,2.5,1+3j]
相当于c++中的struct
索引和字符串一样，可用负数按末尾索引，也可以加和乘。
可以逐个元素地改变列表。
列表和字符串的截取可以传递3个参数：list[1:4:2]表示从1到3，每隔两个截取一个元素，即list[1],list[3]，其中第三个参数为负数时，表示逆向截取。
翻转一个字符串的方法：words=words[-1::-1]
del list[i]表示删除第i个列表中的元素。
len(list) 返回list的长度。
for x in [1, 2, 3]: print(x, end=" ") 遍历list的元素
列表可以嵌套列表，相当于二维数组
max,min(list)返回list的最大元素和最小元素
两个list合并：直接+=
list的方法：
append(x) 在列表末尾添加x，相当于入栈。
count(x) 返回x在列表中出现的次数
index(x) 返回第一个x的下标，注意list里面没有find
insert(index,x) 把x插入到list[index]的前面
pop(i=-1) 删掉list[i]，并返回这个元素的值
remove(x) 删除第一个x
reverse() 翻转列表
sort(key=None,reverse=False) 排序，对于非一般数据类型来说，key是指明排序对象的函数，reverse=0是升序，reverse=1是降序。
按纵坐标降序的点排列：

list=[[1,2],[1,3],[3,4],[-1,7]]
def cmp(list):
    return list[1]

list.sort(key=cmp,reverse=1)//必须这么写
print(list)

clear() 清空列表

$(4)$ Tuple(元组)：tup=('string',1,2.5,1+3j)
和List差不多，但是不能逐个元素地改变元组。
字符串是一种特殊的元组。
创建空元组：tup=()
创建一个元素的元组：tup=(1,) 别掉了','
元组不能删除和添加元素，但可以用del删除整个元组
元组支持max,min,len等函数

$(5)$ Set(集合)：s={'string',1,2.5,1+3j}
创建空集合：s=set()
和c++stl里的set差不多，自动合并相同的元素。
还可以用a=set('abc') 生成一个含有'a','b','c'的集合。
成员测试：if 1 in a:
集合可以运算：
a-b 差集
a|b 并集
a&b 交集
a^b a|b-a&b
集合的方法和函数：
add(x) 在集合中添加元素x，如果x已经在集合里了，就什么也不做
remove(x) 在集合中删除元素x，如果没有x，就报错
len(set) 返回set的元素个数
set1.isdisjoint(set2) 判断set1和set2是否不交
set1.issubset(set2) 判断set1是否是set2的子集

$(6)$ Dictionary(字典)：dict={'string':1,2:'str'}
相当于c++stl的map。
dict={} 创建一个空字典，注意和set的区分。
print(dict.keys())和print(dict.value())输出dict的所有键和值。
key可以用数字，字符串或元组，但是不能用列表！
字典的方法：
get(key,default=none) 返回key对应的值，如果key不在字典里，返回默认值。
pop(key) 删除key和key对应的值。

$(7)$ 强制类型转换：和c++一样，用str(123)和int('123')可以方便地实现字符串和数字的转换。
一个很强的函数：eval(str)将一个字符串转化成表达式并求值。
print(eval(str)) 即可实现中缀表达式求值。

2.运算符

a**b= $a^b$
位运算都支持。
没有&&，也没有||，和！用and，or，not代替，运算规则也不一样：
x and y：如果x=0，返回0，否则返回y的值。
x or y : 如果x！=0，返回x的值，否则返回y的值。
not x：如果x！=0，返回0，否则返回1。
in和not in 运算符：可以用于字符串，列表或元组，相当于c++中的find函数。
is 运算符：先注意一下a=b就相当于b是a的引用，a is b判断a和b是否对应同一块内存空间，a==b只是判断a和b是否相等。
复合赋值：a,b=0,1 相当于a=0，b=1
运算顺序：先从左往右算右边，再对应地赋值给左边。

3.条件语句

任何非空和非0的对象为True，0或NULL为False
注意换行，冒号和缩进：

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

python不支持switch。
也可以用单行if，不用缩进：

if 2>1 : print(1)

4.循环语句

while-else语句：正常退出的循环会执行else的内容，从循环中break出来则不会。
for-in-else语句：用于遍历序列

for <variable> in <sequence>:
    <statements>
else:
    <statements>

range函数：用于遍历数字序列
range(start=0,end,step=1) 表示从[start,end)以step为步长(可以为负数)的数字序列
利用range和len生成序列表：

list=['string',1+2j,3,4.8]
for x in range(len(list)):
    print(x,list[x])

将range转化为list： l=list(range(10))

5.迭代器 it=iter(list)

和c++stl中的迭代器差不多，但不能向后移动。
字符串，列表，元组都可以用于创建迭代器。
next(it)，返回迭代器的值，使迭代器向前移动一个位置。
用for循环可以遍历迭代器：

list=[1,2,3,4]
it=iter(list)
for x in it:
    print(x)

生成器：使用了yield的函数，返回值是一个迭代器
例：生成一个斐波那契数列对应list的迭代器

def f(max):
    a,b=0,1
    while b<=max:
        yield b//返回值为b的迭代器
        a,b=b,a+b
        
for i in f(5):
    print(i)

用这种方法不用把整个list存下来，节约了空间。

6.函数

def 函数名（参数列表）:
    函数体

return 返回值如果没有，则返回None
参数传递：
$(1)$ 对于不可变类型（数字，字符串，元组），相当于c++的值传递，函数调用结束后原来的值不改变。
$(2)$ 对于可变类型（列表，字典，集合），相当于c++的引用传递，函数调用结束后原来的值改变。

关键字参数：
f(key=a,value=b) 把函数的关键字写出来，此时key和value的顺序可以和原来不同。
不定长参数：不知道要用几个参数，就在后面加上*
def functionname([formal_args,] var_args_tuple )
第2，3，4…个参数以元组形式传入。
加*，则参数以字典形式传入。

lambda函数：相当于c++中的内联函数或者宏，只能写一行

sum = lambda arg1, arg2: arg1 + arg2
print(sum(1,2))

7.变量作用域

全局变量：会被局部变量屏蔽。

a=0
def f(i):
    a=i+1
    print(a)#2
    return a

print(f(1))#2
print(a)#0

如果想让函数改变全局变量的值，需要补充声明global a（可以用于递归）

a=0
def f(i):
    if i==10:
        return
    global a#不加这一行函数体内就访问不到外面的a了
    a+=1
    f(i+1)
f(0)
print(a)

函数嵌套调用时，如果想让内层函数修改外层函数的变量，要加nonlocal

def outer():
    num=10
    def inner():
        nonlocal num
        num=100
        print(num)
    inner()
    print(num)
outer()

8.列表推导式

把列表当成队列：先from collections import deque，然后就可以生成双向队列了。

from collections import deque
queue=deque([1,2,3,4,5])
queue.append(6)#从右边进队
queue.popleft()#从左边出队
for x in queue:
    print(x,end='')
    print()

列表推导式：用公式生成列表
[条件 for x in 序列]

list=[1,2,3,4]
while list[1]<1000:
    list=[x*2 for x in list]
    print(list)

也可以二重循环：

vec1=[2,4,6]
vec2=[4,3,-9]
print([vec1[i]*vec2[i] for i in range(len(vec1))])#对应分量相乘
print([x*y for x in vec1 for y in vec2])#二重循环遍历相乘

实现矩阵的转置：

matrix=[
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12]
    ]
print(matrix)
print([[row[i] for row in matrix] for i in range(4)])

集合和字典也有推导式，和列表一样。
反向遍历序列：用reversed()函数

list=[11,22,33,44]
for i in reversed(range(4)):
    print(i,list[i])#3 44，2 33，1 22，0 11

9.模块

import自己的模块：直接把.py文件复制到根目录
可以代替from m import f的简单方法：
f=m.f 在新的文件中可以重命名m中的f
from m import * 把m中的所有f都导入，相当于using namespace m
一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用双下划线-name属性来使该程序块仅在该模块自身运行时执行。

import show
show.show()
if __name__=='__main__':#是字符串
    print("This program") #仅在本程序运行时显示，import的过程不显示
else:
    print("import")

dir()函数可以返回模块内命名的所有关键字所组成的列表。
很多模块可以组成包，由取对象运算符.访问。

10.输入输出

按空格分隔输入：
list=input().split()
再把list赋值给需要的变量
输出格式控制：
$(1)$ repr()方法
和str差不多，可以用str的方法输出，如
rjust(width,fillchar=' ')：右对齐，左边空位fillchar
ljust(width,fillchar=' ')：左对齐，右边空位fillchar
center(width,fillchar=' ')：居中
$(2)$ format()方法

print('{} must be {}.'.format('cwk','a gay')) #cwk must be a gay.
print('{1} must be {0}.'.format('a gay','cwk')) #可以用索引控制输出顺序
print('{0:.3f},{1:2d}'.format(3,2)) #可以格式控制 3.000, 2

11.文件读写

f=open('文件名','读写模式') 读写模式同c++
f是个文件对象，有以下方法：
read(size) 读取长度为size的内容并返回其字符串
readline() 读取一行（不含'\n'）并返回其字符串
结合split方法可以读入list
readlines() 读取所有行（含'\n'）并返回这些行构成的字符串列表
write(str) 把str写入文件并返回写入的字符数
tell() 返回当前位置距离文件开头的字符数
seek(x,0) 当前位置设为文件开头向后移动x个字符
seek(x,1) 当前位置设为当前位置向后移动x个字符
seek(-x,2) 当前位置设为文件结尾向前移动x个字符
close() 关文件

12.面向对象

类定义：

    def __init__(self,a):
        self.data=a
    def f(self):
        print('self.data') #不能直接data

s=stu(1)
print(s.data) #1
s.f()

注意类方法必须有至少一个参数self，相当于c++中的this指针，但调用时可以没有；下划线-init函数是默认构造函数。
类的私有属性和方法：名称前面加两个下划线。
运算符重载：和c++差不多，但是每种运算符都有对应的下划线函数，需要的时候上网查一下……

class Point:
    def __init__(self,x,y):
        self.x,self.y=x,y
    def __add__(self,other):
        return Point(self.x+other.x,self.y+other.y)
    def __str__(self):#作为字符串输出
        return '({},{})'.format(self.x,self.y)

p1=Point(1,2)
p2=Point(3,4)
print(p1+p2)#(4,6)

继承先欠着……