Python装饰器详解

采菊篱下 发表了文章 • 0 个评论 • 694 次浏览 • 2016-08-18 23:11 • 来自相关话题

装饰器

定义:本质就是函数,(装饰其他函数)就是为其他函数添加额外的功能;
遵循的原则:1、不能修改其被装饰函数的源代码    2、不能修改其被装饰函数的调用方式
 
实现装饰器需要用到的知识点:
函数即"变量"高阶函数嵌套函数
如果你对装饰器实现的如上三个知识点理解了的话,那你就完全可以理解装饰器了,图示如下:




下面我们就把装饰器的知识分解一个一个来理解。
 
1、函数即"变量"
让我们来看一下几个例子,来说明函数即变量
函数的错误调用案例,跟变量一样,还没有定义就调用:
# 错误调用方式一:
def foo():
print('in the foo!')
bar()

foo()
# 输出
NameError: name 'bar' is not defined (因为在调用foo函数执行的时候函数体内又调用了bar函数,但是bar函数并没有定义)

# 错误调用方式二:
def foo():
print('in the foo!')
bar()

foo()

def bar():
print('in the bar!')

# 输出
NameError: name 'bar' is not defined (同上面,不同的是虽然你在下面定义了bar函数,但是在调用之后才定义的.)从上面的例子可以看出,函数的定义和调用,其实是跟变量是一样的,变量在没有定义之前你对变量进行操作也是会报变量没有被定义的错误。
 
正确的调用方式如下:
# 错误调用方式二:
def foo():
print('in the foo!')
bar()

def bar():
print('in the bar!')

foo()

# 输出
in the foo!
in the bar!具体说明我们可以结合定义变量图示说明,我们把整个内存看作是一个大楼,把变量看做是门牌号,而变量真正存在的值看做是房间里面的东西,房间就相当于是大内存中的一小块内存块,图示如下:




如图所示我们可以看出函数def下定义的函数名就相当于变量的变量名,而函数体就相当于变量的值;所以函数的执行跟调用变量是一样的,只有在你执行之前所有的函数已经声明,占用了内存地址才可以执行,否则在你执行之前未定义,而会报错。
 
函数和变量一样,如果你已经定义好了,就会从内存中划分出一块内存空间存储进行存储,那什么时候回收这个内存空间呢?1、当你整个程序执行完成后,你所定义的变量或者函数占用的内存空间就会被释放  2、就是你利用del()内置函数的删除方法,把变量名和函数名删除,然后Python的内存回收机制发现这块内存空间没有被引用了,就把这块没有被引用的内存空间回收了。
 
2、高阶函数
高阶函数定义:
把一个函数名当做实参传给另外一个函数当做形参返回值(return)中包含函数名
只要满足以上其中一个条件就称为高阶函数。
 
首先我们看一个高阶函数的例子:
def foo(func):
print('in the foo!')
print(func)
func()


def bar():
print('in the bar!')

foo(bar)

结果:
in the foo!
<function bar at 0x10ba280d0> # 打印了函数bar的内存地址
in the bar!如上是一个符号传递函数名的一个高阶函数的例子。
 
下面我们利用高阶函数来做一个不改变被装饰函数代码,为被装饰函数添加一个新功能,我们这里添加一个程序运行时间的功能。
 
把一个函数名当做实参传给另外一个函数(没有改变函数的代码,添加了一个功能,但是运行方法改变了)
import time
def foo(func):
print('in the foo!')
start_time = time.time()
func()
stop_time = time.time()
print("func run time is %s" % (stop_time - start_time))


def bar():
time.sleep(2)
print('in the bar!')

foo(bar)

# 结果如下:
in the foo!
in the bar!
func run time is 2.002309799194336如上代码把bar函数当做一个实参,传给了foo函数当做形参,然后在里面运行了bar函数。
 
返回值中包含函数(虽然没有改变函数运行方式,但是好像功能没有加上)
import time
def foo(func):
print(func)
return func


def bar():
time.sleep(2)
print('in the bar!')

bar = foo(bar)
bar()

# 结果为:
<function bar at 0x10b0110d0>
in the bar!好像都并没有什么卵用,但是你应该发现了,我可以做到不改变函数调用方式和增加功能,但是单独利用高阶函数,这两个条件同事满足是做不到的,因为还需要结合嵌套函数才行。
 
3、嵌套函数
定义:在一个函数体内创建另外一个函数,这种函数就叫内嵌函数(基于python支持静态嵌套域)
 
函数嵌套示范:def foo():
print('in the foo')
def bar():
print('in the bar')

bar()

foo()这就是一个最简单的一个嵌套函数,一个函数下,再定义另外一个函数。
 
局部作用域和全局作用域的访问顺序:x = 0
def grandpa():
x = 1
def dad():
x = 2
def son():
x = 3
print(x) # 打印出来为3
son()
dad()
grandpa()

print(x) # 这个还是0结果是 3, 0,过程如图所示:




 
闭包:
如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是 closuredef counter(start_num=0):
count=[start_num]
def incr():
count[0]+=1
return count[0]
return incr

print(counter())
print(counter()())
print(counter()())

c=counter()
print(c())
print(c())没看懂,先记录一下。
 
4、装饰器
讲了装饰器 = 高阶函数 + 嵌套函数,还是添加一个打印程序执行时间功能,例子如下:import time
def timer(func):
print("in the timer")
def foo():
start_time = time.time()
func()
stop_time = time.time()
print("fun run time is %s" % (stop_time - start_time))
return foo


def bar():
time.sleep(2)
print('in the bar')

bar = timer(bar)
bar()

# 结果

in the timer
in the bar
fun run time is 2.004901885986328如上代码所示,我们为了给bar函数增加一个计算他运行时间的功能,我们既没有改变他的运行方式bar(),也没有改变他的内部代码,功能,也实现了,这就是利用高阶函数 + 嵌套函数完成的一个简易版的装饰器,在python中为了简化方法,装饰函数可以直接利用@符号把装饰函数应用到被装饰函数的上,如下所示:
import time
def timer(func):
print("in the timer")
def foo():
start_time = time.time()
func()
stop_time = time.time()
print("fun run time is %s" % (stop_time - start_time))
return foo

@timer # @timer 相当于 bar = timer(bar)
def bar():
time.sleep(2)
print('in the bar')

# bar = timer(bar)
bar()

# 结果如下:
in the timer
in the bar
fun run time is 2.000408887863159如上可以看出来,结果是一样的,简易版的装饰器我们可以做出来了,那下面我们在深入一下,做一个高级版本的装饰器,那我们在熟悉如下几个知识点。
 
1、函数参数固定
def decor(func):
def wrapper(n):
print('starting')
func(n)
print('stopping')
return wrapper


def test(n):
print('in the test arg is %s' % n)

decor(test)('lucky')分解过程:




其实就是 decor(test)('lucky')   的过程你可以理解为  a = decor(test) = wrapper  然后在调用  a('lucky') = wrapper('lucky') 。
 
2、函数参数不固定
def decor(func):
def wrapper(*args, **kwargs):
print('starting')
func(*args, **kwargs)
print('stopping')
return wrapper


def test(n, x=1):
print('in the test n is %s, x is %s' % (n, x))

decor(test)('alex', x=2)

# 结果如下:
starting
in the test n is alex, x is 2
stopping
3、无参装饰器
import time
def decorator(func):
def wrapper(*args, **kwargs):
start = time.time()
func(*args, **kwargs)
stop = time.time()
print('run time is %s ' % (stop - start))
print('timeout')
return wrapper

@decorator
def test(list_test):
for i in list_test:
time.sleep(0.1)
print('-' * 20, i)

#decorator(test)(range(10))
test(range(10))
4、带参数的装饰器
import time
def timer(timeout=0):
def decorator(func):
def wrapper(*args, **kwargs):
start=time.time()
func(*args, **kwargs)
stop=time.time()
print('run time is %s ' %(stop-start))
print(timeout)
return wrapper
return decorator

@timer(2)
def test(list_test):
for i in list_test:
time.sleep(0.1)
print('-'*20, i)

# timer(timeout=2)(test)(range(10)) timer(timeout=2) = decorator timer(timeout=2)(test) = decorator(test) = wrapper
# timer(timeout=2)(test)(range(10)) = decorator(test)(range(10)) = wrapper(range(10))
test(range(10))
高级版装饰器:
user, passwd = 'lucky', 'abc123'

def auth(auth_type):
print("auth func:", auth_type)
def outer_wrapper(func):
def wrapper(*args, **kwargs):
print("wrapper func args:", *args, **kwargs)
if auth_type == "local":
username = input("Username:").strip()
password = input("Password:").strip()
if user == username and passwd == password:
print("\033[32mUser has passwed authentication\033[0m")
res = func(*args, **kwargs) # from home
print("---after authenticaion")
return res
else:
exit("\033[31mInvalid username or passwd\033[0m")
elif auth_type == "ldap":
print("\033[33m不会ldap,搞毛线啊!\033[0m")
return wrapper
return outer_wrapper

@auth(auth_type="ldap")
def bbs():
print("welcome to bbs page")

@auth(auth_type="local") # home = wrapper()
def home():
print("welcome to home page")
return "from home"

bbs()
home()
装饰器的应用:
装饰器功能:函数超时则终止
# -*- coding: utf-8 -*-
from threading import Thread
import time

class TimeoutException(Exception):
pass

ThreadStop = Thread._Thread__stop#获取私有函数

def timelimited(timeout):
def decorator(function):
def decorator2(*args,**kwargs):
class TimeLimited(Thread):
def __init__(self,_error= None,):
Thread.__init__(self)
self._error = _error

def run(self):
try:
self.result = function(*args,**kwargs)
except Exception,e:
self._error =e

def _stop(self):
if self.isAlive():
ThreadStop(self)

t = TimeLimited()
t.start()
t.join(timeout)

if isinstance(t._error,TimeoutException):
t._stop()
raise TimeoutException('timeout for %s' % (repr(function)))

if t.isAlive():
t._stop()
raise TimeoutException('timeout for %s' % (repr(function)))

if t._error is None:
return t.result

return decorator2
return decorator

@timelimited(2)
def fn_1(secs):
time.sleep(secs)
return 'Finished'

if __name__ == "__main__":
print fn_1(4) 查看全部


装饰器


定义:本质就是函数,(装饰其他函数)就是为其他函数添加额外的功能;
遵循的原则:1、不能修改其被装饰函数的源代码    2、不能修改其被装饰函数的调用方式
 
实现装饰器需要用到的知识点:
  1. 函数即"变量"
  2. 高阶函数
  3. 嵌套函数

如果你对装饰器实现的如上三个知识点理解了的话,那你就完全可以理解装饰器了,图示如下:
Decorator.png

下面我们就把装饰器的知识分解一个一个来理解。
 
1、函数即"变量"
让我们来看一下几个例子,来说明函数即变量
函数的错误调用案例,跟变量一样,还没有定义就调用:
# 错误调用方式一:
def foo():
print('in the foo!')
bar()

foo()
# 输出
NameError: name 'bar' is not defined (因为在调用foo函数执行的时候函数体内又调用了bar函数,但是bar函数并没有定义)

# 错误调用方式二:
def foo():
print('in the foo!')
bar()

foo()

def bar():
print('in the bar!')

# 输出
NameError: name 'bar' is not defined (同上面,不同的是虽然你在下面定义了bar函数,但是在调用之后才定义的.)
从上面的例子可以看出,函数的定义和调用,其实是跟变量是一样的,变量在没有定义之前你对变量进行操作也是会报变量没有被定义的错误。
 
正确的调用方式如下:
# 错误调用方式二:
def foo():
print('in the foo!')
bar()

def bar():
print('in the bar!')

foo()

# 输出
in the foo!
in the bar!
具体说明我们可以结合定义变量图示说明,我们把整个内存看作是一个大楼,把变量看做是门牌号,而变量真正存在的值看做是房间里面的东西,房间就相当于是大内存中的一小块内存块,图示如下:
funcvar.png

如图所示我们可以看出函数def下定义的函数名就相当于变量的变量名,而函数体就相当于变量的值;所以函数的执行跟调用变量是一样的,只有在你执行之前所有的函数已经声明,占用了内存地址才可以执行,否则在你执行之前未定义,而会报错。
 
函数和变量一样,如果你已经定义好了,就会从内存中划分出一块内存空间存储进行存储,那什么时候回收这个内存空间呢?1、当你整个程序执行完成后,你所定义的变量或者函数占用的内存空间就会被释放  2、就是你利用del()内置函数的删除方法,把变量名和函数名删除,然后Python的内存回收机制发现这块内存空间没有被引用了,就把这块没有被引用的内存空间回收了。
 
2、高阶函数
高阶函数定义:
  1. 把一个函数名当做实参传给另外一个函数当做形参
  2. 返回值(return)中包含函数名

只要满足以上其中一个条件就称为高阶函数。
 
首先我们看一个高阶函数的例子:
def foo(func):
print('in the foo!')
print(func)
func()


def bar():
print('in the bar!')

foo(bar)

结果:
in the foo!
<function bar at 0x10ba280d0> # 打印了函数bar的内存地址
in the bar!
如上是一个符号传递函数名的一个高阶函数的例子。
 
下面我们利用高阶函数来做一个不改变被装饰函数代码,为被装饰函数添加一个新功能,我们这里添加一个程序运行时间的功能。
 
把一个函数名当做实参传给另外一个函数(没有改变函数的代码,添加了一个功能,但是运行方法改变了)
import time
def foo(func):
print('in the foo!')
start_time = time.time()
func()
stop_time = time.time()
print("func run time is %s" % (stop_time - start_time))


def bar():
time.sleep(2)
print('in the bar!')

foo(bar)

# 结果如下:
in the foo!
in the bar!
func run time is 2.002309799194336
如上代码把bar函数当做一个实参,传给了foo函数当做形参,然后在里面运行了bar函数。
 
返回值中包含函数(虽然没有改变函数运行方式,但是好像功能没有加上)
import time
def foo(func):
print(func)
return func


def bar():
time.sleep(2)
print('in the bar!')

bar = foo(bar)
bar()

# 结果为:
<function bar at 0x10b0110d0>
in the bar!
好像都并没有什么卵用,但是你应该发现了,我可以做到不改变函数调用方式和增加功能,但是单独利用高阶函数,这两个条件同事满足是做不到的,因为还需要结合嵌套函数才行。
 
3、嵌套函数
定义:在一个函数体内创建另外一个函数,这种函数就叫内嵌函数(基于python支持静态嵌套域)
 
函数嵌套示范:
def foo():
print('in the foo')
def bar():
print('in the bar')

bar()

foo()
这就是一个最简单的一个嵌套函数,一个函数下,再定义另外一个函数。
 
局部作用域和全局作用域的访问顺序:
x = 0
def grandpa():
x = 1
def dad():
x = 2
def son():
x = 3
print(x) # 打印出来为3
son()
dad()
grandpa()

print(x) # 这个还是0
结果是 3, 0,过程如图所示:
sorted.png

 
闭包:
如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是 closure
def counter(start_num=0):
count=[start_num]
def incr():
count[0]+=1
return count[0]
return incr

print(counter())
print(counter()())
print(counter()())

c=counter()
print(c())
print(c())
没看懂,先记录一下。
 
4、装饰器
讲了装饰器 = 高阶函数 + 嵌套函数,还是添加一个打印程序执行时间功能,例子如下:
import time
def timer(func):
print("in the timer")
def foo():
start_time = time.time()
func()
stop_time = time.time()
print("fun run time is %s" % (stop_time - start_time))
return foo


def bar():
time.sleep(2)
print('in the bar')

bar = timer(bar)
bar()

# 结果

in the timer
in the bar
fun run time is 2.004901885986328
如上代码所示,我们为了给bar函数增加一个计算他运行时间的功能,我们既没有改变他的运行方式bar(),也没有改变他的内部代码,功能,也实现了,这就是利用高阶函数 + 嵌套函数完成的一个简易版的装饰器,在python中为了简化方法,装饰函数可以直接利用@符号把装饰函数应用到被装饰函数的上,如下所示:
import time
def timer(func):
print("in the timer")
def foo():
start_time = time.time()
func()
stop_time = time.time()
print("fun run time is %s" % (stop_time - start_time))
return foo

@timer # @timer 相当于 bar = timer(bar)
def bar():
time.sleep(2)
print('in the bar')

# bar = timer(bar)
bar()

# 结果如下:
in the timer
in the bar
fun run time is 2.000408887863159
如上可以看出来,结果是一样的,简易版的装饰器我们可以做出来了,那下面我们在深入一下,做一个高级版本的装饰器,那我们在熟悉如下几个知识点。
 
1、函数参数固定
def decor(func):
def wrapper(n):
print('starting')
func(n)
print('stopping')
return wrapper


def test(n):
print('in the test arg is %s' % n)

decor(test)('lucky')
分解过程:
argsfun.png

其实就是 decor(test)('lucky')   的过程你可以理解为  a = decor(test) = wrapper  然后在调用  a('lucky') = wrapper('lucky') 。
 
2、函数参数不固定
def decor(func):
def wrapper(*args, **kwargs):
print('starting')
func(*args, **kwargs)
print('stopping')
return wrapper


def test(n, x=1):
print('in the test n is %s, x is %s' % (n, x))

decor(test)('alex', x=2)

# 结果如下:
starting
in the test n is alex, x is 2
stopping

3、无参装饰器
import time
def decorator(func):
def wrapper(*args, **kwargs):
start = time.time()
func(*args, **kwargs)
stop = time.time()
print('run time is %s ' % (stop - start))
print('timeout')
return wrapper

@decorator
def test(list_test):
for i in list_test:
time.sleep(0.1)
print('-' * 20, i)

#decorator(test)(range(10))
test(range(10))

4、带参数的装饰器
import time
def timer(timeout=0):
def decorator(func):
def wrapper(*args, **kwargs):
start=time.time()
func(*args, **kwargs)
stop=time.time()
print('run time is %s ' %(stop-start))
print(timeout)
return wrapper
return decorator

@timer(2)
def test(list_test):
for i in list_test:
time.sleep(0.1)
print('-'*20, i)

# timer(timeout=2)(test)(range(10)) timer(timeout=2) = decorator timer(timeout=2)(test) = decorator(test) = wrapper
# timer(timeout=2)(test)(range(10)) = decorator(test)(range(10)) = wrapper(range(10))
test(range(10))

高级版装饰器:
user, passwd = 'lucky', 'abc123'

def auth(auth_type):
print("auth func:", auth_type)
def outer_wrapper(func):
def wrapper(*args, **kwargs):
print("wrapper func args:", *args, **kwargs)
if auth_type == "local":
username = input("Username:").strip()
password = input("Password:").strip()
if user == username and passwd == password:
print("\033[32mUser has passwed authentication\033[0m")
res = func(*args, **kwargs) # from home
print("---after authenticaion")
return res
else:
exit("\033[31mInvalid username or passwd\033[0m")
elif auth_type == "ldap":
print("\033[33m不会ldap,搞毛线啊!\033[0m")
return wrapper
return outer_wrapper

@auth(auth_type="ldap")
def bbs():
print("welcome to bbs page")

@auth(auth_type="local") # home = wrapper()
def home():
print("welcome to home page")
return "from home"

bbs()
home()

装饰器的应用:
装饰器功能:函数超时则终止
# -*- coding: utf-8 -*-  
from threading import Thread
import time

class TimeoutException(Exception):
pass

ThreadStop = Thread._Thread__stop#获取私有函数

def timelimited(timeout):
def decorator(function):
def decorator2(*args,**kwargs):
class TimeLimited(Thread):
def __init__(self,_error= None,):
Thread.__init__(self)
self._error = _error

def run(self):
try:
self.result = function(*args,**kwargs)
except Exception,e:
self._error =e

def _stop(self):
if self.isAlive():
ThreadStop(self)

t = TimeLimited()
t.start()
t.join(timeout)

if isinstance(t._error,TimeoutException):
t._stop()
raise TimeoutException('timeout for %s' % (repr(function)))

if t.isAlive():
t._stop()
raise TimeoutException('timeout for %s' % (repr(function)))

if t._error is None:
return t.result

return decorator2
return decorator

@timelimited(2)
def fn_1(secs):
time.sleep(secs)
return 'Finished'

if __name__ == "__main__":
print fn_1(4)

Python匿名函数和高阶函数

采菊篱下 发表了文章 • 0 个评论 • 452 次浏览 • 2016-08-17 23:23 • 来自相关话题

匿名函数

Lambda(Lambda expressions)表达式是用lambda关键字创建的匿名函数,Lambda函数可以用于任何需要函数对象的地方,在语法上,它们被局限于只能有一个单独的表达式,但是他可以跟其他内置函数map,reduce,filter等联合使用,更加便利和快捷的一些方法。
 
lambda 和if  else的三元运算一样,是为了简化函数定义,但是:
只能做简单的操作自动return
例子如下:
# 这段代码
def f(x, y):
return x + y
print(f(3, 4))

# 换成匿名函数
f = lambda x, y: x + y

print(f(3, 4))
效果是相同的结果都是7,lambda创建的函数和def创建的函数对应关系如图所示:




 
这看起来并没有什么卵用,但是它和其他内置函数搭配起来,具体联合使用请参考:http://openskill.cn/article/272 

高阶函数

变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。
 
满足下列条件之一就可成函数为高阶函数:
某一函数当做实参传入另一个函数中函数的返回值包含n个函数,n>0
 
先来看一个简单的例子:
def bar():
print 'in the bar'


def foo(func):
res=func()
return res

