day14

#复习课
id(变量v)#获取变量的内存地址
    #可变不可变
    1、可变。:重新赋值后id号没变。列表，字典，集合（set）
    2、不可变。:重新赋值后id号变了。字符串，数字，元组,集合(frozenset('faker',1,2))
    #访问顺序
    1、顺序访问：字符串，列表，元组
    2、映射访问：字典（占的内存大，但是找起来很快，基于hash）
    3、直接访问：数字
    #存储元素个数：
    1、容器类型：一个数据类型能存放多个值。 列表，元组，字典
    2、原子类型：数字，字符串

#####集合`set`
集合是一组无序排列的可以进行hash的值，可以作为字典的Key
特性：不同元素组成，无序，集合中的元素必须是不可变类型(hashable)
s = set('hello')#将字符串强转为集合
#result: {'h','e','l','o'}
s = set(['bjfu','bjfu','vth'])
#result:{'bjfu','vth'}
###set一个东西，相当于对它进行了for循环，把里面的东西一个一个取出来
s.add(待加入元素)#加入元素
s.pop()#任意删除一个元素
s.remove(待删除元素)#精准删除  不存在待删除元素时会报错
s.descard(待删除元素)#精确删除 不存在待删除元素时不会报错
#如果只想做简单的去重操作，就用set()
s.intersection(set)#求交集
#也可以直接写  new_s = s1&s2 #
s.union(set)#求并集
s|set#求并集
s - set#s有，set中没有
set - s#set有，s中没有
s.difference(set)#s有，set中没有
#交叉补集 s独有的与set独有的 的并集
s = s1.symmetric_difference(s2)
s = s1^s2
s.differene_update(set)#s-set的值赋值回给s
s.intersection_update(set)#s 与 set求交集 赋值回给s
s1.isdisjoint(s2)#如果s1,s2没有交集，返回true.有交集返回False.
s1.issubset(s2)#s1是s2的子集的话，返回True.
s1.issuperset(s2)#s1是s2的父集的话，返回False.
s1.update(set/tuple/str/list等可迭代)#将s1,s2的并集更新到s1

s = frozenset('faker')#不可变集合
list(s)#将集合转变为list 但是顺序不可控
names = list(set(names))#顺序不可控


##字符串格式化
s = '%s is a sb' %'faker'
s = '%s is a %s' %('faker','sb')
result: faker is a sb
s = '%s is a %s' %('faker',[1,2])
result: faker is a [1,2]
s = '%s is a %s' %('faker',1)
result: faker is a 1
s = 'faker is a ' + 'sb'#加号效率很低很低
result: faker is a sb
s = '%s is a %d' %('faker',3)
result: faker is a 3
s = '%s is a %f' %('faker',3.3)
result: faker is a 3.300000#默认保留6位小数
s = '%s is a %.2f' %('faker',3.333333333)
result: faker is a 3.33
s = '%s is a %9.2f' %('faker',3.333333333)
#输出浮点数的总占位为9位
s = 'percentage is %9.2f%%' %('faker',3.333333333)
result:percentage is      3.33%
s = '%.2s is a %s' %('faker','sb')
#字符串中的.x代表从左到右保留多少位字符串
tpl = "my name is %(name)s, my age is %(age)d" %{'name':"faker",'age':18}
print(tpl)
语法：%(key1)s %(key2)d  %{'key1':  ,'key2': }#注意，'key1'和'key2'特地写成了字符串
############字符串格式化的两种办法：
    1、%   2、format()
    ###1  %
        %[(name)][flags][width].[precision]typecode
        flags == '-' #左对齐
                 ''
    print('','','',das,sep(分隔子串),end=结束子串)

    ###2 format()
    s = '{} is a {}'.format('faker','sb')
    result: faker is a sb
    s = '{0} is a {1}'.format('faker','sb')
    result: faker is a sb
    s = '{1} is a {0}'.format('faker','sb')
    result: sb is a faker
    s = '{1} is a {1}'.format('faker','sb')
    result: sb is a sb
    s = '{} is a {}'.format(*['faker','sb'])#列表的格式
    result: faker is a sb
    #也就是说，format后面的东西相当于一个元组，前面{}用索引来取对应元素值
    s = '{name} is a {age}'.format(name = 'faker',age = 18)#另外一种字典的格式，根据key value取的。
    result: faker is a 18
    s = '{name} is a {age}'.format(**{'name' : 'faker','age' : 18})#字典的另一种格式。注意key应该写成串。
    result: faker is a 18
    s = '{0[1]} is a {1[1]}'.format([1,2,3],[4,5,6])
    result: 2 is a 5
    #format()中相当于一个元组，外层0相当于元组的第一个元素，也就是列表1，然后你懂的。
    s = '{:s} {:d} {:f}'.format('faker',11,111.1)#按照格式化输出
    result: faker 11 111.100000
    s = '{:s} {:d} '.format(*['faker',11])#列表的方式
    result: faker 11 
    s = '{name} {age} '.format(**{'name':'faker','age':11})#注意键的写法。写成了个串。
    result: faker 11 
    s = '{name} {age} '.format(name='faker',age=18)#注意这种方式键值的写法
    result: faker 18 
    s = '{name:s} {age:d} '.format(name='faker',age=18)#规定了键值的类型
    result: faker 18 
    s = '{:b} {:o} {:d} {:x} {:X} {:%} '#显示为2，8,10，小写16，大写16进制，改变为百分比。
    s = '{0:b} {0:o} '.format(15)#注意，这样指定索引
    result: 1111 17 
    s = '{num:b} {num:o} '.format(num = 15)#注意这样指定key
    result: 1111 17 


