【笔记】Python基础二：数据类型之集合，字符串格式化，函数

一，新类型：集合

集合出现之前

python_l = ['lcg','szw','zjw']
linux_l = ['lcg','szw','sb']

#循环方法求交集
python_and_linux_l = []
for p_name in python_l:
    if p_name in linux_l:
        python_and_linux_l.append(p_name)

print(python_and_linux_l)

特点：

1，不同元素组成

2，无序

3，集合中的元素必须是不可变类型：数字，字符串，元组

4，集合本身是可变类型，可以追加和删除元素。注意：使用frozenset('hello')把集合定义成不可变类型

s = frozenset('hello')
print(s)

形式：

s = {1,2,3,4,5,6}

s = set("hello")                 # s={'e','o','h','l'}

s = set(['alex','alex','sb'])    # s={'sb','alex'}

用途：删除重复值

names = ['alex', 'alex','wupeiqi']
s = set(names)
print(s)
names  = list(s)
print(names)

输出：

{'wupeiqi', 'alex'}
['wupeiqi', 'alex']

内置方法：

s = {1,2,3,4,5,6}

1，s.add(7)

2，s.clear()

3，s1 = s.copy()

4，s.pop() #无序的集合，随机删除

5，s.remove('sb')

如果不存在，会报错

6，s.discard('sbb')

如果不存在，不会报错

7，求交集,同时报了两门课程的人

python_l = ['lcg','szw','zjw']
linux_l = ['lcg','szw','sb']

p_s = set(python_l)
l_s = set(linux_l)
print(p_s,l_s)

print(p_s.intersection(l_s))
print(p_s&l_s)

8，求并集,所有人的集合

print(p_s.union(l_s))
print(p_s|l_s)

9，求差集,报了python没有报linux的人

print('差集',p_s - l_s)
print('差集',p_s.difference(l_s))

10，交叉补集,合到一块,扣掉共同的部分，只报了一门课程的人,可能是python,也可能是linux

print('交叉补集',p_s.symmetric_difference(l_s))
print('交叉补集',p_s^l_s)

11，求差集后更新

p_s.difference_update(l_s) #相当于 p_s = p_s - l_s
print(p_s)

12，如果没有交集则为TRUE

s1 = {1,2}
s2 = {1,2,3,5}
print(s1.isdisjoint(s2)) #False

13，父集与子集

print(s1.issubset(s2))  #True S1是S2的子集
print(s2.issuperset(s1)) #True S2是S1的父集

14，update可以更新(添加)多个值

s1 = {1,2}
s2 = {1,2,3,5}
#s1.update(s2)
s1.update([3,4])
s2.add(4) #add只能更新一个值
print(s1,s2)

二，字符串格式化

（一），百分号方式

#%s万能替换符号
msg='i am %s my hobby is %s' % ('lhf','alex')
print(msg)

#传数字
msg='i am %s my hobby is %s' % ('lhf',1)
print(msg)

#传列表
msg='i am %s my hobby is %s' % ('lhf',[1,2])
print(msg)

#传变量
name='lhf'
age=19
msg='i am %s my hobby is %d' % (name,age)
print(msg)

#打印浮点数
tpl = "percent %.2f" % 99.976234444444444444
print(tpl)

#打印百分号
tpl = 'percent  %.2f %%' % 99.976234444444444444
print(tpl)

#传字典，键值形式打印
tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}
print(tpl)

#打印格式调整
msg='i am %(name)+60s my hobby is alex' %{'name':'lhf'}
print(msg)

#颜色
msg='i am \033[43;1m%(name)+60s\033[0m my hobby is alex' %{'name':'lhf'}
print(msg)

#使用分隔符 sep
print('root','x','','',sep=':')

（二），format方式

#一一对应
tpl = "i am {}, age {}, really {}".format("seven", 18,"alex")
print(tpl)

#控制顺序
tpl = "i am {2}, age {1}, really {0}".format("seven", 18,"alex")
print(tpl)

tpl = "i am {1}, age {1}".format("seven", 18,"alex")
print(tpl)

#传入字典形式
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
print(tpl)

#传入字典,必须使用两个**,
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
print(tpl)

#传入列表使用一个*
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
print(tpl)

tpl = "i am {:s}, age {:d}".format("seven", 19) #["seven", 19]
print(tpl)
l=["seven", 19]
tpl = "i am {:s}, age {:d}".format(*l) #*相当于遍历列表l,一个一个取出来替换到字符串里面
print(tpl)

