Python语法基础

蓝桥杯竞赛python评测机1s可以跑8e7 

1.输入

a,b=input().split() #一行两个数输入的情况
x1,y1=map(float,input().split())#如果想要直接确定类型，可以用map

a=input() #一行一个数，占两行
b=input()

r=float(input()) #输入浮点数

a = list(map(int, input().split()))#读入一个int型的一维数组

a = []  #读入一个二位数组
for i in range(row):
    a.append(list(map(int, input().split())))


3 4 3
xo.x
..o.
xx.o
输入上述情况的
a=[[]]
for i in range(h):
    a.append([0]+list(input()))
表示横纵下标都从1开始的二维数组

2.输出

print("A=%.4f"%(pi*r*r)) #保留4位小数

print("Em percentual: %d %%"%(e));
print("Em percentual: {} %".format(e)); #e是一个数字，等价于上边那个
#上边那个需要%%进行转义，都是用来表示%
print("Em percentual: {} {}%".format(e，"sdasd"));#也可以是字符串
print("The value is: {:.2f}".format(value))#这个可以确定小数点的位数

3.精度

1.float只有15位有效数字

2.如果需要更大的需求可以用decimal

from decimal import Decimal, getcontext

getcontext().prec = 50  # 设置精度为 50 位
x = Decimal('1.23456789012345678901234567890')
print(x)  # 输出: 1.23456789012345678901234567890

4.运算法则

3**2 #3的平方
3/2 #3除以2 浮点数
3//2 #3整除2

5.标准库 

1.math库

import math

math.gcd()#求最大公约数

python的内置库

        sort()

a=list(map(int,input().split()))
a.sort()#升序排序

a=list(map(int,input().split()))
a.sort()
a.reverse()#降序排序

如果需要对一部分排序，可以把那一部分通过切片操作单拎出来
单独对那一部分进行sort排序，再把原列表中的值代替掉

6.循环

for i in range(a - 1, 0, -1) #range(起始位置，终止位置，步长)

7.列表

a=[int(input()) for i in range(10)]#往列表中输入数据
a=[list(map(float, input().split())) for i in range(12)]#二位数组中输入值
#可以看为一个二维数组，索引a[i][j]
a=[c for c in input()]#把字符串变为可以索引的字符串！！！

a=[0]*11 #创建一个列表，相当于创建一个长度为11，里边的值全为0的数组，
#需要注意的是必须的先创建确定长度的列表，才能通过下标进行索引，然后修改

a=[[] for i in range(5)]
for i in a:
    i.extend(3*[0])
#创建一个特定长度的二维列表
#上述结果： [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

res=[ [0 for j in range(m)] for i in range(n)]#创建一个n×m的二维数组，全为0
for i in res:#需要这样遍历
    for j in i:
        print(j,end=" ")
    print()

a.append() #在列表后边加上一个数，和c++的vector的push_back()差不多

创建数组

二维数组
a=[[0 for i in range(m+1)] for j in range(n+1)]#nxm的二维数组

列表的排序 

`list` 类型的对象在 Python 中有一个 `sort()` 方法，
用于对列表进行原地排序（即改变原列表而不返回新的列表）。
`sort()` 方法默认使用元素的自然顺序进行排序。
以下是一个简单的例子：

```python
# 创建一个列表
my_list = [4, 1, 8, 3, 6]

# 使用 sort() 方法对列表进行排序（默认是升序）
my_list.sort()

print(my_list)
```

上述代码会输出：

```
[1, 3, 4, 6, 8]
```

如果你想进行降序排序，可以使用 `reverse` 参数：

```python
# 创建一个列表
my_list = [4, 1, 8, 3, 6]

# 使用 sort() 方法对列表进行降序排序
my_list.sort(reverse=True)

print(my_list)
```

上述代码会输出：

```
[8, 6, 4, 3, 1]
```

需要注意的是，`sort()` 方法是原地排序，
会改变原列表。如果你想创建一个新的排序后的列表而不改变原列表，
可以使用 `sorted()` 函数：

```python
# 创建一个列表
my_list = [4, 1, 8, 3, 6]

# 使用 sorted() 函数创建一个新的排序后的列表
sorted_list = sorted(my_list)

print(sorted_list)
print(my_list)  # 原列表不变
```

上述代码中，`sorted()` 函数返回一个新的已排序列表，而不改变原列表。

8.字符串操作

s = input()
c = input()
s.replace(c, "#")#把s字符串中的c字符全部换位"#"

from sys import stdin #从sys中导入stdin


str=''#创建一个空字符串
str+=t#逐个添加字符t

readline()

import sys  
str=sys.stdin.readline()#会读取行末的换行
str=sys.stdin.readline().strip()#去掉行末的换行,一般使用readline时一定要加上strip
a,b=sys.stdin.readline().strip().split() #读入一行的多个字符串
print(str)

readlines() 需要读入多行字符串时

import sys  
str=sys.stdin.readlines()

for i in str:
    a,b=line.strip().split()#将字符串去掉行末的换行符并分隔开
    
    print(i.strip())#去掉行末的换行，因为readlines会读如换行

输入：
abcab eee
12343 555
输出：
abcab eee
12343 555

readlines()的使用：字符串的插入

chr()   ord()

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

2、ord()函数是chr()函数（对于8位的ASCII字符串）的配对函数，它以一个字符串（Unicode字符）作为参数，返回对应的ASCII数值。

