模块与对象(六)

2018-06-18 00:40:03来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

 

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期\day6\1 本节内容').st_size)   #文件大小

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

res=os.system('tasklist')

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

 

 

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

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

 

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

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

 

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

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

 

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\temp

 

 

1.2.9 os路径处理

1.2.9.1  方式一:

F:\Python周末20期\day6\3 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期\day6\1 本节内容'))

 

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下为"\t\n",Linux下为"\n"

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('\r%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('\r%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期\day6\aaa')

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

 

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Windows 64 位系统下 Python 环境的搭建

下一篇:全局变量和局部变量迷惑人的小示例