python小tips

函数：

格式：

def 函数的名字():函数体例如：def playgame():print("I am playing!")函数调用：
playgame()

     调用的方法： 函数名()     

函数的定义只是定义函数，调用了才会有结果     

函数的参数

分类：1.形参：在函数定义的时候，需要准备一些变量来接收信息1.位置参数，按照位置一个一个声明变量2.默认值参数，在函数声明的时候给变量一个默认值，如果实参不传递信息，此时默认值生效，否则就不生效

def luru(name, age, gender="男"):print(name, age, gender)luru("张三", 18)    # 张三 18 男
luru("李四", 18)
luru("王二麻子", 18)
luru("赵敏", 18, "女")    # 赵敏 18 女
luru("周芷若", 18, "女")
luru("吴老二", 18)

       3.动态传参1. * 参数名（args） 表示接收所有的位置参数的动态传参，接收到的值被统一放在元组里2. ** 参数名（kwargs） 表示接收所有的关键字的动态传参，接收到的值统一放在字典里

def chi(*food):   # * 表示位置参数的动态传参，*接收到的值会被统一放在一个元组里面print(food)chi('大米饭', "烧茄子",  "紫菜蛋花汤")   # ('大米饭', '烧茄子', '紫菜蛋花汤')
chi("大米饭")   # ('大米饭',)# 关键字参数的动态接收
def chi(**food):  # ** 表示接收关键字的动态传参，接收到的所有参数都会被处理成字典print(food)chi(zhu="小米饭", tang="胡辣汤", )  # {'zhu': '小米饭', 'tang': '胡辣汤'}

        混合使用的顺序：位置参数  >  *args  > 默认值  > **kwargs上述参数可以随意搭配使用；位置参数 在 默认值参数之前2.实参：实际调用的时候传递信息1.位置参数，按照位置进行参数传递2.关键字参数，按照参数的名字进行传递参数

def chi(zhu, fu, tang, tian):print(zhu, fu, tang, tian)chi("大米饭", '西红柿炒鸡蛋', "紫菜蛋花汤", "哈根达斯")          # 位置参数chi(zhu="小米饭", tang="胡辣汤", fu="西红柿炒鸡蛋", tian="老冰棍")    # 关键字参数chi("小米饭","胡辣汤", tang="西红柿炒鸡蛋", tian="老冰棍")   # 混合参数

        3.混合参数 (位置参数放前面，关键字参数放后面---> 否则报错)实参在执行的时候，必须保障形参有数据

open(xxxx,mode="xx",encoding="xxxx")  # xxxx是文件名，这个就是混合参数

        * 在实参位置，是把列表打散成位置参数进行传递** 在实参位置，可以把字典自动转化成关键字参数进行传递

def func(*args):print(args)# list少量元素
func(stu_lst[0], stu_lst[1], stu_lst[2], stu_lst[3],)   # ('流川枫', '樱木', '大老王', '隔壁二老王')# list 大量元素
func(*stu_lst)   # * 在实参位置，是把列表打散成位置参数进行传递# ** 在实参位置，可以把字典自动转化成关键字参数进行传递
# ('流川枫', '樱木', '大老王', '隔壁二老王')

      
返回值

返回值：函数执行之后，会给调用方一个结果，这个结果就是返回值关于return：
函数只要执行到了return，函数就会立即停止并返回内容，函数内的return后续代码不会执行

def func(a, b):# print(a + b)return a + bret = func(10, 30)
print( ret * 3)     # 90# 不写return
def func():passret = func()print(ret)   # None# 写了return但没有返回值
def fun():print(1223)return   # 不管return有没有返回值，只要读到return就会让程序停止，后续代码不会执行，有点像循环里的breakprint(234)ret = fun()
print(ret)     # 1223   None

1.如果函数里没有return，此时函数收到的是什么？   默认收到的时None
2.如果写了return1.只写了return 后面不跟数据             （充当的break情况）2.return 值，此时表示函数有一个返回值，外界能收到一个数据  （用的最多）3.return 值1，值2，值3....  此时函数有多个返回值，外界收到的是什么呢     外界收到的是元组，且该元组内存放所有返回值

内置函数（上）

内置函数： 直接拿来用的函数 例：print, input和数学运算相关数据类型： bool、 int、 float、 complex（复数）进制转换：bin（二进制）、oct（八进制）, int（十进制），hex（十六进制）数学运算：sum, min, max, pow(次方)

