机器学习笔记01–python基础部分
第一阶段:Python基础和数据分析
1、第一课
Python环境,基本类型、判断与循环流程等
运行环境
Anaconda本地环境搭建
- Jupyter notebook及云平台的使用
Python基础
- Python简介,解释执行,与运行方式
- 基础语法及相应帮助的使用
- Python标识符、关键字
- Python运算符
- 判断循环语句
- Python基本数据类型(文本,字符串)与数据结构(列表 集合, 元组, 字典)
- 函数
- 面向对象
- 文件操作
- 异常
学习路线
- Python基础与数据分析
- 机器学习原理
- 机器学习实战
- 深度学习
- 各个方向的应用技能提升
- 综合项目(NLP/推荐/CV)
2、预备知识
Jupyter Notebook环境快速上手
Anaconda Jupyter Lab环境配置,安装及使用
推荐:正常安装及启动
启动的方式2种:
第一种:直接点击anaconda图标—》找到里面的jupyter notebook
第二种:terminal—>输入:jupyter notebook
Notebook使用
-
目录
-
文件新建及导入导出
-
菜单
-
快捷键 [esc+h]
jupyter常用的快捷键:
选中单元格情况下:M----->markdown,Y------>codeshift + Tab :查看方法中的参数
双击D,删除当前的单元格(删除之后,Crtl + Z还原无效)
插入一行:b(bellow),a(above)
执行单元:Ctrl + Enter(运行本单元,选中本单元)
shift + Enter(运行本单元,选中下一个单元)
Alt + Enter(运行本单元,向下插入一个单元)
更多魔法指令:%lsmagic查看
Notebook中详解
- Python CELL
- Markdown CELL &* Latex in markdown cell
- Magic
shell这边分为几个部分,
- 1.Python cell----写Python代码
- 2.makedown cell
- 3.latex cell—写数学公式
Python Cell
print(‘julyedu.com’)
Markdown CELL &* Latex in markdown cell
LaTeX实现的原理类似于HTML,Notebook中的Markdown格式解释器中内置Latex渲染器,可以将由$与$包裹的内容进行渲染并产生最终效果。
sum求和符号
∑ i = 1 n a b \sum_{i =1}^{n}ab i=1∑nab
希腊字母
希腊字母小写/大写 | LaTeX形式 | 希腊字母小写/大写 | LaTeX形式 |
---|---|---|---|
α A | \alpha A | μ N | \mu N |
β B | \beta B | ξ Ξ | \xi \Xi |
γ Γ | \gamma \Gamma | o O | o O |
δ Δ | \delta \ Delta | π Π | \pi \Pi |
ϵ ε E | \epsilon \varepsilon E | ρ ϱ P | \rho \varrho P |
ζ Z | \zeta Z | σ Σ | \sigma \Sigma |
η H | \eta H | τ T | \tau T |
θ ϑ Θ | \theta \vartheta \Theta | υ Υ | \upsilon \Upsilon |
ι I | \iota I | ϕ φ Φ | \phi \varphi \Phi |
κ K | \kappa K | χ X | \chi X |
λ Λ | \lambda \Lambda | ψ Ψ | \psi \Psi |
不同字体
mathbb:
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
,
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
\mathbb{ABCDEFGHIJKLMNOPQRSTUVWXYZ,abcdefghijklmnopqrstuvwxyz}
ABCDEFGHIJKLMNOPQRSTUVWXYZ,abcdefghijklmnopqrstuvwxyz
mathscr:
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
,
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
\mathscr{ABCDEFGHIJKLMNOPQRSTUVWXYZ,abcdefghijklmnopqrstuvwxyz}
ABCDEFGHIJKLMNOPQRSTUVWXYZ,abcdefghijklmnopqrstuvwxyz
mathcal:
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
,
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
\mathcal{ABCDEFGHIJKLMNOPQRSTUVWXYZ,abcdefghijklmnopqrstuvwxyz}
ABCDEFGHIJKLMNOPQRSTUVWXYZ,abcdefghijklmnopqrstuvwxyz
mathbf:
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
,
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
\mathbf{ABCDEFGHIJKLMNOPQRSTUVWXYZ,abcdefghijklmnopqrstuvwxyz}
ABCDEFGHIJKLMNOPQRSTUVWXYZ,abcdefghijklmnopqrstuvwxyz
取消默认斜体
默认倾斜:$ x_{z}$
取消默认倾斜
x
z
\rm x_{z}
xz
特殊符号
⋂
i
=
1
n
⋃
i
=
1
n
(
5
3
)
\bigcap_{i=1}^{n} \bigcup_{i=1}^n \binom{5}{3}
⋂i=1n⋃i=1n(35)
∀
\forall
∀- 全称量词,表示任意的,
∃
\exists
∃- 存在量词,表示存在/至少一个
∂
\partial
∂ 偏导符号,
∝
\propto
∝ 正比符号,
lim
n
→
∞
f
(
x
)
\mathop{\lim}_{n \to \infty }f(x)
limn→∞f(x)无穷符号及极限
简单公式
y = x 2 y=x^2 y=x2
e i π + 1 = 0 e^{i\pi} + 1 = 0 eiπ+1=0
e x = ∑ i = 0 ∞ 1 i ! x i e^x=\sum_{i=0}^\infty \frac{1}{i!}x^i ex=∑i=0∞i!1xi
独占一行: n ! k ! ( n − k ) ! = ( n k ) \frac{n!}{k!(n-k)!} = {n \choose k} k!(n−k)!n!=(kn)
矩阵
A m , n = ( a 1 , 1 a 1 , 2 ⋯ a 1 , n a 2 , 1 a 2 , 2 ⋯ a 2 , n ⋮ ⋮ ⋱ ⋮ a m , 1 a m , 2 ⋯ a m , n ) A_{m,n} = \begin{pmatrix} a_{1,1} & a_{1,2} & \cdots & a_{1,n} \\ a_{2,1} & a_{2,2} & \cdots & a_{2,n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m,1} & a_{m,2} & \cdots & a_{m,n} \end{pmatrix} Am,n=⎝⎜⎜⎜⎛a1,1a2,1⋮am,1a1,2a2,2⋮am,2⋯⋯⋱⋯a1,na2,n⋮am,n⎠⎟⎟⎟⎞
Notebook中的Magic开关
这个主要是一些快捷操作,类似快捷键,帮助提升效率
在jupyter的Code模式下,除了一般的python代码编辑外,jupyter还支持一些其他的编程语言,如R,Julia,bash等,不过需要使用magic单元。
- 为实现一些快捷操作,提升效率。Notebook中提供了Magic开关,能极大得优化我们使用Notebook的体验。
- Magic 开关分为两大类:%line magic(%表示magic只在本行有效) & %%cell magic(%%表示magic在整个cell单元有效)
例如:使用magic产生Linux下的shell环境,
%%bash
pwd && ls
Magic开关总览
#查看magic里面所有的魔法指令
%lsmagic
Available line magics:
%alias %alias_magic %autocall %automagic %autosave %bookmark %cd %clear %cls %colors %config %connect_info %copy %ddir %debug %dhist %dirs %doctest_mode %echo %ed %edit %env %gui %hist %history %killbgscripts %ldir %less %load %load_ext %loadpy %logoff %logon %logstart %logstate %logstop %ls %lsmagic %macro %magic %matplotlib %mkdir %more %notebook %page %pastebin %pdb %pdef %pdoc %pfile %pinfo %pinfo2 %popd %pprint %precision %profile %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconsole %quickref %recall %rehashx %reload_ext %ren %rep %rerun %reset %reset_selective %rmdir %run %save %sc %set_env %store %sx %system %tb %time %timeit %unalias %unload_ext %who %who_ls %whos %xdel %xmode
Available cell magics:
%%! %%HTML %%SVG %%bash %%capture %%cmd %%debug %%file %%html %%javascript %%js %%latex %%perl %%prun %%pypy %%python %%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %%time %%timeit %%writefile
Automagic is ON, % prefix IS NOT needed for line magics.
line magic
# 格式化输出
%pprint
Pretty printing has been turned OFF
#表示一个可以修改内核选项ast_node_interactivity,使得jupyter对独占一行的所有变量都自动显示
"""
重要的magic:%config ZMQInteractiveShell.ast_node_interactivity='all'
"""
%config ZMQInteractiveShell.ast_node_interactivity='all'
a = 2
n = 4
a
n
4
cell magic
查看代码运行时间
- %time 一行
- %%time 多行
- %%timeit多行的平均时间
#查看一行代码运行的时间
%time
print('hello 七月在线')
Wall time: 0 ns
hello 七月在线
%%time
for item in range(100):
a=item
del a
Wall time: 0 ns
%%timeit
for item in range(100):
a=item
del a
1000000 loops, best of 3: 2.13 µs per loop
Python简介,解释执行,运行方式
Python简介
python应用场景
- web应用开发
- 服务器运维
- 科学计算
Python源码目录结构
- /Library/Frameworks/Python.framework/Versions/3.6
- Include: 这个目录包括了 Python 的所有头文件。
- Lib:这里是 Python 标准库,都是用 Python 实现的。
- Modules:用 C 语言编写的模块,比如 cStringIO / tkinter 高性能实现
- Objects:Python 内建对象,如 int / list 的实现
- Parser:Python 解释器的 Scanner 和 Parser
- Python:Python 解释器的 Compiler 和执行引擎,运行核心
Python解释与运行
Python解释器interpreter
运行在系统线程上的C语言函数+超大循环。每个字节码指令均对应一个完全由C实现的逻辑。
#注释,可以在里写一些功能说明之类的哦
print('hello world')
hello world
3、python基础语法
注释
概述
注释在程序中毫无用处,既不解释也不输出。方便后期的阅读
标识符
定义
开发人员在程序中自定义的一些符号和名称
标示符是自己定义的,如变量名 、函数名等
规则
- 固定规则
标示符由字母、下划线和数字组成,且数字不能开头
思考:下面的标示符哪些是正确的,哪些不正确为什么
fromNo12,from#12,my_Boolean,my-Boolean,Obj2,2ndObj
myInt,test1,Mike2jack,My_tExt,_test,test!32,haha(da)tt
int,jack_rose,jack&rose,GUI,G.U.I
注意:
python中的标识符是区分大小写的
- 行业内规则
1.见名知意
起一个有意义的名字,尽量做到看一眼就知道是什么意思(提高代码可 读性) 比如: 名字 就定义为 name , 定义学生 用 student
2.驼峰命名法
2.1 小驼峰式命名法(lower camel case): 第一个单词以小写字母开始;第二个单词的首字母大写,例如:myName、aDog
2.2 大驼峰式命名法(upper camel case): 每一个单字的首字母都采用大写字母,例如:FirstName、LastName
3.下划线连接法
不过在程序员中还有一种命名法比较流行,就是用下划线“_”来连接所有的单词,比如send_buf
好的命名习惯让开发更有效率
- 变量,函数或方法:salary,houseworker,booksname
- 常量:INTEREST_RATES
- 类:BankAccount,Employee,Company,OrderedDict #骆峰命名法
关键字
定义:
python一些具有特殊功能的标示符,这就是所谓的关键字
关键字,是python已经使用的了,所以不允许开发者自己定义和关键字相同的名字的标示符
如何查看关键字?
import keyword
print(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']
运算符
算术运算符
下面以a=10 ,b=20为例进行计算
运算符 描述 实例
+ 加 两个对象相加 a + b 输出结果 30
- 减 得到负数或是一个数减去另一个数 a - b 输出结果 -10
* 乘 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 x除以y b / a 输出结果 2
// 取整除 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
% 取余 返回除法的余数 b % a 输出结果 0
** 幂 返回x的y次幂 a ** b 为10的20次方, 输出结果 100000000000000000000
例如:
9/2.0—》4.5
9//2.0—>4.0
赋值运算符
运算符 描述 实例
= 赋值运算符 把=号右边的结果给左边的变量 num=1+2*3 结果num的值为7
赋值运算表达式
格式:变量 = 表达式
功能:计算了等号右侧“表达式”的值,并赋值给等号左侧的变量
值:赋值结束后变量的
num3 = 10
num4 = num3 + 20
复合运算符
+= 加法赋值运算符 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=3,b=3则(a == b) 为 true.
!= 检查两个操作数的值是否相等,如果值不相等,则条件变为真。 如a=1,b=3则(a != b) 为 true.
> 检查左操作数的值是否大于右操作数的值,如果是,则条件成立。 如a=7,b=3则(a > b) 为 true.
< 检查左操作数的值是否小于右操作数的值,如果是,则条件成立。 如a=7,b=3则(a < b) 为 false.
>= 检查左操作数的值是否大于或等于右操作数的值,如果是,则条件成立。 如a=3,b=3则(a >= b) 为 true.
<= 检查左操作数的值是否小于或等于右操作数的值,如果是,则条件成立。 如a=3,b=3则(a <= b) 为 true.
逻辑运算符
运算符 逻辑表达式 描述 实例
-
1.and x and y 布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 (a and b) 返回 20。
例如:
a = 1
b = 3
c = a>b
print(c and b)----》False
-
2.or x or y 布尔"或" - 如果 x 是 True,它返回 True,否则它返回 y 的计算值。 (a or b) 返回 10。
-
3.not not x 布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 not(a and b) 返回 False
例如:
a = 10
b = 20
print(not x)
位运算符
概述:
按位运算符是把数字看作二进制来进行计算的。
Python中的按位运算法则如下:
下表中变量 a 为 60,b 为 13,二进制格式如下:
60二进制–》0011 1100
13二进制–》0000 1101
运算符 描述 实例
& 按位与运算符:参与运算的两个值,如果两个相应位都为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
运算符优先级
第一名 - 函数调用、寻址、下标
第二名 - 幂运算 **
第三名 - 翻转运算符 ~
第四名 - 正负号
第五名 - *、/、%
第六名 - +、-
控制语句
if条件控制语句
生活中的场景:
例如火车站、地铁等需要安检,如果没有携带违禁物品则放行,反之。。。
开发中的场景:
密码的判断—用户登录某个应用时
总结:
如果某些条件满足,才能做某件事情,而不满足时不允许做,这就是所谓的判断
不仅生活中有,在软件开发中“判断”功能也经常会用到
if语句的格式
if语句是用来进行判断的,其使用格式如下:
-
if 基本格式
if 要判断的条件:
条件成立时,要做的事情 -
if … else 当条件不成立时
if 条件:
满足条件时要做的事情1
else:
不满足条件时要做的事情1
-
if … elif 当有多个条件时
elif的使用格式如下:
if xxx1:
事情1
elif xxx2:
事情2
elif xxx3:
事情3
-
if … elif …else 当有多个条件并有可能不成立时
if 性别为男性:
输出男性的特征
elif 性别为女性:
输出女性的特征
else:
第三种性别的特征
-
if 语句的嵌套
在一个if语句中可以嵌入多个if相关的语句·
#if
age = 25
if age >= 25:
print('可以')
可以
#if...else
cheP = 1 # 用1代表有车票,0代表没有车票
if cheP == 1:
print("有车票,可以上火车")
print("终于可以见到Ta了,美滋滋~~~")
else:
print("没有车票,不能上车")
print("亲爱的,那就下次见了,一票难求啊")
有车票,可以上火车
终于可以见到Ta了,美滋滋~~~
#if...elif...else
sex = input("请输入你的性别:")
if sex == "男":
print("你是男性,可以留胡子")
elif sex == "女":
print("你是女性,可以留长头发")
#elif sex == "中性":
else:
print("你是第3种性别,想干啥就干啥")
请输入你的性别:男
你是男性,可以留胡子
#注意:if语句嵌套
"""
if xx:
事情1
if XXX:
事情2
"""
#比如进火车站,先检票和身份证,在安检,是否有违禁物品,两个条件都成立的话,
'\nif xx:\n 事情1\n if XXX:\n 事情2\n'
循环控制语句
while 循环语句格式
while 条件:
条件满足时,做的事情1
条件满足时,做的事情2
条件满足时,做的事情3
...(省略)...
#1~100之间的求和计算
i = 1
sum = 0
while i <=100:
sum = sum +i
i += 1
print(sum)
5050
for循环
for循环格式
for 临时变量 in 列表或者字符串等:
循环满足条件时执行的代码
else:
循环不满足条件时执行的代码
name = 'julyedu.com'
for x in name:
print(x)
j
u
l
y
e
d
u
.
c
o
m
#循环的嵌套
"""
前面学习过if的嵌套了,想一想if嵌套是什么样子的?
类似if的嵌套,while嵌套就是:while里面还有while
"""
'\n前面学习过if的嵌套了,想一想if嵌套是什么样子的?\n\n类似if的嵌套,while嵌套就是:while里面还有while\n'
#案例3:打印99乘法表
i = 1
while i <= 9:
j = 1
while j <= i:
print("%d*%d=%-6d " % (j, i, i * j), end='')
j += 1
print('\n')
i += 1
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
break
break的作用:用来结束整个循环
name = 'julyedu.com'
for x in name:
if x == 'd':
break
print(x)
j
u
l
y
e
continue
用来结束本次循环,紧接着执行下一次的循环
name = 'julyedu.com'
for x in name:
if x == 'd':
continue
print(x)
j
u
l
y
e
u
.
c
o
m
注意事项
break/continue只能用在循环中,除此以外不能单独使用
break/continue在嵌套循环中,只对最近的一层循环起作用
防止死循环的产生
数据结构
- number
- string
- list
- dictionary
- tuple
- set
number
- int
- float
- bool
- complex(复数)
Python3 支持 int、float、bool、complex(复数)。
a,b,c,d = 20,5.5,True,4+3j
print(type(a))
print(type(b))
print(type(c))
print(type(d))
<class 'int'>
<class 'float'>
<class 'bool'>
<class 'complex'>
string
"""
定义: 双引号或者单引号中的数据,就是字符串
"""
'\n定义: 双引号或者单引号中的数据,就是字符串\n'
字符串下表和切片
-
下标
-
下标的定义:字符串或串(String)是由数字、字母、下划线组成的一串字符
所谓“下标”,就是编号,就好比超市中的存储柜的编号,通过这个编号就能找到相应的存储空间
字符串中下标的使用:
列表与元组支持下标索引好理解,字符串实际上就是字符的数组,所以也支持下标索引。
比如在下面写的一个例子
-
如果有字符串:name = ‘abcdef’,在内存中的实际存储如下:
a b c d e f
name[0] name[1] name[2] name[3] name[4] name[5]
- 如果想取出部分字符,那么可以通过下标的方法,(注意python中下标从 0 开始)
name = ‘abcdef’
print(name[0])
print(name[1])
print(name[2])
- 切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法:[起始:结束:步长]
注意:选取的区间属于左闭右开型,即从"起始"位开始,到"结束"位的前一位结束(不包含结束位本身)。
如果取出一部分,则可以在中括号[]中,使用:
name = ‘abcdef’
print(name[0:3]) # 取 下标0~2 的字符
name = ‘abcdef’
print(name[0:5]) # 取 下标为0~4 的字符
print(name[3:5]) # 取 下标为3、4 的字符
print(name[2:]) # 取 下标为2开始到最后的字符
print(name[1:-1]) # 取 下标为1开始 到 最后第2个 之间的字符
a = 'abcdef'
print(a[:3])
print(a[::2])
print(a[::-2])
print(a[5:1:-2])
abc
ace
fdb
fd
list
列表的格式
格式:列表名 = [列表选项1, 列表选项2, ……, 列表选项n]
例如:
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
比C语言的数组强大的地方在于列表中的元素可以是不同类型的
testList = [1, 'a']
列表的定义
list是一种数据结构,专门用于存储一串信息; 列表用 [ ] 定义数据之间使用逗号分隔;列表的索引从0开始,索引就是数据在列表中的位置编号,索引又称为下标。
列表的常见操作
- 增(append/extend/insert)
- 删 (del/pop/remove)
- 改 (可以直接进行修改)
- 查 (in/not in)
- 排序 (sort)
namesList = ['laowang','gebilaosong','rongmei']
#append
namesList.append('hello')
print(namesList)
['laowang', 'gebilaosong', 'rongmei', 'hello']
#extend
a = [1,2]
b = [3,4]
a.extend(b)
print(a)
[1, 2, 3, 4]
#insert
a = [0,1,2]
a.insert(1,6)
print(a)
[0, 6, 1, 2]
"""
查找,就是看看指定的元素是否存在
in, not in
python中查找的常用方法为:
in(存在),如果存在那么结果为true,否则为false
not in(不存在),如果不存在那么结果为true,否则false
"""
'\n查找,就是看看指定的元素是否存在\nin, not in\n\npython中查找的常用方法为:\n\n in(存在),如果存在那么结果为true,否则为false\n not in(不存在),如果不存在那么结果为true,否则false\n'
#待查找的列表
namesList = ['laowang','gebilaosong','rongmei']
#获取用户要查找的名字
findName = input('请输入要查找的姓名:')
#查找是否存在
if findName in namesList:
print('在字典中找到了相同的名字')
else:
print('没有找到')
请输入要查找的姓名:laowang
在字典中找到了相同的名字
"""
删除
概述:
类比现实生活中,如果某位同学调班了,那么就应该把这个条走后的学生的姓名删除掉;在开发中经常会用到删除这种功能。
列表元素的常用删除方法有:
del:根据下标进行删除
pop:删除最后一个元素,很常用
remove:根据元素的值进行删除
"""
'\n删除\n概述:\n 类比现实生活中,如果某位同学调班了,那么就应该把这个条走后的学生的姓名删除掉;在开发中经常会用到删除这种功能。\n\n列表元素的常用删除方法有:\n del:根据下标进行删除\n pop:删除最后一个元素,很常用\n remove:根据元素的值进行删除\n'
#1.del:
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------')
for tempName in movieName:
print(tempName)
del movieName[2]
print('------删除之后------')
for tempName in movieName:
print(tempName)
------删除之前------
加勒比海盗
骇客帝国
第一滴血
指环王
霍比特人
速度与激情
------删除之后------
加勒比海盗
骇客帝国
指环王
霍比特人
速度与激情
#2.pop
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------')
for tempName in movieName:
print(tempName)
movieName.pop()
print('------删除之后------')
for tempName in movieName:
print(tempName)
------删除之前------
加勒比海盗
骇客帝国
第一滴血
指环王
霍比特人
速度与激情
'速度与激情'
------删除之后------
加勒比海盗
骇客帝国
第一滴血
指环王
霍比特人
#3.remove
movieName = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']
print('------删除之前------')
for tempName in movieName:
print(tempName)
movieName.remove('指环王')
print('------删除之后------')
for tempName in movieName:
print(tempName)
------删除之前------
加勒比海盗
骇客帝国
第一滴血
指环王
霍比特人
速度与激情
------删除之后------
加勒比海盗
骇客帝国
第一滴血
霍比特人
速度与激情
#排序---sort---正向排序
a = [1,2,3,5,1,3,2]
a.sort()
print(a)
# reverse---逆向排序
a.reverse()
print(a)
[1, 1, 2, 2, 3, 3, 5]
[5, 3, 3, 2, 2, 1, 1]
dictionary
字典格式
格式:
{key:value,key:value…}
定义变量info为字典类型:
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
说明:
字典和列表一样,也能够存储多个数据
字典中找某个元素时,是根据'名字'(就是冒号:前面的那个值,例如上面代码中的'name'、'id'、'sex')
字典的每个元素由2部分组成,键:值。例如 'name':'班长' ,'name'为键,'班长'为值
字典的常见操作
- 添加元素
- 删除元素(del—删除指定元素。 clear()------清空字典)
- 修改元素
- 查询元素(字典的遍历)
#案例:
info = {'name': '班长', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国北京'}
print(info['name'])
print(info['address'])
班长
地球亚洲中国北京
#在我们不确定字典中是否存在某个键而又想获取其值时,可以使用get方法,还可以设置默认值:
#案例:
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
age = info.get('age')#'age'键不存在,所以age为None
print(age)
## 若info中不存在'age'这个键,就返回默认值18
age = info.get('age', 18)
print(age)
None
18
#修改元素
#定义:
# 字典的每个元素中的数据是可以修改的,只要通过key找到,即可修改
#案例:
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
newId = input('请输入新的学号')
info['id'] = int(newId)
print('修改之后的id为%d!'%info['id'])
请输入新的学号2019
修改之后的id为2019!
"""
添加元素
"""
info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
# print('id为:%d'%info['id'])#程序会终端运行,因为访问了不存在的键
newId = input('请输入新的学号')
newId=int(newId)
# 直接通过键进行赋值,就可以添加新元素
info['id'] = newId
print('添加之后的id为:%d'%info['id'])
print(info)
'\n添加元素\n'
请输入新的学号2018
添加之后的id为:2018
{'id': 2018, 'address': '地球亚洲中国北京', 'name': '班长', 'sex': 'f'}
"""
删除元素
概述:
对字典进行删除操作,有一下几种:
del
clear()
del删除指定的元素:
"""
info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
print('删除前,%s'%info['name'])
# del info['name']
# print(info)
# print('删除后,%s'%info['name'])
#del删除整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('删除前,%s'%info)
# del info
# print('删除后,%s'%info) #这句报错
# clear清空整个字典:
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('清空前,%s'%info)
# info.clear()
# print('清空后,%s'%info)
'\n删除元素\n概述:\n对字典进行删除操作,有一下几种:\n del\n clear()\n\ndel删除指定的元素:\n'
删除前,班长
删除前,{'address': 'China', 'name': 'monitor', 'sex': 'f'}
清空前,{'address': 'China', 'name': 'monitor', 'sex': 'f'}
#字典的遍历
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
print(info.keys())
print(info.values())
print(info.items())
dict_keys(['id', 'address', 'name', 'sex'])
dict_values([100, '地球亚洲中国北京', '班长', 'f'])
dict_items([('id', 100), ('address', '地球亚洲中国北京'), ('name', '班长'), ('sex', 'f')])
tuple
元祖的格式和常见操作
Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。
本质:是一种有序集合
格式:
元组名 = (元组元素1, 元组元素2, ……, 元组元素n)
#创建空的元组
tuple1 = ()
print(tuple1)
#创建带有元素的元组
#元组中的元素的类型可以不同
tuple2 = (1, 2, 3, "good", True)
print(tuple2)
#定义只有一个元素的元组
tuple3 = (1, )
print(tuple3)
print(type(tuple3))
#元组元素的访问
#格式:元组名[下标]
#下标从0开始
#取值
tuple4 = (1,2,3,4,5)
print(tuple4[0])
print(tuple4[1])
print(tuple4[2])
print(tuple4[3])
print(tuple4[4])
#print(tuple4[5]) #下标超过范围(越界)
#获取最后一个元素
print(tuple4[-1])
print(tuple4[-2])
print(tuple4[-5])
#修改元组
#删除元组
#元组的操作
#元组重复
#判断元素是否在元组中
#元组的截取
#元组的遍历
()
(1, 2, 3, 'good', True)
(1,)
<class 'tuple'>
1
2
3
4
5
5
4
1
set
集合的概述
集合与之前列表、元组类似,可以存储多个数据,但是这些数据是不重复的
理解:
是一组key的集合,不存储value
本质:无序和无重复元素的集合
操作:
集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric_difference(对称差集)等数学运算
s1 = set([1,2,3,4,5,4,3])
print(s1)
s2 = set((1,2,3,4,5,4,3))
print(s2)
s3 = set({1:'good',2:'nice'})
print(s3)
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}
{1, 2}
#1.添加add
#2.插入(更新)update()
#3.删除remove()
#4.遍历for
#5.交集和并集
4、函数
函数概述
例如:现在有这样一段代码
print(“天王盖地虎”)
print(“小鸡炖蘑菇”)
再来一段代码:在不同的地方相同的代码,那么这样的程序改如何设计
if 条件1:
print("天王盖地虎")
print("小鸡炖蘑菇")
elif 条件2:
print("天王盖地虎")
print("小鸡炖蘑菇")
elif 条件3:
print("天王盖地虎")
print("小鸡炖蘑菇")
如果需要输出多次,是否意味着要编写这块代码多次呢?
小总结:
如果在开发程序时,需要某块代码多次,但是为了提高编写的效率以及代码的重用,所以把具有独立功能的代码块组织为一个小模块,这就是函数
函数定义
函数定义的格式:
def 函数名():
代码
#案例:
# 定义一个函数,能够完成打印信息的功能
def printInfo():
print('------------------------------------')
print(' 人生苦短,我用Python')
print('------------------------------------')
函数调用
定义了函数之后,就相当于有了一个具有某些功能的代码,想要让这些代码能够执行,需要调用它
调用函数很简单的,通过 函数名() 即可完成调用
# 定义完函数后,函数是不会自动执行的,需要调用它才可以
printInfo()
------------------------------------
人生苦短,我用Python
------------------------------------
#练习使用def定义函数,编写完函数之后,通过 函数名() 进行调用
def message():
name = input("请输入你的名字:")
age = input("请输入的你年龄:")
print("你的姓名:%s,年龄:%s"%(name,age))
#函数的调用
message()
请输入你的名字:xiong
请输入的你年龄:26
你的姓名:xiong,年龄:26
函数参数
#案例:求两个数的和
def add2num():
a = 11
b = 22
c = a + b
print(c)
add2num()
33
定义带有参数函数
#将上面的求和案例进行修改
def add2num(a, b):
c = a+b
print(c)
调用带有参数的函数
add2num(11,22)
33
"""
求:定义一个函数,完成前2个数完成加法运算,然后对第3个数,进行减法;然后调用这个函数
"""
def add2num(a,b,c):
d = a+b
e = d-c
print(e)
add2num(11,22,10)
'\n求:定义一个函数,完成前2个数完成加法运算,然后对第3个数,进行减法;然后调用这个函数\n'
23
#调用函数时参数的顺序
def demo(a,b):
print(a,b)
demo(1,2)
demo(b=1,a=2)
1 2
2 1
总结
- 定义时小括号中的参数,用来接收参数用的,称为 “形参”
- 调用时小括号中的参数,用来传递给函数用的,称为 “实参”
函数的返回值
所谓“返回值”,就是程序中函数完成一件事情后,最后给调用者的结果
注意:在python中return默认值为空–》None
#来证明下函数默认的返回值是None
def a():
print('hello')
print(a())
hello
None
#想要在函数中把结果返回给调用者,需要在函数中使用return
#如下示例:
def add2num(a, b):
c = a + b
return c
#将调用函数返回的值赋值给一个变量,存储起来
sum = add2num(1,2)
print(sum)
3
函数的类型
函数根据有没有参数,有没有返回值,可以相互组合,一共有4种
无参数,无返回值(此类函数,不能接收参数,也没有返回值,一般情况下,打印提示灯类似的功能,使用这类的函数)
无参数,有返回值(此类函数,不能接收参数,但是可以返回某个数据,一般情况下,像采集数据,用此类函数)
有参数,无返回值(此类函数,能接收参数,但不可以返回数据,一般情况下,对某些变量设置数据而不需结果时,用此类函数)
有参数,有返回值(此类函数,不仅能接收参数,还可以返回某个数据,一般情况下,像数据处理并需要结果的应用,用此类函数)
总结:
函数根据有没有参数,有没有返回值可以相互组合
定义函数时,是根据实际的功能需求来设计的,所以不同开发人员编写的函数类型各不相同
函数嵌套调用
一个函数里面又调用了另外一个函数,这就是所谓的函数嵌套调用
def testB():
print('---- testB start----')
print('这里是testB函数执行的代码...(省略)...')
print('---- testB end----')
def testA():
print('---- testA start----')
testB()
print('---- testA end----')
testA()
---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testB end----
---- testA end----
关键字参数
定义:
允许函数调用时参数的顺序与定义时不一致
#案例1:
def myPrint(str, age):
print(str, age)
#使用关键字参数
myPrint(age = 18, str = "张三")
张三 18
#案例2:
# 关键字参数:**kw
def person(name,age,**kw):
print('name:',name,'age:',age,'other:',kw)
person('Frank','37')
person('Frank','37',city='Shanghai')
person('Frank','37',gender='M',job='Engineer')
name: Frank age: 37 other: {}
name: Frank age: 37 other: {'city': 'Shanghai'}
name: Frank age: 37 other: {'job': 'Engineer', 'gender': 'M'}
默认参数(缺省参数)
概述:
python为了简化函数的调用,提供了默认参数机制
调用函数时,缺省参数的值如果没有传入,则被认为是默认值
#案例1:
def printinfo( name, age = 35 ):
# 打印任何传入的字符串
print("Name: ", name)
print("Age ", age)
# 调用printinfo函数
printinfo(name="miki")
printinfo( age=9,name="miki")
Name: miki
Age 35
Name: miki
Age 9
#案例2:
def pow(x, n = 2):
r = 1
while n > 0:
r *= x
n -= 1
return r
#这样在调用pow函数时,就可以省略最后一个参数不写:
print(pow(5))
25
#案例3:
def printinfo(name,sex,age=35):
print(name)
printinfo("张三","男")
'''
#注意:带有默认值的参数一定要位于参数列表的最后面。
#在定义有默认参数的函数时,需要注意以下:
"""
写法一定要注意:必选参数必须在前面,默认参数在后
"""
#1.必选参数必须在前面,默认参数在后;
#2.设置何种参数为默认参数?一般来说,将参数值变化小的设置为默认参数。
'''
张三
'\n#注意:带有默认值的参数一定要位于参数列表的最后面。\n#在定义有默认参数的函数时,需要注意以下:\n"""\n写法一定要注意:必选参数必须在前面,默认参数在后\n\n"""\n\n\n #1.必选参数必须在前面,默认参数在后;\n #2.设置何种参数为默认参数?一般来说,将参数值变化小的设置为默认参数。\n'
不定长参数
概述:
有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,声明时不会命名。
基本语法如下:
def functionname([formal_args,] *args, **kwargs):
"函数_文档字符串"
function_suite
return [expression]
#案例:
def fun(a, b, *args, **kwargs):
"""可变参数演示示例"""
print ("a =", a)
print ("b =", b)
print ("args =", args)
print ("kwargs: ")
for key, value in kwargs.items():
print (key, "=", value)
#方式1
fun(1, 2, 3, 4, 5, m=6, n=7, p=8)
#方式2
c = (3, 4, 5)
d = {"m":6, "n":7, "p":8}
fun(1, 2, *c, **d)
#方式3
# 注意不加星号与上面的区别
fun(1, 2, c, d)
a = 1
b = 2
args = (3, 4, 5)
kwargs:
n = 7
m = 6
p = 8
a = 1
b = 2
args = (3, 4, 5)
kwargs:
n = 7
m = 6
p = 8
a = 1
b = 2
args = ((3, 4, 5), {'n': 7, 'm': 6, 'p': 8})
kwargs:
匿名函数
定义:
不使用def这样的语句定义函数,使用lambda来创建匿名函数
用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,…argn]]:expression
或者:
lambda 参数1,参数2,……,参数n:expression
#案例:
sum = lambda arg1, arg2: arg1 + arg2
#调用sum函数
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))
Value of total : 30
Value of total : 40
回调函数
定义:
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,
我们就说这是回调函数。回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外的一方调用的,用于对该事件或条件进行
响应
#案例2:
# 回调函数1
# 生成一个2k形式的偶数
def double(x):
return x * 2
# 回调函数2
# 生成一个4k形式的偶数
def quadruple(x):
return x * 4
# 中间函数
# 接受一个生成偶数的函数作为参数
# 返回一个奇数
def getOddNumber(k, getEvenNumber):
return 1 + getEvenNumber(k)
# 起始函数,这里是程序的主函数
def main():
k = 1
# 当需要生成一个2k+1形式的奇数时
i = getOddNumber(k, double)
print(i)
# 当需要一个4k+1形式的奇数时
i = getOddNumber(k, quadruple)#kua tree plo
print(i)
# 当需要一个8k+1形式的奇数时
i = getOddNumber(k, lambda x: x * 8)
print(i)
main()
3
5
9
5、面向对象
面向对象
定义:
面向对象(object-oriented ;简称: OO) 至今还没有统一的概念 我这里把它定义为: 按人们 认识客观世界的系
统思维方式,采用基于对象(实体) 的概念建立模型,模拟客观世界分析、设 计、实现软件的办法。
面向对象编程(Object Oriented Programming-OOP) 是一种解决软件复用的设计和编程方法。 这种方法把软件
系统中相近相似的操作逻辑和操作 应用数据、状态,以类的型式描述出来,以对象实例的形式在软件系统中复用,以达
到提高软件开发效率的作用。
-
面向过程:根据业务逻辑从上到下写代码
-
面向对象:将数据与函数绑定到一起,进行封装,这样能够更快速的开发程序,减少了重复代码的重写过程
面向过程编程最易被初学者接受,其往往用一长段代码来实现指定功能,开发过程的思路是将数据与函数按照执行的逻
辑顺序组织在一起,数据与函数分开考虑。
类和对象
类
定义:
类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象
对象
概述:
某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的。
可以是直接使用的
总结:
类和对象之间的关系:
就像利用玩具的模型来创建多种不同的玩具
类就是创建对象的模板
类的设计
类(Class) 由3个部分构成
类的名称:类名
类的属性:一组数据
类的方法:允许对进行操作的方法 (行为)
<1> 举例:
1)人类设计,只关心3样东西:
事物名称(类名):人(Person)
属性:身高(height)、年龄(age)
方法(行为/功能):跑(run)、打架(fight)
2)狗类的设计
类名:狗(Dog)
属性:品种 、毛色、性别、名字、 腿儿的数量
方法(行为/功能):叫 、跑、咬人、吃、摇尾巴
定义类
# 定义类
"""
定义一个类,格式如下:
class 类名:
方法列表
"""
class Car:
# 方法
def getCarInfo(self):
print('车轮子个数:%d, 颜色%s'%(self.wheelNum, self.color))
def move(self):
print("车正在移动...")
'\n定义一个类,格式如下:\nclass 类名:\n 方法列表\n\n'
对象创建
python中,可以根据已经定义的类去创建出一个个对象
创建对象的格式为:
对象名 = 类名()
# 定义类
class Car:
# 移动
def move(self):
print('车在奔跑...')
# 鸣笛
def toot(self):
print("车在鸣笛...嘟嘟..")
# 创建一个对象,并用变量BMW来保存它的引用
BMW = Car()
#为对象添加属性
BMW.color = '黑色'
BMW.wheelNum = 4 #轮子数量
BMW.move()
BMW.toot()
print(BMW.color)
print(BMW.wheelNum)
车在奔跑...
车在鸣笛...嘟嘟..
黑色
4
init()
def 类名:
#初始化函数,用来完成一些默认的设定
def __init__():
pass
#案例:
# 定义汽车类
class Car:
def __init__(self):
self.wheelNum = 4
self.color = '蓝色'
def move(self):
print('车在跑,目标:夏威夷')
# 创建对象
BMW = Car()
print('车的颜色为:%s'%BMW.color)
print('车轮胎数量为:%d'%BMW.wheelNum)
车的颜色为:蓝色
车轮胎数量为:4
#案例:
# 定义汽车类
class Car:
def __init__(self, newWheelNum, newColor):
self.wheelNum = newWheelNum
self.color = newColor
def move(self):
print('车在跑,目标:夏威夷')
# 创建对象
BMW = Car(4, 'green')
print('车的颜色为:%s'%BMW.color)
print('车轮子数量为:%d'%BMW.wheelNum)
车的颜色为:green
车轮子数量为:4
当然一个类可以创建多个对象
封装:
- 数据封装
封装数据的主要原因是:保护隐私-私有属性
- 方法封装
封装方法的主要原因是:隔离复杂度–函数封装
继承
继承的概念
在现实生活中,继承一般指的是子女继承父辈的财产
在程序中,继承描述的是事物之间的所属关系,例如猫和狗都属于动物,程序中便可以描述为猫和狗继承自动物;
同理,波斯猫和巴厘猫都继承自猫,而沙皮狗和斑点狗都继承足够,如下如所示:
单继承
#单继承:就近原则,先在子类中找,如果没有,就去父类中找
# 定义一个父类,如下:
class Cat(object):
def __init__(self, name, color="白色"):
self.name = name
self.color = color
def run(self):
print("%s--在跑"%self.name)
# 定义一个子类,继承Cat类如下:
class Bosi(Cat):
def setNewName(self, newName):
self.name = newName
def eat(self):
print("%s--在吃"%self.name)
bs = Bosi("印度猫")
print('bs的名字为:%s'%bs.name)
print('bs的颜色为:%s'%bs.color)
bs.eat()
bs.setNewName('波斯')
bs.run()
bs的名字为:印度猫
bs的颜色为:白色
印度猫--在吃
波斯--在跑
#注意点:设置私有属性
多继承
"""
理解:
骡子是马和驴的杂交品种
所谓多继承,即子类有多个父类,并且具有它们的特征
"""
#Python中多继承的格式如下:
# 定义一个父类
class A:
def printA(self):
print('----A----')
# 定义一个父类
class B:
def printB(self):
print('----B----')
# 定义一个子类,继承自A、B
class C(A,B):
def printC(self):
print('----C----')
obj_C = C()
obj_C.printA()
obj_C.printB()
'\n理解:\n 骡子是马和驴的杂交品种\n所谓多继承,即子类有多个父类,并且具有它们的特征 \n'
----A----
----B----
多态
多态的概念是应用于Java和C#这一类强类型语言中,而Python崇尚“鸭子类型”。
所谓多态:定义时的类型和运行时的类型不一样,此时就成为多态
Python伪代码实现Java或C#的多态
类属性和实例属性
在前面的例子中我们接触到的就是实例属性(对象属性),顾名思义,类属性就是类对象所拥有的属性,它被所有类对
象的实例对象所共有,在内存中只存在一个副本,这个和C++中类的静态成员变量有点类似。对于公有的类属性,在类
外可以通过类对象和实例对象访问
"""
1、对于公有的类属性,在类外可以通过类对象和实例对象访问;
"""
#类属性
class People(object):
name = 'Tom'
__age = 12
p = People()
# 实例对象、类对象
print(p.name)
print(People.name)
# 私有类属性不能被实例对象和类对象调用
print(p.__age)
print(People.__age)
'\n\n1、对于公有的类属性,在类外可以通过类对象和实例对象访问;\n\n'
Tom
Tom
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-69-a7e637c1cff2> in <module>()
17
18 # 私有类属性不能被实例对象和类对象调用
---> 19 print(p.__age)
20 print(People.__age)
AttributeError: 'People' object has no attribute '__age'
#实例属性
class People(object):
address = '山东'
def __init__(self):
self.name = 'xiaowang'
self.age = 20
# 实例属性只能通过实例对象调用,不能由类对象调用
p = People()
p.age =12
print(p.address)
print(p.name)
print(p.age)
#类对象可以调用类属性,但是不能调用实例属性
print(People.address)
print(People.name)
print(People.age)
山东
xiaowang
12
山东
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-70-7af27dce1c2c> in <module>()
15 #类对象可以调用类属性,但是不能调用实例属性
16 print(People.address)
---> 17 print(People.name)
18 print(People.age)
AttributeError: type object 'People' has no attribute 'name'
#通过实例(对象)去修改类属性
class People(object):
country = 'china'
print(People.country)
"""
如果需要在类外修改类属性,必须通过类对象去引用然后进行修改
"""
p = People()
print(p.country)
p.country = 'japan'
print(p.country)
print(People.country)
del p.country
print(p.country)
"""
总结:核心就是类对象与实例对象 --> 类属性与实例属性之间的调用规则
1、如果需要在类外修改类属性,必须通过类对象去引用然后进行修改
2、如果通过实例对象去引用,会产生一个同名的实例属性,
这种方式修改的是实例属性,不会影响到类属性,并且之后如果通过实例对象去引用该名称的属性,
实例属性会强制屏蔽掉类属性,即引用的是实例属性,除非删除了该实例属性
"""
china
'\n如果需要在类外修改类属性,必须通过类对象去引用然后进行修改\n'
china
japan
china
china
'\n总结:核心就是类对象与实例对象 --> 类属性与实例属性之间的调用规则\n\n1、如果需要在类外修改类属性,必须通过类对象去引用然后进行修改\n\n2、如果通过实例对象去引用,会产生一个同名的实例属性,\n这种方式修改的是实例属性,不会影响到类属性,并且之后如果通过实例对象去引用该名称的属性,\n实例属性会强制屏蔽掉类属性,即引用的是实例属性,除非删除了该实例属性\n\n\n'
常见方法类型
- 实例方法
- 静态方法
- 类方法
实例方法
'''
定义:第一个参数必须是实例对象,该参数名一般约定为“self”,通过它来传递实例的属性和方法(也可以传类的属性和方法);
调用:只能由实例对象调用。
'''
静态方法
'''
定义:
需要通过修饰器@staticmethod来进行修饰,静态方法不需要多定义参数
重点:
1、不需要实例对象调用,可以直接用类对象调用
2、不需要self参数
案例:
'''
class People(object):
country = 'china'
@staticmethod
#静态方法
def getCountry():
return People.country
print(People.getCountry())
'\n 定义:\n需要通过修饰器@staticmethod来进行修饰,静态方法不需要多定义参数\n\n 重点:\n1、不需要实例对象调用,可以直接用类对象调用\n2、不需要self参数\n案例:\n'
china
'''
静态方法是类中的函数,不需要实例。静态方法主要是用来存放逻辑性的代码,主要是一些逻辑属于类,
但是和类本身没有交互,即在静态方法中,不会涉及到类中的方法和属性的操作。
可以理解为将静态方法存在此类的名称空间中。事实上,在python引入静态方法之前,
通常是在全局名称空间中创建函数
'''
import time
class TimeTest(object):
def __init__(self,hour,minute,second):
self.hour = hour
self.minute = minute
self.second = second
@staticmethod
def showTime():
return time.strftime("%H:%M:%S", time.localtime())
# 1、可以直接用类对象调用静态方法
print(TimeTest.showTime())
# 2、也可以直接用实例对象调用静态方法
t = TimeTest(2,10,10)
nowTime = t.showTime()
print(nowTime)
22:02:00
22:02:00
类方法
'''
是类对象所拥有的方法,需要用修饰器@classmethod来标识其为类方法,
对于类方法,第一个参数必须是类对象,一般以cls作为第一个参数(
当然可以用其他名称的变量作为其第一个参数,
但是大部分人都习惯以'cls'作为第一个参数的名字,就最好用'cls'了),
能够通过实例对象和类对象去访问。
案例:
'''
class People(object):
country = 'china'
#类方法,用classmethod来进行修饰
@classmethod
def getCountry(cls):
return cls.country
p = People()
print (p.getCountry()) #1、可以用过实例对象引用
print (People.getCountry()) #2、也可以通过类对象引用
print("*"*50)
'''
类方法还有一个用途就是可以对类属性进行修改:
案例:
'''
class People(object):
country = 'china'
#类方法,用classmethod来进行修饰
@classmethod
def getCountry(cls):
return cls.country
@classmethod
def setCountry(cls,country):
cls.country = country
p = People()
print (p.getCountry()) #可以用过实例对象引用
print (People.getCountry()) #可以通过类对象引用
p.setCountry('japan')
print (p.getCountry())
print (People.getCountry())
"\n是类对象所拥有的方法,需要用修饰器@classmethod来标识其为类方法,\n对于类方法,第一个参数必须是类对象,一般以cls作为第一个参数(\n当然可以用其他名称的变量作为其第一个参数,\n但是大部分人都习惯以'cls'作为第一个参数的名字,就最好用'cls'了),\n能够通过实例对象和类对象去访问。\n\n案例:\n"
china
china
**************************************************
'\n类方法还有一个用途就是可以对类属性进行修改:\n案例:\n'
china
china
japan
japan
总结
‘’’
总结:
1、从类方法和实例方法以及静态方法的定义形式就可以看出来,
类方法的第一个参数是类对象cls,那么通过cls引用的必定是类对象的属性和方法;
2、而实例方法的第一个参数是实例对象self,
那么通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析),
不过在存在相同名称的类属性和实例属性的情况下,实例属性优先级更高。
静态方法中不需要额外定义参数,因此在静态方法中引用类属性的话,必须通过类对象来引用
可以这样理解:
1.书写的格式不一样
1.1 类方法有一个默认参数cls代表这个类。可以用别的名词来替代,但不建议用别的名词。
1.2 静态方法没有默认参数,就像普通函数一样。是可以传参的。
2.使用不同:
2.1 在完全面向对象的程序中,如果一个函数即与类无关,也与对象无关,那么就用staticmethod。
2.2 静态方法和类方法都是类调用的。
2.3 对象可以调用类方法和静态方法,一般情况下,推荐用类名调用。
‘’’
6、文件操作
概述:
常见的txt/avi/html/zip/word等都称之为文件
文件作用:
存储数据
- 文件打开
- 文件关闭
- 文件读写
- 文件定位读写
- 文件重命名
- 文件删除
文件基本操作
在python,使用open函数,可以打开一个已经存在的文件,或者创建一个新文件
open(文件名,访问模式)
示例如下:
f = open('test.txt', 'w')
说明:
访问模式 说明
-
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
-
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
-
a 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
-
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
-
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
-
ab 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
-
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
-
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
-
a+ 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
-
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
-
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
-
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。
# w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件
f = open('test.txt','w')
# write写文件
f.write('hello world')
f.close()
11
# 读取文件
# read(arg)
f = open('test.txt','r')
# read读文件
contend = f.read()
print(contend)
f.close()
hello world
# readline--读取一行
# readlines--按行读取,读取所有文件的所有数据
# 文件重命名
import os
os.rename('hah.txt','test.txt')
---------------------------------------------------------------------------
FileNotFoundError Traceback (most recent call last)
<ipython-input-78-67ef24cf29fa> in <module>()
3
4
----> 5 os.rename('hah.txt','test.txt')
FileNotFoundError: [WinError 2] 系统找不到指定的文件。: 'hah.txt' -> 'test.txt'
文件夹基本操作
- 文件夹创建
- 获取当前目录
- 获取目录列表
- 删除文件夹
# 创建文件夹或者目录
# mkdir()
# os.mkdir('张三')
# 获取当前目录
os.getcwd()
# 获取指定目录下的文件
os.listdir("D:\\Jupyter_Notebook_task\\")
# 删除文件
os.rmdir('张三')
异常
open('123.txt','r')
"""
打开一个不存在的文件123.txt,当找不到123.txt 文件时,
就会抛出给我们一个IOError类型的错误,
No such file or directory:123.txt (没有123.txt这样的文件或目录)
"""
---------------------------------------------------------------------------
FileNotFoundError Traceback (most recent call last)
<ipython-input-81-450c020c9934> in <module>()
----> 1 open('123.txt','r')
2 """
3 打开一个不存在的文件123.txt,当找不到123.txt 文件时,
4 就会抛出给我们一个IOError类型的错误,
5 No such file or directory:123.txt (没有123.txt这样的文件或目录)
FileNotFoundError: [Errno 2] No such file or directory: '123.txt'
异常的处理
当出现异常情况时改如何处理?
捕获异常
捕获异常的基本格式:
try…except…
# try后面跟一些可能出现异常的代码
try:
print('-----test--1---')
open('123.txt','r')
print('-----test--2---')
# except后面跟解决异常方案
except IOError:
print('找不到123.txt 文件')
-----test--1---
找不到123.txt 文件
else
咱们应该对else并不陌生,在if中,它的作用是当条件不满足时执行的实行;
同样在try…except…中也是如此,即如果没有捕获到异常,那么就执行else中的事情
try:
num = 100
print(num)
except NameError as errorMsg:
print('产生错误了:%s'%errorMsg)
else:
print('没有捕获到异常,真高兴')
100
没有捕获到异常,真高兴
try…finally…
try…finally…语句用来表达这样的情况:
在程序中,如果一个段代码必须要执行,即无论异常是否产生都要执行,那么此时就需要使用finally。
比如文件关闭,释放锁,把数据库连接返还给连接池等
自定义异常
你可以用raise语句来引发一个异常
class ShortInputException(Exception):
def __init__(self, length, atleast):
#super().__init__()
self.length = length
self.atleast = atleast
def main():
try:
s = input('请输入 --> ')
if len(s) < 3:
# raise引发一个你定义的异常
raise ShortInputException(len(s), 3)
except ShortInputException as result:#x这个变量被绑定到了错误的实例
print('ShortInputException: 输入的长度是 %d,长度至少应是 %d'%
(result.length, result.atleast))
else:
print('没有异常发生.')
main()
请输入 --> 12345
没有异常发生.