算法中常用的python基础语法（持续更新）

一、语法小点

  1. 实现c++的？：语句
    s[num] = stack[-1] if stack else -1
  2. 赋值运算符 :=
  • 用处：直接声明并初始化
  • if语句
my_list = [1,2,3]
count = len(my_list)
if count > 3:
   print(f"Error, {count} is too many items")

# when converting to walrus operator...
if (count := len(my_list)) > 3:
   print(f"Error, {count} is too many items")
  • while语句
line = f.readLine()
while line:
   print(line)
   line = f.readLine()

# when converting to walrus operator...
while line := f.readLine():
   print(line)


n = 0
while n < 3:
   print(n) # 0,1,2
   n += 1

# when converting to walrus operator...
w = 0
while (w := w + 1) < 3:
   print(w) # 1,2

二、列表

2.1 列表基础

  • 列表中不需要同一个类
    list = [3,3.0,True]

  • 运算

    • \(+ \quad\)列表连接在一起
    • \(* \quad\)重复N次连接 ——> 一维的重复后是二维，且修改某个值重复的值都会改变
    • \(in \quad\) 询问列表中是否有某元素
    • \([:] \quad\) 取出列表的一部分 ——> 不包括末尾的下标，eg [1:3] == [1]和[2]
    • \([-1] \quad\) 取末尾元素

  • 方法

l = [1,2,3,4]
l.append(item) # 末尾末尾加入item
l.insert(i,item) # 第i个位置插入item
l.pop() # 删除最后一个元素
l.pop(1) # 删除第i个元素并返回该元素的值
l.sort() # 排序，从小到大，O(nlogn)
l.reverse() # 倒序排列
del l[i] # 删除第i个位置的元素
l.index(item) # item每一次出现的下标 
l.count(item) # 计数，返回item的数量
l.remove(item) # 列表中删除第一次出现的item

2.2 数组相关

  1. 创建数组
## 一维数组
# 创建1到999的一维数组
l = list(range(1000)) # 速度最快
l = [i for i in range(1000)] # 次快
# 创建相同元素的一维数组
l = [0] * n

## 二维数组
# 创建m行n列的二维0数组
l = [[0 for i in range(n)]for j in range(m)] # 先列后行

三、字符串

3.1 方法

python中的字符串对象是不能更改的，也即直接修改字符串中的某一位或几位字符是实现不了的
下面是特有的方法：

## 常见的方法
s ='helo'
num = s.count('i') # 返回i的个数
idx = s.find('i') # 返回第一次出现i的下标，如果不在会返回-1
ss = s.split('e') # 在'e'位置将字符串分割成子串 结果：['h','lo']
print(s.isdigit()) # 无参数，判断字符串是否只包含数字，只有数字返回True
temp = s[::-1] # 字符串翻转

## 其他方法
s = 'hello'
# 居中，空格填充使其长度为w
new = s.center(w) # '       hello        '
# 靠左/右放置，填充空格至长度w
new = s.ljust(w)
new = s.rjust(w)
# 变为小写
new = s.lower()
# 变为大写
new = s.upper()

3.2 分割 split()

  • 语法
    str.split(str="", num=string.count(str))
  • 参数
    • str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
    • num -- 分割次数。默认为 -1, 即分隔所有
  • 取分片
s = 'www.baidu.com'
part = s.split('.',2)[0] # 分割两次，取第一个分片（序号为0）
# part = 'www'

3.3 字符串修改 join()

  • 字符串不能够被修改，即 s[0]='w' 不支持
  • join()
    • join()方法用于将序列中的元素以指定的字符连接生成一个新的字符串
    • 语法：str.join(sequence)
      • 参数：sequence要连接的元素序列
      • 返回值：字符串
  • 可以通过join()将字符串转成list修改
s = 'abc'
l = []
for i in s:
  l.append(i)
# 利用list对字符串修改
s = "".join(l) # 转为字符串

四、字典

4.1 哈希表初始化、dict()

  • 用花括号括起一个个键值对
d = {'david':1410,'brad':1137}

## 下面这个最常用，用于哈希表
d = {}
d['david'] = 1410 # 直接创建映射联系
d['brad'] = 1137
  • dict()
>>>dict()                        # 创建空字典
{}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>> dict(x=5, y=0)
{'y': 0, 'x': 5}

4.2 运算

运算 用法 含义
[] d[k] k为键，返回相关联的值
in key in d 搜索的是key，存在的话返回True
del del d[k] del d[k]

4.3 方法

d = {'david':1410, 'brad':110}