#各种格式表示符号
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%},{}".format(15, 15, 15, 15, 15, 15.87623, 2)
print(tpl)

三，函数

（一），数学定义的函数和Python里的函数

1，数学函数：对于每个确定的x的值，y都有唯一的值与其对应，y是因变量，x是自变量

2，python中函数

def test(x): #:param x:整形数字
    '''注释解释函数作用'''
    y=2*x+1
    return y #:return: 返回计算结果

y = test(3)
print(y)

（二），函数特点

1，同名的函数，最后一个会覆盖前面的函数，只能使用最后一个，下面函数执行结果是：9

def test(x): #:param x:整形数字
    '''注释解释函数作用'''
    y=2*x+1
    return y #:return: 返回计算结果

def test(): #:param x:整形数字
    '''注释解释函数作用'''
    x =4
    y=2*x+1
    return y #:return: 返回计算结果

y = test()
print(y)

（三），函数作用

1，代码重用

2，保持一致性，易维护

3，可扩展性

（四），函数和过程

过程：就是没有返回值的函数

Python里面可以认为没有过程。

（五），函数返回值，返回一个对象：数字，字符串，元组和字典等，只要一碰到return就结束，多个return没有作用

def test01():
    msg = 'test01'
    print(msg)

def test02():
    msg = 'test02'
    print(msg)
    return msg

def test03():
    msg = 'test03'
    print(msg)
    return 1,2,3,4,'a',['alex'],{'name':'alex'},None

def test04():
    msg = 'test04'
    print(msg)
    return {'name':'alex'}
t1=test01()
t2=test02()
t3=test03()
t4=test04()
print(t1)
print(t2)
print(t3)
print(t4)

输出：

test01
test02
test03
test04
None
test02
(1, 2, 3, 4, 'a', ['alex'], {'name': 'alex'}, None)
{'name': 'alex'}

（六），函数参数

1，形参变量：只有在被调用时才分配内存单元，在调用结束时，即可释放所分配的内存单元，因此，形参只在函数内部有效，调用结束后会释放资源不能再使用。

2，实参变量：可以是常量，变量，表达式，函数等，无论是什么类型，在调用时必须有确定的值，以便把这些值传给形参。因此应预先用赋值，输入等办法使参数获得确定值。

def calc(x,y): #x,y 形参
    res=x**y
    return res

res=calc(2,3) #2，3实参
print(res)

3，位置参数：必须一一对应，缺一不行多一也不行

def test(x,y,z):#x=1,y=2,z=3
    print(x)
    print(y)
    print(z)

test(1,2,3) #位置参数

4，关键字参数，无须一一对应，缺一不行多一也不行

test(y=1,x=3,z=4)

5，混合使用，位置参数必须在关键字参数左边

# test(1,y=2,3)#报错
# test(1,3,y=2)#报错
# test(1,3,z=2)
# test(1,3,z=2,y=4)#报错
# test(z=2,1,3)#报错

6，默认参数

def handle(x,type='mysql'):
    print(x)
    print(type)
handle('1hello')
handle('2hello',type='sqlite')
handle('3hello','sqlite') #位置参数调用

输出结果

1hello
mysql
2hello
sqlite
3hello
sqlite

7，参数组：**可用于传字典 *可用于传列表

1）作用，可以预留一个 *args，一个**kwargs，方便以后扩展。

2） *举例，归根结底还是传位置参数

def test(x,*args):
    print(x)
    print(args)
    print(type(args))
    print(type(args[0]))
test(1) #1传给x，args得到的为空()
test(1,2,3,4,5,6) #1传给x，2,3,4,5,6作为个体数字传给args元组
test(1,{'name':'alex'}) #1传给x,一个元组整体传给args,元组的第一个元素是字典{'name':'alex'}
test(1,['x','y','z'])#1传给x,一个元组整体传给args,元组的第一个元素是列表['x', 'y', 'z']
test(1,*['x','y','z'])#1传给x,'x','y','z'作为个体字符串传给args元组

3） * *举例，传字典

def test10(x,**kwargs):
    print(x)
    print(kwargs)
    print(type(kwargs))

test10(1,y = 2,z = 3)#1传给x，{'z': 3, 'y': 2}作为一个字典传给kwargs
test10(1,1,2,2,2,2,2,y=2,z=3)#报错，位置参数必须一一对应，不能多也不能少
test10(1,y=2,z=3,z=3)#报错 ：一个参数不能传两个值

