6.1.1 概念
整数
Python可以处理任意大小的整数，当然包括负整数，在Python程序中，整数的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
字符串
字符串是以''或""括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。
布尔值
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来。
布尔值可以用and、or和not运算。
and运算是与运算，只有所有都为 True，and运算结果才是 True。A与B true true
or运算是或运算，只要其中有一个为 True，or 运算结果就是 True。
not运算是非运算，它是一个单目运算符，把 True 变成 False，False 变成 True。
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
6.1.2 代码示例
#整数a=1;#浮点数b=1.1;#字符串c="abc";#boolean类型d=True;#空值e=None;print(a);print(b);print(c);print(d);print(e)a=TrueandTrue# ==> Trueb=TrueandFalse# ==> Falsec=FalseandTrue# ==> Falsed=FalseandFalse# ==> Falsee=TrueorTrue# ==> Truef=TrueorFalse# ==> Trueg=FalseorTrue# ==> Trueh=FalseorFalse# ==> Falsei=notTrue# ==> Falsej=notFalse# ==> Trueprint(a,b,c,d,e,f,g,h,i,j)
说明：
在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。
6.1.3 标识符
什么是标识符？
开发人员在程序中自定义的一些符号和名称
标识符是自己定义的,如变量名 、函数名等
标识符的命名规则
. 标识符只能由字母、下划线“_”、数字组成。. 标识符不能以数字开头。. 标识符不能使用关键字. 标识符对大小写敏感。（建议:标识符命名应“见名知意”）
python中的关键字
'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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']
注释：
单行注释:
/* *///定义一个变量name="jack"
多行注释:
'''
定义一个变量
'''name="jack"
课堂思考:下列哪些标识符符合规则
ifname and my_list my_list1from#1age2listasTruewetyui height my_log qwe&qwe
标识符的命名方法
小驼峰式命名法：
函数名 addName
大驼峰式命名法：
类名 AddName
6.2.Python中print语句
print() 方法用于打印输出，最常见的一个函数。
语法:
print(*objects, sep=' ', end='\n', file=sys.stdout)
参数:
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file -- 要写入的文件对象。
#直接打印print("哈哈哈哈")#多条打印print("哈哈哈哈","呵呵呵呵","吼吼吼吼"),#打印+计算print("100+200的和是:",100+200);#设置间隔符号print("www","runoob","com",sep=".") # 设置间隔符 www.runoob.com
格式化输出
方式一:使用百分号（%）字符串格式化
print("my name is %s, and my age is %d" %(name,age))
方式二：使用format字符串格式化
位置参数
print("my name is{}, and my age is{}".format(age,name))
关键字参数
print("my name is {name}, and my age is {age}".format(age=18,name="jack"))
注释:位置参数("{0}".format())，关键字参数("{关键字}".format())
6.3.设置换行符号
print(a,b,c,d,e,sep=";",end="\n");
6.4.Python中input语句
input() 用来获取控制台的输入。
语法：
input([prompt])
image.png
6.5.Python中变量
在Python中，变量的概念基本上和初中代数的方程变量是一致的。
例如，对于方程式 y=x*x ，x就是变量。当x=2时，计算结果是4，当x=5时，计算结果是25。
只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。
在Python程序中，变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头，比如：
a = 123 # a是整数print (a)a = 'imooc' # a变为字符串print (a)b=11; #b是整数d=11.1;#d是浮点数print(b*d)
七、Python条件循环和判断
7.1. If语句
Python 编程中 if 语句用于控制程序的执行，基本形式为：
if 判断条件： 执行语句……else： 执行语句……
其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。
else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句，具体
7.2.If else 语句
age = 12if age>18: print("年龄大于18")else: print("年龄小于等于18")age=20;if age>18: print("年龄大于18")if not age <=18: print("年龄大于18")
注意：Python代码的缩进规则。具有相同缩进的代码被视为代码块，上面的 print 语句就构成一个代码块。如果 if 语句判断为 True，就会执行这个代码块。
缩进请严格按照Python的习惯写法：4个空格，一个Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。
7.3. If else else 多层嵌套方式
age=10;if age >= 18: print ('adult')else: if age >= 6: print ('teenager') else: if age >= 3: print ('kid') else: print ('baby')
标准格式
if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。
当判断条件为多个值时，可以使用以下形式：
if 判断条件1: 执行语句1……elif 判断条件2: 执行语句2……elif 判断条件3: 执行语句3……else:执行语句4……
案例：
score=85;if score>=90: print("成绩优秀")elif score>=80: print("成绩不错")elif score>=60: print("及格")else: print("不及格");
7.4. For循环：重复执行语句
forn inrange(1,20):print(n)arr=[100,90,86,80,77]forindex in arr:print(index)
注意: b这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋值给 name，然后执行for循环体（就是缩进的代码块）
练习：求四个同学的平均成绩 L = [75, 92, 59, 68]
arr=[100,90,86,80,77]sum=0.0forindex in arr:sum+=indexprint(sum/len(arr))
7.5. While 循环
Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：
while 判断条件： 执行语句……
执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。当判断条件假false时，循环结束,while 循环不会迭代 list 或 tuple 的元素
要从 0 开始打印不大于 N 的整数：
N = 20i = 0while i < N: print(i) i += 1;
练习:求100以内的和
sum = 0i = 0while i < 100: sum += i i += 1print(sum)
7.6. Break中断循环
break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。
break语句用在while和for循环中。
如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。
var=10whilevar>0:print(var)var=var-1ifvar==5:# 当变量var等于5时退出循环break
7.7. Continue
Python continue 语句跳出本次循环，而break跳出整个循环。
continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
continue语句用在while和for循环中。
var=10whilevar>0:var=var-1ifvar==5:continueprint(var)
7.8.嵌套循环
Python 语言允许在一个循环体里面嵌入另一个循环
for x in ['A', 'B', 'C']: for y in ['1', '2', '3']: print (x + y)
7.9.Python字符串操作
字符串转义
a='learn "python" from teacher liang';b='bob said \"I\'m ok\"';print(a)print(b);
\n 表示换行
\t 表示一个制表符
\ 表示 \ 字符本身
字符串截取操作(左闭右开)
a="hello world";print(a[0:2]) #he 截取字符串 从第0到第2个 包含头不包含尾print(a[1]) #e 某个索引的字符
字符串拼接
b="hello";c="world"d=b+c;print(d)#hello world 字符串拼接
包含不包含,使用in和not in判断是否包含
e="hello world";f='he' in e;g='haahha' in e;h="he" not in e;i='haahha' not in e;print(f,g); #True False 判断是否包含print(h,i); #False true 判断是否不包含
常用字符串的操作api
a="hello world"print(a.upper())#HELLO WORLD 变成大写b=a.startswith("hello");#true 是以什么进行开头c=a.endswith("world");#true 以什么进行结尾d=a.replace("h","hhhhh");#hhhhhello world 替换字符print(d);
八、Python中List和Tuple类型
序列是Python中最基本的数据结构。
序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
a= ['physics', 'chemistry', 1997, 2000]b = [1, 2, 3, 4, 5 ]c = ["a", "b", "c", "d"]
8.1. 定义集合
a=["aaa",123,"bbb",True];#定义集合
8.2. 获取某个索引的元素
print(a[1]);#123 获取索引值为1处的元素
8.3. 倒序获取元素
print(a[-1],a[-2],a[-3],a[-4]);#True bbb 123 aaa 倒数第一个，倒数第二个，倒数第三个
8.4.添加元素
追加
a.append("哈哈哈");print(a);#['aaa',123,'bbb',True,'哈哈哈']
插入
a.insert(1,"82岁韩美林);a.insert(2,"PGone")print(a);#['aaa','李小璐','PGone',123,'bbb',True,'哈哈哈']
8.5.删除元素
a.pop(2);a.pop(1);print(a);#['aaa',123,'bbb',True,'哈哈哈']删除某索引值的元素
8.6.替换元素
a[2]="贾乃亮";a[-1]="吼吼吼"print(a);#['aaa',123,'贾乃亮',True,'吼吼吼']替换指定位置元素
8.7.定义元组(Tuple)[ˈtjup(ə)l]
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
t = ('Adam', 'Lisa', 'Bart')
现在，这个 t 就不能改变了，tuple没有 append()方法，也没有insert()和pop()方法。所以，新同学没法直接往 tuple 中添加，老同学想退出 tuple 也不行。
a=("a","b","c");print(a);#('a','b','c')
8.8. 可变Tuple
元组可以使用下标索引来访问元组中的值，如下实例:
a = (1, 2, 3, 4, 5, 6, 7 )print(a[1:5]) # 2,3,4,5
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
tup1=(12,34.56)tup2=('abc','xyz')tup3=tup1+tup2print(tup3)a=("a","b",["c"]);print(a);#('a','b','c')l=a[2];l.insert(0,"d");print(a)#('a','b',['d','c'])
九、Dict介绍--字典类型 dictionary
9.1.字典介绍
我们已经知道，list 和 tuple 可以用来表示顺序集合，例如，班里同学的名字：
['Adam','Lisa','Bart']
或者考试的成绩列表：
[95,85,59]
但是，要根据名字找到对应的成绩，用两个 list 表示就不方便。
如果把名字和分数关联起来，组成类似的查找表：
'Adam'==>95'Lisa'==>85'Bart'==>59
给定一个名字，就可以直接查到分数。
Python的 dict 就是专门干这件事的。用 dict 表示“名字”-“成绩”的查找表如下：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59}
我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。
花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
key value(键值对)形式数据对应，比如 name：张三 age：18 sex:男
info={"name":"张三","age":18,"sex":"男"}
9.2. Dict特点
字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的；字典中找某个元素时，是根据'名字'（就是冒号:前面的那个值，例如上面代码中的'name'、'age'、'sex'）
dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
由于dict是按 key 查找，所以，在一个dict中，key不能重复。
dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样：
dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。
9.3. 元素获取
print(info["name"])print(info.get("name"))##print(info.get("xx"))如果元素没有会报错误
9.4. 字典的增删改操作
修改元素
字典中每个元素都是可修改的，只要通过key找到，既可以修改Demo
info["name"]="李四"
添加元素
想要添加元素，只需要指定key 指定 value就可以
info["address"]="北京"
删除元素
对字典进行删除操作，有以下两种方式：
# del info[] 指定要删除的元素delinfo["name"]# clear 清空元素info.clear()
9.5. 字典内置函数&方法
号函数及描述实例
1len(dict)计算字典元素个数，即键的总数。 >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> len(dict)3
2str(dict)输出字典，以可打印的字符串表示。 >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> str(dict)"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
3type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。 >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> type(dict)
9.6.字典的常见操作
keys() 获取字典的所有key 列表
print(info.keys())
values 获取字典的所有values 列表
print(info.values())
items 返回一个包含所有元组(键，值)的列表
print(info.items())
9.7. 字典的遍历
遍历key
for key in info.keys(): print(key)
遍历value
forvalueininfo.values():print(value)
遍历items
for item in info.items(): print(item)
遍历key value
forkey,valueininfo.items():print(key,value)
十、Python中函数
10.1.什么是函数
如果在开发的时候，需要某块代码多次，但是为了提高便携的效率以及代码的重用，所以把具有独立功能的代码块组织成一个小的模块，这就是函数。
10.2.函数定义和调用
10.2.1. 定义函数
定义函数的格式如下：
def函数名():代码
定义一个函数，能够完成打印信息的功能
defprintInfo():print'------------------------------------'print' 人生苦短，我用Python'print'------------------------------------'
10.2.2. 调用函数
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它
调用函数很简单的，通过函数名() 即可完成调用
案例：
# 定义完函数后，函数是不会自动执行的，需要调用它才可以printInfo()
10.3.函数的好处
减少代码的冗余，减少维护量，功能的封装，降低学习成本，提高开发速度
10.4. 函数参数
定义带有参数的函数:
defprintSum(a,b):print(a+b)
调用带有参数的函数
printSum(10,20)
形式参数和实际参数
定义时小括号中的参数，用来接受参数用的,称为“形参”
调用时小括号中的参数，用来传递给函数用的，称为”实际参数”
10.5.缺省参数
默认有参数值的函数
defstudent(name,age,sex="男"):print(name,age,sex)student("格日仓",18)student("格日仓",20,"女")
10.6. 可变参数(一 元组类型)
defgetSum(*args):print(args)sum=0foriinargs:sum+=ireturnsumprint(getSum(1,2,3,4))
10.7. 可变参数(二 字典类型)
dic={'a':90,'b':80,'c':70,'d':100}defkv(**kwargs):print(kwargs)kv(a=90,b=80,c=70,d=100)
十一、函数返回值
所谓返回值，就是程序中函数完成一件事后，最后给调用者的结果。
11.1.定义带有返回值的函数
11.2.调用带有返回值参数的函数
11.3.多个返回值的函数
案例:两个数字除数和商
十二、函数类型
12.1.无参数，无返回值的函数
12.2.无参数，有返回值的函数
12.3.有参数，无返回值的函数
12.4.有参数，有返回值的函数
十三、函数的嵌套调用
案例:在函数A中调用函数B，然后调用函数。
分析调用顺序。
defadd():print("这是add1")print("加法运算的逻辑")defadd2():print("想实现加法的运算")add()print("计算出一个结果")add2()
十四、局部变量
局部变量，就是在函数内部定义的变量
不同的函数，可以定义相同的名字的局部变量，各用个的不会影响
局部变量作用:为了临时保存数据需要在函数中定义变量来存储。
十五、全局变量
如果一个变量，既能在一个函数中使用，又能在其他函数中使用，这样的变量就是全局变量。
在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问
如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错
如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的
#全局变量，局部变量#全局变量：在函数外定义的变量#局部变量：在函数内部定义的变量#全局变量与局部变量，就近原则a=100b=200defadd():globala#修改全局变量a=200#局部变量returna+bdefadd2():returna+bre=add()print(re)print(add2())
十六、递归函数
如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。
16.1.循环完成
求n的阶乘
defgetMultipy(n):i=1result=1whilei<=n:result=result*i i+=1returnresultprint(getMultipy(10))
16.2.函数调用函数自身
求n的阶乘
defgetMultipy(n):ifn>=1:result=n*getMultipy(n-1)else:result=1returnresultprint(getMultipy(3))
十七、Python中模块和包
在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似，比如在Python中要调用sqrt函数，必须用import关键字引入math这个模块。
导入模块import 语句
模块定义好后，我们可以使用 import 语句来引入模块，语法如下：
importmodule1[,module2[,...moduleN]
比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。
在调用 math 模块中的函数时，必须这样引用：
#模块名.函数名importmathprint(math.pi);#3.141592653589793
from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
from modname import name1[, name2[, ... nameN]]
例如，要导入模块 math 的 pi 函数，使用如下语句：
frommathimportpiprint(pi)
17.1.导入自定义模块
在test1中定义求和方法
defsum(a,b):returna+b
test中直接导入方法
fromtest2importsumprint(sum(1,2))
十八、文件操作
18.1. 什么是文件
使用文件的目的：就是把一些文件存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力
在操作文件的整体过程与使用word编写一份简历的过程是很相似的：
打开文件，或者新建立一个文件
读/写数据
关闭文件
18.2. 打开、关闭文件
python中打开文件，可以使用open函数，可以打开一个已经存在的文件，或者创建一个新的文件。
open(文件名，访问模式)
# 新建一个文件，文件名为:test.txtf = open('test.txt', 'w')# 关闭这个文件f.close()
18.3. 文件访问模式
文件打开分为两种：文本模式（r/w/a），二进制模式（rb/wb/ab）
image.png
18.4. 文件的读写
写数据(write) - write()方法
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符('\n')：
f=open('test.txt','w')f.write('hello world, i am here!')f.close()
读数据(read)
使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
f = open('test3.txt','r')print(f.read())
Python写入内容
file=open("test.txt","r+")content=file.read(2)print(content)content=file.read()print(content)file.close()
如果open是打开一个文件，那么可以不用写打开的模式，即只写 open('test.txt')
如果使用读了多次，那么后面读取的数据是从上次读完后的位置开始的
读数据（readline）按照行读取内容
Python写入内容
file=open("test.txt","r+")content=file.readline()print(content)content=file.readline()print(content)
读数据（readlines）读取每一行
就像read没有参数时一样，readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
#coding=utf-8f = open('test.txt', 'r')content = f.readlines()print(type(content))i=1for temp in content: print("%d:%s"%(i, temp)) i+=1f.close()file = open("E:\\ceshi.txt")read = file.readlines()read2= file.readline()print(read)print(read2)
18.5. File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：
属性描述
file.closed返回true如果文件已被关闭，否则返回false。
file.mode返回被打开文件的访问模式。
file.name返回文件的名称。
file.softspace如果用print输出后，必须跟一个空格符，则返回false。否则返回true。
如下实例：
#!/usr/bin/python# -*- coding: UTF-8 -*-# 打开一个文件fo = open("foo.txt", "w")print "文件名: ", fo.nameprint "是否已关闭 : ", fo.closedprint "访问模式 : ", fo.modeprint "末尾是否强制加空格 : ", fo.softspace
十九、文件的重命名、删除
有些时候，需要对文件进行重命名、删除等一些操作，python的os模块中都有这么功能
19.1.文件重命名
os模块中的rename()可以完成对文件的重命名操作
rename(需要修改的文件名, 新的文件名)
importosos.rename("毕业论文.txt","毕业论文-最终版.txt")
19.2.删除文件
os模块中的remove()可以完成对文件的删除操作
remove(待删除的文件名)import osos.remove("毕业论文.txt")
19.3.创建文件夹，删除文件夹
Python里的目录：
所有文件都包含在各个不同的目录下，不过Python也能轻松处理。
os模块有许多方法能帮你创建，删除和更改目录。
mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。
rmdir()方法
rmdir()方法删除目录，目录名称以参数传递。
注意：在删除这个目录之前，它的所有内容应该先被清除。
Import osos.mkdir("aaa")os.rmdir("test")print(os.getcwd()) 获取当前目录
二十、文件拷贝
打开现有一个文件1，读取文件当中的内容
test = open("E:\\ceshi.txt","r")read = test.readlines()
新建一个文件，写入文件1当中的内容
test2=open("test2.txt","w")forx in read:test2.write(x)test.close()test2.close()
读取新文件内容
test3 = open("test2.txt",'r')print(test3 .read())
十三、Python面向对象编程
面向过程：根据业务逻辑从上到下写代码
面向对象：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程
面向对象编程的2个非常重要的概念：类和对象
对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念——类
类就相当于制造飞机时的图纸，用它来进行创建的飞机就相当于对象
类与对象的关系：类就是创建对象的模板
13.1. Python定义类并创建实例
13.1.1类(Class) 由3个部分构成：
类的名称:类名
类的属性:一组数据
类的方法:允许对进行操作的方法 (行为)
对象 = 属性 + 方法
静态 + 动态
引入：
案例一：人类设计,只关心3样东西:
事物名称(类名):人(Person)
属性:身高(height)、年龄(age)
方法(行为/功能):跑(run)、打架(fight)
案例二：狗类的设计
类名:狗(Dog)
属性:品种 、毛色、性别、名字、 腿儿的数量
方法(行为/功能):叫 、跑、咬人、吃、摇尾巴
13.1.2 以 Person 为例，定义一个Person类如下：
classPerson(object):passxiaoming=Person();xiaohong=Person();print(xiaoming)#<__main__.Person object at 0x000001C113239128>print(xiaohong)#<__main__.Person object at 0x000001C113239160>print(xiaohong==xiaohong)#False
按照 Python 的编程习惯，类名以大写字母开头，紧接着是(object)，表示该类是从哪个类继承下来的。类的继承将在后面的章节讲解，现在我们只需要简单地从object类继承。
pass语句什么也不做，一般作为占位符或者创建占位程序，pass语句不会执行任何操作
13.2.创建对象
通过上一节课程，定义了一个Car类；就好比有车一个张图纸，那么接下来就应该把图纸交给生成工人们去生成了
python中，可以根据已经定义的类去创建出一个个对象
创建对象的格式为:
对象名 = 类名()
创建对象demo:
# 定义类classCar:# 移动defmove(self):print('车在奔跑...')# 鸣笛deftoot(self):print("车在鸣笛...嘟嘟..")# 创建一个对象，并用变量BMW来保存它的引用BMW=Car()BMW.color='黑色'BMW.wheelNum=4#轮子数量BMW.move()BMW.toot()print(BMW.color)print(BMW.wheelNum)
image.png
总结：
BMW = Car()，这样就产生了一个Car的实例对象，此时也可以通过实例对象BMW来访问属性或者方法
第一次使用BMW.color = '黑色'表示给BMW这个对象添加属性，如果后面再次出现BMW.color = xxx表示对属性进行修改
BMW是一个对象，它拥有属性（数据）和方法（函数）
当创建一个对象时，就是用一个模子，来制造一个实物
13.3. Python中创建实例属性
虽然可以通过Person类创建出xiaoming、xiaohong等实例，但是这些实例看上除了地址不同外，没有什么其他不同。在现实世界中，区分xiaoming、xiaohong要依靠他们各自的名字、性别、生日等属性。
如何让每个实例拥有各自不同的属性？由于Python是动态语言，对每一个实例，都可以直接给他们的属性赋值，例如，给xiaoming这个实例加上name、gender和birth属性：
classPerson(object):passxiaoming=Person();xiaohong=Person();xiaoming.name="小明"xiaoming.age=12xiaoming.grade=3xiaohong.name="小红"xiaohong.age=19;xiaohong.sex="女"print(xiaoming)#地址print(xiaohong)#地址print(xiaoming.name)#小明print(xiaoming==xiaohong)#False
13.4. Python中初始化实例属性
在定义 Person 类时，可以为Person类添加一个特殊的init()方法，当创建实例时，init()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：
classPerson:def__init__(self,name,sex,age):self.name=name;self.sex=sex;self.age=age;person1=Person("小明","男",19);person2=Person("小红","女",20);print(person1.name,person1.sex,person1.age);#小明 男 19print(person2.name,person2.sex,person2.age);#小红 女 20
init()方法，在创建一个对象时默认被调用，不需要手动调用init(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么init(self)中出了self作为第一个形参外还需要2个形参，例如init(self,x,y)
init(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去
13.5. Python中访问限制
我们可以给一个实例绑定很多属性，如果有些属性不希望被外部访问到怎么办？
Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问
classPerson(object):def__init__(self,name,score):self.name=nameself.__score=scorep=Person('Bob',59)print(p.name,p._score);
但是，如果一个属性以"xxx"的形式定义，那它又可以被外部访问了，以"xxx"定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用"xxx"定义。
13.6. python中定义实例方法
一个实例的私有属性就是以__开头的属性，无法被外部访问，那这些属性定义有什么用？
虽然私有属性无法从外部访问，但是，从类的内部是可以访问的。除了可以定义实例的属性外，还可以定义实例的方法。
实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的：
classPerson:def__init__(self,name,age):self.__name=nameself.age=agedefgetName(self):returnself.__name;person1=Person("张三",19)print(person1.getName())
13.7. python中创建类属性
类是模板，而实例则是根据类创建的对象。
绑定在一个实例上的属性不会影响其他实例，
但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！
也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。
classPerson:#声明address地址address="earth"def__init__(self,name,age):self.name=nameself.age=ageperson1=Person('zhangsan',19)print(person1.address)#earthprint(Person.address)#earth
13.8. python中定义类方法
和属性类似，方法也分实例方法和类方法。
在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。
classPerson(object):count=0@classmethoddefhowMany(cls):returncls.countdef__init__(self,name):self.name=name Person.count=Person.count+1print(Person.count,"-----------")person1=Person("张三");print(person1.howMany())#1print(Person.howMany())#1
十四、Python中继承
14.1. 继承概念
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。
通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。
14.2. 为什么要继承
新类不必从头编写，代码的重用
新类从现有类继承，就自动拥有了现有类的所有功能
新类只需要编写现有类缺少的新功能
在程序中,继承描述的是事物之间的所属关系,例如猫和狗都属于动物.
image.png
14.3. 继承特点以及单继承
子类在继承的时候，在定义类时，小括号()中为父类的名字
父类的属性、方法，会被继承给子类
classDog(object):def__init__(self,name,color="黄色"):self.name=nameself.color=colordefrun(self):print("%s在跑着"%self.name)classJinMao(Dog):defsetNewName(self,name):self.name=namedefeat(self):print("%s在吃饭，颜色是%s"%(self.name,self.color))dog1=JinMao("大黄")dog1.run()dog1.setNewName("小阿黄")dog1.eat()
说明:虽然子类没有定义init方法，但是父类有，所以在子类继承父类的时候这个方法被继承了，所以只要创建子类的对象，就默认执行了这个init方法.
14.4. 多继承
classMa(object):defprintMa(self):print("ma的特性")classLv(object):defprintLv(self):print("lv的特性")classLuoZi(Ma,Lv):defprintLuo(self):print("骡子的特性")luo=LuoZi()luo.printLuo()luo.printLv()luo.printMa()
14.5. 多继承同名方法调用
classMa(object):defprintMa(self):print("ma的特性")defrun(self):print("万马奔腾")classLv(object):defprintLv(self):print("lv的特性")defrun(self):print("万驴奔腾")classLuoZi(Ma,Lv):defprintLuo(self):print("骡子的特性")luo=LuoZi()luo.run()print(LuoZi.__mro__)
先继承哪个，就调用哪个的方法
关于Python类的多继承中的mro属性使用的C3算法以及继承顺序解释
14.6. 方法的重写及调用父类方法
#方法的重写classAnimal(object):def__init__(self,name,sex,color):self.name=nameself.sex=sexself.color=colordefplay(self):print("动物都有各自的玩法")classCat(Animal):def__init__(self,name,sex,color,age):#super代表父类super().__init__(name,sex,color)self.age=age#方法的重写/覆盖defplay(self):super().play()print("%d岁的猫喜欢爬墙"%self.age)c=Cat("小花","母","花色",8)c.play()#猫喜欢爬墙print(c.name,c.sex)
14.7. 类属性和对象属性
类属性就是类(类对象)所拥有的属性。它被类和所有对象所拥有。对于共有类属性，在类外可以通过类对象和实例对象访问。
类属性
classDog(object):name="Tom"__age=10print(Dog.name)#正确print(Dog.__age)#错误，__age属于私有属性，不能在外边访问d=Dog()print(d.name)#正确print(d.__age)#错误，__age属于私有属性，不能在外边访问
对象属性
def__init__(self,name):self.name=nameprint(Dog.name)#Tomd=Dog("大黄",19)print(d.name)#大黄print(d.getAge())defgetAge(self):returnself.__age
14.8.python中多态（了解）
类具有继承关系，并且子类类型可以向上转型看做父类类型，如果我们从 Person 派生出 Student和Teacher ，并都写了一个 whoAmI() 方法，在一个函数中，如果我们接收一个变量 x，则无论该 x 是 Person、Student还是 Teacher，都可以正确打印出结果：这种行为称为多态。
方法调用将作用在 x 的实际类型上。s 是Student类型，它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法，但调用 s.whoAmI()总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。
classPerson(object):def__init__(self,name,gender):self.name=nameself.gender=genderdefwhoAmI(self):return'I am a Person, my name is '+self.nameclassStudent(Person):def__init__(self,name,gender,score):super().__init__(name,gender)self.score=scoredefwhoAmI(self):return'I am a Student, my name is '+self.nameclassTeacher(Person):def__init__(self,name,gender,course):super(Teacher,self).__init__(name,gender)self.course=coursedefwhoAmI(self):return'I am a Teacher, my name is '+self.namep=Person('Tim','Male')s=Student('Bob','Male',88)t=Teacher('Alice','Female','English')print(p.whoAmI())print(s.whoAmI())print(t.whoAmI())
14.9.python中多重继承（了解）
除了从一个父类继承外，Python允许从多个父类继承，称为多重继承。
classA(object):def__init__(self,a):print('init A...')self.a=aclassB(A):def__init__(self,a):super().__init__(a)print('init B...')classC(A):def__init__(self,a):super().__init__(a)print('init C...')classD(B,C):def__init__(self,a):super().__init__(a)print('init D...')d=D("--");# init A...# init C...# init B...# init D...
十五、Python中异常
15.1. 什么是异常？
异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
一般情况下，在Python无法正常处理程序时就会发生一个异常。
异常是Python对象，表示一个错误。
当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。
#演示各种异常情况
#第一个异常，数学异常
# ZeroDivisionError: division by zero < # i=1/0 #第二个异常，类型转换错误 # TypeError: must be str, not int # age=int(input("请输入年龄")) # print("年龄是"+age) #第三个异常:文件异常 # FileNotFoundError: [Errno 2] No such file or directory: 'aa.txt' # file=open("aa.txt","r") # file.write("哈哈") # file.close() #第四个异常 未定义异常 # NameError: name 'num' is not defined # print(num)#编译错误