Python基础语法

python 输入与输出规则

python 输入

简单输入

我们可以用input进行输入

a = input()
print(a)

Python基础语法_数据结构

当然为了更加友好,你可以在iput里面加入提示语句。

a = input("请输入数据:")
print(a)

Python基础语法_python_02

对输入数据的类型转换

首先你要明白我们输入的数据是什么类型。

a = input("请输入数据:")
print(a)
print(type(a))

Python基础语法_virtualenv_03

你看我输入是一个1但是它给出是一个str类型,也就是字符串类型。这是因为我们的键盘录入的数据是默认为字符串类型的。

但是如果你要根据输入的数据做一个加法或者减法,或者其他的一些处理。我们就需要进行类型转换。我们可以直接在input前面加上强制转换。

a = int(input("请输入数据:"))
print(a)
b=a+1;
print(type(a))
print(b)

Python基础语法_pycharm_04

你看这样就可以完成我们这样的需求。

但是你总不能输入一个a让它直接转换为int类型做运算。这在python里面是不允许的。

Python基础语法_python_05

你可能想到转到对应的ascii码值。

a = ord(input("请输入数据:"))
print(a)
b=a+1;
print(type(a))
print(b)

Python基础语法_virtualenv_06

我们可以按照这样操作。输入语法还是比较简单的。

python 输出

虽然是输出,但是也是有许多操作。我们可以进行不同类型的输出,往下看,你将发现输出语句蕴含的一些有趣的操作。

你是怎样用python的输出语句呢?

是这样吗?

下面展示一些 ​​内联代码片​​。

print("Hello World")

其实print函数的用途不止这些,输出也并不是只有有这样单调

那么具体的根源,我们就看这个函数完整的形式喽!

print(*values, sep=' ', end='\n', file=sys.stdout, flush=False)

对各个参数进行分析

下面展示一些 ​​内联代码片​​。

values :值,代表了你要输出的内容,比如你的hello world
sep : 打印出值得分割方式(具体看后面得代码演示)
end: 代表结束得方式(默认是'\n'结束,所以print()函数输出内容会自动换行)
file : 指定了输出内容到哪里,默认是到控制台,所以我们一般很自然就在控制台
看到我们的输出内容。
flush:代表了刷新方式(具体的我们在后面代码中说明)

1:对sep参数的解析

#values就不做过多的说明了,我们直接从step开始

print("你好","世界",sep="--");#前面的逗号分隔决定了你好和世界是两个字符串,指定sep的值是采用了什么符号对两个字符串进行分割。

输出结果如下:

Python基础语法_pycharm_07

还有一点说明,看代码

print("你好"+"世界",sep=",")#与上面的对比输出区分

输出结果如下:

Python基础语法_virtualenv_08

可见并没有对你好世界进行分割,这样的原因是以加号进行的前面,先拼接为一个字符串,sep指定的分割是区别两个字符串的。不明白?看下面

print("你好"+"世界","hello",sep=",")

输出结果如下

Python基础语法_pycharm_09

2:对end参数的解析

#我们先这样输出
print("十年生死两茫茫")#end参数一般会默认\n,就是换行的意思,改变end参数的值观察输出效果
print("不思量,自难忘")

可以看到这边的print()是自动换行的

输出结果:

Python基础语法_virtualenv_10

#然后我们这样输出
print("十年生死两茫茫",end=",")#end参数一般会默认\n,就是换行的意思,改变end参数的值观察输出效果
print("不思量,自难忘")

输出结果:

Python基础语法_list_11

3:对file参数的解析

通常我们的输出会直接输出到终端,那么我现在要把我想要输出的内容直接输出到我的文件中,怎么做?看代码。

建立一个文件作为输出目标

Python基础语法_python_12

我们现在要输出内容到这里面,看代码

File = open("D:\\python\\pydoc\\jgdabc_666\\1.txt",'w',encoding="utf-8")#这边指定编码,以防乱码
print("蒋光道要么变强,要么灭亡!",file=File)
File.close()

运行结果:

Python基础语法_virtualenv_13

4flush参数的解析

看代码

#我们还是对文件进行一下输入内容
我采用了一种对文件操作的方式
while True :
File = open("D:\\python\\pydoc\\jgdabc_666\\1.txt",'w',encoding="utf-8")#这边指定编码,以防乱码
print("蒋光道要么变强,要么灭亡!",file=File,flush=False)
input()

说明,我这边采用了一个无限循环的方式,也就是对文件进行反复写入,我可以在文件中看到效果的动态变化(如果我们没有加入input的话,可以看到文件写入文件内容的动态变化效果)

这边说明input的作用


我这边其实想演示的就是flush刷新的作用,当你的文件没有关闭的话,flush参数指定为flase并不会写入文件,而是先写入缓存区,所以其实文件中暂且不会出现内容。我这边开始没有让文件关闭来着,但是我发现程序运行太快,自动执行完程序,文件就自动关闭了,那么我就先让程序处于一个等待我输入的状态,那么文件也就不会因为程序自动执行完而自动关闭。所以文件没有关闭的情况下,内容是不会写入的。
Python基础语法_virtualenv_14
我的程序还在等待我输入,但是写入操作已经执行完毕了,但是因为flush指定参数的原因,内容没有写入文件,而是先写入了缓冲区。


while True : 
File = open("D:\\python\\pydoc\\jgdabc_666\\1.txt",'w',encoding="utf-8")#这边指定编码,以防乱码
print("蒋光道要么变强,要么灭亡!",file=File,flush=False)
#input()

可以看到input()函数注释后就会写入了,即使是while死循环也阻止不了文件每次执行到底部的自动关闭,然后文件又自动打开,反复进行。while循环对全局是死循环,但是内部是一直在执行。

Python基础语法_virtualenv_15

注意:这一点我是按照个人的理解进行的,如果读者觉得有问题可以提出或者指正。谢谢!

4格式化输出format占位格式

这边我们进行整体输出对比即可,然后我会对疑点进行说明

{} 与format() 函数进行配合,起到占位的作用,具体格式以及输出样子看代码

print("my name is{},and i love {}".format('jgdabc','programing'))#格式化输出,{}里面不带参数
print("{}is {}".format('jgdabc','蒋光道'))
print("{1} is {0}".format("jgdabc","蒋光道"))#{}指定参数,调换填入数据的前后顺序
print("{0} is {1} is {0}".format("jgdabc",'蒋光道'))#对输出的控制
print("{a} {b} {c}".format(a="hello",b="world",c="everyone"))#指定输出
print("{:5s} is {:>5s}".format("hello","world"))# 取位对齐
print("{:^10s} is {:^10s}".format("jgdabc","蒋光道")) #中间取位对齐
print("{0} is {0:1.2f}".format(1.231)) # 取数值的位数
print("{:.1f} and {:.2f}".format(1.23,1.32))
print("{0} is {0:b} ".format(2)) # 对数取进制
print("{0} is {0:g}".format(11111111))# g格式,数值太大,会以数的带e格式输出
print("{0} is {0:%}".format(1.21)) # 以百分格式输出

好,我们看输出结果

Python基础语法_python_16

格式化占位f开头占位

看代码

name = "jgdabc"
age = 22
print(f'my name is {name}') # f格格式占位输出
print(f"my age is {age:.2f}")#f格式输出以及格式控制

输出结果 :

Python基础语法_list_17

对print()函数的解析就到这里,我们常用的就是这些,当然还有其它的输出函数形式。如果对print()函数的格式话输出又疑问的话欢迎留言。


缩进规则简说


python 对缩进是敏感的,而大多教程对缩进规则,往往就几句话带过,对于没有其他语言基础的初学者,十分不友好,本文就把python常见的缩进问题做了一些整理。



一、Python缩进长度及缩进字符
常看到一些Python缩进错误的解读,“tab符和空格做为缩进不能混用”、“缩进一定是4个空格”。实际上并没有这些限制。


我们之所以使用缩进除了代码条条理,还有就是我们需要我们满足语法的逻辑控制,比如我们的if条件控制。

if score >= 60 : 
print("成绩合格")
if score >=80 :
print("成绩良好")
if score > 90 :
print("成绩优异")
if score > 95 :
print("成绩拔尖")
elif score ==59:

print("成绩处于边缘,继续加油")
else :
print("成绩不合格")

你想啊,如果没有缩进都可以写在同一个层次的话,那么语句之间就无法实现正常的逻辑控制。


空格和tab符通常都以空白形式显示。如果混用,代码容易意混淆,增加维护及调试的困难、降低了代码易读性。因此 Python PEP8 编码规范,指导使用4个空格作为缩进。而实际开发,比较复杂的代码则会选择2个空格做为缩进,这样更易于阅读那些嵌套比较深的代码。


流程控制语句

说明概要


在程序中,程序运行的流程控制决定程序是如何执行的,主流的程序设计语言一般有三大流程控制语句:分别是顺序控制、分支控制和循环控制。



Python 的常用流程控制有 if 、for 和 while 。



顺序控制
所谓的顺序控制就是程序从上到下逐行的执行,中间没有任何判断和跳转。



分支控制
分支控制就是让程序有选择的执行,主要有三种形式:单分支、双分支和多分支。Python 中的分支控制主要是借助于if语句来实现。



循环控制
循环控制就是让程序在满足一定的条件下就一直循环的去执行,直到条件不满足,则跳出循环继续执行循环以外的语句。Python 中的循环控制主要是借助于 for 和 while 来实现。



Python流程控制总结
在程序中,程序运行的流程控制决定程序是如何执行的,主流的程序设计语言一般有三大流程控制语句:分别是顺序控制、分支控制和循环控制。


if 条件语句

在 Python 中,关键字 if 是用于测试某个条件(布尔型 或逻辑型)的语句是否满足一定的条件,如果满足特定的条件,则会执行 if 后代码块,否则就忽略该代码块继续执行后续的代码。

Python if语句详解

语法


if condition:
# do something


说明

Python 中的 if 语句后面的条件判断表达式,是使用 : ,而不是类似其他语言的大括号,也不是类似 Go 语言 后面不需要写。

同时,Python if 语句要执行的代码块是使用缩进的形式,而且同一代码块的缩进风格需要严格的保持一致。

案例

if语句条件为真

如果 if 语句条件为真,则会执行相对应的代码

a = 10
b = 5
if a > b:
print('In if')
print("a > b")
print("Over")

首先,我们定义了两个 变量 a 和 b,并分别赋值为 10 和 5。接着,我们使用 if 语句判断 a > b 的条件,如果条件满足,则执行后面缩进的两条输出语句。

最后,我们的程序输出了 “In if”,“a > b” 和 “Over” ,因为 a > b 的条件是成立的,所以会执行 if 后面缩进里面的输出语句,而最后一个输出语句不管条件满足不满足则都会执行。

if语句条件为假

如果 if 语句条件为假,则不会执行相对应的代码

Python 中的 if 语句后面的条件判断表达式,是使用 : ,同时,Python if 语句要执行的代码块是使用缩进的形式,而且同一代码块的缩进风格需要严格的保持一致。

elif语句

在 Python 中,关键字 if 是用于测试某个条件(布尔型 或逻辑型)的语句是否满足一定的条件,如果满足特定的条件,则会执行 if 后缩进的代码块,否则就忽略该代码块继续执行后续的代码。

elif 关键字 用于在 if 语句条件不满足的情况下,继续执行 elif 里面的逻辑判断,如果满足条件则执行 elif 缩进里面的逻辑。

elif 语句只能写在 if 语句的同级代码的后面,且 elif 语句可以写任意多个。

Python elif语句详解

语法

if condition:
# do something
elif condition1:
# do something1
elif condition2:
# do something2

说明

