day6-常用模块与面向对象基础

第1章 常用模块

1.1 random模块

1.1.1 random模块介绍

import random       ####取随机数模块

print(random.random())#(0,1)----float    大于0且小于1之间的小数

print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之间的整数

print(random.randrange(1,3)) #[1,3)    大于等于1且小于3之间的整数

print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5]

print(random.sample([1,'23',[4,5]],2))#列表元素任意2个组合

print(random.uniform(1,3))#大于1小于3的小数，如1.927109612082716

item=[1,3,5,7,9]

random.shuffle(item) #打乱item的顺序,相当于"洗牌"

print(item)

 

1.1.2 random模块实例(生成随机验证码)

import random

def make_code(n):

    res=''

    for i in range(n):

        s1=chr(random.randint(65,90))

        s2=str(random.randint(0,9))

        res+=random.choice([s1,s2])

    return res

 

print(make_code(9))

1.2 os模块

1.2.1 os模块介绍

os模块是与操作系统交互的一个接口

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

os.curdir  返回当前目录: ('.')

os.pardir  获取当前目录的父目录字符串名：('..')

os.makedirs('dirname1/dirname2')    可生成多层递归目录

os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname

os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

os.remove()  删除一个文件

os.rename("oldname","newname")  重命名文件/目录

os.stat('path/filename')  获取文件/目录信息

os.sep    输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"

os.linesep    输出当前平台使用的行终止符，win下为"
",Linux下为"
"

os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:

os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

os.system("bash command")  运行shell命令，直接显示

os.environ  获取系统环境变量

os.path.abspath(path)  返回path规范化的绝对路径

os.path.split(path)  将path分割成目录和文件名二元组返回

os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素

os.path.basename(path)  返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素

os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False

os.path.isabs(path)  如果path是绝对路径，返回True

os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False

os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False

os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

os.path.getsize(path) 返回path的大小

 

 

1.2.2 os.path.normcase的使用

在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为反斜杠。

