常用语句

1.print()：输出语句，默认输出的结果分隔符是换行，如果想设置结尾分隔符，则设置end参数，例如：print(i,end='')（代表用空字符串隔开）；如果想要设置多个对象输出的分隔符（默认是空格），则设置sep参数，举例：print(1,2,sep='-')（结果输出1-2）；如果想要将内容重定向输出，则可以设置file参数，举例：

with open("aaa.txt", "w") as f:
    print("aaa", file=f)    //将aaa输出到文件当中

2.input()：输入语句，默认为str型，可以做好强制转型，举例：

>>> a = input("please input:")
please input:1  #手动输入1
>>> a
'1'
>>> a = int(input("please input:"))    #强转int型

如果希望输入的内容不被看见（比如密码），那么就可以用getpass模块下的getpass()函数，举例：

>>> import getpass
>>> psd = getpass.getpass("password>>")
password>>
>>> psd
'123456'
#输入了123456没显示

3.python中也有break、continue
4.a,b = 1,2+3：a等于逗号左边的值也就是1，b等于括号右边的也就是5
5.a = b = 1：a、b都赋值为1
6.交换语句：a, b = b, a，此时就会把a和b的值对调，别的语言基本要个中间变量，python不用
注：

• python3.8中新增了海象运算符（:=），通过该运算符可以实现在if等语句当中运行语句的同时赋值变量，详细参考：https://cloud.tencent.com/developer/article/1548009

2.运算操作符

（1）基本的=、-、*、/、%都有，而且同样有+=、-=、*=、/=，但是/和C语言中的不太一样，比如这里3/2会变成1.5，也就是会像正常计算器那样算，而不会自动取整。如果想自动取整可以用//，这时会去掉小数部分，且不论是整数运算还是浮点数运算，举例：

>>> 3//2
1
>>> 3.1//2    #即使浮点数运算也会强制取整
1.0

（2）幂运算操作符**，例如：3**4=81，但是要注意优先级问题，其优先级比左边的内容高，比右边的低，比如：-3**2=-9，此时运算是这样：-(3**2)，又如3**-2=0.11111111，此时运算是这样：3**(-2)，
（3）多个变量同时赋值，例如：a=b=c=1
（4）位运算：|表示或，&表示与（还有or/and表示与和或，相当于原来的||/&&，即只要第一个条件为真/假，则可不用判断第二个条件，直接出结果），^在表示异或，~表示取反（01对调，相当于-x-1），<<左移，>>右移，这些位运算对于十进制的数会先转成2进制再进行运算，然后再转回十进制，举例：

>>> 5 | 3    #0101 | 0011
7  #0111
>>> 5 & 3
1  #0001
>>> 5^3
6  #0110
>>> ~5  #-5-1
-6  #-1010
>>> 5 << 2  #5*2*2
20  #0001 0100，高位丢弃，低位补0
>>> 5 >> 1  #5/2
2  #0010，低位丢弃，高位补0

注:
Python里没有++、--

3.逻辑运算符

(1)True、False（记住首字母大写）

(2)==/is：前者判断值是否相等，后者判断地址是否相等，所以如果后者符合则前者也一定符合，举例：

>>> a = 1
>>> b = 1
>>> id(a) == id(b)
True
#地址相等
>>> a == b
True
>>> a is b
True
>>> c = [1]
>>> d = [1]
>>> id(c) == id(d)
False
#地址不等，但值相等
>>> c == d
True
>>> c is d
False

(3)not：去相反逻辑符，比如：not False就是True，not 5就是True，因为非0的都是True，还有not is

(4)在Python里还可以3<4<5，结果是True

4.格式化（format）

针对字符串的概念，对字符串当中要格式化的地方用{}包住，有位置记录（如：{0}，{1}）和关键字记录（自定义名称，如{a}，{first}）

• 位置格式化
  例如""{} love {}.{}".format(*["I","you","com"])就会变成：'I love you.com'，也可以自定义传入位置，如："{1} love {0}.{2}".format(*["I","you","com"])就是'you love I.com'
