Python ☞ day 4

Python学习笔记之 (set)集合 & 迭代器 & 函数 & 匿名函数 & 高阶函数

set

set:类似dict1，是一组key的集合，不存储value
本质：无序和无重复元素的集合

#创建
#创建set需要一个list或者tuple或者dict作为输入
#重复元素在set中会自动被过滤
set1 = set([1,2,3,4,5,5,4,3,3])
print(set1)

set2 = set((1,2,3,4,3,2))
print(set2)

set3 = set({1:"good",2:"nice"})
print(set3)

#添加
set4 = set([1,2,3,4,5])
set4.add(6)
set4.add(4) #可以添加重复的，但是不会有效果
#set4.add([7,8,9]) #set的元素不能是列表，因为列表是可变的
set4.add((7,8,9))
#set4.add({4:"good"}) #set的元素不能是字典，因为字典也是可变的
print(set4)

#插入整个list、tuple、字符串，打碎插入
set5 = set([1,2,3,4,5])
set5.update([6,7,8])
set5.update((9,10))
set5.update("sunck")
print(set5)

#删除
set6 = set([1,2,3,4,5])
set6.remove(3)
print(set6)

#遍历
set7 = set([1,2,3,4,5])
for i in set7:
    print(i)
#set没有索引
#print(set7[2])

for index,i in enumerate(set7):
    print(index,i)

set8 = set([1,2,3])
set9 = set([2,3,4])
#交集
a1 = set8 & set9
print(a1)
print(type(a1))
#并集
a2 = set8 | set9
print(a2)
print(type(a2))

类型转换

#list > set
l1 = [1,2,3,4,5,5,3,2,5,6,9]
print(set(l1))

#tuple > set
t1 = (1,2,3,4,4,5,2)
print(set(t1))

#set > list
s1 = {1,2,3,4}
print(list(s1))

#set > tuple
s2 = {1,2,3,4,5}
print(tuple(s2))

迭代器

• 可迭代对象：可以直接作用于for循环的对象统称为迭代对象
  (Iterable)。可以用isinstance()去判断一个对象是否是Iterable对象

• 可以直接作用于for的数据类型一般分为两种
  1、集合数据类型，如list、tuple、dict、set、string
  2、是generator，包括生成器和带yield的generator function

from collections import Iterable,Iterator
print(isinstance([],Iterable))
print(isinstance((),Iterable))
print(isinstance({},Iterable))
print(isinstance("",Iterable))
print(isinstance((x for x in range(10)),Iterable))

• 迭代器：不但可以作用于for循环，还可以被next()函数不断的调用并返回下一个值,直到最后抛出一个StopIteration错误，说明表示继续返回下一个值

• 可以被next()函数调用并不断返回下一个值的对象称为迭代器
  (Iterator对象)

• 可以使用isinstance()函数判断一个对象是否是Iterator对象

print(isinstance([],Iterator))
print(isinstance((),Iterator))
print(isinstance({},Iterator))
print(isinstance("",Iterator))
print(isinstance((x for x in range(10)),Iterator))

l = (x for x in range(10))
print(next(l))
print(next(l))
print(next(l))
print(next(l))

#转成Iterator对象
a = iter([1,2,3,4,5])
print(next(a))
print(next(a))
print(isinstance(iter([]),Iterator))
print(isinstance(iter(()),Iterator))
print(isinstance(iter({}),Iterator))
print(isinstance(iter(""),Iterator))

'''
endstr = "end"
str = ""
for line in iter(input,endstr):
    str += line + "\n"
print(str)
'''

函数

• 认识函数：在一个完整的项目中，某些功能会反复使用。那么会将功能封装成函数，当我们要使用功能的时候直接调用函数即可。

• 本质：函数就是对功能的封装

• 优点：
  1、简化代码结构，增加了代码的复用度(重复使用的程度)
  2、如果想修改某些功能或者调试某个BUG，只需要修改对应的函数即可