>>> os.path.normcase('c:/windows\system32\')  

'c:\windows\system32\'  

  

 

规范化路径，如..和/

>>> os.path.normpath('c://windows\System32\../Temp/')  

'c:\windows\Temp'  

 

>>> a='/Users/jieli/test1/\a1/\\aa.py/../..'

>>> print(os.path.normpath(a))

/Users/jieli/test1

 

1.2.3 os路径处理

os路径处理

#方式一：推荐使用

import os

#具体应用

import os,sys

possible_topdir = os.path.normpath(os.path.join(

    os.path.abspath(__file__),

    os.pardir, #上一级

    os.pardir,

    os.pardir

))

sys.path.insert(0,possible_topdir)

 

 

#方式二：不推荐使用

os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

 

 

1.3 sys模块

1.3.1 sys模块功能介绍

sys.argv           命令行参数List，第一个元素是程序本身路径

sys.exit(n)        退出程序，正常退出时exit(0)

sys.version        获取Python解释程序的版本信息

sys.maxint         最大的Int值

sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform       返回操作系统平台名称

1.3.2 打印进度条

#=========知识储备==========

#进度条的效果

[#             ]

[##            ]

[###           ]

[####          ]

 

#指定宽度

print('[%-15s]' %'#')

print('[%-15s]' %'##')

print('[%-15s]' %'###')

print('[%-15s]' %'####')

 

#打印%

print('%s%%' %(100)) #第二个%号代表取消第一个%的特殊意义

 

#可传参来控制宽度

print('[%%-%ds]' %50) #[%-50s]

print(('[%%-%ds]' %50) %'#')

print(('[%%-%ds]' %50) %'##')

print(('[%%-%ds]' %50) %'###')

 

 

#=========实现打印进度条函数==========

import sys

import time

 

def progress(percent,width=50):

    if percent >= 1:

        percent=1

    show_str=('[%%-%ds]' %width) %(int(width*percent)*'#')

    print('
%s %d%%' %(show_str,int(100*percent)),file=sys.stdout,flush=True,end='')

 

 

#=========应用==========

data_size=10250

recv_size=0

while recv_size < data_size:

    time.sleep(1) #模拟数据的传输延迟

    recv_size+=1024 #每次收1024

 

    percent=recv_size/data_size #接收的比例

    progress(percent,width=70) #进度条的宽度70

 

 

1.4 shutil模块

高级的 文件、文件夹、压缩包 处理模块

1.4.1 shutil模块的各种应用示例

shutil.copyfileobj(fsrc, fdst[, length])

将文件内容拷贝到另一个文件中

import shutil

 

shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

shutil.copyfile(src, dst)

拷贝文件

import shutil

 

shutil.copyfile('f1.log', 'f2.log') #目标文件无需存在

shutil.copymode(src, dst)

仅拷贝权限。内容、组、用户均不变

import shutil

shutil.copymode('f1.log', 'f2.log') #目标文件必须存在

shutil.copystat(src, dst)

仅拷贝状态的信息，包括：mode bits, atime, mtime, flags

shutil.copystat('f1.log', 'f2.log') #目标文件必须存在

shutil.copy(src, dst)

拷贝文件和权限

import shutil

shutil.copy('f1.log', 'f2.log')

shutil.copy2(src, dst)

拷贝文件和状态信息

import shutil

shutil.copy2('f1.log', 'f2.log')

shutil.ignore_patterns(*patterns)

shutil.copytree(src, dst, symlinks=False, ignore=None)

递归的去拷贝文件夹

import shutil

shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) #目标目录不能存在，
注意对folder2目录父级目录要有可写权限，ignore的意思是排除 

拷贝软连接示例

import shutil

 

shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

 

'''

通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件

'''

shutil.rmtree(path[, ignore_errors[, onerror]])

递归的去删除文件

import shutil

shutil.rmtree('folder1')

shutil.move(src, dst)

递归的去移动文件，它类似mv命令，其实就是重命名。

import shutil

shutil.move('folder1', 'folder3')

shutil.make_archive(base_name, format,...)

创建压缩包并返回文件路径，例如：zip、tar

创建压缩包并返回文件路径，例如：zip、tar

base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，

如 data_bak                       =>保存至当前路径

如：/tmp/data_bak =>保存至/tmp/

format：                                      压缩包种类，“zip”, “tar”, “bztar”，“gztar”

root_dir：                                    要压缩的文件夹路径（默认当前目录）

owner：                                       用户，默认当前用户

group：                                        组，默认当前组

logger：                                       用于记录日志，通常是logging.Logger对象

#将 /data 下的文件打包放置当前程序目录

import shutil

ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')

 

 

#将 /data下的文件打包放置 /tmp/目录

import shutil

ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')

 

1.4.2 zipfile压缩解压缩与tarfile压缩解压缩

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：

#######zipfile压缩解压缩

 

import zipfile

 

# 压缩

z = zipfile.ZipFile('laxi.zip', 'w')

z.write('a.log')

z.write('data.data')

z.close()

 

# 解压

z = zipfile.ZipFile('laxi.zip', 'r')

z.extractall(path='.')

z.close()

 

 

 

######tarfile压缩解压缩

import tarfile

 

# 压缩

>>> t=tarfile.open('/tmp/egon.tar','w')

>>> t.add('/test1/a.py',arcname='a.bak')

>>> t.add('/test1/b.py',arcname='b.bak')

>>> t.close()

 

 

# 解压

>>> t=tarfile.open('/tmp/egon.tar','r')

>>> t.extractall('/egon')

>>> t.close()

 

 

1.5 json&pickle模块

1.5.1 json介绍

之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

import json

x="[null,true,false,1]"

print(eval(x)) #报错，无法解析null类型，而json就可以

print(json.loads(x))

1.5.2 什么是序列化？

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

1.5.3 为什么要序列化？

1：持久保存状态

需知一个软件/程序的执行就在处理一系列状态的变化，在编程语言中，'状态'会以各种各样有结构的数据类型(也可简单的理解为变量)的形式被保存在内存中。

内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关于这个程序的之前一段时间的数据（有结构）都被清空了。

在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到文件中），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。

具体的来说，你玩使命召唤闯到了第13关，你保存游戏状态，关机走人，下次再玩，还能从上次的位置开始继续闯关。或如，虚拟机状态的挂起等。

2：跨平台数据交互

序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平台数据交互。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

1.5.4 如何序列化之json和pickle：

#############json##############

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

 

import json

 

dic={'name':'alvin','age':23,'sex':'male'}

print(type(dic))#<class 'dict'>

 

j=json.dumps(dic)

print(type(j))#<class 'str'>

 

 

f=open('序列化对象','w')

f.write(j)  #-------------------等价于json.dump(dic,f)

f.close()

#-----------------------------反序列化<br>

import json

f=open('序列化对象')

data=json.loads(f.read())#  等价于data=json.load(f)

 

 

######注意点

 

import json

#dct="{'1':111}"#json 不认单引号

#dct=str({"1":111})#报错,因为生成的数据还是单引号:{'one': 1}

 

dct='{"1":"111"}'

print(json.loads(dct))

 

#conclusion:

#无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads

 

 

########pickle##########

 

import pickle

 

dic={'name':'alvin','age':23,'sex':'male'}

 

print(type(dic))#<class 'dict'>

 

j=pickle.dumps(dic)

print(type(j))#<class 'bytes'>

 

 

f=open('序列化对象_pickle','wb')#注意是w是写入str,wb是写入bytes,j是'bytes'

f.write(j)  #-------------------等价于pickle.dump(dic,f)

 

f.close()

#-------------------------反序列化

import pickle

f=open('序列化对象_pickle','rb')

 

data=pickle.loads(f.read())#  等价于data=pickle.load(f)

 

 

print(data['age'])

 

 

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

1.6 shelve模块

shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型。

1.6.1 示例一

import shelve

 

f=shelve.open(r'sheve.txt')

# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}

# f['stu2_info']={'name':'gangdan','age':53}

# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}

 

print(f['stu1_info']['hobby'])

f.close()

 

1.6.2 示例二

import shelve

 

# dic={'a':1,'b':2}

#

# d=shelve.open(r'db.shl')

# d['egon']={'pwd':'123','age':18}

# d['alex']={'pwd':'123465','age':18}

# d['x']=dic

#

#

# d.close()

 

 

 

obj=shelve.open(r'db.shl')

print(obj['x']['a'])

 

obj.close()

 

1.7 xml模块

1.7.1 xml模块介绍

xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

xml的格式如下，就是通过<>节点来区别数据结构的:

##### xml数据

 

<?xml version="1.0"?>

<data>

    <country name="Liechtenstein">

        <rank updated="yes">2</rank>

        <year>2008</year>

        <gdppc>141100</gdppc>

        <neighbor name="Austria" direction="E"/>

        <neighbor name="Switzerland" direction="W"/>

    </country>

    <country name="Singapore">

        <rank updated="yes">5</rank>

        <year>2011</year>

        <gdppc>59900</gdppc>

        <neighbor name="Malaysia" direction="N"/>

    </country>

    <country name="Panama">

        <rank updated="yes">69</rank>

        <year>2011</year>

        <gdppc>13600</gdppc>

        <neighbor name="Costa Rica" direction="W"/>

        <neighbor name="Colombia" direction="E"/>

    </country>

</data>

 

 

1.7.2 在python中操作xml

xml协议在各个语言里的都 是支持的，在python中可以用以下模块操作xml：

# print(root.iter('year')) #全文搜索

# print(root.find('country')) #在root的子节点找，只找一个

# print(root.findall('country')) #在root的子节点找，找所有

import xml.etree.ElementTree as ET

 

tree = ET.parse("xmltest.xml")

root = tree.getroot()

print(root.tag)

 

#遍历xml文档

for child in root:

    print('========>',child.tag,child.attrib,child.attrib['name'])

    for i in child:

        print(i.tag,i.attrib,i.text)

 

#只遍历year 节点

for node in root.iter('year'):

    print(node.tag,node.text)

#---------------------------------------

 

import xml.etree.ElementTree as ET

 

tree = ET.parse("xmltest.xml")

root = tree.getroot()

 

#修改

for node in root.iter('year'):

    new_year=int(node.text)+1

    node.text=str(new_year)

    node.set('updated','yes')

    node.set('version','1.0')

tree.write('test.xml')

 

 

#删除node

for country in root.findall('country'):

   rank = int(country.find('rank').text)

   if rank > 50:

     root.remove(country)

 

tree.write('output.xml')

 

#在country内添加（append）节点year2

import xml.etree.ElementTree as ET

tree = ET.parse("a.xml")

root=tree.getroot()

for country in root.findall('country'):

    for year in country.findall('year'):

        if int(year.text) > 2000:

            year2=ET.Element('year2')

            year2.text='新年'

            year2.attrib={'update':'yes'}

            country.append(year2) #往country节点下添加子节点

 

tree.write('a.xml.swap')

 

 

1.7.3 自己创建xml文档

import xml.etree.ElementTree as ET

 

 

new_xml = ET.Element("namelist")

name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})

age = ET.SubElement(name,"age",attrib={"checked":"no"})

sex = ET.SubElement(name,"sex")

sex.text = '33'

name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})

age = ET.SubElement(name2,"age")

age.text = '19'

 

et = ET.ElementTree(new_xml) #生成文档对象

et.write("test.xml", encoding="utf-8",xml_declaration=True)

 

ET.dump(new_xml) #打印生成的格式

 

1.8 configparser模块

1.8.1 示例一

########## my.ini##################

[mysqld]

charater-server-set = utf8

default-engine = innodb

skip-grant-table = True

port = 3306

data_dir='C:adata'

 

[client]

user = root

password = alex3714

 

[egon]

name = egon

age = 18

import configparser

 

config=configparser.ConfigParser()

config.read('my.ini')

 

# print(config.sections())

# print(config.options('mysqld'))

 

# print(config.get('mysqld','charater-server-set'))

 

# if config.has_option('mysqld','aaa'):

#     print(config.get('mysqld','aaa'))

 

# print(config.getboolean('mysqld','skip-grant-table'))

# print(config.getint('mysqld','port'))

# print(config.getfloat('mysqld','port'))

 

 

# config.add_section('egon')

# config.set('egon','name','egon')

# config.set('egon','age','18')

 

config.set('client','password','alex3714')

 

config.write(open('my.ini','w',encoding='utf-8'))

 

 

1.8.2 示例二

###################配置文件如下：#######################

# 注释1

; 注释2

 

[section1]

k1 = v1

k2:v2

user=egon

age=18

is_admin=true

salary=31

 

[section2]

k1 = v1

################################读取################################

import configparser

 

config=configparser.ConfigParser()

config.read('a.cfg')

 

#查看所有的标题

res=config.sections() #['section1', 'section2']

print(res)

 

#查看标题section1下所有key=value的key

options=config.options('section1')

print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary']

 

#查看标题section1下所有key=value的(key,value)格式

item_list=config.items('section1')

print(item_list) #[('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]

 

#查看标题section1下user的值=>字符串格式

val=config.get('section1','user')

print(val) #egon

 

#查看标题section1下age的值=>整数格式

val1=config.getint('section1','age')

print(val1) #18

 

#查看标题section1下is_admin的值=>布尔值格式

val2=config.getboolean('section1','is_admin')

print(val2) #True

 

#查看标题section1下salary的值=>浮点型格式

val3=config.getfloat('section1','salary')

print(val3) #31.0

 

####################################改写##############################

import configparser

 

config=configparser.ConfigParser()

config.read('a.cfg',encoding='utf-8')

 

 

#删除整个标题section2

config.remove_section('section2')

 

#删除标题section1下的某个k1和k2

config.remove_option('section1','k1')

config.remove_option('section1','k2')

 

#判断是否存在某个标题

print(config.has_section('section1'))

 

#判断标题section1下是否有user

print(config.has_option('section1',''))

 

 

#添加一个标题

config.add_section('egon')

 

#在标题egon下添加name=egon,age=18的配置

config.set('egon','name','egon')

config.set('egon','age',18) #报错,必须是字符串

 

 

#最后将修改的内容写入文件,完成最终的修改

config.write(open('a.cfg','w'))

################################基于上述方法添加一个ini文档########################

 

import configparser

 

config = configparser.ConfigParser()

config["DEFAULT"] = {'ServerAliveInterval': '45',

                      'Compression': 'yes',

                     'CompressionLevel': '9'}

 

config['bitbucket.org'] = {}

config['bitbucket.org']['User'] = 'hg'

config['topsecret.server.com'] = {}

topsecret = config['topsecret.server.com']

topsecret['Host Port'] = '50022'     # mutates the parser

topsecret['ForwardX11'] = 'no'  # same here

config['DEFAULT']['ForwardX11'] = 'yes'

with open('example.ini', 'w') as configfile:

   config.write(configfile)

 

 

 

1.9 hashlib模块

1.9.1 hashlib模块介绍

hash：一种算法 ,3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

三个特点：

1.内容相同则hash运算结果相同，内容稍微改变则hash值则变

2.不可逆推

3.相同算法：无论校验多长的数据，得到的哈希值长度固定。

1.9.2 hashlib应用

import hashlib

 

m=hashlib.md5()# m=hashlib.sha256()

 

m.update('hello'.encode('utf8'))

print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592

 

m.update('alvin'.encode('utf8'))

 

print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af

 

m2=hashlib.md5()

m2.update('helloalvin'.encode('utf8'))

print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

 

'''

注意：把一段很长的数据update多次，与一次update这段长数据，得到的结果一样

但是update多次为校验大文件提供了可能。

'''

 

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

import hashlib

 

# ######## 256 ########

 

hash = hashlib.sha256('898oaFs09f'.encode('utf8'))

hash.update('alvin'.encode('utf8'))

print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

 

1.9.3 模拟撞库破解密码

################模拟撞库破解密码##################

 

import hashlib

passwds=[

    'alex3714',

    'alex1313',

    'alex94139413',

    'alex123456',

    '123456alex',

    'a123lex',

    ]

def make_passwd_dic(passwds):

    dic={}

    for passwd in passwds:

        m=hashlib.md5()

        m.update(passwd.encode('utf-8'))

        dic[passwd]=m.hexdigest()

    return dic

 

def break_code(cryptograph,passwd_dic):

    for k,v in passwd_dic.items():

        if v == cryptograph:

            print('密码是===>33[46m%s33[0m' %k)

 

cryptograph='aee949757a2e698417463d47acac93df'

break_code(cryptograph,make_passwd_dic(passwds))

 

 

1.9.4 hmac模块使用

python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密:

import hmac

h = hmac.new('alvin'.encode('utf8'))

h.update('hello'.encode('utf8'))

print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

 

###################注意！注意！注意########################

 

#要想保证hmac最终结果一致，必须保证：

#1:hmac.new括号内指定的初始key一样

#2:无论update多少次，校验的内容累加到一起是一样的内容

 

import hmac

 

h1=hmac.new(b'egon')

h1.update(b'hello')

h1.update(b'world')

print(h1.hexdigest())

 

h2=hmac.new(b'egon')

h2.update(b'helloworld')

print(h2.hexdigest())

 

h3=hmac.new(b'egonhelloworld')

print(h3.hexdigest())

 

'''

f1bf38d054691688f89dcd34ac3c27f2

f1bf38d054691688f89dcd34ac3c27f2

bcca84edd9eeb86f30539922b28f3981

'''

 

 

1.9.5 hashlib模块使用示例二

import hashlib

 

# m=hashlib.md5()

# m.update('hello'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# print(m.hexdigest())

 

# fc5e038d38a57032085441e7fe7010b0

 

 

# m=hashlib.md5()

# m.update('hello'.encode('utf-8'))

# m.update('world'.encode('utf-8'))

# print(m.hexdigest())

#

# m1=hashlib.md5()

# m1.update('hellowor'.encode('utf-8'))

# m1.update('l'.encode('utf-8'))

# m1.update('d'.encode('utf-8'))

# print(m1.hexdigest())

 

 

 

# name=input('user:>> ')

# pwd=input('password:>> ')

# m=hashlib.md5()

# m.update(pwd.encode('utf-8'))

# pwd=m.hexdigest()

#

# print(name,pwd)

 

# cryt_pwd='aee949757a2e698417463d47acac93df'

# pwds=[

#     'alex3714',

#     'alex123',

#     '123alex'

# ]

# def make_dic(pwds):

#     dic={}

#     for pwd in pwds:

#         m=hashlib.md5(pwd.encode('utf-8'))

#         dic[pwd]=m.hexdigest()

#     return dic

#

# dic=make_dic(pwds)

# for pwd in dic:

#     if dic[pwd] == cryt_pwd:

#         print(pwd)

 

 

import hashlib

 

# m=hashlib.sha512()

# m=hashlib.md5('一行白鹭上青天'.encode('utf-8'))

# m.update('alex3714'.encode('utf-8'))

# m.update('两个黄鹂鸣翠柳'.encode('utf-8'))

# print(m.hexdigest())

 

 

 

# import hmac

# m=hmac.new('加盐'.encode('utf-8'))

# m.update('alex3714'.encode('utf-8'))

# print(m.hexdigest())

 

 

 

 

 

 

1.10 suprocess模块

1.10.1 suprocess模块(子进程模块)示例一

# import subprocess

# import time

#

# subprocess.Popen('tasklist',shell=True)

# print('----->主')

# time.sleep(1)

 

 

# import subprocess

import time

#

# obj=subprocess.Popen('tasklist',shell=True,

#                  stdout=subprocess.PIPE,

#                  stderr=subprocess.PIPE,

#                  )

# print(obj)

# print('第1次:',obj.stdout.read())

# print('第2次:',obj.stdout.read())

# print('---->主')

 

# print(obj.stdout.read().decode('gbk'))

 

 

 

# import subprocess #ls /etc ;pwd;ps aux

# obj=subprocess.Popen('tssssasklist',shell=True,

#                  stdout=subprocess.PIPE,

#                  stderr=subprocess.PIPE,

#                  )

 

# print(obj.stdout.read())

# print(obj.stderr.read().decode('gbk'))

 

 

#了解

import subprocess #tasklist | findstr python

# obj=subprocess.Popen('tasklist | findstr python',shell=True,

#                  stdout=subprocess.PIPE,

#                  stderr=subprocess.PIPE,

#                  )

#

# print(obj.stdout.read())

 

 

 

obj1=subprocess.Popen('tasklist',shell=True,

                 stdout=subprocess.PIPE,

                 stderr=subprocess.PIPE,

                 )

 

obj2=subprocess.Popen('findstr python',shell=True,

                 stdin=obj1.stdout,

                 stdout=subprocess.PIPE,

                 stderr=subprocess.PIPE,

                 )

 

print(obj2.stdout.read())

 

 

1.10.2 示例二

import  subprocess

 

'''

sh-3.2# ls /Users/egon/Desktop |grep txt$

mysql.txt

tt.txt

事物.txt

'''

 

res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stdout=subprocess.PIPE)