foo(bar)首先定义好函数bar和foo,然后执行foo的时候把bar函数当实参传递进去。 查看全部


匿名函数


Lambda(Lambda expressions)表达式是用lambda关键字创建的匿名函数,Lambda函数可以用于任何需要函数对象的地方,在语法上,它们被局限于只能有一个单独的表达式,但是他可以跟其他内置函数map,reduce,filter等联合使用,更加便利和快捷的一些方法。
 
lambda 和if  else的三元运算一样,是为了简化函数定义,但是:
  1. 只能做简单的操作
  2. 自动return

例子如下:
# 这段代码
def f(x, y):
return x + y
print(f(3, 4))

# 换成匿名函数
f = lambda x, y: x + y

print(f(3, 4))

效果是相同的结果都是7,lambda创建的函数和def创建的函数对应关系如图所示:
lambda.png

 
这看起来并没有什么卵用,但是它和其他内置函数搭配起来,具体联合使用请参考:http://openskill.cn/article/272 


高阶函数


变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。
 
满足下列条件之一就可成函数为高阶函数:
  1. 某一函数当做实参传入另一个函数中
  2. 函数的返回值包含n个函数,n>0

 
先来看一个简单的例子:
def bar():
print 'in the bar'


def foo(func):
res=func()
return res

foo(bar)
首先定义好函数bar和foo,然后执行foo的时候把bar函数当实参传递进去。

Python三元计算和深浅拷贝

采菊篱下 发表了文章 • 0 个评论 • 513 次浏览 • 2016-08-17 21:54 • 来自相关话题

三元计算

三元计算也称为三目计算,如名字表示的三元运算符需要三个操作数,语法为:
条件表达式?表达式1:表达式2。 or
var = 值1 if 条件 else 值2
说明:问号前面的位置是判断的条件,判断结果为bool型,为true时调用表达式1,为false时调用表达式2。
其逻辑为:如果为真执行第一个,否则执行第二个。
例子:
>>> a = 'xxoo'

>>> Re = 'xx' if a == 'xxoo' else 'oo'
>>> print(Re)
xx

>>> a = 'xx'
>>> Re = 'xx' if a == 'xxoo' else 'oo'
>>> print(Re)
oo如上结果你可以看成是如下代码的简写的例子:
a = 'xxoo'
if a == 'xxoo':
Re = 'xx'
else:
Re = 'oo'这样我想你就知道了!
 

深浅拷贝

深浅拷贝分为两部分,一部分是数字和字符串另一部分是列表、元组、字典等其他数据类型。
 
数字和字符串:
对于数字和字符串而言,赋值、浅拷贝和深拷贝无意义,因为他们的值永远都会指向同一个内存地址,他们就是内存地址的复用。
>>> import copy # 导入内置copy模块
>>> name = 'lucky' # 命名name变量
>>> id(name) # 查看name变量的内存地址
4426658624
>>>
>>> name1 = name # 赋值应用变量 name1
>>> id(name1) # 查看变量name1内存地址
4426658624
>>>
>>> name2 = copy.copy(name) # 浅copy name变量赋值给name2变量
>>> id(name2) # 查看name2变量内存地址
4426658624
>>>
>>> name3 = copy.deepcopy(name) # 深copy name变量复制给name2变量
>>> id(name3) # 查看name3变量的内存地址
4426658624
>>>
>>> print(name, name1, name2, name3) # 打印四个变量的值
lucky lucky lucky lucky如上结果可以看出,不管是直接引用还是深浅copy其最后的结果变量的内存地址都没有变,只是定义的方法不一样,如下图示:




 
其他数据类型:
对于字典、元祖、列表 而言,进行赋值、浅拷贝和深拷贝时,内存地址可能会发生相应的变化。
1、赋值
>>> num1 = {'n1': 1, 'n2': 2, 'n3': [3, 4]}
>>> num2 = num1
>>> print(id(num1), id(num2))
4424864840 4424864840
>>>
>>> num1['n1'] = 7
>>> print(id(num1), id(num2))
4424864840 4424864840
>>> print(num1, num2)
{'n2': 2, 'n3': [3, 4], 'n1': 7} {'n2': 2, 'n3': [3, 4], 'n1': 7}
>>>
>>> num1['n3'][0] = 9
>>> print(id(num1), id(num2))
4424864840 4424864840
>>> print(num1, num2)
{'n2': 2, 'n3': [9, 4], 'n1': 7} {'n2': 2, 'n3': [9, 4], 'n1': 7}
如上所示,不管怎么改变原始的info字典内容,哪怕是改变里面的列表元素值,而info2的内容随之变化,运维他们的引用的内存地址是一样的,图示如下:




 
2、浅拷贝
 
浅拷贝,在内存中只额外创建第一层数据,里面则是完全复制。
>>> num1 = {'n1': 1, 'n2': 2, 'n3': [3, 4]}
>>> num2 = num1.copy()
>>> print(id(num1), id(num2))
4426663432 4426602824

>>> print(id(num1['n1']), id(num2['n1']))
4423026704 4423026704
>>> print(id(num1['n3']), id(num2['n3']))
4427044168 4427044168
>>> print(id(num1['n3'][0]), id(num2['n3'][0]))
4423026768 4423026768
>>> num1['n3'][0] = 9
>>> print(id(num1), id(num2))
4426663432 4426602824
>>> print(num1, num2)
{'n2': 2, 'n3': [9, 4], 'n1': 1} {'n2': 2, 'n3': [9, 4], 'n1': 1}
>>> num1['n1'] = 19
>>> print(num1, num2)
{'n2': 2, 'n3': [9, 4], 'n1': 19} {'n2': 2, 'n3': [9, 4], 'n1': 1}
>>> print(id(num1['n3'][0]), id(num2['n3'][0]))
4423026960 4423026960
浅copy也可以利用copy模块 num2 = copy.copy(num1)
 图示如下:




 
3、深拷贝
深拷贝,在内存中将所有的数据重新创建一份(排除最后一层,即:python内部对字符串和数字的优化)
 
>>> num1 = {'n1': 1, 'n2': 2, 'n3': [3, 4]}
>>> num2 = copy.deepcopy(num1)
>>> print(id(num1), id(num2))
4424864840 4427043656
>>> print(id(num1['n1']), id(num2['n1']))
4423026704 4423026704
>>> print(id(num1['n3']), id(num2['n3']))
4427043592 4426939976
>>> num1['n1'] = 9
>>> print(id(num1['n1']), id(num2['n1']))
4423026960 4423026704从上面来看,深copy内存地址则完全不一样,图示如下: 查看全部


三元计算


三元计算也称为三目计算,如名字表示的三元运算符需要三个操作数,语法为:
条件表达式?表达式1:表达式2。  or  
var = 值1 if 条件 else 值2
说明:问号前面的位置是判断的条件,判断结果为bool型,为true时调用表达式1,为false时调用表达式2。
其逻辑为:如果为真执行第一个,否则执行第二个。
例子:
>>> a = 'xxoo'

>>> Re = 'xx' if a == 'xxoo' else 'oo'
>>> print(Re)
xx

>>> a = 'xx'
>>> Re = 'xx' if a == 'xxoo' else 'oo'
>>> print(Re)
oo
如上结果你可以看成是如下代码的简写的例子:
a = 'xxoo'
if a == 'xxoo':
Re = 'xx'
else:
Re = 'oo'
这样我想你就知道了!
 


深浅拷贝


深浅拷贝分为两部分,一部分是数字和字符串另一部分是列表、元组、字典等其他数据类型。
 
数字和字符串:
对于数字和字符串而言,赋值、浅拷贝和深拷贝无意义,因为他们的值永远都会指向同一个内存地址,他们就是内存地址的复用。
>>> import copy      # 导入内置copy模块
>>> name = 'lucky' # 命名name变量
>>> id(name) # 查看name变量的内存地址
4426658624
>>>
>>> name1 = name # 赋值应用变量 name1
>>> id(name1) # 查看变量name1内存地址
4426658624
>>>
>>> name2 = copy.copy(name) # 浅copy name变量赋值给name2变量
>>> id(name2) # 查看name2变量内存地址
4426658624
>>>
>>> name3 = copy.deepcopy(name) # 深copy name变量复制给name2变量
>>> id(name3) # 查看name3变量的内存地址
4426658624
>>>
>>> print(name, name1, name2, name3) # 打印四个变量的值
lucky lucky lucky lucky
如上结果可以看出,不管是直接引用还是深浅copy其最后的结果变量的内存地址都没有变,只是定义的方法不一样,如下图示:
strcopy.png

 
其他数据类型:
对于字典、元祖、列表 而言,进行赋值、浅拷贝和深拷贝时,内存地址可能会发生相应的变化。
1、赋值
>>> num1 = {'n1': 1, 'n2': 2, 'n3': [3, 4]}
>>> num2 = num1
>>> print(id(num1), id(num2))
4424864840 4424864840
>>>
>>> num1['n1'] = 7
>>> print(id(num1), id(num2))
4424864840 4424864840
>>> print(num1, num2)
{'n2': 2, 'n3': [3, 4], 'n1': 7} {'n2': 2, 'n3': [3, 4], 'n1': 7}
>>>
>>> num1['n3'][0] = 9
>>> print(id(num1), id(num2))
4424864840 4424864840
>>> print(num1, num2)
{'n2': 2, 'n3': [9, 4], 'n1': 7} {'n2': 2, 'n3': [9, 4], 'n1': 7}

如上所示,不管怎么改变原始的info字典内容,哪怕是改变里面的列表元素值,而info2的内容随之变化,运维他们的引用的内存地址是一样的,图示如下:
fuzhi.png

 
2、浅拷贝
 
浅拷贝,在内存中只额外创建第一层数据,里面则是完全复制。
>>> num1 = {'n1': 1, 'n2': 2, 'n3': [3, 4]}
>>> num2 = num1.copy()
>>> print(id(num1), id(num2))
4426663432 4426602824

>>> print(id(num1['n1']), id(num2['n1']))
4423026704 4423026704
>>> print(id(num1['n3']), id(num2['n3']))
4427044168 4427044168
>>> print(id(num1['n3'][0]), id(num2['n3'][0]))
4423026768 4423026768
>>> num1['n3'][0] = 9
>>> print(id(num1), id(num2))
4426663432 4426602824
>>> print(num1, num2)
{'n2': 2, 'n3': [9, 4], 'n1': 1} {'n2': 2, 'n3': [9, 4], 'n1': 1}
>>> num1['n1'] = 19
>>> print(num1, num2)
{'n2': 2, 'n3': [9, 4], 'n1': 19} {'n2': 2, 'n3': [9, 4], 'n1': 1}
>>> print(id(num1['n3'][0]), id(num2['n3'][0]))
4423026960 4423026960

浅copy也可以利用copy模块 num2 = copy.copy(num1)
 图示如下:
ashcopy.png

 
3、深拷贝
深拷贝,在内存中将所有的数据重新创建一份(排除最后一层,即:python内部对字符串和数字的优化)
 
>>> num1 = {'n1': 1, 'n2': 2, 'n3': [3, 4]}
>>> num2 = copy.deepcopy(num1)
>>> print(id(num1), id(num2))
4424864840 4427043656
>>> print(id(num1['n1']), id(num2['n1']))
4423026704 4423026704
>>> print(id(num1['n3']), id(num2['n3']))
4427043592 4426939976
>>> num1['n1'] = 9
>>> print(id(num1['n1']), id(num2['n1']))
4423026960 4423026704
从上面来看,深copy内存地址则完全不一样,图示如下:
deepcopy.png

Python函数详解

采菊篱下 发表了文章 • 2 个评论 • 691 次浏览 • 2016-08-15 00:43 • 来自相关话题

在介绍Python的函数之前我们先来回顾一下,我们平常写代码是不是需要什么功能就写什么功能,但是到后面深入你会发现在写代码的过程中,有好多代码是重叠的,就是一个功能块在不同的地方都被使用,但是每次都得重新写一遍,这样就造成了写程序的效率问题,而Python中的函数就可以很好的解决这么一点。例如一个登陆代码快的代码,你比如刚登陆的时候需要验证用户名密码,你执行他事件比如购物、结算等逻辑的时候也需要做验证,那如果我们把这个验证的逻辑封装成一个函数,然后用到的地方,想怎么调就怎么调用,所以减少代码的重复性是函数的特性之一。
 
同时在过去的十年间,大家广为熟知的编程方法无非两种:面向对象和面向过程,其实,无论哪种,都是一种编程的规范或者是如何编程的方法论。而如今,一种更为古老的编程方式:函数式编程,以其不保存状态,不修改变量等特性重新进入人们的视野。下面我们就来依次了解这一传统的编程理念,下面我们介绍一些Python中函数的概念。
 
面向过程:根据业务逻辑从上到下写垒代码
函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可

函数是什么?

在我们的初中书写中我们应该知道3x  = 4y 这就是一个简单的函数,而x、y就是两个变量,如果x确定为一个值,那y的值就是确定的,我们把x叫做自变量,而把y叫做应变量,y是x的函数,当然也可以反过来说。这里就是y会随着x的值变化而变化。而这个自变量x的取值范围我们就叫做这个函数的定义域。
 
函数一词虽源于数学,但编程中的「函数」概念,与数学中的函数是有很大不同的,具体区别,我们后面会讲,编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序),在Pascal中叫做procedure(过程)和function,在C中只有function,在Java里面叫做method。
 
定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名的方法即可

函数的特性:
减少重复代码使程序变的可扩展(装饰器本质是函数)使程序变得易维护
 
语法定义:def test(x):
"The function definitions"
x+=1
return x

******************************************************************
def:定义函数的关键字
test:函数名
():内可定义形参
"":文档描述(非必要,但是强烈建议为你的函数添加描述信息)
x+=1:泛指代码块或程序处理逻辑
return:定义返回值**编程语言中函数定义:函数是逻辑结构化和过程化的一种编程方法,函数式编程就是先定义一个数学函数,然后按照这个数学模型用编程语言去实现它。
 
一个栗子:#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

# 常规码代码
a, b = 5, 8
c = a * b
print(c)

print("我是分割线".center(30, '*'))
# 函数方法
def calc(x, y):
res = x * y
return res # 返回函数执行结果

c = calc(a, b) # 结果赋值给c变量
print(c)Result:40
************我是分割线*************
40这不是功能一样吗,看起来并没有什么卵用!!!嘿嘿!

函数参数与局部变量





形参:形式参数,不是实际存在,是虚拟变量。在定义函数和函数体的时候使用形参,目的是在函数调用时接收实参(实参个数,类型应与实参一一对应)。实参:实际参数,调用函数时传给函数的参数,可以是常量,变量,表达式,函数,传给形参。
区别:形参是虚拟的,不占用内存空间,形参变量只有在被调用时才分配内存单元,实参是一个变量,占用内存空间,数据传送单向,实参传给形参,不能形参传给实参。实参就是函数执行的时候用户调用函数实际传输的参数简称为实参,实参又分为位置参数和关键参数。
 
位置参数实例如下:def test(x, y): # x, y是形参
print("x is %d, y is %d" % (x, y))
calc_age = x * y
return calc_age

# 3在前,6在后 那么传给函数的形参就是按照位置 x = 3 , y = 6
print(test(3, 6))
print("我是分割线".center(30, '*'))
# 如果调用的时候6在前,3在后,那么 x = 6, y = 3
print(test(6, 3))结果如下:x is 3, y is 6
18
************我是分割线*************
x is 6, y is 3
18关键参数实例如下:def test(x, y, z): # x, y是形参
print("x is %d, y is %d, z is %d" % (x, y, z))
calc_age = x * y * z
return calc_age

# 指定y和z的值而x的值就是默认出入位置为第个的实参
print(test(3, y=2, z=3))
print("我是分割线".center(30, '*'))
# 指定y和z的值,但是y和z的位置对调
print(test(3, z=2, y=3))结果如下:x is 3, y is 2, z is 3
18
************我是分割线*************
x is 3, y is 3, z is 2
18如果这样呢?def test(x, y, z): # x, y是形参
print("x is %d, y is %d, z is %d" % (x, y, z))
calc_age = x * y * z
return calc_age

# 我指定第一个实参的数值,而不指定y和z的呢?
print(test(x=3, 2, 3))结果如下报错了: File "/Users/crh/PycharmProjects/app/test.py", line 12
print(test(x=3, 2, 3))
^
SyntaxError: positional argument follows keyword argument如上实例介绍可以得出如下结论:
正常情况下,给函数传参数要按顺序,不想按顺序就可以用关键参数,只需指定参数名即可,但记住一个要求就是,关键参数必须放在位置参数之后。
 
默认参数实例如下:def test(x, y=3, z): # x, y是形参
print("x is %d, y is %d, z is %d" % (x, y, z))
calc_age = x * y * z
return calc_age

# 只传两个参数,按照正常逻辑 x=1, y=3, z=3
print(test(1, 3))
# 但是报错了报错如下: File "/Users/crh/PycharmProjects/app/test.py", line 6
def test(x, y=3, z): # x, y是形参
^
SyntaxError: non-default argument follows default argumentdef test(x, y, z=3): # x, y是形参
print("x is %d, y is %d, z is %d" % (x, y, z))
calc_age = x * y * z
return calc_age

# 只传两个参数,按照正常逻辑 x=1, y=3, z=3
print(test(1, 6))结果如下:x is 1, y is 6, z is 3
18def test(x, z, y=3): # x, y是形参
print("x is %d, y is %d, z is %d" % (x, y, z))
calc_age = x * y * z
return calc_age

# 只传两个参数,按照正常逻辑 x=1, y=3, z=3
print(test(3, 2))结果如下:x is 3, y is 3, z is 2
18如上实例可以知道,函数的形参设置默认参数的时候,默认参数应该放到非默认参数后面,否则按照位置参数传入则就会报错,除非传入实参都设置位置参数!
上面实例报错分析:




 
动态参数实例如下:
动态参数也称为非固定参数,若你的函数在定义时不确定用户想传入多少个参数,就可以使用动态参数,使用了动态参数你就可以动态扩展,想传入多少参数都行!
 
1、argsdef test(x, y, *args):
print("x is %d, y is %d, z is %s" % (x, y, args))

test(1, 2, 3, 4, 5, 6)结果如下:x is 1, y is 2, z is (3, 4, 5, 6) def test(x, y, *args):
print("x is %d, y is %d, z is %s" % (x, y, args))
print(type(args))

test(1, 2) # 不传入args的值
test(1, 2, (3, 4, 5)) # 传入一个元组
test(1, 2, [3, 4, 5]) # 传入一个列表
test(1, 2, {3, 4, 5}) # 传入一个集合
test(1, 2, {1: 'lucky', 2: 'jack'}) # 传入一个字典结果如下:x is 1, y is 2, z is ()
<class 'tuple'>
x is 1, y is 2, z is ((3, 4, 5),)
<class 'tuple'>
x is 1, y is 2, z is ([3, 4, 5],)
<class 'tuple'>
x is 1, y is 2, z is ({3, 4, 5},)
<class 'tuple'>
x is 1, y is 2, z is ({1: 'lucky', 2: 'jack'},)
<class 'tuple'>总结:由上面代码可以看出,*args会把多传入的实参变成一个元组的类型;传入其他数据类型也一样,成为元组中的一个元素;另函数中有*args与其他形参的时候,*args一定要写到其他形参的后面,否则传入的实参都会被传入到*args当中打印成元组;还有如果没有多出传入的实参即*args没有值的时候,*args为空,不会报错。
 
2、kwargsdef test(x, y, **kwargs):
print("x is %d, y is %d, z is %s" % (x, y, kwargs))
print(type(kwargs))

test(1, 2) # 不传入kwargs的值
test(1, 2, 3, 4, 5)结果如下:Traceback (most recent call last):
x is 1, y is 2, z is {}
File "/Users/crh/PycharmProjects/app/test.py", line 11, in <module>
<class 'dict'>
test(1, 2, 3, 4, 5)
TypeError: test() takes 2 positional arguments but 5 were givendef test(x, y, **kwargs):
print("x is %d, y is %d, z is %s" % (x, y, kwargs))
print(type(kwargs))

test(1, 2, name='lucky', age=18, job='IT')结果如下:x is 1, y is 2, z is {'job': 'IT', 'name': 'lucky', 'age': 18}
<class 'dict'>**kwargs会把多出的a=b这种类型的实参打印成字典的类型(要区分开与关键参数的区别,关键参数的实参有对应的形参)test_list = [8, 9, 10, 11]
test_dict = {'name': 'lucky', 'age': '18', 'job': 'it'}

def test(x, y, *args, **kwargs):
print("x is %d, y is %d, args is %s, kwargs is %s" % (x, y, args, kwargs))

test(1, 2, test_list, test_dict)结果如下:x is 1, y is 2, args is ([8, 9, 10, 11], {'job': 'it', 'name': 'lucky', 'age': '18'}), kwargs is {}如上所示为什么把把字典传入函数后,打印的**kwargs为空值呢?!  是这样的,传入的字典会被当成一个元素传入函数,所有被当成多余的实参传入到了*args里面,所以**kwargs的值才为空;那么有什么办法可以把字典传入到**kwargs呢?test_list = [8, 9, 10, 11]
test_dict = {'name': 'lucky', 'age': '18', 'job': 'it'}

def test(x, y, *args, **kwargs):
print("x is %d, y is %d, args is %s, kwargs is %s" % (x, y, args, kwargs))

test(1, 2, *test_list, **test_dict)结果如下:x is 1, y is 2, args is (8, 9, 10, 11), kwargs is {'name': 'lucky', 'job': 'it', 'age': '18'}这下结果就是我想要的了,所以如果要把列表或者字典放到函数中,指定关键符号就好。
 
