该变量指向原来内部存款和储蓄器地址,name.count(‘lex’) 总括 lex出现次数

1. 列表、元组操作

Python基础(三),python基础

本章内容:

  • 浓度拷贝
  • 函数(全局与局部变量)
  • 文本处理
  • 三朝运算
  • lambda 表达式
  • 递归(斐波那契数列)
深浅拷贝

壹 、数字和字符串

对此 数字 和 字符串
而言,赋值、浅拷贝和深拷贝无意义,因为其永香港恒生股价平均指数向同1个内部存款和储蓄器地址。

import copy
#定义变量   数字、字符串
n1 = 123
#n1 = 'nick'
print(id(n1))

#赋值
n2 = n1
print(id(n2))

#浅拷贝
n3 = copy.copy(n1)
print(id(n3))

#深拷贝
n4 = copy.deepcopy(n1)
print(id(n4))

永利网上娱乐 1

二、字典、元祖、列表

对于字典、元祖、列表
而言,进行赋值、浅拷贝和深拷贝时,其内存地址的生成是例外的。

1、赋值

始建二个变量,该变量指向原来内部存款和储蓄器地址

n1 = {"k1": "nick", "k2": 123, "k3": ["jenny", 666]}
n2 = n1

永利网上娱乐 2

2、浅拷贝

在内部存款和储蓄器中只额外成立第二层数据

import copy

n1 = {"k1": "nick", "k2": 123, "k3": ["jenny", 666]}
n2 = copy.copy(n1)

永利网上娱乐 3

3、深拷贝

在内部存款和储蓄器中校全数的数码重复创立一份(排除最终一层,即:python内部对字符串和数字的优化)

import copy

n1 = {"k1": "nick", "k2": 123, "k3": ["jenny", 666]}
n2 = copy.deepcopy(n1)

永利网上娱乐 4

函数

一 、定义和选择

函数式编制程序最要害的是增加代码的重用性和可读性

def 函数名(参数):

    ...
    函数体
    ...
    返回值

函数的定义重要有如下要点:

  • def:表示函数的第②字
  • 函数名:函数的称号,日后遵照函数名调用函数
  • 函数体:函数中展开一名目繁多的逻辑计算
  • 参数:为函数体提供数据
  • 重临值:当函数执行实现后,能够给调用者重回数据。

1、返回值

def 发送邮件():

    发送邮件的代码...

    if 发送成功:
        return True
    else:
        return False


while True:

    # 每次执行发送邮件函数,都会将返回值自动赋值给result
    # 之后,可以根据result来写日志,或重发等操作

    result = 发送邮件()
    if result == False:
        记录日志,邮件发送失败...

2、参数

函数的有三中分化的参数:

  • 平凡参数
  • 暗许参数
  • 动态参数

永利网上娱乐 5#定义函数
#n 叫做函数 name 的款型参数,简称:形参 def name(n): print(n)
#实施函数 #’nick’ 叫做函数 name 的实际上参数,简称:实参 name(‘nick’)
普通参数
永利网上娱乐 6def
func(name, age = 18): print(“%s:%s”)%(name,age) # 钦定参数 func(‘nick’,
19) # 使用默许参数 func(‘nick’) 注:暗中认可参数必要放在参数列表最后 默许参数
永利网上娱乐 7def
func(*args): print args # 执行办法一 func(11,22,33,55,66) #
执行措施二 li = [11,22,33,55,66] func(*li) 动态参数(*args)
永利网上娱乐 8def
func(**kwargs): print kwargs # 执行情势一 func(name=’nick’,age=18)
# 执行办法二 li = {‘name’:’nick’, age:18, ‘job’:’pythoner’}
func(**li) 动态参数(**kwargs)
永利网上娱乐 9def
hi(a,*args,**kwargs): print(a,type(a)) print(args,type(args))
print(kwargs,type(kwargs)) hi(11,22,33,k1=’nick’,k2=’jenny’) 动态参数(a,*args,**kwargs)

#永利网上娱乐,出殡邮件实例

永利网上娱乐 10def
mail(焦点,邮件内容=’test’,收件人=’[email protected]‘):
import smtplib from email.mime.text import MIMEText from email.utils
import formataddr msg = MIMEText(邮件内容, ‘plain’, ‘utf-8’)
msg[‘From’] = formataddr([“发件人”, ‘发件人地址’]) msg[‘To’] =
formataddr([“收件人”,
[email protected]‘])
msg[‘Subject’] = 大旨 server = smtplib.SMTP(“smtp.126.com”, 25)
server.login(“登录邮箱账号”, “邮箱密码”)
server.sendmail(‘发件邮箱地址账号’, [收件人地址, ], msg.as_string())
server.quit()
mail(‘作者是大旨’,收件人=’[email protected]‘,邮件内容=’邮件内容’)
mail(主旨=’我是宗旨’,) 发送邮件实例