res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout,

                 stdout=subprocess.PIPE)

 

print(res.stdout.read().decode('utf-8'))

 

 

#等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep

res1=subprocess.Popen('ls /Users/jieli/Desktop |grep txt$',shell=True,stdout=subprocess.PIPE)

print(res1.stdout.read().decode('utf-8'))

 

 

#windows下:

# dir | findstr 'test*'

# dir | findstr 'txt$'

import subprocess

res1=subprocess.Popen(r'dir C:UsersAdministratorPycharmProjects	est函数备课',shell=True,stdout=subprocess.PIPE)

res=subprocess.Popen('findstr test*',shell=True,stdin=res1.stdout,

                 stdout=subprocess.PIPE)

 

print(res.stdout.read().decode('gbk')) #subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码

 

 

 

第2章 面向对象基础

2.1 什么是面向对象的程序设计及为什么要有它

面向过程的程序设计：核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么......面向过程的设计就好比精心设计好一条流水线，是一种机械式的思维方式。

优点是：复杂度的问题流程化，进而简单化（一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单）

缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

面向对象的程序设计：核心是对象二字，（要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的数据属性和方法属性），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取),对象是特征与技能的结合体，基于面向对象设计程序就好比在创造一个世界，你就是这个世界的上帝，存在的皆为对象，不存在的也可以创造出来，与面向过程机械式的思维方式形成鲜明对比，面向对象更加注重对现实世界的模拟，是一种“上帝式”的思维方式。

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：

