python打卡学习5.2

集合

定义

是不含有value而只含有key且key不能重复的set

num ={}
print(type(num))
num={1,2,3,4}
print(type(num))
# <class 'dict'>
# <class 'set'>

创建

1.先创建对象再加入元素，用add添加元素（还可以用update更新元素，重复的不再添加）

2.创建只能用s = set() ,而 s={}只能是字典

fruit =set()
# add()添加元素，如果有了就不再添加
fruit.add('apple')
fruit.add('banana')

print(fruit)
# {'banana', 'apple'}
fruit_p ={'orange','pear','banana'}
fruit.update(fruit_p)
print(fruit.update)
# {'banana', 'pear', 'orange', 'apple'}

3.用set可将列表或元组转换成集合

a =set('abadcdge')
print(a)
b =set(('Baidu','Google','Bing','Baidu'))
print(b)
c =set(['goodjob','badjob','welldone','welldone'])
print(c)
# {'d', 'g', 'c', 'e', 'a', 'b'}
# {'Google', 'Baidu', 'Bing'}
# {'goodjob', 'badjob', 'welldone'}

4.set可以去除列表中的重复值，但是无序

# 这里用list和set两种方法比较
t =[2,1,3,4,1,2,4,5,7,3]
# 用列表去重
new =[]
for i in t:
    if i not in new:
        new.append(i)
print(new)

t1 =list(set(t))
print(t1)
# [2, 1, 3, 4, 5, 7]
# [1, 2, 3, 4, 5, 7]

5.访问集合的元素

thisset ={'baidu','google','bing'}
# len()获取元素的个数
print(len(thisset))
# for 可以把元素取出来
for _ in thisset:
    print(_ ,end=' ')
s ='baidu'
s1 ='sougou'
print(s in thisset)
print(s1 in thisset)	
# 3
# baidu bing google 
# True
# False

6.移除元素 --remove 和 discard 还有pop

fruit ={'banana', 'pear', 'orange', 'apple'}
fruit.remove('banana')
print(fruit)
# {'apple', 'orange', 'pear'}
fruit.discard('grape')
# 不会报错
fruit.pop()
print(fruit)
# {'orange', 'apple'}

7.数学上的集合操作

set. intersection(set1, set2 ...) 返回两个集合的交集。
set1 & set2 返回两个集合的交集。
set. intersection_ update(set1, set2 ... ) 交集，在原始的集合.上移除不重叠的元素。

用 set 可以把字符串变成一个个字符

set. union(set1, set2...) 返回两个集合的并集。
set1| set2 返回两个集合的并集。

set. difference(set)返回集合的差集。
set1 - set2 返回集合的差集。
set. difference_ update(set) 集合的差集，直接在原来的集合中移除元素,没有返回值。

set.symmetric_ difference(set) 返回集合的异或。
set1^set2 返回集合的异或。
set.symmetric_difference_update(set) 移除当前集合中在另外-一个指定集合相同的元素，并将另外-一个指定集合中不同的元素插入到当前集合中。

set. issubset(set)判断集合是不是被其他集合包含，如果是则返回True,否则返回False.
set1 <= set2
判断集合是不是被其他集合包含，如果是则返回True,否则返回False。

set. issuperset(set)用于判断集合是不是包含其他集合，如果是则返回True,否则返回False。
set1>=set2 判断集合是不是包含其他集合,如果是则返回True, 否则返回False。

set. isdisjoint(set)用于判断两个集合是不是不相交，如果是返回True,否则返回False。

序列

• 一般对字符串，列表和元组，集合与字典支持一些操作，但是对字典和集合不支持切片，索引和**+和***的操作

内置函数

tuple(sub)

a = tuple()
print(a)  # ()

b = 'I Love LsgoGroup'
b = tuple(b)
print(b)  
# ('I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p')

c = [1, 1, 2, 3, 5, 8]
c = tuple(c)
print(c)  # (1, 1, 2, 3, 5, 8)

list(sub)

a = list()
print(a)  # []

b = 'I Love LsgoGroup'
b = list(b)
print(b)  
# ['I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p']

c = (1, 1, 2, 3, 5, 8)
c = list(c)
print(c)  # [1, 1, 2, 3, 5, 8]

str(obj)

a = 123
a = str(a)
print(a)  # 123

len(s)–s 为object

a = list()
print(len(a))  # 0

b = ('I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p')
print(len(b))  # 16

c = 'I Love LsgoGroup'
print(len(c))  # 16

max(sub)

print(max(1, 2, 3, 4, 5))  # 5
print(max([-8, 99, 3, 7, 83]))  # 99
print(max('IloveLsgoGroup'))  # v

min(sub)