# 进制
a = 18
print(bin(a))   # 0b10010   二进制
print(oct(a))   # 0o22    八进制
print(hex(a))    # 0x12    十六进制b = 0b10011
print(int(b))   # 19  二进制转十进制# 数学运算
#  pow
c = 10
d = 3
print(pow(c, d))   # 1000
print(c ** d)    # 1000  表示的也是次方# max , min , sum
lst = [12, 32, 57, 789, 1000]
print(max(lst))   # 1000
print(min(lst))   # 12
print(sum(lst))   # 1890

    和数据结构相关列表和元组： list, tuple相关内置函数：slice(切片)字符串：str,format,bytes,ord(把文字转化成unicode编码中的码位), chr（把unicode编码的码位转化为文字）, repr相关内置函数：len, enumerate（能够直接拿到索引和元素）, all（当作and看）, any（当作or看）,     zip, filter, map, sorted,

# 列表
s = {1, 3, 4}
lst = list("呵呵哒")   # list 内部有个for循环
print(lst)    # [1, 3, 4]   ['呵', '呵', '哒']
# list的原理
for item in s:lst.append(item)
lst = list("呵呵哒")
print(lst)  # ['呵', '呵', '哒']s = slice(1, 4, 3)  # [1: 4:3]  从1切到4，每3个出来一个
print("呵呵呵呵呵呵"[s])  # 呵# format, ord, chr
# format  格式化
a = 18
print(format(a, "b"))   # 二进制 10010print(format(a, "08b"))   # 需要一个由0补充的8位的二进制   00010010    只能补齐，不能切割
c = 12000
print(format(c, "08b"))   # 10111011100000print(format(a, "o"))   # 八进制 22
print(format(a, "x"))    # 十六进制 12# ord, chr
a = '中'   # python的内存是unicode
print(ord(a))  # 20013   “中”在unicode中码位是20013
print(chr(20013))   # 中   给出编码位置，展示出文字# enumerate, all, any,
# all, any
print(all([12, "呵呵", "豆沙包"]))    # 把all当作and来看   True
print(all([0, "呵呵", "豆沙包"]))    # False，有一个空就是false
print(any([0, "呵呵", "豆沙包"]))    # True  把any当作or来看
print(any([0, "", ""]))     # False，全是空就是falselst = ["张无忌", "张翠山", "张三丰","张大大"]for item in enumerate(lst):print(item)
'''
(0, '张无忌')
(1, '张翠山')
(2, '张三丰')
(3, '张大大')
'''
for index,item in enumerate(lst):print(index,item)
#   #  等价于下面
for i in range(len(lst)):print(i, lst[i])
'''
0 张无忌
1 张翠山
2 张三丰
3 张大大
'''

    其他id (字符串的内存地址)help（）   dir（） （告诉当前数据能执行的操作）print(dir(s))

python进阶

作用域

作用域：变量的访问权限全局变量：顶格写，全局作用域局部变量：内侧 ，局部作用域总结： 里面访问外面没问题，外面访问里面不能直接访问

def func():c = 199return c   # 想要在函数外面访问到函数里面的东西，必须要return,必须！c1 = func()   # 此时调用的func是c的值
print(c1)   # 199

函数的嵌套

结论（*）：1.函数可以作为返回值进行返回2.函数可以作为参数进行相互传递函数实际上就是一个变量名，都表示一个内存地址

def fun1():passdef fun2():fun1()    # 这个叫函数的调用，不叫嵌套fun2()def func1():b = 20def func2():  # 函数的嵌套print(b)func2()  # 20 局部的东西，一般都是在局部自己访问使用的# func1内部的func2函数访问了局部变量b，并且在调用func1()时输出了20。# 外部无法直接访问b和func2，因为它们是在func1内部定义的局部变量和函数。
func1() # 20 这算直接调用func1()
print(func1())  # None
# 输出 None 是因为函数 func1 没有明确地返回任何值。在 Python 中，如果函数没有显式使用 return 语句返回一个值，它将默认返回 None。
print(b)      # 访问不了，外面没办法访问里面
print(func2)  # 访问不了，外面没办法访问里面# 函数嵌套执行过程
def func1():print(123)def func2():print(234)def func3():print(345)print(1)func3()print(2)print(3)func2()print(4)func1()
"""
只有调用了才会执行
123
3
234
1
345
2
4"""def func():def inner():print(123)print(inner)  # <function func.<locals>.inner at 0x000001C7CD54B520> 打印出来的是函数func的局部变量inner的地址return inner    # 返回的是函数，如果返回inner()，返回的是None,把函数当成一个变量进行返回b1 = func()   # b1是func的返回值，此时是b1内部的inner
print(b1)   # <function func.<locals>.inner at 0x000001A8F892B520>  和inner一样
b1()           # 123# 在外部调用局部变量
def an():print(123)an()   # 123bn = an  # 把an赋值给了bn
bn()   # 123 此时的bn()就是an()# 函数就是一个变量！# 代理模式
def func(an):# print(an)    # 传入func的变量，打印该变量本身an()   # 传入func的函数，执行该函数
# 实参可以是函数
def target():print("我是target")c = 123
func(c)   # 123   给func传变量c，调用func，输出123
func(target)   # <function target at 0x000001FDC715B520>  给func（）传函数，调用func，返回的是传入函数的地址# 用的是  print(an)
func(target)    # 我是target     说明实参可以是函数

