机器学习笔记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求和符号

∑ i = 1 n a b \sum_{i =1}^{n}ab i=1nab

希腊字母
希腊字母小写/大写LaTeX形式希腊字母小写/大写LaTeX形式
α A\alpha Aμ N\mu N
β B\beta Bξ Ξ\xi \Xi
γ Γ\gamma \Gammao Oo 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=1ni=1n(35)
∀ \forall - 全称量词,表示任意的, ∃ \exists - 存在量词,表示存在/至少一个
∂ \partial 偏导符号, ∝ \propto 正比符号, lim ⁡ n → ∞ f ( x ) \mathop{\lim}_{n \to \infty }f(x) limnf(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=0i!1xi

独占一行: n ! k ! ( n − k ) ! = ( n k ) \frac{n!}{k!(n-k)!} = {n \choose k} k!(nk)!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,1am,1a1,2a2,2am,2a1,na2,nam,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
没有异常发生.
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值