python 基础篇第四节课

---恢复内容开始---

　　总结：可变可不变：1可变：列表，字典

　　　　　　　　　　　 2 不可变：字符串，数字，元组

　　　　　访问顺序：　 1直接访问：数字

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

　　　　　　　　　　　 3映射：字典

　　存放元素个数：容器类型：列表，元组，字典

　　　　　　　　　原子：数字，字符串

集合

　　特征：1 不同元素组成

　　　　　2无序

　　　　　3集合中元素必须是不可变类型

　　添加

　　添加字符串

s = {1,2,3,4,5,6}
s.add("c")
print(s)

#输出{1, 2, 3, 4, 5, 6, 'c'}

　　添加数字 .dd()

s = {1,2,3,4,5,6}
s.add(8)
print(s)

#输出{1, 2, 3, 4, 5, 6, 8}

　　添加重复的数字可以运行但不显示

　　清空 .clear()

s = {1,2,3,4,5,6}
s.clear()
print()

　　拷贝 .copy()

s = {1,2,3,4,5,6}
s1 = s.copy()
print(s1)

#输出{1, 2, 3, 4, 5, 6}

　　随机删 .pop()

s = {1,2,3,4,5,6}
s.pop()
print(s)

#输出{2, 3, 4, 5, 6}

　　指定内容删 .remove() 删除内容不存在会报错

s = {1,2,3,4,5,6}
s.remove(4)
print(s)

#删除{1, 2, 3, 5, 6}

　　指定内容删除 . discard() 删除元素不存在不会报错

s = {1,2,3,4,5,6}
s.discard(9)
print(s)

#输出{1, 2, 3, 4, 5, 6}

　　set  列表变为集合

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s,l_s)

#输出{'JZH', 'KLY', 'LPP'} {'KLY', 'JZH'}

　　.intersection & 求交集

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s.intersection(l_s))

#输出{'JZH', 'KLY'}

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s & l_s)

#输出{'KLY', 'JZH'}

　　求并集

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s.union(l_s))

#输出{'KLY', 'JZH', 'LPP'}

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s|l_s)

#输出{'JZH', 'LPP', 'KLY'}

　　　.difference() - 求差集

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s.difference(l_s))

#输出{'LPP'}

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s - l_s)

#输出{'LPP'}

　　　.symmetric_difference() 交叉补集

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s.symmetric_difference(l_s))

#输出{'LPP'}

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s ^ l_s)

#输出{'LPP'}

　　　　.difference_update() 差集并更新

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
p_s.difference_update(l_s)
print(p_s)

#输出{'LPP'}

　　　　.isdisjoint() 判断有无共有的元素：有 False 无 True

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s.isdisjoint(l_s))

#输出False

　　　.issuperset() >= 父集

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s.issuperset(l_s))

#输出 True

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s >= l_s)

#输出True

　　　　.issubset() <= 子集

p_s = set(python_1)
l_s = set(linux_1)
print(p_s.issubset(l_s))

#输出False

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
print(p_s <= l_s)

#输出False

　　　　更新数据 .update()

python_1 = ["KLY","LPP","JZH"]
linux_1 = ["KLY","JZH"]
p_s = set(python_1)
l_s = set(linux_1)
l_s.update(python_1)
print(l_s)

#输出{'KLY', 'LPP', 'JZH'}

s = frozenset("JZH")
print(s)

#输出frozenset({'Z', 'H', 'J'})

　　字符串格式化

　　%s可以是任何值

v = "i am %s my hobby is playing" % "JZH"
print(v)

#输出i am JZH my hobby is playing

　　%d 只能是数字

v = "i am %d my hobby is playing" % 5
print(v)

#输出i am 5 my hobby is playing

　　打印浮点数

v = "percent %.3f" % 99.784531
print(v)

#输出percent 99.785

　　打印百分比

v = "percent %.3f %%" % 99.784531
print(v)

#输出percent 99.785 %

　　打印字典

v = "i am %(name)s age%(age)d" %{"name":"JZH","age":18}
print(v)

#输出i am JZH age18

　　百分号方式 %[(name)][(flags)][(width)][precision]typecode %[(key)][(可供选择的值 +左对齐 -右对齐)][占有数][小数点后保留的位数]

v = "i am %(name)+10s my hobby is playing" %{"name":"JZH"}
print(v)

#输出i am        JZH my hobby is playing

v = "i am %(name)-10s my hobby is playing" %{"name":"JZH"}
print(v)

#输出i am JZH        my hobby is playing

　　打印字符用：隔开

print("root","s","0","5",sep=":")

#输出root:s:0:5

format 字符串常用格式化

tp1 = "i am {}，age {},{}".format("JZH","18","handsome")
print(tp1)

#输出i am JZH，age 18,handsome  （不一一对应会报错）

tp1 = "i am {2}，age {1},{0}".format("JZH","18","handsome")
print(tp1)

#输出i am handsome，age 18,JZH

　　传字典

tp1 = "i am {name}，age {age},{name}".format(name = "JZH",age = 18)
print(tp1)

#输出i am JZH，age 18,JZH

