Python学习笔记
----------------------------------------------------------------------------------------第一阶段-------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------基本格式-------------------------------------------------------------------------------------------
Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。
在文件开头加入 # -*- coding: UTF-8 -*- 或者 # coding=utf-8 。
=======================================
print 输出打印
例：可以输出数字 print(30) 结果是：30
可以输出字符串 print("home") 结果是：home
print('home') 结果是：home
可以输出表达式 print(3+4) 结果是：7
打印：print('输出的结果为：{0},地址为{1}'.format(a,b))
将数据输入文件中1.打开文件：fp=open('D:/text.txt','a+') 注：文件位置、a+（如果文件存在就直接放入文件中，如果文件不存在就创建一个文件）
2.输出到文件中：print('早上好',file=fp) 注：file函数
3.关闭文件：fp.close()
要进行一行输出：print('早'，‘上’，‘好’) 结果是：早 上 好
======================================
转义字符：\n 换行 || print('ni\nhao') 结果为：ni
|| hao
\r 覆盖 || print('ni\rhao') 结果为：hao
\t 4个空格 || print('ni\thao') 结果为：ni hao
\b 退一个位 || print('ni\bhao') 结果为：nhao
\\ 单斜杠 || print('ni\\hao') 结果为：ni\hao
\' 单引号 || print('ni\'hao') 结果为：ni'hao
\" 双引号 || print('ni\"hao') 结果为：ni"hao
r/R 原意字符 || print(r'ni\nhao') 结果为：ni\nhao
=====================================
二进制： 1Gb=1024Mb
1Mb=1024kb
1kb=1024byte
1byte=8bit 一字节有256，对应ASCLL码中128个符号
=====================================
变量的地址和类型： id(变量) 获取变量的物理地址
type(变量) 获取变量的数据类型
五个标准的数据类型：numbers 数字（num）
string 字符串（str）
list 列表
tuple 元组
dictionary 字典
常见的数据类型： int 整形
float 浮点型
str 字符串
bool 布尔
进制表示：0xff 十六进制
0o77 八进制
0b11 二进制
99 十进制
======================================
类型转换：str转int 必须是整形数字串，不能有字符和浮点字符串 错误：int（'a'）int('12.25')
int转str 可以随便转换
------------------------------------------------------------------------
int转float 可以随便转换
float转int 可以随便转换
------------------------------------------------------------------------
float转str 可以随便转换
str转float 必须是数字串，不能有字符 错误：float('a')
chr(数值) 转换后可为汉字
ord('汉字') 转换后可为数值
====================================
注释： # 单行注释
“ ”“ ”“ ”多行注释
#coding:dbk ANSI编码格式 （用记事本打开文件，然后另存为就可以看到编码格式）
#coding:utf-8 UTF-8编码格式
=====================================
函数：input 输入函数,输入的结果为字符串类型（str），可以在存储后转换结果，也可在存储的过程中转换 例：time=int（input('输入前的提示')）
运算符：
算数运算符：加(+)、减(-)、乘(*)、除(/)、幂运算(**)、整除(//)、取余(%)
赋值运算符：链式赋值：a=b=c=2(地址相同)
参数赋值：+=、-=、*=、/=、//=、%=
解包赋值：a,b,c=1,2,3(可用于交换数据)
比较运算符：>、==、<、>=、<=、！=(比较value，其结果为bool类型)
is(比较id是否相同)
is not(比较id是否不相同)
布尔运算符：and(有假为假) 例：a,b=True,False a and b 结果为：False
or(有真为真) 例：a,b=True,False a or b 结果为：True
not（结果取反） 例：a=false not a 结果为：True
in(判断是否存在) 例：s='abcde' 'b' in s 结果为：True
not in 例：s='abcde' 'b' not in s结果为：False
位运算符：& 按位与
| 按位或
<< 位左移(*2^移动位数)
>> 位右移(/2^移动位数)
运算符的优先级：算数运算->位运算->比较运算->布尔运算->赋值运算
----------------------------------------------------------------------------------------第二阶段-------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------判断语句-------------------------------------------------------------------------------------------
单分支结构：if 条件：
执行语句
======================================
双分支结构：if 条件：
执行语句
else:
执行语句
======================================
多分支结构：if 条件：
执行语句
elif 条件：
执行语句
elif 条件：
执行语句
else:
执行语句
=======================================
嵌套结构：if 条件：
if条件：
执行语句
else:
执行语句
elif条件：
执行语句
else：
执行语句
=========================================
条件表达式：执行语句 if 条件 else 执行语句
=========================================
pass语句：if 条件:
pass（占位使用，不会报错）
else:
pass（占位使用，不会报错）
=========================================
----------------------------------------------------------------------------------------第三阶段-------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------循环结构-------------------------------------------------------------------------------------------
range内置函数:
range(s) 0到stpe-1,步长为1
range(t,s) t到s-1,步长为1
range(t,s,i) t到s-1,步长为i
一般用于创建整数序列，用于遍历
=================================================
while函数：
while 条件：
执行语句
=================================================
for in函数：
for i in range(20): in就是将其中的依次取出
print(i) 其结果为：0、1、2、3......18、19
例：计算100到999的水仙花束（数值与数值的百位十位个位各乘三次之和）
y=0
a=0
for i range(100,1000):
for x in ‘i’
a=int(x)
y+=a*a*a
if y==int(i):
print(y)
==================================================
for _ in:
for _ in range(20): 不需要使用到变量就可以用_代替，直接执行循环次数
执行语句
==================================================
break、continue与else语句：
break 退出当前的循环体(一般用于while和for)
continue 结束当前循环进行下一循环
else 用于循环末尾，循环体正常执行结束后执行，退出循环不会执行
===================================================
嵌套循环：
for in :
for in :
执行语句
===================================================
----------------------------------------------------------------------------------------第四阶段-------------------------------------------------------------------------------------------
------------------------------------------------------------------------列表（列表是逗号，切片是冒号）--------------------------------------------------------------------------
列表的创建：
创建方式：1、st=[元素、元素、元素、、、]
2、st=list([元素、元素、元素、、、])
========================================
列表的特点：列表可以存储重复数据
任意数据类型混存
元素按顺序有序排列
用下标使用元素
========================================
列表元素的获取：
列表 . index(元素) ||返回元素的位置，有多个相同元素时，则返回第一个
||如果元素不存在，则会报错ValueError
列表 . index(元素，起始，结束) ||可在指定的范围内查找起始位置到结束位置-1
列表[下标] ||获取下标位置的元素
=========================================
列表的切片：
列表[开始：结束：步长] 步长为正，正向切片
步长为负，反向切片
=========================================
列表元素的判断：
元素 in 列表 查询元素是否在列表中
元素 not in 列表 查询元素是否不在列表中
=========================================
列表元素的遍历：
for 变量 in 列表：
print(变量) //会依次将列表中的元素取出赋给变量
==========================================
列表元素的操作：
元素的增加：列表 . append(元素) 在列表的末尾添加一个元素
例：a=[1,2,3,4] b=[5,6] a.append(b) 结果为：a=[1,2,3,4,[5,6]]
列表 . extend(元素) 在列表的末尾一次至少添加一个元素（可将列表中的元素取出添加进去）
例：a=[1,2,3,4] b=[5,6] a.extend(b) 结果为：a=[1,2,3,4,5,6]
列表 . insert(位置，元素) 在列表的任意位置添加一个元素
例：a=[1,2,3,4] a.insert(2,7) 结果为：a=[1,2,7,3,4]
切片 在列表的任意位置至少添加一个元素
例：a=[1,2,3,4] b=[5,6] a[1:]=b 结果为：a=[1,5,6]
元素的删除：列表 . remove(元素) 在列表中移除一个元素
例：a=[1,2,3,4] a.append(2) 结果为：a=[1,3,4]
列表 . pop(位置) 在列表中移除对应位置的元素
例：a=[1,2,3,4] a.pop(2) 结果为：a=[1,2,4]
切片 将列表中的元素切走用空列表代替
例：a=[1,2,3,4] a[1,3]=[] 结果为：a=[1,4]
列表 . clear() 清除列表中所有元素
例：a=[1,2,3,4] a.clear() 结果为：a=[]
del 列表 删除列表
元素的修改：下标 赋值给对应位置
例：a=[1,2,3,4] a[1]=9 结果为：a=[1,9,3,4]
切片 把列表赋值到切片的位置
例：a=[1,2,3,4] a[1：3]=[5,6,7] 结果为：a=[1,5,6,7,4]
元素的排序：操作原列表：
列表 . sort() 升序排列列表
例：a=[1,4,2,3] a.sort() 结果为：a=[1,2,3,4]
列表 . sort(reverse=False) 升序排列列表
例：a=[1,4,2,3] a.sort(reverse=False) 结果为：a=[1,2,3,4]
列表 . sort(reverse=True) 降序排列列表
例：a=[1,4,2,3] a.sort(reverse=True) 结果为：a=[4,3,2,1]
操作新列表：新列表=sorted(列表) 升序排列列表
例：a=[1,4,2,3] b=sorted(a) 结果为：a=[1,4,2,3] b=[1,2,3,4]
新列表=sorted(列表,revered=False) 升序排列列表
例：a=[1,4,2,3] b=sorted(a,revered=False) 结果为：a=[1,4,2,3] b=[1,2,3,4]
新列表=sorted(列表,revered=True) 升序排列列表
例：a=[1,4,2,3] b=sorted(a,revered=True) 结果为：a=[1,4,2,3] b=[4,3,2,1]
列表生成式：列表=[含i的表达式 for i in range(1,10)] 生成一个‘含i的表达式’值的列表
例：a=[i for i in range(1,10)] 结果为：a=[1,2,3,4......8,9]
=========================================
----------------------------------------------------------------------------------------第五阶段-------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------字典{键：值}----------------------------------------------------------------------------------------
hash函数计算后放入一定的位置，与列表不同，不是按时间先后来排序
字典的创建：
创建方式：1、字典={'键':值} eg:a={'张三':10，age:20} 结果为：{'张三'：10，'age:20}
2、字典=dict(键=值) eg:dict(name='张三',age=10) 结果为：{'name'：'张三'，'age':10}
3、创建空字典 字典={}
==========================================
字典的特点：
键不能重复，值可以重复
字典中的元素是无序的
字典中的键不可变
==========================================
字典元素的获取：1、字典['键'] 字典中不存在该键会报错
例：dic={'张三':10,'李四':20,'王五':30} dic['陈六'] 结果为：运行时报错
2、字典.get('键') 字典中不存在会返回None,也可设置一个默认值
例：dic={'张三':10,'李四':20,'王五':30} dic['陈六'，70] 结果为：70
==========================================
字典元素的判断：in 键存在
例：dic={'张三':10,'李四':20,'王五':30} '陈六' in dic 结果为：False
ont in 键不存在
例：dic={'张三':10,'李四':20,'王五':30} '陈六' not in dic 结果为：True
===========================================
字典键、值的获取：
获取字典中所有的键：变量=字典 . keys() 变量中就有字典的所有键
例：dic={'张三':10,'李四':20} a=dic.keys() 结果为：a=['张三','李四']
获取字典中所有的值：变量=字典 . valuse() 变量中就有字典的所有值
例：dic={'张三':10,'李四':20} a=dic.vluse() 结果为：a=[10,20]
获取字典中所有的键、值：变量=字典 . items() 变量中就有字典的所有键、值
例：dic={'张三':10,'李四':20} a=dic.items() 结果为：a=[('张三',10),('李四',20)]
===========================================
字典的遍历：
for 变量 in 字典：
print(变量) //得出的是键
字典[变量] //得到的是值
字典.get(变量) //得到的是值
===========================================
字典元素的操作：
字典元素的增加：字典['键']=值 添加键值
例：dic={'张三':10,'李四':20} dic['王五']=30 结果为：dic={'张三':10,'李四':20,'王五':30}
字典元素的删除：del 字典['键'] 删除键值
例：dic={'张三':10,'李四':20} del dic['李四'] 结果为：dic={'张三':10}
字典 . clear() 清除字典
例：dic={'张三':10,'李四':20} dic.clear() 结果为：dic={}
字典元素的更改：字典['键']=值 改变键的值
例：dic={'张三':10,'李四':20} dic['张三']=30 结果为：dic={'张三':30,'李四':20}
字典生成式：字典={变量1:变量2 for 变量1,变量2 in zip(列表1,列表2)}
例：a=['语文','数学','英语'] b=[10,20,30] f={c:d for c,d in zip(a,b)}
结果为：a={'语文':10,'数学':20,'英语':30}
键.upper() 将键转为大写
例：a={'Time','Gete','Home'} b=[10,20,30] f={c.upper:d for c,d in zip(a,b)}
结果为：a={'TIME':10,'GETE':20,'HOME':30}
===========================================
----------------------------------------------------------------------------------------第六阶段-------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------元组（元素,）--------------------------------------------------------------------------------------
元组不可变但，列表和字典可变。t=（10，20，[30，40]） t[2].append(50) 结果为：t=（10，20，[30，40，50]）
===========================================
元组的创建：
1、t=('字符串','字符串',变量、、、) 直接创建元组
2、t=tuple(('字符串','字符串',变量、、、)) 使用内置函数创建元组
===========================================
元组的遍历：
for 变量 in 元组
print(变量)
===========================================
----------------------------------------------------------------------------------------第七阶段-------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------集合{}----------------------------------------------------------------------------------------------
集合的创建：
1、s={元素、元素、元素、、、}
2、s=set({元素、元素、、、、})
===========================================
集合的特点：集合中的元素不会重合，在创建时有相同的元素时只会存储一个
例：s={1,2,3,4,5,6,5} print(s) 结果为：s={1,2,3,4,5,6}
集合的数据是无序的
===========================================
集合元素的操作：
集合元素的判断： in
not in
集合元素的增加： 集合.add(元素) 在集合中添加一个元素
集合.update({元素、元素、、、})
集合.update([元素、元素、、、])
集合.update((元素、元素、、、)) 在集合中添加多个元素
集合元素的删除： 集合.remove(元素) 有元素时会删除，无元素时会报错
集合.discard(元素) 有元素时会删除，无元素时不会报错
集合.pop() 一次删除任意一个元素
集合.clear() 清空集合中的元素
===========================================
集合间的关系：
两个集合是否相等：
== 例：s={1,2,3,4} t={4,3,2,1} s==t 结果为：True
!= 例：s={1,2,3,4} t={4,3,2,1} s!=t 结果为：False
一个集合是否是另一个的子集： 集合1.issubset(集合2) 集合1是否在集合2中
一个集合是否是另一个集合的超集：集合1.issuperset(集合2) 集合1的元素是否全在在集合2中
两个集合是否没有交集：集合.isdisjoint(集合2) 集合1与集合2是否没有相同元素
===========================================
求交集： 1、集合1.intersection(集合2) 例：s={1,2,3,4} t={3,4,5,6} s.intersection(t) 结果为：{3,4}
2、集合1&集合2 例：s={1,2,3,4} t={3,4,5,6} s & t 结果为：{3,4}
求并集： 1、集合1.union(集合2) 例：s={1,2,3,4} t={3,4,5,6} s.union(t) 结果为：{1,2,3,4,5,6}
2、集合1|集合2 例：s={1,2,3,4} t={3,4,5,6} s | t 结果为：{1,2,3,4,5,6}
求差集： 1、集合1.difference(集合2) 例：s={1,2,3,4} t={3,4,5,6} s.difference(t) 结果为：{1,2}
2、集合1-集合2 例：s={1,2,3,4} t={3,4,5,6} s - t 结果为：{1,2}
对称差集：1、集合1.symmetric_difference(集合2) 例：s={1,2,3,4} t={3,4,5,6} s.difference(t) 结果为：{1,2,5,6}
2、集合1^集合2 例：s={1,2,3,4} t={3,4,5,6} s ^ t 结果为：{1,2,5,6}
===========================================
集合生成式：
集合={含i的表达式 for i in range(起始，结束)} 生成一个‘含i的表达式’值的集合 例：s={i*i for i in range(4)} 结果为：s={0,1,4,9}
===========================================
----------------------------------------------------------------------------------------第七阶段-------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------字符串---------------------------------------------------------------------------------------------
字符串的创建：变量='字符串'
===================================
字符串的常用操作：
字符串的查找： index(字符串) 查找第一次出现的位置，没有就报错
rindex(字符串) 查找最后一次出现的位置，没有就报错
字符串.find(字符串) 查找第一次出现的位置，没有返回-1 -----常用------
字符串.rfind(字符串) 查找最后一次出现的位置，没有返回-1 -----常用------
====================================
字符串大小写转换： 字符串.upper() 把字符串中所有字符都转成大写字母 -----常用------
字符串.lower() 把字符串中所有字符都转成小写字母 -----常用------
字符串.swapcase() 把字符串中大写字母转成小写字母，小写字母转成大写字母 -----常用------
字符串.capitalize() 把第一个字符转成大写，其余字符转为小写 -----常用------
字符串.title() 把每个单词第一个字符转成大写，其余字符转为小写 -----常用------
====================================
字符串内容对齐： 字符串.center(总长度，填充符) 居中对齐,设置总的字符长度，居中后两边用填充符填充 -----常用------
字符串.ljust(总长度，填充符) 左对齐,设置总的字符长度，左对齐后右边用填充符填充 -----常用------
字符串.rjust(总长度，填充符) 右对齐,设置总的字符长度，右对齐后左边用填充符填充 -----常用------
字符串.zfill(总长度) 右对齐，用0填充左边，如是'-34'这种，结果就为'-0034' -----常用------
====================================
字符串的分割： 字符串.split(sep='分割符') 从左边按照所给的分割符将字符串分割了 -----常用------
例：t='ni hao ma' t.split() 结果为：['ni','hao','ma']
字符串.split(sep='分割符',maxsplit=分割次数) 按照所给的分割符将字符串分割为分割份数 -----常用------
例：t='ni hao ma' t.split() 结果为：['ni','hao','ma']
字符串.rsplit(sep='分割符') 从右边按照所给的分割符将字符串分割了 -----常用------
例：t='ni hao ma' t.split() 结果为：['ni','hao','ma']
字符串.rsplit(sep='分割符',maxsplit=分割次数) 按照所给的分割符将字符串分割为分割份数 -----常用------
例：t='ni hao ma' t.split() 结果为：['ni','hao','ma']
====================================
字符串的判断： 字符串.isidentifier() 判断指定的字符串是不是合法的标识符(由数字、字母、'_'组成)
字符串.isspace() 判断指定的字符串是否全由空白字符组成
字符串.isalpha() 判断指定的字符串是否全部由字母组成
字符串.isdecimal() 判断指定的字符串是否全部由十进制的数字组成(只能是数字'1')
字符串.isnumeric() 判断指定的字符串是否全部由数字组成(可以是汉字‘二’，数字‘1’、罗马字符'Ⅰ')
字符串.isalnum() 判断指定的字符串是否全部由字母和数字组成
=====================================
字符串的替换与合并：字符串.replace(需要替换的字符,替换成的字符,替换的次数) 例：t='python' t.replace('th','qq') 结果为：pyqqon
'连接符'.join(列表/元组) 例：t=['go','to','python'] ' '.join(t) 结果为：go to python
=====================================
字符串的比较：'>' '>=' '<' '<=' '==' '!='
=====================================
字符串的切片：字符串[起始:结束:步长]
=====================================
字符串的格式化： 方法一：%s %d %f
'xxx%sxxxx%d' % (变量1,变量2)
方法二：'xxx{0}xxxx{1}xx' .format(变量1，变量2)
方法三：f'xxxx{变量1}xxxx{变量2}x'
%3d % 变量 左边空3个
%.3f % 变量 保留小数点后3位数字
%3.3f % 变量 左边空3个,保留小数点后3位数字
'{0：.3}'.format(变量) 保留3位有效数字
'{0：.3f}'.format(变量) 保留小数点后3位数字
'{0：3.3f}'.format(变量) 左边空3个,保留小数点后3位数字
======================================
字符串的编码转换：
编码： 方法一：字符串.encode(encoding='GBK') #在GBK编码格式中，一个中文占两个十六进制的字节
方法一：字符串.encode(encoding='UTF-8') #在UTF-8编码格式中，一个中文占三个十六进制的字节
解码： 编码数据.decode(encoding='编码的格式') #将字符串的编码格式解码
----------------------------------------------------------------------------------------第八阶段-------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------函数-----------------------------------------------------------------------------------------------
函数的创建：
实参的位置在调用的位置，形参的位置在函数命名的位置
有一个返回值时会返回一个原值，有多个返回值时返回一个元组
///////////////////传入参数固定时：
def 函数名(变量名)：
函数体
return 返回值
//////////////////传入的参数不固定时：
def 函数名(*args) || 函数名(参数1) 传入的是一个参数 || 例：def num(*args)
函数体 || 函数名(参数1，参数2) 传入的是一个元组 || print(args)
print(args) || 函数名(参数1，参数2，参数3，，，) 传入的是一个元组 || num(10,20,30) 结果为:(10,20,30)
////////////////////传入的参数不固定：
def 函数名(**args) || 函数名(参数1) 传入的是一个参数 || 例：def num(**args)
函数体 || 函数名(参数1，参数2) 传入的是一个字典 || print(args)
print(args) || 函数名(参数1，参数2，参数3，，，) 传入的是一个字典 || num(a=10,b=20,c=30) 结果为:{a:10,b:20,c:30}
---------------------------------------------------------------------------------
全局变量和局部变量：
在函数内部用global修饰变量，这是变量就是全局变量
例：def num():
global adg=10
print(adg) 结果为:10
-------------------------------------------------------------------------------------------------
递归函数：自己调用自己
例：使用递归函数计算阶乘(从1开始乘到当前数)
def fac(n):
if n==1:
return1
else
return n*fac(n-1)
例：斐波那挈数列(当前的值等于前两项之和)
def fac(n):
if n==1 or n==2:
return 1
else
return fac(n-1)+fac(n-2)
----------------------------------------------------------------------------------------第九阶段-------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------BUG处理--------------------------------------------------------------------------------------------
------------------try_except结构-------------------
try： || 例：try:
可能会出现异常的代码 || n1=int(input('请输入被除数：'))
except 错误提示1 || n2=int(input('请输入除数：'))
执行代码 || n=n1/n2
excpet 错误提示2 || print('结果为：'，n)
执行代码 || except ZeroDivisionError:
print('除数不能为0')
except ValueError:
print('不能输入字母')
------------------try_except_else结构-------------
try： || 例：try:
可能会出现异常的代码 || n1=int(input('请输入被除数：'))
except 错误提示1 || n2=int(input('请输入除数：'))
执行代码 || n=n1/n2
excpet 错误提示2 || print('结果为：'，n)
执行代码 || except ZeroDivisionError:
else || print('除数不能为0')
print('程序结束') || except ValueError:
|| print('不能输入字母')
|| else:
|| print('程序运行结束')
--------------try_except_else_finally结构---------
finally程序正常运行和出错都会运行，一般用来释放资源
try： || 例：try:
可能会出现异常的代码 || n1=int(input('请输入被除数：'))
except 错误提示1: || n2=int(input('请输入除数：'))
执行代码 || n=n1/n2
excpet 错误提示2: || print('结果为：'，n)
执行代码 || except ZeroDivisionError:
else: || print('除数不能为0')
print('程序结束') || except ValueError:
finally: || print('不能输入字母')
print('不管怎样都会执行') || else:
|| print('不管怎样都会执行')
--------------------常见异常出错---------------------
ZeroDivisionError 除数为零
IndexError 列表中没有此索引(也就是使用越界)
KeyError 映射中没有这个键(字典中没有这个键)
NameError 未声明/初始化对象(没有出现过)
SyntaxError Python语法错误(如int a=10)
ValueError 传入无效的参数
--------------------traceback模块---------------------
import traceback
try:
print('打印出错后的东西')
print(1/0)
except:
traceback.print_exe()
----------------------------------------------------------------------------------------第十阶段-------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------编程思想--------------------------------------------------------------------------------------------
-----------------------两大编程思想--------------------
面向过程：思维比较简单，可以使用线性思维的方式去解决问题
面向对象：思维比较复杂，无法使用线性思维方式去解决
----------------------类和对象的创建-------------------
类：就是分类
对象：具体的东西
类的创建：class 类名:
pass
例：class Student:
a='四川' //类属性
b=24
def __init__(self,变量1,变量2)： //初始化方法
self.变量=变量1
print('初始化方法的括号内可以有变量也可以没有变量')
def cat(self): //实例方法
print('实例方法的括号内可写self,也可不写self')
@staticmethod //静态方法(使用的staticmethod修饰)
def cay():
print('静态方法的括号内不能写self')
@classmethod //类方法
def cab(cls):
print('类方法的括号内必须写cls')
////在类中定义的叫属性，在类之外定义的叫变量////
////在类中定义的叫实例方法，在类之外定义的叫函数////
////静态方法////
////类方法////
对象的创建：实例名=类名()
使用方法1:实例名.类中的方法
使用方法2:类名.类中的方法(实例名)
例：class Student:
a='四川' //类属性
b=24
def __init__(self,变量1,变量2)： //初始化方法
self.变量=变量1
print('初始化方法的括号内可以有变量也可以没有变量')
def cat(self): //实例方法
print('实例方法的括号内可写self,也可不写self')
@staticmethod //静态方法(使用的staticmethod修饰)
def cay():
print('静态方法的括号内不能写self')
@classmethod //类方法
def cab(cls):
print('类方法的括号内必须写cls')
stud1=Student()
stud1.cat() //结果为：'实例方法的括号内可写self,也可不写self'
stud2=Student('张三',20)
print(stud2.变量1) //结果为：'张三'
----------------------类对象和类属性-------------------
删除类对象：del 名.对象
---------------------类方法与静态方法------------------
hasattr(emp1, 'age') # 如果存在 'age' 属性返回 True。
getattr(emp1, 'age') # 返回 'age' 属性的值
setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
delattr(emp1, 'age') # 删除属性 'age'
----------------------------------------------------------------------------------第十一阶段-------------------------------------------------------------------------------------------
---------------------------------------------------------封装、继承、方法重写、object类、多态、特殊方法和特殊属性------------------------------------------------
-----------------------------封装--------------------------
提高程序的安全性
有两个_的变量在类的外面不可以被访问，在内部可以使用，如：__age
在外部访问时可以用dir(类名)查看，通过‘_Student__类变量’访问，如：类名._Student__age
例：
def head:
def __init__(self,name,age):
self.num=name
self.__aet=age
def show(self):
print(self.name,self.__age)
stu=head('张三'，20)
print(stu.__Student__aet) //可以使用
print(stu.head) //可以使用
-----------------------------继承--------------------------
提高程序的安全性
class 子类类名(父类1,父类2...)：
pass
--------------------------方法重写-----------------------
使用super().xxx()进行重写
例：
class A(object):
def __init__(self,name,age)
self.name=name //声明变量
self.age=age
def info(self):
print('姓名：{0}年龄：{1}'.format(self.name,self.age)) //使用变量
class B(A):
def __init__(self,name,age,score):
super().__init__(name,age)
self.score=scoer //声明变量
def info(self):
super().info
print('学号：{0}'.format(self.score)) //使用变量
stu=B('张三',30,2020)
stu.info()
-----------------------------多态--------------------------
提高程序的可扩展性和可维护性
特殊属性： __dict__ 获得类对象或实例对象所绑定的所有属性和方法的字典
特殊方法： __len__() 通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
__add__() 通过重写__add__()方法，可以用自定义对象具有“+”功能
__new__() 用于创建对象
__init__() 对于创建的对象进行初始化
----------------------------类的拷贝-------------------------
可变序列 列表list：[元素，元素，、、、] 生成式：列表=[含变量的表达式 for 变量 in range(起始,结束)]
可变序列 字典dict：{'键'：值，'键'：值，、、、} 生成式：字典={ 变量1:变量2 for 变量1,变量2 in zip(列表1,列表2)}
不可变序列 元组tuple:(元素，元素，、、、)
可变序列 集合set:{元素，元素、、、} 生成式：集合={含变量的表达式 for 变量 in range(起始，结束)}
浙公网安备 33010602011771号