第一节 认识变量

变量名=变量

查找内存地址 id(变量名)

命名规则字母 下划线 数字 数字不开头且不可全为数字

命名习惯，大驼峰 MyName MyAge 小驼峰 myName myAge

数据类型str int float bool tuple(元组） list(列表) dict(字典) set(集合)

查找数据类型 type(变量名)

查找数据类型 type(变量名)

第二节 数据类型转换

1、输出print()

格式化输出 %d %s %f

%d 有符号十进制整数

%.3d %03d 001 %3d (空格）（空格）1

后面是小数 整数都可以输出整数

%s 字符串

无论后面是整数 小数 字符串都可以输出

%f 小数输出6位小数

%.1f 180.4

后面是小数 整数都可以输出小数

字符串插入操作

“xxx%dxxx"%变量名 ”

“xxx%(s/d/f)xxx%(s/d/f)xxx%(s/d/f)"%(变量名，变量名，变量名）“ 一一对应

f"xxxx{变量名}xxx"

"xxxx{}xxx{}".format(变量名，变量名) 一一对应

"xxxx{a}xxx{b}".format(a=变量名，b=变量名)

2、输入input()将输入的东西全部变 字符串

当程序执行到input，等待用户输入，输入完成后才能继续执行

Python中，input接受用户输入后，一般存储到变量中，方便使用

Python中，input会把接收到的任意数据当作字符串来处理

3、数据类型转型

想要转换到的数据类型（要转化的变量名）

a="123"(字符型) print(int(a))123

整数类型可以转换为浮点数

浮点数可以转换为整数

列表 元组 集合可以互相转换

eval：会将长得像某种数据类型的字符串，转换成它对应的数据类型

扒光衣服

注意 长得像浮点数的字符串不可转换成整数型，可间接转换

4、转义字符

\n换行

\t 制表格4个空格

\ 续行

\'

\"

第三节 运算符

1、算术运算符加减乘除

加+

减—

乘*

除/

整除//

取余%

乘方**

==#优先级==

** > * = \ = % = // > + = -

print("1"+"1")11

2、赋值运算符

= 将“=”右边的值赋给左边变量名

3、复合运算符

+=

-=

\=

*=

%=

\\=

**=

==#优先级==

先计算赋值运算符右边的表达式

4、判断运算符

== != >= <=

5、逻辑运算符

and 和 只要有一个为假，则输出False 必须两个都为真，才能输出True

or 或 只要有一个为真，返回True 两个都为假，返回False

not 取返 如果为Ture,返回False 同理

6、数学之间的逻辑运算符

and运算符，只要有一个为0，则结果为0，否则结果为最后一个非0数字

or运算符，只有所有为0结果才为0，否则结果为第一个非0数字

==#优先级==

not > and > or

not必须写在最前面

not 0 不管后面还有什么输出Ture

7、in not in

in 在里面

not in 不在里面

第四节 了解条件语句

1、if语法

if 表达式:表达式​：冒号，说明当前代码并未完成缩进相同说明属于同一代码块

2、if...else...

if 表达式：表达式else：表达式​else 与离得最近的if配对​if True 永远执行if False 永远不执行

3、if...elif...else...

elif 再如果​if 表达式：表达式elif 表达式：表达式elif 表达式：表达式else：表达式

4、多重判断

5、if嵌套 重在逻辑

6、三目运算

a=1b=2c=a if a>b else b # 如果a>b,c=a;如果a不大于b，c=bprint(c)

第六节 while循环（条件循环）

1、循环：将事物循环执行

2、循环分类：while for

while：在给定的判断条件为True时执行循环体，否则退出循环体

while 循环条件：满足条件，进行循环

3、break:

代表停止，终止循环

4、continue：

代表跳过，continue之后的代码不会执行，跳出本次循环

5、while嵌套循环

内部循环执行完毕才会执行外部循环

外部循环一旦不满足条件，内部循环也将不会执行

第七节 for循环（遍历循环、迭代循环）

1、for.....in......循环 遍历循环

可迭代对象：字符串、元组、列表、字典、集合

for 临时变量 in 待处理数据集（可迭代对象）:重复执行代码

2、rang()语句

for循环本质是遍历"序列类型"，但是，使用rang语句，可以获得简单的”数字序列“

例：1、rang(num)获得一个从0开始到num结束的数字序列（不包含num）​rang(5)--->[0,1,2,3,4]​2、rang(num1,num2)​获得一个从num1开始到num2结束的数字序列（不包括num 2）​rang(4,9)--->[4,5,6,7,8]​3、rang(num1,num2,step) ​step默认为1​rang(1,10,2)--->[1,3,5,7,9]4、倒着打步长变为负数num1=10num2=0rang(num1,num2,-1)--->[10,9,8,7,6,5,4,3,2,1]

3、for循环的嵌套应用

for 临时变量 in 待处理数据集:重复执行代码一重复执行代码二重复执行代码三for 临时变量 in 待处理数据集:重复执行代码三重复执行代码三重复执行代码三

第八节 字符串

1、字符串的输入输出：

var1="name"var2='name'var3="""namei love you"""​%s---->字符串 %d----->整数%f------->小数

2、下标（索引）

索引值从0开始

从左往右从0开始

从右往左从-1开始

var1="hello world"print(var1[0])-------->h

3、切片

根据索引值切片var1=' h e l l o w o r l d'01 2 3 4 5 6 7 8 9-10 -9 -8 -7 -6 -5 -4 -3 -2 -1​print(var1[0:5])------->hello[0:4]----->左闭右开

[开始下标：结束下标（不能取到）：步长] 默认为1

[:5]----->默认从0开始

[5:]----->默认取到最后

[:]------->默认全取

4、常用操作方法

字符串的常用操作方法有查找、修改、判断三类

1、查找：

所谓字符串的查找方法即是查找子串在字符串中的位置或出现的次数

①find（）：

检测某个字符串是否包含在这个字符串中，如果在，返回这个字符串开始的位置的下标，否则返回-1

var="hello and python and hello world"print(var.find("and"))------->查找到and首字母下标print(var.find("and",11,20))------>在11-19范围内查找and首字母下标的下标print(var.find("hei"))------>-1（没有此字符串）返回-1

②index():

var="hello and python and hello world"print(var.index("and"))------->查找到and首字母下标print(var.index("and",11,20))------>在11-19范围内查找and首字母下标的下标print(var.index("hei"))------>报错（没有此字符串）

③count():

返回某个子串在字符串中出现的次数

print(var.count("a"))------>2​print(var.count("nihao"))----->没有返回0

2、修改：对字符串当中的内容进行修改

①replace():

替代内容

print(字符串序列.replace(“旧子串”，“新子串‘，替换次数))​注意：替换次数如果超出子串出现次数，则替换次数为该子串出现次数​print(字符串序列.replace(”旧子串“，”新子串“))--------->替换所有旧子串

②split():

按照指定字符分割字符串

print(字符串序列.split(“分割字符",切割次数))--------->返回列表

③join():

用一个字符串合并字符串，即是将多个字符串合并为一个新的字符串。

print(“指定符号”.join(多字符串组成的序列（列表、元组、集合）（单个）))list1=["a","b","c"]print(" -".join(list))---->a-b-c​将（列表、元组、集合）转化为字符串，并且使用指定符号隔开

3、大小写转换：

①capitalize():

将字符串第一个字母转换成大写。

var=“hello and python and hello world"​print(var.capitalize())

②#title():

将字符串每个单词首字母转换成大写。

print(var.title())

③#upper():

将字符串中小写转大写。

print(var.upper())

④#lower():

将字符串中大写转小写。

print(var.lower())

⑤#strip():

删除字符串两侧空白字符。

print(var.lstrip())

⑥lstrip():

删除字符串左侧空白字符。

⑦rstrip():

删除字符串右侧空白字符。

⑧ljust():

左对齐

⑨rjust():

右对齐

⑩center():

居中对齐

4、判断：输出为True False

①startswitch():检查字符串是否已指定子串开头

字符串序列.startswitch(子串，开始位置下标，结束为止下标(取不到))

②endswitch():检查字符串是否是以指定子串结尾

③isalpha():如果字符串所有字符都是字母则返回True,否则返回False

④isdigit():如果字符串只包含数字则返回True否则返回False

⑤isalnum():如果字符串所有字符都是字母或数字返回Ture否则返回False

⑥isspace():如果字符串中只包含空白，则返回True,否则返回False

5、字符串运算：

a="hello"b="world"​+:字符串连接 print(a+b)---->helloworldin:成员运算符 -如果字符串中包含给定的字符返回Truenot in:成员运算符-如果字符串中不包含给定的字符返回True[]:通过索引获取字符串中字符[ : ]:截取字符串中的一部分r:取消转义%：格式字符串

第九节 元组与列表

1、列表：

①列表的应用场景：列表可以一次性存储多个数据，且可以为不同数据类型

②列表的格式：list1=[1,2,3,3.4,5.8,"张三“,”李四“]

③列表的常用操作：

列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查

查找：

根据下标查找

函数

index():

返回指定数据所在位置的下标。

print(列表序列.index(数据，开始位置下标，结束位置下标))

count():

统计指定数据在当前列表出现的次数。

print(列表序列.count(数据，开始位置下标，结束位置下标))

len():

访问列表长度，即列表中数据的个数。

print(len(列表序列))

in与not in

in:判断指定数据在某个列表序列，如果在返回True,否则返回False

not in:判断指定数据不在某个列表序列，如果不在返回True,否则返回False

增加：

增加指定数据到列表中。

append():

列表结尾追加数据

列表序列.append(数据)​如果append()追加的数据是一个序列，则追加整个序列到列表

列表是可变类型，增加完数据后内存地址不变，字符串不可变**

（修改之后，内存地址如果不变，那么就是可变的）

extend():

列表结尾追加数据，如果数据是一个列表，则将这个序列的数据逐一添加到列表（字符串拆分成若干字母依次添加）

insert():

指定位置新增数据。

列表序列.insert(位置下标，要添加的数据)

删除：

删除列表中的数据。

del：

删除整个列表

del 列表序列---->删除整个列表​del 列表序列[索引值]----->删除指定索引值的数据​del 列表序列[ : ]----->范围删除，不包括最后一个索引值数据

pop():

删除指定下标的数据（默认为最后一个），并返回该数据。

列表序列.pop(索引值)

remove():

移除列表中某一个数据的第一个匹配项。

列表序列.remove()默认删除第一个​列表序列.remove("数据")

clear():

清空列表。

修改：

修改指定下标数据。

直接修改(非删除)

name=["张三"，“李四”，“王五”]name[0]="阿坤"print(name)------>["阿坤",“李四”，“王五”]

reverse():逆置(数字)

列表序列.reverse()

sort()：排序，

reverse表示排序规则，reverse=True降序，reverse=False升序(默认)(int 类型)

列表序列.sort(reverse=False)​列表序列.sort(reverse=True)

复制：

copy():

list1，list2​list2=list1.copy()

④列表的循环遍历

for循环

while循环

⑤列表的嵌套：所谓列表的嵌套指的就是一个列表中里面包含了其他的子列表

name=[["张三"，“李四”，“王五”]，[“唱”，“跳”，“rap”，“篮球”]，[1,2,3,4]]​print(name[ 0 ] [ 1])----->李四------>第一个是列表，第二个是列表中的索引值

2、元组（多个数据不可修改）

①定义元组：定义元组使用小括号，且括号隔开各个数据，数据可以是不同的数据类型。

单个元组（1，）

②元组常见操作：

根据下标查找

index():

返回指定数据所在位置的下标。

元组序列.index(数据，开始位置下标，结束位置下标)

count():

统计指定数据在当前列表出现的次数。

元组序列.count(数据，开始位置下标，结束位置下标)

len():

访问列表长度，即列表中数据的个数。

len(元组序列)

元组中的直接数据如果修改直接报错，如果里面有列表则可以修改列表里面的数据

第十节 集合与字典

1、集合（没有索引值）

①创建集合(无序，不重复)

创建集合使用{}或set(),但是如果要创建空集合只能使用set(),因为{}用来创建空字典

②集合中常见的操作

增加数据：

add():

因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作

集合序列.add(数据)

update():

追加的数据是序列

集合序列.update(序列)

删除数据：

remove():

删除集合中的指定数据，如果数据不存在则报错

集合序列.remove(指定数据)

discard()：

删除数据中的指定数据，若数据不存在不报错

集合序列.discard(指定数据)

pop():

删除集合中的随机一个数据，并返回这个数据。

集合序列.pop()

查找数据：

in：

判断数据在集合序列

not in：

判断数据不再集合序列

2、字典

① 字典的应用场景：字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可

冒号左边的是键key，冒号右边是值value

②创建字典：

符号为大括号

数据以键值对的形式出现

各个键值对之间用逗号隔开

③字典常见操作

增加数据：

根据键增加

字典["添加的键"]=要添加的数据​字典[key]=value​如果key存在则修改这个key对应的值，如果key不存在则新增此键值对

删除数据：

del()/del:

删除字典或删除字典中指定键值对

del 字典[key]---->删除指定键值对​del(字典)---->删除整个字典

clear()：

清空字典

字典.clear()​字典.clear()------>set()

修改数据：

字典["添加的键"]=要添加的数据​字典[key]=value​如果key存在则修改这个key对应的值，如果key不存在则新增此键值对

查找数据：

key根据键查找值

print(字典[key])

get():

字典序列.get(key)​字典序列.get(key,默认值)

keys():

查找所有的键，类型就是键

字典.keys()

values():

查找所有的值

字典.values()

items():

查找所有的键值对

字典.items()

字典的遍历循环

for循环遍历字典key：遍历值values:遍历键值对items:拆包分开：for 变量名 in 字典.items():k,v=变量名print(k,v)for k,v in 字典.items():print(k,v)

第十一节 公共操作与推导式

可变 修改后内存地址没发生变化---列表、集合、字典

不可变 修改后内存地址发生变化----字符串、数组、元组

1、公共操作

合并 +：

var1='aa'​var2='bb'​print(var1+var2)---->aabb

复制 *：

print('-'*10)---->----------​list1=[1,2,3]​print(list1*2)---->[1,2,3,1,2,3]

2、公共方法

①len():

计算容器中元素的个数

②del/del():

删除

③max():

返回容器中元素的最大值

④min():

返回容器中元素的最小值

⑤range(start,end,step):

生成从start到end的数字，步长为step，供for循环使用

⑥#enumerate():

函数用于将一个可遍历数据对象（列表、元组、集合）组合成一个索引序列，同时列出数据和数据下标，一般用于for循环当中

enumerate（,start=0(默认)）​list1=['张三'，'李四','王五’，‘赵六’]for i in enumerate(list1):print(i)----->[(0,张三)，(1,李四)，(2,王五)，(3,赵六)]

拆包

⑦sum():

序列求和

⑧zip():

合并序列

list1=[1,2,3,4]list2=[5,6,7,8]print(list(zip(list1,list2)))----->[(1,5),(2,6),(3,7),(4,8)]

3、推导式

左边 推导式中间for循环右边条件判断​[表达式 for 变量 in 列表 if 条件]{键：值 for 变量 in 字典 if 条件}{表达式 for 变量 in 集合 if 条件}(表达式 for 变量 in 元组 if 条件)

①列表推导式

[表达式 for 变量 in 列表 if 条件]

②字典推导式

{键：值 for 变量 in 字典 if 条件}​将两个列表合并为一个字典：list1=['a','b','c']list2=[1,2,3]print({list1[i]:list2[i] for i in range(len(list1))})

③集合推导式

{表达式 for 变量 in 集合 if 条件}

④元组推导式

（表达式 for 变量 in 元组 if 条件）​返回一个生成器需要转换为元组

第十二节 函数入门

1、函数的作用：

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

2、函数的使用步骤：

①定义一个函数：

函数代码块以def关键词开头，后接函数标识符名称和圆括号()

任何传入参数和自变量必须放在原括号中间。圆括号之间可以定义参数

函数的第一行语句可以选择性的使用文档字符串一用于存放函数说明

函数内容以冒号起始，并且缩进

return[表达式]结束函数，选择性的返回一个值给调用方。不带表达式的return相当于返回None

②函数的调用：

③函数的参数作用

①必备参数：必备参数必须以正确的顺序传入函数。调用时的数量必须和声明时的一样。调用函数，你必须传入一个参数，不然会出现语法错误。

if name__ __ == '_main__':#程序入口 #程序会从此处开始执行

②关键字参数：关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

def demo(name,age):print(f"大家好，我是{name}，今年{age}岁了“)​name=“张三”age=18demo(name,age)

③默认参数：调用函数时，默认参数的值如果没有传入，则被认为是默认值。传入参数后，默认参数会被覆盖。

def demo(name='张三'，age=18):print（f"大家好，我是{name}，今年{age}岁了“）​demo(name,age)----张三，18demo（“李四”，19）-----李四，19

④不定长参数：Python自定义函数中有两种不定长参数，第一种*XXX，在传入额外的参数是可以不用指明参数名，直接传入参数值即可。第二种是**XXX，这种类型返回的是字典，传入时需要指定参数名。

加了一个星号*不定长参数会以元组的形式导入，存放所有未命名的变量参数。加了两个星号**的参数会以字典形式导入，存放已命名的变量参数。

#先后顺序不能乱args,kwargs，后面必须不能跟参数**

拓展2

def demo(name,age,*args,**kwargs)：print(name)print(age)print(args)print(kwargs)​if ____name____=='______main_____':demo('张三'，'18'，'阿坤'，'爱跳舞'，a='王五'，b='赵六')​张三18（'阿坤'，'爱跳舞'）{'a':'王五‘，'b':'赵六'}

④函数的返回值

return 语句[表达式]退出函数

return可返回多个值

数据类型为元组

⑤变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问。访问权限决定于这个变量是在哪里赋值的。变量的作用域决定留在那一部分程序你可以访问哪个特定的变量名称

全局变量局部变量global num后num变为全局变量

⑥函数的嵌套使用

函数之中调用函数

第十三节 函数进阶

1、多函数程序执行流程

①共用全局变量

global 变量名---->变量成为全局变量

②返回值作为参数传递

函数的返回值可以当做参数传递

2、拆包和交换变量值

①a,b=b,a

a,b互换值

②函数返回多个值

return后可跟多值，数据类型是元组

##3、递归##

①函数内部自己调用自己

②必须有出口

递归三原则：

递归必须有停止条件

递归必须改变其状态并向停止条件靠近

递归必须递归地调用自己

4、lambda表达式(匿名函数)

如果一个函数有一个返回值，并且只有一句代码，可以用lambda（）简化

语法lambda ：表达式（）（lambda （参数）：表达式）（传参）

5、lambda的参数形式

无参数

fn1=(lambda : 100)​print(fn1())----->100

单个参数

fn2=(lambda a : a)('abcdefg')​print(fn2------->abcdefg

多个参数

fn3=(lambda a,b : a+b)(5,7)​print(fn3）----->12

默认参数

fn4=(lambda a ,b,c=10 : a+b+c)(10,10)​print(fn4）---->30

不定长参数

fn5=(lambda *args: args)(1,2,3,4)​print(fn5）----->(1,2,3,4)​fn6=(lambda **kwargs :kwargs)(a=600,b=777)​print(fn6）----->{'a':666,'b':777}​fn7=(lambda *args,**kwargs : (args,kwargs))(1,2,3,4,a=666)​print(fn7)---->((1,2,3,4),{'a':666})

带判断的lambda表达式

print(lambda a,b:a if a>b else b)(1000,200)​1000

lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用

lambda函数能接受任何数量的参数但只能返回一个表达式的值

6、内置函数

abs():

函数可以完成对数字求绝对值计算

map(function,iterable)

将传入的函数变量function作用到iterable变量的每一个元素中，并将结果组成新的序列 function---函数 iterable---序列

list1=[1,2,3,4,5]def functinon(x):return x**2​result=map(function,list1)print(list(result))---->[1,4,9,16,25]

filter():

filter(function,list1)函数用于过滤序列过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表list()

第十四节、文件操作

1、文件操作的作用

文件操作包括：打开、关闭、读、写、复制.....

文件操作的作用是：读取内容、写入内容、备份内容....

文件操作的作用就是把一些内容（数据）存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力。

2、文件操作的基本步骤----打开文件

①打开：

在Python中使用open函数，可以打开一个已经存在的文件，或者创建一个新文件

open(name，mode)

{name：是要打开的目标文件名的字符串（可以包含文件所在的具体路径）

mode：设置打开文件的模式（访问模式）：只读、写入、追加等

mode：r（读写）,rb,r+,rb+w（添加（覆盖））,wb,w+,wb+a（追加）,ab,a+,ab+

r：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认设置。

w：打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

a：打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

r只读 r+读写 rb以二进制的形式进行读

w添加（覆盖） w+读写（覆盖） wb以二进制的形式进行添加（覆盖）

a追加 a+读写 ab以二进制的形式进行追加

3、文件对象方法

①写入操作：

w

#打开文件f=open('test.txt','w',encoding='utf-8')​#写入内容f.write("要写入的内容")​#关闭文件f.close()

a

f=open('text.txt','a',encoding='utf-8')f.write("写入内容")f.close()

②读取操作：r

read(num)----num表示要从文件中读取的长度

f=open('test.txt','r',encoding='utf-8')content=f.read()print(content)f.close()

上下文管理器

with open（"test.txt",'a'，encoding='utf-8') as name:name.write("添加的内容")

readlines()和readline()

readlines可以按照行的方式把整个文件中的内容进行一次性读取，并返回一个列表，其中每一行的数据为一个元素

readline()只读第一行

seek()

用来移动文件指针文件对象.seek(偏移量（字节），起始位置)​0：文件开头1：当前位置2：文件结尾​字节---一个字母占一个字节，一个汉字占两个字节，数字占一个字节

③文件备份

需求：用户输入当前目录下任意文件名，程序完成该文件的备份功能（备份文件名为xx[备份]后缀，例如：test备份.txt)

1、接收用户输入的文件名

2、规划备份文件名

3、备份文件写入数据

4、文件和文件夹的操作

导入os模块

import os

文件重命名

os.rename(目标文件名，新文件名)

删除文件

os.remove(目标文件名)

创建文件夹

os.mkdir(文件夹名字)

删除文件夹

os.rmdir(文件夹名字)

获取当前目录

os.getcwd()

改变默认目录

os.chdir(目录)

获取目录列表

os.listdir(目录)

十五、面向对象

1、理解面向对象

例如：肚子饿了，想吃饭

面向过程：去超市，买菜，卖肉，买米，回家，洗菜，炒菜，煮米饭，盛饭，开吃

面向对象：点外卖

总结：面向对象就是将编程当成是一个事物，对外界来说，事物是直接使用的，不用去管他内部的情况，而编程就是设置事物能够做什么事。

2、类和对象

在面向对象编程过程中，有两个重要的组成部分：类和对象

类和对象的关系：用类去创建一个对象

3、理解类和对象

①类

类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物

特征：即是属性

行为：即是方法

类比如是制造洗衣机是要用到图纸，也就是说类是用来创建对象的

②对象

对象是类创建出来的真实存在的事物，如手机

注意：开发中，先有类，再有对象

4、面向对象实现方法

语法：class 类名（）:代码pass

括号里不能写参数，但可以传参

注意：类名要满足标识符命名规则，同时遵循大驼峰命名习惯

5、创建对象

语法：#变量名 = 类名（）（实例化类 创建对象）

6、添加和获取对象属性

①类外面添加对象属性：

语法：对象名.属性名=值

②类里面获取对象属性

语法：self.属性名

7、self

self代表类的实例

类方法与普通函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，按照惯例它的名称是self

8、魔术方法

在Python中，_____xx__()的函数叫做魔术方法，指的是具有特殊功能的函数。

①___init___()：初始化对象

__init__()：在创建一个对象时默认被调用，不需要手动调用__init__(self)：中的self参数，不需要开发者传递，Python解释器会自动把当前对象引用传递过去

②__str__()

当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了str方法，那么就会打印从这个方法中return的数据。

③__del__()

当删除对象时，Python解释器也会默认调用__del__()方法。在对象销毁的时候被调用，当对象不再使用时，__del__()方法运行

9、类属性与方法

类的私有属性

两个下划线开头，声明该属性为私有，不能再类的外部被使用或直接访问

16、面向对象进阶

1、面向对线的特性：

继承的概念

Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法

在Python中，所有的类默认继承object类，object类是顶级或基类，其他子类叫做派生类

单继承

class Master(object):def ______init______(self):self.kunfu='六脉神剑'def demo(self):print(self.kunfu)class Apprentice(Master):pass

多继承

子类重写父类的方法和属性

子类调用父类的方法和属性

多重继承

super()

调用父类方法

私有权限

定义私有属性和方法

在Python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类

设置私有权限的方法：在属性名和方法名面前加上两个下划线

2、面向对象的三大特征

多态

传入不同的对象，产生不同的结果

多态指的是一类事物有多种形态

定义：多态是一种使用对象的子式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果。

好处：调用灵活，有了多态，更容易变写出通用的代码，做出通用的编程，以适应需求的不断变化

实现步骤：

定义父类，并提供公共方法

定义子类，并重写父类方法

传递子类对象给调用者，可以看到不用子类执行效果不同

class Father(object):def demo(self):print('攻城')​class Son1(Father):def demo(self):print("正面强攻")​class Son2(Father):def demo(self):print('偷袭')​class Main(object):def func_demo(self,result):result.demo()​​​func1=Son1()func2=Son2()func3=Main()func3.func_demo(func1)func3.func_demo(dunc2)

类方法和静态方法

需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数

class Demo(object):__num=10@classmethoddef get_num(cls):return cls.__num​func=Demo()print(func.get_num())

静态方法

当方法中既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性、类方法、创建实例等）时，定义静态方法

取消不需要参数传递，有利于减少不必要的内存占用和性能消耗

@staticmethod

17、一闭三器

1、闭包

保证数据安全

全局变量可随意修改，数据不安全

如果放到一个函数中，数据安全，但无法引用

①闭包结构

内层函数对外层函数的局部变量的使用，内层函数被称为闭包函数

闭指的是：该函数的内部函数

包指的是：内部函数在外部被引用

②构成条件

函数嵌套

外部函数返回内部函数名

内部函数使用外部函数的变量

def external():print("我是外层函数")def inside():print("我是内层函数")return inside​str=external()str()

2、装饰器

装饰器的本质，就是一个闭包

在不改变函数作用基础上，给函数增加一些新功能

装饰器是Python的一个重要部分。简单的说，他们是不改变函数功能的基础上，给函数增加一些功能。他们有助于让我们的代码更简短，更有范儿

函数可以作为参数进行传递

def demo1()：print（"全民制作人，大家好"）​def demo2(func):func()​demo2(demo1)----->全民制作人，大家好​

3、迭代器

迭代器是一种对象，该对象包含值的可计数数字

迭代器是可迭代的对象，这意味着您可以遍历所有值

从技术上讲，在Python中，迭代器是实现迭代器协议的对象，它包含方法iter()和next()

迭代器与可迭代对象

列表、元组、字典和集合都是可迭代对象他们是可迭代的容器，你可以从中获取迭代器（lterator),所有这些对象都有用于获取迭代器的iter()方法

4、生成器

生成器的本质就是迭代器

创建生成器的两种方案

生成器函数中有一个关键字yield

生成器函数执行的时候，并不会执行函数，得到的是生成器

只要函数中出现了yield，那他就是一个生成器函数

可以返回数据

可以分段执行函数的内容，通过next，执行到下一个yield的位置

18、异常与模块

异常处理

什么是异常

异常即是一个事件，该事件在程序执行过程中发生，影响了程序的正常执行

一般情况下，在Python无法正常处理程序时就会发生一个异常

异常是Python对象，表示一个错误

当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行

异常处理

捕获异常可以使用try/except语句

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理

如果你不想在异常发生时结束你的程序，只需在try里捕获它

异常的else

else表示的是如果没有异常要执行的代码。

异常的finally

finally表示的是无论是否异常都要执行的代码，例如关闭文件

自定义异常

自定义异常类，必须要继承Exception，并且包含init和str魔术方法（设置异常描述） 在Python中，抛出自定义异常的语法为raise异常类对象

模块

导入模块方式import 模块名​from 模块名 import 功能名​from 模块名 import *​import 模块名 as 别名​from 模块名 import 功能名 as 别名

时间模块time

获取当前时间

从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数

获取格式化时间​Python中时间日期格式化符号年%Y 两位数的年份表示（00-99）%y 四位数的年份表示（0000-9999）​月%m 月份（01-12）​日%d 月内中第一天​时%H 24小时制小数时（0-23）%h 12小时制小时数（01-12）​分%M 分钟数（00-59）

制作模块

在Python中，每个Python文件都可以作为一个模块，模块名字就是文件的名字。也就是说自定义模块名必须要符合标识符命名规则。

调用模块

import 模块名

制作包

[new]——[Python package]——输入包名——新建功能模块

导入包

import 包名.模块名

包名.模块名.目标