机器学习笔记01--python基础部分

机器学习笔记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------>code

  shift + Tab :查看方法中的参数

  双击D，删除当前的单元格（删除之后，Crtl + Z还原无效）

  插入一行：b（bellow），a（above）

  执行单元：Ctrl + Enter(运行本单元，选中本单元)

  shift + Enter(运行本单元，选中下一个单元)

  Alt + Enter(运行本单元，向下插入一个单元)

  更多魔法指令：%lsmagic查看

baidu

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求和符号

$$\sum _{i=1}^{n}ab$$

希腊字母

希腊字母小写/大写	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:$\mathbb{A}\mathbb{B}\mathbb{C}\mathbb{D}\mathbb{E}\mathbb{F}\mathbb{G}\mathbb{H}\mathbb{I}\mathbb{J}\mathbb{K}\mathbb{L}\mathbb{M}\mathbb{N}\mathbb{O}\mathbb{P}\mathbb{Q}\mathbb{R}\mathbb{S}\mathbb{T}\mathbb{U}\mathbb{V}\mathbb{W}\mathbb{X}\mathbb{Y}\mathbb{Z},abcdefghij\mathbb{k}lmnopqrstuvwxyz$
mathscr:$\mathcal{A}\mathcal{B}\mathcal{C}\mathcal{D}\mathcal{E}\mathcal{F}\mathcal{G}\mathcal{H}\mathcal{I}\mathcal{J}\mathcal{K}\mathcal{L}\mathcal{M}\mathcal{N}\mathcal{O}\mathcal{P}\mathcal{Q}\mathcal{R}\mathcal{S}\mathcal{T}\mathcal{U}\mathcal{V}\mathcal{W}\mathcal{X}\mathcal{Y}\mathcal{Z},abcdefghijklmnopqrstuvwxyz$
mathcal:$\mathcal{A}\mathcal{B}\mathcal{C}\mathcal{D}\mathcal{E}\mathcal{F}\mathcal{G}\mathcal{H}\mathcal{I}\mathcal{J}\mathcal{K}\mathcal{L}\mathcal{M}\mathcal{N}\mathcal{O}\mathcal{P}\mathcal{Q}\mathcal{R}\mathcal{S}\mathcal{T}\mathcal{U}\mathcal{V}\mathcal{W}\mathcal{X}\mathcal{Y}\mathcal{Z},abcdefghijklmnopqrstuvwxyz$
mathbf:$\mathbf{A}\mathbf{B}\mathbf{C}\mathbf{D}\mathbf{E}\mathbf{F}\mathbf{G}\mathbf{H}\mathbf{I}\mathbf{J}\mathbf{K}\mathbf{L}\mathbf{M}\mathbf{N}\mathbf{O}\mathbf{P}\mathbf{Q}\mathbf{R}\mathbf{S}\mathbf{T}\mathbf{U}\mathbf{V}\mathbf{W}\mathbf{X}\mathbf{Y}\mathbf{Z},\mathbf{a}\mathbf{b}\mathbf{c}\mathbf{d}\mathbf{e}\mathbf{f}\mathbf{g}\mathbf{h}\mathbf{i}\mathbf{j}\mathbf{k}\mathbf{l}\mathbf{m}\mathbf{n}\mathbf{o}\mathbf{p}\mathbf{q}\mathbf{r}\mathbf{s}\mathbf{t}\mathbf{u}\mathbf{v}\mathbf{w}\mathbf{x}\mathbf{y}\mathbf{z}$

取消默认斜体

默认倾斜：$ x_{z}$
取消默认倾斜${\mathrm{x}}_{\mathrm{z}}$

特殊符号

${\bigcap }_{i=1}^n{\bigcup }_{i=1}^n\left(\genfrac{}{}{0ex}{}{5}{3}\right)$
$\forall$- 全称量词,表示任意的，$\exists$- 存在量词,表示存在/至少一个
$\partial$ 偏导符号， $\propto$ 正比符号，${\lim }_{n\to \infty }f(x)$无穷符号及极限

简单公式

$y=x^2$

$e^{i\pi }+1=0$

$e^x={\sum }_{i=0}^{\infty }\frac{1}{i!}{x}^i$

独占一行：$$\frac{n!}{k!(n-k)!}=\left(\genfrac{}{}{0ex}{}{n}{k}\right)$$

矩阵

$A_{m,n}=\left(\begin{array}{cccc}{a}_{1,1}& a_{1,2}& \cdots & a_{1,n}\\ a_{2,1}& a_{2,2}& \cdots & a_{2,n}\\ ⋮& ⋮& \ddots & ⋮\\ a_{m,1}& a_{m,2}& \cdots & a_{m,n}\end{array}\right)$

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
没有异常发生.