python中的函数
def test(x):
    #函数功能  ''
    #函数体
    return x
Demo
def test():
    'faker is a sb'
    print('faker is a sb')
test()
result: faker is a sb

print(test)#返回test函数的内存地址
python中的函数也是可以重载的。

函数与过程： 过程就是没有返回值的函数
没有写return 的话，python自动返回一个返回值None
可以用return 1,2,3,'a',[1,2,3],{}
return返回多个值，多个返回值其实是构成了一个元组。
##
没有返回值时，返回None
有一个返回值时，返回一个object(对象)
有多个返回值时，返回一个tuple

###参数
def test(a,b,c):#
    print(a,b,c)#这个叫位置参数
test(a=1,c=3,b=2)#python可以以这种方式精确的指定参数
精切定义的参数如果与传统参数混搭的话，精确定义的参数一定要在最右边（跟c++一个操行）
def handle(name,type = 'sb'):#默认形参，跟C++一个操行
    print(name+' is a '+type)
handle('faker')
handle('faker','zz')#这个和下面那个是等价的
handle('faker',type='nc')#这个和上面那个是等价的
def handle(name,type = 'sb'):
    pass#什么也不做的函数应该这么写。

#参数组： **字典   *列表
def inx(a,*args):#可变长的参数组
    print(a,args)
    print(type(args))
inx(1,2,3,4,5,6,7,78,8,9)#1给a，其余的构成一个元组。
inx(1,*(2,3,4,5,6,7,78,8,9))#这样也可以
inx(1,*{2,3,4,5,6,7,78,8,9})#这样也可以
inx(1,*[2,3,4,5,6,7,78,8,9])#这样也可以
inx(1,*{'name':'sss'})#这样不可以，只能把key传进去
result:
1 (2, 3, 4, 5, 6, 7, 78, 8, 9)

inx(1,(2,3,4,5,6,7,78,8,9))#这样是把元组当成元组中的一个元素来处理
inx(1,{2,3,4,5,6,7,78,8,9})#这样是把集合当成元组中的一个元素来处理
inx(1,[2,3,4,5,6,7,78,8,9])#这样是把列表当成元组中的一个元素来处理
inx(1,{'name':'sss'})#这样是把字典当做元组中的一个元素来处理
result:
1 ((2, 3, 4, 5, 6, 7, 78, 8, 9),)
<class 'tuple'>
1 ({2, 3, 4, 5, 6, 7, 8, 9, 78},)
<class 'tuple'>
1 ([2, 3, 4, 5, 6, 7, 78, 8, 9],)
<class 'tuple'>
1 ({'name': 'sss'},)
<class 'tuple'>


<class 'tuple'>
def inx(a,*args):
    print(a,args)
    print(type(args))
    print(args[0])
    print(args[0][0])
inx(1,['x','y','z'])

result:
1 (['x', 'y', 'z'],)
<class 'tuple'>
['x', 'y', 'z']
x
#####深入分析，这是传进去两个参数。任何一个可变长参数传进去都会被当做元组中的一个元素来处理，args[0]其实是进入到了元组里面，获取到了元组的第一个元素，急list ['x','y','z'] 然后再通过args[0][0]取到'x'

#*args是一个位置参数。解决不了关键字参数的问题。

#**kwargs
def inx(**kwargs):#把传进来的玩意儿认为是个字典。
    print(kwargs)
inx(x=1,y=2,k=3)#这样给键值对，也算是没毛病，之前接触过

result:
{'y': 2, 'x': 1, 'k': 3}

def test(x,*args,**kwargs)#固定格式。次序不可变