Python基础学习
记录一下自己的Python的学习历程。
Python的IDLE shell是外壳的意思 即文本与程序交互的过程。
print函数 print('hello')字符串带引号 若为整型 则为print(5+3) 变量打印直接print(techer)
字符串之间直接可以用加号整合 print('water'+'lijian') 也可以对一个字符串进行乘法 ‘hello’*8
注意Python内置函数返回的数据类型 例如input返回字符串类型 temp = input（‘输入：’） num = (int) temp ..
变量及字符串
字符串拼接 mytecer = 'tech' youtecher = 'er' we = mytecher + youtecher print(we) 输出为techer
转义字符\ 当打印有\ 的字符串时 要用转义字符
原始字符串：r 例如 str = r'C:noe\techer'; 自己会加上转义字符
Python的条件分支
if True :
(真执行语句)
else :
(假执行语句)
Python循环
while True :
(while执行语句)
逻辑操作符
and or not
Pytnon引入外援即模块
例 引入random模块 import random
调用时即 random._ num=random._(调用函数)
Python的数据类型
整型 浮点型 字符串型 布尔值 e记法
e记法 2.5e-27 即2.5X e的-27次方 此时若赋值 变量值会变成一个浮点型 1.5e2 是150.0
字符串 整型 浮点型之间转换 int() float() str() 的内置函数
内置函数type() 返回值为输入参数的数据类型 isinstance()函数 isinstance(a,str) 若a即输入参数为str则返回值为TRUE
Python的操作符
+ - * / %运算同C语言
Pyton3舍弃了地板除法 即 10/8=1.25 而不是转换为整型为1 如果想要得到整数 则应//除法 10//8=1 3.0//2=1.0
**用于幂运算 3**2=9
优先级 先算乘除后算加减 有括号先算括号里的 在-3**2=-9 3**-2=0.000001 可得右边的优先级高 -3**2=-（3*3）
优先级由高到低 幂运算 正负号 算数操作符 比较操作符 逻辑运算
分支及循环
Python 的分支 if elif 用法同C语言中if else if 可以有效的避免else悬挂 及 提高程序运行速度
条件表达式（三元） 例 small = x if x<y else y 意思是如果x<y 则smal 为x否则为 y
断言 assert 后面的条件不成立则程序会崩溃 抛出assertionerror异常 一般用于确定的程序检测某一条件为真。 例 arssert 3>4 则会异常
while循环 不再赘述
for循环 for 目标 in 表达式
循环体
例 for i in lijian print（i，end=' '） 打印为 l i j i a n end为空格隔开
range(start stop step )函数 range(2,9) 打印为从2到8 steP为步进 range(2,9,2)打印为2 4 6 8
break 跳出当前循环体
contiue 跳出当前循环 执行下一次循环
列表
其中包括了extend 等等的一些方法 如果需要则调用即可 。
定义为【】
列表的拷贝 tuple2 = tuple1[:] 复制一个列表
元组 （带上枷锁的列表）
定义为（）
元祖不能随意的插入，去除的操作 。
定义元祖时， 是关键 temp1=（1） type(temp )为整形 temp2=2，4，3 此时为元祖
元祖的拼接 tuple=('小脚丫'，‘大脚丫’，‘岁月’，‘老婆’) 此时的拼接为tuple = tuple[:2]+('哈哈哈',)+tuple{2;} 新的元祖tuple生成后 老的tuple仍然存在 但是没有标签指向他 此时python会把老的tuple销毁掉 （）及， 不可缺少
删除元祖同于列表 del 例如del temp会删除元祖
元祖所用操作符 上面的增加 以及列表重复*8 逻辑 比较操作符等等
字符串的很多奇葩方法
截取 string = ‘alexhahahaha’ str[;6] 即可截取
访问单个字符 同索引 string[5]
拼接字符串steing[;6] +('666')+string[6;] 字符串拼接 旧的字符串python会回收掉
| capitalize() | 把字符串的第一个字符改为大写 |
| casefold() | 把整个字符串的所有字符改为小写 |
| center(width) | 将字符串居中，并使用空格填充至长度 width 的新字符串 |
| count(sub[, start[, end]]) | 返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。 |
| encode(encoding='utf-8', errors='strict') | 以 encoding 指定的编码格式对字符串进行编码。 |
| endswith(sub[, start[, end]]) | 检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。 |
| expandtabs([tabsize=8]) | 把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。 |
| find(sub[, start[, end]]) | 检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。 |
| index(sub[, start[, end]]) | 跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。 |
| isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。 |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。 |
| isdecimal() | 如果字符串只包含十进制数字则返回 True，否则返回 False。 |
| isdigit() | 如果字符串只包含数字则返回 True，否则返回 False。 |
| islower() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回 True，否则返回 False。 |
| isnumeric() | 如果字符串中只包含数字字符，则返回 True，否则返回 False。 |
| isspace() | 如果字符串中只包含空格，则返回 True，否则返回 False。 |
| istitle() | 如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回 True，否则返回 False。 |
| isupper() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回 True，否则返回 False。 |
| join(sub) | 以字符串作为分隔符，插入到 sub 中所有的字符之间。 |
| ljust(width) | 返回一个左对齐的字符串，并使用空格填充至长度为 width 的新字符串。 |
| lower() | 转换字符串中所有大写字符为小写。 |
| lstrip() | 去掉字符串左边的所有空格 |
| partition(sub) | 找到子字符串 sub，把字符串分成一个 3 元组 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 则返回 ('原字符串', '', '') |
| replace(old, new[, count]) | 把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。 |
| rfind(sub[, start[, end]]) | 类似于 find() 方法，不过是从右边开始查找。 |
| rindex(sub[, start[, end]]) | 类似于 index() 方法，不过是从右边开始。 |
| rjust(width) | 返回一个右对齐的字符串，并使用空格填充至长度为 width 的新字符串。 |
| rpartition(sub) | 类似于 partition() 方法，不过是从右边开始查找。 |
| rstrip() | 删除字符串末尾的空格。 |
| split(sep=None, maxsplit=-1) | 不带参数默认是以空格为分隔符切片字符串，如果 maxsplit 参数有设置，则仅分隔 maxsplit 个子字符串，返回切片后的子字符串拼接的列表。 |
| splitlines(([keepends])) | 在输出结果里是否去掉换行符，默认为 False，不包含换行符；如果为 True，则保留换行符。。 |
| startswith(prefix[, start[, end]]) | 检查字符串是否以 prefix 开头，是则返回 True，否则返回 False。start 和 end 参数可以指定范围检查，可选。 |
| strip([chars]) | 删除字符串前边和后边所有的空格，chars 参数可以定制删除的字符，可选。 |
| swapcase() | 翻转字符串中的大小写。 |
| title() | 返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串。 |
| translate(table) | 根据 table 的规则（可以由 str.maketrans('a', 'b') 定制）转换字符串中的字符。 |
| upper() | 转换字符串中的所有小写字符为大写。 |
| zfill(width) | 返回长度为 width 的字符串，原字符串右对齐，前边用 0 填充。 |
次部分学自鱼C工作室论坛 ， 小甲鱼牛逼
字符串的格式化 str1= ‘{0} love {1}.{2} ’ {}中的是replacemen字段
str1.format('i','my','laopo') = 'i love my laopo' 这个是位置参数 分别放到0 1 2上
format方法的关键字参数 ‘{a} love {b}.{b} ’.format('a=i','b=my','c=laopo') = 'i love my laopo'
一起使用 ‘{0} love {b}.{b} ’.format('i','b=my','c=laopo') = 'i love my laopo 注意 位置参数要在位置参数要在关键字参数之前 即0要在bc之前
‘’{0;.1f}{1}''.foramt(;27','GB') ;表示格式化符号
格式化操作符辅助命令
Python 的转义字符及其含义
|
>>> b = [4,5,6,7,8,0]
>>> a = [1,2,3,4,5,6,0,9,9,9]
>>> zip(a,b)
<zip object at 0x000001C3EAB32088>
>>> list(zip(a,b))
[(1, 4), (2, 5), (3, 6), (4, 7), (5, 8), (6, 0)]
产生这养的结果
python的函数
（1）
>>> def myfirstfunction():
print('hahah')
print("为什么啊")
>>> myfirstfunction
<function myfirstfunction at 0x000001C3EABC4288>
>>> myfirstfunction()
hahah
为什么啊
上述为定义函数 以及调用函数和输出结果
定义一个输入参数几个的函数def myfirstfunction(name,time) 之间用，隔开即可
（2）
def mysecondfunction()
'这个是一个函数文档' #字符串形式出现 但是是函数文档
#注视注释
print('lalalal')
在调用该函数时 mysecondfunction._doc_ 是函数的默认属性 可以看到函数文档
help函数同样可以看到函数文档
（3）def say(name,words)
print(name+words)
调用时 say(words='haha') 也可以 python可以按照关键字赋值 不依靠于索引 所以可以不按顺寻写
（4）
def test(*xiao)
在不知道要用几个参数时 *可以输入更过多的参数 只有一个xiao 但是可以输入好几个
test(xiao,hu,ni)
如果还有别的参数 则用关键字定义 def test(*xiao，exp) 则调用test(1,2,3,6,exp=8)
（5）
返回值
>>> temo =hello()
hello world
>>> print(temp)
Traceback (most recent call last):
File "<pyshell#4>", line 1, in <module>
print(temp)
NameError: name 'temp' is not defined
>>> print(temo)
None
>>> def hello():
return [1,3,5,6]
>>> temp = hello()
>>>
>>> temp
[1, 3, 5, 6]
python 的返回值可以是列表 元祖等 默认的返回值是NONE
（6）
作用域
定义的局部变量不能再全局变量里面是用 同C语言
定义的全局变量在局部变量中使用 则
def shaonian():
old = 50
print('当前值是：',old)
old = 100
shaonian()
print('当前值是2：',old)
返回为
当前值是： 50
当前值是2： 100
在局部中使用时 Python创建同名的一个局部变量在函数中 只不过是存放的位置不同 并不改变全局变量的值
（7）
内嵌函数和闭包
count = 6
def test():
global count
count = 666
print(count)
test()
print(count)
如果想要在函数中修改局部变量 则需要global关键字修饰即可
内嵌函数
def tset1():
print("hahaha")
def tset2():
print('lalala')
tset2()
tset1()
tset2()
内嵌的函数只能在定义的范围中作用 而不能再全局调用
闭包
def fun1():
x = 5
def fun():
x*=5
return x
在这种情况下 相当于定义在了fun1 的作用域中 直接调用的话fun中没有定义变量
需要用nonlocal关键字修饰即可
（8）lmbda表达式
def add(x,y):
retun x+y
转化成lmbda表达式为 lmbda x,y : x+y 调用为 g= lmbda x,y : x+y g(3,4)
（9） 递归的概念 递归好于迭代
def caonima(n):
if n == 1 :
return 1
else :
return n*caonima(n-1)
result = caonima(n)
本函数为递归函数 一遍一遍的执行本身几位递归 从底部往上执行递归
递归有深度 默认为100 有函数可以对其更改
递归与迭代的区别 例如兔子的斐波那契数列
def test_1(number) :
if number <=0 :
print("错误！！！")
if number == 1 or number ==2 :
return 1
esle: return test_1(n-1)+test_1(n-2)
为斐波那契数列的递归算法 而迭代则要麻烦很多
（10） 字典 字典没有排序顺徐 有自己的排序方式
序列通过索引值访问
当使用数组时
print('字典')
brind = ["李宁",'NIKE','彪马']
slogan = ['666','333','007']
print('李宁是:',slogan[brind.index('彪马')]) 会输出李宁是007 但此时使用效率不高 所以应当使用字典
字典的创建于访问 ---------------------------------------------- 字典的创建 dict = {'索引'（空格）：'键值' } 大括号 中间用冒号隔开 类似于映射的形式 索引 keys 键值 values items为项 即1‘one’ 对应的索引
dict1 = {'李宁是':'007','彪马是':'001'}
print('李宁是：',dict1['彪马是'])
此时的索引和键值可以为任意的数据类型 dict2 = {'1':'one','2':'two'} 访问只需要访问健 即可 print(‘1：’，‘dict2[2]’)
检查健 in not in 判断健 查看是否在字典中
（11） 集合 集合里面的元素唯一 set 用（）定义
list1 = [0，1，2,3,5,9,9,9,6,5]
若想要换成里面元素唯一 定义一个新列表list2 然后for 循环 notin
若用集合则 temp=list(set(list1))即可
forzenset ： 不能动的集合 即集合不能更改
（12）文件！！！！！！！！！！！！ Python 的 输入 输出
| r' | 以只读方式打开文件（默认） |
| 'w' | 以写入的方式打开文件，会覆盖已存在的文件 |
| 'x' | 如果文件已经存在，使用此模式打开将引发异常 |
| 'a' | 以写入模式打开，如果文件存在，则在末尾追加写入 |
| 'b' | 以二进制模式打开文件 |
| 't' | 以文本模式打开（默认） |
| '+' | 可读写模式（可添加到其他模式中使用） |
| 'U' | 通用换行符支持 |
文件对象方法
| 文件对象方法 | 执行操作 |
| f.close() | 关闭文件 |
| f.read([size=-1]) | 从文件读取size个字符，当未给定size或给定负值的时候，读取剩余的所有字符，然后作为字符串返回 |
| f.readline([size=-1]) | 从文件中读取并返回一行（包括行结束符），如果有size有定义则返回size个字符 |
| f.write(str) | 将字符串str写入文件 |
| f.writelines(seq) | 向文件写入字符串序列seq，seq应该是一个返回字符串的可迭代对象 |
| f.seek(offset, from) | 在文件中移动文件指针，从from（0代表文件起始位置，1代表当前位置，2代表文件末尾）偏移offset个字节 |
| f.tell() | 返回当前在文件中的位置 |
| f.truncate([size=file.tell()]) | 截取文件到size个字节，默认是截取到文件指针当前位置 |
上述表格摘自 小甲鱼！！！！ 感谢鱼C工作室
注意：：：： 如果用read()方法不能打开文件 则用UTF-8打开 即 open('D:\\Guanghan.txt','r',encoding='UTF-8')
例子：
>>> d = open('D:\\Guanghan.txt','r',encoding='UTF-8')
>>> d.read()
'小甲鱼 ：啦啦啦\n小王八 : 哈哈哈\n小金鱼 ：嘿嘿嘿\n小青蛙 ：嘎嘎嘎\n'
>>> d.close()
>>> g=open('D:\\Guanghan.txt','r',encoding='UTF-8')
>>> g.read(5)
'小甲鱼 ：'
>>> g.tell()
13
>>> g.reek(0,0)
>>> list(g)
[]
>>> g.seek(0,0)
0
>>> list(g)
['小甲鱼 ：啦啦啦\n', '小王八 : 哈哈哈\n', '小金鱼 ：嘿嘿嘿\n', '小青蛙 ：嘎嘎嘎\n']
>>> for each_line in g :
print(each_line)
小王八 : 哈哈哈
小金鱼 ：嘿嘿嘿
小青蛙 ：嘎嘎嘎
>>> g.close()
>>> h = open("D:\\Guanghan.txt",'w',encoding='UTF-8')
>>> h.write('我爱你')
3
>>> h.close()
注意 ！！！ 当写进去时，会把TXT之前的文件替换掉
（13）训练一手 依托于小甲鱼论坛的题目 这里来说对初学者不太友好 可以百度一下
f = open('record.txt')
boy = []
girl = []
if each_line in f :
if each_line[:6] != '=====' :
(role,line_spoken) = each_line(':',1) #元组中式2个被分割的字符串
if role == '小甲鱼' :
boy.append(line_spoken)
if role == '小客服' :
girl.append(line_spoken)
else :
file_boy_name = 'boy'+str(count)+'.txt'
file_girl_name = 'girl'+str(count)+'.txt'
boy_file = open(file_boy_name,'w') #打开文件并写入
girl_file = open(file_giel_name,'w')
boy_file.writelines(boy) #方法中有
girl_file.writelines(girl)
boy_file.colse()
girl_file.close()
boy = []
girl = []
count+=1
f.colse()
（14）模块 想学爬虫的这里比较重要 ~~~~~
import 模块名即可 调用模块
1. OS模块 因为Python是跨平台语音 不同的系统的底层不同 所以当我调用OS模块时 他会自己调用正确的系统 直接使用即可 下面学习一下OS模块的内置函数
|
os模块中关于文件/目录常用的函数使用方法
os.path模块中关于路径常用的函数使用方法
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
>>> my_list3 = [1,2,'真的是为社么',['啦啦啦']]
>>> pickle_file = open('my_list.pkl','wb')
>>> pickle.dump(my_list3,pickle_file)
>>> pickle_file.close()
>>> pickle_file = open('my_list.pkl','rb')
>>> Y_list2 = pickle.load(pickle_file)
>>> print(Y_list2)
[1, 2, '真的是为社么', ['啦啦啦']]
（16） 标准异常及处理方式
| AssertionError | 断言语句（assert）失败 |
| AttributeError | 尝试访问未知的对象属性 |
| EOFError | 用户输入文件末尾标志EOF（Ctrl+d） |
| FloatingPointError | 浮点计算错误 |
| GeneratorExit | generator.close()方法被调用的时候 |
| ImportError | 导入模块失败的时候 |
| IndexError | 索引超出序列的范围 |
| KeyError | 字典中查找一个不存在的关键字 |
| KeyboardInterrupt | 用户输入中断键（Ctrl+c） |
| MemoryError | 内存溢出（可通过删除对象释放内存） |
| NameError | 尝试访问一个不存在的变量 |
| NotImplementedError | 尚未实现的方法 |
| OSError | 操作系统产生的异常（例如打开一个不存在的文件） |
| OverflowError | 数值运算超出最大限制 |
| ReferenceError | 弱引用（weak reference）试图访问一个已经被垃圾回收机制回收了的对象 |
| RuntimeError | 一般的运行时错误 |
| StopIteration | 迭代器没有更多的值 |
| SyntaxError | Python的语法错误 |
| IndentationError | 缩进错误 |
| TabError | Tab和空格混合使用 |
| SystemError | Python编译器系统错误 |
| SystemExit | Python编译器进程被关闭 |
| TypeError | 不同类型间的无效操作 |
| UnboundLocalError | 访问一个未初始化的本地变量（NameError的子类） |
| UnicodeError | Unicode相关的错误（ValueError的子类） |
| UnicodeEncodeError | Unicode编码时的错误（UnicodeError的子类） |
| UnicodeDecodeError | Unicode解码时的错误（UnicodeError的子类） |
| UnicodeTranslateError | Unicode转换时的错误（UnicodeError的子类） |
| ValueError | 传入无效的参数 |
| ZeroDivisionError | 除数为零 |
以下是 Python 内置异常类的层次结构：
BaseException
+-- SystemExit
+-- KeyboardInterrupt
+-- GeneratorExit
+-- Exception
+-- StopIteration
+-- ArithmeticError
| +-- FloatingPointError
| +-- OverflowError
| +-- ZeroDivisionError
+-- AssertionError
+-- AttributeError
+-- BufferError
+-- EOFError
+-- ImportError
+-- LookupError
| +-- IndexError
| +-- KeyError
+-- MemoryError
+-- NameError
| +-- UnboundLocalError
+-- OSError
| +-- BlockingIOError
| +-- ChildProcessError
| +-- ConnectionError
| | +-- BrokenPipeError
| | +-- ConnectionAbortedError
| | +-- ConnectionRefusedError
| | +-- ConnectionResetError
| +-- FileExistsError
| +-- FileNotFoundError
| +-- InterruptedError
| +-- IsADirectoryError
| +-- NotADirectoryError
| +-- PermissionError
| +-- ProcessLookupError
| +-- TimeoutError
+-- ReferenceError
+-- RuntimeError
| +-- NotImplementedError
+-- SyntaxError
| +-- IndentationError
| +-- TabError
+-- SystemError
+-- TypeError
+-- ValueError
| +-- UnicodeError
| +-- UnicodeDecodeError
| +-- UnicodeEncodeError
| +-- UnicodeTranslateError
+-- Warning
+-- DeprecationWarning
+-- PendingDeprecationWarning
+-- RuntimeWarning
+-- SyntaxWarning
+-- UserWarning
+-- FutureWarning
+-- ImportWarning
+-- UnicodeWarning
+-- BytesWarning
+-- ResourceWarning
转自小甲鱼论坛 异常总结部分
（17）检测异常的方法 try语句
try :
检测范围
expect ecpection as reason:
出现异常
finally:
肯定会执行的语句
例子
try :
f = open ('为什么我没有一个文件','wb')
print(f.write('我存在了'))
sum = '1'+ 1
f.close()
except (OSError,TypeError) : 或者 expect OSerror as reson : expect IOerror as reson : 这里用于多级判断 也可以使用括号
print('啊啦啦啦')
finally :
f.close()
当检测的一个错误时，剩下的try部分会不再执行 ，所以可能剩下的部分代码会保存不到 所以finally用于肯定执行的操作
else 语句同样可以和 try语句一起使用
with 语句 f = open ('alla.txt') 最后肯定要f.close()
当使用with时 with f= open('lalal.txt') wuth自己会关注这个文件 当不再使用他时 with会自己关闭这个文件
（18） 图形编程 GUI
嵌入式无所畏惧
（19） 对象 封装 继承 多态
封装 : def 函数的封装等
继承 ： list1 = [0,1,2,3] list是个列表 此时可以调用list 的很多方法 实质上list也是一个对象 继承了list 的这个类
首先介绍类和对象 class Template : #类的名字的第一个必须为大写字母
test1 = '肤白' #属性
test2 = '貌美'
test3 = '大长腿'
test4 = 2
def example1 （self）: #方法
print('我爱')
def example2 （self）:
print('我爱你')
之后 tt = Template() 调用tt.example1() 则显示为我爱
用类定义一个列表 定义好类的好处是可以批量生产
class Template1 (list) ：
pass #意思为空
test2 = Template1() 实例化之后继承list这个类 则此时list2相当于list类的一个对象 同时可以电泳list的内置函数 这称为继承 list为父类 list2为子类
若同时test3 = Template1() test4 = Template1() test3.xx='' test4.xx = '' 此时两个不同的对象均会输出同一个值 这个称为多态
关于Python中 %s及%的用法有 https://www.cnblogs.com/wh-ff-ly520/p/9390855.html 参考这个博客即可这里不再赘述
class Ball:
def setName(self,name) :
self.name = name
def kick(self) : print('我是%s,不要打我' %self.name)
实例化的时候 a = Ball() a.setName('球A') a.kick() 输出为我是球A不要打我 这里的self 是把a这个元素作用到（）中 由ython完成 就是说self有了 我们在类的定义时 self写进第一个参数 这个时默认要求
在创建实例化的时候 会自动调用 __init()__(self)方法 可以通过写入参数，改变对象的初始化操作 举个例子和上面做杜比
class Balll():
def __init__(self,name) :
self.name = name
def kick(self) :
print('我是%s,该死的，不要踢我'%self.name)
通过更改这个__init()__()的方法，达到改变初始化的目的
调用方式为 a = Balll('球A') 再调用kick方法时 a.kick() 此时直接输出结果
公有和私有
公有的属性可以通过。去访问 私有及属性前面加上2个下划线
>> class BUG :
name = '小狐狸'
>>> a = BUG()
>>> a.name
'小狐狸'
>>> class BUG :
__name = '打狐狸'
>>> b = BUG()
>>> b.__name() 这样就不可以进行对属性的访问
或者在内部返回属性的值 即为
class BUG:
__name = '小狐狸'
def setName(self) :
return self.__name
>>> c = BUG()
>>> c.setName()
'小狐狸'
其实 Python在对变量私有化的情况下 是对属性进行了 _类名__属性名 的操作 也可以通过 c._BUG__name 去访问
继承
定义 class 类名（父类名）
>>> class Ha(Heng) :
print('ahhaha')
ahhaha
>>> class Heng :
def hello(self) :
print('哈哈哈')
>>> class Ha(Heng) :
pass
>>> p = Heng()
>>> p.hello()
哈哈哈
>>> c = Ha()
>>> c.hello()
哈哈哈
继承Heng这个父类 此时Ha为子类
如过子类中存在和父类相同的方法 子类调用时会覆盖掉父类的方法 但不会影响父类本身
如
class Ha(Heng) :
def hello(self):
print('我是岁月')
>>> c = Ha()
>>> c.hello()
我是岁月
多继承在这里不再赘述
拾遗
类定义
类对象
实例对象
关系为从下至上 如果上面定义改变 已更改的实例对象不会受到影响 但是未更改的实例对象及类对象会受到影响 类对象是 直接操作定义下的对象
与对象和类相关的库函数 这里不再赘述
构造与析构
__init()__方法在前面已经介绍过 这里不再赘述
其实Python在定义一个新的类的时候，第一个调用的并不是__init()__方法 而是new方法
new方法是new一个类 最后的返回是一个实例化的对象
例如我要把一个字符串输入后就返回大写 则
class Caps (str):
def __new__(cla,string) :
string = string.upper()
return str.__new__(cla,string)
>>> b = Caps('I love LIjian')
>>> b
'I LOVE LIJIAN'
__del__() 方法 内部自己完成
