【Python】基础(学习笔记)

一、Python介绍

1、Python优点

学习成本低

开源

适应⼈群⼴泛

应⽤领域⼴泛

2、Python解释器

Python解释器作用:运行Python文件

Python解释器分类

CPython:C语⾔开发的解释器[官⽅],应⽤⼴泛的解释器。

IPython:基于CPython的⼀种交互式解释器。

PyPy:基于Python语⾔开发的解释器。

Jython:运⾏在Java平台的解释器,直接把Python代码编译成Java字节码执⾏。

IronPython:运⾏在微软.Net平台上的Python解释器,可以直接把Python代码编译成.Net的字节码。

3、PyCharm

PyCharm是⼀种Python IDE(集成开发环境)

1)PyCharm新建⽂件

项⽬管理空⽩位置 — 右键 – New – PythonFile

2)运⾏⽂件

代码内部 — 右键 – Run

3)修改代码⽂字格式

[fifile] – [Settings]/[Default Settings] – [Editor] – [Font]

4)Debug⼯具

断点位置:⽬标要调试的代码块的第⼀⾏代码即可,即⼀个断点即可。

打断点的⽅法:单击⽬标代码的⾏号右侧空⽩位置,在⽂件内部任意位置 — 右键 – Debug’⽂件名’ — 即可调出Debug⼯具⾯板 – 单击StepOver/F8,即可按步执⾏代码。

Debug输出⾯板:
Debugger显示变量和变量的细节
Console:输出内容

4、查看python版本

cmd --> Python3 -V

二、Python基础语法

1、编码

Python 3 源码文件以 UTF-8 编码,所有字符串都是 unicode 字符串

2、标识符

  1. 第一个字符必须是字母表中字母或下划线 _
  2. 标识符的其他的部分由字母、数字和下划线组成
  3. 标识符对大小写敏感
  4. 可以用中文作为变量名

3、保留字

保留字即关键字,我们不能把它们用作任何标识符名称。

Python 的标准库提供了一个 keyword 模块,可以输出当前版本的所有关键字

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

4、注释

Python中单行注释以 # 开头

# 第一个注释
print ("Hello, Python!") # 第二个注释

多行注释可以用多个 #号,还有 '''"""

# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""

5、行与缩进

缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数

6、多行语句

Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠 \ 来实现多行语句

total = item_one + \
        item_two + \
        item_three

在 [], {}, 或 () 中的多行语句,不需要使用反斜杠 \

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

7、空行

函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。

空行与代码缩进不同,空行并不是 Python 语法的一部分。书写时不插入空行,Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。

空行也是程序代码的一部分。

8、同一行显示多条语句

Python 可以在同一行中使用多条语句,语句之间使用分号 ; 分割

name = 'wmh'; print(name)

9、多个语句构成代码组

缩进相同的一组语句构成一个代码块,我们称之代码组。

像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)

10、print 输出

print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=""

x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

11、import 与 from…import

在 python 用 import 或者 from...import 来导入相应的模块。

  1. 将整个模块(somemodule)导入,格式为: import somemodule
  2. 从某个模块中导入某个函数,格式为: from somemodule import somefunction
  3. 从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc
  4. 将某个模块中的全部函数导入,格式为: from somemodule import *

三、数据类型

1、赋值

Python 中的变量不需要声明。但每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。

在 Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。

一个变量可以通过赋值指向不同类型的对象。

等号(=)用来给变量赋值。

a = 'wmh'
print(a)

Python允许你同时为多个变量赋值

a = b = c = 1

可以为多个对象指定多个变量

a, b, c = 1, 2, "runoob"

交换两变量的值

a,b = b,a

2、标准数据类型

  1. Number(数字)
  2. String(字符串)
  3. List(列表)
  4. Tuple(元组)
  5. Set(集合)
  6. Dictionary(字典)

**不可变数据(3 个):**Number(数字)、String(字符串)、Tuple(元组)

**可变数据(3 个):**List(列表)、Dictionary(字典)、Set(集合)

3、Number(数字)

Python3 支持 int、float、bool、complex(复数)

  • 整型(int):不分正负但不带小数点。Python3 整型是没有限制大小的,所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
  • 浮点型(float):浮点型由整数部分与小数部分组成,可以用科学计数法表示(2.5e2 = 2.5 x 102 = 250)
  • 复数(complex):复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, a和b都是浮点型。

可以用十六进制和八进制来代表整数

>>> number = 0xA0F	# 十六进制
>>> number
2575

>>> number=0o37 	# 八进制
>>> number
31

