python函数手写笔记,用python写函数

python3.4学习笔记 3.x和2.x的区别，持续更新

python3.4学习笔记(四) 3.x和2.x的区别

成都创新互联公司主营宜川网站建设的网络公司,主营网站建设方案,app软件开发公司,宜川h5微信小程序开发搭建,宜川网站营销推广欢迎宜川等地区企业咨询

在2.x中:print html，3.x中必须改成:print(html)

import urllib2

ImportError: No module named 'urllib2'

在python3.x里面，用urllib.request代替urllib2

import thread

ImportError: No module named 'thread'

在python3.x里面，用_thread(在前面加一个下划线)代替thread

在2.x中except Exception,e : 3.x中改为except (Exception):

=================================

print函数

虽然print语法是Python 3中一个很小的改动，且应该已经广为人知，但依然值得提一下：Python 2中的print语句被Python 3中的print()函数取代，这意味着在Python 3中必须用括号将需要输出的对象括起来。

在Python 2中使用额外的括号也是可以的。但反过来在Python 3中想以Python2的形式不带括号调用print函数时，会触发SyntaxError。

Python 2.7.6

print 'Python', python_version()

print 'Hello, World!'

print('Hello, World!')

print "text", ; print 'print more text on the same line'

输出：

Hello, World!

Hello, World!

text print more text on the same line

---------------------------

Python 3.4.1

print('Python', python_version())

print('Hello, World!')

print("some text,", end="")

print(' print more text on the same line')

输出：

Hello, World!

some text, print more text on the same line

print 'Hello, World!'

File "ipython-input-3-139a7c5835bd", line 1

print 'Hello, World!'

^

SyntaxError: invalid syntax

注意：在Python中，带不带括号输出”Hello World”都很正常。

但如果在圆括号中同时输出多个对象时，就会创建一个元组，这是因为在Python 2中，print是一个语句，而不是函数调用。

print 'Python', python_version()

print('a', 'b')

print 'a', 'b'

Python 2.7.7

('a', 'b')

a b

---------------------------------

整数除法

由于人们常常会忽视Python 3在整数除法上的改动（写错了也不会触发Syntax Error），所以在移植代码或在Python 2中执行Python 3的代码时，需要特别注意这个改动。

所以，我还是会在Python 3的脚本中尝试用float(3)/2或 3/2.0代替3/2，以此来避免代码在Python

2环境下可能导致的错误（或与之相反，在Python 2脚本中用from __future__ import division来使用Python

3的除法）。

Python 2.7.6

3 / 2 = 1

3 // 2 = 1

3 / 2.0 = 1.5

3 // 2.0 = 1.0

Python 3.4.1

3 / 2 = 1.5

3 // 2 = 1

3 / 2.0 = 1.5

3 // 2.0 = 1.0

---------------------------------

Unicode

Python 2有基于ASCII的str()类型，其可通过单独的unicode()函数转成unicode类型，但没有byte类型。

而在Python 3中，终于有了Unicode（utf-8）字符串，以及两个字节类：bytes和bytearrays。

Python 2.7.6

print type(unicode('this is like a python3 str type'))

type 'unicode'

print type(b'byte type does not exist')

type 'str'

print 'they are really' + b' the same'

they are really the same

print type(bytearray(b'bytearray oddly does exist though'))

type 'bytearray'

Python 3.4.1 has class 'bytes'

print('and Python', python_version(), end="")

print(' also has', type(bytearray(b'bytearrays')))

and Python 3.4.1 also has class 'bytearray'

1

'note that we cannot add a string' + b'bytes for data'

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

ipython-input-13-d3e8942ccf81 in module()

---- 1 'note that we cannot add a string' + b'bytes for data'

TypeError: Can't convert 'bytes' object to str implicitly

=================================

python 2.4 与 python 3.0 的比较

一、 print 从语句变为函数

原: print 1,2+3

改为: print ( 1,2+3 )

