关于python中字符串索引的问题

利用索引进行切片操作时，可包含三个参数:
如对列表来说即：list[start_index: stop_index: step]
起始位置 : start_index (空时默认为 0)。
起始位置 : start_index (空时默认为 0)。
步长: step (空时默认为 1，不能为 0)。
当起始位置或者终止位置为0的时候：

1. 当 step>0，start_index 的空值下标为 0，stop_index 的空值下标为 length，step 的方向是左到右；
2. 当 step<0，start_index 的空值下标为 length，stop_index 的空值下标为 0，此时反向为右到左了！也即： start_index、 stop_index 空值代表的头和尾，是随着 step 的正负而改变的。

list=[1,2,3,4]
# 打印列表中索引从0~-1，不包含-1的数
print(list[:-1])

# 打印列表中索引从-1~末尾数据
print(list[1:])

# 从后往前打印数据
print(list[::-1])

# 从后往前打印数据，第一个数从索引为-2开始
print(list[-2::-1])

# 从后往前打印数据，索引截至下标为1
print(list[:1:-1])

# 以下为各种 的输出结果
# [1, 2, 3]
# [2, 3, 4]
# [4, 3, 2, 1]
# [3, 2, 1]
# [4, 3]

count()函数用法

count():用于统计字符串中某个字符串或子字符串出现的次数，可选参数为字符串搜索的开始与结束的位置
str.count(sub, start= 0,end=len(string))
sub – 搜索的子字符串
start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
a = ‘banana pie banana’
print(a.count(“a”,2))
输出结果：5
第一个a是变量，第二个a是字符，索引从第二个开始

python中全部的内置函数的用法

以下为python中内置的函数的详细描述和示例演示：参考链接如下：
https://blog.csdn.net/weixin_30896825/article/details/98826323
reverse（）函数：用于反向列表中元素
replace() 函数：把字符串中的旧字符替换成为新的字符，如果指定第三个参数，替换不超过max次
示例：str.replace(old,new[,max])

将任意的进制转化为十进制以及将十进制转化为任意进制：

https://www.cnblogs.com/aaronthon/p/9446048.html
print(int(“54”, 8))
表示把8进制的54转换成十进制数并输出结果。
8可以是2、8，10，16等进制数

1. 将十进制decimal system转换成二进制binary system
2. bin(10)
3. 将十进制decimal system转换成八进制Octal
4. oct(10)
5. 将十进制decimal system转换成十六进制Hexadecimal
6. hex(20)

# 任意进制转换为10进制
print(int('1010',2))
print(int('12',8))
print(int('14',16))
————————————
# 将10进制转化为其他进制（2进制-8进制-16进制）
print(bin(10))
print(oct(10))
print(hex(20))
#打印结果如下：
10
10
20
————————————
0b1010
0o12
0x14

对于10进制转化为2进制之后高位补零的操作

这里提供两种方式：
nums=[10,0,3,193]
将这4个数转化为二进制，其中不足8位的高位要用0来补位,然后将其连接起来
方式一：用format()函数

nums=[10,0,3,193]
res=''
for c in nums:
    temp='{:08b}'.format(c)
    res+=temp
print(res)
#打印结果：
00001010000000000000001111000001

方式二：直接连接

nums=[10,0,3,193]
res=''
for c in nums:
    temp=bin(c)[2:]
    temp='0'*(8-len(temp)) +temp if len(temp)<8 else temp
    res+=temp
print(res)

方式三：借用原始的概念

#先把计算出来二进制的字符串存储起来，然后反向输出字符串
a=eval(input("请输入十进制的数:"))
res=''
while a >0:
    res+=str(a%2)  # a对2求余数添加到字符串中
    a=a//2
print(res[::-1])

打开文件：

