devbox
代码探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python语法入门

作者：代码探险家 | 2024-08-13 06:08:18

赞

踩

python语法入门

 Python语言是比C和C++语言更高级的语言，Python不像C/C++那样，Python有系统自带的大整数模式，而且Python没有那么多的头文件，其中的一些模块使用起来比C/C++方便,本篇将会概述Python的一些入门,包括一些基本的块、数据类型、函数的使用等。

目录

一.输入和输出

1.字符串的读入

2.字符串定义时读入

3.整型的读入

4.浮点数的读入

 二.模块的应用

1.math模块

2.random模块

3.string模块

三.数据类型

1.列表

(1).声明一个列表，并使用下标访问元素。

（2).访问第一个元素

(3).列表的查询

(4).列表的添加

(5).列表的修改

(6).列表的切片

(7).列表的排序

2.元组(Tuple)

(1)元组的截取 

(2).元组的一些函数

(3).元组的拆包和装包

3.字典(Dict)

(1).定义一个空字典

(2).初始化

(3).定义一个字典，之后添加元素

(4).修改字典元素

(5).字典相关函数

(6).字典的删除

四、六种最基础的数据类型

1.type

2.数字类型

2.1.int类型(py中不用定义类型，可以直接用)

2.2.py浮点型只有float

2.3.complex复数类型

3.运算符

4.蛇形取名法

5.大驼峰小驼峰取名法

五、字符串string

1.python没有char类型

2.字符串的一些操作

3.字符串的切片

4.变量的赋值,多变量赋值

六、基本序列

1.列表list补充

2.集合

3.字典

七、强制转换与输入输出处理

1.字符串和整型数字

2.list和set

3.基本输入输出处理

4.判断语句的用法

4.1 单分支if语句

4.2双分支if-else语句

4.3多分支if-elif语句

5.比较运算符

6.循环语句

6.1 for语句和while语句

6.2并行遍历

八、序列精讲

1.索引  list[i]

2.切片

3.拼接

4.乘法

5.clear()操作

6.浅拷贝

7.深拷贝

8.count(x)

9.extend

10.index(l,r,x)

11.pop()

12.remove(x)

13.reverse

14.sort

15.sorted

16字符串转换list

17.set()

18.dict():字典

19.len()

20.列表可以进行乘法

21.列表的迭代

22.max():最大值

23.min():最小值

24.range(start,end,step)

25.dict 字典

26.字符串

九、函数

基础函数⽤法

1.基本格式

2.函数参数

3.函数的说明⽂档

4.函数的返回值

5.变量作⽤域

6.参数拓展

十、高级函数的用法

1.Python函数是可以嵌套。

2.lambda表达式

3.闭包

4.装饰器

5.⽣成器

一.输入和输出

1.字符串的读入

  1. a=input()
  2. print(a)
'
运行

2.字符串定义时读入

  1. a='Hello World'
  2. print(a)
'
运行

3.整型的读入

  1. a=int(input())
  2. print(a)
'
运行

4.浮点数的读入

float型：

  1. a=float(input())
  2. print(a)
'
运行

double型

  1. a=float(input())
  2. print(a)
'
运行

 二.模块的应用

1.math模块

  1. import math
  2.  
  3. print(math.ceil(4.1)) #返回数字的上入整数 5
  4. print(math.floor(4.9)) #返回数字的下舍整数 4
  5. print(math.fabs(-10)) #返回数字的绝对值 10
  6. print(math.sqrt(9)) #返回数字的平方根 3.0
  7. print(math.exp(1)) #返回e的x次幂 2.718281828459045
'
运行

2.random模块

随机生成一个[0,1)范围的实数

  1. import random
  2. ran=random.random()
  3. print(ran)
'
运行

当使用random.seed(x)设置好种子之后，random()生成的随机数将会是同一个

  1. print("----设置随机种子----")
  2. random.seed(10)
  3. print("Random number with seed 10:",random.random())

3.string模块

输出：分成单引号、双引号、三引号。

  1. print('Hello World')
  2. print("Hello World")
  3. print('''Hello World''')
'
运行

字符串的连接

使用加运算符

  1. str1="Hello "
  2. str2="World"
  3. print(str1+str2) #Hello World
'
运行

使用join 运算符

  1. a='-'.join('Hello')
  2. print(a) #H-e-l-l-o
'
运行

三.数据类型

1.列表

(1).声明一个列表，并使用下标访问元素。

  1. names=['jack','tom','tonney','superman','jay']
  2.  
  3. print(names[0]) #jack
  4. print(names[1]) #tom
  5.  
  6. #访问最后一个元素
  7. print(names[-1])
  8. print(names[len(names)-1])
'
运行

（2).访问第一个元素

  1. print(names[-5])
  2. print(names[0])

(3).列表的查询

第一种方法：

  1. flag=0
  2. for name in names:
  3.     if name=="supperman":
  4.         print("有超人")
  5.         flag=1
  6.         break;
  7. if flag==0:
  8.     print("无超人")

第二种方法：

  1. if "supperman" in names:
  2.     print("有超人")
  3. else:
  4.     print("无超人")

(4).列表的添加

append():在列表尾追加元素。

  1. girls=[]
  2. girls.append('Hello')
  3. print(girls) #Hello
'
运行

extend():合并列表。

  1. a=['Hello','World']
  2. girls.extend(a)
  3. print(girls) # ['Hello','Hello',World']

insert():在指定位置添加。

  1. girls.insert(1,'happy')
  2. print(girls) #['Hello','happy','Hello','World']

(5).列表的修改

  1. fruits=['apple','pear','香蕉','pineapple','草莓']
  2. fruits[-1]='strawberry'
  3. print(fruits) #['apple','pear','香蕉','pineapple','strawberry']
'
运行