二、range 与 xrange

原 : range( 0, 4 ) 结果 是 列表 [0,1,2,3 ]

改为：list( range(0,4) )

原 : xrange( 0, 4 ) 适用于 for 循环的变量控制

改为：range(0,4)

三、字符串

原: 字符串以 8-bit 字符串存储

改为: 字符串以 16-bit Unicode 字符串存储

四、try except 语句的变化

在2.x中except Exception,e : 3.x中改为except (Exception):

五、打开文件

原： file( ..... )

或 open(.....)

改为：

只能用 open(.....)

六、从键盘录入一个字符串

原: raw_input( "提示信息" )

改为: input( "提示信息" )

七、bytes 数据类型

A bytes object is an immutable array. The items are 8-bit bytes, represented by integers in the range 0 = x 256.

bytes 可以看成是“字节数组”对象，每个元素是 8-bit 的字节，取值范围 0~255。

由于在 python 3.0中字符串以 unicode 编码存储，当写入二进制文件时，字符串无法直接写入（或读取），必须以某种方式的编码为字节序列后，方可写入。

（一）字符串编码(encode) 为 bytes

例: s = "张三abc12"

b = s.encode( 编码方式)

# b 就是 bytes 类型的数据

# 常用的编码方式为 ： "uft-16" , "utf-8", "gbk", "gb2312", "ascii" , "latin1" 等

# 注 ： 当字符串不能编码为指定的“编码方式”时，会引发异常

(二) bytes 解码(decode)为字符串

s = "张三abc12"

b = s.encode( "gbk") # 字符串 s 编码为 gbk 格式的字节序列

s1 = b.decode("gbk") # 将字节序列 b以gbk格式 解码为字符串

# 说明，当字节序列不能以指定的编码格式解码时会引发异常