python 中的 elif 语句后面的条件判断表达式,同样适用的是冒号 : 类似于 if 语句。

案例

如果 if 语句条件为真,则不会执行 elif 相对应的代码

a = 10
b = 5
if a > 8:
print("a > 8")
elif a > b:
print("a > b")
print("Over")

Python基础语法_virtualenv_18

首先,我们定义了两个 变量 a 和 b,并分别赋值为 10 和 5。接着,我们使用 if 语句判断 a > 8 的条件,如果条件满足,则执行缩进里面的输出语句。

同时,我们还使用 elif 语句,判断 a > b 的条件时否满足,如果 if 语句不满足,elif 语句满足,则才会执行 elif 语句里面的逻辑。

最后,我们的程序输出了 “a > 8” 和 “Over” ,因为在第一个判断时 a > 8 的条件是成立的,所以会执行 if 缩进里面的输出语句,此时,虽然 elif 语句里面的逻辑也是成立的,但因为 if 语句已经成立了,if 语句与 elif 语句是互斥的执行,所以 elif 里面的语句未能执行。最后一个输出语句不管条件满足不满足则都会执行。

如果 if 语句条件为假,elif 为真,此时会执行 elif 相对应的代码

如果 if 语句条件为假,elif 为真,此时会执行 elif 相对应的代码

a = 10
b = 5
if a > 20:
print("a > 20")
elif a > b:
print("a > b")
print("Over")

程序运行后,控制台输出如下:

Python基础语法_数据结构_19

首先,我们定义了两个变量 a 和 b,并分别赋值为 10 和 5。接着,我们使用 if 语句判断 a > 20 的条件,如果条件满足,则执行缩进里面的输出语句。

同时,我们还使用 elif 语句,判断 a > b 的条件时否满足,如果 if 语句不满足,elif 语句满足,则才会执行 elif 语句里面的逻辑。

最后,我们的程序输出了 “a > b” 和 “Over” ,因为在第一个判断时 a > 20 的条件是不成立的,所以不会执行 if 大括号里面的输出语句,此时,elif 语句里面的逻辑是成立的,而且前面的 if 语句不成立了,所以 elif 里面的语句能成功执行。最后一个输出语句不管条件满足不满足则都会执行。

多个 elif 语句,会被依次判断,直到满足的第一个执行

a = 10
b = 5
if a > 20:
print("a > 20")
elif a > 15:
print("a > 15")
elif a > 10:
print("a > 10")
elif a > b:
print("a > b")
print("Over")

程序运行后,控制台输出如下:

Python基础语法_list_20

首先,我们定义了两个变量 a 和 b,并分别赋值为 10 和 5。接着,我们使用 if 语句判断 a > 20 的条件,如果条件满足,则执行缩进里面的输出语句。

同时,我们还使用 elif 语句,判断 a > 15 的条件时否满足,判断 a > 10 的条件是否满足,判断 a > b 的条件是否满足,如果满足任意一个,则会执行相对应的代码。

最后,我们的程序输出了 “a > b” 和 “Over” ,因为在第一个判断时 a > 20 的条件是不成立的,所以不会执行 if 缩进里面的输出语句,此时,最后一个 elif 语句里面的逻辑是成立的,而前面所有的 elif 语句都不成立,所以最后一个 elif 里面的语句被执行。最后一个输出语句不管条件满足不满足则都会执行。

Python elif条件判断总结

elif 关键字用于在 if 语句条件不满足的情况下,继续执行 elif 里面的逻辑判断,如果满足条件则执行 elif 缩进里面的逻辑。

elif 语句只能写在 if 语句的同级代码的后面,且 elif 语句可以写任意多个。Python elif 语句语法:

if condition:
# do something
elif condition1:
# do something1
elif condition2:
# do something2

python 中的 elif 语句后面的条件判断表达式,同样适用的是冒号 : 类似于 if 语句。

python if else 语句

语法

if condition:
# do something
else:
# do something1

说明

else 语句可以直接配套 if 语句使用,如果 if 条件判断不成立,则执行 else 里面的代码逻辑。

Python if elif else语句详解

语法

if condition:
# do something
elif condition1:
# do something1
elif condition2:
# do something2
else:
# do something3

说明

else 语句可以配套 elif 使用,else 后面是没有加判断条件的,且不能加判断条件,否则会编译错误。

案例

if语句条件为真

如果 if 语句条件为真,则不会执行 else 相对应的代码

如果 if 语句条件为真,则不会执行 else 相对应的代码

a = 10
b = 5
if a > b:
print("a > b")
else:
print("a <= b")
print("Over")

程序运行后,控制台输出如下:

Python基础语法_数据结构_21

首先,我们定义了两个 变量 a 和 b,并分别赋值为 10 和 5。接着,我们使用 if 语句判断 a > b 的条件,如果条件满足,则执行缩进里面的输出语句,如果条件不满足,则会执行 else 里面的代码逻辑。

最后,我们的程序输出了 “a > b” 和 “Over” ,因为 a > b 的条件是成立的,所以会执行 if 缩进里面的输出语句,而 else 里面的代码不会被执行,而最后一个输出语句不管条件满足不满足则都会执行。

if语句条件为假

如果 if 语句条件为假,则会执行 else 相对应的代码

如果 if 语句条件为假,则会执行 else 相对应的代码

a = 10
b = 5
if a < b:
print("a < b")
else:
print("a >= b")
print("Over")

程序运行后,控制台输出如下:

Python基础语法_python_22

首先,我们定义了两个变量 a 和 b,并分别赋值为 10 和 5。接着,我们使用 if 语句判断 a < b 的条件,如果条件满足,则执行缩进里面的输出语句,如果条件不满足,则会执行 else 里面的代码逻辑。

最后,我们的程序输出了 “a >= b” 和 “Over” ,因为 a < b 的条件是不成立的,所以不会执行 if 缩进里面的输出语句,因此 else 里面的代码会被执行,而最后一个输出语句不管条件满足不满足则都会执行。

if elif else

if elif 和 else 语句可以一起使用

a = 10
if a > 20:
print("a > 20")
elif a > 15:
print("a > 15")
elif a > 10:
print("a > 10")
else:
print("a <= 10")
print("Over")

程序运行后,控制台输出如下:

Python基础语法_pycharm_23

首先,我们定义了变量 a,并赋值为 10。接着,我们使用 if 语句判断 a > 20 的条件,如果条件满足,则执行缩进里面的输出语句,如果条件不满足,则会继续执行下面所有的 elif 的判断条件。

此时,如果有任何一个 elif 满足,则下面所有的 elif 都不会再执行,else 也不会被执行,如果所有的 elif 都不满足,则会执行最后的 else 里面的逻辑。

最后,我们的程序输出了 “a <= b” 和 “Over” ,因为上面的 if 判断和所有的 elif 判断都不满足,因此 else 里面的代码会被执行,而最后一个输出语句不管条件满足不满足则都会执行。

Python else条件判断总结

在 Python 中,关键字 else 是用于在 if 条件不满足,且所有的 elif 条件也都不满足的情况下,执行的代码逻辑。Python if else 语句语法:

if condition:
# do something
else:
# do something1
Python if elif else 语句语法:

if condition:
# do something
elif condition1:
# do something1
elif condition2:
# do something2
else:
# do something3

Python if else嵌套详解

Python if else嵌套详解

语法

if condition:
if condition1:
# do something1
elif condition2:
# do something2
else:
if condition3:
# do something3
elif condition4:
# do something4
else:
# do something5

说明

Python 的 if 语句、elif 语句 和 else 语句可以进行任意的嵌套。

案例

if语句嵌套

if 语句里面可以嵌套任意的 if、elif 以及 else

a = 10
if a > 5:
if a > 20:
print("a > 20")
elif a > 10:
print("a > 10")
else:
print("a > 5")
else:
print("a <= 5")
print("Over")

程序运行后,控制台输出如下:

Python基础语法_python_24

首先,我们定义了一个 变量 a,并赋值为 5。接着,我们使用 if 语句判断 a > 5 的条件,如果条件满足,则继续执行判断 a > 20,如果不满足则继续执行 a > 10 的判断,如果最后还是不满足,则会执行 if 里面嵌套的 else 语句。

如果第一个 if 语句都不满足,则会执行执行最外层的 else 语句。最后,我们的程序输出了 “a > 5” 和 “Over”。

elif 语句嵌套

elif 语句里面可以嵌套任意的 if、elif 以及 else

a = 10
if a > 20:
print("a > 20")
elif a >= 10:
if a > 15:
print("a > 15")
elif a > 10:
print("a > 10")
else:
print("a >= 10")
else:
print("a < 10")
print("Over")

程序运行后,控制台输出如下:

Python基础语法_virtualenv_25

首先,我们定义了一个变量 a,并赋值为 10。接着,我们使用 if 语句判断 a > 20 的条件,如果条件不满足,则继续执行 else if 的判断 a >= 10,如果满足则继续执行 a > 15 的判断和 a > 10的判断,如果最后还是不满足,则会执行 if 里面嵌套的 else 语句。

如果第一个 if 语句都不满足,则会执行执行最外层的 else 语句。最后,我们的程序输出了 “a >= 10” 和 “Over”。

else 语句嵌套

else 语句里面可以嵌套任意的 if、elif 以及 else

a = 10
if a > 20:
print("a > 20")
elif a > 15:
print("a > 15")
else:
if a >= 10:
print("a >= 10")
else:
print("a < 10")
print("Over")

程序运行后,控制台输出如下:

Python基础语法_list_26

首先,我们定义了一个变量 a,并赋值为 10。接着,我们使用 if 语句判断 a > 20 的条件,如果条件不满足,则继续执行 else if 的判断 a >= 15,如果条件不满足则继续执行 else 里面嵌套的 if 和 else 的判断。

最后,我们的程序输出了 “a >= 10” 和 “Over”。

Python if else嵌套总结

在 Python 中,if 语句、elif 语句和 else 语句可以进行任意的嵌套。

python pass

有时候程序需要占一个位、放一条语句,但又不希望这条语句做任何事情,这就是 “空语句”。很多程序设计语言都提供了 “空语句” 的功能,在 Python 中,空语句就是 pass 语句 。

Python pass使用

Python 的 pass 语句,可以使用在 函数 中、if 条件判断中、for 循环中、while 循环中等等,几乎可以使用在程序的任何位置。

在程序合适的位置,使用 pass 语句,可以使程序变得更完整。

Python pass if详解

语法

if condition:
# do something1
else:
pass

说明

如果我们不需要 else 语句做任何操作,那么我们可以使用 pass 占位符。

Python pass for详解

语法

for iterating_var in sequence:
pass

说明

如果我们不需要 for 循环做任何操作,那么我们可以使用 pass 占位符。

案例

if else语句 pass

if else 语句里面可以使用 pass

a = 10
if a > 20:
print("a > 20")
elif a > 15:
print("a > 15")
else:
pass
print("Over")

程序运行后,控制台输出如下:

Python基础语法_python_27

首先,我们定义了一个 变量 a,并赋值为 10。接着,我们使用 if 语句判断 a > 20 的条件,如果条件不满足,则继续执行判断 a > 15 的判断,如果不满足则继续执行 else 语句,else 语句里面不需要执行任何操作,因此我们使用 pass 占位符。

因为前面的 if 和 elif 都不满足,因此执行了 else 语句,而 else 语句没有任何的操作,只是一个 pass 占位符。最后,我们的程序输出了 “Over”。

for 循环语句里面使用 pass

for c in 'HCoder':
if c == 'C' or c == 'd':
pass
else:
print("c =", c)

程序运行后,控制台输出如下:

Python基础语法_virtualenv_28