常见的打开文件的语法：text = oepn(filePath, 操作方式，编码方式）
常见操作方式
‘r’:读
‘w’:写
‘a’:追加
常见编码方式
utf-8
gbk

“r”,”w”,”a”,”rb”,”wb”,”ab”：指定对文件打开方式即文件内容操作方式，即只读，可写，追加，二进制读，二进制写，二进制追加

lis = [‘apple’,’lemon’,’pear’,’peach’]
def fn(x):
return x[::-1]
lis.sort(key=fn,reverse=True)
print(lis)
结果输出为： [‘pear’, ‘lemon’, ‘peach’, ‘apple’]
函数fn的作用就是将字符反转，比如fn(“apple”) 得到 “elppa”。
列表lis使用函数fn排序，其实就是给[”e”, “n”, “r”, “h”]排序-> [‘e’, ‘h’, ‘n’, ‘r’]，并且将列表降序排列-> [‘r’, ‘n’, ‘h’, ‘e’]，最终得到 [‘pear’, ‘lemon’, ‘peach’, ‘apple’] （给sort函数中添加reverse = True，重新运行程序结果是降序排列。

关于小数对象池的问题

id（object）是python的一个函数用于返回object的内存地址。但值得注意的是，python 为了提高内存利用效率会对一些简单的对象（如数值较小的int型对象，字符串等）采用重用对象内存的办法。

python中__main__的理解

这一次自己的整理一定要把这个知识点吃透才行：
同时结合廖雪峰老师在将模块这一章节的理解，结合起来看这个问题会更加的透彻和清晰：
案例一：
已知print_func.py的代码如下：

print('Hello World!')
print('__name__value: ', __name__)
  
def main():
    
print('This message is from main function')
  
if __name__ =='__main__':    
main()

**print_module.py的代码如下：**

import print_func
print("Done!")

运行print_module.py程序，结果是：
Done!

案例二：
Assuming the filename for the code below is /usr/lib/python/person.py
and the program is run as: python /usr/lib/python/person.py
What gets printed?()
代码的文件名是…，程序运行为…,最后打印的结果为…

#这个文件的名称为：person.py
 class Person:
    def __init__(self):
        pass
    def getAge(self):
        print (__name__)
p = Person()
p.getAge()
如果是直接运行：运行的结果为：__name__

如果是按照导入的方式也即：
#新建一个文件，文件名为：person_LDL.py
import person
if __name__ == '__main__':
    p = person.Person()
    p.getAge()
# 运行结果为：
# person
# person
# 打印了两遍
# 1.第一遍是在import person的时候进行的打印
# 2.第二遍是在person.Person()中执行打印的
# __name__的名称由之前的main变成模块名称person

理解如下：
* 当运行自己的程序时，name__即为__main
* 当程序当作脚本被别人调用运行时，name__为自己的模块名称（print_func.py被导入到print_module.pyz中当作脚本被运行，） if__name==’main‘之下的代码快块不被运行
附加理解：（深度理解，整理的只是比较粗浅的理解）
* 每个py文件既可以被直接执行，也可以当作脚本导入到其他文件中，构建各个模块的联系
* 属于脚本语言，不能像编译语言将程序编译成二进制再运行，是动态的逐行的解释运行，没有统一的入口
* 不管是直接运行还是被导入，顶层代码都会被执行，当做为模块被导入的时候，不希望一部分代码被运行
* if name == ‘main‘相当于Python模拟的程序入口，Python本身并没有这么规定，这只是一种编码习惯。由于模块之间相互引用，不同模块可能有这样的定义，而程序入口只有一个。到底哪个程序入口被选中，这取决于__name__的值。
* name
* __name__反应一个包的结构 ，可以清晰的反应一个模块在包中的层次
* __name__是内置变量，可以表示当前模块的名字

附上廖雪峰网上的一个案例分析题：

python中本身内置了很多的非常有用的模块，只要安装完毕就可以使用的：
#!/usr/bin/env python3
#-*- coding: utf-8-*-
'a  test module'    #模块的文档注释
__author__ = 'Michael Liao'    #使用__author__变量把作者的名字写上去
#以下才为代码的重要部分

#导入内建的sys模块来编写一个hello模块，就有了变量sys指向该模块，利用sys这个变量可以访问sys模块中的所有功能
import sys    
def test():
    args = sys.argv    #sys模块中一个argv变量，用list存储了命令行的所有参数
    if len(args) ==1:
        print('Hello,world')
    elif len(args)==2:
        print('Hello,%s!' % args[1])
    else:
        print('Too many arguements!')

if __name__=='__main__':  #解释器把一个特殊变量__name__置为__main__，在其他的地方导入该hello模块，if判断失败，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。
    test()

关于return作用的总结

1、终止函数并将return值传回
程序运行到所遇到的第一个return即返回（退出def块），不会再运行第二个return。
如果要返回多个值写在一行即可

def odd(x):
    if x%2 != 0:
        return x
    else:
        return None

2、return与print的区别:return返回的值可以传递保存计算

>>> def odd(x):
>>>     if x%2 != 0:
>>>         print(x)
>>>     else:
>>>         print(0) 
>>> a = odd(3)
>>> b = odd(4)
>>> print(a + b)
3
0
Type error

在上例中由于没有使用return，所以a的赋值是a = print(3)而非a = 3
这会导致变量无法保存进行计算。所以绝大多数情况下要用return返回值，而非用print打印值。
3、什么时候用print?
如果你的函数只需打印语句，不需要传递值的时候可以使用print代替return
但绝大多数应用中仍需使用return打印值。

关于if语句的几个代码块

if语句
if else语句:只存在两种情况
if -elif-else语句：检查超过两个的情形，只执行if-elif-else结构中的一个代码块，依次检查每个条件测试，直到遇到通过了的条件测试，测试通过执行代码，并跳过余下的测试
多个elif代码块：

python中的pop()函数和popleft()函数

对于pop()函数是用于栈的处理的
stack = [1, 2, 3, 4]
print(stack)
stack.append(6)
print(stack)
print(stack.pop(1)) # 可以带参数，如果不带默认的就是移除队列中的第一个元素
print(stack)
输出结果如下：
[1, 2, 3, 4]
[1, 2, 3, 4, 6]
2
[1, 3, 4, 6]
popleft()是用于collections的处理的：
from collections import deque
name = deque([“aaa”, “bbb”, “ccc”, “ddd”])
print(name)
name.append(“xxx”)
print(name)
name.append(“yyy”)
print(name)
print(name.popleft()) # 不可以带参数，默认的就是移除第一个元素
print(name)
输出的结果如下：
deque([‘aaa’, ‘bbb’, ‘ccc’, ‘ddd’])
deque([‘aaa’, ‘bbb’, ‘ccc’, ‘ddd’, ‘xxx’])
deque([‘aaa’, ‘bbb’, ‘ccc’, ‘ddd’, ‘xxx’, ‘yyy’])
aaa #将移除的元素打印出来
deque([‘bbb’, ‘ccc’, ‘ddd’, ‘xxx’, ‘yyy’])

针对牛客网的输入与输出问题的一些总结(系统性的)

把这些问题全部一次性弄懂

关于python中的sys.stdin.readline()

sys.stdin是一个标准化输入的方法
python3中使用sys.stdin.readline()可以实现标准输入，其中默认输入的格式是字符串，如果是int，float类型则需要强制转换。并且也会包括末尾的换行符’\n’，input()会把’\n’忽略
以下举例子来说明：

import sys
print('Plase input your name: ')
name = sys.stdin.readline()
print('Hello ', name)
# 
# XR(输入的数据)
# Hello  XR(打印的数据)

stdin 输入
需要import sys
如果在平时使用sys.stdin.readline()获取输入的化，不要忘了去掉末尾的换行符号

1. sys.stdin.readline().strip() :会将标准输入末尾的’\n’去除
2. sys.stdin.readline().strip().split(): 读一行输入，行中每个字符以空格间隔（也可以用其他的间隔）
3. in = sys.stdin.readline().strip()
   list(map(int,in.split())) ：将输入的每个字符强制转化为int类型
   stdout
   sys.stdout.write(hello” +’\n’)
   等价于print(‘hello’)

关于sys.stdin与input()的区别
input()方法和stdin()类似，不同的是input()括号内可以直接填写说明文字(功能基本相同)。

while True:
    n = int(input('Please input a number:\n'))
    sn = list(map(int,input('Please input some numbers:\n').split()))
    print(n)
    print(sn,'\n')

关于 while true try except的相关用法整理

try except代码块是为了让python执行指定的操作，同时告诉python发生异常的时候该怎么办，及即便是出现异常，程序也会继续运行，显示你编写的指定的错误信息，而不是返回一个traceback

#只执行除法的简单计算器
print("Give me two numbers, and I'll divide them.")
print("Enter 'q' to quit.")

while True:
    first_number = input("\nFirst number: ")
    if first_number == 'q':
        break
    second_number = input("Second number: ")
    if second_number == 'q':
        break
    try:
        answer = int(first_number) / int(second_number)
    #告诉程序，如果出现ZeroDivisionError错误的时候该怎么去执行
    #打印一条友好信息，告诉用户如何避免这样的一种错误，让程序继续的运行，traceback错误被隐藏起来了。
    #通过预测可能出现错误的代码，可编写健壮的程序，即使是面临无效数据或缺失资源，也能继续运行，从而抵御无意的用户错误和恶意的攻击
    except ZeroDivisionError:
        print("You can't divide by 0!")
    #依赖try代码块成功执行的代码都都应该放到else代码块中
    else:
        print(answer)

不知道输入的数据有几组的时候的处理的方法

简单的输入与输出的时候经常碰到这样的问题
这里举了几个简单的小例子来说明问题，其中把主要的注释写在了第一个例子里面
实例一：
KiKi想知道他的考试分数是否通过，请帮他判断。从键盘任意输入一个整数表示的分数，编程判断该分数是否在及格范围内，如果及格，即：分数大于等于60分，是输出“Pass”，否则，输出“Fail”。
输入描述：多组输入，每行输入包括一个整数表示的分数（0~100）。
输出描述：针对每行输入，输出“Pass”或“Fail”。

# 方法一：
# 用导入模块的方法
# 先导入sys模块
import sys
# sys.stdin为一个可迭代对象
for i in sys.stdin:
    n = int(i)
    if n >=60:
        print('Pass')
    else:
        print('Fail')

# 方法二：
# try,expect是异常抛出，当获取数据异常时就执行expect下语句退出while循环
while True:
    try:
        n = int(input())
        if n >=60:
            print('Pass')
        else:
            print('Fail')
    except:
        break

实例二：
输入描述：输入包括两个正整数a,b(1 <= a, b <= 1000),输入数据包括多组。
输出描述：输出a+b的结果
用stdin()来写：

import sys
for line in sys.stdin:
    a = line.split()
    print(int(a[0]) + int(a[1]))

或者直接用while try except

while True:
    try:
        a,b=map(int,input().split())
        print(a+b)
    except:
        break

例子三：
输入描述:
输入数据包括多组。
每组数据一行,每行的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。
接下来n个正整数,即需要求和的每个正整数。
输出描述：
每组数据输出求和的结果

import sys
for line in sys.stdin:
    data=list(map(int,line.split()))
    n=data[0]
        if n==0:
            continue
        sum=0
        for i in range(1,len(data)):
            sum+=data[i]
        print(sum)

while True:
    try:
        data=list(map(int,input().split()))
        n=data[0]
        if n==0:
            continue
        sum=0
        for i in range(1,len(data)):
            sum+=data[i]
        print(sum)     
    except:
        break

例子四：这道题是牛客网上作为测试题目必须要通过的一道题目
输入描述:
多个测试用例，每个测试用例一行。
每行通过,隔开，有n个字符，n＜100
输出描述:：
对于每组用例输出一行排序后的字符串，用’,’隔开，无结尾空格
这里有一个要点：输出的字符串用’,’隔开，并且结尾是没有空格或者其他字符的，所以就必须要用到join()函数。
这里也是用了两种输入的方法。

while True:
    try:
        data=input().split(",")
        data.sort()
        print(','.join(data))
    except:
        break

import sys
for line in sys.stdin:
    data=line[:-1].split(',')
    data.sort()
    print(','.join(data))

python中split()函数的用法

Python3 多行数据输入

1. input().split()用法
2. map()用法
3. str.split()用法
4. 测试用例

input().split()用法

input() 接收多个用户输入需要与split()结合使用
实例1：
host, port, username, passwd, dbname = input(“请输入服务器地址,端口号,用户名，密码及数据库名，空格隔开：”).split()
注意input()的返回类型是str
这里解释一下与list(map(int,input().split()))的区别：

1. 用map函数是可以将类型进行强制转换的，比如我想要int或者float类型
2. input().split():就只能默认的返回str类型
   print(host,port,username,passwd,dbname)
   输出结果：
   请输入服务器地址,端口号,用户名，密码及数据库名，空格隔开：http://localhost:4000/ root 123456 db_name
   http://localhost:4000/ root 123456 db_name

map()用法

map(function, iterable, …)
要加list（）函数将迭代器转化为列表(重点理解)
自定义函数：

def f(x):
    return x*x
print(list(map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])))
输出：[1, 4, 9, 10, 25, 36, 49, 64, 81]
匿名函数：
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))
输出：[1, 4, 9, 16, 25]