4）联合使用

def test(x,*args,**kwargs):
    print(x)
    print(args,args[-1])
    print(kwargs,kwargs.get('y'))

test(1,1,2,1,1,11,1,x=1,y=2,z=3) #报错,x被赋给多个值
test(1,1,2,3,4,5,6,y=2,z=3) #元组(1, 2, 3, 4, 5, 6)传给args,字典{'z': 3, 'y': 2}传给kwargs
test(1,*[1,2,3],**{'y':1})#使用*和**传递,和上面一样

（七），全局变量与局部变量

局部变量在子程序里面定义，在子程序里面使用；全局变量顶头写，在整个文件可以使用。

下面这段代码和论述可以省略了，因为总结一下：如果global关键字在函数里出现，那操作的对象就是全局变量；如果没出现，就在函数内找这个变量，找到就用，没找到就往上一级找，直到全局变量为止。

全局变量和局部变量的关系

如果函数的内容无global关键字，
  - 有声明局部变量,则直接操作局部变量
        NAME = ["产品经理","廖波湿"]
        def qupengfei():
            NAME = "自己"
            print('我要搞', NAME)
        qupengfei()
  - 无声明局部变量,只能读取全局变量,无法对全局变量重新赋值,因为如果赋值就相当于声明局部变量
        但是对于可变类型如列表,可以对元素进行操作如append
        NAME = ["产品经理","廖波湿"]
        def qupengfei():
            NAME.append('XXOO')
            print('我要搞', NAME)
        qupengfei()

如果函数的内容有global关键字
  - 有声明局部变量,其实是给全局变量重新赋值
        NAME = ["产品经理","廖波湿"]
        def qupengfei():
            global NAME
            NAME = "自己"
            print('我要搞', NAME)
        qupengfei()
        错误示例,报错,因为先声明一个局部变量,然后又把全局变量弄来,产生混乱
        NAME = ["产品经理","廖波湿"]
        def qupengfei():
            NAME = "自己"
            global NAME
            print('我要搞', NAME)
        qupengfei()
  - 无声明局部变量,变量本质上是全局那个变量,可以读取,修改
        NAME = ["产品经理","廖波湿"]
        def qupengfei():
            global NAME
            NAME.append('XXOO')
            print('我要搞', NAME)
        qupengfei()

####### 全局变量变量名大写
####### 局部变量变量名小写

练习：

NAME = '海风'
def huangwei():
    name = "黄伟"
    print(name)
    def liuyang():
        name = "刘洋"
        print(name)
        def nulige():
            name = '沪指花'
            print(name)
        print(name)
        nulige()
    liuyang()
    print(name)

huangwei()

输出：黄伟，刘洋，刘洋，沪指花，黄伟

nonlocal关键字

name = "刚娘"

def weihou():
    name = "陈卓"
    def weiweihou():
        nonlocal name   # nonlocal，指定上一级变量，如果没有就继续往上直到找到为止
        name = "冷静"

    weiweihou()
    print(name)

print(name)
weihou()
print(name)

输出：刚娘，冷静，刚娘

（八），前向引用：可以把函数当成变量，在使用之前需要先声明，否则会报错

1，缺少声明报错

def foo():
    print('from foo')
    bar()

foo()

2，先声明，后使用，正常情况

def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()

foo()

def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')
foo()

3，使用在声明前，报错

def foo():
    print('from foo')
    bar()

foo()

def bar():
    print('from bar')

（九），函数递归

1，递归特性

1）必须有一个明确的结束条件

2）每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3）递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈stack这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

2，举例1

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

res=calc(10)
print(res)

3，举例2

import time
count1 = 0

person_list=['alex','wupeiqi','linhaifeng','zsc']
def ask_way(person_list):
    global count1
    count1 += 1
    print('-'*60)
    if len(person_list) == 0:
        return '根本没人知道'
    person=person_list.pop(0)
    if person == 'linhaifeng':
        return '%s说:我知道,老男孩就在沙河汇德商厦,下地铁就是' %person

    print('hi 美男[%s],敢问路在何方' % person)
    print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' % (person, person_list))
    time.sleep(10)
    res=ask_way(person_list)

    print('%s问的结果是: %s:%d' %(person,res,count1))
    time.sleep(10) #注意这个sleep，如果在print上面使用完全看不到结果，因为整个递归调用的时间远大于sleep时间
    #所以当递归返回时，sleep已经完成，就会马上返回。还可以说明如果sleep紧跟递归函数则认为sleep是并行的
    #如果sleep跟在print后面则会起到期望的效果
    count1 -= 1
    return res