我们使用 for 循环,遍历 字符串,并且在遍历中,如果当前字符是 C 或者是 d ,那么就不执行任何操作,所以使用占位符 “pass” 来占位,否则就输出当前字符。

Python pass总结

Python 的 pass 语句,可以使用在函数中、if 条件判断中、for 循环中、while 循环中等等,几乎可以使用在程序的任何位置。

Python assert断言

Python 的 assert 是用于程序的断言,Python 的 assert 断言语句和 if 语句有点类似,都是用于对一个 bool 表达式进行判断。

assert 语句一般用于非常重要的 参数 校验和条件判断,如果参数校验不过或者一定的条件不满足,那么程序必须要结束,这时候就可以使用 assert 断言,提前结束程序。

Python assert断言与if区别

在使用 if 语句对表达式进行判断时,如果表达式为 True,程序执行一个逻辑,如果表达式为 False,可以执行另一个逻辑,或者终止程序。

使用 assert 对程序进行断言时,如果断言返回 False,那么程序则会引发 AssertionError 错误,程序终止执行。

Python assert断言详解

语法

assert condition

说明

assert 后面可以直接跟断言的条件,如果断言失败,则程序终止运行。

案例

assert断言校验参数

使用 assert 断言,校验参数

pageSize = -1
assert pageSize > 0
print("Over")

程序运行后,控制台输出如下:

Python基础语法_list_29

首先,我们定义了一个 变量 pageSize,并赋值为 -1。接着,我们使用 assert 断言语句断定变量 pageSize > 0 成立。

因为,我们的断言条件不成立,所以程序直接抛出了错误,并且程序终止了运行。

assert断言成功

assert断言成功,则程序继续运行

pageSize = 10
assert pageSize > 0
print("Over")

程序运行后,控制台输出如下:

Python基础语法_virtualenv_30

首先,我们定义了一个变量 pageSize,并赋值为 10。接着,我们使用 assert 断言语句断定变量 pageSize > 0 成立。

因为,我们的断言条件成立,所以程序没有抛出任何错误,程序继续正常运行。

Python assert断言总结

assert 语句一般用于非常重要的参数校验和条件判断,如果参数校验不过或者一定的条件不满足,那么程序必须要结束,这时候就可以使用 assert 断言,提前结束程序。

使用 assert 对程序进行断言时,如果断言返回 False,那么程序则会引发 AssertionError 错误,程序终止执行。

Python for循环

一般程序设计语言的循环可以分为 for 循环 、while 循环 和 do while 循环 ,但是在 Python 中,只支持 for 循环和 while 循环。

Python 的 for 循环使用的是 for in 的格式,类似于其他语言的 foreach 循环,循环条件最后的分割符使用的是 :,类似于 if 语句最后的 :。

Python for循环详解

语法

for iterating_var in sequence:
statements(s)

参数

参数 描述

for for 循环使用的关键字。

iterating_var for 循环每次迭代使用的变量。

in for 循环使用的关键字。

sequence for 循环需要遍历的变量。

statements 每次循环执行的逻辑。

案例

使用 for循环,遍历数值

for i in range(3):
print('i =', i)
print("Over")

程序运行后,控制台输出如下:

Python基础语法_virtualenv_31

我们定义了一个 for循环结构,计数器 变量 i 从 0 开始,结束条件是 i < 3,每次执行一次循环都打印出 i 的值,并且将 i 的值加 1。

这里使用了 range() 函数,此函数是 Python 内置的 函数,用于生成一系列连续的 整数,多用于 for 循环中。

for循环字符串

使用 for循环,遍历字符串

strHaiCoder = "HaiCoder"
for s in strHaiCoder:
print(s, end=' ')
print("\nOver")

程序运行后,控制台输出如下:

Python基础语法_virtualenv_32

我们定义了一个 for 循环结构用来遍历 字符串,每次执行一次循环都打印出当前字符串值,同时,我们在 print 函数中,指定了分隔符。

for循环求和

使用 for循环,求 1 到 100 的和

sum = 0
for num in range(101):
sum += num
print("Sum =", sum)

程序运行后,控制台输出如下:

Python基础语法_python_33

我们定义了一个 for 循环结构,计数器变量 i 从 0 开始,结束条件是 i < 101,每次执行一次循环都将当前的 i 的值加到变量 sum 上去,并且将 i 的值加 1。

最后,我们打印变量 sum 的值,为 5050,即 1 到 100 的和。

Python for循环总结

Python 的 for 循环使用的是 for in 的格式,类似于其他语言的 foreach 循环,循环条件最后的分割符使用的是 :,类似于 if 语句最后的 :。Python for 循环语法:

for iterating_var in sequence:
statements(s)

Python for循环集合

Python 的 for 循环 除了可以遍历 数字、字符串 还可以用来遍历 元祖、列表、字典 等数据类型。

案例

for循环元祖

使用 for 循环,遍历元祖

tup = ("Hello", "HaiCoder")
for t in tup:
print("t =", t)

程序运行后,控制台输出如下:

Python基础语法_python_34

首先,我们定义了一个元祖类型的 变量 tup,接着使用 for循环来遍历该元祖,每次遍历后都使用 print 函数打印当前的遍历的值。

for循环列表

使用 for 循环,遍历列表

ls = ["Hello", "HaiCoder"]
for l in ls:
print("l =", l)

程序运行后,控制台输出如下:

Python基础语法_list_35

首先,我们定义了一个列表类型的变量 ls,接着使用 for 循环来遍历该列表,每次遍历后都使用 print 函数打印当前的遍历的值。

列表的遍历和元祖的遍历几乎是一样的。

for循环字典key

使用 for 循环,遍历字典所有 key

dic = {"Name":"HaiCoder", "Site":"haicoder.net", "Course":"Python"}
for d in dic:
print("d =", d)

程序运行后,控制台输出如下:

Python基础语法_pycharm_36

首先,我们定义了一个字典类型的变量 dic,接着使用 for 循环来遍历该字典,每次遍历后都使用 print 函数打印当前的遍历的值。

使用 for 循环,遍历字典,获取的是字典的 key。

dic = {"Name":"HaiCoder", "Site":"haicoder.net", "Course":"Python"}
for key, val in dic.items():
print("key =", key, "val =", val)

程序运行后,控制台输出如下:

Python基础语法_数据结构_37

首先,我们定义了一个字典类型的变量 dic,接着使用 for 循环来遍历该字典的 items,每次遍历后都使用 print 函数打印当前的遍历的值。

使用 for 循环,遍历字典的 items 时,返回的是 key 和 value,因此我们在 for 循环里面使用了两个变量来接受。

for循环字典值

使用 for 循环,遍历字典值

dic = {"Name":"HaiCoder", "Site":"haicoder.net", "Course":"Python"}
for val in dic.values():
print("val =", val)

程序运行后,控制台输出如下:

Python基础语法_list_38

首先,我们定义了一个字典类型的变量 dic,接着使用 for 循环来遍历该字典的 values,每次遍历后都使用 print 函数打印当前的遍历的值。

使用 for 循环,遍历字典的 values 时,返回的是 value。

Python for循环集合总结

Python 的 for 循环除了可以遍历数字、字符串还可以用来遍历元祖、列表、字典等数据类型。

使用 for 循环,遍历字典,获取的是字典的 key,如果使用 for 循环来遍历字典的 items 时,则获取的是字典的 key 和 value,如果使用 for 循环来遍历字典的 values 时,则获取的是字典的 value。

for循环嵌套

Python 的 for 循环 也可以实现嵌套的效果,即 for 循环里面嵌套一个或多个 for 循环。这种写法就类似于 python 的 if 语句 、else if 语句 和 else 语句 的嵌套。

Python for循环嵌套详解

语法

for i in cond1 {
# do something
for j in cond2 {
for k in cond3{
# do something
}
}
}

说明

这里,我们定义了三个 for 循环的嵌套,当然,我们可以嵌套任意多个的 for 循环。

案例

循环嵌套

使用循环嵌套,打印计数器

i = 0
j = 0
for i in range(3):
print("i =", i)
for j in range(2):
print("\tj =", j)
print("Over")

程序运行后,控制台输出如下:

Python基础语法_python_39

首先,我们定义了一个最外层的 for 循环嵌套,计数器 变量 i 从 0 开始,结束条件是 i < 3,每次执行一次循环将 i 的值加 1,并打印当前 i 的值。

在最外层循环的里面,同时又定义了一个内部循环,计数器变量 j 从 0 开始,结束条件是 i < 2,每次执行一次循环将 j 的值加 1,并打印当前 j 的值。

循环嵌套打印数列

使用循环嵌套,打印数列

i = 0
j = 0
for i in range(3):
print("i =", i)
for j in range(i):
print("\tj =", j)
print("Over")

程序运行后,控制台输出如下:

Python基础语法_数据结构_40

首先,我们定义了一个最外层的 for 循环嵌套,计数器变量 i 从 1 开始,结束条件是 i < 3,每次执行一次循环将 i 的值加 1,并打印当前 i 的值。

在最外层循环的里面,同时又定义了一个内部循环,计数器变量 j 从 0 开始,结束条件是 j < i,每次执行一次循环将 j 的值加 1,并打印当前 j 的值。

Python for循环嵌套总结

Python 的 for 循环也可以实现嵌套的效果,即 for 循环里面嵌套一个或多个 for 循环。

打印乘法表

使用 for 循环嵌套,打印乘法表

使用 for循环嵌套,打印乘法表

for row in range(1, 10):
for col in range(1, row+1):
print("{0}x{1}={2:2} ".format(col, row, row * col), end="")
print("")

程序运行后,控制台输出如下:

Python基础语法_virtualenv_41

首先,我们定义了一个外层循环,从 1 开始到 9 结束,表示一共需要打印的行数。接着,我们在该循坏里面继续定义了一个循环,从1 开始到 当前行的大小结束,表示需要打印的列数据。

我们在每一列的遍历里面,打印当前行的索引与列的索引的乘积,同时,每一行结束后,我们都打印一个换行。

Python while循环

说明

当 cond 条件为真时,一直执行缩进里面的代码块,直到 cond 条件为假,循环结束。

案例

while循环数字

使用 while 循环,遍历数字

num = 0
while num < 3:
print('Num =', num)
num = num + 1

程序运行后,控制台输出如下:

Python基础语法_list_42

首先,我们定义了一个 整型类型 的 变量 num,并且赋值为 0,接着使用 while 循环来判断变量 num 是否小于 3,如果小于,则一直执行 print 的代码块,并且每次执行后都将 num 变量加 1。

while求和

使用 while 循环,求和

num = 0
sum = 0
while num <= 100:
sum += num
num += 1
print("Sum =", sum)

程序运行后,控制台输出如下:

Python基础语法_数据结构_43

首先,我们定义了一个整型类型变量 num 和 sum,并且都赋值为 0,接着使用 while 循环来判断变量 num 是否小于等于 100,如果成立,则一直将当前 sum 的值加上 num,并且每次执行后都将 num 变量加 1。

整个 while 循环执行完毕后,执行 print 的代码块,输出 Sum 的值。因为 print 语句不是在 while 循环的缩进代码块里面,而是跟 while 是平级的,因此 print 是 while 循环执行完毕才会执行的。

while循环列表

使用 while 循环,遍历列表

ls = ["Hello", "HaiCoder"]
i = 0
while i < len(ls):
print(ls[i])
i += 1
print("Over")

Python基础语法_virtualenv_44

首先,我们定义了一个 列表类型 的变量 ls 和一个整型变量 i,接着使用 while 循环来遍历该列表,遍历的条件是当前的 i 的值小于列表的长度。

每次遍历后都使用 print 函数打印当前的遍历的值并且将变量 i 的值加 1。

使用 while循环,遍历元祖