• 关键字格式化
  例如："{a} love {b}.{c}".format(a="I",b="you",c="com")，结果为：'I love you.com'
  注:
  两种格式化能一起用，但位置格式化只能在关键字格式化前面用，如果前面有关键字格式化了，后面就不能位置格式化，例如："{a} love {1}.{2}".format(a="I","you","com")是不可以的；还有如果想输出像'{0}'这样的字符，可以在这外面再来一层{}，比如："{{0}} love {1}.{2}".format("I","you","com")，结果就是'{0} love you.com'
• 字符格式化
  （此时不用format，直接在要格式化的字符和格式化后的内容间用%隔开，参考下面例子就知道了）
  （1）%d：整数格式化（非整数会自动转成整数），如果要要显示正数，可以前面加+号，前面加数字可以控制字符串长度，前面加0用于补全（默认右对齐，如果左对齐就不会给0补全，加-号左对齐），举例：

>>> "%d" % 5.1
'5'    #自动转整数
>>> "%+d" % 5
'+5'    #前面加+号
>>> "%5d" % 5
'    5'    #字符串长度为5
>>> "%05d" % 5
'00005'  #前面用0补全
>>> "%-5d" % 5
'5    '    #加-号左对齐

（2）%f：浮点数，可指定精度，默认精确到小数点后6位，小数点前面还可以加数字，代表字符串长度，默认右对齐，前面加-是左对齐，举例：

>>> "%f" % 5.157
'5.157000'    #默认精确6位
>>> "%.2f" % 5.157
'5.16'    #精确2位
>>> "%10.2f" % 5.157
'      5.16'  #长度为10
>>> "%-10.2f" % 5.157
'5.16      '  #左对齐

（3）%c：单个字符
（4）%s：字符串
（5）%o：8进制，举例：

>>> "%o" % 8
'10'  #8进制的8就是10

（6）%x：16进制小写，还有%X为16进制大写
（7）%e：e记法，如果要大写就%E
（8）%g：自动决定用%f还是%e记法，大写用%G，举例：

>>> "%g" % 100000000
'1e+08'  #貌似7位数开始就自动用e记法
>>> "%g" % 10000
'10000'

注:
字符格式化一般用在print里，比如：print("%d 和 %f是两个格式化输出" % (num1, num2))这个时候num1和num2的值就会被传到格式化里了
注2：
在python3.6+版本，新出了f-string格式化字符串，相当于字符串和format()格式化的结合，只需要字符串前面加个f定义即可，简单易用，随便举个例感受下：

>>> a = 1
>>> f'num:0{a}2'
'num:012'
>>> b = 2
>>> f'12{a+b}'
'123'

详细参考：https://blog.csdn.net/sunxb10/article/details/81036693

5.局部变量、全局变量、非局部变量

在Python里，全局变量可以被任意地方访问，非局部变量能在局部被访问，但仅限于访问和读取值而已（列表、字典等比较特殊，一会儿会介绍），一旦要修改值的时候，将会报变量未定义的错，例如下面的例子：

a = 1  # 全局变量a
def test(b=2):  # 非局部变量b
    def test2():
        # 局部调用和修改全局、非局部变量
        print(a, b) # a和b能被正常读取
        a += 1  # 会报a没有定义的错
        b += 1  # 一样也报错

    test2()
    
test()

从上面可以知道无法在局部修改全局和非局部变量，但如果需要修改，那么只需要在该局部通过global 全局变量名和nonloacal 非局部变量名关键字定义一下就可以了，举例：

a = 1  # 全局变量a
def test(b=2):  # 非局部变量b
    def test2():
        global a    # global关键字定义全局变量
        nonlocal b  # nonlocal关键字定义非局部变量
        a += 1  # 正常修改
        b += 1  # 正常修改
        print(a, b) # a和b能被正常读取

    test2()

test()

列表、字典等特殊数据的作用域问题：
前面全局、非局部的值无法在局部只赋予了读取的权限而没有修改，而列表和字典这些数据如果只是修改其内部的数据，是允许的，但如果要修改整个变量，则是不允许的，举例：