叁 、全局与局地变量

全局变量在函数里能够随便调用,但要修改就无法不用 global 注脚

############### 全 局 与 局 部 变 量 ##############
#全局变量
P = 'nick'

def name():
    global P        #声明修改全局变量
    P = 'jenny'     #局部变量
    print(P)

def name2():
    print(P)

name()
name2()

 

文件处理

open函数,该函数用于文书处理
① 、打开文件

文件句柄 = open('文件路径', '模式')

开辟文件时,需求钦赐文件路径和以何等措施打开文件,打开后,即可取得该文件句柄,日后通过此文件句柄对该公文操作。

开辟文件的形式有:

  • r ,只读格局【私下认可】
  • w,只写方式【不可读;不设有则开创;存在则清空内容】
  • x, 只写情势【不可读;不设有则开创,存在则报错】
  • a, 追加情势【不可读;不设有则创设;存在则只增添内容】

“+” 表示能够同时读写有个别文件

  • r+, 读写【可读,可写】
  • w+,写读【可读,可写】
  • x+ ,写读【可读,可写】
  • a+, 写读【可读,可写】

 “b”表示以字节的方法操作

  • rb  或 r+b
  • wb 或 w+b
  • xb 或 w+b
  • ab 或 a+b

 注:以b方式打开时,读取到的内容是字节类型,写入时也亟需提供字节类型

二、操作

####### r 读 #######
f = open('test.log','r',encoding='utf-8')
a = f.read()
print(a)

###### w 写(会先清空!!!) ######
f = open('test.log','w',encoding='utf-8')
a = f.write('car.\n索宁')
print(a)    #返回字符

####### a 追加(指针会先移动到最后) ########
f = open('test.log','a',encoding='utf-8')
a = f.write('girl\n索宁')
print(a)    #返回字符

####### 读写 r+ ########
f = open('test.log','r+',encoding='utf-8')
a = f.read()
print(a)
f.write('nick')

##### 写读 w+(会先清空!!!) ######
f = open('test.log','w+',encoding='utf-8')
a = f.read()
print(a)
f.write('jenny')

######## 写读 a+(指针先移到最后) #########
f = open('test.log','a+',encoding='utf-8')
f.seek(0)   #指针位置调为0
a = f.read()
print(a)
b = f.write('nick')
print(b)

####### rb #########
f = open('test.log','rb')
a = f.read()
print(str(a,encoding='utf-8'))

# ######## ab #########
f = open('test.log','ab')
f.write(bytes('索宁\ncar',encoding='utf-8'))
f.write(b'jenny')

##### 关闭文件 ######
f.close()

##### 内存刷到硬盘 #####
f.flush()

##### 获取指针位置 #####
f.tell()

##### 指定文件中指针位置 #####
f.seek(0)

###### 读取全部内容(如果设置了size,就读取size字节) ######
f.read()

###### 读取一行 #####
f.readline()

##### 读到的每一行内容作为列表的一个元素 #####
f.readlines()

