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))

　　#

　　print(f(10))

　　#

　　　　　　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,321}

_set02  = set(['',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}