str.split()用法

通过指定的分隔符对字符串进行切片，返回的是字符串列表
str.split(str=””, num=string.count(str))
str是分隔符（默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等），num是分隔次数
举例：

txt = "Google#Facebook#Runoob#Taobao"
x = txt.split("#", 1)   #分隔次数是1
print(x)
输出：['Google', 'Facebook#Runoob#Taobao']    

txt = "Google#Facebook#Runoob#Taobao"
x = txt.split("#", 2)    #分隔次数是2
print(x)
输出：['Google', 'Facebook', 'Runoob#Taobao']   

算多少人被请家长：
小乐乐的班主任想统计一下班级里一共有多少人需要被请家长，三个成绩（语文，数学，外语）平均分低于60的将被请家长，小乐乐想编程帮助班主任算一下有多少同学被叫家长。
输入描述：
共n+1行
第一行，输入一个数n，代表小乐乐的班级中有n个同学。
在接下来的n行中每行输入三个整数代表班级中一个同学的三科成绩（语文，数学，外语），用空格分隔。
输出描述：
一行，一个整数，代表班级中需要被请家长的人数。
代码如下：

a = int(input())
list1=[]
count = 0
for i in range(0,a):      #对行数即学生的人数进行遍历
    #读取第一行的数据，返回一个列表，存储在data数组中
    data = list(map(int,input().split()))    
    list1.append(data)  #把下一行的数据加到list1列表中去
    if sum(list1[i])/3 < 60: #判断当前的列表中的成绩的平均数是否小于60
        count+=1
print(count)

题目2描述：
大学的同学来自全国各地，对于远离家乡步入陌生大学校园的大一新生来说，碰到老乡是多么激动的一件事，于是大家都热衷于问身边的同学是否与自己同乡，来自新疆的小赛尤其热衷。但是大家都不告诉小赛他们来自哪里，只是说与谁是不是同乡，从所给的信息中，你能告诉小赛有多少人确定是她的同乡吗？
输入描述：
包含多组测试用例。
对于每组测试用例：
第一行包括2个整数，N（1 <= N <= 1000），M(0 <= M <= N*(N-1)/2)，代表现有N个人（用1~N编号）和M组关系；
在接下来的M行里，每行包括3个整数，a，b, c，如果c为1，则代表a跟b是同乡；如果c为0，则代表a跟b不是同乡；
已知1表示小赛本人。

输入样例：
3 1
2 3 1
5 4
1 2 1
3 4 0
2 5 1
3 2 1

代码实现如下：

import math
while 1:
    #每组第一行是N和M 
    nm = list(map(int,input().split(" ")))
    N = nm[0]
    M = nm[1]
    print(str(N) + ' ' + str(M))
    # 接下来M行，每行a b c
    for i in range(M):
      abc = list(map(int,input().split(" ")))
      a = abc[0]
      b = abc[1]
      c = abc[2]
      print(str(a) + ' ' + str(b) + ' ' + str(c))

输出结果：
3 1
2 3 1
5 4
1 2 1
3 4 0
2 5 1
3 2 1

python中字符串的遍历问题