'''
定义函数：
格式：
def 函数名(参数列表):
    语句
    return 表达式

def:函数代码块以def关键字开始
函数名：遵循标识符规则
():是参数列表的开始和结束
参数列表(参数1，参数2,……，参数n)：任何传入函数的参数和变量必须放在圆括号之间，用逗号分隔。函数从函数的调用者那里获取的信息
冒号：函数内容(封装的功能)以冒号开始,并且缩进。
语句：函数封装的功能
return：一般用于结束函数，并返回信息给函数的调用者。
表达式：即为要返回给函数的调用者的信息，

注意：最后的return表达式，可以不写，相当于return None
'''

#   定义了一个无参无返回值的函数
def myPrint():
    print("lee is a very good man!")
    print("lee is a nice man!")
    print("lee is a handsome man!")
myPrint()
myPrint()
myPrint()
myPrint()

• 函数的调用
  格式：函数名(参数列表)
  函数名：是要使用的功能的函数名字
  参数列表：函数的调用者给函数传递的信息,如果没有参数，小括号也不能省略

• 函数调用的本质：实参给形参赋值的过程

函数的参数

#   需求：编写一个函数，给函数一个字符串和一个年龄，在函数内部打印出来

#   形参(形式参数)：定义函数时小括号中的变量，本质是变量
#   参数必须按顺序传递，个数目前要对应
# def myPrint(str,age,hoby):
#     print(str,age)
def myPrint(str,age):
    print(str,age)

#   实参(实际参数)：调用参数时给函数传递的数据，实参的本质是值
myPrint("lee is a good man!", a)

• 返回值：

#   编写函数，实现功能，给函数两个数，返回这两个数的和
def mySum(num1,num2):
    #   将结果返回给函数的调用者
    return num1 + num2
    #   执行完return语句，该函数就结束了，return后面的代码不执行
    print("888888888")

res = mySum(1,2)
print(res)

• 传递参数
  1、值传递：传递的不可变类型
  string、tuple、number是不可变的
  2、引用传递：传递的可变类型
  list、dict、set是可变的

def func1(num):
    num = 10

temp = 20
func1(temp)     #num = temp
print(temp)

def func2(lis):
    lis[0] = 100

list1 = [1,2,3,4,5]
func2(list1)
print(list1)

• 关键字参数：允许函数调用时参数的顺序与定义时不一致

def myPrint(str,age):
    print(str,age)

#   使用关键字参数
myPrint(age = 18,str = "lee is a good man!")

• 默认参数：调用函数时，如果没有传递参数，则使用默认参数

#   要用默认参数，最好将默认参数放在最后
def myPrint(str,age = 18):
    print(str,age)
myPrint("lee",10)

• 不定长参数：能处理比定义时更多的参数

#   加了星号(*)的变量存放未命名的变量参数，如果在函数调用时没有指定参数，它就是一个空元组
def function(name, *args):
    print(name)
    print(type(args))
    for x in args:
        print(x)
function("lee","good","nice")

def function1(*args):
    sum = 0
    for i in args:
        sum += i
    return sum
print(function1(1,2,3,4,5,5,6,7,7,1))

#   **代表着键值对的参数字典，和*所代表的意义类似
def function2(**kwargs):
    print(kwargs)
    print(type(kwargs))
function2(x=1,y=2,z=3)


def function3(*args,**kwargs):
    pass    #代表一个空语句

匿名函数

• 不使用def这样的语句定义函数，使用lambda来创建匿名函数
• 特点：
  1、lambda只是一个表达式，函数体比def简单
  2、lambda的主体是一个表达式，而不是代码块，仅仅只能在lambda表达式中封装简单的逻辑
  3、lambda函数有自己的命名空间，且不能访问自由参数列表之外的或全局命名空间的参数
  4、虽然lambda是一个表达式且只看起来只能写一行，与C和C++内联函数不同。
• 格式：lambda 参数1,参数2,……参数n:expression

sum = lambda num1,num2:num1 + num2
print(sum(1,2))

高阶函数

