python学习篇之【集合、函数与内置函数】

一、set 集合

定义：由不同元素组成的集合，集合中，是一组无序排列，可hash的值，可以作为字典的key，必须是不可变的值。

特性：做关系运算

1、集合的格式

 #不考虑顺序，集合自带去重功能，不过生成后是无序的。

s = {1,'a',3,3,4,5,5}  # 集合的格式
print(s,type(s))          #查看类型
s = set('hello')           #使用set函数 定义集合
print(s)    

2、集合的内置方法（最常用）

# a、求交集 .intersection()  或使用 "&" 符号做交集运算。
# 作用：提取出 两个集合中，相同的 元素 
# 如下例：
s1 = {'p1',1,'p2',2,4}
s2 = {'p1',1,'p3',2,3}
print(s1.intersection(s2))
print(s1&s2)

# b、求并集  .union() 或使用 "|"符号做并集运算。
# 作用：提取出 两个集合合并到一起，去重 后得到的元素。
# 如下例：
s1 = {'p1',1,'p2',2,4}
s2 = {'p1',1,'p3',2,3}
print(s1.union(s2))
print(s1|s2)

# c、求差集  .difference()  或使用  "-"符号做差集运算。
# 作用：提取出 s1 有的 s2没有 的元素
# 如下例：
s1 = {'p1',1,'p2',2,4}
s2 = {'p1',1,'p3',2,3}
print(s1-s2)
print(s1.difference(s2))


# d、交叉补集  或使用  "^"符号做交叉补集运算。
# 作用：把两个集合合并到一起，去除共有的元素 后得到的元素。
# 如下例：
s1 = {'p1',1,'p2',2,4}
s2 = {'p1',1,'p3',2,3}
print(s1.symmetric_difference(s2))
print(s1^s2)

 3、集合的其他内置方法

#a、.isdisjoint() 交集运算
# 功能：如果两个集合中没有相同的元素，返回True，反之false
# 如下例：
s1 = {1,2}
s2 = {3,5,}
s3 = {1,5}
print(s1.isdisjoint(s2))
print(s1.isdisjoint(s3))

# b、.issubset()  判断子集。 符号<=
# 功能：判断s1 是不是s2的子集
# 如下例：
s1 = {1,2}
s2 = {1,2,3}
print(s1.issubset(s2))  

# c、.issuperset判断父集  符号 >=
# 功能：判断s2 是不是s的子集，（s2包含不包含s1）
# 如下例：
s1 = {1,2}
s2 = {1,2,3}
print(s2.issuperset(s1))  


# d、.update() 更新集合
# 补充：.union()只是求出结果，而.update()是赋值
# 一次可以更新多个值，而add一次只能增加一个。
# 如下例：
s1 = {1,2}
s2 = {1,2,3}
s1.update(s2) #把s2的值更新到s1中，只要是可迭代的类型都能往里传
print(s1)

# e、.difference_update() 把输出后的结果赋值 给该变量。
# 如下例：
s1 = {'p1',1,'p2',2,4}
s2 = {'p1',1,'p3',2,3}
s1.difference(s2)
print(s1)
s1.difference_update(s2)
print(s1)

二、函数

　　定义：为了完成特定的功能。逻辑结构化 和 过程化的一种编程方法。代码自上而下运行，碰到函数，会把函数编译到内存中，不会运行

如果想运行这个函数，把函数名加上括号 ，如 test() 就是执行test函数

1、如何定义一个函数：

def test(x):
    '函数注释'
    x += 1
    return x

def : 定义函数的关键字
test  函数名
()    可定义形参
''' '''    函数描述（非必要，但是最好最好是写上描述） 
x += 1  代码块
return 定义返回值

2、函数的参数：

 

1、形参：只有在被调用时，才分配内存单元，在调用结束后立即释放内存单元.
因此，形参只在函数内部有效。在下面例子的函数中，函数体中的：x,y就是 calc函数的形参

 

def calc(x,y):
    res = x * y #x ， y函数的形参，只在被调用时候才分配内存
    return res

a = 10
b = 10
calc(a,b)

 

2、实参：可以是变量，常量，表达式，函数等，无论实参是什么类型的量，调用时
都必须有确定的值.以便把参数传给形参。

num = 10    #num 就是实参

def calc(x,y):
    res = x * y
    return res