li = [1]

def test1():
    li.append(2)    # 修改列表的内部数据是允许的
    print(li)   # 将全局变量li的值修改成了[1, 2]

def test2():
    li += [2]   # 修改整个表是不允许的，会报错，此时需要提前用global关键字定义变量

test1()
print(li)   # 结果是[1, 2]
test2()

global使用原因：https://www.cnblogs.com/yanfengt/p/6305542.html
global/nonlocal区别：https://www.cnblogs.com/huwt/p/11185516.html
更多变量作用域和闭包问题参考：https://www.cnblogs.com/Lin-Yi/p/7305364.html

6.判断语句

• 第一种

if 条件:
    (满足条件的在下一行用缩进)
else :
    (不满足条件的在下一行用缩进)

• 第二种

if 条件:
    (满足条件的在下一行用缩进)
elif :
    (不满足，判断下个条件，满足条件的在下一行用缩进)
else :
    (不满足条件的在下一行用缩进)

• 第三种（三元操作符）

value = x if x < y else y

意思是如果x<y，则x赋值给value，否则y赋值给value，举例：

>>> a = 2
>>> 1 if a else 0
1

注：
Python中条件必须是逻辑语句，不能是赋值语句之类的，比如：if x=1在C中可能不会报错，但在这里会报错

7.循环语句

• 第一种：while

while 条件 ：
    (满足条件的在下一行用缩进)

• 第二种：for

for 目标 in 表达式 :
    (循环语句)

for举例1

value = 'abcde'
for i in value :
    print(i,end=' ')
输出结果：a b c d e 

解释：循环当中依次把a、b、c、d、e赋值给i，并输出。比如第一次循环时，i为'a'，到第二次循环时i为'b'...

• for举例2

member = ['aaa','bbbb','ccccc']
for each in member :
    print(each, len(each))
输出结果：
aaa 3
bbbb 4
ccccc 5

解释：依次把列表每个值赋值给each，并输出

• for举例3
  前面只是从一个列表之类对象里取出每个值，但是如果我们想要获取其对应的下标的话，可以通过enumerate()函数实现，举例：

member = ['aaa','bbbb','ccccc']
for i, each in enumerate(member):
    print(i, each)
输出结果：
0 aaa
1 bbbb
2 ccccc

• for举例4
  前面都是针对单个列表之类的对象进行循环遍历，如果想同时对多个呢？可以通过，zip()函数将多个列表结合成一个，举例：

member = ['aaa','bbbb','ccccc']
index = ['a', 'b', 'c']
name = ['x', 'y', 'z']
for i, n, each in zip(index, name, member):
    print(i, n, each)
输出结果：
a x aaa
b y bbbb
c z ccccc

• for举例5
  举例4里只能同时对多个列表进行一次遍历，如果希望的是依次对这些表实现循环呢？可以通过itertools模块下product函数实现，举例：

from itertools import product
index = ['a', 'b', 'c']
name = ['x', 'y', 'z']
for i, n in product(index, name):
    print(i, n)
输出结果：
a x
a y
a z
b x
b y
b z
c x
c y
c z

• for举例6
  假如循环遍历时我只想读取前3个中的第奇数个的话，则可以用itertools下的islice()函数实现，举例：

from itertools import islice
member = ['aaa','bbbb','ccccc', 'dddddd']
for each in islice(member, 0, 3, 2):
    print(each)

输出结果：
aaa
ccccc

islice()函数类似列表的切片操作，传入的后三个参数分别为起始位、结束位的后一位，步长，上面的用切片替代也是一样的，举例：

for each in member[:3:2]:
    print(each)
# 结果一样

8.循环判断

for 目标 in 表达式 :
    if 条件:
        …
        break
    else :
        …

意思是执行for语句，循环进行判断，如果符合条件时就进入if语句，最后执行break退出，如果都不符合条件，那么就会执行else语句。但记住循环判断的else是前面的循环完了就会执行else，所以如果不加break，那么最后一定会执行else里的内容。举例：