res=ask_way(person_list)
print(res)

（十）函数作用域

函数的作用域只跟函数声明时定义的作用域有关，跟函数的调用位置无任何关系

例1，在python里面得到一个函数的地址，在地址后面加一个括号（）表示执行

def test1():
    print('in the test1')
def test():
    print('in the test')
    return test1 #这里返回的是test1的地址,而不是运行test1

res=test() #运行test函数后输出'in the test'并把test1的地址赋给res
print(res()) #在res后面加括号表示运行test1函数，会输出'in the test1'，最后整个函数是返回一个None

输出

in the test
in the test1
None

例2，每个变量的作用域符合前面“全局与局部变量”论述的原则。

name='alex'

def foo():
    name='lhf'
    def bar():
        name='wupeiqi'
        print(name)
        def tt():
            #global name
            print(name)
        return tt
    return bar

# bar=foo() #运行foo得到函数bar地址
# tt=bar()  #运行bar得到函数tt地址,输出wupeiqi
# tt()      #运行tt输出wupeiqi
foo()()()   #相当于上面三句运行

输出

wupeiqi
wupeiqi

（十一），匿名函数

1，匿名函数使用关键字lambda，

#分号前为形参，分号后为返回值
func=lambda x:x+'_sb' #func只为演示使用，正常使用时，不会起函数名
res=func('alex')      #传实参‘alex’给形参x
print('匿名函数的运行结果',res)

输出：匿名函数的运行结果 alex_sb

2，匿名函数可以传多个参数，返回多个值

mul =lambda x,y,z:(x+1,y+1,z+1)
res = mul(1,2,3)
print(res)

输出

(2, 3, 4)

（十二），函数式编程

编程的方法论 1，面向过程：从头开始，一步一步执行流程。 2，函数式：使用编程语言定义的函数来表示数学模型。 3，面向对象

python不是严格意义函数式编程语言。Hashell，clean，erlang是函数式编程语言。

1，函数式编程特点

例一，不可变，函数内不用变量保存状态，不修改变量

例二，第一类对象：函数即“变量”。符合下面两个条件的任一个为高阶函数

a，函数名可以当作参数传递

def foo(n): #n=bar foo是高阶函数
    print(n)

def bar(name): #bar不是高阶函数
    print('my name is %s' %name)

#foo(bar)
foo(bar('alex'))

输出

my name is alex
None

b，返回值可以是函数名

例1：

def bar():
    print('from bar')
def foo():
    print('from foo')
    return bar
n=foo()
n()

输出

from foo
from bar

例2：

def hanle():
    print('from handle')
    return hanle  #handle是高阶函数
h=hanle()
h()

输出

from handle
from handle

例三，尾调用：在函数的最后一步调用另外一个函数（最后一行不一定是函数的最后一步）

如果符合尾调用的条件，则因为递归的栈不需要保存当前状态，所以效率会更高

1， 最后一行不一定是函数最后一步例子

def test(x):
    if x > 1:
        return True
    elif x == 1:
        return False
    else:
        return True

test(1)

2，非尾调用例子

def bar():
    return n
def foo(x):
    return bar(x) + 1 #这步不是尾调用，因为bar()后还要运行+1运算。

（十三），map函数

例1，对列表里的每个元素进行加1

num_l=[1,2,10,5,3,7]

#lambda x:x+1
def add_one(x):
    return x+1

def map_test(func,array): #func=lambda x:x+1    arrary=[1,2,10,5,3,7]
    ret=[]
    for i in array:
        res=func(i) #add_one(i)
        ret.append(res)
    return ret

print(map_test(lambda x:x+1,num_l))
res=map(lambda x:x+1,num_l)
print('内置函数map，处理结果',res) #首先证明处理结果是一个可迭代对象<map object at 0x0000000000A68C88>
print('内置函数map，使用list取出处理结果',list(res))#使用list把可迭代对象的内容取出来,只能取一次
print('也可以传有名函数，等效的',list(map(add_one,num_l)))

输出：

