1-2 集合与函数

五大基本数据类型：字符串、数字、列表、元组、字典

可变不可变：id（）指向内存地址

1:可变：列表、字典

2:不可变：字符串、数字、元组

访问顺序：

1.直接访问：数字

2.顺序访问：字符串、列表、元组

3.映射：字典（比列表爬行速度快）

存放元素个数：

容器类型：列表、元组、字典

原子（只能存放一个值）：数字、字符串

集合

定义：不同元素组成（不可变数据类型），集合中是一组无序排列可hash的值，可以作为字典的key。（无论如何定义，集合无序）

s={1,2,3,3}
type(s)
#type之后的s，是去重结果
>>>s
{1,2,3}
s=set('hello')
>>>s
{'o','h','l','e'}
s={1,2,3,4,5,6}
s.add('3')    #加入
>>>s
{1,2,3,4,5,6,'3'}
s.clear()   #清空
s.pop()    #随机删除集合中的元素
s.remove('')   #指定删除 删除元素不存在会报错
s.discard('')   #指定删除 删除元素不会报错

集合运算

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

python_and_linux_l=[]
for p_name in python_1:
     if p_name in linux_1:
         python_and_linux_1.qppend(p_name)

print(python_ang_linux_1]

pyhton_l=['lcg','szw','zjw','lcg']
linux_1=['lcg','szw','sb']

#简单去重操作set即可但原集合顺序改变
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)

#求并集
print(p_s.union(l_s))
print(p_s|l_s)

#差集
print('差集'，p_s-l_s)
print(p_s.difference(l_s))

#交叉补集 去除交集再并
print(p_s.symmetric_difference(l_s))
print(p_s^l_s)

#difference_update()
#issubset()  判断一个集合是另一个集合的子集
#issuperset() 判断一个集合是另一个集合的父集
#update() 对一个集合更新多个元素，括号中为一个集合 add只能更新一个值

集合内置  集合可变

定义不可变集合

s=frozenset('hello')

 字符串拼接和格式化

%s   % 代表在%s处放置一个字符串数据，后%表示把后面的传给他

msg='i am %s my hobby is alex' %'lhf'
print(msg)
>>>i am lhf my hobby is alex

传接多个值 %s

msg='i am %s my hobby is  %s' % ('lhf','alex')
msg='i am %s my hobby is  %s' % ('lhf',1)
msg='i am %s my hobby is  %s' % ('lhf',[1,2])

#%d只能传数字类型数据
msg='i am %s my hobby is  %d' % ('lhf',1)

打印浮点型数字

#默认保留六位小数  .2f表示保留小数点后两位小数
tpl="percent %f" % 9976234
tpl="percent %.2f" % 99.97623

打印百分比

#截取字符串  截取4位数（从右往左）
tpl="percent %.4s" % 'abcdef'
print(tpl)

#打印百分号  %%
tpl='percent %.2f %%' % 99.97623444

#简单使用传入   (name),(age)字典key
tpl="i am %(name)s age %(age)d" % {"name":"alex","age":18}

#\033[43;1m      \033[0m 表示加入颜色   +60右对齐60公分处（flags）
msg='i am \033[43;1m%(name)+60s\033[0m my hobby is alex' %{'name':'alex'}

#sep加上分隔符
print('root','x','0','0',sep=':')

fornat字符串格式化    处理为列表或元组

#一一对应关系  不一一对应则报错
tpl='i am {},age {}, {}".format("seven",18,'alex')
print(tpl)

#按元组方式填充{2,1,0}
tpl='i am {2},age {1}, {0}".format("seven",18,'alex')
print(tpl)
tpl='i am {1},age {1}".format("seven",18,'alex')
>>> i am 18,age 18

#字典形式..或format{**{"name":"seven","age":18}
tpl='i am {name}, age {age}, 
 really{name}".format(name="seven",age=18)

#b二进制，o八进制，d整形，x16进制 X大写，%显示百分比默认六位
tpl="numbers: {:b},{,o},{:d},{,x},{:X}, {:%}，{}".format(15,15,15,15,15.87623,2)

函数

python 中函数定义：函数是逻辑结构化和过程化的一种编程方法。

#python中函数定义方法

def test(x):
     "The function definition"
      x+=1
      return x 


def：定义函数的关键字
test：函数名
（）：内可定义形参
”“：文档描述（非必要，但是强烈建议为你的函数添加描述信息）
x+=1：泛指代码块或程序处理逻辑
return：定义返回值

调用运行：可以带参数也可以不带
函数名（）

def test(x):
     y=2*x+1
     return(y)
print(test)  #打印出的是test函数信息
a=test(3)
print(a)
>>a=7

def test():
     x=3
     y=2*x+1
     return(y)
print(test)  #打印出的是test函数信息
a=test(3)  #接着返回结果

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

函数参数

1.形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束后返回主调用函数后则不能再使用该形参变量

2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参.因此应预先用赋值，输入等方法使参数获得确定值。

 

#x,y 形参  a,b实参（赋值代入）
def calc(x,y):
     res = x**y
     return(res)

c=calc(a,b)
print(c)

 

3.位置参数与关键字（标准调用：实参和形参位置一一对应；关键字调用：位置无需一一对应  但二者不可缺）

def test(x,y,z)
     print(x)
     print(y)
     print(z)

#位置参数
test(1,2,3)
#关键字调用
test(y=2,x=1,z=3)
 #位置参数和关键字可混用，位置参数必须在关键字左边

4.默认参数

#type=None 默认参数  也可赋值
def handle(x,type=None);
      print(x)
      print(type)

5.参数组

#参数组：**字典  *列表
def test(x,*args):
     print(x)
     print(args)
     print(args[0])
test(1,2,3,4,5,6)
#列表[2,3,4,5,6]单作为一个元素传给args
test(1,[2,3,4,5,6])
#加*号依次赋值给args
test(1,*[2,3,4,5,6])
#传字典
test(1,{'name':'alex'})

#error y=2,z=3 相当于k对应变量 一个*难以满足
test(1,y=2,z=3)
#处理关键字参数
def test(x,**kwargs):
      print(x)
      print(kwargs)

test(1,y=2,z=3)
>>1 
     {'y':2,'z':3}

test(1,y=2,z=3,z=3) #会报错 一个参数不能传入两个值