内置的 type() 函数可以用来查询变量所指的对象类型

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

可以用 isinstance 来判断

>>> a = 111
>>> isinstance(a, int)
True

sinstance 和 type 的区别在于:

  • type()不会认为子类是一种父类类型
  • isinstance()会认为子类是一种父类类型

Python3 中,bool 是 int 的子类,True 和 False 可以和数字相加,True==1False==0会返回 True,但可以通过 is 来判断类型。

issubclass(bool, int) 	# True
True==1					# True
False==0				# True
True+1					# 2
False+1					# 1
1 is True				# False
0 is False				# False

del语句删除单个或多个对象

del var
del var_a, var_b

Python还支持复数,复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型

在交互模式中,最后被输出的表达式结果被赋值给变量 _

类似于jQuery中的$

>>> 1 + 2
3
>>> _
3

4、String(字符串)

字符串:单引号 ' 或双引号 " 括起来,同时使用反斜杠 \ 转义特殊字符。

变量[头下标:尾下标:步长]		# 字符串分片(左闭右开)

索引值:从左往右以0开始,从右往左以-1开始

+运算符连接在一起,用*运算符重复

print (str * 2)      # 输出字符串两次,也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串

使用反斜杠 \ 转义特殊字符

\r:回车,将 \r 后面的内容移到字符串开头,并逐一替换开头部分的字符,直至将 \r 后面的内容完全替换完成

>>> print('google runoob taobao\r123456')
123456 runoob taobao

在字符串前面添加一个 r,表示原始字符串

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob

反斜杠(\)可以作为续行符,表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

字符串格式化输出

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
符号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%f 格式化浮点数字,可指定小数点后的精度

f-string输出

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'

>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8
x+1=2

Python 没有单独的字符类型,一个字符就是长度为1的字符串。

与 C 字符串不同的是,Python 字符串不能被改变。向一个索引位置赋值,word[0] = 'm'会导致错误。

5、List(列表)

列表中元素的类型可以不相同,它支持数字,字符串与列表嵌套

列表写在方括号 [] 之间、用逗号分隔开的元素列表

和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。

变量[头下标:尾下标:步长]		# 列表分片

索引值:从左往右以0开始,从右往左以-1开始

+运算符连接在一起,用*运算符重复

列表中的元素是可以改变的

删除列表元素:del list[2]

列表比较

import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))	# False
print("operator.eq(c,b): ", operator.eq(c,b))	# True

6、Tuple(元组)

与列表类似,不同之处在于元组的元素不能修改。

所谓元组的不可变指的是元组所指向的内存中的内容不可变

重新赋值的元组变量,绑定到了新的对象,不是修改了原来的对象了

元组写在小括号 () 里,元素之间用逗号隔开

元组也可以被索引和切片,也可以使用+操作符进行拼接

可以把字符串看作一种特殊的元组

虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表

构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则

tup1 = ()    	# 空元组
tup2 = (20,) 	# 一个元素,需要在元素后添加逗号

string、list 和 tuple 都属于 sequence(序列)

7、Set(集合)

集合(set):由一个或数个形态各异的大小整体组成的

构成集合的事物或对象称作元素或是成员

基本功能:进行成员关系测试和删除重复元素

可以使用大括号 { } 或者 set() 函数创建集合

创建一个空集合必须用 set() ,因为 { } 是用来创建一个空字典

parame = {value01,value02,...}
set(value)

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)   # 输出集合,重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')


# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')


print(a - b)     # a 和 b 的差集
{'r', 'b', 'd'}

print(a | b)     # a 和 b 的并集
{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}

print(a & b)     # a 和 b 的交集
{'c', 'a'}

print(a ^ b)     # a 和 b 中不同时存在的元素
{'z', 'b', 'm', 'r', 'l', 'd'}

1)添加元素

添加元素:s.add( x )

添加元素、列表、元组、字典:s.update( x )

x 可以有多个,用逗号分开

2)移除元素

不存在报错:s.remove( x )

不存在不报错:s.discard( x )

随机删一个:s.pop()

set 集合的 pop 方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除

3)其他操作

计算集合元素个数:len(s)

清空集合:s.clear()

判断元素是否在集合中存在:x in s

8、Dictionary(字典)

列表是有序的对象集合,字典是无序的对象集合
两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取

字典是一种映射类型,字典用 { } 标识,它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行

在同一个字典中,键(key)必须是唯一的。

创建时如果同一个键被赋值两次,后一个值为准

注:dict 作为 Python 的关键字和内置函数,变量名不建议命名为 dict

dict = {}
dict['one'] = "123"
dict[2]     = "456"