tp1 = "i am {name}，age {age},{name}".format(**{"name":"JZH","age":18})
print(tp1)

#输出i am JZH，age 18,JZH

　　传元组

tp1 = "i am {0[0]}，age {0[1]},{0[2]}".format(["JZH",18,"handsome"],[11,22,33])
print(tp1)

#输出i am JZH，age 18,handsome

tp1 = "i am {:s}, age{:d},{:s}".format(*["JZH",18,"handsome"])
print(tp1)

#输出i am JZH, age18,handsome

tp1 = "i am {name:s}, age{age:d},{a:s}".format(name = "JZH",age = 18,a = "handsome")
print(tp1)

#输出i am JZH, age18,handsome

tp1 = "i am {name:s},age{age:d},{a:s}".format(**{"name":"JZH","age":18,"a":"handsome"})
print(tp1)

#输出i am JZH,age18,handsome

tp1 = "numbers:{:b},{:o},{:d},{:x},{:X},{:%}".format(15,15,15,15,15,15.846545)
print(tp1)

#输出numbers:1111,17,15,f,F,1584.654500%
# b 二进制 o八进制 d十六进制 x小写 X大写 %显示百分号

python中的函数

　　　　def:定义函数关键字

　　　　test:函数名

　　　　（）：可定义参数，整形数字

　　　　 “”：文档描述

　　　　 x += 1:泛指代码块或程序处理逻辑

　　使用函数的好处：1减少代码重用

　　　　　　　　　　2保持一致性，易维护性

　　　　　　　　　　3可扩展性

　　　　 return:定义返回值

def test(x):
    '''
    y=2*x+1
    :param x:整形数字
    :return y:返回值
    :param x:
    :return:
    '''

    y=2*x+1
    return y
a=test(3)
print(a)

#输出 7

def test():
    '''
    y=2*x+1
    :param x:整形数字
    :return y:返回值
    :param x:
    :return:
    '''
    x=3
    y=2*x+1
    return y
a=test()
print(a)

#输出 7

　　函数和过程

　　过程：没有返回值的函数时，输出none

　　　　　返回值=1时，返回对象

　　　　　返回值>1时，返回元组

def test():
    msg = "test"
    v = msg
    return
a = test()
print(a)

#输出None

def test():
    msg = "test"
    v = msg
    return 1
a = test()
print(a)

#输出1

def test():
    msg = "test"
    v = msg
    return 1,312,844,"name"
a = test()
print(a)

#输出(1, 312, 844, 'name',)

　　函数参数：形参和实参的区别是，是否会在内存中占有一定的空间，有则实参，无则形参

def calc(x,y):  #形参
    res = x**y
    return res
a = calc(3,4)   #实参
print(a)

　位置参数和关键字参数

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

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

#输出 
1
2
3

　　关键字参数：位置无需一一对应，缺一不行，多一也不行

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

#输出
9
3
2

　　混合使用：位置参数必须在关键词参数的左边

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

#输出
3
2
9

　　默认参数

def handle(x,type="mysql"):
    print(x)
    print(type)
handle("hello",456)

#输出
hello
456

　　参数组，**字典，*列表

def test(x,*args):
    print(x)
    print(args)
test(1,2,3,4,56,789)

#输出
1
(2, 3, 4, 56, 789)

def test(x,*args):
    print(x)
    print(args[4])
test(1,2,3,4,56,789)

#输出
1
789

def test(x,*args):
    print(x)
    print(args)
test(1,["name","alex"])

#输出
1
(['name', 'alex'],)

def test(x,*args):
    print(x)
    print(args)
test(1,*["name","alex"])

#输出
1
('name', 'alex')

def test(x,*args):
    print(x)
    print(args)
test(1,{"name":"alex"})

#输出
1
({'name': 'alex'},)

def test(x,**kwargs):
    print(x)
    print(kwargs)
test(1,z=789,y="haha")

#输出
1
{'z': 789, 'y': 'haha'}

　　综合

def test(x,*args,**kwargs):    #def test(单个，列表，字典)
    print(x)
    print(args)
    print(kwargs)
test("name",145,["a","b",3],{"JZH":"henqiang"},*[55,"uio",99],k=["kly",651],z=789,y="haha",q={"hs":42},f=(7,9,1,))


#输出
name
(145, ['a', 'b', 3], {'JZH': 'henqiang'}, 55, 'uio', 99)
{'f': (7, 9, 1), 'z': 789, 'y': 'haha', 'q': {'hs': 42}, 'k': ['kly', 651]}

def test(x,*args,**kwargs):
    print(x)
    print(args,args[-1])
    print(kwargs,kwargs.get("k"))
test(1,*[1,2,3],**{"k":456})

#输出
1
(1, 2, 3) 3
{'k': 456} 456

posted @ 2018-08-28 17:33 Lune23333 阅读(133) 评论(0) 收藏举报

刷新页面返回顶部

Lune23333

python 基础篇 第四节课

集合

字符串格式化

format 字符串 常用格式化

python中的函数

公告

python 基础篇第四节课

　　字符串格式化

format 字符串常用格式化