永利网上娱乐 11class
file(object) def close(self): # real signature unknown; restored from
__doc__ 关闭文件 “”” close() -> None or (perhaps) an integer.
Close the file. Sets data attribute .closed to True. A closed file
cannot be used for further I/O operations. close() may be called more
than once without error. Some kinds of file objects (for example, opened
by popen()) may return an exit status upon closing. “”” def
fileno(self): # real signature unknown; restored from __doc__
文件讲述符 “”” fileno() -> integer “file descriptor”. This is needed
for lower-level file interfaces, such os.read(). “”” return 0 def
flush(self): # real signature unknown; restored from __doc__
刷新文件内部缓冲区 “”” flush() -> None. Flush the internal I/O
buffer. “”” pass def isatty(self): # real signature unknown; restored
from __doc__ 判断文件是或不是是同意tty设备 “”” isatty() -> true or
false. True if the file is connected to a tty device. “”” return False
def next(self): # real signature unknown; restored from __doc__
获取下一行数据,不存在,则报错 “”” x.next() -> the next value, or
raise StopIteration “”” pass def read(self, size=None): # real
signature unknown; restored from __doc__ 读取钦命字节数据 “””
read([size]) -> read at most size bytes, returned as a string. If
the size argument is negative or omitted, read until EOF is reached.
Notice that when in non-blocking mode, less data than what was requested
may be returned, even if no size parameter was given. “”” pass def
readinto(self): # real signature unknown; restored from __doc__
读取到缓冲区,不要用,将被扬弃 “”” readinto() -> Undocumented. Don’t
use this; it may go away. “”” pass def readline(self, size=None): #
real signature unknown; restored from __doc__ 仅读取一行数据 “””
readline([size]) -> next line from the file, as a string. Retain
newline. A non-negative size argument limits the maximum number of bytes
to return (an incomplete line may be returned then). Return an empty
string at EOF. “”” pass def readlines(self, size=None): # real
signature unknown; restored from __doc__
读取全数数据,并依照换行保存值列表 “”” readlines([size]) -> list of
strings, each a line from the file. Call readline() repeatedly and
return a list of the lines so read. The optional size argument, if
given, is an approximate bound on the total number of bytes in the lines
returned. “”” return [] def seek(self, offset, whence=None): # real
signature unknown; restored from __doc__ 钦定文件中指针地点 “””
seek(offset[, whence]) -> None. Move to new file position. Argument
offset is a byte count. Optional argument whence defaults to (offset
from start of file, offset should be >= 0); other values are 1 (move
relative to current position, positive or negative), and 2 (move
relative to end of file, usually negative, although many platforms allow
seeking beyond the end of a file). If the file is opened in text mode,
only offsets returned by tell() are legal. Use of other offsets causes
undefined behavior. Note that not all file objects are seekable. “””
pass def tell(self): # real signature unknown; restored from
__doc__ 获取当前线指挥部针地点 “”” tell() -> current file position, an
integer (may be a long integer). “”” pass def truncate(self, size=None):
# real signature unknown; restored from __doc__
截断数据,仅保留钦命此前数据 “”” truncate([size]) -> None. Truncate
the file to at most size bytes. Size defaults to the current file
position, as returned by tell(). “”” pass def write(self, p_str): #
real signature unknown; restored from __doc__ 写内容 “”” write(str)
-> None. Write string str to file. Note that due to buffering,
flush() or close() may be needed before the file on disk reflects the
data written. “”” pass def writelines(self, sequence_of_strings): #
real signature unknown; restored from __doc__
将3个字符串列表写入文件 “”” writelines(sequence_of_strings) ->
None. Write the strings to the file. Note that newlines are not added.
The sequence can be any iterable object producing strings. This is
equivalent to calling write() for each string. “”” pass def
xreadlines(self): # real signature unknown; restored from __doc__
可用于逐行读取文件,非全体 “”” xreadlines() -> returns self. For
backward compatibility. File objects now include the performance
optimizations previously implemented in the xreadlines module. “”” pass
2.x
永利网上娱乐 12class
TextIOWrapper(_TextIOBase): “”” Character and line based layer over a
BufferedIOBase object, buffer. encoding gives the name of the encoding
that the stream will be decoded or encoded with. It defaults to
locale.getpreferredencoding(False). errors determines the strictness of
encoding and decoding (see help(codecs.Codec) or the documentation for
codecs.register) and defaults to “strict”. newline controls how line
endings are handled. It can be None, ”, ‘\n’, ‘\r’, and ‘\r\n’. It
works as follows: * On input, if newline is None, universal newlines
mode is enabled. Lines in the input can end in ‘\n’, ‘\r’, or
‘\r\n’, and these are translated into ‘\n’ before being returned to
the caller. If it is ”, universal newline mode is enabled, but line
endings are returned to the caller untranslated. If it has any of the
other legal values, input lines are only terminated by the given string,
and the line ending is returned to the caller untranslated. * On
output, if newline is None, any ‘\n’ characters written are translated
to the system default line separator, os.linesep. If newline is ” or
‘\n’, no translation takes place. If newline is any of the other legal
values, any ‘\n’ characters written are translated to the given string.
If line_buffering is True, a call to flush is implied when a call to
write contains a newline character. “”” def close(self, *args,
**kwargs): # real signature unknown 关闭文件 pass def fileno(self,
*args, **kwargs): # real signature unknown 文件讲述符 pass def
flush(self, *args, **kwargs): # real signature unknown
刷新文件之中缓冲区 pass def isatty(self, *args, **kwargs): # real
signature unknown 判断文件是或不是是同意tty设备 pass def read(self, *args,
**kwargs): # real signature unknown 读取钦赐字节数据 pass def
readable(self, *args, **kwargs): # real signature unknown 是不是可读
pass def readline(self, *args, **kwargs): # real signature unknown
仅读取一行数据 pass def seek(self, *args, **kwargs): # real
signature unknown 内定文件中指针地方 pass def seekable(self, *args,
**kwargs): # real signature unknown 指针是或不是可操作 pass def
tell(self, *args, **kwargs): # real signature unknown 获取指针位置pass def truncate(self, *args, **kwargs): # real signature unknown
截断数据,仅保留钦点以前数据 pass def writable(self, *args,
**kwargs): # real signature unknown 是还是不是可写 pass def write(self,
*args, **kwargs): # real signature unknown 写内容 pass def
__getstate__(self, *args, **kwargs): # real signature unknown
pass def __init__(self, *args, **kwargs): # real signature
unknown pass @staticmethod # known case of __new__ def
__new__(*args, **kwargs): # real signature unknown “”” Create
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