[2, 3, 11, 6, 4, 8]
内置函数map，处理结果 <map object at 0x0000000000848E80>
内置函数map，使用list取出处理结果 [2, 3, 11, 6, 4, 8]
也可以传有名函数，等效的 [2, 3, 11, 6, 4, 8]

例2，处理字符串变大写

msg='linhaifeng'
print(list(map(lambda x:x.upper(),msg)))

输出：['L', 'I', 'N', 'H', 'A', 'I', 'F', 'E', 'N', 'G']

（十四），filter函数

filter函数和map函数有些类似，也是传入一个可迭代对象，经过处理，返回一个可迭代对象。处理的逻辑为对每个可迭代对象的元素进行逻辑判断，为真则保留

例1：过滤掉列表里带’sb‘的元素

movie_people=['alex_sb','wupeiqi_sb','linhaifeng','yuanhao_sb']
print(list(filter(lambda n:not n.endswith('sb'),movie_people))) #判断逻辑是以'sb'结尾前加了一个not,就是不是以'sb'结尾

输出：['linhaifeng']

（十五），reduce函数

reduce函数的作用是把一个可迭代对象进行压缩，比如加和或者连乘

例1：

from functools import reduce
num_l=[1,2,3,100]
print(reduce(lambda x,y:x+y,num_l,1))
print(reduce(lambda x,y:x+y,num_l))

输出：

107

106

三个函数一起总结：

#map处理序列中的每个元素，得到的结果是一个‘列表’，该‘列表’元素个数及位置与原来一样

#filter遍历序列中的每个元素，判断每个元素得到布尔值，如果是True则留下来
#而且filter不仅能处理数值,下面这个就是字典组成的列表
people=[
    {'name':'alex','age':1000},
    {'name':'wupei','age':10000},
    {'name':'yuanhao','age':9000},
    {'name':'linhaifeng','age':18},
]
print(list(filter(lambda p:p['age']<=18,people)))
#输出:[{'age': 18, 'name': 'linhaifeng'}]

#reduce:处理一个序列，然后把序列进行合并操作
from functools import reduce
print(reduce(lambda x,y:x+y,range(100),100))#1到99加上初始值100
print(reduce(lambda x,y:x+y,range(1,101)))  #1到100,没有初始值

（十六），内置函数

1，第一部分

print(abs(-1))#绝对值
#输出:1

print(all([1,2,'']))#序列中每个元素拿出来，做布尔运算,如果全是True,则返回True
#输出:True
print(all([1,2,'','']))
#输出:False
print(all(''))
#输出:True
print(all([])) #如果可迭代对象为空，则返回True。注意这里面只有一个对象[]
#输出:True
print(all('')) #如果可迭代对象为空，则返回True。注意这里面只有一个对象''
#输出:True

print(any([0,''])) #如果有一个为True，则为True
#输出:True
print(any([0,'']))
#输出:False

print(bin(3))#转换二进制
#输出:0b11

#空(""空字符串,()空元组,[]空列表,{}空字典),None,0的布尔值为False,其余为True，
print(bool(''),bool([]),bool(()),bool({}))
#输出:False False False False
print(bool(None))
#输出:False
print(bool(0))
#输出:False

#所有乱码的根源就是编码是一种格式，解码使用另外一种格式·
name = '你好'
print(bytes(name,encoding='utf-8'))
#输出:b'\xe4\xbd\xa0\xe5\xa5\xbd'  前三个字节代表你,后三个字节代表好
print(bytes(name,encoding='utf-8').decode('utf-8'))
#输出:你好

print(bytes(name,encoding='gbk'))
#输出:b'\xc4\xe3\xba\xc3'
print(bytes(name,encoding='gbk').decode('gbk'))
#输出:你好

#print(bytes(name,encoding='ascii')) #ascii不能编码中文
#输出:UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

print(chr(97)) #输出数字对应的ascii字符
#输出:a

print(dir(all))#打印内置函数里面都有哪些方法和属性
#输出:['__call__', '__class__', '__delattr__', '__dir__', '__doc__', ......

print(divmod(10,3))#取商得余数，可以在blog中做分页功能
#输出:(3, 1)

#eval把字符串里面的数据结构提取出来
dic = {'name':'alex'}
dic_str = str(dic)
print(dic_str)
#输出:{'name': 'alex'}  #注意这是一个字符串
d1 = eval(dic_str)
print(d1['name'])
#输出:alex
#eval可以计算字符串里的数学表达式
express = '1+2*(3/3-1)-2'
print(eval(express))
#输出:-1.0