python的字符串遍历有4种方式：
1. 下标法
2. for in
3. iter内置函数
4. enumerate：枚举
其中下标法和enumerate适合需要判断后续字符的场景，比如循环到下标index出，要求判断index+1的字符这种。最典型的题目就是语法解析器，判断”(())”这种成对的括号的算法。
“for in”和iter适合对字符进行直接处理的一类题目，比如大小准换，字符串对比之类的。
总之，如果需要用到下标就使用下标法和enumerate，其中enumerate比下标法性能更优。

第一种方式：for in

girl_str = "love You"
for every_char in girl_str:
    print(every_char)
# 输出的结果为：
l
o
v
e

Y
o
u

内置函数range()或xrange（）

girl_str = "love You"

for index in range(len(girl_str)):
    print(girl_str[index])

# 输出的结果为：
l
o
v
e

Y
o
u

内置函数enumerate()

# 把元素一个个的枚举出来，返回的是元素以及对应的索引
girl_str = "love You"
for index, every_char in enumerate(girl_str):
print(str(index) + every_char)

输出结果如下：
0l
1o
2v
3e
4
5Y
6o
7u

第四种方式，内置函数iter()

girl_str = "love You"
for every_char in iter(girl_str):
    print(every_char)

# 输出的结果为：
l
o
v
e

Y
o
u

以一道例题为例：
今年是2019年，KiKi想知道12019中有多少个包含数字9的数。包含数字的数是指有某一位是“9”的数，例如“2019”、“199”等。
输出描述：一行，一个整数，表示12019中共有多少个数包含数字9
代码如下：

count = 0
for i in range(0,2020):  
    a = str(i)    #把i的值强制转换成字符串类型
    for s in a:   #让变量s在a中进行遍历
        if s =="9":    #对于i中9只有记录一次
            count += 1
            break
print(int(count))

python中format格式化函数的整理

https://www.runoob.com/python/att-string-format.html
新增的一种格式化字符串的函数str.format(),它增强了字符串格式化的功能
基本语法：通过 {} 和 : 来代替以前的 %
函数可以接受不限个参数，位置可以不按顺序
print(“{} {}”.format(“hello”, “world”)) #不设置指定位置，按照默认的顺序
print(“{0} {1}”.format(“hello”, “world”))
print(“{1} {0} {1}”.format(“hello”, “world”) ) # 设置指定位置
输出分别为：
hello world
hello world
world hello world

也可以设置相应的参数：
方式一：通过字典来设置参数
print(“网站名：{name}, 地址 {url}”.format(name=”xr的博客”,url=”http://localhost:4000/"))
输出结果：网站名：xr的博客, 地址 http://localhost:4000/

方式二：通过列表设置参数
my_list = [‘xr的博客’, ‘http://localhost:4000/']
print(“网站名：{0[0]}, 地址 {0[1]}”.foemat(my_list))
输出结果：网站名：xr的博客, 地址 http://localhost:4000/

向str.format()传入对象

数字格式化
^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

• 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
  b、d、o、x 分别是二进制、十进制、八进制、十六进制。

以下为实际的例子分析：
print(“{:.2f}”.format(3.1415926)) #保留小数点后两位
print(“{:+.2f}”.format(3.1415926)) #带符号保留小数点后两位
print(“{:.0f} “.format(3.1415926)) #不带小数
print(“{:0>2d} “.format(5)) #数字补0，填充左边，宽度为2
print(“{:x<4d} “.format(5)) #数字补x，填充右边，宽度为4
print(“{:,}”.format(1000000)) #以逗号分隔的数字形式
print(“{:.2%}”.format(0.25)) #保留两位小数的百分数形式
print(“{:.2e}”.format(1000000)) #指数计数法
print(“{:>10d}”.format(13)) #右对齐，默认宽度为10
print(“{:<10d}”.format(13)) #左对齐，默认宽度为10
print(“{:^10d}”.format(13)) #中间对齐，默认宽度为10

输出结果如下：
3.14
+3.14
3
05
5xxx
1,000,000
25.00%
1.00e+06
13
13
13

用{}来转义{}
print (“{} 对应的位置是 0“.format(“runoob”))
输出为：runoob 对应的位置是 {0}

在python3.6中新增一种f字符串的格式化
格式化的字符串文字前缀为’f’和str.format()相似。它们包含由花括号包围的替换区域。替换字段是表达式或变量，在运行时进行评估，然后使用format()协议进行格式化。以 f 开头，包含的{}表达式在程序运行时会被表达式的值代替。

if not x:和if x is not None:和if not x is None

主要出现的是判断变量是否为None的三种写法：
1、if x is None
2、if not x
3、if not x is None ：（正确的理解方式为：if not (x is None）

x = 1
print(not x)
输出： False

x = [1]
print(not x)
输出： False

x = 0
print(not x)
输出： True

x = [0]
print(not x)
输出： False

在python中 None, False, 空字符串””, 0, 空列表[], 空字典{}, 空元组()都相当于False ：
以下打印的结果全为True
print(not False )
print(not None )
print(not ‘’)
print(not 0)
print(not [])
print( not {})
print(not ())
什么时候用if not x 会出错？以下想区分x==[]和x==None

x = []
y = None
print(x is None)
print(y is None)
输出：False
输出：True
备注：这种情况下想判断x是否为None,但是把x=[]的情况盘判断进来了，这种情况无法进行相应的区分

print(not x)
print(not y)
输出：False
输出：False

print(not x is None)
print(not y is None)
输出：False
输出：False

for、while循环

简单小例子的整理（入门级简单而已）
for循环：针对集合中的每一个元素都执行代码块。for循环可以遍历任何序列的项目，比如字符串、列表、元组、字典、集合等序列类型，逐个获取序列中的各个元素
while循环：满足指定的条件，循环不断的运行，直到指定条件不满足（对应的布尔表达式为false）才会跳出循环。

输入描述：输入只有一行，其中含有一个正整数 n(1≤n≤20)，代表KiKi说祝福话的遍数。
输出描述：输出 n行”Happy new year!Good luck!”。
方法一：

n = int(input())
for i in range(1,n):
    print("Happy new year!Good luck!")
上诉方法再简化：
for i in range(int(input())):
    print("Happy new year!Good luck!")

方法二：采用while循环

n = int(input())
i =1
while i <=n:
    i =i+1
    print("Happy new year!Good luck!")

只能用while不能用for的情况
有一个数字魔法，给你一个正整数n，如果n为偶数，就将他变为n/2, 如果n为奇数，就将他变为乘3加1
不断重复这样的运算，经过有限步之后，一定可以得到1
牛牛为了验证这个魔法，决定用一个整数来计算几步能变成1
输入描述：输入一个正整数n,范围在100以内
输出描述：输出一个整数
举例：输入3，输出7
分析：3->10->5->16->8->4->2->1。总共需要7步
用while循环实现

n = int(input())
count = 0
while n !=1:  #循环终止的条件，只要条件不满足，就必须要不停的进行循环
    if n %2 ==0:
        n= n/2
        count +=1
    else:
        n = 3*n+1
        count +=1
print(count)
考虑用for循环却不能表达出n!=1的情况

在while中使用break和continue
break:跳出循环
continue:跳过本次循环开始下次循环

#continue用法
i = 1
while i < 10:
    i +=1
    if i%2 ==1: # 非双数时跳过输出
        continue # 输出双数2、4、6、8、10
    print(i)

#break用法
i = 1
while 1: 
    i +=1
    if i > 10:# 当i大于10时跳出循环
        break
    print(i)

while循环中使用else示例

count = 0
while count < 5:
　　print(count, " is less than 5")
　　count = count + 1
else:
　　print(count, " is not less than 5")
# 结果为：
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5

关于pyton的a ,b = b , a+b的问题

这种是属于多个值赋给多个变量
第一种情况：

a = 0, b = 1
a, b = b, a+b
print a, b   #结果为：1 1
#Python先计算等号的右边，再赋值，能够保证a,b都是初始值

第二种情况

a = 0, b = 1
a = b
b = a + b
print a, b   #结果为：1 2
#是一种顺序计算赋值，a+b中的a值已经发生了相应的改变

为了使第二种情况也能够达到上面的的相应的效果
通过增加一个中间变量来储存相应的值

a = 0, b = 1, c = 0
c = a
a = b
b = c + b
print a, b   #结果为：1 1

关于str()函数、chr()函数以及ord()的区别

1. chr()函数是把一个小整数作为参数，并返回对应于ASCII单字符的字符串
2. str()函数是把任何整数作为参数，返回一个该整数的文本形式的字符串
3. ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的Unicode码，而函数chr()则是用来返回Unicode编码对应的字符。（记住互相转换就好了），以下的几个小例子用于自己的辅助理解。

print(ord('熊'))
print(ord('锐'))
# 输出的结果为
# 29066
# 38160
a = list(map(chr,(29066,38160)))
print(a)
print(''.join(map(chr,(29066,38160))))
# 输出结果为
# ['熊', '锐']
# 熊锐

# str()将任意类型的参数转换为字符串
print(str(12345))
print(str([1, 2, 3]))
print( str((1, 2, 3)))
print(str({1, 2, 3}))
print(str({1:'a', 2:'b', 3:'c'}))
# 输出结果如下
# 12345
# [1, 2, 3]
# (1, 2, 3)
# {1, 2, 3}
# {1: 'a', 2: 'b', 3: 'c'}

python中二维数组、三维数组以及多维数组的创建问题

这里主要是不使用numpy进行相应的创建
10行3列的二维数组的创建：

m = [[0]*3 for _ in range(10)]
或者用m = [[0] *3] *10
m = [[0]*3 for _ in range(10)]
print(m)
for i in range(10):
    for j in range(3):
        try:
            if (m[i][j] != 0):  print(i,j)
        except:
            print(i,j,"error")
#输出结果为：
#[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

三维数组的创建：
4行3列，z=2的三维数组的创建：

m = [[[0] * 2 for _ in range(3) ] for _ in range(4)]
或者用 m = [[[0] * 2] * 3] *4   #这种方式不建议用，也有可能会出现一定的问题
m = [[[0] * 2 for _ in range(3) ] for _ in range(4)]
for i in range(4):
    for j in range(3):
        for k in range(2):
            try:
                if (m[i][j][k] != 0):   print(i, j,k);
            except:
                print(i,j,k ,"error")
#输出结果：
[[[0, 0], [0, 0], [0, 0]], 
[[0, 0], [0, 0], [0, 0]], 
[[0, 0], [0, 0], [0, 0]], 
[[0, 0], [0, 0], [0, 0]]]

多维数组的创建

m = [.....[[0]*q]*w]*e]*r]*t]*y]*u]*.........]