3、局部变量def change_name(name):
print("before change:", name)
name = "采菊篱下"
print("after change", name)

change_name(name)

print("在外面看看name改了么?", name)结果如下:before change: Lucky chen
after change 采菊篱下
在外面看看name改了么? Lucky chen全局与局部变量:
在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量;全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序;当全局变量与局部变量同名时,在定义局部变量的子程序内,局部变量起作用;在其它地方全局变量起作用。





返回值

要想获取函数的执行结果,就可以用return语句把结果返回,可以返回任何你想得到的东西,多返回值返回的是一个元组。def test(x, y, z, name):
calc_age = x * y * z
print(name)
return calc_age, name

age = test(3, 2, 3, 'lucky')
print(age, type(age))结果如下:lucky
(18, 'lucky') <class 'tuple'>总结:
函数在执行过程中只要遇到return语句,就会停止执行并返回结果,所以 return 语句代表着函数的结束,跟循环中的break一样。如果未在函数中指定return,那这个函数的返回值为None 
 

递归函数

在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。就是把函数体处理的结果,再次传到本函数再次执行。

递归特性:
必须有一个明确的结束条件每次进入更深一层递归时,问题规模相比上次递归都应有所减少递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出) 
def calc(n):
print(n)
if int(n/2) == 0:
return n
return calc(int(n/2))


calc(10)

Result:
10
5
2
1下面我们再来看一个斐波那契数列的例子:
def func(count, n1, n2): # 获取斐波那契数列第200个数字并返回给调用者
if count == 200:
return n1
n3 = n1 + n2
r = func(count + 1, n2, n3)
return r
ret = func(1, 0, 1)
print(ret)

Result:
173402521172797813159685037284371942044301

函数的作用域





再看一个例子:
name2 = "chenronghua"
def say():
name = "lucky"
print(name)
print(name2)
say()结果为:
lucky
chenronghua总结:
函数的作用域就是在函数里定义的变量不能被外面使用!但是外部全局定义的全局变量在函数内是可以使用的。
举个例子来说:你在房子里可以看到屋内的东西和房子外的东西,但是你在房子外面就只能看到房子外的东西不能看到房子内的东西!
原因防止在函数调用的时候防止变量冲突!
那问题来了,我在外面定义的全局变量在函数内可以改他吗,例子如下:
name2 = "chenronghua"
def say():
name = "lucky"
name2 = "crh"
print(name)
print("function inside name2 value %s" % name2)
say()
print("function outside name value %s" % name2)结果如下:
lucky
function inside name2 value crh
function outside name value chenronghua从上面的例子可以看出函数里面把name2的值改了,但是在外部打印还是没有发生改变,这就是函数作用域的诠释。
 
如果我就是想改,怎么办呢,可以吗?如下例子所示:
name2 = "chenronghua"
def say():
global name2
name = "lucky"
name2 = "crh"
print(name)
print("function inside name2 value %s" % name2)
say()
print("function outside name value %s" % name2)结果如下:
lucky
function inside name2 value crh
function outside name value crh可以看出,是可以做到的,你需要在函数体内利用内置函数global来声明你想作为全局变量的变量。 查看全部
在介绍Python的函数之前我们先来回顾一下,我们平常写代码是不是需要什么功能就写什么功能,但是到后面深入你会发现在写代码的过程中,有好多代码是重叠的,就是一个功能块在不同的地方都被使用,但是每次都得重新写一遍,这样就造成了写程序的效率问题,而Python中的函数就可以很好的解决这么一点。例如一个登陆代码快的代码,你比如刚登陆的时候需要验证用户名密码,你执行他事件比如购物、结算等逻辑的时候也需要做验证,那如果我们把这个验证的逻辑封装成一个函数,然后用到的地方,想怎么调就怎么调用,所以减少代码的重复性是函数的特性之一。
 
同时在过去的十年间,大家广为熟知的编程方法无非两种:面向对象和面向过程,其实,无论哪种,都是一种编程的规范或者是如何编程的方法论。而如今,一种更为古老的编程方式:函数式编程,以其不保存状态,不修改变量等特性重新进入人们的视野。下面我们就来依次了解这一传统的编程理念,下面我们介绍一些Python中函数的概念。
 
面向过程:根据业务逻辑从上到下写垒代码
函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可


函数是什么?


在我们的初中书写中我们应该知道3x  = 4y 这就是一个简单的函数,而x、y就是两个变量,如果x确定为一个值,那y的值就是确定的,我们把x叫做自变量,而把y叫做应变量,y是x的函数,当然也可以反过来说。这里就是y会随着x的值变化而变化。而这个自变量x的取值范围我们就叫做这个函数的定义域。
 
函数一词虽源于数学,但编程中的「函数」概念,与数学中的函数是有很大不同的,具体区别,我们后面会讲,编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序),在Pascal中叫做procedure(过程)和function,在C中只有function,在Java里面叫做method。
 
定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名的方法即可

函数的特性:
  • 减少重复代码
  • 使程序变的可扩展(装饰器本质是函数)
  • 使程序变得易维护

 
语法定义:
def test(x):
"The function definitions"
x+=1
return x

******************************************************************
def:定义函数的关键字
test:函数名
():内可定义形参
"":文档描述(非必要,但是强烈建议为你的函数添加描述信息)
x+=1:泛指代码块或程序处理逻辑
return:定义返回值
**编程语言中函数定义:函数是逻辑结构化和过程化的一种编程方法,函数式编程就是先定义一个数学函数,然后按照这个数学模型用编程语言去实现它。
 
一个栗子
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

# 常规码代码
a, b = 5, 8
c = a * b
print(c)

print("我是分割线".center(30, '*'))
# 函数方法
def calc(x, y):
res = x * y
return res # 返回函数执行结果

c = calc(a, b) # 结果赋值给c变量
print(c)
Result:
40
************我是分割线*************
40
这不是功能一样吗,看起来并没有什么卵用!!!嘿嘿!


函数参数与局部变量


func.png

形参:
形式参数,不是实际存在,是虚拟变量。在定义函数和函数体的时候使用形参,目的是在函数调用时接收实参(实参个数,类型应与实参一一对应)。
实参:
实际参数,调用函数时传给函数的参数,可以是常量,变量,表达式,函数,传给形参。

区别:
形参是虚拟的,不占用内存空间,形参变量只有在被调用时才分配内存单元,实参是一个变量,占用内存空间,数据传送单向,实参传给形参,不能形参传给实参。
实参就是函数执行的时候用户调用函数实际传输的参数简称为实参,实参又分为位置参数和关键参数。
 
位置参数实例如下
def test(x, y):     # x, y是形参
print("x is %d, y is %d" % (x, y))
calc_age = x * y
return calc_age

# 3在前,6在后 那么传给函数的形参就是按照位置 x = 3 , y = 6
print(test(3, 6))
print("我是分割线".center(30, '*'))
# 如果调用的时候6在前,3在后,那么 x = 6, y = 3
print(test(6, 3))
结果如下:
x is 3, y is 6
18
************我是分割线*************
x is 6, y is 3
18
关键参数实例如下:
def test(x, y, z):     # x, y是形参
print("x is %d, y is %d, z is %d" % (x, y, z))
calc_age = x * y * z
return calc_age

# 指定y和z的值而x的值就是默认出入位置为第个的实参
print(test(3, y=2, z=3))
print("我是分割线".center(30, '*'))
# 指定y和z的值,但是y和z的位置对调
print(test(3, z=2, y=3))
结果如下:
x is 3, y is 2, z is 3
18
************我是分割线*************
x is 3, y is 3, z is 2
18
如果这样呢?
def test(x, y, z):     # x, y是形参
print("x is %d, y is %d, z is %d" % (x, y, z))
calc_age = x * y * z
return calc_age

# 我指定第一个实参的数值,而不指定y和z的呢?
print(test(x=3, 2, 3))
结果如下报错了:
  File "/Users/crh/PycharmProjects/app/test.py", line 12
print(test(x=3, 2, 3))
^
SyntaxError: positional argument follows keyword argument
如上实例介绍可以得出如下结论:
正常情况下,给函数传参数要按顺序,不想按顺序就可以用关键参数,只需指定参数名即可,但记住一个要求就是,关键参数必须放在位置参数之后
 
默认参数实例如下:
def test(x, y=3, z):     # x, y是形参
print("x is %d, y is %d, z is %d" % (x, y, z))
calc_age = x * y * z
return calc_age

# 只传两个参数,按照正常逻辑 x=1, y=3, z=3
print(test(1, 3))
# 但是报错了
报错如下:
  File "/Users/crh/PycharmProjects/app/test.py", line 6
def test(x, y=3, z): # x, y是形参
^
SyntaxError: non-default argument follows default argument
def test(x, y, z=3):     # x, y是形参
print("x is %d, y is %d, z is %d" % (x, y, z))
calc_age = x * y * z
return calc_age

# 只传两个参数,按照正常逻辑 x=1, y=3, z=3
print(test(1, 6))
结果如下:
x is 1, y is 6, z is 3
18
def test(x, z, y=3):     # x, y是形参
print("x is %d, y is %d, z is %d" % (x, y, z))
calc_age = x * y * z
return calc_age

# 只传两个参数,按照正常逻辑 x=1, y=3, z=3
print(test(3, 2))
结果如下:
x is 3, y is 3, z is 2
18
如上实例可以知道,函数的形参设置默认参数的时候,默认参数应该放到非默认参数后面,否则按照位置参数传入则就会报错,除非传入实参都设置位置参数!
上面实例报错分析:
args.png

 
动态参数实例如下:
动态参数也称为非固定参数,若你的函数在定义时不确定用户想传入多少个参数,就可以使用动态参数,使用了动态参数你就可以动态扩展,想传入多少参数都行!
 
1、args
def test(x, y, *args):
print("x is %d, y is %d, z is %s" % (x, y, args))

test(1, 2, 3, 4, 5, 6)
结果如下:
x is 1, y is 2, z is (3, 4, 5, 6)
 
def test(x, y, *args):
print("x is %d, y is %d, z is %s" % (x, y, args))
print(type(args))

test(1, 2) # 不传入args的值
test(1, 2, (3, 4, 5)) # 传入一个元组
test(1, 2, [3, 4, 5]) # 传入一个列表
test(1, 2, {3, 4, 5}) # 传入一个集合
test(1, 2, {1: 'lucky', 2: 'jack'}) # 传入一个字典
结果如下:
x is 1, y is 2, z is ()
<class 'tuple'>
x is 1, y is 2, z is ((3, 4, 5),)
<class 'tuple'>
x is 1, y is 2, z is ([3, 4, 5],)
<class 'tuple'>
x is 1, y is 2, z is ({3, 4, 5},)
<class 'tuple'>
x is 1, y is 2, z is ({1: 'lucky', 2: 'jack'},)
<class 'tuple'>
总结:由上面代码可以看出,*args会把多传入的实参变成一个元组的类型;传入其他数据类型也一样,成为元组中的一个元素;另函数中有*args与其他形参的时候,*args一定要写到其他形参的后面,否则传入的实参都会被传入到*args当中打印成元组;还有如果没有多出传入的实参即*args没有值的时候,*args为空,不会报错。
 
2、kwargs
def test(x, y, **kwargs):
print("x is %d, y is %d, z is %s" % (x, y, kwargs))
print(type(kwargs))

test(1, 2) # 不传入kwargs的值
test(1, 2, 3, 4, 5)
结果如下:
Traceback (most recent call last):
x is 1, y is 2, z is {}
File "/Users/crh/PycharmProjects/app/test.py", line 11, in <module>
<class 'dict'>
test(1, 2, 3, 4, 5)
TypeError: test() takes 2 positional arguments but 5 were given
def test(x, y, **kwargs):
print("x is %d, y is %d, z is %s" % (x, y, kwargs))
print(type(kwargs))

test(1, 2, name='lucky', age=18, job='IT')
结果如下:
x is 1, y is 2, z is {'job': 'IT', 'name': 'lucky', 'age': 18}
<class 'dict'>
**kwargs会把多出的a=b这种类型的实参打印成字典的类型(要区分开与关键参数的区别,关键参数的实参有对应的形参)
test_list = [8, 9, 10, 11]
test_dict = {'name': 'lucky', 'age': '18', 'job': 'it'}

def test(x, y, *args, **kwargs):
print("x is %d, y is %d, args is %s, kwargs is %s" % (x, y, args, kwargs))

test(1, 2, test_list, test_dict)
结果如下:
x is 1, y is 2, args is ([8, 9, 10, 11], {'job': 'it', 'name': 'lucky', 'age': '18'}), kwargs is {}
如上所示为什么把把字典传入函数后,打印的**kwargs为空值呢?!  是这样的,传入的字典会被当成一个元素传入函数,所有被当成多余的实参传入到了*args里面,所以**kwargs的值才为空;那么有什么办法可以把字典传入到**kwargs呢?
test_list = [8, 9, 10, 11]
test_dict = {'name': 'lucky', 'age': '18', 'job': 'it'}

def test(x, y, *args, **kwargs):
print("x is %d, y is %d, args is %s, kwargs is %s" % (x, y, args, kwargs))

test(1, 2, *test_list, **test_dict)
结果如下:
x is 1, y is 2, args is (8, 9, 10, 11), kwargs is {'name': 'lucky', 'job': 'it', 'age': '18'}
这下结果就是我想要的了,所以如果要把列表或者字典放到函数中,指定关键符号就好。
 
3、局部变量
def change_name(name):
print("before change:", name)
name = "采菊篱下"
print("after change", name)

change_name(name)

print("在外面看看name改了么?", name)
结果如下:
before change: Lucky chen
after change 采菊篱下
在外面看看name改了么? Lucky chen
全局与局部变量:
  • 在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量;
  • 全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序;
  • 当全局变量与局部变量同名时,在定义局部变量的子程序内,局部变量起作用;在其它地方全局变量起作用。

zuoyongyu.png


返回值


要想获取函数的执行结果,就可以用return语句把结果返回,可以返回任何你想得到的东西,多返回值返回的是一个元组。
def test(x, y, z, name):
calc_age = x * y * z
print(name)
return calc_age, name

age = test(3, 2, 3, 'lucky')
print(age, type(age))
结果如下:
lucky
(18, 'lucky') <class 'tuple'>
总结:
  • 函数在执行过程中只要遇到return语句,就会停止执行并返回结果,所以 return 语句代表着函数的结束,跟循环中的break一样。
  • 如果未在函数中指定return,那这个函数的返回值为None 

 


递归函数


在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。就是把函数体处理的结果,再次传到本函数再次执行。

递归特性:
  1. 必须有一个明确的结束条件
  2. 每次进入更深一层递归时,问题规模相比上次递归都应有所减少
  3. 递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出) 

def calc(n):
print(n)
if int(n/2) == 0:
return n
return calc(int(n/2))


calc(10)

Result:
10
5
2
1
下面我们再来看一个斐波那契数列的例子:
def func(count, n1, n2):        # 获取斐波那契数列第200个数字并返回给调用者
if count == 200:
return n1
n3 = n1 + n2
r = func(count + 1, n2, n3)
return r
ret = func(1, 0, 1)
print(ret)

Result:
173402521172797813159685037284371942044301


函数的作用域


zyy.png

再看一个例子:
name2 = "chenronghua"
def say():
name = "lucky"
print(name)
print(name2)
say()
结果为:
lucky
chenronghua
总结:
函数的作用域就是在函数里定义的变量不能被外面使用!但是外部全局定义的全局变量在函数内是可以使用的。
举个例子来说:你在房子里可以看到屋内的东西和房子外的东西,但是你在房子外面就只能看到房子外的东西不能看到房子内的东西!
原因防止在函数调用的时候防止变量冲突!

那问题来了,我在外面定义的全局变量在函数内可以改他吗,例子如下:
name2 = "chenronghua"
def say():
name = "lucky"
name2 = "crh"
print(name)
print("function inside name2 value %s" % name2)
say()
print("function outside name value %s" % name2)
结果如下:
lucky
function inside name2 value crh
function outside name value chenronghua
从上面的例子可以看出函数里面把name2的值改了,但是在外部打印还是没有发生改变,这就是函数作用域的诠释。
 
如果我就是想改,怎么办呢,可以吗?如下例子所示:
name2 = "chenronghua"
def say():
global name2
name = "lucky"
name2 = "crh"
print(name)
print("function inside name2 value %s" % name2)
say()
print("function outside name value %s" % name2)
结果如下:
lucky
function inside name2 value crh
function outside name value crh
可以看出,是可以做到的,你需要在函数体内利用内置函数global来声明你想作为全局变量的变量。

Python中怎么去除字符串中间的空格?

采菊篱下 回复了问题 • 2 人关注 • 1 个回复 • 1426 次浏览 • 2016-08-13 14:56 • 来自相关话题

Python文件读写操作详解

采菊篱下 发表了文章 • 0 个评论 • 668 次浏览 • 2016-08-11 13:15 • 来自相关话题

文件打开流程

Python中文件操作可以分为三步:
打开文件,得到文件句柄并赋值给一个变量通过句柄对文件进行操作关闭文件 





打开文件模式

打开文件的模式有:
r,只读模式(默认)。w,只写模式。【不可读;不存在则创建;存在则删除内容;】a,追加模式。【可读;   不存在则创建;存在则只追加内容;】
 
"+" 表示可以同时读写某个文件
r+,可读写文件。【可读;可写;可追加】w+,写读a+,同a
 
"U"表示在读取时,可以将 \r \n \r\n自动转换成 \n (与 r 或 r+ 模式同使用)
rUr+U
 
"b"表示处理二进制文件(如:FTP发送上传ISO镜像文件,linux可忽略,windows处理二进制文件时需标注)
rbwbab
 
操作文件内容如下:I took a pill in Ibiza
我在Ibiza岛上嗑药
To show Avicii I was cool
为了让Avicii觉得我很酷
And when I finally got sober, felt 10 years older
当我终于清醒过来了 仿佛已经是十年之后
But fuck it, it was something to do
但操他妈的 那也算是消遣了
I'm living out in LA
我住在LA
I drive a sports car just to prove
我开跑车只为了证明
I'm a real big baller cause I made a million dollars
我真的超屌能赚百万
And I spend it on girls and shoes
然后我把它们全部都花在妞和鞋上
But you don't wanna be high like me
但你不会想和我一样拥有这么多
Never really knowing why like me
我都不明白为什么人想要得到这么多
You don't ever wanna step of that roller coaster and be all alone
(一旦你拥有过之后)你就再也不想离开这过山车 再变得独自一人
You don't wanna ride the bus like this
你不会想要过这样的生活
Never knowing who to trust like this
像这样永远不知道能信任谁
You don't wanna be stuck up on that stage singing
你不会想在台上自我感觉良好地唱歌 受到万人追捧
Stuck up on that stage singing
不想这样骄傲地在台上唱歌
All I know are sad songs, sad songs
我只知道 我只想唱 那些悲伤的歌
Darling, all I know are sad songs, sad songs
宝贝儿 我真的只知道 只想唱 那些悲伤的歌

文件操作常用功能

1、read()、readline()、readlines()的区别#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt', encoding='utf-8')
print(f)


# 打印出来的是一个文件句柄信息:<_io.TextIOWrapper name='aa.txt' mode='r' encoding='utf-8'>

print(f.read()) # 打印出来的就是文件所有的内容,全部加载到内存,读取出来
print(f.readline()) # 打印的是文件第一行的内容
print(f.readlines()) # 把文件内容每行当做一个列表的元素,放到一个列表中,打印的是一个列表
f.close()
2、文件指针#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt', encoding='utf-8')
print("第一次读取开始指针位置为%s".center(30, '*') % f.tell())
print(f.readline().strip()) # 打印的是文件第一行的内容
end_tell = f.tell() # 获取当前指针位置
print("第一次读取结束指针位置为%s".center(30, '*') % end_tell)

print("第二次读取开始指针位置为%s".center(30, '*') % f.tell())
print(f.readline().strip())
end_tell = f.tell() # 获取当前指针位置
print("第二次读取结束指针位置为%s".center(30, '*') % end_tell)

# 把指针调节到最开始重新重新读取
f.seek(0) # 把指针调节到最开头
print("重新读取开始指针位置为%s".center(30, '*') % f.tell())
print(f.readline().strip())
end_tell = f.tell()
print("重新读取结束指针位置为%s".center(30, '*') % end_tell)
f.close()Result:********第一次读取开始指针位置为0********
I took a pill in Ibiza
********第一次读取结束指针位置为23********
********第二次读取开始指针位置为23********
我在Ibiza岛上嗑药
********第二次读取结束指针位置为47********
********重新读取开始指针位置为0*********
I took a pill in Ibiza
********重新读取结束指针位置为23*********
 3、encoding 显示打开文件的编码格式#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt')
print(f.encoding)
f.close()

f = open('aa.txt', 'r+', encoding='gbk')
print(f.encoding)
f.close()Result:UTF-8
gbk
4、seekable  判断一个文件是否是光标可移动文件,有些二进制文件是无法进行光标移动的。#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt', 'r+', encoding='utf-8')
Re = f.seekable()
if Re:
print("Allow Move Cursor")
f.close()Result:Allow Move Cursor
5、read() 如果不输入任何参数,读取整个文件,可以跟参数指定读取文件的字节数#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt', 'r+', encoding='utf-8')
# 读取三个字节
print(f.read(3))
print("*" * 30)
# 读取50个字节
print(f.read(50))
f.close()Result:I t
******************************
ook a pill in Ibiza
我在Ibiza岛上嗑药
To show Avicii I w
6、readable() 判断一个文件是否可读,返回布尔值#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt', 'r+', encoding='utf-8')
Re = f.readable()