#可hash的意味着不可变数据类型,不可hash的是可变数据类型
#hash特性：得到的结果是固定长度，不能根据hash值反推源，
print(hash('12sdfdfdffdf'))
#输出：2927147762795949558

#hash可以防伪验证
name = 'alex'
print('before:',hash(name))
name = 'sb'
print('after:',hash(name))
#输出：before: 4476987748893815718       after: 6390428375411445355

print(help(dir))#函数如何使用
#输出：
'''
Help on built-in function dir in module builtins:
dir(...)
    dir([object]) -> list of strings

    If called without an argument, return the names in the current scope.
    Else, return an alphabetized list of names comprising (some of) the attributes
    of the given object, and of attributes reachable from it.
    If the object supplies a method named __dir__, it will be used; otherwise
    the default dir() logic is used and returns:
      for a module object: the module's attributes.
      for a class object:  its attributes, and recursively the attributes
        of its bases.
      for any other object: its attributes, its class's attributes, and
        recursively the attributes of its class's base classes.

None
'''

print(bin(10))#10进制->2进制
#输出：0b1010
print(hex(12))#10进制->16进制
#输出：0xc
print(oct(12))#10进制->8进制
#输出：0o14

print(isinstance(1,int))
print(isinstance('abc',str))
print(isinstance([],list))
print(isinstance({},dict))
print(isinstance({1,2},set))
#以上输出均为 True

namehaha='哈哈哈哈哈哈哈哈哈哈哈哈哈哈啊哈粥少陈'
print(globals()) #系统全局变量
#输出:{'namehaha': '哈哈哈哈哈哈哈哈哈哈哈哈哈哈啊哈粥少陈', '__cached__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000675EB8>, 'express': '1+2*(3/3-1)-2', '__doc__': None, '__name__': '__main__', 'name': 'sb', '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, 'd1': {'name': 'alex'}, 'dic_str': "{'name': 'alex'}", 'dic': {'name': 'alex'}, '__file__': 'C:/Users/fudonghai/Desktop/temp/python_s3/day16/S5.py', '__package__': None}
print(__file__)
#输出:C:/Users/fudonghai/Desktop/temp/python_s3/day16/S5.py

def test():
    name = '哈哈哈测试'
    #print(globals()) #系统全局变量
    print(locals()) #当前级别局部变量
test()
#输出:{'name': '哈哈哈测试'}

2，第二部分

#zip函数
print(zip(('a','b','c'),(1,2,3)))
#输出：<zip object at 0x0000000002453888>
print(list(zip(('a','b','c'),(1,2,3))))
#输出：[('a', 1), ('b', 2), ('c', 3)]
print(list(zip(('a','b','c'),(1,2,3,4))))
#输出：[('a', 1), ('b', 2), ('c', 3)]
print(list(zip(('a','b','c','d'),(1,2,3))))
#输出：[('a', 1), ('b', 2), ('c', 3)]

p={'name':'alex','age':18,'gender':'none'}
print(list(zip(p.keys(),p.values())))
#输出:[('name', 'alex'), ('age', 18), ('gender', 'none')]
print(list(p.keys()))
#输出:['name', 'age', 'gender']
print(list(p.values()))
#输出:['alex', 18, 'none']

print(list(zip(['a','b'],'')))
#输出:[('a', '1'), ('b', '2')]

#max,min函数，求最大最小

#如果是一个简单的数据类型,直接就能求出大小
l=[1,3,100,-1,2]
print(max(l))
#输出:100
print(min(l))
#输出:-1

#如果是一个复杂的数据类型,比如字典可以使用.values()，但是不能知道是哪个key对应
age_dic={'age1':18,'age4':20,'age3':100,'age2':30}
print(max(age_dic.values()))
#输出:100
print(max(age_dic))
#输出:age4  因为使用字典名就是比较key的值，而key的值是以ascii码来比较的，比较的顺序是一个字符一个字符的来

age_dic={'alex_age':18,'wupei_age':20,'zsc_age':100,'lhf_age':30}
for item in zip(age_dic.values(),age_dic.keys()):
    print(item)
#输出：
# (100, 'zsc_age')
# (18, 'alex_age')
# (30, 'lhf_age')
# (20, 'wupei_age')

#结合zip函数使用,把value放在前面,可以得到对应的key
print(max(zip(age_dic.values(),age_dic.keys())))
#输出：(100, 'zsc_age')