# 获取key，但是返回的是dict_keys对象，用list()转换
key = list(d.keys()) # key：['david','brad']

# 获取value，但是返回的是dict_values对象，用list()转换
value = list(d.values()) # value:[1410,110]

# 获取所有键值对，list()转换后是关于元组的list
item = list(d.items()) # item: [('david':1410), ('brad':110)]

# 获取键key关联的值，如果没有返回False
v = d.get('david') 

# 获取键key关联的值，如果没有返回0(第二个参数）
v = d.get('david',0) 

seq = [1,2,3]
value = 0
# 以序列seq中元素做字典的键，value为字典所有键对应的初始值
d = dict.fromkeys(seq, value)

五、集合

5.1 集合的初始化

# 两种初始化
s = set()
s = {}
s = {1,2}

5.2 集合间的运算

运算 含义
in 集合中是否有某元素
len 集合长度
A\｜B 返回包含集合A和集合B所有元素的新集合
A & B 返回包含A和B共有元素的新集合
A - B 返回只出现在A的元素集合
A < = B A集合元素都在B中，则返回True

5.3 方法

s = {1,2,3}
s.add(4) # 添加元素
s.remove(3) # 移除3
s.pop() # 随机删除一个元素
s.clear() # 清空

六、输入输出

6.1 输入 input()

  1. 读取的是一整行
  2. 返回的是字符串，因此需要的话要用int()、float()等转换

6.2 比赛常见的输入问题

  1. 读取二维数组
  • 一行一行读取，用append
a = []
n,m = tuple(map(int,input().split()))
for i in range(n):
    a.append(list(map(int, input().split())))

  1. 读取两个整数，赋给两个变量

    a,b,c = map(int, input().split())

  2. 多组输入

while True:
    try:
        a = int(input())
				....
    except:
        break

6.3 格式化输出

  1. 格式化字符串

print(”%s is %d years old.” % (name,age))

  1. 格式化修改符
    |修改符|实例|含义|
    | ---- | ---- | ---- |
    |数字|%20d|放在20字符宽的区域|
    |-|%-20d|同上，且左对齐|
    |+|%+20d|同第一点，且右对齐|
    |0|%020d|同第一点，前面补齐0|
    |.|%20.2f|同第一点，且保留小数点后2位|
    |（name）|%（name）d|字典中获取name键对应的值（该值为整数，后面跟d），最后%跟上字典名|
d = {"item":"banana","cost",24}
print("The %(item)s costs %(cost)7.1f cents" % d)
# The banana cost     24.0 cents

6.4 比赛常见的输出问题

  1. 列表输出为一行 print(x,end=' ')

七、构造类（如结构体）

用类构造，然后类的参数写在__init__中

class Node:
  def __init__(self, data):
    self.data = data
    self.Next = None

# 使用
node = Node(2)

八、for-else用法

for i in range(3):
  xxx
else:
  xxx

else 里面的语句不一定执行，取决于 for 循环能否正常执行完毕：

  • for正常执行完毕，循环结束后执行else语句
  • 如果 for 循环中有 break字段等导致 for 循环没有正常执行完毕，那么 else 中的内容不会执行

九、python内置函数

9.1 enumerate()

  • 将一个可遍历的对象组合为索引序列，同时列出数据和数据下标
  • 一般用在for循环中
seq = ['one','two','three']
for index,i in enumerate(seq):
  print(index,i)
# 结果
0 one
1 two
2 three

# edges=[[0,1],[1,2]] succProb = [0.5,0.2]
for i, (x, y) in enumerate(edges):
  graph[x].append((succProb[i], y))
  graph[y].append((succProb[i], x))

9.2 sort()

  • sort函数有两种形式，一种是list.sort()，一种是sorted()
  • list.sort()属于永久性排列，直接改变list，没有返回值
  • sorted()属于暂时性排列，会产生一个新的序列

9.2.1 list.sort()

  1. 语法：

list.sort(key=None, reverse=False)

  1. 参数
  • key -- 主要是用来进行比较的元素，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序
  • reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）

9.2.2 sorted()

  1. 语法：

sorted(iterable, cmp=None, key=None, reverse=False)

  1. 参数
  • iterable是可迭代对象，包括列表、元组、字典、字符串
  • 返回的是List！！
  • cmp代表比较函数
  • key代表迭代对象中的某个属性，如某个元素的下标
  • reverse代表升序或者降序
  1. 例子
  • 对部分元素进行排序
arr = [2,1,3]
temp = sorted(arr[:2]) # 记得切片不包括末尾下标
arr[:2]=temp
# 结果 arr = [1,2,3]