(6).列表的切片

  1. #[]中设置要使用的第一个元素和最后一个元素的索引，牢记左闭右开
  2. animals=['cat','dog','tiger','snake','mouse','bird']
  3. #     正向索引 反向索引
  4. # cat  0        -6
  5. # dog  1        -5
  6. #tiger 2        -4
  7. #snake 3        -3
  8. #mouse 4        -2
  9. #bird  5        -1
  10.  
  11. print(animals[2:5]) #tiger snake mouse
  12. print(animals[-1:]) #bird
  13. print(animals[-3:-1] #snake mouse
  14. print(animals[::2]) #从0开始，步数为2 ，cat,tiger,mouse
  15. print(animals[-5:-1:2]) #从[-5,-1)的下标索引中，步数为2，dog snake

(7).列表的排序

生成10个不同的随机数，存放在列表中，并进行排序

  1. import random
  2.  
  3. a=[]
  4.  
  5. i=0
  6. while i<10:
  7.     ran=random.random(1,20)
  8.     if ran not in a:  #使列表中的随机数不重复
  9.         a.append(ran)
  10.         i+=1
  11. print(a)
  12.  
  13. #默认升序
  14. b=sorted(a)
  15. print(b)
  16.  
  17. #降序
  18. b=sorted(a,reverse=True)
  19. print(b)

2.元组(Tuple)

与列表类似，区别是元组中的内容不可以修改。

注意·：元组中只有一个元素时，需要在后面加逗号。

  1. import random
  2. random_list=[]
  3. for i in range(10):
  4.     ran=random.randint(1,20) #[16,19,7,15,16,9,6,2.17]
  5.     random_list.append(ran)  #(16,19,7,15,16,9,6,2,17)
  6. print(random_list)
  7.  
  8. random_tuple=tuple(random_list)
  9. print(random_tuple)
'
运行

(1)元组的截取 

  1. print(random_tuple[0]) #16
  2. print(random_tuple[-1]) #17
  3. print(random_tuple[1:-3]) #(19,1,7,15,16,9,)
  4. print(random_tuple[::-1]) #(17,2,6,9,16,15,7,1,19,16)

(2).元组的一些函数

  1. print(max(random_tuple)) #19
  2. print(min(random_tuple)) #1
  3. print(sum(random_tuple)) #108
  4. print(len(random_tuple)) #10

(3).元组的拆包和装包

  1. #元组个数与变量的个数相等
  2. t3=(1,2,3)
  3.  
  4. #将元素赋给a,b,c
  5. a,b,c=t3
  6.  
  7. print(a,b,c) #1 2 3
  8.  
  9. #元组个数与变量的个数不相等
  10. t4=(1,2,3,4,5)
  11.  
  12. #将t4[0],t4[1]分别赋给a,b;其余元素封装好赋给c
  13. a,b,*c=t4
  14. print(a,b,c) #1 2 [3 4 5]
  15. print(c) [3,4,5]

3.字典(Dict)

(1).定义一个空字典

dict2={}'
运行

(2).初始化

  1. dict2={'name':'Hello','weight':45,'age':25}
  2. print(dict2['name']) # Hello 
'
运行

(3).定义一个字典，之后添加元素

  1. dict4={}
  2. dict4['name']='Hello'
  3. dict4['weight']=43
  4. print(dict4)
'
运行

(4).修改字典元素

dict4['weight']=44

(5).字典相关函数

items()

  1. dict5={'A':165,'B':166}
  2. print(dict5.items())
  3.  
  4. for key,value in dict5.items():
  5.     if value>165:
  6.         print(key) #'B'
'
运行

keys()

  1. names=dict5.keys()
  2. print(names) #'A','B'

values()

  1. height=dict5.values()
  2. print(height)
  3. total=sum(height)
  4. avg=total/len(height)
  5. print(avg) #165.0

(6).字典的删除

  1. del:
  2.  
  3. dict6={'A':1,'B':'2','C':3,'D':4}
  4. del dict6['A']
  5. print(dict6) #B:2 C:3 D:4
  6.  
  7. pop:
  8.  
  9. result=dict6.pop('B')
  10. print(dict6) #C:3 D:4

四、六种最基础的数据类型

1.type

type(变量):可以返回变量的数据类型

  1. a=10
  2. print(type(a))#打印a的数据类型
'
运行

2.数字类型

2.1.int类型(py中不用定义类型，可以直接用)

a=10'
运行

2.2.py浮点型只有float

  1. a=1.00
  2. print(a)
  3. print(type(a))
'
运行

2.3.complex复数类型

类似于高中学过的复数

注意:j前面的虚部数字一定要写,不然会报错

  1. x=1+1j
  2. print(x)
  3. print(type(x))
'
运行

3.运算符

(1)除法

/:返回一个浮点数

//:返回一个整数,相当于整除

  1. a=2
  2. b=1
  3. print(a/b) #返回的是一个浮点数
  4. print(a//b) #返回的是一个整数
'
运行

(2)取余:%

  1. a=1
  2. b=2
  3. print(a%b)
'
运行

(3)乘法

  1. a=2
  2. b=3
  3. print(a*b)
'
运行

(4)乘方

  1. a=2
  2. b=3
  3. print(a ** b) #2^3
'
运行

4.蛇形取名法

name_and_sex

5.大驼峰小驼峰取名法

#NameAndSex

首字母大写

五、字符串string

1.python没有char类型

单引号和双引号甚至三引号都可以表示字符串

  1. a='123456'
  2. b="123456"
  3. c="""123456"""
  4. #a和b和c相等
  5. print(a,b,c)
'
运行

2.字符串的一些操作

  1. s="i love py"
  2.  
  3. print(s.title())#给每个单词首字母大写
  4. print(s.upper())#把所有字母变成大写
  5. print(s.lower())#把所有字母变成小写
  6.  
  7. a = ",too"
  8. print(s+a)#拼接
  9.  
  10. sn=f"i {a} love py"#插入字符串
  11.  
  12. #'\n'表示换行
  13.  
  14. print(1,end='123')
  15.  
  16. s=r'\n'#取消所有的转义字符
  17.  
  18. #给字符串删除一些空白
  19. s='    1234     '
  20. print(s.strip())#去除头尾空格
  21. print(s.lstrip())#去除左边的空格
  22. print(s.rstrip())#去除右边的空格
'
运行

3.字符串的切片

  1. s="aabbccdd"
  2. #切片
  3. #print(s[头下标:尾下标+1:步长])
  4.  
  5. print(s[0:8:1]) #aabbccdd
  6. print(s[0:8:2]) #abcd
  7. print(s[7::-1]) #ddccbbaa 从左往右切片
  8. print(s[7::-2]) #dcba
'
运行

字符串不能进行更改。

4.变量的赋值,多变量赋值

  1. x=1
  2. y=2
  3. z=3
  4.  
  5. x,y,z=1,2,3
'
运行

六、基本序列

1.列表list补充

相当于c\c++里面的数组

  1. List = []   #空列表
  2. print(List)
  3. List = [1,2,3]
  4. print(List)
  5. print(type(List))
  6.  
  7. #列表的切片
  8. print(List[0:2:]) #[1,2]
  9. print(List[1])
  10.  
  11. #修改
  12. List[1]=3
  13.  
  14. #list里面可以套list
'
运行

2.集合

  1. #集合的性质:
  2.     #互异性
  3.     #无序性
  4.  
  5. L1={1,2}
  6. L2={2,1}
  7.  
  8. if L1==L2:
  9.     print("ok")
  10. else:
  11.     print("no")
  12.  
  13. #集合set和list的转换
  14. b=[1,1,2,3,4]
  15. b=set(b) #用于去重
  16.  
  17. a={1,2,3,4}
  18. a.clear()
  19. a.pop()
  20. a.add()
  21. a.update()
  22. a.remove()

3.字典

  1. #字典 相当于哈希表
  2. #定义一个空字典
  3. d={} #空字典
  4.  
  5. #元素类型键值对 key:value
  6.  
  7. d={'name':'zsy','sex':'male','qq':1110012}
  8.  
  9. print(d['name']) #zsy
  10.  
  11. print(d.get('name')) #通过键取值
  12.  
  13. d.pop('qq') #通过键删除
  14.  
  15. print(d.keys()) #获取所有的键
  16. print(d.values()) #获取所有的值
  17. d['nmae']='li' #修改
'
运行

七、强制转换与输入输出处理

1.字符串和整型数字

  1. a=1
  2. print(str(a))
  3.  
  4. a='110'
  5. print(a) # '110'
  6. print(int(a)) # 110
'
运行

2.list和set

  1. L=[1,1,2,3]
  2. L=set(L)
  3. print(L) #123
'
运行

3.基本输入输出处理

对输出的字符串进行追加处理：

  1. names=['zsy','wq']
  2.  
  3. print(f'hello {names[0]}')
  4.  
  5. print("hello {0},{1}".format(names[0],names[1]))
'
运行

基本的输入输出处理，和C++类似：

  1. #和C语言类似的格式化输出
  2. print("%d %f"%(5,1.0))
  3. print("%8d %f"%(5,1.0))
  4. print("%-8d %f"%(5,1.0))
  5. print("%s"%('zsy'))
  6. print("%.2f"%(5.223))
'
运行

4.判断语句的用法

4.1 单分支if语句

  1. #3.判断语句 True,False
  2. #被视为假的:False,0,None,"",[],(),{}
  3. #单分支if语句,必须要缩进
  4. #if 条件表达式:
  5. #   执行语句
  6. a=10
  7. if a>0:
  8.     print(True)
'
运行

4.2双分支if-else语句

  1. a=10
  2. if a==0:
  3.     print(False)
  4. else:
  5.     print(True)
'
运行

4.3多分支if-elif语句

  1. b=1
  2. if b==3:
  3.     print('y')
  4. elif b==1:
  5.     print('n')
'
运行

5.比较运算符

  1. #>,<,>=,<=,==,!=
  2. #is,is not,in,not in
  3. #is:双目运算符，必须两个变量值和对象都一样，才为真
  4. #is not:和is相反
  5. #in:判断一个是否在另一个中
  6.  
  7.  
  8.  
  9. a=1 #int
  10. b=1.0 #float
  11. #is不仅仅要求值一样，类型也要一样
  12. if a is b: #如果换成==，输出的是y,因为==比较的仅仅是值，而is不仅比较值，而且还有类型，只有全部相同，才是一样
  13.     print('y')
  14. else:
  15.     print('n')
  16.  
  17. #&:逻辑和 相当于and
  18. #|:逻辑或，相当于or
  19. #not:逻辑非
'
运行

6.循环语句

6.1 for语句和while语句

  1. #循环语句
  2.  
  3. #c/c++
  4. #for(int i=1;i<=n;i++)
  5.  
  6. n=3
  7. for i in range(1,n):
  8.     print('*')
  9.  
  10. #while
  11. #continue,break
  12.  
  13. b=True
  14. flag=0
  15. while b:
  16.     flag+=1
  17.     print('*')
  18.     if flag==10:
  19.         continue
  20.     elif flag==15:
  21.         break
  22.  
  23. #for i in range(1,9,步长):
  24.  
  25. num=[1,2,3,4]
  26.  
  27. a=len(num) #获取序列长度
  28.  
  29. for i in num:
  30.     print(i)
'
运行

6.2并行遍历

  1. #并行遍历
  2. #调用zip()方法
  3. age=[18,19,17,20]
  4.  
  5. for i,j in zip(num,age):
  6.     print(i,j)
  7.  
  8.  
  9. #字典的迭代
  10. d={
  11.     'name':'zsy',
  12.     'age':20,
  13.     'sex':'male',
  14. } 
  15.  
  16. #要所有的值
  17. for it in d:
  18.     print(it,d[it])
  19.  
  20. for it in d.values():
  21.     print(it)
  22.  
  23. # 打印键和值
  24. for key,value in d.items():
  25.     print(key,value)
  26.  
  27. #获取1~9的平方
  28. a=range(1,10)
  29. b=[]
  30. for i in range(1,9):
  31.     b.append(i*i)
  32.  
  33. #列表推倒式实现获取1~9的平方
  34. b=[i*i for i in a]
  35.  
  36. #C:switch case
  37. #py:match...case a | case
  38.  
  39. #异常捕捉
  40. a=[]
  41. try:
  42.     print(a[2])
  43. except:
  44.     print("Program is error!")

八、序列精讲

python中序列的概述

列表，元组，字典，集合:容器，数据结构

序列的通用操作

1.索引  list[i]

2.切片

索引的进阶用法，通过两个下标或者步长来确定序列中的一段/间隔的一段。

        [start:end:step]=赋值为新的序列

3.拼接

      通过+，将两个序列拼接起来，两个序列对象必须相同。

4.乘法

序列*int(n),可以得到类型n个相同的序列。

print("abc"*3)'
运行

5.clear()操作

  1. list=['1','2']
  2. list.clear()
'
运行

6.浅拷贝

相当于list的切片，全复制一遍，只会复制值，改变a不影响list.

  1. a=list.copy() #构造了一个新的对象
  2. a.clear()

7.深拷贝

相当于地址，如果清除b,那么list也会清除，改变b影响list。

  1. b=list.deepcopy()
  2. b.clear()

8.count(x)

输出序列中x的个数。

  1. List=[1,2,3,4]
  2. print(List.count(3))
'
运行

9.extend

在序列后面追加。

  1. List.extend({'6':6.0,'7':7.0}) #把键追加到List后面
  2. #键:'6'
  3. #键值对:6.0

10.index(l,r,x)

可以判断x中是否在[l,r]中，如果存在，返回下标。

  1. print(List.index(0,3,3))
  2.  
  3. #insert(i,x):在i这个位置插入x
  4. List.index(1,6)

11.pop()

将最后一个元素输出，还可以输出。

  1. x=List.pop()
  2. print(x)

12.remove(x)

把值为x的删除。

List.remove(x)

13.reverse

把序列变成相反的。

List.reverse

14.sort

  1. List.sort() #默认升序
  2.  
  3. List.sort(reverse=True) #降序排序
  4.  
  5. List.sort(key=lambda x:x+1) #把所有的值+1后升序排序
  6.  
  7. List.sort(key=lambda x:x+1,reverse=True) #降序

15.sorted

生成一个全新的升序序列，可以做到改变新的序列，不影响原本序列。

y=List.sorted()

16字符串转换list

  1. s='123'
  2. l=list(s)
  3. print(l)
'
运行

17.set()

集合,集合中不能有相同的元素，可以自动去重。

list.set() #可以实现列表的去重

18.dict():字典

19.len()

返回序列长度，int型。

20.列表可以进行乘法

print([1.3]*3)'
运行

21.列表的迭代

  1. for i in List:
  2.     print(i)
  3.  
  4. for i in List[0:3:2]:
  5.     print(i)

22.max():最大值

print(max(List))

23.min():最小值

print(min(List))

24.range(start,end,step)

常在循环中出现。

25.dict 字典

  1. Dict={
  2.     '1':1,
  3.     '2':2
  4. }
  5. #'1':键
  6. #1:键值对
'
运行

26.字符串

  1. print(s.index('d')) #找到字符串的下标
  2. print(s.title())
  3. s.rstrip() #去除尾空格
  4. s.lstrip() #去除头空格
  5. s.strip() #去除头尾空格
  6. s.lower() #把所有的字母变成小写
  7. s.upper() #把所有的字母变成大写
  8. s.split('分隔符') #通过分裂
  9.     #list.split(" ") 通过空格隔开
  10. s.join("123") 
  11. s.replace('ab','xx') #将ab替换为xx

九、函数

基础函数⽤法

函数 （function） ⼜称为⽅法 ， 可以理解为⽤⼾个⼈定义的公式 ， 当定义好⼀个公式后， 我们可以⽤此公式得到⼀定的答案 ， 或是完成⼀些功能 。 即函数必须先定义才能使
⽤ 。

1.基本格式

使⽤关键字 def ， 本⾝是英⽂单词 define 的缩写 ， 意为定义 。 随后写上函数名和括号 ，函数名与变量名的编写规则⼀样。
定义函数的优点 ：
整理和优化代码 ， 提⾼代码的复⽤率 ， 避免重复代码 ， 使代码保持简洁
使代码可以更好的编写 、 阅读和维护。 
  1. def 函数名(参数):
  2.     return #可以有返回值，也可以没有返回值
'
运行

2.函数参数

“ 主要了解如何定义参数以及参数的基本⽤法 ” 参数 - 在调⽤函数式 ， 向函数提供数据
此处我们定义⼀个函数 line() 功能为打印⼀条横线 
  1. def line():
  2.     print("-----")
'
运行
调⽤函数即可得到⼀条⻓度为5 的横线 ， 若我们想得到可变⻓的横线⼜该如何做呢 ？
可以如下 ， 在编写函数时给 line() 函数⼀个 width 形式参数 ， 通过 width 变量控制打印
的内容 
  1. # 在python中我们定义函数参数还是较为简单的，只需要在括号内按照顺序添上形参即可
  2. def line(width):
  3.     print("-" * width)
'
运行
同样的 ， 如果我们⼜想将函数功能改为打印⼀条可变⻓相同字符的字符串 ， 即传⼊两个参
数 ， 我们直接将两个参数放⼊括号内即可
需要牢记的是 ， 我们在调⽤函数时 ， 实参需要按照形参的顺序传⼊ ， 这种参数我们也称为
位置参数
我们在使⽤ IDEL 进⾏代码编写时 ， 按照变量的类型 ， 我们可以得到不同的代码提⽰ ， 可
是在函数中的形参变量却⽆法得到代码提⽰ ， 这是因为 python ⽆法识别出参数的类型 ，
对于这种情况 ， 我们可以使⽤ 参数 : 数据类型
这种⽅式声明我们的参数类型 ， 我
们同样也使⽤该⽅法在调⽤该函数时告诉外界此函数的参数类型 ， 但是在调⽤函数时传⼊
不同类型的值 ， 只要⽆基本错误 ， 则不会影响函数的运⾏ 。 
  1. def line(width: int, char: str):
  2.     print(char * width)
'
运行

3.函数的说明⽂档

在使⽤外⼈定义的函数时 ， 若不清晰的看到函数代码逻辑 ， 我们⽆法知道此函数的⽤法 ，
那么在 python 中 ， 规定函数在定义时应该尽量的写上说明⽂档来帮助他⼈使⽤该函数 ，
⽅法即在函数头下⽅直接使⽤⽂档字符串 （ 三引号字符串 ）， 在其中写上函数说明 ， 参数
说明和返回说明 。 
  1. def line():
  2.     '''
  3.     打印⼀条⻓度为5的横线
  4.     return: None
  5.     '''
  6.     print("-----")
'
运行
如何查看函数的⽂档说明呢 ？
使⽤属性 doc ， 即双下划线 doc 双下划线 。 
  1. def line():
  2.     """
  3.     print a line
  4.     :return: None
  5.     """
  6.     print("-----")
  7.  
  8. print(line.__doc__)
  9. # 打印结果：
  10. # print a line
  11. # :return: None
'
运行

4.函数的返回值

所谓函数的返回值 ， 即调⽤函数后获得到的结果 ， 例如 ： 
  1. def get_max(a, b):
  2.     '''获取a和b中的较⼤值'''
  3.     # 将return后⾯的值返回给外界
  4.     # return可以提前结束整个函数
  5.     return a if a > b else b
  6.     # python中三⽬运算符的⽤法：
  7.     # <表达式1> if <条件> else <表达式2>
'
运行
在 python 中 ， 函数的返回值不仅仅可以返回⼀个 ， 实际上可以返回多个 ， 例如 ： 
  1. def func(a, b):
  2.     '''获取变量a和b的和差'''
  3.     return a + b, a - b
  4. add, reduce = func(21, 9)
  5. # 同时需要两个变量来接收返回值
  6. # 若只⽤⼀个变量接收，这多个值会被识别为元组，该变量则直接作为元组接收所有的值
'
运行

5.变量作⽤域

主要了解全局 （ global ） 变量和局部 （ local ） 变量的⽤法 变量作⽤域是指， 在程序的哪些地⽅可以使⽤变量.
⾸先在函数外部定义的变量 ， 我们称为全局 （global） 变量 ， 在程序的任意位置 （ 变量 的后续代码中） 都可以访问该变量 ， 但存在⼀定限制.
在函数中或者条件语句中定义变量我们称为局部 （local） 变量 ， 此变量只能在其声明的
区域进⾏使⽤或修改. 
  1. a = 1 # a 为全局变量
  2.  
  3. def func():
  4.     b = 2 # b为局部变量
  5.  
  6. if 1 > 2:
  7.     v = 3 # v为局部变量
  8.  
  9. for i in range(0, 10):
  10.     m = 4 # m为全局变量
'
运行
全局变量作⽤于全局 ， 但是若在函数中 ， 直接声明⼀个与全局变量相同名称的变量 ， 则在
该作⽤域中会⾃动屏蔽对应的全局变量 ， 使⽤该变量名只会对局部作⽤域中的对应变量造
成影响 ， 与外部的全局变量⽆关 。
除此之外 ， 在局部作⽤域中 ， ⽆法对全局变量进⾏修改 ， 只能进⾏访问 。
若想在局部作⽤域中对全局变量进⾏修改 ， 则必须使⽤关键词 global ， ⽤于声明该变量 ⾮同名的局部变量， ⽽是全局变量 ， 由此可以进⾏全局变量的修改. 
  1. x = 1
  2. def func():
  3.     '''change global x'''
  4.     global x
  5.     x = 2
'
运行

6.参数拓展

默认值 (default) 参数
在使⽤函数时 ， 可能存在某个参数不常更改 ， 但是每次调⽤参数的时候都必须去传⼊相同
的参数 ， 为了简化操作 ， 我们可以在声明函数时 ， 给对应的参数赋予⼀个默认值 ， 如此可
以在调⽤函数时不⽤传⼊该参数 ， 其在函数中的值直接被赋予默认值 。 
  1. # 值得注意的是，如果我们是想省略某个参数的传递，根据位置参数按照顺序传参的⽅式，如果
  2. 前⽅参数赋予默认值⽽后⽅参数不予默认值，则很容以看出会有逻辑上的⽭盾，故默认值只能从
  3. 后往前进⾏设置
  4. def f(a, b = 0, c = 1):
  5.     return a + b + c
关键字 (keyword) 参数
若存在未初始化的参数 ， 则可以 kwarg=value 形式的 关键字参数 调⽤函数 ： 
  1. def solve(age, name="lys", status="dog"):
  2.     print(f"{name} is", end=' ')
  3.     print(f"{age} years old, and {name}", end=' ')
  4.     print(f"is a {status} .")
  5. # solve(114514) # 第⼀个参数是必选参数，剩余参数可不选
  6. # solve(114514, "LYS") # 不声明关键字会默认匹配除默认参数后的最近的关键字参数
  7. # solve(114514, name="LYS")
  8. # solve(14, status="debu cat", name="Hiiro") # 传⼊关键字参数与参数列表的
  9. 关键字对应
除上述调⽤⽅法外 ， 以下调⽤⾮法 ： 
  1. solve() # 缺省 age 参数
  2. solve(name="Hiiro") # 缺省 age 参数
  3. solve(age=114514, "debu cat") # debu cat 需要照应⼀个关键字
  4. solve(114514, age=1919) # age 存在多个不同的值
可变⻓参数
        *args
        **kwargs
先来看个例⼦ ： 
  1. def foo(*args, **kwargs):
  2.     print('args = ', args)
  3.     print('kwargs = ', kwargs)
  4.     print('---------------------------------------')
  5.  
  6. if __name__ == '__main__':
  7.     foo(1,2,3,4)
  8.     foo(a=1,b=2,c=3)
  9.     foo(1,2,3,4, a=1,b=2,c=3)
  10.     foo('a', 1, None, a=1, b='2', c=3)
'
运行
可以看到 ， 这两个是 python 中的可变参数 。 args 表⽰任何多个⽆名参数 ， 它是⼀个 tuple ； **kwargs 表⽰关键字参数 ， 它是⼀个 dict 。 并且同时使⽤ args 和 kwargs 时 ， 必须 * args 参数列要在 kwargs 前 ， 像 foo (a=1, b='2', c=3, a', 1, None,) 这样调⽤的话 ， 会提⽰语法错误 “SyntaxError: non-keyword arg after keyword arg”。 知道 * args 和 **kwargs 是什么了吧 。 还有⼀个很漂亮的⽤法， 就是创建字典 ： 
  1. def kw_dict(**kwargs):
  2.     return kwargs
  3. print(kw_dict(a=1,b=2,c=3) == {'a':1, 'b':2, 'c':3})
'
运行
其实 python 中就带有 dict 类 ， 使⽤ dict (a=1,b=2,c=3) 即可创建⼀个字典 了。

十、高级函数的用法

1.Python函数是可以嵌套。

实际上在 python 中万物皆对象
那么我们在声明⼀个函数的时候 ， 实际上是声明了⼀个全局的函数对象 。 
  1. # 声明⼀个函数对象
  2. def func():
  3.     print("hello!")
  4.  
  5. # 给⼀个变量浅拷⻉为func函数变量
  6. a = func
  7. a() # 将a作为函数⽅法调⽤
  8.  
  9. # 结果：hello!
'
运行
由此可⻅ ， 函数与其他变量⽆异 ， 那么 ， 函数变量也满⾜其他变量的作⽤域使⽤规则 ， 同
时也可以在函数中声明⼀个函数变量 ， 从⽽实现函数的嵌套 。 
  1. def outer():
  2.     def inner():
  3.         print("This is inner.")
  4.     print('This is outer.')
  5.     b = inner
  6.     b()
  7.  
  8. a = outer
  9. a()
  10. # 结果：
  11. # This is outer.
  12. # This is inner.
  13. # b = inner
  14. # b()
  15. # 结果：报错
'
运行
同样的 ， 函数也可以如其他变量⼀样 ， 作为对象被返回 （return） 
  1. def outer():
  2.     def inner():
  3.     print('This is inner.')
  4.     print('This is outer.')
  5.     return inner
  6.  
  7. a = outer
  8. b = a() # 结果： This is outer.
  9. b() # 结果： This is inner.
并且 ， 函数也可以作为参数传⼊另⼀个函数 
  1. def func_1():
  2.     print('This is func_1.')
  3.  
  4. def func_2(func):
  5.     print('This is func_2.')
  6.     func() # 在func_2中调⽤func函数
  7.  
  8. func_2(func_1) # 调⽤func_2, 同时把func_1作为参数传⼊
  9.  
  10. # 结果：
  11. # This is func_1.
  12. # This is func_2.
'
运行

2.lambda表达式

许多时候 ， 我们或许会使⽤⽐较简单的函数 ， 但是声明起来却很⿇烦 ， 需要⼀块位置去专
⻔写⼀块代码 。
实际上在许多的⾼级语⾔中都涉及了匿名函数的设计 ， 可以快速的设计⼀个函数对象 。 那
么在 python 中也同样可以使⽤ ， 我们称为 lambda 表达式 ， 使⽤ lambda 关键字和规定语
法即可申请⼀个匿名的函数对象 。 
  1. def GetAnonymous():
  2.     '''获取⼀个匿名的函数对象，且其功能为获得参数加上偏移量5的值'''
  3.     return lambda x: x + 5
  4.  
  5. a = GetAnonymous()
  6. print(a(10))
  7.  
  8. # 结果：
  9. # 15
'
运行

3.闭包

所谓闭包 ， 简⽽⾔之就是将数据封装在⼀个包 （ 区域 ） 中 ， 使⽤时我们再去⾥⾯取 。（ 本
质上 ， 闭包是基于函数嵌套搞出来的⼀个中特殊嵌套 ）
· 闭包应⽤场景 1 ： 封装数据防⽌污染全局 
  1. def func(age, sex: string):
  2.     name = 'zsy'
  3.     # 如此可以防⽌name全局变量的污染
  4.     def func_1():
  5.         print(name, age)
  6.     
  7.     def func_2():
  8.         print(name. sex)
  9.     
  10.     func_1()
  11.     func_2()
  12.  
  13. a = func
  14. a()
  15. # 但实际上我们很少能⽤得上该种⽅式
· 闭包场景应⽤ 2 ： 封装数据到⼀个包中 ， 使⽤时再取 
  1. def task(arg):
  2.     def inner():
  3.         print(arg)
  4.     return inner
  5.  
  6. innner_func_list = []
  7. for val in range(0, 4):
  8.     inner_func_list.append(task(val))
  9.  
  10. for val in inner_func_list:
  11. val()
  12. # 结果：
  13. # 0
  14. # 1
  15. # 2
  16. # 3
实际上在 python 中闭包使⽤得到的场景是没有那么清晰直观的 ， 这边有⼀些提前的知识
来让⼤家了解到闭包的使⽤场景 
  1. """基于多线程并⾏完成爬⾍任务"""
  2. from concurrent.futures.thread import ThreadPoolExecutor
  3. import requests
  4. # 构建线程池
  5. POOL = ThreadPoolExecutor(5)
  6. # 三个爬⾍任务
  7. spider_tasks = [
  8.     ('哪⾥都是你mv.mp4',
  9.  
  10. 'http://vodkgeyttp8.vod.126.net/cloudmusic/da70/core/b88c/70c2e21a75785
  11. 7fe8a12fe0345986398.mp4?
  12. wsSecret=b815d122a2dd93eaf122c52686da471d&wsTime=1675325208'),
  13.     ('成都mv.mp4',
  14.  
  15. 'http://vodkgeyttp8.vod.126.net/cloudmusic/IjAyMCAgMyEgYDEwIDhhMg==/mv/
  16. 5619601/79bd07d7bd9394871da0c324d53f48dd.mp4?
  17. wsSecret=efd55511ee0c07c53c230301d116d6e6&wsTime=1675325208'),
  18.     ('江南mv.mp4',
  19.  
  20. 'http://vodkgeyttp8.vod.126.net/cloudmusic/MTI5MDc0OTc=/d23df6673394543
  21. e4d1dd291e566c337/767999bafb2a5d407708e2770f7725e8.mp4?
  22. wsSecret=f010419757e1f2359119519422967ce2&wsTime=1675325208')
  23. ]
  1. def task(url):
  2.     content = requests.get(url=url).content
  3.     # return content
  4.     print('任务：', url, '已完成!')
  5.     return content
  6.  
  7. def outer(filename):
  8.     def done(arg):
  9.         data = arg.result()
  10.         with open(filename, 'wb') as f:
  11.             f.write(data)
  12.  
  13.     return done
  14.  
  15. for item in spider_tasks:
  16.     a = POOL.submit(task, item[1])
  17.     print('已分配任务:', item[0])
  18.     a.add_done_callback(outer(item[0]))
  19.  
  20. # 结果：
  21. 已分配任务: 哪⾥都是你mv.mp4
  22. 已分配任务: 成都mv.mp4
  23. 已分配任务: 江南mv.mp4
  24. 任务：
  25. http://vodkgeyttp8.vod.126.net/cloudmusic/IjAyMCAgMyEgYDEwIDhhMg==/mv/5
  26. 619601/79bd07d7bd9394871da0c324d53f48dd.mp4？
  27. wsSecret=efd55511ee0c07c53c230301d116d6e6&wsTime=1675325208 已完成!
  28. 任务：
  29. http://vodkgeyttp8.vod.126.net/cloudmusic/da70/core/b88c/70c2e21a757857
  30. fe8a12fe0345986398.mp4？
  31. wsSecret=b815d122a2dd93eaf122c52686da471d&wsTime=1675325208 已完成!
  32. 任务：
  33. http://vodkgeyttp8.vod.126.net/cloudmusic/MTI5MDc0OTc=/d23df6673394543e
  34. 4d1dd291e566c337/767999bafb2a5d407708e2770f7725e8.mp4？
  35. wsSecret=f010419757e1f2359119519422967ce2&wsTime=1675325208 已完成!
  36. # 由此在⼀系列⼯作中，闭包可以在不需要更改原本函数的情况下添加上额外的功能

4.装饰器

装饰器其实也是⼀种闭包 ， 作为⼀种语法糖在 python 中⼴泛使⽤ ， 在写 python 的时候 ，
偶尔会对某个冗⻓的函数加上其他功能 ， 但是如此修改起来会很⿇烦 ， 那么此时装饰器可
以帮助我们在不修改原本函数内容的同时增添新的功能 ， 名⽈ ： ’ 装饰 ‘
例如 ： 要求在函数 func 执⾏时在先前操着之前和之后执⾏分别打印 before 和 after 
  1. def func():
  2.     print('This is func.')
'
运行
第⼀时间想到的思路是直接修改 func 
  1. # 简单思路
  2. def func():
  3.     print('before')
  4.  
  5.     print('This is func.')
  6.  
  7.     print('after')
'
运行
通过前⽅的闭包思路 ， 其实可以如此修改 
  1. # 闭包思路
  2. def outer(func):
  3.     def inner():
  4.         print("before")
  5.         func()
  6.         print('after')
  7.     return inner
  8.  
  9. task = outer(func)
  10. task()
实际上 ， 上述⽅法反⽽会显得冗杂 ， 那么有没有办法可以简单化呢 ？ 这就要讲到 python
的语法糖 ， 所谓语法糖 ， 甜的 ， 好的 ， 就是将⼀系列冗杂的语法简单化 。
对于闭包的使⽤ ， 就拥有⼀个语法糖 ， 我们也称为装饰器 。 即使⽤ @ 函数名的⽅式实现 。
实现⽅式如下 ： 
  1. """
  2. 语法糖的使⽤：
  4. @func
  5. def xxx():
  6.     pass
  8. 其中，python会根据该段代码⾃动执⾏如下代码：
  9. xxx = func(xxx)
  11. 那么我们即可以根据闭包，甚⾄可以在func中使⽤额外参数去装饰函数xxx
  12. """
'
运行
如此上⽅代码可以简化为下 ： 
  1. # 闭包思路
  2. def outer(func):
  3.     def inner():
  4.         print("before")
  5.         func()
  6.         print('after')
  7.     return inner
  8.  
  9. @outer
  10. def func():
  11.     print('This is func.')
  12.  
  13. func() # 调⽤func
'
运行
但是在此中 ， 虽然是简化了语法 ， 但是有种曲线救国的意思 ， 依然是显得冗杂 ， 不如最简
单的思路 ， 实际上 ， 在此需求中 ， 确实第⼀种⽅法最为⽅便和简洁 。 那么此时更换⼀下需
求 ， 若是要在多个函数中不修改函数内容 ， 在每次函数调⽤时先打印⼀个 before ， 执⾏
后再打印⼀个 after 呢 ？ 
  1. def func_1():
  2.     print('this is func_1')
  3. def func_2():
  4.     print('this is func_2')
  5. # ........
'
运行
此时 ， 再逐⼀更改函数内容会显得很⿇烦了 ， 再之 ， 若我们的需求不仅仅是打印 before
和 after ， ⽽是完成其他更复杂的操作 ， 加之需要修改的函数⼗分之多 ， 则会显得装饰器
的使⽤反⽽更为简洁了 ， 并且在维护代码时 ， 装饰器会更为优秀 。
那么对于装饰器的使⽤场景 ， 还需要⾃⼰去思考和发现 。 例如 ， 对于参数可变 ， 我们则可
以对 inner 函数加上 *args 和 **kwargs 来实现装饰带有可变⻓参数的函数 除此之外 ， 我们需要认识到 ， 使⽤装饰器或者闭包时 ， 声名的函数本质上是⼀个 inner 对
象 ， 其函数⽂档和函数名 （ 通过 name ， 和 doc ） 都是 inner 函数的内容 。
那么如何拿到原函数内容呢 ？
这⾥要使⽤的⼀个内置库 ， 名为 functools 
  1. def outer(func):
  2.  
  3.     @functools.wraps(func)
  4.     def inner(*args, **kwargs):
  5.         data = func(*args, **kwargs)
  6.         return data
  7.  
  8.     return inner
  9. # 如此即可得到相应的⽂档名称等等
'
运行
在使⽤装饰器时加上 functools 是更好的习惯

5.⽣成器

对于任何⼀个函数 ， 我们都有⼀个返回值 ， 使⽤ return 去返回⼀个值 ， 当不⽤ return 或
者使⽤ return 后续不接任何值时会默认返回⼀个 None 的值
但其实在 python 中我们有⼀个更为⾼级的关键字 yield 来实现可变的返回值
使⽤⽅式很简单 ， 将 return 改回 yield 即 : 
  1. def func():
  2.     yield None
'
运行
此种函数 ， 我们称之为⽣成器函数 ， 简称⽣成器.
其⽤法在特定情况下可以帮我们节省内存. 
  1. def func():
  2.     '''使⽤该函数进⾏⼀个计数，每次调⽤得到⼀个更⼤的⾃然数'''
  3.     
  4.     for num in range(0, 100):
  5.         print("计数ing...")
  6.         yield num
  7.  
  8. a = func() # 得到⽣成器对象
  9. print(a) # 得到⽣成器时，是不会执⾏函数内部代码的
  10.  
  11. # 使⽤next()对象进⼊⽣成器，执⾏代码，同时可以⽤变量的到yield的返回值
  12. num = next(a)
  13. print(num)
  14.  
  15. num = next(a)
  16. print(num)
  17.  
  18. num = next(a)
  19. print(num)
  20.  
  21. # 返回结果：
  22. # <generator object func at 0x0000021D0A50EE40>
  23. # 计数ing...
  24. # 0
  25. # 计数ing...
  26. # 1
  27. # 计数ing...
  28. # 2
'
运行
当⽣成器的代码实际执⾏完毕之后 ， 会报错 ， 错误类型为 :StopIteration ，
来表⽰该⽣成器已结束 ， 对于该错误我们可以⽤异常捕捉来解决.
对于更简单的⽣成器调⽤ ， 可以⽤ for 循环来执⾏⽣成器对象. 
  1. def func():
  2.     '''使⽤该函数进⾏⼀个计数，每次调⽤得到⼀个更⼤的⾃然数'''
  3.     
  4.     for num in range(0, 5):
  5.         print("计数ing...")
  6.         yield num
  7.  
  8. a = func() # 得到⽣成器对象
  9.  
  10. for item in a:
  11.     print(item)
  12.  
  13. # 结果：
  14. # 计数ing...
  15. # 0
  16. # 计数ing...
  17. # 1
  18. # 计数ing...
  19. # 2
  20. # 计数ing...
  21. # 3
  22. # 计数ing...
  23. # 4
'
运行
如此我们可以不需要捕捉异常 ， 即可将⽣成器完整地迭代完毕 ， 在⼯程设计时 ， 也经常如
此使⽤ 。
需要牢记的是⽣成器的最⼤作⽤ ， 是实现内存的节省 ！
例如要求⽣成 300000000 多个对象 ， 如果使⽤其他⽅法 ， 开销是巨⼤的 。 特别是在
redis 这种数据库中 ， 若不适⽤⽣成器 ， 则可能会直接导致 redis 爆炸 ， 内存直接爆栈 ！
⽣成器拓展.
该处不要求记住 ， 只要求能看懂 。
实际上 ， 在⽣成器函数中 ， 我们可以使⽤ < 变量名 > = yield < 返回值 > 的⽅式将⽣成
器封存 ， 直到下次对⽣成器对象使⽤ send(value) ⽅法将 value 的值赋给 < 变量 > 之后 ，
才可以继续往下执⾏代码 。 
  1. def func():
  2.     for i in range(5):
  3.         v = yield i
  4.         print(v)
  5.  
  6. g = func()
  7.  
  8. g.send(None)
  9. for i in range(4):
  10.     a = g.send('计数ing')
  11.     print(a)
  12.  
  13. # 结果：
  14. # 计数ing
  15. # 1
  16. # 计数ing
  17. # 2
  18. # 计数ing
  19. # 3
  20. # 计数ing
  21. # 4
  22. """
  23. 值得注意的是，send函数会直接进⾏⽣成器的迭代
  24. """
'
运行

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/代码探险家/article/detail/973554
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号