#max比较的数据类型,一定是一个可迭代数据类型,可以使用for循环,依次取出每一个元素进行比较
#比较的顺序是从第一个元素开始比较
l=[
    (5,'e'),
    (1,'b'),
    (3,'a'),
    (4,'d'),
]
# l1=['a10','b12','c10',100] #不同类型之间不能进行比较
l1=['a10','a2','a10'] #不同类型之间不能进行比较
print(max(l))
#输出:(5, 'e')
print('--->',max(l1))
#输出:--->  a2

people=[
    {'name':'alex','age':1000},
    {'name':'wupei','age':10000},
    {'name':'yuanhao','age':9000},
    {'name':'linhaifeng','age':18},
]
# max(people,key=lambda dic:dic['age'])
print('周绍陈取出来没有',max(people,key=lambda dic:dic['age']))
#输出:周绍陈取出来没有 {'age': 10000, 'name': 'wupei'}
ret=[]
for item in people:
    ret.append(item['age'])
print(ret)
#输出:[1000, 10000, 9000, 18]
max(ret)

#chr与ord是相反操作
print(chr(97))
#输出:a
print(ord('a'))
#输出:97

#乘方
print(pow(3,3))#3**3
#输出：27
print(pow(3,3,3))#3**3%3
#输出：0

#反转
l=[1,2,3,4]
print(list(reversed(l)))
#输出:[4, 3, 2, 1]

#四舍五入
print(round(3.5))
#输出：4

#使用slice切片,也就是把[]变成单词slice
l = 'heltlo'
print(l[3:5]) #硬编码，可读性差
#输出:tl
s1 = slice(3,5)
print(l[s1])
#输出:tl
s2 = slice(1,5,2)#第1个开始e，步长2，跳到t，t是第3个，但是到第四个就结束了，所以后面就没有了
print(l[s2])
#输出:et

#sorted排序
l = [3,2,1,5,7]
print(sorted(l))
#输出：[1, 2, 3, 5, 7]
# l1 = [3,2,1,'a',5,7] #报错，不同类型不能比较大小
# print(sorted(l1))

people=[
    {'name':'alex','age':1000},
    {'name':'wupei','age':10000},
    {'name':'yuanhao','age':9000},
    {'name':'linhaifeng','age':18},
]
print(sorted(people,key=lambda dic:dic['age']))
#输出:[{'name': 'linhaifeng', 'age': 18}, {'name': 'alex', 'age': 1000}, {'name': 'yuanhao', 'age': 9000}, {'name': 'wupei', 'age': 10000}]

name_dic={
    'abyuanhao': 11900,
    'alex':1200,
    'wupei':300,
}
print(sorted(name_dic))
#输出:['abyuanhao', 'alex', 'wupei']
print(sorted(name_dic.values())) #不能得到key
#输出:[300, 1200, 11900]
print(sorted(name_dic,key=lambda key:name_dic[key]))
#输出:['wupei', 'alex', 'abyuanhao']

print(sorted(zip(name_dic.values(),name_dic.keys())))
#输出:[(300, 'wupei'), (1200, 'alex'), (11900, 'abyuanhao')]

#str转换成字符串
print(str(''))
#输出:1
print(type(str({'a':1})))
#输出:<class 'str'>
dic_str=str({'a':1})
print(eval(dic_str))
#输出:{'a': 1}
print(type(eval(dic_str)))
#输出:<class 'dict'>

#sum求和
l = [1,2,3,4]
print(sum(l))
#输出:10
print(sum(range(5)))
#输出:10

#type取类型
msg = ''
if type(msg) is str:
    msg = int(msg)
    res = msg + 1
    print(res)
#输出:124

#vars 如果没有参数,显示局部变量,相当于locals
def test():
    msg = '是对方是否'
    print(locals())
    print(vars())
test()
#输出:{'msg': '是对方是否'}
#输出:{'msg': '是对方是否'}

#如果有一个参数,查看对象所有的方法,并返回字典格式
print(vars(int))
#输出:{'bit_length': <method 'bit_length' of 'int' objects>, '__mul__': <slot wrapper '__mul__' of 'int' objects>,...}

#import------>sys----->__import__()
import test
test.say_hi()
#输出:你好啊林师傅

#import 'test'#导入字符串类型报错
__import__('test')
test.say_hi()
#输出:你好啊林师傅