python学习之非空即为真,函数,集合,解包与打包

python基础

非空即真，非零即真

#之前代码：
sex = input("请输入性别：")
if sex != '':
　　print("输入成功")
else:
　　print("不能为空")
　　if sex >= 0:
　　　　print("输入成功")
　　else:
　　　　print("输入必须为正数")
　　
#简写代码：
sex = input("请输入性别：") 
if sex: 　　
　　print("输入成功") 
else: 　　
　　print("不能为空")
　　if sex:
　　　　print("输入成功")
　　else:
　　　　print("输入必须为正数")

　　#其实很好记忆这个用法，只要记住if sex：如果sex不为空，不为零就很方便了

　　#除了用在变量，空的字典{}，列表[]，元祖()，都可以这么写

函数

　　作用：提高代码的复用性

　　def a():
　　　　print("sadad")
　　#def函数 　　a函数名随便起　　（）调用参数在里面填，为空表示直接执行这个函数　　print("sadad") 函数内容　
　　def b(nihao):#形参，传入的过程叫做入参
　　　　print(nihao)
　　b('wohenhao')#实参，使用函数
　　def c(nihao):
    　　　d=nihao
    　　　return d 　
　　print(c('wobuhao'))

　　pass占位符

def function():
    pass

　　return返回值

　return两个作用： 1.如果要用到指定处理结果要使用返回值return，如果没有写返回值，返回None 　　　　　　　　　　　　　　　　　

　　　　　　　　　2.立即结束函数，下面代码不执行，相当于break

def my():#定义三个变量
　　a,b,v =1,2,3
　　return a,b,c #返回三个变量
　d,e,c = my()  #用d,e,c分别接受a,b,c 

　　全局变量&局部变量　　

　　name = ‘我是大帅哥’　　#在函数外定义的是全局变量，在所有地方都可以使用的变量
　　　　def boy():
　　　　　　name = '我也是大帅哥'　#在函数中定义的是局部变量，在本函数体才能使用的变量，如果局部变量name注释掉，调用boy函数，在函数中，没有找到name变量，会去全局变量中寻找，找到返回全局变量的name
　　　　　　print(name)
　　　　print(name)　　#打印全局变量
　　　　boy()　　　　#打印局部变量

　　　　global　　全局变量和局部变量都为name，如果想要使用函数修改全局变量的值可以加global

　　　　name = '我是大帅哥'
　　　　def boy():
    　　　global name
    　　　name = '我是小救星'
    　　　print(name)
    　　　name = '我也是大帅哥'
    　　　print(name)
　　　　print(name)
　　　　boy()
　　　　print(name)　　　　#顺序分别打印的是：我是大帅哥 我是小救星 我也是大帅哥 我也是大帅哥

　　　　#全局变量尽量少用，占内存，多人开发更改会混乱

　　　　#global 只有str，int，tuple才要声明。list，dict不需要声明，直接修改　

　　　　nonlocal

# nonlocal声明外层函数的局部变量，在内层函数可以修改
# 层级函数只能查看不能修改,如要修改定义nonlocal
def outer():
    a = 1
    def inner():
        nonlocal a  # 当添加了bonlocal函数,将outer中的a=1修改成了a=2
        a = 2
        print("inner:", a)
    inner()
    print("outer:", a)
outer()#结果为 2
#              2

　　递归

　　def nihao():
　　　　print("nihao")
　　　　nihao()#自己调用自己，最多递归999次，效率不高　

　　四种参数

　　　　1.位置参数

　　　　　　必填参数，不填报错

　　　　2.默认值参数

　　　def connect(ip,port=3306): #ip为位置参数，传参时必填，port为默认值参数，如果不填默认3306，如果填3307，值覆盖3306
　　　　　print(ip,port)
　　　connect('192.168.1.1')
　　　connect('192.168.1.1',port=3307)

　　　　默认值遇到列表，字典或者大多数类时，默认值会变成一个可变的对象

　　  def f(a, L=[]):
      　　L.append(a)
    　　  return L　

　　　　pycharm会标黄，提出警告，正确做法如下

　　　　

　　　def f(a, L=None):
    　　　if L is None:
        　　　L = []
    　　　L.append(a)
    　　　return L

　　　　3.可变参数　　#不限参数个数，以元祖形式返回

　　　　def lalal(*args):
　　　　　　print(“sadads”)
　　　　lalal()　　#当不传参数返回一个空的元祖（）
　　　　lalal(233)　　#当传一个参数返回(233,)
　　　　lalal(233,2333,23333)　　#传多个参数，把参入的参数放到一个元祖中

　　　　4.关键字参数　　#不限参数个数，以字典形式返回，不能传重复使用同一个key

　　　　def nihao(**args):
　　　　　　print(args)
　　　　nihao()　　#当没有传参时返回一个空的字典{}
　　　　nihao(name = 233)　　#当传入一个参数返回一个字典k-v形式
　　　　nihao(name = 233,asd = 2333,sex = 11)　　#当传入多个参数返回多个k-v形式字典

　　　　参数多种形式应用

　　　　　　如果要使用位置参数，默认值参数，可变参数，关键字参数一起使用，以防万一按照此顺序写

　　　　参数的提示

　　　def hi(s:str,l:list)　　#冒号表示参数类型提示，在使用传参时，pycharm会显示指定类型，但是只是提示的作用，你要传其他的也可以
　　　def ni(s):　　　　#在函数中加入三个单引号，表示注释，pycharm会自动加入param和return方便我们使用
　　　　　'''
　　　　　:param s:
　　　　　:return:
　　　　　'''

 　　　　分离参数列表