tup = ("Hello", "HaiCoder")
i = 0
while i < len(tup):
print(tup[i])
i += 1
print("Over")

程序运行后,控制台输出如下:

Python基础语法_virtualenv_45

首先,我们定义了一个 元祖类型 的变量 tup 和一个整型变量 i,接着使用 while 循环来遍历该元祖,遍历的条件是当前的 i 的值小于元祖的长度。

每次遍历后都使用 print 函数打印当前的遍历的值并且将变量 i 的值加 1。

Python while循环总结

Python 的 while 循环跟 if 条件判断类似,都是在特定条件满足的情况下,执行相对应的代码,不过,while 循环是只要条件满足,会一直执行缩进里面的代码块,这点又类似于 for 循环 。Python while 循环语法:

while cond:
# do something

Python while循环嵌套详解

语法

while cond1:
# do something
while cond2:
while cond3:
# do something

说明

这里,我们定义了三个 while 循环的嵌套,当然,我们可以嵌套任意多个的 while 循环。

案例

循环嵌套

使用循环嵌套,打印计数器

i = 0
while i < 3:
print("i =", i)
j = 0
while j < 2:
print("\tj =", j)
j += 1
i += 1
print("Over")

程序运行后,控制台输出如下:

Python基础语法_数据结构_46

首先,我们定义了一个最外层的 while 循环嵌套,计数器 变量 i 从 0 开始,结束条件是 i < 3,每次执行一次循环将 i 的值加 1,并打印当前 i 的值。

在最外层循环的里面,同时又定义了一个内部循环,计数器变量 j 从 0 开始,结束条件是 i < 2,每次执行一次循环将 j 的值加 1,并打印当前 j 的值。

循环嵌套打印数列

使用循环嵌套,打印数列

i = 0
while i < 3:
print("i =", i)
j = 0
while j < i:
print("\tj =", j)
j += 1
i += 1
print("Over")

程序运行后,控制台输出如下:

Python基础语法_数据结构_47

首先,我们定义了一个最外层的 while 循环嵌套,计数器变量 i 从 1 开始,结束条件是 i < 3,每次执行一次循环将 i 的值加 1,并打印当前 i 的值。

在最外层循环的里面,同时又定义了一个内部循环,计数器变量 j 从 0 开始,结束条件是 j < i,每次执行一次循环将 j 的值加 1,并打印当前 j 的值。

Python while循环嵌套总结

Python 的 while 循环也可以实现嵌套的效果,即 while 循环里面嵌套一个或多个 while 循环。

python while循环打印乘法表

我们使用 Python 的 while 循环 实现打印乘法表的功能。

打印乘法表

使用 while循环嵌套,打印乘法表

Python while循环打印乘法表

i = 1
while i<= 9:
j = 1
while j <= i:
sum = j*i
print("%dx%d=%2d" % (j,i,sum), end=("\t"))
j += 1
print()
i += 1

程序运行后,控制台输出如下:

Python基础语法_list_48

首先,我们定义了一个外层循环,从 1 开始到 9 结束,表示一共需要打印的行数。接着,我们在该循坏里面继续定义了一个循环,从1 开始到 当前行的大小结束,表示需要打印的列数据。

我们在每一列的遍历里面,打印当前行的索引与列的索引的乘积,同时,每一行结束后,我们都打印一个换行。

python break 语句

for i in range(10):
if i >= 3:
break
print("i =", i)

程序运行后,控制台输出如下:

Python基础语法_pycharm_49

首先,我们定义了一个 for 循环,该循环从 0 开始到 10 结束,每次循环循环控制 变量 加 1,并打印当前循环控制变量的值。

但,我们这里使用了 if 语句 判断,如果循环控制变量的值已经大于等于 3 了,那么我们就使用 break 语句来终止循环,因此最终结果只输出了 0,1,2,因为到 3 的时候,整个循环被 break 语句终止了。

break语句终止双重循环

使用 break 语句,终止双重循环

print(“嗨客网(www.haicoder.net)”)

使用 break语句,终止双重循环

例如:

for i in range(3):
for j in range(20):
if j >= 2:
break
print("i =", i, "j =", j)
print("Over")

程序运行后,控制台输出如下:

Python基础语法_virtualenv_50

首先,我们定义了一个 for 循环,该循环从 0 开始到 3 结束,每次循环循环控制变量加 1。

同时,我们在外层的 for 循环里面又定义了一个 for 循环,该循环从 0 开始到 20 结束,每次循环循环控制变量加 1,并在该循环里面打印循环控制变量 i 和 j 的值。

我们在第二层循环里面使用了 if 语句判断,如果循环控制变量的值已经大于等于 2 了,那么我们就使用 break 语句来终止循环,我们看到最终 j 的值最大只能输出到 1,但 i 的值可以全部输出,因为这的 break 语句只能终止内层的 for 循环,外层的 for 循环该 break 语句是无法终止的。

Python break语句总结

在 Python 中,终止循环的继续运行使用的关键字为 break。Python break 语句语法:

for i in range(num):
# do something
if condition:
break

python continue语句

在我们使用 for 循环 时,在某种条件满足的情况下,需要跳过本次循环,继续执行下一次循环,在 Python 中,跳过本次循环的继续运行下一次循环使用的 关键字 为 continue。

注意 continue 与 break 的区别,break 是直接终止了当前的循环,当前的循环不会再运行,而 continue 只是跳过本次循环,当前循环的后续循环还会继续运行。

Python continue语句详解

语法

for i in range(num):
# do something
if condition:
continue

说明

上面的循环是在 condition 条件满足的情况下,跳过本次 for 循环,继续执行下一次循环。

案例

continue语句跳过本次循环

for i in range(5):
if i == 3:
continue
print("i =", i)
print("Over")

程序运行后,控制台输出如下:

Python基础语法_pycharm_51

首先,我们定义了一个 for 循环,该循环从 0 开始到 5 结束,每次循环循环控制 变量 加 1,并打印当前循环控制变量的值。

但,我们这里使用了 if 语句 判断,如果循环控制变量的值等于 3,那么我们就使用 continue 语句来跳过本次循环,因此最终结果只输出了 0,1,2,4 。

因为到 3 的时候,该次循环被 continue 语句跳过了,但后续的 4 还是会继续执行,如果这换成 break 语句,那么就不会输出 4。

continue语句跳过双重循环

使用 continue 语句,跳过双重循环

for i in range(3):
for j in range(3):
if j == 1:
continue
print("i =", i, "j =", j)
print("Over")

程序运行后,控制台输出如下:

Python基础语法_pycharm_52

首先,我们定义了一个 for 循环,该循环从 0 开始到 3 结束,每次循环循环控制变量加 1。

同时,我们在外层的 for 循环里面又定义了一个 for 循环,该循环从 0 开始到 3 结束,每次循环循环控制变量加 1,并在该循环里面打印循环控制变量 i 和 j 的值。

我们在第二层循环里面使用了 if 语句判断,如果循环控制变量的值等于 1,那么我们就使用 continue 语句来跳过本次循环,我们看到最终 j 的值输出了 0 和 2,但 i 的值可以全部输出。

因为这的 continue 语句只是跳过 j 为 1 的情况,所以 j 为 2 的循环可以继续运行。

Python continue语句总结

在 Python 中,跳过本次循环的继续运行下一次循环使用的关键字为 continue。Python continue 语句语法:

for i in range(num):
# do something
if condition:
continue

Python break while 循环操作

在我们使用 while 循环 时,在某种条件满足的情况下,需要终止循环的继续执行,在 Python 中,终止循环的继续运行使用的 关键字 为 break。

在 while 中,使用 break 结束循环的用法跟在 for 循环 中几乎是一样的。

Python break while循环详解

语法

while condition:
# do something
if condition1:
break

说明

上面的循环是在 condition 条件满足的情况下,终止 while 循环。

案例

break语句终止while循环

使用 break 语句,终止 while 循环

i = 0
while i < 10:
if i >= 3:
break
print("i =", i)
i += 1

程序运行后,控制台输出如下:

Python基础语法_数据结构_53

首先,我们定义了一个 while 循环,该循环从 0 开始到 10 结束,每次循环循环控制 变量 加 1,并打印当前循环控制变量的值。

但,我们这里使用了 if 语句 判断,如果循环控制变量的值已经大于等于 3 了,那么我们就使用 break 语句来终止循环,因此最终结果只输出了 0,1,2,因为到 3 的时候,整个循环被 break 语句终止了。

break语句终止双重while循环

使用 break 语句,终止双重 while 循环

i = 0
while i < 3:
j = 0
while j < 20:
if j >= 2:
break
print("i =", i, "j =", j)
j += 1
i += 1
print("Over")

程序运行后,控制台输出如下:

Python基础语法_pycharm_54

首先,我们定义了一个 while 循环,该循环从 0 开始到 3 结束,每次循环循环控制变量加 1。

同时,我们在外层的 while 循环里面又定义了一个 while 循环,该循环从 0 开始到 20 结束,每次循环循环控制变量加 1,并在该循环里面打印循环控制变量 i 和 j 的值。

我们在第二层循环里面使用了 if 语句判断,如果循环控制变量的值已经大于等于 2 了,那么我们就使用 break 语句来终止循环,我们看到最终 j 的值最大只能输出到 1,但 i 的值可以全部输出。

因为这的 break 语句只能终止内层的 while 循环,外层的 while 循环该 break 语句是无法终止的。

Python break while循环总结

在 Python 中,终止 while 循环的继续运行使用的关键字为 break。Python break 语句语法:

while condition:
# do something
if condition1:
break

python 数据结构和字符串操作

一:字符串以及切片相关

#py字符串操作
# 切片语法[start:end:step] step默认是1
#下表会越界,但是切片不会
Test = "python"
print(type(Test))
print('获取第一个字符%s'%Test[0])
for item in Test :
print(item,end=' ')
name = 'Peter'
print("姓名转换变大写%s"%name.capitalize())#首字母变大写
a = ' hello '
b = a.strip()#去除字符串中存在地空格
c = ' hello '
d = c.lstrip() #去除左边的空格
e = 'hello '
f =e.rstrip()#去除右边的空格
print(b)
print(d)
print(f)
#id函数,查看一个对象的内存地址
g = id(a);
g1 = id(b)
print(g,g1,end=',')
dataStr = 'i love python'
h1 = dataStr.find('p')#查找p是再字符串当中所对应的下标值(一般返回第一次出现的位置)
h2 = dataStr.find('o')
h3 = dataStr.find('m') #如果没有找到就会返回-1
print(h1)
print(h2)
print(h3)
print(dataStr.index('v'))#也是一种查找的方式,和find方式很相似
print(dataStr.index('o'))
# print(dataStr.index('m'))#index如果没有找到就会返回异常
print(dataStr.startswith('i'))#判断想要查找的字符串是否以某字符开头
print(dataStr.endswith('y'))#判断要查找的字符串是否以某字符结尾
print(dataStr.lower)#将字符串都变成小写
print(dataStr.upper)#将字符串都转换为大写
#进行切片的操作

strMsg = "hello word"
#下面进行切片,也就是取字符串当中部分数据
print(strMsg[2:5])#不包含5下标(切片,左闭右开)
print(strMsg[2:])#从第二个下标一直取到最后(从第三个字符到最后)
print(strMsg[0:3])#从第一个字符取到第三个字符
print(strMsg[::-1])#倒序输出

Python基础语法_pycharm_55

二:数据结构

1:列表(list)

from typing import List