print (dict['one'])			# 输出键为 'one' 的值
print (dict[2])				# 输出键为 2 的值
print (dict)          		# 输出完整的字典
print (dict.keys())   		# 输出所有键
print (dict.values()) 		# 输出所有值

创建空字典使用 {}

修改字典

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8					# 更新 Age
tinydict['School'] = "No.1"			# 添加信息

9、隐式类型转换

较低数据类型(整数)就会转换为较高数据类型(浮点数)以避免数据丢失

10、显式类型转换

int() 强制转换为整型

x = int(1)   	# x 输出结果为 1
y = int(2.8) 	# y 输出结果为 2
z = int("3") 	# z 输出结果为 3

float() 强制转换为浮点型

x = float(1)     # x 输出结果为 1.0
y = float(2.8)   # y 输出结果为 2.8
z = float("3")   # z 输出结果为 3.0
w = float("4.2") # w 输出结果为 4.2

str() 强制转换为字符串类型

x = str("s1") 	# x 输出结果为 's1'
y = str(2)   	# y 输出结果为 '2'
z = str(3.0)  	# z 输出结果为 '3.0'
函数 描述
int(x [,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
[complex(real ,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

四、推导式

1、什么是推导式

Python 推导式是一种独特的数据处理方式,可以从一个数据序列构建另一个新的数据序列的结构体

  • 列表(list)推导式
  • 字典(dict)推导式
  • 集合(set)推导式
  • 元组(tuple)推导式

2、列表推导式

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
  • out_exp_res:列表生成元素表达式,可以是有返回值的函数。
  • for out_exp in input_list:迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
  • if condition:条件语句,可以过滤列表中不符合条件的值。

过滤掉长度小于或等于3的字符串列表,并将剩下的转换成大写字母

>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper() for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']

计算 30 以内可以被 3 整除的整数

>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

3、字典推导式

{ key_expr: value_expr for value in collection }

{ key_expr: value_expr for value in collection if condition }

提供三个数字,以三个数字为键,三个数字的平方为值来创建字典

>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}

4、集合推导式

{ expression for item in Sequence }

{ expression for item in Sequence if conditional }

判断不是 abc 的字母并输出

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

5、元组推导式

(expression for item in Sequence )(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同,只是元组推导式是用 () 圆括号将各部分括起来,而列表推导式用的是中括号 []

元组推导式返回的结果是一个生成器对象

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数,可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

五、运算符

1、算数运算符

运算符 说明
+ 加 - 两个对象相加
- 减 - 得到负数或是一个数减去另一个数
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串
/ 除 - x 除以 y
% 取模 - 返回除法的余数
** 幂 - 返回x的y次幂
// 取整除 - 向下取接近商的整数

2、比较运算符

运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。 (a < b) 返回 True。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。

所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。

3、赋值运算符

运算符 描述 实例
= 赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a

:= 海象运算符

可在表达式内部为变量赋值。(Python3.8 版本新增运算符)

List = ['r','e','x','h','a','o']
for i in range(Len := len(List)):
    print(List[i],end="")
# rexhao

4、位运算符(摆烂)

运算符 描述 实例
& 按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ,二进制解释: 0000 1100
| 按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。 (a | b) 输出结果 61 ,二进制解释: 0011 1101
^ 按位异或运算符:当两对应的二进位相异时,结果为1 (a ^ b) 输出结果 49 ,二进制解释: 0011 0001
~ 按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 (~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。
<< 左移动运算符:运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。 a << 2 输出结果 240 ,二进制解释: 1111 0000
>> 右移动运算符:把">>“左边的运算数的各二进位全部右移若干位,”>>"右边的数指定移动的位数 a >> 2 输出结果 15 ,二进制解释: 0000 1111

5、逻辑运算符

运算符 逻辑表达式 描述 实例
and x and y 布尔"与" - 如果 x 为 False,x and y 返回 x 的值,否则返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔"或" - 如果 x 是 True,它返回 x 的值,否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 not(a and b) 返回 False

6、成员运算符

运算符 描述 实例
in 如果在指定的序列中找到值返回 True,否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True,否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

7、身份运算符

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y , 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True,否则返回 False。

id():获取对象内存地址。

is 与 == 区别:is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。

8、运算符优先级

运算符 描述
(expressions...),[expressions...], {key: value...}, {expressions...} 圆括号的表达式
x[index], x[index:index], x(arguments...), x.attribute 读取,切片,调用,属性引用
await x await 表达式
** 乘方(指数)
+x, -x, ~x 正,负,按位非 NOT
*, @, /, //, % 乘,矩阵乘,除,整除,取余
+, - 加和减
<<, >> 移位
& 按位与 AND
^ 按位异或 XOR
` `
in,not in, is,is not, <, <=, >, >=, !=, == 比较运算,包括成员检测和标识号检测
not x 逻辑非 NOT
and 逻辑与 AND
or 逻辑或 OR
if -- else 条件表达式
lambda lambda 表达式
:= 赋值表达式

Pyhton3 已不支持 <> 运算符

六、分支

1、if

Python 中用 elif 代替了 else if,所以if语句的关键字为:if - elif - else

使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块。

在Python中没有switch – case语句。

2、while

在 Python 中没有 do…while 循环

使用 CTRL+C 来退出死循环

支持while - else语句,break跳出不执行else

3、for

for 循环用来遍历任何可迭代对象

break 语句用于跳出当前循环体

range(起始值, 结束值, 步长):创建数字序列

4、pass

pass是空语句,是为了保持程序结构的完整性。

pass 不做任何事情,一般用做占位语句(空着会报错)

5、迭代器

1)迭代器概述

迭代:用来访问集合(字符串,列表或元组对象)元素

迭代器:一个可以记住遍历的位置的对象

迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束(只能往前不会后退)

迭代器的两个基本的方法:iter()next()

list=[1,2,3,4]
it1 = iter(list)    # 创建迭代器对象
print (next(it1))   # 输出迭代器的下一个元素
# 1

it2 = iter(list)    # 创建迭代器对象
for x in it2:
    print (x, end="")
# 1234


2)迭代器创建

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__()__next__()

__iter__() 返回一个特殊的迭代器对象, 这个迭代器对象实现了 __next__() 并通过 StopIteration 异常标识迭代的完成

__next__() 会返回下一个迭代器对象

创建一个返回数字的迭代器,初始值为 1,逐步递增 1

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))

3)StopIteration