　　　　　　拿内置函数range（）为例，其需要一个参数　　　

　　 a = list(range(2))
　　 # [0,1]
　　 args = [2]              #传一个只有2的list
　　 b = list(range(*args))  #如果输出不是独立的函数，可以用*把range中所有元素取出来
　　 # [0,1]

　　　　 匿名函数:Lambda 表达式

　　　　　　匿名函数　　函数即变量，只要在函数没运行之前都是变量,冒号前面是参数，冒号后面是返回值,我们可以拿lambda关键字做一个小型的匿名函数，此函数会返回两个参数之和　　

　　def make_incrementor(n):
    　　return lambda x:x+n
　　f = make_incrementor(10)
　　print(f(0))
　　# 11
　　print(f(10))
　　# 20

　　　　　　lambda另一个用途是传递一个小型函数作为参数

　　pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
　　pairs.sort(key=lambda pair: pair[1])
　　print(pairs)
　　# [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

　　　　文档字符串

　　def my_function():
    　　"啥都不写"
　　print(my_function.__doc__)
　　#

　　# 啥都不写

　　

集合　　#无序的，天生去重,返回{xxx，xxx，xxxx}其返回看上去是一个字典，但字典是key:value形式,集合不是这种形式

　　集合的定义　

_set01 = {'123',123,'123','123',123,321}
_set02  = set(['123',123,'123','123',123,321])

　　集合和列表的转换

　　　　a = [1,2,3,4,5,6,7,1]
　　　　jihe = set（a）#集合的定义
　　　　print(jihe)　　#打印{1,2,3,4,5,6,7}  最后一个1被去重了
　　　　a_new = list(jihe)　　#将集合转换成列表

　　　　集合操作　

 　　　　lis1 = {3, 4, 5, 6, 8, 6, 9}
        lis2 = {2, 3, 4, 6, 9}
        lis3 = {1, 2, 3，4}
        print(lis1.intersection(lis2))  # 取交集，也就是取lis1和lis2中都有的
        print(lis1 & lis2)# 取交集
        print(lis1.union(lis2))  # 取并集，也就是把lis1和lis2合并了，然后去除重复的
        print(lis1 | lis2)# 取并集
        print(lis1.difference(lis2))  #取差集 在list中存在，在lis2中没有的
        print(lis1 - lis2)
        print(lis3.issubset(lis1))#判断lis3是不是lis1的子集
        print(lis1.issuperset(lis3))#判断lis1是不是lis3的父集
        print(lis1.isdisjoint(lis3))#判断lis1和lis3是否有交集
        print(lis1.symmetric_difference(lis2))#对称差集，输出两个列表中都没有的值，也就是把两个集合中相同的去掉
        print(lis1 ^ lis2)

　　　#集合的增删改查
        lis1.add(123)#添加元素
        lis1.update([45,66,623])
        lis1.remove(407)#删除元素，如果元素不存在会报错
        lis1.pop()#删除一个随机的元素，并返回删除的元素
        lis1.discard('dtt')#如果删除的元素存在，删除，不存在不做处理
　　　集合的应用
　　　　　list = 

　　　　如何在很多字典中找到公共的值?

>>> d1 = {1:2,2:3,3:2}
>>> d2 = {3:3,4:2,5:2,1:2}
>>> d3 = {1:2,7:1,6:2}
>>> d1.keys() & d2.keys() & d3.keys()
>>> {1}

函数中的解包与打包(*args,**kwargs)

#解包:
def fuc01(ip, port, username, password):
    print(ip, port, username, password)


_list = ['ip', 'port', 'username', 123456]
_set = {'ip', 'port', 'username', 123456}
_str = 'user'
_tuple = ('ip', 'port', 'username', 123456)
_dict = {'ip': '127.0.0.1', 'port': 3306, 'username': 'rainbol', 'password': 123456}

fuc01(*_list)  # 对应拿到列表的值
fuc01(*_set)  # 对应拿到集合的值
fuc01(*_str)  # 对应拿到字符串的值,但注意如果fuc函数的形参数量要与_str字符串的个数一致才行
fuc01(*_tuple)  # 对应拿到元祖的值
fuc01(**_dict)  # 对应拿到字典的值,如果只写一个*则只能拿到key不能拿value,所以一定要写**
# 如上这种方法称为解包

#打包
#说完解包,打包就很简单了,将形参定义成组成任意位置参数的*args或关键字参数**kwargs来接收,并配合解包来实现增加任意参数,实现参数无须一一对应,无限扩容的做法大大减少了代码量

list_pack = ['ip', 'port', 'username', 123456]
dict_pack = {'ip': '127.0.0.1', 'port': 3306, 'username': 'rainbol', 'password': 123456}
def list_fuc02(*args):
    print(args)
list_fuc02(*list_pack)
#('ip', 'port', 'username', 123456)

def dict_fuc02(**kwargs):
    print(kwargs)
dict_fuc02(**dict_pack)
#{'ip': '127.0.0.1', 'port': 3306, 'username': 'rainbol', 'password': 123456}

def all_fuc02(*args, **kwargs):
    print(args, kwargs)
all_fuc02(*list_pack, **dict_pack)
#('ip', 'port', 'username', 123456) {'ip': '127.0.0.1', 'port': 3306, 'username': 'rainbol', 'password': 123456}

版权声明：本文原创发表于 博客园，作者为 RainBol 本文欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则视为侵权。