listA = ["python","java","c",12,True]
print("输出完整的列表:",listA)
print("输出第一个元素:",listA[0])
print("列表切片操作",listA[2:5])
print("多次输出列表当中的数据",listA*3)
listA.append("蒋光道")#给列表追加入数据
print("追加之后的列表:",listA)
listA.insert(1,'daodaozi')#列表插入数据
print("插入数据之后的列表:",listA)
listB =list(range(10))
print(listB)
listA.extend(listB)#扩展listA,批量添加
listA[0] = '康哥'#修改列表相应的值
print("修改之后的列表:",listA)
del listA[0] #删除列表第一个元素
print("删除第一个元素后的列表",listA)
del listA[1:3] #进行批量范围删除
print("批量删除后的列表:",listA)
listA.remove(12)#移除指定元素
print("移除指定元素后的列表",listA)
listB.pop(0)#移除第一个元素
print("移除第一个元素的列表",listB)
n = listB.index(1)#查找元素所在的索引下标
print("查找到的索引下标",n)

Python基础语法_数据结构_56

2:元组(tuple)

#py数据结构元组
# 特点 1:不可变
# 2:用小括号来创建元组类型
# 3:用,号来分割可以是任何的类型
# 4:当元组中只有一个元素时,要加入逗号,不然解释器会当作整型来进行处理
# 4:元组同样支持切片操作

tupleA = ()
print(id(tupleA))
print("查看元组类型为:",type(tupleA))#查看元组类型
tupleA = ("abcd","sdjnsd",83782,True,["jgdabc","jis"])
print("赋值后的元组为:",tupleA)
# 遍历元组
for item in tupleA :
print(item,end=",")
#取元组的元素
print(tupleA[0])
#切片元组
print("切片",tupleA[2:4])
print("切片倒序输出:",tupleA[::-1])
print("切片倒序步长输出:",tupleA[::-2])#倒序输出每个两个字符取一次
print(tupleA[-2:-1:])#要考虑到左闭右开,不指定步长的话默认步长为1
print(id(tupleA) ) #打印元组的内存地址id
tupleA[4][0] = "蒋光道" #尝试对元组中的列表元素进行修改
print(tupleA)
tuple_c = tuple(range(10)) #强转
print(tuple_c)
print(tuple_c.count(1)) #统计数据项中指定元素的出现个数

Python基础语法_数据结构_57

3:字典(dict)

#python数据结构字典
# 字典是由键值对组成得集合,通常使用键来进行对数据得访问。
# 特点:
"""
不是序列类型,没有下标得概念,是一个无无序的键值组合
{}表示字典对象,每个键用逗号分隔
键必须是不变的类型
每个键必须是唯一,如果重复,则后者会被覆盖
"""
# 创建字典
dict_a = {}
print("dict_a数据类型为:",type(dict_a))
dict_a['name']='jgdabc'#说明可以通过键值进行追加
dict_a['post']="歌手"
# 另一个添加方式
dict_a={"pro":"艺术","school":"北京电影学院"}
print("添加数据后字典为:",dict_a)
print("数据1的长度:",len(dict_a))
# 通过键来查找值
print("通过键来查找值;",dict_a['pro'])
print("打印所有的键:",dict_a.keys())
print("打印所有的值:",dict_a.values())
print("获取所有的键和值",dict_a.items())
for key,Value in dict_a.items() :
print(key+"=="+Value)
dict_a.update({"age":32}) #可以添加或者更新
print(dict_a)
# 删除操作
#del dict_a['age']
print(dict_a)
#另一种删除
#dict_a.pop("school")
print(dict_a)
# 排序操作
dict_a = {"蒋光道":1,"约翰":2,"詹姆森":3}
new_dict_aa = sorted(dict_a.values())#按照值牌序
print(new_dict_aa)
new_dict_bb = sorted(dict_a.items(),key=lambda d:d[1],reverse=False)
print("输出按照值排序后的字典",new_dict_bb)
print("按照值来排序,单独答应排序值:",new_dict_aa)
new_dict_a = sorted(dict_a.items(),key=lambda d:d[0],reverse=False)#按照key升序排序,ASCII码排序
print("按照key升序排序后的字典",new_dict_a)
new_dict_a_1 = sorted(dict_a)
print("单独打印出排序后的key值:",new_dict_a_1)

Python基础语法_virtualenv_58

python 常见函数以及内置函数

输入输出函数

常见的我们一般的集成功能的函数,比如输入输入,匹配字符串函数等等都算。我们举一些常见的函数的例子。

输入函数

name = input("请输入你的名字")

前面已经详细说明过,就不再多说

输出函数

print("Hello") # 简单输出
print("hello","are","you","ok") # 输出多字符串
print(1+2) #得到计算结果
# 可见print函数里面可以进行一些简单的计算

进制转换函数

十进制转二进制

i = 10;
j = bin(i)
print(j)

Python基础语法_pycharm_59

十进制到八进制

i = 10;
j = oct(i)
print(j)

Python基础语法_pycharm_60

十进制到十六进制

i = 10;
j = hex(i)
print(j)

Python基础语法_pycharm_61

二进制转换为十进制

a = eval('0b11')
print(a)

Python基础语法_数据结构_62

数学函数

1、abs(num) 返回num的绝对值

print(abs(-3))

2、max(num1,num2,…,numn) 返回给定参数的最大值

num1 = 10
num2 = 20
print(num1 > num2)
print(max(num1,num2,56))

3、min(num1,num2,…,numn) :返回给定参数的最小值

print(min(12,3,34,0))

4、pow(x,y) : 求x的y次方,x^y

print(pow(2,3))

5、round(num,n) : 四舍五入,

​ 参数一:需要进行四舍五入的数据;

参数二:保留小数的位数。若n不写,默认为0

print(round(123.486,2))

range()函数

range([start,] stop [,step])

实质:创建了一个可迭代对象;一般情况下与for循环一起连用

1、start 可以不写,默认值是0,若给定则从start开始

2、stop 必须给定;

3、取值范围[start,stop)

4、step:步长,若不给则默认为1

‘’’

需求:使用for循环计算123…*20的值

accou = 1
for i in range(1,21):
accou *= i
print(accou)

数据结构和字符串等相关操作函数见上目录。

python类

什么是面向对象编程

1、面向对象编程(oop)是一种程序设计思想。oop把对象作为程序的基本单元,一个对象包含数据和操作数据的函数

2、在python中,所有数据类型都被视为对象,也可以自定义对象。自定义对象数据类型就是面向对象中类的概念

面向对象术语简介

1、类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例

2、方法:类中定义的函数

3、类变量(属性):类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体(方法)之外。类变量通常不作为实例变量使用,类变量也称作属性

4、数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据

5、方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写

6、实例变量:定义在__init__方法中的变量,只作用于当前实例的类

7、继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待,以普通的类为基础建立专门的类对象

8、实例化:创建一个类的实例,类的具体对象。一个类可以实例化出无数个对象

9、对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法

10、多态:对不同类的对象使用同样的操作

11、封装:对外部世界隐藏对象的工作细节

Python类

1、类提供了一种组合数据和功能的方法。创建一个新类意味着创建一个新的对象类型,从而允许创建一个该类型的新实例

2、每个类的实例可以拥有保存自己状态的属性。一个类的实例也可以有改变自己状态的(定义在类中的)方法

3、Python的类提供了面向对象编程的所有标准特性:

⑴类继承机制允许多个基类,派生类可以覆盖它基类的任何方法,一个方法可以调用基类中相同名称的的方法

⑵对象可以包含任意数量和类型的数据

⑶和模块一样,类也拥有Python天然的动态特性:它们在运行时创建,可以在创建后修改

Python类的定义

1、python中定义类使用class关键字,class后面紧接类名,类名通常是大写开头的单词(无类继承时类名后可以加括号也可以不加括号)

2、python中类的定义语法如下:

class ClassName:
语句1
...
语句n

注:

1、类定义与函数定义(def语句)一样:只有在被执行才会起作用

⑴在定义阶段只是语法检查

2、类是属性和方法的组合,所以语句1可能是内部变量(数据、属性)的定义和赋值语句,也可能是内部方法(函数)的定义语句

⑴一个对象的特征称为"属性"

⑵一个对象的行为称为"方法"

⑶属性在代码层面上来看就是变量,方法实际就是函数,通过调用这些函数来完成某些工作

3、进入类定义时,就会创建一个新的命名空间,并把它用作局部作用域

⑴因此,所有对局部变量的赋值都是在这个新命名空间内进行的。特别的,函数定义会绑定到这个局部作用域里的新函数名称

4、正常离开(从结尾出)类定义时,就会创建一个类对象

⑴它基本上是一个包围在类定义所创建的命名空间内容周围的包装器

⑵元素的(在进入类定义之前起作用的)局部作用域将重新生效,类对象将在这里被绑定到类定义头给出的类名称(在上面的例子中就是ClassName)

例1:

class MyClass:
"""定义一个MyClass类"""
i = 12345

def func(self):
return 'hello world'

注:

1、类包含属性和方法

⑴属性:分为类属性和实例属性

①"i = 12345":表示定义了一个类属性i其值为12345(实例属性后面介绍)

⑵方法:即定义在类中的函数(与普通的函数类似)

②func:表示定义了一个名为func的实例方法,实际上就是一个稍微特殊点的函数(方法的第一个参数必须为self)

2、在类中定义方法的形式和函数差不多,但其不称为函数,而是叫方法。方法的调用需要绑定到特定的对象上(通过self.或实例对象名),而函数不需要

⑴类内部的函数定义通常具有一种特别形式的参数列表,这个特别形式就是第一个参数必须是self(self参数后面介绍)

⑵方法是所有实例都共用的:类外所有实例都可以调用类中的方法,类中方法之间也可以相互调用

3、上面例子中创建了一个MyClass抽象类,定义好类后会在当前作用域定义名字MyClass,指向类对象MyClass

4、类也是一种对象类型,跟前面学习过的数值、字符串、列表等等是一样的

⑴比如这里构建的类名字叫做MyClass,那么就是我们要试图建立一种对象类型,这种类型被称之为MyClass,就如同有一种对象类型是list一样

5、Python中一切皆对象。不管是我们自己定义的类、6种基本数据类型还是内置的类(第三方类)等都称作为对象

⑴一个对象,就会拥有自己的属性和方法。我们可以通过一定的方式来调用一个对象的属性和方法。这一点自定义类与其他Python类型是一样的

6、Python类中的方法分为:实例方法、类方法、静态方法。这里主要介绍实例方法(方法中第一个参数必须为self),感觉其他两种方法用的比较少

类对象

1、类是抽象的概念,它是一种数据结构:就好比一个模型,该模型是生活中具有相同属性(特征)和方法(动作)的同一类事务,可以用它来生产真实的物体(实例)

⑴在python中,把具有相同属性和方法的对象归为一个类(class)

2、比如,我们可以将类看做是一个"饼干模具",这个模具上有一些饼干的特征(属性)和行为(方法)

⑴有了这个模具之后我们就可以通过这个模块来制作很多具有相同属性和行为的不同饼干了(制作出来的肯定不是同一块饼干)

3、定义一个类后,就相当于有了一个类对象了:Python中"一切皆对象"。类也称为"类对象"

⑴比如前面例1中定义了类MyClass,其也可以成为类对象

4、类对象支持两种操作:属性引用和实例化

⑴实例化:使用instance_name = class_name()的方式实例化,实例化操作创建该类的实例(格式:实例对象名 = 类名(),实例对象名是我们自己定义的)

⑵属性引用:使用class_name.attr_name的方式引用类属性(类名.属性名)

例2:属性引用

class MyClass:
"""定义一个MyClass类"""
i = 12345

def func(self):
return 'hello world'

print(MyClass.i) # 引用类属性
print(MyClass.func) # 引用实例方法:实例方法可以这样被引用,但是这样引用无意义(知道即可)

== 类属性也可以被赋值,因此可以通过赋值来更改类属性的值==