1. 编程的复杂度远高于面向过程，不了解面向对象而立即上手基于它设计程序，极容易出现过度设计的问题。一些扩展性要求低的场景使用面向对象会徒增编程难度，比如管理linux系统的shell脚本就不适合用面向对象去设计，面向过程反而更加适合。

2. 无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法准确地预测最终结果。于是我们经常看到对战类游戏，新增一个游戏人物，在对战的过程中极容易出现阴霸的技能，一刀砍死3个人，这种情况是无法准确预知的，只有对象之间交互才能准确地知道最终的结果。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方

面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性。

 

2.2 面向对象与面向过程的对比

面向过程：核心是过程二字，过程即解决问题的步骤，就是先干什么再干什么

    基于该思想写程序就好比在设计一条流水线，是一种机械式的思维方式

    优点：复杂的过程流程化，进而简单化

    缺点：扩展性差

    面向对象：核心是对象二字，对象是特征与技能的结合体

    基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种“上帝式”的思维方式

    优点：可扩展性强

    缺点：编程复杂高，容易出现过度设计

2.3 类与对象

对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体

    在现实世界中：一定是先有的一个个具体存在的对象，后总结出的类

    在程序中：一定保证先定义类，后产生对象

类即类别、种类，是面向对象设计最重要的概念，对象是特征与技能的结合体，而类则是一系列对象相似的特征与技能的结合体

