函数 参数引用 知识点
写在前面：
python中 函数传参，传引用 ，形参其实是指针映射到 实际参数的的内存地址中的。一旦更改形参对应的值，实际参数也会改。 而 java c# 是可以改的，形参 实际参数都 生成一份数据 ，这个功能要想完成只需在 形参处 加一个ref out /再创建一份值
python 函数形参 是指针向实际参数的。
python中 直接 copy一份就行
函数参数 引用 1 ：修改 或删除形参的 值 ，实际参数值也变化
函数调用，而实际参数传入的是一个列表， 这样就是 形式参数args = 实际参数li = [1,2] 由下图表示
def func(args): type(args) print(type(args)) args.append(123) print(args)li = [1, 2]func(li)print(li)
删除 也删除 其实 li = [] args=li 原理一样def func(args): del args[2:]li=[1,2,3,4]a=func(li)print(li) #结果[1, 2]
函数 参数引用2 ： 形式参数 赋值 另开辟内存
尽管 传入实际参数 li 使得 args =li ，但是 函数主体 args=123 重新赋值 相当于args重新开辟了一段 内存空间，而原li还是原来的值 如果是同一个变量名 重新赋值，原来占用内存的那个 变量空间 python会定时回收
赋值 尽管 函数调用时候 args=li 但是重新赋值，等于申请了新的内存空间。def func(args): args=123li=[1,2,3,4]a=func(li)print(li)#结果 [1,2,3,4]
三 lambda 匿名函数
# lambda 匿名函数def f1(ar1, ar2): return ar1 + ar2f2 = lambda ar3, ar4: ar3 + ar4ret = f2(3, 4)print(ret)
学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：
1 # 普通条件语句2 if 1 == 1:3 name = 'wupeiqi'4 else:5 name = 'alex'6 7 # 三元运算8 name = 'wupeiqi' if 1 == 1 else 'alex'
对于简单的函数，也存在一种简便的表示方式，即：lambda表达式
1 # ###################### 普通函数 ###################### 2 # 定义函数（普通方式） 3 def func(arg): 4 return arg + 1 5 6 # 执行函数 7 result = func(123) 8 9 # ###################### lambda ######################10 11 # 定义函数（lambda表达式）12 my_lambda = lambda arg : arg + 113 14 # 执行函数15 result = my_lambda(123)
四 python的内置函数
注：查看详细
1 大部分函数
abs()返回一个数字的绝对值。如果给出复数，返回值就是该复数的模。
>>>print abs(-100)100>>>print abs(1+2j)2.2360679775
1 # 内置函数：2 # 1 abs() 绝对值3 a = 1234 b = -1235 print(abs(a))6 print(abs(b))
all() 所有为真才为真，只要有一个假就是假 判断假的条件：
任何一种都为假： 0 None 空值（字符串 列表 元组 字典）
li = [1, 2, 3, "", False]print(all(li))
any（） 一个为真就为真 同all相反，只有有真就返回True 真： 非0 非None 非空
1 li = [1, 2, 3, "", False]2 print(any(li))
ascii（） 用法：ascii（对象） ===去类中找 __repr__ 方法，获取返回值
1 class Foo(object):2 def __repr__(self):3 return "hello repr"4 5 6 li = Foo()7 n = ascii(li)8 print(n)
bin oct int hex 二进制 八进制 十进制 十六进制
1 # bin() 可以将 八 十 十六 进制 转换成二进制2 print(bin(10), bin(0o13), bin(0x14))3 # oct() 可以将 二 十 十六 进制 转换为八进制4 print(oct(10), oct(0b101), oct(0x14))5 # int() 可以将 二 八 十六进制转换为十进制6 print(int(0o13), int(0b101), int(0x14))7 # hex() 可以将 二 八 十 进制转换为十六进制8 print(hex(0b101), hex(110), hex(0o12))
bool 判断真假
看到上面的结果了没？是True。突然记起Python中除了''、""、0、()、[]、{}、None为False之外，其他的都是True。也就是说上面的'False'就是一个不为空的字符串，所以结果就为True了 1 >>> bool('False')2 True 将一个值转化成布尔值，使用标准的真值测试例程。如果x为假或者被忽略它返回；否则它返回。也是一个类，它是的子类。不能被继承。它唯一的实例就是和。
# 7 bytes bytearray 字节列表 byte在前面已经介绍过了 bytes('str',encoding='') bytearray([source[, encoding[, errors]]])
1 返回一个新的字节数组。bytearray类型是一个可变的整数序列，整数范围为0 <= x < 256（即字节）。 它有可变序列的大多数方法，参见Mutable Sequence Types，同时它也有str类型的大多数方法，参见String Methods。2 3 source参数可以以不同的方式来初始化数组，它是可选的：4 5 如果是string，必须指明encoding（以及可选的errors）参数；bytearray()使用str.encode()将字符串转化为字节数组。6 如果是integer，生成相应大小的数组，元素初始化为空字节。7 如果是遵循buffer接口的对象，对象的只读buffer被用来初始化字节数组。8 如果是iterable，它的元素必须是整数，其取值范围为0 <= x < 256，用以初始化字节数组。9 如果没有参数，它创建一个大小为0的数组。
>>> a = bytearray(3)>>> abytearray(b'\x00\x00\x00')>>> a[0] >>> a[1] >>> a[2] >>> b = bytearray("abc")>>> bbytearray(b'abc')>>> b[0] >>> b[1]>>> b[2] >>> c = bytearray([1, 2, 3])>>> cbytearray(b'\x01\x02\x03')>>> c[0] >>> c[1]>>> c[2] >>> d = bytearray(buffer("abc"))>>> dbytearray(b'abc')>>> d[0] >>> d[1] >>> d[2]
chr ord 转换 ascii对应的字符与十进制整数转换 可以百度 ascii 对照表 返回一个单字符字符串，字符的ASCII码为整数i。例如，chr(97)返回字符串'a'。 它是的逆运算。参数的取值范围为[0..255]的闭区间；如果i超出取值范围，抛出。参见。
1 c = chr(65)2 i = ord("A")3 print(c, i) 打印 字母 数字 # 随机验证码 程序：# 65 -90 A - Z# 而 random.randrange(num1,num2) 大于等于num1 小于num2 的随机数import randomtmp = ""for i in range(6): num = random.randrange(0, 4) # 0-3 随机 if num == 2 or num == 3: # 随机数字时候 赋值随机数字 rad1 = random.randrange(0, 9) rad1 = str(rad1) #转换字符串 tmp += rad1 #字符串拼接 else: rad2 = random.randrange(65, 91) rad2 = chr(rad2) tmp += rad2print("本次验证码：", tmp)
我自己写的验证码 数字 大小写字母
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | import random print (random.random()) print (random.randint( 1 , 2 )) # 返回列表的值[1,2] 因此 start 和end 都能访问到 ''' def randint(self, a, b): """Return random integer in range [a, b], including both end points. """ return self.randrange(a, b+1) ''' print (random.randrange( 1 , 10 )) # randrange(self, start, stop=None, step=1, _int=int) temp = "" flag = 1 for i in range ( 6 ): num = random.randint( 65 , 90 ) for n in range ( 4 ): if len (temp) > = 6 : flag = 0 break x = random.randint( 0 , 9 ) if x < n: temp + = str (x) elif x = = n: #temp += chr(num).swapcase() # 大写变小写，小写变大写到 temp + = chr (num).lower() # 大写变小写，小写变大写到 if len (temp) > = 6 : flag = 0 break if flag = = 0 : break temp + = chr (num) print (temp) |
callable(object)
检查某个对象是否可以被执行 即 对象（）
如果object参数可调用，返回；否则返回。如果返回真，对其调用仍有可能失败；但是如果返回假，对object的调用总是失败。注意类是可调用的（对类调用返回一个新实例）；如果类实例有方法，则它们也是可调用的。
# 10 classmethod 后面讲 重要
# 11 compile 编译 默认读文件都是字符串，经过编译变成代码
#!usr/bin/env python#coding:utf-8 namespace = {'name':'wupeiqi','data':[18,73,84]} code = '''def hellocute():return "name %s ,age %d" %(name,data[0],) ''' func = compile(code, ' ', "exec") exec func in namespace result = namespace['hellocute']() print result hasattr getattr delattr 反射 后面单独讲
# hasattr() getattr() delattr()# >>> hasattr(list, 'append')# True # >>> hasattr(list, 'add')# False
# 12 complex 复数
创建一个复数，它的值为real + imag*j；或者将一个字符串／数字转化成一个复数。如果第一个参数是个字符串，它将被解释成复数，同时函数不能有第二个参数。 第二个参数不能是字符串。每个参数必须是数值类型（包括复数）。如果imag被忽略，它的默认值是0，这时该函数就像是int()，long()和float()这样的数值转换函数。 如果两个参数都被忽略，返回0j。注意 当从字符串转化成复数的时候，字符串中+或者-两边不能有空白。例如，complex('1+2j')是可行的，但complex('1 + 2j')会抛出ValueError异常。在Numeric Types — int, float, long, complex中有对复数的描述。 # dir 显示类的方法
如果没有参数，返回当前本地作用域内的名字列表。如果有参数，尝试返回参数所指明对象的合法属性的列表。
如果对象有__dir__()方法，该方法被调用且必须返回一个属性列表。这允许实现了定制化的或者函数的对象定制报告对象属性的方式。
如果对象没有提供__dir__()，同时如果对象有定义__dict__属性，dir()会先尝试从__dict__属性中收集信息，然后是对象的类型对象。结果列表没有必要是完整的，如果对象有定制化的，结果还有可能是不准确的。
对于不同类型的对象，默认的行为也不同，因为它尝试产生相关的而不是完整的信息：
- 如果对象是模块对象，列表包含模块的属性名。
- 如果对象是类型或者类对象，列表包含类的属性名，及它的基类的属性名。
- 否则，列表包含对象的属性名，它的类的属性名和类的基类的属性名。
返回的列表按字母顺序排序。例如：
1 >>> import struct 2 >>> dir() # show the names in the module namespace 3 ['__builtins__', '__doc__', '__name__', 'struct'] 4 >>> dir(struct) # show the names in the struct module 5 ['Struct', '__builtins__', '__doc__', '__file__', '__name__', 6 '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into', 7 'unpack', 'unpack_from'] 8 >>> class Shape(object): 9 def __dir__(self):10 return ['area', 'perimeter', 'location']11 >>> s = Shape()12 >>> dir(s)13 ['area', 'perimeter', 'location']
注意
因为主要是为了在交互式环境下使用方便，它尝试提供有意义的名字的集合，而不是提供严格或一致定义的名字的集合，且在不同的版本中，具体的行为也有所变化。例如，如果参数是一个类，那么元类属性就不会出现在结果中。
# 14 divmod（10,3） 显示商和余数
# 分页 ：余数大于0 商+1 为页数
在长整数除法中，传入两个数字（非复数）作为参数，返回商和余数的二元组。 对于混合的操作数类型，应用二元算术运算符的规则。对于普通整数或者长整数，结果等同于(a // b, a % b)。对于浮点数结果是(q, a % b)，q一般是math.floor(a / b)，但也可能比那小1。 不管怎样，q * b + a % b非常接近于a，如果a % b非0，它和b符号相同且0 <= abs(a % b) < abs(b)。
# 15 enumerate 序列
enumeratesequence, start=0
返回一个枚举对象。sequence必须是个序列，迭代器，或者支持迭代的对象。返回的迭代器的next()方法返回一个元组，它包含一个计数（从start开始，默认为0）和从sequence中迭代得到的值：
1 >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']2 >>> list(enumerate(seasons))3 [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]4 >>> list(enumerate(seasons, start=1))5 [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
等同于：
def enumerate(sequence, start=0): n = start for elem in sequence: yield n, elem n += 1
# 16 eval # 字符串 转算 执行表达式 有返回值
evalexpression[, globals[, locals]]
参数是Unicode或者Latin-1编码的字符串，全局变量和局部变量可选。如果有全局变量，globals必须是个字典。如果有局部变量，locals可以是任何映射类型对象。
改变于版本2.4：在此之前locals需要是个字典。
expression参数被当作Python表达式来解析并演算（技术上来说，是个条件列表），使用globals和locals字典作为全局和局部的命名空间。如果globals字典存在，且缺少‘__builtins__’，在expression被解析之前，当前的全局变量被拷贝进globals。这意味着一般来说expression能完全访问标准模块，且受限的环境会传播。如果locals字典被忽略，默认是globals字典。如果都被忽略，表达式在被调用的环境中执行。返回值是被演算的表达式的结果。语法错误报告成异常。例子：
>>> x = 1>>> print eval('x+1')2 a = "1 + 3" n = eval(a) print(n) ret = eval("a+60", {"a": 88}) print(ret) 该函数也能执行任意的代码对象（如返回的结果）。 在这种情况下，传递代码对象而不是字符串。如果代码对象编译时mode参数为'exec'，返回None。
提示：语句支持动态的语句执行。函数支持执行文件中的语句。和函数返回当前的全局变量和局部变量的字典，可以传递给或者。
参见，该函数能安全演算只含字面量的表达式的字符串。
# 17 exec 将字符串 执行 complie 编译功能 结合是 模板引擎
exec("for i in range(3):print(i)")
# 18 filter map reduce # filter(函数，可迭代的对象）
1 def f1(x):2 if x >22:3 return True4 else:5 return False6 ret = filter(f1,[11,22,33])7 # 默认处理结果返回是一个类，需要迭代打印，因为浪费内存。 可以用next迭代取值。 或者for循环 循环依次取出8 print(next(ret)) print(list(ret))
1 #filter 实现 2 def myfilter(fuc,seq): 3 new_li = [] 4 for i in seq: 5 #print(i) 6 ret = fuc(i) 7 if ret: 8 new_li.append(i) 9 return new_li10 def f1(x):11 if x > 22:12 return True13 else:14 return False15 li = [11,22,33,44]16 new=myfilter(f1,li)17 print(new)
filterfunction, iterable
构造一个列表，列表的元素来自于iterable，对于这些元素function返回真。iterable可以是个序列，支持迭代的容器，或者一个迭代器。如果iterable是个字符串或者元组，则结果也是字符串或者元组；否则结果总是列表。如果function是None，使用特性函数，即为假的iterable被移除。
注意，在function不为None的情况下， filter(function, iterable) 等同于 [item for item in iterable if function(item)]； 否则等同于 [item foritem in iterable if item]（function为None）。
# filter中 lambda 函数替换 函数f1
1 ret1 = filter(lambda x:x>22,[11,22,33,44])2 print(list(ret1))
# map map(函数，可迭代的对象
1 # map 实现 2 def mymap(fuc,seq): 3 n_li = [] 4 for i in seq: 5 n_i=fuc(i) 6 n_li.append(n_i) 7 # print(n_li) 8 return n_li 9 def f2(x):10 return x+1011 li = [11,22,33,44]12 13 ret = mymap(f2,li)14 print(ret)
1 def f1(x): 2 if x >22: 3 return True 4 else: 5 return False 6 ret1 = map(f1,[11,22,33,44]) 7 print(list(ret1)) 8 结果是：[False, False, True, True] 9 10 ret1 = map(lambda x:x+22,[11,22,33,44])11 print(list(ret1))12 结果是：[33, 44, 55, 66]
# format 格式化 字符串拼接+ 性能低
后面讲
# globals（） 获取所有的全局变量 #local（） #获取所有局部变量
# hash（对象） 获取对象hash 内存优化 返回对象的hash（哈希/散列）值（如果有的话）。hash值是整数。它被用于在字典查找时快速比较字典的键。相同的数值有相同的hash（尽管它们有不同的类型，比如1和1.0）。 # isinstance（对象，类） 上面有讲 判断对象是否是某个类创建的 父类的话也成立 # issubclass 是否是子类 后面讲 # iter 迭代器 后面讲
obj = iter([11,22,33,44])ret = next(obj)print(ret)
# yield 生成器
后面讲
# max 最大 min
li = [11,22,33,44]max(li)
# pow求次方
a= pow(2,10)print(a)
# repr() === ascii() # round 四舍五入 round()方法返回 x 的小数点四舍五入到n个数字。
语法以下是round()方法的语法：round( x [, n] )参数x --这是一个数值表达式n --这也是一个数值表达式返回值该方法返回 x 的小数点四舍五入到n个数字例子下面的例子显示了round()方法的使用 #!/usr/bin/pythonprint "round(80.23456, 2) : ", round(80.23456, 2)print "round(100.000056, 3) : ", round(100.000056, 3)print "round(-100.000056, 3) : ", round(-100.000056, 3)当我们运行上面的程序，它会产生以下结果：round(80.23456, 2) : 80.23round(100.000056, 3) : 100.0round(-100.000056, 3) : -100.0
# slice 对象切片 在python中，list, tuple以及字符串等可以遍历访问的类型都可以应用slice访问。slice本身的意思是指切片，在这些可以遍历访问的类型中截取其中的某些部分。 #sum 求和 sum(iterable[, start]
将start以及iterable的元素从左向右相加并返回总和。start默认为0。iterable的元素通常是数字，start值不允许是一个字符串。
对于某些使用场景，有比更好的选择。连接字符串序列的首选和快速的方式是调用''.join(sequence)。如要相加扩展精度的浮点数，请参阅。若要连接一系列的可迭代量，可以考虑使用。
其实sum()的参数是一个list例如：sum([1,2,3])sum(range(1,11))还有一个比较有意思的用法a = range(1,11)b = range(1,10)c = sum([item for item in a if item in b])print c输出：45
# supper 找到父类 super
(
type[, object-or-type]
返回一个代理对象，这个对象指派方法给一个父类或者同类. 这对进入类中被覆盖的继承方法非常有用。搜索顺序和 一样。而它自己的 类型则被忽略
# vars 对象的变量个数 # zip 拉链 将两个列表合起来，做成一个列表，元素为数组
>>> a = range(5,10)>>> a[5, 6, 7, 8, 9]>>> b =(1,5)>>> b(1, 5)>>> b =range(1,5)>>> b[1, 2, 3, 4]>>> b.append(0)>>> b[1, 2, 3, 4, 0]>>> zip(a,b)[(5, 1), (6, 2), (7, 3), (8, 4), (9, 0)]>>> b.pop()0>>> b[1, 2, 3, 4]>>> a[5, 6, 7, 8, 9]>>> zip(a,b)[(5, 1), (6, 2), (7, 3), (8, 4)]
sort 函数
sortediterable[, cmp[, key[, reverse]]]
依据iterable中的元素返回一个新的列表。
可选参数cmp、key和reverse与list.sort()方法的参数含义相同（在一节描述）。
cmp指定一个自定义的带有两个参数的比较函数（可迭代的元素），它应该根据第一个参数是小于、等于还是大于第二个参数返回负数、零或者正数：cmp=lambda x,y: cmp(x.lower(), y.lower())。默认值是None。
key指定一个带有一个参数的函数，它用于从每个列表元素选择一个比较的关键字：key=str.lower。默认值是None（直接比较元素）。
reverse是一个布尔值。如果设置为True，那么列表元素以反向比较排序。
通常情况下，key和reverse转换处理比指定一个等同的cmp函数要快得多。这是因为cmp为每个元素调用多次但是key和reverse只会触摸每个元素一次。使用来转换旧式的cmp函数为key函数。
关于排序的实例和排序的简明教程，请参阅。
>>> sorted([5, 2, 3, 1, 4])[1, 2, 3, 4, 5]>>> a = [5, 2, 3, 1, 4]>>> a.sort()>>> a[1, 2, 3, 4, 5]sorted 默认值对列表排序故字典只对key排序>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})[1, 2, 3, 4, 5]key 函数>>> sorted("This is a test string from Andrew".split(), key=str.lower)['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']lambda>>> student_tuples = [ ('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10),]>>> sorted(student_tuples, key=lambda student: student[2]) # sort by age[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]The same technique works for objects with named attributes. For example:>>> class Student: def __init__(self, name, grade, age): self.name = name self.grade = grade self.age = age def __repr__(self): return repr((self.name, self.grade, self.age)) def weighted_grade(self): return 'CBA'.index(self.grade) / float(self.age)>>> student_objects = [ Student('john', 'A', 15), Student('jane', 'B', 12), Student('dave', 'B', 10),]>>> sorted(student_objects, key=lambda student: student.age) # sort by age[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]更多详见 https://wiki.python.org/moin/HowTo/Sorting/