MyClass.i = 123
print(MyClass.i)

例2_1:实例化

class MyClass:
"""定义一个MyClass类"""
i = 12345

def func(self):
return 'hello world'

#实例化一个类
my_class = MyClass()
print(my_class)

可以看到实例化类后返回的是一个MyClass对象,这个对象跟python中的数字、字符串、列表等是一样的

#对象都可以拥有属性、方法

注:

1、类的实例化:是使用函数表示法,可以把类对象看做是会返回一个新的类实例的函数

⑴比如上面类对象的实例化就是:my_class = MyClass()。这就创建了一个类的新实例并将此对象分配给局部变量my_class

2、实例化操作可以看成是"调用"类对象:将一个类实例化后获得的对象(所赋值的变量)称为实例对象。my_class就称为实例对象

3、类只是一个抽象的概念,只有经过实例化后(获得实例对象),才会有意义,才能正常使用这个类中的属性和方法

实例对象

1、实例对象就是具有类属性和方法的具体事物:是基于类而创建的一个具体的事物

⑴比如类可以看做制作饼干的模板,那么通过这个模板制作出来的一块块饼干就是实例对象

2、通过类产生实例对象的过程称为实例化

⑴格式:实例对象名 = 类名()

⑵通过简单的赋值操作,就实例化了一个对象,得到一个实例对象

3、一个类可以实例化出无数个实例对象:这些实例对象之间的属性和方法都是独立的,互不干扰

⑴一个饼干模具可以生产出无数块饼干

4、实例对象是类对象实例化的产物,实例对象仅支持一个操作:属性引用

⑴实例对象名.属性名

⑵实例对象名.方法名()

例3:

class MyClass:
"""定义一个MyClass类"""
i = 12345

def func(self):
return 'hello world'

#第一个实例对象
my_class = MyClass()
print(id(my_class))
print(my_class.i) # 引用类属性
print(my_class.func()) # 引用实例方法

#第二个实例对象
my_class1 = MyClass()
print(id(my_class1))
#类属性重新赋值
my_class1.i = 123
print(my_class1.i) # 引用类属性
print(my_class1.func()) # 引用实例方法

#第三个实例对象
my_class2 = MyClass()
print(id(my_class2))
print(my_class2.i) # 引用类属性
print(my_class2.func()) # 引用实例方法

注:

1、一个类可以实例化出无数个实例对象:这些实例对象之间的属性和方法都是独立的,互不干扰

⑴my_class、my_class1、my_class2…这些都是通过MyClass类实例化后得到的实例对象,他们之间是互不干扰的

2、在未实例化类时(my_class = MyClass()前),只是定义了类对象的属性和方法,此时其还不是一个完整的对象,将定义的这些称为类(抽象类)。需要使用类来创建一个真正的对象,这个对象就叫做这个类的一个实例,也叫作实例对象(一个类可以有无数个实例)

3、创建一个对象也叫做类的实例化,即my_class = MyClass()(此时得到的my_class变量称为类的具体对象)。注意此时类名后面是跟着小括号的,这跟调用函数一样

⑴另外赋值操作是必须的,但如果没有将创建好的实例对象赋值给一个变量,那这个对象就没办法使用,因为没有任何引用指向这个实例(其实也可以说赋值操作是必须的)

4、使用class语句只能创建一个类,而无法创建类的实例对象,因此要想使用已创建好的类,还需要手动创建类的实例对象,创建类对象的过程又称为类的实例化

例3_1:

"""这种写法知道就好了,实际中肯定不能这么写:未进行赋值操作!!!!!"""
class MyClass:
"""定义一个MyClass类"""
i = 12345

def __init__(self,name):
self.name = name


def func(self):
print(self)
print("名字是:%s" % self.name)


#未进行赋值操作
print(MyClass("张三").i) # 引用类属性
print(MyClass("张三").func()) # 引用实例方法

print(MyClass("李四").i) # 引用类属性
print(MyClass("李四").func()) # 引用实例方法

"""
12345
<__main__.MyClass object at 0x000001356F83D780>
名字是:张三
None
12345
<__main__.MyClass object at 0x000001356F83D780>
名字是:李四
None
"""

注:

1、如果在实例化类时,未将实例赋值给一个变量:虽然可以正常调用类的属性和方法

⑴但是这样是没有意义的。因为:没有任何引用指向这个实例,都没法调用这个实例(只有赋值后才会产生实例对象)

2、如果这样写的话,每次调用这个类的实例对象都需要去实例化一次了,那么就显得很麻烦了,还不如实例化一次并赋值给一个变量,此后每次去调用这个变量(实例对象)就好了

3、因此:类在使用前必须先实例化,并将实例赋值给一个变量(得到实例对象)

self参数

1、在定义实例变量、实例方法时的第一个参数必须是self

⑴其实:self名称不是必须的,在python中self不是关键词,你可以定义成a或b或其它名字都可以,只是约定成俗都使用了self

⑵也就是说在定义实例方法时必须有一个参数是默认已经存在了的,可以是self,可以是a,也可以是b。不管这个参数名是什么,但必须得有这个参数

2、self在定义时需要定义,但是在调用时会自动传入(不需要手动传入了)

3、self其实就相当于C++中的this指针

4、如果把类比作图纸,那么由类实例化后的对象才是真正可以住人的房子。根据一张图纸就可以设计出成千上万的房子,他们都长得差不多,但他们都有不同的主人,每个人都只能回自己的家里…所以self这里就相当于每个房子的门牌号,有了self就可以轻松找到自己房子

5、python中的self参数就是同一个道理,由同一个类可以生成无数对象,当一个对象的方法被调用的时候,对象会将自身的引用作为第一个参数传给该方法,那么python就知道需要操作哪个对象的方法了

6、简单的来说就是:self代表的当前的实例对象本身,这样在调用实例方法等时Python就知道当前是哪个实例对象了

⑴一个抽象类实例化后,实例对象为a,那么此时self就代表实例对象a

⑵一个抽象类实例化后,实例对象为b,那么此时self就代表实例对象b

例4:

class MyClass:
"""定义一个MyClass类"""
i = 12345

def func(self):
print("self参数:",self)
return 'hello world'

a = MyClass()
print("实例对象:",a)
a.func()

b = MyClass()
print("实例对象:",b)
b.func()

"""
实例对象: <__main__.MyClass object at 0x000002D29354E3C8>
self参数: <__main__.MyClass object at 0x000002D29354E3C8>
实例对象: <__main__.MyClass object at 0x000002D29354EFD0>
self参数: <__main__.MyClass object at 0x000002D29354EFD0>
"""

注:

1、通过打印的id值可以看出,self参数实际上就是类通过实例化后得到的实例对象。不同的实例对象对应的self参数是不一样的(self参数始终与当前实例对象时一一对应的)

2、在这个例子可中可能并不能很好的理解self参数的含义,感觉是实例变量中能更好的理解self参数

3、目前我们只需记住:

⑴实例方法第一个参数必须是self,在调用时会自动传入(不需要手动传入了)

⑵self代表的当前的实例对象本身

例4_1:

class Ball:
def setname(self,name,age):
self.name = name
print(age)

def kick(self):
return "我叫%s" % self.name

a = Ball()
b = Ball()
c = Ball()

a.setname("A",1)
b.setname("B",2)
c.setname("C",3)

print(a.kick())
print(b.kick())
print(c.kick())

注:从上面例子可以看出

1、有Ball类生成了三个实例对象a,b,c,这三个对象在调用kick()方法时,是通过self参数去确定究竟当前是哪个对象在调用方法的。因此在写实例方法时一定要写self参数且其位置在第一个,在调用时就不需要传入self参数了

2、在方法中定义的参数,一般来说只能在当前方法中使用(作用域)

⑴如果想要一个方法中的参数能在其他方法中使用,那么就可以使用"self.“来将这个参数变成一个实例变量(实例变量后面介绍,这里主要是遇到了这种写法)

⑵name参数:在方法中使用了"self.name = name”,这步就相当于是将这个name参数变成了一个实例变量,因此可以在所有方法中使用(这种写法了解即可,没啥意义,因为一个实例变量最好直接定义在__init__方法中)

⑶age参数:age参数就没有使用name参数那样的写法,仅仅是在setname()方法中定义并使用,因此age参数就只能在setname()方法中使用,而不能在kick()方法中使用,即使他们是在同一个类中(经常遇到的是这种写法)

类变量

1、类变量:是该类所有实例对象共享的属性(也可以叫"类属性")

⑴类属性是所有实例都共用的:所有实例都可以调用这个类属性

⑵在类中任意地方(所有方法中)都可以使用"类名.类属性名"来调用类属性

⑶在类外任意地方都可以使用"类名.类属性名"或"实例名.类属性名"来调用类属性

2、类变量是直接定义在类中的,比如例1中的"i = 12345",变量i就是一个类属性,该变量是所有实例对象共有的。类中的所有方法、实例都可以使用它

例5:

class Car():
"""这是一个汽车类"""
brand = "宝马"

def run(self, s):
# 类中调用类属性:类名.属性名
print("当前车型为:%s,当前行驶速度:%s KM/S" % (Car.brand,s))


a = Car()

类外调用类属性:实例名.属性名

print(a.brand, id(a.brand))
a.run(110)

b = Car()
print(b.brand, id(b.brand))
b.run(200)

"""
宝马 1744629351728
当前车型为:宝马,当前行驶速度:110 KM/S
宝马 1744629351728
当前车型为:宝马,当前行驶速度:200 KM/S
"""

实例变量

1、类变量是所有实例公用的属性。也就是说一些属性是所有实例都共有的,那么此时我们可以将该属性定义为类属性

⑴那么如果某些属性是每个实例独有的(每个实例的属性值都不一致),那么我们就可以将这些属性定义为实例属性

2、实例变量:是每个实例都独有的数据(也可以叫"实例属性")

⑴即某个属性对于每个实例都是独有的,就需要将其定义为实例变量

⑵某个属性是每个实例同共有的就可以定义为类属性

3、实例变量是定义在__init__方法中的

⑴__init__()方法也是类中的一个方法,因此其第一个参数也必须是self

⑵实例变量是每个实例对象独有的,因此在定义实例变量时,必须是:self.实例变量名 = 外部形参名(通过self来绑定当前实例对象)

⑶在类中任意地方(所有方法中)都可以使用"self.实例属性名"来调用实例属性

⑷在类外任意地方都可以使用"实例名.实例属性名"来调用实例属性

例6:

class People():
country = "china"

def __init__(self,name):
self.name = name

def speak(self, age):
# 类中调用类属性:类名.属性名
# 类中调用实例属性:self.属性名
print("我的名字是:%s,来自:%s,年龄是:%s" % (self.name,People.country,age))

实例化类时传入实例变量值

a = People("Tom")
a.speak(11)

b = People("Jack")
b.speak(12)

"""
我的名字是:Tom,来自:china,年龄是:11
我的名字是:Jack,来自:china,年龄是:12
"""

注:

1、上面例子中定义了一个类属性"country",是所有实例共有的;定义了一个实例属性"name",是每个实例独有的

2、一个类中存在实例变量(定义了init方法且init方法中存在形参)时,那么在实例化类时就需要传入对应的实参,否则会报错

3、实例方法、类方法、静态方法中可以有自己参数(例子中的参数age),方法中的参数的作用域为方法本身内部(只能在该方法中使用,即使是同一个类中的不同方法,也不能使用)

⑴方法中的参数类型与普通函数的参数类型是一样的(只是第一个参数必须是self)。可以是位置参数(必填参数)、关键字参数、默认参数、可变参数等

⑵如果方法中定义了一些参数,那么在调用这些方法时就必须传入对应参数的值了