print(min(1, 2, 3, 4, 5))  # 1
print(min([-8, 99, 3, 7, 83]))  # -8
print(min('IloveLsgoGroup'))  # G

sum(iterable[,start =0])

# 用于放回序列和可选参数的总和
print(sum([1, 3, 5, 7, 9]))  # 25
print(sum([1, 3, 5, 7, 9], 10))  # 35
print(sum((1, 3, 5, 7, 9)))  # 25
print(sum((1, 3, 5, 7, 9), 20))  # 45

sorted(iterable,key =None , reverse =False)

• iterable表示可迭代的对象
  • key表示用来比较的函数，具体参数选择iterable上的元素
    • reverse 表示排序规则，False表示升序，True表示降序

t = ({"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"})
s =sorted(t, key=lambda a:a['age'] )
print(s)
s =sorted(t,key =lambda a:a['age'],reverse=True)
print(s)

"""[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]
[{'age': 25, 'name': 'b'}, {'age': 20, 'name': 'a'}, {'age': 10, 'name': 'c'}]
"""

reversed(seq)

• 用于反转的迭代器，seq表示转换的序列模型 对象可以是

  list tuple string range

s ='I love China'.split()
print(s)
x =reversed(s)
print(type(x))
print(x)
print(list(x))
t =('W','H',"A","T",'T','H','E','H','E','L','P')
print(list(reversed(t)))
a =range(1,10)
print(list(reversed(a)))
# ['I', 'love', 'China']
# <class 'list_reverseiterator'>
# <list_reverseiterator object at 0x7f33740a3ad0>
# ['China', 'love', 'I']
# ['P', 'L', 'E', 'H', 'E', 'H', 'T', 'T', 'A', 'H', 'W']
# [9, 8, 7, 6, 5, 4, 3, 2, 1]

enumerate(sequence , [start =0])

• 用于一个可遍历的对象如元组，字符串和列表，同时列出数据和下标

seasons =['Spring','Summer','Fall','Winter']
a =list(enumerate(seasons))
a
#[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
b =list(enumerate(seasons,1))
b
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

for i,element in b:
    print("{0}:{1}".format(i,element))
"""
1:Spring
2:Summer
3:Fall
4:Winter
"""

zip(iter1[,iter2[,iter3[…]]])

# 验证我的猜想
# zip
a =[1,2,3]
b=[5,6,7]
c =[3,4,6,7,8,9]
e =zip(a,b)
print(e)
print(list(e))
f =zip(b,c)
print(f)
print(list(f))
g =zip(*zip(a,b))
print(g)
print(list(g))
h,q =zip(*zip(b,c)) # *号为操作符，对变量自身的储存值进行操作
print(h,q)
print(list(h),list(q))
# <zip object at 0x7fd0120fdd20>
# [(1, 5), (2, 6), (3, 7)]
# <zip object at 0x7fd01202a640>
# [(5, 3), (6, 4), (7, 6)]
# <zip object at 0x7fd011d0d0f0>
# [(1, 2, 3), (5, 6, 7)]
# (5, 6, 7) (3, 4, 6)
# [5, 6, 7] [3, 4, 6]

函数

定义

Python万物介对象，函数也是Python的对象，函数还可以是作传入变量，作返回变量

因此，有一下特点

• def 开头，后面接函数名和括号（）
• 有冒号和缩进
• return[表达式] 为结束函数，返回一个值给调用方，函数中没有return表达式则放回None

def fuctionname(paraments):
    # 函数文档字符串
    fuction_suite
    return [expression]

调用

def function(str):
    print(str)
    return None
function("我要调用函数")
function("我要在调用一次函数")
string =function(hello)
string
# 我要调用函数
# 我要在调用一次函数
# NameError: name 'hello' is not defined

def myfirstfunction(Name):
    print("{0}是我的实际调用的名字".format(Name))
myfirstfunction("Justin Bieer")
print(myfirstfunction.__doc__)
print(help(myfirstfunction))
# Justin Bieer是我的实际调用的名字
# None
# Help on function myfirstfunction in module __main__:

函数参数

1.位置参数(positional argument)

def functionname(arg1):
    "函数_文档字符串"
    function_suite
    return [expression]
# arg1为位置参数，call function位置要固定

2.默认参数

def functionname(arg1,arg2=v):
    function_suite
    return [expression]
# v为arg2的默认参数，如果参数没有被传进，则v为默认值
# 传入时可以只填参数

3.可变参数

def functionname(arg1,arg2=v,*args):
    function_suite
    return [expression]
# *arg3 为可变参数，会存放所有未命名的变量参数

4.关键字参数

def functionname(arg1,arg2=v,*args,**kw):
    function_suite
    return [expression]
## 将剩余的参数表达式存放到字典中

5.命名关键字参数