关于多维矩阵输出的问题

# 本题主要是打印回型矩阵中最后一步的输出的一个过程
s=[[1, 2, 3, 4], [12, 13, 14, 5], [11, 16, 15, 6], [10, 9, 8, 7]]
for i in range(4):
    for j in range(4):
        print(s[i][j],end=' ')
    print()
# 输出结果
1 2 3 4 
12 13 14 5 
11 16 15 6

统计字符串长度（去除无关的）

replace()函数：将字符串中的旧字符替换为新字符
万能的，可以替换掉所有的东西:后面的内容替换掉前面的内容
replace(“space”,””):将空格去掉
replace(“\n”,””) ：将换行符去掉
replace(“\r”,””) ：

str = '''     《
            人民日报
            》                  (
             2022年03月26日

              04
              版)

                             》    '''

#print(str.strip().replace(' ', '').replace('\n', ''))
print(str.replace(' ', '').replace('\n', ''))
# 输出结果
《人民日报》(2022年03月26日04版)》

strip()函数：删除字符串中的字符
strip： 用来去除头尾字符、空白符(包括\n、\r、\t、’ ‘，即：换行、回车、制表符、空格)
lstrip：用来去除开头字符、空白符(包括\n、\r、\t、’ ‘，即：换行、回车、制表符、空格)
rstrip：用来去除结尾字符、空白符(包括\n、\r、\t、’ ‘，即：换行、回车、制表符、空格)
以下附上一些比较简单的例子：

s="abxcdxyhabxfgcjkabx"
s1="abx"
print(s.strip(s1))  # 去掉头尾的"abx"
print(s.lstrip(s1)) # 去掉前面的"abx"
print(s.rstrip(s1)) # 去掉后面的"abx"
# 输出结果
# cdxyhabxfgcjk
# cdxyhabxfgcjkabx
# abxcdxyhabxfgcjk

s = "   Runnerxr      "  # 去除首尾空格
print(s.strip())
# Runnerxr

判断字符是否是数字 、大写字母、小写字母

isdigit():检测字符串是否只由数字组成
isalpha():检测字符串是否只由字母组成
isupper():检测字符串中所有字母都为大写
islower():检测字符串中所有字母都为小写
将字符串中的字符全部改为大写：.upper()
将字符串中的字符全部改为小写：.lower()

str1 = "123456"
str2 = "AB123"
str3 = "ABcd123"
print(str1.isdigit())
print(str2.lower())
print(str3.upper())
# True
# ab123
# ABCD123
# abcd123

python中的collections模块的理解

是一种高性能容量的数据类型，主要包含5种数据类型（了解会用就行）
参考链接：
https://zhangyx.blog.csdn.net/article/details/88202672?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1.pc_relevant_default&utm_relevant_index=1
https://blog.csdn.net/qq_43608884/article/details/90243678

