def func1():

     return 123

 result1 = func1()

 print(result1)

 # 正常定义一个函数 => 123 

 func2 = lambda: 123

 result2 = func2()

 print(result2)

 # 使用lambda定义函数，效果同上 => 123 

 1 def func1(x, y):

 2     return x + y

 3

 4 result1 = func1(2, 3)

 5 print(result1)

 6 # func1()求两数之和 => 5

 7

 8

 9 func2 = lambda i, j: i + j

10 result2 = func2(2, 3)

11 print(result2)

12 # 效果同上 => 5 

 # abs() 取绝对值函数

 print(abs(-19))

 # => 19

 # all() 传入一个可迭代的参数，如果参数里所有元素为真，则返回真

 # 判断元素的真假可以使用bool(args)来判断

 list0 = [1, 'python', (1), {'key':'value'}]

 print(all(list0))

 # 以上列表里所有的元素都为真 所以结果 => True

 # 出现False的情况：元素里含有 0, None, [], (), {} 即 0， None 以及各种空值

 a = (0,1)

 b = [2, {}]

 print(all(a))

 print(all(b))

 # 以上a 里面有0， b 里面有{}, 两个结果都为False

 # any() 方法和all() 类似，any()的参数列表里只要有一个元素为True, 返回结果则为True

 a = (0,1)

 b = [2, {}]

 c = (0, [])

 print(any(a))

 print(any(b))

 print(any(c))

 # 以上结果分别为True, True, False

 # ascii() 使用ascii()会去对象所在的类里面找到__repr__() 方法，然后获取其返回值

 #

 list0 = list()

 result = ascii(list0)

 print(result)

 # 结果 => []

 # bin(), oct(), int(), hex() 二进制，八进制，十进制，十六进制

 # 参数默认十进制，在数字前加上所要转换的对应的方法即可得到相对应进制的值

 n1 = 12

 print(bin(n1))  # 0b1100

 print(oct(n1))  # 0o14

 print(int(n1))  # 12 十进制当然就不变啦

 print(hex(n1))  # 0xc

 # 其他进制转为十进制同理：

 i1 = int('', base=2)

 print(i1)  #

 i2 = int('', base=8)

 print(i2)  #

 i3 = int('aa', base=16)

 print(i3)  #

 # bool() 判断真假，即把一个对象转换为bool值

 print(bool(None))

 print(bool(0))

 print(bool([]))

 # 正如前面所提，上述bool值皆为False

 # bytes(), bytearray() bytes是字节，bytearray是字节数组/字节列表，两者的关系类似于字符串和列表

 # 需要记住的字符串和字节的转换

 print(bytes('爬虫', encoding='utf-8'))

 # 结果 => b'\xe7\x88\xac\xe8\x99\xab'

 # chr(), ord()

 # chr() 接收一个数字，找到数字在ascii码里对应的元素

 # ord() 接收一个ascii码里的元素，找到这个元素在ascii码里所对应的数字

 print(chr(56))  # => 8 ascii码里56对应数字8

 print(chr(255))  # => ÿ

 print(ord(''))  # => '0' 在ascii表里对应数字48

 print(ord('A'))  # => 'A' 在ascii表里对应65

 import random

 code = ''

 for i in range(0, 6):

     number = random.randrange(0, 4)

     if number == 1 or number == 2:

         dig = random.randrange(0, 10)

         code += str(dig)

     else:

         char = random.randrange(65, 91)

         code += chr(char)

 print(code)

 # 生成一个六位的随机验证码 

 # callable() 判断一个对象是否是可执行的

 def f1():

     return 123

 ret = callable(f1)

 print(ret)

 # 返回True，表示f1是可执行的

 f1 = 123

 ret = callable(f1)

 print(ret)

 # 返回False，可见变量f1是不可执行的

 # complex() 复数

 # dir()，显示对象所具有的所有功能 help() 显示具体类的功能

 # divmod() 输入两个参数，被除数和除数，返回商和余数

 r1 = divmod(100, 23)

 print(r1)

 r2 = divmod(20, 20)

 print(r2)

 # 分别结果为(4, 8) 和(1, 0)

 # divmod() 方法在数据分页中会用到，比如一共有120条博客，每一页只能显示25条，那么就需要5页来显示，最后一页显示20条博客信息。

 # eval() exec() eval()可以将字符串转换为表达式，exec()可以将字符串转为代码来执行

 # eval() 有返回值，exec() 无返回值

 a = ' 21 * 2 + 62 * 3'

 print(a)  # 结果 => 21 * 2 + 62 * 3

 print(eval(a))  # 结果 => 228

 # 在有一堆字符串记录的数字的时候，可以通过eval()方法来提取数据进行转换计算，非常方便。

 a = eval('a + 30', {'a': 20})

 print(a)

 # 结果为50 eval()的参数还可以带有参数，参数可以通过列表来传入

 a = exec('print("Hello Python")')

 a = exec('for i in range(0, 3): print(i)')

 print(a)

 # 第一个语句输出了'Hello Python'

 # 第二个语句循环出了0, 1, 2

 # exec() 没有返回值

 # compile() 用来编译， exec() 用来执行

 # filter() - map()

 # filter() 输入两个参数：1. 函数， 2. 可迭代的对象。所做的事情是循环可迭代的对象，对每个元素执行函数，留下返回值为True的元素

 # map() 对每个元素进行统一的操作

 def f1(x):

     if x > 10:

         return True

 result = filter(f1, [2, 12, 3, 41, 21, 9])

 print(result)  # 结果为<filter object at 地址> 迭代后创建显示结果

 for i in result:

     print(i)

 # 结果为12, 41, 21

 # 以上用lambda表达式也可以写为：

 result = filter(lambda x: x > 10, [2, 12, 3, 41, 21, 9])

 for i in result:

     print(i)

 # 结果和上例一样

 map_result = map(lambda x: x**2, [1, 3, 5, 7, ])

 for i in map_result:

     print(i)

 # 得到结果1, 9, 25, 49

 # format() 字符串格式化

 # frozenset() 冻结的一个set，不可以增删改

 # globals() 获取当前代码里所有的全局变量

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

 ret = globals()

 ret2 = locals()

 print(ret)

 print(ret2)

 # 得到结果： {'result': <filter object at 0x0000020E81268588>, '__package__': None, '__doc__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020E811F7B70>, 'r1': (4, 8), '__file__': 'D:/NaomiPyer/naomi_01/mod8/built_in2.py', '__name__': '__main__', 'ret': {...}, 'ret2': {...}, '__builtins__': <module 'builtins' (built-in)>, 'i': 49, 'f1': <function f1 at 0x0000020E8125F2F0>, '__spec__': None, 'map_result': <map object at 0x0000020E81268518>, 'r2': (1, 0), 'a': None, '__cached__': None}

 # {'result': <filter object at 0x0000020E81268588>, '__package__': None, '__doc__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020E811F7B70>, 'r1': (4, 8), '__file__': 'D:/NaomiPyer/naomi_01/mod8/built_in2.py', '__name__': '__main__', 'ret': {...}, 'ret2': {...}, '__builtins__': <module 'builtins' (built-in)>, 'i': 49, 'f1': <function f1 at 0x0000020E8125F2F0>, '__spec__': None, 'map_result': <map object at 0x0000020E81268518>, 'r2': (1, 0), 'a': None, '__cached__': None}

 # hash() 用在key的保存上，给定一个对象，可以自动转一个hash值

 print(hash(18.91))

 print(hash('a'))

 print(hash(0.1342))

 # 分别返回了 2098317138384461842, -7491389250214063272, 309444131836477760

 # iter() 返回一个可以被迭代的对象

 obj = iter([1, 2, 3])

 print(obj)

 for i in obj:

     print(i)

 # 和range()一样，返回一个对象，循环里面每个元素输出每个对象值

 # max() min() 返回参数里的最大值/最小值

 # pow(a, b) 求a的b次方

 a = pow(2, 10)

 print(a)  # =>1024

 # memoryview() 查看对象的内存地址 对象要求是bytes形式

 a = bytes(123)

 b = memoryview(a)

 print(b)

 # => <memory at 0x0000021DE8D02E88>

 # repr() 和ascii() 一样，都是指向__repr__()，找到类的返回值

 # round() 四舍五入

 a = 3.14

 print(round(a))  # => 3

 # sum() 求和

 a = [21, 35, 52, 63, 92, -62]

 b = sum(a)

 print(b)

 # => 201

 # var() 查看一个对象里有多少的变量

 # super() 查看父类

 # reversed(), reverse(), sort(), sorted()

 list0 = [1, 3, 5, 2, 4]

 print(reversed(list0))

 # reversed() 重新生成列表，返回对象位置 => reversed(list0) <list_reverseiterator object at 0x000001489292E358>

 print(sorted(list0))

 # 重新生成一个升序列表 => [1, 2, 3, 4, 5]

 # sort(), sorted() 只能对同类型的数据进行排序

 list0.reverse()

 print(list0)

 # 直接修改原list, 结果 => [5, 4, 3, 2, 1]

 list0.sort()

 print(list0)

 # sort() 也是直接修改list => [1, 2, 3, 4, 5]

 # zip() 将多个列表的元素一次串起来形成字典

 a = [1, 2, 3, 4, 5, ]

 b = ['bananas', 'carrots', 'blueberries', 'milk', 'queso', ]

 c = ['nestle', 'oreo', 'cheetos', 'lays', 'pepsi', ]

 d = zip(a, b, c)

 for i in d:

     print(i)

 '''

 返回结果：

 (1, 'bananas', 'nestle')

 (2, 'carrots', 'oreo')

 (3, 'blueberries', 'cheetos')

 (4, 'milk', 'lays')

 (5, 'queso', 'pepsi')

 '''

 # 关于排序， sort() 只排同一类型的数据

 # sort() 比较字符串的时候，顺序基本是数字>字母>中文，比较时，先对元素第一个字符进行比较

 list1 = ['', 'carrots', '大老虎', 'cap', '__',  '', '瞎驴', '**', 'south park']

 list1.sort()

 print(list1)

 # => ['**', '110', '21', '__', 'cap', 'carrots', 'south park', '大老虎', '瞎驴']

>>> a = 4

>>> b = 3

>>> a if a >= b else b

4

1 a = 'asdfewfqwef'

2 r = isinstance(a, str)

3 print(r)

4 # 如果a 是一个str，返回True

5

6 b = 1323412

7 r = isinstance(b, int)

8 print(r)

9 # 如果b是一个int，返回True

 def func1(args):

     args = [0]

     return args

 li = [1, 2, 3]

 ret = func1(li)

 print(ret)  # => [0]

 print(li)  # => [1, 2, 3]