高中python语言常用语句,高中python例题和答案

目录

一：数据类型及定义

二：输入与输出

1）输入

python实现一行多个数据输入

Python实现多组输入 

2）输出

三：运算操作符

基础操作符

比较操作符

逻辑操作符

优先级

四：分支语句if

五：循环语句while，for

while语句

for语句

六：序列

1）列表（数组list）

列表常用库函数

2）元组（tuple)

3）字符串（str）

4）字典（dict）

字典常用库函数

5）集合（set）

序列切片操作

序列的运算

序列常用库函数

1）序列之间的相互转化 

2) 返回序列的最大值和最小值

3） 计量函数

4）排序和翻转

七：函数

参数形式

位置参数

关键字参数

默认参数

可变参数 （收集参数）

混合参数

函数闭包

闭包概念

闭包调用

闭包意义

---

一：数据类型及定义

python基础的数据类型只有int ， float ， string(python中简称str) ， complex（复数）以及bool类型。注意：是string而不是char

但是严格的来说：python的数据类型是有六种：数字(Number），字符串(str)，元组(Tuple)，列表(list)，字典(dict)，集合(set)

所以，可以用int(a)，float(a)，str(a)，bool(a)  将a分别强转为int类型，float类型，string类型，bool类型快码论文。

python不像c/c++，定义需要int xx；python的定义只需要写a=xxx，会根据xxx的类型自适应。

a=1       #定义a为整形,并且赋值为1
a=1.3     #定义a为浮点形,并且赋值为1.3
a="ab2ba" #定义a为字符串形,并且赋值为ab2ba
a=True    #定义a为bool形，并且赋值为True
a,b=1,2   #定义a和b均为整形,并且赋值为1,2

另外：python行末没有分号，一行只有一句话，并且没有大括号。 

isinstance(a,类型)
#检查a是否是该类型，若是返回true,若不是返回false
例如:
a=1
isinstance(a,int) #则返回true
isinstance(a,str) #则返回false

二：输入与输出

1）输入

类似于C语言的scanf() ，python的输入是input()函数，但是要注意输入的是默认为string类型。

a=input() #输入a的值(默认为string类型)

要想输入不是string类型的也可以，但是需要运用到强转：

a=int(input())   #输入整数
b=float(input()) #输入浮点数
c=bool(input())  #输入布尔值

但是对于平时我们刷题目，那种一行有多个数据的这样输入就会RE了，因为python输入完了是会自动换行的，而不是空格。 

 

python实现一行多个数据输入

那么，要想一行多个输入该怎么办呢？ 

首先，介绍一个库函数：split()。

split()函数表示对字符串进行分割。例如：

a="123242521"
b=a.split('2')# 在字符串a中以'2'为标准,进行分割
print(b)# b自动适应成列表(数组)
# b为：1 3 4 5 1
# 如果括号里面没有东西,就默认按照空格,换行,制表符进行分割。

由于input()输入的机制是默认为字符串，所以对一行进行多个输入方式如下：

a,b,c=input().split() #输入a,b,c的值(默认为string类型)

那么又怎么将输入的数据换成int类型呢？要是一行一行的去强转，那太复杂了。

这又不得不提到一个新的函数。map()。STL狂喜

map(函数，序列1，序列2.....) 它的目的是将后面的n个数(序列)，依次作用于前面的那个函数。并且返回的是迭代器，也就是地址 (STL狂喜）。

所以，要是想要输入一行整数，就可以这样：

a,b,c=map(int,input().split())# 定义a,b,c，并且输入他们的值
#其中第一个int表示int()函数,即强转为int类型
#第二个input().split()即输入的序列
#所以这个意思就是输入一些数,并且将他们都强转为int类型

但是这样是对单个数据进行输入，那怎么去对数组进行输入呢？

刚刚我们提到了，map函数返回的是迭代器，也就是地址，所以我们需要新建立一个 序列：列表 list() 去强转并接收它。即

a=list(map(int,input().split()))# 定义数组a,并输入值
#由于map返回的是迭代器,所以用list来接收,并存储。

Python实现多组输入 

python实现多组输入的方式为：

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

2）输出

类似与C语言的printf()，python的输出是print()函数。例如：

print("12345") # 输出12345
print(1+2) # 输出3
print(1.1+2.1) #输出3.2
print("1"+"2") #输出12
print(1*3) #输出3
print("1"*3) #输出111
print("\n") #输出换行

但是特别要注意，python的输出是默认自带换行的，要想不默认带换行，可以这样

print(a,end='')
print(a,end=' ')#a后面带有一个空格
print(a,end='\n') #a后面换行,当然也可以直接print(a)

如果说，要让python规定输出带有小数点位数，可以这样：

a,b=1.2,0.5
print(f"{a:.2f}") #结果为1.20
print(f"{a-b:.2f}") #结果为0.70
#其格式为：f"{参数:保留位数}"

三：运算操作符

基础操作符

python的运算符其他编程语言类似，均有+，-，*，/，%。

不过需要特别注意的是+还可以是字符串的拼接，例如："aa"+"bb"="aabb"，并且 / 是会有小数点的，也就是不会像c语言那样向下取整。如果想要向下取整，可以 // 来表示，例如：3 / 2 =1.5，3 //2 =1，同样，有 // 那也会有 **，**表示幂，例如：5**3=5*5*5=125。

有基础运算符，那必然也会有 +=，-=，*=，/=，%=，//=，**=。但是python却没有++和--。

比较操作符

比较操作符即：>，<，>=，<=，==，!= 。

逻辑操作符

c语言的逻辑操作符是&&，||，! 。而在python中则是 and，or ，not。

优先级

和其他编程语言类似，优先级为：幂 > 正负号 > 乘除 > 加减 > 比较操作符 > 逻辑运算符

四：分支语句if

在python中，if语句后面不需要括号，只需要一个冒号，然后换行对齐即可。

并且else if可以简化为elif 。例如：

if a>b :
    print(a)
    print(b)
elif b>c :
    print(b)
else :
    print(c)

但是 python 有其独特的三目运算符，不再像C语言那样的 ? :

python的三目运算符为：

maxn=b if b>c else c #即 maxn=a>b?a:b;即maxn=max(a,b);

五：循环语句while，for

while语句

和if语句一样，while语句后面也不需要括号，只需要一个冒号，然后换行对齐即可。

例如：

a=1
b=1
while a<10:
    a+=1
    b+=2
print(b) #输出19

for语句

这里先提到一个range函数，range函数的本质是一个迭代器。在for循环里的用法为：

for i in range(a,b,c) :
#相当与for(int i=a;i<b;i+=c){}
#当然,range()函数也可以不用写三个参数,如:
for i in range(a,b) :
#相当于for(int i=a;i<b;i++){}
for i in range(b) :
#相当于for(int i=0;i<b;i++){}

另外，python的for循环可以遍历字符串，即

s="abcd"
for i in s:
    print(i,end=' ')
#输出为a b c d

六：序列

1）列表（数组list）

和c语言数组不同的是，python的数组叫做列表，和c++ STL的list有点类似，它是一个动态的链表，并且里面存储的可以是不同类型的数据。

arr1=[1,2,1.3,'aa',True] #定义一个列表
#甚至还可以套娃
arr2=[1,2,[1,2,3]]
arr3=[[1,2,3],[4,5,6],[7,8,9]] #定义二维列表
arr4=[[1,2,3],
      [4,5,6],
      [7,8,9]] #这样也是定义二维列表
print(arr1) #将会直接输出整个数组 [1,2,1.3,'aa',True] 

列表常用库函数

增

1）arr.append()，类似于STL的arr.push_back()，即尾插。但是只能尾插一个数据

2）arr.extend()，特别注意：extend()也可以尾插另一个列表。即：arr.extand(['a','b'])：尾插'a'和'b'两个数据。

3）arr.insert()，类似于STL的insert()，即可以在任意一个位置插入元素。用法为：arr.insert(位置，元素）同样，insert也可以插入另一个列表。例如：arr.insert(2,3) 即在第二个位置插入3这个数据。

删

1）按照位置来删除  arr.pop()

和STL的pop()不同的是，它可以选择删除的位置。用法为：arr.pop(位置)。例如：arr.pop(2) 即删除第二个位置的数据

2）按照数据来删除 arr.remove()。用法为：arr.remove(数据) 。例如：arr.remove(2) 即删除数据2 但是要注意，存在多个2的时候，删除的是第一个2

3）当然也可以使用arr.clear()一键清空。

查

列表的访问也可以直接按照下标的方式，也可以使用库函数查找下标及数量。

arr=[12,13,14,15,16]
#arr[0]=12,arr[1]=13
#arr[len(arr)-1]=16
#arr[-1]=16,arr[-2]=15
 
arr.count(数据) #查找该数据有多少个
arr.index(数据) #查找该数据的下标

改

列表的改数据，可以直接按照下标的方式进行修改

arr=[11,12,14,14,15]
arr[2]=13 #将下标为2的数据修改为13

其他库函数

arr=[14,13,19,17,15]
arr.sort() #对列表从小到大排序
arr.reverse() #将列表倒序
arr.sort(key=cmp) #按照cmp函数的方式进行排序

2）元组（tuple)

元组是一种弱化版的列表。它一旦被赋值了，就不能再做任何的修改，即增，删，改。但是元组还是可以切片的。

元组的定义方式是用小括号：

Tuple=(1,2,3,4) #定义一个元组

3）字符串（str）

字符串的库函数和列表的库函数类似。列表的库函数在字符串中同样适用，可以大致理解为字符串就是列表，只不过全是字符而已。

4）字典（dict）

“字典这个数据结构活跃在所有Python程序的背后，即便你的源码里并没有直接用到它。”

顾名思义，字典是一种类似于《字典》的数据结构(或者说序列）。例如查找 abandon 我们知道意思是 放弃 。

因此字典是一种对应的映射关系，也就是键值对，通过查找键，获取该键对应的值。

dict1={键1:值1,键2:值2...} #字典的格式

通过表示键可以获取值

num={"one":1,"two":2} #定义字典
print(num["one"]) #打印结果为1

当然，字典的表示是这样，但是定义方式却不止这一种，但是无论哪种定义方式，表示的方式只有一种。

dict1={键1:值1,键2:值2,键3:值3...} #按照表达方式定义
dict2=dict(键1=值1,键2=值2,键3=值3...) #利用dict函数强转,但是这里要注意键不管是不是str类型,都不要引号
dict3=dict([(键1,值1),(键2,值2),(键3,值3)...]) #利用dict函数以及列表的方式定义
dict4=dict(zip([键1,键2,键3...],[值1,值2,值3...])) #利用dict函数以及zip函数定义。

字典常用库函数

除了以上死板的定义方式外，还可以利用库函数：dict.fromkeys()快速创建字典

a=dict.fromkeys("123","13")
b=dict.fromkeys("123",13)
#快速创建的字典a为 {'1': '13', '2': '13', '3': '13'}
#快速创建的字典b为 {'1': 13, '2': 13, '3': 13}

增

字典可以直接添加，添加方式为： 字典名[新的键]=值。 

a={"one":1,"two":2} #定义字典
a["three"]=3 #向字典添加元素
#这时候字典为: {"one":1,"two":2,"three":3}

删

删除字典的元素需要用到函数：字典名.pop(键)  那该键值对就删除了

a={'one': 1, 'two': 2, 'three': 3}
a.pop("two")
# a为 {'one': 1, 'three': 3}

字典也有库函数：字典名.clear() 可以做到删除整个字典

查

在之前提到了，可以直接利用字典的键来查找值 

也可以利用库函数：字典名.get(键，"备注的文字") 。当没有该键的时候，返回的就是备注了

当然，字典在查找的同时还可以新增元素：字典名.setdefault(键，值)。当有键的时候返回值，当没有键的时候就新增一个键值对

字典还有三个查找的库函数：字典名.items()，字典名.keys()，字典名.values()。他们分别查找的范围是 键值对，键，值。

改

字典的修改方式可以直接修改，即：字典名[已经有的键]=新的值

a={"one":1,"two":2,"three":4} #定义字典
a["three"]=3 #修改字典
#这时候字典为: {"one":1,"two":2,"three":3}

也可以利用库函数：字典名.update(另一个字典) 进行更新修改，当然，如果原来没有键，那么将会增加新的键值对

5）集合（set）

集合就和高中或者说集合论学的那种集合一样。具有同样的性质：确定性，互异性以及无序性。

a={"12","34"} #定义集合a

序列切片操作

下面以列表的切片为例，但是字典和集合没有切片操作。

列表切片可以说是一种表示方式，可以很方便的获取一个或多个数据

列表切片的原理还是基于for循环的方式。

列表切片为：arr[a:b:c],类似于
for(int i=a;i<b;i+=c) { 
    printf("%d",arr[i]);//cout<<arr[i];
}
或者说
for(int i=a;i>b;i-=c) { 
    printf("%d",arr[i]);//cout<<arr[i];
}
会自动根据c的值采用相应方式,若c>0则是第一种,若c<0则是第二种

有时候为了方便，a的值默认为0，即当a=0的时候可以不写出，b的值默认为len(arr)，即当c=len(arr)的时候可以不写出，c的值默认为1，即当c=1的时候，可以不写出。

例如：

arr=[12,13,14,15,16,17,18]
print(arr[0:5:2]) #输出[12,14,16]
print(arr[0:3])   #输出[12,13,14]
print(arr[3:5])   #输出[15,16]
print(arr[:3])    #输出[12,13,14]
print(arr[3:])    #输出[15,16,17,18]
print(arr[:])     #输出[12,13,14,15,16,17,18]
print(arr[::2])   #输出[12,14,16,18]
print(arr[::-1])  #输出[18, 17, 16, 15, 14, 13, 12]
print(arr[6:2:-1])  #输出[18, 17, 16, 15]
print(arr[6:1:-2])  #输出[18,16,14]

之前提到插入数据是用extend或者insert函数，删除数据是pop或者remove函数。由于列表的灵活性，所以也可以采用切片的方式插入数据，删掉数据，改数据。

arr=[12,13,14,15,16,17,18]
#-------分------界------线--------
arr[len(arr):]=[19,20] #尾插[19,20]两个数据
arr[:0]=[9,10] #头插入[9和10]两个数据
arr[2:2]=[11] #在第2个位置插入11这个数据
arr[3:3]=[11,12,12] #在第3个位置插入11,12,12这三个数据
#-------分------界------线--------
arr[len(arr)-1:]=[] #尾删
arr[:1]=[] #头删
arr[3:4]=[] #删掉下标为3的数据
arr[2:4]=[] #删掉下标为2和3的数据
#-------分------界------线--------
arr[len(arr)-1]=20 #将最后一个数替换为20
arr[len(arr)-1:len(arr)]=[19] #将最后一个数替换为19
 
arr[:1]=[9] #将第一个数替换为9(下标为0)
arr[1:2]=[10] #将第二个数替换为10(下标为1)
arr[2:5]=[11,12,13] #将第三个到第5个数替换为11,12,13
 
print(arr[:])

序列的运算

下面以列表的切片为例，但是字典和集合没有运算操作。

1）加法：序列的相加，相当于字符串的拼接。

arr1=[1,2,3]
arr2=[4,5,6]
arr1+arr2 #[1,2,3,4,5,6]
tuple1=(1,2,3)
tuple2=(4,5,6)
tuple1+tuple2 #(1,2,3,4,5,6)
str1="123"
str2="456"
str1+str2 #'123456'

2） 乘法：序列的乘法也类似于字符串的拼接

arr,tuple,str=[1,2,3],(1,2,3),"123"
arr*3 #[1,2,3,1,2,3,1,2,3]
tuple*3 #(1,2,3,1,2,3,1,2,3)
str*3 #'123123123'

序列常用库函数

1）序列之间的相互转化 

list(a) #将a强转为列表形式
tuple(a) #将a强转为元组形式
str(a) #将a强转为字符串形式

所以在之前对数组进行输入的时候是这样的：

a=list(map(int,input().split()))

2) 返回序列的最大值和最小值

即max()函数和min()函数

maxn=max(a) #如果a是一个序列,则返回a中的最大值,如果是字符则对应ASC||表
minn=min(a) #如果a是一个序列,则返回a中的最小值,如果是字符则对应ASC||表

3） 计量函数

计量函数即：len()，sum()，count()

len(a) #返回a的长度,但是超过2的31次方位的数 会报错
sum(a) #将序列中的数全部加起来,也就是求和
#例如sum([1,4,7])=12
sum(a,start=y) # 求和之后再加个y
a.count(y) #count在前面提到过，即在序列a中查找y有多少个

4）排序和翻转

排序函数：sorted(a,key=函数) a代表序列，key代表方式。如果没有key则默认从小到大排

翻转函数：reversed(a) a代表序列

但是不管之前是什么序列，返回的结果统一会变成列表

特别注意：之前提到了a.sort()，a.reverse() 这里的a只能是列表

七：函数

类似于C的函数，C是void 而python则是def。

#函数的模板为：
def 函数名(形式参数):
    函数内容
    #return 可以有return也可以没有
函数名(实际参数)#调用该函数

特别注意的是，这里函数的参数，没有int等的定义，会根据传入的参数自适应。 

#斐波那契递归
def f(a):
    if a==1 or a==2: return 1
    else: return f(a-1)+f(a-2)
 
a=int(input()) #输入a
print(f(a)) #调用函数并输出

参数形式

位置参数

位置参数就和我们所理解的函数概念一样，也就是形式参数与实际参数在数量和位置上必须一一对应。

关键字参数

关键字参数是利用形参的名字来输入实参。关键字参数和位置参数不同的是：关键字参数的位置可以不用一一对应，只要将参数名写正确即可。

def fun(a,b):
    print(a+"  "+b)
fun("123","321") #位置参数
fun("123",b="321") #关键字参数
fun(b="123",a="321") #关键字参数
# 运行结果为: 123  321
#            123  321
#            321  123

 但是要注意的是，关键字参数必须在位置参数的后面。而位置参数是要对应的。

默认参数

默认参数是指在定义函数的时候，就已经给形式参数一个初始值(默认值)，所以叫默认参数。当然后续的实参可以修改已经有了的初始值。

也就是说有了默认参数以后，就不用像位置参数那样数量对应了，例如一个函数有4个参数，其中2个默认参数，那么实参只需要至少2个，至多4个就行。

def fun(a,b,c="234",d="432"): #其中c和d即为默认参数
    print(a+"  "+b+"  "+c+"  "+d)
fun("123","321") 
fun(b="123",a="321")
fun("123","321","324")
# 运行结果为: 123  321  234  432
#            321  123  234  432
#            123  321  324  432

可变参数 （收集参数）

这个和指针有点类似。函数的形式参数是带有*号的。

def fun(*args):
    print(args)
fun(1,2,3,4,5)
# 输出结果为 (1, 2, 3, 4, 5) 注意是元组

也就是说，当形参带有*号，那么传入的数据将以元组的形式储存。

这种情况，如果说形式参数还有其他的数据。那么必须以关键字参数的形式传入，不然全部均储存在args中

def fun(*args,b):
    print(args,b)
fun(1,2,3,4,5,b=6)
# 输出结果为 (1, 2, 3, 4, 5) 6
# 注意b是int类型并非元组
fun(1,2,3,4,5,b=tuple(str(6))) #输出为 (1, 2, 3, 4, 5) ('6',)
# 由此可见，args是独立的

同样的，函数也可以一次性返回多个值，当返回多个值的时候将以元组形式暂时储存。

def fun():
    return 1,2,3,4,5
a=fun()
print(a) #输出结果(1, 2, 3, 4, 5)

不仅如此，可变参数也可以有两个*号，即**kwargs  这个时候储存的结果就是字典了

def fun(**kwargs):
    print(kwargs)
fun(a=1,b=2,c=3)
# 输出结果为: {'a': 1, 'b': 2, 'c': 3}

混合参数

混合参数即上述的各类参数形式可以混合使用，但是要注意先后顺序：位置参数-->可变一维参数(*args)-->默认参数-->关键字参数-->可变二维参数(**kwargs)

def fun(a,b,*c,d="100",e="100000",f,**g):
    print(g)
    print(f)
    print(e,d)
    print(c,b,a)
fun(1,2,3,4,5,6,d=7,f=8,g=9,h=10,i=11)
# 打印结果为 {'g': 9, 'h': 10, 'i': 11}
#           8
#           100000 7
#           (3, 4, 5, 6) 2 1

函数闭包

闭包概念

闭包就是能够读取其他函数内部变量的函数。例如在java中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。

def 外部函数():
    def 内部函数():
        print(123)
    return 内部函数 #<----这里划重点,是返回名字而不是函数
#像这样就是闭包函数

闭包调用

闭包是外部函数 返回 内部函数。所以按照正常的想法，我们调用外部函数，会返回内部函数，从而执行内部函数。然而我们直接打

外部函数() #这样去调用外部函数

实际上没有效果。因为在之前，是return的内部函数的名字，而不是函数。所以直接调用没有用。

那该怎么去调用呢？

def 外部函数():
    def 内部函数():
        print(123)
    return 内部函数
fun=外部函数() #在这里,运行代码,实际上就是fun=内部函数
fun() #所以这里实际上就是内部函数(),于是就完成了调用

像这样，再起一个函数fun让他等于外部函数() 然后调用fun()才行。

闭包意义

闭包的意义是减少调用的参数数量。

例如：输出x+y。当y都是同样的值的时候，每次调用还需要输入y，这样就显得麻烦。

def fun(x,y):
    print(x+y)
fun(x1,y)
fun(x2,y)
fun(x3,y)

利用闭包，可以先储存y的值，然后每次只需要调用x就行。

def 外部函数(y):
    def 内部函数(x):
        print(x+y)
    return 内部函数
fun=外部函数(y)
fun(x1)
fun(x2)
fun(x3)

闭包会让程序变得更简洁易读

函数装饰器

设想一下，有没有一种可能，我们可以把某个函数作为另一个函数的参数进行调用。

那答案是肯定的。

def 另一个函数(func):
    func(2,3)
def 某函数(a,b):
    print(a*b)
 
另一个函数(某函数)
#像这样,结果就是6

如果我们以闭包的形式，让闭包的参数是某函数，写一段代码：

import time
def 外部函数(func):
    def 内部函数():
        start=time.time()
        func()
        end=time.time()
        print(f"函数调用的时间是{end-start:.10f}秒")
    return 内部函数
def 某函数():
    time.sleep(2)
 
fun=外部函数(某函数)
fun() #结果自然是2.xxxxxxxxx秒,会根据电脑不同后面数值不同。

当然，这是一种闭包的情况，假设说有多个闭包，都是调用该函数，那我们岂不是要打多行代码去调用闭包了？

实际上可以将上述代码简化如下：将fun=外部函数(某函数)删去，改为@外部函数，写在定义函数的前面。

这时候直接调用某函数，会自动进行闭包。

import time
def 外部函数(func):
    def 内部函数():
        start=time.time()
        func()
        end=time.time()
        print(f"函数调用的时间是{end-start:.10f}秒")
    return 内部函数
 
@外部函数
def 某函数():
    time.sleep(2)
某函数()

当然也可以写多个@

import time
def 外部函数1(func):
    def 内部函数():
        start=time.time()
        func()
        end=time.time()
        print(f"函数调用的时间是{end-start:.7f}秒")
    return 内部函数
def 外部函数2(func):
    def 内部函数():
        start=time.time()
        func()
        end=time.time()
        print(f"函数调用的时间是{end-start:.10f}秒")
    return 内部函数
    
@外部函数2
@外部函数1
def 某函数():
    time.sleep(2)
某函数()

 像这样以@的形式表示闭包，就是函数装饰器。