print(calc(num，10)）

 

3、位置参数:缺一不行，多一行也不行。关键字参数，无需一一对应，，缺一不行，

多一行也不行，如果混合使用，位置参数一定要再关键字的左边,且关键字要对应。

 

def calc(x,y):   #x，y 就是位置参数
    res = x * y
    return res

a = 10
b = 10
calc(a,b)

 

 

 

4、默认参数：下面例子中 y=2 就是默认参数，如果不往里面传第二个参数y就是2

def calc(x,y=2):
    a = x*y
    print(y)
    return a
print(calc(2)) 
print(calc(2,6))

5、参数组：**kwargs字典 *args列表  非固定长度参数。

# a、**args 接收字典类型
def fuc(a,*args):
    print(a)
    print(args)
    print(args[0])

test = fuc(1,3,4,5)  # 把第二个位置参数后(包括第二位)
                       #全部的元素以元组类型 递归 传入args变量中。
test1 = fuc(1,[3,4,5]) # 如果第二位置参数传进来的是个列表，
                       #整个列表，作为args元组中的第一个元素。
test3 = fuc(1,*[3,4,5]) # 加*后 等同第一个例子。把第二个位置参数后(包括第二位)
                       #全部的元素以元组类型 递归 传入args变量中。

# b、**kwargs 接收字典类型
def func(x,**kwargs):
    print(x)
    print(kwargs)

func(1,k1=11,k2='aa')
func(1,**{'name':'oyangfeng','age':77})


c、*args **kwargs 组合使用，能接收任意长度参数
可以再函数内部做处理，索引切片取值。

def func(x,*args,**kwargs):
    print(x)
    print(args)
    print(kwargs)

func(1,1,2,3,4,k1='ab',k2=11)  #如果传入字典类型，函数的关键字不能合字典中的key相同。

 

 

5、内置函数

# 1、abs()绝对值 全都是正数

print(abs(-5))
print(abs(5))

# 2、all() #把序列中每一个元素拿出来做布尔运算,序列全部是真的返回True，有一个为假，就返回false,如果是个空字符串，就是True

print(all(['a',1,2,3]))
print(all(['a',1,2,3,0]))
print(all(''))

# 3、any()只要有一个为真，就是真

print(any(['a',1,2,3,0]))

# 4、bin()把十进制转成二进制

print(bin(10))

# 5、bool()空 None 0，其他都为true

# 6、bytes() 一个字符串转换成字节,encoding 编码，decode解码

name = '你好'
print(bytes(name,encoding='utf-8'))  #使用 encoding指定编码格式 打印出name的二进制。
print(bytes(name,encoding="utf-8").decode('utf-8'))# .decode()解码

print(bytes(name,encoding='ascii'))  #ascii 不能给中文进行编码

# 7、chr()  #按照ascii 码打印 对应的
print(chr(99))

# 8、dir()  打印某一个对象下面都由哪些方法
# print(dir(chr))

# 9、divmod()  取商得余数,分页功能，博客抽屉功能

print(divmod(100,8) )  #100 代表总共有多少条记录， 8代表一页显示几条

# 输出结果>>>：(12,4)    #12 代表可以分多少页，判断 第二位是否为0,不为零 还要多加一页，12+1

# 10、eval()
# 功能一： 把字符串中的数据结构给提取出来

dic_test = {'name':'zhuzijian','age':18}
dic_str = str(dic_test)        # 把字典类型改成str类型
dic_eval = eval(dic_str)       # 使用eval函数提取 字符串中 的数据结构，
print(type(dic_str),dic_str)   # type查看数据类型
print(type(dic_eval),dic_eval) # type查看数据类型

# 功能二：把字符串中是是的表达式进行运算
count = '1+2*3-4'
print(eval(count))

#11、重点：面向对象详解
 getattr()
 setattr()
 delattr()

# #12、hash()  哈西运算 整个字符串进行一个整体运算 ，自己的运算逻辑
# 可哈西的数据类型，即不可变数据类型，不可哈西的数据类型即可变数据类型
# 特性：
#   不管传入参数有多长，最终结果都是固定的，不会跟这传入参数的长短做改变。
#   不能根据hash结果，去反推出字符串是什么
#   hash校验，文件改动测试，（文件包其实就是字符串
name = 'oyangfeng'
print(hash(name))
print(hash(name))
print('after---->',hash(name))
name = 'guojing'
print('before---->',hash(name))

# 13、help()打印函数详细使用方法

print(help(all))

# 14、进制转换

# bin()十进制---->二进制

print(bin(10))

# hex()十进制---->十六进制

print(hex(10))

# oct()十进制---->八进制
print(oct(10))

# 15、判断前一个参数对应的数据类型，是不是正确，返回布尔值

print(isinstance(1,int))
print(isinstance('abc',str))
print(isinstance([],list))

# 16、globals() 打印全局变量

name= "哈哈哈哈哈哈哈哈哈哈哈哈"
print(globals())
print(__file__)  查看当前文件位置

# 17、locals() 打印局部变量

print(locals())

# 18、max()  #取最大值
#     min()  #取最小值
# 比较原理：
    a. max 函数处理的是可迭代对象，相当于一个for循环取出每个元素进行比较，
    注意不同类型之间不能进行比较
    
    b. 每个元素建进行比较，是从每个元素的第一个位置一次比较，如果这一个位置
    分出大小，后面的都不需要比较了，直接得出这两个元素的大小。

# 示例：

li= [1,23,412,100,21,-1,-8]
print(max(li))
print(min(li))

# 19、zip()方法  拉链:把前后序列的每一个元素，对应拿出来，组成一个元组。多出来的不显示。
li1=['a','b','c','d,','e']
li2=[1,2,3,4,5,6]
dic = {'name':'ouyangfeng','age':69,'local':'hongkong'}
print(zip(li1,li2))
print(list(zip(li1,li2)))
print(list(zip('hello','12345')))
print(list(zip(dic.keys(),dic.values())))  #转换字典，把字典里的key，values放到一个元组中。

# 18.1、组合使用：min max  zip 其他玩法
age_dic = {'age1':18,'age2':40,'age3':38,'age4':99,'age5':6,}
# a.取出最大年纪 ，比较的原理，就是循环一位一位元素取比较。通过ascii码去定义的大小。
print(max(age_dic.values()))
# b.取出最大年纪和对应的姓名。
# 思路：zip是通过序列中的每个元素从左到右判断大小，所以用zip组成一个新的
# 数据类型，把values放在左边，keys放在右边进行组合。在通过max判断。
#
print(max(zip(age_dic.values(),age_dic.keys())))
# 补充：
li1=['b','c','d,',1]
print(list(max(li1)))   #不同类型不能比较。

# 18.2、终极玩法 max  可以指定方法 key= 取值
people = [
    {'name':'欧阳锋','age':1000},
    {'name':'郭靖','age':10000},
    {'name':'黄蓉','age':9000},
    {'name':'洪七公','age':18},
]
# 取出年纪最大的
# 思路：引入 key= 方法，使用lambda，把列表中字典类型的 age 作为返回值
# 使用max给 传入的返回值循环做比较。
#第一个参数 是可迭代的序列，max 会依次从序列中拿取一个元素，做比较
#第二个参数 key = ，可以自己定义规则去序列里取值。（扩展性超强）
print( max(people,key=lambda x:x['age']))

# 19、ord() 写一个字符，会转换成对应的ascii码
print(ord('a'))

# 20、pow() 
print(pow(2,3))  # 2**3   2的3次方
print(pow(2,3,3))# 2**3%3 2的3次方，除以3 取余

# 21、reversed()  序列反转
li = [1,2,3,4,5]
print(list(reversed(li)))

# 22、round() 四舍五入

print(round(3.5))


# 22、slice() 切片
l = 'hello'
print(l[2:4])    # 硬编码， 如果大量使用这种硬编码，可读性差。
s1 = slice(2,4)  # 把切片方式 定义到slice函数里
s2 = slice(1,5,2)# 也可指定 步长
print(l[s1])
print(l[s2])
print(s2.start) #起始位置
print(s2.stop)  #结束位置
print(s2.step)  #步长 （间隔）

# 22、sorted()  大到小排序，跟 max min 非常类似,
# 排序本质就是在比较大小，不同类型不能进行排序
# li = [1,4,6,2,3,5,7]
# print(sorted(li))

# 按年纪排序
people = [
    {'name':'欧阳锋','age':1000},
    {'name':'郭靖','age':10000},
    {'name':'黄蓉','age':9000},
    {'name':'洪七公','age':18},
]
print(sorted(people, key=lambda dic: dic['age']))  # 与max 使用方法相同。

# 按照价位排序,并取出对应的人
# 按照价位排序，给价格对应的人名排序
mach = {'岳不群': 1000,
        '东方不败': 200,
        '令狐冲': 500,
        }
print(sorted(zip(mach.values(),mach.keys())))
print(sorted(mach,key=lambda x:mach[x])) 
# 循环前一个参数拿到的第一个元素，给key = 后面的功能做处理，然后拿出处理后
的元素，做sorted排序。


# 23、sum() 序列中做相加运算

li = [1,1,2,3,5]
print(sum(li))
print(sum(range(1,10)))  # 1-9相加


# 24、type() 查看类型  
# 写程序就是处理状态的变化，状态的变化用变量来保存下来。
msg = '123'
if type(msg) is str:  # 假设程序执行到这里，我们不知道msg的数据类型，就需要做个判断
    res = int(msg) + 2
print(res)

# 25、vars() 如果没有参数传入，获取当前的局部变量locals，如果有参数，
# 就获取，传入参数的 使用方法，存为字典格式
def var_test():
    name = 'hhhadhhhhhhhhhhhhhhhhhhhhhhhhhh'
    print(locals())
    print(vars())
var_test()
print(vars(int))