StopIteration 异常用于标识迭代的完成,防止出现死循环

import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

__next__()方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
	print(x)

6、生成器

生成器:使用了 yield 的函数

生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器

在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行

# 使用 yield 实现斐波那契数列
import sys
 
def fibonacci(n): 		# 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) 		# f 是一个迭代器,由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

七、函数

1、定义函数

def 函数名(参数列表):
    函数体

return [表达式] :结束函数,选择性地返回一个值给调用方
不带表达式的 return 相当于返回 None

2、传参

1)值传递和引用传递

类型属于对象,对象有不同类型的区分,变量是没有类型的

  • **不可变类型:**类似 C++ 的值传递,如整数、字符串、元组。
  • **可变类型:**类似 C++ 的引用传递,如 列表、字典。

python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象

2)必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

3)关键字参数

关键字参数允许函数调用时参数的顺序与声明时不一致,解释器能够用参数名匹配参数值

def printinfo( name, age ):
   print ("名字: ", name)
   print ("年龄: ", age)
   return

printinfo( age=50, name="wmh" )

4)默认参数

调用函数时,如果没有传递参数,则会使用默认参数

def printinfo( name, age = 35 ):
   print ("名字: ", name)
   print ("年龄: ", age)
   return

printinfo( name="wmh" )

5)不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述 2 种参数不同,声明时不会命名。

def functionname([formal_args,] *var_args_tuple ):
   function_suite
   return [expression]

星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数

def printinfo( arg1, *vartuple ):
    print (arg1)
    print (vartuple)
    return

printinfo( 70, 60, 50 )
# 70
# (60, 50)

加了两个星号 ** 的参数会以字典的形式导入

def printinfo( arg1, **vardict ):
    print ("输出: ")
    print (arg1)
    print (vardict)
    return

printinfo(1, a=2,b=3)
# 1
# {'a': 2, 'b': 3}

参数中星号 * 可以单独出现

def f(a,b,*,c):
    return a+b+c
f(1,2,3)   # 报错
f(1,2,c=3) # 正常

3、匿名函数

使用 lambda 来创建匿名函数

lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数

虽然 lambda 函数看起来只能写一行,却不等同于 C 或 C++ 的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率

lambda [arg1 [,arg2,.....argn]]:expression
sum = lambda a,b: a + b
sum(1,2)	# 3

4、强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数,不能使用关键字参数的形式

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    return
f(10, 20, 30, d=40, e=50, f=60)			# 对
f(10, b=20, c=30, d=40, e=50, f=60)		# 错:b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)				# 错:e 必须使用关键字参数的形式

你可能感兴趣的:(python,学习,笔记)