9.3 lambda函数

  1. 语法形式
    lambda [arg1 [,arg2,…argn]]:expression
    其中，
  • lambda是关键字；
  • [arg…] 是参数列表,可以是多个，也可以是一个；
  • expression 是一个参数表达式，表达式中出现的参数需要在[arg…]中有定义，并且表达式只能是单行的，只能有一个表达式
  1. lambda函数是没有名字的；
  2. 输入是传入到参数列表[arg1 [,arg2,…argn]]的值，输出是根据表达式expression计算得到的值
  3. 与sort函数结合
  • 对列表进行排序需要用到参数key时，也就是关键词
  • 做法
a = [('b', 4), ('a', 12)]
a.sort(key=lambda x: x[0])
print(a)

<br>>>>[('a', 12), ('b', 4)]
  • 理解：
    • lambda是一个匿名函数，是固定写法
    • x表示匿名函数的输入，即列表中的一个元素，在这里，表示一个元组
    • x只是临时起的一个名字，你可以使用任意的名字
    • x[0]表示匿名函数的输出，即元组里的第一个元素，即key = x[0]
    • 这句命令的意思就是按照列表中第一个元素进行排序

9.4 all()、any()

  1. all()

用于判断给定的参数所有元素是否都为True，如果都为True则返回True，否则返回False

  • 0、‘ ’、None、False外都算True
  • 空元组、空列表返回值为True
print(all(['a','b','b'])) # True
print(all(['','b','b']))  # False
  1. any()

用于判断给定的可迭代参数 iterable 是否全部为 False，如果都为False，则返回 False，如果有一个为 True，则返回 True（只要有一个True就是True）

print(any(['a','b','b'])) # True
print(any(['','b','b']))  # True

9.5 bin()、oct()、chr()、ord()

  1. bin()
     返回一个整数 int 或者长整数 long int 的二进制表示，返回值是字符串

    bin(10) # '0b1010'

  2. oct()

    将一个整数转换成 8 进制字符串，前缀是0o

    oct(10) # '0o12'

  3. chr()

    chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的ASCII字符

    chr(97) # a

  4. ord()

    以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，是一个十进制整数

    ord('a') # 97

9.6 sqrt()、round()、modf()

  1. sqrt()
    • 返回数字x的平方根
    • 需要 import math
    • 结果为浮点数
    • 语法： math.sqrt(x) 注意有个math
  2. round()
    • 返回浮点数x的四舍五入值
    • 语法：round( x [, n])
    • 参数： x（浮点数） n（表示小数点位数）[]的意思是可以加也可以不加
    • 例子：round(80.23456, 2) # 80.23
  3. modef()
    • 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示
    • 需要 import math
    • 语法： math.modf(x) 注意有个math
    • 返回值是一个元组，签名是小数部分，后面是整数部分（也是浮点数）
    • 例子：math.modf(100.72) #(0.71999999999999886, 100.0)

9.7 reduce()

  • reduce()函数会对参数序列中元素进行累积（累积的意思是积累，不是相乘的意思）
  • 需要 from functools import reduce
  • 语法：reduce(function, iterable[, initial])
    • 参数：
      • function -- 函数，有两个参数
      • iterable -- 可迭代对象（列表等）
      • initializer -- 可选，初始参数
    • 返回值为函数的计算结果
  • 例子
l = [1,2,3,4,5]
sum1 = reduce(lambda x, y: x+y, l)
# sum1 = 15 (1+2=3 -> 3+3=6 -> 6+4=10 -> 10+5=15)

9.8 map()

  • map()会根据提供的函数对指定序列做映射
  • 语法：map(function, iterable, ...)
    • 参数：
      • function -- 函数
      • iterable -- 一个或多个序列
    • 返回值：迭代器 eg. <map object at 0x100d3d550> 用list()转换为列表
  • map()函数不改变原有的 list，而是返回一个新的list
  • 例子：
list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))

十、 global 和 nonlocal

  1. global
  • global关键字用来在函数或其他局部作用域中使用全局变量。
  • 如果不修改全局变量也可以不使用global关键字
  • 例子
gcount = 0 
def global_test():
  global  gcount
  gcount+=1
  print (gcount)
global_test()
# 结果为 1

'''如果不修改，不用global'''
gcount = 0
def global_test():
  print (gcount)
global_test()
# 结果为0
  1. nonlocal
    nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量
posted @ 2022-06-29 15:30  要兵长还是里维  阅读(73)  评论(0)  编辑  收藏  举报