def functionname(arg1,arg2=v,*arg,*,nkw,**kw):
    function_suite
    return [expression]
# *,nkw 为命名关键字参数，输入变量必须为赋值表达式，在栈中第n个位置中数据结构放到对应的内存地址中的变量赋值引用
def printinfo(arg1,*,nkw,**kargs):
    print(arg1)
    print(nkw)
    print(kargs)
printinfo(1,nkw=2,a=3,b=4)
printinfo(1,2,a=3,b=4)
Justin Bieer是我的实际调用的名字
None
Help on function myfirstfunction in module __main__:
"""
1
2
{'a': 3, 'b': 4}
TypeError: printinfo() takes 1 positional argument but 2 were given
"""

6.参数组合

参数顺序为：
位置参数>默认参数>命名关键字参数>可变参数>关键字参数
*arg为可变参数，接收的是tuple
**kw为关键字参数，接收的是dict

函数作用域

Python中有__局部变量__和__全局变量__

关键词为：global 和 nonlocal

内嵌函数

闭包

• 本质是一个内嵌函数

递归

1.阶乘

n=1
for k in range(1,6):
    n=n*k
print(n)  	# 120

def function(n):
    if n ==1:
        return 1
    return n*function(n-1)
print(function(5))
# 120

2.斐波那契数列

i =0
j =1
lists =[i,j]
for k in range(2,11):
    k =i+j
    lists.append(k)
    i = j
    j = k
print(lists)
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

def recur_fibo(n):
    if n<=1:
        return n
    return recur_fibo(n-1) + recur_fibo(n-2)
lst =list()
for k in range(11):
    lst.append(recur_fibo(k))
print(lst)
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

lambda 匿名函数

定义

lambda argument_list: expression

• lambda 为匿名函数的关键字
• argument_lsit 为5大参数类型，具体类型和上面一样
• ：
• expression 一个表达式，对输入值进行变换

形式

def sqrt(x):
    return x**2
lis =[sqrt(x) for x in range(11)]
print(lis)
fc_lis =lambda x:x**2
print(fc_lis)
l_lis = [fc_lis(x) for x in range(11) ]
print(l_lis)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# <function <lambda> at 0x7f6f0d5bbb00>
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

summary = lambda arg1,arg2:(arg1+arg2)
print(summary(10,20))
# 30

summary = lambda arg1,arg2:(arg1+arg2)
print(summary(10,20))
summary2 =lambda *arg:sum(arg)
print(summary2(1,2,3,4,5,65,76,7))

# 163

练习题

集合练习

怎么表示只包含⼀个数字1的元组。
>>> a =1,
>>> a
(1,)

创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。
>>> empty_set =set()
>>> empty_set.add('x')
>>> empty_set.add('y')
>>> empty_set.add('z')
>>> empty_set
{'x', 'y', 'z'}

列表['A', 'B', 'A', 'B']去重。
>>> lists =['A','B','A','B']
>>> lists = list(set(lists))
>>> lists
['A', 'B']
求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素（差集指的是两个集合交集外的部分）。
sets1 ={6,7,8}
sets2 ={7,8,9}
sets3 =sets1 & sets2
set4 =set()
for i in sets1-sets3:
    set4.add(i) 
for j in sets2-sets3:
    set4.add(j)
print(set4)
# {9, 6}

求{'A', 'B', 'C'}中元素在 {'B', 'C', 'D'}中出现的次数。
set1 ={'A',"B",'C'}
set2 ={'B',"C",'D'}
i =0
for m in set1:
    if m in set2:
        i+=1
print("{'A', 'B', 'C'}中元素在 {'B', 'C', 'D'}中出现的次数为",i)
# {'A', 'B', 'C'}中元素在 {'B', 'C', 'D'}中出现的次数为 2

序列练习

1.如何找出序列中的最大最小值

max()和min()

2.sort()和sorted()的区别

l=[1,9,7,2,3]
l1= l.sort()
print(l1)
l2 =sorted(l)
print(l2)
# None
# [1, 2, 3, 7, 9]
sorted(iterable,key =None , reverse =False)是将某个元素按照某个规则进行排序
表达：sort()会在原序列上排序，而不会把原列表复制一遍，这个函数的方法返回为None，就是提醒使用者sort是在原来的基础上变动而不是产生了新的对象

3.怎么快速求1到100所有整数相加之和

sum(range(0,101))

4.求列表[2,3,4,5]中每个元素的立方根

print([item for item in map(lambda x:pow(x,1/3),[2,3,4,5])])
# [1.2599210498948732, 1.4422495703074083, 1.5874010519681994, 1.7099759466766968]

5.运用zip

a =['x','y','z']
b =[1,2,3]
[(a,b) for a,b in zip(a,b)]
# [('x', 1), ('y', 2), ('z', 3)]