• 高阶函数 - map
  map()
  原型 map(fn, lsd)
  参数1是列表
  参数2是序列
  功能：将传入的函数依次作用与序列中的每一个元素，并把结果作为新的Interator返回

'''
def myMap(func, li):
    resList = []
    for parase in li:
        res = func(parase)
        resList.append(res)
'''


#将单个字符转成对应的字面量整数
def chr2int(chr):
    return {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}[chr]

list1 = ["2","1","6","5"]
res = map(chr2int, list1)
#[chr2int("2"),chr2int("1"),chr2int("6"),chr2int("5")]
print(res)
# 打印结果：<map object at 0x000001CE1D0C9E10>
print(list(res))
# 打印结果：[2, 1, 6, 5]


#将整数元素的序列，转为字符串型
#[1,2,3,4]  -> ["1","2","3","4"]
l = map(str, [1,2,3,4])
print(list(l))
# 打印结果：['1', '2', '3', '4']

• 高阶函数 - reduce
  reduce(fn, lsd)
  参数1是列表
  参数2是序列
  功能：一个函数作用在序列上，这个函数必须接受两个参数，reduce把结果继续和序列 的下一个元素累计运算
  reduce(f, [a, b, c, d])

#求一个序列的和
list2 = [1,2,3,4,5]
#1 + 2
#1 + 2  + 3
#1 + 2  + 3 +4
#1 + 2  + 3 +4 +5
def mySum(x,y):
    return x + y
r = reduce(mySum, list2)
print("r =", r)
# 打印结果：15


# 需求：将字符串转成对应字面量数字
def str2int(str):
    def fc(x, y):
        return x * 10 + y
    def fs(chr):
        return {"0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9}[chr]
    return reduce(fc, map(fs, list(str)))

a = str2int("12534")
print(a)
print(type(a))

• 高阶函数 - filter （过滤）
  原型：filter(fn, lsd)
  参数1为函数
  参数2为序列
  功能：用于过滤序列的
  白话文：把传入的函数依次作用与系列每个元素，根据返回的是True还是False决定是否保留该元素

list1 = [1,2,3,4,5,6,7,8,9]
#筛选条件
def func(num):
    #偶数保留
    if num%2 == 0:
        return True
    #奇数剔除
    return False
l = filter(func, list1)
print(list(l))
# 打印结果：[2, 4, 6, 8]

data= [["姓名","年龄","爱好"],["tom", 25, "无"],["hanmeimei", 26, "金钱"]]
def func2(v):
    v = str(v)
    if v == "无":
        return False
    return True
for line in data:
    m = filter(func2, line)
    print(list(m))
# 打印结果：
['姓名', '年龄', '爱好']
['tom', 25]
['hanmeimei', 26, '金钱']

• 高阶函数 - sorted (排序）
  常见的排序有：冒泡， 选择 快速， 插入， 计数器

# sorted排序：
普通排序
list1 = [3,4,6,2,9]
list2 = sorted(list1)   #默认升序排序
print(list1)
#打印结果：[3, 4, 6, 2, 9]
print(list2)
#打印结果：[2, 3, 4, 6, 9]

#按绝对值大小排序
list3 = [3,4,-7,6,-10,2,9]
#key接受函数来实现自定义排序规则
list4 = sorted(list3, key=abs)
print(list3)
#打印结果：[3, 4, -7, 6, -10, 2, 9]
print(list4)
#打印结果：[2, 3, 4, 6, -7, 9, -10]

#降序
list5 = [3,4,6,2,9]
list6 = sorted(list5, reverse=True)
print(list5)
#打印结果：[3, 4, 6, 2, 9]
print(list6)
#打印结果：[9, 6, 4, 3, 2]

#函数可以自己写
def myLen(str):
    return len(str)
list7 = ['b333','a1111111','c22','d5554']
list8 = sorted(list7,key=myLen)#默认升序排序
print(list7)
#打印结果：['b333', 'a1111111', 'c22', 'd5554']
print(list8)
#打印结果：['c22', 'b333', 'd5554', 'a1111111']

Python 内置函数参考链接 官方文档