from collections import Counter
#统计字符串
# top n问题
user_counter = Counter("abbafafpskaag")
print(user_counter.most_common(3)) #[('a', 5), ('b', 2), ('f', 2)]
print(user_counter['a']) # 5

理解python中实现most_common的原理：

 def most_common(self, n=None):
        '''List the n most common elements and their counts from the most
        common to the least.  If n is None, then list all element counts.(如果传入参数n,就列出前n个出现最多的元素以及相应的计数，如果不传入参数就列出所有的数以及相应的计数)
        >>> Counter('abcdeabcdabcaba').most_common(3)
        [('a', 5), ('b', 4), ('c', 3)]
        此处列出了前三个出现最多的元素以及相应的计数
        '''
        # Emulate Bag.sortedByCount from Smalltalk
        if n is None:
            return sorted(self.items(), key=_itemgetter(1), reverse=True)
        return _heapq.nlargest(n, self.items(), key=_itemgetter(1))
    ```
n是None的情况，因为Counter类继承自dict，所以 self.iteritems 得到的是键值对元组的列表，用 sorted对这个列表进行排序，因为是要按照元组的第1位的数字从大到小的顺序来排序，所以key应该是元组的第1位。代码中用 _itemgetter(1)来取出元组的第1位，_itemgetter是 operator 模块里的 itemgetter 类
如果 n 不为 None ，调用了 heapq(最上边导入时将heapq as 重命名成了 _heapq) 模块中的 nlargest 函数,函数的介绍：
```python
    Find the n largest elements in a dataset.
    Equivalent to:  sorted(iterable, key=key, reverse=True)[:n]

python使用typing

之前都只是在用到的时候直接记住的，后面有时间再整理与研究
参考链接：https://blog.csdn.net/qq_43355223/article/details/105753668

关于python中join()函数的用法

作用：用于将序列中的元素以指定的字符连接生成一新的字符串
str.join(元组、列表、字典、字符串) 之后生成的只能是字符串。
所以很多地方很多时候生成了元组、列表、字典后，可以用 join() 来转化为字符串。

# 元组、列表、字符串（前提是其中的元素需要是字符串）
# list=['1','2','3','4','5']
# list='1','2','3','4','5'
list=('1','2','3','4','5')
print(''.join(list))
# 输出
# 12345

# join里面加入一个字典
seq = {'hello':'nihao','good':2,'boy':3,'doiido':4}
print('-'.join(seq))        #字典只对键进行连接
# 输出结果
# hello-good-boy-doiido

关于python中list()函数的用法

作用：用于将元组、区间（range）、字典(dict)、集合（set）转化为列表
补充说明：支持元组的，都能够支持列表，列表是增强版本的元组，如果程序中不需要修改列表包含的元素，使用元组代替列表更加的安全

# 举例说明
a = (1,2) #tuple
b = {"1":2,"3":3} #dict,只会输出key值组成列表
c = {1,2,3}  #set
d = range(2,10,2) #range
print(list(a))
print(list(b))
print(list(c))
print(list(d))
# 打印结果如下：
# [1, 2]
# ['1', '3']
# [1, 2, 3]
# [2, 4, 6, 8]

关于列表生成式（List Comprehensions）

1. 创建list的生成式(最简单的形式)：range()
2. 把要生成的放在前面，后面跟for循环 if判断（可以自己进行相应的附加增加相应的筛选条件）
3. 还可以使用两层循环生成相应的全排列
4. 列出当前目录下的所有的文件和目录名
5. for循环可以同时使用两个甚至多个变量（dict()的item()可以同时迭代key和value）:备注：items()为以函数的列表返回可遍历的键、值
6. 列表生成式也可以使用两个变量来生成list
   1. for k ,v in d.items() 遍历d.items() 得到 k =’x’ ,v = ‘A’/ k =’y’ ,v = ‘B’/k =’z’ ,v = ‘C’
   2. k + “=” + v 这里（k + “=” + v）连接起来就是字符串“x=A”/“y=B”/“z=C”
7. 把一个list中的所有字符串变成小写：s.lower() :转换所有大小写字符为小写

# 附上代码有助于理解的更清楚
print([x * x for x in range(1, 11)])
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 使列表生成式，并加入了if条件判断，用于筛选中其中的偶数
print([x * x for x in range(1, 11) if x % 2 == 0])
# [4, 16, 36, 64, 100]

# 使用两个循环生成全排列
print([m + n for m in 'ABC' for n in 'XYZ'])
# ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

# 对字典使用
# for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value：
# 这里用列表生成式来改写
d = {'x': 'A', 'y': 'B', 'z': 'C' }
print([k + '=' + v for k, v in d.items()])
# ['x=A', 'y=B', 'z=C']

L = ['Hello', 'World', 'IBM', 'Apple']
print([s.lower() for s in L])
# ['hello', 'world', 'ibm', 'apple']

python中的一些插入：append() insert() add() 以及extend()

首先：append()和insert()是用于列表的插入的：append()是直接插到末尾，insert()，是插到指定索引前面
add()是用于元组的插入的，因为元组讲究的是不重复，是无序的，这也是需要注意的地方
只有弄清楚这些函数的意义才能运用自如
append()函数：将新元素追加到列表末尾

a = [1, 2, 3, 4, 5]
a.append(6)
print(a)
# [1, 2, 3, 4, 5, 6]

extend(): 通过该函数可以将另一个列表中的元素逐一添加到指定列表中
比如使用append()函数：

a = [1, 2]
b = [3, 4]
a.append(b)
print(a)
# [1, 2, [3, 4]]

使用extend()函数的效果：

a = [1, 2]
b = [3, 4]
a.extend(b)
print(a)
# [1, 2, 3, 4]

insert(index, object)
它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素

a = [1, 2, 3, 4, 5]
# 将元素0添加到索引为0的前面
a.insert(0, 0)
print(a)
# [0, 1, 2, 3, 4, 5]

add()函数的运用：

# 运用于集合的情况
numbers_set = {1, 2, 3, 4, 4, 5}
numbers_set.add(6)
numbers_set.add(4)
print(numbers_set.add)
# 输出为：{1，2，3，4，5，6}

关于.sort(key = lambda x: (-len(x), x))

来源：做leetcoad720-词典中的最长单词出现的一个语法，这里当做一种学习
lambda x ：指具有排序规则（用x设置，如x的长度、x的大小）
len(x) :将长度按照从小到大的顺序排列
‘ dictionary.sort(key=lambda x: (-len(x), x)) ‘ :表示将这个字典先按照长度从大到小排序，如果长度相同，则用出现的先后顺序（ASCII顺序）

dictionary = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
# dictionary.sort( key=lambda x: (-len(x), x))
sorted(dictionary, key=lambda x: (-len(x), x))
print(dictionary)
# 输出为：['banana', 'apple', 'apply', 'appl', 'app', 'ap', 'a']