4、上面实例化了两个实例对象a、b,在方法speak()中都调用了实例属性name。那么Python是怎么确定当前实例变量name的值是"Tom"或"Jack"的呢?其实就是通过self参数来确定的:一个类可以实例化出无数个实例对象,通过self参数来确定当前是哪个实例对象在调用了

⑴比如当前为实例对象a在调用时,此时self参数就表示实例对象a,此时Python就去找实例对象a的实例属性name的值

⑵比如当前为实例对象b在调用时,此时self参数就表示实例对象b,此时Python就去找实例对象b的实例属性name的值

⑶这样就不会出现什么,实例对象a在调用,但找的是实例对象b的实例属性值了

5、在类中是不可能出现实例对象名的(实例对象是实例化后才产生的),因此在类中使用self参数来表示实例对象

⑴类中的self参数就相当于一个形参,当类实例化后,实例对象就相当于self参数的实参

⑵哪个实例对象在调用,self参数就表示哪个实例对象

6、self.name = name表示:将外部传来的变量name的值赋值给当前实例对象的name属性(两个name之间无任何关系,只是变量名一致)

⑴name:只是一个形参,用来接收外部传入的实参值

⑵self.name:表示当前实例对象的实例属性(当前是哪个实例对象,就表示哪个实例对象的实例属性)

7、因此在类中调用实例属性时都必须使用"self.实例属性名"的方式来调用,这样才能通过self参数来确定当前是哪个实例对象在调用

类变量与实例变量

1、在调用一个类中的属性时,Python会按照一定的顺序去查找这个属性:先在当前实例中找,有就用当前实例中的,如果没有就找类中的

例15:

class C:
count = 0
a = C()
b = C()
c = C()
print(a.count,b.count,c.count) #output:0,0,0

a.count += 10 #实例对象调用类属性
print(a.count,b.count,c.count) #output:10,0,0

C.count += 100 #类对象调用类属性
print(a.count,b.count,c.count) #output:10 100 100

#print(count) #name 'count' is not defined,不能直接访问类属性,具体访问方法参考前面的属性访问

注:

1、对实例对象的count属性进行赋值后,就相当于覆盖了类对象C的count属性,如果没有赋值覆盖,那么引用的就是类对象的count属性

⑴通过"实例对象名.属性名"来覆盖类属性,只会影响到当前实例对象,不会影响到其他实例对象中的类属性

⑵通过"类名.属性名"来覆盖类属性,会影响到所有实例的类属性

⑶因此在类外调用类变量时,最好使用"实例对象名.属性名",避免在重新赋值时影响到其他实例

2、类变量和实例变量的区别在于:类变量是所有对象共有,其中一个对象将它值改变,其他对象得到的就是改变后的结果;而实例变量则属对象私有,某一个对象将其值改变,不影响其他对象

3、获取一个实例对象的属性时,其属性名后面都是不需要加园括号的(不管是我们自己定义的类还是Python自带的类);如果属性名后面带上了园括号,那么就变成了一个方法名了。这肯定是不对的。所以要分清楚调用的是类的属性还是类的方法

⑴不管是调用类方法还是属性,都是通过"."点操作来实现的

类的使用

1、定义个类主要是将一些具有相同属性的数据、方法放到一个类中整合起来方便代码的管理。最终目的还是调用类中的属性和方法

2、在调用类中的方法或属性时都必须遵循一定的规则:调用类的属性或方法分类在类中调用、在类外调用。不同地方调用,调用的方式也会有一定的差距

3、调用类属性:

⑴类中访问类变量:类名. 类变量名

⑵类外访问类变量:类名.类变量名或实例名.类变量名

4、调用实例属性:

⑴类中访问实例变量:self.实例变量名

⑵类外访问实例变量:实例名.实例变量名

4、调用实例方法:

⑴类中访问实例方法:self.方法名(参数)或类名.方法名(self,参数)

⑵类外访问实例方法:实例名.方法名(参数)

例7:

class MyClass:
"""一个简单的类实例"""
i = 12345#定义一个类属性

def f(self):#定义一个实例方法
print(MyClass.i) #类中调用类属性
return 'hello world'

def g(self):
# 类中调用实例方法
self.f()
MyClass.f(self)

x = MyClass() # 实例化类

访问类的属性和方法

print("MyClass 类的属性 i 为:", x.i) #类外调用类属性
print("MyClass 类的属性 i 为:", MyClass.i)
print("MyClass 类的方法 f 输出为:", x.f()) #类外调用实例方法
x.g()

"""
MyClass 类的属性 i 为: 12345
MyClass 类的属性 i 为: 12345
12345
MyClass 类的方法 f 输出为: hello world
12345
12345
"""

注:

1、在未实例化类时(x = MyClass()前),只是定义了对象的属性和方法,此时其还不是一个完整的对象,将定义的这些称为类(抽象类)。需要使用类来创建一个真正的对象,这个对象就叫做这个类的一个实例,也叫作实例对象(一个类可以有无数个实例)

2、创建一个对象也叫做类的实例化,即x = MyClass()。(此时得到的x变量称为类的具体对象)。注意此时类名后面是跟着小括号的,这跟调用函数一样。另外赋值操作并不是必须的,但如果没有将创建好的实例对象赋值给一个变量,那这个对象就没办法使用,因为没有任何引用指向这个实例

3、如果要调用对象里的方法,就需要判断是在类中调用还是在类外调用:

⑴在类中调用实例方法:self.方法名(参数)或类名.方法名(self,参数)这个这里只是提一下,可以先不纠结

⑵在类外调用实例方法:实例对象名.方法名(参数)。这里的例子就是类外调用方法,只是说实例方法中没有定义参数。x.f():x为实例对象名,f()为类中定义的实例方法

4、 x.i和MyClass.i都是用于调用类的属性,也就是我们前面所说的类变量;x.f()用于调用类的实例方法

⑴调用类属性可以使用:实例对象名.类属性名或类名.类属性名。虽然这两种方法都可以调用类属性,但是两者在调用使用还是有区别的,后面介绍

5、类中定义方法的要求:在类中定义方法时,第一个参数必须是self,除第一个参数外,类的方法和普通的函数没什么区别,如可以使用默认参数,可变参数,关键字参数和命名关键字参数等

⑴虽然在定义方法时会定义一个self参数,但是不管是在类中或是在类外调用方法都不用传递self,其他参数正常传入

⑵self参数究竟是什么,这里也可以先不纠结,目前只需要知道定义一个实例方法时,第一个参数必须是self,但是在调用实例方法时,不需要传递这个self参数

6、类对象(抽象类)支持两种操作:即属性引用和实例化

⑴属性引用:方法为类名.类属性名(也可以实例对象名.类属性名)

⑵实例化:将一个抽象类实例化成一个实例对象(x = MyClass() )。一个类可以实例化出无数个对象

7、类是一个抽象的概念,对象则是一个实际存在的东西。就像我们说的"狮子",它只是一个抽象的东西,只有具体到狮子这种动物身上它才是实际存在的。在比如设计房子的图纸只能告诉你房子是什么样的,并不是真正的房子,只有通过钢筋水泥建造出来的房子才实际存在,才能住人。

⑴"造房子"这个过程就相当于是"实例化类’,一个抽象类只有实例化成一个具体的实例对象后,才会有意义(抽象类只有实例化后才能使用,才会有意义)

例8:

class Student():
address = "china" #定义类变量address

def __init__(self,name,age): #定义实例变量age和name
self.name = name
self.age = age

def Info(self,score):#定义在方法中的变量(普通的变量:作用域为这个方法内)
return "学生来自于%s,名字为%s,年龄为%s,成绩为%s"%(Student.address,self.name,self.age,score)
#类中访问实例变量:self.实例变量名
#类中访问类变量:类名.类变量名
#类中访问方法中的普通变量:直接变量名(且该变量只能在这个方法中使用,不能再其他方法或类外调用)


student = Student("张三",18) #实例化类
print(student.name) #类外访问实例变量:实例名.实例属性名
print(Student.address) #类外访问类变量:类名.类属性名(也可以实例名.类属性名)
print(student.Info(98)) #类外访问实例方法:实例名.方法名(参数)

#另一个实例对象
student_1 = Student("李四",20)
print(student_1.name)
print(student_1.address)
print(student_1.Info(100))

"""
张三
china
学生来自于china,名字为张三,年龄为18,成绩为98
李四
china
学生来自于china,名字为李四,年龄为20,成绩为100
"""

注:

1、在Student类中,类属性address为所有实例所共享;实例属性name和age每个student的实例独有(每个实例有不同的name和age)

⑴类属性:实例对象student和student_1拥有一样的address属性

⑵实例属性:实例对象student和student_1拥有不一样的name和age属性(每个实例独有的属性)

属性绑定

1、在定义类时,通常我们说的定义属性,其实是分为两个方面的:类属性绑定、实例属性绑定(也就是定义类属性或实例属性)

2、用绑定这个词更加确切;不管是类对象还是实例对象,属性都是依托对象而存在的。我们说的属性绑定,首先需要一个可变对象,才能执行绑定操作,使用objname.attr = attr_value的方式,为对象objname绑定属性attr。这分两种情况:

⑴若属性attr已经存在,绑定操作会将属性名指向新的对象

⑵若不存在,则为该对象添加新的属性,后面就可以引用新增属性

类属性绑定

Python作为动态语言,类对象和实例对象都可以在运行时绑定任意属性。因此,类属性的绑定发生在两个地方

⑴类定义时

⑵运行时任意阶段

例9:

class Dog:

kind = 'canine'

Dog.country = 'China' #绑定一个新的类属性country

print(Dog.kind, ' - ', Dog.country) # 输出: canine - China
del Dog.kind
print(Dog.kind, ' - ', Dog.country) #由于上一行删除的kind属性,因此输出为AttributeError: type object 'Dog' has no attribute 'kind'

注:

1、在类定义中,类属性的绑定并没有使用objname.attr = attr_value的方式,这是一个特例,其实是等同于后面使用类名绑定属性的方式

2、因为是动态语言,所以可以在运行时增加属性,删除属性

实例属性绑定

与类属性绑定相同,实例属性绑定也发生在两个地方:类定义时、运行时任意阶段

例10:

class Dog:

def __init__(self, name, age):
self.name = name
self.age = age

dog = Dog('Lily', 3)
dog.fur_color = 'red' #为实例对象dog增加一个fur_color属性

print('%s is %s years old, it has %s fur' % (dog.name, dog.age, dog.fur_color))

#上面代码的输出结果为:Lily is 3 years old, it has red fur
注:
1、语句self.name = name,self.age = age以及后面的语句dog.fur_color = 'red'为实例dog增加三个属性name, age, fur_color。

2、Python类实例有两个特殊之处:

⑴__init__在实例化时执行

⑵Python实例对象调用方法时,会将实例对象作为第一个参数传递因此,__init__方法中的self就是实例对象本身,这里是dog

属性引用

属性的引用与直接访问名字不同,不涉及到作用域

类属性引用

类属性的引用,肯定是需要类对象的,属性分为两种:数据属性、函数属性。只是通常很少有引用类函数属性的需求

例11:数据属性引用很简单

class Dog:

kind = 'canine'

Dog.country = 'China'

print(Dog.kind, ' - ', Dog.country) # output: canine - China

例11_1:

class Dog:
kind = 'canine'

def tell_kind(self):
print(Dog.kind)

def info(self):
return self.tell_kind() #类中调用实例方法

dog = Dog()
dog.tell_kind() # Output: canine
dog.info() # Output: canine

实例属性引用

使用实例对象引用属性稍微复杂一些,因为实例对象可引用类属性以及实例属性。但是实例对象引用属性时遵循以下规则:

