建设工作站服务器
三元运算(三目运算)是对简单条件句的缩写。
#写入格式
result=值1 if条件else值2
#条件成立时，将“值1”分配给result变量，否则，将“值2”分配给result变量
基本数据类型完成
集
set集合是无序且不重复的要素的集合
classset (对象) :
set ( ) -新empty set object
集( interable ) -新集对象
buildanunorderedcollectionofuniqueelements。
defadd(self，*args，**kwargs ):# real signature unknown
添加元素，添加元素
thishasnoeffectiftheelementisalreadypresent。
通过
defclear(self，*args，**kwargs ):# real signature unknown
清除所有元素从from this set .内容
通过
efcopy(self，*args，**kwargs ):# real signature unknown
Return a shallow copy of a set .浅拷贝
通过
defdifference(self，*args，**kwargs ):# real signature unknown
存在于returnthedifferenceoftwoormoresetsasanewset.a中，而不存在于b中
( I.e.allelementsthatareinthissetbutnottheothers.) )。
通过
defdifference_update(self，*args，**kwargs ):# real signature unknown
removeallelementsofanothersetfromthisset .从当前集合中删除与b相同的元素
通过
defdiscard(self，*args，**kwargs ):# real signature unknown
removeanelementfromasetifitisamember
If the element is not a member，do nothing .即使删除指定的元素，也没有未得到保证的元素
通过
defintersection(self，*args，**kwargs ):# real signature unknown
returntheintersectionoftwosetsasanewset .交叉
( I.e.allelementsthatareinbothsets.) )。
通过
defintersection_update(self，*args，**kwargs ):# real signature unknown
取updateasetwitheintersectionofitselfandanother .交集，更新为a
通过
defisdisjoint(self，*args，**kwargs ):# real signature unknown
returntrueiftwosetshaveanullintersection .如果没有交集，则返回true；否则返回False
通过
defissubset(self，*args，**kwargs ):# real signature unknown
reportwhetheranothersetcontainsthisset .是否是子序列
通过
dfissuperset(self，*args，**kwargs ):# real signature unknown
reportwhetherthissetcontainsanotherset .是否为父序列
通过
defpop(self，*args，**kwargs ):# real signature unknown
removeandreturnanarbitrarysetelement。
删除Raises KeyError if the set is empty .元素
通过
defremove(self，*args，**kwargs ):# real signature unknown
Remove an element from a set； it must be a member。
If the element is not a member，raise a KeyError .删除指定的元素没有保证错误
通过
efsymmetric_difference(self，*args，**kwargs ):# real signature unknown
returnthesymmetricdifferenceoftwosetsasanewset .对称差分集
( I.e.allelementsthatareinexactlyoneofthesets.) )。
通过
def symmetric _ difference _ update ( self，*args，**kwargs ):# real signature unknown
updateasetwithesymmetricdifferenceofitselfandanother .对称差分集，然后更新为a
通过
defunion(self，*args，**kwargs ):# real signature unknown
Return the union of sets as a new set .并集
( I.e.allelementsthatareineitherset.) )。
通过
defupdate(self，*args，**kwargs ):# real signature unknown
updateasetwitheunionofitselfandothers .更新
通过
练习：寻找差异
#数据库中的现有
old_dict={
#1\\\\&； quot； Hostname\\&； quot； C1，\\\&； #039； cpu_count\\\&； #039； 2，\\&； quot； \&； quot； \\&； quot； mem_capicity\\\&； quot；
#2\\\\&； quot； Hostname\\&； quot； C1，\\\&； #039； cpu_count\\\&； #039； 2，\\&； quot； \&； quot； \\&； quot； mem_capicity\\\&； quot；
#3\\\\&； quot； Hostname\\&； quot； C1，\\\&； #039； cpu_count\\\&； #039； 2，\\&； quot； \\&； quot； mem_capicity\\\&； quot；
}
# cmdb新报告的数据
new_dict={
#1\\\\&； quot； Hostname\\&； quot； C1，\\\&； #039； cpu_count\\\&； #039； 2，\\&； quot； \&； quot； \\&； quot； mem_capicity\\\&； quot；
#3\\\\&； quot； Hostname\\&； quot； C1，\\\&； #039； cpu_count\\\&； #039； 2，\\&； quot； \\&； quot； mem_capicity\\\&； quot；
#4\\\\&； quot； Hostname\\&； quot； C2，\\\&； #039； cpu_count\\\&； #039； 2，\\\&； quot； \\&； quot； mem_capicity\\\&； quot；
}
必须删除：
需要新的吗？
需要更新吗？
注意：没有必要在意内部要素是否发生了变化。 只要原来存在，新的报告也存在，就需要更新
浓淡复印
一.数字和字符串
对于数字和字符串，赋值、浅拷贝和深拷贝没有意义，因为它们总是指向同一个存储器地址。
导入副本
# # # # #数字、字符串######
n1=123
# n1=i am alex age 10
print(id ) N1 ) )
# ##代入
n2=n1
print(id ) N2 ) )
###浅拷贝# #
N2=copy.copy(N1 ) )。
print(id ) N2 ) )
###深度复制# #
N3=copy.deepcopy(N1 ) )。
打印( id ( n3 ) )
二.其他基本数据类型
在词典、鼻祖、列表的情况下，进行代入、浅复制、深复制时，存储器地址的变化会不同。
1、赋值
代入。 您只需创建一个指向原始存储器地址的变量，例如：
n1={k1: wu，k2: 123，k3: [alex，456]}
n2=n1
2、浅文案
浅拷贝，在内存中只追加制作第1层的数据
导入副本
n1={k1: wu，k2: 123，k3: [alex，456]}
N3=copy.copy(N1 ) )。
3、深度复制
深度复制，重新创建内存中的所有数据。 排除最后一层。 即，优化python内部的字符串和数字)
导入副本
n1={k1: wu，k2: 123，k3: [alex，456]}
N4=copy.deepcopy(N1 ) )。
函数
一.背景
在学习函数之前，按照面向过程的编程，即基于业务逻辑从上到下实现功能。 它往往实现由长代码指定的功能。 开发中最常见的操作是粘贴复制，也就是将以前安装的代码块复制到现有的功能中。 如下。
while True :
if cpu使用率90% :
#用邮件发送提醒
连接到邮箱服务器
发送邮件
关闭连接
90%的if硬盘使用空间：
#用邮件发送提醒
连接到邮箱服务器
发送邮件
关闭连接
if存储器为80% :
#用邮件发送提醒
连接到邮箱服务器
发送邮件
关闭连接
针对上述代码，可以提取if条件语句下的内容并使其通用化，如下所示。
def发送邮件(内容) )
#用邮件发送提醒
连接到邮箱服务器
发送邮件
关闭连接
while True :
if cpu使用率90% :
发送邮件： #039； CPU警报\\&； quot；
90%的if硬盘使用空间：
发送邮件： quot； 硬盘报警\\&； quot；
if存储器为80% :
关于上述两种实现方式，第二次必然优于第一次的复用性和可读性。 实际上，这就是函数型编程和面向过程的编程的区别：
函数表达式：如果把某个功能代码封装在函数中，以后就不需要重复写了，只需要调用函数就可以了
面向对象：将函数分类封装，使开发“更快、更强……”
函数式编程中最重要的是提高代码的复用性和可读性
二.定义和使用
def函数名称(参数) :
……
函数体
……
返回值
函数的定义主要有以下几点。
def :表示函数的关键字
函数名称：函数的名称。 稍后根据函数名称调用函数
函数体)发送邮件，计算[ 11，22，38，888，2 ]的最大数等，在函数中进行一系列的逻辑计算…
参数：为函数主体提供数据
返回值：函数执行完成后，可以将数据返回给调用方。
1、返回值
函数是需要通过返回值通知调用方执行是否成功的功能块。
以上要点中，重要的是参数和返回值。
def发送邮件() :
发送邮件的代码…
if发送成功：
返回真
else :
返回假
while True :
每次执行#邮件发送函数时，都会自动将返回值分配给result
#然后，可以根据result写入日志或重新发送日志
result=发送邮件()。
if result==False :
记录日志，发送邮件失败…
2、参数
为什么需要参数？
def CPU报警邮件() )
#用邮件发送提醒
连接到邮箱服务器
发送邮件
关闭连接
defHDD警告邮件() ) ) ) ) ) ) ) ) )。
#用邮件发送提醒
连接到邮箱服务器
发送邮件
关闭连接
def内存报警邮件() ) )
#用邮件发送提醒
连接到邮箱服务器
发送邮件
关闭连接
while True :
if cpu使用率90% :
CPU报警邮件() )
90%的if硬盘使用空间：
硬盘警告邮件() )
if存储器为80% :
内存报警邮件() )。
发送def邮件(邮件内容) ) ) ) ) )。
#用邮件发送提醒
连接到邮箱服务器
发送邮件
关闭连接
while True :
if cpu使用率90% :
发送邮件( CPU报警了。 ）
90%的if硬盘使用空间：
发送邮件(硬盘报警了。 ）
if存储器为80% :
发送邮件) )发生了内存报警。 ）
有参数安装
函数有三个不同的参数。
正常参数
######定义函数# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# name称为函数func的形式参数，简称：形参
deffunc(name ) :
print name
#######执行函数# # # # # #执行函数
#\\&； quot； wupeiqi\\&； quot； 称为函数func的实际参数，简称：实参
func ( ( ) ) Wupeiqi ( ( ) ) ) ) ) )
默认参数
deffunc(name，age=18 ) :
打印% s:% s % ( name，age )
#指定参数
func ( ( ) ) ( Wupeiqi ( ) ) ) )，19 ) ) ) ) ) ) ) ) ) ) )。
#使用默认参数
func333Alex3333 )
注：默认参数必须位于参数列表的末尾
动态参数
effunc(*Args ) :
打印区域
#执行方式1
func ( 11，33，4，4454，5 ) )。
#执行方式2
Li=[ 11，2，2，3，3，4，54 ]
函数( * Li ) )。
effunc(*Args，**kwargs ) :
打印区域
打印工作
扩展：发送邮件实例
发送邮件实例
import smtplib
fromemail.mime.textimportmimetext
fromemail.utilsimportformataddr
msg=mimetext (邮件内容((() )、((() )、plain ()、( ) )、utf-8 ) ) )
msg[\\&； quot； 来自\ & amp； quot； ]=formataddr([武沛齐，\\&； quot； wptawy@126.com\\&； quot； ) ]
msg[\\&； quot； to\\&； quot； ]=formataddr([离开，\\&； quot； 424662508@QQ.com\\&； quot； ( ]
msg[\\&； quot； subject\\&； quot； ]=主题
server=smtplib.SMTP ( SMTP.126.com，25 ) ) ) ) ) ) ) ) ) server=smtplib.SMTP ( SMTP.126.com，25 ) ) ) ) )
server.login(wptawy@126.com，邮箱密码() ) ) ) )。
server.sendmail(wptawy(126.com ( ) )、[\\ ( ) 424662508@QQ.com ( )、]、msg.as_、msg.as_ )
server.quit (
内置函数
注：请看详细猛击这里
用于文件处理的open函数
要处理文件，一般需要执行以下步骤：
打开文件
操作文件
一.打开文件
句柄=open (文件路径： quot；\\&； quot； 模式\\&； quot；
打开文件时，必须指定文件路径和如何打开文件。 打开后，可以获得该文件句柄，以后可以通过该文件句柄对其进行操作。
打开文件的模式如下。
r、只读模式【默认】
w，只写模式【看不懂； 如果不存在，则创建； 清空内容； 】
x，只写模式【看不懂； 如果不存在则创建，如果存在则报告错误】
a、添加模式【可读； 如果不存在，则创建； 只添加内容】
表示可以同时读写文件
r、读写【可读、可写】
w、读写【可读、可写】
x、写读【读，写】
A、写读【读，写】
b表示用字节工作
rb或rb
网页或网页
xb或w b
ab或ab
注：以b模式打开时，读取的内容为字节类型，写入时也必须指定字节类型
二.操作
2.
类文件( object )
ef close ( self ( # realsignatureunknown； restored from __doc__
关闭文件
close ( )-noneor ) Perhaps ) an integer. Close the file。
setsdataattribute.closedtotrue.aclosedfilecannotbeusedfor
further I/O operations. close ( ) may be called more than once without
error.somekindsoffileobjects ( for example，opened by popen ) )
mayreturnanexitstatusuponclosing。
effileno(self ) # real signature unknown； restored from __doc__
文件描述符
fileno ( -集成文件描述符)。
thisisneededforlower-levelfileinterfaces，such os.read (
返回0
e fflush ( self ( # realsignatureunknown； restored from __doc__
刷新文件内部缓冲区
flush (-none.flushtheinternali/o buffer。
通过
efisatty(self ):# real signature unknown； restored from __doc__
确定文件是否同意tty设备
isatty ( )-trueorfalse.trueifthefileisconnectedtoattydevice。
返回假
def next ( self ( # realsignatureunknown； restored from __doc__
获取下一行中的数据，如果不存在，则报告错误
x.next(-thenextvalue，or raise StopIteration
通过
defread(self，size=None ):# real signature unknown； restored from __doc__
读取指定的字节数据
读( size ) -读at most size bytes，returned as a string。
ifthesizeargumentisnegativeoromitted，读单元eof is reached。
noticethatwheninnon-blocking mode，less data than what was requested
may be returned，even if no size parameter was given。
通过
defreadinto ( self ( # realsignatureunknown； restored from __doc__
读取到缓冲区，不要使用。 被扔掉
读我(-undocumented.don ( ) ) tusethis； 我要去哪里？
通过
defreadline(self，size=none ( # realsignatureunknown； restored from __doc__
只读取一行数据
readline(size )- next line from the file，as a string。
retain newline.anon-negativesizeargumentlimitsthemaximum
numberofbytestoreturn ( anincompletelinemaybereturnedthen )。
返回an empty string at eof。
通过
defreadlines(self，size=None ):# real signature unknown； restored from __doc__
读取所有数据并根据换行符保存值列表
读线( [ size ]-list of strings，each a line from the file。
呼叫就绪( repeatedlyandreturnalistofthelinessoread )。
The optional size argument，if given，is an approximate bound on the
totalnumberofbytesinthelinesreturned。
return []
defseek(self，offset，whence=None ):# real signature unknown； restored from __doc__
指定指针在文件中的位置
seek(offset (，whence] ) )- None. Move to new file position。
argumentoffsetisabytecount.optionalargumentwhencedefaultsto
( offset from start of file，offset should be=0) other values are 1
( move relative to current position，positive or negative )，and2) move
relative to end of file，usually negative，although many platforms allow
seekingbeyondtheendofafile (.ifthefileisopenedintextmode，
onlyoffsetsreturnedbytell ( are legal.useofotheroffsetscauses
未定义的视野。
notethatnotallfileobjectsareseekable。
通过
deftell(self ) # real signature unknown； restored from __doc__
获取当前指针位置
tell ( )- current file position，aninteger ) maybealonginteger )。
通过
deftruncate(self，size=None ):# real signature unknown； restored from __doc__
截断数据，仅保留指定的上一个数据
truncate(size )-none.truncatethefiletoatmostsizebytes。
sizedefaultstothecurrentfileposition，as returned by tell ( )。
通过
defwrite(self，p_str ):# real signature unknown； restored from __doc__
写内容
write(str )- None. Write string str to file。
Note that due to buffering，flush(orclose ) may be needed before
thefileondiskreflectsthedatawritten。
通过
defwritelines(self，sequence_of_strings ):# real signature unknown； restored from __doc__
将字符串列表写入文件
writelines(sequence_of_strings )- None. Write the strings to the file。
notethatnewlinesarenotadded.thesequencecanbeanyiterableobject
producing strings.thisisequivalenttocallingwrite ( ) for each string。
通过
defxreadlines ( self ( # realsignatureunknown； restored from __doc__
可以逐行读取文件，而不是全部读取
xreadlines(-returnsself )。
forbackwardcompatibility.fileobjectsnowincludetheperformance
optimizationspreviouslyimplementedinthexreadlinesmodule
通过
复制代码
复制代码
classtextiowrapper(_textiobase ) :
characterandlinebasedlayeroverabufferediobaseobject，buffer。
encodinggivesthenameoftheencodingthatthestreamwillbe
decodedorencodedwith.itdefaultstolocale.getpreferredencoding ( false )。
errorsdeterminesthestrictnessofencodinganddecoding (
help(codecs.codec ) orthedocumentationforcodecs.register ) and
默认为严格。
newlinecontrolshowlineendingsarehandled.itcanbenone，\\\\&； quot；
\\\\\\n\\\&； quot；\\\&； quot；\\\&； quot；\\&； quot； \\r\\\n\\&； quot；and\\\\&； quot；
* On input，if newline is None，universal newlines mode is
enabled.linesintheinputcanendin\\ & amp； quot；或\\\\& amp； quot；n\\\&； quot；\\\&； quot；\\&； quot； \&； quot；\\&； quot； \&； quot；r\\\\&； quot；
thesearetranslatedinto\\\&； quot； \&； quot； \&； quot； \&； quot； n\\&； quot； beforebeingReturnedtothe
caller.ifitis\\\&； quot；universal newline mode is enabled，but line
endingsarereturnedtothecalleruntranslated.ifithasanyof
the other legal values，inputlinesareonlyterminatedbythegiven
string，andthelineendingisreturnedtothecalleruntranslated。
* On output，if newline is None，any\\\\&； quot； \&； quot； \&； quot； 字符写入
translatedtothesystemdefaultlineseparator，os.linesep. If
newlineis\\\&； quot；notranslationtakesplace.ifnewlineisany
of the other legal values，any\\\\&； quot； \&； quot； \&； quot； \&； quot； n\\\&； quot； 角色写入tenaretranslated
to the given string。
If line_buffering is True，acalltoflushisimpliedwhenacallto
写内容a新字符。
defclose(self，*args，**kwargs ):# real signature unknown
关闭文件
通过
deffileno(self，*args，**kwargs ):# real signature unknown
文件描述符
通过
defflush(self，*args，**kwargs ):# real signature unknown
刷新文件内部缓冲区
通过
defisatty(self，*args，**kwargs ):# real signature unknown
确定文件是否同意tty设备
通过
efread(self，*args，**kwargs ):# real signature unknown
读取指定的字节数据
通过
defreadable(self，*args，**kwargs ):# real signature unknown
是否可读
通过
defreadline(self，*args，**kwargs ):# real signature unknown
只读取一行数据
通过
defseek(self，*args，**kwargs ):# real signature unknown
指定指针在文件中的位置
通过
defseekable(self，*args，**kwargs ):# real signature unknown
指针是否可操作
通过
efTell(self，*args，**kwargs ):# real signature unknown
获取指针的位置
通过
deftruncate(self，*args，**kwargs ):# real signature unknown
截断数据，仅保留指定的上一个数据
通过
defwritable(self，*args，**kwargs ):# real signature unknown
是否可写
通过
defwrite(self，*args，**kwargs ):# real signature unknown
写内容
通过
def __getstate__(self，*args，**kwargs ):# real signature unknown
通过
def __init__(self，*args，**kwargs ):# real signature unknown
通过
@ static method # knowncaseof _ _ new _ _ u
def __new__(*args，**kwargs ):# real signature unkn
ownCreate and return a new object. See help(type) for accurate signature.
pass
def __next__(self, *args, **kwargs): # real signature unknown
Implement next(self).
pass
def __repr__(self, *args, **kwargs): # real signature unknown
Return repr(self).
pass
buffer = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
encoding = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
errors = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
name = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
newlines = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
_CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
_finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
3.x
三、管理上下文
为了避免打开文件后忘记关闭，可以通过管理上下文，即：
with open(\\\’log\\\’,\\\’r\\\’) as f:
…
如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。
在Python 2.7 及以后，with又支持同时对多个文件的上下文进行管理，即：
with open(\\\’log1\\\’) as obj1, open(\\\’log2\\\’) as obj2:
pass
lambda表达式
学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：
# 普通条件语句
if 1 == 1:
name = \\\’wupeiqi\\\’
else:
name = \\\’alex\\\’
# 三元运算
name = \\\’wupeiqi\\\’ if 1 == 1 else \\\’alex\\\’
对于简单的函数，也存在一种简便的表示方式，即：lambda表达式
# ###################### 普通函数 ######################
# 定义函数（普通方式）
def func(arg):
return arg 1
# 执行函数
result = func(123)
# ###################### lambda ######################
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg 1
# 执行函数
result = my_lambda(123)
递归
利用函数编写如下数列：
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368…
def func(arg1,arg2):
if arg1 == 0:
print arg1, arg2
arg3 = arg1 arg2
print arg3
func(arg2, arg3)
func(0,1)
练习题
1、简述普通参数、指定参数、默认参数、动态参数的区别
2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
4、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
5、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
6、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
7、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
dic = {k1: v1v1, k2: [11,22,33,44]}
PS:字典中的value只能是字符串或列表
8、写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。
更多关于云服务器，域名注册，虚拟主机的问题，请访问西部数码官网：www.chenqinet.cn