补充一点关于sort()与sorted()函数的区别：

1. sort()与sorted()的区别：sort是在原位重新排列列表，sorted()是产生一个新的列表。
2. sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作(这句话需要重点理解)。
3. sort 只是应用在 list 上的方法（就地排序无返回值）。
4. sorted 是内建函数，可对所有可迭代的对象进行排序操作，（返回新的list）。
5. list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

# 以一个例子来辅助理解
from operator import itemgetter

L = ['bob', 'about', 'Zoo', 'Credit']
print(sorted(L))
# 默认的是按照ASCII来排序的（大写自己在前）
# ['Credit', 'Zoo', 'about', 'bob']

print(sorted(L, key=str.lower))
# 传入一个key函数，然后全部变成小写按照自己顺序排列
# ['about', 'bob', 'Credit', 'Zoo']

students = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

print(sorted(students, key=itemgetter(0)))
# print(sorted(students, key=lambda t: t[0]))
# 按照名字进行排序(按键进行排序)，上面的两种按名字排序的结果是一样的
# [('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]

print(sorted(students, key=lambda t: t[1]))
# 按照成绩进行升序排序
# [('Bart', 66), ('Bob', 75), ('Lisa', 88), ('Adam', 92)]

print(sorted(students, key=itemgetter(1), reverse=True))
# 按照成绩进行降序排列
# [('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]

这里在补充一个用sorted()对字典排序返回一个列表的例子

hashmap = {8: 46828, 24: 47153, 3: 93735, 13: 72600, 4: 44422}
# 直接借助sorted()函数进行排序，排序后会转换成一个列表
# sorted(iterable, key=None,reverse=False)
lis1=sorted(hashmap.items(),key=lambda d:d[0]) #按键来排序
print(lis1)
# [(3, 93735), (4, 44422), (8, 46828), (13, 72600), (24, 47153)]

关于lamda函数做一点补充
匿名函数（在廖雪峰老师的课上，这里讲的还是比较的明白，可以自己去回顾）

关于ASCII的一点小的记录

ASCII实际上就是键盘上输入的字符，在计算机中二进制形式，规定了不同的字符用哪个整数值去表示
记住有一张ASCII的对照表

参考链接：http://c.biancheng.net/c/ascii/里面有详细介绍ASCII码的情况
包括数字、字母、符号一共128个字符，可以用7位二进制编码，为了存入计算机，在最高位需要补0。
可印刷字符：32126，其余为控制、通信字符
数字：48(0011 0000)57(0011 1001)
大写字母：65(0100 0001)90(0101 1010)
小写字母：97(0110 0001)122(0111 1010)

python中re.compile函数的使用

通过re模块提供对正则表达式的支持，使用re的一般步骤：

1. 先使用re.compile()函数，将正则表达式的字符串形式编译成Pattern实例
2. 然后使用Pattern实例处理文本并获取匹配结果（一个match实例），最后使用Match实例获得信息，进行其他的操作

import re
pattern = re.compile('[a-zA-Z]')
# 用findall()返回包含所有匹配项的列表
result = pattern.findall('as3SiOP')
print(result)
# 输出结果
# ['a', 's', 'S', 'i', 'O', 'P']

# 另外的一种写法
import re
txt = "my name is Runnerxr"
x = re.findall("am", txt)
print(x)
# 输出结果
# ['am']

关于ACM模式和核心代码模式

对于ACM模式需要能够在本地直接运行，需要自己写include哪些库函数、构造输入用例、构造输出用例
ACM更锻炼代码能力，和兴代码模式把侧重点放在算法逻辑上面。

ACM中的一些python3的使用方法

参考链接：https://blog.csdn.net/Miaplacidus/article/details/106474221
输入方式：这个基本上自己已经很熟悉了

'''
def main():
    Do somthing
if __name__ == '__main__':
    t = int(input())
    for i in range(t):
        main()
'''
for T in range(0,int(input())): #T组数据
    N=int(input())
    n,m=map(int,input().split())
    s=input()
    s=[int(x) for x in input().split()] #一行输入的数组
    a[1:]=[int(x) for x in input().split()] #从下标1开始读入一行
    for i in range(0,len(s)):
        a,b=map(int,input().split())

while True: #未知多组数据
    try:
        #n,m=map(int,input().split())
        #print(n+m,end="\n")
    except EOFError: #捕获到异常
        break

一些基本数据结构
python中的栈和队列可以用列表来模拟，或者用import deque
匿名函数使用lambda关键字来定义 lambda 参数：表达式

#使用中括号[]定义一个列表
# l=[23,'wtf',3.14]
list.append(obj)#将obj添加到list末尾,O(1)
list.insert(index,obj)#将obj插入列表index位置,O(n)
list.pop([index=-1])#移除元素并返回该元素
list.sort(key=None,reverse=False)#默认升序排序,O(nlogn)
list.reverse()#反转列表元素
list.clear()
len(list)#列表元素个数,O(1)
max(list)#返回列表元素最大值,O(n)
del list[2]#删除list中第三个元素

#用小括号定义一个元组,可以当作不能修改的list
# t=(23,'wtf',3.14)

#用花括号{}定义一个字典
d={key1:value1,key2:value2}#通过key访问value
print(d[key1])#输出value1
if key in dict : #key不存在会报错,要先询问
    do somthing #或者使用
d.get(key)
for key in d: #遍历字典d
    print(key,':',d.get(key))
dMerge=dict(d1,**d2)#将d1和d2合并为dMerge

#调用set()方法创建集合
s=set([1,2,3])#定义
s.add(4)#添加
s.remove(4)#删除

math库

import math
math.e #常量e,2.718281828459045
math.pi #常量pi,3.141592653589793
math.factorial(x) #x的阶乘
math.gcd(x,y) #x,y的gcd(返回最大公约数)
math.sqrt(x) #x的平方根
x=math.log(n,a) #以a为底n的对数x,a^x=n,默认底数为e
math.log(32,2) #5.0
math.degrees(math.pi/4) #将Π/4转为角度
math.radians(45) #将45度转为弧度
math.cos(math.pi/4) #参数都为弧度

一些封装的模板：
快速幂：快速计算底数的n次幂

def qmod(a,b,mod):
    a=a%mod
    ans=1
    while b!=0:
        if b&1:
            ans=(ans*a)%mod
        b>>=1
        a=(a*a)%mod
    return ans

并查集（尝试整理成自己的模板）

N,m=map(int,input().split())
fa=[int(i) for i in range(N+1)]
siz=[1]*(N+1)
def findfa(x):
    if fa[x]!=x:
        fa[x]=findfa(fa[x])
    return fa[x]
