【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']
1
2
3

4、注释

Python中单行注释以 # 开头

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

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

# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""
1
2
3
4
5
6
7
8
9
10
11
12

5、行与缩进

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

6、多行语句

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

total = item_one + \
        item_two + \
        item_three
1
2
3

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

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

7、空行

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

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

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

8、同一行显示多条语句

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

name = 'wmh'; print(name)
1

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()
1
2
3
4
5
6
7
8
9
10
11

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)
1
2

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

a = b = c = 1
1

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

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

交换两变量的值

a,b = b,a
1

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
1
2
3
4
5
6
7

内置的 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'>
1
2
3

可以用 isinstance 来判断

>>> a = 111
>>> isinstance(a, int)
True
1
2
3

sinstance 和 type 的区别在于：

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

Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加，True==1、False==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
1
2
3
4
5
6
7

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

del var
del var_a, var_b
1
2

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

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

类似于jQuery中的$

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

4、String（字符串）

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

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

索引值：从左往右以0开始，从右往左以-1开始

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

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

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

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

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

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

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
1
2
3
4
5

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

字符串格式化输出

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
1

f-string输出

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

>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8
x+1=2
1
2
3
4
5
6
7

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

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

5、List（列表）

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

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

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

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

索引值：从左往右以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
1
2
3
4
5
6
7

6、Tuple（元组）

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

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

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

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

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

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

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

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

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

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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()) 		# 输出所有值
1
2
3
4
5
6
7
8
9

创建空字典使用 {}

修改字典

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

9、隐式类型转换

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

10、显式类型转换

int() 强制转换为整型

x = int(1)   	# x 输出结果为 1
y = int(2.8) 	# y 输出结果为 2
z = int("3") 	# z 输出结果为 3
1
2
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
1
2
3
4

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

x = str("s1") 	# x 输出结果为 's1'
y = str(2)   	# y 输出结果为 '2'
z = str(3.0)  	# z 输出结果为 '3.0'
1
2
3

四、推导式

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]
1
2
3
4
5

• 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']
1
2
3
4

计算 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]
1
2
3

3、字典推导式

{ key_expr: value_expr for value in collection }

{ key_expr: value_expr for value in collection if condition }
1
2
3

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

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

4、集合推导式

{ expression for item in Sequence }

{ expression for item in Sequence if conditional }
1
2
3

判断不是 abc 的字母并输出

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

5、元组推导式

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )
1
2
3

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

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

>>> 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
2
3
4
5
6

五、运算符

1、算数运算符

2、比较运算符

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

3、赋值运算符

:= 海象运算符

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

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

4、位运算符（摆烂）

5、逻辑运算符

6、成员运算符

7、身份运算符

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

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

8、运算符优先级

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


1
2
3
4
5
6
7
8
9
10
11

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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3）StopIteration

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

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

在__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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

七、函数

1、定义函数

def 函数名（参数列表）:
    函数体
1
2

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

2、传参

1）值传递和引用传递

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

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

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

2）必需参数

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

3）关键字参数

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

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

printinfo( age=50, name="wmh" )
1
2
3
4
5
6

4）默认参数

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

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

printinfo( name="wmh" )
1
2
3
4
5
6

5）不定长参数

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

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

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

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

printinfo( 70, 60, 50 )
# 70
# (60, 50)
1
2
3
4
5
6
7
8

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

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

printinfo(1, a=2,b=3)
# 1
# {'a': 2, 'b': 3}
1
2
3
4
5
6
7
8
9

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

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

3、匿名函数

使用 lambda 来创建匿名函数

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

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

lambda [arg1 [,arg2,.....argn]]:expression
1

sum = lambda a,b: a + b
sum(1,2)	# 3
1
2

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 必须使用关键字参数的形式
1
2
3
4
5
6