模块与对象（六）

1.1 random模块

import random

1.1.1 大于0且小于1之间的小数
print(random.random())

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

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

1.1.4 1或者alex或者sb
print(random.choice([1,'alex','sb']))

1.1.5 列表元素任意2个组合
print(random.sample([1,'alex','sb'],2))

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

打乱数字顺序

l=[1,3,4,2,5]

random.shuffle(l)

print(l)

生成7位数校验码

def make_code(n):

    res=''

    for i in range(n):

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

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

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

    return res

 

print(make_code(7))

1.2 os模块

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

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

print(os.stat(r'F:Python周末20期day61 本节内容').st_size)   #文件大小

1.2.2 打印系统进程，无返回值

res=os.system('tasklist')

print('====>',res)

 

1.2.3 将path分割成目录和文件名二元组返回

print(os.path.split(r'F:Python周末20期day61 本节内容'))

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

print(os.path.dirname(r'F:Python周末20期day61 本节内容'))

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

print(os.path.basename(r'F:Python周末20期day61 本节内容'))

1.2.6 如果path是绝对路径，返回True

print(os.path.isabs(r'C:\a123sz'))

print(os.path.isabs(r'/root/a123sz'))

1.2.7 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

print(os.path.join('C:','D:\','dir1','dir2','a.txt'))

print(os.path.join('D:\','dir1','dir2','a.txt'))

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

print(os.path.normcase('c:/windows\SYstem32\..'))

规范化路径，如..和/

print(os.path.normpath('c://windows\System32\../Temp/')) #C:windows	emp

1.2.9 os路径处理

1.2.9.1  方式一：

F:Python周末20期day63 os模块.py....

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

1.2.9.2  方式二：

BASE_DIR=os.path.normpath(os.path.join(

    os.path.abspath(__file__),

    '..',

    '..'

))

print(BASE_DIR)

1.2.10 返回path文件的大小

print(os.path.getsize(r'F:Python周末20期day61 本节内容'))

1.2.11 常用模块

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.3 sys模块

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

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

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

sys.maxint         最大的Int值

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

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

import sys

sys.argv

sys.exit(0)

sys.path

进度条的效果制定宽度

print('[%-50s]' %('#'*1))

print('[%-50s]' %('#'*2))

print('[%-50s]' %('#'*3))

print('[%-50s]' %('#'*4))

print('[%-50s]' %('#'*5))

打印%

([%-50s]) %('#'*10)

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

可传参来控制宽度

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

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

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

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

打印%

print('%d%%' %30)

1.3.1 进度条功能

import time 

#指定宽度

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='')

 

应用

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

    if percent >= 1:

        percent=1

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

    print('
%s %d%%' %(show_str,int(100*percent)),end='')

 

recv_size=0

total_size=10241

while recv_size < total_size:

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

    recv_size+=1024 #每次收1024

    progress(recv_size/total_size) #接收的比例

1.4 shutil模块

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

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

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

import shutil

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

shutil.copyfile(src, dst)

1.4.2 拷贝文件

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

shutil.copymode(src, dst) 仅拷贝权限。内容、组、用户均不变

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

shutil.copystat(src, dst) 仅拷贝状态的信息，包括：mode bits, atime, mtime, flags

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

1.4.2.1  shutil.copy(src, dst)

import shutil

shutil.copy('f1.log', 'f2.log') 拷贝文件和权限

import shutil

shutil.copy2('f1.log', 'f2.log') 拷贝文件和状态信息 

1.4.2.2  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的意思是排除 

1.4.2.3  拷贝软连接

import shutil

 

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

'''

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

'''

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

递归的去删除文件

import shutil

shutil.rmtree('folder1')

1.4.4 shutil.move(src, dst)

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

import shutil

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

 

1.4.5 压缩解压缩

1.4.5.1  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对象

import shutil

shutil.make_archive("bak", 'gztar', root_dir=r'F:Python周末20期day6') #tar cvzf bak.tar.gz /root

#将 /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.5.2  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()

1.4.5.3  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()

压缩

import tarfile

t=tarfile.open('bak.tar.gz')

t.extractall(r'F:Python周末20期day6aaa')

t.close()

 

# 解压

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

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

>>> t.close()

 

1.5 jison和pickle模块

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

dic={'a':1}

 

with open('db.txt','w',encoding='utf-8') as f:

    f.write(str(dic))

 

with open('db.txt','r',encoding='utf-8') as f:

    dic=eval(f.read()) #"{'a':1}"

    print(dic['a'])

打印报错

eval("[null,false,1]")

无法解析null类型，而json就可以

import json

dic={'a':1}

x=None

 

res1=json.dumps(dic) #str(dic)

res2=str(dic)

print(res1,type(res1))

print(res2,type(res2))

 

res=json.dumps(x)

print(res,type(res))

1.5.1 json序列化

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

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

 

图1-1  

 

图1-2  

import json,time

user={'name':'egon','age':18,'nb':True}

with open('user.json','w',encoding='utf-8') as f:

    f.write(json.dumps(user))  #等价于json.dump(dic,f)

 

students=['alex','egon','wxx','yxx']

json.dump(students,open('students.json','w',encoding='utf-8'))

 

time.sleep(500)

 

1.5.2 pickle

 

图1-3  

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

import pickle,json

import pickle,json

 

s={1,2,3}

print(json.dumps(s))

print(pickle.dumps(s))

 

with open('s.pkl','wb') as f:  #注意是w是写入str,wb是写入bytes,j是'bytes'

    f.write(pickle.dumps(s))

 

pickle.dump(s,open('s.pkl','wb'))

1.5.3 json反序列化

with open('s.pkl','rb') as f:

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

    print(s,type(s))

 

s=pickle.load(open('s.pkl','rb'))

print(s, type(s))

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

1.6 shelve模块

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

import shelve

 

f=shelve.open('db.shl')

# f['stu1']={'name':'alex1','age':38}

# f['stu2']={'name':'alex2','age':28}

print(f['stu1']['name'])

f.close()

1.7 xml模块

xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用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>

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

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

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

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

from xml.etree import ElementTree

 

tree=ElementTree.parse('a.xml')

 

root=tree.getroot()

print(root.tag)

print(root.attrib)

print(root.text)

三种查找方式

从子节点中找

print(root.find('country'))

print(root.findall('country'))

print(root.find('rank')) #None

从正树形结构中查找

print(list(root.iter('rank')))

 

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

    rank=country.find('rank')

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

 

遍历文档树

for country in root:

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

    for item in country:

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

 

 

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

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

 

 

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

    year.set('updated',"yes")

    year.text=str(int(year.text)+1)

 

tree.write('a.xml')

#在country内添加（append）节点

for country in root:

    obj=ElementTree.Element('egon') #<egon name="egon" age="18">egon is good</egon>

    obj.attrib={'name':'egon','age':'18'}

    obj.text='egon is good'

    country.append(obj)

 

tree.write('a.xml')

 

for rank in root.iter('rank'):

    if int(rank.text) == 5:

        obj=ElementTree.Element('egon') #<egon name="egon" age="18">egon is good</egon>

        obj.attrib={'name':'egon','age':'18'}

        obj.text='egon is good'

        rank.append(obj)

 

tree.write('a.xml')

1.8 configerparser模块

import configparser

 

config=configparser.ConfigParser()

config.read('my.ini')

#查看所有的标题

print(config.sections())

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

print(config.options('mysqld'))

#查看标题mysqld下charater-server-set的值=>字符串格式

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

 

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

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

查看标题mysqld下'skip-grant-table的值=>布尔值格式

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

查看标题mysqld'下port的值=>整数格式

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

查看标题mysqld'下port的值=> >浮点型格式
print(config.getfloat('mysqld','port'))

添加一个标题

config.add_section('egon')

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

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.9 hashlib模块

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

1.9.1 三个特点：

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

2.不可逆推

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

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()) 

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

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

name=input('user:>> ')

pwd=input('password:>> ')

m=hashlib.md5()

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

pwd=m.hexdigest()

 

print(name,pwd)

1.9.2 模拟撞库

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)

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

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())

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

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

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

print(m.hexdigest())

#要想保证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.10 subprocess模块

import subprocess

import time

 

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

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

time.sleep(1)

 

import time

import subprocess

 

 

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'))

 

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

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())  #subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码

面向对象

1.11 类的定义与使用

1.11.1 面向过程与面向对象

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

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

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

    缺点：扩展性差

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

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

    优点：可扩展性强

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

1.11.2 类

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

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

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

1.11.3 站在老男孩学校的角度

现实中的对象：

    对象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')

 

1.12 对象的定义与使用

1.12.1 面向过程与面向对象

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

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

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

    缺点：扩展性差

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

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

    优点：可扩展性强

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

1.12.2 类

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

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

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

1.12.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)

1.13 属性查找与绑定方法

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.13.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)

 

1.13.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()

1.13.3 小练习

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)

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)

 

1.14 类即类型

# 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')

1.15 从代码级别看面向对象

1.15.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;')

1.15.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()

1.15.3 使用类

# 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')