if Re:
print("File Allow Read!")
else:
print("File Not Allow Read!")
f.close()

print('分割线'.center(30, '*'))

f = open('aa.txt', 'a', encoding='utf-8')
Re = f.readable()

if Re:
print("File Allow Read!")
else:
print("File Not Allow Read!")
f.close()Result:File Allow Read!
*************分割线**************
File Not Allow Read! f.writeble()和上面的一样,是用来测试文件的打开方式是否可读。
 
 
7、flush 强制刷新到内存#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen
# load module
import sys
import time

# 模拟进度条
for i in range(61):
sys.stdout.write('>')
sys.stdout.flush() # flush 强制刷新缓存到内存的数据写入硬盘
time.sleep(0.1)
8、with语句
为了避免打开文件后忘记关闭,可以通过管理上下文,即:with open('log','r', encoding='utf-8') as f:

...如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。

在Python 2.7 后,with又支持同时对多个文件的上下文进行管理,即:with open('log1') as obj1, open('log2') as obj2:
pass例子:比如要修改haproxy.cfg 文件然后还的回滚怎么做?
with open('haproxy.cfg','r') as obj1,open('haproxy.cfg.new','w') as obj2:
for i in obj1.readlines():
i = i.strip()
print i
obj2.write(i)
obj2.write('\n')

#读取harpoxy.cfg每行然后存储到新的文件haproxy.cfg.new里!
 9、文件遍历
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen
# load module

f = open("aa.txt", 'r', encoding="utf-8")

for index, line in enumerate(f.readlines()):
# 先把文件内容以行为分割生成列表,数据量大不能用
if index == 5:
print("我是分割线".center(50, '-'))
continue
print(line.strip())

# f.readlines()是把整个文件的每一行当做一个元素,存放在一个列表中,然后循环这个列表就可以了。
# 注:此种方式存在隐患,假如一个文件过大,会把整个内存撑爆
f.close()


f = open("aa.txt", 'r', encoding="utf-8")
count = 0
for line in f:
count += 1
if count == 3:
print("我是第二个分割线".center(50, '-'))
continue
print(line.strip())

f.close()

# 直接for循环后面直接跟文件句炳,此时这个文件句炳是一个迭代器,这样读取是一行一行的读取,内存只会存放一行内容,故而不会涉及内存的问题。

# 两者的优缺点,第一种方法因为是列表,可以直接使用下标,对文件读取那行进行方便控制;第二种方法没有下标,只能自己写计数器,进行判断。 查看全部


文件打开流程


Python中文件操作可以分为三步:
  1. 打开文件,得到文件句柄并赋值给一个变量
  2. 通过句柄对文件进行操作
  3. 关闭文件 

filecontrol.png


打开文件模式


打开文件的模式有:
  • 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

 
操作文件内容如下:
I took a pill in Ibiza
我在Ibiza岛上嗑药
To show Avicii I was cool
为了让Avicii觉得我很酷
And when I finally got sober, felt 10 years older
当我终于清醒过来了 仿佛已经是十年之后
But fuck it, it was something to do
但操他妈的 那也算是消遣了
I'm living out in LA
我住在LA
I drive a sports car just to prove
我开跑车只为了证明
I'm a real big baller cause I made a million dollars
我真的超屌能赚百万
And I spend it on girls and shoes
然后我把它们全部都花在妞和鞋上
But you don't wanna be high like me
但你不会想和我一样拥有这么多
Never really knowing why like me
我都不明白为什么人想要得到这么多
You don't ever wanna step of that roller coaster and be all alone
(一旦你拥有过之后)你就再也不想离开这过山车 再变得独自一人
You don't wanna ride the bus like this
你不会想要过这样的生活
Never knowing who to trust like this
像这样永远不知道能信任谁
You don't wanna be stuck up on that stage singing
你不会想在台上自我感觉良好地唱歌 受到万人追捧
Stuck up on that stage singing
不想这样骄傲地在台上唱歌
All I know are sad songs, sad songs
我只知道 我只想唱 那些悲伤的歌
Darling, all I know are sad songs, sad songs
宝贝儿 我真的只知道 只想唱 那些悲伤的歌


文件操作常用功能


1、read()、readline()、readlines()的区别
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt', encoding='utf-8')
print(f)


# 打印出来的是一个文件句柄信息:<_io.TextIOWrapper name='aa.txt' mode='r' encoding='utf-8'>

print(f.read()) # 打印出来的就是文件所有的内容,全部加载到内存,读取出来
print(f.readline()) # 打印的是文件第一行的内容
print(f.readlines()) # 把文件内容每行当做一个列表的元素,放到一个列表中,打印的是一个列表
f.close()

2、文件指针
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt', encoding='utf-8')
print("第一次读取开始指针位置为%s".center(30, '*') % f.tell())
print(f.readline().strip()) # 打印的是文件第一行的内容
end_tell = f.tell() # 获取当前指针位置
print("第一次读取结束指针位置为%s".center(30, '*') % end_tell)

print("第二次读取开始指针位置为%s".center(30, '*') % f.tell())
print(f.readline().strip())
end_tell = f.tell() # 获取当前指针位置
print("第二次读取结束指针位置为%s".center(30, '*') % end_tell)

# 把指针调节到最开始重新重新读取
f.seek(0) # 把指针调节到最开头
print("重新读取开始指针位置为%s".center(30, '*') % f.tell())
print(f.readline().strip())
end_tell = f.tell()
print("重新读取结束指针位置为%s".center(30, '*') % end_tell)
f.close()
Result:
********第一次读取开始指针位置为0********
I took a pill in Ibiza
********第一次读取结束指针位置为23********
********第二次读取开始指针位置为23********
我在Ibiza岛上嗑药
********第二次读取结束指针位置为47********
********重新读取开始指针位置为0*********
I took a pill in Ibiza
********重新读取结束指针位置为23*********

 3、encoding 显示打开文件的编码格式
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt')
print(f.encoding)
f.close()

f = open('aa.txt', 'r+', encoding='gbk')
print(f.encoding)
f.close()
Result:
UTF-8
gbk

4、seekable  判断一个文件是否是光标可移动文件,有些二进制文件是无法进行光标移动的。
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt', 'r+', encoding='utf-8')
Re = f.seekable()
if Re:
print("Allow Move Cursor")
f.close()
Result:
Allow Move Cursor

5、read() 如果不输入任何参数,读取整个文件,可以跟参数指定读取文件的字节数
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt', 'r+', encoding='utf-8')
# 读取三个字节
print(f.read(3))
print("*" * 30)
# 读取50个字节
print(f.read(50))
f.close()
Result:
I t
******************************
ook a pill in Ibiza
我在Ibiza岛上嗑药
To show Avicii I w

6、readable() 判断一个文件是否可读,返回布尔值
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

f = open('aa.txt', 'r+', encoding='utf-8')
Re = f.readable()

if Re:
print("File Allow Read!")
else:
print("File Not Allow Read!")
f.close()

print('分割线'.center(30, '*'))

f = open('aa.txt', 'a', encoding='utf-8')
Re = f.readable()

if Re:
print("File Allow Read!")
else:
print("File Not Allow Read!")
f.close()
Result:
File Allow Read!
*************分割线**************
File Not Allow Read!
 f.writeble()和上面的一样,是用来测试文件的打开方式是否可读。
 
 
7、flush 强制刷新到内存
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen
# load module
import sys
import time

# 模拟进度条
for i in range(61):
sys.stdout.write('>')
sys.stdout.flush() # flush 强制刷新缓存到内存的数据写入硬盘
time.sleep(0.1)

8、with语句
为了避免打开文件后忘记关闭,可以通过管理上下文,即:
with open('log','r', encoding='utf-8') as f:

...
如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。

在Python 2.7 后,with又支持同时对多个文件的上下文进行管理,即:
with open('log1') as obj1, open('log2') as obj2:
pass
例子:比如要修改haproxy.cfg 文件然后还的回滚怎么做?
with open('haproxy.cfg','r') as obj1,open('haproxy.cfg.new','w') as obj2:
for i in obj1.readlines():
i = i.strip()
print i
obj2.write(i)
obj2.write('\n')

#读取harpoxy.cfg每行然后存储到新的文件haproxy.cfg.new里!

 9、文件遍历
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen
# load module

f = open("aa.txt", 'r', encoding="utf-8")

for index, line in enumerate(f.readlines()):
# 先把文件内容以行为分割生成列表,数据量大不能用
if index == 5:
print("我是分割线".center(50, '-'))
continue
print(line.strip())

# f.readlines()是把整个文件的每一行当做一个元素,存放在一个列表中,然后循环这个列表就可以了。
# 注:此种方式存在隐患,假如一个文件过大,会把整个内存撑爆
f.close()


f = open("aa.txt", 'r', encoding="utf-8")
count = 0
for line in f:
count += 1
if count == 3:
print("我是第二个分割线".center(50, '-'))
continue
print(line.strip())

f.close()

# 直接for循环后面直接跟文件句炳,此时这个文件句炳是一个迭代器,这样读取是一行一行的读取,内存只会存放一行内容,故而不会涉及内存的问题。

# 两者的优缺点,第一种方法因为是列表,可以直接使用下标,对文件读取那行进行方便控制;第二种方法没有下标,只能自己写计数器,进行判断。

图解Python 集合

采菊篱下 发表了文章 • 2 个评论 • 763 次浏览 • 2016-08-10 23:41 • 来自相关话题

集合基本功能

集合是一个无序的,不重复的数据组合,用{}表示,它的主要作用如下:
去重,把一个列表变成集合,就会自动去重关系测试,测试两组数据之前的交集、差集、并集、子集等关系
 集合创建:
>>> set_job = set(['DEV', 'OPS', 'DBA', 'QA', 'Sales'])
>>> set_man = set(('lucky', 'jack', 'andy', 'tom', 'andy', 'jim'))
>>> print(set_job, type(set_job))
{'DEV', 'OPS', 'Sales', 'QA', 'DBA'} <class 'set'>
>>> print(set_man, type(set_man)) # 天生去重,只有一个andy了
{'andy', 'jack', 'lucky', 'tom', 'jim'} <class 'set'>
 