for i in range(0,10):
    if  i > 5:
        print("existing")
    else:
        print("Nothing")
结果为：
existing
existing
existing
existing
Nothing     #没有break，最后执行结束会执行这句

9.推导式

• [X for x in [列表]]
  链表推导式，第一个X是表达式，该语法将列表（集合、字典等也都可以）内容按表达式方式计算后生成一个新的列表（迭代器），举例：

>>> [3*x for x in [1,2,3]]
[3, 6, 9]

还可以在列表后面加条件，举例：

>>> [3*x for x in [1,2,3,4,5] if x>3]
[12, 15]

还可以有很多种变化，举例：

>>> [(x,x+1) for x in range(3)]
[(0, 1), (1, 2), (2, 3)]

举例删除一个列表的所有字符串的空格：

>>> [ x.strip() for x in [' ab','bc ',' sf ','s g'] ]
['ab', 'bc', 'sf', 's g']

有时我们要一定数量的某个常量，比如要10个0的列表，那么就可以：

>>> [0 for x in range(10)]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

还有更好的用法，比如可以通过链表推导式在多线程函数中使用，当函数需要一堆不同参数传入时，可以通过其实现：

>>> def abc(i):
    return i

>>> a = [abc(i) for i in range(10)]  #通过链表推导式将参数依次传入至函数当中，这在后面的多线程、协程爬虫等里面传地址很好用
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• {X:Y for x in [列表/...]}
  字典推导式，举例：

>>> {x : x%2==0 for x in range(5)}
{0: True, 1: False, 2: True, 3: False, 4: True}  #返回0-5能否被2整除的字典

注:
还有集合推导式，举例：

>>> {x for x in [1,2,3,3,2,1,4,5,6]}
{1, 2, 3, 4, 5, 6}

注：
没有字符串推导式，并且()包着的也不是元组推导式，而是生成器推导式，举例：

>>> (x for x in [1,2,3,3,2,1,4,5,6])
<generator object <genexpr> at 0x03DF9FC0>  #生成器类型

10.断言

assert 条件，如果后面的条件正确就没事，如果错误将会程序奔溃并报错，例如：

>>> assert 3>4
Traceback (most recent call last):
  File "<pyshell#89>", line 1, in <module>
    assert 3>4
AssertionError    #提示断言错误

通过该方法可以知道错误的地方，而且也保护了后面的语句不被执行。一般用来检测某一个条件必须为真时使用。

11.返回多个值

由于函数中return执行后就结束该函数，所以如果想返回多个数就不能多次return，但是可以返回一个列表、元组或者字典，比如：return [1,2,3,4,5]，也可以比如想返回两个列表就：return [list1,list2]
注:
像return a,b,c这个实质上就是返回一个元组

12.with关键字

参考：https://www.jianshu.com/p/5b01fb36fd4c

13.exit()

退出，括号里可以加退出时的提示，比如：exit("the procedure is break")

14.输出彩色字体

格式：\033[显示方式;前景色;背景色m + 结尾部分：\033[0m（即：\033[数字;m+内容+\033[0m）
其中显示方式:

0    （默认值）
1    （高亮）
22   （非粗体）
4    （下划线）
24   （非下划线）
5    （闪烁）
25   （非闪烁）
7    （反显，就是前景色和背景色对调）
27   （非反显）

前景色:

30    （黑色）
31    （红色）
32    （绿色）
33    （黄色）
34    （蓝色）
35    （洋红）
36    （青色）
37    （白色）

背景色:

40    （黑色）
41    （红色）
42    （绿色）
43    （黄色）
44    （蓝色）
45    （洋红）
46    （青色）
47    （白色）

举例：

print("\033[27;34;42m这是非反显蓝色字，且背景是绿色\033[0m")
print("\033[1;31;43m这是高亮红色字，且背景是黄色\033[0m")

注：
上面的语句在idle这样的编译器当中可能无法显示效果，可以在pycharm里尝试`