⑴总是先到实例对象中查找属性,再到类属性中查找属性

⑵属性绑定语句总是为实例对象创建新属性,属性存在时,更新属性指向的对象

例12:

class Dog:

kind = 'canine'
country = 'China'

def __init__(self, name, age, country):
self.name = name
self.age = age
self.country = country

dog = Dog('Lily', 3, 'Britain')
print(dog.name, dog.age, dog.kind, dog.country) #output:Lily 3 canine Britain

注:

类对象Dog与实例对象dog均有属性country,按照规则,dog.country会引用到实例对象的属性;但实例对象dog没有属性kind,按照规则会引用类对象的属性

例13:

class Dog:

kind = 'canine'
country = 'China'

def __init__(self, name, age, country):
self.name = name
self.age = age
self.country = country

dog = Dog('Lily', 3, 'Britain')

print(dog.name, dog.age, dog.kind, dog.country) # Lily 3 canine Britain
print(dog.__dict__) # {'name': 'Lily', 'age': 3, 'country': 'Britain'}

dog.kind = 'feline'

print(dog.name, dog.age, dog.kind, dog.country) # Lily 3 feline Britain
print(dog.__dict__) # {'name': 'Lily', 'age': 3, 'country': 'Britain', 'kind': 'feline'}
print(Dog.kind) # canine (没有改变类属性的指向)

注:

使用属性绑定语句dog.kind = ‘feline’,按照规则,为实例对象dog增加了属性kind,后面使用dog.kind引用到实例对象的属性。这里不要以为会改变类属性Dog.kind的指向,实则是为实例对象新增属性,可以使用查看__dict__的方式证明这一点。

可变类属性引用

例14:

class Dog:

tricks = []

def __init__(self, name):
self.name = name

def add_trick(self, trick):
self.tricks.append(trick)

d = Dog('Fido')
e = Dog('Buddy')
d.add_trick('roll over')
e.add_trick('play dead')
print(d.tricks) output:# ['roll over', 'play dead']
注:

语句self.tricks.append(trick)并不是属性绑定语句,因此还是在类属性上修改可变对象

拓展

python中的self参数

例16:定义任意一个类:

class Student(object):
pass
student = Student()

注:

由于类起到模板的作用,因此,可以在创建实例的时候,把我们认为必须绑定的属性强制填写进去(绑定实例变量)。这里就用到Python当中的一个内置方法__init__方法,例如在Student类时,把name、score等属性绑上去

例16_1:

class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score

>>>student = Student("Hugh", 99)
>>>student.name
"Hugh"
>>>student.score
99

注:

1、__init__方法的第一参数永远是self,表示创建的当前类实例本身,因此,在__init__方法内部,就可以把各种属性绑定到self,因为self就指向创建的实例本身

2、有了__init__方法,在创建实例的时候(类实例化),就不能传入空的参数了,必须传入与__init__方法匹配的参数,但self不需要传,Python解释器会自己把实例变量传进去

3、这里self就是指当前实例对象本身,self.name就是当前student实例对象的name属性,是该student实例对象独有的

4、name是外部传来的参数,不是Student类自带的。故,self.name = name的意思就是把外部传来的参数name的值赋值给student当前实例对象自己的实例属性name(只是实例变量的名字和形参的一样而已)

例16_2:

class Student(object):
def __init__(self, name_1, score_1):
self.name = name_1
self.score = score_1

student = Student("zh",12)
print(student.name)
print(student.score)

"""
zh
12
"""

注:

这个例子中就特意把实例变量名和形参名定义成不一样了:self.name = name_1

⑴name_1相当于是占位的形参,只是方便外部向类中传递参数(给实例变量传递值),没有什么实际意义

⑵self.name中的name才是真正的实例变量了,是每个实例独有的属性

⑶只是说这两个变量表示的属性意义是一样的,因此更多的是将两个写成一样的名字。不然,有一个实例属性是"名字",形参用的是"a",实例属性用的是"name",这样就看起来比较奇怪的,都表示的是"名字"却用了不一样的名字

例16_3:

class Person:
def __init__(self, name, job=None, pay=10):
self.name = name
self.job = job
self.pay = pay

def getRaise(self, percent):
self.pay = int(self.pay * (1 + percent))
return self.pay


p = Person("xiaoming", "jixie")
print(p.getRaise(0.8)) # output:18

注:

self是指当前被调用的对象,对的,就是上边刚被你实例化的对象p。当你需要调用当前对象(实例对象)的方法或者属性时,要用self.来进行调用(类中调用实例属性或方法:self.)

例17:

class CC:
def setXY(self,x,y):
self.x = x
self.y = y
def printXY(self):
print(self.x ,self.y)

dd = CC()
dd.setXY(4,5)

注:

self参数:当实例对象dd去调用setXY方法的时候,它传入的第一个参数就是dd,那么self.x = 4,self.y = 5也就相当于dd.x = 4,dd.y = 5,所以你在实例对象,甚至类对象中都看不到x和y,因为这两个属性是只属于实例对象dd的

例18:

class TestClass(object):
val1 = 100

def __init__(self):
self.val2 = 200

def fcn(self, val=400):
val3 = 300

self.val4 = val
self.val5 = 500


if __name__ == '__main__':
inst = TestClass()

print(TestClass.val1)
print(inst.val1)
print(inst.val2)
#print(inst.val3)
#val3为局部变量,无法在函数为调用'TestClass' object has no attribute 'val3'
#print(inst.val4)
#print(inst.val5)

注:

1、val1是类变量,可以由类名直接调用,也可以有对象来调用;

2、val2是实例变量,可以由类的对象来调用,这里可以看出成员变量一定是以self.的形式给出的,因为self的含义就是代表实例对象

3、val3既不是类变量也不是实例变量,它只是函数fcn内部的局部变量

4、val4和val5也都不是实例变量,虽是以self.给出,但并没有在构造函数中初始化

在实例方法中调用其他方法

例18:

class Dog():
def __init__(self,name,age):
self.name = name
self.age = age

def get_dog_information(self):
dog_information = "name is {0},age is {1}".format(self.name,self.age)
return dog_information

def get_dog_speak(self,love):
dog_speak = self.get_dog_information() + love
return dog_speak

dog = Dog("jake",13)
print(dog.get_dog_speak("swimming"))

#name is jake,age is 13swimming

注:在上面例子中

在get_dog_information()方法中调用了get_dog_information(),且get_dog_information()方法前加了self参数,该参数的意义与其他self的意思一样,都是代表实际本身

实例方法、类方法、静态方法

1、在面向对象的编程中,类属性可细分为类属性和实例属性一样,同样的,对于类中的方法也可以具体可划分为类方法、实例方法和静态方法

实例方法

1、在类编程中,一般情况下在类中定义的方法、函数默认都是实例方法

2、python的类编程中实例方法最大的特点就是最少要包含一个self参数,该参数必须定义,但调用时不需要传

⑴该self参数的作用是绑定调用此方法的实例对象(确定当前是哪个实例对象在调用方法、实例变量,Python会自动完成绑定),类比C++中的this指针

⑵实例方法:方法中第一个参数都是self,实例变量、实例方法都需要要绑定self(self参数表示当前实例对象本身)

⑶调用实例方法:只能由实例对象调用

3、感觉经常用到的都是实例方法,所以前面主要介绍了实例方法。类方法和静态方法感觉不是经常用到,所以在这里补充下

例19:

class MyClass:
className = "三年2班" # 定义一个类属性className

def __init__(self,name):#定义一个实例变量name
self.name = name

def BaseInfo(self):
# 类中调用实例变量、类变量
baseInfo = "My name is %s,I am a student in %s" % (self.name,MyClass.className)
return baseInfo

def ComeFrom(self,country,*args): # 在方法中定义一些局部变量(只能在该方法中使用)
# 类中调用类方法
baseInfo = self.BaseInfo()
comeFrom = baseInfo + ".I comefrom " + country + "," + ",".join(args)
return comeFrom

x = MyClass("张三") # 实例化类
engdu","高新区","茂业中心"))

y = MyClass(“李四”) # 实例化类

类外访问实例方法

print(y .ComeFrom("china","meishan","hongya","gaomiao"))

"""
My name is 张三,I am a student in 三年2班.I comefrom china,chengdu,高新区,茂业中心
My name is 李四,I am a student in 三年2班.I comefrom china,meishan,hongya,gaomiao
"""

类方法

1、Python中的类方法和实例方法类似,但类方法需要满足以下要求:

⑴类方法至少需要包含一个参数,与实例方法不同的是该参数并非self,而是python程序员约定俗成的参数:cls(cls表示当前类对象)

⑵Python会自动将类本身绑定到cls参数(非实例对象),故在调用类方法时,无需显式为cls参数传递参数

⑶类方法需要使用修饰语句: @classmethod

2、调用类方法:类和实例对象都可以调用

⑴类方法推荐使用类名直接调用,当然也可以使用实例对象来调用(不推荐)

例20:

class CLanguage:
#类构造方法,也属于实例方法
def __init__(self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
#下面定义了一个类方法
@classmethod
def info(cls):
print("正在调用类方法",cls)


#使用类名直接调用类方法
CLanguage.info()
#使用类对象调用类方法
clang = CLanguage()
clang.info()

"""
正在调用类方法 <class '__main__.CLanguage'>
正在调用类方法 <class '__main__.CLanguage'>
"""

例20_1:

文件在工程中的路径:Py_Project/zxc.py

class People():
def __init__(self,name):
self.name = name

# 定义了一个类方法:类方法中是不能有实例变量的
@classmethod
def Age(self,age):
age = "age is %s" % (age)
return age
# 定义一个实例方法:可正常使用实例变量
def Info(self,age):
info = "name is %s,age is %s" % (self.name,age)
return info

导入所需模块

from Py_Project.zxc import People

调用实例方法:在调用实例方法前必须实例化类

people = People("jack")
print(people.Info(12))

name is jack,age is 12

导入所需模块

from Py_Project.zxc import People

调用类方法:通过实例名来调用类方法,也要先实例化类

people = People("jack")
print(people.Age(13))

调用类方法:通过类名来调用类方法,就不需要实例化类

print(People.Age(14))

age is 13

注:

1、在一个类中可以同时定义实例方法、类方法、静态方法

2、类方法中是不能调用实例变量的,但是可以调用类变量:因为类方法是指向类的,而不是实例对象的

3、调用实例方法前必须实例化类;调用类方法就可以直接使用类名进行调用

静态方法

1、类中的静态方法,实际上就是大家众所周知的普通函数,存在的唯一区别是:

⑴类静态方法在类命名空间中定义,而函数则在程序的全局命名空间中定义

2、需要注意的是:

⑴类静态方法没有self、cls这样的特殊参数,故Python解释器不会对其包含的参数做任何类或对象的绑定

⑵类静态方法中无法调用任何类和对象的属性和方法,类静态方法与类的关系不大

⑶静态方法需要使用@staticmethod修饰

3、静态方法的调用,既可以使用类名,也可以使用类对象

4、静态方法是类中的函数,不需要实例等

⑴静态方法主要是用来存放逻辑性的代码,逻辑上属于类,但是和类本身没有关系

⑵也就是说在静态方法中,不会涉及到类中的属性和方法的操作(静态方法中不能使用实例变量、类变量、实例方法等)

⑶可以理解为,静态方法是个独立的、单纯的函数,它仅仅托管于某个类的名称空间中,便于使用和维护

例21:

class CLanguage:
@staticmethod
def info(name,add):
print(name,add)
#使用类名直接调用静态方法


#使用类对象调用静态方法
clang = CLanguage()

注:

1、在Python类编程中,实例方法是必须要掌握的内容,类方法与类静态方法用得不多,因为两者完全可以使用函数来代替