前言

温馨提示：本讲义所使用python环境为3.11.1版本，编辑器Pycharm professional 为2024.1.7版本；本文受《中华人民共和国著作权法》保护，未经作者允许，任何人不得以任何理由商用、外泄等等。本文档仅供参考学习，任何违法行为均与作者无关。本文内容均为作者参考网上公开文献资料亲手整理，如有错误或不妥之处还望见谅并指正。 作者：添柴不加火

一、python环境搭建

1、python安装

python官网：https://www.python.org

1.下载得到安装包后双击运行。

2.勾选 “Add Python to PATH” 复选框，点击 “Customize installaion”。

3.点击下一步，“next”，修改python安装路径，然后安装即可。

4.安装完成后，同时按“win+R”，输入cmd回车，在命令行输入“python”，回车，出现python版本号即成功安装，例如：

Python 3.11.1 (tags/v3.11.1:a7a450f, Dec 6 2022, 19:58:39) [MSC v.1934 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.

2、python编辑器安装

pycharm官网：https://www.jetbrains.com/zh-cn/pycharm/

请自行安装，不再过多赘述。

温馨提示：如果不会安装，可以参考作者的文章

https://www.cnblogs.com/xize766/articles/19535648/python-install；

https://www.cnblogs.com/xize766/articles/19541594/pycharm-install

3、什么是python

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

二、基本语法

1、标识符

1.由字母、数字、下划线（ _ ）组成。

2.第一个字符必须以字母（a-z, A-Z）或下划线（ _ ）。

3.标识符对大小写敏感，如：count 和 Count 是不同的标识符。

4.禁止使用保留关键字，如：if、for、class 等不能作为标识符。

python保留的关键字：False None True and as assert async await 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，共35个。

也可以通过代码查询关键字：

import keyword

# 获取所有保留关键字并以空格分隔输出
print(" ".join(keyword.kwlist))

2、关键字说明

类别	关键字	说明
逻辑值	True	布尔真值
	False	布尔假值
	None	表示空值或无值
逻辑运算	and	逻辑与运算
	or	逻辑或运算
	not	逻辑非运算
条件控制	if	条件判断语句
	elif	否则如果（else if 的缩写）
	else	否则分支
循环控制	for	迭代循环
	while	条件循环
	break	跳出循环
	continue	跳过当前循环的剩余部分，进入下一次迭代
异常处理	try	尝试执行代码块
	except	捕获异常
	finally	无论是否发生异常都会执行的代码块
	raise	抛出异常
函数定义	def	定义函数
	return	从函数返回值
	lambda	创建匿名函数
类与对象	class	定义类
	del	删除对象引用
模块导入	import	导入模块
	from	从模块导入特定部分
	as	为导入的模块或对象创建别名
作用域	global	声明全局变量
	nonlocal	声明非局部变量（用于嵌套函数）
异步编程	async	声明异步函数
	await	等待异步操作完成
其他	assert	断言，用于测试条件是否为真
	in	检查成员关系
	is	检查对象身份（是否是同一个对象）
	pass	空语句，用于占位
	with	上下文管理器，用于资源管理
	yield	从生成器函数返回值

3、变量

变量是指向内存中的数据引用实体，其名称必须是合法标识符，是标识符的一种具体应用。

以下进行标识符举例：

#	合法
age = 12
_name = "zhangsan"
M_name_age = 1888

#	非法
2n = 1     					# 错误：数字开头
user-name = "zs"             # 包含连字符
class = "Math"          	# 错误：使用关键字
$price = 9.99         		 # 错误：包含特殊字符

4、变量赋值（=）

python中变量赋值使用=号。

Python允许你同时为多个变量赋值，例如：a = b = c = 1

以上示例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。

也可以为多个对象指定多个变量，例如：a, b, c = 1, 2, "lisi"

以上示例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "lisi" 分配给变量 c。

一般情况下，每次只为一个变量赋值，例如：a = 1

5、注释

1.注释就是写个人注解用的，以防后期读不懂代码，注释部分不会被当作代码执行。

2.单行注释 # 开头 。

3.多行注释 ''' 和 """，三个单引号或双引号对注释部分包裹。 示例如下：

#  打印“hello”
print("hello")    # 打印
'''
第一行注释
第二行注释
'''
"""
第三行注释
第四行注释
"""

特别注意：python代码中的所有标点符号皆为英文（半角）！！！

6、行与缩进

1.python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

2.缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。 示例如下：

# 正确示例，一般缩进皆为一个制表符（Tab键），或者四个空格键。
if True:
    print ("True")
else:
    print ("False")



# 错误示范
if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进不一致，会导致运行错误

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

one = 1
two = 2
three = 3
total = one + \
        two + \
        three
print(total) # 输出为 6

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

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']
# 因为它们是一个整体，从[开始，到]结束

三、基本数据类型介绍

1、数字型

1.python中数字有四种类型：整数、布尔型、浮点数和复数。

• int (整数)，如 1， 只有一种整数类型 int。
• bool (布尔)，如 True、False，以为真（对）、假（错）。
• float (浮点数)，如 1.23，数学上称为小数。
• complex (复数) - 复数由实部和虚部组成，形式为 a + bj，其中 a 是实部，b 是虚部，j 表示虚数单位，虚部为0时不能省略。如 1 + 2j 、1.1 + 2.2j 、1 + 0j。

2、字符串

1.Python 中单引号 ' 和双引号 " 使用完全相同。

2.使用三引号(''' 或 """)可以指定一个多行字符串。

3.符串可以用 + 运算符连接在一起，用 * 运算符重复。

示例如下：

#  字符串
word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""

转义：

转义符 \，反斜杠。

转义顾名思义就是转换其本来的意思，\n：为换行；但是在转义符前加 r ，可以让反斜杠不转义，示例如下：

print('\n')       # 输出空行

print(r'\n')      # 输出 \n ，没有转移，输出字符串本身。
\n

空行：

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

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

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

用户输入：

input()：用于获取用户输入，将输入的内容转换成字符串类型，输入后回车结束输入。

输出：

print()：用于打印输出，默认输出换行，如果要实现不换行需要在变量末尾加上 end=""。

示例如下：

# 代码
a = input("请输入：")
print(a)

执行结果：

3、标准数据类型

• Number（数字）
• String（字符串）
• bool（布尔类型）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。 特别注意

type():

可以通过 type() 函数查看变量的类型，示例如下：

# 变量定义并赋值
x = 10          # 整数
y = 3.14         # 浮点数
name = "Alice"   # 字符串
is_active = True # 布尔值

# 多变量赋值
a, b, c = 1, 2, "three"

# 查看数据类型
print(type(x))        # <class 'int'>
print(type(y))        # <class 'float'>
print(type(name))     # <class 'str'>
print(type(is_active)) # <class 'bool'>

3.1、Number（数字）

Python支持 int、float、bool、complex（复数），定义变量并赋值，示例如下：

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'> # 整型、浮点型、布尔型、复数        

3.2、String（字符串）

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

a = "zhangsan"

3.3、Bool（布尔）

布尔类型即 True 或 False。

在 Python 中，True 和 False 都是关键字，表示布尔值。

0为false，非0为true。

3.4、List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

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

li = [1, 1.24, "yingzg"]

3.5、Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 ( ) 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同，例如：

tup  = (1, 2.33, "liuxz")

3.6、Set（集合）

Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。

集合中的元素不会重复（自动去重），并且可以进行交集、并集、差集等常见的集合操作。

在 Python 中，集合使用大括号 { } 表示，元素之间用逗号 , 分隔。

另外，也可以使用 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。示例如下：

set = {'Google', 'Taobao', 'Python', 'Facebook', 'Zhihu', 'Baidu'}    # 如有重复的元素，输出时自动去重。

3.7、Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

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

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

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

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

四、数据类型转换

Python 数据类型转换可以分为两种：

• 隐式类型转换 - 自动完成
• 显式类型转换 - 需要使用类型函数来转换

隐式类型转换其实就是定义变量时赋的值的类型，显式类型转换就是将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。例如：

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

以下几个内置的函数可以执行数据类型之间的转换：

函数	描述
int(x [,base]	将x转换为一个整数，base为转换的进制数，如int(12,16)，转为16进制
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运算符有哪些类型？

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符
• 运算符优先级

1.1、算术运算符

运算用的，用法与数学一致。

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 31
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除 - x 除以 y	b / a 输出结果 2.1
%	取模 - 返回除法的余数	b % a 输出结果 1
**	幂 - 返回x的y次幂	a**b 为10的21次方
//	取整除 - 往小的方向取整数	>>> 9//2 4

示例如下：

a = 21
b = 10
c = 0
 
c = a + b
print ("1 - c 的值为：", c)
 
c = a - b
print ("2 - c 的值为：", c)
 
c = a * b
print ("3 - c 的值为：", c)
 
c = a / b
print ("4 - c 的值为：", c)
 
c = a % b
print ("5 - c 的值为：", c)
 
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值为：", c)
 
a = 10
b = 5
c = a//b 
print ("7 - c 的值为：", c)

# 输出结果
1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2

1.2、比较运算符

顾名思义，进行比较。

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

示例如下：

a = 21
b = 10
c = 0
 
if ( a == b ):
   print ("1 - a 等于 b")
else:
   print ("1 - a 不等于 b")
 
if ( a != b ):
   print ("2 - a 不等于 b")
else:
   print ("2 - a 等于 b")
 
if ( a < b ):
   print ("3 - a 小于 b")
else:
   print ("3 - a 大于等于 b")
 
if ( a > b ):
   print ("4 - a 大于 b")
else:
   print ("4 - a 小于等于 b")
 
# 修改变量 a 和 b 的值
a = 5
b = 20
if ( a <= b ):
   print ("5 - a 小于等于 b")
else:
   print ("5 - a 大于  b")
 
if ( b >= a ):
   print ("6 - b 大于等于 a")
else:
   print ("6 - b 小于 a")
   
   
# 输出结果
1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a

1.3、赋值运算符

用于赋值操作，例如a+=1，a自增。

运算符	描述	实例
=	简单的赋值运算符	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

示例如下：

a = 21
b = 10
c = 0
 
c = a + b
print ("1 - c 的值为：", c)
 
c += a
print ("2 - c 的值为：", c)
 
c *= a
print ("3 - c 的值为：", c)
 
c /= a 
print ("4 - c 的值为：", c)
 
c = 2
c %= a
print ("5 - c 的值为：", c)
 
c **= a
print ("6 - c 的值为：", c)
 
c //= a
print ("7 - c 的值为：", c)

# 输出结果
1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864

1.4、逻辑运算符

运算符	逻辑表达式	描述	实例
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

示例如下：

a = 10
b = 20
 
if ( a and b ):
   print ("1 - 变量 a 和 b 都为 true")
else:
   print ("1 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("2 - 变量 a 和 b 都不为 true")
 
# 修改变量 a 的值
a = 0
if ( a and b ):
   print ("3 - 变量 a 和 b 都为 true")
else:
   print ("3 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("4 - 变量 a 和 b 都不为 true")
 
if not( a and b ):
   print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
   print ("5 - 变量 a 和 b 都为 true")

# 输出结果
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

其它运算符暂且不讲，请自行查阅。

2、数据类型

2.1、数字（Number）

Python 数字数据类型用于存储数值。

Python 支持三种不同的数值类型：

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

数字类型转换：

>>> a = 1.0
>>> int(a)    # int()强制转换浮点型（小数）为整形（整数）
1       

数字的运算不再赘述，详见算数运算符。

数学函数：

函数	返回（描述）
abs(x)	返回数字的绝对值，如abs(-10) 返回 10。
max(x)	返回给定参数的最大值，参数可以为序列。
min(x)	返回给定参数的最小值，参数可以为序列。
pow(x,i)	返回x的i次方的值。
round(x[,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根，即开二次方。注意：sqrt()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

随机数、三角函数不再介绍。

2.2、字符串（String）

字符串定义不再赘述，详见上面介绍，Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

字符串索引（切片），访问字符串中的值。

Python 访问子字符串，可以使用方括号 [ ] 来截取字符串，字符串的截取（切片）的语法格式如下：

变量[起始下标:终止下标:步长]  # 起始下标包括，终止标不包括，步长为每次跨几个。

索引方向	字符串及索引值
从后往前索引	-6 -5 -4 -3 -2 -1
从前往后索引	0 1 2 3 4 5
字符串"Qwerty"	Q w e r t y
从前面截取	:0 1 2 3 4 5:
从后面截取	:-6 -5 -4 -3 -2 -1:

字符串更新：

var1 = 'Hello World!'     # 注意空格自符串' ',和空字符串''的区别。 
print ("已更新字符串 : ", var1[:6] + 'python!')    # + 用于拼接字符串
# 输出  已更新字符串 :  Hello python!
# 特别注意：空格自符串长度为1，空字符串长度为0

转义字符表：

转义字 符	描述	实例
\(在行尾时)	续行符	>>> print("line1 \ ... line2 \ ... line3") line1 line2 line3 >>>
\\	反斜杠符号	>>> print("\\") \
\'	单引号	>>> print('\'') '
\"	双引号	>>> print("\"") "
\a	响铃	>>> print("\a")执行后电脑有响声。
\b	退格(Backspace)	>>> print("Hello \b World!") Hello World!
\000	空	>>> print("\000") >>>
\n	换行	>>> print("\n") >>>
\v	纵向制表符	>>> print("Hello \v World!") Hello World! >>>
\t	横向制表符	>>> print("Hello \t World!") Hello World! >>>
\r	回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。	>>> print("Hello\rWorld!") World! >>> print('google Python taobao\r123456') 123456 Python taobao
\f	换页	>>> print("Hello \f World!") Hello World! >>>
\yyy	八进制数，y 代表 0~7 的字符，例如：\012 代表换行。	>>> print("\110\145\154\154\157\40\127\157\162\154\144\41") Hello World!
\xyy	十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行	>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21") Hello World!
\other	其它的字符以普通格式输出

示例如下：

print('\'Hello, world!\'')  # 输出：'Hello, world!'

print("Hello, world!\nHow are you?")  # 输出：Hello, world!
                                        #       How are you?

print("Hello, world!\tHow are you?")  # 输出：Hello, world!    How are you?

print("Hello,\b world!")  # 输出：Hello world!

print("Hello,\f world!")  # 输出：
                           # Hello,
                           #  world!

print("A 对应的 ASCII 值为：", ord('A'))  # 输出：A 对应的 ASCII 值为： 65

print("\x41 为 A 的 ASCII 代码")  # 输出：A 为 A 的 ASCII 代码

decimal_number = 42
binary_number = bin(decimal_number)  # 十进制转换为二进制
print('转换为二进制:', binary_number)  # 转换为二进制: 0b101010

octal_number = oct(decimal_number)  # 十进制转换为八进制
print('转换为八进制:', octal_number)  # 转换为八进制: 0o52

hexadecimal_number = hex(decimal_number)  # 十进制转换为十六进制
print('转换为十六进制:', hexadecimal_number) # 转换为十六进制: 0x2a

字符串运算符：

操作符	描述	实例
+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果：HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分，遵循左闭右开（左包含右不包含）原则，str[0:2] 是不包含第 3 个字符的。	a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	'H' in a 输出结果 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	'M' not in a 输出结果 True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print( r'\n' ) print( R'\n' )
%	格式字符串	请看下一节内容。

示例如下：

a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
 
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
 
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")
 
print (r'\n')
print (R'\n')



# 输出结果
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

字符串格式化：

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。示例如下：

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

字符串格式化符号表：

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

f-string格式化:

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

之前我们习惯用百分号 (%)：

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

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，示例如下：

name = 'Python'
f'Hello {name}'  # 替换变量
'Hello Python'
f'{1+2}'         # 使用表达式
'3'

 w = {'name': 'Python', 'url': 'www.Python.com'} # 这是字典，键值对
 f'{w["name"]}: {w["url"]}'
'Python: www.Python.com'

format()格式化输出：

format()函数是Python中用于格式化字符串的强大工具，同样使用大括号{}占位，以下简称为“槽”，按“槽”给值，一个萝卜一个坑，基本语法如下：

"字符串{}".format(值)
"字符串{}，{}，{}".format(值1，值2，值3)    # {} 槽中不填序号，则从左往右依次填充
"字符串{1}，{0}，{2}".format(值2，值1，值3) # {} 槽中填序号，则按序号012依次填充

示例如下：

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

2.3、列表（List）

序列是 Python 中最基本的数据结构。

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

Python 有 6 个序列的内置类型，但最常见的是列表和元组。

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Python', 1997, 2000]
list2 = [1, 2, 3, [4, 5]]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

列表索引：

与字符串索引一致，下标从0开始（从前往后/从左到右），从后往前索引（右到左）下标从-1（最后（右）边的元素）开始。索引语法如下：

变量[下标]  

示例如下：

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )
print( list[-1] )
print( list[-2] )
print( list[-3] )

#    结果
red
green
blue
black
white
yellow

列表切片：

与字符串切片一致，语法如下：

变量[起始下标:终止下标:步长]  # 起始下标包括，终止标不包括，步长为每次跨几个。

切片示例如下：

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
# 结果   [10, 20, 30, 40]



list = ['Google', 'python', "Zhihu", "Taobao", "Wiki"]
# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])
# 结果
list[1]:  python
list[1:-2]:  ['python', 'Zhihu']

更新列表：

你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：

list = ['Google', 'Python', 1997, 2000]

print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])

list1 = ['Google', 'Python', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

# 结果
第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的列表 :  ['Google', 'Python', 'Taobao', 'Baidu']

删除列表元素：

可以使用 del 语句来删除列表中的元素，示例如下：

list = ['Google', 'python', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]   				 # 索引删除
print ("删除第三个元素 : ", list)

# 结果
原始列表 :  ['Google', 'python', 1997, 2000]
删除第三个元素 :  ['Google', 'python', 2000]

列表操作符：

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表，如下所示：

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

列表截取与拼接：

列表截取与字符串操作类似，如下所示：

L=['Google', 'python', 'Taobao']

操作：

Python 表达式	结果	描述
L[2]	'Taobao'	读取第三个元素
L[-2]	'python'	从右侧开始读取倒数第二个元素: count from the right
L[1:]	['python', 'Taobao']	输出从第二个元素开始后的所有元素

>>> L=['Google', 'python', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'python'
>>> L[1:]
['python', 'Taobao']
>>>

列表还支持拼接操作：

>>> squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]   # a+=1  <==>  a=a+1 
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

列表嵌套：

使用嵌套列表即在列表里创建其它列表，例如：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [['a', 'b', 'c'], [1, 2, 3]]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

列表比较暂且不讲。

列表常用函数&方法：

序号	函数
1	len(list)列表元素个数
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj)统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj)从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)将对象插入列表
6	list.pop([index=-1\]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse()反向列表中元素
9	list.sort( key=None, reverse=False) 对原列表进行排序 ，False升序（默认），True降序
10	list.clear()清空列表
11	list.copy()复制列表

2.4、元组（Tuple）

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

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可，示例如下：

>>> tup1 = ('Google', 'python', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>
# 创建空元组
tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等，示例如下：

tup1 = ('Google', 'python', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

# 结果
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，示例如下：

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100  报错
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
>>>(12, 34.56, 'abc', 'xyz')

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，示例如下：

tup = ('Google', 'python', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

>>>删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined   # 报错“未定义”

元组运算符：

与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> c = a+b >>> c (1, 2, 3, 4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接，c 就是一个新的元组，它包含了 a 和 b 中的所有元素。
>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> a += b >>> a (1, 2, 3, 4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接，a 就变成了一个新的元组，它包含了 a 和 b 中的所有元素。
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制（重复）
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x, end=" ")	1 2 3	迭代

元组索引、截取（切片）：

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，示例如下：

tup = ('Google', 'python', 'Taobao', 'Wiki', 'Weibo','Weixin')

Python 表达式	结果	描述
tup[1]	'python'	读取第二个元素。
tup[-2]	'Weibo'	反向读取，读取倒数第二个元素。
tup[1:]	('python', 'Taobao', 'Wiki', 'Weibo', 'Weixin')	截取元素，从第二个开始后的所有元素。
tup[1:4]	('python', 'Taobao', 'Wiki')	截取元素，从第二个开始到第四个元素（索引为 3）。

代码示例如下：

>>> tup = ('Google', 'python', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'python'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('python', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('python', 'Taobao', 'Wiki')

元组的内置函数：

序号	方法及描述	实例
1	len(tuple) 计算元组元素个数。	>>> tuple1 = ('Google', 'python', 'Taobao') >>> len(tuple1) 3
2	max(tuple) 返回元组中元素最大值。	>>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8'
3	min(tuple) 返回元组中元素最小值。	>>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4'
4	tuple(iterable) 将可迭代系列转换为元组。	>>> list1= ['Google', 'Taobao', 'python', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'python', 'Baidu')

元组不可变的原因：

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素  报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

从以上示例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。（对象改变-->内存改变了）

2.5、字典（Dictionary）

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

注意： dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。

	key1	value1
字典	key2	value2
	key3	value3

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字，示例如下：

tinydict = {'name': 'python', 'likes': 123, 'url': 'www.python.org'}
tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }

使用大括号 { } 创建空字典：
emptyDict = {}
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:", len(emptyDict))
# 查看类型
print(type(emptyDict))

# 结果
{}
Length: 0
<class 'dict'>


使用内建函数 dict() 创建字典：
emptyDict = dict()
# 打印字典
print(emptyDict) 
# 查看字典的数量
print("Length:",len(emptyDict)) 
# 查看类型
print(type(emptyDict))

# 结果
{}
Length: 0
<class 'dict'>

访问字典里的值：

tinydict = {'Name': 'python', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])

# 结果
tinydict['Name']:  python
tinydict['Age']:  7

如果用字典里没有的键访问数据，会输出错误如下：

tinydict = {'Name': 'python', 'Age': 7, 'Class': 'First'}
print ("tinydict['Alice']: ", tinydict['Alice'])

# 结果 报错
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'

也可以使用 d.get(‘键’)方法来访问字典的值，如果键名不存在则返回空，如下：   # 其中d为字典名
tinydict = {'Name': 'python', 'Age': 7, 'Class': 'First'}
print("tinydict.get['Alice']: ", tinydict.get('Alice'))

# 结果
tinydict.get['Alice']:  None

删除字典元素：

能删单一的元素也能清空字典，清空只需一项操作。

显式删除一个字典用del命令，示例如下：

tinydict = {'Name': 'python', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
 
print ("tinydict['Age']: ", tinydict['Age'])   # 结果会报错，因为del删除字典了
print ("tinydict['School']: ", tinydict['School'])

2.6、集合（Set）

集合（set）是一个无序的不重复元素序列。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。

集合创建格式：

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

示例如下：

set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

更多示例如下：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

添加元素：

s.add( x ) 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

>>> thisset = set(("Google", "python", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'python'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x ) x 可以有多个，用逗号分开。

>>> thisset = set(("Google", "python", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'python'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'python'}
>>>

移除元素：

s.remove( x ) 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误，示例如下：

>>> thisset = set(("Google", "python", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'python'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

>>> thisset = set(("Google", "python", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'python'}

也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop()

thisset = set(("Google", "python", "Taobao", "Facebook"))
x = thisset.pop()

print(x)
# 结果 python

计算集合元素个数：

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

>>> thisset = set(("Google", "python", "Taobao"))
>>> len(thisset)
3

清空集合：

s.clear() 清空集合 s。

>>> thisset = set(("Google", "python", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

判断元素是否在集合中存在：

x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

>>> thisset = set(("Google", "python", "Taobao"))
>>> "python" in thisset
True
>>> "Facebook" in thisset
False
>>>

六、流程控制

1、条件控制

条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。

if 语句，格式如下：

if condition_1:
    statement_block_1
elif（else if） condition_2:
    statement_block_2
else:
    statement_block_3

• 如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句。
• 如果 "condition_1" 为False，将判断 "condition_2"。
• 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句。
• 如果 "condition_2" 为False，将执行"statement_block_3"块语句。

注意：

• Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。
• 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
• 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

单分支语句示例如下：

var1 = 100
if var1:
    print ("1 - if 表达式条件为 true")
    print (var1)
 
var2 = 0
if var2:
    print ("2 - if 表达式条件为 true")
    print (var2)
print ("Good bye!")

# 结果
1 - if 表达式条件为 true
100
Good bye!
# 第二个if语句为什么没有执行，因为“var2 = 0”，条件为false，详见布尔数据类型。

以下示例演示了狗的年龄计算判断：

age = int(input("请输入你家狗狗的年龄: "))
print("")
if age <= 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相当于 14 岁的人。")
elif age == 2:
    print("相当于 22 岁的人。")
elif age > 2:
    human = 22 + (age -2)*5
    print("对应人类年龄: ", human)
 
# 结果
请输入你家狗狗的年龄: 1
相当于 14 岁的人。

以下为 if 中常用的操作运算符：

操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于，比较两个值是否相等
!=	不等于

示例如下：

# 程序演示了 == 操作符
# 使用数字
print(5 == 6)
# 使用变量
x = 5
y = 8
print(x == y)

# 输出
False
False

数字的比较运算如下：

number = 7
guess = -1
print("数字猜谜游戏!")
while guess != number:       # 采用了while循环，后面讲
    guess = int(input("请输入你猜的数字："))
 
    if guess == number:
        print("恭喜，你猜对了！")
    elif guess < number:
        print("猜的数字小了...")
    elif guess > number:
        print("猜的数字大了...")
 
 # 结果
 数字猜谜游戏!
请输入你猜的数字：1
猜的数字小了...
请输入你猜的数字：9
猜的数字大了...
请输入你猜的数字：7
恭喜，你猜对了！

if 嵌套

在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中，语句格式如下：

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

示例如下：

num=int(input("输入一个数字："))
if num%2==0:
    if num%3==0:
        print ("你输入的数字可以整除 2 和 3")
    else:
        print ("你输入的数字可以整除 2，但不能整除 3")
else:
    if num%3==0:
        print ("你输入的数字可以整除 3，但不能整除 2")
    else:
        print  ("你输入的数字不能整除 2 和 3")
        
#  结果
输入一个数字：6
你输入的数字可以整除 2 和 3

2、循环控制

Python 中的循环语句有 for 和 while。

2.1、while循环

while 语句的一般形式：

while 判断条件(condition)：
    执行语句(statements)……

while循环是死循环，条件为真（True）永远执行，一般情况下会加条件进行控制。

同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环。

以下示例使用了 while 来计算 1 到 100 的总和：

n = 100
 
sum = 0       # 初始化“和”
counter = 1   # 初始化起始值
while counter <= n:   # n可以直接换成100
    sum = sum + counter
    counter += 1
 
print("1 到 %d 之和为: %d" % (n,sum))    # %d占位符，详见格式化输出

# 结果
1 到 100 之和为: 5050

无限循环（死循环）：

var = 1
while var == 1 :  # 表达式永远为 true
   num = int(input("输入一个数字  :"))
   print ("你输入的数字是: ", num)
 
print ("挂科！！")   # 因为条件恒真，所以永远不挂科。

# 结果
输入一个数字  :5
你输入的数字是:  5
输入一个数字  :
.
.
.

注意：上面示例的print ("挂科！！")不执行的真正原因是python代码永远从上往下执行，只要有一部分代码死循环，就不会往下执行。示例中while条件恒真，所以永远不执行print ("挂科！！")语句。

while循环加else语句：

如果 while 后面的条件语句为 false 时，则执行 else 的语句块，语法格式如下：

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>
    
# expr 条件语句为 true 则执行 statement(s) 语句块，如果为 false，则执行 additional_statement(s)。    

循环输出数字，并判断大小：

count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1   # 等价count += 1
else:
   print (count, " 大于或等于 5")
   
# 结果
0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

简单while语句组：

类似 if 语句的语法，如果你的 while 循环体中只有一条语句，你可以将该语句与 while 写在同一行中， 如下所示：

flag = 1
while (flag): print ('永远不挂科!')     # 条件恒真，一条语句

# 结果
永远不挂科!
永远不挂科!
永远不挂科!
永远不挂科!
......

2.2、for循环

for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

遍历：可以理解为 “每一遍都经历”。

for循环的一般格式如下：

for <variable> in <sequence>:    # for 表达式 in ..中:
    <statements>				#	语句
else:							
    <statements>

示例如下：

sites = ["Baidu", "Google","python","Taobao"]
for site in sites:
    print(site)     # 默认换行，取消换行 end=""

# 结果
Baidu
Google
python
Taobao

也可用于打印字符串中的每个字符：

str = "逢考必过不挂科"
for i in str:
    print(i)
       
# 结果
逢
考
必
过
不
挂
科

整数范围值可以配合 range() 函数使用：

#  1 到 5 的所有数字：
for number in range(1, 6):
    print(number,end="")   # 取消换行

# 结果
12345

range()函数详讲：

range()函数基本语法：range(起始值,终止值,步长)

如果你需要遍历数字序列，可以使用内置 range() 函数。它会生成数列，例如：

for number in range(6):
    print(number) 
    
# 结果
1
2
3
4
5

也可以使用 range() 指定区间的值：

for number in range(6,10):
    print(number)
    
# 结果
6
7
8
9

也可以使 range() 以指定数字开始并指定不同的增量：

for i in range(0, 10, 3) :
    print(i)
 
# 结果    
0
3
6
9

for i in range(-10, -100, -30) :
    print(i)
 
# 结果   
-10
-40
-70

还可以结合 range() 和 len() 函数以遍历一个序列的索引,如下所示：

>>>a = ['Google', 'Baidu', 'python', 'Taobao', 'QQ']
>>> for i in range(len(a)):
    	 print(i, a[i])

0 Google
1 Baidu
2 python
3 Taobao
4 QQ

还可以使用 range() 函数来创建一个列表：

>>> list(range(5))
>>> [0, 1, 2, 3, 4]

range()函数是不是很强大，相信聪明的你已经发现range函数是一个前闭后开区间（前包含，后不包含），但还有一些注意点。

注意：

• 如果只提供开始值和结束值，那么步长默认为 1。
• 如果只提供一个参数，它将生成一个从 0 开始的整数序列，参数为结束值，步长默认为 1。
• 如果使用负数作为步长，则开始值必须大于结束值。

for...else 语句：

for...else 语句用于在循环结束后执行一段代码，语法格式如下：

for item in iterable:
    # 循环主体
else:
    # 循环结束后执行的代码

当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码，如果在循环过程中遇到了 break 语句，则会中断循环，此时不会执行 else 子句，示例如下：

for x in range(6):
  print(x)
else:
  print("完成")
  
# 结果
0
1
2
3
4
5
完成

以下 for 示例中使用了 break 语句，break 语句用于跳出当前循环体，不会执行 else 子句：

sites = ["Baidu", "Google","python","Taobao"]
for site in sites:
    if site == "python":
        print("跳出循环，略过淘宝!")
        break
    print("循环数据 " + site)   ##
else:						##   全部跳出循环，不执行
    print("没有循环数据!")	 ##
print("完成循环!")

# 结果
循环数据 Baidu
循环数据 Google
跳出循环，略过淘宝!
完成循环!

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环，示例如下：

n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
print('循环结束。')

# 结果
4
3
1
0
循环结束。

pass语句暂且不讲，pass 不做任何事情，一般用做占位语句，了解即可。

**end ** 关键字：

可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，示例如下：

# 斐波那契
a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a+b

# 结果
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

七、函数

1、函数的定义

什么是函数？

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

函数定义的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

定义函数使用 def 关键字，一般格式如下：

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

示例如下：

def hello() :    # hello()函数名，无参
    print("Hello World!")

hello()  # 函数调用

# 结果
Hello World!

2、函数的调用

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

如下示例调用了 printme() 函数：

# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

# 结果
我要调用用户自定义函数!
再次调用同一函数

3、参数

以下是调用函数时可使用的正式参数类型：

• 必需参数
• 关键字参数
• 默认参数
• 不定长参数

必须参数：

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

调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：

#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme()

# 结果
Traceback (most recent call last):
  File "test.py", line 10, in <module>
    printme()
TypeError: printme() missing 1 required positional argument: 'str'

关键字参数：

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

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

以下实例在函数 printme() 调用时使用参数名：

# 可写函数说明
def printme(str1,str2):
    # "打印任何传入的字符串"
    print(str1)
    print(str2)
    return


# 调用printme函数
printme(str2="必过",str1="逢考")    # 传参不需要指定顺序

# 结果
逢考
必过

默认参数：

调用函数时，如果没有传递参数，则会使用默认参数。以下示例中如果没有传入 age 参数，则使用默认值：

#可写函数说明
def printinfo( name, age = 35 ):    # age=35为默认参数
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="python" )
print ("------------------------")
printinfo( name="python" )

# 结果
名字:  python
年龄:  50
------------------------
名字:  python
年龄:  35

不定长参数与匿名函数不在详讲。

八、面向对象

1、面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

特点：封装、继承、多态

2、类定义

语法格式如下：

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

3、类对象

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样：

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
#  以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象

# 结果
MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

类有一个名为__init()__的特殊方法（构造方法）也称为初始化方法，该方法在类实例化时会自动调用，像下面这样：

def __init__(self):
    self.data = []

类定义了 init() 方法，类的实例化操作会自动调用__init__()方法。如下实例化类 MyClass，对应的__init__()方法就会被调用：

x = MyClass()

当然，__init__()方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如：

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，按照惯例它的名称是 self。

self 是一个惯用的名称，用于表示类的实例（对象）自身。它是一个指向实例的引用，使得类的方法能够访问和操作实例的属性。示例如下：

class MyClass:
    def __init__(self, value):
        self.value = value

    def display_value(self):
        print(self.value)

# 创建一个类的实例
obj = MyClass(42)

# 调用实例的方法
obj.display_value() # 输出 42

# 在上面的例子中，self 是一个指向类实例的引用，它在 __init__ 构造函数中用于初始化实例的属性，也在 display_value 方法中用于访问实例的属性。通过使用 self，你可以在类的方法中访问和操作实例的属性，从而实现类的行为。

4、类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('python',10,30)
p.speak()

# 结果
python 说: 我 10 岁。

5、继承

派生类的定义如下所示：

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法，示例如下：

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()

# 结果
ken 说: 我 10 岁了，我在读 3 年级

多继承暂且不讲。

九、文件处理

1、open()方法

Python open() 方法用于打开一个文件，并返回文件对象。

在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

完整的语法格式为：

open(file, mode='r',  encoding=None, buffering=-1, errors=None, newline=None, closefd=True, opener=None)

# 现在都用  with open(file, mode='r',encoding='utf-8')  with语句自动关闭文件，无需手动调用close()

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode参数：

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

默认为文本模式，如果要以二进制模式打开，加上 b 。

2、file对象

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数。

读取类：

方法名	核心功能	关键说明/注意事项
read(size=-1)	默认读取文件全部内容，指定 size 则读取对应长度的字符（文本模式）或字节（二进制模式）	1. size=-1 是默认值（读取全部）；2. 读取后文件指针会移动到读取末尾；3. 大文件慎用（占用内存）
readline()	逐行读取文件内容，每次返回一行	1. 读取到文件末尾返回空字符串 ""；2. 适合处理大文件；3. 返回结果包含行尾的 \n 换行符
readlines()	读取文件所有行，返回一个以每行为元素的字符串列表	1. 列表中每个元素对应文件的一行（包含 \n）；2. 可配合 enumerate() 遍历行号和内容

写入类：

方法名	核心功能	关键说明/注意事项
write(string)	向文件中写入指定字符串，返回写入的字符数（文本模式）或字节数（二进制模式）	1. 不会自动添加换行符，需手动加 \n；2. 'w' 模式会覆盖原有内容，'a' 模式追加在末尾
writelines(sequence)	向文件中写入字符串序列（列表、元组等可迭代对象）	1. 不会给每个序列元素自动添加换行符，需提前在元素中加入 \n；2. 仅写入字符串，非字符串需先转换
flush()	强制将内存中缓存的写入内容刷新到磁盘中	1. close() 和 with 语句会自动调用；2. 特殊场景（需立即持久化内容）下手动使用

---

至此，python基础知识整理完成，如有错误，劳烦指正，感谢支持！