python02-函数

http://www.cnblogs.com/wupeiqi/articles/5453708.html

三元运算符

#三元运算符
num = 60
ret = 100 if num > 100 else num
print(ret)

set集合

• set集合是无序无索引不可重复的

s = set([11,22,33,44,55])
print(s)
# ==> {33, 11, 44, 22, 55}

• set集合可以修改，如果重复添加，只会保存一个
• 创建空的set集合

s = set()
print(type(s)) # {} type = set
s = {}
print(type(s)) # {} type = dict
# 如果通过第二种方式创建，默认创建的是字典，所以创建空的set集合用第一种方式

• 创建set集合

s = set('abcdefg')
print(s)
s = set([11, 22, 33, 44])
print(s)
s = set(('aa', 'bb', 'cc'))
print(s)
# ===>
{'e', 'b', 'g', 'a', 'c', 'f', 'd'}
{33, 11, 44, 22}
{'bb', 'aa', 'cc'}
# 参数的类型必须是可迭代的

• set集合的方法
  • add(arg)：添加元素，如果set集合里有，则不会重复保存

s = set() # 创建一个空的集合
num1 = -10000
print("num1的内存地址为：", id(num1))  # 内存地址:16377440
s.add(num1)
num2 = -10000
print("num2的内存地址为：", id(num2))  # 内存地址:16377456
s.add(num2)
getNum = s.pop()
print("获取最新的内存地址：", id(getNum)) # 内存地址为第一次添加的地址，第二个没有保存进去

• • clear:清空集合
  • difference：比对像个集合A.difference(B),把A有B没有的元素返回到新给集合
  • difference_update：比对A、B集合，把A中与B公共的元素去除，直接操作A集合

A = set([11,22,33,44,55,66])
B = set([11,33,55,77,99])
return_set = A.difference(B)
print(return_set)   # {66, 44, 22}

A.difference_update(B)
print(A)            # {66, 44, 22}

• • discard:丢弃，删除，若不存在不会报错
  • remove:移除，若不存在则报错

s = {11,22,33,44,55,66}
s.discard(11)
print(s)
s.discard(77)
print(s)
s.remove(22)
print(s)
s.remove(99)
print(s)

• • updata:更新，参数为可迭代类型，内部通过for循环add进入

s = set()
li = [11, 22, 33, 44, 55, 66]
s.update(li)
print(s)
string = 'Hello_World'
s.update(string)
print(s)

• • issupset:是否是父集合
  • issubset:是否是子集合

s1 = {11, 22, 33, 44}
s2 = {11, 22, 33, 44, 55, 66, 77, 88}
print(s1.issubset(s1))
print(s2.issuperset(s1))
===>
True
True

• • pop:移除元素并返回值，由于set集合是无序的，删除的元素不一定是新增的元素

# pop：删除元素并返回值
s = {11, 22, 33, 44, 55, 66}
print(s)
popEle = s.pop()
print(popEle)

• • isdisjoint:是否没有交集,没有交集返回True
  • symmetric_difference:对称差集,把两个集合合并，同时去除交集
  • union:并集
  • update:更新,接收可迭代参数

深浅拷贝

• 对于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址

import copy
# ######### 数字、字符串 #########
n1 = 123
# n1 = "i am alex age 10"
print(id(n1))
# ## 赋值 ##
n2 = n1
print(id(n2))
# ## 浅拷贝 ##
n2 = copy.copy(n1)
print(id(n2))
  
# ## 深拷贝 ##
n3 = copy.deepcopy(n1)
print(id(n3))
# ===>
1485856400
1485856400
1485856400
1485856400

• 对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。
  • 赋值

n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
  
n2 = n1

• image
  • 浅拷贝
  • 浅拷贝，在内存中只额外创建第一层数据

import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n3 = copy.copy(n1)

• iamge
  • 深拷贝
  • 深拷贝，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）

import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n4 = copy.deepcopy(n1)

• iamge

函数

• 函数式编程最重要的是增强代码的重用性和可读性
• 参数类型
  • 普通参数
  • 默认参数
    • 注：默认参数需要放在参数列表最后
  • 动态参数

def func(name, age=18):
    print(name)
    print(age)

func("你好，世界")
func("Hello World", 19)  # 注：默认参数需要放在参数列表最后

def func(*args):
    print(args)
func(1, 2, 3, 4, 5, 6, 7)
func(*[11,22,33,44,55,66]) # 直接传入可迭代的类型,在前面加 * 

# 打印是一个元组

def func(**kwargs):
    print args

# 执行方式一
func(name='余浩宏', age=20, gender='man')

# 执行方式二
dic = {'name': '张三', 'age': 19, 'gender': 'man'}
func(**dic) # 直接传入字典，在前面加入** 

• 字符串、字典、列表最重要
• set集合没它们这么重要

lanbda表达式

• lanbda表达式只适用于简单的函数，不能表示复杂的函数表达式
• 函数名 = lanbda : 函数体
• 函数名 = lanbda 参数1,参数2,... : 返回值

fun = lambda str, num: int(str) + num
ret = fun('100', 100)
print('reslut is',ret)

内置函数