###### 从一文件挨行读取并写入二文件 #########

with open('test.log','r') as obj1 , open('test1.log','w') as obj2:
    for line in obj1:
        obj2.write(line)

 

三元运算

春节初中一年级运算(三目运算),是对简易的尺度语句的缩写。

result = 值1 if 条件 else 值2

# 如果条件成立,那么将 “值1” 赋值给result变量,否则,将“值2”赋值给result变量

########## 三 元 运 算 ############
name = "nick" if 1==1 else "jenny"
print(name)

  

lambda表达式

对于简易的函数,存在一种方便人民群众的表示方法,即:lambda表明式

######## 普 通 函 数 ########
# 定义函数(普通方式)
def func(arg):
    return arg + 1
    
# 执行函数
result = func(123)
    
######## lambda 表 达 式 ########
    
# 定义函数(lambda表达式)
my_lambda = lambda arg : arg + 1
    
# 执行函数
result = my_lambda(123)

  

递归

 

递归算法是一种直接或许直接地调用本身算法的长河。在计算机编写程序中,递归算法对消除一大类难点是丰盛立竿见影的,它往往使算法的讲述简洁而且便于明白。
  递归算法化解难题的特色:

  • 递归正是在经过或函数里调用本人。
  • 在利用递归策略时,必须有3个可想而知的递归纳束条件,称为递归出口。
  • 递归算法解题平时展现很简短,但递归算法解题的运转功用较低。所以一般不提倡用递归算法设计程序。
  • 在递归调用的进度当中系统为每一层的归来点、局地量等开发了栈来存款和储蓄。递归次数过多简单造成栈溢出等。所以一般不提倡用递归算法设计程序。

应用函数编写如下数列:

斐波那契数列指的是如此一个数列 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)

#写函数,利用递归获取斐波那契数列中的第 10 个数

def fie(n):
    if n == 0 or n == 1:
        return n
    else:
        return (fie(n-1)+fie(n-2))
set = fie(10)
print(set)

  

 

http://www.bkjia.com/Pythonjc/1125040.htmlwww.bkjia.comtruehttp://www.bkjia.com/Pythonjc/1125040.htmlTechArticlePython基础(三),python基础 本章内容: 深浅拷贝
函数(全局与局地变量) 文件处理 伊利运算 lambda 表明式
递归(斐波那契数列) 深浅拷…

列表是大家最今后最常用的数据类型之一,通过列表能够对数据完结最方便的仓库储存、修改等操作

概念列表

names = [‘Alex’,”Tenglan”,’Eric’]

经过下标访问列表中的成分,下标从0开头计数

>>> names[0]
'Alex'
>>> names[2]
'Eric'
>>> names[-1]
'Eric'
>>> names[-2] #还可以倒着取
'Tenglan'

 

切开:取三个因素  

>>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]

>>> names[1:4]  #取下标1至下标4之间的数字,包括1,不包括4

['Tenglan', 'Eric', 'Rain']

>>> names[1:-1] #取下标1至-1的值,不包括-1

['Tenglan', 'Eric', 'Rain', 'Tom']

>>> names[0:3] 

['Alex', 'Tenglan', 'Eric']

>>> names[:3] #如果是从头开始取,0可以忽略,跟上句效果一样

['Alex', 'Tenglan', 'Eric']

>>> names[3:] #如果想取最后一个,必须不能写-1,只能这么写

['Rain', 'Tom', 'Amy'] 

>>> names[3:-1] #这样-1就不会被包含了

['Rain', 'Tom']

>>> names[0::2] #后面的2是代表,每隔一个元素,就取一个

['Alex', 'Eric', 'Tom'] 

>>> names[::2] #和上句效果一样

['Alex', 'Eric', 'Tom']

追加

>>> names

['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']

>>> names.append("我是新来的")

>>> names