那么问题来了，先有的一个个具体存在的对象（比如一个具体存在的人），还是先有的人类这个概念，这个问题需要分两种情况去看

在现实世界中：先有对象，再有类

世界上肯定是先出现各种各样的实际存在的物体，然后随着人类文明的发展，人类站在不同的角度总结出了不同的种类，如人类、动物类、植物类等概念

也就说，对象是具体的存在，而类仅仅只是一个概念，并不真实存在

在程序中：务必保证先定义类，后产生对象

这与函数的使用是类似的，先定义函数，后调用函数，类也是一样的，在程序中需要先定义类，后调用类

不一样的是，调用函数会执行函数体代码返回的是函数体执行的结果，而调用类会产生对象，返回的是对象

按照上述步骤，我们来定义一个类（我们站在老男孩学校的角度去看，在座的各位都是学生）

######################在现实世界中：先有对象，再有类##################

 

#在现实世界中，站在老男孩学校的角度：先有对象，再有类

对象1：李坦克

    特征:

        学校=oldboy

        姓名=李坦克

        性别=男

        年龄=18

    技能：

        学习

        吃饭

        睡觉

 

对象2：王大炮

    特征:

        学校=oldboy

        姓名=王大炮

        性别=女

        年龄=38

    技能：

        学习

        吃饭

        睡觉

 

对象3：牛榴弹

    特征:

        学校=oldboy

        姓名=牛榴弹

        性别=男

        年龄=78

    技能：

        学习

        吃饭

        睡觉

 

 

现实中的老男孩学生类

    相似的特征:

        学校=oldboy

    相似的技能：

        学习

        吃饭

        睡觉

 

 

 

####################在程序中：先定义类，后产生对象#######################

 

#在程序中，务必保证：先定义（类），后使用（产生对象）

PS:

  1. 在程序中特征用变量标识，技能用函数标识

  2. 因而类中最常见的无非是：变量和函数的定义

 

#程序中的类

class OldboyStudent:

    school='oldboy'

    def learn(self):

        print('is learning')

       

    def eat(self):

        print('is eating')

   

    def sleep(self):

        print('is sleeping')

 

 

 

#注意：

  1.类中可以有任意python代码，这些代码在类定义阶段便会执行

  2.因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过OldboyStudent.__dict__查看

  3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的.语法

  4.点是访问属性的语法，类中定义的名字，都是类的属性

 

#程序中类的用法

.:专门用来访问属性，本质操作的就是__dict__

OldboyStudent.school #等于经典类的操作OldboyStudent.__dict__['school']

OldboyStudent.school='Oldboy' #等于经典类的操作OldboyStudent.__dict__['school']='Oldboy'

OldboyStudent.x=1 #等于经典类的操作OldboyStudent.__dict__['x']=1

del OldboyStudent.x #等于经典类的操作OldboyStudent.__dict__.pop('x')

 

 

#程序中的对象

#调用类，或称为实例化，得到对象

s1=OldboyStudent()

s2=OldboyStudent()

s3=OldboyStudent()

 

#如此，s1、s2、s3都一样了，而这三者除了相似的属性之外还各种不同的属性，这就用到了__init__

#注意：该方法是在对象产生之后才会执行，只用来为对象进行初始化操作，可以有任意代码，但一定不能有返回值

class OldboyStudent:

    ......

    def __init__(self,name,age,sex):

        self.name=name

        self.age=age

        self.sex=sex

    ......

 

 

s1=OldboyStudent('李坦克','男',18) #先调用类产生空对象s1，然后调用OldboyStudent.__init__(s1,'李坦克','男',18)

s2=OldboyStudent('王大炮','女',38)

s3=OldboyStudent('牛榴弹','男',78)

 

 

#程序中对象的用法

#执行__init__,s1.name='牛榴弹'，很明显也会产生对象的名称空间

s2.__dict__

{'name': '王大炮', 'age': '女', 'sex': 38}

 

s2.name #s2.__dict__['name']

s2.name='王三炮' #s2.__dict__['name']='王三炮'

s2.course='python' #s2.__dict__['course']='python'

del s2.course #s2.__dict__.pop('course')

 

2.3.1 类的定义与使用

##########################站在老男孩学校的角度##############################

现实中的对象：

    对象1：

        特征

            学校=老男孩

            名字=李三炮

            性别=男

            年龄=18

        技能

            学习

            选课

 

    对象2：

        特征

            学校=老男孩

            名字=张铁蛋

            性别=女

            年龄=38

        技能

            学习

            选课

 

    对象3：

        特征

            学校=老男孩

            名字=武大郎

            性别=男

            年龄=28

        技能

            学习

            选课

 

    对象4：

        特征

            学校=老男孩

            名字=egon

            性别=男

            年龄=18

        技能

            教学

 

 

现实中的老男孩学生类：

    老男孩学生类

        相似的特征

            学校=老男孩

        相似的技能

            学习

            选课

 

