这篇文章主要介绍了高中生学python从哪里学起，具有一定借鉴价值，需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获，下面让小编带着大家一起了解一下。
目录
一：数据类型及定义
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:
break2）输出
类似与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) #输出19for语句
这里先提到一个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)
某函数()像这样以@的形式表示闭包，就是函数装饰器。
1692
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