两个关键字global，nonlocal

global:在局部引入全局变量
nonlocal: 在局部，引入外层的局部变量

a = 10
def func():# 此时就想要在函数内部修改全局变量a，怎么办？global a   # 把外面的全局变量引入到局部a = 20  # 创建一个局部变量，并没有改变全局变量中的afunc()
print(a)   # 10 为什么还是10（按理说应该是20）？  只写了a = 20不行# 有了global a ，a的结果变成20   20def func():a = 10def func2():nonlocal a  # 向外找一层，看有没有该变量，如果有就引入，如果没有，继续向外扩一层，直到全局（不包括）a = 20func2()print(a)func()   # 10# 20   （nonlocal a）

闭包

闭包：本质：内层函数对外层函数的局部变量的使用，此时内层函数被称为闭包函数1. 可以让一个变量常驻于内存2. 避免全局变量被修改

def func():a = 10   # 把成员变量变成局部变量，将其保护起来def inner():nonlocal aa += 1return areturn inner     # 此时inner构成闭包函数ret = func()   # inner  ==> ret ==> 什么时候执行r1 = ret()
print(r1)   # 11r2 = ret()
print(r2)   # 12

装饰器

函数回顾：

1. 函数可以作为参数进行传递
2.  函数可以作为返回值进行返回
3. 函数名称可以当成变量一样进行赋值

# 1.函数可以作为参数传递
def func():print("我是函数")def gggg(fn):fn()gggg(func)   # 我是函数# 2.函数可以作为返回值进行返回
def func():def inner():print("123")return innerret = func()
ret()   # 123# 3.函数名称可以当成变量一样进行赋值
def func1():print("我是函数1")def func2():print("我是函数2")
func1 = func2
func1()   # 我是函数2

装饰器：  --> 要求记住最后的结论装饰器本质上是一个闭包作用：在不改变原有函数调用的情况下，给函数增加新功能直白：可以在函数前后添加新功能，但不改原代码应用： 在用户登录的地方，日志，通用装饰器写法：def wrapper(fn):     wrapper: 装饰器，fn：目标函数def inner(* args, **kwargs):# 在目标函数执行之前ret = fn(* args, **kwargs)            # 执行目标函数# 在目标函数执行之后return retreturn inner     # 千万不能加小括号@wrapperdef target():passtarget()   # ==> inner()一个函数可以被多个装饰器装饰@wrapper1@wrapper2def target():print('我是目标')target()作用顺序： wrapper1 wrapper2  target  wrapper2  wrapper1

def wrapper1(fn):  # fn: wrapper2.innerdef inner(*args, **kwargs):print("这里是wrapper1,进")   # 1ret = fn(*args,**kwargs)   #  调用 fn : wrapper2.innerprint("这里是wrapper1,出")   # 4return retreturn innerdef wrapper2(fn):   # fn ： targetdef inner(*args, **kwargs):print("这里是wrapper2,进")   # 2ret = fn(*args,**kwargs)    # targetprint("这里是wrapper2,出")    # 4return retreturn inner@wrapper1  # target = wrapper1(wrapper2.inner) ==> target:wrapper1.inner
@wrapper2  # target = wrapper2(target)  此时的target是wrapper2的inner
def target():print('我是目标')target()wrapper1 wrapper2  target  wrapper2  wrapper1
"""
这里是wrapper1,进
这里是wrapper2,进
我是目标
这里是wrapper2,出
这里是wrapper1,出
"""