• 10进制转其他进制

  • int():转成10进制
  • hex():转成16进制
  • bin():转成2进制
  • oct():转成8进制

  ten2bin = bin(100)
  print(ten2bin) # 0b1100100
  
  ten2eight = oct(100)
  print(ten2eight) # 0o144
  
  ten2hex = hex(100)
  print(ten2hex) # 0x64
  

• 其他进制转10进制

  • int(str, base=2/8/10/16)

  bin2ten = int("0x64",base=16)
  print(bin2ten)
  

• str -- bytes转换

  b = bytes('HelloWorld', encoding='utf-8')
  s = str(b, encoding='utf-8')
  print(s)
  

• isinstance():判断实例是否属于这个类

• all()：传入interable参数，底层循环遍历所有的值，如果都为True，则返回True

  • False 、 None 、 [] 、{} 、'' 、0 、"" 为False

  """
  Return True if bool(x) is True for all values x in the iterable.
  If the iterable is empty, return True.
  """
  ret = all([1,2,3,0]) # 有0为False
  print(ret)
  

• any():和all一样，如果有一个为True,则返回True

  • False 、 None 、 [] 、{} 、'' 、0 、"" 为False

  """
  Return True if bool(x) is True for any x in the iterable.
  If the iterable is empty, return False.
  """
  

• ascii():传入对象，会自动调用对象的__repr__方法，或去返回的值

• boolean():根据传入的参数转为boolean

  b = bool(0)# False
  b = bool(1)# True
  b = bool('')# False
  b = bool([])# False
  b = bool({})# False
  b = bool(None)# False
  

• abs():取绝对值

• bytes:

• bytesarr:

  • 将字符串转为字节和字节数组，类似与字符串和列表

  b = bytes('string', encoding='utf-8')
  print(b)
  for i in b:
      print(i, "", end='')
  print('')
  bs = bytearray('string', encoding='utf-8')
  for i in bs:
      print(i, "", end='')
  #115 116 114 105 110 103 
  #115 116 114 105 110 103 
  

• chr():传入数字，转成acsii对应的字符

• ord()：传入字符，返回acsii对应的编码

  • 只适用于ascii码表

  chart = chr(65)
  print(chart) # A
  order = ord('a')
  print(order) # 97
  

• str():

• callable():是否和执行，传入的对象后面加()是否有代码执行

  • 如：创建对象，调用方法

• compile(str):编译，将字符串传入，编译成代码执行

• dir():查看方法

• help():查看详情

• divmod():除法，返回一个tuple(商,余),用于分页

  ret = divmod(10, 3)
  print(ret) # (3, 1)
  

• eval():执行字符串代码，有返回值(简单)

  • 在一些excle文档中有这样的需求:

  string = '1 + 3'
  ret = eval(string)
  print(ret)
  

• exec():执行字符串代码，没有返回值(复杂)

  string = '''
  for i in range(10):
      print('Hello World')
  '''
  exec(string)
  

• filter('函数'，iterable)：

  • 参数1为过滤函数，范围值通过boolean()转换为True，则保存起来，否则不保存
  • 参数2为可迭代类型，通过for循环取出来作为参数传入函数
  • 返回值为函数结果为True的参数，通过迭代可以取值

  li = [11,22,33,44,55]
  ret = filter(lambda num:True if num > 22 else False, li)
  for i in ret:
      print(i) # 33 44 55
  

• map('函数',iterale)：

  • 函数没有返回值
  • 参数通过for循环取出来作为参数传入函数

  li = [11,22,33,44,55]
  
  def addMethod(num):
      num += 100
      return num
  ret = map(addMethod, li)
  
  for i in ret:
      print(i)
  

• globals():获取所有的全局变量

• locals():获取所有的局部变量

• hash():获取hash值，一般用作键值

• iter():传入可被迭代的数，和next()函数并用

• next():取下一个值

  li = [11, 22, 33, 44, 55, 66]
  it = iter(li)
  item = next(it)
  print(item) # 11
  item = next(it)
  print(item) # 22
  

• max():取最大值

• min():取最小值

• pow(2,3):2的3次方

• reverse():反转

• rount():四舍五入

• sorted():排序

• zip(iterable, iterable):

  li1 = [1, 2, 3, 4, 5, 6]
  li2 = ['a', 'b', 'c', 'd', 'e', 'f']
  ret = zip(li1, li2)
  for item in ret:
      print(item)
  # ===>
  (2, 'b')
  (3, 'c')
  (4, 'd')
  (5, 'e')
  (6, 'f')
  

• --import--()

  r = __import__('random')
  a = r.random()
  print(a)
  

• sorted:

  • 参数传入可得到的类型，且元素必须是同一种类型，然后会调用参数的sort方法
  • 返回排序后的变量

  li = [22, 33, 11, 77, 55, 99]
  new_li = sorted(li)
  print(new_li)
  li.sort()
  print(li)
  

• 验证码

import random
ret = ''
for i in range(4):
    numOrStr = random.randrange(4)
    if numOrStr == 0 or numOrStr == 3:
        strIndex = random.randint(97, 122)
        c = chr(strIndex)
        ret += c
    else:
        strNum = str(random.randint(0, 9))
        ret += strNum
print('验证码:', ret)