(三）使用方法举例

#coding=gbk

f = open("c:\\1234.txt", "wb")

s = "张三李四abcd1234"

# -------------------------------

# 在 python2.4 中我们可以这样写：

# f.write( s )

# 但在 python 3.0中会引发异常

# -------------------------------

b = s.encode("gbk")

f.write( b )

f.close()

input("?")

读取该文件的例子:

#coding=gbk

f = open("c:\\1234.txt", "rb")

f.seek(0,2) #定位至文件尾

n = f.tell() #读取文件的字节数

f.seek(0,0) #重新定位至文件开始处

b = f.read( n )

# ------------------------------

# 在 python 2.4 中 b 是字符串类型

# 要 python 3.0 中 b 是 bytes 类型

# 因此需要按指定的编码方式确码

# ------------------------------

s = b.decode("gbk")

print ( s )

# ------------------------------

# 在 python 2.4 中 可以写作 print s 或 print ( s )

# 要 python 3.0 中 必须写作 print ( s )

# ------------------------------

f.close()

input("?")

运行后应显示:

张三李四abcd1234

(四) bytes序列，一但形成，其内容是不可变的，例：

s="ABCD"

b=s.encode("gbk")

print b[0] # 显示 65

b[0] = 66

# 执行该句，出现异常: 'bytes' object does not support item assignment

八、 chr( K ) 与 ord( c )

python 2.4.2以前

chr( K ) 将编码K 转为字符，K的范围是 0 ~ 255

ord( c ) 取单个字符的编码, 返回值的范围: 0 ~ 255

python 3.0

chr( K ) 将编码K 转为字符，K的范围是 0 ~ 65535

ord( c ) 取单个字符的编码, 返回值的范围: 0 ~ 65535

九、 除法运算符

python 2.4.2以前

10/3 结果为 3

python 3.0

10 / 3 结果为 3.3333333333333335

10 // 3 结果为 3

十、字节数组对象 --- 新增

(一） 初始化

a = bytearray( 10 )

# a 是一个由十个字节组成的数组，其每个元素是一个字节，类型借用 int

# 此时，每个元素初始值为 0

（二） 字节数组 是可变的

a = bytearray( 10 )

a[0] = 25

# 可以用赋值语句更改其元素，但所赋的值必须在 0 ~ 255 之间

(三) 字节数组的切片仍是字节数组

(四) 字符串转化为字节数组

#coding=gbk

s ="你好"

b = s.encode( "gbk") # 先将字符串按某种“GBK”编码方式转化为 bytes

c = bytearray( b ) #再将 bytes 转化为 字节数组

也可以写作

c = bytearray( "你好", "gbk")

(五) 字节数组转化为字符串

c = bytearray( 4 )

c[0] = 65 ; c[1]=66; c[2]= 67; c[3]= 68

s = c.decode( "gbk" )

print ( s )

# 应显示： ABCD

(六) 字节数组可用于写入文本文件

#coding=gbk

f = open("c:\\1234.txt", "wb")

s = "张三李四abcd1234"

# -------------------------------

# 在 python2.4 中我们可以这样写：

# f.write( s )

# 但在 python 3.0中会引发异常

# -------------------------------

b = s.encode("gbk")

f.write( b )

c=bytearray( "王五","gbk")

f.write( c )

f.close()

input("?")

Python笔记：Python装饰器

装饰器是通过装饰器函数修改原函数的一些功能而不需要修改原函数，在很多场景可以用到它，比如① 执行某个测试用例之前，判断是否需要登录或者执行某些特定操作；② 统计某个函数的执行时间；③ 判断输入合法性等。合理使用装饰器可以极大地提高程序的可读性以及运行效率。本文将介绍Python装饰器的使用方法。

python装饰器可以定义如下：

输出：

python解释器将test_decorator函数作为参数传递给my_decorator函数，并指向了内部函数 wrapper()，内部函数 wrapper() 又会调用原函数 test_decorator()，所以decorator()的执行会先打印'this is wrapper'，然后打印'hello world'， test_decorator()执行完成后，打印 'bye' ，*args和**kwargs，表示接受任意数量和类型的参数。

装饰器 my_decorator() 把真正需要执行的函数 test_decorator() 包裹在其中，并且改变了它的行为，但是原函数 test_decorator() 不变。

一般使用如下形式使用装饰器：

@my_decorator就相当于 decorator = my_decorator(test_decorator) 语句。

内置装饰器@functools.wrap可用于保留原函数的元信息（将原函数的元信息，拷贝到对应的装饰器函数里）。先来看看没有使用functools的情况：

输出：

从上面的输出可以看出test_decorator() 函数被装饰以后元信息被wrapper() 函数取代了，可以使用@functools.wrap装饰器保留原函数的元信息：

输出：

装饰器可以接受自定义参数。比如定义一个参数来设置装饰器内部函数的执行次数：

输出：

Python 支持多个装饰器嵌套：

装饰的过程：

顺序从里到外：

test_decorator('hello world') 执行顺序和装饰的过程相反。

输出：

类也可以作为装饰器，类装饰器主要依赖__call__()方法，是python中所有能被调用的对象具有的内置方法（python魔术方法），每当调用一个类的实例时，__call__()就会被执行一次。

下面的类装饰器实现统计函数执行次数：

输出：

下面介绍两种装饰器使用场景

统计函数执行所花费的时间

输出：

在使用某些web服务时，需要先判断用户是否登录，如果没有登录就跳转到登录页面或者提示用户登录：

--THE END--

python中函数定义

1、函数定义

①使用def关键字定义函数

②

def 函数名(参数1.参数2.参数3...):

"""文档字符串，docstring，用来说明函数的作用"""

#函数体

return 表达式

注释的作用：说明函数是做什么的，函数有什么功能。

③遇到冒号要缩进，冒号后面所有的缩进的代码块构成了函数体，描述了函数是做什么的，即函数的功能是什么。Python函数的本质与数学中的函数的本质是一致的。

2、函数调用

①函数必须先定义，才能调用，否则会报错。

②无参数时函数的调用：函数名()，有参数时函数的调用：函数名(参数1.参数2.……)

③不要在定义函数的时候在函数体里面调用本身，否则会出不来，陷入循环调用。

④函数需要调用函数体才会被执行，单纯的只是定义函数是不会被执行的。

⑤Debug工具中Step into进入到调用的函数里，Step Into My Code进入到调用的模块里函数。

68 个 Python 内置函数详解

内置函数就是Python给你提供的，拿来直接用的函数，比如print.，input等。

截止到python版本3.6.2 ，python一共提供了68个内置函数，具体如下

本文将这68个内置函数综合整理为12大类，正在学习Python基础的读者一定不要错过，建议收藏学习！

（1）列表和元组

（2）相关内置函数

（3）字符串

frozenset 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。

语法：sorted(Iterable, key=函数(排序规则), reverse=False)

语法：fiter(function. Iterable)

function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留留此项数据 , Iterable: 可迭代对象

搜索公众号顶级架构师后台回复“面试”，送你一份惊喜礼包。

语法 : map(function, iterable)

可以对可迭代对象中的每一个元素进行映射. 分别去执行 function

hash : 获取到对象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空间换的时间 比较耗费内存

python主函数怎么写

一般来说，Python程序员可能是这样写main()函数的：

"""Module docstring.

This serves as a long usage message.

"""import sysimport getoptdef main():

# parse command line options

try:

opts, args = getopt.getopt(sys.argv[1:], "h", ["help"]) except getopt.error, msg: print msg print "for help use --help"

sys.exit(2) # process options

for o, a in opts: if o in ("-h", "--help"): print __doc__

sys.exit(0) # process arguments

for arg in args:

process(arg) # process() is defined elsewhereif __name__ == "__main__":

main()1234567891011121314151617181920212223242526

Guido也承认之前自己写的main()函数也是类似的结构，但是这样写的灵活性还不够高，尤其是需要解析复杂的命令行选项时。为此，他向大家提出了几点建议。

添加可选的 argv 参数

首先，修改main()函数，使其接受一个可选参数 argv，支持在交互式shell中调用该函数：

def main(argv=None):

if argv is None:

argv = sys.argv # etc., replacing sys.argv with argv in the getopt() call.1234

这样做，我们就可以动态地提供 argv 的值，这比下面这样写更加的灵活：

def main(argv=sys.argv):

# etc.12

这是因为在调用函数时，sys.argv 的值可能会发生变化；可选参数的默认值都是在定义main()函数时，就已经计算好的。

但是现在sys.exit()函数调用会产生问题：当main()函数调用sys.exit()时，交互式解释器就会推出！解决办法是让main()函数的返回值指示退出状态（exit status）。因此，最后面的那行代码就变成了这样：

if __name__ == "__main__":

sys.exit(main())12

并且，main()函数中的sys.exit(n)调用全部变成return n。

定义一个Usage()异常

另一个改进之处，就是定义一个Usage()异常，可以在main()函数最后的except子句捕捉该异常：

import sysimport getoptclass Usage(Exception):

def __init__(self, msg):

self.msg = msgdef main(argv=None):

if argv is None:

argv = sys.argv try: try:

opts, args = getopt.getopt(argv[1:], "h", ["help"]) except getopt.error, msg: raise Usage(msg) # more code, unchanged

except Usage, err: print sys.stderr, err.msg print sys.stderr, "for help use --help"

return 2if __name__ == "__main__":

sys.exit(main())123456789101112131415161718192021222324

这样main()函数就只有一个退出点（exit）了，这比之前两个退出点的做法要好。而且，参数解析重构起来也更容易：在辅助函数中引发Usage的问题不大，但是使用return 2却要求仔细处理返回值传递的问题。

文章题目：python函数手写笔记,用python写函数
本文来源：http://6mz.cn/article/dssccei.html