'''

# 类体代码在类的定义阶段就会立刻执行，

class Student:

    school='oldboy'

 

    def learn(self):

        print('is learning')

 

    def choose_course(self):

        print('choose course')

 

    # print('====run')

 

 

# print(Student)

# print(Student.__dict__)

 

#查看

# print(Student.school) #数据属性

# print(Student.learn) #函数属性

 

#增加

# Student.country='China'

# print(Student.country)

 

#修改

# Student.school='Oldboy'

# print(Student.school)

 

#删除

# del Student.country

# print(Student.country)

 

# print(Student.learn)

# Student.learn('xxxxx')

 

PS：

1. 站的角度不同，定义出的类是截然不同的，详见面向对象实战之需求分析

2. 现实中的类并不完全等于程序中的类，比如现实中的公司类，在程序中有时需要拆分成部门类，业务类......

3. 有时为了编程需求，程序中也可能会定义现实中不存在的类，比如策略类，现实中并不存在，但是在程序中却是一个很常见的类

2.3.2 对象的定义与使用

'''

1、面向过程与面向对象

    面向过程：核心是过程二字，过程即解决问题的步骤，就是先干什么再干什么

    基于该思想写程序就好比在设计一条流水线，是一种机械式的思维方式

    优点：复杂的过程流程化，进而简单化

    缺点：扩展性差

 

    面向对象：核心是对象二字，对象是特征与技能的结合体

    基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种“上帝式”的思维方式

    优点：可扩展性强

    缺点：编程复杂高，容易出现过度设计

 

2、类

    对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体

    在现实世界中：一定是先有的一个个具体存在的对象，后总结出的类

    在程序中：一定保证先定义类，后产生对象

 

3、站在老男孩学校的角度

现实中的对象：

    对象1：

        特征

            学校=老男孩

            名字=李三炮

            性别=男

            年龄=18

        技能

            学习

            选课

 

    对象2：

        特征

            学校=老男孩

            名字=张铁蛋

            性别=女

            年龄=38

        技能

            学习

            选课

 

    对象3：

        特征

            学校=老男孩

            名字=武大郎

            性别=男

            年龄=28

        技能

            学习

            选课

 

    对象4：

        特征

            学校=老男孩

            名字=egon

            性别=男

            年龄=18

        技能

            教学

 

 

现实中的老男孩学生类：

    老男孩学生类

        相似的特征

            学校=老男孩

        相似的技能

            学习

            选课

 

'''

class Student:

    school='oldboy'

 

    #stu1,'李三炮','男',18

    def __init__(self,name,sex,age): #在调用类时会自动触发执行

        self.Name=name

        self.Sex=sex

        self.Age = age

 

        #stu1.Name='李三炮'

        #stu1.Sex='男'

        #stu1.Age=18

 

    def learn(self):

        print('is learning')

 

    def choose_course(self):

        print('choose course')

 

#调用类的过程又称之为实例化:stu1=Student('李三炮','男',18)

#1、得到一个返回值，即对象，该对象是一个空对象stu1

#2、Student.__init__(stu1,'李三炮','男',18)

 

stu1=Student('李三炮','男',18)

# print(stu1.__dict__)

# print(stu1.Name,stu1.Age,stu1.Sex)

 

stu2=Student('张铁蛋','女',38)

stu3=Student('武大郎','男',28)

# print(stu2.__dict__)

# print(stu3.__dict__)

 

# print(stu1,stu2,stu3)

 

# print(stu2.Name)

 

 

2.3.3 类内置的特殊属性(了解)

##########################类的特殊属性(了解即可)######################

 

#python为类内置的特殊属性

类名.__name__# 类的名字(字符串)

类名.__doc__# 类的文档字符串

类名.__base__# 类的第一个父类(在讲继承时会讲)

类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)

类名.__dict__# 类的字典属性

类名.__module__# 类定义所在的模块

类名.__class__# 实例对应的类(仅新式类中)

2.4 补充说明：从代码级别看面向对象

2.4.1 示例一

######################数据与专门操作该数据的功能组合到一起########################

 

#1、在没有学习类这个概念时，数据与功能是分离的

def exc1(host,port,db,charset):

    conn=connect(host,port,db,charset)

    conn.execute(sql)

    return xxx

 

 

def exc2(host,port,db,charset,proc_name)

    conn=connect(host,port,db,charset)

    conn.call_proc(sql)

    return xxx

 

#每次调用都需要重复传入一堆参数

exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')

exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字')

 

 

 

 

#2、我们能想到的解决方法是，把这些变量都定义成全局变量

HOST=‘127.0.0.1’

PORT=3306

DB=‘db1’

CHARSET=‘utf8’

 

def exc1(host,port,db,charset):

    conn=connect(host,port,db,charset)

    conn.execute(sql)

    return xxx

 

 

def exc2(host,port,db,charset,proc_name)

    conn=connect(host,port,db,charset)

    conn.call_proc(sql)

    return xxx

 

exc1(HOST,PORT,DB,CHARSET,'select * from tb1;')

exc2(HOST,PORT,DB,CHARSET,'存储过程的名字')

 

 

#3、但是2的解决方法也是有问题的，按照2的思路，我们将会定义一大堆全局变量，这些全局变量并没有做任何区分，即能够被所有功能使用，然而事实上只有HOST，PORT，DB，CHARSET是给exc1和exc2这两个功能用的。言外之意：我们必须找出一种能够将数据与操作数据的方法组合到一起的解决方法，这就是我们说的类了

 

class MySQLHandler:

    def __init__(self,host,port,db,charset='utf8'):

        self.host=host

        self.port=port

        self.db=db

        self.charset=charset

    def exc1(self,sql):

        conn=connect(self.host,self.port,self.db,self.charset)

        res=conn.execute(sql)

        return res

 

 

    def exc2(self,sql):

        conn=connect(self.host,self.port,self.db,self.charset)

        res=conn.call_proc(sql)

        return res

 

 

obj=MySQLHandler('127.0.0.1',3306,'db1')

obj.exc1('select * from tb1;')

obj.exc2('存储过程的名字')

 

 

#改进

class MySQLHandler:

    def __init__(self,host,port,db,charset='utf8'):

        self.host=host

        self.port=port

        self.db=db

        self.charset=charset

        self.conn=connect(self.host,self.port,self.db,self.charset)

    def exc1(self,sql):

        return self.conn.execute(sql)

 

    def exc2(self,sql):

        return self.conn.call_proc(sql)

 

 

obj=MySQLHandler('127.0.0.1',3306,'db1')

obj.exc1('select * from tb1;')

obj.exc2('存储过程的名字')

 

 

2.4.2 示例二

'''

#1、在没有学习类这个概念时，数据与功能是分离的

def exc1(host,port,db,charset,sql):

    conn=connect(host,port,db,charset)

    res=conn.execute(sql)

    return res

 