def Merge(x,y):
    xx,yy=findfa(x),findfa(y)
    if xx == yy:
        return False
    if siz[xx] > siz[yy]: #按秩合并
        fa[yy]=xx
        siz[xx]+=siz[yy]
    else:
        fa[xx]=yy
        siz[yy]+=siz[xx]
    return True
for i in range(m):
    z,x,y=map(int,input().split())
    if z==1:
        Merge(x,y)
    else:
        print('Y' if findfa(x)==findfa(y)else 'N')

在调用函数需要注意的点

当写在while True try except里面的
引用函数之前需要把函数写好放在前面，后面才能用，否则就会发现找不到的情况。
其实这也是和leetcoad上是一样的套路

1. 如果是写在同一个类下面的，是不需要进行参数传递的，注意相应的先后关系就可以了
2. 如果不在同一个类下面，这个时候就需要注意了，需要用到self

关于eval函数的一些用法

参考资料：https://blog.51cto.com/u_15075510/2582004
ambda的一般形式是关键字lambda后面跟一个或多个参数，紧跟一个冒号，以后是一个表达式。lambda是一个表达式而不是一个语句。它能够出现在Python语法不允许def出现的地方。作为表达式，lambda返回一个值（即一个新的函数）。lambda用来编写简单的函数，而def用来处理更强大的任务。
eval(str)函数很强大，官方解释为：将字符串str当成有效的表达式来求值并返回计算结果。所以，结合math当成一个计算器很好用。

计算字符串中有效的表达式，并返回结果

将字符串转成相应的对象（如list tuple dict和string之间的转换）

# 字符串转化为列表
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
b=eval(a)
print(b)
#输出结果
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]

# 字符串转换为字典
a = "{1:'xx',2:'yy'}"
c=eval(a)
print(c)
#输出结果
{1: 'xx', 2: 'yy'}

# 字符串转换为元组
a = "(1,2,3,4)"
d=eval(a)
print(d)
# 输出结果
(1,2,3,4)

将利用反引号转换的字符串再返回对象

关于print打印换行与不换行

以下以几个小的例子来举例说明即可

# 直接打印，默认的是每打印一个换行一次
# 更改用特殊符号来连接
nums = [12,34,45,64,77,89,90,21,34,54]
even = []
odd = []
i = 0
while i < len(nums):
    num = nums.pop()
    if(num % 2 == 0):
        even.append(num)
    else:
        odd.append(num)
print(even)
print(odd)

for i in 'ajdka':
    # 每打印一个数字换一次行
    print(i)

for i in [1,2,3,4,5,6,7]:
    # 打印到一行，并且每个数之间用空格隔开
    print(i,end=' ')

# 打印结果如下
[54, 34, 90, 64, 34, 12]
[21, 89, 77, 45]
a
j
d
k
a
1 2 3 4 5 6 7

关于float(“inf”)与np.inf的使用

https://qa.1r1g.com/sf/ask/2962087901/
https://www.jianshu.com/p/8d7ed2b956da
之前在做动态规划的题目的时候发现有这样的一个用法，首先说这两个到底有没有区别：
两者没有区别,具有相同的值和相同的类型，可以进行互换，以下用代码来展示

# 两者具有相同的值
import math
import numpy as np
# 判断两者的值是否相等
print(np.inf==float('inf'))
print(np.inf==math.inf)
#打印结果
True
True

# 两者具有相同的类型
import numpy as np 
print(type(np.inf))
print(type(np.inf) is type(float('inf')))
# 打印结果
<class 'float'>
True

使用np.inf的原因

1. 键入的内容更少:
   • np.inf (6个字符)
   • math.inf (8个字符; python 3.5中的新字符)
   • float(‘inf’) (12个字符)
     这意味着如果您已经导入了NumPy,那么与float(‘inf’)(或math.inf)相比,每次出现可以节省6(或2)个字符.
2. 更好记住：np.inf相比float用字符调用，同时NumPy还定义了一些额外的别名np.Inf np.inf…
3. 常量是常量：会相应的节省内存
4. 访问常量比创建变量更快：

如果是使用float(‘inf’) 和float(‘inf’)
有一些性质需要记住的：

1. 用INF做加法、乘法等算数运算仍然会的到inf：
2. 除了 INF 外的其他数除以 INF ，会得到0：
3. 任何其他的数值除以 INF 都会得到 INF， 因为INF表示正无穷
4. 所有数都比 -inf 大，所有数都比 +inf 小就可以了。

关于python return中的or和and语句

这个记载的原因是刷算法的时候突然遇到：return ''.join(stack[:len(stack) - k]).lstrip('0') or "0" 一时间这种表达方式没有反应过来。这里只好把相关的一些知识点整理一下
二元运算：
如果一个True，一个False或两个False
return True and False # 返回False
return True or False # 返回True

如果两边都是True，则and返回右边的，or返回左边的
return 1 or 2 # 返回1
return 1 and 2 # 返回2

多元运算
从左到右，两两运算，两两运算的逻辑就是二元运算
以下举例分析：
return 1 or 2 or 3 # 返回1
return 1 and 2 and 3 # 返回3
return 1 and 2 or 3 # 返回2

通过上面的这些分析搞明白了：
条件1：’’.join(stack[:len(stack) - k]).lstrip(‘0’)
条件2：”0”

python中三目运算符的使用方法

True_statements if expression else False_statements
语句解释：先对逻辑表达式expression求值，如果逻辑表达式返回True，执行True_statements的值，如果逻辑表达式返回False，则执行False_statements的值

a,b=5,3
print('a大于b') if a>b else print('a不大于b')
# 打印结果：a大于b

python中的index（）函数的用法

语法：list.index(x[, start[, end]])

1. 返回列表中元素 x 第一次出现时的索引。
2. 如果没有元素 x，则会抛出 ValueError 异常。
3. 其中start和end为查找的起始位置和结束位置

关于Python函数中全局变量与局部变量

gloab是python中的一个关键字，作用在变量上，通常放在函数块中，用来声明该变量为全局变量。
例如下面变量a，定义在函数外面的是全局变量a，定义在fun函数里面的a是另一个a，是局部变量a，两者没有任何关系。好比这个地区有个叫张三的人，公办室里有个另一个叫张三的人。他们是两个不同的人。

a = 10
def fun():
    a = 2
fun()
print(a) # 输出 10

如果想要函数里面的那个a就代表外面的全局变量a，那么就要将函数里面的a 用关键字 global 声明为全局变量

a=10
def fun():
    gloab a
    a=2
fun()
print(a)  # 输出为2

下面的这段代码中，函数里面的a是局部变量，但是打印的a还是外面的，a还是1
b经过函数已经变成了2

a = 1
b = 1
def foo1():
    global b  # 申明使用全局b
    for i in range(1,3):
        a = 2  # a是本地变量
        b = 2  # b是全局变量
foo1()
print(a)
print(b)
# 打印结果
1
2