['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

插入

>>> names

['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

>>> names.insert(2,"强行从Eric前面插入")

>>> names

['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

 

>>> names.insert(5,"从eric后面插入试试新姿势")

>>> names

['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

修改

>>> names

['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

>>> names[2] = "该换人了"

>>> names

['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

删除

>>> del names[2] 

>>> names

['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

>>> del names[4]

>>> names

['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

>>> 

>>> names.remove("Eric") #删除指定元素

>>> names

['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']

>>> names.pop() #删除列表最后一个值 

'我是新来的'

>>> names

['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']

扩展

>>> names

['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']

>>> b = [1,2,3]

>>> names.extend(b)

>>> names

['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

拷贝

>>> names

['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

 

>>> name_copy = names.copy()

>>> name_copy

['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

 

统计

>>> names

['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]

>>> names.count("Amy")

2

排序&翻转

>>> names

['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]

>>> names.sort() #排序

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了,擦

>>> names[-3] = '1'

>>> names[-2] = '2'

>>> names[-1] = '3'

>>> names

['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '1', '2', '3']

>>> names.sort()

>>> names

['1', '2', '3', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

 

>>> names.reverse() #反转

>>> names

['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']

 

获取下标

>>> names

['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']

>>> names.index("Amy")

2 #只返回找到的第一个下标

元组

元组其实跟列表大概,也是存一组数,只不是它一旦创设,便不可能再修改,所以又叫只读列表

语法

names = ("alex","jack","eric")

2. 字符串操作   

特征:不可修改 

 

name.capitalize()  首字母大写

name.casefold()   大写全体变小写

name.center(50,”-“)  输出 ‘———————Alex
Li———————-‘

name.count(‘lex’) 计算 lex出现次数

name.encode()  将字符串编码成bytes格式

name.endswith(“Li”)  判断字符串是或不是以 Li结尾

 “Alex\tLi”.expandtabs(10) 输出’Alex      Li’, 将\t转换到多长的空格

 name.find(‘A’)  查找A,找到重回其索引, 找不到重临-1

 

format :

    >>> msg = "my name is {}, and age is {}"

    >>> msg.format("alex",22)

    'my name is alex, and age is 22'

    >>> msg = "my name is {1}, and age is {0}"

    >>> msg.format("alex",22)

    'my name is 22, and age is alex'

    >>> msg = "my name is {name}, and age is {age}"

    >>> msg.format(age=22,name="ale")

    'my name is ale, and age is 22'

format_map

    >>> msg.format_map({'name':'alex','age':22})

    'my name is alex, and age is 22'

 

 

msg.index(‘a’)  再次回到a所在字符串的目录

‘9aA’.isalnum()   True

 

‘9’.isdigit() 是还是不是整数

name.isnumeric 

name.isprintable

name.isspace

name.istitle

name.isupper

 “|”.join([‘alex’,’jack’,’rain’])

‘alex|jack|rain’

 

 

maketrans

    >>> intab = "aeiou"  #This is the string having actual characters. 

    >>> outtab = "12345" #This is the string having corresponding mapping character

    >>> trantab = str.maketrans(intab, outtab)

    >>> 

    >>> str = "this is string example....wow!!!"

    >>> str.translate(trantab)

    'th3s 3s str3ng 2x1mpl2....w4w!!!'

 

 msg.partition('is')   输出 ('my name ', 'is', ' {name}, and age is {age}') 

 

 >>> "alex li, chinese name is lijie".replace("li","LI",1)

     'alex LI, chinese name is lijie'

 

 msg.swapcase 大小写互换

 

 

 >>> msg.zfill(40)

'00000my name is {name}, and age is {age}'

 

 

 

>>> n4.ljust(40,"-")

'Hello 2orld-----------------------------'

>>> n4.rjust(40,"-")

'-----------------------------Hello 2orld'

 

 

>>> b="ddefdsdff_哈哈" 

>>> b.isidentifier() #检测一段字符串可否被当作标志符,即是否符合变量命名规则

True

 

3. 字典操作

字典一种key – value
的数据类型,使用就好像大家学习用的字典,通过笔划、字母来核查应页的详实内容。

语法:

info = {

    'stu1101': "TengLan Wu",

    'stu1102': "LongZe Luola",

    'stu1103': "XiaoZe Maliya",

}

字典的风味:

  • dict是冬日,冬辰的
  • key必须是唯一的,so 天生去重
    • 增加

 

>>> info["stu1104"] = "苍井空"

>>> info

{'stu1102': 'LongZe Luola', 'stu1104': '苍井空', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'}

修改

 

>>> info['stu1101'] = "武藤兰"

>>> info

{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}

删除

>>> info

{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}

>>> info.pop("stu1101") #标准删除姿势

'武藤兰'

>>> info

{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}

>>> del info['stu1103'] #换个姿势删除

>>> info

{'stu1102': 'LongZe Luola'}

>>> 

>>> 

>>> 

>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}

>>> info

{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随机删除

>>> info.popitem()

('stu1102', 'LongZe Luola')

>>> info

{'stu1103': 'XiaoZe Maliya'}

查找

>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}

>>> 

>>> "stu1102" in info #标准用法

True

>>> info.get("stu1102")  #获取

'LongZe Luola'

>>> info["stu1102"] #同上,但是看下面

'LongZe Luola'

>>> info["stu1105"]  #如果一个key不存在,就报错,get不会,不存在只返回None

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 'stu1105'

不可计数字典嵌套及操作

av_catalog = {

    "欧美":{

        "www.youporn.com": ["很多免费的,世界最大的","质量一般"],

        "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],

        "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],

        "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]

    },

    "日韩":{

        "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]

    },

    "大陆":{

        "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]

    }

}

 

av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来"

print(av_catalog["大陆"]["1024"])

#ouput 

['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

别的姿势

 

 

#values

>>> info.values()

dict_values(['LongZe Luola', 'XiaoZe Maliya'])

 

#keys

>>> info.keys()

dict_keys(['stu1102', 'stu1103'])

 

 

#setdefault

>>> info.setdefault("stu1106","Alex")

'Alex'

>>> info

{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

>>> info.setdefault("stu1102","龙泽萝拉")

'LongZe Luola'

>>> info

{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

 

 

#update 

>>> info

{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

>>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}

>>> info.update(b)

>>> info  #值可以不唯一

{'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

 

#items

info.items()

dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])

 

 

#通过一个列表生成默认dict,有个没办法解释的坑,少用吧这个

>>> dict.fromkeys([1,2,3],'testd')

{1: 'testd', 2: 'testd', 3: 'testd'}

循环dict 

 

#方法1

for key in info:

    print(key,info[key])

 

#方法2

for k,v in info.items(): #会先把dict转成list,数据里大时莫用

    print(k,v)

程序练习

次第: 三级菜单

要求: 

  1. 打字与印刷省、市、县三级菜单
  2. 可重回上一级
  3. 可随时退出程序

 

menu = {

    ‘北京’:{

        ‘海淀’:{

            ‘五道口’:{

                ‘soho’:{},

                ‘网易’:{},

                ‘google’:{}

            },

            ‘中关村’:{

                ‘爱奇艺’:{},

                ‘小车之家’:{},

                ‘youku’:{},

            },

            ‘上地’:{

                ‘百度’:{},

            },

        },

        ‘昌平’:{

            ‘沙河’:{

                ‘老男孩’:{},

                ‘北航’:{},

            },

            ‘天通苑’:{},

            ‘回龙观’:{},

        },

        ‘朝阳’:{},

        ‘东城’:{},

    },

    ‘上海’:{

        ‘闵行’:{

            “人民广场”:{

                ‘炸鸡店’:{}

            }

        },

        ‘闸北’:{

            ‘火车战’:{

                ‘携程’:{}

            }

        },

        ‘浦东’:{},

    },

    ‘山东’:{},

}

 

 

exit_flag = False

current_layer = menu

 

layers = [menu]

 

while not  exit_flag:

    for k in current_layer:

        print(k)

    choice = input(“>>:”).strip()

    if choice == “b”:

        current_layer = layers[-1]

        #print(“change to laster”, current_layer)

        layers.pop()

    elif choice not  in current_layer:continue

    else:

        layers.append(current_layer)

        current_layer = current_layer[choice]

4.汇集操作

晤面是三个冬天的,不重复的数据整合,它的要紧成效如下:

  • 去重,把1个列表变成集合,就活动去重了
  • 关联测试,测试两组数据以前的混杂、差集、并集等涉及

常用操作

 

s = set([3,5,9,10])      #创建一个数值集合  

  

t = set("Hello")         #创建一个唯一字符的集合  

 

a = t | s          # t 和 s的并集  

  

b = t & s          # t 和 s的交集  

  

c = t – s          # 求差集(项在t中,但不在s中)  

  

d = t ^ s          # 对称差集(项在t或s中,但不会同时出现在二者中)  

  

基本操作: 

  

t.add('x')            # 添加一项  

  

s.update([10,37,42])  # 在s中添加多项  

  

   

  

使用remove()可以删除一项:  

  

t.remove('H')  

  

  

len(s)  

set 的长度  

  

x in s  

测试 x 是否是 s 的成员  

  

x not in s  

测试 x 是否不是 s 的成员  

  

s.issubset(t)  

s <= t  

测试是否 s 中的每一个元素都在 t 中  

  

s.issuperset(t)  

s >= t  

测试是否 t 中的每一个元素都在 s 中  

  

s.union(t)  

s | t  

返回一个新的 set 包含 s 和 t 中的每一个元素  

  

s.intersection(t)  

s & t  

返回一个新的 set 包含 s 和 t 中的公共元素  

  

s.difference(t)  

s - t  

返回一个新的 set 包含 s 中有但是 t 中没有的元素  

  

s.symmetric_difference(t)  

s ^ t  

返回一个新的 set 包含 s 和 t 中不重复的元素  

  

s.copy()  

返回 set “s”的一个浅复制  

5.文本操作

对文本操作流程

  1. 开辟文件,获得文件句柄并赋值给八个变量
  2. 透过句柄对文件进行操作
  3. 闭馆文件 

幸存文件如下 

Somehow, it seems the love I knew was always the most destructive kind

不知为何,我经历的爱情总是最具毁灭性的的那种

Yesterday when I was young

昨日当我年少轻狂

The taste of life was sweet

生命的滋味是甜的

As rain upon my tongue

就如舌尖上的雨露

I teased at life as if it were a foolish game

我戏弄生命 视其为愚蠢的游戏

The way the evening breeze

就如夜晚的微风

May tease the candle flame

逗弄蜡烛的火苗

The thousand dreams I dreamed

我曾千万次梦见

The splendid things I planned

那些我计划的绚丽蓝图

I always built to last on weak and shifting sand

但我总是将之建筑在易逝的流沙上

I lived by night and shunned the naked light of day

我夜夜笙歌 逃避白昼赤裸的阳光

And only now I see how the time ran away

事到如今我才看清岁月是如何匆匆流逝

Yesterday when I was young

昨日当我年少轻狂

So many lovely songs were waiting to be sung

有那么多甜美的曲儿等我歌唱

So many wild pleasures lay in store for me

有那么多肆意的快乐等我享受

And so much pain my eyes refused to see

还有那么多痛苦 我的双眼却视而不见

I ran so fast that time and youth at last ran out

我飞快地奔走 最终时光与青春消逝殆尽

I never stopped to think what life was all about

我从未停下脚步去思考生命的意义

And every conversation that I can now recall

如今回想起的所有对话

Concerned itself with me and nothing else at all

除了和我相关的 什么都记不得了

The game of love I played with arrogance and pride

我用自负和傲慢玩着爱情的游戏

And every flame I lit too quickly, quickly died

所有我点燃的火焰都熄灭得太快

The friends I made all somehow seemed to slip away

所有我交的朋友似乎都不知不觉地离开了

And only now I'm left alone to end the play, yeah

只剩我一个人在台上来结束这场闹剧

Oh, yesterday when I was young

噢 昨日当我年少轻狂

So many, many songs were waiting to be sung

有那么那么多甜美的曲儿等我歌唱

So many wild pleasures lay in store for me

有那么多肆意的快乐等我享受

And so much pain my eyes refused to see

还有那么多痛苦 我的双眼却视而不见

There are so many songs in me that won't be sung

我有太多歌曲永远不会被唱起

I feel the bitter taste of tears upon my tongue

我尝到了舌尖泪水的苦涩滋味

The time has come for me to pay for yesterday

终于到了付出代价的时间 为了昨日

When I was young

当我年少轻狂

 

基本操作  

f = open(‘lyrics’) #开拓文件

first_line = f.readline()

print(‘first line:’,first_line) #读一行

print(‘小编是分隔线’.center(50,’-‘))

data = f.read()# 读取剩下的富有剧情,文件大时不要用

print(data) #打字与印刷文件

 

f.close() #关闭文件

开拓文件的情势有:

  • r,只读方式(私下认可)。
  • w,只写情势。【不可读;不存在则开创;存在则删除内容;】
  • a,追加方式。【可读;   不存在则开创;存在则只扩充内容;】

“+” 表示能够同时读写有些文件

  • r+,可读写文件。【可读;可写;可扩张】
  • w+,写读
  • a+,同a

“U”表示在读取时,可以将 \r \n \r\n自动转换到 \n (与 r 或 r+
形式同使用)

  • rU
  • r+U

“b”表示处理二进制文件(如:FTP发送上传ISO镜像文件,linux可忽略,windows处理二进制文件时需标注)

  • rb
  • wb
  • ab

其他语法

 

    def close(self): # real signature unknown; restored from
__doc__

        “””

        Close the file.

       

        A closed file cannot be used for further I/O operations. 
close() may be

        called more than once without error.

        “””

        pass

 

    def fileno(self, *args, **kwargs): # real signature unknown

        “”” Return the underlying file descriptor (an integer). “””

        pass

 

    def isatty(self, *args, **kwargs): # real signature unknown

        “”” True if the file is connected to a TTY device. “””

        pass

 

    def read(self, size=-1): # known case of _io.FileIO.read

        “””

        注意,不自然能全读回来

        Read at most size bytes, returned as bytes.

       

        Only makes one system call, so less data may be returned than
requested.

        In non-blocking mode, returns None if no data is available.

        Return an empty bytes object at EOF.

        “””

        return “”

 

    def readable(self, *args, **kwargs): # real signature unknown

        “”” True if file was opened in a read mode. “””

        pass

 

    def readall(self, *args, **kwargs): # real signature unknown

        “””

        Read all data from the file, returned as bytes.

       

        In non-blocking mode, returns as much as is immediately
available,

        or None if no data is available.  Return an empty bytes object
at EOF.

        “””

        pass

 

    def readinto(self): # real signature unknown; restored from
__doc__

        “”” Same as RawIOBase.readinto(). “””

        pass #毫不用,没人知道它是干嘛用的

 

    def seek(self, *args, **kwargs): # real signature unknown

        “””

        Move to new file position and return the file position.

       

        Argument offset is a byte count.  Optional argument whence
defaults to

        SEEK_SET or 0 (offset from start of file, offset should be
>= 0); other values

        are SEEK_CUR or 1 (move relative to current position, positive
or negative),

        and SEEK_END or 2 (move relative to end of file, usually
negative, although

        many platforms allow seeking beyond the end of a file).

       

        Note that not all file objects are seekable.

        “””

        pass

 

    def seekable(self, *args, **kwargs): # real signature unknown

        “”” True if file supports random-access. “””

        pass

 

    def tell(self, *args, **kwargs): # real signature unknown

        “””

        Current file position.

       

        Can raise OSError for non seekable files.

        “””

        pass

 

    def truncate(self, *args, **kwargs): # real signature unknown

        “””

        Truncate the file to at most size bytes and return the truncated
size.

       

        Size defaults to the current file position, as returned by
tell().

        The current file position is changed to the value of size.

        “””

        pass

 

    def writable(self, *args, **kwargs): # real signature unknown

        “”” True if file was opened in a write mode. “””

        pass

 

    def write(self, *args, **kwargs): # real signature unknown

        “””

        Write bytes b to file, return number written.

       

        Only makes one system call, so not all of the data may be
written.

        The number of bytes actually written is returned.  In
non-blocking mode,

        returns None if the write would block.

        “””

        pass

with语句

为了防止打开文件后忘记关闭,能够透过管住上下文,即:

with open(‘log’,’r’) as f:

     

    …

那般方法,当with代码块执行达成时,内部会活动关闭并释放文件能源。

在Python 2.7 后,with又援救同时对五个文件的上下文实行管理,即:

with open(‘log1’) as obj1, open(‘log2’) as obj2:

    pass

程序练习  

程序1: 达成简单的shell sed替换功用

先后2:修改haproxy配置文件 

需求:

 

1、查

    输入:www.oldboy.org

    获取当前backend下的拥有记录

 

2、新建

    输入:

        arg = {

            ‘bakend’: ‘www.oldboy.org’,

            ‘record’:{

                ‘server’: ‘100.1.7.9’,

                ‘weight’: 20,

                ‘maxconn’: 30

            }

        }

 

3、删除

    输入:

        arg = {

            ‘bakend’: ‘www.oldboy.org’,

            ‘record’:{

                ‘server’: ‘100.1.7.9’,

                ‘weight’: 20,

                ‘maxconn’: 30

            }

        }

 

global      

        log 127.0.0.1 local2

        daemon

        maxconn 256

        log 127.0.0.1 local2 info

defaults

        log global

        mode http

        timeout connect 5000ms

        timeout client 50000ms

        timeout server 50000ms

        option  dontlognull

 

listen stats :8888

        stats enable

        stats uri       /admin

        stats auth      admin:1234

 

frontend oldboy.org

        bind 0.0.0.0:80

        option httplog

        option httpclose

        option  forwardfor

        log global

        acl www hdr_reg(host) -i www.oldboy.org

        use_backend www.oldboy.org if www

 

backend www.oldboy.org

        server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000

6. 字符编码与转码

 

需知:

1.在python2暗中认可编码是ASCII, python3里暗中同意是unicode

2.unicode 分成
utf-32(占多少个字节),utf-16(占七个字节),utf-8(占1-陆个字节), so
utf-16便是当今最常用的unicode版本,
但是在文书里存的依旧utf-8,因为utf8省空中

3.在py3中encode,在转码的同时还会把string
变成bytes类型,decode在解码的还要还会把bytes变回string

 永利网上娱乐 13

 

上海教室仅适用于py2

 

 

 

#-*-coding:utf-8-*-

__author__ = ‘Alex Li’

 

import sys

print(sys.getdefaultencoding())

 

 

msg = “小编爱东京大明门”

msg_gb2312 = msg.decode(“utf-8”).encode(“gb2312”)

gb2312_to_gbk = msg_gb2312.decode(“gbk”).encode(“gbk”)

 

print(msg)

print(msg_gb2312)

print(gb2312_to_gbk)

 

 

 

#-*-coding:gb2312 -*-   #那些也可以去掉

__author__ = ‘Alex Li’

 

import sys

print(sys.getdefaultencoding())

 

 

msg = “笔者爱东京西安门”

#msg_gb2312 = msg.decode(“utf-8”).encode(“gb2312”)

msg_gb2312 = msg.encode(“gb2312”)
#私下认可就是unicode,不用再decode,喜大普奔

gb2312_to_unicode = msg_gb2312.decode(“gb2312”)

gb2312_to_utf8 = msg_gb2312.decode(“gb2312”).encode(“utf-8”)

 

print(msg)

print(msg_gb2312)

print(gb2312_to_unicode)

print(gb2312_to_utf8)

 

 

 

 

相关文章