def exc2(host,port,db,charset,proc_name)

    conn=connect(host,port,db,charset)

    res=conn.call_proc(prco_name)

    return res

 

#每次调用都需要重复传入一堆参数

exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')

exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字')

 

exc1('127.0.0.1',3306,'db1','utf8','select * from tb2;')

 

#2、在没有学习类这个概念时，数据与功能是分离的

host='127.0.0.1'

port=3306

db='db1'

charset='utf-8'

 

x=1

y=2

 

def exc1(sql):

    conn=connect(host,port,db,charset)

    res=conn.execute(sql)

    return res

 

def exc2(proc_name)

    conn=connect(host,port,db,charset)

    res=conn.call_proc(prco_name)

    return res

 

def func1():

    print(x)

    print(y)

 

def func2():

    print(x)

    print(y)

 

#每次调用都需要重复传入一堆参数

exc1('select * from tb1;')

exc2('utf8','存储过程的名字')

 

exc1('select * from tb2;')

 

func()

'''

 

# class Mysqlhandle:

#     def __init__(self,host,port,db,charset='utf-8'):

#         self.host=host

#         self.port=port

#         self.db=db

#         self.charset=charset

#         self.conn=connect(host,port,db,charset)

#

#     def exc1(self,sql):

#         return self.conn.execute(sql)

#

#     def exc2(self,proc_name)

#         return self.conn.call_proc(prco_name)

#

# obj1=Mysqlhandle('127.0.0.1',3306,'db1')

#

# obj1.exc1('select * from t1')

# obj1.exc1('select * from t2')

# obj1.exc1('select * from t3')

 

# obj2=Mysqlhandle('10.10.10.9',3306,'db2')

# obj2.exc1('select * from t1 where id > 3')

 

 

2.5 属性查找

2.5.1 类的属性查找介绍

类有两种属性：数据属性和函数属性

1. 类的数据属性是所有对象共享的

2. 类的函数属性是绑定给对象用的

#类的数据属性是所有对象共享的,id都一样

print(id(OldboyStudent.school))

 

print(id(s1.school))

print(id(s2.school))

print(id(s3.school))

 

'''

4377347328

4377347328

'''

 

 

 

#类的函数属性是绑定给对象使用的,obj.method称为绑定方法,内存地址都不一样

#ps:id是python的实现机制,并不能真实反映内存地址,如果有内存地址,还是以内存地址为准

print(OldboyStudent.learn)

print(s1.learn)

print(s2.learn)

print(s3.learn)

'''

<function OldboyStudent.learn at 0x1021329d8>

<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x1021466d8>>

<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146710>>

<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146748>>