chr('a')
#a的ascall码  97

ord(97)
#代表'a'

split()

split()#默认以空格将字符串分隔开

s=Hello      world.This is    c language.

for word in s.split():
    print(word, end=' ')#每次循环的word以空格分隔开

输出为：Hello world.This is c language.

for i in s.split('.'):#也可以以.作为分割符
    print(i)

输出为：
Hello      world
This is    c language

reverse()

s=input()# s=I am a student
a=s.split()#将s划分为一个列表
           #输出a的结果为['I', 'am', 'a', 'student']
a.reverse()
#然后再依次打印a列表  
for i in a:
    print(i,end=' ')#student a am I 

9.函数

def print1D(a, size):  #a为1个列表，size为一个整数
                       #需要用到a时，可以直接传过去，不需要变量类型

10.set

会自动删除重复元素

s=set()      #定义一个set容器，set是python内置容器
s.add()      #向容器内添加内容
s.discard()  #删除容器中的元素 s.discard(0)就是删除容器中的0

if x in s:  #查询x是否在s中
    print("yes")
if d[i] not in s:#如果d[i]不在s中，首先要先给s[d[i]]赋0，后续才能使用
        s[d[i]]=0

11.字典

dic={}#创建一个空字典

dic.get(key, default)  #返回键key所对应的值，如果没有此键则返回default

dic = {5: '555', 2: '222', 4: '444'}
print(sorted(dic))		#默认根据键排序 [2, 4, 5]
print(sorted(dic.values()))     #根据值排序 ['222', '444', '555']
print(sorted(dic.items()))      #根据键排序 [(2, '222'), (4, '444'), (5, '555')]

#删
dic5 = {'name': 'hh', 'age': '20', 'hobby': 'girl', 'school': '北大'}
del dic5['name']        #删除键是name的条目
print(dic5)

red = dic5.pop('hobby')       #通过pop删除键是hoppy的条目，并返回删除的值
print(red)
print(dic5)

dic5.clear()        #清空字典
print(dic5)

del dic5        #直接删除字典


#改
dic4 = {'name': 'cgk', 'age': '20', 'hobby': 'girl'}
dic5 = {1: "1", 'age': "30"}
dic4.update(dic5)       #把dic5加进dic4里面，如果有重复的键，则覆盖
print(dic4)

字典的排序

a = list(cnt.items())
a.sort(key=lambda item: (-item[1], item[0]))  # 双关键字排序

for k, v in a:
    print(k, v)

data = [('apple', 3, 50), ('banana', 2, 30), ('kiwi', 1, 20), ('orange', 2, 40)]

data.sort(key=lambda item: (-item[1], item[2], item[0]))#三关键字排序

print(data)
'''

1. `cnt` 应该是一个字典（dictionary），其中包含了一些元素的计数信息。
2. `cnt.items()` 将字典 `cnt` 转换为一个包含键值对的列表，其中每个元素是一个元组 `(key, value)`，表示字典中的键和对应的值。
3. `a = list(cnt.items())` 将得到的列表赋值给变量 `a`。

现在，对列表 `a` 进行排序。排序的规则是按照元组的第二个元素（值）降序排列，如果值相同，则按照元组的第一个元素（键）升序排列。这是通过 `a.sort(key=lambda item: (-item[1], item[0]))` 实现的。

- `key=lambda item: (-item[1], item[0])` 定义了排序的规则。这里使用了一个 lambda 函数，它接受一个元组 `item`，并返回一个包含两个元素的元组。第一个元素是 `-item[1]`，表示按照值的降序排列，第二个元素是 `item[0]`，表示按照键的升序排列。
- `-item[1]` 表示取值的负数，这样可以实现降序排列，因为默认是升序排列。

最终，列表 `a` 将按照指定的排序规则进行排序。
'''

12.空

head.next = None

13、常用函数

内置函数

bin(n)#可以将10进制转为2进制 bin(8)=0b1000 前面会多一个0b bin(10)=0b1010
y=x[::-1]#逆序完之后会变为“0001b0” “0101b0”
 

deque

from collections import deque
 
# 创建一个空的deque
d = deque()
 
# 向deque中添加元素
d.append(1)
 
# 在左侧添加元素
d.appendleft(0)
 
# 弹出最右侧的元素
d.pop()
 
# 弹出最左侧的元素
d.popleft()
 
# 将deque中的元素转换为列表
list_d = list(d)
 
#索引对头
d[0]

#索引队尾
d[len(d)-1]

print(d)  # deque([1, 2])
print(list_d)  # [1, 2]

int()

1. 整数较小时： 如果字符串表示的整数长度较短，那么 int() 函数的时间复杂度可以视为 O(k)，其中 k 是字符串的长度。

2. 整数较大时： 当字符串表示的整数非常大时，int() 函数的时间复杂度可能会更高，取决于整数的大小。在这种情况下，时间复杂度可能会接近 O(n)，其中 n 是整数的位数。

循环里一般不要用int这个函数，会增加时间复杂度

14、slove

如果想要把一个字符串放到列表里

 直接放list里

a=list("hello")
print(a)#['h','e','l','l','o']


string_example = "12345"
list_result = [int(char) for char in string_example]
print(list_result)#[1, 2, 3, 4, 5]

m=input()
str=list(int(i) for i in m)
print(str)

original_list = [1, 2, 3, 4, 5]
modified_list = [0] + original_list#在列表前加一个0