元素添加:
>>> set_job = set(['DEV', 'OPS', 'DBA', 'QA', 'Sales'])
>>> set_job.add('HR') # add方法只能添加一个
>>> print(set_job)
{'QA', 'HR', 'Sales', 'DEV', 'OPS', 'DBA'}
>>> set_job.update(['FD', 'MD', 'MD'])
>>> print(set_job)
{'QA', 'HR', 'Sales', 'DEV', 'MD', 'OPS', 'FD', 'DBA'}
>>> set_job.update(('AD', 'PD')) # update方法可以添加是列表或者元组,去重,如果添加的为一个单独字符串,则把字符串拆成字母添加到集合中
>>> print(set_job)
{'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}
元素删除:
>>> set_job = {'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.remove('PD') # 删除指定元素
>>> set_job.remove('xx') # 元素不存在则报错 KeyError
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'xx'
>>> print(set_job)
{'QA', 'HR', 'MD', 'DEV', 'Sales', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.pop() # 随机删除一个元素
'QA'
>>> print(set_job)
{'HR', 'MD', 'DEV', 'Sales', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.discard('OPS') # 指定删除
>>> set_job.discard('xxx') # 不存在返回None,不会报KeyError
>>> print(set_job)
{'HR', 'MD', 'DEV', 'Sales', 'AD', 'FD', 'DBA'}
其他:
>>> set_job = {'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}
>>> len(set_job)  # 集合长度
10
>>> 'QA' in set_job  # 判断是否在集合中
True
>>> 'XXX' not in set_job # 不在集合中
True
>>> for i in set_job:   # 循环
...     print(i)

集合关系测试

交集:



>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> print(set_a.intersection(set_b)) # 常规方式
{5, 6}
>>> print(set_a & set_b) # 运算符(&)方式
{5, 6}
并集



>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a.union(set_b)    # 关键字union做并集运算 先后顺序无关,谁并谁都可以
>>> print(set_c)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
>>> 
>>> set_c = set_a | set_b     # 运算符关键符 | 做并集运算  先后顺序无关,谁并谁都可以
>>> print(set_c)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

差集



>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a - set_b # a集合跟b集合做差集 关键符 -
>>> print(set_c)
{8, 9, 10, 7}
>>> set_d = set_b - set_a # b集合跟a集合做差集 关键符 -
>>> print(set_d)
{1, 2, 3, 4}
>>> set_c = set_a.difference(set_b) # a集合跟b集合做差集 关键字difference
>>> print(set_c)
{8, 9, 10, 7}
>>> set_d = set_b.difference(set_a) # b集合跟a集合做差集 关键字difference
>>> print(set_d)
{1, 2, 3, 4}
 
子集父集




拿苹果来打比方就是,把苹果掰开,然后掰开的一小部分就是子集,然后整个苹果就是父集
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = {7, 8, 9, 10}
>>> set_d = {1, 2, 3, 4}
>>> set_e = {5, 6}
>>> set_f = {11, 12, 13, 14, 15, 16}
>>> set_c.issubset(set_a) # 测试集合c是否是集合a的子集 放回布尔值 关键字issubset
True
>>> set_d.issubset(set_b) # 测试集合d是否是集合b的子集 返回布尔值 issubset
True
>>> set_e.issubset(set_a)
True
>>> set_e.issubset(set_b)
True
>>> set_e <= set_a # 测试集合e是否是集合a的子集 关键符 <=
True
>>> set_e <= set_b
True
>>> set_f.issuperset(set_a) # 测试f集合是否是a集合的父集
False
>>> set_a.issuperset(set_e) # 测试a集合是否是集合e的父集 关键字issuperset
True
>>> set_b >= set_e # 测试集合b是否是集合e的父集 关键符 >=
True
>>> set_b >= set_d
True
对称差集
对称差集就是两个集合去掉相同的部分,然后剩下的所有元素组成的集合



>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a.symmetric_difference(set_b) # 集合a和集合b做对称差集 关键字symmetric_difference
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}
>>> set_c = set_a ^ set_b # 集合a和集合b做对称差集 关键符 ^
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}
>>> set_c = set_b ^ set_a
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}
所有方法:
class set(object):
"""
set() -> new empty set object
set(iterable) -> new set object

Build an unordered collection of unique elements.
"""
def add(self, *args, **kwargs): # real signature unknown
"""
Add an element to a set.

This has no effect if the element is already present.
"""
pass

def clear(self, *args, **kwargs): # real signature unknown
""" Remove all elements from this set. """
pass

def copy(self, *args, **kwargs): # real signature unknown
""" Return a shallow copy of a set. """
pass

def difference(self, *args, **kwargs): # real signature unknown
"""
Return the difference of two or more sets as a new set.

(i.e. all elements that are in this set but not the others.)
"""
pass

def difference_update(self, *args, **kwargs): # real signature unknown
""" Remove all elements of another set from this set. """
pass

def discard(self, *args, **kwargs): # real signature unknown
"""
Remove an element from a set if it is a member.

If the element is not a member, do nothing.
"""
pass

def intersection(self, *args, **kwargs): # real signature unknown
"""
Return the intersection of two sets as a new set.

(i.e. all elements that are in both sets.)
"""
pass

def intersection_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the intersection of itself and another. """
pass

def isdisjoint(self, *args, **kwargs): # real signature unknown
""" Return True if two sets have a null intersection. """
pass

def issubset(self, *args, **kwargs): # real signature unknown
""" Report whether another set contains this set. """
pass

def issuperset(self, *args, **kwargs): # real signature unknown
""" Report whether this set contains another set. """
pass

def pop(self, *args, **kwargs): # real signature unknown
"""
Remove and return an arbitrary set element.
Raises KeyError if the set is empty.
"""
pass

def remove(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.
"""
pass

def symmetric_difference(self, *args, **kwargs): # real signature unknown
"""
Return the symmetric difference of two sets as a new set.

(i.e. all elements that are in exactly one of the sets.)
"""
pass

def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the symmetric difference of itself and another. """
pass

def union(self, *args, **kwargs): # real signature unknown
"""
Return the union of sets as a new set.

(i.e. all elements that are in either set.)
"""
pass

def update(self, *args, **kwargs): # real signature unknown
""" Update a set with the union of itself and others. """
pass 查看全部


集合基本功能


集合是一个无序的,不重复的数据组合,用{}表示,它的主要作用如下:
  1. 去重,把一个列表变成集合,就会自动去重
  2. 关系测试,测试两组数据之前的交集、差集、并集、子集等关系

 集合创建:
>>> set_job = set(['DEV', 'OPS', 'DBA', 'QA', 'Sales'])
>>> set_man = set(('lucky', 'jack', 'andy', 'tom', 'andy', 'jim'))
>>> print(set_job, type(set_job))
{'DEV', 'OPS', 'Sales', 'QA', 'DBA'} <class 'set'>
>>> print(set_man, type(set_man)) # 天生去重,只有一个andy了
{'andy', 'jack', 'lucky', 'tom', 'jim'} <class 'set'>

 
元素添加:
>>> set_job = set(['DEV', 'OPS', 'DBA', 'QA', 'Sales'])
>>> set_job.add('HR') # add方法只能添加一个
>>> print(set_job)
{'QA', 'HR', 'Sales', 'DEV', 'OPS', 'DBA'}
>>> set_job.update(['FD', 'MD', 'MD'])
>>> print(set_job)
{'QA', 'HR', 'Sales', 'DEV', 'MD', 'OPS', 'FD', 'DBA'}
>>> set_job.update(('AD', 'PD')) # update方法可以添加是列表或者元组,去重,如果添加的为一个单独字符串,则把字符串拆成字母添加到集合中
>>> print(set_job)
{'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}

元素删除:
>>> set_job = {'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.remove('PD') # 删除指定元素
>>> set_job.remove('xx') # 元素不存在则报错 KeyError
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'xx'
>>> print(set_job)
{'QA', 'HR', 'MD', 'DEV', 'Sales', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.pop() # 随机删除一个元素
'QA'
>>> print(set_job)
{'HR', 'MD', 'DEV', 'Sales', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.discard('OPS') # 指定删除
>>> set_job.discard('xxx') # 不存在返回None,不会报KeyError
>>> print(set_job)
{'HR', 'MD', 'DEV', 'Sales', 'AD', 'FD', 'DBA'}

其他:
>>> set_job = {'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}
>>> len(set_job)  # 集合长度
10
>>> 'QA' in set_job  # 判断是否在集合中
True
>>> 'XXX' not in set_job # 不在集合中
True
>>> for i in set_job:   # 循环
...     print(i)


集合关系测试


交集:
intercaiton.png
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> print(set_a.intersection(set_b)) # 常规方式
{5, 6}
>>> print(set_a & set_b) # 运算符(&)方式
{5, 6}

并集
bingji.png
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a.union(set_b)    # 关键字union做并集运算 先后顺序无关,谁并谁都可以
>>> print(set_c)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
>>> 
>>> set_c = set_a | set_b     # 运算符关键符 | 做并集运算  先后顺序无关,谁并谁都可以
>>> print(set_c)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

差集
chaji.png
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a - set_b # a集合跟b集合做差集 关键符 -
>>> print(set_c)
{8, 9, 10, 7}
>>> set_d = set_b - set_a # b集合跟a集合做差集 关键符 -
>>> print(set_d)
{1, 2, 3, 4}
>>> set_c = set_a.difference(set_b) # a集合跟b集合做差集 关键字difference
>>> print(set_c)
{8, 9, 10, 7}
>>> set_d = set_b.difference(set_a) # b集合跟a集合做差集 关键字difference
>>> print(set_d)
{1, 2, 3, 4}

 
子集父集
fuziji.png

拿苹果来打比方就是,把苹果掰开,然后掰开的一小部分就是子集,然后整个苹果就是父集
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = {7, 8, 9, 10}
>>> set_d = {1, 2, 3, 4}
>>> set_e = {5, 6}
>>> set_f = {11, 12, 13, 14, 15, 16}
>>> set_c.issubset(set_a) # 测试集合c是否是集合a的子集 放回布尔值 关键字issubset
True
>>> set_d.issubset(set_b) # 测试集合d是否是集合b的子集 返回布尔值 issubset
True
>>> set_e.issubset(set_a)
True
>>> set_e.issubset(set_b)
True
>>> set_e <= set_a # 测试集合e是否是集合a的子集 关键符 <=
True
>>> set_e <= set_b
True
>>> set_f.issuperset(set_a) # 测试f集合是否是a集合的父集
False
>>> set_a.issuperset(set_e) # 测试a集合是否是集合e的父集 关键字issuperset
True
>>> set_b >= set_e # 测试集合b是否是集合e的父集 关键符 >=
True
>>> set_b >= set_d
True

对称差集
对称差集就是两个集合去掉相同的部分,然后剩下的所有元素组成的集合
duichengchaji.png
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a.symmetric_difference(set_b) # 集合a和集合b做对称差集 关键字symmetric_difference
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}
>>> set_c = set_a ^ set_b # 集合a和集合b做对称差集 关键符 ^
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}
>>> set_c = set_b ^ set_a
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}

所有方法:
class set(object):
"""
set() -> new empty set object
set(iterable) -> new set object

Build an unordered collection of unique elements.
"""
def add(self, *args, **kwargs): # real signature unknown
"""
Add an element to a set.

This has no effect if the element is already present.
"""
pass

def clear(self, *args, **kwargs): # real signature unknown
""" Remove all elements from this set. """
pass

def copy(self, *args, **kwargs): # real signature unknown
""" Return a shallow copy of a set. """
pass

def difference(self, *args, **kwargs): # real signature unknown
"""
Return the difference of two or more sets as a new set.

(i.e. all elements that are in this set but not the others.)
"""
pass

def difference_update(self, *args, **kwargs): # real signature unknown
""" Remove all elements of another set from this set. """
pass

def discard(self, *args, **kwargs): # real signature unknown
"""
Remove an element from a set if it is a member.

If the element is not a member, do nothing.
"""
pass

def intersection(self, *args, **kwargs): # real signature unknown
"""
Return the intersection of two sets as a new set.

(i.e. all elements that are in both sets.)
"""
pass

def intersection_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the intersection of itself and another. """
pass

def isdisjoint(self, *args, **kwargs): # real signature unknown
""" Return True if two sets have a null intersection. """
pass

def issubset(self, *args, **kwargs): # real signature unknown
""" Report whether another set contains this set. """
pass

def issuperset(self, *args, **kwargs): # real signature unknown
""" Report whether this set contains another set. """
pass

def pop(self, *args, **kwargs): # real signature unknown
"""
Remove and return an arbitrary set element.
Raises KeyError if the set is empty.
"""
pass

def remove(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.
"""
pass

def symmetric_difference(self, *args, **kwargs): # real signature unknown
"""
Return the symmetric difference of two sets as a new set.

(i.e. all elements that are in exactly one of the sets.)
"""
pass

def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the symmetric difference of itself and another. """
pass

def union(self, *args, **kwargs): # real signature unknown
"""
Return the union of sets as a new set.

(i.e. all elements that are in either set.)
"""
pass

def update(self, *args, **kwargs): # real signature unknown
""" Update a set with the union of itself and others. """
pass

Python菜鸟之路基础篇(三)

采菊篱下 发表了文章 • 0 个评论 • 621 次浏览 • 2016-08-05 22:42 • 来自相关话题

列表

列表(list)是Python以及其他语言中最常用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。列表是可变的(mutable)——可以改变列表的内容。

列表是一组有序项目的集合 ,可变的数据类型【可进行增删改查】; 列表中可以包含任何数据类型,也可包含另一个列表【可任意组合嵌套】 列表是以方括号“”包围的数据集合,不同成员以“,”分隔 列表可通过序号访问其中成员.
 
1、创建列表>>> names = ['lucky', 'jack', 'tom', 'jim', 'erica'] #方法一
[quote]>> print(names)
['lucky', 'jack', 'tom', 'jim', 'erica'][/quote]

[quote]>> names = list(('jason', 'chris', 'andy', 'sunny', 'sun')) #方法二
>>> print(names)
['jason', 'chris', 'andy', 'sunny', 'sun']
 2、访问元素
通过下标访问列表中的元素,下标从0开始计数>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[1]
'UI'
>>> jobs[2]
'UE'
>>> jobs[4]
'DBA'
>>> jobs[-2] # 还可以倒数着来,不过下标从-1开始
'DBA'
 3、列表切片>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[1:4] # 取下标从1到4的元素,但是不包括4,列表切片的特征就是左开右闭,也就是左取右弃。
['UI', 'UE', 'OPS']
>>> jobs[1:-1] # 取下标为1到-1的元素,不包括-1,也就是最后一个元素不会被取出来。
['UI', 'UE', 'OPS', 'DBA']
>>> jobs[:] # 这个在切片符左右没有下标限制,所以就是代表全取
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[::] # 效果和上面一样,但是你会发现有两切片符,这是因为切片有一个步长的概念
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[0:3] # 取下标0到3的元素,但不包括3
['PM', 'UI', 'UE']
>>> jobs[:3] # 和上面效果一样
['PM', 'UI', 'UE']
>>> jobs[3:] # 从下标3开始,到最后一个元素
['OPS', 'DBA', 'DEV']
>>> jobs[3:-1] # 从下标3开始,到最后一个元素,但是不包括最后一个元素
['OPS', 'DBA']
>>> jobs[0::2] # 从下标0开始,按照2个步长取值
['PM', 'UE', 'DBA']
>>> jobs[::2] # 和上面效果一样
['PM', 'UE', 'DBA']利用下标取出的一个单独元素是str类型,而利用分片取出的是一个list类型。[/quote]

 4、列表追加>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
[quote]>> jobs.append('QA') #添加到最后
>>> jobs
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV', 'QA']
 5、列表插入>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.insert(2, 'Sales') # 从下标为2的元素后面插入,其实可以理解为我插入一个元素,下标为3
>>> jobs
['PM', 'UI', 'Sales', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.insert(-1, 'QA') # 也可以倒数着来
>>> jobs
['PM', 'UI', 'Sales', 'UE', 'OPS', 'DBA', 'QA', 'DEV']
 6、修改元素>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[2] = 'QA' # 把下标为2的元素替换成QA,根据下标然后给元素重新赋值
>>> jobs
['PM', 'UI', 'QA', 'OPS', 'DBA', 'DEV']
>>> jobs[-2] = 'Sales' # 把下标为12的元素替换成Sales,根据下标然后给元素重新赋值
>>> jobs
['PM', 'UI', 'QA', 'OPS', 'Sales', 'DEV']
7、删除元素>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> del jobs[-1] # del方法删除最后一个元素
>>> jobs
['PM', 'UI', 'UE', 'OPS', 'DBA']
>>> del jobs[1] # del方法删除下标为1的元素
>>> jobs
['PM', 'UE', 'OPS', 'DBA']
>>> jobs.remove("DBA") # 根据remove方法,指定你想删除的元素
>>> jobs
['PM', 'UE', 'OPS']
>>> jobs.pop() # pop方法,默认删除最后一个,返回删除元素
'OPS'
>>> jobs
['PM', 'UE']
>>> jobs.pop(0) # pop还可以指定元素下标,指定删除
'PM'
>>> jobs
['UE']
>>> jobs.clear() # clear 删除列表所有的元素,就是清空列表,变成为一个空列表
>>> jobs
remove方法删除一个元素,必须是在列表中的,否则会报错,del利用下标来删除元素,pop默认删除最后一个元素,也可以指定元素下标来删除。
 
8、扩展列表>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> job = ['Sales', 'QA', 'HR']
>>> jobs.extend(job) # extend方法就是把job列表里面的元素一个个添加到jobs列表中。
>>> jobs
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV', 'Sales', 'QA', 'HR']
9、列表拷贝>>> jobs
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs_copy = jobs.copy() # 复制一份jobs列表
>>> jobs_copy
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs = ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 嵌入式列表
>>> jobs_copy2 = jobs.copy()
>>> jobs_copy2
['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']]
>>> jobs[0] = 'HR' # 改变小标为0的元素
>>> jobs
['HR', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 改变了
>>> jobs_copy2
['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 没变
>>> jobs[-1][0] = 'Sales' # 改变内嵌列表的下标为0的元素
>>> jobs
['HR', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']] # 改变了
>>> jobs_copy2
['PM', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']] # 改变了从上面可以看出列表的copy方法是一个浅copy的栗子,只会拷贝第一次,而多层嵌入的话,会随着源列表的变化为变化,关于深拷贝和浅拷贝后面详细介绍。
 
10、列表统计>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.count('OPS') # 因为列表是有序的一种数据类型,所以它的元素是可以重叠的,所以有元素统计。
2
11、排序和翻转>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 1, 2, 3]
>>> jobs.sort()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str() # Python3.0里不同数据类型不能放在一起排序了,擦
>>> jobs[-1] = '3'
>>> jobs[-2] = '2'
>>> jobs[-3] = '1'
>>> jobs
['DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI', '1', '2', '3']
>>> jobs.sort()
>>> jobs
['1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']
>>> jobs.append('#')
>>> jobs.append('&')
>>> jobs.sort()
>>> jobs
['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI'] # 可以看出排序的顺序 特殊字符->数字->字母 这么一个优先级
>>> jobs.reverse() # 翻转最后到最前面
>>> jobs
['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']sort()方法会修改原列表,而不是创建一个新的有序列表,reverse()也会修改原列表,但是你希望排序,但是又不希望修改原列表,你只能利用python中一个名为sorted()的内置函数来操作:>>> jobs = ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
>>> newlist = sorted(jobs)
>>> jobs
['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
>>> newlist
['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']
12、列表索引>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 'UE']
>>> jobs.index('OPS')
2
>>> jobs.index('UE')
3
>>> jobs.index('xx')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'xx' is not in list
>>> if 'OPS' in jobs:
... print(jobs.index('OPS'))
...
2索引下标,只会返回第一个元素的下标,如果元素不在列表中,会报错,我们可以利用in这个关键之来判断元素是否在列表中。
 
列表所有的方法如下:class list(object):
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
"""
def append(self, p_object): # real signature unknown; restored from __doc__
""" L.append(object) -> None -- append object to end """
pass[/quote]

def clear(self): # real signature unknown; restored from __doc__
""" L.clear() -> None -- remove all items from L """
pass

def copy(self): # real signature unknown; restored from __doc__
""" L.copy() -> list -- a shallow copy of L """
return

def count(self, value): # real signature unknown; restored from __doc__
""" L.count(value) -> integer -- return number of occurrences of value """
return 0

def extend(self, iterable): # real signature unknown; restored from __doc__
""" L.extend(iterable) -> None -- extend list by appending elements from the iterable """
pass

def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
"""
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return 0

def insert(self, index, p_object): # real signature unknown; restored from __doc__
""" L.insert(index, object) -- insert object before index """
pass

def pop(self, index=None): # real signature unknown; restored from __doc__
"""
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
"""
pass

def remove(self, value): # real signature unknown; restored from __doc__
"""
L.remove(value) -> None -- remove first occurrence of value.
Raises ValueError if the value is not present.
"""
pass

def reverse(self): # real signature unknown; restored from __doc__
""" L.reverse() -- reverse [i]IN PLACE[/i] """
pass

def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
""" L.sort(key=None, reverse=False) -> None -- stable sort [i]IN PLACE[/i] """
pass
 
13、列表的遍历
在Python中常用循环对象来遍历列表,在这里for循环自动调用next()方法,将该方法的返回值赋予给循环对象i。循环检测到StopIteration的时候才结束。相对于序列,用循环对象的好处在于:不用在循环还没有开始的时候,就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样,节省了空间,提高了效率,编程更灵活。#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

jobs = ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']

for i in jobs:
print(i) # 自动调用迭代器,自动检测StopIteration

# 在上面的程序中,无法知道当前访问元素的索引,于是有如下代码:
for i in range(len(jobs)):
print(jobs[i])

# 同时需要索引,又结合迭代器,就可以采用内置的enumerate函数,代码如下:
for index, i in enumerate(jobs):
print(index, i)[/i]
扩展:(表推导方法)
表推导(list comprehension)是快速生成列表的方法。它的语法简单,很有实用价值。[i]L = [x**2 for x in range(10)]
print(L)

Result:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81][/i]
 zip函数
如果你多个等长的序列,然后想要每次循环时从各个序列分别取出一个元素,可以利用zip()方便地实现:[i]t1 = [1, 2, 3]
t2 = [9, 8, 7]
t3 = ['a', 'b', 'c']
for (a, b, c) in zip(t1, t2, t3):
print(a, b, c)

Result:
1 9 a
2 8 b
3 7 c[/i]
 每次循环时,从各个序列分别从左到右取出一个元素,合并成一个tuple,然后tuple的元素赋予给a,b,c[i]#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

ShopName = ['iphone', 'MacPro', 'iWatch']
money = [5500, 12000, 3800]

Car =
for it in zip(ShopName, money):
Car.append(it)
print(Car)

Result:
[('iphone', 5500), ('MacPro', 12000), ('iWatch', 3800)][/i]
 

元组

元组其实跟列表差不多,也是存一组数,只不是它一旦创建,便不能再修改,所以又叫只读列表,用小括号()表示。
 
元组创建:
>>> tup1 = () # 创建空元组
[quote]>> tup2 = ('DEV', 'DBA', 1, 2, 3) # 中括号方式
>>> tup3 = "x", "y", "z" # 字符串排列方式
>>>
# 元组中只包含一个元素时,需要在元素后面添加逗号
>>> tup4 = ('openskill')
>>> print(tup4)
openskill
>>> tup5 = ('openskill.cn',)
>>> print(tup5)
('openskill.cn',)元组与字符串类似,下标索引从0开始,可以进行截取,组合等。[/quote]

访问元组
元组可以使用下标索引来访问元组中的值,如下实例:
 
 
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

tup1 = ('Python', 'PHP', 1989, 1994)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])Result:
tup1[0]: Python
tup2[1:5]: (2, 3, 4, 5)
 修改元组
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例:#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

tup1 = (200000, 400000)
tup2 = ('MG', 'JD')

# 以下修改元组元素操作是非法的。
# tup1[0] = 100;

# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)Resutl:
code[/code]
删除元组
 
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例:
 
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

tup = ('dog', 'cat', 3000, 2000)

print(tup)
del tup
print("After deleting tup : ")
print(tup)以上实例元组被删除后,输出变量会有异常信息,输出如下所示:

code
After deleting tup :
Traceback (most recent call last):
File "/Users/crh/PycharmProjects/s14/day3/qixi.py", line 10, in <module>
print(tup)
NameError: name 'tup' is not defined[/code]
 元组运算符
与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。




 
元组索引,截取
 
因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素,如下所示:
 
L = ('spam', 'Spam', 'SPAM!')



 
无关闭分隔符
 
任意无符号的对象,以逗号隔开,默认为元组,如下实例:
 
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

print('abc', -4.24e93, 18+6.6j, 'xyz')
x, y = 1, 2
print("Value of x , y : ", x, y)以上实例运行结果:abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2
 元组内置方法
a = (1, 2, 3, 4, 3, 2, 1, 4)

print(a.count(2)) # count方法统计元素的个数
print(a.index(2)) # index检索元素的下标,默认是第一个元素
print(a.index(2, 4, 6)) # 可以指定下标范围来检索
 
系统内置函数
 
Python元组包含了以下内置函数




 

字典

 
字典是另一种可变容器模型,且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,使用就像我们上学用的字典,通过笔划、字母来查对应页的详细内容,格式如下所示:
d = {key1 : value1, key2 : value2 }字典的特性:
[]dict是无序的[/][]key必须是唯一的,天生去重[/]
 
元素添加
>>> d = {'name': 'lucky', 'job': 'IT', 'gender': 'man'}
[quote]>> d['address'] = 'BJ'
>>> print(d)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
元素修改
>>> d = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> d['address'] = 'SH'
>>> print(d)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'SH'}[/quote]

# 把北京修改为上海
元素删除
>>> d = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
[quote]>> d.pop('gender')    # 标准删除一个,如果元素不存在会报错
'man'
>>> print(d)
{'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> 
>>> del d['job']     # 内置函数删除,如果元素不存在会报错
>>> print(d)
{'name': 'lucky', 'address': 'BJ'}
>>> 
>>> d.popitem()   # 随机删除,如果字典为空报错
('name', 'lucky')
>>> print(d)
{'address': 'BJ'}
>>> del d   # 删除整个字典
元素查找
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> 'job' in info # 判断元素是否在字典中
True
>>> info.get('job') # 获取
'IT'
>>> info['name'] # 跟列表获取index一样
'lucky'
>>> info['phone'] # 如果不存在的key会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'phone'
>>> info.get('phone') # get方法则不会
>>> if 'job' in info: info.get('job') # 标准获取方法
...
'IT'
多级字典嵌套
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen[/quote]

av_catalog = {
"欧美": {
"www.youporn.com": ["很多免费的,世界最大的","质量一般"],
"www.youjizz.com": ["都是免费的,挺多", "质量还不错"],
"www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
"x-art.com": ["质量很高,真的很高","全部收费,屌比请绕过"]
},
"日韩": {
"tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
},
"大陆": {
"1024": ["全部免费,真好,好人一生平安","服务器在国外,慢"],
"720lu": ["很多免费的,小众", "访问速度还行"]
}
}

# 嵌套逻辑就是 AV层---->国家层---->网站层---->说明层(列表)
# 一切皆可嵌套

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

# 执行结果
['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']
其他方法
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
[quote]>> info.clear() # 清空字典
>>> print(info)
{}
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> cinfo = info.copy() # 字典浅copy
>>> print(info, cinfo)
({'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}, {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'})
>>> print(info)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> print(cinfo)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'SH']}
>>> cinfo = info.copy()
>>> info['address'][1] = 'TJ'
>>> print(info)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'TJ']}
>>> print(cinfo)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'TJ']}
>>> info['address'] = 'BJ'
>>> print(cinfo)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'TJ']}
>>> print(info)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>>
>>> dict.fromkeys([1,2,3],'testd') # 通过一个列表生成默认dict,有个没办法解释的坑,少用吧这个
{1: 'testd', 2: 'testd', 3: 'testd'}
>>> info.items() # 把key和value 编程一个元组放到列表中
[('gender', 'man'), ('job', 'IT'), ('name', 'lucky'), ('address', 'BJ')]
>>> info.keys() # 获取所有的key
['gender', 'job', 'name', 'address']
>>>
>>> info.setdefault('wage', '2000') # 添加一个元素,如果存在则不添加
'2000'
>>> info
{'wage': '2000', 'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> info.setdefault('gender', 'woman')
'man'
>>> info
{'wage': '2000', 'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> info.values() # 获取所有的value
['2000', 'man', 'IT', 'lucky', 'BJ']
>>> db = {'db': 'mysql', 'job': 'IT'}
>>> info.update(db) # 更新字典,相当于合并,但是相同的key的不会合并过来
>>> info
{'wage': '2000', 'job': 'IT', 'name': 'lucky', 'address': 'BJ', 'gender': 'man', 'db': 'mysql'}所有方法说明如下:
class dict(object):
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
"""
def clear(self): # real signature unknown; restored from __doc__
""" D.clear() -> None. Remove all items from D. """
pass[/quote]

def copy(self): # real signature unknown; restored from __doc__
""" D.copy() -> a shallow copy of D """
pass

@staticmethod # known case
def fromkeys([i]args, [/i]*kwargs): # real signature unknown
""" Returns a new dict with keys from iterable and values equal to value. """
pass

def get(self, k, d=None): # real signature unknown; restored from __doc__
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
pass

def items(self): # real signature unknown; restored from __doc__
""" D.items() -> a set-like object providing a view on D's items """
pass

def keys(self): # real signature unknown; restored from __doc__
""" D.keys() -> a set-like object providing a view on D's keys """
pass

def pop(self, k, d=None): # real signature unknown; restored from __doc__
"""
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
"""
pass

def popitem(self): # real signature unknown; restored from __doc__
"""
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
"""
pass

def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
""" D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
pass

def update(self, E=None, **F): # known special case of dict.update
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
"""
pass

def values(self): # real signature unknown; restored from __doc__
""" D.values() -> an object providing a view on D's values """
pass
字典的遍历
#方法1
for key in info:
print(key,info[key])

#方法2
for k,v in info.items(): #会先把dict转成list,数据里大时莫用
print(k,v)
未完待续,下面介绍set集合。。。。。。。。 查看全部


列表


列表(list)是Python以及其他语言中最常用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。列表是可变的(mutable)——可以改变列表的内容。

列表是一组有序项目的集合 ,可变的数据类型【可进行增删改查】; 列表中可以包含任何数据类型,也可包含另一个列表【可任意组合嵌套】 列表是以方括号“”包围的数据集合,不同成员以“,”分隔 列表可通过序号访问其中成员.
 
1、创建列表
>>> names = ['lucky', 'jack', 'tom', 'jim', 'erica']    #方法一
[quote]>> print(names)
['lucky', 'jack', 'tom', 'jim', 'erica'][/quote]

[quote]>> names = list(('jason', 'chris', 'andy', 'sunny', 'sun')) #方法二
>>> print(names)
['jason', 'chris', 'andy', 'sunny', 'sun']

 2、访问元素
通过下标访问列表中的元素,下标从0开始计数
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[1]
'UI'
>>> jobs[2]
'UE'
>>> jobs[4]
'DBA'
>>> jobs[-2] # 还可以倒数着来,不过下标从-1开始
'DBA'

 3、列表切片
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[1:4] # 取下标从1到4的元素,但是不包括4,列表切片的特征就是左开右闭,也就是左取右弃。
['UI', 'UE', 'OPS']
>>> jobs[1:-1] # 取下标为1到-1的元素,不包括-1,也就是最后一个元素不会被取出来。
['UI', 'UE', 'OPS', 'DBA']
>>> jobs[:] # 这个在切片符左右没有下标限制,所以就是代表全取
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[::] # 效果和上面一样,但是你会发现有两切片符,这是因为切片有一个步长的概念
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[0:3] # 取下标0到3的元素,但不包括3
['PM', 'UI', 'UE']
>>> jobs[:3] # 和上面效果一样
['PM', 'UI', 'UE']
>>> jobs[3:] # 从下标3开始,到最后一个元素
['OPS', 'DBA', 'DEV']
>>> jobs[3:-1] # 从下标3开始,到最后一个元素,但是不包括最后一个元素
['OPS', 'DBA']
>>> jobs[0::2] # 从下标0开始,按照2个步长取值
['PM', 'UE', 'DBA']
>>> jobs[::2] # 和上面效果一样
['PM', 'UE', 'DBA']
利用下标取出的一个单独元素是str类型,而利用分片取出的是一个list类型。[/quote]

 4、列表追加
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
[quote]>> jobs.append('QA') #添加到最后
>>> jobs
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV', 'QA']

 5、列表插入
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.insert(2, 'Sales') # 从下标为2的元素后面插入,其实可以理解为我插入一个元素,下标为3
>>> jobs
['PM', 'UI', 'Sales', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.insert(-1, 'QA') # 也可以倒数着来
>>> jobs
['PM', 'UI', 'Sales', 'UE', 'OPS', 'DBA', 'QA', 'DEV']

 6、修改元素
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[2] = 'QA' # 把下标为2的元素替换成QA,根据下标然后给元素重新赋值
>>> jobs
['PM', 'UI', 'QA', 'OPS', 'DBA', 'DEV']
>>> jobs[-2] = 'Sales' # 把下标为12的元素替换成Sales,根据下标然后给元素重新赋值
>>> jobs
['PM', 'UI', 'QA', 'OPS', 'Sales', 'DEV']

7、删除元素
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> del jobs[-1] # del方法删除最后一个元素
>>> jobs
['PM', 'UI', 'UE', 'OPS', 'DBA']
>>> del jobs[1] # del方法删除下标为1的元素
>>> jobs
['PM', 'UE', 'OPS', 'DBA']
>>> jobs.remove("DBA") # 根据remove方法,指定你想删除的元素
>>> jobs
['PM', 'UE', 'OPS']
>>> jobs.pop() # pop方法,默认删除最后一个,返回删除元素
'OPS'
>>> jobs
['PM', 'UE']
>>> jobs.pop(0) # pop还可以指定元素下标,指定删除
'PM'
>>> jobs
['UE']
>>> jobs.clear() # clear 删除列表所有的元素,就是清空列表,变成为一个空列表
>>> jobs
remove方法删除一个元素,必须是在列表中的,否则会报错,del利用下标来删除元素,pop默认删除最后一个元素,也可以指定元素下标来删除。
 
8、扩展列表
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> job = ['Sales', 'QA', 'HR']
>>> jobs.extend(job) # extend方法就是把job列表里面的元素一个个添加到jobs列表中。
>>> jobs
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV', 'Sales', 'QA', 'HR']

9、列表拷贝
>>> jobs
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs_copy = jobs.copy() # 复制一份jobs列表
>>> jobs_copy
['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs = ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 嵌入式列表
>>> jobs_copy2 = jobs.copy()
>>> jobs_copy2
['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']]
>>> jobs[0] = 'HR' # 改变小标为0的元素
>>> jobs
['HR', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 改变了
>>> jobs_copy2
['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 没变
>>> jobs[-1][0] = 'Sales' # 改变内嵌列表的下标为0的元素
>>> jobs
['HR', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']] # 改变了
>>> jobs_copy2
['PM', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']] # 改变了
从上面可以看出列表的copy方法是一个浅copy的栗子,只会拷贝第一次,而多层嵌入的话,会随着源列表的变化为变化,关于深拷贝和浅拷贝后面详细介绍。
 
10、列表统计
>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.count('OPS') # 因为列表是有序的一种数据类型,所以它的元素是可以重叠的,所以有元素统计。
2

11、排序和翻转
>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 1, 2, 3]
>>> jobs.sort()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str() # Python3.0里不同数据类型不能放在一起排序了,擦
>>> jobs[-1] = '3'
>>> jobs[-2] = '2'
>>> jobs[-3] = '1'
>>> jobs
['DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI', '1', '2', '3']
>>> jobs.sort()
>>> jobs
['1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']
>>> jobs.append('#')
>>> jobs.append('&')
>>> jobs.sort()
>>> jobs
['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI'] # 可以看出排序的顺序 特殊字符->数字->字母 这么一个优先级
>>> jobs.reverse() # 翻转最后到最前面
>>> jobs
['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
sort()方法会修改原列表,而不是创建一个新的有序列表,reverse()也会修改原列表,但是你希望排序,但是又不希望修改原列表,你只能利用python中一个名为sorted()的内置函数来操作:
>>> jobs = ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
>>> newlist = sorted(jobs)
>>> jobs
['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
>>> newlist
['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']

12、列表索引
>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 'UE']
>>> jobs.index('OPS')
2
>>> jobs.index('UE')
3
>>> jobs.index('xx')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'xx' is not in list
>>> if 'OPS' in jobs:
... print(jobs.index('OPS'))
...
2
索引下标,只会返回第一个元素的下标,如果元素不在列表中,会报错,我们可以利用in这个关键之来判断元素是否在列表中。
 
列表所有的方法如下:
class list(object):
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
"""
def append(self, p_object): # real signature unknown; restored from __doc__
""" L.append(object) -> None -- append object to end """
pass[/quote]

def clear(self): # real signature unknown; restored from __doc__
""" L.clear() -> None -- remove all items from L """
pass

def copy(self): # real signature unknown; restored from __doc__
""" L.copy() -> list -- a shallow copy of L """
return

def count(self, value): # real signature unknown; restored from __doc__
""" L.count(value) -> integer -- return number of occurrences of value """
return 0

def extend(self, iterable): # real signature unknown; restored from __doc__
""" L.extend(iterable) -> None -- extend list by appending elements from the iterable """
pass

def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
"""
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return 0

def insert(self, index, p_object): # real signature unknown; restored from __doc__
""" L.insert(index, object) -- insert object before index """
pass

def pop(self, index=None): # real signature unknown; restored from __doc__
"""
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
"""
pass

def remove(self, value): # real signature unknown; restored from __doc__
"""
L.remove(value) -> None -- remove first occurrence of value.
Raises ValueError if the value is not present.
"""
pass

def reverse(self): # real signature unknown; restored from __doc__
""" L.reverse() -- reverse [i]IN PLACE[/i] """
pass

def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
""" L.sort(key=None, reverse=False) -> None -- stable sort [i]IN PLACE[/i] """
pass

 
13、列表的遍历
在Python中常用循环对象来遍历列表,在这里for循环自动调用next()方法,将该方法的返回值赋予给循环对象i。循环检测到StopIteration的时候才结束。相对于序列,用循环对象的好处在于:不用在循环还没有开始的时候,就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样,节省了空间,提高了效率,编程更灵活。
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

jobs = ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']

for i in jobs:
print(i) # 自动调用迭代器,自动检测StopIteration

# 在上面的程序中,无法知道当前访问元素的索引,于是有如下代码:
for i in range(len(jobs)):
print(jobs[i])

# 同时需要索引,又结合迭代器,就可以采用内置的enumerate函数,代码如下:
for index, i in enumerate(jobs):
print(index, i)[/i]

扩展:(表推导方法)
表推导(list comprehension)是快速生成列表的方法。它的语法简单,很有实用价值。
[i]L = [x**2 for x in range(10)]
print(L)

Result:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81][/i]

 zip函数
如果你多个等长的序列,然后想要每次循环时从各个序列分别取出一个元素,可以利用zip()方便地实现:
[i]t1 = [1, 2, 3]
t2 = [9, 8, 7]
t3 = ['a', 'b', 'c']
for (a, b, c) in zip(t1, t2, t3):
print(a, b, c)

Result:
1 9 a
2 8 b
3 7 c[/i]

 每次循环时,从各个序列分别从左到右取出一个元素,合并成一个tuple,然后tuple的元素赋予给a,b,c
[i]#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

ShopName = ['iphone', 'MacPro', 'iWatch']
money = [5500, 12000, 3800]

Car =
for it in zip(ShopName, money):
Car.append(it)
print(Car)

Result:
[('iphone', 5500), ('MacPro', 12000), ('iWatch', 3800)][/i]

 


元组


元组其实跟列表差不多,也是存一组数,只不是它一旦创建,便不能再修改,所以又叫只读列表,用小括号()表示。
 
元组创建:
>>> tup1 = ()    # 创建空元组
[quote]>> tup2 = ('DEV', 'DBA', 1, 2, 3) # 中括号方式
>>> tup3 = "x", "y", "z" # 字符串排列方式
>>>
# 元组中只包含一个元素时,需要在元素后面添加逗号
>>> tup4 = ('openskill')
>>> print(tup4)
openskill
>>> tup5 = ('openskill.cn',)
>>> print(tup5)
('openskill.cn',)
元组与字符串类似,下标索引从0开始,可以进行截取,组合等。[/quote]

访问元组
元组可以使用下标索引来访问元组中的值,如下实例:
 
 
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

tup1 = ('Python', 'PHP', 1989, 1994)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])
Result:
tup1[0]:  Python
tup2[1:5]: (2, 3, 4, 5)

 修改元组
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例:
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

tup1 = (200000, 400000)
tup2 = ('MG', 'JD')

# 以下修改元组元素操作是非法的。
# tup1[0] = 100;

# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)
Resutl:
code[/code]
删除元组
 
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例:
 
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

tup = ('dog', 'cat', 3000, 2000)

print(tup)
del tup
print("After deleting tup : ")
print(tup)
以上实例元组被删除后,输出变量会有异常信息,输出如下所示:

code
After deleting tup :
Traceback (most recent call last):
File "/Users/crh/PycharmProjects/s14/day3/qixi.py", line 10, in <module>
print(tup)
NameError: name 'tup' is not defined[/code]
 元组运算符
与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。
yunsuan.png

 
元组索引,截取
 
因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素,如下所示:
 
L = ('spam', 'Spam', 'SPAM!')
index.png

 
无关闭分隔符
 
任意无符号的对象,以逗号隔开,默认为元组,如下实例:
 
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

print('abc', -4.24e93, 18+6.6j, 'xyz')
x, y = 1, 2
print("Value of x , y : ", x, y)
以上实例运行结果:
abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

 元组内置方法
a = (1, 2, 3, 4, 3, 2, 1, 4)

print(a.count(2)) # count方法统计元素的个数
print(a.index(2)) # index检索元素的下标,默认是第一个元素
print(a.index(2, 4, 6)) # 可以指定下标范围来检索

 
系统内置函数
 
Python元组包含了以下内置函数
func.png

 


字典


 
字典是另一种可变容器模型,且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,使用就像我们上学用的字典,通过笔划、字母来查对应页的详细内容,格式如下所示:
d = {key1 : value1, key2 : value2 }
字典的特性:
    []dict是无序的[/][]key必须是唯一的,天生去重[/]

 
元素添加
>>> d = {'name': 'lucky', 'job': 'IT', 'gender': 'man'}
[quote]>> d['address'] = 'BJ'
>>> print(d)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}

元素修改
>>> d = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> d['address'] = 'SH'
>>> print(d)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'SH'}[/quote]

# 把北京修改为上海

元素删除
>>> d = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
[quote]>> d.pop('gender')    # 标准删除一个,如果元素不存在会报错
'man'
>>> print(d)
{'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> 
>>> del d['job']     # 内置函数删除,如果元素不存在会报错
>>> print(d)
{'name': 'lucky', 'address': 'BJ'}
>>> 
>>> d.popitem()   # 随机删除,如果字典为空报错
('name', 'lucky')
>>> print(d)
{'address': 'BJ'}
>>> del d   # 删除整个字典

元素查找
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> 'job' in info # 判断元素是否在字典中
True
>>> info.get('job') # 获取
'IT'
>>> info['name'] # 跟列表获取index一样
'lucky'
>>> info['phone'] # 如果不存在的key会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'phone'
>>> info.get('phone') # get方法则不会
>>> if 'job' in info: info.get('job') # 标准获取方法
...
'IT'

多级字典嵌套
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen[/quote]

av_catalog = {
"欧美": {
"www.youporn.com": ["很多免费的,世界最大的","质量一般"],
"www.youjizz.com": ["都是免费的,挺多", "质量还不错"],
"www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
"x-art.com": ["质量很高,真的很高","全部收费,屌比请绕过"]
},
"日韩": {
"tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
},
"大陆": {
"1024": ["全部免费,真好,好人一生平安","服务器在国外,慢"],
"720lu": ["很多免费的,小众", "访问速度还行"]
}
}

# 嵌套逻辑就是 AV层---->国家层---->网站层---->说明层(列表)
# 一切皆可嵌套

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

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

其他方法
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
[quote]>> info.clear() # 清空字典
>>> print(info)
{}
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> cinfo = info.copy() # 字典浅copy
>>> print(info, cinfo)
({'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}, {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'})
>>> print(info)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> print(cinfo)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'SH']}
>>> cinfo = info.copy()
>>> info['address'][1] = 'TJ'
>>> print(info)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'TJ']}
>>> print(cinfo)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'TJ']}
>>> info['address'] = 'BJ'
>>> print(cinfo)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'TJ']}
>>> print(info)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>>
>>> dict.fromkeys([1,2,3],'testd') # 通过一个列表生成默认dict,有个没办法解释的坑,少用吧这个
{1: 'testd', 2: 'testd', 3: 'testd'}
>>> info.items() # 把key和value 编程一个元组放到列表中
[('gender', 'man'), ('job', 'IT'), ('name', 'lucky'), ('address', 'BJ')]
>>> info.keys() # 获取所有的key
['gender', 'job', 'name', 'address']
>>>
>>> info.setdefault('wage', '2000') # 添加一个元素,如果存在则不添加
'2000'
>>> info
{'wage': '2000', 'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> info.setdefault('gender', 'woman')
'man'
>>> info
{'wage': '2000', 'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> info.values() # 获取所有的value
['2000', 'man', 'IT', 'lucky', 'BJ']
>>> db = {'db': 'mysql', 'job': 'IT'}
>>> info.update(db) # 更新字典,相当于合并,但是相同的key的不会合并过来
>>> info
{'wage': '2000', 'job': 'IT', 'name': 'lucky', 'address': 'BJ', 'gender': 'man', 'db': 'mysql'}
所有方法说明如下:
class dict(object):
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
"""
def clear(self): # real signature unknown; restored from __doc__
""" D.clear() -> None. Remove all items from D. """
pass[/quote]

def copy(self): # real signature unknown; restored from __doc__
""" D.copy() -> a shallow copy of D """
pass

@staticmethod # known case
def fromkeys([i]args, [/i]*kwargs): # real signature unknown
""" Returns a new dict with keys from iterable and values equal to value. """
pass

def get(self, k, d=None): # real signature unknown; restored from __doc__
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
pass

def items(self): # real signature unknown; restored from __doc__
""" D.items() -> a set-like object providing a view on D's items """
pass

def keys(self): # real signature unknown; restored from __doc__
""" D.keys() -> a set-like object providing a view on D's keys """
pass

def pop(self, k, d=None): # real signature unknown; restored from __doc__
"""
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
"""
pass

def popitem(self): # real signature unknown; restored from __doc__
"""
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
"""
pass

def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
""" D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
pass

def update(self, E=None, **F): # known special case of dict.update
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
"""
pass

def values(self): # real signature unknown; restored from __doc__
""" D.values() -> an object providing a view on D's values """
pass

字典的遍历
#方法1
for key in info:
print(key,info[key])

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

未完待续,下面介绍set集合。。。。。。。。

Python菜鸟之路基础篇(二)

采菊篱下 发表了文章 • 0 个评论 • 681 次浏览 • 2016-08-05 10:19 • 来自相关话题

简单模块初识

很多人都说Python的扩展性很强,有很多第三方的类库,那这些类库到底怎么使用呢,其实在Python语言中不管是内置的类库和其他开发扩展的类库,在Python中我们习惯把它叫做「模块」。那模块该怎么用呢?不着急下面我们简单介绍几个常用的内库「内裤吗?」。
1、sys (系统内裤)#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

import sys

# Python全局环境变量路径
print(sys.path)

# 打印传递给脚本的第二个参数
print(sys.argv[2])Result:['/Users/crh/PycharmProjects/app', '/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/Versions/3.5/lib/python35.zip', '/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/Versions/3.5/lib/python3.5', '/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/Versions/3.5/lib/python3.5/plat-darwin', '/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/Versions/3.5/lib/python3.5/lib-dynload', '/usr/local/lib/python3.5/site-packages']
2说明一下Python的环境变量,比如我们导入一个模块它先到你本路径找有没有,然后回到Python的环境路径下再去找,一般扩展的模块安装后都会在site-packages的路径下。
 
2、os(系统内裤)#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

import os

# 调用系统命令
os.system("df -h")Result:Filesystem Size Used Avail Capacity iused ifree %iused Mounted on
/dev/disk1 233Gi 80Gi 153Gi 35% 20947137 40038205 34% /
devfs 181Ki 181Ki 0Bi 100% 626 0 100% /dev
map -hosts 0Bi 0Bi 0Bi 100% 0 0 100% /net
map auto_home 0Bi 0Bi 0Bi 100% 0 0 100% /home
3、sys、os结合玩一玩:#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

import os
import sys

# 把用户传入的参数当做命令执行
os.system(''.join(sys.argv[1:])) 
4、自己编写简单模块
Python tab补全模块:
Linux版本:#!/usr/bin/env python3
# python startup file
import sys
import readline
import rlcompleter
import atexit
import os
# tab completion
readline.parse_and_bind('tab: complete')
# history file
histfile = os.path.join(os.environ['HOME'], '.pythonhistory')
try:
readline.read_history_file(histfile)
except IOError:
pass
atexit.register(readline.write_history_file, histfile)
del os, histfile, readline, rlcompleterMac版:# linux and python3 on mac
import sys
import readline
import rlcompleter

if sys.platform == 'darwin' and sys.version_info[0] == 2:
readline.parse_and_bind("bind ^I rl_complete")
else:
readline.parse_and_bind("tab: complete") 写完保存后就可以导入使用:>>> import tab
[quote]>> import os
>>> os.
Display all 234 possibilities? (y or n)
>>> os.sy
os.symlink( os.sys os.sysconf( os.sysconf_names os.system(
>>> os.sy
os.symlink( os.sys os.sysconf( os.sysconf_names os.system(
>>> os.sy你会发现,上面自己写的tab.py模块只能在当前目录下导入,如果想在系统的何何一个地方都使用怎么办呢? 此时你就要把这个tab.py放到python全局环境变量目录里啦,基本一般都放在一个叫 site-packages 目录下,这个目录在不同的OS里放的位置不一样,用 print(sys.path) 可以查看python环境变量列表。
 

基础数据类型认识

A、数字2 是一个整数的例子。
长整数 不过是大一些的整数。
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里,52.3E-4表示52.3 * 10-4。
(-5+4j)和(2.3-4.6j)是复数的例子,其中-5,4为实数,j为虚数,数学中表示复数是什么?。数学中表示复数的虚数是n,而Python中跟大数据计算一样统一用的是j。
 
1、int(整型)在32位机器上,整数的位数为32位,取值范围为-2[b]31~2[/b]31-1,即-2147483648~2147483647
在64位系统上,整数的位数为64位,取值范围为-2[b]63~2[/b]63-1,即-9223372036854775808~9223372036854775807
所以不同的操作系统中数据的长度是有限制范围的,就好像32位系统最多支持4GB内存一样。
 
在我们里面12、34、56、100000等都是整型。#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen[/quote]

a = '3'
print(type(a))

b = int(a)
print(type(a))其他具体功能可以查看帮助:




 
2、long(长整型)跟C语言不同,Python的长整数没有指定位宽,即:Python没有限制长整数数值的大小,但实际上由于机器内存有限,我们使用的长整数数值不可能无限大。
注意,自从Python2.2起,如果整数发生溢出,Python会自动将整数数据转换为长整数,所以如今在长整数数据后面不加字母L也不会导致严重后果了。如:9223372036854775808、922337203685477580800  默认在Python2版本里面超过263 就是长整型,而Python3.中都是整型。>>> print(type(2[/b]63))
<type 'long'>
[quote]>> print(type(2**62))
<type 'int'> [b]3、float(浮点型)浮点数用来处理实数,即带有小数的数字。类似于C语言中的double类型,占8个字节(64位),其中52位表示底,11位表示指数,剩下的一位表示符号。例如:1.2 、0.98、100.38 都是浮点类型#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen[/quote]

a = 3
print(type(a))

b = float(a)

print(type(b), b)<class 'int'>
<class 'float'> 3.0具体更多功能查看帮助:





4、complex(复数)复数由实数部分和虚数部分组成,一般形式为x+yj,其中的x是复数的实数部分,y是复数的虚数部分,这里的x和y都是实数。注:Python中存在小数字池:-5 ~ 257
比如:1+2j,3+6j等都是复数#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

a = (3-4j).conjugate()

print(a)

print(type(a))

# 结果
(3+4j)
<class 'complex'>具体更多功能查看帮助:





B、布尔值在Python的世界里面有一个叫布尔值的东西,其实就是 真或假 1 或 0,简单点就是True和False。
在其他的配置或者语言里面,我们都知道把某个东西打开需要把他调试为True,关闭则设置为False。
在Python里面也是一样True就代表为真,条件成立;False就代表为假,条件不成立;1代表为真,0
代表假。#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

a, b = 1, 0

if a:
print("a is True")
else:
print("a is False")

if b:
print("b is True")
else:
print("b is False")

# 结果
a is True
b is False
C、字符串
1、拼接
在之前的文章http://openskill.cn/article/415  里已经介绍过了字符串拼接的方法如:+  %  format函数等。Python中的字符串在C语言中体现为是一个字符数组,每次创建字符串时候需要在内存中开辟一块连续的空,并且一旦需要修改字符串的话,就需要再次开辟空间,万恶的+号每出现一次就会在内从中重新开辟一块空间。所以最好不要用+比较好name = "lucky"
print "i am %s " % name

#输出: i am luckyPS: 字符串是 %s;整数 %d;浮点数%f

2、字符串常用功能介绍
移除空白:
rstrip 去掉右边的空格以及tab制表符def rstrip(self, [i]args, [/i]*kwargs): # real signature unknown
"""
Strip trailing bytes contained in the argument.

If the argument is omitted or None, strip trailing ASCII whitespace.
"""
passmsg = " my name is lucky "

print("[i][b][/i]" + msg.lstrip() + "[/b]*")

Result:
[i][b][/i]  my name is lucky[/b]*lstrip 去掉左边的空格以及tab制表符def lstrip(self, chars=None): # real signature unknown; restored from __doc__
"""
S.lstrip([chars]) -> str

Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
"""
return ""msg = " my name is lucky "
info = " game is\tlol\tover!"

print("[b][i]" + msg.lstrip() + "[/b][/i]")
print("[b][i]" + info.lstrip() + "[/b][/i]")

Result:
[b][i]my name is lucky [/b][/i]
[b][i]game is lol over![/b][/i]strip 去除字符串两边的空格和换行def strip(self, chars=None): # real signature unknown; restored from __doc__
"""
S.strip([chars]) -> str

Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
"""
return ""msg = " ox\nB "

print("[b][i]" + msg.strip() + "[/b][/i]")

Result:
***ox
B***
分割:
splitlines 使用回车符进行字符串分片,最后得到一个列表def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
"""
S.splitlines([keepends]) -> list of strings

Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
"""
return msg = "niu\nbai"
print(msg.splitlines())

Result:
['niu', 'bai']rsplit 是从右开始切片,当不指定从哪个分隔符数开始,默认和split没有区别,但是指定了从第几个分隔符之后,就会有所不同了def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
"""
S.rsplit(sep=None, maxsplit=-1) -> list of strings

Return a list of the words in S, using sep as the
delimiter string, starting at the end of the string and
working to the front. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified, any whitespace string
is a separator.
"""
return msg = "wo is wo wo tou wo is wo is lucky"
print(msg.rsplit('wo', 2))

Result:
['wo is wo wo tou ', ' is ', ' is lucky']

从0开始数,到第二个wo之后开始分隔。split 使用指定分隔符对字符串进行分割,最后得到一个列表def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
"""
S.split(sep=None, maxsplit=-1) -> list of strings

Return a list of the words in S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result.
"""
return msg = "1a2a3a4a5"
print(msg.split('a'))

Result:
['1', '2', '3', '4', '5']
长度:
ljust 打印固定长度的字符串,如果不够在字符串的右边补全指定字符达到制定长度def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.ljust(width[, fillchar]) -> str

Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""msg = "lucky"
print(msg.ljust(30, 'G'))

Result:
luckyGGGGGGGGGGGGGGGGGGGGGGGGGrjust 打印固定长度的字符串,如果不够在字符串的左边补充指定字符def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.rjust(width[, fillchar]) -> str

Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""msg = "lucky"
print(msg.rjust(30, 'G'))

Result:
GGGGGGGGGGGGGGGGGGGGGGGGGluckyzfill 打印指定长度字符串,不够的使用0在左边补全def zfill(self, width): # real signature unknown; restored from __doc__
"""
S.zfill(width) -> str

Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
"""
return ""msg = "lucky"
print(msg.zfill(30))

Result:
0000000000000000000000000lucky
索引:
find  查找一个字符或字符组合在一个字符串中的索引位置,索引位置从0开始,而且找到了第一个就不会往下找了,字符串可以根据索引进行切片def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.find(sub[, start[, end]]) -> int

Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.

Return -1 on failure.
"""
return 0msg = "lucky.chen@126.com"
print(msg.find('c'))
print("[i]" [/i] 20)
print(msg.find('c', 3, 10))
print("[i]" [/i] 20)
print(msg.find('c', 8, 19))

Result:
2
********************
6
********************
15
index 返回某个字符在字符串中的下标def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.index(sub[, start[, end]]) -> int

Like S.find() but raise ValueError when the substring is not found.
"""
return 0name = 'lucky'
print(name.index('u'))
print(name.index('c', 0, 4))

Result:
1
2
rfind 查找一个字符串中某个字符所在的索引,如果这个字符串中有多个这个字符,那么会找到最右边的那个字符def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.rfind(sub[, start[, end]]) -> int

Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.

Return -1 on failure.
"""
return 0msg = "lucky.chen@126.com"
print(msg.rfind('c'))
print("[i]" [/i] 10)
print(msg.rfind('c', 1, 6))


if msg.rfind('c', 22, 23) == -1:
print("failure")
else:
print("OK")

Result:
15
**********
2
failure
rindex 跟rfind差不多def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.rindex(sub[, start[, end]]) -> int

Like S.rfind() but raise ValueError when the substring is not found.
"""
return 0msg = "lucky.chen@126.com"
print(msg.rindex('c'))
print("[i]" [/i] 10)
print(msg.rindex('c', 1, 6))

Result:
15
**********
2
大小写:
capitalize 大写字符串首字母def capitalize(self): # real signature unknown; restored from __doc__
"""
S.capitalize() -> str

Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.
"""
return ""msg = "lol"

print(msg.capitalize())

Result:
Lolislower  判断字符串是不是不包含大写,返回是布尔值def islower(self): # real signature unknown; restored from __doc__
"""
S.islower() -> bool

Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
"""
return Falsemsg = "lol"
print(msg.islower())
print("[i]" [/i] 10)
msg = "Wo I Lol"
print(msg.islower())

Result:
True
**********
Falseistitle 判断一个字符串是否为title,字符串首字母大写就为title,返回时布尔值def istitle(self): # real signature unknown; restored from __doc__
"""
S.istitle() -> bool

Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.
"""
return Falsemsg = "lol"
print(msg.istitle())
print("[i]" [/i] 10)
msg = "Wo I Lol"
print(msg.istitle())

Result:
False
**********
Trueisupper 判断字符串是否为全部大写,返回布尔值def isupper(self): # real signature unknown; restored from __doc__
"""
S.isupper() -> bool

Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
"""
return Falsemsg = "12lol"
print(msg.isupper())
print("[i]" [/i] 10)
msg = "Wo I Lol"
print(msg.isupper())
print("[i]" [/i] 10)
msg = "12WINE"
print(msg.isupper())

Result:
False
**********
False
**********
Trueupper 把字符串都变换为大写def upper(self): # real signature unknown; restored from __doc__
"""
S.upper() -> str

Return a copy of S converted to uppercase.
"""
return ""msg = "12lol"
print(msg.upper())
msg = " Lucky is Good! "
print("[size=16]#" + msg.upper() + "[/size]#")

Result:
12LOL
[size=16]# LUCKY IS GOOD! [/size]#lower  把所有的字符串都变为小写def lower(self): # real signature unknown; restored from __doc__
"""
S.lower() -> str

Return a copy of the string S converted to lowercase.
"""
return ""msg = "12lol"
print(msg.lower())
msg = " Lucky is Good! "
print("[size=16]#" + msg.lower() + "[/size]#")

Result:
12lol
[size=16]# lucky is good! [/size]#swapcase 大小写互换def swapcase(self): # real signature unknown; restored from __doc__
"""
S.swapcase() -> str

Return a copy of S with uppercase characters converted to lowercase
and vice versa.
"""
return ""msg = "12lOl"
print(msg.swapcase())
msg = " Lucky is Good! "
print("[size=16]#" + msg.swapcase() + "[/size]#")

Result:
12LoL
[size=16]# lUCKY IS gOOD! [/size]#
判断:
isalnum 判断这个字符串是否为单单有阿拉伯字母和数字组成,返回布尔值def isalnum(self): # real signature unknown; restored from __doc__
"""
S.isalnum() -> bool

Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
"""
return Falsesb = "123xx^ff"
ub = "123meting"
u = "123"
b = "meting"

print(sb.isalnum())
print(ub.isalnum())
print(u.isalnum())
print(b.isalnum())

Result:
False
True
True
Trueisalpha 判断字符串是否由纯英文,包括大小字母,返回布尔值def isalpha(self): # real signature unknown; restored from __doc__
"""
S.isalpha() -> bool

Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
"""
return Falseub = "123meting"
u = "123"
b = "meting"

print(ub.isalpha())
print(u.isalpha())
print(b.isalpha())

Result:
False
False
Trueisdigit 判断是不是一个整数,返回布尔值def isdigit(self): # real signature unknown; restored from __doc__
"""
S.isdigit() -> bool

Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
"""
return Falseub = "123meting"
u = "123"
b = "123.0"

print(ub.isdigit())
print(u.isdigit())
print(b.isdigit())

Result:
False
True
Falseisidentifier 判断是否是一个合法的标识符也可以叫做是否是一个合法的变量名def isidentifier(self): # real signature unknown; restored from __doc__
"""
S.isidentifier() -> bool

Return True if S is a valid identifier according
to the language definition.

Use keyword.iskeyword() to test for reserved identifiers
such as "def" and "class".
"""
return Falseub = "123meting"
u = "Fun"
b = "123.0"

print(ub.isidentifier())
print(u.isidentifier())
print(b.isidentifier())

Result:
False
True
Falseisnumeric 判断字符串是否只有数字,返回布尔值def isnumeric(self): # real signature unknown; restored from __doc__
"""
S.isnumeric() -> bool

Return True if there are only numeric characters in S,
False otherwise.
"""
return Falseub = "123meting"
u = "123.0"
b = "123"

print(ub.isnumeric())
print(u.isnumeric())
print(b.isnumeric())

Result:
False
False
Trueisprintable 如果字符串中有制表符\t,返回布尔值def isprintable(self): # real signature unknown; restored from __doc__
"""
S.isprintable() -> bool

Return True if all characters in S are considered
printable in repr() or S is empty, False otherwise.
"""
return Falsemsg = "Lucky is Good\t Man"

if msg.isprintable():
print(msg)
else:
print("have 制表符")

Result:
have 制表符isspace 判断字符串是否是一个以上空格,返回布尔值def isspace(self): # real signature unknown; restored from __doc__
"""
S.isspace() -> bool

Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
"""
return Falsemsg = " " # 一个空格
if msg.isspace():
print("是空格")
else:
print("不是空格")

msg = " " # 三个空格
if msg.isspace():
print("是空格")
else:
print("不是空格")

Result:
是空格
是空格

 其他:
count 统计字符串中某个字符出现的次数,返回整型结果def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.count(sub[, start[, end]]) -> int

Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.
"""
return 0msg = "lucky.chen@126.com"
print(msg.count('c'))
print("[i]" [/i] 10)
print(msg.count('c', 3, 8))

Result:
3
**********
1center 美观打印,打印包括现有变量在内的30个字符串, 如果字符串不够实用相应的字符前后补全def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.center(width[, fillchar]) -> str

Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
"""
return ""msg = "Shopping List"
print(msg.center(50, '*'))

Result:
**************[i][b][/i]Shopping List[/b]*****************encond 编码转换,在py3中把字符串转为二进制def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
"""
S.encode(encoding='utf-8', errors='strict') -> bytes

Encode S using the codec registered for encoding. Default encoding
is 'utf-8'. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.
"""
return b""msg = "葫芦娃"
print(msg.encode(encoding='utf-8', errors='strict'))

Result:
b'\xe8\x91\xab\xe8\x8a\xa6\xe5\xa8\x83'endswith 判断一个字符串以什么结尾,返回布尔值def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.endswith(suffix[, start[, end]]) -> bool

Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
"""
return Falsemsg = "lucky.chen@126.com"

if msg.endswith('126.com'):
print("Mail is True")
else:
print("Mail is False")

if msg.endswith('@', 8, 11):
print(msg.find('@', 8, 11))

Result:
Mail is True
10expandtabs  如果字符串中包含一个\t的字符,如果包含则把\t变成8个空格,当然也可以指定个数def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
"""
S.expandtabs(tabsize=8) -> str

Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
"""
return ""msg = "Lol is\tGood Game"
print(msg.expandtabs())
print(msg.expandtabs(tabsize=1))
print(msg.expandtabs(tabsize=20))

Result:
Lol is Good Game
Lol is Good Game
Lol is Good Gameformat 这是一种文件格式化的输出,可以是变量值也可以是下标索引的方法def format([i]args, [/i]*kwargs): # known special case of str.format
"""
S.format([i]args, [/i]*kwargs) -> str

Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
"""
passmsg = """**********[i][b][/i] Shopping List [/b]*************
book: {Book}
bike: {Bike}
food: {Food} """

print(msg.format(Book=1, Bike=2, Food=3))

print("#" * 50)

msg = """**********[i][b][/i] Shopping List [/b]*************
book: {0}
bike: {1}
food: {1} """

print(msg.format(100, 200))

Result:
**********[i][b][/i] Shopping List [/b]*************
book: 1
bike: 2
food: 3
###############################################[size=16]#[/size]
**********[i][b][/i] Shopping List [/b]*************
book: 100
bike: 200
food: 200 format_map 其实跟format功能是一样的,只不过传入的是字典,这个也有一个好处,就是你希望把你字典中的数据格式化输出,直接传入字典就好。def format_map(self, mapping): # real signature unknown; restored from __doc__
"""
S.format_map(mapping) -> str

Return a formatted version of S, using substitutions from mapping.
The substitutions are identified by braces ('{' and '}').
"""
return ""msg = """**********[i][b][/i] Shopping List [/b]*************
book: {Book}
bike: {Bike}
food: {Food} """

print(msg.format_map({'Book': 38, 'Bike': 800, 'Food': 1000}))

Result:
**********[i][b][/i] Shopping List [/b]*************
book: 38
bike: 800
food: 1000 join 常用的方法,把一个列表拼成一个字符串,中间用某个字符串分隔def join(self, iterable): # real signature unknown; restored from __doc__
"""
S.join(iterable) -> str

Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
"""
return ""a = ['1', '2', '3', '4'] # 元素必须要是str类型
print(':'.join(a))

Result:
1:2:3:4maketrans 这个方法要配合translate方法使用,对数据进行加密/反解def maketrans(self, [i]args, [/i]*kwargs): # real signature unknown
"""
Return a translation table usable for str.translate().

If there is only one argument, it must be a dictionary mapping Unicode
ordinals (integers) or characters to Unicode ordinals, strings or None.
Character keys will be then converted to ordinals.
If there are two arguments, they must be strings of equal length, and
in the resulting dictionary, each character in x will be mapped to the
character at the same position in y. If there is a third argument, it
must be a string, whose characters will be mapped to None in the result.
"""
passs = "Hello World!"
#加密
p = s.maketrans("abcdefg", "3!@#$%^")

print(p)

# 解密,打出真实的p的内容
print(s.translate(p))

Result:
{97: 51, 98: 33, 99: 64, 100: 35, 101: 36, 102: 37, 103: 94}
H$llo Worl#!replace 替换字符串字符,也可以指定替换的次数def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
"""
S.replace(old, new[, count]) -> str

Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
"""
return ""msg = 'abcbcacba'

print(msg.replace('a', 'w'))
print(msg.replace('a','c', 3))

Result:
wbcbcwcbw
cbcbcccbcstartswith 判断以什么开头,返回布尔值def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.startswith(prefix[, start[, end]]) -> bool

Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
"""
return Falsemsg = "lucky"

print(msg.startswith('l'))
print(msg.startswith('c', 2, 4))

Result:
True
Truetitle 把一个字符串变为一个title,首字母大写def title(self): # real signature unknown; restored from __doc__
"""
S.title() -> str

Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.
"""
return ""msg = " shopping list "
print(msg.title())

Result:
Shopping List translate 配合maketrans进行字符串的交换def translate(self, table): # real signature unknown; restored from __doc__
"""
S.translate(table) -> str

Return a copy of the string S in which each character has been mapped
through the given translation table. The table must implement
lookup/indexing via __getitem__, for instance a dictionary or list,
mapping Unicode ordinals to Unicode ordinals, strings, or None. If
this operation raises LookupError, the character is left untouched.
Characters mapped to None are deleted.
"""
return ""name = "lucky"
f = name.maketrans('abcde', '12345')

# 加密文
print(f)

# 解密,明文
print('test'.translate(f))

Result:
{97: 49, 98: 50, 99: 51, 100: 52, 101: 53}
t5st
​bytes类型
Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分。文本总是Unicode,由str类型表示,二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes(类似int和long之间自动转换),正是这使得两者的区分特别清晰。你不能拼接字符串和字节包,也无法在字节包里搜索字符串(反之亦然),也不能将字符串传入参数为字节包的函数(反之亦然)。这是件好事。不管怎样,字符串和字节包之间的界线是必然的,下面的图解非常重要,务请牢记于心:




在python中二进制的数据都是bytes的数据类型,文本都是字符串的数据类型,字符串可以编码成字节包,而字节包可以解码成字符串:#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

msg = "康师傅"

print(msg.encode("utf-8")) # 如果不指定编码格式,默认为utf-8
# b'\xe5\xba\xb7\xe5\xb8\x88\xe5\x82\x85'

print(b'\xe5\xba\xb7\xe5\xb8\x88\xe5\x82\x85'.decode("utf-8"))
# 康师傅 

数据运算

算数运算:




 
比较运算:




 
赋值运算:




 
逻辑运算:




 
成员运算:




 
身份运算:




 
位运算:



#!/usr/bin/python

a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0

c = a & b; # 12 = 0000 1100
print "Line 1 - Value of c is ", c

c = a | b; # 61 = 0011 1101
print "Line 2 - Value of c is ", c

c = a ^ b; # 49 = 0011 0001
print "Line 3 - Value of c is ", c

c = ~a; # -61 = 1100 0011
print "Line 4 - Value of c is ", c

c = a << 2; # 240 = 1111 0000
print "Line 5 - Value of c is ", c

c = a >> 2; # 15 = 0000 1111
print "Line 6 - Value of c is ", c运算符优先级:




更多内容参考:猛击这里!
 
三元运算:result = 值1 if 条件 else 值2如果条件为真:result = 值1
如果条件为假:result = 值2#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

a, b, c = 1, 2, 3

d = a if a > b else c
# 如果a大于b 则把的值赋给d, 如果a不大于b, 则把c的值直接赋给d
print(d)

Result:
3如果不熟悉这种方法,只能老实的写if ... elif .... else 语句等! 查看全部


简单模块初识


很多人都说Python的扩展性很强,有很多第三方的类库,那这些类库到底怎么使用呢,其实在Python语言中不管是内置的类库和其他开发扩展的类库,在Python中我们习惯把它叫做「模块」。那模块该怎么用呢?不着急下面我们简单介绍几个常用的内库「内裤吗?」。
1、sys (系统内裤)
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

import sys

# Python全局环境变量路径
print(sys.path)

# 打印传递给脚本的第二个参数
print(sys.argv[2])
Result:
['/Users/crh/PycharmProjects/app', '/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/Versions/3.5/lib/python35.zip', '/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/Versions/3.5/lib/python3.5', '/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/Versions/3.5/lib/python3.5/plat-darwin', '/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/Versions/3.5/lib/python3.5/lib-dynload', '/usr/local/lib/python3.5/site-packages']
2
说明一下Python的环境变量,比如我们导入一个模块它先到你本路径找有没有,然后回到Python的环境路径下再去找,一般扩展的模块安装后都会在site-packages的路径下。
 
2、os(系统内裤)
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

import os

# 调用系统命令
os.system("df -h")
Result:
Filesystem      Size   Used  Avail Capacity  iused    ifree %iused  Mounted on
/dev/disk1 233Gi 80Gi 153Gi 35% 20947137 40038205 34% /
devfs 181Ki 181Ki 0Bi 100% 626 0 100% /dev
map -hosts 0Bi 0Bi 0Bi 100% 0 0 100% /net
map auto_home 0Bi 0Bi 0Bi 100% 0 0 100% /home

3、sys、os结合玩一玩
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

import os
import sys

# 把用户传入的参数当做命令执行
os.system(''.join(sys.argv[1:]))
 
4、自己编写简单模块
Python tab补全模块:
Linux版本:
#!/usr/bin/env python3 
# python startup file
import sys
import readline
import rlcompleter
import atexit
import os
# tab completion
readline.parse_and_bind('tab: complete')
# history file
histfile = os.path.join(os.environ['HOME'], '.pythonhistory')
try:
readline.read_history_file(histfile)
except IOError:
pass
atexit.register(readline.write_history_file, histfile)
del os, histfile, readline, rlcompleter
Mac版:
# linux and python3 on mac
import sys
import readline
import rlcompleter

if sys.platform == 'darwin' and sys.version_info[0] == 2:
readline.parse_and_bind("bind ^I rl_complete")
else:
readline.parse_and_bind("tab: complete")
写完保存后就可以导入使用:
>>> import tab
[quote]>> import os
>>> os.
Display all 234 possibilities? (y or n)
>>> os.sy
os.symlink( os.sys os.sysconf( os.sysconf_names os.system(
>>> os.sy
os.symlink( os.sys os.sysconf( os.sysconf_names os.system(
>>> os.sy
你会发现,上面自己写的tab.py模块只能在当前目录下导入,如果想在系统的何何一个地方都使用怎么办呢? 此时你就要把这个tab.py放到python全局环境变量目录里啦,基本一般都放在一个叫 site-packages 目录下,这个目录在不同的OS里放的位置不一样,用 print(sys.path) 可以查看python环境变量列表。
 


基础数据类型认识


A、数字
2 是一个整数的例子。
长整数 不过是大一些的整数。
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里,52.3E-4表示52.3 * 10-4。
(-5+4j)和(2.3-4.6j)是复数的例子,其中-5,4为实数,j为虚数,数学中表示复数是什么?。
数学中表示复数的虚数是n,而Python中跟大数据计算一样统一用的是j。
 
1、int(整型
在32位机器上,整数的位数为32位,取值范围为-2[b]31~2[/b]31-1,即-2147483648~2147483647
在64位系统上,整数的位数为64位,取值范围为-2[b]63~2[/b]63-1,即-9223372036854775808~9223372036854775807
所以不同的操作系统中数据的长度是有限制范围的,就好像32位系统最多支持4GB内存一样。
 
在我们里面12、34、56、100000等都是整型。
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen[/quote]

a = '3'
print(type(a))

b = int(a)
print(type(a))
其他具体功能可以查看帮助:
int.png

 
2、long(长整型)
跟C语言不同,Python的长整数没有指定位宽,即:Python没有限制长整数数值的大小,但实际上由于机器内存有限,我们使用的长整数数值不可能无限大。
注意,自从Python2.2起,如果整数发生溢出,Python会自动将整数数据转换为长整数,所以如今在长整数数据后面不加字母L也不会导致严重后果了。
如:9223372036854775808、922337203685477580800  默认在Python2版本里面超过263 就是长整型,而Python3.中都是整型。
>>> print(type(2[/b]63))
<type 'long'>
[quote]>> print(type(2**62))
<type 'int'>
 [b]3、float(浮点型)
浮点数用来处理实数,即带有小数的数字。类似于C语言中的double类型,占8个字节(64位),其中52位表示底,11位表示指数,剩下的一位表示符号。
例如:1.2 、0.98、100.38 都是浮点类型
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen[/quote]

a = 3
print(type(a))

b = float(a)

print(type(b), b)
<class 'int'>
<class 'float'> 3.0
具体更多功能查看帮助:
float.png


4、complex(复数)
复数由实数部分和虚数部分组成,一般形式为x+yj,其中的x是复数的实数部分,y是复数的虚数部分,这里的x和y都是实数。
注:Python中存在小数字池:-5 ~ 257
比如:1+2j,3+6j等都是复数
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

a = (3-4j).conjugate()

print(a)

print(type(a))

# 结果
(3+4j)
<class 'complex'>
具体更多功能查看帮助:
complex.png


B、布尔值
在Python的世界里面有一个叫布尔值的东西,其实就是 真或假 1 或 0,简单点就是True和False。
在其他的配置或者语言里面,我们都知道把某个东西打开需要把他调试为True,关闭则设置为False。
在Python里面也是一样True就代表为真,条件成立;False就代表为假,条件不成立;1代表为真,0
代表假。
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

a, b = 1, 0

if a:
print("a is True")
else:
print("a is False")

if b:
print("b is True")
else:
print("b is False")

# 结果
a is True
b is False

C、字符串
1、拼接
在之前的文章http://openskill.cn/article/415  里已经介绍过了字符串拼接的方法如:+  %  format函数等。
Python中的字符串在C语言中体现为是一个字符数组,每次创建字符串时候需要在内存中开辟一块连续的空,并且一旦需要修改字符串的话,就需要再次开辟空间,万恶的+号每出现一次就会在内从中重新开辟一块空间。
所以最好不要用+比较好
name = "lucky"
print "i am %s " % name

#输出: i am lucky
PS: 字符串是 %s;整数 %d;浮点数%f

2、字符串常用功能介绍
移除空白
rstrip 去掉右边的空格以及tab制表符
def rstrip(self, [i]args, [/i]*kwargs): # real signature unknown
"""
Strip trailing bytes contained in the argument.

If the argument is omitted or None, strip trailing ASCII whitespace.
"""
pass
msg = "  my name is lucky   "

print("[i][b][/i]" + msg.lstrip() + "[/b]*")

Result:
[i][b][/i]  my name is lucky[/b]*
lstrip 去掉左边的空格以及tab制表符
def lstrip(self, chars=None): # real signature unknown; restored from __doc__
"""
S.lstrip([chars]) -> str

Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
"""
return ""
msg = "  my name is lucky   "
info = " game is\tlol\tover!"

print("[b][i]" + msg.lstrip() + "[/b][/i]")
print("[b][i]" + info.lstrip() + "[/b][/i]")

Result:
[b][i]my name is lucky [/b][/i]
[b][i]game is lol over![/b][/i]
strip 去除字符串两边的空格和换行
def strip(self, chars=None): # real signature unknown; restored from __doc__
"""
S.strip([chars]) -> str

Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
"""
return ""
msg = "  ox\nB  "

print("[b][i]" + msg.strip() + "[/b][/i]")

Result:
***ox
B***

分割:
splitlines 使用回车符进行字符串分片,最后得到一个列表
def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
"""
S.splitlines([keepends]) -> list of strings

Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
"""
return
msg = "niu\nbai"
print(msg.splitlines())

Result:
['niu', 'bai']
rsplit 是从右开始切片,当不指定从哪个分隔符数开始,默认和split没有区别,但是指定了从第几个分隔符之后,就会有所不同了
def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
"""
S.rsplit(sep=None, maxsplit=-1) -> list of strings

Return a list of the words in S, using sep as the
delimiter string, starting at the end of the string and
working to the front. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified, any whitespace string
is a separator.
"""
return
msg = "wo is wo wo tou wo is wo is lucky"
print(msg.rsplit('wo', 2))

Result:
['wo is wo wo tou ', ' is ', ' is lucky']

从0开始数,到第二个wo之后开始分隔。
split 使用指定分隔符对字符串进行分割,最后得到一个列表
def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
"""
S.split(sep=None, maxsplit=-1) -> list of strings

Return a list of the words in S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result.
"""
return
msg = "1a2a3a4a5"
print(msg.split('a'))

Result:
['1', '2', '3', '4', '5']

长度:
ljust 打印固定长度的字符串,如果不够在字符串的右边补全指定字符达到制定长度
def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.ljust(width[, fillchar]) -> str

Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""
msg = "lucky"
print(msg.ljust(30, 'G'))

Result:
luckyGGGGGGGGGGGGGGGGGGGGGGGGG
rjust 打印固定长度的字符串,如果不够在字符串的左边补充指定字符
def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.rjust(width[, fillchar]) -> str

Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""
msg = "lucky"
print(msg.rjust(30, 'G'))

Result:
GGGGGGGGGGGGGGGGGGGGGGGGGlucky
zfill 打印指定长度字符串,不够的使用0在左边补全
def zfill(self, width): # real signature unknown; restored from __doc__
"""
S.zfill(width) -> str

Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
"""
return ""
msg = "lucky"
print(msg.zfill(30))

Result:
0000000000000000000000000lucky

索引:
find  查找一个字符或字符组合在一个字符串中的索引位置,索引位置从0开始,而且找到了第一个就不会往下找了,字符串可以根据索引进行切片
def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.find(sub[, start[, end]]) -> int

Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.

Return -1 on failure.
"""
return 0
msg = "lucky.chen@126.com"
print(msg.find('c'))
print("[i]" [/i] 20)
print(msg.find('c', 3, 10))
print("[i]" [/i] 20)
print(msg.find('c', 8, 19))

Result:
2
********************
6
********************
15

index 返回某个字符在字符串中的下标
def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.index(sub[, start[, end]]) -> int

Like S.find() but raise ValueError when the substring is not found.
"""
return 0
name = 'lucky'
print(name.index('u'))
print(name.index('c', 0, 4))

Result:
1
2
rfind 查找一个字符串中某个字符所在的索引,如果这个字符串中有多个这个字符,那么会找到最右边的那个字符
def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.rfind(sub[, start[, end]]) -> int

Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.

Return -1 on failure.
"""
return 0
msg = "lucky.chen@126.com"
print(msg.rfind('c'))
print("[i]" [/i] 10)
print(msg.rfind('c', 1, 6))


if msg.rfind('c', 22, 23) == -1:
print("failure")
else:
print("OK")

Result:
15
**********
2
failure

rindex 跟rfind差不多
def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.rindex(sub[, start[, end]]) -> int

Like S.rfind() but raise ValueError when the substring is not found.
"""
return 0
msg = "lucky.chen@126.com"
print(msg.rindex('c'))
print("[i]" [/i] 10)
print(msg.rindex('c', 1, 6))

Result:
15
**********
2

大小写
capitalize 大写字符串首字母
def capitalize(self): # real signature unknown; restored from __doc__
"""
S.capitalize() -> str

Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.
"""
return ""
msg = "lol"

print(msg.capitalize())

Result:
Lol
islower  判断字符串是不是不包含大写,返回是布尔值
def islower(self): # real signature unknown; restored from __doc__
"""
S.islower() -> bool

Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
"""
return False
msg = "lol"
print(msg.islower())
print("[i]" [/i] 10)
msg = "Wo I Lol"
print(msg.islower())

Result:
True
**********
False
istitle 判断一个字符串是否为title,字符串首字母大写就为title,返回时布尔值
def istitle(self): # real signature unknown; restored from __doc__
"""
S.istitle() -> bool

Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.
"""
return False
msg = "lol"
print(msg.istitle())
print("[i]" [/i] 10)
msg = "Wo I Lol"
print(msg.istitle())

Result:
False
**********
True
isupper 判断字符串是否为全部大写,返回布尔值
def isupper(self): # real signature unknown; restored from __doc__
"""
S.isupper() -> bool

Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
"""
return False
msg = "12lol"
print(msg.isupper())
print("[i]" [/i] 10)
msg = "Wo I Lol"
print(msg.isupper())
print("[i]" [/i] 10)
msg = "12WINE"
print(msg.isupper())

Result:
False
**********
False
**********
True
upper 把字符串都变换为大写
def upper(self): # real signature unknown; restored from __doc__
"""
S.upper() -> str

Return a copy of S converted to uppercase.
"""
return ""
msg = "12lol"
print(msg.upper())
msg = " Lucky is Good! "
print("[size=16]#" + msg.upper() + "[/size]#")

Result:
12LOL
[size=16]# LUCKY IS GOOD! [/size]#
lower  把所有的字符串都变为小写
def lower(self): # real signature unknown; restored from __doc__
"""
S.lower() -> str

Return a copy of the string S converted to lowercase.
"""
return ""
msg = "12lol"
print(msg.lower())
msg = " Lucky is Good! "
print("[size=16]#" + msg.lower() + "[/size]#")

Result:
12lol
[size=16]# lucky is good! [/size]#
swapcase 大小写互换
def swapcase(self): # real signature unknown; restored from __doc__
"""
S.swapcase() -> str

Return a copy of S with uppercase characters converted to lowercase
and vice versa.
"""
return ""
msg = "12lOl"
print(msg.swapcase())
msg = " Lucky is Good! "
print("[size=16]#" + msg.swapcase() + "[/size]#")

Result:
12LoL
[size=16]# lUCKY IS gOOD! [/size]#

判断:
isalnum 判断这个字符串是否为单单有阿拉伯字母和数字组成,返回布尔值
def isalnum(self): # real signature unknown; restored from __doc__
"""
S.isalnum() -> bool

Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
"""
return False
sb = "123xx^ff"
ub = "123meting"
u = "123"
b = "meting"

print(sb.isalnum())
print(ub.isalnum())
print(u.isalnum())
print(b.isalnum())

Result:
False
True
True
True
isalpha 判断字符串是否由纯英文,包括大小字母,返回布尔值
def isalpha(self): # real signature unknown; restored from __doc__
"""
S.isalpha() -> bool

Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
"""
return False
ub = "123meting"
u = "123"
b = "meting"

print(ub.isalpha())
print(u.isalpha())
print(b.isalpha())

Result:
False
False
True
isdigit 判断是不是一个整数,返回布尔值
def isdigit(self): # real signature unknown; restored from __doc__
"""
S.isdigit() -> bool

Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
"""
return False
ub = "123meting"
u = "123"
b = "123.0"

print(ub.isdigit())
print(u.isdigit())
print(b.isdigit())

Result:
False
True
False
isidentifier 判断是否是一个合法的标识符也可以叫做是否是一个合法的变量名
def isidentifier(self): # real signature unknown; restored from __doc__
"""
S.isidentifier() -> bool

Return True if S is a valid identifier according
to the language definition.

Use keyword.iskeyword() to test for reserved identifiers
such as "def" and "class".
"""
return False
ub = "123meting"
u = "Fun"
b = "123.0"

print(ub.isidentifier())
print(u.isidentifier())
print(b.isidentifier())

Result:
False
True
False
isnumeric 判断字符串是否只有数字,返回布尔值
def isnumeric(self): # real signature unknown; restored from __doc__
"""
S.isnumeric() -> bool

Return True if there are only numeric characters in S,
False otherwise.
"""
return False
ub = "123meting"
u = "123.0"
b = "123"

print(ub.isnumeric())
print(u.isnumeric())
print(b.isnumeric())

Result:
False
False
True
isprintable 如果字符串中有制表符\t,返回布尔值
def isprintable(self): # real signature unknown; restored from __doc__
"""
S.isprintable() -> bool

Return True if all characters in S are considered
printable in repr() or S is empty, False otherwise.
"""
return False
msg = "Lucky is Good\t Man"

if msg.isprintable():
print(msg)
else:
print("have 制表符")

Result:
have 制表符
isspace 判断字符串是否是一个以上空格,返回布尔值
def isspace(self): # real signature unknown; restored from __doc__
"""
S.isspace() -> bool

Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
"""
return False
msg = " "   # 一个空格
if msg.isspace():
print("是空格")
else:
print("不是空格")

msg = " " # 三个空格
if msg.isspace():
print("是空格")
else:
print("不是空格")

Result:
是空格
是空格

 其他:
count 统计字符串中某个字符出现的次数,返回整型结果
def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.count(sub[, start[, end]]) -> int

Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.
"""
return 0
msg = "lucky.chen@126.com"
print(msg.count('c'))
print("[i]" [/i] 10)
print(msg.count('c', 3, 8))

Result:
3
**********
1
center 美观打印,打印包括现有变量在内的30个字符串, 如果字符串不够实用相应的字符前后补全
def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.center(width[, fillchar]) -> str

Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
"""
return ""
msg = "Shopping List"
print(msg.center(50, '*'))

Result:
**************[i][b][/i]Shopping List[/b]*****************
encond 编码转换,在py3中把字符串转为二进制
def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
"""
S.encode(encoding='utf-8', errors='strict') -> bytes

Encode S using the codec registered for encoding. Default encoding
is 'utf-8'. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.
"""
return b""
msg = "葫芦娃"
print(msg.encode(encoding='utf-8', errors='strict'))

Result:
b'\xe8\x91\xab\xe8\x8a\xa6\xe5\xa8\x83'
endswith 判断一个字符串以什么结尾,返回布尔值
def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.endswith(suffix[, start[, end]]) -> bool

Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
"""
return False
msg = "lucky.chen@126.com"

if msg.endswith('126.com'):
print("Mail is True")
else:
print("Mail is False")

if msg.endswith('@', 8, 11):
print(msg.find('@', 8, 11))

Result:
Mail is True
10
expandtabs  如果字符串中包含一个\t的字符,如果包含则把\t变成8个空格,当然也可以指定个数
def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
"""
S.expandtabs(tabsize=8) -> str

Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
"""
return ""
msg = "Lol is\tGood Game"
print(msg.expandtabs())
print(msg.expandtabs(tabsize=1))
print(msg.expandtabs(tabsize=20))

Result:
Lol is Good Game
Lol is Good Game
Lol is Good Game
format 这是一种文件格式化的输出,可以是变量值也可以是下标索引的方法
def format([i]args, [/i]*kwargs): # known special case of str.format
"""
S.format([i]args, [/i]*kwargs) -> str

Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
"""
pass
msg = """**********[i][b][/i] Shopping List [/b]*************
book: {Book}
bike: {Bike}
food: {Food} """

print(msg.format(Book=1, Bike=2, Food=3))

print("#" * 50)

msg = """**********[i][b][/i] Shopping List [/b]*************
book: {0}
bike: {1}
food: {1} """

print(msg.format(100, 200))

Result:
**********[i][b][/i] Shopping List [/b]*************
book: 1
bike: 2
food: 3
###############################################[size=16]#[/size]
**********[i][b][/i] Shopping List [/b]*************
book: 100
bike: 200
food: 200
format_map 其实跟format功能是一样的,只不过传入的是字典,这个也有一个好处,就是你希望把你字典中的数据格式化输出,直接传入字典就好。
def format_map(self, mapping): # real signature unknown; restored from __doc__
"""
S.format_map(mapping) -> str

Return a formatted version of S, using substitutions from mapping.
The substitutions are identified by braces ('{' and '}').
"""
return ""
msg = """**********[i][b][/i] Shopping List [/b]*************
book: {Book}
bike: {Bike}
food: {Food} """

print(msg.format_map({'Book': 38, 'Bike': 800, 'Food': 1000}))

Result:
**********[i][b][/i] Shopping List [/b]*************
book: 38
bike: 800
food: 1000
join 常用的方法,把一个列表拼成一个字符串,中间用某个字符串分隔
def join(self, iterable): # real signature unknown; restored from __doc__
"""
S.join(iterable) -> str

Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
"""
return ""
a = ['1', '2', '3', '4']  # 元素必须要是str类型
print(':'.join(a))

Result:
1:2:3:4
maketrans 这个方法要配合translate方法使用,对数据进行加密/反解
def maketrans(self, [i]args, [/i]*kwargs): # real signature unknown
"""
Return a translation table usable for str.translate().

If there is only one argument, it must be a dictionary mapping Unicode
ordinals (integers) or characters to Unicode ordinals, strings or None.
Character keys will be then converted to ordinals.
If there are two arguments, they must be strings of equal length, and
in the resulting dictionary, each character in x will be mapped to the
character at the same position in y. If there is a third argument, it
must be a string, whose characters will be mapped to None in the result.
"""
pass
s = "Hello World!"
#加密
p = s.maketrans("abcdefg", "3!@#$%^")

print(p)

# 解密,打出真实的p的内容
print(s.translate(p))

Result:
{97: 51, 98: 33, 99: 64, 100: 35, 101: 36, 102: 37, 103: 94}
H$llo Worl#!
replace 替换字符串字符,也可以指定替换的次数
def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
"""
S.replace(old, new[, count]) -> str

Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
"""
return ""
msg = 'abcbcacba'

print(msg.replace('a', 'w'))
print(msg.replace('a','c', 3))

Result:
wbcbcwcbw
cbcbcccbc
startswith 判断以什么开头,返回布尔值
def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.startswith(prefix[, start[, end]]) -> bool

Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
"""
return False
msg = "lucky"

print(msg.startswith('l'))
print(msg.startswith('c', 2, 4))

Result:
True
True
title 把一个字符串变为一个title,首字母大写
def title(self): # real signature unknown; restored from __doc__
"""
S.title() -> str

Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.
"""
return ""
msg = " shopping list "
print(msg.title())

Result:
Shopping List
translate 配合maketrans进行字符串的交换
def translate(self, table): # real signature unknown; restored from __doc__
"""
S.translate(table) -> str

Return a copy of the string S in which each character has been mapped
through the given translation table. The table must implement
lookup/indexing via __getitem__, for instance a dictionary or list,
mapping Unicode ordinals to Unicode ordinals, strings, or None. If
this operation raises LookupError, the character is left untouched.
Characters mapped to None are deleted.
"""
return ""
name = "lucky"
f = name.maketrans('abcde', '12345')

# 加密文
print(f)

# 解密,明文
print('test'.translate(f))

Result:
{97: 49, 98: 50, 99: 51, 100: 52, 101: 53}
t5st

​bytes类型
Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分。文本总是Unicode,由str类型表示,二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes(类似int和long之间自动转换),正是这使得两者的区分特别清晰。你不能拼接字符串和字节包,也无法在字节包里搜索字符串(反之亦然),也不能将字符串传入参数为字节包的函数(反之亦然)。这是件好事。不管怎样,字符串和字节包之间的界线是必然的,下面的图解非常重要,务请牢记于心:
bytes.png

在python中二进制的数据都是bytes的数据类型,文本都是字符串的数据类型,字符串可以编码成字节包,而字节包可以解码成字符串:
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

msg = "康师傅"

print(msg.encode("utf-8")) # 如果不指定编码格式,默认为utf-8
# b'\xe5\xba\xb7\xe5\xb8\x88\xe5\x82\x85'

print(b'\xe5\xba\xb7\xe5\xb8\x88\xe5\x82\x85'.decode("utf-8"))
# 康师傅
 


数据运算


算数运算:
suanshu.png

 
比较运算:
bijiao.png

 
赋值运算:
fuzhi.png

 
逻辑运算:
luoji.png

 
成员运算:
chengyuan.png

 
身份运算:
shenfen.png

 
位运算:
wei.png
#!/usr/bin/python

a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0

c = a & b; # 12 = 0000 1100
print "Line 1 - Value of c is ", c

c = a | b; # 61 = 0011 1101
print "Line 2 - Value of c is ", c

c = a ^ b; # 49 = 0011 0001
print "Line 3 - Value of c is ", c

c = ~a; # -61 = 1100 0011
print "Line 4 - Value of c is ", c

c = a << 2; # 240 = 1111 0000
print "Line 5 - Value of c is ", c

c = a >> 2; # 15 = 0000 1111
print "Line 6 - Value of c is ", c
运算符优先级:
yxj.png

更多内容参考:猛击这里!
 
三元运算:
result = 值1 if 条件 else 值2
如果条件为真:result = 值1
如果条件为假:result = 值2
#!/usr/bin/env python3
# _[i]_coding:utf-8_[/i]_
# Author: Lucky.chen

a, b, c = 1, 2, 3

d = a if a > b else c
# 如果a大于b 则把的值赋给d, 如果a不大于b, 则把c的值直接赋给d
print(d)

Result:
3
如果不熟悉这种方法,只能老实的写if ... elif .... else 语句等!

用Python从网页提取的文本,转换成str格式后,怎么逐行处理呢?

采菊篱下 回复了问题 • 2 人关注 • 2 个回复 • 987 次浏览 • 2016-07-27 11:51 • 来自相关话题