'''

 

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常。

2.5.2 类的属性查找小练习

练习：编写一个教师类，产生一堆教师对象，要求有一个计数器（属性），任意一个教师都能够统计总共有多少个教师对象。

class Teacher:

    school='oldboy'

    count=0

 

    def __init__(self,name,sex,age,level,salary):

        self.name=name

        self.sex=sex

        self.age=age

        self.level=level

        self.salary=salary

        Teacher.count+=1

 

    def teach(self):

        print('%s is teaching' %self.name)

 

t1=Teacher('egon','male',18,10,3000)

t2=Teacher('alex','female',38,9,30000)

t3=Teacher('wxx','female',28,10,30000)

 

print(t1.count)

print(t2.count)

print(t3.count)

 

2.6 绑定到对象的方法的特殊之处

#改写

class OldboyStudent:

    school='oldboy'

    def __init__(self,name,age,sex):

        self.name=name

        self.age=age

        self.sex=sex

    def learn(self):

        print('%s is learning' %self.name) #新增self.name

 

    def eat(self):

        print('%s is eating' %self.name)

 

    def sleep(self):

        print('%s is sleeping' %self.name)

 

 

s1=OldboyStudent('李坦克','男',18)

s2=OldboyStudent('王大炮','女',38)

s3=OldboyStudent('牛榴弹','男',78)

 

类中定义的函数（没有被任何装饰器装饰的）是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数。

OldboyStudent.learn(s1) #李坦克 is learning

OldboyStudent.learn(s2) #王大炮 is learning

OldboyStudent.learn(s3) #牛榴弹 is learning

类中定义的函数（没有被任何装饰器装饰的）,其实主要是给对象使用的，而且是绑定到对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法

强调：绑定到对象的方法的特殊之处在于，绑定给谁就由谁来调用，谁来调用，就会将‘谁’本身当做第一个参数传给方法，即自动传值（方法__init__也是一样的道理）。

s1.learn() #等同于OldboyStudent.learn(s1)

s2.learn() #等同于OldboyStudent.learn(s2)

s3.learn() #等同于OldboyStudent.learn(s3)

注意：绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self。

2.7 属性查找与绑定方法的使用

x=1

class Student:

    school='oldboy'

    # Name='xxx'

 

    def __init__(self,name,sex,age): #在调用类时会自动触发执行

        self.Name = name

        self.Sex = sex

        self.Age = age

 

 

        #stu1.Name='李三炮'

        #stu1.Sex='男'

        #stu1.Age=18

 

    def learn(self,x,y):

        print('%s is learning' %self.Name)

        print(x,y)

 

    def choose_course(self):

        print('choose course')

 

    def commit_hw():

        print('commit homework')

 

#1、查找一个对象的属性顺序是：先找对象自己的__dict__,再找类的__dict__

# stu1=Student('李三炮','男',18)

# # print(stu1.__dict__)

#

# # print(stu1.Name)

# # print(stu1.school)

# # print(stu1.x)

 

stu1=Student('李三炮','男',18)

stu2=Student('张铁蛋','女',38)

stu3=Student('武大郎','男',28)

 

 

# 2、类的数据属性是所有对象共享，所有对象都指向同一个内存地址

# stu1.school='xxx'

# Student.school='Oldgirl'

# print(Student.school,id(Student.school))

# print(stu1.school,id(stu1.school))

# print(stu2.school,id(stu2.school))

# print(stu3.school,id(stu3.school))

 

# 3、类中定义的函数是绑定给对象使用：

# 3.1：不同对象就是不同绑定方法

# 3.2：绑定给谁，就应该由谁来调用,谁来调用就会把谁当做第一个参数传给对应的函数

# print(Student.learn)

# print(stu1.learn)

# print(stu2.learn)

# print(stu3.learn)

 

# stu1.learn(1,2) #Student.learn(stu1,1,2)

# stu2.learn(1,3)

# stu3.learn(1,4)

# print(Student.learn)

 

# stu1.commit_hw()

 

 

2.8 类即类型

提示：python的class术语与c++有一定区别，与 Modula-3更像。

python中一切皆为对象，且python3中类与类型是一个概念，类型就是类

2.8.1 示例一

#类型dict就是类dict

>>> list

<class 'list'>

 

#实例化的到3个对象l1,l2,l3

>>> l1=list()

>>> l2=list()

>>> l3=list()

 

#三个对象都有绑定方法append,是相同的功能,但内存地址不同

>>> l1.append

<built-in method append of list object at 0x10b482b48>

>>> l2.append

<built-in method append of list object at 0x10b482b88>

>>> l3.append

<built-in method append of list object at 0x10b482bc8>

 

#操作绑定方法l1.append(3),就是在往l1添加3,绝对不会将3添加到l2或l3

>>> l1.append(3)

>>> l1

[3]

>>> l2

[]

>>> l3

[]

#调用类list.append(l3,111)等同于l3.append(111)

>>> list.append(l3,111) #l3.append(111)

>>> l3

[111]

 

2.8.2 示例二

#类即类型

# class Teacher:

#     school='oldboy'

#     count=0

#

#     def __init__(self,name,sex,age,level,salary):

#         self.name=name

#         self.sex=sex

#         self.age=age

#         self.level=level

#         self.salary=salary

#         Teacher.count+=1

#

#     def teach(self):

#         print('%s is teaching' %self.name)

#

# t1=Teacher('egon','male',18,10,3000)

# print(type(t1))

 

 

# l=[1,2,3,4] #l=list([1,2,3,4])

# print(type(l))

 

l1=list([1,2,3,4])

l2=list([1,2,3,4])

# print(id(l1))

# print(id(l2))

 

# print(l1.append)

# l1.append(5) #list.appent(l1,5)

# list.append(l1,5)

# print(l1)

 

l1.append('a')

l2.append('b')

 

 

2.9 对象之间的交互

2.9.1 介绍

class Garen:        #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;

    camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;

    def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;

        self.nickname=nickname  #为自己的盖伦起个别名;

        self.aggressivity=aggressivity #英雄都有自己的攻击力;

        self.life_value=life_value #英雄都有自己的生命值;

    def attack(self,enemy):   #普通攻击技能，enemy是敌人;

        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。

我们可以仿照garen类再创建一个Riven类

class Riven:

    camp='Noxus'  #所有玩家的英雄(锐雯)的阵营都是Noxus;

    def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻击力54;

        self.nickname=nickname  #为自己的锐雯起个别名;

        self.aggressivity=aggressivity #英雄都有自己的攻击力;

        self.life_value=life_value #英雄都有自己的生命值;

    def attack(self,enemy):   #普通攻击技能，enemy是敌人;

        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。

实例出俩英雄

>>> g1=Garen('草丛伦')

>>> r1=Riven('锐雯雯')

交互：锐雯雯攻击草丛伦，反之一样

>>> g1.life_value

455

>>> r1.attack(g1)

>>> g1.life_value

401

补充：

　　garen_hero.Q()称为向garen_hero这个对象发送了一条消息，让他去执行Q这个功能，类似的有：

　　garen_hero.W()

　　garen_hero.E()

　　garen_hero.R()

2.9.2 对象之间的交互小练习一

class Garen:

    camp='demacia'

    def __init__(self,nickname,life_value,aggresivity):

        self.nickname=nickname

        self.life_value=life_value

        self.aggresivity=aggresivity

 

    def attack(self,enemy):

        enemy.life_value-=self.aggresivity

 

 

class Riven:

    camp = 'Noxus'

 

    def __init__(self, nickname, life_value, aggresivity):

        self.nickname = nickname

        self.life_value = life_value

        self.aggresivity = aggresivity

 

    def attack(self, enemy):

        enemy.life_value -= self.aggresivity

 

    def fire(self,enemy):

        enemy.life_value-=100

 

g1=Garen('草丛猥琐男',1000,100)

r1=Riven('猛男雯雯',200,500)

 

print(r1.life_value)

g1.attack(r1)

print(r1.life_value)

 

 

 

2.9.3 小练习二（基于面向对象设计一个对战游戏）

定义锐雯类：

 

class Riven:

    camp='Noxus'

    def __init__(self,nickname,

                 aggressivity=54,

                 life_value=414,

                 money=1001,

                 armor=3):

        self.nickname=nickname

        self.aggressivity=aggressivity

        self.life_value=life_value

        self.money=money

        self.armor=armor

    def attack(self,enemy):

        damage_value=self.aggressivity-enemy.armor

        enemy.life_value-=damage_value

定义盖文类：

 

class Garen:

    camp='Demacia'

    def __init__(self,nickname,

                 aggressivity=58,

                 life_value=455,

                 money=100,

                 armor=10):

        self.nickname=nickname

        self.aggressivity=aggressivity

        self.life_value=life_value

        self.money=money

        self.armor=armor

    def attack(self,enemy):

        damage_value=self.aggressivity-enemy.armor

        enemy.life_value-=damage_value

 

定义装备：

 

class BlackCleaver:

    def __init__(self,price=475,aggrev=9,life_value=100):

        self.price=price

        self.aggrev=aggrev

        self.life_value=life_value

    def update(self,obj):

        obj.money-=self.price #减钱

        obj.aggressivity+=self.aggrev #加攻击

        obj.life_value+=self.life_value #加生命值

    def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方

        obj.life_value-=1000 #假设火烧的攻击力是1000

 

#########测试交互#######

r1=Riven('草丛伦')

g1=Garen('盖文')

b1=BlackCleaver()

 

print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲

 

if r1.money > b1.price:

    r1.b1=b1

    b1.update(r1)

 

 

print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲

 

print(g1.life_value)

r1.attack(g1) #普通攻击

print(g1.life_value)

r1.b1.fire(g1) #用装备攻击

print(g1.life_value) #g1的生命值小于0就死了

按照这种思路一点一点的设计类和对象，最终你完全可以实现一个对战类游戏。