第一章
👉个人信息- 属性1：填合适内容
- 属性2：填合适内容
- 属性3：填合适内容
- ipynb文件下载：https://wwm.lanzouf.com/iT8K5023qare
- 整本书放在本文最下方
语法基础
1. 代码注释方法
例1-1
#-*- coding: utf-8 -*-
"""
遍历list中的元素
Created on Sun Mar 13 21:20:06 2016
@author: yubg
"""
lis = [1,2,3]
for i in lis: #半角状态冒号不能少, 行注意缩进
i += 1
print(i)
2
3
4
2. 用缩进来表示分层
Python的语句块是使用代码缩进4个空格来表示分层， 当然也可以使用一个Tab键来替代4个空格。
3. 语句断行
from pandas import DataFrame #导入模块中的函数, 后面会讲解
from pandas import Series
df = DataFrame({'age':Series ([26, 85, 64]),
'name':Series(['Ben','Joh','Jef'])})
print (df)
age name
0 26 Ben
1 85 Joh
2 64 Jef
3. print()的作用
A = input('从键盘接收输入：')
print("打印出刚才的输入A: " , A)
从键盘接收输入：青青河畔草，绵绵思远道
打印出刚才的输入A: 青青河畔草，绵绵思远道
4. 在一个字符串中嵌入一个单引号
有以下两种方法：
（1） 字符串在单引号中， 可以在单引号前加反斜杠（＼）嵌入， 如＼ ＇。
（2） 字符串在双引号中， 可以直接加单引号嵌入。即’和"在使用上没
有本质差别， 但同时使用时要注意区别。
s1 = 'I\'d been loving three things in this world.\nSun,Moon and You.'
print(s1)
I'd been loving three things in this world.
Sun,Moon and You.
程序结构
Hello world !
print("Hello World !")
Hello World !
运算符介绍
- 比较运算符
| 运算符 | 意义 |
|---|---|
| x<y | 判断x是否小于y，如"是"则返回真，否则返回假 |
| x<=y | 判断x是否小千等千y，如"是"则返回真，否则返回假 |
| x>y | 判断x是否大千y，如"是"则返回真，否则返回假 |
| x>=y | 判断x是否大千等于y，如"是"则返回真，否则返回假 |
| x==y | 判断x是否等千y，如"是"则返回真，否则返回假 |
| x!=y | 判断x是否不等千y，如"是" 则返回真，否则返回假 |
| x is y | 判断x的地址(id)是否等，如"是"返回真，否则返回假 |
| x is not y | 判断x的地址(id)是否不等于y，如"是"则返回真，否则返回假 |
print(1<2)
print(1<=2)
print(1>2)
print(1>=2)
print(1==2)
print(1!=2)
True
True
False
False
False
True
1 is 2
<>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
<>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
C:\Users\b2014\AppData\Local\Temp\ipykernel_8980\1180083856.py:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
1 is 2
False
1 is not 2
<>:1: SyntaxWarning: "is not" with a literal. Did you mean "!="?
<>:1: SyntaxWarning: "is not" with a literal. Did you mean "!="?
C:\Users\b2014\AppData\Local\Temp\ipykernel_8980\1952261205.py:1: SyntaxWarning: "is not" with a literal. Did you mean "!="?
1 is not 2
True
- 数值运算符
| 运算符 |
|
|---|---|
| x = y | 将y赋值给x |
| x+y | 返回x+y的值 |
| x-y | 返回x-y的值 |
| x*y | 返回x*y的值 |
| x/y | 返回x/y 的值 |
| X//y | 返回x除y的整数部分 |
| x%y | 返回x除y的余数 |
| -x | 返回负x |
| +x | 返回正x |
| abs(x) | 返回x的绝对值 |
| int(x) | 返回x的整数值 |
| float(x) | 返回x的浮点数 |
| complex(re,im) | 定义复数 |
| c.conjugate() | 返回复数的共辄复数 |
| divmod(x,y) | 相当千(x//y,x%y) |
| pow(x,y) | 返回x的y次方 |
| x ** y | 相当于pow(x,y) |
顺序结构
用顺序结构的程序将直接一行一行地执行代码直到程序结束。
例1-2 解一元二次方程（存在解的情况）
A = float(input( "输入A:"))
B = float(input( "输入B:"))
C = float(input("输入C:"))
#计算delta
delta = B**2 -4 * A * C
#计3,f方程的两个根
x1 = (B + delta**0.5) / (-2 * A)
x2 = (B - delta**0.5) / (-2 * A)
#输出两个解
print ("x1=", x1)
print("x2=", x2)
输入A:1
输入B:-3
输入C:2
x1= 1.0
x2= 2.0
判断结构
例1-3
#输入A 、B 、C
def solution():
A = float(input("输入A:"))
B = float(input("输入B:"))
C = float(input("输入C:"))
#计算delta
delta = B**2 - 4 * A* C
#判断解的个数
if delta < 0:
print("该方程无解！")
elif delta == 0:
x = B / (-2 * A)
print("x1 =x2 =", x)
else:
#计绊xl、x2
xl = (B + delta**0.5) / (-2 * A)
x2 = (B - delta**0.5) / (-2 * A)
#输出xl 、x2
print("x1=", x1)
print("x2=", x2)
solution()
solution()
输入A:1
输入B:-4
输入C:4
x1 =x2 = 2.0
输入A:1
输入B:4
输入C:2
x1= 1.0
x2= -0.5857864376269049
循环结构
- while循环
n = int(input("请输入结束的数："))
i = 1
su = 0
while i <= n:
su += i
i += 1
print("从1加到%d结果是: %d" %(n, su))
请输入结束的数：100
从1加到100结果是: 5050
- for循环
n = int(input("请输入结束的数："))
i = 1
su = 0
for i in range(n + 1):
su += i
print("从1加到%d结果是： %d" %(n,su))
请输入结束的数：100
从1加到100结果是： 5050
异常
在Python中，try/except语句主要是用于处理程序正常执行过程中出现的一些异常悄况， 如语法错误、数据除零错误、从未定义的变量上取值等；
尽管try/except和try/finlaly的作用不同， 但是在编程实践中通池可以把它们组合在一起， 使用tyr/execpte/else/finally的形式来实现稳定性和灵活性更好的设计。
Python 中try/except/else/finally 诏句的完整格式如下:
try:
Normal execution block
except A:
Exception A handle
except B:
Exception B handle
except:
Other exception handle
else: #可无， 若有， 则必有except x 或except 块存在仅在try 后无异常时执行
if no exception, get here
finally: #此语句务必放在最后， 并且也是必须执行的语句
print("finally")
- try-except结构
try:
处理代码
except Exception as e:
处理代码发生异附， 在这甩进行异＇常处理
try:
print(l / 0)
except Exception as e:
print('代码出现除0异常， 这里进行处理！')
print("我还在运行")
代码出现除0异常， 这里进行处理！
我还在运行
except Exception as e:捕获错误， 并输出信息。程序捕获错误后， 并没有
“死＂ 掉或者终止， 还在继续执行后面的代码。
- try-except-finally结构
该结构运行过程如下： 程序进入try语句部分， 当try语句部分发生异常则
进入except语句部分， 若不发生异常则进入else语句部分。示例代码如下:
try:
print(l / 0)
except Exception as e:
print("除0异常")
finally:
print("必须执行")
print(" -－－－－－－－－－－－－－－－－")
try:
print("这里没有异常")
except Exception as e:
print("这句话不会输出")
finally:
print("这里是必须执行的")
除0异常
必须执行
-－－－－－－－－－－－－－－－－
这里没有异常
这里是必须执行的
- try-except-else结构
顾名思义， 这是try-except-else结构的升级版， 在原有的基础上增加了必须
要执行的部分。示例代码如下：
try:
print( "正常代码！")
except Exception as e:
print( "将不会输出这句话" )
else:
print( "这句话将被输出")
print("-------------------")
try:
print(1 / 0)
except Exception as e:
print( "进入异常处理" )
else:
print( "不会输出" )
正常代码！
这句话将被输出
-------------------
进入异常处理
- try-except-else-finally结构
try:
print( "没有异常！")
except Exception as e:
print( "不会输出！")
else:
print("进入else")
finally:
print( "必须输出")
print("-------------------")
try:
print(1/0)
except Exception as e:
print( "引发异常！" )
else:
print( "小会进入else")
finally:
print( "必须输出！ ")
没有异常！
进入else
必须输出
-------------------
引发异常！
必须输出！
函数
基本函数结构
def f(x, y):
z = x**2 + y**2
return z
res = f(2, 3)
print(res)
13
参数结构
-
传统参数传递
-
默认参数传递
Python默认参数传递的机制减少了重复参数的多次输入，函数允许默认参数是大多数程序语言都支持的。通过下面的代码来介绍这种机制。
def func (x, y=100, z="hello"):
print(x, y, z)
func(0)
func(0, 1)
func(0, 34, "world")
func(66, z ="hello world")
func(44, y= 90, z= "kkk")
0 100 hello
0 1 hello
0 34 world
66 100 hello world
44 90 kkk
- 未知参数个数传递
对于某些函数，我们不知道传进来多少个参数，只知道对这些参数进行怎样的处理。Pyhton允许我们创造这样的函数，即未知参数个数的传递机制，只斋要在参数前面加个＊就可以了。
def func(name,*args):
print(name+" 有以下雅称： ")
for i in args:
print(i)
func('尹钞院','猴子','毛毛' ,'尹麦霸')
尹钞院 有以下雅称：
猴子
毛毛
尹麦霸
- 带键参数传递
***带键参数传递是指参数通过键值对的方式进行传递。什么叫键值对？下面
这个例子将会展示这种结构。带键参数的传递只需要在参数前面加＊＊就可以
了。***
示例代码如下:
def func(**kwargs):
print (type (kwargs))
for i in kwargs:
print(i, kwargs[i])
func(aa= 1, bb= 2, cc= 3)
print("--- ------")
func(x= 1, y=2, z="hello")
<class 'dict'>
aa 1
bb 2
cc 3
--- ------
<class 'dict'>
x 1
y 2
z hello
回调函数
***回调函数又叫函数回调， 指的是将函数作为参数传递到另外的函数中执
行。例如将A函数作为参数传递到B函数， 然后在B函数中执行A函数。这
种做法的好处是在函数被定义之前就可以使用函数， 或者对千其他程序提供的
API（可看成函数）进行调用。***
概念比较抽象， 下面以例子说明。示例代码如下:
def func(fun, args):
fun(args)
def fl (x) :
print("这是fl凶数：" , x)
def f2 (x) :
print("这是f2函数：", x)
func(fl, 1)
func(f2, "hello")
这是fl凶数： 1
这是f2函数： hello
函数的递归与嵌套
- 函数的递归
函数的递归是指函数在泊数休中直接按或间接地调用自身的现象。递归要有停止条件， 否则函数将永远儿法跳出递归， 成了死循环。
def fib(n) :
if n <= 2:
return 1
else:
return fib(n-1)+fib(n-2)
for i in range (1, 10):
print("fib(%s)=%s" % (i, fib(i)))
fib(1)=1
fib(2)=1
fib(3)=2
fib(4)=3
fib(5)=5
fib(6)=8
fib(7)=13
fib(8)=21
fib(9)=34
- 函数的嵌套
函数的嵌套是指在函数中调用另外的函数。这是函数式编程的重要结构也是我们在编程中最常用的一种程序结构。
下面利用函数的嵌套重写1.3.4节解方程的程片。
def args_input():
#定义输入函数
try:
A = float(input( "输入A:"))
B = float(input( "输入B:"))
C = float(input( "输入C:"))
return A, B, C
except: #输入出错则重新输入
print( "请输入正确的数值类型！")
return args_input() #为了出错时能够重新输入
def get_delta(A, B, C):
#计氧delta
return B**2 - 4 *A* C
def solve():
A, B, C = args_input()
delta = get_delta(A, B, C)
if delta < 0:
print( " 该方程无解！ ")
elif delta == 0:
x = B / (-2 * A)
print ("x=", x)
else:
#计算xl、x2
xl = (B + delta**0.5) / (-2 * A)
print ("xl=", xl)
print("x2=", x2)
#在当前程序下直接执行本程序
def main() :
solve()
if __name__ == '__main__'
main()
输入A:2
输入B:a
请输入正确的数值类型！
输入A:2
输入B:5
输入C:1
xl= -2.2807764064044154
x2= -0.21922359359558485
闭包
***所谓的闭包其实跟回调函数有相通之处。回调函数是将函数作为参数传递， 而闭包是将函数作为返回值返回。***
闭包可以延长变量的作用时间与作用域看下面的例子：
def say(word):
def name(name):
print(word, name)
return name
hi = say(' 你好')
hi('小明')
bye = say( ' 再见')
bye ( '小明')
你好 小明
再见 小明
通过下面的例子，更深刻地理解闭包的概念
def func():
res =[]
def put(x):
res.append(x)
def get():
return res
return put, get
p,g=func()
p(1)
p(2)
print("当前res值：",g())
p(3)
p(4)
print("当前res：",g())
当前res值： [1, 2]
当前res： [1, 2, 3, 4]
匿名函数lambda
Python中允许用lambda关键字定义一个匿名函数。所谓匿名函数，是指调用一次或几次后就不再需要的函数，属千 ”一次性 ” 函数。 示例代码如下：
#求两数之和， 定义函数 f(x,y)=x+y
f = lambda x, y: x + y
print(f(2, 3))
#或者这样求两数的平方和
print((lambda x, y: x**2 + y**2) (3, 4))
5
25
关键字yield
yield关键字可以将函数执行的中间结果返回但不结束程序。听起来比较抽象，用起来却很简单。下面的例子将模仿range(）函数写一个自己的range。
代码如下：
def func(n):
i = 0
while i < n:
yield i
i +=1
for i in func(10):
print(i)
0
1
2
3
4
5
6
7
8
9
代码1：简单输出斐波那契数列前N个数
def fab(rnax):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a+ b
n = n + 1
代码2：输出斐波那契数列前N个数（笫二个版本）
def fab(rnax):
n, a, b = 0, 0, 1
L = []
while n < max:
L.append(b)
a, b = b, a+ b
n = n + 1
return L
代码3:使用yield关键字输出斐波那契数列前N个数
def fab(max):
n, a, b = 0, 0, 1
while n < max:
yield b
#print(b)
a, b = b, a+ b
n -- n + 1
数据结构
列表
- 列表的定义
s=[1,2,3,4,5]
- list的常用函数
| 函数名 |
|
|---|---|
| list.append(x ) | 将元素x 追加到列表尾部 |
| list. extend(L) | 将列表L中的所有元素追加到列表尾部形成新列表 |
| list.insert(i, x) | 在列表中index为i的位置插入x元素 |
| list.remove(x) | 将列表中第一个为x的元素移除。若不存在x元素将引发一个异常 |
| list.pop(i) | 删除index为i的元素， 并将删除的元素显示。若不指定i’则默认弹出最后一个元素 |
| list.clear() | 消空列表 |
| list.index(x) | 返回第一个x元素的位置， 若不存在X, 则报错 |
| list.count(x) | 统计列表中x元素的个数 |
| list.reverse() | 将列表反向排列 |
| list.sort() | 将列表从小到大排序。若需从大到小排序， 则用list.sort(reverse=True)表示 |
| list.copy() | 返回列表的副本 |
元组
元组(tuple) 跟list 很像， 只不过是用小括号（）的形式，但是tuple中的元素一旦确定就不可更改。下面两种方式都是定义一个tuple。
集合
集合(set)是大多数程序语言都会提供的数据结构。它不能保存重复的数据， 即具有过滤重复数据的功能。
字典
字典(dict) 又称键值对， 前面曾简单地介绍过这种数据结构。
集合的操作
| 操作符或函数 |
|
|---|---|
| x in S | 如果S中包含x元素， 则返回True, 否则返回False |
| x not in S | 如果S中不包含x元素， 则返回True,否则返回False |
| S+T | 连接S与T,返回连接后的新集合类 |
| s*n或者n*s | 将S延长自身n次 |
| len(S) | 返回S的长度 |
学以致用
在古罗马人占领乔塔帕特后， 39个犹太人与约瑟夫和他的朋友躲到一个洞中。39个犹太人决定宁死也不被敌人抓到，于是商定以一种特殊的方式自杀： 41个人排成一个圆圈， 由笫一个人开始报数， 每报数到3的人就必须自杀， 直到所有人都自杀身亡为止。但是约瑟夫及其朋友并不想死， 那么请问约瑟夫及其朋友应该怎样安排自己的位置才能逃过一劫？
分析： 如果约瑟夫及其朋友不想死， 那么他们将是最后剩下的两个人， 因此， 问题的关键在于如何安排他们的位置才能将他们留到最后。
下面我们用程序模拟这个自杀过程， 找出最后两个人的位置， 这两个位置就是约瑟夫及其朋友的位置。
def move(man,sep):
"""
将man列表向左移动sep单位,最左边的元素向列表后面添加，
相当于队列顺时针移动
"""
for i in range(sep):
item = man.pop(0)
man.append(item)
def play(man=41, sep=3, rest=2):
"""
man :玩家个数
sep :杀死数到的第几个人
rest :幸存者数蜀
"""
print('总共%d个人,每报数到第%d的人自杀,最后剩余%d个人' %(man, sep,rest))
man = [i for i in range(1, man + 1)]
print("玩家队列：", man)
sep -= 1
while len(man) > rest:
move(man, sep)#执行数数操作
print('kill', man.pop(0))#自杀数到尾数的入， 将其移除队列
return man
servive = play()
print( "最后逃生的人编号是：", servive)
总共41个人,每报数到第3的人自杀,最后剩余2个人
玩家队列： [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, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41]
kill 3
kill 6
kill 9
kill 12
kill 15
kill 18
kill 21
kill 24
kill 27
kill 30
kill 33
kill 36
kill 39
kill 1
kill 5
kill 10
kill 14
kill 19
kill 23
kill 28
kill 32
kill 37
kill 41
kill 7
kill 13
kill 20
kill 26
kill 34
kill 40
kill 8
kill 17
kill 29
kill 38
kill 11
kill 25
kill 2
kill 22
kill 4
kill 35
最后逃生的人编号是： [16, 31]
3个函数(map/filter/reduce)
遍历函数(map)
map函数用于遍历序列。对序列中每个元素进行操作，最终获取新的序列。
li=[11,22,33]
new_list=map(lambda a:a+100,li)
list(new_list)
[111, 122, 133]
筛选函数(filter)
filter函数用于对序列中的元素进行筛选，最终获取符合条件的序列。
li =[11,22,33]
new_list=filter(lambda x:x>22,li)
list(new_list)
[33]
累计函数(reduce)
reduce函数用于对序列内所有元素进行累计操作。
from functools import reduce # 从functools模块导入reduce函数
li = [11, 22, 33, 44]
reduce(lambda arg1, arg2: arg1 + arg2, li)
110
面向对象编程基础
类
面向对象编程(Object Oriented Programming, OOP)是一种程序设计思想。
面向对象编程(Object Oriented Programming, OOP)是一种程序设计思想。面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息， 并处理这些消息。计算机程序的执行就是一系
列消息在各个对象之间传递。
在Python中， 所有数据类型都可以被视为对象。当然也可以自定义对象，自定义对象的数据类型就是面向对象中类(Class)的概念。
类和实例
面向对象编程中最重要的概念就是类(Class) 和实例(Instance) ， 必须牢记类是抽象的模板， 比如Student 类， 而实例是根据类创建出来的一个个具体的“对象” ， 每个对象都拥有相同的方法， 但各自的数据可能不同。
数据封装
面向对象编程的一个重要特点就是数据封装。在上面的Student类中个实例都拥有各自的na1ne和tell等数据。
私有变量与私有方法
类可以有公有变量与公有方法， 也可以有私有变量与私有方法， 公有部分
的对象可以从外部访问， 而私有部分的对象只有在类的内部才可访问。在普通
变量名或方法名（即公有变量名或方法名）前加两个“ _ ”， 即可成为私有变
量或方法。
例1-4
class PubAndPri:
pub = '这是公有变量'
__pri = "这是私有变量"
def __init__(self):
self.other = "公有变量也可以这样定义"
def out_pub(self):
print("公有方法", self.pub, self.__pri)
def __out_pri(self):
print("私有方法", self.pub, self._pri)
pp = PubAndPri()
pp.out_pub()
print(pp.pub, pp.other)
try:
pp._out_pri()
except Exception as e:
print("调用私有方法发生错误！")
try:
print(pp._pri)
except Exception as e:
print("访问私有变掀发生错误！")
公有方法 这是公有变量 这是私有变量
这是公有变量 公有变量也可以这样定义
调用私有方法发生错误！
访问私有变掀发生错误！
906
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
